(root)/android/import-contacts
» Revision
65
(compared to revision 52)
: src/am/ed/importcontacts/ContactsCache.java
To get this branch, use:
bzr branch
http://bzr.ed.am/android/import-contacts
« back to all changes in this revision
Viewing changes to src/am/ed/importcontacts/ContactsCache.java
- browse files at revision 65
- compare with another revision
- download diff
- download tarball
- view history from revision 65
- Committer: edam
- Date: 2012-12-20 16:49:39 UTC
- Revision ID: tim@ed.am-20121220164939-j9mg98v0uofws7kw
added support for notes; rewrote backends so that all normalising of data is now done within the contacts cache; made the vCard unescape routine slightly more acceptant of non-standard escaped characters
- files added:
- src/am/ed/importcontacts/Backend.java
- files modified:
- .project
added
removed
src/am/ed/importcontacts/ContactsCache.java
1
1
/*
2
2
* ContactsCache.java
3
3
*
4
* Copyright (C) 2011 Tim Marston <tim@ed.am>
4
* Copyright (C) 2011 to 2012 Tim Marston <tim@ed.am>
5
5
*
6
6
* This file is part of the Import Contacts program (hereafter referred
7
7
* to as "this program"). For more information, see
25
25
26
26
import java.util.HashMap;
27
27
import java.util.HashSet;
28
29
import am.ed.importcontacts.Importer.AbortImportException;
30
31
import android.app.Activity;
32
import android.database.Cursor;
33
import android.provider.Contacts;
34
28
import java.util.Locale;
35
29
36
30
public class ContactsCache
37
31
{
38
32
/**
39
* Information that can be used to identify a contact within the cache
33
* A thing that can be used to identify (or lookup) a contact within the
34
* contacts cache. It is not a reference to a cache entry and may not
35
* identify an existing contact in the cache.
40
36
*/
41
static public class CacheIdentifier
37
public static class CacheIdentifier
42
38
{
43
39
public enum Type {
44
40
NONE, NAME, ORGANISATION, PRIMARY_NUMBER, PRIMARY_EMAIL }
51
47
_type = Type.NONE;
52
48
}
53
49
50
/**
51
* Obtain a cache identifier. This routine is designed to be as robust
52
* as possible (in terms of bad or null detail values), and to return
53
* null when a cache identifier can not be created.
54
* @param type the detail type
55
* @param detail the detail
56
* @return the cache identifier, or null
57
*/
58
public static CacheIdentifier factory( Type type, String detail )
59
{
60
switch( type )
61
{
62
case NAME: detail = normaliseName( detail ); break;
63
case ORGANISATION: detail = normaliseOrganisation( detail ); break;
64
case PRIMARY_NUMBER: detail = normalisePhoneNumber( detail ); break;
65
case PRIMARY_EMAIL: detail = normaliseEmailAddress( detail ); break;
66
default: return null;
67
}
68
if( detail == null ) return null;
69
return new CacheIdentifier( type, detail );
70
}
71
72
/**
73
* Obtain a cache identifier from contact data. This routine is
74
* designed to be as robust as possible and may return null when a cache
75
* identifier can not be created.
76
* @param contact the contact data
77
* @return the cache identifier, or null
78
*/
79
public static CacheIdentifier factory( Importer.ContactData contact )
80
{
81
CacheIdentifier ret = null;
82
83
if( contact.hasName() )
84
ret = factory( CacheIdentifier.Type.NAME,
85
contact.getName() );
86
if( ret == null && contact.hasPrimaryOrganisation() )
87
ret = factory( CacheIdentifier.Type.ORGANISATION,
88
contact.getPrimaryOrganisation() );
89
if( ret == null && contact.hasPrimaryNumber() )
90
ret = factory( CacheIdentifier.Type.PRIMARY_NUMBER,
91
contact.getPrimaryNumber() );
92
if( ret == null && contact.hasPrimaryEmail() )
93
ret = factory( CacheIdentifier.Type.PRIMARY_EMAIL,
94
contact.getPrimaryEmail() );
95
96
return ret;
97
}
98
54
99
protected CacheIdentifier( Type type, String detail )
55
100
{
56
101
_type = type;
69
114
}
70
115
71
116
// mappings of contact names, organisations and primary numbers to ids
72
private HashMap< String, Long > _contactsByName;
73
private HashMap< String, Long > _contactsByOrg;
74
private HashMap< String, Long > _contactsByNumber;
75
private HashMap< String, Long > _contactsByEmail;
117
private HashMap< String, Long > _contactsByName
118
= new HashMap< String, Long >();
119
private HashMap< String, Long > _contactsByOrg
120
= new HashMap< String, Long >();
121
private HashMap< String, Long > _contactsByNumber
122
= new HashMap< String, Long >();
123
private HashMap< String, Long > _contactsByEmail
124
= new HashMap< String, Long >();
76
125
77
126
// mapping of contact ids to sets of associated data
78
private HashMap< Long, HashSet< String > > _contactNumbers;
79
private HashMap< Long, HashSet< String > > _contactEmails;
80
private HashMap< Long, HashSet< String > > _contactAddresses;
81
private HashMap< Long, HashSet< String > > _contactOrganisations;
82
83
public static CacheIdentifier createIdentifier(
84
Importer.ContactData contact )
85
{
86
if( contact.hasName() ) {
87
String name = normaliseName( contact.getName() );
88
if( name != null )
89
return new CacheIdentifier(
90
CacheIdentifier.Type.NAME, name );
91
}
92
93
if( contact.hasPrimaryOrganisation() ) {
94
String organisation = normaliseOrganisation(
95
contact.getPrimaryOrganisation() );
96
if( organisation != null )
97
return new CacheIdentifier(
98
CacheIdentifier.Type.ORGANISATION, organisation );
99
}
100
101
if( contact.hasPrimaryNumber() ) {
102
String number = normalisePhoneNumber( contact.getPrimaryNumber() );
103
if( number != null )
104
return new CacheIdentifier(
105
CacheIdentifier.Type.PRIMARY_NUMBER, number );
106
}
107
108
if( contact.hasPrimaryEmail() ) {
109
String email = normaliseEmailAddress( contact.getPrimaryEmail() );
110
if( email != null )
111
return new CacheIdentifier(
112
CacheIdentifier.Type.PRIMARY_EMAIL, email );
113
}
114
115
return null;
116
}
127
private HashMap< Long, HashSet< String > > _contactNumbers
128
= new HashMap< Long, HashSet< String > >();
129
private HashMap< Long, HashSet< String > > _contactEmails
130
= new HashMap< Long, HashSet< String > >();
131
private HashMap< Long, HashSet< String > > _contactAddresses
132
= new HashMap< Long, HashSet< String > >();
133
private HashMap< Long, HashSet< String > > _contactOrganisations
134
= new HashMap< Long, HashSet< String > >();
135
private HashMap< Long, HashSet< String > > _contactNotes
136
= new HashMap< Long, HashSet< String > >();
117
137
118
138
public boolean canLookup( CacheIdentifier identifier )
119
139
{
120
140
return lookup( identifier ) != null;
121
141
}
122
142
143
/**
144
* Retrieve the contact id of a contact identified by the specified cache
145
* identifier, if it exists.
146
* @param identifier the cache identifier
147
* @return a contact id, or null
148
*/
123
149
public Long lookup( CacheIdentifier identifier )
124
150
{
125
151
switch( identifier.getType() )
136
162
return null;
137
163
}
138
164
165
/**
166
* Remove any cache entry that is identified by the cache identifier.
167
* @param identifier the cache identifier
168
* @return the contact id of the contact that was removed, or null
169
*/
139
170
public Long removeLookup( CacheIdentifier identifier )
140
171
{
141
172
switch( identifier.getType() )
152
183
return null;
153
184
}
154
185
186
/**
187
* Add a lookup from a contact identifier to a contact id to the cache.
188
* @param identifier the cache identifier
189
* @param id teh contact id
190
*/
155
191
public void addLookup( CacheIdentifier identifier, Long id )
156
192
{
157
193
switch( identifier.getType() )
171
207
}
172
208
}
173
209
210
/**
211
* Remove any data that is associated with an contact id.
212
* @param id
213
*/
174
214
public void removeAssociatedData( Long id )
175
215
{
176
216
_contactNumbers.remove( id );
177
217
_contactEmails.remove( id );
178
218
_contactAddresses.remove( id );
179
219
_contactOrganisations.remove( id );
220
_contactNotes.remove( id );
180
221
}
181
222
182
223
public boolean hasAssociatedNumber( Long id, String number )
198
239
set = new HashSet< String >();
199
240
_contactNumbers.put( id, set );
200
241
}
201
set.add( normalisePhoneNumber( number ) );
242
set.add( number );
202
243
}
203
244
204
245
public boolean hasAssociatedEmail( Long id, String email )
207
248
if( email == null ) return false;
208
249
209
250
HashSet< String > set = _contactEmails.get( id );
210
return set != null && set.contains( normaliseEmailAddress( email ) );
251
return set != null && set.contains( email );
211
252
}
212
253
213
254
public void addAssociatedEmail( Long id, String email )
220
261
set = new HashSet< String >();
221
262
_contactEmails.put( id, set );
222
263
}
223
set.add( normaliseEmailAddress( email ) );
264
set.add( email );
224
265
}
225
266
226
267
public boolean hasAssociatedAddress( Long id, String address )
229
270
if( address == null ) return false;
230
271
231
272
HashSet< String > set = _contactAddresses.get( id );
232
return set != null && set.contains( normaliseAddress( address ) );
273
return set != null && set.contains( address );
233
274
}
234
275
235
276
public void addAssociatedAddress( Long id, String address )
242
283
set = new HashSet< String >();
243
284
_contactAddresses.put( id, set );
244
285
}
245
set.add( normaliseAddress( address ) );
286
set.add( address );
246
287
}
247
288
248
289
public boolean hasAssociatedOrganisation( Long id, String organisation )
251
292
if( organisation == null ) return false;
252
293
253
294
HashSet< String > set = _contactOrganisations.get( id );
254
return set != null && set.contains(
255
normaliseOrganisation( organisation ) );
295
return set != null && set.contains( organisation );
256
296
}
257
297
258
298
public void addAssociatedOrganisation( Long id, String organisation )
265
305
set = new HashSet< String >();
266
306
_contactOrganisations.put( id, set );
267
307
}
268
set.add( normaliseOrganisation( organisation ) );
269
}
270
271
public void buildCache( Activity activity )
272
throws AbortImportException
273
{
274
Cursor cur;
275
276
// init id lookups
277
_contactsByName = new HashMap< String, Long >();
278
_contactsByOrg = new HashMap< String, Long >();
279
_contactsByNumber = new HashMap< String, Long >();
280
_contactsByEmail = new HashMap< String, Long >();
281
282
// init associated data cache
283
_contactNumbers = new HashMap< Long, HashSet< String > >();
284
_contactEmails = new HashMap< Long, HashSet< String > >();
285
_contactAddresses = new HashMap< Long, HashSet< String > >();
286
_contactOrganisations = new HashMap< Long, HashSet< String > >();
287
288
// set of contact ids that we have not yet added
289
HashSet< Long > unadded = new HashSet< Long >();
290
291
// get all contacts
292
cur = activity.managedQuery( Contacts.People.CONTENT_URI,
293
new String[] {
294
Contacts.People._ID,
295
Contacts.People.NAME,
296
}, null, null, null );
297
while( cur.moveToNext() ) {
298
Long id = cur.getLong(
299
cur.getColumnIndex( Contacts.People._ID ) );
300
String name = normaliseName( cur.getString(
301
cur.getColumnIndex( Contacts.People.NAME ) ) );
302
if( name != null )
303
{
304
// if we can, add a lookup for the contact id by name
305
if( name.length() > 0 ) {
306
addLookup( new CacheIdentifier(
307
CacheIdentifier.Type.NAME, name ), id );
308
continue;
309
}
310
}
311
312
// record that a lookup for this contact's id still needs to be
313
// added by some other means
314
unadded.add( id );
315
}
316
317
// get contact organisations, primary ones first
318
cur = activity.managedQuery( Contacts.Organizations.CONTENT_URI,
319
new String[] {
320
Contacts.Phones.PERSON_ID,
321
Contacts.Organizations.COMPANY,
322
}, null, null, Contacts.Organizations.ISPRIMARY + " DESC" );
323
while( cur.moveToNext() ) {
324
Long id = cur.getLong( cur.getColumnIndex(
325
Contacts.Organizations.PERSON_ID ) );
326
String organisation = normaliseOrganisation( cur.getString(
327
cur.getColumnIndex( Contacts.Organizations.COMPANY ) ) );
328
if( organisation != null )
329
{
330
// if this is an organisation name for a contact for whom we
331
// have not added a lookup, add a lookup for the contact id
332
// by organisation
333
if( unadded.contains( id ) ) {
334
addLookup( new CacheIdentifier(
335
CacheIdentifier.Type.ORGANISATION, organisation ), id );
336
unadded.remove( id );
337
}
338
339
// add associated data
340
addAssociatedOrganisation( id, organisation );
341
}
342
}
343
344
// get all phone numbers, primary ones first
345
cur = activity.managedQuery( Contacts.Phones.CONTENT_URI,
346
new String[] {
347
Contacts.Phones.PERSON_ID,
348
Contacts.Phones.NUMBER,
349
}, null, null, Contacts.Phones.ISPRIMARY + " DESC" );
350
while( cur.moveToNext() ) {
351
Long id = cur.getLong(
352
cur.getColumnIndex( Contacts.Phones.PERSON_ID ) );
353
String number = normalisePhoneNumber( cur.getString(
354
cur.getColumnIndex( Contacts.Phones.NUMBER ) ) );
355
if( number != null )
356
{
357
// if this is a number for a contact for whom we have not
358
// added a lookup, add a lookup for the contact id by phone
359
// number
360
if( unadded.contains( id ) ) {
361
addLookup( new CacheIdentifier(
362
CacheIdentifier.Type.PRIMARY_NUMBER, number ), id );
363
unadded.remove( id );
364
}
365
366
// add associated data
367
addAssociatedNumber( id, number );
368
}
369
}
370
371
// now get all email addresses, primary ones first, and postal addresses
372
cur = activity.managedQuery( Contacts.ContactMethods.CONTENT_URI,
373
new String[] {
374
Contacts.ContactMethods.PERSON_ID,
375
Contacts.ContactMethods.DATA,
376
Contacts.ContactMethods.KIND,
377
}, Contacts.ContactMethods.KIND + " IN( ?, ? )", new String[] {
378
"" + Contacts.KIND_EMAIL,
379
"" + Contacts.KIND_POSTAL,
380
}, Contacts.ContactMethods.ISPRIMARY + " DESC" );
381
while( cur.moveToNext() ) {
382
Long id = cur.getLong(
383
cur.getColumnIndex( Contacts.ContactMethods.PERSON_ID ) );
384
int kind = cur.getInt(
385
cur.getColumnIndex( Contacts.ContactMethods.KIND ) );
386
if( kind == Contacts.KIND_EMAIL )
387
{
388
String email = normaliseEmailAddress( cur.getString(
389
cur.getColumnIndex( Contacts.ContactMethods.DATA ) ) );
390
if( email != null )
391
{
392
// if this is an email address for a contact for whom we
393
// have not added a lookup, add a lookup for the contact
394
// id by email address
395
if( unadded.contains( id ) ) {
396
addLookup( new CacheIdentifier(
397
CacheIdentifier.Type.PRIMARY_EMAIL, email ), id );
398
unadded.remove( id );
399
}
400
401
// add associated data
402
addAssociatedEmail( id, email );
403
}
404
}
405
else if( kind == Contacts.KIND_POSTAL )
406
{
407
String address = normaliseAddress( cur.getString(
408
cur.getColumnIndex( Contacts.ContactMethods.DATA ) ) );
409
if( address != null )
410
{
411
// add associated data
412
addAssociatedAddress( id, address );
413
}
414
}
415
}
416
}
417
418
static private String normaliseName( String name )
308
set.add( organisation );
309
}
310
311
public boolean hasAssociatedNote( Long id, String note )
312
{
313
note = normaliseNote( note );
314
if( note == null ) return false;
315
316
HashSet< String > set = _contactNotes.get( id );
317
return set != null && set.contains( note );
318
}
319
320
public void addAssociatedNote( Long id, String note )
321
{
322
note = normaliseNote( note );
323
if( note == null ) return;
324
325
HashSet< String > set = _contactNotes.get( id );
326
if( set == null ) {
327
set = new HashSet< String >();
328
_contactNotes.put( id, set );
329
}
330
set.add( note );
331
}
332
333
static public String normaliseName( String name )
419
334
{
420
335
if( name == null ) return null;
421
336
name = name.trim();
422
337
return name.length() > 0? name : null;
423
338
}
424
339
425
static private String normalisePhoneNumber( String number )
340
static public String normalisePhoneNumber( String number )
426
341
{
427
342
if( number == null ) return null;
428
343
number = number.trim().replaceAll( "[-\\(\\) ]", "" );
429
344
return number.length() > 0? number : null;
430
345
}
431
346
432
static private String normaliseEmailAddress( String email )
347
static public String normaliseEmailAddress( String email )
433
348
{
434
349
if( email == null ) return null;
435
email = email.trim().toLowerCase();
350
email = email.trim().toLowerCase( Locale.US );
436
351
return email.length() > 0? email : null;
437
352
}
438
353
439
static private String normaliseOrganisation( String organisation )
354
static public String normaliseOrganisation( String organisation )
440
355
{
441
356
if( organisation == null ) return null;
442
357
organisation = organisation.trim();
443
358
return organisation.length() > 0? organisation : null;
444
359
}
445
360
446
static private String normaliseAddress( String address )
361
static public String normaliseAddress( String address )
447
362
{
448
363
if( address == null ) return null;
449
364
address = address.trim();
450
365
return address.length() > 0? address : null;
451
366
}
367
368
static public String normaliseNote( String note )
369
{
370
if( note == null ) return null;
371
note = note.trim();
372
return note.length() > 0? note : null;
373
}
452
374
}
Loggerhead is a web-based interface for Bazaar branches
Version: 1.18.2, Revision: 480