core/java/android/pim/vcard/VCardEntryConstructor.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2009 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package android.pim.vcard;

 import android.accounts.Account;
 import android.util.CharsetUtils;
 import android.util.Log;

 import org.apache.commons.codec.DecoderException;
 import org.apache.commons.codec.binary.Base64;
 import org.apache.commons.codec.net.QuotedPrintableCodec;

 import java.io.UnsupportedEncodingException;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;

 public class VCardEntryConstructor implements VCardInterpreter {
     private static String LOG_TAG = "VCardEntryConstructor";

     /**
      * If there's no other information available, this class uses this charset for encoding
      * byte arrays to String.
      */
     /* package */ static final String DEFAULT_CHARSET_FOR_DECODED_BYTES = "UTF-8";

     private VCardEntry.Property mCurrentProperty = new VCardEntry.Property();
     private VCardEntry mCurrentContactStruct;
     private String mParamType;

     /**
      * The charset using which {@link VCardInterpreter} parses the text.
      */
     private String mInputCharset;

     /**
      * The charset with which byte array is encoded to String.
      */
     final private String mCharsetForDecodedBytes;
     final private boolean mStrictLineBreakParsing;
     final private int mVCardType;
     final private Account mAccount;

     /** For measuring performance. */
     private long mTimePushIntoContentResolver;

     final private List<VCardEntryHandler> mEntryHandlers = new ArrayList<VCardEntryHandler>();

     public VCardEntryConstructor() {
         this(null, null, false, VCardConfig.VCARD_TYPE_V21_GENERIC_UTF8, null);
     }

     public VCardEntryConstructor(final int vcardType) {
         this(null, null, false, vcardType, null);
     }

     public VCardEntryConstructor(final String charset, final boolean strictLineBreakParsing,
             final int vcardType, final Account account) {
         this(null, charset, strictLineBreakParsing, vcardType, account);
     }

     public VCardEntryConstructor(final String inputCharset, final String charsetForDetodedBytes,
             final boolean strictLineBreakParsing, final int vcardType,
             final Account account) {
         if (inputCharset != null) {
             mInputCharset = inputCharset;
         } else {
             mInputCharset = VCardConfig.DEFAULT_CHARSET;
         }
         if (charsetForDetodedBytes != null) {
             mCharsetForDecodedBytes = charsetForDetodedBytes;
         } else {
             mCharsetForDecodedBytes = DEFAULT_CHARSET_FOR_DECODED_BYTES;
         }
         mStrictLineBreakParsing = strictLineBreakParsing;
         mVCardType = vcardType;
         mAccount = account;
     }

     public void addEntryHandler(VCardEntryHandler entryHandler) {
         mEntryHandlers.add(entryHandler);
     }

     public void start() {
         for (VCardEntryHandler entryHandler : mEntryHandlers) {
             entryHandler.onStart();
         }
     }

     public void end() {
         for (VCardEntryHandler entryHandler : mEntryHandlers) {
             entryHandler.onEnd();
         }
     }

     /**
      * Called when the parse failed between {@link #startEntry()} and {@link #endEntry()}.
      */
     public void clear() {
         mCurrentContactStruct = null;
         mCurrentProperty = new VCardEntry.Property();
     }

     /**
      * Assume that VCard is not nested. In other words, this code does not accept
      */
     public void startEntry() {
         if (mCurrentContactStruct != null) {
             Log.e(LOG_TAG, "Nested VCard code is not supported now.");
         }
         mCurrentContactStruct = new VCardEntry(mVCardType, mAccount);
     }

     public void endEntry() {
         mCurrentContactStruct.consolidateFields();
         for (VCardEntryHandler entryHandler : mEntryHandlers) {
             entryHandler.onEntryCreated(mCurrentContactStruct);
         }
         mCurrentContactStruct = null;
     }

     public void startProperty() {
         mCurrentProperty.clear();
     }

     public void endProperty() {
         mCurrentContactStruct.addProperty(mCurrentProperty);
     }

     public void propertyName(String name) {
         mCurrentProperty.setPropertyName(name);
     }

     public void propertyGroup(String group) {
     }

     public void propertyParamType(String type) {
         if (mParamType != null) {
             Log.e(LOG_TAG, "propertyParamType() is called more than once " +
                     "before propertyParamValue() is called");
         }
         mParamType = type;
     }

     public void propertyParamValue(String value) {
         if (mParamType == null) {
             // From vCard 2.1 specification. vCard 3.0 formally does not allow this case.
             mParamType = "TYPE";
         }
         mCurrentProperty.addParameter(mParamType, value);
         mParamType = null;
     }

     private String encodeString(String originalString, String charsetForDecodedBytes) {
         if (mInputCharset.equalsIgnoreCase(charsetForDecodedBytes)) {
             return originalString;
         }
         Charset charset = Charset.forName(mInputCharset);
         ByteBuffer byteBuffer = charset.encode(originalString);
         // byteBuffer.array() "may" return byte array which is larger than
         // byteBuffer.remaining(). Here, we keep on the safe side.
         byte[] bytes = new byte[byteBuffer.remaining()];
         byteBuffer.get(bytes);
         try {
             return new String(bytes, charsetForDecodedBytes);
         } catch (UnsupportedEncodingException e) {
             Log.e(LOG_TAG, "Failed to encode: charset=" + charsetForDecodedBytes);
             return null;
         }
     }

     private String handleOneValue(String value, String charsetForDecodedBytes, String encoding) {
         if (encoding != null) {
             if (encoding.equals("BASE64") || encoding.equals("B")) {
                 mCurrentProperty.setPropertyBytes(Base64.decodeBase64(value.getBytes()));
                 return value;
             } else if (encoding.equals("QUOTED-PRINTABLE")) {
                 // "= " -> " ", "=\t" -> "\t".
                 // Previous code had done this replacement. Keep on the safe side.
                 StringBuilder builder = new StringBuilder();
                 int length = value.length();
                 for (int i = 0; i < length; i++) {
                     char ch = value.charAt(i);
                     if (ch == '=' && i < length - 1) {
                         char nextCh = value.charAt(i + 1);
                         if (nextCh == ' ' || nextCh == '\t') {

                             builder.append(nextCh);
                             i++;
                             continue;
                         }
                     }
                     builder.append(ch);
                 }
                 String quotedPrintable = builder.toString();

                 String[] lines;
                 if (mStrictLineBreakParsing) {
                     lines = quotedPrintable.split("\r\n");
                 } else {
                     builder = new StringBuilder();
                     length = quotedPrintable.length();
                     ArrayList<String> list = new ArrayList<String>();
                     for (int i = 0; i < length; i++) {
                         char ch = quotedPrintable.charAt(i);
                         if (ch == '\n') {
                             list.add(builder.toString());
                             builder = new StringBuilder();
                         } else if (ch == '\r') {
                             list.add(builder.toString());
                             builder = new StringBuilder();
                             if (i < length - 1) {
                                 char nextCh = quotedPrintable.charAt(i + 1);
                                 if (nextCh == '\n') {
                                     i++;
                                 }
                             }
                         } else {
                             builder.append(ch);
                         }
                     }
                     String finalLine = builder.toString();
                     if (finalLine.length() > 0) {
                         list.add(finalLine);
                     }
                     lines = list.toArray(new String[0]);
                 }

                 builder = new StringBuilder();
                 for (String line : lines) {
                     if (line.endsWith("=")) {
                         line = line.substring(0, line.length() - 1);
                     }
                     builder.append(line);
                 }
                 byte[] bytes;
                 try {
                     bytes = builder.toString().getBytes(mInputCharset);
                 } catch (UnsupportedEncodingException e1) {
                     Log.e(LOG_TAG, "Failed to encode: charset=" + mInputCharset);
                     bytes = builder.toString().getBytes();
                 }

                 try {
                     bytes = QuotedPrintableCodec.decodeQuotedPrintable(bytes);
                 } catch (DecoderException e) {
                     Log.e(LOG_TAG, "Failed to decode quoted-printable: " + e);
                     return "";
                 }

                 try {
                     return new String(bytes, charsetForDecodedBytes);
                 } catch (UnsupportedEncodingException e) {
                     Log.e(LOG_TAG, "Failed to encode: charset=" + charsetForDecodedBytes);
                     return new String(bytes);
                 }
             }
             // Unknown encoding. Fall back to default.
         }
         return encodeString(value, charsetForDecodedBytes);
     }

     public void propertyValues(List<String> values) {
         if (values == null || values.isEmpty()) {
             return;
         }

         final Collection<String> charsetCollection = mCurrentProperty.getParameters("CHARSET");
         final String charset =
             ((charsetCollection != null) ? charsetCollection.iterator().next() : null);
         final Collection<String> encodingCollection = mCurrentProperty.getParameters("ENCODING");
         final String encoding =
             ((encodingCollection != null) ? encodingCollection.iterator().next() : null);

         String charsetForDecodedBytes = CharsetUtils.nameForDefaultVendor(charset);
         if (charsetForDecodedBytes == null || charsetForDecodedBytes.length() == 0) {
             charsetForDecodedBytes = mCharsetForDecodedBytes;
         }

         for (final String value : values) {
             mCurrentProperty.addToPropertyValueList(
                     handleOneValue(value, charsetForDecodedBytes, encoding));
         }
     }

     public void showPerformanceInfo() {
         Log.d(LOG_TAG, "time for insert ContactStruct to database: " +
                 mTimePushIntoContentResolver + " ms");
     }
 }
	/*
	* Copyright (C) 2009 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package android.pim.vcard;

	import android.accounts.Account;
	import android.util.CharsetUtils;
	import android.util.Log;

	import org.apache.commons.codec.DecoderException;
	import org.apache.commons.codec.binary.Base64;
	import org.apache.commons.codec.net.QuotedPrintableCodec;

	import java.io.UnsupportedEncodingException;
	import java.nio.ByteBuffer;
	import java.nio.charset.Charset;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.List;

	public class VCardEntryConstructor implements VCardInterpreter {
	private static String LOG_TAG = "VCardEntryConstructor";

	/**
	* If there's no other information available, this class uses this charset for encoding
	* byte arrays to String.
	*/
	/* package */ static final String DEFAULT_CHARSET_FOR_DECODED_BYTES = "UTF-8";

	private VCardEntry.Property mCurrentProperty = new VCardEntry.Property();
	private VCardEntry mCurrentContactStruct;
	private String mParamType;

	/**
	* The charset using which {@link VCardInterpreter} parses the text.
	*/
	private String mInputCharset;

	/**
	* The charset with which byte array is encoded to String.
	*/
	final private String mCharsetForDecodedBytes;
	final private boolean mStrictLineBreakParsing;
	final private int mVCardType;
	final private Account mAccount;

	/** For measuring performance. */
	private long mTimePushIntoContentResolver;

	final private List<VCardEntryHandler> mEntryHandlers = new ArrayList<VCardEntryHandler>();

	public VCardEntryConstructor() {
	this(null, null, false, VCardConfig.VCARD_TYPE_V21_GENERIC_UTF8, null);
	}

	public VCardEntryConstructor(final int vcardType) {
	this(null, null, false, vcardType, null);
	}

	public VCardEntryConstructor(final String charset, final boolean strictLineBreakParsing,
	final int vcardType, final Account account) {
	this(null, charset, strictLineBreakParsing, vcardType, account);
	}

	public VCardEntryConstructor(final String inputCharset, final String charsetForDetodedBytes,
	final boolean strictLineBreakParsing, final int vcardType,
	final Account account) {
	if (inputCharset != null) {
	mInputCharset = inputCharset;
	} else {
	mInputCharset = VCardConfig.DEFAULT_CHARSET;
	}
	if (charsetForDetodedBytes != null) {
	mCharsetForDecodedBytes = charsetForDetodedBytes;
	} else {
	mCharsetForDecodedBytes = DEFAULT_CHARSET_FOR_DECODED_BYTES;
	}
	mStrictLineBreakParsing = strictLineBreakParsing;
	mVCardType = vcardType;
	mAccount = account;
	}

	public void addEntryHandler(VCardEntryHandler entryHandler) {
	mEntryHandlers.add(entryHandler);
	}

	public void start() {
	for (VCardEntryHandler entryHandler : mEntryHandlers) {
	entryHandler.onStart();
	}
	}

	public void end() {
	for (VCardEntryHandler entryHandler : mEntryHandlers) {
	entryHandler.onEnd();
	}
	}

	/**
	* Called when the parse failed between {@link #startEntry()} and {@link #endEntry()}.
	*/
	public void clear() {
	mCurrentContactStruct = null;
	mCurrentProperty = new VCardEntry.Property();
	}

	/**
	* Assume that VCard is not nested. In other words, this code does not accept
	*/
	public void startEntry() {
	if (mCurrentContactStruct != null) {
	Log.e(LOG_TAG, "Nested VCard code is not supported now.");
	}
	mCurrentContactStruct = new VCardEntry(mVCardType, mAccount);
	}

	public void endEntry() {
	mCurrentContactStruct.consolidateFields();
	for (VCardEntryHandler entryHandler : mEntryHandlers) {
	entryHandler.onEntryCreated(mCurrentContactStruct);
	}
	mCurrentContactStruct = null;
	}

	public void startProperty() {
	mCurrentProperty.clear();
	}

	public void endProperty() {
	mCurrentContactStruct.addProperty(mCurrentProperty);
	}

	public void propertyName(String name) {
	mCurrentProperty.setPropertyName(name);
	}

	public void propertyGroup(String group) {
	}

	public void propertyParamType(String type) {
	if (mParamType != null) {
	Log.e(LOG_TAG, "propertyParamType() is called more than once " +
	"before propertyParamValue() is called");
	}
	mParamType = type;
	}

	public void propertyParamValue(String value) {
	if (mParamType == null) {
	// From vCard 2.1 specification. vCard 3.0 formally does not allow this case.
	mParamType = "TYPE";
	}
	mCurrentProperty.addParameter(mParamType, value);
	mParamType = null;
	}

	private String encodeString(String originalString, String charsetForDecodedBytes) {
	if (mInputCharset.equalsIgnoreCase(charsetForDecodedBytes)) {
	return originalString;
	}
	Charset charset = Charset.forName(mInputCharset);
	ByteBuffer byteBuffer = charset.encode(originalString);
	// byteBuffer.array() "may" return byte array which is larger than
	// byteBuffer.remaining(). Here, we keep on the safe side.
	byte[] bytes = new byte[byteBuffer.remaining()];
	byteBuffer.get(bytes);
	try {
	return new String(bytes, charsetForDecodedBytes);
	} catch (UnsupportedEncodingException e) {
	Log.e(LOG_TAG, "Failed to encode: charset=" + charsetForDecodedBytes);
	return null;
	}
	}

	private String handleOneValue(String value, String charsetForDecodedBytes, String encoding) {
	if (encoding != null) {
	if (encoding.equals("BASE64") \|\| encoding.equals("B")) {
	mCurrentProperty.setPropertyBytes(Base64.decodeBase64(value.getBytes()));
	return value;
	} else if (encoding.equals("QUOTED-PRINTABLE")) {
	// "= " -> " ", "=\t" -> "\t".
	// Previous code had done this replacement. Keep on the safe side.
	StringBuilder builder = new StringBuilder();
	int length = value.length();
	for (int i = 0; i < length; i++) {
	char ch = value.charAt(i);
	if (ch == '=' && i < length - 1) {
	char nextCh = value.charAt(i + 1);
	if (nextCh == ' ' \|\| nextCh == '\t') {

	builder.append(nextCh);
	i++;
	continue;
	}
	}
	builder.append(ch);
	}
	String quotedPrintable = builder.toString();

	String[] lines;
	if (mStrictLineBreakParsing) {
	lines = quotedPrintable.split("\r\n");
	} else {
	builder = new StringBuilder();
	length = quotedPrintable.length();
	ArrayList<String> list = new ArrayList<String>();
	for (int i = 0; i < length; i++) {
	char ch = quotedPrintable.charAt(i);
	if (ch == '\n') {
	list.add(builder.toString());
	builder = new StringBuilder();
	} else if (ch == '\r') {
	list.add(builder.toString());
	builder = new StringBuilder();
	if (i < length - 1) {
	char nextCh = quotedPrintable.charAt(i + 1);
	if (nextCh == '\n') {
	i++;
	}
	}
	} else {
	builder.append(ch);
	}
	}
	String finalLine = builder.toString();
	if (finalLine.length() > 0) {
	list.add(finalLine);
	}
	lines = list.toArray(new String[0]);
	}

	builder = new StringBuilder();
	for (String line : lines) {
	if (line.endsWith("=")) {
	line = line.substring(0, line.length() - 1);
	}
	builder.append(line);
	}
	byte[] bytes;
	try {
	bytes = builder.toString().getBytes(mInputCharset);
	} catch (UnsupportedEncodingException e1) {
	Log.e(LOG_TAG, "Failed to encode: charset=" + mInputCharset);
	bytes = builder.toString().getBytes();
	}

	try {
	bytes = QuotedPrintableCodec.decodeQuotedPrintable(bytes);
	} catch (DecoderException e) {
	Log.e(LOG_TAG, "Failed to decode quoted-printable: " + e);
	return "";
	}

	try {
	return new String(bytes, charsetForDecodedBytes);
	} catch (UnsupportedEncodingException e) {
	Log.e(LOG_TAG, "Failed to encode: charset=" + charsetForDecodedBytes);
	return new String(bytes);
	}
	}
	// Unknown encoding. Fall back to default.
	}
	return encodeString(value, charsetForDecodedBytes);
	}

	public void propertyValues(List<String> values) {
	if (values == null \|\| values.isEmpty()) {
	return;
	}

	final Collection<String> charsetCollection = mCurrentProperty.getParameters("CHARSET");
	final String charset =
	((charsetCollection != null) ? charsetCollection.iterator().next() : null);
	final Collection<String> encodingCollection = mCurrentProperty.getParameters("ENCODING");
	final String encoding =
	((encodingCollection != null) ? encodingCollection.iterator().next() : null);

	String charsetForDecodedBytes = CharsetUtils.nameForDefaultVendor(charset);
	if (charsetForDecodedBytes == null \|\| charsetForDecodedBytes.length() == 0) {
	charsetForDecodedBytes = mCharsetForDecodedBytes;
	}

	for (final String value : values) {
	mCurrentProperty.addToPropertyValueList(
	handleOneValue(value, charsetForDecodedBytes, encoding));
	}
	}

	public void showPerformanceInfo() {
	Log.d(LOG_TAG, "time for insert ContactStruct to database: " +
	mTimePushIntoContentResolver + " ms");
	}
	}