RIL源码分析
前面已经RILD进行了分析，现在就对RILJ进行简单的分析
1.绪论
所有上层对RIL层的请求，最终都需要在RILJ中转换为RIL层可识别的命令，然后通过Socket通道传输下去
同时，RIL层据的上报，也要通过RILJ进行解码，还原为上层容易识别的格式
RILJ有两个主要特点：
1、开启了两个独立线程分别负责发送数据和接收数据
2、数据的发送和接收是异步的,采用令牌系统来找到当初的请求者
2.RILRequest令牌系统
class RILRequest {
........
private static Object sPoolSync = new Object(); //sPool分配与回收的互斥锁
private static RILRequest sPool = null;//代表了一个RILRequest对象的链表
private static int sPoolSize = 0;// 当前sPool所在链表的长度
private static final int MAX_POOL_SIZE = 4; // sPool的最大个数
........
int mSerial; //令牌,每生成(obtain)一个新的请求,都将产生一个递增的,唯一的mSerial。当从RILC中得到一个数据后,我们就是通过mSerial找到当初发送这个请求的对象
int mRequest; // 请求码，需要和RIL层中的ril_commands.h文件内定义的请求码一致
Message mResult; // 生成当前请求的请求者。从RILC中得到数据后，需要把数据处理后返回给mResult指向的对象
Parcel mParcel; // 附加数据
RILRequest mNext; // 链表结构，代表下一个RILRequest
........
static RILRequest obtain(int request, Message result) { // 生成一个RILRequest的消息对象
// 如果sPool所在链表不为空则从该链表中获取一个RILRequest对象,否则新构造一个
RILRequest rr = null;
synchronized(sPoolSync) {
if (sPool != null) {
rr = sPool;
sPool = rr.mNext;
rr.mNext = null;
sPoolSize--;
}
}
if (rr == null) {
rr = new RILRequest();
}
// 初始化令牌mSerial,AtomicInteger的getAndIncrement可保证当前请求的令牌是唯一的,递增的
rr.mSerial = sNextSerial.getAndIncrement();
rr.mRequest = request;// 初始化请求码mRequest
rr.mResult = result;// 初始化请求者mResult
rr.mParcel = Parcel.obtain();
if (result != null && result.getTarget() == null) {
throw new NullPointerException("Message target must not be null");
}
// 写入请求码与请求者
rr.mParcel.writeInt(request);
rr.mParcel.writeInt(rr.mSerial);
return rr;
}
void release() { // 释放资源
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) { // 如果当前sPool链表还没有满,则将当前RILRequest对象添加到链表中以便复用
mNext = sPool;
sPool = this;
sPoolSize++;
mResult = null;
}
}
}
private RILRequest() {} // 构造函数，内容为空
static void resetSerial() {........} // 重置令牌
String serialString() {........} // 生成包含mSerial的字串，主要用于打印Log
void onError(int error, Object ret) {........} // 异常处理
}
3.发送子线程
1、如何把数据发送到mSenderThread中；
// 创建mSender的时候就是用mSenderThread的looper来创建的,即用mSender发送消息即可发送到mSenderThread中
public RIL(Context context, int preferredNetworkType, int cdmaSubscription) {
super(context);
........
//发送子线程
mSenderThread = new HandlerThread("RILSender");
mSenderThread.start();
Looper looper = mSenderThread.getLooper();
//mSender是发送子线程的Handler，通过他可以发送数据
mSender = new RILSender(looper);
........
//接收子线程
mReceiver = new RILReceiver();
mReceiverThread = new Thread(mReceiver, "RILReceiver");
mReceiverThread.start();
........
}
// 发送短消息
public void sendSMS (String smscPDU, String pdu, Message result) {
// 构建一个请求
RILRequest rr = RILRequest.obtain(RIL_REQUEST_SEND_SMS, result);
constructGsmSendSmsRilRequest(rr, smscPDU, pdu);
if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
//发送
send(rr);
}
........
private void send(RILRequest rr) {
Message msg;
// 如果Socket通道还没有打开
if (mSocket == null) {
rr.onError(RADIO_NOT_AVAILABLE, null);
rr.release();
return;
}
// 生成mSender的消息
msg = mSender.obtainMessage(EVENT_SEND, rr);
acquireWakeLock();
// 发送给子线程
msg.sendToTarget();
}
2、mSenderThread是如何把请求发送给RILC的
class RILSender extends Handler implements Runnable {
........
@Override
public void run() {}
@Override
public void handleMessage(Message msg) {
RILRequest rr = (RILRequest)(msg.obj);
RILRequest req = null;
switch (msg.what) {
case EVENT_SEND:
try {
LocalSocket s;
// 得到Socket通道
s = mSocket;
........
// 获取数据的长度
dataLength[0] = dataLength[1] = 0;
dataLength[2] = (byte)((data.length >> 8) & 0xff);
dataLength[3] = (byte)((data.length) & 0xff);
//Rlog.v(RILJ_LOG_TAG, "writing packet: " + data.length + " bytes");
// 通过Socket通道将数据长度与数据发送出去
s.getOutputStream().write(dataLength);
s.getOutputStream().write(data);
} catch (IOException ex) {
........
} catch (RuntimeException exc) {
........
}
break;
case EVENT_WAKE_LOCK_TIMEOUT:
........
break;
}
}
}
4.接收子线程
1、如何接收的消息
// 读取ril传回的数据
private static int readRilMessage(InputStream is, byte[] buffer) throws IOException {
........
do { // 先读取数据的长度
countRead = is.read(buffer, offset, remaining);// 从InputStream中读取数据
if (countRead < 0 ) {
Rlog.e(RILJ_LOG_TAG, "Hit EOS reading message length");
return -1;
}
offset += countRead;
remaining -= countRead;
} while (remaining > 0);
// 计算数据的长度
messageLength = ((buffer[0] & 0xff) << 24)
| ((buffer[1] & 0xff) << 16)
| ((buffer[2] & 0xff) << 8)
| (buffer[3] & 0xff);
// Then, re-use the buffer and read in the message itself
offset = 0;
remaining = messageLength;
do { // 再读取有效数据
countRead = is.read(buffer, offset, remaining);
if (countRead < 0 ) {
Rlog.e(RILJ_LOG_TAG, "Hit EOS reading message. messageLength=" + messageLength
+ " remaining=" + remaining);
return -1;
}
offset += countRead;
remaining -= countRead;
} while (remaining > 0);
return messageLength;
}
class RILReceiver implements Runnable {
byte[] buffer;
RILReceiver() {
buffer = new byte[RIL_MAX_COMMAND_BYTES];
}
@Override
public void run() {
int retryCount = 0;
String rilSocket = "rild";
try {
for (;;) { // 如果出现异常,将会关闭socket并清除令牌和请求列表,并重新打开Socket通道
//开启Socket通道
LocalSocket s = null;
LocalSocketAddress l;
if (mInstanceId == null || mInstanceId == 0 ) {
rilSocket = SOCKET_NAME_RIL[0];
} else {
rilSocket = SOCKET_NAME_RIL[mInstanceId];
}
try {
s = new LocalSocket();
l = new LocalSocketAddress(rilSocket,
LocalSocketAddress.Namespace.RESERVED);
s.connect(l);
} catch (IOException ex){
........
}
retryCount = 0;
mSocket = s;
Rlog.i(RILJ_LOG_TAG, "Connected to '" + rilSocket + "' socket");
int length = 0;
try {
InputStream is = mSocket.getInputStream();
for (;;) { //接收数据过程
Parcel p;
// 通过管道读取数据
length = readRilMessage(is, buffer);
if (length < 0) {
// End-of-stream reached
break;
}
p = Parcel.obtain();
p.unmarshall(buffer, 0, length);
p.setDataPosition(0);
// 处理数据【见详情】
processResponse(p);
p.recycle();
}
} catch (java.io.IOException ex) {
........
}
Rlog.i(RILJ_LOG_TAG, "Disconnected from '" + rilSocket + "' socket");
setRadioState (RadioState.RADIO_UNAVAILABLE);
//关闭Socket，等下一次for循环的时候会重新打开Socket
try {
mSocket.close();
} catch (IOException ex) {
}
mSocket = null;
//清除令牌
RILRequest.resetSerial();
//清除所有请求
clearRequestList(RADIO_NOT_AVAILABLE, false);
}
} catch (Throwable tr) {
Rlog.e(RILJ_LOG_TAG,"Uncaught exception", tr);
}
//通知ril连接状态改变
notifyRegistrantsRilConnectionChanged(-1);
}
}
2、消息的处理流程
private void processResponse (Parcel p) { // 信息处理
int type;
type = p.readInt();//得到数据的类型，是URC消息还是非URC消息
if (type == RESPONSE_UNSOLICITED) {
processUnsolicited (p); //URC消息的处理【见详情】
} else if (type == RESPONSE_SOLICITED) {
RILRequest rr = processSolicited (p); //非URC消息的处理
if (rr != null) {
rr.release();
decrementWakeLock();
}
}
}
//URC消息的处理
private void processUnsolicited (Parcel p) {
int response;
Object ret;
//读取当前消息的消息码
response = p.readInt();
try {
switch(response) { // 预处理
case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: ret = responseVoid(p); break; // responseVoid当前消息的附带数据为空
case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: ret = responseVoid(p); break;
case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: ret = responseVoid(p); break;
case RIL_UNSOL_RESPONSE_NEW_SMS: ret = responseString(p); break; // responseString当前消息的附带数据为String型，需要得到String
........
}
........
}
// 再处理
switch(response) {
case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: // Radio状态改变
RadioState newState = getRadioStateFromInt(p.readInt());
if (RILJ_LOGD) unsljLogMore(response, newState.toString());
switchToRadioState(newState);
break;
case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED:
mImsNetworkStateChangedRegistrants.notifyRegistrants(new AsyncResult(null, null, null));
break;
case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: //通知call状态改变
if (RILJ_LOGD) unsljLog(response);
mCallStateRegistrants.notifyRegistrants(new AsyncResult(null, null, null));
break;
case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: //通知网络状态改变
if (RILJ_LOGD) unsljLog(response);
mVoiceNetworkStateRegistrants.notifyRegistrants(new AsyncResult(null, null, null));
break;
case RIL_UNSOL_RESPONSE_NEW_SMS: {
if (RILJ_LOGD) unsljLog(response);
// FIXME this should move up a layer
String a[] = new String[2];
a[1] = (String)ret;
SmsMessage sms; // 新短信
sms = SmsMessage.newFromCMT(a);
if (mGsmSmsRegistrant != null) { //发送短信通知
mGsmSmsRegistrant.notifyRegistrant(new AsyncResult(null, sms, null));
}
break;
}
case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: //短信报告
if (RILJ_LOGD) unsljLogRet(response, ret);
if (mSmsStatusRegistrant != null) {
mSmsStatusRegistrant.notifyRegistrant(
new AsyncResult(null, ret, null));
}
break;
........
}
}
//非URC消息的处理
private RILRequest processSolicited (Parcel p) {
int serial, error;
boolean found = false;
serial = p.readInt();
error = p.readInt();
RILRequest rr;
// 得到当前的RILRequest对象，然后从mRequestList中将其删除
rr = findAndRemoveRequestFromList(serial);
if (rr == null) {
Rlog.w(RILJ_LOG_TAG, "Unexpected solicited response! sn: "
+ serial + " error: " + error);
return null;
}
Object ret = null;
if (error == 0 || p.dataAvail() > 0) {
// either command succeeds or command fails but with data payload
try {
switch (rr.mRequest) { //得到RIL上报的数据
case RIL_REQUEST_GET_SIM_STATUS: ret = responseIccCardStatus(p); break;
case RIL_REQUEST_ENTER_SIM_PIN: ret = responseInts(p); break;
case RIL_REQUEST_ENTER_SIM_PUK: ret = responseInts(p); break;
........
}
}
........
}
........
switch (rr.mRequest) { //对PUK的两个消息需要单独的通知其管理者
case RIL_REQUEST_ENTER_SIM_PUK:
case RIL_REQUEST_ENTER_SIM_PUK2:
if (mIccStatusChangedRegistrants != null) {
if (RILJ_LOGD) {
riljLog("ON enter sim puk fakeSimStatusChanged: reg count="
+ mIccStatusChangedRegistrants.size());
}
mIccStatusChangedRegistrants.notifyRegistrants();
}
break;
}
if (error != 0) {
........
} else {
if (RILJ_LOGD) riljLog(rr.serialString() + "< " + requestToString(rr.mRequest)
+ " " + retToString(rr.mRequest, ret));
//将返回值返回给当初的请求者，由请求者去决定如何处理数据
if (rr.mResult != null) {
AsyncResult.forMessage(rr.mResult, ret, null);
rr.mResult.sendToTarget();
}
}
return rr;
}