DataRowHandlerForPhoneNumber.java revision eeeed5669d98897501bf2b18c88579c7effd0955 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5 * use this file except in compliance with the License. You may obtain a copy of
6 * 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, WITHOUT
12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 * License for the specific language governing permissions and limitations under
14 * the License
15 */
16package com.android.providers.contacts;
17
18import com.android.providers.contacts.ContactsDatabaseHelper.PhoneColumns;
19import com.android.providers.contacts.ContactsDatabaseHelper.PhoneLookupColumns;
20import com.android.providers.contacts.ContactsDatabaseHelper.Tables;
21import com.android.providers.contacts.SearchIndexManager.IndexBuilder;
22
23import android.content.ContentValues;
24import android.database.Cursor;
25import android.database.sqlite.SQLiteDatabase;
26import android.provider.ContactsContract.CommonDataKinds.Phone;
27import android.telephony.PhoneNumberUtils;
28import android.text.TextUtils;
29
30/**
31 * Handler for phone number data rows.
32 */
33public class DataRowHandlerForPhoneNumber extends DataRowHandlerForCommonDataKind {
34
35    public DataRowHandlerForPhoneNumber(
36            ContactsDatabaseHelper dbHelper, ContactAggregator aggregator) {
37        super(dbHelper, aggregator, Phone.CONTENT_ITEM_TYPE, Phone.TYPE, Phone.LABEL);
38    }
39
40    @Override
41    public long insert(SQLiteDatabase db, TransactionContext txContext, long rawContactId,
42            ContentValues values) {
43        long dataId;
44        if (values.containsKey(Phone.NUMBER)) {
45            String number = values.getAsString(Phone.NUMBER);
46
47            String numberE164 =
48                    PhoneNumberUtils.formatNumberToE164(number, mDbHelper.getCurrentCountryIso());
49            if (numberE164 != null) {
50                values.put(PhoneColumns.NORMALIZED_NUMBER, numberE164);
51            }
52            dataId = super.insert(db, txContext, rawContactId, values);
53
54            updatePhoneLookup(db, rawContactId, dataId, number, numberE164);
55            mContactAggregator.updateHasPhoneNumber(db, rawContactId);
56            fixRawContactDisplayName(db, txContext, rawContactId);
57            if (numberE164 != null) {
58                triggerAggregation(rawContactId);
59            }
60        } else {
61            dataId = super.insert(db, txContext, rawContactId, values);
62        }
63        return dataId;
64    }
65
66    @Override
67    public boolean update(SQLiteDatabase db, TransactionContext txContext, ContentValues values,
68            Cursor c, boolean callerIsSyncAdapter) {
69        String number = null;
70        String numberE164 = null;
71        if (values.containsKey(Phone.NUMBER)) {
72            number = values.getAsString(Phone.NUMBER);
73            if (number != null) {
74                numberE164 = PhoneNumberUtils.formatNumberToE164(number,
75                        mDbHelper.getCurrentCountryIso());
76            }
77            if (numberE164 != null) {
78                values.put(PhoneColumns.NORMALIZED_NUMBER, numberE164);
79            }
80        }
81
82        if (!super.update(db, txContext, values, c, callerIsSyncAdapter)) {
83            return false;
84        }
85
86        if (values.containsKey(Phone.NUMBER)) {
87            long dataId = c.getLong(DataUpdateQuery._ID);
88            long rawContactId = c.getLong(DataUpdateQuery.RAW_CONTACT_ID);
89            updatePhoneLookup(db, rawContactId, dataId, number, numberE164);
90            mContactAggregator.updateHasPhoneNumber(db, rawContactId);
91            fixRawContactDisplayName(db, txContext, rawContactId);
92            triggerAggregation(rawContactId);
93        }
94        return true;
95    }
96
97    @Override
98    public int delete(SQLiteDatabase db, TransactionContext txContext, Cursor c) {
99        long dataId = c.getLong(DataDeleteQuery._ID);
100        long rawContactId = c.getLong(DataDeleteQuery.RAW_CONTACT_ID);
101
102        int count = super.delete(db, txContext, c);
103
104        updatePhoneLookup(db, rawContactId, dataId, null, null);
105        mContactAggregator.updateHasPhoneNumber(db, rawContactId);
106        fixRawContactDisplayName(db, txContext, rawContactId);
107        triggerAggregation(rawContactId);
108        return count;
109    }
110
111    private void updatePhoneLookup(SQLiteDatabase db, long rawContactId, long dataId,
112            String number, String numberE164) {
113        mSelectionArgs1[0] = String.valueOf(dataId);
114        db.delete(Tables.PHONE_LOOKUP, PhoneLookupColumns.DATA_ID + "=?", mSelectionArgs1);
115        if (number != null) {
116            String normalizedNumber = PhoneNumberUtils.normalizeNumber(number);
117            if (!TextUtils.isEmpty(normalizedNumber)) {
118                ContentValues phoneValues = new ContentValues();
119                phoneValues.put(PhoneLookupColumns.RAW_CONTACT_ID, rawContactId);
120                phoneValues.put(PhoneLookupColumns.DATA_ID, dataId);
121                phoneValues.put(PhoneLookupColumns.NORMALIZED_NUMBER, normalizedNumber);
122                phoneValues.put(PhoneLookupColumns.MIN_MATCH,
123                        PhoneNumberUtils.toCallerIDMinMatch(normalizedNumber));
124                db.insert(Tables.PHONE_LOOKUP, null, phoneValues);
125
126                if (numberE164 != null && !numberE164.equals(normalizedNumber)) {
127                    phoneValues.put(PhoneLookupColumns.NORMALIZED_NUMBER, numberE164);
128                    phoneValues.put(PhoneLookupColumns.MIN_MATCH,
129                            PhoneNumberUtils.toCallerIDMinMatch(numberE164));
130                    db.insert(Tables.PHONE_LOOKUP, null, phoneValues);
131                }
132            }
133        }
134    }
135
136    @Override
137    protected int getTypeRank(int type) {
138        switch (type) {
139            case Phone.TYPE_MOBILE: return 0;
140            case Phone.TYPE_WORK: return 1;
141            case Phone.TYPE_HOME: return 2;
142            case Phone.TYPE_PAGER: return 3;
143            case Phone.TYPE_CUSTOM: return 4;
144            case Phone.TYPE_OTHER: return 5;
145            case Phone.TYPE_FAX_WORK: return 6;
146            case Phone.TYPE_FAX_HOME: return 7;
147            default: return 1000;
148        }
149    }
150
151    @Override
152    public boolean containsSearchableColumns(ContentValues values) {
153        return values.containsKey(Phone.NUMBER);
154    }
155
156    @Override
157    public void appendSearchableData(IndexBuilder builder) {
158        String number = builder.getString(Phone.NUMBER);
159        String normalizedNumber = PhoneNumberUtils.normalizeNumber(number);
160        if (TextUtils.isEmpty(normalizedNumber)) {
161            return;
162        }
163
164        builder.appendToken(normalizedNumber);
165
166        String numberE164 = PhoneNumberUtils.formatNumberToE164(
167                number, mDbHelper.getCurrentCountryIso());
168        if (numberE164 != null && !numberE164.equals(normalizedNumber)) {
169            builder.appendToken(numberE164);
170        }
171    }
172}
173