1 /* 2 * Copyright (C) 2016 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 17 package android.car.cluster.demorenderer; 18 19 import static android.provider.ContactsContract.Contacts.openContactPhotoInputStream; 20 21 import android.annotation.Nullable; 22 import android.content.ContentResolver; 23 import android.content.ContentUris; 24 import android.content.Context; 25 import android.content.CursorLoader; 26 import android.content.Loader; 27 import android.content.Loader.OnLoadCompleteListener; 28 import android.content.res.Resources; 29 import android.database.Cursor; 30 import android.graphics.Bitmap; 31 import android.graphics.BitmapFactory; 32 import android.graphics.BitmapFactory.Options; 33 import android.graphics.Rect; 34 import android.net.Uri; 35 import android.os.AsyncTask; 36 import android.provider.ContactsContract; 37 import android.provider.ContactsContract.CommonDataKinds.Phone; 38 import android.provider.ContactsContract.PhoneLookup; 39 import android.telephony.PhoneNumberUtils; 40 import android.telephony.TelephonyManager; 41 import android.text.TextUtils; 42 import android.util.Log; 43 import android.util.LruCache; 44 45 import java.io.InputStream; 46 import java.lang.ref.WeakReference; 47 import java.util.HashMap; 48 import java.util.HashSet; 49 import java.util.Locale; 50 import java.util.Set; 51 52 /** 53 * Class that provides contact information. 54 */ 55 class PhoneBook { 56 57 private final static String TAG = PhoneBook.class.getSimpleName(); 58 59 private final ContentResolver mContentResolver; 60 private final Context mContext; 61 private final TelephonyManager mTelephonyManager; 62 private final Object mSyncContact = new Object(); 63 private final Object mSyncPhoto = new Object(); 64 65 private volatile String mVoiceMail; 66 67 private static final String[] CONTACT_ID_PROJECTION = new String[] { 68 PhoneLookup.DISPLAY_NAME, 69 PhoneLookup.TYPE, 70 PhoneLookup.LABEL, 71 PhoneLookup._ID 72 }; 73 74 private HashMap<String, Contact> mContactByNumber; 75 private LruCache<Integer, Bitmap> mContactPhotoById; 76 private Set<Integer> mContactsWithoutImage; 77 78 PhoneBook(Context context, TelephonyManager telephonyManager) { 79 mContentResolver = context.getContentResolver(); 80 mContext = context; 81 mTelephonyManager = telephonyManager; 82 } 83 84 /** 85 * Formats provided number according to current locale. 86 * */ 87 public static String getFormattedNumber(String number) { 88 if (TextUtils.isEmpty(number)) { 89 return ""; 90 } 91 92 String countryIso = Locale.getDefault().getCountry(); 93 if (countryIso == null || countryIso.length() != 2) { 94 countryIso = "US"; 95 } 96 String e164 = PhoneNumberUtils.formatNumberToE164(number, countryIso); 97 String formattedNumber = PhoneNumberUtils.formatNumber(number, e164, countryIso); 98 formattedNumber = TextUtils.isEmpty(formattedNumber) ? number : formattedNumber; 99 return formattedNumber; 100 } 101 102 /** 103 * Loads contact details for a given phone number asynchronously. It may call listener's 104 * callback function immediately if there were image in the cache. 105 */ 106 public void getContactDetailsAsync(String number, ContactLoadedListener listener) { 107 if (number == null || number.isEmpty()) { 108 listener.onContactLoaded(number, null); 109 return; 110 } 111 112 synchronized (mSyncContact) { 113 if (mContactByNumber == null) { 114 mContactByNumber = new HashMap<>(); 115 } else if (mContactByNumber.containsKey(number)) { 116 listener.onContactLoaded(number, mContactByNumber.get(number)); 117 return; 118 } 119 } 120 121 fetchContactAsync(number, listener); 122 } 123 124 /** 125 * Loads photo for a given contactId asynchronously. It may call listener's callback function 126 * immediately if there were image in the cache. 127 */ 128 public void getContactPictureAsync(int contactId, ContactPhotoLoadedListener listener) { 129 synchronized (mSyncPhoto) { 130 if (mContactsWithoutImage != null && mContactsWithoutImage.contains(contactId)) { 131 listener.onPhotoLoaded(contactId, null); 132 return; 133 } 134 135 if (mContactPhotoById == null) { 136 mContactPhotoById = new LruCache<Integer, Bitmap>(4 << 20 /* 4mb */) { 137 @Override 138 protected int sizeOf(Integer key, Bitmap value) { 139 return value.getByteCount(); 140 } 141 }; 142 } else { 143 Bitmap photo = mContactPhotoById.get(contactId); 144 if (photo != null) { 145 listener.onPhotoLoaded(contactId, photo); 146 return; 147 } 148 } 149 } 150 151 fetchPhotoAsync(contactId, listener); 152 } 153 154 /** Returns true if given phone number is a voice mail number. */ 155 public boolean isVoicemail(String number) { 156 return !TextUtils.isEmpty(number) && number.equals(getVoiceMailNumber()); 157 } 158 159 @Nullable 160 private String getVoiceMailNumber() { 161 if (mVoiceMail == null) { 162 mVoiceMail = mTelephonyManager.getVoiceMailNumber(); 163 } 164 165 return mVoiceMail; 166 } 167 168 interface ContactLoadedListener { 169 void onContactLoaded(String number, @Nullable Contact contact); 170 } 171 172 interface ContactPhotoLoadedListener { 173 void onPhotoLoaded(int contactId, @Nullable Bitmap picture); 174 } 175 176 private void fetchContactAsync(String number, ContactLoadedListener listener) { 177 CursorLoader cursorLoader = new CursorLoader(mContext); 178 cursorLoader.setUri(Uri.withAppendedPath( 179 PhoneLookup.CONTENT_FILTER_URI, 180 Uri.encode(number))); 181 cursorLoader.setProjection(CONTACT_ID_PROJECTION); 182 cursorLoader.registerListener(0, new LoadCompleteListener(this, number, listener)); 183 cursorLoader.startLoading(); 184 } 185 186 private void fetchPhotoAsync(int contactId, ContactPhotoLoadedListener listener) { 187 LoadPhotoAsyncTask.createAndExecute(this, contactId, listener); 188 } 189 190 private void cacheContactPhoto(int contactId, Bitmap bitmap) { 191 synchronized (mSyncPhoto) { 192 if (bitmap != null) { 193 mContactPhotoById.put(contactId, bitmap); 194 } else { 195 if (mContactsWithoutImage == null) { 196 mContactsWithoutImage = new HashSet<>(); 197 } 198 mContactsWithoutImage.add(contactId); 199 } 200 } 201 } 202 203 static class Contact { 204 private final int mId; 205 private final String mName; 206 private final CharSequence mType; 207 private final String mNumber; 208 209 Contact(Resources resources, String number, int id, String name, String label, int type) { 210 mNumber = number; 211 mId = id; 212 mName = name; 213 mType = Phone.getTypeLabel(resources, type, label); 214 } 215 216 int getId() { 217 return mId; 218 } 219 220 public String getName() { 221 return mName; 222 } 223 224 public CharSequence getType() { 225 return mType; 226 } 227 228 public String getNumber() { return mNumber; } 229 } 230 231 private static class LoadPhotoAsyncTask extends AsyncTask<Void, Void, Bitmap> { 232 233 private final WeakReference<PhoneBook> mPhoneBookRef; 234 private final ContactPhotoLoadedListener mListener; 235 private final int mContactId; 236 237 static void createAndExecute(PhoneBook phoneBook, int contactId, 238 ContactPhotoLoadedListener listener) { 239 new LoadPhotoAsyncTask(phoneBook, contactId, listener) 240 .execute(); 241 } 242 243 private LoadPhotoAsyncTask(PhoneBook phoneBook, int contactId, 244 ContactPhotoLoadedListener listener) { 245 mPhoneBookRef = new WeakReference<>(phoneBook); 246 mContactId = contactId; 247 mListener = listener; 248 } 249 250 @Nullable 251 private Bitmap fetchBitmap(int contactId) { 252 Log.d(TAG, "fetchBitmap, contactId: " + contactId); 253 PhoneBook phoneBook = mPhoneBookRef.get(); 254 if (phoneBook == null) { 255 return null; 256 } 257 258 Uri uri = ContentUris.withAppendedId(ContactsContract.Contacts.CONTENT_URI, contactId); 259 InputStream photoDataStream = openContactPhotoInputStream( 260 phoneBook.mContentResolver, uri, true); 261 Log.d(TAG, "fetchBitmap, uri: " + uri); 262 263 Options options = new Options(); 264 options.inPreferQualityOverSpeed = true; 265 options.inScaled = false; 266 Rect nullPadding = null; 267 Bitmap photo = BitmapFactory.decodeStream(photoDataStream, nullPadding, options); 268 if (photo != null) { 269 photo.setDensity(Bitmap.DENSITY_NONE); 270 } 271 Log.d(TAG, "bitmap fetched: " + photo); 272 return photo; 273 } 274 275 @Override 276 protected Bitmap doInBackground(Void... params) { 277 return fetchBitmap(mContactId); 278 } 279 280 @Override 281 protected void onPostExecute(Bitmap bitmap) { 282 PhoneBook phoneBook = mPhoneBookRef.get(); 283 if (phoneBook != null) { 284 phoneBook.cacheContactPhoto(mContactId, bitmap); 285 } 286 mListener.onPhotoLoaded(0, bitmap); 287 } 288 } 289 290 private static class LoadCompleteListener implements OnLoadCompleteListener<Cursor> { 291 private final String mNumber; 292 private final ContactLoadedListener mContactLoadedListener; 293 private final WeakReference<PhoneBook> mPhoneBookRef; 294 295 private LoadCompleteListener(PhoneBook phoneBook, String number, 296 ContactLoadedListener contactLoadedListener) { 297 mPhoneBookRef = new WeakReference<>(phoneBook); 298 mNumber = number; 299 mContactLoadedListener = contactLoadedListener; 300 } 301 302 @Override 303 public void onLoadComplete(Loader<Cursor> loader, Cursor cursor) { 304 Log.d(TAG, "onLoadComplete, cursor: " + cursor); 305 PhoneBook phoneBook = mPhoneBookRef.get(); 306 Contact contact = null; 307 if (cursor != null && phoneBook != null) { 308 try { 309 if (cursor.moveToFirst()) { 310 int id = cursor.getInt(cursor.getColumnIndex(PhoneLookup._ID)); 311 String name = cursor 312 .getString(cursor.getColumnIndex(PhoneLookup.DISPLAY_NAME)); 313 String label = cursor.getString(cursor.getColumnIndex(PhoneLookup.LABEL)); 314 int type = cursor.getInt(cursor.getColumnIndex(PhoneLookup.TYPE)); 315 Resources resources = phoneBook.mContext.getResources(); 316 contact = new Contact(resources, mNumber, id, name, label, type); 317 } 318 } finally { 319 cursor.close(); 320 } 321 322 if (contact != null) { 323 synchronized (phoneBook.mSyncContact) { 324 phoneBook.mContactByNumber.put(mNumber, contact); 325 } 326 } 327 } 328 329 mContactLoadedListener.onContactLoaded(mNumber, contact); 330 } 331 } 332 } 333