android/incallui/CallerInfoAsyncQuery.java

/*
 * 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 "";
        }
    }
}