android RILJ运行机制

    如我们所知，和phone相关的framwork层命令，最后都都会传送到RIL，最终完成语音通话，服务网络状态和手机数据连接的控制和管理。

    在讲解RILJ之前，我们先梳理下android的RIL框架。RIL的全名为Radio Interface Layer,android RIL代码框架可以分为两部分：

    (1)Framework层的代码，是用java语言实现的，简称RILJ。

    (2)HAL层中代码，是用C和C++语言来实现的，简称RILC。

              


         

     上图为RILJ，RILC,RILD和modem之间的关系，在本篇文章我们只讲解RILJ,至于RILD，RILJ，RILC这三者之间的关系和交互流程，我们在后续的章节中再讲解，再本篇文章中，我们先只需要知道RILJ和RILC是通过socket进行通信的。

     RILJ最核心的的代码主要有三个，分别是CommandsInterface.java,BaseCommands.java和RIL.java.这个三个类的关系如下图：

             

    


  我们先关注RIL.java的一些关键属性:   

LocalSocket mSocket;
HandlerThread mSenderThread;
RILSender mSender;//给RILC发送请求消息
Thread mReceiverThread;
RILReceiver mReceiver;//接受RILC发来的消息
Display mDefaultDisplay;
int mDefaultDisplayState = Display.STATE_UNKNOWN;
WakeLock mWakeLock;
final int mWakeLockTimeout;
// The number of wakelock requests currently active.  Don't release the lock
// until dec'd to 0
int mWakeLockCount;

SparseArray<RILRequest> mRequestList = new SparseArray<RILRequest>();//保存solicited类型的RILrequest对象

         查看ril.java文件，我们可以看出RIL.java中定义了三个内部类RILRequest,RILSender,RILReceiver。

     RILRequest:每个从framework层传下的命令都会被封装成为一个RILRequest对象。

     RILSender:发送从framework层传下的命令到RILC。

     RILRecever:接受从RILC上报的消息。

     如我们所知，java中的类在代码运行的时候，都会被new一个对象来执行代码，那么Ril.java在什么时候被new成一个对象呢，答案就是在phone模块加载的过程中，在PhoneFactory.java的makeDefaultPhone函数中会根据选网方式来创建GSMphone或者CDMAphone，在创建phone对象的时候会同时new一个RIL对象，每个phone对象会绑定一个RIL.java对象。

 

int numPhones = TelephonyManager.getDefault().getPhoneCount();
int[] networkModes = new int[numPhones];
sProxyPhones = new PhoneProxy[numPhones];
sCommandsInterfaces = new RIL[numPhones];
for (int i = 0; i < numPhones; i++) {
PhoneBase phone = null;
int phoneType = TelephonyManager.getPhoneType(networkModes[i]);
if (phoneType == PhoneConstants.PHONE_TYPE_GSM) {
phone = new GSMPhone(context,
sCommandsInterfaces[i], sPhoneNotifier, i);
} else if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
phone = new CDMALTEPhone(context,
sCommandsInterfaces[i], sPhoneNotifier, i);
}
Rlog.i(LOG_TAG, "Creating Phone with type = " + phoneType + " sub = " + i);

sProxyPhones[i] = new PhoneProxy(phone);
}

           接下来我们再详解看RILRequest这个类，获取这个类的对象java中工厂设计模式，RILRequest关键属性如下：

 

static Random sRandom = new Random();
static AtomicInteger sNextSerial = new AtomicInteger(0);//下一个RIlRequest对象编号
private static Object sPoolSync = new Object();//同步访问枷锁对象
private static RILRequest sPool = null;//保存下一个要处理的RILRequest对象
private static int sPoolSize = 0;
private static final int MAX_POOL_SIZE = 4;
private Context mContext;

//***** Instance Variables
int mSerial;//当前RIL的请求编号
int mRequest;//RIL请求类型
Message mResult;//从Framework层传下来的命令消息对象
Parcel mParcel;
RILRequest mNext;//保存下一个要处理的RILRequest对象

   

       RILSender这个内部类集成了handler类同时实现了Runnable接口，RILSender的handleMessage的处理的一个重要消息就是EVENT_SEND，每个framework层下发的命令最后都会调用send函数，send函数会封装一个EVENT_SEND消息，最后交由RILSender的handleMessage函数来处理。

       

private void
send(RILRequest rr) {
Message msg;

if (mSocket == null) {
rr.onError(RADIO_NOT_AVAILABLE, null);
rr.release();
return;
}

msg = mSender.obtainMessage(EVENT_SEND, rr);

acquireWakeLock();

msg.sendToTarget();
}

      RILSender的handleMessage的函数收到EVENT_SEND消息后，首先会获取跟RILC建立起来的socket客户端，然后通过java输出流把数据发送到RILC。

 

 

LocalSocket s;

s = mSocket;

if (s == null) {
rr.onError(RADIO_NOT_AVAILABLE, null);
rr.release();
decrementWakeLock();
return;
}

synchronized (mRequestList) {
mRequestList.append(rr.mSerial, rr);
}

byte[] data;

data = rr.mParcel.marshall();
rr.mParcel.recycle();
rr.mParcel = null;

if (data.length > RIL_MAX_COMMAND_BYTES) {
throw new RuntimeException(
"Parcel larger than max bytes allowed! "
+ data.length);
}

// parcel length in big endian
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");

s.getOutputStream().write(dataLength);
s.getOutputStream().write(data);

            那么RILJ跟RILC的socket连接什么时候建立起来的呢，那么接下我们在分析RILReceiver这个类，看完这个类你就会明白上面提到的socket是什么时候建立起来的，观看代码我们会发现RILReceiver实现了Runnable接口，它会以一个单独线程在运行，查看RILReceiver的run函数，我们会发现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,
ocalSocketAddress.Namespace.RESERVED);
s.connect(l);

 

        RILReceiver的run函数中有一个for死循环，就是不停的接受从RILC上报的消息，代码如下：

  

      

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);
//Rlog.v(RILJ_LOG_TAG, "Read packet: " + length + " bytes");

processResponse(p);
p.recycle();

        processResponse这个函数就是处理从RILC上报的消息，在函数processResponse中我们会发现首先会获取RILC上报的消息的类型，如果是RESPONSE_UNSOLICITED，就会调用processUnsolicited函数，如果是RESPONSE_SOLICITED就是调用processSolicited函数，processUnsolicited函数和processSolicited函数在这里就不多解析了，有兴趣的读者可以自己查看相应的代码。