Android 6.0 Phone"通话显示"查询流程

一、概要

无论是在MT (Mobile Termination Call被叫——来电)，还是MO (Mobile Origination Call主叫——去电) 流程中，通话界面上都会显示当前通话的名称( 后文以displayName指代 )。通常情况下，如果是一个陌生号码，则会显示为该陌生号码。如果是已知联系人，则会显示该联系人的名称。当然，在会议电话( Conference Call )的情况下则直接显示”会议电话”。但是，在某些特殊情况下，displayName还会显示诸如”私人号码”、”公用电话”、”未知号码”等。

本文主要分析displayName的获取显示流程及显示”未知号码”的原因

二、查询流程

1、开始查询——CallCardPresenter
displayName是隶属于CallCardFragment的控件，当通话MO/MT流程发起时InCallActivity会显示，此时将会触发CallCardFragment界面更新，在CallCardPresenter的init方法中查询displayName，关键代码如下：
CallCardPresenter.java (\packages\apps\incallui\src\com\android\incallui)

 public void init(Context context, Call call) { // Call may be null if disconnect happened already. if (call != null) { mPrimary = call;
            // start processing lookups right away. if (!call.isConferenceCall()) { startContactInfoSearch(call, CallEnum.PRIMARY, call.getState() == Call.State.INCOMING);
            } else {
                /// M: Modified this for MTK DSDA feature. @{
                /* Google Code: updateContactEntry(null, true); */
                updateContactEntry(null, CallEnum.PRIMARY, true);
                /// @}
            }
        }
    }

startContactInfoSearch的具体代码如下：

    /** * Starts a query for more contact data for the save primary and secondary calls. */
    private void startContactInfoSearch(final Call call, CallEnum type,
            boolean isIncoming) {
        final ContactInfoCache cache = ContactInfoCache.getInstance(mContext);
// ContactInfoCache中开始查找 
        cache.findInfo(call, isIncoming, new ContactLookupCallback(this, type));
    }

2、异步查询——ContactInfoCache
在CallCardPresenter中发起查询之后会跳转到ContactInfoCache.findInfo()方法中，ContactInfoCache不仅用于查询当前通话的相关信息，还可以将这些信息缓存以备下次查询相同信息时快速返回。findInfo关键代码如下：

    /** * Requests contact data for the Call 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. */
    public void findInfo(final Call call, final boolean isIncoming,
            ContactInfoCacheCallback callback) {
// 查询caller信息，完成之后会回调到FindInfoCallback中，会调用findInfoQueryComplete 
        final CallerInfo callerInfo = CallerInfoUtils.getCallerInfoForCall(
                mContext, call, new FindInfoCallback(isIncoming));
// 当查询完毕之后回调并更新ContactEntry，这里最终会去更新界面显示 
        findInfoQueryComplete(call, callerInfo, isIncoming, false);
    }

CallerInfo中包含了当前call的基本信息，比如号码、类型、特殊相关服务等，在获取到这些信息之后再进行进一步的联系人数据库查询。

3、获取CallerInfo——CallerInfoUtils
在getCallerInfoForCall()方法中，除了获取当前Call的基本信息之外，还会根据当前Call的phoneNumber去数据库中查询，关键代码如下：

ContactInfoCache.java (\packages\apps\incallui\src\com\android\incallui)

    /** * This is called to get caller info for a call. This will return a CallerInfo * object immediately based off information in the call, but * more information is returned to the OnQueryCompleteListener (which contains * information about the phone number label, user's name, etc). */
    public static CallerInfo getCallerInfoForCall(Context context, Call call,
            CallerInfoAsyncQuery.OnQueryCompleteListener listener) {
// 获取当前Call的基本信息并创建CallerInfo对象 
        CallerInfo info = buildCallerInfo(context, call);
    // 根据phoneNumber在CallerInfoAsyncQuery中开启具体查询 
        if (info.numberPresentation == TelecomManager.PRESENTATION_ALLOWED) {
            // Start the query with the number provided from the call.
            Log.d(TAG, "==> Actually starting CallerInfoAsyncQuery.startQuery()...");
            CallerInfoAsyncQuery.startQuery(QUERY_TOKEN, context, info, listener, call);
        }
        return info;
    }

在以上代码中，有两个重要的方法，即buildCallerInfo()和CallerInfoAsyncQuery.startQuery()，先查询看buildCallerInfo()的关键代码：

   public static CallerInfo buildCallerInfo(Context context, Call call) {
        CallerInfo info = new CallerInfo();
        // Store CNAP information retrieved from the Connection (we want to do this
        // here regardless of whether the number is empty or not).
// 获取当前Call的CNAP name 
        info.cnapName = call.getCnapName();
        info.name = info.cnapName;
        info.numberPresentation = call.getNumberPresentation();
        info.namePresentation = call.getCnapNamePresentation();
        String number = call.getNumber();
    // 获取当前Call的number，如果不为空则执行 
        if (!TextUtils.isEmpty(number)) {
            final String[] numbers = number.split("&");
            number = numbers[0];
            if (numbers.length > 1) {
                info.forwardingNumber = numbers[1];
            }
// 针对CNAP的情况特殊处理number显示
            number = modifyForSpecialCnapCases(context, info, number, info.numberPresentation);
            info.phoneNumber = number; 
        }
        // Because the InCallUI is immediately launched before the call is connected, occasionally
        // a voicemail call will be passed to InCallUI as a "voicemail:" URI without a number.
        // This call should still be handled as a voicemail call.
        if ((call.getHandle() != null &&
                PhoneAccount.SCHEME_VOICEMAIL.equals(call.getHandle().getScheme())) ||
                isVoiceMailNumber(context, call)) {
            info.markAsVoiceMail(context);
        }
        return info;
    }

如果当前Call的被叫一方没有开通该业务，则cnapName的值返回为空。同时，在buildCallerInfo方法中也对当前Call的number是否为空做了判断。这里的number来自于网络侧的返回，比如作为主叫方，当通话接通后被叫方的号码会通过网络返回，在某些特殊的情况下返回值有可能为空。

注：关于CNAP
CNAP即Calling Name Presentation的缩写，是运营商提供的一种服务。比如，用户开通该服务后，在运营商处设置Calling Name Presentation为”HelloSeven”。当该用户与其他用户通话时，如果对方的手机支持CNAP功能，那么无论对方联系人里是否存入了该号码，displayName都会显示为”HelloSeven”。加拿大的一些运营商有使用该服务，比如Rogers，但目前国内的运营商均不支持该服务。

4、查询数据库——CallerInfoAsyncQuery
当buildCallerInfo()执行完成后，会根据当前Call的number查询本机Contacts数据库。这里以MTK双卡为例，因此会执行CallerInfoAsyncQuery.startQueryEx(QUERY_TOKEN, context, number,listener, call, call.getSlotId())方法，关键代码如下( frameworks/base/telephony/java/com/android/internal/telephony/CallerInfoAsyncQuery.java )：

CallerInfoAsyncQuery.java (\packages\apps\incallui\src\com\android\incallui)

    /** * 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. */
    public static CallerInfoAsyncQuery startQuery(int token, Context context, CallerInfo info,
            OnQueryCompleteListener listener, Object cookie) {
        // Construct the URI object and query params, and start the query.
        final Uri contactRef = PhoneLookup.ENTERPRISE_CONTENT_FILTER_URI.buildUpon()
                .appendPath(info.phoneNumber)
                .appendQueryParameter(PhoneLookup.QUERY_PARAMETER_SIP_ADDRESS,
                        String.valueOf(PhoneNumberHelper.isUriNumber(info.phoneNumber)))
                .build();

        CallerInfoAsyncQuery c = new CallerInfoAsyncQuery();
        c.allocate(context, contactRef);//这里需要注意，allocate会对mHanlder对象进行赋值
        //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.
// 设置查询类型包括：EMERGENCY_NUMBER、VOICEMAIL、NEW_QUERY 
        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;
        }
 // 开始查询 
        c.mHandler.startQuery(token,
                              cw,  // cookie
                              contactRef,  // uri
                              null,  // projection
                              null,  // selection
                              null,  // selectionArgs
                              null);  // orderBy
        return c;
    }

以上代码中主要完成：设置查询对应的数据库表；设置查询类型(紧急号码、语音号码、普通查询)；发起数据库查询。其中c.allocate()方法会对mHandler进行赋值，关键代码如下：

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

当执行c.mHandler.startQuery的时候，会先查询CallerInfoAsyncQuery.CallerInfoAsyncQueryHandler中是否有startQuery方法，之后再跳转到父类AsyncQueryHandler的startQuery方法中( frameworks/base/core/java/android/content/AsyncQueryHandler.java )：

    /**
     * This method begins an asynchronous query. When the query is done
     * {@link #onQueryComplete} is called.
     *
     * @param token A token passed into {@link #onQueryComplete} to identify
     *  the query.
     * @param cookie An object that gets passed into {@link #onQueryComplete}
     * @param uri The URI, using the content:// scheme, for the content to
     *         retrieve.
     * @param projection A list of which columns to return. Passing null will
     *         return all columns, which is discouraged to prevent reading data
     *         from storage that isn't going to be used.
     * @param selection A filter declaring which rows to return, formatted as an
     *         SQL WHERE clause (excluding the WHERE itself). Passing null will
     *         return all rows for the given URI.
     * @param selectionArgs You may include ?s in selection, which will be
     *         replaced by the values from selectionArgs, in the order that they
     *         appear in the selection. The values will be bound as Strings.
     * @param orderBy How to order the rows, formatted as an SQL ORDER BY
     *         clause (excluding the ORDER BY itself). Passing null will use the
     *         default sort order, which may be unordered.
     */
    public void startQuery(int token, Object cookie, Uri uri,
            String[] projection, String selection, String[] selectionArgs,
            String orderBy) {
        // Use the token as what so cancelOperations works properly
        Message msg = mWorkerThreadHandler.obtainMessage(token);
//类型为EVENT_ARG_QUERY
        msg.arg1 = EVENT_ARG_QUERY;
        WorkerArgs args = new WorkerArgs();
    //从CallerInfoAsyncQuery.CallerInfoAsyncQueryHandler跳转到AsyncQueryHandler，因此这里的this是CallerInfoAsyncQuery.CallerInfoAsyncQueryHandler对象 
        args.handler = this;
        args.uri = uri;
        args.projection = projection;
        args.selection = selection;
        args.selectionArgs = selectionArgs;
        args.orderBy = orderBy;
        args.cookie = cookie;
        msg.obj = args;
//这里的mWorkerThreadHandler的实例在 
        mWorkerThreadHandler.sendMessage(msg);
    }

最后通过mWorkerThreadHandler.sendMessage()方法跳转到CallerInfoAsyncQuery.CallerInfoAsyncQueryHandler.CallerInfoWorkerHandler的handleMessage方法中，关键代码如下：

       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;
//这里的cw在startQueryEx中进行了设置，不为null
                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) {
//此时event为NEW_QUERY
                        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:
                    }
                }
            }
        }

如果只是普通的号码查询，则执行case EVENT_NEW_QUERY，回调到父类AsyncQueryHandler.WorkerHandler的handleMessage方法中：

AsyncQueryHandler.java (alps\frameworks\base\core\java\android\content)

   protected class WorkerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (event) {
                case EVENT_ARG_QUERY:
                    Cursor cursor;
                    try {
// 查询Contacts数据库中的PhoneLookup表 
                        cursor = resolver.query(args.uri, args.projection,
                                args.selection, args.selectionArgs,
                                args.orderBy);
                        // Calling getCount() causes the cursor window to be filled,
                        // which will make the first access on the main thread a lot faster.
                        if (cursor != null) {
                            cursor.getCount();
                        }
                    } catch (Exception e) {
                        Log.w(TAG, "Exception thrown during handling EVENT_ARG_QUERY", e);
                        cursor = null;
                    }
// 将查询结果保存到args中 
                    args.result = cursor;
                    break;
                case EVENT_ARG_INSERT:
                    args.result = resolver.insert(args.uri, args.values);
                    break;
                case EVENT_ARG_UPDATE:
                    args.result = resolver.update(args.uri, args.values, args.selection,
                            args.selectionArgs);
                    break;
                case EVENT_ARG_DELETE:
                    args.result = resolver.delete(args.uri, args.selection, args.selectionArgs);
                    break;
            }
            // passing the original token value back to the caller
            // on top of the event values in arg1.
        //注意：这里的args.handler对象实际上是CallerInfoAsyncQuery.CallerInfoAsyncQueryHandler的实例 
            Message reply = args.handler.obtainMessage(token);
            reply.obj = args;
            reply.arg1 = msg.arg1;
            if (localLOGV) {
                Log.d(TAG, "WorkerHandler.handleMsg: msg.arg1=" + msg.arg1
                        + ", reply.what=" + reply.what);
            }
            reply.sendToTarget();
        }
    }

在WorkHandler中查询完毕之后，执行args.handler.obtainMessage()，这里的args.handler实际上是CallerInfoAsyncQuery.CallerInfoAsyncQueryHandler的实例，但在CallerInfoAsyncQuery.CallerInfoAsyncQueryHandler中并没有handleMessage方法，因此回调其父类AsyncQueryHandler的handleMessage方法：

    @Override
    public void handleMessage(Message msg) {
        // pass token back to caller on each callback.
        switch (event) {
// 查询完毕之后执行
            case EVENT_ARG_QUERY:
                onQueryComplete(token, args.cookie, (Cursor) args.result);
                break;
            case EVENT_ARG_INSERT:
                onInsertComplete(token, args.cookie, (Uri) args.result);
                break;
            case EVENT_ARG_UPDATE:
                onUpdateComplete(token, args.cookie, (Integer) args.result);
                break;
            case EVENT_ARG_DELETE:
                onDeleteComplete(token, args.cookie, (Integer) args.result);
                break;
        }
    }

onQueryComplete方法可以看做this.onQueryComplete，而this来源于CallerInfoAsyncQuery.CallerInfoAsyncQueryHandler。因此，这里会回调到CallerInfoAsyncQuery.CallerInfoAsyncQueryHandler的onQueryComplete方法中，关键代码如下：

       @Override
        protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
            try {
                //get the cookie and notify the listener.
                CookieWrapper cw = (CookieWrapper) cookie;
                //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();
                }
            }
        }
    }

以上代码中的cw.listener来自于CallerInfoAsyncQuery.startQueryEx()，在ContactInfoCache.findInfo()中可以看到，listener实际为ContactInfoCache.FindInfoCallback的对象：

final CallerInfo callerInfo = CallerInfoUtils.getCallerInfoForCall(
        mContext, identification, new FindInfoCallback(isIncoming));
private class FindInfoCallback implements CallerInfoAsyncQuery.OnQueryCompleteListener {
    private final boolean mIsIncoming;
    public FindInfoCallback(boolean isIncoming) {
        mIsIncoming = isIncoming;
    }
    @Override
    public void onQueryComplete(int token, Object cookie, CallerInfo callerInfo) {
        final CallIdentification identification = (CallIdentification) cookie;
        findInfoQueryComplete(identification, callerInfo, mIsIncoming, true);
    }
}

也就是说查询完成之后会回调到ContactInfoCache.FindInfoCallback的onQueryComplete()方法中，并执行ContactInfoCache.findInfoQueryComplete()。
5、完善查询结果——ContactInfoCache
经过各种回调之后，终于将查询结果返回到ContactInfoCache.findInfoQueryComplete方法中，该方法主要用于将查询结果封装为ContactCacheEntry对象，并发起查询完毕的回调，关键代码如下：

private void findInfoQueryComplete(CallIdentification identification,
        CallerInfo callerInfo, boolean isIncoming, boolean didLocalLookup) {
    //将查询结果保存到ContactCacheEntry中
    final ContactCacheEntry cacheEntry = buildEntry(mContext, callId,
            callerInfo, presentationMode, isIncoming);
    //将cacheEntry对应与之相对的callId
    mInfoMap.put(callId, cacheEntry);
    if(!mExpiredInfoMap.containsKey(callId)) {
        //将查询完成的消息通知到相应的回调方法
        sendInfoNotifications(callId, cacheEntry);
    }
    //... ...省略
}

注意以下两点：
①. buildEntry()会将最终的显示内容准备好，以供后续使用；
②. sendInfoNotifications()发起回调，通知相关listener“查询完毕可供显示”；
查看buildEntry()的关键代码如下：

    private ContactCacheEntry buildEntry(Context context, String callId,
            CallerInfo info, int presentation, boolean isIncoming) {
        // The actual strings we're going to display onscreen:
        Drawable photo = null;
//构造ContatcCacheEntry
        final ContactCacheEntry cce = new ContactCacheEntry();
        populateCacheEntry(context, info, cce, presentation, isIncoming);

        // This will only be true for emergency numbers
        if (info.photoResource != 0) {
            photo = context.getResources().getDrawable(info.photoResource);
        } else if (info.isCachedPhotoCurrent) {
            if (info.cachedPhoto != null) {
                photo = info.cachedPhoto;
            } else {
                photo = context.getResources().getDrawable(R.drawable.picture_unknown);
                photo.setAutoMirrored(true);
            }
        } else if (info.contactDisplayPhotoUri == null) {
            photo = context.getResources().getDrawable(R.drawable.picture_unknown);
            photo.setAutoMirrored(true);
        } else {
            cce.displayPhotoUri = info.contactDisplayPhotoUri;
        }
        //mod-start by depeng.li for bug 39488 on 2015.12.23
        //if (info.lookupKeyOrNull == null || info.contactIdOrZero == 0) {
        // Log.v(TAG, "lookup key is null or contact ID is 0. Don't create a lookup uri.");
        // cce.lookupUri = null;
        //} else {
            cce.lookupUri = Contacts.getLookupUri(info.contactIdOrZero, info.lookupKeyOrNull);
        //}
        //mod-end by depeng.li for bug 39488 on 2015.12.23
        cce.photo = photo;
        cce.lookupKey = info.lookupKeyOrNull;
        return cce;
    }

在buildEntry方法中，主要是调用populateCacheEntry()完成ContactCacheEntry对象的构造，同时会对紧急号码做一些处理。populateCacheEntry()关键代码如下：

public static void populateCacheEntry(Context context, CallerInfo info, ContactCacheEntry cce,  
        int presentation, boolean isIncoming) {  
    Preconditions.checkNotNull(info);  
    String displayName = null;  
    String displayNumber = null;  
    String displayLocation = null;  
    String label = null;  
    boolean isSipCall = false;  
        String number = info.phoneNumber;  
        if (!TextUtils.isEmpty(number)) {  
            isSipCall = PhoneNumberUtils.isUriNumber(number);  
            if (number.startsWith("sip:")) {  
                number = number.substring(4);  
            }  
        }  
        // 如果CallerInfo的name为空则执行 
        // 通过前面的分析可以知道，CallerInfo的name默认赋值为cnapName，而 
        // cnapName并不是每个运营商都会支持。因此大多数情况下返回为空 
        if (TextUtils.isEmpty(info.name)) {  
            if (TextUtils.isEmpty(number)) {  
                // 如果CallerInfo的number也为空则表明当前通话为特殊通话 
                // 特殊通话需要显示Unknown PayPhone Private等特殊字段 
                displayName = getPresentationString(context, presentation);  
            } else if (presentation != Call.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);  
            } else if (!TextUtils.isEmpty(info.cnapName)) {  
                // 如果cnapName不为空，则将displayName设置未cnapName 
                displayName = info.cnapName;  
                info.name = info.cnapName;  
                displayNumber = number;  
            } else {  
                // 如果当前通话的号码并未存储到用户的联系人列表中，将displayNumber设置为 
                // 对应的号码，后面显示的时候会判断，如果displayName为空的话，就显示displayNumber 
                displayNumber = number;  
                  if (isIncoming) {  
                    // 如果是来电，则显示号码归属地相关信息 
                      displayLocation = info.geoDescription; // may be null 
                  }  
            }  
        } else {  
            // 如果info.name不为空，则表示之前的cnapName赋值成功，则将结果直接显示 
            if (presentation != Call.PRESENTATION_ALLOWED) {  
                displayName = getPresentationString(context, presentation);  
            } else {  
                displayName = info.name;  
                displayNumber = number;  
                label = info.phoneLabel;  
            }  
        }  
    // 最后将显示结果存放到ContactCacheEntry对象中 
    cce.name = displayName;  
    cce.number = displayNumber;  
    cce.location = displayLocation;  
    cce.label = label;  
    cce.isSipCall = isSipCall;  
}  

通过以上方法将ContactCacheEntry对象构造完成之后，InCallActivity显示界面所需要的内容已经准备好，此时会调用sendInfoNotifications()发起回调通知，关键代码如下：
ContactInfoCache.java (\packages\apps\incallui\src\com\android\incallui)

    /** * Sends the updated information to call the callbacks for the entry. */
    private void sendInfoNotifications(String callId, ContactCacheEntry entry) {
        final Set<ContactInfoCacheCallback> callBacks = mCallBacks.get(callId);
        Log.d(TAG, "onContactInfoComplete sendInfoNotifications()...");     
        if (callBacks != null) {
            for (ContactInfoCacheCallback callBack : callBacks) {
// 回调所有的onContactInfoComplete方法
                callBack.onContactInfoComplete(callId, entry);
            }
        }
    }

CallCardPresenter.java (\packages\apps\incallui\src\com\android\incallui)

    /** * Starts a query for more contact data for the save primary and secondary calls. */
//在CallCardPresenter的startContactInfoSearch方法里，发起联系人查询时 
//在new ContactInfoCacheCallback()中匿名实现了onContactInfoComplete() 
    private void startContactInfoSearch(final Call call, CallEnum type,
            boolean isIncoming) {
        final ContactInfoCache cache = ContactInfoCache.getInstance(mContext);
//在ContactInfoCache的findInfo方法中添加ContactInfoCacheCallback 
        cache.findInfo(call, isIncoming, new ContactLookupCallback(this, type));
    }

当数据库查询结束后，最终会通过CallCardPresenter.updateContactEntry()方法来更新界面，关键代码如下：

   /** * Update the contact entry and view with specified view type. * * @param entry * @param type Includes the following three types: PRIMARY/SECONDARY/THIRD. * @param isConference */
// 显示的信息是从ContactCacheEntry 获取的
    private void updateContactEntry(ContactCacheEntry entry, CallEnum type, boolean isConference) {
        switch (type) {
            case PRIMARY:
                mPrimaryContactInfo = entry;
                updatePrimaryDisplayInfo();     
                break;
            case SECONDARY:
                mSecondaryContactInfo = entry;
                updateSecondaryDisplayInfo();
                break;
            case THIRD:
                mThirdContactInfo = entry;
                updateThirdDisplayInfo(isConference);
                break;
            default:
                break;
        }
    }

三、界面显示Unknown的原因
在前面的分析中已经提到，在特殊情况下会显示特殊的displayName：

displayName = getPresentationString(context, presentation);
private static String getPresentationString(Context context, int presentation) {
    String name = context.getString(R.string.unknown);//Unknown 位置号码
    if (presentation == Call.PRESENTATION_RESTRICTED) {
        name = context.getString(R.string.private_num);// Private 私人号码
    } else if (presentation == Call.PRESENTATION_PAYPHONE) {
        name = context.getString(R.string.payphone); //Pay Phone 共用电话
    }
    return name;
}

  这里所说的特殊情况一般指的是运营商提供的一些服务，比如COLP 即Connected Line identification Presentation。该服务国内运营商称为——号码隐藏服务，即当用户开通该业务后，网络侧返回数据中不会包含该用户的号码信息。该服务目前国内运营商均已不再受理，以前办理过该业务的号码持续有效。
  比如一名用户开启了该服务，呼叫该用户，当该用户接通来电后，主叫设备上不会显示对方的号码或者联系人信息，取而代之的是Unknown( 未知号码 )。如果遇到这种情况，可以通过查看相应的AT日志以及Modem日志来分析(注：MTK使用使用的AT Command，QCom使用的ShareMemory与Modem通信)，如图4：

总结
关于InCallUI中displayName的获取需要注意以下三点：
1. 发起点在CallCardPresenter的init方法中，通过startContactInfoSearch()方法开始查询；
2. 查询过程主要分为四步：
①. CallerInfo获取
在CallerInfoUtils.getCallerInfoForCall()方法中获取CallerInfo对象。
②. 联系人数据库查询
在CallerInfoUtils.getCallerInfoForCall()方法中调用CallerInfoAsyncQuery.startQueryEx开启联系人数据库查询。注意：因为MTK在原生AOSP的基础上修改了代码，用以支持双SIM卡，因此有些地方与原生AOSP有些许不同。这里MTK的代码会执行frameworks/base/telephony/java/com/android/internal/telephony/CallerInfoAsyncQuery.java中的startQueryEx，而原生AOSP的代码则会执行packages/app/InCallUI/src/com/android/incallui/CallerInfoAsyncQuery.java中的startQuery。
③. 将查询结果返回
联系人数据库查询完毕之后需要将查询结果返回，并最终回调到ContactInfoCache.FindInfoCallback的onQueryComplete()方法中。
④. 显示displayName
最后通过ContactInfoCache.sendInfoNotifications()方式回调到CallCardPresenter中，并更新界面displayName。
3. 界面显示Unknown的原因，是因为号码为特殊号码，displayName的特殊号码包括：Unknown( 未知号码 )、Private( 私人号码 )、Pay Phone( 共用电话 )。具体原因则有可能是网络返回异常或运营商特殊服务(COLP/CNAP)等。
整个displayName获取并显示流程如图6所示：