/android/import-contacts : contents of src/am/ed/importcontacts/ContactsContractBackend.java at revision 62

: (revision 62)

To get this branch, use:

bzr branch
http://bzr.ed.am/android/import-contacts

/*
 * ContactsBackend.java
 *
 * Copyright (C) 2012 Tim Marston <tim@ed.am>
 *
 * This file is part of the Import Contacts program (hereafter referred
 * to as "this program"). For more information, see
 * http://ed.am/dev/android/import-contacts
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package am.ed.importcontacts;

import java.util.HashMap;
import java.util.HashSet;

import am.ed.importcontacts.ContactsCache.CacheIdentifier;
import am.ed.importcontacts.Importer.ContactData;
import android.annotation.TargetApi;
import android.app.Activity;
import android.content.ContentUris;
import android.content.ContentValues;
import android.database.Cursor;
import android.net.Uri;
import android.provider.ContactsContract;
import android.provider.ContactsContract.CommonDataKinds;

@TargetApi(5)
public class ContactsContractBackend implements Backend
{
	private Activity _activity = null;
	private HashMap< Long, Long > _aggregate_to_raw_ids = null;

	ContactsContractBackend( Activity activity )
	{
		_activity = activity;
		_aggregate_to_raw_ids = new HashMap< Long, Long >();
	}

	@Override
	public void populateCache( ContactsCache cache )
	{
		Cursor cur;

		// build a set of aggregate contact ids that haven't been added to the
		// cache yet
		HashSet< Long > unadded_ids = new HashSet< Long >();
		cur = _activity.managedQuery( ContactsContract.Contacts.CONTENT_URI,
			new String[] {
				ContactsContract.Contacts._ID,
			}, null, null, null );
		while( cur.moveToNext() ) {
			Long id = cur.getLong(
				cur.getColumnIndex( ContactsContract.Contacts._ID ) );
			unadded_ids.add( id );
		}

		// build a mapping of the ids of raw contacts to the ids of their
		// aggregate contacts
		HashMap< Long, Long > raw_to_aggregate_ids =
			new HashMap< Long, Long >();
		cur = _activity.managedQuery( ContactsContract.RawContacts.CONTENT_URI,
			new String[] {
				ContactsContract.RawContacts._ID,
				ContactsContract.RawContacts.CONTACT_ID,
			}, ContactsContract.RawContacts.DELETED + " != 0", null, null );
		while( cur.moveToNext() ) {
			Long raw_id = cur.getLong(
				cur.getColumnIndex( ContactsContract.RawContacts._ID ) );
			Long id = cur.getLong(
				cur.getColumnIndex( ContactsContract.RawContacts.CONTACT_ID ) );
			raw_to_aggregate_ids.put( raw_id, id );
		}

		// get structured names, primary ones first
		cur = _activity.managedQuery( ContactsContract.Data.CONTENT_URI,
			new String[] {
				ContactsContract.Data.RAW_CONTACT_ID,
				CommonDataKinds.StructuredName.DISPLAY_NAME,
			},
			ContactsContract.Data.MIMETYPE + " = '" +
				CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE + "'",
			null, ContactsContract.Data.IS_PRIMARY + " DESC" );
		while( cur.moveToNext() ) {
			Long raw_id = cur.getLong( cur.getColumnIndex(
				ContactsContract.Data.RAW_CONTACT_ID ) );
			Long id = raw_to_aggregate_ids.get( raw_id );
			String name = ContactsCache.normaliseName(
				cur.getString( cur.getColumnIndex(
					CommonDataKinds.StructuredName.DISPLAY_NAME ) ) );
			if( name != null && id != null )
			{
				// if this is a name for a contact for whom we have not added a
				// lookup, add a lookup for the contact id by name
				if( unadded_ids.contains( id ) ) {
					cache.addLookup( new CacheIdentifier(
						CacheIdentifier.Type.NAME, name ), id );
					unadded_ids.remove( id );
				}
			}
		}

		// get contact organisations, primary ones first
		cur = _activity.managedQuery( ContactsContract.Data.CONTENT_URI,
			new String[] {
				ContactsContract.Data.RAW_CONTACT_ID,
				CommonDataKinds.Organization.COMPANY,
			},
			ContactsContract.Data.MIMETYPE + " = '" +
				CommonDataKinds.Organization.CONTENT_ITEM_TYPE + "'",
			null, ContactsContract.Data.IS_PRIMARY + " DESC" );
		while( cur.moveToNext() ) {
			Long raw_id = cur.getLong( cur.getColumnIndex(
				ContactsContract.Data.RAW_CONTACT_ID ) );
			Long id = raw_to_aggregate_ids.get( raw_id );
			String organisation = ContactsCache.normaliseOrganisation(
				cur.getString( cur.getColumnIndex(
					CommonDataKinds.Organization.COMPANY ) ) );
			if( organisation != null && id != null )
			{
				// if this is an organisation name for a contact for whom we
				// have not added a lookup, add a lookup for the contact id
				// by organisation
				if( unadded_ids.contains( id ) ) {
					cache.addLookup( new CacheIdentifier(
						CacheIdentifier.Type.ORGANISATION, organisation ), id );
					unadded_ids.remove( id );
				}

				// add associated data
				cache.addAssociatedOrganisation( id, organisation );
			}
		}

		// get all phone numbers, primary ones first
		cur = _activity.managedQuery( ContactsContract.Data.CONTENT_URI,
			new String[] {
				ContactsContract.Data.RAW_CONTACT_ID,
				CommonDataKinds.Phone.NUMBER,
			},
			ContactsContract.Data.MIMETYPE + " = '" +
				CommonDataKinds.Phone.CONTENT_ITEM_TYPE + "'",
			null, ContactsContract.Data.IS_PRIMARY + " DESC" );
		while( cur.moveToNext() ) {
			Long raw_id = cur.getLong( cur.getColumnIndex(
				ContactsContract.Data.RAW_CONTACT_ID ) );
			Long id = raw_to_aggregate_ids.get( raw_id );
			String number = ContactsCache.normalisePhoneNumber(
				cur.getString( cur.getColumnIndex(
					CommonDataKinds.Phone.NUMBER ) ) );
			if( number != null && id != null )
			{
				// if this is a number for a contact for whom we have not
				// added a lookup, add a lookup for the contact id by phone
				// number
				if( unadded_ids.contains( id ) ) {
					cache.addLookup( new CacheIdentifier(
						CacheIdentifier.Type.PRIMARY_NUMBER, number ), id );
					unadded_ids.remove( id );
				}

				// add associated data
				cache.addAssociatedNumber( id, number );
			}
		}

		// get all email addresses, primary ones first
		cur = _activity.managedQuery( ContactsContract.Data.CONTENT_URI,
			new String[] {
				ContactsContract.Data.RAW_CONTACT_ID,
				CommonDataKinds.Email.DATA,
			},
			ContactsContract.Data.MIMETYPE + " = '" +
				CommonDataKinds.Email.CONTENT_ITEM_TYPE + "'",
			null, ContactsContract.Data.IS_PRIMARY + " DESC" );
		while( cur.moveToNext() ) {
			Long raw_id = cur.getLong( cur.getColumnIndex(
				ContactsContract.Data.RAW_CONTACT_ID ) );
			Long id = raw_to_aggregate_ids.get( raw_id );
			String email = ContactsCache.normaliseEmailAddress(
				cur.getString( cur.getColumnIndex(
					CommonDataKinds.Email.DATA ) ) );
			if( email != null && id != null )
			{
				// if this is an email address for a contact for whom we have
				// not added a lookup, add a lookup for the contact id by email
				// address
				if( unadded_ids.contains( id ) ) {
					cache.addLookup( new CacheIdentifier(
						CacheIdentifier.Type.PRIMARY_EMAIL, email ), id );
					unadded_ids.remove( id );
				}

				// add associated data
				cache.addAssociatedEmail( id, email );
			}
		}

		// get all postal addresses, primary ones first
		cur = _activity.managedQuery( ContactsContract.Data.CONTENT_URI,
			new String[] {
				ContactsContract.Data.RAW_CONTACT_ID,
				CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS,
			},
			ContactsContract.Data.MIMETYPE + " = '" +
				CommonDataKinds.Organization.CONTENT_ITEM_TYPE + "'",
			null, ContactsContract.Data.IS_PRIMARY + " DESC" );
		while( cur.moveToNext() ) {
			Long raw_id = cur.getLong( cur.getColumnIndex(
				ContactsContract.Data.RAW_CONTACT_ID ) );
			Long id = raw_to_aggregate_ids.get( raw_id );
			String address = ContactsCache.normaliseAddress(
				cur.getString( cur.getColumnIndex(
					CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS ) ) );
			if( address != null && id != null )
			{
				// add associated data
				cache.addAssociatedAddress( id, address );
			}
		}
	}

	@Override
	public void deleteContact( Long id )
	{
		Uri contact_uri = ContentUris.withAppendedId(
			ContactsContract.Contacts.CONTENT_URI, id );
		_activity.getContentResolver().delete( contact_uri, null, null );
	}

	@Override
	public Long addContact( String name ) throws ContactCreationException
	{
		// create raw contact
		ContentValues values = new ContentValues();
		Uri contact_uri = _activity.getContentResolver().insert(
			ContactsContract.RawContacts.CONTENT_URI, values);
		Long raw_id = ContentUris.parseId( contact_uri );
		if( raw_id == 0 ) throw new ContactCreationException();

		// add name data for this raw contact
		if( name != null ) {
			values.put( ContactsContract.Data.RAW_CONTACT_ID, raw_id );
			values.put( ContactsContract.Data.MIMETYPE,
				CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE );
			values.put( CommonDataKinds.StructuredName.DISPLAY_NAME, name );
			_activity.getContentResolver().insert(
				ContactsContract.Data.CONTENT_URI, values );
		}

		// find corresponding aggregate contact
		contact_uri = Uri.withAppendedPath(
			ContentUris.withAppendedId(
				ContactsContract.RawContacts.CONTENT_URI, raw_id ),
			ContactsContract.RawContacts.Entity.CONTENT_DIRECTORY );
		Cursor cur = _activity.managedQuery( contact_uri,
			new String[] {
				ContactsContract.RawContacts.CONTACT_ID,
			}, null, null, null );
		Long id = null;
		if( cur.moveToNext() )
			id = cur.getLong(
				cur.getColumnIndex( ContactsContract.RawContacts.CONTACT_ID ) );
		if( id == null || id == 0 )
		{
			// we didn't find an aggregate contact id, so try to clean up (by
			// deleting the raw contact we just created) before bailing
			contact_uri = ContentUris.withAppendedId(
				ContactsContract.RawContacts.CONTENT_URI, id );
			_activity.getContentResolver().delete( contact_uri, null, null );

			throw new ContactCreationException();
		}

		return id;
	}

	/**
	 * Obtain the raw contact id for the phone-only raw contact that is
	 * associated with the aggregate contact id.  One will be created if
	 * necessary.
	 * @param id the aggregate contact id
	 * @return the raw contact id
	 * @throws ContactCreationException
	 */
	Long obtainRawContact( Long id ) throws ContactCreationException
	{
		// attempt to lookup cached value
		Long raw_id = _aggregate_to_raw_ids.get( id );
		if( raw_id != null ) return raw_id;

		// find a corresponding raw contact that has no account name/type
		Cursor cur = _activity.managedQuery(
			ContactsContract.RawContacts.CONTENT_URI,
			new String[] {
				ContactsContract.RawContacts._ID,
			},
			ContactsContract.RawContacts.DELETED + " != 0 AND " +
				"IFNULL( " + ContactsContract.RawContacts.ACCOUNT_NAME +
					", '' ) = '' AND " +
				"IFNULL( " + ContactsContract.RawContacts.ACCOUNT_TYPE +
					", '' ) = ''",
			null, null );
		if( cur.moveToNext() )
			raw_id = cur.getLong(
				cur.getColumnIndex( ContactsContract.RawContacts._ID ) );

		// if one wasn't found, we'll need to create one
		if( raw_id == null ) {
			ContentValues values = new ContentValues();
			Uri contact_uri = _activity.getContentResolver().insert(
				ContactsContract.RawContacts.CONTENT_URI, values);
			raw_id = ContentUris.parseId( contact_uri );
			if( raw_id == 0 ) throw new ContactCreationException();
		}

		// save value in our cache
		_aggregate_to_raw_ids.put( id, raw_id );
		return raw_id;
	}

	private int convertTypeToBackendType( Class< ? > cls, int type )
		throws ContactCreationException
	{
		if( cls == CommonDataKinds.Phone.class )
		{
			switch( type )
			{
			case ContactData.TYPE_HOME:
				return CommonDataKinds.Phone.TYPE_HOME;
			case ContactData.TYPE_WORK:
				return CommonDataKinds.Phone.TYPE_WORK;
			case ContactData.TYPE_MOBILE:
				return CommonDataKinds.Phone.TYPE_MOBILE;
			case ContactData.TYPE_FAX_HOME:
				return CommonDataKinds.Phone.TYPE_FAX_HOME;
			case ContactData.TYPE_FAX_WORK:
				return CommonDataKinds.Phone.TYPE_FAX_WORK;
			case ContactData.TYPE_PAGER:
				return CommonDataKinds.Phone.TYPE_PAGER;
			}
		}
		else if( cls == CommonDataKinds.Email.class )
		{
			switch( type )
			{
			case ContactData.TYPE_HOME:
				return CommonDataKinds.Email.TYPE_HOME;
			case ContactData.TYPE_WORK:
				return CommonDataKinds.Email.TYPE_WORK;
			}
		}
		else if( cls == CommonDataKinds.StructuredPostal.class )
		{
			switch( type )
			{
			case ContactData.TYPE_HOME:
				return CommonDataKinds.StructuredPostal.TYPE_HOME;
			case ContactData.TYPE_WORK:
				return CommonDataKinds.StructuredPostal.TYPE_WORK;
			}
		}

		// still here?
		throw new ContactCreationException();
	}

	@Override
	public void addContactPhone( Long id, String number,
		ContactData.PreferredDetail data ) throws ContactCreationException
	{
		ContentValues values = new ContentValues();
		values.put( ContactsContract.Data.RAW_CONTACT_ID,
			obtainRawContact( id ) );
		values.put( ContactsContract.Data.MIMETYPE,
			CommonDataKinds.Phone.CONTENT_ITEM_TYPE );
		values.put( CommonDataKinds.Phone.TYPE,
			convertTypeToBackendType( CommonDataKinds.Phone.class,
				data.getType() ) );
		values.put( CommonDataKinds.Phone.NUMBER, number );
		if( data.isPreferred() )
			values.put( CommonDataKinds.Phone.IS_PRIMARY, 1 );

		_activity.getContentResolver().insert(
			ContactsContract.Data.CONTENT_URI, values );
	}

	@Override
	public void addContactEmail( Long id, String email,
		ContactData.PreferredDetail data ) throws ContactCreationException
	{
		ContentValues values = new ContentValues();
		values.put( ContactsContract.Data.RAW_CONTACT_ID,
			obtainRawContact( id ) );
		values.put( ContactsContract.Data.MIMETYPE,
			CommonDataKinds.Email.CONTENT_ITEM_TYPE );
		values.put( CommonDataKinds.Email.TYPE,
			convertTypeToBackendType( CommonDataKinds.Email.class,
				data.getType() ) );
		values.put( CommonDataKinds.Email.DATA, email );
		if( data.isPreferred() )
			values.put( CommonDataKinds.Email.IS_PRIMARY, 1 );

		_activity.getContentResolver().insert(
			ContactsContract.Data.CONTENT_URI, values );
	}

	@Override
	public void addContactAddresses( Long id, String address,
		ContactData.TypeDetail data ) throws ContactCreationException
	{
		ContentValues values = new ContentValues();
		values.put( ContactsContract.Data.RAW_CONTACT_ID,
			obtainRawContact( id ) );
		values.put( ContactsContract.Data.MIMETYPE,
			CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE );
		values.put( CommonDataKinds.StructuredPostal.TYPE,
			convertTypeToBackendType( CommonDataKinds.StructuredPostal.class,
				data.getType() ) );
		values.put(
			CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS, address );

		_activity.getContentResolver().insert(
			ContactsContract.Data.CONTENT_URI, values );
	}

	@Override
	public void addContactOrganisation( Long id, String organisation,
		ContactData.ExtraDetail data ) throws ContactCreationException
	{
		ContentValues values = new ContentValues();
		values.put( ContactsContract.Data.RAW_CONTACT_ID,
			obtainRawContact( id ) );
		values.put( ContactsContract.Data.MIMETYPE,
			CommonDataKinds.Organization.CONTENT_ITEM_TYPE );
		values.put( CommonDataKinds.Organization.TYPE,
			CommonDataKinds.Organization.TYPE_WORK );
		values.put(
			CommonDataKinds.Organization.COMPANY, organisation );
		if( data.getExtra() != null )
			values.put( CommonDataKinds.Organization.TITLE, data.getExtra() );

		_activity.getContentResolver().insert(
			ContactsContract.Data.CONTENT_URI, values );
	}
}

62 by edam added preliminary (buggy) ContactsContract backend	1	/*
	2	* ContactsBackend.java
	3	*
	4	* Copyright (C) 2012 Tim Marston <tim@ed.am>
	5	*
	6	* This file is part of the Import Contacts program (hereafter referred
	7	* to as "this program"). For more information, see
	8	* http://ed.am/dev/android/import-contacts
	9	*
	10	* This program is free software: you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation, either version 3 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	22	*/
	23
	24	package am.ed.importcontacts;
	25
	26	import java.util.HashMap;
	27	import java.util.HashSet;
	28
	29	import am.ed.importcontacts.ContactsCache.CacheIdentifier;
	30	import am.ed.importcontacts.Importer.ContactData;
	31	import android.annotation.TargetApi;
	32	import android.app.Activity;
	33	import android.content.ContentUris;
	34	import android.content.ContentValues;
	35	import android.database.Cursor;
	36	import android.net.Uri;
	37	import android.provider.ContactsContract;
	38	import android.provider.ContactsContract.CommonDataKinds;
	39
	40	@TargetApi(5)
	41	public class ContactsContractBackend implements Backend
	42	{
	43	private Activity _activity = null;
	44	private HashMap< Long, Long > _aggregate_to_raw_ids = null;
	45
	46	ContactsContractBackend( Activity activity )
	47	{
	48	_activity = activity;
	49	_aggregate_to_raw_ids = new HashMap< Long, Long >();
	50	}
	51
	52	@Override
	53	public void populateCache( ContactsCache cache )
	54	{
	55	Cursor cur;
	56
	57	// build a set of aggregate contact ids that haven't been added to the
	58	// cache yet
	59	HashSet< Long > unadded_ids = new HashSet< Long >();
	60	cur = _activity.managedQuery( ContactsContract.Contacts.CONTENT_URI,
	61	new String[] {
	62	ContactsContract.Contacts._ID,
	63	}, null, null, null );
	64	while( cur.moveToNext() ) {
65	Long id = cur.getLong(
66	cur.getColumnIndex( ContactsContract.Contacts._ID ) );
67	unadded_ids.add( id );
68	}
69
70	// build a mapping of the ids of raw contacts to the ids of their
71	// aggregate contacts
72	HashMap< Long, Long > raw_to_aggregate_ids =
73	new HashMap< Long, Long >();
74	cur = _activity.managedQuery( ContactsContract.RawContacts.CONTENT_URI,
75	new String[] {
76	ContactsContract.RawContacts._ID,
77	ContactsContract.RawContacts.CONTACT_ID,
78	}, ContactsContract.RawContacts.DELETED + " != 0", null, null );
79	while( cur.moveToNext() ) {
80	Long raw_id = cur.getLong(
81	cur.getColumnIndex( ContactsContract.RawContacts._ID ) );
82	Long id = cur.getLong(
83	cur.getColumnIndex( ContactsContract.RawContacts.CONTACT_ID ) );
84	raw_to_aggregate_ids.put( raw_id, id );
85	}
86
87	// get structured names, primary ones first
88	cur = _activity.managedQuery( ContactsContract.Data.CONTENT_URI,
89	new String[] {
90	ContactsContract.Data.RAW_CONTACT_ID,
91	CommonDataKinds.StructuredName.DISPLAY_NAME,
92	},
93	ContactsContract.Data.MIMETYPE + " = '" +
94	CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE + "'",
95	null, ContactsContract.Data.IS_PRIMARY + " DESC" );
96	while( cur.moveToNext() ) {
97	Long raw_id = cur.getLong( cur.getColumnIndex(
98	ContactsContract.Data.RAW_CONTACT_ID ) );
99	Long id = raw_to_aggregate_ids.get( raw_id );
100	String name = ContactsCache.normaliseName(
101	cur.getString( cur.getColumnIndex(
102	CommonDataKinds.StructuredName.DISPLAY_NAME ) ) );
103	if( name != null && id != null )
104	{
105	// if this is a name for a contact for whom we have not added a
106	// lookup, add a lookup for the contact id by name
107	if( unadded_ids.contains( id ) ) {
108	cache.addLookup( new CacheIdentifier(
109	CacheIdentifier.Type.NAME, name ), id );
110	unadded_ids.remove( id );
111	}
112	}
113	}
114
115	// get contact organisations, primary ones first
116	cur = _activity.managedQuery( ContactsContract.Data.CONTENT_URI,
117	new String[] {
118	ContactsContract.Data.RAW_CONTACT_ID,
119	CommonDataKinds.Organization.COMPANY,
120	},
121	ContactsContract.Data.MIMETYPE + " = '" +
122	CommonDataKinds.Organization.CONTENT_ITEM_TYPE + "'",
123	null, ContactsContract.Data.IS_PRIMARY + " DESC" );
124	while( cur.moveToNext() ) {
125	Long raw_id = cur.getLong( cur.getColumnIndex(
126	ContactsContract.Data.RAW_CONTACT_ID ) );
127	Long id = raw_to_aggregate_ids.get( raw_id );
128	String organisation = ContactsCache.normaliseOrganisation(
129	cur.getString( cur.getColumnIndex(
130	CommonDataKinds.Organization.COMPANY ) ) );
131	if( organisation != null && id != null )
132	{
133	// if this is an organisation name for a contact for whom we
134	// have not added a lookup, add a lookup for the contact id
135	// by organisation
136	if( unadded_ids.contains( id ) ) {
137	cache.addLookup( new CacheIdentifier(
138	CacheIdentifier.Type.ORGANISATION, organisation ), id );
139	unadded_ids.remove( id );
140	}
141
142	// add associated data
143	cache.addAssociatedOrganisation( id, organisation );
144	}
145	}
146
147	// get all phone numbers, primary ones first
148	cur = _activity.managedQuery( ContactsContract.Data.CONTENT_URI,
149	new String[] {
150	ContactsContract.Data.RAW_CONTACT_ID,
151	CommonDataKinds.Phone.NUMBER,
152	},
153	ContactsContract.Data.MIMETYPE + " = '" +
154	CommonDataKinds.Phone.CONTENT_ITEM_TYPE + "'",
155	null, ContactsContract.Data.IS_PRIMARY + " DESC" );
156	while( cur.moveToNext() ) {
157	Long raw_id = cur.getLong( cur.getColumnIndex(
158	ContactsContract.Data.RAW_CONTACT_ID ) );
159	Long id = raw_to_aggregate_ids.get( raw_id );
160	String number = ContactsCache.normalisePhoneNumber(
161	cur.getString( cur.getColumnIndex(
162	CommonDataKinds.Phone.NUMBER ) ) );
163	if( number != null && id != null )
164	{
165	// if this is a number for a contact for whom we have not
166	// added a lookup, add a lookup for the contact id by phone
167	// number
168	if( unadded_ids.contains( id ) ) {
169	cache.addLookup( new CacheIdentifier(
170	CacheIdentifier.Type.PRIMARY_NUMBER, number ), id );
171	unadded_ids.remove( id );
172	}
173
174	// add associated data
175	cache.addAssociatedNumber( id, number );
176	}
177	}
178
179	// get all email addresses, primary ones first
180	cur = _activity.managedQuery( ContactsContract.Data.CONTENT_URI,
181	new String[] {
182	ContactsContract.Data.RAW_CONTACT_ID,
183	CommonDataKinds.Email.DATA,
184	},
185	ContactsContract.Data.MIMETYPE + " = '" +
186	CommonDataKinds.Email.CONTENT_ITEM_TYPE + "'",
187	null, ContactsContract.Data.IS_PRIMARY + " DESC" );
188	while( cur.moveToNext() ) {
189	Long raw_id = cur.getLong( cur.getColumnIndex(
190	ContactsContract.Data.RAW_CONTACT_ID ) );
191	Long id = raw_to_aggregate_ids.get( raw_id );
192	String email = ContactsCache.normaliseEmailAddress(
193	cur.getString( cur.getColumnIndex(
194	CommonDataKinds.Email.DATA ) ) );
195	if( email != null && id != null )
196	{
197	// if this is an email address for a contact for whom we have
198	// not added a lookup, add a lookup for the contact id by email
199	// address
200	if( unadded_ids.contains( id ) ) {
201	cache.addLookup( new CacheIdentifier(
202	CacheIdentifier.Type.PRIMARY_EMAIL, email ), id );
203	unadded_ids.remove( id );
204	}
205
206	// add associated data
207	cache.addAssociatedEmail( id, email );
208	}
209	}
210
211	// get all postal addresses, primary ones first
212	cur = _activity.managedQuery( ContactsContract.Data.CONTENT_URI,
213	new String[] {
214	ContactsContract.Data.RAW_CONTACT_ID,
215	CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS,
216	},
217	ContactsContract.Data.MIMETYPE + " = '" +
218	CommonDataKinds.Organization.CONTENT_ITEM_TYPE + "'",
219	null, ContactsContract.Data.IS_PRIMARY + " DESC" );
220	while( cur.moveToNext() ) {
221	Long raw_id = cur.getLong( cur.getColumnIndex(
222	ContactsContract.Data.RAW_CONTACT_ID ) );
223	Long id = raw_to_aggregate_ids.get( raw_id );
224	String address = ContactsCache.normaliseAddress(
225	cur.getString( cur.getColumnIndex(
226	CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS ) ) );
227	if( address != null && id != null )
228	{
229	// add associated data
230	cache.addAssociatedAddress( id, address );
231	}
232	}
233	}
234
235	@Override
236	public void deleteContact( Long id )
237	{
238	Uri contact_uri = ContentUris.withAppendedId(
239	ContactsContract.Contacts.CONTENT_URI, id );
240	_activity.getContentResolver().delete( contact_uri, null, null );
241	}
242
243	@Override
244	public Long addContact( String name ) throws ContactCreationException
245	{
246	// create raw contact
247	ContentValues values = new ContentValues();
248	Uri contact_uri = _activity.getContentResolver().insert(
249	ContactsContract.RawContacts.CONTENT_URI, values);
250	Long raw_id = ContentUris.parseId( contact_uri );
251	if( raw_id == 0 ) throw new ContactCreationException();
252
253	// add name data for this raw contact
254	if( name != null ) {
255	values.put( ContactsContract.Data.RAW_CONTACT_ID, raw_id );
256	values.put( ContactsContract.Data.MIMETYPE,
257	CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE );
258	values.put( CommonDataKinds.StructuredName.DISPLAY_NAME, name );
259	_activity.getContentResolver().insert(
260	ContactsContract.Data.CONTENT_URI, values );
261	}
262
263	// find corresponding aggregate contact
264	contact_uri = Uri.withAppendedPath(
265	ContentUris.withAppendedId(
266	ContactsContract.RawContacts.CONTENT_URI, raw_id ),
267	ContactsContract.RawContacts.Entity.CONTENT_DIRECTORY );
268	Cursor cur = _activity.managedQuery( contact_uri,
269	new String[] {
270	ContactsContract.RawContacts.CONTACT_ID,
271	}, null, null, null );
272	Long id = null;
273	if( cur.moveToNext() )
274	id = cur.getLong(
275	cur.getColumnIndex( ContactsContract.RawContacts.CONTACT_ID ) );
276	if( id == null \|\| id == 0 )
277	{
278	// we didn't find an aggregate contact id, so try to clean up (by
279	// deleting the raw contact we just created) before bailing
280	contact_uri = ContentUris.withAppendedId(
281	ContactsContract.RawContacts.CONTENT_URI, id );
282	_activity.getContentResolver().delete( contact_uri, null, null );
283
284	throw new ContactCreationException();
285	}
286
287	return id;
288	}
289
290	/**
291	* Obtain the raw contact id for the phone-only raw contact that is
292	* associated with the aggregate contact id. One will be created if
293	* necessary.
294	* @param id the aggregate contact id
295	* @return the raw contact id
296	* @throws ContactCreationException
297	*/
298	Long obtainRawContact( Long id ) throws ContactCreationException
299	{
300	// attempt to lookup cached value
301	Long raw_id = _aggregate_to_raw_ids.get( id );
302	if( raw_id != null ) return raw_id;
303
304	// find a corresponding raw contact that has no account name/type
305	Cursor cur = _activity.managedQuery(
306	ContactsContract.RawContacts.CONTENT_URI,
307	new String[] {
308	ContactsContract.RawContacts._ID,
309	},
310	ContactsContract.RawContacts.DELETED + " != 0 AND " +
311	"IFNULL( " + ContactsContract.RawContacts.ACCOUNT_NAME +
312	", '' ) = '' AND " +
313	"IFNULL( " + ContactsContract.RawContacts.ACCOUNT_TYPE +
314	", '' ) = ''",
315	null, null );
316	if( cur.moveToNext() )
317	raw_id = cur.getLong(
318	cur.getColumnIndex( ContactsContract.RawContacts._ID ) );
319
320	// if one wasn't found, we'll need to create one
321	if( raw_id == null ) {
322	ContentValues values = new ContentValues();
323	Uri contact_uri = _activity.getContentResolver().insert(
324	ContactsContract.RawContacts.CONTENT_URI, values);
325	raw_id = ContentUris.parseId( contact_uri );
326	if( raw_id == 0 ) throw new ContactCreationException();
327	}
328
329	// save value in our cache
330	_aggregate_to_raw_ids.put( id, raw_id );
331	return raw_id;
332	}
333
334	private int convertTypeToBackendType( Class< ? > cls, int type )
335	throws ContactCreationException
336	{
337	if( cls == CommonDataKinds.Phone.class )
338	{
339	switch( type )
340	{
341	case ContactData.TYPE_HOME:
342	return CommonDataKinds.Phone.TYPE_HOME;
343	case ContactData.TYPE_WORK:
344	return CommonDataKinds.Phone.TYPE_WORK;
345	case ContactData.TYPE_MOBILE:
346	return CommonDataKinds.Phone.TYPE_MOBILE;
347	case ContactData.TYPE_FAX_HOME:
348	return CommonDataKinds.Phone.TYPE_FAX_HOME;
349	case ContactData.TYPE_FAX_WORK:
350	return CommonDataKinds.Phone.TYPE_FAX_WORK;
351	case ContactData.TYPE_PAGER:
352	return CommonDataKinds.Phone.TYPE_PAGER;
353	}
354	}
355	else if( cls == CommonDataKinds.Email.class )
356	{
357	switch( type )
358	{
359	case ContactData.TYPE_HOME:
360	return CommonDataKinds.Email.TYPE_HOME;
361	case ContactData.TYPE_WORK:
362	return CommonDataKinds.Email.TYPE_WORK;
363	}
364	}
365	else if( cls == CommonDataKinds.StructuredPostal.class )
366	{
367	switch( type )
368	{
369	case ContactData.TYPE_HOME:
370	return CommonDataKinds.StructuredPostal.TYPE_HOME;
371	case ContactData.TYPE_WORK:
372	return CommonDataKinds.StructuredPostal.TYPE_WORK;
373	}
374	}
375
376	// still here?
377	throw new ContactCreationException();
378	}
379
380	@Override
381	public void addContactPhone( Long id, String number,
382	ContactData.PreferredDetail data ) throws ContactCreationException
383	{
384	ContentValues values = new ContentValues();
385	values.put( ContactsContract.Data.RAW_CONTACT_ID,
386	obtainRawContact( id ) );
387	values.put( ContactsContract.Data.MIMETYPE,
388	CommonDataKinds.Phone.CONTENT_ITEM_TYPE );
389	values.put( CommonDataKinds.Phone.TYPE,
390	convertTypeToBackendType( CommonDataKinds.Phone.class,
391	data.getType() ) );
392	values.put( CommonDataKinds.Phone.NUMBER, number );
393	if( data.isPreferred() )
394	values.put( CommonDataKinds.Phone.IS_PRIMARY, 1 );
395
396	_activity.getContentResolver().insert(
397	ContactsContract.Data.CONTENT_URI, values );
398	}
399
400	@Override
401	public void addContactEmail( Long id, String email,
402	ContactData.PreferredDetail data ) throws ContactCreationException
403	{
404	ContentValues values = new ContentValues();
405	values.put( ContactsContract.Data.RAW_CONTACT_ID,
406	obtainRawContact( id ) );
407	values.put( ContactsContract.Data.MIMETYPE,
408	CommonDataKinds.Email.CONTENT_ITEM_TYPE );
409	values.put( CommonDataKinds.Email.TYPE,
410	convertTypeToBackendType( CommonDataKinds.Email.class,
411	data.getType() ) );
412	values.put( CommonDataKinds.Email.DATA, email );
413	if( data.isPreferred() )
414	values.put( CommonDataKinds.Email.IS_PRIMARY, 1 );
415
416	_activity.getContentResolver().insert(
417	ContactsContract.Data.CONTENT_URI, values );
418	}
419
420	@Override
421	public void addContactAddresses( Long id, String address,
422	ContactData.TypeDetail data ) throws ContactCreationException
423	{
424	ContentValues values = new ContentValues();
425	values.put( ContactsContract.Data.RAW_CONTACT_ID,
426	obtainRawContact( id ) );
427	values.put( ContactsContract.Data.MIMETYPE,
428	CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE );
429	values.put( CommonDataKinds.StructuredPostal.TYPE,
430	convertTypeToBackendType( CommonDataKinds.StructuredPostal.class,
431	data.getType() ) );
432	values.put(
433	CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS, address );
434
435	_activity.getContentResolver().insert(
436	ContactsContract.Data.CONTENT_URI, values );
437	}
438
439	@Override
440	public void addContactOrganisation( Long id, String organisation,
441	ContactData.ExtraDetail data ) throws ContactCreationException
442	{
443	ContentValues values = new ContentValues();
444	values.put( ContactsContract.Data.RAW_CONTACT_ID,
445	obtainRawContact( id ) );
446	values.put( ContactsContract.Data.MIMETYPE,
447	CommonDataKinds.Organization.CONTENT_ITEM_TYPE );
448	values.put( CommonDataKinds.Organization.TYPE,
449	CommonDataKinds.Organization.TYPE_WORK );
450	values.put(
451	CommonDataKinds.Organization.COMPANY, organisation );
452	if( data.getExtra() != null )
453	values.put( CommonDataKinds.Organization.TITLE, data.getExtra() );
454
455	_activity.getContentResolver().insert(
456	ContactsContract.Data.CONTENT_URI, values );
457	}
458	}