我们从按下拨号开始分析呼出电话的流程。此流程从拨号盘分析到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层。

三、总体流程图

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

Android呼出电话流程（原）