The Tor Browser: mobile/android/base/ContactService.java@b8a032363ba2 (annotated)

mobile/android/base/ContactService.java@b8a032363ba2 (annotated)

mobile/android/base/ContactService.java

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 package org.mozilla.gecko;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map.Entry;
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 import org.mozilla.gecko.util.GeckoEventListener;
 import org.mozilla.gecko.util.ThreadUtils;
 import android.accounts.Account;
 import android.accounts.AccountManager;
 import android.app.AlertDialog;
 import android.content.ContentProviderOperation;
 import android.content.ContentProviderResult;
 import android.content.ContentResolver;
 import android.content.ContentUris;
 import android.content.ContentValues;
 import android.content.DialogInterface;
 import android.content.OperationApplicationException;
 import android.database.Cursor;
 import android.net.Uri;
 import android.os.Build;
 import android.os.RemoteException;
 import android.provider.ContactsContract;
 import android.provider.ContactsContract.CommonDataKinds.BaseTypes;
 import android.provider.ContactsContract.CommonDataKinds.Email;
 import android.provider.ContactsContract.CommonDataKinds.Event;
 import android.provider.ContactsContract.CommonDataKinds.GroupMembership;
 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.StructuredName;
 import android.provider.ContactsContract.CommonDataKinds.StructuredPostal;
 import android.provider.ContactsContract.CommonDataKinds.Website;
 import android.provider.ContactsContract.Data;
 import android.provider.ContactsContract.Groups;
 import android.provider.ContactsContract.RawContacts;
 import android.provider.ContactsContract.RawContacts.Entity;
 import android.telephony.PhoneNumberUtils;
 import android.util.Log;
 public class ContactService implements GeckoEventListener {
     private static final String LOGTAG = "GeckoContactService";
     private static final boolean DEBUG = false;
     private final static int GROUP_ACCOUNT_NAME = 0;
     private final static int GROUP_ACCOUNT_TYPE = 1;
     private final static int GROUP_ID = 2;
     private final static int GROUP_TITLE = 3;
     private final static int GROUP_AUTO_ADD = 4;
     private final static String CARRIER_COLUMN = Data.DATA5;
     private final static String CUSTOM_DATA_COLUMN = Data.DATA1;
     // Pre-Honeycomb versions of Android have a "My Contacts" system group that all contacts are
     // assigned to by default for a given account. After Honeycomb, an AUTO_ADD database column
     // was added to denote groups that contacts are automatically added to
     private final static String PRE_HONEYCOMB_DEFAULT_GROUP = "System Group: My Contacts";
     private final static String MIMETYPE_ADDITIONAL_NAME = "org.mozilla.gecko/additional_name";
     private final static String MIMETYPE_SEX = "org.mozilla.gecko/sex";
     private final static String MIMETYPE_GENDER_IDENTITY = "org.mozilla.gecko/gender_identity";
     private final static String MIMETYPE_KEY = "org.mozilla.gecko/key";
     private final static String MIMETYPE_MOZILLA_CONTACTS_FLAG = "org.mozilla.gecko/contact_flag";
     private final EventDispatcher mEventDispatcher;
     private String mAccountName;
     private String mAccountType;
     private String mGroupTitle;
     private long mGroupId;
     private boolean mGotDeviceAccount;
     private HashMap<String, String> mColumnNameConstantsMap;
     private HashMap<String, String> mMimeTypeConstantsMap;
     private HashMap<String, Integer> mAddressTypesMap;
     private HashMap<String, Integer> mPhoneTypesMap;
     private HashMap<String, Integer> mEmailTypesMap;
     private HashMap<String, Integer> mWebsiteTypesMap;
     private HashMap<String, Integer> mImTypesMap;
     private ContentResolver mContentResolver;
     private GeckoApp mActivity;
     ContactService(EventDispatcher eventDispatcher, GeckoApp activity) {
         mEventDispatcher = eventDispatcher;
         mActivity = activity;
         mContentResolver = mActivity.getContentResolver();
         mGotDeviceAccount = false;
         registerEventListener("Android:Contacts:Clear");
         registerEventListener("Android:Contacts:Find");
         registerEventListener("Android:Contacts:GetAll");
         registerEventListener("Android:Contacts:GetCount");
         registerEventListener("Android:Contact:Remove");
         registerEventListener("Android:Contact:Save");
     }
     public void destroy() {
         unregisterEventListener("Android:Contacts:Clear");
         unregisterEventListener("Android:Contacts:Find");
         unregisterEventListener("Android:Contacts:GetAll");
         unregisterEventListener("Android:Contacts:GetCount");
         unregisterEventListener("Android:Contact:Remove");
         unregisterEventListener("Android:Contact:Save");
     }
     @Override
     public void handleMessage(final String event, final JSONObject message) {
         // If the account chooser dialog needs shown to the user, the message handling becomes
         // asychronous so it needs posted to a background thread from the UI thread when the
         // account chooser dialog is dismissed by the user.
         Runnable handleMessage = new Runnable() {
             @Override
             public void run() {
                 try {
                     if (DEBUG) {
                         Log.d(LOGTAG, "Event: " + event + "\nMessage: " + message.toString(3));
                     }
                     final JSONObject messageData = message.getJSONObject("data");
                     final String requestID = messageData.getString("requestID");
                     // Options may not exist for all operations
                     JSONObject contactOptions = messageData.optJSONObject("options");
                     if ("Android:Contacts:Find".equals(event)) {
                         findContacts(contactOptions, requestID);
                     } else if ("Android:Contacts:GetAll".equals(event)) {
                         getAllContacts(messageData, requestID);
                     } else if ("Android:Contacts:Clear".equals(event)) {
                         clearAllContacts(contactOptions, requestID);
                     } else if ("Android:Contact:Save".equals(event)) {
                         saveContact(contactOptions, requestID);
                     } else if ("Android:Contact:Remove".equals(event)) {
                         removeContact(contactOptions, requestID);
                     } else if ("Android:Contacts:GetCount".equals(event)) {
                         getContactsCount(requestID);
                     } else {
                         throw new IllegalArgumentException("Unexpected event: " + event);
                     }
                 } catch (JSONException e) {
                     throw new IllegalArgumentException("Message: " + e);
                 }
             }
         };
         // Get the account name/type if they haven't been set yet
         if (!mGotDeviceAccount) {
             getDeviceAccount(handleMessage);
         } else {
             handleMessage.run();
         }
     }
     private void findContacts(final JSONObject contactOptions, final String requestID) {
         long[] rawContactIds = findContactsRawIds(contactOptions);
         Log.i(LOGTAG, "Got " + (rawContactIds != null ? rawContactIds.length : "null") + " raw contact IDs");
         final String[] sortOptions = getSortOptionsFromJSON(contactOptions);
         if (rawContactIds == null || sortOptions == null) {
             sendCallbackToJavascript("Android:Contacts:Find:Return:KO", requestID, null, null);
         } else {
             sendCallbackToJavascript("Android:Contacts:Find:Return:OK", requestID,
                                      new String[] {"contacts"},
                                      new Object[] {getContactsAsJSONArray(rawContactIds, sortOptions[0],
                                                                           sortOptions[1])});
         }
     }
     private void getAllContacts(final JSONObject contactOptions, final String requestID) {
         long[] rawContactIds = getAllRawContactIds();
         Log.i(LOGTAG, "Got " + rawContactIds.length + " raw contact IDs");
         final String[] sortOptions = getSortOptionsFromJSON(contactOptions);
         if (rawContactIds == null || sortOptions == null) {
             // There's no failure message for getAll
             return;
         } else {
             sendCallbackToJavascript("Android:Contacts:GetAll:Next", requestID,
                                      new String[] {"contacts"},
                                      new Object[] {getContactsAsJSONArray(rawContactIds, sortOptions[0],
                                                                           sortOptions[1])});
         }
     }
     private static String[] getSortOptionsFromJSON(final JSONObject contactOptions) {
         String sortBy = null;
         String sortOrder = null;
         try {
             final JSONObject findOptions = contactOptions.getJSONObject("findOptions");
             sortBy = findOptions.optString("sortBy").toLowerCase();
             sortOrder = findOptions.optString("sortOrder").toLowerCase();
             if ("".equals(sortBy)) {
                 sortBy = null;
             }
             if ("".equals(sortOrder)) {
                 sortOrder = "ascending";
             }
             // Only "familyname" and "givenname" are valid sortBy values and only "ascending"
             // and "descending" are valid sortOrder values
             if ((sortBy != null && !"familyname".equals(sortBy) && !"givenname".equals(sortBy)) ||
                 (!"ascending".equals(sortOrder) && !"descending".equals(sortOrder))) {
                 return null;
             }
         } catch (JSONException e) {
             throw new IllegalArgumentException(e);
         }
         return new String[] {sortBy, sortOrder};
     }
     private long[] findContactsRawIds(final JSONObject contactOptions) {
         List<Long> rawContactIds = new ArrayList<Long>();
         Cursor cursor = null;
         try {
             final JSONObject findOptions = contactOptions.getJSONObject("findOptions");
             String filterValue = findOptions.optString("filterValue");
             JSONArray filterBy = findOptions.optJSONArray("filterBy");
             final String filterOp = findOptions.optString("filterOp");
             final int filterLimit = findOptions.getInt("filterLimit");
             final int substringMatching = findOptions.getInt("substringMatching");
             // If filter value is undefined, avoid all the logic below and just return
             // all available raw contact IDs
             if ("".equals(filterValue) || "".equals(filterOp)) {
                 long[] allRawContactIds = getAllRawContactIds();
                 // Truncate the raw contacts IDs array if necessary
                 if (filterLimit > 0 && allRawContactIds.length > filterLimit) {
                     long[] truncatedRawContactIds = new long[filterLimit];
                     for (int i = 0; i < filterLimit; i++) {
                         truncatedRawContactIds[i] = allRawContactIds[i];
                     }
                     return truncatedRawContactIds;
                 }
                 return allRawContactIds;
             }
             // "match" can only be used with the "tel" field
             if ("match".equals(filterOp)) {
                 for (int i = 0; i < filterBy.length(); i++) {
                     if (!"tel".equals(filterBy.getString(i))) {
                         Log.w(LOGTAG, "\"match\" filterBy option is only valid for the \"tel\" field");
                         return null;
                     }
                 }
             }
             // Only select contacts from the selected account
             String selection = null;
             String[] selectionArgs = null;
             if (mAccountName != null) {
                 selection = RawContacts.ACCOUNT_NAME + "=? AND " + RawContacts.ACCOUNT_TYPE + "=?";
                 selectionArgs = new String[] {mAccountName, mAccountType};
             }
             final String[] columnsToGet;
             // If a filterBy value was not specified, search all columns
             if (filterBy == null || filterBy.length() == 0) {
                 columnsToGet = null;
             } else {
                 // Only get the columns given in the filterBy array
                 List<String> columnsToGetList = new ArrayList<String>();
                 columnsToGetList.add(Data.RAW_CONTACT_ID);
                 columnsToGetList.add(Data.MIMETYPE);
                 for (int i = 0; i < filterBy.length(); i++) {
                     final String field = filterBy.getString(i);
                     // If one of the filterBy fields is the ID, just return the filter value
                     // which should be the ID
                     if ("id".equals(field)) {
                         try {
                             return new long[] {Long.valueOf(filterValue)};
                         } catch (NumberFormatException e) {
                             // If the ID couldn't be converted to a long, it's invalid data
                             // so return null for failure
                             return null;
                         }
                     }
                     final String columnName = getColumnNameConstant(field);
                     if (columnName != null) {
                         columnsToGetList.add(columnName);
                     } else {
                         Log.w(LOGTAG, "Unknown filter option: " + field);
                     }
                 }
                 columnsToGet = columnsToGetList.toArray(new String[columnsToGetList.size()]);
             }
             // Execute the query
             cursor = mContentResolver.query(Data.CONTENT_URI, columnsToGet, selection,
                                             selectionArgs, null);
             if (cursor.getCount() > 0) {
                 cursor.moveToPosition(-1);
                 while (cursor.moveToNext()) {
                     String mimeType = cursor.getString(cursor.getColumnIndex(Data.MIMETYPE));
                     // Check if the current mimetype is one of the types to filter by
                     if (filterBy != null && filterBy.length() > 0) {
                         for (int i = 0; i < filterBy.length(); i++) {
                             String currentFilterBy = filterBy.getString(i);
                             if (mimeType.equals(getMimeTypeOfField(currentFilterBy))) {
                                 String columnName = getColumnNameConstant(currentFilterBy);
                                 int columnIndex = cursor.getColumnIndex(columnName);
                                 String databaseValue = cursor.getString(columnIndex);
                                 boolean isPhone = false;
                                 if (Phone.CONTENT_ITEM_TYPE.equals(mimeType)) {
                                     isPhone = true;
                                 } else if (GroupMembership.CONTENT_ITEM_TYPE.equals(mimeType)) {
                                     // Translate the group ID to the group name for matching
                                     try {
                                         databaseValue = getGroupName(Long.valueOf(databaseValue));
                                     } catch (NumberFormatException e) {
                                         Log.e(LOGTAG, "Number Format Exception", e);
                                         continue;
                                     }
                                 } else if (databaseValue == null) {
                                     continue;
                                 }
                                 // Check if the value matches the filter value
                                 if (isFindMatch(filterOp, filterValue, databaseValue, isPhone, substringMatching)) {
                                     addMatchToList(cursor, rawContactIds);
                                     break;
                                 }
                             }
                         }
                     } else {
                         // If no filterBy options were given, check each column for a match
                         int numColumns = cursor.getColumnCount();
                         for (int i = 0; i < numColumns; i++) {
                             String databaseValue = cursor.getString(i);
                             if (databaseValue != null && isFindMatch(filterOp, filterValue, databaseValue, false, substringMatching)) {
                                 addMatchToList(cursor, rawContactIds);
                                 break;
                             }
                         }
                     }
                     // If the max found contacts size has been hit, stop looking for contacts
                     // A filter limit of 0 denotes there is no limit
                     if (filterLimit > 0 && filterLimit <= rawContactIds.size()) {
                         break;
                     }
                 }
             }
         } catch (JSONException e) {
             throw new IllegalArgumentException(e);
         } finally {
             if (cursor != null) {
                 cursor.close();
             }
         }
         // Return the contact IDs list converted to an array
         return convertLongListToArray(rawContactIds);
     }
     private boolean isFindMatch(final String filterOp, String filterValue, String databaseValue,
                                 final boolean isPhone, final int substringMatching) {
         Log.i(LOGTAG, "matching: filterOp: " + filterOp);
         if (DEBUG) {
             Log.d(LOGTAG, "matching: filterValue: " + filterValue);
             Log.d(LOGTAG, "matching: databaseValue: " + databaseValue);
         }
         Log.i(LOGTAG, "matching: isPhone: " + isPhone);
         Log.i(LOGTAG, "matching: substringMatching: " + substringMatching);
         if (databaseValue == null) {
             return false;
         }
         filterValue = filterValue.toLowerCase();
         databaseValue = databaseValue.toLowerCase();
         if ("match".equals(filterOp)) {
             // If substring matching is a positive number, only pay attention to the last X characters
             // of both the filter and database values
             if (substringMatching > 0) {
                 databaseValue = substringStartFromEnd(cleanPhoneNumber(databaseValue), substringMatching);
                 filterValue = substringStartFromEnd(cleanPhoneNumber(filterValue), substringMatching);
                 return databaseValue.startsWith(filterValue);
             }
             return databaseValue.equals(filterValue);
         } else if ("equals".equals(filterOp)) {
             if (isPhone) {
                 return PhoneNumberUtils.compare(filterValue, databaseValue);
             }
             return databaseValue.equals(filterValue);
         } else if ("contains".equals(filterOp)) {
             if (isPhone) {
                 filterValue = cleanPhoneNumber(filterValue);
                 databaseValue = cleanPhoneNumber(databaseValue);
             }
             return databaseValue.contains(filterValue);
         } else if ("startsWith".equals(filterOp)) {
             // If a phone number, remove non-dialable characters and then only pay attention to
             // the last X digits given by the substring matching values (see bug 877302)
             if (isPhone) {
                 String cleanedDatabasePhone = cleanPhoneNumber(databaseValue);
                 if (substringMatching > 0) {
                     cleanedDatabasePhone = substringStartFromEnd(cleanedDatabasePhone, substringMatching);
                 }
                 if (cleanedDatabasePhone.startsWith(filterValue)) {
                     return true;
                 }
             }
             return databaseValue.startsWith(filterValue);
         }
         return false;
     }
     private static String cleanPhoneNumber(String phone) {
         return phone.replace(" ", "").replace("(", "").replace(")", "").replace("-", "");
     }
     private static String substringStartFromEnd(final String string, final int distanceFromEnd) {
         int stringLen = string.length();
         if (stringLen < distanceFromEnd) {
             return string;
         }
         return string.substring(stringLen - distanceFromEnd);
     }
     private static void addMatchToList(final Cursor cursor, List<Long> rawContactIds) {
         long rawContactId = cursor.getLong(cursor.getColumnIndex(Data.RAW_CONTACT_ID));
         if (!rawContactIds.contains(rawContactId)) {
             rawContactIds.add(rawContactId);
         }
     }
     private JSONArray getContactsAsJSONArray(final long[] rawContactIds, final String sortBy, final String sortOrder) {
         List<JSONObject> contactsList = new ArrayList<JSONObject>();
         JSONArray contactsArray = new JSONArray();
         // Get each contact as a JSON object
         for (int i = 0; i < rawContactIds.length; i++) {
             contactsList.add(getContactAsJSONObject(rawContactIds[i]));
         }
         // Sort the contacts
         if (sortBy != null) {
             Collections.sort(contactsList, new ContactsComparator(sortBy, sortOrder));
         }
         // Convert the contacts list to a JSON array
         for (int i = 0; i < contactsList.size(); i++) {
             contactsArray.put(contactsList.get(i));
         }
         return contactsArray;
     }
     private JSONObject getContactAsJSONObject(long rawContactId) {
         // ContactManager wants a contact object with it's properties wrapped in an array of objects
         JSONObject contact = new JSONObject();
         JSONObject contactProperties = new JSONObject();
         JSONArray names = new JSONArray();
         JSONArray givenNames = new JSONArray();
         JSONArray familyNames = new JSONArray();
         JSONArray honorificPrefixes = new JSONArray();
         JSONArray honorificSuffixes = new JSONArray();
         JSONArray additionalNames = new JSONArray();
         JSONArray nicknames = new JSONArray();
         JSONArray addresses = new JSONArray();
         JSONArray phones = new JSONArray();
         JSONArray emails = new JSONArray();
         JSONArray organizations = new JSONArray();
         JSONArray jobTitles = new JSONArray();
         JSONArray notes = new JSONArray();
         JSONArray urls = new JSONArray();
         JSONArray impps = new JSONArray();
         JSONArray categories = new JSONArray();
         String bday = null;
         String anniversary = null;
         String sex = null;
         String genderIdentity = null;
         JSONArray key = new JSONArray();
         // Get all the data columns
         final String[] columnsToGet = getAllColumns();
         Uri rawContactUri = ContentUris.withAppendedId(RawContacts.CONTENT_URI, rawContactId);
         Uri entityUri = Uri.withAppendedPath(rawContactUri, Entity.CONTENT_DIRECTORY);
         Cursor cursor = mContentResolver.query(entityUri, columnsToGet, null, null, null);
         cursor.moveToPosition(-1);
         while (cursor.moveToNext()) {
             String mimeType = cursor.getString(cursor.getColumnIndex(Data.MIMETYPE));
             // Put the proper fields for each mimetype into the JSON arrays
             try {
                 if (StructuredName.CONTENT_ITEM_TYPE.equals(mimeType)) {
                     final String displayName = cursor.getString(cursor.getColumnIndex(StructuredName.DISPLAY_NAME));
                     final String givenName = cursor.getString(cursor.getColumnIndex(StructuredName.GIVEN_NAME));
                     final String familyName = cursor.getString(cursor.getColumnIndex(StructuredName.FAMILY_NAME));
                     final String prefix = cursor.getString(cursor.getColumnIndex(StructuredName.PREFIX));
                     final String suffix = cursor.getString(cursor.getColumnIndex(StructuredName.SUFFIX));
                     if (displayName != null) {
                         names.put(displayName);
                     }
                     if (givenName != null) {
                         givenNames.put(givenName);
                     }
                     if (familyName != null) {
                         familyNames.put(familyName);
                     }
                     if (prefix != null) {
                         honorificPrefixes.put(prefix);
                     }
                     if (suffix != null) {
                         honorificSuffixes.put(suffix);
                     }
                 } else if (MIMETYPE_ADDITIONAL_NAME.equals(mimeType)) {
                     additionalNames.put(cursor.getString(cursor.getColumnIndex(CUSTOM_DATA_COLUMN)));
                 } else if (Nickname.CONTENT_ITEM_TYPE.equals(mimeType)) {
                     nicknames.put(cursor.getString(cursor.getColumnIndex(Nickname.NAME)));
                 } else if (StructuredPostal.CONTENT_ITEM_TYPE.equals(mimeType)) {
                     initAddressTypesMap();
                     getAddressDataAsJSONObject(cursor, addresses);
                 } else if (Phone.CONTENT_ITEM_TYPE.equals(mimeType)) {
                     initPhoneTypesMap();
                     getPhoneDataAsJSONObject(cursor, phones);
                 } else if (Email.CONTENT_ITEM_TYPE.equals(mimeType)) {
                     initEmailTypesMap();
                     getGenericDataAsJSONObject(cursor, emails, Email.ADDRESS, Email.TYPE, Email.LABEL, mEmailTypesMap);
                 } else if (Organization.CONTENT_ITEM_TYPE.equals(mimeType)) {
                     getOrganizationDataAsJSONObject(cursor, organizations, jobTitles);
                 } else if (Note.CONTENT_ITEM_TYPE.equals(mimeType)) {
                     notes.put(cursor.getString(cursor.getColumnIndex(Note.NOTE)));
                 } else if (Website.CONTENT_ITEM_TYPE.equals(mimeType)) {
                     initWebsiteTypesMap();
                     getGenericDataAsJSONObject(cursor, urls, Website.URL, Website.TYPE, Website.LABEL, mWebsiteTypesMap);
                 } else if (Im.CONTENT_ITEM_TYPE.equals(mimeType)) {
                     initImTypesMap();
                     getGenericDataAsJSONObject(cursor, impps, Im.DATA, Im.TYPE, Im.LABEL, mImTypesMap);
                 } else if (GroupMembership.CONTENT_ITEM_TYPE.equals(mimeType)) {
                     long groupId = cursor.getLong(cursor.getColumnIndex(GroupMembership.GROUP_ROW_ID));
                     String groupName = getGroupName(groupId);
                     if (!doesJSONArrayContainString(categories, groupName)) {
                         categories.put(groupName);
                     }
                 } else if (Event.CONTENT_ITEM_TYPE.equals(mimeType)) {
                     int type = cursor.getInt(cursor.getColumnIndex(Event.TYPE));
                     String date = cursor.getString(cursor.getColumnIndex(Event.START_DATE));
                     // Add the time info onto the date so it correctly parses into a JS date object
                     date += "T00:00:00";
                     switch (type) {
                         case Event.TYPE_BIRTHDAY:
                             bday = date;
                             break;
                         case Event.TYPE_ANNIVERSARY:
                             anniversary = date;
                             break;
                     }
                 } else if (MIMETYPE_SEX.equals(mimeType)) {
                     sex = cursor.getString(cursor.getColumnIndex(CUSTOM_DATA_COLUMN));
                 } else if (MIMETYPE_GENDER_IDENTITY.equals(mimeType)) {
                     genderIdentity = cursor.getString(cursor.getColumnIndex(CUSTOM_DATA_COLUMN));
                 } else if (MIMETYPE_KEY.equals(mimeType)) {
                     key.put(cursor.getString(cursor.getColumnIndex(CUSTOM_DATA_COLUMN)));
                 }
             } catch (JSONException e) {
                 throw new IllegalArgumentException(e);
             }
         }
         cursor.close();
         try {
             // Add the fields to the contact properties object
             contactProperties.put("name", names);
             contactProperties.put("givenName", givenNames);
             contactProperties.put("familyName", familyNames);
             contactProperties.put("honorificPrefix", honorificPrefixes);
             contactProperties.put("honorificSuffix", honorificSuffixes);
             contactProperties.put("additionalName", additionalNames);
             contactProperties.put("nickname", nicknames);
             contactProperties.put("adr", addresses);
             contactProperties.put("tel", phones);
             contactProperties.put("email", emails);
             contactProperties.put("org", organizations);
             contactProperties.put("jobTitle", jobTitles);
             contactProperties.put("note", notes);
             contactProperties.put("url", urls);
             contactProperties.put("impp", impps);
             contactProperties.put("category", categories);
             contactProperties.put("key", key);
             putPossibleNullValueInJSONObject("bday", bday, contactProperties);
             putPossibleNullValueInJSONObject("anniversary", anniversary, contactProperties);
             putPossibleNullValueInJSONObject("sex", sex, contactProperties);
             putPossibleNullValueInJSONObject("genderIdentity", genderIdentity, contactProperties);
             // Add the raw contact ID and the properties to the contact
             contact.put("id", String.valueOf(rawContactId));
             contact.put("updated", null);
             contact.put("published", null);
             contact.put("properties", contactProperties);
         } catch (JSONException e) {
             throw new IllegalArgumentException(e);
         }
         if (DEBUG) {
             try {
                 Log.d(LOGTAG, "Got contact: " + contact.toString(3));
             } catch (JSONException e) {}
         }
         return contact;
     }
     private boolean bool(int integer) {
         return integer != 0 ? true : false;
     }
     private void getGenericDataAsJSONObject(Cursor cursor, JSONArray array, final String dataColumn,
                                             final String typeColumn, final String typeLabelColumn,
                                             final HashMap<String, Integer> typeMap) throws JSONException {
         String value = cursor.getString(cursor.getColumnIndex(dataColumn));
         int typeConstant = cursor.getInt(cursor.getColumnIndex(typeColumn));
         String type;
         if (typeConstant == BaseTypes.TYPE_CUSTOM) {
             type = cursor.getString(cursor.getColumnIndex(typeLabelColumn));
         } else {
             type = getKeyFromMapValue(typeMap, Integer.valueOf(typeConstant));
         }
         // Since an object may have multiple types, it may have already been added,
         // but still needs the new type added
         boolean found = false;
         if (type != null) {
             for (int i = 0; i < array.length(); i++) {
                 JSONObject object = array.getJSONObject(i);
                 if (value.equals(object.getString("value"))) {
                     found = true;
                     JSONArray types = object.getJSONArray("type");
                     if (!doesJSONArrayContainString(types, type)) {
                         types.put(type);
                         break;
                     }
                 }
             }
         }
         // If an existing object wasn't found, make a new one
         if (!found) {
             JSONObject object = new JSONObject();
             JSONArray types = new JSONArray();
             object.put("value", value);
             types.put(type);
             object.put("type", types);
             object.put("pref", bool(cursor.getInt(cursor.getColumnIndex(Data.IS_SUPER_PRIMARY))));
             array.put(object);
         }
     }
     private void getPhoneDataAsJSONObject(Cursor cursor, JSONArray phones) throws JSONException {
         String value = cursor.getString(cursor.getColumnIndex(Phone.NUMBER));
         int typeConstant = cursor.getInt(cursor.getColumnIndex(Phone.TYPE));
         String type;
         if (typeConstant == Phone.TYPE_CUSTOM) {
             type = cursor.getString(cursor.getColumnIndex(Phone.LABEL));
         } else {
             type = getKeyFromMapValue(mPhoneTypesMap, Integer.valueOf(typeConstant));
         }
         // Since a phone may have multiple types, it may have already been added,
         // but still needs the new type added
         boolean found = false;
         if (type != null) {
             for (int i = 0; i < phones.length(); i++) {
                 JSONObject phone = phones.getJSONObject(i);
                 if (value.equals(phone.getString("value"))) {
                     found = true;
                     JSONArray types = phone.getJSONArray("type");
                     if (!doesJSONArrayContainString(types, type)) {
                         types.put(type);
                         break;
                     }
                 }
             }
         }
         // If an existing phone wasn't found, make a new one
         if (!found) {
             JSONObject phone = new JSONObject();
             JSONArray types = new JSONArray();
             phone.put("value", value);
             phone.put("type", type);
             types.put(type);
             phone.put("type", types);
             phone.put("carrier", cursor.getString(cursor.getColumnIndex(CARRIER_COLUMN)));
             phone.put("pref", bool(cursor.getInt(cursor.getColumnIndex(Phone.IS_SUPER_PRIMARY))));
             phones.put(phone);
         }
     }
     private void getAddressDataAsJSONObject(Cursor cursor, JSONArray addresses) throws JSONException {
         String streetAddress = cursor.getString(cursor.getColumnIndex(StructuredPostal.STREET));
         String locality = cursor.getString(cursor.getColumnIndex(StructuredPostal.CITY));
         String region = cursor.getString(cursor.getColumnIndex(StructuredPostal.REGION));
         String postalCode = cursor.getString(cursor.getColumnIndex(StructuredPostal.POSTCODE));
         String countryName = cursor.getString(cursor.getColumnIndex(StructuredPostal.COUNTRY));
         int typeConstant = cursor.getInt(cursor.getColumnIndex(StructuredPostal.TYPE));
         String type;
         if (typeConstant == StructuredPostal.TYPE_CUSTOM) {
             type = cursor.getString(cursor.getColumnIndex(StructuredPostal.LABEL));
         } else {
             type = getKeyFromMapValue(mAddressTypesMap, Integer.valueOf(typeConstant));
         }
         // Since an email may have multiple types, it may have already been added,
         // but still needs the new type added
         boolean found = false;
         if (type != null) {
             for (int i = 0; i < addresses.length(); i++) {
                 JSONObject address = addresses.getJSONObject(i);
                 if (streetAddress.equals(address.getString("streetAddress")) &&
                     locality.equals(address.getString("locality")) &&
                     region.equals(address.getString("region")) &&
                     countryName.equals(address.getString("countryName")) &&
                     postalCode.equals(address.getString("postalCode"))) {
                     found = true;
                     JSONArray types = address.getJSONArray("type");
                     if (!doesJSONArrayContainString(types, type)) {
                         types.put(type);
                         break;
                     }
                 }
             }
         }
         // If an existing email wasn't found, make a new one
         if (!found) {
             JSONObject address = new JSONObject();
             JSONArray types = new JSONArray();
             address.put("streetAddress", streetAddress);
             address.put("locality", locality);
             address.put("region", region);
             address.put("countryName", countryName);
             address.put("postalCode", postalCode);
             types.put(type);
             address.put("type", types);
             address.put("pref", bool(cursor.getInt(cursor.getColumnIndex(StructuredPostal.IS_SUPER_PRIMARY))));
             addresses.put(address);
         }
     }
     private void getOrganizationDataAsJSONObject(Cursor cursor, JSONArray organizations,
                                                  JSONArray jobTitles) throws JSONException {
         int organizationColumnIndex = cursor.getColumnIndex(Organization.COMPANY);
         int titleColumnIndex = cursor.getColumnIndex(Organization.TITLE);
         if (!cursor.isNull(organizationColumnIndex)) {
             organizations.put(cursor.getString(organizationColumnIndex));
         }
         if (!cursor.isNull(titleColumnIndex)) {
             jobTitles.put(cursor.getString(titleColumnIndex));
         }
     }
     private class ContactsComparator implements Comparator<JSONObject> {
         final String mSortBy;
         final String mSortOrder;
         public ContactsComparator(final String sortBy, final String sortOrder) {
             mSortBy = sortBy.toLowerCase();
             mSortOrder = sortOrder.toLowerCase();
         }
         @Override
         public int compare(JSONObject left, JSONObject right) {
             // Determine if sorting by "family name, given name" or "given name, family name"
             boolean familyFirst = false;
             if ("familyname".equals(mSortBy)) {
                 familyFirst = true;
             }
             JSONObject leftProperties;
             JSONObject rightProperties;
             try {
                 leftProperties = left.getJSONObject("properties");
                 rightProperties = right.getJSONObject("properties");
             } catch (JSONException e) {
                 throw new IllegalArgumentException(e);
             }
             JSONArray leftFamilyNames = leftProperties.optJSONArray("familyName");
             JSONArray leftGivenNames = leftProperties.optJSONArray("givenName");
             JSONArray rightFamilyNames = rightProperties.optJSONArray("familyName");
             JSONArray rightGivenNames = rightProperties.optJSONArray("givenName");
             // If any of the name arrays didn't exist (are null), create empty arrays
             // to avoid doing a bunch of null checking below
             if (leftFamilyNames == null) {
                 leftFamilyNames = new JSONArray();
             }
             if (leftGivenNames == null) {
                 leftGivenNames = new JSONArray();
             }
             if (rightFamilyNames == null) {
                 rightFamilyNames = new JSONArray();
             }
             if (rightGivenNames == null) {
                 rightGivenNames = new JSONArray();
             }
             int maxArrayLength = max(leftFamilyNames.length(), leftGivenNames.length(),
                                      rightFamilyNames.length(), rightGivenNames.length());
             int index = 0;
             int compareResult;
             do {
                 // Join together the given name and family name per the pattern above
                 String leftName = "";
                 String rightName = "";
                 if (familyFirst) {
                     leftName = leftFamilyNames.optString(index, "") + leftGivenNames.optString(index, "");
                     rightName = rightFamilyNames.optString(index, "") + rightGivenNames.optString(index, "");
                 } else {
                     leftName = leftGivenNames.optString(index, "") + leftFamilyNames.optString(index, "");
                     rightName = rightGivenNames.optString(index, "") + rightFamilyNames.optString(index, "");
                 }
                 index++;
                 compareResult = leftName.compareTo(rightName);
             } while (compareResult == 0 && index < maxArrayLength);
             // If descending order, flip the result
             if (compareResult != 0 && "descending".equals(mSortOrder)) {
                 compareResult = -compareResult;
             }
             return compareResult;
         }
     }
     private void clearAllContacts(final JSONObject contactOptions, final String requestID) {
         ArrayList<ContentProviderOperation> deleteOptions = new ArrayList<ContentProviderOperation>();
         // Delete all contacts from the selected account
         ContentProviderOperation.Builder deleteOptionsBuilder = ContentProviderOperation.newDelete(RawContacts.CONTENT_URI);
         if (mAccountName != null) {
             deleteOptionsBuilder.withSelection(RawContacts.ACCOUNT_NAME + "=?", new String[] {mAccountName})
                                 .withSelection(RawContacts.ACCOUNT_TYPE + "=?", new String[] {mAccountType});
         }
         deleteOptions.add(deleteOptionsBuilder.build());
         // Clear the contacts
         String returnStatus = "KO";
         if (applyBatch(deleteOptions) != null) {
             returnStatus = "OK";
         }
         Log.i(LOGTAG, "Sending return status: " + returnStatus);
         sendCallbackToJavascript("Android:Contacts:Clear:Return:" + returnStatus, requestID,
                                  new String[] {"contactID"}, new Object[] {"undefined"});
     }
     private boolean deleteContact(String rawContactId) {
         ContentProviderOperation deleteOptions = ContentProviderOperation.newDelete(RawContacts.CONTENT_URI)
                                                  .withSelection(RawContacts._ID + "=?",
                                                  new String[] {rawContactId})
                                                  .build();
         ArrayList<ContentProviderOperation> deleteOptionsList = new ArrayList<ContentProviderOperation>();
         deleteOptionsList.add(deleteOptions);
         return checkForPositiveCountInResults(applyBatch(deleteOptionsList));
     }
     private void removeContact(final JSONObject contactOptions, final String requestID) {
         String rawContactId;
         try {
             rawContactId = contactOptions.getString("id");
             Log.i(LOGTAG, "Removing contact with ID: " + rawContactId);
         } catch (JSONException e) {
             // We can't continue without a raw contact ID
             sendCallbackToJavascript("Android:Contact:Remove:Return:KO", requestID, null, null);
             return;
         }
         String returnStatus = "KO";
         if(deleteContact(rawContactId)) {
             returnStatus = "OK";
         }
         sendCallbackToJavascript("Android:Contact:Remove:Return:" + returnStatus, requestID,
                                  new String[] {"contactID"}, new Object[] {rawContactId});
     }
     private void saveContact(final JSONObject contactOptions, final String requestID) {
         try {
             String reason = contactOptions.getString("reason");
             JSONObject contact = contactOptions.getJSONObject("contact");
             JSONObject contactProperties = contact.getJSONObject("properties");
             if ("update".equals(reason)) {
                 updateContact(contactProperties, contact.getLong("id"), requestID);
             } else {
                 insertContact(contactProperties, requestID);
             }
         } catch (JSONException e) {
             throw new IllegalArgumentException(e);
         }
     }
     private void insertContact(final JSONObject contactProperties, final String requestID) throws JSONException {
         ArrayList<ContentProviderOperation> newContactOptions = new ArrayList<ContentProviderOperation>();
         // Account to save the contact under
         newContactOptions.add(ContentProviderOperation.newInsert(RawContacts.CONTENT_URI)
                          .withValue(RawContacts.ACCOUNT_NAME, mAccountName)
                          .withValue(RawContacts.ACCOUNT_TYPE, mAccountType)
                          .build());
         List<ContentValues> newContactValues = getContactValues(contactProperties);
         for (ContentValues values : newContactValues) {
             newContactOptions.add(ContentProviderOperation.newInsert(Data.CONTENT_URI)
                                   .withValueBackReference(Data.RAW_CONTACT_ID, 0)
                                   .withValues(values)
                                   .build());
         }
         String returnStatus = "KO";
         Long newRawContactId = new Long(-1);
         // Insert the contact!
         ContentProviderResult[] insertResults = applyBatch(newContactOptions);
         if (insertResults != null) {
             try {
                 // Get the ID of the newly created contact
                 newRawContactId = getRawContactIdFromContentProviderResults(insertResults);
                 if (newRawContactId != null) {
                     returnStatus = "OK";
                 }
             } catch (NumberFormatException e) {
                 Log.e(LOGTAG, "NumberFormatException", e);
             }
             Log.i(LOGTAG, "Newly created contact ID: " + newRawContactId);
         }
         Log.i(LOGTAG, "Sending return status: " + returnStatus);
         sendCallbackToJavascript("Android:Contact:Save:Return:" + returnStatus, requestID,
                                  new String[] {"contactID", "reason"},
                                  new Object[] {newRawContactId, "create"});
     }
     private void updateContact(final JSONObject contactProperties, final long rawContactId, final String requestID) throws JSONException {
         // Why is updating a contact so weird and horribly inefficient? Because Android doesn't
         // like multiple values for contact fields, but the Mozilla contacts API calls for this.
         // This means the Android update function is essentially completely useless. Why not just
         // delete the contact and re-insert it? Because that would change the contact ID and the
         // Mozilla contacts API shouldn't have this behavior. The solution is to delete each
         // row from the contacts data table that belongs to the contact, and insert the new
         // fields. But then why not just delete all the data from the data in one go and
         // insert the new data in another? Because if all the data relating to a contact is
         // deleted, Android will "conviently" remove the ID making it impossible to insert data
         // under the old ID. To work around this, we put a Mozilla contact flag in the database
         ContentProviderOperation removeOptions = ContentProviderOperation.newDelete(Data.CONTENT_URI)
                                                  .withSelection(Data.RAW_CONTACT_ID + "=? AND " +
                                                  Data.MIMETYPE + " != '" + MIMETYPE_MOZILLA_CONTACTS_FLAG + "'",
                                                  new String[] {String.valueOf(rawContactId)})
                                                  .build();
         ArrayList<ContentProviderOperation> removeOptionsList = new ArrayList<ContentProviderOperation>();
         removeOptionsList.add(removeOptions);
         ContentProviderResult[] removeResults = applyBatch(removeOptionsList);
         // Check if the remove failed
         if (removeResults == null || !checkForPositiveCountInResults(removeResults)) {
             Log.w(LOGTAG, "Null or 0 remove results");
             sendCallbackToJavascript("Android:Contact:Save:Return:KO", requestID, null, null);
             return;
         }
         List<ContentValues> updateContactValues = getContactValues(contactProperties);
         ArrayList<ContentProviderOperation> updateContactOptions = new ArrayList<ContentProviderOperation>();
         for (ContentValues values : updateContactValues) {
             updateContactOptions.add(ContentProviderOperation.newInsert(Data.CONTENT_URI)
                                   .withValue(Data.RAW_CONTACT_ID, rawContactId)
                                   .withValues(values)
                                   .build());
         }
         String returnStatus = "KO";
         // Update the contact!
         applyBatch(updateContactOptions);
         sendCallbackToJavascript("Android:Contact:Save:Return:OK", requestID,
                                  new String[] {"contactID", "reason"},
                                  new Object[] {rawContactId, "update"});
     }
     private List<ContentValues> getContactValues(final JSONObject contactProperties) throws JSONException {
         List<ContentValues> contactValues = new ArrayList<ContentValues>();
         // Add the contact to the default group so it is shown in other apps
         // like the Contacts or People app
         ContentValues defaultGroupValues = new ContentValues();
         defaultGroupValues.put(Data.MIMETYPE, GroupMembership.CONTENT_ITEM_TYPE);
         defaultGroupValues.put(GroupMembership.GROUP_ROW_ID, mGroupId);
         contactValues.add(defaultGroupValues);
         // Create all the values that will be inserted into the new contact
         getNameValues(contactProperties.optJSONArray("name"),
                       contactProperties.optJSONArray("givenName"),
                       contactProperties.optJSONArray("familyName"),
                       contactProperties.optJSONArray("honorificPrefix"),
                       contactProperties.optJSONArray("honorificSuffix"),
                       contactValues);
         getGenericValues(MIMETYPE_ADDITIONAL_NAME, CUSTOM_DATA_COLUMN,
                          contactProperties.optJSONArray("additionalName"), contactValues);
         getNicknamesValues(contactProperties.optJSONArray("nickname"), contactValues);
         getAddressesValues(contactProperties.optJSONArray("adr"), contactValues);
         getPhonesValues(contactProperties.optJSONArray("tel"), contactValues);
         getEmailsValues(contactProperties.optJSONArray("email"), contactValues);
         //getPhotosValues(contactProperties.optJSONArray("photo"), contactValues);
         getGenericValues(Organization.CONTENT_ITEM_TYPE, Organization.COMPANY,
                          contactProperties.optJSONArray("org"), contactValues);
         getGenericValues(Organization.CONTENT_ITEM_TYPE, Organization.TITLE,
                          contactProperties.optJSONArray("jobTitle"), contactValues);
         getNotesValues(contactProperties.optJSONArray("note"), contactValues);
         getWebsitesValues(contactProperties.optJSONArray("url"), contactValues);
         getImsValues(contactProperties.optJSONArray("impp"), contactValues);
         getCategoriesValues(contactProperties.optJSONArray("category"), contactValues);
         getEventValues(contactProperties.optString("bday"), Event.TYPE_BIRTHDAY, contactValues);
         getEventValues(contactProperties.optString("anniversary"), Event.TYPE_ANNIVERSARY, contactValues);
         getCustomMimetypeValues(contactProperties.optString("sex"), MIMETYPE_SEX, contactValues);
         getCustomMimetypeValues(contactProperties.optString("genderIdentity"), MIMETYPE_GENDER_IDENTITY, contactValues);
         getGenericValues(MIMETYPE_KEY, CUSTOM_DATA_COLUMN, contactProperties.optJSONArray("key"),
                          contactValues);
         return contactValues;
     }
     private void getGenericValues(final String mimeType, final String dataType, final JSONArray fields,
                                   List<ContentValues> newContactValues) throws JSONException {
         if (fields == null) {
             return;
         }
         for (int i = 0; i < fields.length(); i++) {
             ContentValues contentValues = new ContentValues();
             contentValues.put(Data.MIMETYPE, mimeType);
             contentValues.put(dataType, fields.getString(i));
             newContactValues.add(contentValues);
         }
     }
     private void getNameValues(final JSONArray displayNames, final JSONArray givenNames,
                                final JSONArray familyNames, final JSONArray prefixes,
                                final JSONArray suffixes, List<ContentValues> newContactValues) throws JSONException {
         int maxLen = max((displayNames != null ? displayNames.length() : 0),
                          (givenNames != null ? givenNames.length() : 0),
                          (familyNames != null ? familyNames.length() : 0),
                          (prefixes != null ? prefixes.length() : 0),
                          (suffixes != null ? suffixes.length() : 0));
         for (int i = 0; i < maxLen; i++) {
             ContentValues contentValues = new ContentValues();
             contentValues.put(Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE);
             final String displayName = (displayNames != null ? displayNames.optString(i, null) : null);
             final String givenName = (givenNames != null ? givenNames.optString(i, null) : null);
             final String familyName = (familyNames != null ? familyNames.optString(i, null) : null);
             final String prefix = (prefixes != null ? prefixes.optString(i, null) : null);
             final String suffix = (suffixes != null ? suffixes.optString(i, null) : null);
             if (displayName != null) {
                 contentValues.put(StructuredName.DISPLAY_NAME, displayName);
             }
             if (givenName != null) {
                 contentValues.put(StructuredName.GIVEN_NAME, givenName);
             }
             if (familyName != null) {
                 contentValues.put(StructuredName.FAMILY_NAME, familyName);
             }
             if (prefix != null) {
                 contentValues.put(StructuredName.PREFIX, prefix);
             }
             if (suffix != null) {
                 contentValues.put(StructuredName.SUFFIX, suffix);
             }
             newContactValues.add(contentValues);
         }
     }
     private void getNicknamesValues(final JSONArray nicknames, List<ContentValues> newContactValues) throws JSONException {
         if (nicknames == null) {
             return;
         }
         for (int i = 0; i < nicknames.length(); i++) {
             ContentValues contentValues = new ContentValues();
             contentValues.put(Data.MIMETYPE, Nickname.CONTENT_ITEM_TYPE);
             contentValues.put(Nickname.NAME, nicknames.getString(i));
             contentValues.put(Nickname.TYPE, Nickname.TYPE_DEFAULT);
             newContactValues.add(contentValues);
         }
     }
     private void getAddressesValues(final JSONArray addresses, List<ContentValues> newContactValues) throws JSONException {
         if (addresses == null) {
             return;
         }
         for (int i = 0; i < addresses.length(); i++) {
             JSONObject address = addresses.getJSONObject(i);
             JSONArray addressTypes = address.optJSONArray("type");
             if (addressTypes != null) {
                 for (int j = 0; j < addressTypes.length(); j++) {
                     // Translate the address type string to an integer constant
                     // provided by the ContactsContract API
                     final String type = addressTypes.getString(j);
                     final int typeConstant = getAddressType(type);
                     newContactValues.add(createAddressContentValues(address, typeConstant, type));
                 }
             } else {
                 newContactValues.add(createAddressContentValues(address, -1, null));
             }
         }
     }
     private ContentValues createAddressContentValues(final JSONObject address, final int typeConstant,
                                                      final String type) throws JSONException {
         ContentValues contentValues = new ContentValues();
         contentValues.put(Data.MIMETYPE, StructuredPostal.CONTENT_ITEM_TYPE);
         contentValues.put(StructuredPostal.STREET, address.optString("streetAddress"));
         contentValues.put(StructuredPostal.CITY, address.optString("locality"));
         contentValues.put(StructuredPostal.REGION, address.optString("region"));
         contentValues.put(StructuredPostal.POSTCODE, address.optString("postalCode"));
         contentValues.put(StructuredPostal.COUNTRY, address.optString("countryName"));
         if (type != null) {
             contentValues.put(StructuredPostal.TYPE, typeConstant);
             // If a custom type, add a label
             if (typeConstant == BaseTypes.TYPE_CUSTOM) {
                 contentValues.put(StructuredPostal.LABEL, type);
             }
         }
         if (address.has("pref")) {
             contentValues.put(Data.IS_SUPER_PRIMARY, address.getBoolean("pref") ? 1 : 0);
         }
         return contentValues;
     }
     private void getPhonesValues(final JSONArray phones, List<ContentValues> newContactValues) throws JSONException {
         if (phones == null) {
             return;
         }
         for (int i = 0; i < phones.length(); i++) {
             JSONObject phone = phones.getJSONObject(i);
             JSONArray phoneTypes = phone.optJSONArray("type");
             ContentValues contentValues;
             if (phoneTypes != null && phoneTypes.length() > 0) {
                 for (int j = 0; j < phoneTypes.length(); j++) {
                     // Translate the phone type string to an integer constant
                     // provided by the ContactsContract API
                     final String type = phoneTypes.getString(j);
                     final int typeConstant = getPhoneType(type);
                     contentValues = createContentValues(Phone.CONTENT_ITEM_TYPE, phone.optString("value"),
                                                         typeConstant, type, phone.optBoolean("pref"));
                     if (phone.has("carrier")) {
                         contentValues.put(CARRIER_COLUMN, phone.optString("carrier"));
                     }
                     newContactValues.add(contentValues);
                 }
             } else {
                 contentValues = createContentValues(Phone.CONTENT_ITEM_TYPE, phone.optString("value"),
                                                     -1, null, phone.optBoolean("pref"));
                 if (phone.has("carrier")) {
                     contentValues.put(CARRIER_COLUMN, phone.optString("carrier"));
                 }
                 newContactValues.add(contentValues);
             }
         }
     }
     private void getEmailsValues(final JSONArray emails, List<ContentValues> newContactValues) throws JSONException {
         if (emails == null) {
             return;
         }
         for (int i = 0; i < emails.length(); i++) {
             JSONObject email = emails.getJSONObject(i);
             JSONArray emailTypes = email.optJSONArray("type");
             if (emailTypes != null && emailTypes.length() > 0) {
                 for (int j = 0; j < emailTypes.length(); j++) {
                     // Translate the email type string to an integer constant
                     // provided by the ContactsContract API
                     final String type = emailTypes.getString(j);
                     final int typeConstant = getEmailType(type);
                     newContactValues.add(createContentValues(Email.CONTENT_ITEM_TYPE,
                                                              email.optString("value"),
                                                              typeConstant, type,
                                                              email.optBoolean("pref")));
                 }
             } else {
                 newContactValues.add(createContentValues(Email.CONTENT_ITEM_TYPE,
                                                          email.optString("value"),
                                                          -1, null, email.optBoolean("pref")));
             }
         }
     }
     private void getPhotosValues(final JSONArray photos, List<ContentValues> newContactValues) throws JSONException {
         if (photos == null) {
             return;
         }
         // TODO: implement this
     }
     private void getNotesValues(final JSONArray notes, List<ContentValues> newContactValues) throws JSONException {
         if (notes == null) {
             return;
         }
         for (int i = 0; i < notes.length(); i++) {
             ContentValues contentValues = new ContentValues();
             contentValues.put(Data.MIMETYPE, Note.CONTENT_ITEM_TYPE);
             contentValues.put(Note.NOTE, notes.getString(i));
             newContactValues.add(contentValues);
         }
     }
     private void getWebsitesValues(final JSONArray websites, List<ContentValues> newContactValues) throws JSONException {
         if (websites == null) {
             return;
         }
         for (int i = 0; i < websites.length(); i++) {
             JSONObject website = websites.getJSONObject(i);
             JSONArray websiteTypes = website.optJSONArray("type");
             if (websiteTypes != null && websiteTypes.length() > 0) {
                 for (int j = 0; j < websiteTypes.length(); j++) {
                     // Translate the website type string to an integer constant
                     // provided by the ContactsContract API
                     final String type = websiteTypes.getString(j);
                     final int typeConstant = getWebsiteType(type);
                     newContactValues.add(createContentValues(Website.CONTENT_ITEM_TYPE,
                                                              website.optString("value"),
                                                              typeConstant, type,
                                                              website.optBoolean("pref")));
                 }
             } else {
                 newContactValues.add(createContentValues(Website.CONTENT_ITEM_TYPE,
                                                          website.optString("value"),
                                                          -1, null, website.optBoolean("pref")));
             }
         }
     }
     private void getImsValues(final JSONArray ims, List<ContentValues> newContactValues) throws JSONException {
         if (ims == null) {
             return;
         }
         for (int i = 0; i < ims.length(); i++) {
             JSONObject im = ims.getJSONObject(i);
             JSONArray imTypes = im.optJSONArray("type");
             if (imTypes != null && imTypes.length() > 0) {
                 for (int j = 0; j < imTypes.length(); j++) {
                     // Translate the IM type string to an integer constant
                     // provided by the ContactsContract API
                     final String type = imTypes.getString(j);
                     final int typeConstant = getImType(type);
                     newContactValues.add(createContentValues(Im.CONTENT_ITEM_TYPE,
                                                              im.optString("value"),
                                                              typeConstant, type,
                                                              im.optBoolean("pref")));
                 }
             } else {
                 newContactValues.add(createContentValues(Im.CONTENT_ITEM_TYPE,
                                                          im.optString("value"),
                                                          -1, null, im.optBoolean("pref")));
             }
         }
     }
     private void getCategoriesValues(final JSONArray categories, List<ContentValues> newContactValues) throws JSONException {
         if (categories == null) {
             return;
         }
         for (int i = 0; i < categories.length(); i++) {
             String category = categories.getString(i);
             if ("my contacts".equals(category.toLowerCase()) ||
                 PRE_HONEYCOMB_DEFAULT_GROUP.equalsIgnoreCase(category)) {
                 Log.w(LOGTAG, "New contacts are implicitly added to the default group.");
                 continue;
             }
             // Find the group ID of the given category
             long groupId = getGroupId(category);
             // Create the group if it doesn't already exist
             if (groupId == -1) {
                 groupId = createGroup(category);
                 // If the group is still -1, we failed to create the group
                 if (groupId == -1) {
                     // Only log the category name if in debug
                     if (DEBUG) {
                         Log.d(LOGTAG, "Failed to create new group for category \"" + category + "\"");
                     } else {
                         Log.w(LOGTAG, "Failed to create new group for given category.");
                     }
                     continue;
                 }
             }
             ContentValues contentValues = new ContentValues();
             contentValues.put(Data.MIMETYPE, GroupMembership.CONTENT_ITEM_TYPE);
             contentValues.put(GroupMembership.GROUP_ROW_ID, groupId);
             newContactValues.add(contentValues);
             newContactValues.add(contentValues);
         }
     }
     private void getEventValues(final String event, final int type, List<ContentValues> newContactValues) {
         if (event == null || event.length() < 11) {
             return;
         }
         ContentValues contentValues = new ContentValues();
         contentValues.put(Data.MIMETYPE, Event.CONTENT_ITEM_TYPE);
         contentValues.put(Event.START_DATE, event.substring(0, 10));
         contentValues.put(Event.TYPE, type);
         newContactValues.add(contentValues);
     }
     private void getCustomMimetypeValues(final String value, final String mimeType, List<ContentValues> newContactValues) {
         if (value == null || "null".equals(value)) {
             return;
         }
         ContentValues contentValues = new ContentValues();
         contentValues.put(Data.MIMETYPE, mimeType);
         contentValues.put(CUSTOM_DATA_COLUMN, value);
         newContactValues.add(contentValues);
     }
     private void getMozillaContactFlagValues(List<ContentValues> newContactValues) {
         try {
             JSONArray mozillaContactsFlag = new JSONArray();
             mozillaContactsFlag.put("1");
             getGenericValues(MIMETYPE_MOZILLA_CONTACTS_FLAG, CUSTOM_DATA_COLUMN, mozillaContactsFlag, newContactValues);
         } catch (JSONException e) {
             throw new IllegalArgumentException(e);
         }
     }
     private ContentValues createContentValues(final String mimeType, final String value, final int typeConstant,
                                               final String type, final boolean preferredValue) {
         ContentValues contentValues = new ContentValues();
         contentValues.put(Data.MIMETYPE, mimeType);
         contentValues.put(Data.DATA1, value);
         contentValues.put(Data.IS_SUPER_PRIMARY, preferredValue ? 1 : 0);
         if (type != null) {
             contentValues.put(Data.DATA2, typeConstant);
             // If a custom type, add a label
             if (typeConstant == BaseTypes.TYPE_CUSTOM) {
                 contentValues.put(Data.DATA3, type);
             }
         }
         return contentValues;
     }
     private void getContactsCount(final String requestID) {
         Cursor cursor = getAllRawContactIdsCursor();
         Integer numContacts = Integer.valueOf(cursor.getCount());
         cursor.close();
         sendCallbackToJavascript("Android:Contacts:Count", requestID, new String[] {"count"},
                                  new Object[] {numContacts});
     }
     private void sendCallbackToJavascript(final String subject, final String requestID,
                                           final String[] argNames, final Object[] argValues) {
         // Check the same number of argument names and arguments were given
         if (argNames != null && argNames.length != argValues.length) {
             throw new IllegalArgumentException("Argument names and argument values lengths do not match. " +
                                                "Names length = " + argNames.length + ", Values length = " +
                                                argValues.length);
         }
         try {
             JSONObject callbackMessage = new JSONObject();
             callbackMessage.put("requestID", requestID);
             if (argNames != null) {
                 for (int i = 0; i < argNames.length; i++) {
                     callbackMessage.put(argNames[i], argValues[i]);
                 }
             }
             GeckoAppShell.sendEventToGecko(GeckoEvent.createBroadcastEvent(subject, callbackMessage.toString()));
         } catch (JSONException e) {
             throw new IllegalArgumentException(e);
         }
     }
     private void registerEventListener(final String event) {
         mEventDispatcher.registerEventListener(event, this);
     }
     private void unregisterEventListener(final String event) {
         mEventDispatcher.unregisterEventListener(event, this);
     }
     private ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) {
         try {
             return mContentResolver.applyBatch(ContactsContract.AUTHORITY, operations);
         } catch (RemoteException e) {
             Log.e(LOGTAG, "RemoteException", e);
         } catch (OperationApplicationException e) {
             Log.e(LOGTAG, "OperationApplicationException", e);
         }
         return null;
     }
     private void getDeviceAccount(final Runnable handleMessage) {
         Account[] accounts = AccountManager.get(mActivity).getAccounts();
         if (accounts.length == 0) {
             Log.w(LOGTAG, "No accounts available");
             gotDeviceAccount(handleMessage);
         } else if (accounts.length > 1) {
             // Show the accounts chooser dialog if more than one dialog exists
             showAccountsDialog(accounts, handleMessage);
         } else {
             // If only one account exists, use it
             mAccountName = accounts[0].name;
             mAccountType = accounts[0].type;
             gotDeviceAccount(handleMessage);
         }
         mGotDeviceAccount = true;
     }
     private void showAccountsDialog(final Account[] accounts, final Runnable handleMessage) {
         String[] accountNames = new String[accounts.length];
         for (int i = 0; i < accounts.length; i++) {
             accountNames[i] = accounts[i].name;
         }
         final AlertDialog.Builder builder = new AlertDialog.Builder(mActivity);
         builder.setTitle(mActivity.getResources().getString(R.string.contacts_account_chooser_dialog_title))
             .setSingleChoiceItems(accountNames, 0, new DialogInterface.OnClickListener() {
                 @Override
                 public void onClick(DialogInterface dialog, int position) {
                     // Set the account name and type when an item is selected and dismiss the dialog
                     mAccountName = accounts[position].name;
                     mAccountType = accounts[position].type;
                     dialog.dismiss();
                     gotDeviceAccount(handleMessage);
                 }
             });
         mActivity.runOnUiThread(new Runnable() {
             public void run() {
                 builder.show();
             }
         });
     }
     private void gotDeviceAccount(final Runnable handleMessage) {
         // Force the handleMessage runnable and getDefaultGroupId to run on the background thread
         Runnable runnable = new Runnable() {
             @Override
             public void run() {
                 getDefaultGroupId();
                 // Don't log a user's account if not debug mode. Otherwise, just log a message
                 // saying that we got an account to use
                 if (mAccountName == null) {
                     Log.i(LOGTAG, "No device account selected. Leaving account as null.");
                 } else if (DEBUG) {
                     Log.d(LOGTAG, "Using account: " + mAccountName + " (type: " + mAccountType + ")");
                 } else {
                     Log.i(LOGTAG, "Got device account to use for contact operations.");
                 }
                 handleMessage.run();
             }
         };
         ThreadUtils.postToBackgroundThread(runnable);
     }
     private void getDefaultGroupId() {
         Cursor cursor = getAllGroups();
         cursor.moveToPosition(-1);
         while (cursor.moveToNext()) {
             // Check if the account name and type for the group match the account name and type of
             // the account we're working with
             final String groupAccountName = cursor.getString(GROUP_ACCOUNT_NAME);
             if (!groupAccountName.equals(mAccountName)) {
                 continue;
             }
             final String groupAccountType = cursor.getString(GROUP_ACCOUNT_TYPE);
             if (!groupAccountType.equals(mAccountType)) {
                 continue;
             }
             // For all honeycomb and up, the default group is the first one which has the AUTO_ADD flag set
             if (isAutoAddGroup(cursor)) {
                 mGroupTitle = cursor.getString(GROUP_TITLE);
                 mGroupId = cursor.getLong(GROUP_ID);
                 break;
             } else if (PRE_HONEYCOMB_DEFAULT_GROUP.equals(cursor.getString(GROUP_TITLE))) {
                 mGroupId = cursor.getLong(GROUP_ID);
                 mGroupTitle = PRE_HONEYCOMB_DEFAULT_GROUP;
                 break;
             }
         }
         cursor.close();
         if (mGroupId == 0) {
             Log.w(LOGTAG, "Default group ID not found. Newly created contacts will not belong to any groups.");
         } else if (DEBUG) {
             Log.i(LOGTAG, "Using group ID: " + mGroupId + " (" + mGroupTitle + ")");
         }
     }
     private static boolean isAutoAddGroup(Cursor cursor) {
         // For Honeycomb and up, the default group is the first one which has the AUTO_ADD flag set.
         // For everything below Honeycomb, use the default "System Group: My Contacts" group
         return (Build.VERSION.SDK_INT >= 11 && !cursor.isNull(GROUP_AUTO_ADD) &&
                 cursor.getInt(GROUP_AUTO_ADD) != 0);
     }
     private long getGroupId(String groupName) {
         long groupId = -1;
         Cursor cursor = getGroups(Groups.TITLE + " = '" + groupName + "'");
         cursor.moveToPosition(-1);
         while (cursor.moveToNext()) {
             String groupAccountName = cursor.getString(GROUP_ACCOUNT_NAME);
             String groupAccountType = cursor.getString(GROUP_ACCOUNT_TYPE);
             // Check if the account name and type for the group match the account name and type of
             // the account we're working with or the default "Phone" account if no account was found
             if (groupAccountName.equals(mAccountName) && groupAccountType.equals(mAccountType) ||
                 (mAccountName == null && "Phone".equals(groupAccountType))) {
                 if (groupName.equals(cursor.getString(GROUP_TITLE))) {
                     groupId = cursor.getLong(GROUP_ID);
                     break;
                 }
             }
         }
         cursor.close();
         return groupId;
     }
     private String getGroupName(long groupId) {
         Cursor cursor = getGroups(Groups._ID + " = " + groupId);
         if (cursor.getCount() == 0) {
             cursor.close();
             return null;
         }
         cursor.moveToPosition(0);
         String groupName = cursor.getString(cursor.getColumnIndex(Groups.TITLE));
         cursor.close();
         return groupName;
     }
     private Cursor getAllGroups() {
         return getGroups(null);
     }
     private Cursor getGroups(String selectArg) {
         String[] columns = new String[] {
             Groups.ACCOUNT_NAME,
             Groups.ACCOUNT_TYPE,
             Groups._ID,
             Groups.TITLE,
             (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB ? Groups.AUTO_ADD : Groups._ID)
         };
         if (selectArg != null) {
             selectArg = "AND " + selectArg;
         } else {
             selectArg = "";
         }
         return mContentResolver.query(Groups.CONTENT_URI, columns,
                                       Groups.ACCOUNT_TYPE + " NOT NULL AND " +
                                       Groups.ACCOUNT_NAME + " NOT NULL " + selectArg, null, null);
     }
     private long createGroup(String groupName) {
         if (DEBUG) {
             Log.d(LOGTAG, "Creating group: " + groupName);
         }
         ArrayList<ContentProviderOperation> newGroupOptions = new ArrayList<ContentProviderOperation>();
         // Create the group under the account we're using
         // If no account is selected, use a default account name/type for the group
         newGroupOptions.add(ContentProviderOperation.newInsert(Groups.CONTENT_URI)
                                 .withValue(Groups.ACCOUNT_NAME, (mAccountName == null ? "Phone" : mAccountName))
                                 .withValue(Groups.ACCOUNT_TYPE, (mAccountType == null ? "Phone" : mAccountType))
                                 .withValue(Groups.TITLE, groupName)
                                 .withValue(Groups.GROUP_VISIBLE, true)
                                 .build());
         applyBatch(newGroupOptions);
         // Return the ID of the newly created group
         return getGroupId(groupName);
     }
     private long[] getAllRawContactIds() {
         Cursor cursor = getAllRawContactIdsCursor();
         // Put the ids into an array
         long[] ids = new long[cursor.getCount()];
         int index = 0;
         cursor.moveToPosition(-1);
         while(cursor.moveToNext()) {
             ids[index] = cursor.getLong(cursor.getColumnIndex(RawContacts._ID));
             index++;
         }
         cursor.close();
         return ids;
     }
     private Cursor getAllRawContactIdsCursor() {
         // When a contact is deleted, it actually just sets the deleted field to 1 until the
         // sync adapter actually deletes the contact later so ignore any contacts with the deleted
         // flag set
         String selection = RawContacts.DELETED + "=0";
         String[] selectionArgs = null;
         // Only get contacts from the selected account
         if (mAccountName != null) {
             selection += " AND " + RawContacts.ACCOUNT_NAME + "=? AND " + RawContacts.ACCOUNT_TYPE + "=?";
             selectionArgs = new String[] {mAccountName, mAccountType};
         }
         // Get the ID's of all contacts and use the number of contact ID's as
         // the total number of contacts
         return mContentResolver.query(RawContacts.CONTENT_URI, new String[] {RawContacts._ID},
                                       selection, selectionArgs, null);
     }
     private static Long getRawContactIdFromContentProviderResults(ContentProviderResult[] results) throws NumberFormatException {
         for (int i = 0; i < results.length; i++) {
             if (results[i].uri == null) {
                 continue;
             }
             String uri = results[i].uri.toString();
             // Check if the uri is from the raw contacts table
             if (uri.contains("raw_contacts")) {
                 // The ID is the after the final forward slash in the URI
                 return Long.parseLong(uri.substring(uri.lastIndexOf("/") + 1));
             }
         }
         return null;
     }
     private static boolean checkForPositiveCountInResults(ContentProviderResult[] results) {
         for (int i = 0; i < results.length; i++) {
             Integer count = results[i].count;
             if (DEBUG) {
                 Log.d(LOGTAG, "Results count: " + count);
             }
             if (count != null && count > 0) {
                 return true;
             }
         }
         return false;
     }
     private static long[] convertLongListToArray(List<Long> list) {
         long[] array = new long[list.size()];
         for (int i = 0; i < list.size(); i++) {
             array[i] = list.get(i);
         }
         return array;
     }
     private static boolean doesJSONArrayContainString(final JSONArray array, final String value) {
         for (int i = 0; i < array.length(); i++) {
             if (value.equals(array.optString(i))) {
                 return true;
             }
         }
         return false;
     }
     private static int max(int... values) {
         int max = values[0];
         for (int value : values) {
             if (value > max) {
                 max = value;
             }
         }
         return max;
     }
     private static void putPossibleNullValueInJSONObject(final String key, final Object value, JSONObject jsonObject) throws JSONException{
         if (value != null) {
             jsonObject.put(key, value);
         } else {
             jsonObject.put(key, JSONObject.NULL);
         }
     }
     private static String getKeyFromMapValue(final HashMap<String, Integer> map, Integer value) {
         for (Entry<String, Integer> entry : map.entrySet()) {
             if (value == entry.getValue()) {
                 return entry.getKey();
             }
         }
         return null;
     }
     private String getColumnNameConstant(String field) {
         initColumnNameConstantsMap();
         return mColumnNameConstantsMap.get(field.toLowerCase());
     }
     private void initColumnNameConstantsMap() {
         if (mColumnNameConstantsMap != null) {
             return;
         }
         mColumnNameConstantsMap = new HashMap<String, String>();
         mColumnNameConstantsMap.put("name", StructuredName.DISPLAY_NAME);
         mColumnNameConstantsMap.put("givenname", StructuredName.GIVEN_NAME);
         mColumnNameConstantsMap.put("familyname", StructuredName.FAMILY_NAME);
         mColumnNameConstantsMap.put("honorificprefix", StructuredName.PREFIX);
         mColumnNameConstantsMap.put("honorificsuffix", StructuredName.SUFFIX);
         mColumnNameConstantsMap.put("additionalname", CUSTOM_DATA_COLUMN);
         mColumnNameConstantsMap.put("nickname", Nickname.NAME);
         mColumnNameConstantsMap.put("adr", StructuredPostal.STREET);
         mColumnNameConstantsMap.put("email", Email.ADDRESS);
         mColumnNameConstantsMap.put("url", Website.URL);
         mColumnNameConstantsMap.put("category", GroupMembership.GROUP_ROW_ID);
         mColumnNameConstantsMap.put("tel", Phone.NUMBER);
         mColumnNameConstantsMap.put("org", Organization.COMPANY);
         mColumnNameConstantsMap.put("jobTitle", Organization.TITLE);
         mColumnNameConstantsMap.put("note", Note.NOTE);
         mColumnNameConstantsMap.put("impp", Im.DATA);
         mColumnNameConstantsMap.put("sex", CUSTOM_DATA_COLUMN);
         mColumnNameConstantsMap.put("genderidentity", CUSTOM_DATA_COLUMN);
         mColumnNameConstantsMap.put("key", CUSTOM_DATA_COLUMN);
     }
     private String getMimeTypeOfField(String field) {
         initMimeTypeConstantsMap();
         return mMimeTypeConstantsMap.get(field.toLowerCase());
     }
     private void initMimeTypeConstantsMap() {
         if (mMimeTypeConstantsMap != null) {
             return;
         }
         mMimeTypeConstantsMap = new HashMap<String, String>();
         mMimeTypeConstantsMap.put("name", StructuredName.CONTENT_ITEM_TYPE);
         mMimeTypeConstantsMap.put("givenname", StructuredName.CONTENT_ITEM_TYPE);
         mMimeTypeConstantsMap.put("familyname", StructuredName.CONTENT_ITEM_TYPE);
         mMimeTypeConstantsMap.put("honorificprefix", StructuredName.CONTENT_ITEM_TYPE);
         mMimeTypeConstantsMap.put("honorificsuffix", StructuredName.CONTENT_ITEM_TYPE);
         mMimeTypeConstantsMap.put("additionalname", MIMETYPE_ADDITIONAL_NAME);
         mMimeTypeConstantsMap.put("nickname", Nickname.CONTENT_ITEM_TYPE);
         mMimeTypeConstantsMap.put("email", Email.CONTENT_ITEM_TYPE);
         mMimeTypeConstantsMap.put("url", Website.CONTENT_ITEM_TYPE);
         mMimeTypeConstantsMap.put("category", GroupMembership.CONTENT_ITEM_TYPE);
         mMimeTypeConstantsMap.put("tel", Phone.CONTENT_ITEM_TYPE);
         mMimeTypeConstantsMap.put("org", Organization.CONTENT_ITEM_TYPE);
         mMimeTypeConstantsMap.put("jobTitle", Organization.CONTENT_ITEM_TYPE);
         mMimeTypeConstantsMap.put("note", Note.CONTENT_ITEM_TYPE);
         mMimeTypeConstantsMap.put("impp", Im.CONTENT_ITEM_TYPE);
         mMimeTypeConstantsMap.put("sex", MIMETYPE_SEX);
         mMimeTypeConstantsMap.put("genderidentity", MIMETYPE_GENDER_IDENTITY);
         mMimeTypeConstantsMap.put("key", MIMETYPE_KEY);
     }
     private int getAddressType(String addressType) {
         initAddressTypesMap();
         Integer type = mAddressTypesMap.get(addressType.toLowerCase());
         return (type != null ? Integer.valueOf(type) : StructuredPostal.TYPE_CUSTOM);
     }
     private void initAddressTypesMap() {
         if (mAddressTypesMap != null) {
             return;
         }
         mAddressTypesMap = new HashMap<String, Integer>();
         mAddressTypesMap.put("home", StructuredPostal.TYPE_HOME);
         mAddressTypesMap.put("work", StructuredPostal.TYPE_WORK);
     }
     private int getPhoneType(String phoneType) {
         initPhoneTypesMap();
         Integer type = mPhoneTypesMap.get(phoneType.toLowerCase());
         return (type != null ? Integer.valueOf(type) : Phone.TYPE_CUSTOM);
     }
     private void initPhoneTypesMap() {
         if (mPhoneTypesMap != null) {
             return;
         }
         mPhoneTypesMap = new HashMap<String, Integer>();
         mPhoneTypesMap.put("home", Phone.TYPE_HOME);
         mPhoneTypesMap.put("mobile", Phone.TYPE_MOBILE);
         mPhoneTypesMap.put("work", Phone.TYPE_WORK);
         mPhoneTypesMap.put("fax home", Phone.TYPE_FAX_HOME);
         mPhoneTypesMap.put("fax work", Phone.TYPE_FAX_WORK);
         mPhoneTypesMap.put("pager", Phone.TYPE_PAGER);
         mPhoneTypesMap.put("callback", Phone.TYPE_CALLBACK);
         mPhoneTypesMap.put("car", Phone.TYPE_CAR);
         mPhoneTypesMap.put("company main", Phone.TYPE_COMPANY_MAIN);
         mPhoneTypesMap.put("isdn", Phone.TYPE_ISDN);
         mPhoneTypesMap.put("main", Phone.TYPE_MAIN);
         mPhoneTypesMap.put("fax other", Phone.TYPE_OTHER_FAX);
         mPhoneTypesMap.put("other fax", Phone.TYPE_OTHER_FAX);
         mPhoneTypesMap.put("radio", Phone.TYPE_RADIO);
         mPhoneTypesMap.put("telex", Phone.TYPE_TELEX);
         mPhoneTypesMap.put("tty", Phone.TYPE_TTY_TDD);
         mPhoneTypesMap.put("ttd", Phone.TYPE_TTY_TDD);
         mPhoneTypesMap.put("work mobile", Phone.TYPE_WORK_MOBILE);
         mPhoneTypesMap.put("work pager", Phone.TYPE_WORK_PAGER);
         mPhoneTypesMap.put("assistant", Phone.TYPE_ASSISTANT);
         mPhoneTypesMap.put("mms", Phone.TYPE_MMS);
     }
     private int getEmailType(String emailType) {
         initEmailTypesMap();
         Integer type = mEmailTypesMap.get(emailType.toLowerCase());
         return (type != null ? Integer.valueOf(type) : Email.TYPE_CUSTOM);
     }
     private void initEmailTypesMap() {
         if (mEmailTypesMap != null) {
             return;
         }
         mEmailTypesMap = new HashMap<String, Integer>();
         mEmailTypesMap.put("home", Email.TYPE_HOME);
         mEmailTypesMap.put("mobile", Email.TYPE_MOBILE);
         mEmailTypesMap.put("work", Email.TYPE_WORK);
     }
     private int getWebsiteType(String webisteType) {
         initWebsiteTypesMap();
         Integer type = mWebsiteTypesMap.get(webisteType.toLowerCase());
         return (type != null ? Integer.valueOf(type) : Website.TYPE_CUSTOM);
     }
     private void initWebsiteTypesMap() {
         if (mWebsiteTypesMap != null) {
             return;
         }
         mWebsiteTypesMap = new HashMap<String, Integer>();
         mWebsiteTypesMap.put("homepage", Website.TYPE_HOMEPAGE);
         mWebsiteTypesMap.put("blog", Website.TYPE_BLOG);
         mWebsiteTypesMap.put("profile", Website.TYPE_PROFILE);
         mWebsiteTypesMap.put("home", Website.TYPE_HOME);
         mWebsiteTypesMap.put("work", Website.TYPE_WORK);
         mWebsiteTypesMap.put("ftp", Website.TYPE_FTP);
     }
     private int getImType(String imType) {
         initImTypesMap();
         Integer type = mImTypesMap.get(imType.toLowerCase());
         return (type != null ? Integer.valueOf(type) : Im.TYPE_CUSTOM);
     }
     private void initImTypesMap() {
         if (mImTypesMap != null) {
             return;
         }
         mImTypesMap = new HashMap<String, Integer>();
         mImTypesMap.put("home", Im.TYPE_HOME);
         mImTypesMap.put("work", Im.TYPE_WORK);
     }
     private String[] getAllColumns() {
         return new String[] {Entity.DATA_ID, Data.MIMETYPE, Data.IS_SUPER_PRIMARY,
                              Data.DATA1, Data.DATA2, Data.DATA3, Data.DATA4,
                              Data.DATA5, Data.DATA6, Data.DATA7, Data.DATA8,
                              Data.DATA9, Data.DATA10, Data.DATA11, Data.DATA12,
                              Data.DATA13, Data.DATA14, Data.DATA15};
     }
 }

The Tor Browser / annotate

mobile/android/base/ContactService.java@b8a032363ba2 (annotated)

mobile/android/base/ContactService.java