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