/android/import-contacts

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

  • Committer: edam
  • Date: 2009-01-13 06:35:26 UTC
  • Revision ID: edam@waxworlds.org-20090113063526-l9t1s9git4bav60a
- new contact's phone numebrs and email addresses are added to the caches after those contacts are updated to account for the situation where the same contact is imported again from another file (or the contact exists twice in the same file!?)

Show diffs side-by-side

added added

removed removed

src/am/ed/importcontacts/ContactsCache.java
1
 
/*
2
 
 * ContactsCache.java
3
 
 *
4
 
 * Copyright (C) 2011 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 android.app.Activity;
30
 
 
31
 
 
32
 
public class ContactsCache
33
 
{
34
 
        /**
35
 
         * Information that can be used to identify a contact within the cache
36
 
         */
37
 
        static public class CacheIdentifier
38
 
        {
39
 
                public enum Type {
40
 
                        NONE, NAME, ORGANISATION, PRIMARY_NUMBER, PRIMARY_EMAIL }
41
 
 
42
 
                private Type _type;
43
 
                private String _detail;
44
 
 
45
 
                protected CacheIdentifier()
46
 
                {
47
 
                        _type = Type.NONE;
48
 
                }
49
 
 
50
 
                protected CacheIdentifier( Type type, String detail )
51
 
                {
52
 
                        _type = type;
53
 
                        _detail = detail;
54
 
                }
55
 
 
56
 
                public Type getType()
57
 
                {
58
 
                        return _type;
59
 
                }
60
 
 
61
 
                public String getDetail()
62
 
                {
63
 
                        return _detail;
64
 
                }
65
 
        }
66
 
 
67
 
        // mappings of contact names, organisations and primary numbers to ids
68
 
        private HashMap< String, Long > _contactsByName
69
 
                = new HashMap< String, Long >();
70
 
        private HashMap< String, Long > _contactsByOrg
71
 
                = new HashMap< String, Long >();
72
 
        private HashMap< String, Long > _contactsByNumber
73
 
                = new HashMap< String, Long >();
74
 
        private HashMap< String, Long > _contactsByEmail
75
 
                = new HashMap< String, Long >();
76
 
 
77
 
        // mapping of contact ids to sets of associated data
78
 
        private HashMap< Long, HashSet< String > > _contactNumbers
79
 
                = new HashMap< Long, HashSet< String > >();
80
 
        private HashMap< Long, HashSet< String > > _contactEmails
81
 
                = new HashMap< Long, HashSet< String > >();
82
 
        private HashMap< Long, HashSet< String > > _contactAddresses
83
 
                = new HashMap< Long, HashSet< String > >();
84
 
        private HashMap< Long, HashSet< String > > _contactOrganisations
85
 
                = new HashMap< Long, HashSet< String > >();
86
 
 
87
 
        ContactsCache()
88
 
        {
89
 
                // init id lookups
90
 
//              _contactsByName = new HashMap< String, Long >();
91
 
//              _contactsByOrg = new HashMap< String, Long >();
92
 
//              _contactsByNumber = new HashMap< String, Long >();
93
 
//              _contactsByEmail = new HashMap< String, Long >();
94
 
 
95
 
                // init associated data cache
96
 
//              _contactNumbers = new HashMap< Long, HashSet< String > >();
97
 
//              _contactEmails = new HashMap< Long, HashSet< String > >();
98
 
//              _contactAddresses = new HashMap< Long, HashSet< String > >();
99
 
//              _contactOrganisations = new HashMap< Long, HashSet< String > >();
100
 
        }
101
 
 
102
 
        public static CacheIdentifier createIdentifier(
103
 
                Importer.ContactData contact )
104
 
        {
105
 
                if( contact.hasName() ) {
106
 
                        String name = normaliseName( contact.getName() );
107
 
                        if( name != null )
108
 
                                return new CacheIdentifier(
109
 
                                        CacheIdentifier.Type.NAME, name );
110
 
                }
111
 
 
112
 
                if( contact.hasPrimaryOrganisation() ) {
113
 
                        String organisation = normaliseOrganisation(
114
 
                                contact.getPrimaryOrganisation() );
115
 
                        if( organisation != null )
116
 
                                return new CacheIdentifier(
117
 
                                        CacheIdentifier.Type.ORGANISATION, organisation );
118
 
                }
119
 
 
120
 
                if( contact.hasPrimaryNumber() ) {
121
 
                        String number = normalisePhoneNumber( contact.getPrimaryNumber() );
122
 
                        if( number != null )
123
 
                        return new CacheIdentifier(
124
 
                                CacheIdentifier.Type.PRIMARY_NUMBER, number );
125
 
                }
126
 
 
127
 
                if( contact.hasPrimaryEmail() ) {
128
 
                        String email = normaliseEmailAddress( contact.getPrimaryEmail() );
129
 
                        if( email != null )
130
 
                        return new CacheIdentifier(
131
 
                                CacheIdentifier.Type.PRIMARY_EMAIL, email );
132
 
                }
133
 
 
134
 
                return null;
135
 
        }
136
 
 
137
 
        public boolean canLookup( CacheIdentifier identifier )
138
 
        {
139
 
                return lookup( identifier ) != null;
140
 
        }
141
 
 
142
 
        public Long lookup( CacheIdentifier identifier )
143
 
        {
144
 
                switch( identifier.getType() )
145
 
                {
146
 
                case NAME:
147
 
                        return _contactsByName.get( identifier.getDetail() );
148
 
                case ORGANISATION:
149
 
                        return _contactsByOrg.get( identifier.getDetail() );
150
 
                case PRIMARY_NUMBER:
151
 
                        return _contactsByNumber.get( identifier.getDetail() );
152
 
                case PRIMARY_EMAIL:
153
 
                        return _contactsByEmail.get( identifier.getDetail() );
154
 
                }
155
 
                return null;
156
 
        }
157
 
 
158
 
        public Long removeLookup( CacheIdentifier identifier )
159
 
        {
160
 
                switch( identifier.getType() )
161
 
                {
162
 
                case NAME:
163
 
                        return _contactsByName.remove( identifier.getDetail() );
164
 
                case ORGANISATION:
165
 
                        return _contactsByOrg.remove( identifier.getDetail() );
166
 
                case PRIMARY_NUMBER:
167
 
                        return _contactsByNumber.remove( identifier.getDetail() );
168
 
                case PRIMARY_EMAIL:
169
 
                        return _contactsByEmail.remove( identifier.getDetail() );
170
 
                }
171
 
                return null;
172
 
        }
173
 
 
174
 
        public void addLookup( CacheIdentifier identifier, Long id )
175
 
        {
176
 
                switch( identifier.getType() )
177
 
                {
178
 
                case NAME:
179
 
                        _contactsByName.put( identifier.getDetail(), id );
180
 
                        break;
181
 
                case ORGANISATION:
182
 
                        _contactsByOrg.put( identifier.getDetail(), id );
183
 
                        break;
184
 
                case PRIMARY_NUMBER:
185
 
                        _contactsByNumber.put( identifier.getDetail(), id );
186
 
                        break;
187
 
                case PRIMARY_EMAIL:
188
 
                        _contactsByEmail.put( identifier.getDetail(), id );
189
 
                        break;
190
 
                }
191
 
        }
192
 
 
193
 
        public void removeAssociatedData( Long id )
194
 
        {
195
 
                _contactNumbers.remove( id );
196
 
                _contactEmails.remove( id );
197
 
                _contactAddresses.remove( id );
198
 
                _contactOrganisations.remove( id );
199
 
        }
200
 
 
201
 
        public boolean hasAssociatedNumber( Long id, String number )
202
 
        {
203
 
                number = normalisePhoneNumber( number );
204
 
                if( number == null ) return false;
205
 
 
206
 
                HashSet< String > set = _contactNumbers.get( id );
207
 
                return set != null && set.contains( number );
208
 
        }
209
 
 
210
 
        public void addAssociatedNumber( Long id, String number )
211
 
        {
212
 
                number = normalisePhoneNumber( number );
213
 
                if( number == null ) return;
214
 
 
215
 
                HashSet< String > set = _contactNumbers.get( id );
216
 
                if( set == null ) {
217
 
                        set = new HashSet< String >();
218
 
                        _contactNumbers.put( id, set );
219
 
                }
220
 
                set.add( normalisePhoneNumber( number ) );
221
 
        }
222
 
 
223
 
        public boolean hasAssociatedEmail( Long id, String email )
224
 
        {
225
 
                email = normaliseEmailAddress( email );
226
 
                if( email == null ) return false;
227
 
 
228
 
                HashSet< String > set = _contactEmails.get( id );
229
 
                return set != null && set.contains( normaliseEmailAddress( email ) );
230
 
        }
231
 
 
232
 
        public void addAssociatedEmail( Long id, String email )
233
 
        {
234
 
                email = normaliseEmailAddress( email );
235
 
                if( email == null ) return;
236
 
 
237
 
                HashSet< String > set = _contactEmails.get( id );
238
 
                if( set == null ) {
239
 
                        set = new HashSet< String >();
240
 
                        _contactEmails.put( id, set );
241
 
                }
242
 
                set.add( normaliseEmailAddress( email ) );
243
 
        }
244
 
 
245
 
        public boolean hasAssociatedAddress( Long id, String address )
246
 
        {
247
 
                address = normaliseAddress( address );
248
 
                if( address == null ) return false;
249
 
 
250
 
                HashSet< String > set = _contactAddresses.get( id );
251
 
                return set != null && set.contains( normaliseAddress( address ) );
252
 
        }
253
 
 
254
 
        public void addAssociatedAddress( Long id, String address )
255
 
        {
256
 
                address = normaliseAddress( address );
257
 
                if( address == null ) return;
258
 
 
259
 
                HashSet< String > set = _contactAddresses.get( id );
260
 
                if( set == null ) {
261
 
                        set = new HashSet< String >();
262
 
                        _contactAddresses.put( id, set );
263
 
                }
264
 
                set.add( normaliseAddress( address ) );
265
 
        }
266
 
 
267
 
        public boolean hasAssociatedOrganisation( Long id, String organisation )
268
 
        {
269
 
                organisation = normaliseOrganisation( organisation );
270
 
                if( organisation == null ) return false;
271
 
 
272
 
                HashSet< String > set = _contactOrganisations.get( id );
273
 
                return set != null && set.contains(
274
 
                        normaliseOrganisation( organisation ) );
275
 
        }
276
 
 
277
 
        public void addAssociatedOrganisation( Long id, String organisation )
278
 
        {
279
 
                organisation = normaliseOrganisation( organisation );
280
 
                if( organisation == null ) return;
281
 
 
282
 
                HashSet< String > set = _contactOrganisations.get( id );
283
 
                if( set == null ) {
284
 
                        set = new HashSet< String >();
285
 
                        _contactOrganisations.put( id, set );
286
 
                }
287
 
                set.add( normaliseOrganisation( organisation ) );
288
 
        }
289
 
 
290
 
        static public String normaliseName( String name )
291
 
        {
292
 
                if( name == null ) return null;
293
 
                name = name.trim();
294
 
                return name.length() > 0? name : null;
295
 
        }
296
 
 
297
 
        static public String normalisePhoneNumber( String number )
298
 
        {
299
 
                if( number == null ) return null;
300
 
                number = number.trim().replaceAll( "[-\\(\\) ]", "" );
301
 
                return number.length() > 0? number : null;
302
 
        }
303
 
 
304
 
        static public String normaliseEmailAddress( String email )
305
 
        {
306
 
                if( email == null ) return null;
307
 
                email = email.trim().toLowerCase();
308
 
                return email.length() > 0? email : null;
309
 
        }
310
 
 
311
 
        static public String normaliseOrganisation( String organisation )
312
 
        {
313
 
                if( organisation == null ) return null;
314
 
                organisation = organisation.trim();
315
 
                return organisation.length() > 0? organisation : null;
316
 
        }
317
 
 
318
 
        static public String normaliseAddress( String address )
319
 
        {
320
 
                if( address == null ) return null;
321
 
                address = address.trim();
322
 
                return address.length() > 0? address : null;
323
 
        }
324
 
}