/* * 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 com.android.vcard; import android.content.ContentValues; import android.provider.ContactsContract.CommonDataKinds.Email; import android.provider.ContactsContract.CommonDataKinds.Event; import android.provider.ContactsContract.CommonDataKinds.Im; import android.provider.ContactsContract.CommonDataKinds.Nickname; import android.provider.ContactsContract.CommonDataKinds.Note; import android.provider.ContactsContract.CommonDataKinds.Organization; import android.provider.ContactsContract.CommonDataKinds.Phone; import android.provider.ContactsContract.CommonDataKinds.Photo; import android.provider.ContactsContract.CommonDataKinds.Relation; import android.provider.ContactsContract.CommonDataKinds.SipAddress; import android.provider.ContactsContract.CommonDataKinds.StructuredName; import android.provider.ContactsContract.CommonDataKinds.StructuredPostal; import android.provider.ContactsContract.CommonDataKinds.Website; import android.telephony.PhoneNumberUtils; import android.text.TextUtils; import android.util.Base64; import android.util.Log; import com.android.vcard.VCardUtils.PhoneNumberUtilsPort; import java.io.UnsupportedEncodingException; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; /** * <p> * The class which lets users create their own vCard String. Typical usage is as follows: * </p> * <pre class="prettyprint">final VCardBuilder builder = new VCardBuilder(vcardType); * builder.appendNameProperties(contentValuesListMap.get(StructuredName.CONTENT_ITEM_TYPE)) * .appendNickNames(contentValuesListMap.get(Nickname.CONTENT_ITEM_TYPE)) * .appendPhones(contentValuesListMap.get(Phone.CONTENT_ITEM_TYPE)) * .appendEmails(contentValuesListMap.get(Email.CONTENT_ITEM_TYPE)) * .appendPostals(contentValuesListMap.get(StructuredPostal.CONTENT_ITEM_TYPE)) * .appendOrganizations(contentValuesListMap.get(Organization.CONTENT_ITEM_TYPE)) * .appendWebsites(contentValuesListMap.get(Website.CONTENT_ITEM_TYPE)) * .appendPhotos(contentValuesListMap.get(Photo.CONTENT_ITEM_TYPE)) * .appendNotes(contentValuesListMap.get(Note.CONTENT_ITEM_TYPE)) * .appendEvents(contentValuesListMap.get(Event.CONTENT_ITEM_TYPE)) * .appendIms(contentValuesListMap.get(Im.CONTENT_ITEM_TYPE)) * .appendRelation(contentValuesListMap.get(Relation.CONTENT_ITEM_TYPE)); * return builder.toString();</pre> */ public class VCardBuilder { private static final String LOG_TAG = VCardConstants.LOG_TAG; // If you add the other element, please check all the columns are able to be // converted to String. // // e.g. BLOB is not what we can handle here now. private static final Set<String> sAllowedAndroidPropertySet = Collections.unmodifiableSet(new HashSet<String>(Arrays.asList( Nickname.CONTENT_ITEM_TYPE, Event.CONTENT_ITEM_TYPE, Relation.CONTENT_ITEM_TYPE))); public static final int DEFAULT_PHONE_TYPE = Phone.TYPE_HOME; public static final int DEFAULT_POSTAL_TYPE = StructuredPostal.TYPE_HOME; public static final int DEFAULT_EMAIL_TYPE = Email.TYPE_OTHER; private static final String VCARD_DATA_VCARD = "VCARD"; private static final String VCARD_DATA_PUBLIC = "PUBLIC"; private static final String VCARD_PARAM_SEPARATOR = ";"; public static final String VCARD_END_OF_LINE = "\r\n"; private static final String VCARD_DATA_SEPARATOR = ":"; private static final String VCARD_ITEM_SEPARATOR = ";"; private static final String VCARD_WS = " "; private static final String VCARD_PARAM_EQUAL = "="; private static final String VCARD_PARAM_ENCODING_QP = "ENCODING=" + VCardConstants.PARAM_ENCODING_QP; private static final String VCARD_PARAM_ENCODING_BASE64_V21 = "ENCODING=" + VCardConstants.PARAM_ENCODING_BASE64; private static final String VCARD_PARAM_ENCODING_BASE64_AS_B = "ENCODING=" + VCardConstants.PARAM_ENCODING_B; private static final String SHIFT_JIS = "SHIFT_JIS"; private final int mVCardType; private final boolean mIsV30OrV40; private final boolean mIsJapaneseMobilePhone; private final boolean mOnlyOneNoteFieldIsAvailable; private final boolean mIsDoCoMo; private final boolean mShouldUseQuotedPrintable; private final boolean mUsesAndroidProperty; private final boolean mUsesDefactProperty; private final boolean mAppendTypeParamName; private final boolean mRefrainsQPToNameProperties; private final boolean mNeedsToConvertPhoneticString; private final boolean mShouldAppendCharsetParam; private final String mCharset; private final String mVCardCharsetParameter; private StringBuilder mBuilder; private boolean mEndAppended; public VCardBuilder(final int vcardType) { // Default charset should be used this(vcardType, null); } /** * @param vcardType * @param charset If null, we use default charset for export. * @hide */ public VCardBuilder(final int vcardType, String charset) { mVCardType = vcardType; if (VCardConfig.isVersion40(vcardType)) { Log.w(LOG_TAG, "Should not use vCard 4.0 when building vCard. " + "It is not officially published yet."); } mIsV30OrV40 = VCardConfig.isVersion30(vcardType) || VCardConfig.isVersion40(vcardType); mShouldUseQuotedPrintable = VCardConfig.shouldUseQuotedPrintable(vcardType); mIsDoCoMo = VCardConfig.isDoCoMo(vcardType); mIsJapaneseMobilePhone = VCardConfig.needsToConvertPhoneticString(vcardType); mOnlyOneNoteFieldIsAvailable = VCardConfig.onlyOneNoteFieldIsAvailable(vcardType); mUsesAndroidProperty = VCardConfig.usesAndroidSpecificProperty(vcardType); mUsesDefactProperty = VCardConfig.usesDefactProperty(vcardType); mRefrainsQPToNameProperties = VCardConfig.shouldRefrainQPToNameProperties(vcardType); mAppendTypeParamName = VCardConfig.appendTypeParamName(vcardType); mNeedsToConvertPhoneticString = VCardConfig.needsToConvertPhoneticString(vcardType); // vCard 2.1 requires charset. // vCard 3.0 does not allow it but we found some devices use it to determine // the exact charset. // We currently append it only when charset other than UTF_8 is used. mShouldAppendCharsetParam = !(VCardConfig.isVersion30(vcardType) && "UTF-8".equalsIgnoreCase(charset)); if (VCardConfig.isDoCoMo(vcardType)) { if (!SHIFT_JIS.equalsIgnoreCase(charset)) { /* Log.w(LOG_TAG, "The charset \"" + charset + "\" is used while " + SHIFT_JIS + " is needed to be used."); */ if (TextUtils.isEmpty(charset)) { mCharset = SHIFT_JIS; } else { mCharset = charset; } } else { mCharset = charset; } mVCardCharsetParameter = "CHARSET=" + SHIFT_JIS; } else { if (TextUtils.isEmpty(charset)) { Log.i(LOG_TAG, "Use the charset \"" + VCardConfig.DEFAULT_EXPORT_CHARSET + "\" for export."); mCharset = VCardConfig.DEFAULT_EXPORT_CHARSET; mVCardCharsetParameter = "CHARSET=" + VCardConfig.DEFAULT_EXPORT_CHARSET; } else { mCharset = charset; mVCardCharsetParameter = "CHARSET=" + charset; } } clear(); } public void clear() { mBuilder = new StringBuilder(); mEndAppended = false; appendLine(VCardConstants.PROPERTY_BEGIN, VCARD_DATA_VCARD); if (VCardConfig.isVersion40(mVCardType)) { appendLine(VCardConstants.PROPERTY_VERSION, VCardConstants.VERSION_V40); } else if (VCardConfig.isVersion30(mVCardType)) { appendLine(VCardConstants.PROPERTY_VERSION, VCardConstants.VERSION_V30); } else { if (!VCardConfig.isVersion21(mVCardType)) { Log.w(LOG_TAG, "Unknown vCard version detected."); } appendLine(VCardConstants.PROPERTY_VERSION, VCardConstants.VERSION_V21); } } private boolean containsNonEmptyName(final ContentValues contentValues) { final String familyName = contentValues.getAsString(StructuredName.FAMILY_NAME); final String middleName = contentValues.getAsString(StructuredName.MIDDLE_NAME); final String givenName = contentValues.getAsString(StructuredName.GIVEN_NAME); final String prefix = contentValues.getAsString(StructuredName.PREFIX); final String suffix = contentValues.getAsString(StructuredName.SUFFIX); final String phoneticFamilyName = contentValues.getAsString(StructuredName.PHONETIC_FAMILY_NAME); final String phoneticMiddleName = contentValues.getAsString(StructuredName.PHONETIC_MIDDLE_NAME); final String phoneticGivenName = contentValues.getAsString(StructuredName.PHONETIC_GIVEN_NAME); final String displayName = contentValues.getAsString(StructuredName.DISPLAY_NAME); return !(TextUtils.isEmpty(familyName) && TextUtils.isEmpty(middleName) && TextUtils.isEmpty(givenName) && TextUtils.isEmpty(prefix) && TextUtils.isEmpty(suffix) && TextUtils.isEmpty(phoneticFamilyName) && TextUtils.isEmpty(phoneticMiddleName) && TextUtils.isEmpty(phoneticGivenName) && TextUtils.isEmpty(displayName)); } private ContentValues getPrimaryContentValueWithStructuredName( final List<ContentValues> contentValuesList) { ContentValues primaryContentValues = null; ContentValues subprimaryContentValues = null; for (ContentValues contentValues : contentValuesList) { if (contentValues == null){ continue; } Integer isSuperPrimary = contentValues.getAsInteger(StructuredName.IS_SUPER_PRIMARY); if (isSuperPrimary != null && isSuperPrimary > 0) { // We choose "super primary" ContentValues. primaryContentValues = contentValues; break; } else if (primaryContentValues == null) { // We choose the first "primary" ContentValues // if "super primary" ContentValues does not exist. final Integer isPrimary = contentValues.getAsInteger(StructuredName.IS_PRIMARY); if (isPrimary != null && isPrimary > 0 && containsNonEmptyName(contentValues)) { primaryContentValues = contentValues; // Do not break, since there may be ContentValues with "super primary" // afterword. } else if (subprimaryContentValues == null && containsNonEmptyName(contentValues)) { subprimaryContentValues = contentValues; } } } if (primaryContentValues == null) { if (subprimaryContentValues != null) { // We choose the first ContentValues if any "primary" ContentValues does not exist. primaryContentValues = subprimaryContentValues; } else { // There's no appropriate ContentValue with StructuredName. primaryContentValues = new ContentValues(); } } return primaryContentValues; } /** * To avoid unnecessary complication in logic, we use this method to construct N, FN * properties for vCard 4.0. */ private VCardBuilder appendNamePropertiesV40(final List<ContentValues> contentValuesList) { if (mIsDoCoMo || mNeedsToConvertPhoneticString) { // Ignore all flags that look stale from the view of vCard 4.0 to // simplify construction algorithm. Actually we don't have any vCard file // available from real world yet, so we may need to re-enable some of these // in the future. Log.w(LOG_TAG, "Invalid flag is used in vCard 4.0 construction. Ignored."); } if (contentValuesList == null || contentValuesList.isEmpty()) { appendLine(VCardConstants.PROPERTY_FN, ""); return this; } // We have difficulty here. How can we appropriately handle StructuredName with // missing parts necessary for displaying while it has suppremental information. // // e.g. How to handle non-empty phonetic names with empty structured names? final ContentValues contentValues = getPrimaryContentValueWithStructuredName(contentValuesList); String familyName = contentValues.getAsString(StructuredName.FAMILY_NAME); final String middleName = contentValues.getAsString(StructuredName.MIDDLE_NAME); final String givenName = contentValues.getAsString(StructuredName.GIVEN_NAME); final String prefix = contentValues.getAsString(StructuredName.PREFIX); final String suffix = contentValues.getAsString(StructuredName.SUFFIX); final String formattedName = contentValues.getAsString(StructuredName.DISPLAY_NAME); if (TextUtils.isEmpty(familyName) && TextUtils.isEmpty(givenName) && TextUtils.isEmpty(middleName) && TextUtils.isEmpty(prefix) && TextUtils.isEmpty(suffix)) { if (TextUtils.isEmpty(formattedName)) { appendLine(VCardConstants.PROPERTY_FN, ""); return this; } familyName = formattedName; } final String phoneticFamilyName = contentValues.getAsString(StructuredName.PHONETIC_FAMILY_NAME); final String phoneticMiddleName = contentValues.getAsString(StructuredName.PHONETIC_MIDDLE_NAME); final String phoneticGivenName = contentValues.getAsString(StructuredName.PHONETIC_GIVEN_NAME); final String escapedFamily = escapeCharacters(familyName); final String escapedGiven = escapeCharacters(givenName); final String escapedMiddle = escapeCharacters(middleName); final String escapedPrefix = escapeCharacters(prefix); final String escapedSuffix = escapeCharacters(suffix); mBuilder.append(VCardConstants.PROPERTY_N); if (!(TextUtils.isEmpty(phoneticFamilyName) && TextUtils.isEmpty(phoneticMiddleName) && TextUtils.isEmpty(phoneticGivenName))) { mBuilder.append(VCARD_PARAM_SEPARATOR); final String sortAs = escapeCharacters(phoneticFamilyName) + ';' + escapeCharacters(phoneticGivenName) + ';' + escapeCharacters(phoneticMiddleName); mBuilder.append("SORT-AS=").append( VCardUtils.toStringAsV40ParamValue(sortAs)); } mBuilder.append(VCARD_DATA_SEPARATOR); mBuilder.append(escapedFamily); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(escapedGiven); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(escapedMiddle); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(escapedPrefix); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(escapedSuffix); mBuilder.append(VCARD_END_OF_LINE); if (TextUtils.isEmpty(formattedName)) { // Note: // DISPLAY_NAME doesn't exist while some other elements do, which is usually // weird in Android, as DISPLAY_NAME should (usually) be constructed // from the others using locale information and its code points. Log.w(LOG_TAG, "DISPLAY_NAME is empty."); final String escaped = escapeCharacters(VCardUtils.constructNameFromElements( VCardConfig.getNameOrderType(mVCardType), familyName, middleName, givenName, prefix, suffix)); appendLine(VCardConstants.PROPERTY_FN, escaped); } else { final String escapedFormatted = escapeCharacters(formattedName); mBuilder.append(VCardConstants.PROPERTY_FN); mBuilder.append(VCARD_DATA_SEPARATOR); mBuilder.append(escapedFormatted); mBuilder.append(VCARD_END_OF_LINE); } // We may need X- properties for phonetic names. appendPhoneticNameFields(contentValues); return this; } /** * For safety, we'll emit just one value around StructuredName, as external importers * may get confused with multiple "N", "FN", etc. properties, though it is valid in * vCard spec. */ public VCardBuilder appendNameProperties(final List<ContentValues> contentValuesList) { if (VCardConfig.isVersion40(mVCardType)) { return appendNamePropertiesV40(contentValuesList); } if (contentValuesList == null || contentValuesList.isEmpty()) { if (VCardConfig.isVersion30(mVCardType)) { // vCard 3.0 requires "N" and "FN" properties. // vCard 4.0 does NOT require N, but we take care of possible backward // compatibility issues. appendLine(VCardConstants.PROPERTY_N, ""); appendLine(VCardConstants.PROPERTY_FN, ""); } else if (mIsDoCoMo) { appendLine(VCardConstants.PROPERTY_N, ""); } return this; } final ContentValues contentValues = getPrimaryContentValueWithStructuredName(contentValuesList); final String familyName = contentValues.getAsString(StructuredName.FAMILY_NAME); final String middleName = contentValues.getAsString(StructuredName.MIDDLE_NAME); final String givenName = contentValues.getAsString(StructuredName.GIVEN_NAME); final String prefix = contentValues.getAsString(StructuredName.PREFIX); final String suffix = contentValues.getAsString(StructuredName.SUFFIX); final String displayName = contentValues.getAsString(StructuredName.DISPLAY_NAME); if (!TextUtils.isEmpty(familyName) || !TextUtils.isEmpty(givenName)) { final boolean reallyAppendCharsetParameterToName = shouldAppendCharsetParam(familyName, givenName, middleName, prefix, suffix); final boolean reallyUseQuotedPrintableToName = (!mRefrainsQPToNameProperties && !(VCardUtils.containsOnlyNonCrLfPrintableAscii(familyName) && VCardUtils.containsOnlyNonCrLfPrintableAscii(givenName) && VCardUtils.containsOnlyNonCrLfPrintableAscii(middleName) && VCardUtils.containsOnlyNonCrLfPrintableAscii(prefix) && VCardUtils.containsOnlyNonCrLfPrintableAscii(suffix))); final String formattedName; if (!TextUtils.isEmpty(displayName)) { formattedName = displayName; } else { formattedName = VCardUtils.constructNameFromElements( VCardConfig.getNameOrderType(mVCardType), familyName, middleName, givenName, prefix, suffix); } final boolean reallyAppendCharsetParameterToFN = shouldAppendCharsetParam(formattedName); final boolean reallyUseQuotedPrintableToFN = !mRefrainsQPToNameProperties && !VCardUtils.containsOnlyNonCrLfPrintableAscii(formattedName); final String encodedFamily; final String encodedGiven; final String encodedMiddle; final String encodedPrefix; final String encodedSuffix; if (reallyUseQuotedPrintableToName) { encodedFamily = encodeQuotedPrintable(familyName); encodedGiven = encodeQuotedPrintable(givenName); encodedMiddle = encodeQuotedPrintable(middleName); encodedPrefix = encodeQuotedPrintable(prefix); encodedSuffix = encodeQuotedPrintable(suffix); } else { encodedFamily = escapeCharacters(familyName); encodedGiven = escapeCharacters(givenName); encodedMiddle = escapeCharacters(middleName); encodedPrefix = escapeCharacters(prefix); encodedSuffix = escapeCharacters(suffix); } final String encodedFormattedname = (reallyUseQuotedPrintableToFN ? encodeQuotedPrintable(formattedName) : escapeCharacters(formattedName)); mBuilder.append(VCardConstants.PROPERTY_N); if (mIsDoCoMo) { if (reallyAppendCharsetParameterToName) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(mVCardCharsetParameter); } if (reallyUseQuotedPrintableToName) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(VCARD_PARAM_ENCODING_QP); } mBuilder.append(VCARD_DATA_SEPARATOR); // DoCoMo phones require that all the elements in the "family name" field. mBuilder.append(formattedName); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(VCARD_ITEM_SEPARATOR); } else { if (reallyAppendCharsetParameterToName) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(mVCardCharsetParameter); } if (reallyUseQuotedPrintableToName) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(VCARD_PARAM_ENCODING_QP); } mBuilder.append(VCARD_DATA_SEPARATOR); mBuilder.append(encodedFamily); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(encodedGiven); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(encodedMiddle); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(encodedPrefix); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(encodedSuffix); } mBuilder.append(VCARD_END_OF_LINE); // FN property mBuilder.append(VCardConstants.PROPERTY_FN); if (reallyAppendCharsetParameterToFN) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(mVCardCharsetParameter); } if (reallyUseQuotedPrintableToFN) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(VCARD_PARAM_ENCODING_QP); } mBuilder.append(VCARD_DATA_SEPARATOR); mBuilder.append(encodedFormattedname); mBuilder.append(VCARD_END_OF_LINE); } else if (!TextUtils.isEmpty(displayName)) { // N buildSinglePartNameField(VCardConstants.PROPERTY_N, displayName); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(VCARD_END_OF_LINE); // FN buildSinglePartNameField(VCardConstants.PROPERTY_FN, displayName); mBuilder.append(VCARD_END_OF_LINE); } else if (VCardConfig.isVersion30(mVCardType)) { appendLine(VCardConstants.PROPERTY_N, ""); appendLine(VCardConstants.PROPERTY_FN, ""); } else if (mIsDoCoMo) { appendLine(VCardConstants.PROPERTY_N, ""); } appendPhoneticNameFields(contentValues); return this; } private void buildSinglePartNameField(String property, String part) { final boolean reallyUseQuotedPrintable = (!mRefrainsQPToNameProperties && !VCardUtils.containsOnlyNonCrLfPrintableAscii(part)); final String encodedPart = reallyUseQuotedPrintable ? encodeQuotedPrintable(part) : escapeCharacters(part); mBuilder.append(property); // Note: "CHARSET" param is not allowed in vCard 3.0, but we may add it // when it would be useful or necessary for external importers, // assuming the external importer allows this vioration of the spec. if (shouldAppendCharsetParam(part)) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(mVCardCharsetParameter); } if (reallyUseQuotedPrintable) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(VCARD_PARAM_ENCODING_QP); } mBuilder.append(VCARD_DATA_SEPARATOR); mBuilder.append(encodedPart); } /** * Emits SOUND;IRMC, SORT-STRING, and de-fact values for phonetic names like X-PHONETIC-FAMILY. */ private void appendPhoneticNameFields(final ContentValues contentValues) { final String phoneticFamilyName; final String phoneticMiddleName; final String phoneticGivenName; { final String tmpPhoneticFamilyName = contentValues.getAsString(StructuredName.PHONETIC_FAMILY_NAME); final String tmpPhoneticMiddleName = contentValues.getAsString(StructuredName.PHONETIC_MIDDLE_NAME); final String tmpPhoneticGivenName = contentValues.getAsString(StructuredName.PHONETIC_GIVEN_NAME); if (mNeedsToConvertPhoneticString) { phoneticFamilyName = VCardUtils.toHalfWidthString(tmpPhoneticFamilyName); phoneticMiddleName = VCardUtils.toHalfWidthString(tmpPhoneticMiddleName); phoneticGivenName = VCardUtils.toHalfWidthString(tmpPhoneticGivenName); } else { phoneticFamilyName = tmpPhoneticFamilyName; phoneticMiddleName = tmpPhoneticMiddleName; phoneticGivenName = tmpPhoneticGivenName; } } if (TextUtils.isEmpty(phoneticFamilyName) && TextUtils.isEmpty(phoneticMiddleName) && TextUtils.isEmpty(phoneticGivenName)) { if (mIsDoCoMo) { mBuilder.append(VCardConstants.PROPERTY_SOUND); mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(VCardConstants.PARAM_TYPE_X_IRMC_N); mBuilder.append(VCARD_DATA_SEPARATOR); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(VCARD_END_OF_LINE); } return; } if (VCardConfig.isVersion40(mVCardType)) { // We don't want SORT-STRING anyway. } else if (VCardConfig.isVersion30(mVCardType)) { final String sortString = VCardUtils.constructNameFromElements(mVCardType, phoneticFamilyName, phoneticMiddleName, phoneticGivenName); mBuilder.append(VCardConstants.PROPERTY_SORT_STRING); if (VCardConfig.isVersion30(mVCardType) && shouldAppendCharsetParam(sortString)) { // vCard 3.0 does not force us to use UTF-8 and actually we see some // programs which emit this value. It is incorrect from the view of // specification, but actually necessary for parsing vCard with non-UTF-8 // charsets, expecting other parsers not get confused with this value. mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(mVCardCharsetParameter); } mBuilder.append(VCARD_DATA_SEPARATOR); mBuilder.append(escapeCharacters(sortString)); mBuilder.append(VCARD_END_OF_LINE); } else if (mIsJapaneseMobilePhone) { // Note: There is no appropriate property for expressing // phonetic name (Yomigana in Japanese) in vCard 2.1, while there is in // vCard 3.0 (SORT-STRING). // We use DoCoMo's way when the device is Japanese one since it is already // supported by a lot of Japanese mobile phones. // This is "X-" property, so any parser hopefully would not get // confused with this. // // Also, DoCoMo's specification requires vCard composer to use just the first // column. // i.e. // good: SOUND;X-IRMC-N:Miyakawa Daisuke;;;; // bad : SOUND;X-IRMC-N:Miyakawa;Daisuke;;; mBuilder.append(VCardConstants.PROPERTY_SOUND); mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(VCardConstants.PARAM_TYPE_X_IRMC_N); boolean reallyUseQuotedPrintable = (!mRefrainsQPToNameProperties && !(VCardUtils.containsOnlyNonCrLfPrintableAscii( phoneticFamilyName) && VCardUtils.containsOnlyNonCrLfPrintableAscii( phoneticMiddleName) && VCardUtils.containsOnlyNonCrLfPrintableAscii( phoneticGivenName))); final String encodedPhoneticFamilyName; final String encodedPhoneticMiddleName; final String encodedPhoneticGivenName; if (reallyUseQuotedPrintable) { encodedPhoneticFamilyName = encodeQuotedPrintable(phoneticFamilyName); encodedPhoneticMiddleName = encodeQuotedPrintable(phoneticMiddleName); encodedPhoneticGivenName = encodeQuotedPrintable(phoneticGivenName); } else { encodedPhoneticFamilyName = escapeCharacters(phoneticFamilyName); encodedPhoneticMiddleName = escapeCharacters(phoneticMiddleName); encodedPhoneticGivenName = escapeCharacters(phoneticGivenName); } if (shouldAppendCharsetParam(encodedPhoneticFamilyName, encodedPhoneticMiddleName, encodedPhoneticGivenName)) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(mVCardCharsetParameter); } mBuilder.append(VCARD_DATA_SEPARATOR); { boolean first = true; if (!TextUtils.isEmpty(encodedPhoneticFamilyName)) { mBuilder.append(encodedPhoneticFamilyName); first = false; } if (!TextUtils.isEmpty(encodedPhoneticMiddleName)) { if (first) { first = false; } else { mBuilder.append(' '); } mBuilder.append(encodedPhoneticMiddleName); } if (!TextUtils.isEmpty(encodedPhoneticGivenName)) { if (!first) { mBuilder.append(' '); } mBuilder.append(encodedPhoneticGivenName); } } mBuilder.append(VCARD_ITEM_SEPARATOR); // family;given mBuilder.append(VCARD_ITEM_SEPARATOR); // given;middle mBuilder.append(VCARD_ITEM_SEPARATOR); // middle;prefix mBuilder.append(VCARD_ITEM_SEPARATOR); // prefix;suffix mBuilder.append(VCARD_END_OF_LINE); } if (mUsesDefactProperty) { if (!TextUtils.isEmpty(phoneticGivenName)) { final boolean reallyUseQuotedPrintable = (mShouldUseQuotedPrintable && !VCardUtils.containsOnlyNonCrLfPrintableAscii(phoneticGivenName)); final String encodedPhoneticGivenName; if (reallyUseQuotedPrintable) { encodedPhoneticGivenName = encodeQuotedPrintable(phoneticGivenName); } else { encodedPhoneticGivenName = escapeCharacters(phoneticGivenName); } mBuilder.append(VCardConstants.PROPERTY_X_PHONETIC_FIRST_NAME); if (shouldAppendCharsetParam(phoneticGivenName)) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(mVCardCharsetParameter); } if (reallyUseQuotedPrintable) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(VCARD_PARAM_ENCODING_QP); } mBuilder.append(VCARD_DATA_SEPARATOR); mBuilder.append(encodedPhoneticGivenName); mBuilder.append(VCARD_END_OF_LINE); } // if (!TextUtils.isEmpty(phoneticGivenName)) if (!TextUtils.isEmpty(phoneticMiddleName)) { final boolean reallyUseQuotedPrintable = (mShouldUseQuotedPrintable && !VCardUtils.containsOnlyNonCrLfPrintableAscii(phoneticMiddleName)); final String encodedPhoneticMiddleName; if (reallyUseQuotedPrintable) { encodedPhoneticMiddleName = encodeQuotedPrintable(phoneticMiddleName); } else { encodedPhoneticMiddleName = escapeCharacters(phoneticMiddleName); } mBuilder.append(VCardConstants.PROPERTY_X_PHONETIC_MIDDLE_NAME); if (shouldAppendCharsetParam(phoneticMiddleName)) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(mVCardCharsetParameter); } if (reallyUseQuotedPrintable) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(VCARD_PARAM_ENCODING_QP); } mBuilder.append(VCARD_DATA_SEPARATOR); mBuilder.append(encodedPhoneticMiddleName); mBuilder.append(VCARD_END_OF_LINE); } // if (!TextUtils.isEmpty(phoneticGivenName)) if (!TextUtils.isEmpty(phoneticFamilyName)) { final boolean reallyUseQuotedPrintable = (mShouldUseQuotedPrintable && !VCardUtils.containsOnlyNonCrLfPrintableAscii(phoneticFamilyName)); final String encodedPhoneticFamilyName; if (reallyUseQuotedPrintable) { encodedPhoneticFamilyName = encodeQuotedPrintable(phoneticFamilyName); } else { encodedPhoneticFamilyName = escapeCharacters(phoneticFamilyName); } mBuilder.append(VCardConstants.PROPERTY_X_PHONETIC_LAST_NAME); if (shouldAppendCharsetParam(phoneticFamilyName)) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(mVCardCharsetParameter); } if (reallyUseQuotedPrintable) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(VCARD_PARAM_ENCODING_QP); } mBuilder.append(VCARD_DATA_SEPARATOR); mBuilder.append(encodedPhoneticFamilyName); mBuilder.append(VCARD_END_OF_LINE); } // if (!TextUtils.isEmpty(phoneticFamilyName)) } } public VCardBuilder appendNickNames(final List<ContentValues> contentValuesList) { final boolean useAndroidProperty; if (mIsV30OrV40) { // These specifications have NICKNAME property. useAndroidProperty = false; } else if (mUsesAndroidProperty) { useAndroidProperty = true; } else { // There's no way to add this field. return this; } if (contentValuesList != null) { for (ContentValues contentValues : contentValuesList) { final String nickname = contentValues.getAsString(Nickname.NAME); if (TextUtils.isEmpty(nickname)) { continue; } if (useAndroidProperty) { appendAndroidSpecificProperty(Nickname.CONTENT_ITEM_TYPE, contentValues); } else { appendLineWithCharsetAndQPDetection(VCardConstants.PROPERTY_NICKNAME, nickname); } } } return this; } public VCardBuilder appendPhones(final List<ContentValues> contentValuesList, VCardPhoneNumberTranslationCallback translationCallback) { boolean phoneLineExists = false; if (contentValuesList != null) { Set<String> phoneSet = new HashSet<String>(); for (ContentValues contentValues : contentValuesList) { final Integer typeAsObject = contentValues.getAsInteger(Phone.TYPE); final String label = contentValues.getAsString(Phone.LABEL); final Integer isPrimaryAsInteger = contentValues.getAsInteger(Phone.IS_PRIMARY); final boolean isPrimary = (isPrimaryAsInteger != null ? (isPrimaryAsInteger > 0) : false); String phoneNumber = contentValues.getAsString(Phone.NUMBER); if (phoneNumber != null) { phoneNumber = phoneNumber.trim(); } if (TextUtils.isEmpty(phoneNumber)) { continue; } final int type = (typeAsObject != null ? typeAsObject : DEFAULT_PHONE_TYPE); // Note: We prioritize this callback over FLAG_REFRAIN_PHONE_NUMBER_FORMATTING // intentionally. In the future the flag will be replaced by callback // mechanism entirely. if (translationCallback != null) { phoneNumber = translationCallback.onValueReceived( phoneNumber, type, label, isPrimary); if (!phoneSet.contains(phoneNumber)) { phoneSet.add(phoneNumber); appendTelLine(type, label, phoneNumber, isPrimary); } } else if (type == Phone.TYPE_PAGER || VCardConfig.refrainPhoneNumberFormatting(mVCardType)) { // Note: PAGER number needs unformatted "phone number". phoneLineExists = true; if (!phoneSet.contains(phoneNumber)) { phoneSet.add(phoneNumber); appendTelLine(type, label, phoneNumber, isPrimary); } } else { final List<String> phoneNumberList = splitPhoneNumbers(phoneNumber); if (phoneNumberList.isEmpty()) { continue; } phoneLineExists = true; for (String actualPhoneNumber : phoneNumberList) { if (!phoneSet.contains(actualPhoneNumber)) { // 'p' and 'w' are the standard characters for pause and wait // (see RFC 3601) // so use those when exporting phone numbers via vCard. String numberWithControlSequence = actualPhoneNumber .replace(PhoneNumberUtils.PAUSE, 'p') .replace(PhoneNumberUtils.WAIT, 'w'); String formatted; // TODO: remove this code and relevant test cases. vCard and any other // codes using it shouldn't rely on the formatter here. if (TextUtils.equals(numberWithControlSequence, actualPhoneNumber)) { StringBuilder digitsOnlyBuilder = new StringBuilder(); final int length = actualPhoneNumber.length(); for (int i = 0; i < length; i++) { final char ch = actualPhoneNumber.charAt(i); if (Character.isDigit(ch) || ch == '+') { digitsOnlyBuilder.append(ch); } } final int phoneFormat = VCardUtils.getPhoneNumberFormat(mVCardType); formatted = PhoneNumberUtilsPort.formatNumber( digitsOnlyBuilder.toString(), phoneFormat); } else { // Be conservative. formatted = numberWithControlSequence; } // In vCard 4.0, value type must be "a single URI value", // not just a phone number. (Based on vCard 4.0 rev.13) if (VCardConfig.isVersion40(mVCardType) && !TextUtils.isEmpty(formatted) && !formatted.startsWith("tel:")) { formatted = "tel:" + formatted; } // Pre-formatted string should be stored. phoneSet.add(actualPhoneNumber); appendTelLine(type, label, formatted, isPrimary); } } // for (String actualPhoneNumber : phoneNumberList) { // TODO: TEL with SIP URI? } } } if (!phoneLineExists && mIsDoCoMo) { appendTelLine(Phone.TYPE_HOME, "", "", false); } return this; } /** * <p> * Splits a given string expressing phone numbers into several strings, and remove * unnecessary characters inside them. The size of a returned list becomes 1 when * no split is needed. * </p> * <p> * The given number "may" have several phone numbers when the contact entry is corrupted * because of its original source. * e.g. "111-222-3333 (Miami)\n444-555-6666 (Broward; 305-653-6796 (Miami)" * </p> * <p> * This kind of "phone numbers" will not be created with Android vCard implementation, * but we may encounter them if the source of the input data has already corrupted * implementation. * </p> * <p> * To handle this case, this method first splits its input into multiple parts * (e.g. "111-222-3333 (Miami)", "444-555-6666 (Broward", and 305653-6796 (Miami)") and * removes unnecessary strings like "(Miami)". * </p> * <p> * Do not call this method when trimming is inappropriate for its receivers. * </p> */ private List<String> splitPhoneNumbers(final String phoneNumber) { final List<String> phoneList = new ArrayList<String>(); StringBuilder builder = new StringBuilder(); final int length = phoneNumber.length(); for (int i = 0; i < length; i++) { final char ch = phoneNumber.charAt(i); if (ch == '\n' && builder.length() > 0) { phoneList.add(builder.toString()); builder = new StringBuilder(); } else { builder.append(ch); } } if (builder.length() > 0) { phoneList.add(builder.toString()); } return phoneList; } public VCardBuilder appendEmails(final List<ContentValues> contentValuesList) { boolean emailAddressExists = false; if (contentValuesList != null) { final Set<String> addressSet = new HashSet<String>(); for (ContentValues contentValues : contentValuesList) { String emailAddress = contentValues.getAsString(Email.DATA); if (emailAddress != null) { emailAddress = emailAddress.trim(); } if (TextUtils.isEmpty(emailAddress)) { continue; } Integer typeAsObject = contentValues.getAsInteger(Email.TYPE); final int type = (typeAsObject != null ? typeAsObject : DEFAULT_EMAIL_TYPE); final String label = contentValues.getAsString(Email.LABEL); Integer isPrimaryAsInteger = contentValues.getAsInteger(Email.IS_PRIMARY); final boolean isPrimary = (isPrimaryAsInteger != null ? (isPrimaryAsInteger > 0) : false); emailAddressExists = true; if (!addressSet.contains(emailAddress)) { addressSet.add(emailAddress); appendEmailLine(type, label, emailAddress, isPrimary); } } } if (!emailAddressExists && mIsDoCoMo) { appendEmailLine(Email.TYPE_HOME, "", "", false); } return this; } public VCardBuilder appendPostals(final List<ContentValues> contentValuesList) { if (contentValuesList == null || contentValuesList.isEmpty()) { if (mIsDoCoMo) { mBuilder.append(VCardConstants.PROPERTY_ADR); mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(VCardConstants.PARAM_TYPE_HOME); mBuilder.append(VCARD_DATA_SEPARATOR); mBuilder.append(VCARD_END_OF_LINE); } } else { if (mIsDoCoMo) { appendPostalsForDoCoMo(contentValuesList); } else { appendPostalsForGeneric(contentValuesList); } } return this; } private static final Map<Integer, Integer> sPostalTypePriorityMap; static { sPostalTypePriorityMap = new HashMap<Integer, Integer>(); sPostalTypePriorityMap.put(StructuredPostal.TYPE_HOME, 0); sPostalTypePriorityMap.put(StructuredPostal.TYPE_WORK, 1); sPostalTypePriorityMap.put(StructuredPostal.TYPE_OTHER, 2); sPostalTypePriorityMap.put(StructuredPostal.TYPE_CUSTOM, 3); } /** * Tries to append just one line. If there's no appropriate address * information, append an empty line. */ private void appendPostalsForDoCoMo(final List<ContentValues> contentValuesList) { int currentPriority = Integer.MAX_VALUE; int currentType = Integer.MAX_VALUE; ContentValues currentContentValues = null; for (final ContentValues contentValues : contentValuesList) { if (contentValues == null) { continue; } final Integer typeAsInteger = contentValues.getAsInteger(StructuredPostal.TYPE); final Integer priorityAsInteger = sPostalTypePriorityMap.get(typeAsInteger); final int priority = (priorityAsInteger != null ? priorityAsInteger : Integer.MAX_VALUE); if (priority < currentPriority) { currentPriority = priority; currentType = typeAsInteger; currentContentValues = contentValues; if (priority == 0) { break; } } } if (currentContentValues == null) { Log.w(LOG_TAG, "Should not come here. Must have at least one postal data."); return; } final String label = currentContentValues.getAsString(StructuredPostal.LABEL); appendPostalLine(currentType, label, currentContentValues, false, true); } private void appendPostalsForGeneric(final List<ContentValues> contentValuesList) { for (final ContentValues contentValues : contentValuesList) { if (contentValues == null) { continue; } final Integer typeAsInteger = contentValues.getAsInteger(StructuredPostal.TYPE); final int type = (typeAsInteger != null ? typeAsInteger : DEFAULT_POSTAL_TYPE); final String label = contentValues.getAsString(StructuredPostal.LABEL); final Integer isPrimaryAsInteger = contentValues.getAsInteger(StructuredPostal.IS_PRIMARY); final boolean isPrimary = (isPrimaryAsInteger != null ? (isPrimaryAsInteger > 0) : false); appendPostalLine(type, label, contentValues, isPrimary, false); } } private static class PostalStruct { final boolean reallyUseQuotedPrintable; final boolean appendCharset; final String addressData; public PostalStruct(final boolean reallyUseQuotedPrintable, final boolean appendCharset, final String addressData) { this.reallyUseQuotedPrintable = reallyUseQuotedPrintable; this.appendCharset = appendCharset; this.addressData = addressData; } } /** * @return null when there's no information available to construct the data. */ private PostalStruct tryConstructPostalStruct(ContentValues contentValues) { // adr-value = 0*6(text-value ";") text-value // ; PO Box, Extended Address, Street, Locality, Region, Postal // ; Code, Country Name final String rawPoBox = contentValues.getAsString(StructuredPostal.POBOX); final String rawNeighborhood = contentValues.getAsString(StructuredPostal.NEIGHBORHOOD); final String rawStreet = contentValues.getAsString(StructuredPostal.STREET); final String rawLocality = contentValues.getAsString(StructuredPostal.CITY); final String rawRegion = contentValues.getAsString(StructuredPostal.REGION); final String rawPostalCode = contentValues.getAsString(StructuredPostal.POSTCODE); final String rawCountry = contentValues.getAsString(StructuredPostal.COUNTRY); final String[] rawAddressArray = new String[]{ rawPoBox, rawNeighborhood, rawStreet, rawLocality, rawRegion, rawPostalCode, rawCountry}; if (!VCardUtils.areAllEmpty(rawAddressArray)) { final boolean reallyUseQuotedPrintable = (mShouldUseQuotedPrintable && !VCardUtils.containsOnlyNonCrLfPrintableAscii(rawAddressArray)); final boolean appendCharset = !VCardUtils.containsOnlyPrintableAscii(rawAddressArray); final String encodedPoBox; final String encodedStreet; final String encodedLocality; final String encodedRegion; final String encodedPostalCode; final String encodedCountry; final String encodedNeighborhood; final String rawLocality2; // This looks inefficient since we encode rawLocality and rawNeighborhood twice, // but this is intentional. // // QP encoding may add line feeds when needed and the result of // - encodeQuotedPrintable(rawLocality + " " + rawNeighborhood) // may be different from // - encodedLocality + " " + encodedNeighborhood. // // We use safer way. if (TextUtils.isEmpty(rawLocality)) { if (TextUtils.isEmpty(rawNeighborhood)) { rawLocality2 = ""; } else { rawLocality2 = rawNeighborhood; } } else { if (TextUtils.isEmpty(rawNeighborhood)) { rawLocality2 = rawLocality; } else { rawLocality2 = rawLocality + " " + rawNeighborhood; } } if (reallyUseQuotedPrintable) { encodedPoBox = encodeQuotedPrintable(rawPoBox); encodedStreet = encodeQuotedPrintable(rawStreet); encodedLocality = encodeQuotedPrintable(rawLocality2); encodedRegion = encodeQuotedPrintable(rawRegion); encodedPostalCode = encodeQuotedPrintable(rawPostalCode); encodedCountry = encodeQuotedPrintable(rawCountry); } else { encodedPoBox = escapeCharacters(rawPoBox); encodedStreet = escapeCharacters(rawStreet); encodedLocality = escapeCharacters(rawLocality2); encodedRegion = escapeCharacters(rawRegion); encodedPostalCode = escapeCharacters(rawPostalCode); encodedCountry = escapeCharacters(rawCountry); encodedNeighborhood = escapeCharacters(rawNeighborhood); } final StringBuilder addressBuilder = new StringBuilder(); addressBuilder.append(encodedPoBox); addressBuilder.append(VCARD_ITEM_SEPARATOR); // PO BOX ; Extended Address addressBuilder.append(VCARD_ITEM_SEPARATOR); // Extended Address : Street addressBuilder.append(encodedStreet); addressBuilder.append(VCARD_ITEM_SEPARATOR); // Street : Locality addressBuilder.append(encodedLocality); addressBuilder.append(VCARD_ITEM_SEPARATOR); // Locality : Region addressBuilder.append(encodedRegion); addressBuilder.append(VCARD_ITEM_SEPARATOR); // Region : Postal Code addressBuilder.append(encodedPostalCode); addressBuilder.append(VCARD_ITEM_SEPARATOR); // Postal Code : Country addressBuilder.append(encodedCountry); return new PostalStruct( reallyUseQuotedPrintable, appendCharset, addressBuilder.toString()); } else { // VCardUtils.areAllEmpty(rawAddressArray) == true // Try to use FORMATTED_ADDRESS instead. final String rawFormattedAddress = contentValues.getAsString(StructuredPostal.FORMATTED_ADDRESS); if (TextUtils.isEmpty(rawFormattedAddress)) { return null; } final boolean reallyUseQuotedPrintable = (mShouldUseQuotedPrintable && !VCardUtils.containsOnlyNonCrLfPrintableAscii(rawFormattedAddress)); final boolean appendCharset = !VCardUtils.containsOnlyPrintableAscii(rawFormattedAddress); final String encodedFormattedAddress; if (reallyUseQuotedPrintable) { encodedFormattedAddress = encodeQuotedPrintable(rawFormattedAddress); } else { encodedFormattedAddress = escapeCharacters(rawFormattedAddress); } // We use the second value ("Extended Address") just because Japanese mobile phones // do so. If the other importer expects the value be in the other field, some flag may // be needed. final StringBuilder addressBuilder = new StringBuilder(); addressBuilder.append(VCARD_ITEM_SEPARATOR); // PO BOX ; Extended Address addressBuilder.append(encodedFormattedAddress); addressBuilder.append(VCARD_ITEM_SEPARATOR); // Extended Address : Street addressBuilder.append(VCARD_ITEM_SEPARATOR); // Street : Locality addressBuilder.append(VCARD_ITEM_SEPARATOR); // Locality : Region addressBuilder.append(VCARD_ITEM_SEPARATOR); // Region : Postal Code addressBuilder.append(VCARD_ITEM_SEPARATOR); // Postal Code : Country return new PostalStruct( reallyUseQuotedPrintable, appendCharset, addressBuilder.toString()); } } public VCardBuilder appendIms(final List<ContentValues> contentValuesList) { if (contentValuesList != null) { for (ContentValues contentValues : contentValuesList) { final Integer protocolAsObject = contentValues.getAsInteger(Im.PROTOCOL); if (protocolAsObject == null) { continue; } final String propertyName = VCardUtils.getPropertyNameForIm(protocolAsObject); if (propertyName == null) { continue; } String data = contentValues.getAsString(Im.DATA); if (data != null) { data = data.trim(); } if (TextUtils.isEmpty(data)) { continue; } final String typeAsString; { final Integer typeAsInteger = contentValues.getAsInteger(Im.TYPE); switch (typeAsInteger != null ? typeAsInteger : Im.TYPE_OTHER) { case Im.TYPE_HOME: { typeAsString = VCardConstants.PARAM_TYPE_HOME; break; } case Im.TYPE_WORK: { typeAsString = VCardConstants.PARAM_TYPE_WORK; break; } case Im.TYPE_CUSTOM: { final String label = contentValues.getAsString(Im.LABEL); typeAsString = (label != null ? "X-" + label : null); break; } case Im.TYPE_OTHER: // Ignore default: { typeAsString = null; break; } } } final List<String> parameterList = new ArrayList<String>(); if (!TextUtils.isEmpty(typeAsString)) { parameterList.add(typeAsString); } final Integer isPrimaryAsInteger = contentValues.getAsInteger(Im.IS_PRIMARY); final boolean isPrimary = (isPrimaryAsInteger != null ? (isPrimaryAsInteger > 0) : false); if (isPrimary) { parameterList.add(VCardConstants.PARAM_TYPE_PREF); } appendLineWithCharsetAndQPDetection(propertyName, parameterList, data); } } return this; } public VCardBuilder appendWebsites(final List<ContentValues> contentValuesList) { if (contentValuesList != null) { for (ContentValues contentValues : contentValuesList) { String website = contentValues.getAsString(Website.URL); if (website != null) { website = website.trim(); } // Note: vCard 3.0 does not allow any parameter addition toward "URL" // property, while there's no document in vCard 2.1. if (!TextUtils.isEmpty(website)) { appendLineWithCharsetAndQPDetection(VCardConstants.PROPERTY_URL, website); } } } return this; } public VCardBuilder appendOrganizations(final List<ContentValues> contentValuesList) { if (contentValuesList != null) { for (ContentValues contentValues : contentValuesList) { String company = contentValues.getAsString(Organization.COMPANY); if (company != null) { company = company.trim(); } String department = contentValues.getAsString(Organization.DEPARTMENT); if (department != null) { department = department.trim(); } String title = contentValues.getAsString(Organization.TITLE); if (title != null) { title = title.trim(); } StringBuilder orgBuilder = new StringBuilder(); if (!TextUtils.isEmpty(company)) { orgBuilder.append(company); } if (!TextUtils.isEmpty(department)) { if (orgBuilder.length() > 0) { orgBuilder.append(';'); } orgBuilder.append(department); } final String orgline = orgBuilder.toString(); appendLine(VCardConstants.PROPERTY_ORG, orgline, !VCardUtils.containsOnlyPrintableAscii(orgline), (mShouldUseQuotedPrintable && !VCardUtils.containsOnlyNonCrLfPrintableAscii(orgline))); if (!TextUtils.isEmpty(title)) { appendLine(VCardConstants.PROPERTY_TITLE, title, !VCardUtils.containsOnlyPrintableAscii(title), (mShouldUseQuotedPrintable && !VCardUtils.containsOnlyNonCrLfPrintableAscii(title))); } } } return this; } public VCardBuilder appendPhotos(final List<ContentValues> contentValuesList) { if (contentValuesList != null) { for (ContentValues contentValues : contentValuesList) { if (contentValues == null) { continue; } byte[] data = contentValues.getAsByteArray(Photo.PHOTO); if (data == null) { continue; } final String photoType = VCardUtils.guessImageType(data); if (photoType == null) { Log.d(LOG_TAG, "Unknown photo type. Ignored."); continue; } // TODO: check this works fine. final String photoString = new String(Base64.encode(data, Base64.NO_WRAP)); if (!TextUtils.isEmpty(photoString)) { appendPhotoLine(photoString, photoType); } } } return this; } public VCardBuilder appendNotes(final List<ContentValues> contentValuesList) { if (contentValuesList != null) { if (mOnlyOneNoteFieldIsAvailable) { final StringBuilder noteBuilder = new StringBuilder(); boolean first = true; for (final ContentValues contentValues : contentValuesList) { String note = contentValues.getAsString(Note.NOTE); if (note == null) { note = ""; } if (note.length() > 0) { if (first) { first = false; } else { noteBuilder.append('\n'); } noteBuilder.append(note); } } final String noteStr = noteBuilder.toString(); // This means we scan noteStr completely twice, which is redundant. // But for now, we assume this is not so time-consuming.. final boolean shouldAppendCharsetInfo = !VCardUtils.containsOnlyPrintableAscii(noteStr); final boolean reallyUseQuotedPrintable = (mShouldUseQuotedPrintable && !VCardUtils.containsOnlyNonCrLfPrintableAscii(noteStr)); appendLine(VCardConstants.PROPERTY_NOTE, noteStr, shouldAppendCharsetInfo, reallyUseQuotedPrintable); } else { for (ContentValues contentValues : contentValuesList) { final String noteStr = contentValues.getAsString(Note.NOTE); if (!TextUtils.isEmpty(noteStr)) { final boolean shouldAppendCharsetInfo = !VCardUtils.containsOnlyPrintableAscii(noteStr); final boolean reallyUseQuotedPrintable = (mShouldUseQuotedPrintable && !VCardUtils.containsOnlyNonCrLfPrintableAscii(noteStr)); appendLine(VCardConstants.PROPERTY_NOTE, noteStr, shouldAppendCharsetInfo, reallyUseQuotedPrintable); } } } } return this; } public VCardBuilder appendEvents(final List<ContentValues> contentValuesList) { // There's possibility where a given object may have more than one birthday, which // is inappropriate. We just build one birthday. if (contentValuesList != null) { String primaryBirthday = null; String secondaryBirthday = null; for (final ContentValues contentValues : contentValuesList) { if (contentValues == null) { continue; } final Integer eventTypeAsInteger = contentValues.getAsInteger(Event.TYPE); final int eventType; if (eventTypeAsInteger != null) { eventType = eventTypeAsInteger; } else { eventType = Event.TYPE_OTHER; } if (eventType == Event.TYPE_BIRTHDAY) { final String birthdayCandidate = contentValues.getAsString(Event.START_DATE); if (birthdayCandidate == null) { continue; } final Integer isSuperPrimaryAsInteger = contentValues.getAsInteger(Event.IS_SUPER_PRIMARY); final boolean isSuperPrimary = (isSuperPrimaryAsInteger != null ? (isSuperPrimaryAsInteger > 0) : false); if (isSuperPrimary) { // "super primary" birthday should the prefered one. primaryBirthday = birthdayCandidate; break; } final Integer isPrimaryAsInteger = contentValues.getAsInteger(Event.IS_PRIMARY); final boolean isPrimary = (isPrimaryAsInteger != null ? (isPrimaryAsInteger > 0) : false); if (isPrimary) { // We don't break here since "super primary" birthday may exist later. primaryBirthday = birthdayCandidate; } else if (secondaryBirthday == null) { // First entry is set to the "secondary" candidate. secondaryBirthday = birthdayCandidate; } } else if (mUsesAndroidProperty) { // Event types other than Birthday is not supported by vCard. appendAndroidSpecificProperty(Event.CONTENT_ITEM_TYPE, contentValues); } } if (primaryBirthday != null) { appendLineWithCharsetAndQPDetection(VCardConstants.PROPERTY_BDAY, primaryBirthday.trim()); } else if (secondaryBirthday != null){ appendLineWithCharsetAndQPDetection(VCardConstants.PROPERTY_BDAY, secondaryBirthday.trim()); } } return this; } public VCardBuilder appendRelation(final List<ContentValues> contentValuesList) { if (mUsesAndroidProperty && contentValuesList != null) { for (final ContentValues contentValues : contentValuesList) { if (contentValues == null) { continue; } appendAndroidSpecificProperty(Relation.CONTENT_ITEM_TYPE, contentValues); } } return this; } /** * @param emitEveryTime If true, builder builds the line even when there's no entry. */ public void appendPostalLine(final int type, final String label, final ContentValues contentValues, final boolean isPrimary, final boolean emitEveryTime) { final boolean reallyUseQuotedPrintable; final boolean appendCharset; final String addressValue; { PostalStruct postalStruct = tryConstructPostalStruct(contentValues); if (postalStruct == null) { if (emitEveryTime) { reallyUseQuotedPrintable = false; appendCharset = false; addressValue = ""; } else { return; } } else { reallyUseQuotedPrintable = postalStruct.reallyUseQuotedPrintable; appendCharset = postalStruct.appendCharset; addressValue = postalStruct.addressData; } } List<String> parameterList = new ArrayList<String>(); if (isPrimary) { parameterList.add(VCardConstants.PARAM_TYPE_PREF); } switch (type) { case StructuredPostal.TYPE_HOME: { parameterList.add(VCardConstants.PARAM_TYPE_HOME); break; } case StructuredPostal.TYPE_WORK: { parameterList.add(VCardConstants.PARAM_TYPE_WORK); break; } case StructuredPostal.TYPE_CUSTOM: { if (!TextUtils.isEmpty(label) && VCardUtils.containsOnlyAlphaDigitHyphen(label)) { // We're not sure whether the label is valid in the spec // ("IANA-token" in the vCard 3.0 is unclear...) // Just for safety, we add "X-" at the beggining of each label. // Also checks the label obeys with vCard 3.0 spec. parameterList.add("X-" + label); } break; } case StructuredPostal.TYPE_OTHER: { break; } default: { Log.e(LOG_TAG, "Unknown StructuredPostal type: " + type); break; } } mBuilder.append(VCardConstants.PROPERTY_ADR); if (!parameterList.isEmpty()) { mBuilder.append(VCARD_PARAM_SEPARATOR); appendTypeParameters(parameterList); } if (appendCharset) { // Strictly, vCard 3.0 does not allow exporters to emit charset information, // but we will add it since the information should be useful for importers, // // Assume no parser does not emit error with this parameter in vCard 3.0. mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(mVCardCharsetParameter); } if (reallyUseQuotedPrintable) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(VCARD_PARAM_ENCODING_QP); } mBuilder.append(VCARD_DATA_SEPARATOR); mBuilder.append(addressValue); mBuilder.append(VCARD_END_OF_LINE); } public void appendEmailLine(final int type, final String label, final String rawValue, final boolean isPrimary) { final String typeAsString; switch (type) { case Email.TYPE_CUSTOM: { if (VCardUtils.isMobilePhoneLabel(label)) { typeAsString = VCardConstants.PARAM_TYPE_CELL; } else if (!TextUtils.isEmpty(label) && VCardUtils.containsOnlyAlphaDigitHyphen(label)) { typeAsString = "X-" + label; } else { typeAsString = null; } break; } case Email.TYPE_HOME: { typeAsString = VCardConstants.PARAM_TYPE_HOME; break; } case Email.TYPE_WORK: { typeAsString = VCardConstants.PARAM_TYPE_WORK; break; } case Email.TYPE_OTHER: { typeAsString = null; break; } case Email.TYPE_MOBILE: { typeAsString = VCardConstants.PARAM_TYPE_CELL; break; } default: { Log.e(LOG_TAG, "Unknown Email type: " + type); typeAsString = null; break; } } final List<String> parameterList = new ArrayList<String>(); if (isPrimary) { parameterList.add(VCardConstants.PARAM_TYPE_PREF); } if (!TextUtils.isEmpty(typeAsString)) { parameterList.add(typeAsString); } appendLineWithCharsetAndQPDetection(VCardConstants.PROPERTY_EMAIL, parameterList, rawValue); } public void appendTelLine(final Integer typeAsInteger, final String label, final String encodedValue, boolean isPrimary) { mBuilder.append(VCardConstants.PROPERTY_TEL); mBuilder.append(VCARD_PARAM_SEPARATOR); final int type; if (typeAsInteger == null) { type = Phone.TYPE_OTHER; } else { type = typeAsInteger; } ArrayList<String> parameterList = new ArrayList<String>(); switch (type) { case Phone.TYPE_HOME: { parameterList.addAll( Arrays.asList(VCardConstants.PARAM_TYPE_HOME)); break; } case Phone.TYPE_WORK: { parameterList.addAll( Arrays.asList(VCardConstants.PARAM_TYPE_WORK)); break; } case Phone.TYPE_FAX_HOME: { parameterList.addAll( Arrays.asList(VCardConstants.PARAM_TYPE_HOME, VCardConstants.PARAM_TYPE_FAX)); break; } case Phone.TYPE_FAX_WORK: { parameterList.addAll( Arrays.asList(VCardConstants.PARAM_TYPE_WORK, VCardConstants.PARAM_TYPE_FAX)); break; } case Phone.TYPE_MOBILE: { parameterList.add(VCardConstants.PARAM_TYPE_CELL); break; } case Phone.TYPE_PAGER: { if (mIsDoCoMo) { // Not sure about the reason, but previous implementation had // used "VOICE" instead of "PAGER" parameterList.add(VCardConstants.PARAM_TYPE_VOICE); } else { parameterList.add(VCardConstants.PARAM_TYPE_PAGER); } break; } case Phone.TYPE_OTHER: { parameterList.add(VCardConstants.PARAM_TYPE_VOICE); break; } case Phone.TYPE_CAR: { parameterList.add(VCardConstants.PARAM_TYPE_CAR); break; } case Phone.TYPE_COMPANY_MAIN: { // There's no relevant field in vCard (at least 2.1). parameterList.add(VCardConstants.PARAM_TYPE_WORK); isPrimary = true; break; } case Phone.TYPE_ISDN: { parameterList.add(VCardConstants.PARAM_TYPE_ISDN); break; } case Phone.TYPE_MAIN: { isPrimary = true; break; } case Phone.TYPE_OTHER_FAX: { parameterList.add(VCardConstants.PARAM_TYPE_FAX); break; } case Phone.TYPE_TELEX: { parameterList.add(VCardConstants.PARAM_TYPE_TLX); break; } case Phone.TYPE_WORK_MOBILE: { parameterList.addAll( Arrays.asList(VCardConstants.PARAM_TYPE_WORK, VCardConstants.PARAM_TYPE_CELL)); break; } case Phone.TYPE_WORK_PAGER: { parameterList.add(VCardConstants.PARAM_TYPE_WORK); // See above. if (mIsDoCoMo) { parameterList.add(VCardConstants.PARAM_TYPE_VOICE); } else { parameterList.add(VCardConstants.PARAM_TYPE_PAGER); } break; } case Phone.TYPE_MMS: { parameterList.add(VCardConstants.PARAM_TYPE_MSG); break; } case Phone.TYPE_CUSTOM: { if (TextUtils.isEmpty(label)) { // Just ignore the custom type. parameterList.add(VCardConstants.PARAM_TYPE_VOICE); } else if (VCardUtils.isMobilePhoneLabel(label)) { parameterList.add(VCardConstants.PARAM_TYPE_CELL); } else if (mIsV30OrV40) { // This label is appropriately encoded in appendTypeParameters. parameterList.add(label); } else { final String upperLabel = label.toUpperCase(); if (VCardUtils.isValidInV21ButUnknownToContactsPhoteType(upperLabel)) { parameterList.add(upperLabel); } else if (VCardUtils.containsOnlyAlphaDigitHyphen(label)) { // Note: Strictly, vCard 2.1 does not allow "X-" parameter without // "TYPE=" string. parameterList.add("X-" + label); } } break; } case Phone.TYPE_RADIO: case Phone.TYPE_TTY_TDD: default: { break; } } if (isPrimary) { parameterList.add(VCardConstants.PARAM_TYPE_PREF); } if (parameterList.isEmpty()) { appendUncommonPhoneType(mBuilder, type); } else { appendTypeParameters(parameterList); } mBuilder.append(VCARD_DATA_SEPARATOR); mBuilder.append(encodedValue); mBuilder.append(VCARD_END_OF_LINE); } /** * Appends phone type string which may not be available in some devices. */ private void appendUncommonPhoneType(final StringBuilder builder, final Integer type) { if (mIsDoCoMo) { // The previous implementation for DoCoMo had been conservative // about miscellaneous types. builder.append(VCardConstants.PARAM_TYPE_VOICE); } else { String phoneType = VCardUtils.getPhoneTypeString(type); if (phoneType != null) { appendTypeParameter(phoneType); } else { Log.e(LOG_TAG, "Unknown or unsupported (by vCard) Phone type: " + type); } } } /** * @param encodedValue Must be encoded by BASE64 * @param photoType */ public void appendPhotoLine(final String encodedValue, final String photoType) { StringBuilder tmpBuilder = new StringBuilder(); tmpBuilder.append(VCardConstants.PROPERTY_PHOTO); tmpBuilder.append(VCARD_PARAM_SEPARATOR); if (mIsV30OrV40) { tmpBuilder.append(VCARD_PARAM_ENCODING_BASE64_AS_B); } else { tmpBuilder.append(VCARD_PARAM_ENCODING_BASE64_V21); } tmpBuilder.append(VCARD_PARAM_SEPARATOR); appendTypeParameter(tmpBuilder, photoType); tmpBuilder.append(VCARD_DATA_SEPARATOR); tmpBuilder.append(encodedValue); final String tmpStr = tmpBuilder.toString(); tmpBuilder = new StringBuilder(); int lineCount = 0; final int length = tmpStr.length(); final int maxNumForFirstLine = VCardConstants.MAX_CHARACTER_NUMS_BASE64_V30 - VCARD_END_OF_LINE.length(); final int maxNumInGeneral = maxNumForFirstLine - VCARD_WS.length(); int maxNum = maxNumForFirstLine; for (int i = 0; i < length; i++) { tmpBuilder.append(tmpStr.charAt(i)); lineCount++; if (lineCount > maxNum) { tmpBuilder.append(VCARD_END_OF_LINE); tmpBuilder.append(VCARD_WS); maxNum = maxNumInGeneral; lineCount = 0; } } mBuilder.append(tmpBuilder.toString()); mBuilder.append(VCARD_END_OF_LINE); mBuilder.append(VCARD_END_OF_LINE); } /** * SIP (Session Initiation Protocol) is first supported in RFC 4770 as part of IMPP * support. vCard 2.1 and old vCard 3.0 may not able to parse it, or expect X-SIP * instead of "IMPP;sip:...". * * We honor RFC 4770 and don't allow vCard 3.0 to emit X-SIP at all. */ public VCardBuilder appendSipAddresses(final List<ContentValues> contentValuesList) { final boolean useXProperty; if (mIsV30OrV40) { useXProperty = false; } else if (mUsesDefactProperty){ useXProperty = true; } else { return this; } if (contentValuesList != null) { for (ContentValues contentValues : contentValuesList) { String sipAddress = contentValues.getAsString(SipAddress.SIP_ADDRESS); if (TextUtils.isEmpty(sipAddress)) { continue; } if (useXProperty) { // X-SIP does not contain "sip:" prefix. if (sipAddress.startsWith("sip:")) { if (sipAddress.length() == 4) { continue; } sipAddress = sipAddress.substring(4); } // No type is available yet. appendLineWithCharsetAndQPDetection(VCardConstants.PROPERTY_X_SIP, sipAddress); } else { if (!sipAddress.startsWith("sip:")) { sipAddress = "sip:" + sipAddress; } final String propertyName; if (VCardConfig.isVersion40(mVCardType)) { // We have two ways to emit sip address: TEL and IMPP. Currently (rev.13) // TEL seems appropriate but may change in the future. propertyName = VCardConstants.PROPERTY_TEL; } else { // RFC 4770 (for vCard 3.0) propertyName = VCardConstants.PROPERTY_IMPP; } appendLineWithCharsetAndQPDetection(propertyName, sipAddress); } } } return this; } public void appendAndroidSpecificProperty( final String mimeType, ContentValues contentValues) { if (!sAllowedAndroidPropertySet.contains(mimeType)) { return; } final List<String> rawValueList = new ArrayList<String>(); for (int i = 1; i <= VCardConstants.MAX_DATA_COLUMN; i++) { String value = contentValues.getAsString("data" + i); if (value == null) { value = ""; } rawValueList.add(value); } boolean needCharset = (mShouldAppendCharsetParam && !VCardUtils.containsOnlyNonCrLfPrintableAscii(rawValueList)); boolean reallyUseQuotedPrintable = (mShouldUseQuotedPrintable && !VCardUtils.containsOnlyNonCrLfPrintableAscii(rawValueList)); mBuilder.append(VCardConstants.PROPERTY_X_ANDROID_CUSTOM); if (needCharset) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(mVCardCharsetParameter); } if (reallyUseQuotedPrintable) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(VCARD_PARAM_ENCODING_QP); } mBuilder.append(VCARD_DATA_SEPARATOR); mBuilder.append(mimeType); // Should not be encoded. for (String rawValue : rawValueList) { final String encodedValue; if (reallyUseQuotedPrintable) { encodedValue = encodeQuotedPrintable(rawValue); } else { // TODO: one line may be too huge, which may be invalid in vCard 3.0 // (which says "When generating a content line, lines longer than // 75 characters SHOULD be folded"), though several // (even well-known) applications do not care this. encodedValue = escapeCharacters(rawValue); } mBuilder.append(VCARD_ITEM_SEPARATOR); mBuilder.append(encodedValue); } mBuilder.append(VCARD_END_OF_LINE); } public void appendLineWithCharsetAndQPDetection(final String propertyName, final String rawValue) { appendLineWithCharsetAndQPDetection(propertyName, null, rawValue); } public void appendLineWithCharsetAndQPDetection( final String propertyName, final List<String> rawValueList) { appendLineWithCharsetAndQPDetection(propertyName, null, rawValueList); } public void appendLineWithCharsetAndQPDetection(final String propertyName, final List<String> parameterList, final String rawValue) { final boolean needCharset = !VCardUtils.containsOnlyPrintableAscii(rawValue); final boolean reallyUseQuotedPrintable = (mShouldUseQuotedPrintable && !VCardUtils.containsOnlyNonCrLfPrintableAscii(rawValue)); appendLine(propertyName, parameterList, rawValue, needCharset, reallyUseQuotedPrintable); } public void appendLineWithCharsetAndQPDetection(final String propertyName, final List<String> parameterList, final List<String> rawValueList) { boolean needCharset = (mShouldAppendCharsetParam && !VCardUtils.containsOnlyNonCrLfPrintableAscii(rawValueList)); boolean reallyUseQuotedPrintable = (mShouldUseQuotedPrintable && !VCardUtils.containsOnlyNonCrLfPrintableAscii(rawValueList)); appendLine(propertyName, parameterList, rawValueList, needCharset, reallyUseQuotedPrintable); } /** * Appends one line with a given property name and value. */ public void appendLine(final String propertyName, final String rawValue) { appendLine(propertyName, rawValue, false, false); } public void appendLine(final String propertyName, final List<String> rawValueList) { appendLine(propertyName, rawValueList, false, false); } public void appendLine(final String propertyName, final String rawValue, final boolean needCharset, boolean reallyUseQuotedPrintable) { appendLine(propertyName, null, rawValue, needCharset, reallyUseQuotedPrintable); } public void appendLine(final String propertyName, final List<String> parameterList, final String rawValue) { appendLine(propertyName, parameterList, rawValue, false, false); } public void appendLine(final String propertyName, final List<String> parameterList, final String rawValue, final boolean needCharset, boolean reallyUseQuotedPrintable) { mBuilder.append(propertyName); if (parameterList != null && parameterList.size() > 0) { mBuilder.append(VCARD_PARAM_SEPARATOR); appendTypeParameters(parameterList); } if (needCharset) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(mVCardCharsetParameter); } final String encodedValue; if (reallyUseQuotedPrintable) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(VCARD_PARAM_ENCODING_QP); encodedValue = encodeQuotedPrintable(rawValue); } else { // TODO: one line may be too huge, which may be invalid in vCard spec, though // several (even well-known) applications do not care that violation. encodedValue = escapeCharacters(rawValue); } mBuilder.append(VCARD_DATA_SEPARATOR); mBuilder.append(encodedValue); mBuilder.append(VCARD_END_OF_LINE); } public void appendLine(final String propertyName, final List<String> rawValueList, final boolean needCharset, boolean needQuotedPrintable) { appendLine(propertyName, null, rawValueList, needCharset, needQuotedPrintable); } public void appendLine(final String propertyName, final List<String> parameterList, final List<String> rawValueList, final boolean needCharset, final boolean needQuotedPrintable) { mBuilder.append(propertyName); if (parameterList != null && parameterList.size() > 0) { mBuilder.append(VCARD_PARAM_SEPARATOR); appendTypeParameters(parameterList); } if (needCharset) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(mVCardCharsetParameter); } if (needQuotedPrintable) { mBuilder.append(VCARD_PARAM_SEPARATOR); mBuilder.append(VCARD_PARAM_ENCODING_QP); } mBuilder.append(VCARD_DATA_SEPARATOR); boolean first = true; for (String rawValue : rawValueList) { final String encodedValue; if (needQuotedPrintable) { encodedValue = encodeQuotedPrintable(rawValue); } else { // TODO: one line may be too huge, which may be invalid in vCard 3.0 // (which says "When generating a content line, lines longer than // 75 characters SHOULD be folded"), though several // (even well-known) applications do not care this. encodedValue = escapeCharacters(rawValue); } if (first) { first = false; } else { mBuilder.append(VCARD_ITEM_SEPARATOR); } mBuilder.append(encodedValue); } mBuilder.append(VCARD_END_OF_LINE); } /** * VCARD_PARAM_SEPARATOR must be appended before this method being called. */ private void appendTypeParameters(final List<String> types) { // We may have to make this comma separated form like "TYPE=DOM,WORK" in the future, // which would be recommended way in vcard 3.0 though not valid in vCard 2.1. boolean first = true; for (final String typeValue : types) { if (VCardConfig.isVersion30(mVCardType) || VCardConfig.isVersion40(mVCardType)) { final String encoded = (VCardConfig.isVersion40(mVCardType) ? VCardUtils.toStringAsV40ParamValue(typeValue) : VCardUtils.toStringAsV30ParamValue(typeValue)); if (TextUtils.isEmpty(encoded)) { continue; } if (first) { first = false; } else { mBuilder.append(VCARD_PARAM_SEPARATOR); } appendTypeParameter(encoded); } else { // vCard 2.1 if (!VCardUtils.isV21Word(typeValue)) { continue; } if (first) { first = false; } else { mBuilder.append(VCARD_PARAM_SEPARATOR); } appendTypeParameter(typeValue); } } } /** * VCARD_PARAM_SEPARATOR must be appended before this method being called. */ private void appendTypeParameter(final String type) { appendTypeParameter(mBuilder, type); } private void appendTypeParameter(final StringBuilder builder, final String type) { // Refrain from using appendType() so that "TYPE=" is not be appended when the // device is DoCoMo's (just for safety). // // Note: In vCard 3.0, Type strings also can be like this: "TYPE=HOME,PREF" if (VCardConfig.isVersion40(mVCardType) || ((VCardConfig.isVersion30(mVCardType) || mAppendTypeParamName) && !mIsDoCoMo)) { builder.append(VCardConstants.PARAM_TYPE).append(VCARD_PARAM_EQUAL); } builder.append(type); } /** * Returns true when the property line should contain charset parameter * information. This method may return true even when vCard version is 3.0. * * Strictly, adding charset information is invalid in VCard 3.0. * However we'll add the info only when charset we use is not UTF-8 * in vCard 3.0 format, since parser side may be able to use the charset * via this field, though we may encounter another problem by adding it. * * e.g. Japanese mobile phones use Shift_Jis while RFC 2426 * recommends UTF-8. By adding this field, parsers may be able * to know this text is NOT UTF-8 but Shift_Jis. */ private boolean shouldAppendCharsetParam(String...propertyValueList) { if (!mShouldAppendCharsetParam) { return false; } for (String propertyValue : propertyValueList) { if (!VCardUtils.containsOnlyPrintableAscii(propertyValue)) { return true; } } return false; } private String encodeQuotedPrintable(final String str) { if (TextUtils.isEmpty(str)) { return ""; } final StringBuilder builder = new StringBuilder(); int index = 0; int lineCount = 0; byte[] strArray = null; try { strArray = str.getBytes(mCharset); } catch (UnsupportedEncodingException e) { Log.e(LOG_TAG, "Charset " + mCharset + " cannot be used. " + "Try default charset"); strArray = str.getBytes(); } while (index < strArray.length) { builder.append(String.format("=%02X", strArray[index])); index += 1; lineCount += 3; if (lineCount >= 67) { // Specification requires CRLF must be inserted before the // length of the line // becomes more than 76. // Assuming that the next character is a multi-byte character, // it will become // 6 bytes. // 76 - 6 - 3 = 67 builder.append("=\r\n"); lineCount = 0; } } return builder.toString(); } /** * Append '\' to the characters which should be escaped. The character set is different * not only between vCard 2.1 and vCard 3.0 but also among each device. * * Note that Quoted-Printable string must not be input here. */ @SuppressWarnings("fallthrough") private String escapeCharacters(final String unescaped) { if (TextUtils.isEmpty(unescaped)) { return ""; } final StringBuilder tmpBuilder = new StringBuilder(); final int length = unescaped.length(); for (int i = 0; i < length; i++) { final char ch = unescaped.charAt(i); switch (ch) { case ';': { tmpBuilder.append('\\'); tmpBuilder.append(';'); break; } case '\r': { if (i + 1 < length) { char nextChar = unescaped.charAt(i); if (nextChar == '\n') { break; } else { // fall through } } else { // fall through } } case '\n': { // In vCard 2.1, there's no specification about this, while // vCard 3.0 explicitly requires this should be encoded to "\n". tmpBuilder.append("\\n"); break; } case '\\': { if (mIsV30OrV40) { tmpBuilder.append("\\\\"); break; } else { // fall through } } case '<': case '>': { if (mIsDoCoMo) { tmpBuilder.append('\\'); tmpBuilder.append(ch); } else { tmpBuilder.append(ch); } break; } case ',': { if (mIsV30OrV40) { tmpBuilder.append("\\,"); } else { tmpBuilder.append(ch); } break; } default: { tmpBuilder.append(ch); break; } } } return tmpBuilder.toString(); } @Override public String toString() { if (!mEndAppended) { if (mIsDoCoMo) { appendLine(VCardConstants.PROPERTY_X_CLASS, VCARD_DATA_PUBLIC); appendLine(VCardConstants.PROPERTY_X_REDUCTION, ""); appendLine(VCardConstants.PROPERTY_X_NO, ""); appendLine(VCardConstants.PROPERTY_X_DCM_HMN_MODE, ""); } appendLine(VCardConstants.PROPERTY_END, VCARD_DATA_VCARD); mEndAppended = true; } return mBuilder.toString(); } }