/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: 2010-10-28 15:49:21 UTC
  • Revision ID: edam@waxworlds.org-20101028154921-98svlxlpno3cpzb8
- added file chooser
- changed file/dir entry box for a button that opens the file chooser
- added dialog to ask if you want to select a dir to scan or a file
- fixed bug where you could abort as dialog opened and the dialog wasn't cancelled
- fixed crash where you could abort as the merge prompt opened and it would try to use the just-destroyed importer
- fixed bug where closing the application at the end would show "aborted!" erroniously

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
 
}