Phone与Rild连接过程及消息收发

之前一篇文章中分析了RILD及qcril初始化流程，已经讲过RILD中建立socket服务和接受上层client连接的过程。现在来看下客户端——Phone进程，如何与rild socket建立连接和收发消息。

1. 连接Rild 和消息的接收

开机Phone进程启动后，Ril在PhoneFactory::makeDefaultPhone的时候被创建，并对应着Phone实例的数量，双卡机会有2个RIL各自与Rild关联并各自负责一个卡的业务。

public static void makeDefaultPhone(Context context) {
synchronized (sLockProxyPhones) {
...
//
for (int i = 0; i < numPhones; i++) {
...
//创建RIL实例
sCommandsInterfaces[i] = new RIL(context, networkModes[i], cdmaSubscription, i);
}
//创建Phone实例
for (int i = 0; i < numPhones; i++) {
PhoneBase phone = null;
// int phoneType =
// TelephonyManager.getPhoneType(networkModes[i]);
if (phoneType == PhoneConstants.PHONE_TYPE_GSM) {
phone = TelephonyPluginDelegate.getInstance().makeGSMPhone(context, sCommandsInterfaces[i],
sPhoneNotifier, i);
} else if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
phone = TelephonyPluginDelegate.getInstance().makeCDMALTEPhone(context, sCommandsInterfaces[i],
sPhoneNotifier, i);
}

sProxyPhones[i] = TelephonyPluginDelegate.getInstance().makePhoneProxy(phone);
}
}
}

以下是RIL.java中定义的与Socket连接有关的成员，有Socket、各自负责收发的2个类实例 和 提供给它们运行的子线程。

public final class RIL extends BaseCommands implements CommandsInterface {
...
//与rild连接的socket
LocalSocket mSocket;
//负责发送消息的线程
HandlerThread mSenderThread;
//实现发送消息的Handler
RILSender mSender;
//负责接收消息的线程
Thread mReceiverThread;
//实现接收消息的类，实现了Runnable
RILReceiver mReceiver;

//保存Request消息列表
SparseArray<RILRequest> mRequestList = new SparseArray<RILRequest>();

//rild socket的名字
static final String[] SOCKET_NAME_RIL = {"rild", "rild2", "rild3"};
...
//RIL构造方法
public RIL(Context context, int preferredNetworkType,
int cdmaSubscription, Integer instanceId) {
super(context);
...
//sender & senderThread
mSenderThread = new HandlerThread("RILSender" + mInstanceId);
mSenderThread.start();
Looper looper = mSenderThread.getLooper();
mSender = new RILSender(looper);

...
//Receiver& ReceiverThread
riljLog("Starting RILReceiver" + mInstanceId);
mReceiver = new RILReceiver();
mReceiverThread = new Thread(mReceiver, "RILReceiver" + mInstanceId);
mReceiverThread.start();

...
}
}
}

具体分析代码前，先看一张图了解它们大致的工作方式。

RILReceiver 实现了Runnable接口，在子线程中循环从socket读取RILD上报的消息。

RILSender则是一个Handler，同样实现了Runnable接口，作为下发消息到RILD的角色。



RILReceiver在run方法中连接rild socket，获取到输入流后，进入一个循环读取数据，读出的消息被封装成Parcel并传给processResponse方法处理。

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 (;;) {
LocalSocket s = null;
LocalSocketAddress l;
//根据RIL实例ID选择对应的rild socket名字{rild,rild2...}
if (mInstanceId == null || mInstanceId == 0 ) {
rilSocket = SOCKET_NAME_RIL[0];
} else {
rilSocket = SOCKET_NAME_RIL[mInstanceId];
}

try {
//连接socket
s = new LocalSocket();
l = new LocalSocketAddress(rilSocket,
LocalSocketAddress.Namespace.RESERVED);
s.connect(l);
} catch (IOException ex){
...//失败重连
}

retryCount = 0;

mSocket = s;

int length = 0;
try {

4000
//获得socket输入流
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) {
...
}

//socket连接出错，跳出循环做恢复处理
setRadioState (RadioState.RADIO_UNAVAILABLE);

try {
mSocket.close();
} catch (IOException ex) {
}

mSocket = null;
RILRequest.resetSerial();

// Clear request list on close
clearRequestList(RADIO_NOT_AVAILABLE, false);
}} catch (Throwable tr) {
Rlog.e(RILJ_LOG_TAG,"Uncaught exception", tr);
}

/* We're disconnected so we don't know the ril version */
notifyRegistrantsRilConnectionChanged(-1);
}
}

2. 消息的发送

RILD及qcril初始化流程 提到过Rild中用于处理socket客户端下发消息的eventLoop函数，现在来看下phone进程作为rild socket的客户端处理下发消息的过程。

RILSender只接收和处理EVENT_SEND和EVENT_WAKE_LOCK_TIMEOUT消息：

EVENT_SEND - 向RILD下发消息。

EVENT_WAKE_LOCK_TIMEOUT - 下发消息时会申请WAKE_LOCK，但如果超时没有收到RILD的反馈，这里会释放WAKE_LOCK。

class RILSender extends Handler implements Runnable {
public RILSender(Looper looper) {
super(looper);
}

// Only allocated once
byte[] dataLength = new byte[4];

//***** Runnable implementation
@Override
public void
run() {
//setup if needed
}

@Override public void
handleMessage(Message msg) {
RILRequest rr = (RILRequest)(msg.obj);
RILRequest req = null;

switch (msg.what) {
//send()方法发送包含RILRequest的EVENT_SEND消息
case EVENT_SEND:
try {
LocalSocket s;
s = mSocket;
...
synchronized (mRequestList) {
//下发消息前保存到mRequestList
mRequestList.append(rr.mSerial, rr);
}
//准备数据
byte[] data;
data = rr.mParcel.marshall();
rr.mParcel.recycle();
rr.mParcel = null;
// parcel length in big endian
dataLength[0] = dataLength[1] = 0;
dataLength[2] = (byte)((data.length >> 8) & 0xff);
dataLength[3] = (byte)((data.length) & 0xff);
//向socket输出流写入数据
s.getOutputStream().write(dataLength);
s.getOutputStream().write(data);
} catch (IOException ex) {
...
}

break;

case EVENT_WAKE_LOCK_TIMEOUT:
//下发消息后，超时没有获得RILD的回复，释放wake lock
synchronized (mRequestList) {
if (clearWakeLock()) {
...
}
}
break;
}
}
}

send方法向RILSender发出EVENT_SEND后，会调用acquireWakeLock方法申请一个wakelock并设定超时释放的时间。

private void send(RILRequest rr) {
Message msg;
...
msg = mSender.obtainMessage(EVENT_SEND, rr);
//获取WAKE_LOCK
acquireWakeLock();
msg.sendToTarget();
}

private void
acquireWakeLock() {
synchronized (mWakeLock) {
mWakeLock.acquire();
mWakeLockCount++;
mSender.removeMessages(EVENT_WAKE_LOCK_TIMEOUT);
Message msg = mSender.obtainMessage(EVENT_WAKE_LOCK_TIMEOUT);
//获取wakelock后设定超时的时间
mSender.sendMessageDelayed(msg, mWakeLockTimeout);
}
}

超时的时间由system property定义，默认为60秒。

在我的手机上查看这个property并没有赋值，因此使用默认的时间。

// PROPERTY_WAKE_LOCK_TIMEOUT = "ro.ril.wake_lock_timeout";
// private static final int DEFAULT_WAKE_LOCK_TIMEOUT = 60000;
mWakeLockTimeout = SystemProperties.getInt(TelephonyProperties.PROPERTY_WAKE_LOCK_TIMEOUT,
DEFAULT_WAKE_LOCK_TIMEOUT);

THE END

RILJ通过socket的输入输出流读写数据，实现上比Rild侧简单很多，这估计是得益于JAVA的封装。