1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License
15 */
16
17package com.android.contacts.editor;
18
19import android.content.ContentResolver;
20import android.content.Context;
21import android.database.ContentObserver;
22import android.database.Cursor;
23import android.net.Uri;
24import android.os.Handler;
25import android.os.HandlerThread;
26import android.os.Message;
27import android.os.Process;
28import android.provider.ContactsContract.CommonDataKinds.Email;
29import android.provider.ContactsContract.CommonDataKinds.Nickname;
30import android.provider.ContactsContract.CommonDataKinds.Phone;
31import android.provider.ContactsContract.CommonDataKinds.Photo;
32import android.provider.ContactsContract.CommonDataKinds.StructuredName;
33import android.provider.ContactsContract.Contacts;
34import android.provider.ContactsContract.Contacts.AggregationSuggestions;
35import android.provider.ContactsContract.Contacts.AggregationSuggestions.Builder;
36import android.provider.ContactsContract.Data;
37import android.provider.ContactsContract.RawContacts;
38import android.text.TextUtils;
39
40import com.android.contacts.model.RawContactDelta.ValuesDelta;
41import com.google.common.collect.Lists;
42
43import java.util.ArrayList;
44import java.util.Arrays;
45import java.util.List;
46
47/**
48 * Runs asynchronous queries to obtain aggregation suggestions in the as-you-type mode.
49 */
50public class AggregationSuggestionEngine extends HandlerThread {
51    public static final String TAG = "AggregationSuggestionEngine";
52
53    public interface Listener {
54        void onAggregationSuggestionChange();
55    }
56
57    public static final class RawContact {
58        public long rawContactId;
59        public String accountType;
60        public String accountName;
61        public String dataSet;
62
63        @Override
64        public String toString() {
65            return "ID: " + rawContactId + " account: " + accountType + "/" + accountName
66                    + " dataSet: " + dataSet;
67        }
68    }
69
70    public static final class Suggestion {
71
72        public long contactId;
73        public String lookupKey;
74        public String name;
75        public String phoneNumber;
76        public String emailAddress;
77        public String nickname;
78        public byte[] photo;
79        public List<RawContact> rawContacts;
80
81        @Override
82        public String toString() {
83            return "ID: " + contactId + " rawContacts: " + rawContacts + " name: " + name
84            + " phone: " + phoneNumber + " email: " + emailAddress + " nickname: "
85            + nickname + (photo != null ? " [has photo]" : "");
86        }
87    }
88
89    private final class SuggestionContentObserver extends ContentObserver {
90        private SuggestionContentObserver(Handler handler) {
91            super(handler);
92        }
93
94        @Override
95        public void onChange(boolean selfChange) {
96            scheduleSuggestionLookup();
97        }
98    }
99
100    private static final int MESSAGE_RESET = 0;
101    private static final int MESSAGE_NAME_CHANGE = 1;
102    private static final int MESSAGE_DATA_CURSOR = 2;
103
104    private static final long SUGGESTION_LOOKUP_DELAY_MILLIS = 300;
105
106    private static final int MAX_SUGGESTION_COUNT = 3;
107
108    private final Context mContext;
109
110    private long[] mSuggestedContactIds = new long[0];
111
112    private Handler mMainHandler;
113    private Handler mHandler;
114    private long mContactId;
115    private Listener mListener;
116    private Cursor mDataCursor;
117    private ContentObserver mContentObserver;
118    private Uri mSuggestionsUri;
119
120    public AggregationSuggestionEngine(Context context) {
121        super("AggregationSuggestions", Process.THREAD_PRIORITY_BACKGROUND);
122        mContext = context.getApplicationContext();
123        mMainHandler = new Handler() {
124            @Override
125            public void handleMessage(Message msg) {
126                AggregationSuggestionEngine.this.deliverNotification((Cursor) msg.obj);
127            }
128        };
129    }
130
131    protected Handler getHandler() {
132        if (mHandler == null) {
133            mHandler = new Handler(getLooper()) {
134                @Override
135                public void handleMessage(Message msg) {
136                    AggregationSuggestionEngine.this.handleMessage(msg);
137                }
138            };
139        }
140        return mHandler;
141    }
142
143    public void setContactId(long contactId) {
144        if (contactId != mContactId) {
145            mContactId = contactId;
146            reset();
147        }
148    }
149
150    public void setListener(Listener listener) {
151        mListener = listener;
152    }
153
154    @Override
155    public boolean quit() {
156        if (mDataCursor != null) {
157            mDataCursor.close();
158        }
159        mDataCursor = null;
160        if (mContentObserver != null) {
161            mContext.getContentResolver().unregisterContentObserver(mContentObserver);
162            mContentObserver = null;
163        }
164        return super.quit();
165    }
166
167    public void reset() {
168        Handler handler = getHandler();
169        handler.removeMessages(MESSAGE_NAME_CHANGE);
170        handler.sendEmptyMessage(MESSAGE_RESET);
171    }
172
173    public void onNameChange(ValuesDelta values) {
174        mSuggestionsUri = buildAggregationSuggestionUri(values);
175        if (mSuggestionsUri != null) {
176            if (mContentObserver == null) {
177                mContentObserver = new SuggestionContentObserver(getHandler());
178                mContext.getContentResolver().registerContentObserver(
179                        Contacts.CONTENT_URI, true, mContentObserver);
180            }
181        } else if (mContentObserver != null) {
182            mContext.getContentResolver().unregisterContentObserver(mContentObserver);
183            mContentObserver = null;
184        }
185        scheduleSuggestionLookup();
186    }
187
188    protected void scheduleSuggestionLookup() {
189        Handler handler = getHandler();
190        handler.removeMessages(MESSAGE_NAME_CHANGE);
191
192        if (mSuggestionsUri == null) {
193            return;
194        }
195
196        Message msg = handler.obtainMessage(MESSAGE_NAME_CHANGE, mSuggestionsUri);
197        handler.sendMessageDelayed(msg, SUGGESTION_LOOKUP_DELAY_MILLIS);
198    }
199
200    private Uri buildAggregationSuggestionUri(ValuesDelta values) {
201        StringBuilder nameSb = new StringBuilder();
202        appendValue(nameSb, values, StructuredName.PREFIX);
203        appendValue(nameSb, values, StructuredName.GIVEN_NAME);
204        appendValue(nameSb, values, StructuredName.MIDDLE_NAME);
205        appendValue(nameSb, values, StructuredName.FAMILY_NAME);
206        appendValue(nameSb, values, StructuredName.SUFFIX);
207
208        if (nameSb.length() == 0) {
209            appendValue(nameSb, values, StructuredName.DISPLAY_NAME);
210        }
211
212        StringBuilder phoneticNameSb = new StringBuilder();
213        appendValue(phoneticNameSb, values, StructuredName.PHONETIC_FAMILY_NAME);
214        appendValue(phoneticNameSb, values, StructuredName.PHONETIC_MIDDLE_NAME);
215        appendValue(phoneticNameSb, values, StructuredName.PHONETIC_GIVEN_NAME);
216
217        if (nameSb.length() == 0 && phoneticNameSb.length() == 0) {
218            return null;
219        }
220
221        Builder builder = AggregationSuggestions.builder()
222                .setLimit(MAX_SUGGESTION_COUNT)
223                .setContactId(mContactId);
224
225        if (nameSb.length() != 0) {
226            builder.addParameter(AggregationSuggestions.PARAMETER_MATCH_NAME, nameSb.toString());
227        }
228
229        if (phoneticNameSb.length() != 0) {
230            builder.addParameter(
231                    AggregationSuggestions.PARAMETER_MATCH_NAME, phoneticNameSb.toString());
232        }
233
234        return builder.build();
235    }
236
237    private void appendValue(StringBuilder sb, ValuesDelta values, String column) {
238        String value = values.getAsString(column);
239        if (!TextUtils.isEmpty(value)) {
240            if (sb.length() > 0) {
241                sb.append(' ');
242            }
243            sb.append(value);
244        }
245    }
246
247    protected void handleMessage(Message msg) {
248        switch (msg.what) {
249            case MESSAGE_RESET:
250                mSuggestedContactIds = new long[0];
251                break;
252            case MESSAGE_NAME_CHANGE:
253                loadAggregationSuggestions((Uri) msg.obj);
254                break;
255        }
256    }
257
258    private static final class DataQuery {
259
260        public static final String SELECTION_PREFIX =
261                Data.MIMETYPE + " IN ('"
262                    + Phone.CONTENT_ITEM_TYPE + "','"
263                    + Email.CONTENT_ITEM_TYPE + "','"
264                    + StructuredName.CONTENT_ITEM_TYPE + "','"
265                    + Nickname.CONTENT_ITEM_TYPE + "','"
266                    + Photo.CONTENT_ITEM_TYPE + "')"
267                + " AND " + Data.CONTACT_ID + " IN (";
268
269        public static final String[] COLUMNS = {
270            Data._ID,
271            Data.CONTACT_ID,
272            Data.LOOKUP_KEY,
273            Data.PHOTO_ID,
274            Data.DISPLAY_NAME,
275            Data.RAW_CONTACT_ID,
276            Data.MIMETYPE,
277            Data.DATA1,
278            Data.IS_SUPER_PRIMARY,
279            Photo.PHOTO,
280            RawContacts.ACCOUNT_TYPE,
281            RawContacts.ACCOUNT_NAME,
282            RawContacts.DATA_SET
283        };
284
285        public static final int ID = 0;
286        public static final int CONTACT_ID = 1;
287        public static final int LOOKUP_KEY = 2;
288        public static final int PHOTO_ID = 3;
289        public static final int DISPLAY_NAME = 4;
290        public static final int RAW_CONTACT_ID = 5;
291        public static final int MIMETYPE = 6;
292        public static final int DATA1 = 7;
293        public static final int IS_SUPERPRIMARY = 8;
294        public static final int PHOTO = 9;
295        public static final int ACCOUNT_TYPE = 10;
296        public static final int ACCOUNT_NAME = 11;
297        public static final int DATA_SET = 12;
298    }
299
300    private void loadAggregationSuggestions(Uri uri) {
301        ContentResolver contentResolver = mContext.getContentResolver();
302        Cursor cursor = contentResolver.query(uri, new String[]{Contacts._ID}, null, null, null);
303        try {
304            // If a new request is pending, chuck the result of the previous request
305            if (getHandler().hasMessages(MESSAGE_NAME_CHANGE)) {
306                return;
307            }
308
309            boolean changed = updateSuggestedContactIds(cursor);
310            if (!changed) {
311                return;
312            }
313
314            StringBuilder sb = new StringBuilder(DataQuery.SELECTION_PREFIX);
315            int count = mSuggestedContactIds.length;
316            for (int i = 0; i < count; i++) {
317                if (i > 0) {
318                    sb.append(',');
319                }
320                sb.append(mSuggestedContactIds[i]);
321            }
322            sb.append(')');
323            sb.toString();
324
325            Cursor dataCursor = contentResolver.query(Data.CONTENT_URI,
326                    DataQuery.COLUMNS, sb.toString(), null, Data.CONTACT_ID);
327            mMainHandler.sendMessage(mMainHandler.obtainMessage(MESSAGE_DATA_CURSOR, dataCursor));
328        } finally {
329            cursor.close();
330        }
331    }
332
333    private boolean updateSuggestedContactIds(Cursor cursor) {
334        int count = cursor.getCount();
335        boolean changed = count != mSuggestedContactIds.length;
336        if (!changed) {
337            while (cursor.moveToNext()) {
338                long contactId = cursor.getLong(0);
339                if (Arrays.binarySearch(mSuggestedContactIds, contactId) < 0) {
340                    changed = true;
341                    break;
342                }
343            }
344        }
345
346        if (changed) {
347            mSuggestedContactIds = new long[count];
348            cursor.moveToPosition(-1);
349            for (int i = 0; i < count; i++) {
350                cursor.moveToNext();
351                mSuggestedContactIds[i] = cursor.getLong(0);
352            }
353            Arrays.sort(mSuggestedContactIds);
354        }
355
356        return changed;
357    }
358
359    protected void deliverNotification(Cursor dataCursor) {
360        if (mDataCursor != null) {
361            mDataCursor.close();
362        }
363        mDataCursor = dataCursor;
364        if (mListener != null) {
365            mListener.onAggregationSuggestionChange();
366        }
367    }
368
369    public int getSuggestedContactCount() {
370        return mDataCursor != null ? mDataCursor.getCount() : 0;
371    }
372
373    public List<Suggestion> getSuggestions() {
374        ArrayList<Suggestion> list = Lists.newArrayList();
375        if (mDataCursor != null) {
376            Suggestion suggestion = null;
377            long currentContactId = -1;
378            mDataCursor.moveToPosition(-1);
379            while (mDataCursor.moveToNext()) {
380                long contactId = mDataCursor.getLong(DataQuery.CONTACT_ID);
381                if (contactId != currentContactId) {
382                    suggestion = new Suggestion();
383                    suggestion.contactId = contactId;
384                    suggestion.name = mDataCursor.getString(DataQuery.DISPLAY_NAME);
385                    suggestion.lookupKey = mDataCursor.getString(DataQuery.LOOKUP_KEY);
386                    suggestion.rawContacts = Lists.newArrayList();
387                    list.add(suggestion);
388                    currentContactId = contactId;
389                }
390
391                long rawContactId = mDataCursor.getLong(DataQuery.RAW_CONTACT_ID);
392                if (!containsRawContact(suggestion, rawContactId)) {
393                    RawContact rawContact = new RawContact();
394                    rawContact.rawContactId = rawContactId;
395                    rawContact.accountName = mDataCursor.getString(DataQuery.ACCOUNT_NAME);
396                    rawContact.accountType = mDataCursor.getString(DataQuery.ACCOUNT_TYPE);
397                    rawContact.dataSet = mDataCursor.getString(DataQuery.DATA_SET);
398                    suggestion.rawContacts.add(rawContact);
399                }
400
401                String mimetype = mDataCursor.getString(DataQuery.MIMETYPE);
402                if (Phone.CONTENT_ITEM_TYPE.equals(mimetype)) {
403                    String data = mDataCursor.getString(DataQuery.DATA1);
404                    int superprimary = mDataCursor.getInt(DataQuery.IS_SUPERPRIMARY);
405                    if (!TextUtils.isEmpty(data)
406                            && (superprimary != 0 || suggestion.phoneNumber == null)) {
407                        suggestion.phoneNumber = data;
408                    }
409                } else if (Email.CONTENT_ITEM_TYPE.equals(mimetype)) {
410                    String data = mDataCursor.getString(DataQuery.DATA1);
411                    int superprimary = mDataCursor.getInt(DataQuery.IS_SUPERPRIMARY);
412                    if (!TextUtils.isEmpty(data)
413                            && (superprimary != 0 || suggestion.emailAddress == null)) {
414                        suggestion.emailAddress = data;
415                    }
416                } else if (Nickname.CONTENT_ITEM_TYPE.equals(mimetype)) {
417                    String data = mDataCursor.getString(DataQuery.DATA1);
418                    if (!TextUtils.isEmpty(data)) {
419                        suggestion.nickname = data;
420                    }
421                } else if (Photo.CONTENT_ITEM_TYPE.equals(mimetype)) {
422                    long dataId = mDataCursor.getLong(DataQuery.ID);
423                    long photoId = mDataCursor.getLong(DataQuery.PHOTO_ID);
424                    if (dataId == photoId && !mDataCursor.isNull(DataQuery.PHOTO)) {
425                        suggestion.photo = mDataCursor.getBlob(DataQuery.PHOTO);
426                    }
427                }
428            }
429        }
430        return list;
431    }
432
433    public boolean containsRawContact(Suggestion suggestion, long rawContactId) {
434        if (suggestion.rawContacts != null) {
435            int count = suggestion.rawContacts.size();
436            for (int i = 0; i < count; i++) {
437                if (suggestion.rawContacts.get(i).rawContactId == rawContactId) {
438                    return true;
439                }
440            }
441        }
442        return false;
443    }
444}
445