Android短信接收过程源码分析（原）

        本文主要讨论RILJ接收到一条普通短消息时是如何把它转换成Broadcast发送到系统中的。

一、GsmSMSDispatcher注册监听过程

        在《Framework层中的RIL》一文中我们介绍过，Framework与应用层中的Phone对象其实就是用GSMPhone对象生成的PhoneProxy对象（CDMA制式不谈）。可以简单的理解为Phone就是GSMPhone对象。

        而GSMPhone又是Framework中与RIL层沟通的对象，因此我们从GSMPhone开始入手分析。

@GSMPhone.java
public GSMPhone (Context context, CommandsInterface ci, PhoneNotifier notifier, boolean unitTestMode) {
//调用父类PhoneBase的构造函数，在内部实现一下赋值：phone.mCM=ci=RILJ
super(notifier, context, ci, unitTestMode);

//初始化GsmSMSDispatcher，用于派发短消息
mSMS = new GsmSMSDispatcher(this, mSmsStorageMonitor, mSmsUsageMonitor);
}

        上面看到，在GSMPhone的构造函数中，创建了GsmSMSDispatcher对象，这个对象是干什么用的呢？

        其实在对SMS的处理上，不同的制式也有不同的处理方法，与Phone对象类似，SMS同样抽象出来了一个SMSDispatcher类，他把各个制式对于SMS的处理中相同的部分抽象出来，而对于制式中不同的部分派生出了GsmSMSDispatcher子类和CdmaSMSDispatcher子类。

        而我们主要关注GsmSMSDispatcher子类：

@GsmSMSDispatcher.java
public GsmSMSDispatcher(PhoneBase phone, SmsStorageMonitor storageMonitor, SmsUsageMonitor usageMonitor) {
super(phone, storageMonitor, usageMonitor);
mDataDownloadHandler = new UsimDataDownloadHandler(mCm);
//监测3个与SMS有关的状态
mCm.setOnNewGsmSms(this, EVENT_NEW_SMS, null);
mCm.setOnSmsStatus(this, EVENT_NEW_SMS_STATUS_REPORT, null);
mCm.setOnNewGsmBroadcastSms(this, EVENT_NEW_BROADCAST_SMS, null);
}

        从上面可以看到，GsmSMSDispatcher的作用主要检测三种短消息事件。而上面的mCm是在其父类SMSDispatcher中进行初始化的：

@SMSDispatcher.java
protected SMSDispatcher(PhoneBase phone, SmsStorageMonitor storageMonitor, SmsUsageMonitor usageMonitor) {
mPhone = phone;
//phone是GSMPhone，而phone的mCm就是RILJ
mCm = phone.mCM;
}

        因此，在GsmSMSDispatcher构造函数中通过mCM.setOnNewGsmSms注册的监听器其实调用的是RILJ中的方法，而这个方法其实存在RILJ的父类BaseCommands中：

@BaseCommands.java
public void setOnNewGsmSms(Handler h, int what, Object obj) {
mGsmSmsRegistrant = new Registrant (h, what, obj);
}

        上面的过程，简单来说就是，在GSMPhone的构造函数中，创建了GsmSMSDispatcher的对象用于接收短消息，而GsmSMSDispatcher的初始化过程就是通过GSMPhone对象找到了RILJ(的父类)，并把自己所关注的三种RIL层消息注册给RILJ，等待RILJ接收到短信时通知GsmSMSDispatcher。

二、RILJ通知GsmSMSDispatcher过程

        下面我们来看，当有短消息上来时，RILJ如何把消息派发下去。

        我们在《Framework层中的RIL》一文中分析过，在RILJ中有两个独立的线程，一个用于向RILC发送数据(RILSender)，一个用于接收RILC层上报的数据(RILReceiver)。当有新消息来时，一定会通过RILReceiver发送数据，而他又是通过processResponse处理数据的：

@RIL.java
private void processResponse (Parcel p) {
int type;
type = p.readInt();
//新消息是属于URC消息
if (type == RESPONSE_UNSOLICITED) {
processUnsolicited (p);
} else if (type == RESPONSE_SOLICITED) {
}
}

private void processUnsolicited (Parcel p) {
switch(response) {
case RIL_UNSOL_RESPONSE_NEW_SMS:
{
String a[] = new String[2];
a[1] = (String)ret;
SmsMessage sms;
sms = SmsMessage.newFromCMT(a);
if (mGsmSmsRegistrant != null) {
//通过RILJ中的mGsmSmsRegistrant通知他的注册者，也就是GsmSMSDispatcher对象
mGsmSmsRegistrant.notifyRegistrant(new AsyncResult(null, sms, null));
}
break;
}
}
}

        我们继续看notifyRegistrant的过程：

@Registrant.java
public void notifyRegistrant(AsyncResult ar)
{
internalNotifyRegistrant (ar.result, ar.exception);
}
void internalNotifyRegistrant (Object result, Throwable exception)
{
Handler h = getHandler();
if (h == null) {
clear();
} else {
Message msg = Message.obtain();
msg.what = what;
msg.obj = new AsyncResult(userObj, result, exception);
h.sendMessage(msg);
}
}

        看来，RILJ对注册客户端的通知是通过sendMessage的方式实现的。

三、SMSDispatcher把短信通知发送到系统广播的过程

        在这一步中，SMSDispatcher将把短信转换为Intent，并通过sendOrderedBroadcast发送到系统中。

        上面分析到了sendMessage，还记得当初是GsmSMSDispatcher通过GSMPhone找到了RILJ，并为自己注册了三种关于SMS的监听。

mCm.setOnNewGsmSms(this, EVENT_NEW_SMS, null);
mCm.setOnSmsStatus(this, EVENT_NEW_SMS_STATUS_REPORT, null);
mCm.setOnNewGsmBroadcastSms(this, EVENT_NEW_BROADCAST_SMS, null);

        当前既然有了新的消息，RILJ通过sendMessage的方式发送的Message就会发送给GsmSMSDispatcher,而这个通知是在GsmSMSDispatcher的父类SMSDispatcher中被处理的：

@SMSDispatcher.java
public void handleMessage(Message msg) {
switch (msg.what) {
case EVENT_NEW_SMS:
//新消息的处理
SmsMessage sms;
ar = (AsyncResult) msg.obj;
sms = (SmsMessage) ar.result;
int result = dispatchMessage(sms.mWrappedSmsMessage);
break;

case EVENT_SEND_SMS_COMPLETE: //发送完成
case EVENT_STOP_SENDING://停止发送
}
}

        继续看dispatchMessage的过程，这个过程又进入到了子类GsmSMSDispatcher中处理：

@GsmSMSDispatcher.java
public int dispatchMessage(SmsMessageBase smsb) {
SmsMessage sms = (SmsMessage) smsb;

if (mSmsReceiveDisabled) {
//设备不支持短消息
return Intents.RESULT_SMS_HANDLED;
}

boolean handled = false;
if (sms.isMWISetMessage()) {
//新来语音信箱的短信通知
mPhone.setVoiceMessageWaiting(1, -1);  // line 1: unknown number of msgs waiting
handled = sms.isMwiDontStore();
} else if (sms.isMWIClearMessage()) {
//清除语音信箱的短信通知
mPhone.setVoiceMessageWaiting(1, 0);   // line 1: no msgs waiting
handled = sms.isMwiDontStore();
}

if (!mStorageMonitor.isStorageAvailable() && sms.getMessageClass() != SmsConstants.MessageClass.CLASS_0) {
//存储不够，发送提示
return Intents.RESULT_SMS_OUT_OF_MEMORY;
}
//普通短信处理
return dispatchNormalMessage(smsb);
}

        上面对一些特殊条件进行处理，比如设备不支持短消息，或者接收到的消息是语音信箱提示、设备存储空间不足等，然后就进入普通消息的处理流程，而这个处理过程又进入了父类中：

@SMSDispatcher.java
protected int dispatchNormalMessage(SmsMessageBase sms) {
SmsHeader smsHeader = sms.getUserDataHeader();

if ((smsHeader == null) || (smsHeader.concatRef == null)) {
byte[][] pdus = new byte[1][];
pdus[0] = sms.getPdu();

if (smsHeader != null && smsHeader.portAddrs != null) {
if (smsHeader.portAddrs.destPort == SmsHeader.PORT_WAP_PUSH) {
// GSM-style WAP indication
//Wap push 信息的分发
return mWapPush.dispatchWapPdu(sms.getUserData());
} else {
// The message was sent to a port, so concoct a URI for it.
dispatchPortAddressedPdus(pdus, smsHeader.portAddrs.destPort);
}
} else {
//普通短消息处理
dispatchPdus(pdus);
}
return Activity.RESULT_OK;
} else {
SmsHeader.ConcatRef concatRef = smsHeader.concatRef;
SmsHeader.PortAddrs portAddrs = smsHeader.portAddrs;
return processMessagePart(sms.getPdu(), sms.getOriginatingAddress(),
concatRef.refNumber, concatRef.seqNumber, concatRef.msgCount,
sms.getTimestampMillis(), (portAddrs != null ? portAddrs.destPort : -1), false);
}
}

        这里看到，对于普通短消息，是通过dispatchPdus()接口分发出去的：

protected void dispatchPdus(byte[][] pdus) {
//发送SMS_RECEIVED_ACTION的Intent
Intent intent = new Intent(Intents.SMS_RECEIVED_ACTION);
intent.putExtra("pdus", pdus);
intent.putExtra("format", getFormat());
//接收这个消息需要RECEIVE_SMS_PERMISSION的权限
dispatch(intent, RECEIVE_SMS_PERMISSION);
}

        继续往下看：

public void dispatch(Intent intent, String permission) {
mWakeLock.acquire(WAKE_LOCK_TIMEOUT);
//向系统中发送有序的广播，并且添加接收权限
mContext.sendOrderedBroadcast(intent, permission, mResultReceiver, this, Activity.RESULT_OK, null, null);
}

        由此，Framework就通过SMSDispatcher将短消息用Broadcast的形式发送到了系统中。

四、总体流程图

        现在贴出以上过程的流程图。