/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License */ package com.android.incallui; import android.content.Context; import android.graphics.Bitmap; import android.graphics.drawable.BitmapDrawable; import android.graphics.drawable.Drawable; import android.media.RingtoneManager; import android.net.Uri; import android.os.SystemClock; import android.os.Trace; import android.provider.ContactsContract.CommonDataKinds.Phone; import android.provider.ContactsContract.Contacts; import android.provider.ContactsContract.DisplayNameSources; import android.support.annotation.AnyThread; import android.support.annotation.MainThread; import android.support.annotation.NonNull; import android.support.annotation.Nullable; import android.support.annotation.WorkerThread; import android.support.v4.content.ContextCompat; import android.support.v4.os.UserManagerCompat; import android.telecom.TelecomManager; import android.telephony.PhoneNumberUtils; import android.text.TextUtils; import android.util.ArrayMap; import android.util.ArraySet; import com.android.contacts.common.ContactsUtils; import com.android.dialer.common.Assert; import com.android.dialer.common.concurrent.DialerExecutor; import com.android.dialer.common.concurrent.DialerExecutor.Worker; import com.android.dialer.common.concurrent.DialerExecutorComponent; import com.android.dialer.logging.ContactLookupResult; import com.android.dialer.logging.ContactSource; import com.android.dialer.oem.CequintCallerIdManager; import com.android.dialer.oem.CequintCallerIdManager.CequintCallerIdContact; import com.android.dialer.phonenumbercache.CachedNumberLookupService; import com.android.dialer.phonenumbercache.CachedNumberLookupService.CachedContactInfo; import com.android.dialer.phonenumbercache.ContactInfo; import com.android.dialer.phonenumbercache.PhoneNumberCache; import com.android.dialer.phonenumberutil.PhoneNumberHelper; import com.android.dialer.util.MoreStrings; import com.android.incallui.CallerInfoAsyncQuery.OnQueryCompleteListener; import com.android.incallui.ContactsAsyncHelper.OnImageLoadCompleteListener; import com.android.incallui.bindings.PhoneNumberService; import com.android.incallui.call.DialerCall; import com.android.incallui.incall.protocol.ContactPhotoType; import java.util.Map; import java.util.Objects; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import org.json.JSONException; import org.json.JSONObject; /** * Class responsible for querying Contact Information for DialerCall objects. Can perform * asynchronous requests to the Contact Provider for information as well as respond synchronously * for any data that it currently has cached from previous queries. This class always gets called * from the UI thread so it does not need thread protection. */ public class ContactInfoCache implements OnImageLoadCompleteListener { private static final String TAG = ContactInfoCache.class.getSimpleName(); private static final int TOKEN_UPDATE_PHOTO_FOR_CALL_STATE = 0; private static ContactInfoCache cache = null; private final Context context; private final PhoneNumberService phoneNumberService; // Cache info map needs to be thread-safe since it could be modified by both main thread and // worker thread. private final ConcurrentHashMap infoMap = new ConcurrentHashMap<>(); private final Map> callBacks = new ArrayMap<>(); private int queryId; private final DialerExecutor cachedNumberLookupExecutor; private static class CachedNumberLookupWorker implements Worker { @Nullable @Override public Void doInBackground(@Nullable CnapInformationWrapper input) { if (input == null) { return null; } ContactInfo contactInfo = new ContactInfo(); CachedContactInfo cacheInfo = input.service.buildCachedContactInfo(contactInfo); cacheInfo.setSource(ContactSource.Type.SOURCE_TYPE_CNAP, "CNAP", 0); contactInfo.name = input.cnapName; contactInfo.number = input.number; try { final JSONObject contactRows = new JSONObject() .put( Phone.CONTENT_ITEM_TYPE, new JSONObject().put(Phone.NUMBER, contactInfo.number)); final String jsonString = new JSONObject() .put(Contacts.DISPLAY_NAME, contactInfo.name) .put(Contacts.DISPLAY_NAME_SOURCE, DisplayNameSources.STRUCTURED_NAME) .put(Contacts.CONTENT_ITEM_TYPE, contactRows) .toString(); cacheInfo.setLookupKey(jsonString); } catch (JSONException e) { Log.w(TAG, "Creation of lookup key failed when caching CNAP information"); } input.service.addContact(input.context.getApplicationContext(), cacheInfo); return null; } } private ContactInfoCache(Context context) { Trace.beginSection("ContactInfoCache constructor"); this.context = context; phoneNumberService = Bindings.get(context).newPhoneNumberService(context); cachedNumberLookupExecutor = DialerExecutorComponent.get(this.context) .dialerExecutorFactory() .createNonUiTaskBuilder(new CachedNumberLookupWorker()) .build(); Trace.endSection(); } public static synchronized ContactInfoCache getInstance(Context mContext) { if (cache == null) { cache = new ContactInfoCache(mContext.getApplicationContext()); } return cache; } static ContactCacheEntry buildCacheEntryFromCall(Context context, DialerCall call) { final ContactCacheEntry entry = new ContactCacheEntry(); // TODO: get rid of caller info. final CallerInfo info = CallerInfoUtils.buildCallerInfo(context, call); ContactInfoCache.populateCacheEntry(context, info, entry, call.getNumberPresentation()); return entry; } /** Populate a cache entry from a call (which got converted into a caller info). */ private static void populateCacheEntry( @NonNull Context context, @NonNull CallerInfo info, @NonNull ContactCacheEntry cce, int presentation) { Objects.requireNonNull(info); String displayName = null; String displayNumber = null; String label = null; boolean isSipCall = false; // It appears that there is a small change in behaviour with the // PhoneUtils' startGetCallerInfo whereby if we query with an // empty number, we will get a valid CallerInfo object, but with // fields that are all null, and the isTemporary boolean input // parameter as true. // In the past, we would see a NULL callerinfo object, but this // ends up causing null pointer exceptions elsewhere down the // line in other cases, so we need to make this fix instead. It // appears that this was the ONLY call to PhoneUtils // .getCallerInfo() that relied on a NULL CallerInfo to indicate // an unknown contact. // Currently, info.phoneNumber may actually be a SIP address, and // if so, it might sometimes include the "sip:" prefix. That // prefix isn't really useful to the user, though, so strip it off // if present. (For any other URI scheme, though, leave the // prefix alone.) // TODO: It would be cleaner for CallerInfo to explicitly support // SIP addresses instead of overloading the "phoneNumber" field. // Then we could remove this hack, and instead ask the CallerInfo // for a "user visible" form of the SIP address. String number = info.phoneNumber; if (!TextUtils.isEmpty(number)) { isSipCall = PhoneNumberHelper.isUriNumber(number); if (number.startsWith("sip:")) { number = number.substring(4); } } if (TextUtils.isEmpty(info.name)) { // No valid "name" in the CallerInfo, so fall back to // something else. // (Typically, we promote the phone number up to the "name" slot // onscreen, and possibly display a descriptive string in the // "number" slot.) if (TextUtils.isEmpty(number) && TextUtils.isEmpty(info.cnapName)) { // No name *or* number! Display a generic "unknown" string // (or potentially some other default based on the presentation.) displayName = getPresentationString(context, presentation, info.callSubject); Log.d(TAG, " ==> no name *or* number! displayName = " + displayName); } else if (presentation != TelecomManager.PRESENTATION_ALLOWED) { // This case should never happen since the network should never send a phone # // AND a restricted presentation. However we leave it here in case of weird // network behavior displayName = getPresentationString(context, presentation, info.callSubject); Log.d(TAG, " ==> presentation not allowed! displayName = " + displayName); } else if (!TextUtils.isEmpty(info.cnapName)) { // No name, but we do have a valid CNAP name, so use that. displayName = info.cnapName; info.name = info.cnapName; displayNumber = PhoneNumberHelper.formatNumber(context, number, info.countryIso); Log.d( TAG, " ==> cnapName available: displayName '" + displayName + "', displayNumber '" + displayNumber + "'"); } else { // No name; all we have is a number. This is the typical // case when an incoming call doesn't match any contact, // or if you manually dial an outgoing number using the // dialpad. displayNumber = PhoneNumberHelper.formatNumber(context, number, info.countryIso); Log.d( TAG, " ==> no name; falling back to number:" + " displayNumber '" + Log.pii(displayNumber) + "'"); } } else { // We do have a valid "name" in the CallerInfo. Display that // in the "name" slot, and the phone number in the "number" slot. if (presentation != TelecomManager.PRESENTATION_ALLOWED) { // This case should never happen since the network should never send a name // AND a restricted presentation. However we leave it here in case of weird // network behavior displayName = getPresentationString(context, presentation, info.callSubject); Log.d( TAG, " ==> valid name, but presentation not allowed!" + " displayName = " + displayName); } else { // Causes cce.namePrimary to be set as info.name below. CallCardPresenter will // later determine whether to use the name or nameAlternative when presenting displayName = info.name; cce.nameAlternative = info.nameAlternative; displayNumber = PhoneNumberHelper.formatNumber(context, number, info.countryIso); label = info.phoneLabel; Log.d( TAG, " ==> name is present in CallerInfo: displayName '" + displayName + "', displayNumber '" + displayNumber + "'"); } } cce.namePrimary = displayName; cce.number = displayNumber; cce.location = info.geoDescription; cce.label = label; cce.isSipCall = isSipCall; cce.userType = info.userType; cce.originalPhoneNumber = info.phoneNumber; cce.shouldShowLocation = info.shouldShowGeoDescription; cce.isEmergencyNumber = info.isEmergencyNumber(); cce.isVoicemailNumber = info.isVoiceMailNumber(); if (info.contactExists) { cce.contactLookupResult = info.contactLookupResultType; } } /** Gets name strings based on some special presentation modes and the associated custom label. */ private static String getPresentationString( Context context, int presentation, String customLabel) { String name = context.getString(R.string.unknown); if (!TextUtils.isEmpty(customLabel) && ((presentation == TelecomManager.PRESENTATION_UNKNOWN) || (presentation == TelecomManager.PRESENTATION_RESTRICTED))) { name = customLabel; return name; } else { if (presentation == TelecomManager.PRESENTATION_RESTRICTED) { name = PhoneNumberHelper.getDisplayNameForRestrictedNumber(context); } else if (presentation == TelecomManager.PRESENTATION_PAYPHONE) { name = context.getString(R.string.payphone); } } return name; } ContactCacheEntry getInfo(String callId) { return infoMap.get(callId); } private static final class CnapInformationWrapper { final String number; final String cnapName; final Context context; final CachedNumberLookupService service; CnapInformationWrapper( String number, String cnapName, Context context, CachedNumberLookupService service) { this.number = number; this.cnapName = cnapName; this.context = context; this.service = service; } } void maybeInsertCnapInformationIntoCache( Context context, final DialerCall call, final CallerInfo info) { final CachedNumberLookupService cachedNumberLookupService = PhoneNumberCache.get(context).getCachedNumberLookupService(); if (!UserManagerCompat.isUserUnlocked(context)) { Log.i(TAG, "User locked, not inserting cnap info into cache"); return; } if (cachedNumberLookupService == null || TextUtils.isEmpty(info.cnapName) || infoMap.get(call.getId()) != null) { return; } Log.i(TAG, "Found contact with CNAP name - inserting into cache"); cachedNumberLookupExecutor.executeParallel( new CnapInformationWrapper( call.getNumber(), info.cnapName, context, cachedNumberLookupService)); } /** * Requests contact data for the DialerCall object passed in. Returns the data through callback. * If callback is null, no response is made, however the query is still performed and cached. * * @param callback The function to call back when the call is found. Can be null. */ @MainThread public void findInfo( @NonNull final DialerCall call, final boolean isIncoming, @NonNull ContactInfoCacheCallback callback) { Trace.beginSection("ContactInfoCache.findInfo"); Assert.isMainThread(); Objects.requireNonNull(callback); Trace.beginSection("prepare callback"); final String callId = call.getId(); final ContactCacheEntry cacheEntry = infoMap.get(callId); Set callBacks = this.callBacks.get(callId); // We need to force a new query if phone number has changed. boolean forceQuery = needForceQuery(call, cacheEntry); Trace.endSection(); Log.d(TAG, "findInfo: callId = " + callId + "; forceQuery = " + forceQuery); // If we have a previously obtained intermediate result return that now except needs // force query. if (cacheEntry != null && !forceQuery) { Log.d( TAG, "Contact lookup. In memory cache hit; lookup " + (callBacks == null ? "complete" : "still running")); callback.onContactInfoComplete(callId, cacheEntry); // If no other callbacks are in flight, we're done. if (callBacks == null) { Trace.endSection(); return; } } // If the entry already exists, add callback if (callBacks != null) { Log.d(TAG, "Another query is in progress, add callback only."); callBacks.add(callback); if (!forceQuery) { Log.d(TAG, "No need to query again, just return and wait for existing query to finish"); Trace.endSection(); return; } } else { Log.d(TAG, "Contact lookup. In memory cache miss; searching provider."); // New lookup callBacks = new ArraySet<>(); callBacks.add(callback); this.callBacks.put(callId, callBacks); } Trace.beginSection("prepare query"); /** * Performs a query for caller information. Save any immediate data we get from the query. An * asynchronous query may also be made for any data that we do not already have. Some queries, * such as those for voicemail and emergency call information, will not perform an additional * asynchronous query. */ final CallerInfoQueryToken queryToken = new CallerInfoQueryToken(queryId, callId); queryId++; final CallerInfo callerInfo = CallerInfoUtils.getCallerInfoForCall( context, call, new DialerCallCookieWrapper(callId, call.getNumberPresentation(), call.getCnapName()), new FindInfoCallback(isIncoming, queryToken)); Trace.endSection(); if (cacheEntry != null) { // We should not override the old cache item until the new query is // back. We should only update the queryId. Otherwise, we may see // flicker of the name and image (old cache -> new cache before query // -> new cache after query) cacheEntry.queryId = queryToken.queryId; Log.d(TAG, "There is an existing cache. Do not override until new query is back"); } else { ContactCacheEntry initialCacheEntry = updateCallerInfoInCacheOnAnyThread( callId, call.getNumberPresentation(), callerInfo, false, queryToken); sendInfoNotifications(callId, initialCacheEntry); } Trace.endSection(); } @AnyThread private ContactCacheEntry updateCallerInfoInCacheOnAnyThread( String callId, int numberPresentation, CallerInfo callerInfo, boolean didLocalLookup, CallerInfoQueryToken queryToken) { Trace.beginSection("ContactInfoCache.updateCallerInfoInCacheOnAnyThread"); Log.d( TAG, "updateCallerInfoInCacheOnAnyThread: callId = " + callId + "; queryId = " + queryToken.queryId + "; didLocalLookup = " + didLocalLookup); ContactCacheEntry existingCacheEntry = infoMap.get(callId); Log.d(TAG, "Existing cacheEntry in hashMap " + existingCacheEntry); // Mark it as emergency/voicemail if the cache exists and was emergency/voicemail before the // number changed. if (existingCacheEntry != null) { if (existingCacheEntry.isEmergencyNumber) { callerInfo.markAsEmergency(context); } else if (existingCacheEntry.isVoicemailNumber) { callerInfo.markAsVoiceMail(context); } } int presentationMode = numberPresentation; if (callerInfo.contactExists || callerInfo.isEmergencyNumber() || callerInfo.isVoiceMailNumber()) { presentationMode = TelecomManager.PRESENTATION_ALLOWED; } // We always replace the entry. The only exception is the same photo case. ContactCacheEntry cacheEntry = buildEntry(context, callerInfo, presentationMode); cacheEntry.queryId = queryToken.queryId; if (didLocalLookup) { if (cacheEntry.displayPhotoUri != null) { // When the difference between 2 numbers is only the prefix (e.g. + or IDD), // we will still trigger force query so that the number can be updated on // the calling screen. We need not query the image again if the previous // query already has the image to avoid flickering. if (existingCacheEntry != null && existingCacheEntry.displayPhotoUri != null && existingCacheEntry.displayPhotoUri.equals(cacheEntry.displayPhotoUri) && existingCacheEntry.photo != null) { Log.d(TAG, "Same picture. Do not need start image load."); cacheEntry.photo = existingCacheEntry.photo; cacheEntry.photoType = existingCacheEntry.photoType; return cacheEntry; } Log.d(TAG, "Contact lookup. Local contact found, starting image load"); // Load the image with a callback to update the image state. // When the load is finished, onImageLoadComplete() will be called. cacheEntry.hasPendingQuery = true; ContactsAsyncHelper.startObtainPhotoAsync( TOKEN_UPDATE_PHOTO_FOR_CALL_STATE, context, cacheEntry.displayPhotoUri, ContactInfoCache.this, queryToken); } Log.d(TAG, "put entry into map: " + cacheEntry); infoMap.put(callId, cacheEntry); } else { // Don't overwrite if there is existing cache. Log.d(TAG, "put entry into map if not exists: " + cacheEntry); infoMap.putIfAbsent(callId, cacheEntry); } Trace.endSection(); return cacheEntry; } private void maybeUpdateFromCequintCallerId( CallerInfo callerInfo, String cnapName, boolean isIncoming) { if (!CequintCallerIdManager.isCequintCallerIdEnabled(context)) { return; } if (callerInfo.phoneNumber == null) { return; } CequintCallerIdContact cequintCallerIdContact = CequintCallerIdManager.getCequintCallerIdContactForCall( context, callerInfo.phoneNumber, cnapName, isIncoming); if (cequintCallerIdContact == null) { return; } boolean hasUpdate = false; if (TextUtils.isEmpty(callerInfo.name) && !TextUtils.isEmpty(cequintCallerIdContact.name())) { callerInfo.name = cequintCallerIdContact.name(); hasUpdate = true; } if (!TextUtils.isEmpty(cequintCallerIdContact.geolocation())) { callerInfo.geoDescription = cequintCallerIdContact.geolocation(); callerInfo.shouldShowGeoDescription = true; hasUpdate = true; } // Don't overwrite photo in local contacts. if (!callerInfo.contactExists && callerInfo.contactDisplayPhotoUri == null && cequintCallerIdContact.photoUri() != null) { callerInfo.contactDisplayPhotoUri = Uri.parse(cequintCallerIdContact.photoUri()); hasUpdate = true; } // Set contact to exist to avoid phone number service lookup. if (hasUpdate) { callerInfo.contactExists = true; callerInfo.contactLookupResultType = ContactLookupResult.Type.CEQUINT; } } /** * Implemented for ContactsAsyncHelper.OnImageLoadCompleteListener interface. Update contact photo * when image is loaded in worker thread. */ @WorkerThread @Override public void onImageLoaded(int token, Drawable photo, Bitmap photoIcon, Object cookie) { Assert.isWorkerThread(); CallerInfoQueryToken myCookie = (CallerInfoQueryToken) cookie; final String callId = myCookie.callId; final int queryId = myCookie.queryId; if (!isWaitingForThisQuery(callId, queryId)) { return; } loadImage(photo, photoIcon, cookie); } private void loadImage(Drawable photo, Bitmap photoIcon, Object cookie) { Log.d(TAG, "Image load complete with context: ", context); // TODO: may be nice to update the image view again once the newer one // is available on contacts database. CallerInfoQueryToken myCookie = (CallerInfoQueryToken) cookie; final String callId = myCookie.callId; ContactCacheEntry entry = infoMap.get(callId); if (entry == null) { Log.e(TAG, "Image Load received for empty search entry."); clearCallbacks(callId); return; } Log.d(TAG, "setting photo for entry: ", entry); // Conference call icons are being handled in CallCardPresenter. if (photo != null) { Log.v(TAG, "direct drawable: ", photo); entry.photo = photo; entry.photoType = ContactPhotoType.CONTACT; } else if (photoIcon != null) { Log.v(TAG, "photo icon: ", photoIcon); entry.photo = new BitmapDrawable(context.getResources(), photoIcon); entry.photoType = ContactPhotoType.CONTACT; } else { Log.v(TAG, "unknown photo"); entry.photo = null; entry.photoType = ContactPhotoType.DEFAULT_PLACEHOLDER; } } /** * Implemented for ContactsAsyncHelper.OnImageLoadCompleteListener interface. make sure that the * call state is reflected after the image is loaded. */ @MainThread @Override public void onImageLoadComplete(int token, Drawable photo, Bitmap photoIcon, Object cookie) { Assert.isMainThread(); CallerInfoQueryToken myCookie = (CallerInfoQueryToken) cookie; final String callId = myCookie.callId; final int queryId = myCookie.queryId; if (!isWaitingForThisQuery(callId, queryId)) { return; } sendImageNotifications(callId, infoMap.get(callId)); clearCallbacks(callId); } /** Blows away the stored cache values. */ public void clearCache() { infoMap.clear(); callBacks.clear(); queryId = 0; } private ContactCacheEntry buildEntry(Context context, CallerInfo info, int presentation) { final ContactCacheEntry cce = new ContactCacheEntry(); populateCacheEntry(context, info, cce, presentation); // This will only be true for emergency numbers if (info.photoResource != 0) { cce.photo = ContextCompat.getDrawable(context, info.photoResource); } else if (info.isCachedPhotoCurrent) { if (info.cachedPhoto != null) { cce.photo = info.cachedPhoto; cce.photoType = ContactPhotoType.CONTACT; } else { cce.photoType = ContactPhotoType.DEFAULT_PLACEHOLDER; } } else { cce.displayPhotoUri = info.contactDisplayPhotoUri; cce.photo = null; } if (info.lookupKeyOrNull != null && info.contactIdOrZero != 0) { cce.lookupUri = Contacts.getLookupUri(info.contactIdOrZero, info.lookupKeyOrNull); } else { Log.v(TAG, "lookup key is null or contact ID is 0 on M. Don't create a lookup uri."); cce.lookupUri = null; } cce.lookupKey = info.lookupKeyOrNull; cce.contactRingtoneUri = info.contactRingtoneUri; if (cce.contactRingtoneUri == null || Uri.EMPTY.equals(cce.contactRingtoneUri)) { cce.contactRingtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE); } return cce; } /** Sends the updated information to call the callbacks for the entry. */ @MainThread private void sendInfoNotifications(String callId, ContactCacheEntry entry) { Trace.beginSection("ContactInfoCache.sendInfoNotifications"); Assert.isMainThread(); final Set callBacks = this.callBacks.get(callId); if (callBacks != null) { for (ContactInfoCacheCallback callBack : callBacks) { callBack.onContactInfoComplete(callId, entry); } } Trace.endSection(); } @MainThread private void sendImageNotifications(String callId, ContactCacheEntry entry) { Trace.beginSection("ContactInfoCache.sendImageNotifications"); Assert.isMainThread(); final Set callBacks = this.callBacks.get(callId); if (callBacks != null && entry.photo != null) { for (ContactInfoCacheCallback callBack : callBacks) { callBack.onImageLoadComplete(callId, entry); } } Trace.endSection(); } private void clearCallbacks(String callId) { callBacks.remove(callId); } /** Callback interface for the contact query. */ public interface ContactInfoCacheCallback { void onContactInfoComplete(String callId, ContactCacheEntry entry); void onImageLoadComplete(String callId, ContactCacheEntry entry); } /** This is cached contact info, which should be the ONLY info used by UI. */ public static class ContactCacheEntry { public String namePrimary; public String nameAlternative; public String number; public String location; public String label; public Drawable photo; @ContactPhotoType int photoType; boolean isSipCall; // Note in cache entry whether this is a pending async loading action to know whether to // wait for its callback or not. boolean hasPendingQuery; /** Either a display photo or a thumbnail URI. */ Uri displayPhotoUri; public Uri lookupUri; // Sent to NotificationMananger public String lookupKey; public ContactLookupResult.Type contactLookupResult = ContactLookupResult.Type.NOT_FOUND; public long userType = ContactsUtils.USER_TYPE_CURRENT; Uri contactRingtoneUri; /** Query id to identify the query session. */ int queryId; /** The phone number without any changes to display to the user (ex: cnap...) */ String originalPhoneNumber; boolean shouldShowLocation; boolean isBusiness; boolean isEmergencyNumber; boolean isVoicemailNumber; public boolean isLocalContact() { return contactLookupResult == ContactLookupResult.Type.LOCAL_CONTACT; } @Override public String toString() { return "ContactCacheEntry{" + "name='" + MoreStrings.toSafeString(namePrimary) + '\'' + ", nameAlternative='" + MoreStrings.toSafeString(nameAlternative) + '\'' + ", number='" + MoreStrings.toSafeString(number) + '\'' + ", location='" + MoreStrings.toSafeString(location) + '\'' + ", label='" + label + '\'' + ", photo=" + photo + ", isSipCall=" + isSipCall + ", displayPhotoUri=" + displayPhotoUri + ", contactLookupResult=" + contactLookupResult + ", userType=" + userType + ", contactRingtoneUri=" + contactRingtoneUri + ", queryId=" + queryId + ", originalPhoneNumber=" + originalPhoneNumber + ", shouldShowLocation=" + shouldShowLocation + ", isEmergencyNumber=" + isEmergencyNumber + ", isVoicemailNumber=" + isVoicemailNumber + '}'; } } private static final class DialerCallCookieWrapper { final String callId; final int numberPresentation; final String cnapName; DialerCallCookieWrapper(String callId, int numberPresentation, String cnapName) { this.callId = callId; this.numberPresentation = numberPresentation; this.cnapName = cnapName; } } private class FindInfoCallback implements OnQueryCompleteListener { private final boolean isIncoming; private final CallerInfoQueryToken queryToken; FindInfoCallback(boolean isIncoming, CallerInfoQueryToken queryToken) { this.isIncoming = isIncoming; this.queryToken = queryToken; } @Override public void onDataLoaded(int token, Object cookie, CallerInfo ci) { Assert.isWorkerThread(); DialerCallCookieWrapper cw = (DialerCallCookieWrapper) cookie; if (!isWaitingForThisQuery(cw.callId, queryToken.queryId)) { return; } long start = SystemClock.uptimeMillis(); maybeUpdateFromCequintCallerId(ci, cw.cnapName, isIncoming); long time = SystemClock.uptimeMillis() - start; Log.d(TAG, "Cequint Caller Id look up takes " + time + " ms."); updateCallerInfoInCacheOnAnyThread(cw.callId, cw.numberPresentation, ci, true, queryToken); } @Override public void onQueryComplete(int token, Object cookie, CallerInfo callerInfo) { Trace.beginSection("ContactInfoCache.FindInfoCallback.onQueryComplete"); Assert.isMainThread(); DialerCallCookieWrapper cw = (DialerCallCookieWrapper) cookie; String callId = cw.callId; if (!isWaitingForThisQuery(cw.callId, queryToken.queryId)) { Trace.endSection(); return; } ContactCacheEntry cacheEntry = infoMap.get(callId); // This may happen only when InCallPresenter attempt to cleanup. if (cacheEntry == null) { Log.w(TAG, "Contact lookup done, but cache entry is not found."); clearCallbacks(callId); Trace.endSection(); return; } // Before issuing a request for more data from other services, we only check that the // contact wasn't found in the local DB. We don't check the if the cache entry already // has a name because we allow overriding cnap data with data from other services. if (!callerInfo.contactExists && phoneNumberService != null) { Log.d(TAG, "Contact lookup. Local contacts miss, checking remote"); final PhoneNumberServiceListener listener = new PhoneNumberServiceListener(callId, queryToken.queryId); cacheEntry.hasPendingQuery = true; phoneNumberService.getPhoneNumberInfo(cacheEntry.number, listener); } sendInfoNotifications(callId, cacheEntry); if (!cacheEntry.hasPendingQuery) { if (callerInfo.contactExists) { Log.d(TAG, "Contact lookup done. Local contact found, no image."); } else { Log.d( TAG, "Contact lookup done. Local contact not found and" + " no remote lookup service available."); } clearCallbacks(callId); } Trace.endSection(); } } class PhoneNumberServiceListener implements PhoneNumberService.NumberLookupListener { private final String callId; private final int queryIdOfRemoteLookup; PhoneNumberServiceListener(String callId, int queryId) { this.callId = callId; queryIdOfRemoteLookup = queryId; } @Override public void onPhoneNumberInfoComplete(final PhoneNumberService.PhoneNumberInfo info) { Log.d(TAG, "PhoneNumberServiceListener.onPhoneNumberInfoComplete"); if (!isWaitingForThisQuery(callId, queryIdOfRemoteLookup)) { return; } // If we got a miss, this is the end of the lookup pipeline, // so clear the callbacks and return. if (info == null) { Log.d(TAG, "Contact lookup done. Remote contact not found."); clearCallbacks(callId); return; } ContactCacheEntry entry = new ContactCacheEntry(); entry.namePrimary = info.getDisplayName(); entry.number = info.getNumber(); entry.contactLookupResult = info.getLookupSource(); entry.isBusiness = info.isBusiness(); final int type = info.getPhoneType(); final String label = info.getPhoneLabel(); if (type == Phone.TYPE_CUSTOM) { entry.label = label; } else { final CharSequence typeStr = Phone.getTypeLabel(context.getResources(), type, label); entry.label = typeStr == null ? null : typeStr.toString(); } final ContactCacheEntry oldEntry = infoMap.get(callId); if (oldEntry != null) { // Location is only obtained from local lookup so persist // the value for remote lookups. Once we have a name this // field is no longer used; it is persisted here in case // the UI is ever changed to use it. entry.location = oldEntry.location; entry.shouldShowLocation = oldEntry.shouldShowLocation; // Contact specific ringtone is obtained from local lookup. entry.contactRingtoneUri = oldEntry.contactRingtoneUri; entry.originalPhoneNumber = oldEntry.originalPhoneNumber; } // If no image and it's a business, switch to using the default business avatar. if (info.getImageUrl() == null && info.isBusiness()) { Log.d(TAG, "Business has no image. Using default."); entry.photoType = ContactPhotoType.BUSINESS; } Log.d(TAG, "put entry into map: " + entry); infoMap.put(callId, entry); sendInfoNotifications(callId, entry); entry.hasPendingQuery = info.getImageUrl() != null; // If there is no image then we should not expect another callback. if (!entry.hasPendingQuery) { // We're done, so clear callbacks clearCallbacks(callId); } } } private boolean needForceQuery(DialerCall call, ContactCacheEntry cacheEntry) { if (call == null || call.isConferenceCall()) { return false; } String newPhoneNumber = PhoneNumberUtils.stripSeparators(call.getNumber()); if (cacheEntry == null) { // No info in the map yet so it is the 1st query Log.d(TAG, "needForceQuery: first query"); return true; } String oldPhoneNumber = PhoneNumberUtils.stripSeparators(cacheEntry.originalPhoneNumber); if (!TextUtils.equals(oldPhoneNumber, newPhoneNumber)) { Log.d(TAG, "phone number has changed: " + oldPhoneNumber + " -> " + newPhoneNumber); return true; } return false; } private static final class CallerInfoQueryToken { final int queryId; final String callId; CallerInfoQueryToken(int queryId, String callId) { this.queryId = queryId; this.callId = callId; } } /** Check if the queryId in the cached map is the same as the one from query result. */ private boolean isWaitingForThisQuery(String callId, int queryId) { final ContactCacheEntry existingCacheEntry = infoMap.get(callId); if (existingCacheEntry == null) { // This might happen if lookup on background thread comes back before the initial entry is // created. Log.d(TAG, "Cached entry is null."); return true; } else { int waitingQueryId = existingCacheEntry.queryId; Log.d(TAG, "waitingQueryId = " + waitingQueryId + "; queryId = " + queryId); return waitingQueryId == queryId; } } }