/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/org/waxworlds/edam/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/org/waxworlds/edam/importcontacts/ContactsCache.java
1
 
/*
2
 
 * ContactsCache.java
3
 
 *
4
 
 * Copyright (C) 2009 Tim Marston <edam@waxworlds.org>
5
 
 *
6
 
 * This file is part of the Import Contacts program (hereafter referred
7
 
 * to as "this program"). For more information, see
8
 
 * http://www.waxworlds.org/edam/software/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 org.waxworlds.edam.importcontacts;
25
 
 
26
 
import java.util.HashMap;
27
 
import java.util.HashSet;
28
 
 
29
 
import org.waxworlds.edam.importcontacts.Importer.AbortImportException;
30
 
 
31
 
import android.app.Activity;
32
 
import android.database.Cursor;
33
 
import android.provider.Contacts;
34
 
 
35
 
 
36
 
public class ContactsCache
37
 
{
38
 
        private HashMap< String, Long > _contacts;
39
 
 
40
 
        private HashMap< Long, HashSet< String > > _contactNumbers;
41
 
        private HashMap< Long, HashSet< String > > _contactEmails;
42
 
        private HashMap< Long, HashSet< String > > _contactAddresses;
43
 
 
44
 
        public boolean exists( String name )
45
 
        {
46
 
                return _contacts.containsKey( name );
47
 
        }
48
 
 
49
 
        public Long getId( String name )
50
 
        {
51
 
                return _contacts.get( name );
52
 
        }
53
 
 
54
 
        public void remove( String name )
55
 
        {
56
 
                _contacts.remove( name );
57
 
        }
58
 
 
59
 
        public void put( Long id, String name )
60
 
        {
61
 
                _contacts.put( name, id );
62
 
        }
63
 
 
64
 
        public boolean hasNumber( Long id, String number )
65
 
        {
66
 
                HashSet< String > cache = _contactNumbers.get( id );
67
 
                return cache != null && cache.contains( number );
68
 
        }
69
 
 
70
 
        public void addNumber( Long id, String number )
71
 
        {
72
 
                HashSet< String > cache = _contactNumbers.get( id );
73
 
                if( cache == null ) {
74
 
                        cache = new HashSet< String >();
75
 
                        _contactNumbers.put( id, cache );
76
 
                }
77
 
                cache.add( number );
78
 
        }
79
 
 
80
 
        public boolean hasEmail( Long id, String email )
81
 
        {
82
 
                HashSet< String > cache = _contactEmails.get( id );
83
 
                return cache != null && cache.contains( email );
84
 
        }
85
 
 
86
 
        public void addEmail( Long id, String email )
87
 
        {
88
 
                HashSet< String > cache = _contactEmails.get( id );
89
 
                if( cache == null ) {
90
 
                        cache = new HashSet< String >();
91
 
                        _contactEmails.put( id, cache );
92
 
                }
93
 
                cache.add( email );
94
 
        }
95
 
 
96
 
        public boolean hasAddress( Long id, String address )
97
 
        {
98
 
                HashSet< String > cache = _contactAddresses.get( id );
99
 
                return cache != null && cache.contains( address );
100
 
        }
101
 
 
102
 
        public void addAddress( Long id, String address )
103
 
        {
104
 
                HashSet< String > cache = _contactAddresses.get( id );
105
 
                if( cache == null ) {
106
 
                        cache = new HashSet< String >();
107
 
                        _contactAddresses.put( id, cache );
108
 
                }
109
 
                cache.add( address );
110
 
        }
111
 
 
112
 
        public void buildCache( Activity activity )
113
 
                throws AbortImportException
114
 
        {
115
 
                String[] cols;
116
 
                Cursor cur;
117
 
 
118
 
                // init contacts caches
119
 
                _contacts = new HashMap< String, Long >();
120
 
                _contactNumbers = new HashMap< Long, HashSet< String > >();
121
 
                _contactEmails = new HashMap< Long, HashSet< String > >();
122
 
                _contactAddresses = new HashMap< Long, HashSet< String > >();
123
 
 
124
 
                // query and store map of contact names to ids
125
 
                cols = new String[] { Contacts.People._ID, Contacts.People.NAME };
126
 
                cur = activity.managedQuery( Contacts.People.CONTENT_URI,
127
 
                        cols, null, null, null);
128
 
                if( cur.moveToFirst() ) {
129
 
                        int idCol = cur.getColumnIndex( Contacts.People._ID );
130
 
                        int nameCol = cur.getColumnIndex( Contacts.People.NAME );
131
 
                        do {
132
 
                                _contacts.put( cur.getString( nameCol ), cur.getLong( idCol ) );
133
 
                        } while( cur.moveToNext() );
134
 
                }
135
 
 
136
 
                // query and store map of contact ids to sets of phone numbers
137
 
                cols = new String[] { Contacts.Phones.PERSON_ID,
138
 
                                Contacts.Phones.NUMBER };
139
 
                cur = activity.managedQuery( Contacts.Phones.CONTENT_URI,
140
 
                        cols, null, null, null);
141
 
                if( cur.moveToFirst() ) {
142
 
                        int personIdCol = cur.getColumnIndex( Contacts.Phones.PERSON_ID );
143
 
                        int numberCol = cur.getColumnIndex( Contacts.Phones.NUMBER );
144
 
                        do {
145
 
                                Long id = cur.getLong( personIdCol );
146
 
                                String number = Importer.sanitisePhoneNumber(
147
 
                                                cur.getString( numberCol ) );
148
 
                                if( number != null ) {
149
 
                                        HashSet< String > numbers = _contactNumbers.get( id );
150
 
                                        if( numbers == null ) {
151
 
                                                numbers = new HashSet< String >();
152
 
                                                _contactNumbers.put( id, numbers );
153
 
                                        }
154
 
                                        numbers.add( number );
155
 
                                }
156
 
                        } while( cur.moveToNext() );
157
 
                }
158
 
 
159
 
                // query and store map of contact ids to sets of email addresses
160
 
                cols = new String[] { Contacts.ContactMethods.PERSON_ID,
161
 
                                Contacts.ContactMethods.DATA };
162
 
                cur = activity.managedQuery( Contacts.ContactMethods.CONTENT_URI,
163
 
                                cols, Contacts.ContactMethods.KIND + " = ?",
164
 
                                new String[] { "" + Contacts.KIND_EMAIL }, null );
165
 
                if( cur.moveToFirst() ) {
166
 
                        int personIdCol = cur.getColumnIndex(
167
 
                                Contacts.ContactMethods.PERSON_ID );
168
 
                        int addressCol = cur.getColumnIndex(
169
 
                                Contacts.ContactMethods.DATA );
170
 
                        do {
171
 
                                Long id = cur.getLong( personIdCol );
172
 
                                String address = Importer.sanitiseEmailAddress(
173
 
                                        cur.getString( addressCol ) );
174
 
                                if( address != null ) {
175
 
                                        HashSet< String > addresses = _contactEmails.get( id );
176
 
                                        if( addresses == null ) {
177
 
                                                addresses = new HashSet< String >();
178
 
                                                _contactEmails.put( id, addresses );
179
 
                                        }
180
 
                                        addresses.add( address );
181
 
                                }
182
 
                        } while( cur.moveToNext() );
183
 
                }
184
 
 
185
 
                // query and store map of contact ids to sets of postal addresses
186
 
                cols = new String[] { Contacts.ContactMethods.PERSON_ID,
187
 
                        Contacts.ContactMethods.DATA };
188
 
                cur = activity.managedQuery( Contacts.ContactMethods.CONTENT_URI,
189
 
                        cols, Contacts.ContactMethods.KIND + " = ?",
190
 
                        new String[] { "" + Contacts.KIND_POSTAL }, null );
191
 
                if( cur.moveToFirst() ) {
192
 
                        int personIdCol = cur.getColumnIndex(
193
 
                                Contacts.ContactMethods.PERSON_ID );
194
 
                        int addressCol = cur.getColumnIndex(
195
 
                                Contacts.ContactMethods.DATA );
196
 
                        do {
197
 
                                Long id = cur.getLong( personIdCol );
198
 
                                String address = cur.getString( addressCol );
199
 
                                if( address != null ) {
200
 
                                        HashSet< String > addresses = _contactAddresses.get( id );
201
 
                                        if( addresses == null ) {
202
 
                                                addresses = new HashSet< String >();
203
 
                                                _contactAddresses.put( id, addresses );
204
 
                                        }
205
 
                                        addresses.add( address );
206
 
                                }
207
 
                        } while( cur.moveToNext() );
208
 
                }
209
 
        }
210
 
}