devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

安卓10 来电流程梳理_android 来电流程分析

作者：从前慢现在也慢 | 2024-07-28 16:09:59

赞

踩

android 来电流程分析

来电过程， 是由com.android.phone进程发起的，因为 com.android.phone 进程中 Telephony 直接与Moderm层交互， com.android.phone 进程收到来来电消息后，发送消息给 system 进程， system 进程（Telecom作为中介）开始和com.android.phone 进程建立链接， 并通知 UI 进程 (com.android.dialer) 更新。大体上和拨号过程类似。

来电流程时序图：

 

 对于MO Call来说，一般是由用户自己操作来发起的主动动作,可以根据UI上的button来跟踪流程。但是对于MTcall来说，一般是被动的接收modem的消息，不太好从UI的层面来跟踪流程，所以大概的总结下MT流程。

     首先，查来电消息的处理。在来电时，首先是由modem向上上报来电的消息，上层来处理。第一条消息是：RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED，消息报上来后，到RadioIndication.java来处理（在Android O后，UNSOL消息在RadioIndication处理，SOL消息在RadioResponse里处理。替代了之前的processUnsolicited & processSolicited方法）。这条消息就是modem 告知上层：当前Call的状态发送变化了。但是上层并不知道真正的变化是什么，所以Tele回去询问当前Call到底是属于什么状态，发出请求：RIL_REQUEST_GET_CURRENT_CALLS。当Modem得到这些请求后，会将这些信息返回给Tele.

 

从RIL层开始往上追溯，RIL接收底层来电消息。来电的消息属于主动上报的UnSolicited消息,其对应的事件ID是CALL_STATE_CHANGE,我们进入RIL.java开始查找。

UNSOL_RESPONSE_CALL STATE CHANGED状态改变

  1.   @UnsupportedAppUsage
  2. 5692      void unsljLog(int response) {
  3. 5693          riljLog("[UNSL]< " + responseToString(response));
  4. 5694      }
  5.  
  6.  @UnsupportedAppUsage
  7. 5561      static String responseToString(int request) {
  8. 5562          switch(request) {
  9. 5563              case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED:
  10. 5564                  return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
  11. 5565              case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED:
  12. 5566                  return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
  13. 5567              case RIL_UNSOL_RESPONSE_NETWORK_STATE_CHANGED:

  1. frameworks/opt/telephony/src/java/com/android/internal/telephony/RadioIndication.java

RadioIndication 类有17 个方法调用RIL 对象的unsljLog 方法打印消息，处理此
RIL 消息的代码逻辑详情如下：

  1.     public void callStateChanged(int indicationType) {
  2.         mRil.processIndication(indicationType);
  3.  
  4.         if (RIL.RILJ_LOGD) mRil.unsljLog(RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED);
  5.  
  6.         mRil.mCallStateRegistrants.notifyRegistrants();
  7.     }
  1. 调用processIndication向底层发送确认收到消息
  2. notifyRegistrant发出通知

RIL层在接收到底层的消息后，发起了notify通知。----------- 观测者模式

其中：

public class RadioIndication extends IRadioIndication.Stub {

而 mCallStateRegistrants 在：

RIL继承于父类 BaseCommands ，实现了 mCallStateRegistrants 

public class RIL extends BaseCommands implements CommandsInterface 
protected RegistrantList mCallStateRegistrants = new RegistrantList();

此处是： registerForCallStateChanged

搜索到有：

  1. BaseCommands
  2. GsmCdmaCallTracker
  3. CommandsInterface

其中BascCommands,CommandsInterface都是接口

mCalIStateReg istrants. notifyRegistrant 发出通知后，仅一个 地方可响应此消息通知，即GsmCdmaCallTracker 类的handleMessage 方法，本质上是个Handler处理类

跟进GsmCdmaCallTracker的handleMessage方法，可以看到其在初始化的地方注册了CallStateChanged消息的监听，注册的时候传入了自身的handler，notify的时候使用该handler发送消息，所以我们可以在handleMessage中响应并处理EVENT_CALL_STATE_CHANGE消息。

  1.      @Override
  2.     public void handleMessage(Message msg) {
  3.         AsyncResult ar;
  4.  
  5.         switch (msg.what) {
  6.             ...
  7.              case EVENT_CALL_STATE_CHANGE:
  8.                 pollCallsWhenSafe();
  9.  
  10.             ...

pollCallsWhenSafe 调用父类CallTracker 方法

  1.    protected void pollCallsWhenSafe() {
  2.         mNeedsPoll = true;
  3.  
  4.             mLastRelevantPoll = obtainMessage(EVENT_POLL_CALLS_RESULT);
  5.             mCi.getCurrentCalls(mLastRelevantPoll);
  6.         }
  7.     }

发现其又调用了mCi.getCurrentCalls去查询当前的Call情况，此方法会调用到RIL中对应的方法去（Phone创建的时候对mCi进行初始化使得具有RIL通信能力，其mCi即调用RIL.java）

又回到了 RIL 中

  1.     @Override
  2.     public void getCurrentCalls(Message result) {
  3.         IRadio radioProxy = getRadioProxy(result);
  4.         if (radioProxy != null) {
  5.             RILRequest rr = obtainRequest(RIL_REQUEST_GET_CURRENT_CALLS, result,
  6.                     mRILDefaultWorkSource);
  7.  
  8.             if (RILJ_LOGD) {
  9.                 riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
  10.             }
  11.  
  12.             try {
  13.  
  14.               //向底层发起请求
  15.                 radioProxy.getCurrentCalls(rr.mSerial);
  16.             } catch (RemoteException | RuntimeException e) {
  17.                 handleRadioProxyExceptionForRR(rr, "getCurrentCalls", e);
  18.             }
  19.         }
  20.     }

在发送请求后，等待modem返回结果给RIL层，继续跟踪返回消息的接收(省去  与 RIL 层的交互)

 

在RIL.java中查找底层消息反馈的处理方法,发现有两个方法processRespose和processResponseDone，向上追溯发现其是在RadioResponse.java中的

responseCurrentCalls方法 调用了 processResponseDone 方法，如下：

其继承自一个底层的服务 

public class RadioResponse extends IRadioResponse.Stub

CurrentCall的消息继续在responseCurrentCalls方法追踪。

  1.     public void getCurrentCallsResponse(RadioResponseInfo responseInfo,
  2.                                         ArrayList<android.hardware.radio.V1_0.Call> calls) {
  3.         responseCurrentCalls(responseInfo, calls);
  4.     }

继续追踪调用的responseCurrentCalls方法

  1.      private void responseCurrentCalls(RadioResponseInfo responseInfo,
  2.                                       ArrayList<android.hardware.radio.V1_0.Call> calls) {
  3.         RILRequest rr = mRil.processResponse(responseInfo);
  4.  
  5.         if (rr != null) {
  6.             int num = calls.size();
  7.             ArrayList<DriverCall> dcCalls = new ArrayList<DriverCall>(num);
  8.             DriverCall dc;
  9.  
  10.             for (int i = 0; i < num; i++) {
  11.                 dc = new DriverCall();
  12.                 // TODO: change name of function stateFromCLCC() in DriverCall.java to name
  13.                 // clarifying what is CLCC
  14.                 dc.state = DriverCall.stateFromCLCC((int) (calls.get(i).state));
  15.                 dc.index = calls.get(i).index;
  16.                 dc.TOA = calls.get(i).toa;
  17.                 dc.isMpty = calls.get(i).isMpty;
  18.                 dc.isMT = calls.get(i).isMT;
  19.                 dc.als = calls.get(i).als;
  20.                 dc.isVoice = calls.get(i).isVoice;
  21.                 dc.isVoicePrivacy = calls.get(i).isVoicePrivacy;
  22.                 dc.number = calls.get(i).number;
  23.                 dc.numberPresentation =
  24.                         DriverCall.presentationFromCLIP(
  25.                                 (int) (calls.get(i).numberPresentation));
  26.                 dc.name = calls.get(i).name;
  27.                 dc.namePresentation =
  28.                         DriverCall.presentationFromCLIP((int) (calls.get(i).namePresentation));
  29.                 if (calls.get(i).uusInfo.size() == 1) {
  30.                     dc.uusInfo = new UUSInfo();
  31.                     dc.uusInfo.setType(calls.get(i).uusInfo.get(0).uusType);
  32.                     dc.uusInfo.setDcs(calls.get(i).uusInfo.get(0).uusDcs);
  33.                     if (!TextUtils.isEmpty(calls.get(i).uusInfo.get(0).uusData)) {
  34.                         byte[] userData = calls.get(i).uusInfo.get(0).uusData.getBytes();
  35.                         dc.uusInfo.setUserData(userData);
  36.                     } else {
  37.                         mRil.riljLog("responseCurrentCalls: uusInfo data is null or empty");
  38.                     }
  39.  
  40.                     mRil.riljLogv(String.format("Incoming UUS : type=%d, dcs=%d, length=%d",
  41.                             dc.uusInfo.getType(), dc.uusInfo.getDcs(),
  42.                             dc.uusInfo.getUserData().length));
  43.                     mRil.riljLogv("Incoming UUS : data (hex): "
  44.                             + IccUtils.bytesToHexString(dc.uusInfo.getUserData()));
  45.                 } else {
  46.                     mRil.riljLogv("Incoming UUS : NOT present!");
  47.                 }
  48.  
  49.                 // Make sure there's a leading + on addresses with a TOA of 145
  50.                 dc.number = PhoneNumberUtils.stringFromStringAndTOA(dc.number, dc.TOA);
  52.                 dcCalls.add(dc);
  54.                 if (dc.isVoicePrivacy) {
  55.                     mRil.mVoicePrivacyOnRegistrants.notifyRegistrants();
  56.                     mRil.riljLog("InCall VoicePrivacy is enabled");
  57.                 } else {
  58.                     mRil.mVoicePrivacyOffRegistrants.notifyRegistrants();
  59.                     mRil.riljLog("InCall VoicePrivacy is disabled");
  60.                 }
  61.             }
  63.             Collections.sort(dcCalls);
  65.             if ((num == 0) && mRil.mTestingEmergencyCall.getAndSet(false)) {
  66.                 if (mRil.mEmergencyCallbackModeRegistrant != null) {
  67.                     mRil.riljLog("responseCurrentCalls: call ended, testing emergency call,"
  68.                             + " notify ECM Registrants");
  69.                     mRil.mEmergencyCallbackModeRegistrant.notifyRegistrant();
  70.                 }
  71.             }
  72.             //发送返回消息
  73.             if (responseInfo.error == RadioError.NONE) {
  74.                 sendMessageResponse(rr.mResult, dcCalls);
  75.             }
  76.             mRil.processResponseDone(rr, responseInfo, dcCalls);
  77.         }
  78.     }
  79.  发现其通过底层返回的消息创建了dcCalls对象，也就是当前的Call状态信息，对dc状态进行判断后如果有需要就notify通知，如果没有异常则通过sendMessageResponse方法发送消息
  80.      public static void sendMessageResponse(Message msg, Object ret) {
  81.         if (msg != null) {
  82.             AsyncResult.forMessage(msg, ret, null);
  83.             msg.sendToTarget();
  84.         }
  85.     }

继续回到GsmCdmaCallTracker的handleMessage中,之前发送请求的时候有发送EVENT_POLL_CALLS_RESULT，这里我们继续回到该事件处理的地方来分析

  1.     @Override
  2.     public void handleMessage(Message msg) {
  3.         AsyncResult ar;
  4.  
  5.         switch (msg.what) {
  6.             case EVENT_POLL_CALLS_RESULT:
  7.                 Rlog.d(LOG_TAG, "Event EVENT_POLL_CALLS_RESULT Received");
  8.  
  9.                 if (msg == mLastRelevantPoll) {
  10.                     if (DBG_POLL) log(
  11.                             "handle EVENT_POLL_CALL_RESULT: set needsPoll=F");
  12.                     mNeedsPoll = false;
  13.                     mLastRelevantPoll = null;
  14.                     handlePollCalls((AsyncResult)msg.obj);
  15.                 }
  16.             break;

继续追踪handlePollCalls

  1.     @Override
  2.     protected synchronized void handlePollCalls(AsyncResult ar) {
  3.         //解析返回的结果
  4.         for (int i = 0, curDC = 0, dcSize = polledCalls.size()
  5.                 ; i < mConnections.length; i++) {
  6.             GsmCdmaConnection conn = mConnections[i];
  7.             DriverCall dc = null;
  8.  
  9.             // polledCall list is sparse
  10.             if (curDC < dcSize) {
  11.                 dc = (DriverCall) polledCalls.get(curDC);
  12.  
  13.                 if (dc.index == i+1) {
  14.                     curDC++;
  15.                 } else {
  16.                     dc = null;
  17.                 }
  18.             }
  19.             ...
  20.             if (conn == null && dc != null) {
  21.             ...状态的处理及识别
  22.  
  23.         //响铃消息通知
  24.         if (newRinging != null) {
  25.             mPhone.notifyNewRingingConnection(newRinging);
  26.         }
  27.  
  28.         // clear the "local hangup" and "missed/rejected call"
  29.         // cases from the "dropped during poll" list
  30.         // These cases need no "last call fail" reason
  31.         ArrayList<GsmCdmaConnection> locallyDisconnectedConnections = new ArrayList<>();
  32.         for (int i = mDroppedDuringPoll.size() - 1; i >= 0 ; i--) {
  33.             GsmCdmaConnection conn = mDroppedDuringPoll.get(i);
  34.             //CDMA
  35.             boolean wasDisconnected = false;
  36.             //来电处理，本地挂断或者未接，本地挂断的话直接设置挂断的原因为LOCAL或INVALID_NUMBER
  37.             if (conn.isIncoming() && conn.getConnectTime() == 0) {
  38.                 // Missed or rejected call
  39.                 int cause;
  40.                 if (conn.mCause == DisconnectCause.LOCAL) {
  41.                     cause = DisconnectCause.INCOMING_REJECTED;
  42.                 } else {
  43.                     cause = DisconnectCause.INCOMING_MISSED;
  44.                 }
  45.  
  46.                 if (Phone.DEBUG_PHONE) {
  47.                     log("missed/rejected call, conn.cause=" + conn.mCause);
  48.                     log("setting cause to " + cause);
  49.                 }
  50.                 mDroppedDuringPoll.remove(i);
  51.                 hasAnyCallDisconnected |= conn.onDisconnect(cause);
  52.                 wasDisconnected = true;
  53.                 locallyDisconnectedConnections.add(conn);
  54.             } else if (conn.mCause == DisconnectCause.LOCAL
  55.                     || conn.mCause == DisconnectCause.INVALID_NUMBER) {
  56.                 mDroppedDuringPoll.remove(i);
  57.                 hasAnyCallDisconnected |= conn.onDisconnect(conn.mCause);
  58.                 wasDisconnected = true;
  59.                 locallyDisconnectedConnections.add(conn);
  60.             }
  61.  
  62.             if (!isPhoneTypeGsm() && wasDisconnected && unknownConnectionAppeared
  63.                     && conn == newUnknownConnectionCdma) {
  64.                 unknownConnectionAppeared = false;
  65.                 newUnknownConnectionCdma = null;
  66.             }
  67.         }
  68.         if (locallyDisconnectedConnections.size() > 0) {
  69.             mMetrics.writeRilCallList(mPhone.getPhoneId(), locallyDisconnectedConnections);
  70.         }
  71.  
  72.         /* Disconnect any pending Handover connections */
  73.         //通话断开的一些处理操作
  74.         ...
  75.         if (newRinging != null || hasNonHangupStateChanged || hasAnyCallDisconnected) {
  76.             internalClearDisconnected();
  77.         }
  78.         //更新phone状态
  79.         if (VDBG) log("handlePollCalls calling updatePhoneState()");
  80.         updatePhoneState();
  81.  
  82.         ...
  83.  
  84.     }

其先对底层反馈的消息进行解析，获取其通话状态，判断如果是来电则发出notifyNewRingingConnection响铃消息通知，然后进行一些通话断开连接的操作及更新phone状态。继续跟进notifyNewRingingConnection响铃消息，该消息调用的是phone的方法，往上追溯。

继续查看响铃消息通知到何处，全局搜索（registerForNewRingingConnection)，找到

PstnIncommingCallNotifier.java

  1. /**
  2.  * Listens to incoming-call events from the associated phone object and notifies Telecom upon each
  3.  * occurence. One instance of these exists for each of the telephony-based call services.
  4.  */

用来 监听来电消息 

  1.     private final Handler mHandler = new Handler() {
  2.         @Override
  3.         public void handleMessage(Message msg) {
  4.             switch(msg.what) {
  5.                 case EVENT_NEW_RINGING_CONNECTION:
  6.                     handleNewRingingConnection((AsyncResult) msg.obj);
  7.                     break;
  8.                 case EVENT_CDMA_CALL_WAITING:
  9.                     handleCdmaCallWaiting((AsyncResult) msg.obj);
  10.                     break;
  11.                 case EVENT_UNKNOWN_CONNECTION:
  12.                     handleNewUnknownConnection((AsyncResult) msg.obj);
  13.                     break;
  14.                 default:
  15.                     break;
  16.             }
  17.         }
  18.     };

继续调用handleNewRingingConnection方法处理调用sendIncommingCallIntent发送Intent，这里其实就已经从RIL传递消息到了应用层了

  1.  private void handleNewRingingConnection(AsyncResult asyncResult) {
  2.         Log.d(this, "handleNewRingingConnection");
  3.         Connection connection = (Connection) asyncResult.result;
  4.         if (connection != null) {
  5.             Call call = connection.getCall();
  6.             // Check if we have a pending number verification request.
  7.             if (connection.getAddress() != null) {
  8.                 if (NumberVerificationManager.getInstance()
  9.                         .checkIncomingCall(connection.getAddress())) {
  10.                     // Disconnect the call if it matches
  11.                     try {
  12.                         connection.hangup();
  13.                     } catch (CallStateException e) {
  14.                         Log.e(this, e, "Error hanging up potential number verification call");
  15.                     }
  16.                     return;
  17.                 }
  18.             }
  19.  
  20.             // Final verification of the ringing state before sending the intent to Telecom.
  21.             if (call != null && call.getState().isRinging()) {
  22.                 sendIncomingCallIntent(connection);
  23.             }
  24.         }
  25.     }
  1.     private void sendIncomingCallIntent(Connection connection) {
  2.         ------
  3.  
  4.         PhoneAccountHandle handle = findCorrectPhoneAccountHandle();
  5.         if (handle == null) {
  6.             try {
  7.                 connection.hangup();
  8.             } catch (CallStateException e) {
  9.                 // connection already disconnected. Do nothing
  10.             }
  11.         } else {
  12.             TelecomManager.from(mPhone.getContext()).addNewIncomingCall(handle, extras);
  13.         }
  14.     }

//获取telecomm服务，通过aidl接口调用 telecomService 的addNewIncomingCall方法

  1.  //获取telecomm服务
  2.     public static TelecomManager from(Context context) {
  3.         return (TelecomManager) context.getSystemService(Context.TELECOM_SERVICE);
  4.     }

进入到TelecomService层

  1. 108      private final ITelecomService.Stub mBinderImpl = new ITelecomService.Stub() {
  2. 109          @Override
  3.  
  4. 1083          public void addNewIncomingCall(PhoneAccountHandle phoneAccountHandle, Bundle extras) {
  5. 1084              try {
  6. 1085                  Log.startSession("TSI.aNIC");
  7. 1086                  synchronized (mLock) {
  8. 1087                      Log.i(this, "Adding new incoming call with phoneAccountHandle %s",
  9. 1088                              phoneAccountHandle);
  10. 1089                      。。。。。。。。。
  11. 。。。。。。。。。
  12. 1116                          long token = Binder.clearCallingIdentity();
  13. 1117                          try {
  14. 1118                              Intent intent = new Intent(TelecomManager.ACTION_INCOMING_CALL);
  15. 1119                              intent.putExtra(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE,
  16. 1120                                      phoneAccountHandle);
  17. 1121                              intent.putExtra(CallIntentProcessor.KEY_IS_INCOMING_CALL, true);
  18. 1122                              if (extras != null) {
  19. 1123                                  extras.setDefusable(true);
  20. 1124                                  intent.putExtra(TelecomManager.EXTRA_INCOMING_CALL_EXTRAS, extras);
  21. 1125                              }
  22. 1126                              mCallIntentProcessorAdapter.processIncomingCallIntent(
  23. 1127                                      mCallsManager, intent);
  24. 1128                          } finally {
  25. 1129                              Binder.restoreCallingIdentity(token);
  26. 1130                          }
  27. 1131                      } else {
  28. 1132                          Log.w(this, "Null phoneAccountHandle. Ignoring request to add new" +
  29. 1133                                  " incoming call");
  30. 1134                      }
  31. 1135                  }
  32. 1136              } finally {
  33. 1137                  Log.endSession();
  34. 1138              }
  35. 1139          }

继续跟进mCallIntentProcessorAdapter.processIncomingCallIntent,

  1. 287      static void processIncomingCallIntent(CallsManager callsManager, Intent intent) {
  2. 288          PhoneAccountHandle phoneAccountHandle = intent.getParcelableExtra(
  3. 289                  TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE);
  4. 290  
  5. 291          if (phoneAccountHandle == null) {
  6. 292              Log.w(CallIntentProcessor.class,
  7. 293                      "Rejecting incoming call due to null phone account");
  8. 294              return;
  9. 295          }
  10. 296          if (phoneAccountHandle.getComponentName() == null) {
  11. 297              Log.w(CallIntentProcessor.class,
  12. 298                      "Rejecting incoming call due to null component name");
  13. 299              return;
  14. 300          }
  15. 301  
  16. 302          Bundle clientExtras = null;
  17. 303          if (intent.hasExtra(TelecomManager.EXTRA_INCOMING_CALL_EXTRAS)) {
  18. 304              clientExtras = intent.getBundleExtra(TelecomManager.EXTRA_INCOMING_CALL_EXTRAS);
  19. 305          }
  20. 306          if (clientExtras == null) {
  21. 307              clientExtras = new Bundle();
  22. 308          }
  23. 309  
  24. 310          Log.d(CallIntentProcessor.class,
  25. 311                  "Processing incoming call from connection service [%s]",
  26. 312                  phoneAccountHandle.getComponentName());
  27. 313          callsManager.processIncomingCallIntent(phoneAccountHandle, clientExtras);
  28. 314      }

--------------------------------------------------------------------------

下方与拨号相同

进入到CallsManager中继续跟进

  1.     void processIncomingCallIntent(PhoneAccountHandle phoneAccountHandle, Bundle extras) {
  2.         Log.d(this, "processIncomingCallIntent");
  3.         ...
  4.         Call call = new Call(
  5.                 getNextCallId(),
  6.                 mContext,
  7.                 this,
  8.                 mLock,
  9.                 mConnectionServiceRepository,
  10.                 mContactsAsyncHelper,
  11.                 mCallerInfoAsyncQueryFactory,
  12.                 mPhoneNumberUtilsAdapter,
  13.                 handle,
  14.                 null /* gatewayInfo */,
  15.                 null /* connectionManagerPhoneAccount */,
  16.                 phoneAccountHandle,
  17.                 Call.CALL_DIRECTION_INCOMING /* callDirection */,
  18.                 false /* forceAttachToExistingConnection */,
  19.                 false, /* isConference */
  20.                 mClockProxy);
  21.  
  22.         ...
  23.         call的一些状态设置
  24.         ...
  25.         call.initAnalytics();
  26.         if (getForegroundCall() != null) {
  27.             getForegroundCall().getAnalytics().setCallIsInterrupted(true);
  28.             call.getAnalytics().setCallIsAdditional(true);
  29.         }
  30.         setIntentExtrasAndStartTime(call, extras);
  31.         //添加监听
  32.         // TODO: Move this to be a part of addCall()
  33.         call.addListener(this);
  34.  
  35.         if (!isHandoverAllowed || (call.isSelfManaged() && !isIncomingCallPermitted(call,
  36.                 call.getTargetPhoneAccount()))) {
  37.             notifyCreateConnectionFailed(phoneAccountHandle, call);
  38.         } else {
  39.             //成功上报上去建立连接
  40.             call.startCreateConnection(mPhoneAccountRegistrar);
  41.         }
  42.     }

 

  1.     void startCreateConnection(PhoneAccountRegistrar phoneAccountRegistrar) {
  2.         if (mCreateConnectionProcessor != null) {
  3.             Log.w(this, "mCreateConnectionProcessor in startCreateConnection is not null. This is" +
  4.                     " due to a race between NewOutgoingCallIntentBroadcaster and " +
  5.                     "phoneAccountSelected, but is harmlessly resolved by ignoring the second " +
  6.                     "invocation.");
  7.             return;
  8.         }
  9.         mCreateConnectionProcessor = new CreateConnectionProcessor(this, mRepository, this,
  10.                 phoneAccountRegistrar, mContext);
  11.         mCreateConnectionProcessor.process();
  12.     }

继续跟踪process 方法

packages/services/Telecomm/src/com/android/server/telecom/CreateConnectionProcessor.java

  1.     public void process() {
  2.         Log.v(this, "process");
  3.         clearTimeout();
  4.         mAttemptRecords = new ArrayList<>();
  5.         if (mCall.getTargetPhoneAccount() != null) {
  6.             mAttemptRecords.add(new CallAttemptRecord(
  7.                     mCall.getTargetPhoneAccount(), mCall.getTargetPhoneAccount()));
  8.         }
  9.         if (!mCall.isSelfManaged()) {
  10.             adjustAttemptsForConnectionManager();
  11.             adjustAttemptsForEmergency(mCall.getTargetPhoneAccount());
  12.         }
  13.         mAttemptRecordIterator = mAttemptRecords.iterator();
  14.         attemptNextPhoneAccount();
  15.     }
  16.  
  17.

其中 attemptNextPhoneAccount 方法

  1.     private void attemptNextPhoneAccount() {
  2.         Log.v(this, "attemptNextPhoneAccount");
  3.         CallAttemptRecord attempt = null;
  4.  
  5.  
  6.         if (mCallResponse != null && attempt != null) {
  7.             Log.i(this, "Trying attempt %s", attempt);
  8.             PhoneAccountHandle phoneAccount = attempt.connectionManagerPhoneAccount;
  9.             mService = mRepository.getService(phoneAccount.getComponentName(),
  10.                     phoneAccount.getUserHandle());
  11.             if (mService == null) {
  12.                 Log.i(this, "Found no connection service for attempt %s", attempt);
  13.                 attemptNextPhoneAccount();
  14.             } else {
  15.                 mConnectionAttempt++;
  16.                 mCall.setConnectionManagerPhoneAccount(attempt.connectionManagerPhoneAccount);
  17.                 mCall.setTargetPhoneAccount(attempt.targetPhoneAccount);
  18.                 mCall.setConnectionService(mService);
  19.                 setTimeoutIfNeeded(mService, attempt);
  20.                 if (mCall.isIncoming()) {
  21.                     mService.createConnection(mCall, CreateConnectionProcessor.this);
  22.                 } else {
  23.                     // Start to create the connection for outgoing call after the ConnectionService
  24.                     // of the call has gained the focus.
  25.                     mCall.getConnectionServiceFocusManager().requestFocus(
  26.                             mCall,
  27.                             new CallsManager.RequestCallback(new CallsManager.PendingAction() {
  28.                                 @Override
  29.                                 public void performAction() {
  30.                                     Log.d(this, "perform create connection");
  31.                                     mService.createConnection(
  32.                                             mCall,
  33.                                             CreateConnectionProcessor.this);
  34.                                 }
  35.                             }));
  36.  
  37.                 }
  38.             }
  39.         } else {
  40.             Log.v(this, "attemptNextPhoneAccount, no more accounts, failing");
  41.             DisconnectCause disconnectCause = mLastErrorDisconnectCause != null ?
  42.                     mLastErrorDisconnectCause : new DisconnectCause(DisconnectCause.ERROR);
  43.             notifyCallConnectionFailure(disconnectCause);
  44.         }
  45.     }

核心代码：

  1. private ConnectionServiceWrapper mService;   
  2.              
  3. if (mCall.isIncoming()) {
  4.                     mService.createConnection(mCall, CreateConnectionProcessor.this);
  5.                 }

 

  1. void createConnection(final Call call, final CreateConnectionResponse response) {
  2.  
  3.     // 链接创建成功后 onSuccess 会被调用
  4.     BindCallback callback = new BindCallback() {
  5.         @Override
  6.         public void onSuccess() {
  7.  
  8.             try {
  9.                 /// M: For VoLTE @{
  10.                 boolean isConferenceDial = call.isConferenceDial();
  11.  
  12.                 // 会议通话
  13.                 if (isConferenceDial) {
  14.                     logOutgoing("createConference(%s) via %s.", call, getComponentName());
  15.                     mServiceInterface.createConference(
  16.                             call.getConnectionManagerPhoneAccount(),
  17.                             callId,
  18.                             new ConnectionRequest(
  19.                                     call.getTargetPhoneAccount(),
  20.                                     call.getHandle(),
  21.                                     extras,
  22.                                     call.getVideoState()),
  23.                             call.getConferenceParticipants(),
  24.                             call.isIncoming());
  25.  
  26.                 // 非会议（拨打电话会走这里）
  27.                 } else {
  28.  
  29.                     // 通过远程接口创建链接
  30.                     mServiceInterface.createConnection(
  31.                             call.getConnectionManagerPhoneAccount(),
  32.                             callId,
  33.                             new ConnectionRequest(
  34.                                     call.getTargetPhoneAccount(),
  35.                                     call.getHandle(),
  36.                                     extras,
  37.                                     call.getVideoState()),
  38.                             call.isIncoming(),
  39.                             call.isUnknown());
  40.                 }
  41.                 /// @}
  42.             } catch (RemoteException e) {
  43.  
  44.             }
  45.         }
  46.  
  47.         @Override
  48.         public void onFailure() {
  49.         }
  50.     };
  51.  
  52.     mBinder.bind(callback, call);
  53. }

mBinder是Binder2对象，Binder2是ConnectionServiceWrapper的父类ServiceBinder内部类，所以此处调用的是的ServiceBinder的内部类的Binder2类的bind()方法，先new一个ServiceConnection对象，然后绑定一个远程服务端服务。如果绑定成功的话，在ServiceBinder的内部类ServiceBinderConnection的onServiceConnected()方法就被调用。
在这里做了两件事：


　　1）.通过setBinder()方法，回调ConnectionServiceWrapper的setServiceInterface()方法，通过mServiceInterface = IConnectionService.Stub.asInterface(binder);
这行代码获取一个远程服务端的对象mServiceInterface 。
　　2）、再通过调用handleSuccessfulConnection()方法回调callback 的onSuccess()方法，也就又回到ConnectionServiceWrapper的createConnection()方法里。调用ConnectionService.java里mBinder的createConnection()方法然后通过message传递调用createConnection()方法。

mBider 的bind 方法 

  1. void bind(BindCallback callback, Call call) {
  2.  
  3.             if (mServiceConnection == null) {
  4.                 Intent serviceIntent = new Intent(mServiceAction).setComponent(mComponentName);
  5.                 ServiceConnection connection = new ServiceBinderConnection(call);
  6.  
  7.                 // 进行绑定
  8.                 if (mUserHandle != null) {
  9.                     isBound = mContext.bindServiceAsUser(serviceIntent, connection, bindingFlags,
  10.                             mUserHandle);
  11.                 } else {
  12.                     isBound = mContext.bindService(serviceIntent, connection, bindingFlags);
  13.                 }
  14.                 if (!isBound) {
  15.                     handleFailedConnection();
  16.                     return;
  17.                 }
  18.             } else {
  19.             }
  20.         }

绑定成功后，ServiceBinderConnection 的 onServiceConnected 会触发

  1.         @Override
  2.         public void onServiceConnected(ComponentName componentName, IBinder binder) {
  3.             try {
  4.  
  5.                     if (binder != null) {
  6.                         mServiceDeathRecipient = new ServiceDeathRecipient(componentName);
  7.                         try {
  8.                             binder.linkToDeath(mServiceDeathRecipient, 0);
  9.                             mServiceConnection = this;
  10. // 会触发 ConnectionServiceWrapper.setServiceInterface  ==>  
  11. ConnectionServiceWrapper.addConnectionServiceAdapter 
  12. 通过mServiceInterface，给绑定的服务，提供一个访问自己的接口
  13.  
  14.  
  15.                             setBinder(binder);
  16.  
  17. // 触发bind(BindCallback callback, Call call) 中 callback 的 onSuccess
  18.  
  19.                             handleSuccessfulConnection();
  20.                         } catch (RemoteException e) {
  21.                             Log.w(this, "onServiceConnected: %s died.");
  22.                             if (mServiceDeathRecipient != null) {
  23.                                 mServiceDeathRecipient.binderDied();
  24.                             }
  25.                         }
  26.                     }
  27.                 }
  28.             } finally {
  29.                 Log.endSession();
  30.             }
  31.         }

整个绑定过程，只做2件事，

一是给远程服务提供访问自己的接口，

二是利用远程接口创建一个通话链接。

这2件事都是跨进程进行的。远程服务访问自己的接口是 ConnectionServiceWrapper.Adapter , 是一个Binder。

由内部类 Adapter 继承于 IConnectionServiceAdapter.Stub，可以看出会进行跨进程访问

  1. public class ConnectionServiceWrapper extends ServiceBinder implements
  2.         ConnectionServiceFocusManager.ConnectionServiceFocus {
  3.  
  4.     private final class Adapter extends IConnectionServiceAdapter.Stub {

调用ConnectionService.java里mBinder的createConnection()方法然后通过message传递调用createConnection()方法。

  1.     private void handleSuccessfulConnection() {
  2.         // Make a copy so that we don't have a deadlock inside one of the callbacks.
  3.         Set<BindCallback> callbacksCopy = new ArraySet<>();
  4.         synchronized (mCallbacks) {
  5.             callbacksCopy.addAll(mCallbacks);
  6.             mCallbacks.clear();
  7.         }
  8.  
  9.         for (BindCallback callback : callbacksCopy) {
  10.             callback.onSuccess();
  11.         }
  12.     }

通过调用handleSuccessfulConnection()方法回调callback 的onSuccess()方法，也就又回到ConnectionServiceWrapper的createConnection()方法里。

  1. 1094      public void createConnection(final Call call, final CreateConnectionResponse response) {
  2. 1095          Log.d(this, "createConnection(%s) via %s.", call, getComponentName());
  3. 1096          BindCallback callback = new BindCallback() {
  4. 1097              @Override
  5. 1098              public void onSuccess() {
  6. 1099                  String callId = mCallIdMapper.getCallId(call);
  7. 1100                  mPendingResponses.put(callId, response);
  8. 1101  
  9. ///---------//
  10.  
  11. 1146                                  
  12. 1150          // 核心代码
  13. 1151                  try {
  14. 1152                      mServiceInterface.createConnection(
  15. 1153                              call.getConnectionManagerPhoneAccount(),
  16. 1154                              callId,
  17. 1155                              connectionRequest,
  18. 1156                              call.shouldAttachToExistingConnection(),
  19. 1157                              call.isUnknown(),
  20. 1158                              Log.getExternalSession());
  21. 1159  
  22. 1160                  } catch (RemoteException e) {
  23. 1161                      Log.e(this, e, "Failure to createConnection -- %s", getComponentName());
  24. 1162                      mPendingResponses.remove(callId).handleCreateConnectionFailure(
  25. 1163                              new DisconnectCause(DisconnectCause.ERROR, e.toString()));
  26. 1164                  }
  27. 1165              }
  28. 1166  
  29. 1167              @Override
  30. 1168              public void onFailure() {
  31. 1169                  Log.e(this, new Exception(), "Failure to call %s", getComponentName());
  32. 1170                  response.handleCreateConnectionFailure(new DisconnectCause(DisconnectCause.ERROR));
  33. 1171              }
  34. 1172          };
  35. 1173  
  36. 1174          mBinder.bind(callback, call);
  37. 1175      }
private IConnectionService mServiceInterface;

线中间的处理过程 和 拨号 流程一样 

----------------------------------------------------------------- 

createConnection()方法通过判断是来电还是去电分别创建不同的connection，

  1.     /**
  2.      * This can be used by telecom to either create a new outgoing call or attach to an existing
  3.      * incoming call. In either case, telecom will cycle through a set of services and call
  4.      * createConnection util a connection service cancels the process or completes it successfully.
  5.      */
  6.     /** {@hide} */
  7.     protected void createConnection(
  8.             final PhoneAccountHandle callManagerAccount,
  9.             final String callId,
  10.             final ConnectionRequest request,
  11.             boolean isIncoming,
  12.             boolean isUnknown) {
  13.         Log.d(this, "createConnection, callManagerAccount: %s, callId: %s, request: %s, " +
  14.                         "isIncoming: %b, isUnknown: %b", callManagerAccount, callId, request,
  15.                 isIncoming,
  16.                 isUnknown);
  17.  
  18.         //判断是来电还是去电创造不同的connection
  19.         Connection connection = isUnknown ? onCreateUnknownConnection(callManagerAccount, request)
  20.                 : isIncoming ? onCreateIncomingConnection(callManagerAccount, request)
  21.                 : onCreateOutgoingConnection(callManagerAccount, request);
  22.         ...
  23.  
  24.         Log.d(this, "createConnection, calling handleCreateConnectionSuccessful %s", callId);
  25.         //创建成功后调用
  26.         mAdapter.handleCreateConnectionComplete(
  27.                 callId,
  28.                 request,
  29.                 new ParcelableConnection(
  30.                 ...
  31.  
  32.         if (isIncoming && request.shouldShowIncomingCallUi() &&
  33.                 (connection.getConnectionProperties() & Connection.PROPERTY_SELF_MANAGED) ==
  34.                         Connection.PROPERTY_SELF_MANAGED) {
  35.             // Tell ConnectionService to show its incoming call UX.
  36.             connection.onShowIncomingCallUi();
  37.         }
  38.         if (isUnknown) {
  39.             triggerConferenceRecalculate();
  40.         }
  41.     }

此处先分析： onCreateIncomingConnection

运行完成后分析：mAdapter.handleCreateConnectionComplete

其中：

  1.     public Connection onCreateIncomingConnection(
  2.             PhoneAccountHandle connectionManagerPhoneAccount,
  3.             ConnectionRequest request) {
  4.         return null;
  5.     }

当判断是来电时会通过 onCreateIncomingConnection 创建连接，直接跟进去发现是空实现，那么该方法的实现应该在该类的子类中，跟进到其子类TelephonyConnectionService中 

public class TelephonyConnectionService extends ConnectionService {
  1. /**
  2.  * Service for making GSM and CDMA connections.
  3.  */
  4. public class TelephonyConnectionService extends ConnectionService 
  5.  
  6.     @Override
  7.     public Connection onCreateIncomingConnection(
  8.             PhoneAccountHandle connectionManagerPhoneAccount,
  9.             ConnectionRequest request) {
  10.         ...
  11.         Phone phone = getPhoneForAccount(accountHandle, isEmergency);
  12.         ...
  13.         Call call = phone.getRingingCall();
  14.  
  15.         com.android.internal.telephony.Connection originalConnection =
  16.                 call.getState() == Call.State.WAITING ?
  17.                     call.getLatestConnection() : call.getEarliestConnection();
  18.         ...
  19.         Connection connection =
  20.                 createConnectionFor(phone, originalConnection, false /* isOutgoing */,
  21.                         request.getAccountHandle(), request.getTelecomCallId(),
  22.                         request.getAddress(), videoState);
  23.  
  24.         ...
  25.     }

跳转到 createConnectionFor 方法中

  1.     private TelephonyConnection createConnectionFor(
  2.             Phone phone,
  3.             com.android.internal.telephony.Connection originalConnection,
  4.             boolean isOutgoing,
  5.             PhoneAccountHandle phoneAccountHandle,
  6.             String telecomCallId,
  7.             Uri address,
  8.             int videoState) {
  9.         TelephonyConnection returnConnection = null;
  10.         int phoneType = phone.getPhoneType();
  11.         if (phoneType == TelephonyManager.PHONE_TYPE_GSM) {
  12.             returnConnection = new GsmConnection(originalConnection, telecomCallId, isOutgoing);
  13.         } else if (phoneType == TelephonyManager.PHONE_TYPE_CDMA) {
  14.             boolean allowsMute = allowsMute(phone);
  15.             returnConnection = new CdmaConnection(originalConnection, mEmergencyTonePlayer,
  16.                     allowsMute, isOutgoing, telecomCallId);
  17.         }
  18.         if (returnConnection != null) {
  19.             // Listen to Telephony specific callbacks from the connection
  20.             returnConnection.addTelephonyConnectionListener(mTelephonyConnectionListener);
  21.             returnConnection.setVideoPauseSupported(
  22.                     TelecomAccountRegistry.getInstance(this).isVideoPauseSupported(
  23.                             phoneAccountHandle));
  24.             returnConnection.setManageImsConferenceCallSupported(
  25.                     TelecomAccountRegistry.getInstance(this).isManageImsConferenceCallSupported(
  26.                             phoneAccountHandle));
  27.             returnConnection.setShowPreciseFailedCause(
  28.                     TelecomAccountRegistry.getInstance(this).isShowPreciseFailedCause(
  29.                             phoneAccountHandle));
  30.         }
  31.         return returnConnection;
  32.     }

继续 分析  mAdapter.handleCreateConnectionComplete

这里通过AIDL进行通信，搜索 IConnectionServiceAdapter.Stub，跟进到 ConnectionServiceWrapper

  1.     private final class Adapter extends IConnectionServiceAdapter.Stub {
  2.  
  3.         @Override
  4.         public void handleCreateConnectionComplete(String callId, ConnectionRequest request,
  5.                 ParcelableConnection connection, Session.Info sessionInfo) {
  6.             Log.startSession(sessionInfo, LogUtils.Sessions.CSW_HANDLE_CREATE_CONNECTION_COMPLETE);
  7.             long token = Binder.clearCallingIdentity();
  8.             try {
  9.                 synchronized (mLock) {
  10.                     logIncoming("handleCreateConnectionComplete %s", callId);
  11.                     ConnectionServiceWrapper.this
  12.                             .handleCreateConnectionComplete(callId, request, connection);
  13.  
  14.

继续跟进handleCreateConnectionComplete

  1.  
  2.     private void handleCreateConnectionComplete(
  3.             String callId,
  4.             ConnectionRequest request,
  5.             ParcelableConnection connection) {
  6.         // TODO: Note we are not using parameter "request", which is a side effect of our tacit
  7.         // assumption that we have at most one outgoing connection attempt per ConnectionService.
  8.         // This may not continue to be the case.
  9.         if (connection.getState() == Connection.STATE_DISCONNECTED) {
  10.             // A connection that begins in the DISCONNECTED state is an indication of
  11.             // failure to connect; we handle all failures uniformly
  12.             Call foundCall = mCallIdMapper.getCall(callId);
  13.             if (foundCall != null) {
  14.                 // The post-dial digits are created when the call is first created.  Normally
  15.                 // the ConnectionService is responsible for stripping them from the address, but
  16.                 // since a failed connection will not have done this, we could end up with duplicate
  17.                 // post-dial digits.
  18.                 foundCall.clearPostDialDigits();
  19.             }
  20.             removeCall(callId, connection.getDisconnectCause());
  21.         } else {
  22.             // Successful connection
  23.             if (mPendingResponses.containsKey(callId)) {
  24.                 mPendingResponses.remove(callId)
  25.                         .handleCreateConnectionSuccess(mCallIdMapper, connection);
  26.             }
  27.         }
  28.     }

mPendingResponses是hashMap容器，每次在 createConnection 的时候会将对象加入该容器，如果此时connection还未断开的，会移除此connection，调用hanleCreateConnectionSuccess方法。
往上追溯CreateConnectionResponse，是一个接口，跟踪到mService.createConnection(mCall, this);

public class CreateConnectionProcessor implements CreateConnectionResponse {

CreateConnectionProcessor.java会把自身传入，发现该类也实现了 CreateConnectionResponse ，所以这里的 handleCreateConnectionSuccess
调用的是这个类里面的方法

  1. private CreateConnectionResponse mCallResponse;
  2.  
  3.     @Override
  4.     public void handleCreateConnectionSuccess(
  5.             CallIdMapper idMapper,
  6.             ParcelableConnection connection) {
  7.         if (mCallResponse == null) {
  8.             // Nobody is listening for this connection attempt any longer; ask the responsible
  9.             // ConnectionService to tear down any resources associated with the call
  10.             mService.abort(mCall);
  11.         } else {
  12.             // Success -- share the good news and remember that we are no longer interested
  13.             // in hearing about any more attempts
  14. // 核心代码
  15.             mCallResponse.handleCreateConnectionSuccess(idMapper, connection);
  16.             mCallResponse = null;
  17.             // If there's a timeout running then don't clear it. The timeout can be triggered
  18.             // after the call has successfully been created but before it has become active.
  19.         }
  20.     }

还是 CreateConnectionResponse 接口

实现的是 Call 对象 ，Call 也实现了该接口

  1. public class Call implements CreateConnectionResponse, EventManager.Loggable,
  2. 84          ConnectionServiceFocusManager.CallFocus {
  1.     public void handleCreateConnectionSuccess(
  2.             CallIdMapper idMapper,
  3.             ParcelableConnection connection) {
  4.         Log.v(this, "handleCreateConnectionSuccessful %s", connection);
  5.         setTargetPhoneAccount(connection.getPhoneAccount());
  6.         setHandle(connection.getHandle(), connection.getHandlePresentation());
  7.         setCallerDisplayName(
  8.                 connection.getCallerDisplayName(), connection.getCallerDisplayNamePresentation());
  9.  
  10.         setConnectionCapabilities(connection.getConnectionCapabilities());
  11.         setConnectionProperties(connection.getConnectionProperties());
  12.         setIsVoipAudioMode(connection.getIsVoipAudioMode());
  13.         setSupportedAudioRoutes(connection.getSupportedAudioRoutes());
  14.         setVideoProvider(connection.getVideoProvider());
  15.         setVideoState(connection.getVideoState());
  16.         setRingbackRequested(connection.isRingbackRequested());
  17.         setStatusHints(connection.getStatusHints());
  18.         putExtras(SOURCE_CONNECTION_SERVICE, connection.getExtras());
  19.  
  20.         mConferenceableCalls.clear();
  21.         for (String id : connection.getConferenceableConnectionIds()) {
  22.             mConferenceableCalls.add(idMapper.getCall(id));
  23.         }
  24.  
  25.         switch (mCallDirection) {
  26.             case CALL_DIRECTION_INCOMING:
  27.  
  28.                 for (Listener l : mListeners) {
  29. // 此处触发了回调
  30.                     l.onSuccessfulIncomingCall(this);
  31.                 }
  32.                 break;
  33. 。。。。。

这里根据来电类型，触发回调，监听者会收到通知

,之前在CallManager中执行 processIncomingCallIntent 方法创建Call的时候就添加了监听，所以最后会回调到CallsManager中

可以看出CallsManager的管理作用，创建Calls并添加监听，在完成Call的相关初始化后进行进一步处理，其实就是传递消息到别的的地方去。

  1.     public void onSuccessfulIncomingCall(Call incomingCall) {
  2.         Log.d(this, "onSuccessfulIncomingCall");
  3.         PhoneAccount phoneAccount = mPhoneAccountRegistrar.getPhoneAccountUnchecked(
  4.                 incomingCall.getTargetPhoneAccount());
  5.         Bundle extras =
  6.             phoneAccount == null || phoneAccount.getExtras() == null
  7.                 ? new Bundle()
  8.                 : phoneAccount.getExtras();
  9.         if (incomingCall.hasProperty(Connection.PROPERTY_EMERGENCY_CALLBACK_MODE) ||
  10.                 incomingCall.isSelfManaged() ||
  11.                 extras.getBoolean(PhoneAccount.EXTRA_SKIP_CALL_FILTERING)) {
  12.             Log.i(this, "Skipping call filtering for %s (ecm=%b, selfMgd=%b, skipExtra=%b)",
  13.                     incomingCall.getId(),
  14.                     incomingCall.hasProperty(Connection.PROPERTY_EMERGENCY_CALLBACK_MODE),
  15.                     incomingCall.isSelfManaged(),
  16.                     extras.getBoolean(PhoneAccount.EXTRA_SKIP_CALL_FILTERING));
  17.             onCallFilteringComplete(incomingCall, new CallFilteringResult(true, false, true, true));
  18.             incomingCall.setIsUsingCallFiltering(false);
  19.             return;
  20.         }
  21.  
  22.         incomingCall.setIsUsingCallFiltering(true);
  23. //迭代器模式
  24.         List<IncomingCallFilter.CallFilter> filters = new ArrayList<>();
  25.         filters.add(new DirectToVoicemailCallFilter(mCallerInfoLookupHelper));
  26.         filters.add(new AsyncBlockCheckFilter(mContext, new BlockCheckerAdapter(),
  27.                 mCallerInfoLookupHelper, null));
  28.         filters.add(new CallScreeningServiceController(mContext, this, mPhoneAccountRegistrar,
  29.                 new ParcelableCallUtils.Converter(), mLock,
  30.                 new TelecomServiceImpl.SettingsSecureAdapterImpl(), mCallerInfoLookupHelper,
  31.                 new CallScreeningServiceHelper.AppLabelProxy() {
  32.                     @Override
  33.                     public CharSequence getAppLabel(String packageName) {
  34.                         PackageManager pm = mContext.getPackageManager();
  35.                         try {
  36.                             ApplicationInfo info = pm.getApplicationInfo(packageName, 0);
  37.                             return pm.getApplicationLabel(info);
  38.                         } catch (PackageManager.NameNotFoundException nnfe) {
  39.                             Log.w(this, "Could not determine package name.");
  40.                         }
  41.  
  42.                         return null;
  43.                     }
  44.                 }));
  45. //IncomingCallFilter创建并执行 performFiltering
  46.         new IncomingCallFilter(mContext, this, incomingCall, mLock,
  47.                 mTimeoutsAdapter, filters).performFiltering();
  48.     }

IncomingCallFilter创建并执行 performFiltering

  1.     public void performFiltering() {
  2.         Log.addEvent(mCall, LogUtils.Events.FILTERING_INITIATED);
  3.         for (CallFilter filter : mFilters) {
  4.             //遍历调用，依次执行异步查询方法
  5.             filter.startFilterLookup(mCall, this);
  6.         }
  7.         // synchronized to prevent a race on mResult and to enter into Telecom.
  8.         mHandler.postDelayed(new Runnable("ICF.pFTO", mTelecomLock) { // performFiltering time-out
  9.             @Override
  10.             public void loggedRun() {
  11.                 if (mIsPending) {
  12.                     //超时处理的方法
  13.                     Log.i(IncomingCallFilter.this, "Call filtering has timed out.");
  14.                     Log.addEvent(mCall, LogUtils.Events.FILTERING_TIMED_OUT);
  15.                     //回CallsManager中的监听事件
  16.                     mListener.onCallFilteringComplete(mCall, mResult);
  17.                     mIsPending = false;
  18.                 }
  19.             }
  20.         }.prepare(), mTimeoutsAdapter.getCallScreeningTimeoutMillis(mContext.getContentResolver()));
  21.     }

如果没有超时则在异步查询结束后，会通过回调方法将CallFilterResult传回onCallFilteringComplete.

  1.     public void onCallFilteringComplete(Call call, CallFilteringResult result) {
  2.         synchronized (mTelecomLock) { // synchronizing to prevent race on mResult
  3.             mNumPendingFilters--;
  4.             mResult = result.combine(mResult);
  5.             if (mNumPendingFilters == 0) {
  6.                 // synchronized on mTelecomLock to enter into Telecom.
  7.                 mHandler.post(new Runnable("ICF.oCFC", mTelecomLock) {
  8.                     @Override
  9.                     public void loggedRun() {
  10.                         if (mIsPending) {
  11.                             Log.addEvent(mCall, LogUtils.Events.FILTERING_COMPLETED, mResult);
  12.                             mListener.onCallFilteringComplete(mCall, mResult);
  13.                             mIsPending = false;
  14.                         }
  15.                     }
  16.                 }.prepare());
  17.             }
  18.         }
  19.     }

然后， 回到CallsManager中进行onCallFilteringComplete处理

  1.     @Override
  2.     public void onCallFilteringComplete(Call incomingCall, CallFilteringResult result) {
  3.         ...
  4.         if (incomingCall.getState() != CallState.DISCONNECTED &&
  5.                 incomingCall.getState() != CallState.DISCONNECTING &&
  6.                 incomingCall.getState() != CallState.ACTIVE) {
  7.             //设置Call状态为Ring
  8.             setCallState(incomingCall, CallState.RINGING,
  9.                     result.shouldAllowCall ? "successful incoming call" : "blocking call");
  10.         } else {
  11.             Log.i(this, "onCallFilteringCompleted: call already disconnected.");
  12.             return;
  13.         }
  14.  
  15.         if (result.shouldAllowCall) {
  16.             if (MtkUtil.isInSingleVideoCallMode(incomingCall)) {
  17.                 ...
  18.             }
  19.  
  20.             if (hasMaximumManagedRingingCalls(incomingCall)) {
  21.                 if (shouldSilenceInsteadOfReject(incomingCall)) {
  22.                     incomingCall.silence();
  23.                 } else {
  24.                     Log.i(this, "onCallFilteringCompleted: Call rejected! " +
  25.                             "Exceeds maximum number of ringing calls.");
  26.                     rejectCallAndLog(incomingCall);
  27.                 }
  28.  
  29.             } else {
  30.                 //添加Call
  31.                 addCall(incomingCall);
  32.             }
  33.         } else {
  34.             if (result.shouldReject) {
  35.                 Log.i(this, "onCallFilteringCompleted: blocked call, rejecting.");
  36.                 incomingCall.reject(false, null);
  37.             }
  38.             if (result.shouldAddToCallLog) {
  39.                 Log.i(this, "onCallScreeningCompleted: blocked call, adding to call log.");
  40.                 if (result.shouldShowNotification) {
  41.                     Log.w(this, "onCallScreeningCompleted: blocked call, showing notification.");
  42.                 }
  43.                 //添加通话记录
  44.                 mCallLogManager.logCall(incomingCall, Calls.MISSED_TYPE,
  45.                         result.shouldShowNotification);
  46.             } else if (result.shouldShowNotification) {
  47.                 Log.i(this, "onCallScreeningCompleted: blocked call, showing notification.");
  48.                 mMissedCallNotifier.showMissedCallNotification(
  49.                         new MissedCallNotifier.CallInfo(incomingCall));
  50.             }
  51.         }
  52.     }

跟踪到 addCall 方法

  1. 3207      @VisibleForTesting
  2. 3208      public void addCall(Call call) {
  3. 3209          Trace.beginSection("addCall");
  4. 3210          Log.v(this, "addCall(%s)", call);
  5. 3211          call.addListener(this);
  6. 3212          mCalls.add(call);
  7. 3213  
  8. 3214          // Specifies the time telecom finished routing the call. This is used by the dialer for
  9. 3215          // analytics.
  10. 3216          Bundle extras = call.getIntentExtras();
  11. 3217          extras.putLong(TelecomManager.EXTRA_CALL_TELECOM_ROUTING_END_TIME_MILLIS,
  12. 3218                  SystemClock.elapsedRealtime());
  13. 3219  
  14. 3220          updateCanAddCall();
  15. 3221          // onCallAdded for calls which immediately take the foreground (like the first call).
  16. 3222          for (CallsManagerListener listener : mListeners) {
  17. 3223              if (LogUtils.SYSTRACE_DEBUG) {
  18. 3224                  Trace.beginSection(listener.getClass().toString() + " addCall");
  19. 3225              }
  20. 3226              listener.onCallAdded(call);
  21. 3227              if (LogUtils.SYSTRACE_DEBUG) {
  22. 3228                  Trace.endSection();
  23. 3229              }
  24. 3230          }
  25. 3231          Trace.endSection();
  26. 3232      }

//通知监听Call添加的观察者

listener.onCallAdded(call);

添加的观察者，和拨号一样，主要是 CllAudilManager （负责响铃）和  InCallController

  1.         mListeners.add(mInCallWakeLockController);
  2.         mListeners.add(statusBarNotifier);
  3.         mListeners.add(mCallLogManager);
  4.         mListeners.add(mPhoneStateBroadcaster);
  5.         mListeners.add(mInCallController);
  6.         mListeners.add(mCallAudioManager);
  7.         mListeners.add(mCallRecordingTonePlayer);
  8.         mListeners.add(missedCallNotifier);
  9.         mListeners.add(mHeadsetMediaButton);
  10.         mListeners.add(mProximitySensorManager);

其中：

  1. private void onCallEnteringRinging() {
  2. 641          if (mRingingCalls.size() == 1) {
  3. 642              mCallAudioModeStateMachine.sendMessageWithArgs(
  4. 643                      CallAudioModeStateMachine.NEW_RINGING_CALL,
  5. 644                      makeArgsForModeStateMachine());
  6. 645          }
  7. 646      }

查看 InCallController 的 onCallAdded 方法

  1.     @Override
  2.     public void onCallAdded(Call call) {
  3.         if (!isBoundAndConnectedToServices()) {
  4.             bindToServices(call);
  5.         } else {
  6.             // We are bound, and we are connected.
  7.             adjustServiceBindingsForEmergency();
  8.  
  9.             // This is in case an emergency call is added while there is an existing call.
  10.             mEmergencyCallHelper.maybeGrantTemporaryLocationPermission(call,
  11.                     mCallsManager.getCurrentUserHandle());
  12.  
  13.             //添加Call
  14.             addCall(call);
  15.  
  16.             List<ComponentName> componentsUpdated = new ArrayList<>();
  17.             for (Map.Entry<InCallServiceInfo, IInCallService> entry : mInCallServices.entrySet()) {
  18.                 InCallServiceInfo info = entry.getKey();
  19.  
  20.                 if (call.isExternalCall() && !info.isExternalCallsSupported()) {
  21.                     continue;
  22.                 }
  23.  
  24.                 if (call.isSelfManaged() && !info.isSelfManagedCallsSupported()) {
  25.                     continue;
  26.                 }
  27.  
  28.                 // Only send the RTT call if it's a UI in-call service
  29.                 boolean includeRttCall = info.equals(mInCallServiceConnection.getInfo());
  31.                 componentsUpdated.add(info.getComponentName());
  32.                 IInCallService inCallService = entry.getValue();
  34.                 ParcelableCall parcelableCall = ParcelableCallUtils.toParcelableCall(call,
  35.                         true /* includeVideoProvider */, mCallsManager.getPhoneAccountRegistrar(),
  36.                         info.isExternalCallsSupported(), includeRttCall);
  37.                 try {
  38.                     //AIDL调用远程的addCall方法
  39.                     inCallService.addCall(parcelableCall);
  40.                 } catch (RemoteException ignored) {
  41.                 }
  42.             }
  43.             Log.i(this, "Call added to components: %s", componentsUpdated);
  44.         }
  45.     }

Telecomm Framework

  1. 291      /** Manages the binder calls so that the implementor does not need to deal with it. */
  2. 292      private final class InCallServiceBinder extends IInCallService.Stub {
  3. 293          @Override
  4. 294          public void setInCallAdapter(IInCallAdapter inCallAdapter) {
  5. 295              mHandler.obtainMessage(MSG_SET_IN_CALL_ADAPTER, inCallAdapter).sendToTarget();
  6. 296          }
  7. 297  
  8. 298          @Override
  9. 299          public void addCall(ParcelableCall call) {
  10. 300              mHandler.obtainMessage(MSG_ADD_CALL, call).sendToTarget();
  11. 301          }

继续跟进MSG_ADD_CALL消息的处理

  1. 205      /** Default Handler used to consolidate binder method calls onto a single thread. */
  2. 206      private final Handler mHandler = new Handler(Looper.getMainLooper()) {
  3. 207          @Override
  4. 208          public void handleMessage(Message msg) {
  5. 209              if (mPhone == null && msg.what != MSG_SET_IN_CALL_ADAPTER) {
  6. 210                  return;
  7. 211              }
  8. 212  
  9. 213              switch (msg.what) {
  10. 214                  case MSG_SET_IN_CALL_ADAPTER:
  11. 215                      String callingPackage = getApplicationContext().getOpPackageName();
  12. 216                      mPhone = new Phone(new InCallAdapter((IInCallAdapter) msg.obj), callingPackage,
  13. 217                              getApplicationContext().getApplicationInfo().targetSdkVersion);
  14. 218                      mPhone.addListener(mPhoneListener);
  15. 219                      onPhoneCreated(mPhone);
  16. 220                      break;
  17. 221                  case MSG_ADD_CALL:
  18. 222                      mPhone.internalAddCall((ParcelableCall) msg.obj);
  19. 223                      break;

继续跟进internalAddCall

  1.     final void internalAddCall(ParcelableCall parcelableCall) {
  2.         //创建Call
  3.         Call call = new Call(this, parcelableCall.getId(), mInCallAdapter,
  4.                 parcelableCall.getState(), mCallingPackage, mTargetSdkVersion);
  5.  
  6.         mCallByTelecomCallId.put(parcelableCall.getId(), call);
  7.         //添加到列表中
  8.         mCalls.add(call);
  9.         checkCallTree(parcelableCall);
  10.         call.internalUpdate(parcelableCall, mCallByTelecomCallId);
  11.         //调用phone的监听者的onCallAdded
  12.         fireCallAdded(call);
  13.      }
  14.  
  15.     private void fireCallAdded(Call call) {
  16.         for (Listener listener : mListeners) {
  17.             listener.onCallAdded(this, call);
  18.         }
  19.     }

在 InCallService 中handleMessage处理MSG_SET_IN_CALL_ADAPTER消息的时候就注册了监听，这里继续跟进到InCallService中的实现去

  1.     private Phone.Listener mPhoneListener = new Phone.Listener() {
  2.         /** ${inheritDoc} */
  3.         @Override
  4.         public void onAudioStateChanged(Phone phone, AudioState audioState) {
  5.             InCallService.this.onAudioStateChanged(audioState);
  6.         }
  7. 。。。。。//
  8.  
  9.  
  10.         /** ${inheritDoc} */
  11.         @Override
  12.         public void onCallAdded(Phone phone, Call call) {
  13.             InCallService.this.onCallAdded(call);
  14.         }

这其实是个空实现，具体实现是在子类中，继续跟进到子类 InCallServiceImpl  中分析

Dialer  层

  1. public class InCallServiceImpl extends InCallService {
  2.  
  3.   private ReturnToCallController returnToCallController;
  4.   private CallList.Listener feedbackListener;
  5.   // We only expect there to be one speakEasyCallManager to be instantiated at a time.
  6.   // We did not use a singleton SpeakEasyCallManager to avoid holding on to state beyond the
  7.   // lifecycle of this service, because the singleton is associated with the state of the
  8.   // Application, not this service.
  9.   private SpeakEasyCallManager speakEasyCallManager;
  10.  
  11.   @Override
  12.   public void onCallAudioStateChanged(CallAudioState audioState) {
  13.     Trace.beginSection("InCallServiceImpl.onCallAudioStateChanged");
  14.     AudioModeProvider.getInstance().onAudioStateChanged(audioState);
  15.     Trace.endSection();
  16.   }
  17.  
  18. ///-----------
  19.  
  20.   @Override
  21.   public void onCallAdded(Call call) {
  22.     Trace.beginSection("InCallServiceImpl.onCallAdded");
  23.     InCallPresenter.getInstance().onCallAdded(call);
  24.     Trace.endSection();
  25.   }

跟踪到这里可以看到其所在目录是Dialer下的inCallUI了，这就到dialer层了，如果查看Diler的清单文件可以发现其有android.telecom.InCallService声明

  1.   public void onCallAdded(final android.telecom.Call call) {
  2.     LatencyReport latencyReport = new LatencyReport(call);
  3.     if (shouldAttemptBlocking(call)) {
  4.       maybeBlockCall(call, latencyReport);
  5.     } else {
  6.       if (call.getDetails().hasProperty(CallCompat.Details.PROPERTY_IS_EXTERNAL_CALL)) {
  7.         mExternalCallList.onCallAdded(call);
  8.       } else {
  9.         latencyReport.onCallBlockingDone();
  10.         //CallList（Call的维护列表）调用onCallAdded
  11.         mCallList.onCallAdded(mContext, call, latencyReport);
  12.       }
  13.     }
  14.  
  15.     // Since a call has been added we are no longer waiting for Telecom to send us a call.
  16.     setBoundAndWaitingForOutgoingCall(false, null);
  17.     call.registerCallback(mCallCallback);
  18.   }
  1.   public void onCallAdded(
  2.       final Context context, final android.telecom.Call telecomCall, LatencyReport latencyReport) {
  3.     Trace.beginSection("onCallAdded");
  4.     ...
  5.      if (call.getState() == DialerCall.State.INCOMING
  6.             || call.getState() == DialerCall.State.CALL_WAITING) {
  7.           //来电调用
  8.           onIncoming(call);
  9.         } else {
  10.           dialerCallListener.onDialerCallUpdate();
  11.     }
  12.     ...
  13. }

跟踪 onIncoming 方法

  1.   /** Called when a single call has changed. */
  2.   private void onIncoming(DialerCall call) {
  3.     Trace.beginSection("CallList.onIncoming");
  4.     if (updateCallInMap(call)) {
  5.       LogUtil.i("CallList.onIncoming", String.valueOf(call));
  6.     }
  7.  
  8.     for (Listener listener : listeners) {
  9.       listener.onIncomingCall(call);
  10.     }
  11.     Trace.endSection();
  12.   }

InCallPresenter 监听来电状态

可以看出 InCallPresenter 实现了 CallList.Listener 的接口，所以可以监听来电的状态

public class InCallPresenter implements CallList.Listener, AudioModeProvider.AudioModeListener {

跟踪到 onCallListChange 方法

  1.   @Override
  2.   public void onCallListChange(CallList callList) {
  3.     Trace.beginSection("InCallPresenter.onCallListChange");
  4.     if (inCallActivity != null && inCallActivity.isInCallScreenAnimating()) {
  5.       awaitingCallListUpdate = true;
  6.       Trace.endSection();
  7.       return;
  8.     }
  9.     if (callList == null) {
  10.       Trace.endSection();
  11.       return;
  12.     }
  13.  
  14.     awaitingCallListUpdate = false;
  15.  
  16.     InCallState newState = getPotentialStateFromCallList(callList);
  17.     InCallState oldState = inCallState;
  18.     LogUtil.d(
  19.         "InCallPresenter.onCallListChange",
  20.         "onCallListChange oldState= " + oldState + " newState=" + newState);
  21.  
  22.     // If the user placed a call and was asked to choose the account, but then pressed "Home", the
  23.     // incall activity for that call will still exist (even if it's not visible). In the case of
  24.     // an incoming call in that situation, just disconnect that "waiting for account" call and
  25.     // dismiss the dialog. The same activity will be reused to handle the new incoming call. See
  26.     // a bug for more details.
  27.     DialerCall waitingForAccountCall;
  28.     if (newState == InCallState.INCOMING
  29.         && (waitingForAccountCall = callList.getWaitingForAccountCall()) != null) {
  30.       waitingForAccountCall.disconnect();
  31.       // The InCallActivity might be destroyed or not started yet at this point.
  32.       if (isActivityStarted()) {
  33.         inCallActivity.dismissPendingDialogs();
  34.       }
  35.     }
  36.  
  37. // 核心代码
  38.     newState = startOrFinishUi(newState);
  39.     LogUtil.d(
  40.         "InCallPresenter.onCallListChange", "onCallListChange newState changed to " + newState);
  41.  
  42.     // Set the new state before announcing it to the world
  43.     LogUtil.i(
  44.         "InCallPresenter.onCallListChange",
  45.         "Phone switching state: " + oldState + " -> " + newState);
  46.     inCallState = newState;
  47.  
  48.     // Foreground call changed
  49.     DialerCall primary = null;
  50.     if (newState == InCallState.INCOMING) {
  51.       primary = callList.getIncomingCall();
  52.     } else if (newState == InCallState.PENDING_OUTGOING || newState == InCallState.OUTGOING) {
  53.       primary = callList.getOutgoingCall();
  54.       if (primary == null) {
  55.         primary = callList.getPendingOutgoingCall();
  56.       }
  57.     } else if (newState == InCallState.INCALL) {
  58.       primary = getCallToDisplay(callList, null, false);
  59.     }
  60.     if (primary != null) {
  61.       onForegroundCallChanged(primary);
  62.  
  63.     }
  64.  
  65.     // notify listeners of new state
  66.     for (InCallStateListener listener : listeners) {
  67.       LogUtil.d(
  68.           "InCallPresenter.onCallListChange",
  69.           "Notify " + listener + " of state " + inCallState.toString());
  70.       listener.onStateChange(oldState, inCallState, callList);
  71.     }
  72.  
  73.  
  74.     if (isActivityStarted()) {
  75.       final boolean hasCall =
  76.           callList.getActiveOrBackgroundCall() != null || callList.getOutgoingCall() != null;
  77.       inCallActivity.dismissKeyguard(hasCall);
  78.     }
  79.  
  80.  
  81.     Trace.endSection();
  82.   }

继续跟踪 startOrFinishUi 方法

  1. private InCallState startOrFinishUi(InCallState newState) {
  2.  
  3.     if ((showCallUi || showAccountPicker) && !shouldStartInBubbleMode()) {
  4.       LogUtil.i("InCallPresenter.startOrFinishUi", "Start in call UI");
  5. // 展示来电界面
  6.       showInCall(false /* showDialpad */, !showAccountPicker /* newOutgoingCall */);
  7.     } else if (newState == InCallState.INCOMING) {
  8.       LogUtil.i("InCallPresenter.startOrFinishUi", "Start Full Screen in call UI");
  9.  
  10.       try {
  11.         PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
  12.         PowerHALManager powerHALManager = new PowerHALManager(context, new Handler());
  13.         PowerHALManager.PowerHintScene sceneIncall = powerHALManager.createPowerHintScene(
  14.                 "InCall: InCallPresenter", PowerHintVendorSprd.POWER_HINT_VENDOR_RADIO_CALL, null);
  15.         if (sceneIncall != null && !pm.isScreenOn()) {
  16.           Log.i(this, "power Hint POWER_HINT_VENDOR_RADIO_CALL");
  17.           sceneIncall.acquire(1000);
  18.         }
  19.       } catch (java.lang.NoClassDefFoundError e) {
  20.         LogUtil.e("InCallPresenter.startOrFinishUi", "Exception:" + e.getMessage());
  21.       } catch (java.util.NoSuchElementException e) {
  22.         LogUtil.e("InCallPresenter.startOrFinishUi", "Exception:" + e.getMessage());
  23.       } catch (Exception e) {
  24.         LogUtil.e("InCallPresenter.startOrFinishUi", "Exception:" + e.getMessage());
  25.       }
  26.  
  27.     } else if (newState == InCallState.NO_CALLS) {
  28.       // The new state is the no calls state.  Tear everything down.
  29.       inCallState = newState;
  30.       attemptFinishActivity();
  31.       attemptCleanup();
  32.     }

跟踪 showInCall 方法

  1.   public void showInCall(boolean showDialpad, boolean newOutgoingCall) {
  2.     LogUtil.i("InCallPresenter.showInCall", "Showing InCallActivity");
  3.     context.startActivity(
  4.         InCallActivity.getIntent(context, showDialpad, newOutgoingCall, false /* forFullScreen */));
  5.   }

至此，显示来电界面。

MO 是从Dialer 发起，MT是从Modem发起。所以两个流程最大的差别也就是如何开始创建Call & connection。当准备开始创建和创建完成后，MO & MT在流程上几乎是没有差异的，都是一些Call & connection的控制，然后通过UI显示出来。

 

总的来电各层之间的流程：

RIL→TelephonyFramework →TeleponyService→ TeleComService→

TeleComFramework→ TeleComService→TeleComFramework-->InCallUI

 

 

 

 

 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/894897
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号