1 /* 2 * Copyright (C) 2015 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 package com.android.messaging.datamodel; 17 18 import android.database.Cursor; 19 import android.database.MatrixCursor; 20 import android.provider.ContactsContract.CommonDataKinds.Phone; 21 import android.support.v4.util.SimpleArrayMap; 22 23 import com.android.messaging.util.Assert; 24 import com.android.messaging.util.ContactUtil; 25 26 import java.util.ArrayList; 27 import java.util.Collections; 28 import java.util.Comparator; 29 30 /** 31 * A cursor builder that takes the frequent contacts cursor and aggregate it with the all contacts 32 * cursor to fill in contact details such as phone numbers and strip away invalid contacts. 33 * 34 * Because the frequent contact list depends on the loading of two cursors, it needs to temporarily 35 * store the cursor that it receives with setFrequents() and setAllContacts() calls. Because it 36 * doesn't know which one will be finished first, it always checks whether both cursors are ready 37 * to pull data from and construct the aggregate cursor when it's ready to do so. Note that 38 * this cursor builder doesn't assume ownership of the cursors passed in - it merely references 39 * them and always does a isClosed() check before consuming them. The ownership still belongs to 40 * the loader framework and the cursor may be closed when the UI is torn down. 41 */ 42 public class FrequentContactsCursorBuilder { 43 private Cursor mAllContactsCursor; 44 private Cursor mFrequentContactsCursor; 45 46 /** 47 * Sets the frequent contacts cursor as soon as it is loaded, or null if it's reset. 48 * @return this builder instance for chained operations 49 */ setFrequents(final Cursor frequentContactsCursor)50 public FrequentContactsCursorBuilder setFrequents(final Cursor frequentContactsCursor) { 51 mFrequentContactsCursor = frequentContactsCursor; 52 return this; 53 } 54 55 /** 56 * Sets the all contacts cursor as soon as it is loaded, or null if it's reset. 57 * @return this builder instance for chained operations 58 */ setAllContacts(final Cursor allContactsCursor)59 public FrequentContactsCursorBuilder setAllContacts(final Cursor allContactsCursor) { 60 mAllContactsCursor = allContactsCursor; 61 return this; 62 } 63 64 /** 65 * Reset this builder. Must be called when the consumer resets its data. 66 */ resetBuilder()67 public void resetBuilder() { 68 mAllContactsCursor = null; 69 mFrequentContactsCursor = null; 70 } 71 72 /** 73 * Attempt to build the cursor records from the frequent and all contacts cursor if they 74 * are both ready to be consumed. 75 * @return the frequent contact cursor if built successfully, or null if it can't be built yet. 76 */ build()77 public Cursor build() { 78 if (mFrequentContactsCursor != null && mAllContactsCursor != null) { 79 Assert.isTrue(!mFrequentContactsCursor.isClosed()); 80 Assert.isTrue(!mAllContactsCursor.isClosed()); 81 82 // Frequent contacts cursor has one record per contact, plus it doesn't contain info 83 // such as phone number and type. In order for the records to be usable by Bugle, we 84 // would like to populate it with information from the all contacts cursor. 85 final MatrixCursor retCursor = new MatrixCursor(ContactUtil.PhoneQuery.PROJECTION); 86 87 // First, go through the frequents cursor and take note of all lookup keys and their 88 // corresponding rank in the frequents list. 89 final SimpleArrayMap<String, Integer> lookupKeyToRankMap = 90 new SimpleArrayMap<String, Integer>(); 91 int oldPosition = mFrequentContactsCursor.getPosition(); 92 int rank = 0; 93 mFrequentContactsCursor.moveToPosition(-1); 94 while (mFrequentContactsCursor.moveToNext()) { 95 final String lookupKey = mFrequentContactsCursor.getString( 96 ContactUtil.INDEX_LOOKUP_KEY_FREQUENT); 97 lookupKeyToRankMap.put(lookupKey, rank++); 98 } 99 mFrequentContactsCursor.moveToPosition(oldPosition); 100 101 // Second, go through the all contacts cursor once and retrieve all information 102 // (multiple phone numbers etc.) and store that in an array list. Since the all 103 // contacts list only contains phone contacts, this step will ensure that we filter 104 // out any invalid/email contacts in the frequents list. 105 final ArrayList<Object[]> rows = 106 new ArrayList<Object[]>(mFrequentContactsCursor.getCount()); 107 oldPosition = mAllContactsCursor.getPosition(); 108 mAllContactsCursor.moveToPosition(-1); 109 while (mAllContactsCursor.moveToNext()) { 110 final String lookupKey = mAllContactsCursor.getString(ContactUtil.INDEX_LOOKUP_KEY); 111 if (lookupKeyToRankMap.containsKey(lookupKey)) { 112 final Object[] row = new Object[ContactUtil.PhoneQuery.PROJECTION.length]; 113 row[ContactUtil.INDEX_DATA_ID] = 114 mAllContactsCursor.getLong(ContactUtil.INDEX_DATA_ID); 115 row[ContactUtil.INDEX_CONTACT_ID] = 116 mAllContactsCursor.getLong(ContactUtil.INDEX_CONTACT_ID); 117 row[ContactUtil.INDEX_LOOKUP_KEY] = 118 mAllContactsCursor.getString(ContactUtil.INDEX_LOOKUP_KEY); 119 row[ContactUtil.INDEX_DISPLAY_NAME] = 120 mAllContactsCursor.getString(ContactUtil.INDEX_DISPLAY_NAME); 121 row[ContactUtil.INDEX_PHOTO_URI] = 122 mAllContactsCursor.getString(ContactUtil.INDEX_PHOTO_URI); 123 row[ContactUtil.INDEX_PHONE_EMAIL] = 124 mAllContactsCursor.getString(ContactUtil.INDEX_PHONE_EMAIL); 125 row[ContactUtil.INDEX_PHONE_EMAIL_TYPE] = 126 mAllContactsCursor.getInt(ContactUtil.INDEX_PHONE_EMAIL_TYPE); 127 row[ContactUtil.INDEX_PHONE_EMAIL_LABEL] = 128 mAllContactsCursor.getString(ContactUtil.INDEX_PHONE_EMAIL_LABEL); 129 rows.add(row); 130 } 131 } 132 mAllContactsCursor.moveToPosition(oldPosition); 133 134 // Now we have a list of rows containing frequent contacts in alphabetical order. 135 // Therefore, sort all the rows according to their actual ranks in the frequents list. 136 Collections.sort(rows, new Comparator<Object[]>() { 137 @Override 138 public int compare(final Object[] lhs, final Object[] rhs) { 139 final String lookupKeyLhs = (String) lhs[ContactUtil.INDEX_LOOKUP_KEY]; 140 final String lookupKeyRhs = (String) rhs[ContactUtil.INDEX_LOOKUP_KEY]; 141 Assert.isTrue(lookupKeyToRankMap.containsKey(lookupKeyLhs) && 142 lookupKeyToRankMap.containsKey(lookupKeyRhs)); 143 final int rankLhs = lookupKeyToRankMap.get(lookupKeyLhs); 144 final int rankRhs = lookupKeyToRankMap.get(lookupKeyRhs); 145 if (rankLhs < rankRhs) { 146 return -1; 147 } else if (rankLhs > rankRhs) { 148 return 1; 149 } else { 150 // Same rank, so it's two contact records for the same contact. 151 // Perform secondary sorting on the phone type. Always place 152 // mobile before everything else. 153 final int phoneTypeLhs = (int) lhs[ContactUtil.INDEX_PHONE_EMAIL_TYPE]; 154 final int phoneTypeRhs = (int) rhs[ContactUtil.INDEX_PHONE_EMAIL_TYPE]; 155 if (phoneTypeLhs == Phone.TYPE_MOBILE && 156 phoneTypeRhs == Phone.TYPE_MOBILE) { 157 return 0; 158 } else if (phoneTypeLhs == Phone.TYPE_MOBILE) { 159 return -1; 160 } else if (phoneTypeRhs == Phone.TYPE_MOBILE) { 161 return 1; 162 } else { 163 // Use the default sort order, i.e. sort by phoneType value. 164 return phoneTypeLhs < phoneTypeRhs ? -1 : 165 (phoneTypeLhs == phoneTypeRhs ? 0 : 1); 166 } 167 } 168 } 169 }); 170 171 // Finally, add all the rows to this cursor. 172 for (final Object[] row : rows) { 173 retCursor.addRow(row); 174 } 175 return retCursor; 176 } 177 return null; 178 } 179 } 180