| /* |
| * Copyright (C) 2006 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 com.google.common.primitives.Longs; |
| |
| import android.Manifest; |
| import android.content.AsyncQueryHandler; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.database.Cursor; |
| import android.database.SQLException; |
| import android.net.Uri; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.provider.ContactsContract; |
| import android.provider.ContactsContract.Directory; |
| import android.telephony.PhoneNumberUtils; |
| import android.text.TextUtils; |
| |
| import com.android.contacts.common.ContactsUtils; |
| import com.android.contacts.common.compat.DirectoryCompat; |
| import com.android.contacts.common.util.PermissionsUtil; |
| import com.android.contacts.common.util.TelephonyManagerUtils; |
| import com.android.dialer.R; |
| import com.android.dialer.calllog.ContactInfoHelper; |
| import com.android.dialer.service.CachedNumberLookupService; |
| import com.android.dialer.service.CachedNumberLookupService.CachedContactInfo; |
| import com.android.dialerbind.ObjectFactory; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Locale; |
| |
| /** |
| * Helper class to make it easier to run asynchronous caller-id lookup queries. |
| * @see CallerInfo |
| * |
| */ |
| public class CallerInfoAsyncQuery { |
| private static final boolean DBG = false; |
| private static final String LOG_TAG = "CallerInfoAsyncQuery"; |
| |
| private static final int EVENT_NEW_QUERY = 1; |
| private static final int EVENT_ADD_LISTENER = 2; |
| private static final int EVENT_END_OF_QUEUE = 3; |
| private static final int EVENT_EMERGENCY_NUMBER = 4; |
| private static final int EVENT_VOICEMAIL_NUMBER = 5; |
| |
| private CallerInfoAsyncQueryHandler mHandler; |
| |
| // If the CallerInfo query finds no contacts, should we use the |
| // PhoneNumberOfflineGeocoder to look up a "geo description"? |
| // (TODO: This could become a flag in config.xml if it ever needs to be |
| // configured on a per-product basis.) |
| private static final boolean ENABLE_UNKNOWN_NUMBER_GEO_DESCRIPTION = true; |
| |
| /** |
| * Interface for a CallerInfoAsyncQueryHandler result return. |
| */ |
| public interface OnQueryCompleteListener { |
| /** |
| * Called when the query is complete. |
| */ |
| public void onQueryComplete(int token, Object cookie, CallerInfo ci); |
| } |
| |
| |
| /** |
| * Wrap the cookie from the WorkerArgs with additional information needed by our |
| * classes. |
| */ |
| private static final class CookieWrapper { |
| public OnQueryCompleteListener listener; |
| public Object cookie; |
| public int event; |
| public String number; |
| } |
| |
| /** |
| * Simple exception used to communicate problems with the query pool. |
| */ |
| public static class QueryPoolException extends SQLException { |
| public QueryPoolException(String error) { |
| super(error); |
| } |
| } |
| |
| /** |
| * Our own implementation of the AsyncQueryHandler. |
| */ |
| private class CallerInfoAsyncQueryHandler extends AsyncQueryHandler { |
| |
| @Override |
| public void startQuery(int token, Object cookie, Uri uri, String[] projection, |
| String selection, String[] selectionArgs, String orderBy) { |
| if (DBG) { |
| // Show stack trace with the arguments. |
| android.util.Log.d(LOG_TAG, "InCall: startQuery: url=" + uri + |
| " projection=[" + Arrays.toString(projection) + "]" + |
| " selection=" + selection + " " + |
| " args=[" + Arrays.toString(selectionArgs) + "]", |
| new RuntimeException("STACKTRACE")); |
| } |
| super.startQuery(token, cookie, uri, projection, selection, selectionArgs, orderBy); |
| } |
| |
| /** |
| * The information relevant to each CallerInfo query. Each query may have multiple |
| * listeners, so each AsyncCursorInfo is associated with 2 or more CookieWrapper |
| * objects in the queue (one with a new query event, and one with a end event, with |
| * 0 or more additional listeners in between). |
| */ |
| private Context mQueryContext; |
| private Uri mQueryUri; |
| private CallerInfo mCallerInfo; |
| |
| /** |
| * Our own query worker thread. |
| * |
| * This thread handles the messages enqueued in the looper. The normal sequence |
| * of events is that a new query shows up in the looper queue, followed by 0 or |
| * more add listener requests, and then an end request. Of course, these requests |
| * can be interlaced with requests from other tokens, but is irrelevant to this |
| * handler since the handler has no state. |
| * |
| * Note that we depend on the queue to keep things in order; in other words, the |
| * looper queue must be FIFO with respect to input from the synchronous startQuery |
| * calls and output to this handleMessage call. |
| * |
| * This use of the queue is required because CallerInfo objects may be accessed |
| * multiple times before the query is complete. All accesses (listeners) must be |
| * queued up and informed in order when the query is complete. |
| */ |
| protected class CallerInfoWorkerHandler extends WorkerHandler { |
| public CallerInfoWorkerHandler(Looper looper) { |
| super(looper); |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| WorkerArgs args = (WorkerArgs) msg.obj; |
| CookieWrapper cw = (CookieWrapper) args.cookie; |
| |
| if (cw == null) { |
| // Normally, this should never be the case for calls originating |
| // from within this code. |
| // However, if there is any code that this Handler calls (such as in |
| // super.handleMessage) that DOES place unexpected messages on the |
| // queue, then we need pass these messages on. |
| Log.d(this, "Unexpected command (CookieWrapper is null): " + msg.what + |
| " ignored by CallerInfoWorkerHandler, passing onto parent."); |
| |
| super.handleMessage(msg); |
| } else { |
| Log.d(this, "Processing event: " + cw.event + " token (arg1): " + msg.arg1 + |
| " command: " + msg.what + " query URI: " + |
| sanitizeUriToString(args.uri)); |
| |
| switch (cw.event) { |
| case EVENT_NEW_QUERY: |
| //start the sql command. |
| super.handleMessage(msg); |
| break; |
| |
| // shortcuts to avoid query for recognized numbers. |
| case EVENT_EMERGENCY_NUMBER: |
| case EVENT_VOICEMAIL_NUMBER: |
| |
| case EVENT_ADD_LISTENER: |
| case EVENT_END_OF_QUEUE: |
| // query was already completed, so just send the reply. |
| // passing the original token value back to the caller |
| // on top of the event values in arg1. |
| Message reply = args.handler.obtainMessage(msg.what); |
| reply.obj = args; |
| reply.arg1 = msg.arg1; |
| |
| reply.sendToTarget(); |
| |
| break; |
| default: |
| } |
| } |
| } |
| } |
| |
| |
| /** |
| * Asynchronous query handler class for the contact / callerinfo object. |
| */ |
| private CallerInfoAsyncQueryHandler(Context context) { |
| super(context.getContentResolver()); |
| } |
| |
| @Override |
| protected Handler createHandler(Looper looper) { |
| return new CallerInfoWorkerHandler(looper); |
| } |
| |
| /** |
| * Overrides onQueryComplete from AsyncQueryHandler. |
| * |
| * This method takes into account the state of this class; we construct the CallerInfo |
| * object only once for each set of listeners. When the query thread has done its work |
| * and calls this method, we inform the remaining listeners in the queue, until we're |
| * out of listeners. Once we get the message indicating that we should expect no new |
| * listeners for this CallerInfo object, we release the AsyncCursorInfo back into the |
| * pool. |
| */ |
| @Override |
| protected void onQueryComplete(int token, Object cookie, Cursor cursor) { |
| try { |
| Log.d(this, "##### onQueryComplete() ##### query complete for token: " + token); |
| |
| //get the cookie and notify the listener. |
| CookieWrapper cw = (CookieWrapper) cookie; |
| if (cw == null) { |
| // Normally, this should never be the case for calls originating |
| // from within this code. |
| // However, if there is any code that calls this method, we should |
| // check the parameters to make sure they're viable. |
| Log.d(this, "Cookie is null, ignoring onQueryComplete() request."); |
| return; |
| } |
| |
| if (cw.event == EVENT_END_OF_QUEUE) { |
| release(); |
| return; |
| } |
| |
| // check the token and if needed, create the callerinfo object. |
| if (mCallerInfo == null) { |
| if ((mQueryContext == null) || (mQueryUri == null)) { |
| throw new QueryPoolException |
| ("Bad context or query uri, or CallerInfoAsyncQuery already released."); |
| } |
| |
| // adjust the callerInfo data as needed, and only if it was set from the |
| // initial query request. |
| // Change the callerInfo number ONLY if it is an emergency number or the |
| // voicemail number, and adjust other data (including photoResource) |
| // accordingly. |
| if (cw.event == EVENT_EMERGENCY_NUMBER) { |
| // Note we're setting the phone number here (refer to javadoc |
| // comments at the top of CallerInfo class). |
| mCallerInfo = new CallerInfo().markAsEmergency(mQueryContext); |
| } else if (cw.event == EVENT_VOICEMAIL_NUMBER) { |
| mCallerInfo = new CallerInfo().markAsVoiceMail(mQueryContext); |
| } else { |
| mCallerInfo = CallerInfo.getCallerInfo(mQueryContext, mQueryUri, cursor); |
| Log.d(this, "==> Got mCallerInfo: " + mCallerInfo); |
| |
| CallerInfo newCallerInfo = CallerInfo.doSecondaryLookupIfNecessary( |
| mQueryContext, cw.number, mCallerInfo); |
| if (newCallerInfo != mCallerInfo) { |
| mCallerInfo = newCallerInfo; |
| Log.d(this, "#####async contact look up with numeric username" |
| + mCallerInfo); |
| } |
| |
| // Final step: look up the geocoded description. |
| if (ENABLE_UNKNOWN_NUMBER_GEO_DESCRIPTION) { |
| // Note we do this only if we *don't* have a valid name (i.e. if |
| // no contacts matched the phone number of the incoming call), |
| // since that's the only case where the incoming-call UI cares |
| // about this field. |
| // |
| // (TODO: But if we ever want the UI to show the geoDescription |
| // even when we *do* match a contact, we'll need to either call |
| // updateGeoDescription() unconditionally here, or possibly add a |
| // new parameter to CallerInfoAsyncQuery.startQuery() to force |
| // the geoDescription field to be populated.) |
| |
| if (TextUtils.isEmpty(mCallerInfo.name)) { |
| // Actually when no contacts match the incoming phone number, |
| // the CallerInfo object is totally blank here (i.e. no name |
| // *or* phoneNumber). So we need to pass in cw.number as |
| // a fallback number. |
| mCallerInfo.updateGeoDescription(mQueryContext, cw.number); |
| } |
| } |
| |
| // Use the number entered by the user for display. |
| if (!TextUtils.isEmpty(cw.number)) { |
| mCallerInfo.phoneNumber = PhoneNumberUtils.formatNumber(cw.number, |
| mCallerInfo.normalizedNumber, |
| TelephonyManagerUtils.getCurrentCountryIso(mQueryContext, |
| Locale.getDefault())); |
| } |
| } |
| |
| Log.d(this, "constructing CallerInfo object for token: " + token); |
| |
| //notify that we can clean up the queue after this. |
| CookieWrapper endMarker = new CookieWrapper(); |
| endMarker.event = EVENT_END_OF_QUEUE; |
| startQuery(token, endMarker, null, null, null, null, null); |
| } |
| |
| //notify the listener that the query is complete. |
| if (cw.listener != null) { |
| Log.d(this, "notifying listener: " + cw.listener.getClass().toString() + |
| " for token: " + token + mCallerInfo); |
| cw.listener.onQueryComplete(token, cw.cookie, mCallerInfo); |
| } |
| } finally { |
| // The cursor may have been closed in CallerInfo.getCallerInfo() |
| if (cursor != null && !cursor.isClosed()) { |
| cursor.close(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Private constructor for factory methods. |
| */ |
| private CallerInfoAsyncQuery() { |
| } |
| |
| public static void startQuery(final int token, final Context context, final CallerInfo info, |
| final OnQueryCompleteListener listener, final Object cookie) { |
| Log.d(LOG_TAG, "##### CallerInfoAsyncQuery startContactProviderQuery()... #####"); |
| Log.d(LOG_TAG, "- number: " + info.phoneNumber); |
| Log.d(LOG_TAG, "- cookie: " + cookie); |
| if (!PermissionsUtil.hasPermission(context, Manifest.permission.READ_CONTACTS)) { |
| Log.w(LOG_TAG, "Dialer doesn't have permission to read contacts."); |
| listener.onQueryComplete(token, cookie, info); |
| return; |
| } |
| |
| OnQueryCompleteListener contactsProviderQueryCompleteListener = |
| new OnQueryCompleteListener() { |
| @Override |
| public void onQueryComplete(int token, Object cookie, CallerInfo ci) { |
| Log.d(LOG_TAG, "contactsProviderQueryCompleteListener done"); |
| // If there are no other directory queries, make sure that the listener is |
| // notified of this result. see b/27621628 |
| if ((ci != null && ci.contactExists) || |
| !startOtherDirectoriesQuery(token, context, info, listener, cookie)) { |
| if (listener != null && ci != null) { |
| listener.onQueryComplete(token, cookie, ci); |
| } |
| } |
| } |
| }; |
| startDefaultDirectoryQuery(token, context, info, contactsProviderQueryCompleteListener, |
| cookie); |
| } |
| |
| // Private methods |
| private static CallerInfoAsyncQuery startDefaultDirectoryQuery(int token, Context context, |
| CallerInfo info, OnQueryCompleteListener listener, Object cookie) { |
| // Construct the URI object and query params, and start the query. |
| Uri uri = ContactInfoHelper.getContactInfoLookupUri(info.phoneNumber); |
| return startQueryInternal(token, context, info, listener, cookie, uri); |
| } |
| |
| /** |
| * Factory method to start the query based on a CallerInfo object. |
| * |
| * Note: if the number contains an "@" character we treat it |
| * as a SIP address, and look it up directly in the Data table |
| * rather than using the PhoneLookup table. |
| * TODO: But eventually we should expose two separate methods, one for |
| * numbers and one for SIP addresses, and then have |
| * PhoneUtils.startGetCallerInfo() decide which one to call based on |
| * the phone type of the incoming connection. |
| */ |
| private static CallerInfoAsyncQuery startQueryInternal(int token, Context context, |
| CallerInfo info, OnQueryCompleteListener listener, Object cookie, Uri contactRef) { |
| if (DBG) { |
| Log.d(LOG_TAG, "==> contactRef: " + sanitizeUriToString(contactRef)); |
| } |
| |
| CallerInfoAsyncQuery c = new CallerInfoAsyncQuery(); |
| c.allocate(context, contactRef); |
| |
| //create cookieWrapper, start query |
| CookieWrapper cw = new CookieWrapper(); |
| cw.listener = listener; |
| cw.cookie = cookie; |
| cw.number = info.phoneNumber; |
| |
| // check to see if these are recognized numbers, and use shortcuts if we can. |
| if (PhoneNumberUtils.isLocalEmergencyNumber(context, info.phoneNumber)) { |
| cw.event = EVENT_EMERGENCY_NUMBER; |
| } else if (info.isVoiceMailNumber()) { |
| cw.event = EVENT_VOICEMAIL_NUMBER; |
| } else { |
| cw.event = EVENT_NEW_QUERY; |
| } |
| |
| |
| String[] proejection = CallerInfo.getDefaultPhoneLookupProjection(contactRef); |
| c.mHandler.startQuery(token, |
| cw, // cookie |
| contactRef, // uri |
| proejection, // projection |
| null, // selection |
| null, // selectionArgs |
| null); // orderBy |
| return c; |
| } |
| |
| // Return value indicates if listener was notified. |
| private static boolean startOtherDirectoriesQuery(int token, Context context, CallerInfo info, |
| OnQueryCompleteListener listener, Object cookie) { |
| long[] directoryIds = getDirectoryIds(context); |
| int size = directoryIds.length; |
| if (size == 0) { |
| return false; |
| } |
| |
| DirectoryQueryCompleteListenerFactory listenerFactory = |
| new DirectoryQueryCompleteListenerFactory(context, size, listener); |
| |
| // The current implementation of multiple async query runs in single handler thread |
| // in AsyncQueryHandler. |
| // intermediateListener.onQueryComplete is also called from the same caller thread. |
| // TODO(b/26019872): use thread pool instead of single thread. |
| for (int i = 0; i < size; i++) { |
| long directoryId = directoryIds[i]; |
| Uri uri = ContactInfoHelper.getContactInfoLookupUri(info.phoneNumber, directoryId); |
| if (DBG) { |
| Log.d(LOG_TAG, "directoryId: " + directoryId + " uri: " + uri); |
| } |
| OnQueryCompleteListener intermediateListener = |
| listenerFactory.newListener(directoryId); |
| startQueryInternal(token, context, info, intermediateListener, cookie, uri); |
| } |
| return true; |
| } |
| |
| /* Directory lookup related code - START */ |
| private static final String[] DIRECTORY_PROJECTION = new String[] {Directory._ID}; |
| |
| private static long[] getDirectoryIds(Context context) { |
| ArrayList<Long> results = new ArrayList<>(); |
| |
| Uri uri = Directory.CONTENT_URI; |
| if (ContactsUtils.FLAG_N_FEATURE) { |
| uri = Uri.withAppendedPath(ContactsContract.AUTHORITY_URI, "directories_enterprise"); |
| } |
| |
| ContentResolver cr = context.getContentResolver(); |
| Cursor cursor = cr.query(uri, DIRECTORY_PROJECTION, null, null, null); |
| addDirectoryIdsFromCursor(cursor, results); |
| |
| return Longs.toArray(results); |
| } |
| |
| private static void addDirectoryIdsFromCursor(Cursor cursor, ArrayList<Long> results) { |
| if (cursor != null) { |
| int idIndex = cursor.getColumnIndex(Directory._ID); |
| while (cursor.moveToNext()) { |
| long id = cursor.getLong(idIndex); |
| if (DirectoryCompat.isRemoteDirectoryId(id)) { |
| results.add(id); |
| } |
| } |
| cursor.close(); |
| } |
| } |
| |
| private static final class DirectoryQueryCompleteListenerFactory { |
| // Make sure listener to be called once and only once |
| private int mCount; |
| private boolean mIsListenerCalled; |
| private final OnQueryCompleteListener mListener; |
| private final Context mContext; |
| private final CachedNumberLookupService mCachedNumberLookupService = |
| ObjectFactory.newCachedNumberLookupService(); |
| |
| private class DirectoryQueryCompleteListener implements OnQueryCompleteListener { |
| private final long mDirectoryId; |
| |
| DirectoryQueryCompleteListener(long directoryId) { |
| mDirectoryId = directoryId; |
| } |
| |
| @Override |
| public void onQueryComplete(int token, Object cookie, CallerInfo ci) { |
| onDirectoryQueryComplete(token, cookie, ci, mDirectoryId); |
| } |
| } |
| |
| DirectoryQueryCompleteListenerFactory(Context context, int size, |
| OnQueryCompleteListener listener) { |
| mCount = size; |
| mListener = listener; |
| mIsListenerCalled = false; |
| mContext = context; |
| } |
| |
| private void onDirectoryQueryComplete(int token, Object cookie, CallerInfo ci, |
| long directoryId) { |
| boolean shouldCallListener = false; |
| synchronized (this) { |
| mCount = mCount - 1; |
| if (!mIsListenerCalled && (ci.contactExists || mCount == 0)) { |
| mIsListenerCalled = true; |
| shouldCallListener = true; |
| } |
| } |
| |
| // Don't call callback in synchronized block because mListener.onQueryComplete may |
| // take long time to complete |
| if (shouldCallListener && mListener != null) { |
| addCallerInfoIntoCache(ci, directoryId); |
| mListener.onQueryComplete(token, cookie, ci); |
| } |
| } |
| |
| private void addCallerInfoIntoCache(CallerInfo ci, long directoryId) { |
| if (ci.contactExists && mCachedNumberLookupService != null) { |
| // 1. Cache caller info |
| CachedContactInfo cachedContactInfo = CallerInfoUtils |
| .buildCachedContactInfo(mCachedNumberLookupService, ci); |
| String directoryLabel = mContext.getString(R.string.directory_search_label); |
| cachedContactInfo.setDirectorySource(directoryLabel, directoryId); |
| mCachedNumberLookupService.addContact(mContext, cachedContactInfo); |
| |
| // 2. Cache photo |
| if (ci.contactDisplayPhotoUri != null && ci.normalizedNumber != null) { |
| try (InputStream in = mContext.getContentResolver() |
| .openInputStream(ci.contactDisplayPhotoUri)) { |
| if (in != null) { |
| mCachedNumberLookupService.addPhoto(mContext, ci.normalizedNumber, in); |
| } |
| } catch (IOException e) { |
| Log.e(LOG_TAG, "failed to fetch directory contact photo", e); |
| } |
| |
| } |
| } |
| } |
| |
| public OnQueryCompleteListener newListener(long directoryId) { |
| return new DirectoryQueryCompleteListener(directoryId); |
| } |
| } |
| /* Directory lookup related code - END */ |
| |
| /** |
| * Method to create a new CallerInfoAsyncQueryHandler object, ensuring correct |
| * state of context and uri. |
| */ |
| private void allocate(Context context, Uri contactRef) { |
| if ((context == null) || (contactRef == null)){ |
| throw new QueryPoolException("Bad context or query uri."); |
| } |
| mHandler = new CallerInfoAsyncQueryHandler(context); |
| mHandler.mQueryContext = context; |
| mHandler.mQueryUri = contactRef; |
| } |
| |
| /** |
| * Releases the relevant data. |
| */ |
| private void release() { |
| mHandler.mQueryContext = null; |
| mHandler.mQueryUri = null; |
| mHandler.mCallerInfo = null; |
| mHandler = null; |
| } |
| |
| private static String sanitizeUriToString(Uri uri) { |
| if (uri != null) { |
| String uriString = uri.toString(); |
| int indexOfLastSlash = uriString.lastIndexOf('/'); |
| if (indexOfLastSlash > 0) { |
| return uriString.substring(0, indexOfLastSlash) + "/xxxxxxx"; |
| } else { |
| return uriString; |
| } |
| } else { |
| return ""; |
| } |
| } |
| } |