上图清晰地显示了各层之间的消息处理关系，CallManager连接Framework层和应用层的Phone，CallManager处理GSMPhone注册的消息事件，并且触发CallManager注册的消息事件，而CallNotifier处理CallManager消息，这样就将RIL层的消息一级一级传送的应用层的Phone了。

2. RIL架构

2.1 介绍

Android的无线接口层（RIL）提供了Android电话服务（android.telephony）与无线电硬件之间的抽象层。RIL是通讯无关的，提供基于GSM的网络支持。

下图显示了RIL位于Android电话系统架构中的位置，其中实线框表示Android部分，虚线框表示合作伙伴所专用的部分。

RIL的架构：

RIL 整体架构分为三层，最上层为 RIL-Java 适配层，中间层即为 RILD, 下层为 Modem. RIL-Java 通过 socket 与 RILD 层对接，RILD 层与 Modem 通过串口对接。

RIL是手机上 Modem (基带芯片，WCDMA，CDMA2000 等就是指基带芯片的不同技术) 与 android 系统通讯的桥梁，RIL 的角色非常重要，RIL 被设计成能够可靠的高效的传输数据一个模块。

RIL包含两个基本部件：

RIL守护进程（RIL Daemon）：RIL守护进程初始化Vendor RIL，用于通过 socket 和 framework 通讯以及处理整个 RIL 的 event。管理所有来自Android通讯服务的通讯，将其作为被请求的命令（solicited commands）调度给Vendor RIL。
Vendor RIL：ril.h文件中的无线电专用Vendor RIL掌管着所有和无线电硬件的通讯，并且通过未被请求的命令（unsolicited commands）分发给RIL Daemon。手机厂商自己实现的部分，之所以这样设计是因为不同的厂商使用的 Modem 不一样，而 RIL 又和 Modem 紧密联系，所以 Android 有把和 Modem 联系紧密的部分和公共部分剥离开，让不同的厂商可以自己实现 vendor RIL 以适应厂商自己的 Modem。

[来源于通信百科]

RIL(Radio Interface Layer)

    目前的智能机在硬件上多采用双cpu的架构，一个是基带处理器，主要处理数字信号、语音信号的编码解码以及GSM通信协议，另一个是应用处理器，运行操作系统和各种应用程序。基带处理器、射频和其它外围芯片作为一个模块，成为GSM/GPRS MODEM，提供AT命令接口。网络的应用已经是一个需求的热点，而目前的GSM模块大多都能支持GPRS功能。应用处理器通过AT命令集与带GPRS功能的无线通讯模块通信，为实现网络的应用提供了一个最底层的支持。从软件的角度来看，RIL(Radio Interface Layer)工作在PPP、TCP/IP协议之下，负责数据的可靠传输、AT命令的发送以及response的解析。当然，除了对网络的支持，RIL也支持SMS、Voice Call等功能。从这一点来看，RIL的性能好坏影响着所有无线通信应用相关的软件，而软件设计的合理性又影响着RIL的性能。

Windows Mobile上的RIL

    Windows Mobile是用在智能手机上的主流操作系统之一。微软是这样介绍RIL的：作为Windows Mobile的一个非常重要的组件，RIL使各种无线语音和数据应用成为可能。运行在Windows Mobile上的软件可以通过RIL无缝地与GSM/GPRS或者CDMA2000 1X modem通信。RIL的位置处于无线基带系统的协议栈之上，Windows Mobile的CellCore层之下。由于RIL隐藏了硬件上的一些细节，OEM厂商可以根据自己的需要将不同型号的无线modem集成到它们的产品之中。

Android上的RIL

    Android是目前最流行智能手机操作系统之一，Android的RIL位于应用程序框架与内核之间，分成了两个部分，一个部分是rild,它负责socket与应用程序框架进行通信。另外一个部分是Vendor RIL，这个部分负责向下是通过两种方式与radio进行通信，它们是直接与radio通信的AT指令通道和用于传输包数据的通道，数据通道用于手机的上网功能。对于RIL的java框架部分，也被分成了两个部分，一个是RIL模块，这个模块主要用于与下层的rild进行通信，另外一个是Phone模块，这个模块直接暴露电话功能接口给应用开发用户，供他们调用以进行电话功能的实现。

2.2 RIL初始化

Android在启动时初始化通讯栈和Vendor RIL，描述如下：

RILL Daemon读取rild.lib路径和rild.libargs系统参数，决定应该使用的Vendor RIL库和向Vendor RIL提供的初始化参数；
RILL Daemon加载Vendor RIL库，执行RIL_Init初始化RIL并为RIL函数获取参数；
RILL Daemon调用Android通讯栈中RIL_register，为Vendor RIL函数提供参考。

　　RILL Daemon源码请参考//device/commands/rild/rild.c

2.3 RIL交互

RIL句柄提供了两种交互方式：

主动请求命令（Solicited commands）：主动请求命令来自RIL lib，比如DIAL和HANGUP。
被动请求命令（Unsolicited responses）：被动请求命令来自基带，比如CALL_STATE_CHANGED 和 NEW_SMS。

2.3.1 主动请求

以下代码片段属于主动请求命令：
　　void OnRequest (int request_id, void *data, size_t datalen, RIL_Token t);
　　void OnRequestComplete (RIL_Token t, RIL_Error e, void *response, size_t responselen);
　　
有超过60个主动请求命令：

SIM PIN，IO和IMSI/IMEI（11）
电话状态和动作（拨号，应答，静音…）（16）
网络状态查询（4）
网络设置（禁止，转发，选择…）（12）
短信（3）
PDP连接（4）
电源和复位（2）
辅助服务（5）
供应商定义及其支持（4）

下图表明了Android系统一个主动请求的电话过程：

2.3.2 被动请求

以下代码片段属于被动请求命令：
　　void OnUnsolicitedResponse (int unsolResponse, void *data, size_t datalen);
　　
有超过10条被动请求命令：

网络状态改变（4）
新短信通知（3）
新USSD通知（2）
信号强度和时间改变（2）

下图表明Android系统中一个被动请求的电话过程：

3. RIL层事件注册过程

[frameworks\base\telephony\java\com\android\internal\telephony\PhoneFactory.java]


public static void makeDefaultPhone(Context context) {
	synchronized(Phone.class) {
		if (!sMadeDefaults) {
			sLooper = Looper.myLooper();
			sContext = context;
			if (sLooper == null) {
				throw new RuntimeException("PhoneFactory.makeDefaultPhone must be called from Looper thread");
			}
			int retryCount = 0;
			for(;;) {
				boolean hasException = false;
				retryCount ++;
				try {
					new LocalServerSocket("com.android.internal.telephony");
				} catch (java.io.IOException ex) {
					hasException = true;
				}
				if ( !hasException ) {
					break;
				} else if (retryCount > SOCKET_OPEN_MAX_RETRY) {
					throw new RuntimeException("PhoneFactory probably already running");
				} else {
					try {
						Thread.sleep(SOCKET_OPEN_RETRY_MILLIS);
					} catch (InterruptedException er) {
					}
				}
			}
			sPhoneNotifier = new DefaultPhoneNotifier();
			// Get preferred network mode
			int preferredNetworkMode = RILConstants.PREFERRED_NETWORK_MODE;
			if (TelephonyManager.getLteOnCdmaModeStatic() == PhoneConstants.LTE_ON_CDMA_TRUE) {
				preferredNetworkMode = Phone.NT_MODE_GLOBAL;
			}
			//从数据库中读取网络模式
			int networkMode = Settings.Global.getInt(context.getContentResolver(),
					Settings.Global.PREFERRED_NETWORK_MODE, preferredNetworkMode);
			Log.i(LOG_TAG, "Network Mode set to " + Integer.toString(networkMode));
 
			int cdmaSubscription;        
			int lteOnCdma = TelephonyManager.getLteOnCdmaModeStatic();
			switch (lteOnCdma) {
				case PhoneConstants.LTE_ON_CDMA_FALSE:
					cdmaSubscription = CdmaSubscriptionSourceManager.SUBSCRIPTION_FROM_NV;
					Log.i(LOG_TAG, "lteOnCdma is 0 use SUBSCRIPTION_FROM_NV");
					break;
				case PhoneConstants.LTE_ON_CDMA_TRUE:
					cdmaSubscription = CdmaSubscriptionSourceManager.SUBSCRIPTION_FROM_RUIM;
					Log.i(LOG_TAG, "lteOnCdma is 1 use SUBSCRIPTION_FROM_RUIM");
					break;
				case PhoneConstants.LTE_ON_CDMA_UNKNOWN:
				default:
					//Get cdmaSubscription mode from Settings.System
					cdmaSubscription = Settings.Global.getInt(context.getContentResolver(),
							Settings.Global.PREFERRED_CDMA_SUBSCRIPTION,
							preferredCdmaSubscription);
					Log.i(LOG_TAG, "lteOnCdma not set, using PREFERRED_CDMA_SUBSCRIPTION");
					break;
			}
			Log.i(LOG_TAG, "Cdma Subscription set to " + cdmaSubscription);
			//reads the system properties and makes commandsinterface
			sCommandsInterface = new RIL(context, networkMode, cdmaSubscription);
			// Instantiate UiccController so that all other classes can just call getInstance()
			UiccController.make(context, sCommandsInterface);  
			//根据网络模式得到电话类型
			int phoneType = TelephonyManager.getPhoneType(networkMode);
			//根据电话类型创建对应类型的Phone对象，并且使用创建的Phone对象来构造PhoneProxy代理对象
			if (phoneType == PhoneConstants.PHONE_TYPE_GSM) {
				Log.i(LOG_TAG, "Creating GSMPhone");
				sProxyPhone = new PhoneProxy(new GSMPhone(context,sCommandsInterface, sPhoneNotifier));
			} else if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
				switch (TelephonyManager.getLteOnCdmaModeStatic()) {
					case PhoneConstants.LTE_ON_CDMA_TRUE:
						Log.i(LOG_TAG, "Creating CDMALTEPhone");
						sProxyPhone = new PhoneProxy(new CDMALTEPhone(context,sCommandsInterface, sPhoneNotifier));
						break;
					case PhoneConstants.LTE_ON_CDMA_FALSE:
					default:
						Log.i(LOG_TAG, "Creating CDMAPhone");
						sProxyPhone = new PhoneProxy(new CDMAPhone(context,sCommandsInterface, sPhoneNotifier));
						break;
				}
			}
			sMadeDefaults = true;
		}
	}
}

在PhoneFactory的makeDefaultPhone函数中，首先构造一个DefaultPhoneNotifier对象和RIL对象，然后从数据库中读取网络模式，根据网络模式得到对应的电话类型，从而构造对应的Phone对象，并为该Phone对象创建一个PhoneProxy代理对象。对于GSM网络，会构造一个GSMPhone对象。

[frameworks\base\telephony\java\com\android\internal\telephony\gsm\GSMPhone.java]


public GSMPhone (Context context, CommandsInterface ci, PhoneNotifier notifier, boolean unitTestMode) {
	super(notifier, context, ci, unitTestMode);
	mCM.setPhoneType(Phone.PHONE_TYPE_GSM);
	mIccCard.set(MsUiccController.getInstance(this).getIccCard());
	mIccRecords = mIccCard.get().getIccRecords();
	mCT = new GsmCallTracker(this);
	mSST = new GsmServiceStateTracker (this);
	mSMS = new GsmSMSDispatcher(this, mSmsStorageMonitor, mSmsUsageMonitor);
	if (!unitTestMode) {
		mSimPhoneBookIntManager = new SimPhoneBookInterfaceManager(this);
		mSimSmsIntManager = new SimSmsInterfaceManager(this, mSMS);
		mSubInfo = new PhoneSubInfo(this);
	}
	mCM.registerForAvailable(this, EVENT_RADIO_AVAILABLE, null);
	registerForSimRecordEvents();
	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);
 
	mHandlerThread = new HandlerThread("GSMPhone_AsyncThread");
	mHandlerThread.start();
	mAsyncThread = new AsyncThread(mHandlerThread.getLooper());
	if (false) {
		try {
			//debugSocket = new LocalServerSocket("com.android.internal.telephony.debug");
			debugSocket = new ServerSocket();
			debugSocket.setReuseAddress(true);
			debugSocket.bind (new InetSocketAddress("127.0.0.1", 6666));
 
			debugPortThread
				= new Thread(
					new Runnable() {
						public void run() {
							for(;;) {
								try {
									Socket sock;
									sock = debugSocket.accept();
									Log.i(LOG_TAG, "New connection; resetting radio");
									mCM.resetRadio(null);
									sock.close();
								} catch (IOException ex) {
									Log.w(LOG_TAG,
										"Exception accepting socket", ex);
								}
							}
						}
					},
					"GSMPhone debug");
 
			debugPortThread.start();
 
		} catch (IOException ex) {
			Log.w(LOG_TAG, "Failure to open com.android.internal.telephony.debug socket", ex);
		}
	}
	//Change the system property
	SystemProperties.set(TelephonyProperties.CURRENT_ACTIVE_PHONE,
			new Integer(Phone.PHONE_TYPE_GSM).toString());
}

在构造GSMPhone对象时，首先使用父类的成员变量CommandsInterfac mCM设置电话类型，由于RIL类实现了CommandsInterfac接口，因此mCM引用RIL对象。在构造GSMPhone对象时通过参数传入并设置父类PhoneBase的成员变量mCM。

[frameworks\base\telephony\java\com\android\internal\telephony\PhoneBase.java]


protected PhoneBase(PhoneNotifier notifier, Context context, CommandsInterface ci,
		boolean unitTestMode) {
	this.mNotifier = notifier;
	this.mContext = context;
	mLooper = Looper.myLooper();
	mCM = ci;
	setPropertiesByCarrier();
	setUnitTestMode(unitTestMode);
	SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
	mDnsCheckDisabled = sp.getBoolean(DNS_SERVER_CHECK_DISABLED_KEY, false);
	mCM.setOnCallRing(this, EVENT_CALL_RING, null);
	mIsVoiceCapable = mContext.getResources().getBoolean(com.android.internal.R.bool.config_voice_capable);
	mDoesRilSendMultipleCallRing = SystemProperties.getBoolean(
			TelephonyProperties.PROPERTY_RIL_SENDS_MULTIPLE_CALL_RING, true);
	Log.d(LOG_TAG, "mDoesRilSendMultipleCallRing=" + mDoesRilSendMultipleCallRing);
	mCallRingDelay = SystemProperties.getInt(
			TelephonyProperties.PROPERTY_CALL_RING_DELAY, 3000);
	Log.d(LOG_TAG, "mCallRingDelay=" + mCallRingDelay);
	// Initialize device storage and outgoing SMS usage monitors for SMSDispatchers.
	mSmsStorageMonitor = new SmsStorageMonitor(this);
	mSmsUsageMonitor = new SmsUsageMonitor(context);
}

构造GSMPhone对象同时也会创建一个GsmCallTracker对象，GSMCallTracker实现了电话的拨打 (Dial)、接听/拒绝 (accept/reject)、挂断 (hangup)、保持 (hold)、切换以及电话会议等功能，它还负责查询Modem当前有多少路通话，维护电话状态等功能。

GSMCallTracker中包含了GsmConnection、RegistrantList、 GSMCall和Phone.State等类的对象实例。在GSMCallTracker构造函数中向RIL类实例注册了RegistrantList，当通话状态及射频Radio状态变化时，就会通知GSMCallTracker。

[frameworks\base\telephony\java\com\android\internal\telephony\gsm\GsmCallTracker.java]


GsmCallTracker (GSMPhone phone) {
	this.phone = phone;
	cm = phone.mCM;
	cm.registerForCallStateChanged(this, EVENT_CALL_STATE_CHANGE, null);
	cm.registerForVideoCallStateChanged(this, EVENT_CALL_STATE_CHANGE, null);
	cm.registerForOn(this, EVENT_RADIO_AVAILABLE, null);
	cm.registerForNotAvailable(this, EVENT_RADIO_NOT_AVAILABLE, null);
	sendEmptyMessage(EVENT_INITIALIZE);
}

cm引用RIL对象，在这里注册了电话状态改变事件，视频电话状态改变事件，无线开关事件等。由于RIL实现了CommandsInterface接口，并继承于BaseCommands抽象类，registerForCallStateChanged函数实现在RIL的父类BaseCommands中。

这里为RIL注册了一些消息事件，并指定GsmCallTracker来处理这些消息。

[frameworks\base\telephony\java\com\android\internal\telephony\BaseCommands.java]


public void registerForCallStateChanged(Handler h, int what, Object obj) {
	Registrant r = new Registrant (h, what, obj);
	mCallStateRegistrants.add(r);
}

该函数通过Handler及对应的事件消息来构造一个Registrant对象，并将其注册到mCallStateRegistrants对象中，mCallStateRegistrants为RegistrantList类型变量，定义在RIL的父类BaseCommands中，RegistrantList类是用于保存注册的处理指定消息的所有Handler，RegistrantList类首先将某个消息及处理该消息的Handler封装成Registrant对象，并将该对象保存到成员变量registrants动态数组中。

[frameworks\base\core\java\android\os\RegistrantList.java]


ArrayList   registrants = new ArrayList();     
public synchronized void add(Handler h, int what, Object obj){
	add(new Registrant(h, what, obj));
}
 
public synchronized void add(Registrant r){
	removeCleared();
	registrants.add(r);
}

对于电话状态改变事件，注册的Handle对象为GsmCallTracker，因此在电话状态改变事件到来时，GsmCallTracker将处理EVENT_CALL_STATE_CHANGE消息事件。

GsmCallTracker

EVENT_POLL_CALLS_RESULT
EVENT_OPERATION_COMPLETE
EVENT_SWITCH_RESULT
EVENT_CONFERENCE_RESULT
EVENT_SEPAEATE_RESULT
EVENT_ECT_RESULT
EVENT_GET_LAST_CALL_FALL_CAUSE
EVENT_REPOLL_AFTER_DELAY
EVENT_CALL_STATE_CHANGE
EVENT_RADIO_AVAILABLE
EVENT_RADIO_NOT_AVAILABLE
EVENT_INITIALIZE

GsmCallTracker有三个成员变量：

GsmCall ringingCall = new GsmCall(this) 前台Call，其中对应的Connection是ACTIVE,DIALING,ALERTING状态的，即激活状态；
GsmCall foregroundCall = new GsmCall(this)后台Call，其中对应的Connection是HOLDING状态的，即保持状态；
GsmCall backgroundCall = new GsmCall(this)来电Call，其中对应的Connection是INCOMING,WAITING状态的，即来电状态。

4. Phone层事件注册过程

在Phone进程启动时，PhoneApp的onCreate函数首先被调用，PhoneApp会构造各种全局对象，同时也会注册一些事件。


mCM = CallManager.getInstance();
mCM.registerPhone(phone);

函数registerPhone为构造的相应类型的phone对象注册一些事件。

[frameworks\base\telephony\java\com\android\internal\telephony\CallManager.java]


public boolean registerPhone(Phone phone) {
    Phone basePhone = getPhoneBase(phone);
    if (basePhone != null && !mPhones.contains(basePhone)) {
        if (DBG) {
            Log.d(LOG_TAG, "registerPhone(" +
                    phone.getPhoneName() + " " + phone + ")");
        }
        if (mPhones.isEmpty()) {
            mDefaultPhone = basePhone;
        }
        mPhones.add(basePhone);
        mRingingCalls.add(basePhone.getRingingCall());
        mBackgroundCalls.add(basePhone.getBackgroundCall());
        mForegroundCalls.add(basePhone.getForegroundCall());
        registerForPhoneStates(basePhone);
        return true;
    }
    return false;
}

registerForPhoneStates函数用于注册电话状态变化事件。


private void registerForPhoneStates(Phone phone) {
    // for common events supported by all phones
    phone.registerForPreciseCallStateChanged(mHandler, EVENT_PRECISE_CALL_STATE_CHANGED, null);
    phone.registerForDisconnect(mHandler, EVENT_DISCONNECT, null);
    phone.registerForNewRingingConnection(mHandler, EVENT_NEW_RINGING_CONNECTION, null);
    phone.registerForUnknownConnection(mHandler, EVENT_UNKNOWN_CONNECTION, null);
    phone.registerForIncomingRing(mHandler, EVENT_INCOMING_RING, null);
    phone.registerForRingbackTone(mHandler, EVENT_RINGBACK_TONE, null);
    phone.registerForInCallVoicePrivacyOn(mHandler, EVENT_IN_CALL_VOICE_PRIVACY_ON, null);
    phone.registerForInCallVoicePrivacyOff(mHandler, EVENT_IN_CALL_VOICE_PRIVACY_OFF, null);
    phone.registerForDisplayInfo(mHandler, EVENT_DISPLAY_INFO, null);
    phone.registerForSignalInfo(mHandler, EVENT_SIGNAL_INFO, null);
    phone.registerForResendIncallMute(mHandler, EVENT_RESEND_INCALL_MUTE, null);
    phone.registerForMmiInitiate(mHandler, EVENT_MMI_INITIATE, null);
    phone.registerForMmiComplete(mHandler, EVENT_MMI_COMPLETE, null);
    phone.registerForSuppServiceFailed(mHandler, EVENT_SUPP_SERVICE_FAILED, null);
    phone.registerForServiceStateChanged(mHandler, EVENT_SERVICE_STATE_CHANGED, null);
 
    // for events supported only by GSM and CDMA phone
    if (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_GSM ||
            phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
        phone.setOnPostDialCharacter(mHandler, EVENT_POST_DIAL_CHARACTER, null);
    }
 
    // for events supported only by CDMA phone
    if (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA ){
        phone.registerForCdmaOtaStatusChange(mHandler, EVENT_CDMA_OTA_STATUS_CHANGE, null);
        phone.registerForSubscriptionInfoReady(mHandler, EVENT_SUBSCRIPTION_INFO_READY, null);
        phone.registerForCallWaiting(mHandler, EVENT_CALL_WAITING, null);
        phone.registerForEcmTimerReset(mHandler, EVENT_ECM_TIMER_RESET, null);
    }
}

此时的Phone类型为GsmPhone，其父类为PhoneBase，这里为PhoneBase注册了一些消息事件，并指定CallManager类的mHandler来处理这些消息。

GsmPhone

EVENT_RADIO_AVAILABLE
EVENT_RADIO_ON
EVENT_REGISTERED_TO_NETWORK
EVENT_SIM_RECORDS_LOADED
EVENT_GET_BASEBAND_VERSION_DONE
EVENT_GET_IMEI_DONE
EVENT_GET_IMEISV DONE
EVENT_USSD
EVENT_RADIO_OFF_OR_NOT_AVAILABLE
EVENT_SSN
EVENT_SET_CALL_BARRING_DONE
EVENT_GET_CALL_BARRING_DONE
EVENT_CHANGE_CALL_BARRING_PASSWORD_DONE
EVENT_SET_VM_NUMBER_DONE
EVENT_GET_CALL_FORWARD_DONE
EVENT_NEW_ICC_SMS
EVENT_SET_NETWORK_AUTOMATIC
EVENT_ICC_RECORD_EVENTS
EVENT_SET_NETWORK_MANUAL_COMPLETE
EVENT_SET_NETWORK_AUTOMATIC_COMPLETE
EVENT_SET_CLIR_COMPLETE

PhoneBase

EVENT_CALL_RING
EVENT_CALL_RING_CONTINUE

5. CallManager层事件注册过程

在启动PhoneApp时，同样也会创建一个CallNotifier对象

notifier = CallNotifier.init(this, phone, ringer, mBtHandsfree, new CallLogAsync());

参数phone是通过PhoneFactory.getDefaultPhone()创建而来的，创建过程在前面已经详细介绍了。
参数ringer的构造过程如下：


ringer = Ringer.init(this);
static Ringer init(Context context) {
    synchronized (Ringer.class) {
        if (sInstance == null) {
            sInstance = new Ringer(context);
        } else {
            Log.wtf(LOG_TAG, "init() called multiple times!  sInstance = " + sInstance);
        }
        return sInstance;
    }
}
 
private Ringer(Context context) {
    mContext = context;
    mPowerManager = IPowerManager.Stub.asInterface(ServiceManager.getService(Context.POWER_SERVICE));
    mVibrator = new SystemVibrator();
}

参数mBtHandsfree的构造过程如下：


mBtHandsfree = BluetoothHandsfree.init(this, mCM);
static BluetoothHandsfree init(Context context, CallManager cm) {
    synchronized (BluetoothHandsfree.class) {
        if (sInstance == null) {
            sInstance = new BluetoothHandsfree(context, cm);
        } else {
            Log.wtf(TAG, "init() called multiple times!  sInstance = " + sInstance);
        }
        return sInstance;
    }
}

CallNotifier对象构造过程：

[packages\apps\Phone\src\com\android\phone\CallNotifier.java]


static CallNotifier init(PhoneApp app, Phone phone, Ringer ringer,
                                       BluetoothHandsfree btMgr, CallLogAsync callLog) {
    synchronized (CallNotifier.class) {
        if (sInstance == null) {
            sInstance = new CallNotifier(app, phone, ringer, btMgr, callLog);
        } else {
            Log.wtf(LOG_TAG, "init() called multiple times!  sInstance = " + sInstance);
        }
        return sInstance;
    }
}
 
protected CallNotifier(PhoneApp app, Phone phone, Ringer ringer,
                     BluetoothHandsfree btMgr, CallLogAsync callLog) {
    mApplication = app;
    mCM = app.mCM;
    mCallLog = callLog;
    mLndAsync = new LndAsync();
 
    telMgr = (TelephonyManager) app.getSystemService(Context.TELEPHONY_SERVICE);
    mAudioManager = (AudioManager) mApplication.getSystemService(Context.AUDIO_SERVICE);
    registerForNotifications();
    try {
        mSignalInfoToneGenerator = new ToneGenerator(AudioManager.STREAM_VOICE_CALL,
                TONE_RELATIVE_VOLUME_SIGNALINFO);
    } catch (RuntimeException e) {
        Log.e(LOG_TAG, "CallNotifier: Exception caught while creating " +
                "mSignalInfoToneGenerator: " + e);
        mSignalInfoToneGenerator = null;
    }
    mRinger = ringer;
    mBluetoothHandsfree = btMgr;
    listen();
}

这构造CallNotifier对象过程中，为CallManager层注册了一些消息事件，并指定CallNotifier来处理这些消息。


private void registerForNotifications() {
    mCM.registerForNewRingingConnection(this, PHONE_NEW_RINGING_CONNECTION, null);
    mCM.registerForPreciseCallStateChanged(this, PHONE_STATE_CHANGED, null);
    mCM.registerForDisconnect(this, PHONE_DISCONNECT, null);
    mCM.registerForUnknownConnection(this, PHONE_UNKNOWN_CONNECTION_APPEARED, null);
    mCM.registerForIncomingRing(this, PHONE_INCOMING_RING, null);
    mCM.registerForCdmaOtaStatusChange(this, EVENT_OTA_PROVISION_CHANGE, null);
    mCM.registerForCallWaiting(this, PHONE_CDMA_CALL_WAITING, null);
    mCM.registerForDisplayInfo(this, PHONE_STATE_DISPLAYINFO, null);
    mCM.registerForSignalInfo(this, PHONE_STATE_SIGNALINFO, null);
    mCM.registerForInCallVoicePrivacyOn(this, PHONE_ENHANCED_VP_ON, null);
    mCM.registerForInCallVoicePrivacyOff(this, PHONE_ENHANCED_VP_OFF, null);
    mCM.registerForRingbackTone(this, PHONE_RINGBACK_TONE, null);
    mCM.registerForResendIncallMute(this, PHONE_RESEND_MUTE, null);
}

当有PHONE_NEW_RINGING_CONNECTION类型消息到来时，意味着一个RINGING或WAITING的连接（connection）出现，此时handleMessage函数调用onNewRingingConnection来处理。后者先检查Settings里的设置是否可以接听电话；然后进行响铃（见InCallTonePlayer）和显示InCallScreen的UI，见PhoneUtils.showIncomingCallUi()和PhoneApp.displayCallScreen()两个函数。通话过程中的铃音提示由线程类InCallTonePlayer完成。
当有PHONE_INCOMING_RING类型的消息到来时，意味着RIL层受到Ring，此处播放铃音。它使用的是Ringer.ring()函数，它会创建一个线程去播放铃音,见Ringer.makeLooper函数。
当有PHONE_STATE_CHANGED消息时，表明Phone的状态发生了改变，比如响铃后接通了电话，此时处理函数是onPhoneStateChanged，比如再次确认停止铃音、更新状态栏列的状态通知等。
当有PHONE_DISCONNECT消息时，表明电话连接已挂断或RingCall断掉。其处理函数是onDisconnect。它清理现场诸如音频通道恢复、来电响铃的停止确认、对InCallScreen的UI清理、若有未接电话须在状态栏显示等。

CallManager类的消息注册方法：

参考文献

Android电话来电流程源码分析

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