Android打电话流程学习(一)

目录

1. Android电话的层次设计

2. RIL架构

2.1 介绍

2.2 RIL初始化

2.3 RIL交互

2.3.1 主动请求

2.3.2 被动请求

3. RIL层事件注册过程

4. Phone层事件注册过程

5. CallManager层事件注册过程

参考文献


1. Android电话的层次设计

Framework层的RIL中的RILReceiver线程从RILD服务进程中读取modem发送上来的来电消息等信息,通过消息注册-响应机制来通知应用层处理。

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

CallManager类的消息注册方法:

参考文献

Android电话来电流程源码分析

  • 4
    点赞
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值