| /* |
| * 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(); |
| } |
| } |
