Android呼出电话流程（原）

        我们从按下拨号开始分析呼出电话的流程。此流程从拨号盘分析到RIL层。

一、应用层的流程

1.1、拨号盘初步处理

@DialpadFragment.java
public void dialButtonPressed() {
//得到号码
final String number = mDigits.getText().toString();
//得到拨号的Intent
final Intent intent = ContactsUtils.getCallIntent(number,
(getActivity() instanceof DialtactsActivity ?
((DialtactsActivity)getActivity()).getCallOrigin() : null));
startActivity(intent);
mClearDigitsOnStop = true;
getActivity().finish();
}

        来看上面得到Intent的过程：

@ContactsUtils.java
public static Intent getCallIntent(String number, String callOrigin) {
用号码构建一个类似tel:10086的Uri
return getCallIntent(getCallUri(number), callOrigin);
}
public static Intent getCallIntent(Uri uri, String callOrigin) {
final Intent intent = new Intent(Intent.ACTION_CALL_PRIVILEGED, uri);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
if (callOrigin != null) {
intent.putExtra(DialtactsActivity.EXTRA_CALL_ORIGIN, callOrigin);
}
return intent;
}

        这个过程可以看出，发出的Intent由一下几个结构组成：

        1、Action为：ACTION_CALL_PRIVILEGED，(android.intent.action.CALL_PRIVILEGED)；

        2、Flag为：FLAG_ACTIVITY_NEW_TASK；

        3、号码Uri为：tel:10086
        然后经过startActivity发送出去。那么是那个Activity接受的呢？

1.2、号码初级处理阶段

        这个过程主要针对紧急呼叫处理（OutgoingCallBroadcaster.java）。

        在Phone模块的AndroidManifest.xml文件中有如下描述：

<activity-alias android:name="PrivilegedOutgoingCallBroadcaster"
android:targetActivity="OutgoingCallBroadcaster"
android:screenOrientation="nosensor"
android:permission="android.permission.CALL_PRIVILEGED">
<intent-filter>
<action android:name="android.intent.action.CALL_PRIVILEGED" />
<category android:name="android.intent.category.DEFAULT" />
<data android:scheme="tel" />
</intent-filter>
</activity-alias>

        activity-alias说明这个节点描述的Activity是另一个Activity的别名，也就是说，当前的PrivilegedOutgoingCallBroadcaster是指向OutgoingCallBroadcaster的。

@OutgoingCallBroadcaster.java
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.outgoing_call_broadcaster);
mWaitingSpinner = (ProgressBar) findViewById(R.id.spinner);

Intent intent = getIntent();
processIntent(intent);
}

        继续往下看：

private void processIntent(Intent intent) {
final Configuration configuration = getResources().getConfiguration();

String action = intent.getAction();
String number = PhoneNumberUtils.getNumberFromIntent(intent, this);

//得到当前的号码
if (number != null) {
if (!PhoneNumberUtils.isUriNumber(number)) {
number = PhoneNumberUtils.convertKeypadLettersToDigits(number);
number = PhoneNumberUtils.stripSeparators(number);
}
} else {
}

//判断是否是紧急拨号
final boolean isExactEmergencyNumber =
(number != null) && PhoneNumberUtils.isLocalEmergencyNumber(number, this);
final boolean isPotentialEmergencyNumber =
(number != null) && PhoneNumberUtils.isPotentialLocalEmergencyNumber(number, this);

if (Intent.ACTION_CALL_PRIVILEGED.equals(action)) {
if (isPotentialEmergencyNumber) {
//紧急拨号的action
action = Intent.ACTION_CALL_EMERGENCY;
} else {
//非紧急拨号的action
action = Intent.ACTION_CALL;
}
//重新设置Action，当前不是紧急呼叫，因此Action改为ACTION_CALL
intent.setAction(action);
}

if (Intent.ACTION_CALL.equals(action)) {
if (isPotentialEmergencyNumber) {
//判断不成立
}
//当前的callNow为false
callNow = false;
} else if (Intent.ACTION_CALL_EMERGENCY.equals(action)) {
//紧急呼叫的处理
} else {
}

Uri uri = intent.getData();
String scheme = uri.getScheme();
if (Constants.SCHEME_SIP.equals(scheme) || PhoneNumberUtils.isUriNumber(number)) {
//互联网通话的处理
}

//重新构建Intent
Intent broadcastIntent = new Intent(Intent.ACTION_NEW_OUTGOING_CALL);
if (number != null) {
broadcastIntent.putExtra(Intent.EXTRA_PHONE_NUMBER, number);
}
PhoneUtils.checkAndCopyPhoneProviderExtras(intent, broadcastIntent);
broadcastIntent.putExtra(EXTRA_ALREADY_CALLED, callNow);
broadcastIntent.putExtra(EXTRA_ORIGINAL_URI, uri.toString());
broadcastIntent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);

//添加一个2秒的定时器，2秒内Intent没有收到的话，就显示一个进度条
mHandler.sendEmptyMessageDelayed(EVENT_OUTGOING_CALL_TIMEOUT,
OUTGOING_CALL_TIMEOUT_THRESHOLD);

//发送广播，而且指明了接收者是OutgoingCallReceiver
sendOrderedBroadcastAsUser(broadcastIntent, UserHandle.OWNER,
PERMISSION, new OutgoingCallReceiver(),
null,
Activity.RESULT_OK,
number,
null);
}

        这个过程其实就是对原始的Intent进行解析，对是否紧急呼叫进行不同的处理，对于正常的呼叫，需要重新构建Intent并发送出去。新的Intent构成：

            Intent：ACTION_NEW_OUTGOING_CALL；

            EXTRA_ALREADY_CALLED：false；

            EXTRA_ORIGINAL_URI:号码的Uri；

            发送目标：OutgoingCallReceiver；

        这里所谓的目标OutgoingCallReceiver其实就是OutgoingCallBroadcaster.java中的内部类，我们直接来看他的接收地方：

public void onReceive(Context context, Intent intent) {
//去掉3妙的定时器
mHandler.removeMessages(EVENT_OUTGOING_CALL_TIMEOUT);
doReceive(context, intent);
finish();
}
public void doReceive(Context context, Intent intent) {
//这里的得到的是false
alreadyCalled = intent.getBooleanExtra(OutgoingCallBroadcaster.EXTRA_ALREADY_CALLED, false);
if (alreadyCalled) {
return;
}

//得到号码
number = getResultData();

final PhoneGlobals app = PhoneGlobals.getInstance();
//OTASP功能，CDMA制式支持
if (TelephonyCapabilities.supportsOtasp(app.phone)) {
}

//得到号码的Uri
originalUri = intent.getStringExtra( OutgoingCallBroadcaster.EXTRA_ORIGINAL_URI);
Uri uri = Uri.parse(originalUri);

//把字母转换为数字，比如：a-->2；d-->3；g-->4等
number = PhoneNumberUtils.convertKeypadLettersToDigits(number);
//把所有字符转换为数字
number = PhoneNumberUtils.stripSeparators(number);

//继续处理
startSipCallOptionHandler(context, intent, uri, number);
}
private void startSipCallOptionHandler(Context context, Intent intent, Uri uri, String number) {
//再次构建Intent
Intent newIntent = new Intent(Intent.ACTION_CALL, uri);
newIntent.putExtra(EXTRA_ACTUAL_NUMBER_TO_DIAL, number);
//把原始的Intent数据拷贝过来
//主要去解析EXTRA_GATEWAY_PROVIDER_PACKAGE和EXTRA_GATEWAY_URI，而这两项均为null
PhoneUtils.checkAndCopyPhoneProviderExtras(intent, newIntent);

//还有一个Intent
Intent selectPhoneIntent = new Intent(ACTION_SIP_SELECT_PHONE, uri);
//指明接受者是SipCallOptionHandler
selectPhoneIntent.setClass(context, SipCallOptionHandler.class);
//把上面的Intent放到EXTRA_NEW_CALL_INTENT中
selectPhoneIntent.putExtra(EXTRA_NEW_CALL_INTENT, newIntent);
//用新的task装载
selectPhoneIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
//发送，走起
context.startActivity(selectPhoneIntent);
}

        上面的操作又是发起了一个Intent，构成有：

        Action  --->    ACTION_SIP_SELECT_PHONE

        EXTRA_NEW_CALL_INTENT--->拨号的Intent，而且这个Intent的Action为ACTION_CALL

        EXTRA_ACTUAL_NUMBER_TO_DIAL ---> 为拨号的号码

1.3、互联网通话处理阶段（SipCallOptionHandler.java）

        我们来看上面Intent的接受过程，在SipCallOptionHandler中：

@SipCallOptionHandler.java
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

//得到Intent
Intent intent = getIntent();
String action = intent.getAction();

//外层的Intent
if (!OutgoingCallBroadcaster.ACTION_SIP_SELECT_PHONE.equals(action)) {
finish();
return;
}

//得到拨号的Intent
mIntent = (Intent) intent.getParcelableExtra(OutgoingCallBroadcaster.EXTRA_NEW_CALL_INTENT);
if (mIntent == null) {
finish();
return;
}

//是否支持互联网通话
boolean voipSupported = PhoneUtils.isVoipSupported();
mSipProfileDb = new SipProfileDb(this);
mSipSharedPreferences = new SipSharedPreferences(this);
mCallOption = mSipSharedPreferences.getSipCallOption();
Uri uri = mIntent.getData();
String scheme = uri.getScheme();
//得到通话的号码
mNumber = PhoneNumberUtils.getNumberFromIntent(mIntent, this);
//是否有网络
boolean isInCellNetwork = PhoneGlobals.getInstance().phoneMgr.isRadioOn();
//是否是tel：或者sip：的协议
boolean isKnownCallScheme = Constants.SCHEME_TEL.equals(scheme)||Constants.SCHEME_SIP.equals(scheme);
boolean isRegularCall = Constants.SCHEME_TEL.equals(scheme)
&& !PhoneNumberUtils.isUriNumber(mNumber);

if (!isKnownCallScheme) {
//异常处理，处理非法协议。
setResultAndFinish();
return;
}

if (!voipSupported) {
if (!isRegularCall) {
showDialog(DIALOG_NO_VOIP);
} else {
//当前不是IP通话，因此走这里
setResultAndFinish();
}
return;
}

setResultAndFinish();
}

        继续看setResultAndFinish

private void setResultAndFinish() {
//放在主线程中操作
runOnUiThread(new Runnable() {
public void run() {
if (mOutgoingSipProfile != null) {
//互联网通话
if (!isNetworkConnected()) {
showDialog(DIALOG_NO_INTERNET_ERROR);
return;
}
createSipPhoneIfNeeded(mOutgoingSipProfile);
mIntent.putExtra(OutgoingCallBroadcaster.EXTRA_SIP_PHONE_URI,
mOutgoingSipProfile.getUriString());
if (mMakePrimary) {
mSipSharedPreferences.setPrimaryAccount(
mOutgoingSipProfile.getUriString());
}
}

if (mUseSipPhone && mOutgoingSipProfile == null) {
showDialog(DIALOG_START_SIP_SETTINGS);
return;
} else {
//正常拨号
PhoneGlobals.getInstance().callController.placeCall(mIntent);
}
finish();
}
});
}

        上面可以看出，在SipCallOptionHandler.java文件中主要针对互联网通话进行处理，注意，这里的互联网通话和IP拨号不同。

1.4、Phone模块其他的处理

        主要作用是把intent解析为号码，同时得到拨号必须的Phone、CM、context等重要信息。

@CallController.java
public void placeCall(Intent intent)
{
//拨打
CallStatusCode status = placeCallInternal(intent);
//显示InCallScreen
mApp.displayCallScreen(!intent.getBooleanExtra(Constants.EXTRA_IS_VIDEO_CALL, false), forPlaceCall);
}
private CallStatusCode placeCallInternal(Intent intent) {
//得到号码
number = PhoneUtils.getInitialNumber(intent);
//得到Phone对象
phone = PhoneUtils.pickPhoneBasedOnNumber(mCM, scheme, number, sipPhoneUri);
//检查当前状态
okToCallStatus = checkIfOkToInitiateOutgoingCall(phone.getServiceState().getState());
//得到联系人的数据
Uri contactUri = intent.getData();
//拨号
int callStatus = PhoneUtils.placeCall(mApp,
phone,
number,
contactUri,
(isEmergencyNumber || isEmergencyIntent),
inCallUiState.providerGatewayUri);
}

        上面得到了一个极其重要的变量，Phone变量，我们待会儿详细分析他的来历，这里只需要记住，Phone是通过PhoneUtils.pickPhoneBasedOnNumber()的方式得到的。

@PhoneUtils.java
public static int placeCall(Context context, Phone phone,
String number, Uri contactRef, boolean isEmergencyCall,
Uri gatewayUri) {
//得到app
final PhoneGlobals app = PhoneGlobals.getInstance();
//号码
numberToDial = number;
//拨号
connection = app.mCM.dial(phone, numberToDial);
//设置音频模式
setAudioMode();
return status;
}

        上面的dial是通过app.mCM完成的，而这个mCM就是在PhoneGlobals.java中的onCreate时初始化的：

mCM = CallManager.getInstance();

        说明dial是通过CallManager去执行dial的：

二、framework中的流程

@CallManager.java
public Connection dial(Phone phone, String dialString) throws CallStateException {
//得到basePhone
Phone basePhone = getPhoneBase(phone);

//根据当前的通话状态决定是否可以继续拨号
if (!canDial(phone)) {
throw new CallStateException("cannot dial in current state");
}

if ( hasActiveFgCall() ) {
//已经有电话存在
}
//拨号
result = basePhone.dial(dialString);
return result;
}

        代码走到这里，就简化为调用一个Phone对象的dial方法了，此时要想继续往下分析，就必须知道这个Phone对象的来历。下面我们要做两件事：

            1、查出Phone对象到底来自于哪里。

            2、我们如何通过PhoneUtils.pickPhoneBasedOnNumber()的方式得到了这个Phone对象。

2.1、Phone的来历

        Phone在通话中扮演着极其重要的操作，我们来看一下Phone是怎样产生的。

        我们知道，Phone模块进程第一个启动的类就是PhoneGlobals，他是在手机开机的过程中启动的。那么我们看一下他的初始化过程：

@PhoneGlobals.java
public void onCreate() {
//创建Phone对象
PhoneFactory.makeDefaultPhones(this);
//得到创建的Phone对象
phone = PhoneFactory.getDefaultPhone();
//初始化CallManager并把Phone对象注册给CallManager
mCM = CallManager.getInstance();
mCM.registerPhone(phone);
//初始化NotificationMgr
notificationMgr = NotificationMgr.init(this);
phoneMgr = PhoneInterfaceManager.init(this, phone);
//开启SIP服务
mHandler.sendEmptyMessage(EVENT_START_SIP_SERVICE);
//铃声初始化
ringer = Ringer.init(this);
//得到电源管理服务
mPowerManager = (PowerManager) getSystemService(Context.POWER_SERVICE);
//距离传感器
if (proximitySensorModeEnabled()) {
mAccelerometerListener = new AccelerometerListener(this, this);
}
//按键管理
mKeyguardManager = (KeyguardManager) getSystemService(Context.KEYGUARD_SERVICE);
//电源管理
mPowerManagerService = IPowerManager.Stub.asInterface(ServiceManager.getService("power"));
//又是各种初始化
callController = CallController.init(this);
inCallUiState = InCallUiState.init(this);
callerInfoCache = CallerInfoCache.init(this);
notifier = CallNotifier.init(this, phone, ringer, new CallLogAsync());
//SIM卡状态监听
IccCard sim = phone.getIccCard();
if (sim != null) {
sim.registerForNetworkLocked(mHandler, EVENT_SIM_NETWORK_LOCKED, null);
}
mCM.registerForMmiComplete(mHandler, MMI_COMPLETE, null);
PhoneUtils.initializeConnectionHandler(mCM);
mTtyEnabled = getResources().getBoolean(R.bool.tty_enabled);
//注册一个Filter
IntentFilter intentFilter = new IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED);
intentFilter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
intentFilter.addAction(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED);
intentFilter.addAction(TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED);
intentFilter.addAction(Intent.ACTION_HEADSET_PLUG);
intentFilter.addAction(Intent.ACTION_DOCK_EVENT);
intentFilter.addAction(TelephonyIntents.ACTION_SIM_STATE_CHANGED);
intentFilter.addAction(TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED);
intentFilter.addAction(TelephonyIntents.ACTION_SERVICE_STATE_CHANGED);
intentFilter.addAction(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED);
intentFilter.addAction(AudioManager.RINGER_MODE_CHANGED_ACTION);
registerReceiver(mReceiver, intentFilter);
//注册Filter检测媒体按键的事件
IntentFilter mediaButtonIntentFilter = new IntentFilter(Intent.ACTION_MEDIA_BUTTON);
mediaButtonIntentFilter.setPriority(1);
registerReceiver(mMediaButtonReceiver, mediaButtonIntentFilter);
//注册Filter检测音频服务
AudioManager am = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
am.registerMediaButtonEventReceiverForCalls(new ComponentName(this.getPackageName(),
MediaButtonBroadcastReceiver.class.getName()));
PhoneUtils.setAudioMode(mCM);
}

        可以看到，Phone模块在初始化过程就是对CallManager、CallController、NotificationMgr等进行初始化。同时注册各项必须的服务。而关于Phone对象的创建是通过PhoneFactory.makeDefaultPhones(this)实现的。我们继续往下看创建的过程：

@PhoneFactory.java
public static void makeDefaultPhones(Context context) {
makeDefaultPhone(context);
}
public static void makeDefaultPhone(Context context) {
//打开telephony的Socket
new LocalServerSocket("com.android.internal.telephony");
//Phone的通知管理
sPhoneNotifier = new DefaultPhoneNotifier();
//得到RILJ
sCommandsInterface = new RIL(context, networkMode, cdmaSubscription);
//得到当前的网络类型
int phoneType = TelephonyManager.getPhoneType(networkMode);
//根据当前的网络类型创建响应的PhoneProxy
if (phoneType == PhoneConstants.PHONE_TYPE_GSM) {
//用GSMPhone创建PhoneProxy
sProxyPhone = new PhoneProxy(new GSMPhone(context,sCommandsInterface, sPhoneNotifier));
} else if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
switch (TelephonyManager.getLteOnCdmaModeStatic()) {
case PhoneConstants.LTE_ON_CDMA_TRUE:
//用CDMALTEPhone创建PhoneProxy
sProxyPhone = new PhoneProxy(new CDMALTEPhone(context,sCommandsInterface, sPhoneNotifier));
break;
case PhoneConstants.LTE_ON_CDMA_FALSE:
default:
//用CDMAPhone创建PhoneProxy
sProxyPhone = new PhoneProxy(new CDMAPhone(context,sCommandsInterface, sPhoneNotifier));
break;
}
}
}

        上面看到，我们创建的Phone对象其实只是一个Phone的代理（PhoneProxy）而已，而创建这个代理对象需要分两步：

            1、首先根据当前的网络类型创建不同的PhoneBase对象，也就是GSMPhone/CDMALTEPhone/CDMAPhone等；

            2、然后再用这个PhoneBase对象去构建PhoneProxy对象。

        那么，PhoneProxy和GSMPhone又是什么东西呢？我们来看看他们的继承关系：

        先来看一下PhoneProxy：

public class PhoneProxy extends Handler implements Phone

        再来看GSMPhone：

public class GSMPhone extends PhoneBase
public abstract class PhoneBase extends Handler implements Phone

        上面的继承关系说明，PhoneProxy和GSMPhone其实都是一个Handler，而且是继承了Phone的接口。这么做的好处是什么呢？

        我们知道，对于一个手机来说，无论采用哪种网络制式，他所具备的基本功能是相同的，比如都需要提供打电话、发短信、查询通话状态、读取SIM卡联系人等操作，因此对所有制式的phone都抽象为一个统一的接口：Phone。

        但另一方面，不同的网络制式在具体的每项功能实现上，又有很大的不同。因此，需要根据不同的网络制式去实现不同的basePhone，但是都需要完成Phone接口所定义的方法。

        而在basePhone之上，再次用PhoneProxy把不同的basePhone封装，这样一来，从上层来看，就屏蔽了不同的basePhone，所有的Phone都是统一的PhoneProxy。

        在这里我们只分析GSMPhone，至于CDMAPhone和CDMALTEPhone的基本原理都是类似的。而在分析GSMPhone的创建过程之前，先来看一下创建GSMPhone的必要条件：

sProxyPhone = new PhoneProxy(new GSMPhone(context,sCommandsInterface, sPhoneNotifier));

        上面可以看出，创建GSMPhone对象需要用到2个特殊的变量，sCommandsInterface和sPhoneNotifier：

sPhoneNotifier = new DefaultPhoneNotifier();
sCommandsInterface = new RIL(context, networkMode, cdmaSubscription);

        看来sPhoneNotifier就是DefaultPhoneNotifier对象，而DefaultPhoneNotifier作用就是当相应的Phone有消息从底层上来时，将会通过DefaultPhoneNotifier把消息发送给上层，也就是说，sPhoneNotifier充当了通知的作用。

        而sCommandsInterface就是RIL对象。这是framework层与RILC层沟通的渠道，所有上层与RIL层的沟通都需要通过RIL对象装换为相应的命令，最终在RIL.java中通过Socket通道发送给RIL层。

        在创建相应的XXXPhone的时候把上面两个变量传递下去：

@GSMPhone.java
public GSMPhone (Context context, CommandsInterface ci, PhoneNotifier notifier) {
this(context,ci,notifier, false);
}
public GSMPhone (Context context, CommandsInterface ci, PhoneNotifier notifier, boolean unitTestMode) {
//把参数传递给父类，也就是PhoneBase类
super(notifier, context, ci, unitTestMode);

//mCM是在父类（PhoneBase）中初始化的
mCM.setPhoneType(PhoneConstants.PHONE_TYPE_GSM);
//各种初始化
mCT = new GsmCallTracker(this);
mSST = new GsmServiceStateTracker (this);
mSMS = new GsmSMSDispatcher(this, mSmsStorageMonitor, mSmsUsageMonitor);
mDataConnectionTracker = new GsmDataConnectionTracker (this);
mSimPhoneBookIntManager = new SimPhoneBookInterfaceManager(this);
mSimSmsIntManager = new SimSmsInterfaceManager(this, mSMS);
mSubInfo = new PhoneSubInfo(this);
//对mCM进行各种注册
mCM.registerForAvailable(this, EVENT_RADIO_AVAILABLE, null);
mCM.registerForOffOrNotAvailable(this, EVENT_RADIO_OFF_OR_NOT_AVAILABLE, null);
mCM.registerForOn(this, EVENT_RADIO_ON, null);
mCM.setOnUSSD(this, EVENT_USSD, null);
mCM.setOnSuppServiceNotification(this, EVENT_SSN, null);
mSST.registerForNetworkAttached(this, EVENT_REGISTERED_TO_NETWORK, null);

//设置系统属性，GSMPhone被激活
SystemProperties.set(TelephonyProperties.CURRENT_ACTIVE_PHONE,
new Integer(PhoneConstants.PHONE_TYPE_GSM).toString());
}

        GSMPhone的初始化过程分为两个重要步骤，第一个步骤是在其父类中完成的，主要是用传递下来的sPhoneNotifier去初始化mNotifier，用传递下来的sCommandsInterface初始化mCM。第二个步骤就是在当前类中完成剩余的mCT、mSST、mSMS、mDataConnectionTracker等重要成员变量的初始化过程。

        然后再来看PhoneProxy对象的初始化过程：

@PhoneProxy.java
public PhoneProxy(PhoneBase phone) {
mActivePhone = phone;
mResetModemOnRadioTechnologyChange = SystemProperties.getBoolean(
TelephonyProperties.PROPERTY_RESET_ON_RADIO_TECH_CHANGE, false);
mIccSmsInterfaceManagerProxy = new IccSmsInterfaceManagerProxy(
phone.getIccSmsInterfaceManager());
mIccPhoneBookInterfaceManagerProxy = new IccPhoneBookInterfaceManagerProxy(
phone.getIccPhoneBookInterfaceManager());
mPhoneSubInfoProxy = new PhoneSubInfoProxy(phone.getPhoneSubInfo());
mCommandsInterface = ((PhoneBase)mActivePhone).mCM;

mCommandsInterface.registerForRilConnected(this, EVENT_RIL_CONNECTED, null);
mCommandsInterface.registerForOn(this, EVENT_RADIO_ON, null);
mCommandsInterface.registerForVoiceRadioTechChanged(
this, EVENT_VOICE_RADIO_TECH_CHANGED, null);
mIccCardProxy = new IccCardProxy(phone.getContext(), mCommandsInterface);
if (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_GSM) {
// For the purpose of IccCardProxy we only care about the technology family
mIccCardProxy.setVoiceRadioTech(ServiceState.RIL_RADIO_TECHNOLOGY_UMTS);
} else if (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
mIccCardProxy.setVoiceRadioTech(ServiceState.RIL_RADIO_TECHNOLOGY_1xRTT);
}
}

        在这个过程中把刚才的GSMPhone注册给了mActivePhone变量，然后又创建了一些代理对象，比如mIccSmsInterfaceManagerProxy、IccPhoneBookInterfaceManagerProxy、mPhoneSubInfoProxy、mIccCardProxy等。

        经过上面的步骤，不仅创建了phone的对象，而且又注册了各种附加的代理对象，上层可以通过对不同的代理对象的调用去完成不同的功能。
        至此，Phone的来历我们就摸清了，用一句话来表述就是，Phone对象就是GSMPhone对象（GSM制式下）。

2.2、我们是如何通过pickPhoneBasedOnNumber()的方式得到的Phone对象的

        要回答这个问题，我们就要看当初创建Phone对象之后还做了哪些动作。

        在分析Phone对象来历时，我们知道Phone对象是在PhoneGlobals中被创建的：

@PhoneGlobals.java
public void onCreate() {
//创建Phone对象并获取
PhoneFactory.makeDefaultPhones(this);
phone = PhoneFactory.getDefaultPhone();
//初始化CallManager
mCM = CallManager.getInstance();
//把Phone注册给CallManager
mCM.registerPhone(phone);
}

        我们看到，得到Phone对象后就把他注册给了CallManager，而所谓的注册其实就是把Phone对象传递给mDefaultPhone，同时把它放在一个叫做mPhones的数组中：

@CallManager.java
public boolean registerPhone(Phone phone) {
Phone basePhone = getPhoneBase(phone);
if (basePhone != null && !mPhones.contains(basePhone)) {
if (mPhones.isEmpty()) {
//第一次注册时，mPhones列表当然为空
mDefaultPhone = basePhone;
}
mPhones.add(basePhone);
}
}

        这样一来，我们就可以通过getDefaultPhone的方式从CallManager中得到Phone:

public Phone getDefaultPhone() {
return mDefaultPhone;
}

        我们回到上面拨号的过程，上面看到，在拨号的过程中，我们需要Phone时是通过以下方式得到Phone对象的：

phone = PhoneUtils.pickPhoneBasedOnNumber(mCM, scheme, number, sipPhoneUri);

        我们继续往下看：

@PhoneUtils.java
public static Phone pickPhoneBasedOnNumber(CallManager cm, String scheme, String number, String primarySipUri) {
return cm.getDefaultPhone();
}

        这里的cm就是传递下来了CallManager，因此pickPhoneBasedOnNumber的方式其实就是调用了CallManager中的getDefaultPhone方法，这种形式正好符合我们的预期。
        由此，我们不仅在3.1节中分析了Phone对象的创建过程，而且也在当前节中分析了得到Phone对象的方法。

2.3、继续拨号之旅

        在上面的两个小节中主要讲解了Phone对象的来历，简单的说，Phone对象就是GSMPhone对象（对GSM网络来说）。而在前面追踪拨号流程时，我们跟踪到了CallManager.java中的basePhone.dial(dialString)，因此，这里的dial就到了GSMPhone中：

@GSMPhone.java
public Connection dial(String dialString) throws CallStateException {
return dial(dialString, null);
}

        再次调用，此时uusInfo为空。

public Connection dial (String dialString, UUSInfo uusInfo) throws CallStateException {
return mCT.dial(newDialString, uusInfo);
}

        我们将上面的代码简化到最关键的一句话，就是调用mCT的dial方法。而这里的mCT就是在GSMPhone的构造函数初始化的GsmCallTracker对象：

mCT = new GsmCallTracker(this);

        因此我们又要来到GsmCallTracker中：

@GsmCallTracker.java
Connection dial(String dialString, UUSInfo uusInfo) throws CallStateException {
return dial(dialString, CommandsInterface.CLIR_DEFAULT, uusInfo);
}

        继续调用：

Connection dial (String dialString, int clirMode, UUSInfo uusInfo) throws CallStateException {
//构建一个GSM连接
pendingMO = new GsmConnection(phone.getContext(), checkForTestEmergencyNumber(dialString), this, foregroundCall);
//拨号
cm.dial(pendingMO.address, clirMode, uusInfo, obtainCompleteMessage());
//更新Phone状态
updatePhoneState();
//发送状态更新通知
phone.notifyPreciseCallStateChanged();
}

        在上面这个过程中，调用了cm的dial方法，这里的cm是Phone对象的mCM：

GsmCallTracker (GSMPhone phone) {
this.phone = phone;
cm = phone.mCM;
}

        而在前面分析过，GSMPhone中的mCM是在其父类PhoneBase中被初始化的：

@PhoneBase.java
protected PhoneBase(PhoneNotifier notifier, Context context, CommandsInterface ci, boolean unitTestMode) {
this.mNotifier = notifier;
this.mContext = context;
mCM = ci;
}

        这里看到，mCM其实就是传递下来的CommandsInterface，在往上追溯的话，其实就是当初创建GSMPhone时传递的RIL对象。因此framework拨号的最后，是走到了RIL.java中，并构建拨号的请求发送给RILC，也就是RIL层：

@RIL.java
public void dial(String address, int clirMode, UUSInfo uusInfo, Message result) {
//构建RIL层的请求码：RIL_REQUEST_DIAL
RILRequest rr = RILRequest.obtain(RIL_REQUEST_DIAL, result);
rr.mp.writeString(address);
rr.mp.writeInt(clirMode);

if (uusInfo == null) {
rr.mp.writeInt(0); // UUS information is absent
} else {
rr.mp.writeInt(1); // UUS information is present
rr.mp.writeInt(uusInfo.getType());
rr.mp.writeInt(uusInfo.getDcs());
rr.mp.writeByteArray(uusInfo.getUserData());
}
//发送
send(rr);
}

        发送的过程就是把相应的RILRequest通过mSender发送出去：

private void send(RILRequest rr) {
Message msg;
if (mSocket == null) {
rr.onError(RADIO_NOT_AVAILABLE, null);
rr.release();
return;
}
msg = mSender.obtainMessage(EVENT_SEND, rr);
acquireWakeLock();
msg.sendToTarget();
}

        继续看一下mSender的处理流程：

@Override
public void handleMessage(Message msg) {
//得到要发送的数据
RILRequest rr = (RILRequest)(msg.obj);
switch (msg.what) {
case EVENT_SEND:
//得到Socket
LocalSocket s;
s = mSocket;

byte[] data;
data = rr.mp.marshall();
rr.mp.recycle();
rr.mp = null;

dataLength[0] = dataLength[1] = 0;
dataLength[2] = (byte)((data.length >> 8) & 0xff);
dataLength[3] = (byte)((data.length) & 0xff);

//把数据发送给RIL层
s.getOutputStream().write(dataLength);
s.getOutputStream().write(data);
break;
case EVENT_WAKE_LOCK_TIMEOUT:
}
}

        经过以上的过程，就把拨号的请求发送到了RIL层。

三、总体流程图

        现在我们贴出整个拨出号码的流程图：