RIL层源码分析

最新推荐文章于 2021-05-10 11:29:52 发布
最新推荐文章于 2021-05-10 11:29:52 发布
阅读量1.6k 收藏 3
点赞数
分类专栏： android 3G专题

写在前面

    1、本文从宏观的角度去分析问题，因此忽略了一些非主线的函数。
    2、同理，对于函数内部非主要的逻辑部分，也采取了省略。
    3、受限于知识的积累和理解能力，文中描述如有分析不妥之处，希望能够得到大家更正。

从Main函数开始的故事

    Android的智能机架构是应用处理器+基带芯片，也就是AP+Modem的模式，AP部分相当于CPU，Modem相当于网卡，而且每个厂商使用的Modem都有可能不一样。每种通讯协议如GSM/CDMA又有很大的不同，为了将所有的Modem抽象为统一的模式，因此Android搭建了RIL（Radio Interface Layer）层。在这个层的下面，每个厂商可以有自己不同的实现方式，但是经过RIL层协议的转换，就将所有的Modem抽象为统一的对象向上层负责。
    RILC与上层的RILJ沟通方式是通过Socket传输数据与命令，而与底层Modem的信号传输是通过串口用AT命令来实现。

    

    我们从RIL的入口开始分析。

[cpp] view plain copy
  1. @rild.c  
  2. int main(int argc, char **argv){  
  3.     //连接库地址：/system/lib/libreference-ril.so  
  4.     #define  REFERENCE_RIL_PATH  "/system/lib/libreference-ril.so"  
  5.     rilLibPath = REFERENCE_RIL_PATH;  
  6.     //切换UID为AID_RADIO  
  7.     switchUser();  
  8.     //打开链接库  
  9.     dlHandle = dlopen(rilLibPath, RTLD_NOW);  
  10.     //开启EventLoop循环  
  11.     RIL_startEventLoop();  
  12.     //从链接库中（也就是reference-ril.c）寻找RIL_Init函数地址  
  13.     rilInit = (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))dlsym(dlHandle, "RIL_Init");  
  14.     //调用reference-ril.c中的RIL_Init函数进行初始化INIT，同时得到reference-ril的回调函数  
  15.     funcs = rilInit(&s_rilEnv, argc, rilArgv);  
  16.     //注册得到的reference的回调函数  
  17.     RIL_register(funcs);  
  18. }  

    从上面可以看出，入口函数主要完成了3个作用：
    1、开启EventLoop循环，完成RIL与RILJ层数据交互（通过Socket）
    2、打开动态库reference并构建ReaderLoop循环，完成RIL与Modem层数据交互（通过AT）
    3、注册reference的回调函数
    下面我们详细介绍具体流程。而在介绍之前，先把整个RIL层的数据流向用一张图片展示：


一、Event机制


1.1、Event框架

    Event要做的就是循环检测EventLoop中添加的句柄池，如果在当前的句柄池中有任意一个句柄所代表的通道中有新的数据进来，就去处理当前的新数据。而在句柄池中最重要的句柄就是RILJ与RILC之间的Socket通道。
    Event的实现主要在ril_event.cpp文件中。我们先来看一下一个标准的Event的构成：    

[cpp] view plain copy
  1. struct ril_event {  
  2.     struct ril_event *next;  
  3.     struct ril_event *prev;  
  4.     int fd;  
  5.     int index;  
  6.     bool persist;  
  7.     struct timeval timeout;  
  8.     ril_event_cb func;  
  9.     void *param;  
  10. };  

    从上面的结构体可以看出，Event的管理是通过链表实现的，一些重要的成员变量的意义如下：

        fd：事件相关设备句柄。最重要的就是RILJ与RILC之间的Socket文件句柄
        persist:说明当前的Event需要保持，不能从watch_table中删除
        func:当前Event的处理函数
        param:调用当前Event处理函数时的参数
    接下来，我们在看具体的处理流程之前，先来看一下处理Event需要哪些函数：    

[cpp] view plain copy
  1. //Event的初始化，其实就是对3个主要链表的初始化  
  2. static void init_list(struct ril_event * list)  
  3. //添加Event到链表  
  4. static void addToList(struct ril_event * ev, struct ril_event * list)  
  5. //从链表删除Event  
  6. static void removeFromList(struct ril_event * ev)  
  7. //从watch连表中删除某个Event  
  8. static void removeWatch(struct ril_event * ev, int index)  
  9. //处理超时的Event  
  10. static void processTimeouts()  
  11. //初始化Event链表  
  12. void ril_event_init()  
  13. //初始化一个Event  
  14. void ril_event_set(struct ril_event * ev, int fd, bool persist, ril_event_cb func, void * param)  
  15. //把一个Event添加到watch_table中  
  16. void ril_event_add(struct ril_event * ev)  
  17. //把一个Event添加到timer_list中  
  18. void ril_timer_add(struct ril_event * ev, struct timeval * tv)  
  19. //把一个Event从watch_table中删除  
  20. void ril_event_del(struct ril_event * ev)  
  21. //主循环  
  22. void ril_event_loop()  

    通过上面的主要函数我们可以大致推测出，管理Event的过程应该是生成相应的Event节点，然后将Event添加到链表，处理Event之后就需要把当前的Event从链表中删除。而且我们看出，Event管理中应该存在多个链表，那么究竟有哪些链表在运行呢？

    RIL的Event管理体系中存在3个链表结构：watch_table,timer_list,pending_list,并使用了一个设备句柄池readFDS，把所有的Socket管道的文件句柄保存起来。而管理的过程可以归纳为以下6点：
    1、可以将一个Event添加到watch_table或者timer_list中；
    2、如果Event是添加到watch_table中，需要把当前Event的fd（事件设备句柄）添加到readFDS中；
    3、如果Event是添加到timer_list中，不需要把当前Event的fd（事件设备句柄）添加到readFDS中，而且当前Event的fd值是无效的；
    4、在循环检测过程中，如果发现watch_table中有Event就会把当前Event添加到pending_list中，如果当前Event的persist属性为false，说明不需要保留当前节点，就把当前的Event从watch_table中删除；如果persist为true，说明需要保留，就不需要从watch_table中删除当前节点。
    5、在循环检测过程中，如果发现timer_list中的Event超时时，把当前Event移动到pending_list中，同时删除timer_list中的节点。
    6、在循环检测的过程中，等watch_table和timer_list处理完毕后，就去pending_list中执行里面的Event所指向的func。
    有了以上的认识，我们来看一下具体的流程。从Event的创建入口开始：

[cpp] view plain copy
  1. @ril.cpp  
  2. RIL_startEventLoop(void) {  
  3.     //打开Event线程，并调用eventLoop进入循环  
  4.     ret = pthread_create(&s_tid_dispatch, &attr, eventLoop, NULL);  
  5. }  

    然后我们进入到线程的入口函数中查看：

[cpp] view plain copy
  1. eventLoop(void *param) {  
  2.     //Event的初始化  
  3.     ril_event_init();  
  4.     //创建一个Event  
  5.     ril_event_set (&s_wakeupfd_event, s_fdWakeupRead, true,processWakeupCallback, NULL);  
  6.     //将上面创建的Event加入到watch_table中，这里起到唤醒LoopEvent的作用，后面详细说明  
  7.     rilEventAddWakeup (&s_wakeupfd_event);  
  8.     //进入loop循环  
  9.     ril_event_loop();  
  10. }  

    可以看出，Event的搭建由两个步骤：1、初始化链表；2、进入loop循环。我们分别看一下两个过程：

1.2、EventLoop的搭建过程


1.2.1、Event初始化过程。其实就是ril_event_init过程。

[cpp] view plain copy
  1. @ril_event.cpp  
  2. void ril_event_init()  
  3. {  
  4.     FD_ZERO(&readFds);  
  5.     init_list(&timer_list);  
  6.     init_list(&pending_list);  
  7.     memset(watch_table, 0, sizeof(watch_table));  
  8. }  

    初始化的过程很简单，就是对loop框架中涉及到的文件句柄集和3个重要链表的初始化。

1.2.2、Event循环的过程

[cpp] view plain copy
  1. @ril_event.cpp  
  2. void ril_event_loop()  
  3. {  
  4.     //死循环检测Event消息  
  5.     for (;;) {  
  6.         //计算下一次超时时间  
  7.         if (-1 == calcNextTimeout(&tv)) {  
  8.             //NULL说明select是阻塞模式  
  9.             ptv = NULL;  
  10.         } else {  
  11.             //非空说明在超时时间内是阻塞模式  
  12.             ptv = &tv;  
  13.         }  
  14.         //用select去扫描readFds中的所有管道集合，检测RILJ是否有新数据出现。  
  15.         n = select(nfds, &rfds, NULL, NULL, ptv);  
  16.         //检查超时事件，如果超时，将Event放入pending_list中  
  17.         processTimeouts();  
  18.         //检查watch_table，将Event加入pending_list中  
  19.         processReadReadies(&rfds, n);  
  20.         //执行pending_list中的Event  
  21.         firePending();  
  22.     }  
  23. }  

    上面的for循环可以清晰的看到，当RILJ发送数据后，在EventLoop中会依次被timer_list、watch_table、pending_list处理；接着来分别看一下3个表的处理流程：
    a、timer_list表

[cpp] view plain copy
  1. static void processTimeouts()  
  2. {  
  3.     //如果timer_list中某个事件已经超时  
  4.     while ((tev != &timer_list) && (timercmp(&now, &tev->timeout, >))) {  
  5.         //从timer_list中删除  
  6.         removeFromList(tev);  
  7.         //添加到pending_list中  
  8.         addToList(tev, &pending_list);  
  9.     }  
  10. }  

    b、watch_table表

[cpp] view plain copy
  1. static void processReadReadies(fd_set * rfds, int n)  
  2. {  
  3.     for (int i = 0; (i < MAX_FD_EVENTS) && (n > 0); i++) {  
  4.         //添加到pending_list  
  5.         addToList(rev, &pending_list);  
  6.         if (rev->persist == false) {  
  7.             //如果persist为false才去删除当前Event  
  8.             removeWatch(rev, i);  
  9.         }  
  10.     }  
  11. }  

    c、pending_list表

[cpp] view plain copy
  1. static void firePending()  
  2. {  
  3.     while (ev != &pending_list) {  
  4.         //删除当前节点  
  5.         removeFromList(ev);  
  6.         //执行其func并把参数传递进去  
  7.         ev->func(ev->fd, 0, ev->param);  
  8.     }  
  9. }  

    上面的循环过程说明，eventLoop的是通过在内部循环中用Linux中的select方法检测readFds中所有的文件句柄（或者说管道），如果发现有新的数据进来，就去遍历watch_table和timer_list表，把需要处理的eventLoop加入到pending_list中，然后进入pending_list中去执行每个Event的func。


    上面提到了循环接收数据的过程，那么具体的处理这些命令的过程是怎样的呢？这个过程等我们了解了reference的过程后再去讲解。

    再次提醒一下，这里侦测到的数据主要是RILJ发送下来的命令（而不是Modem侧上来的AT命令）。

二、reference库的加载

    在这一步中，RIL需要加载一个AT相关的***ril.so的动态链接库。之所以使用库的形式，就是考虑到每个厂商使用的Modem不同，我们没法用统一的接口去向底层负责，因此使用库的形式。这样一来，不同的Modem厂商提供不同的链接库，只要符合RIL层的框架即可。而当前的链接库中最主要的就是就是reference-ril.c和atchannel.c文件。
    而reference库需要完成两个任务：
    1、将eventLoop中的命令通过AT发送给Modem;
    2、构建一个readerLoop循环，接受Modem消息，并根据消息的不同（URC和非URC）将消息返回给eventLoop（非URC消息）或者直接发送给RILJ（URC消息）。
    我们先看readerLoop构建过程（发送AT的过程在文档的最后一章介绍）：

2.1、reference中readerLoop建立和循环过程

    在这一步中，需要完成reference的初始化，并且打开的ReaderLoop循环。
[cpp] view plain copy
  1. @reference-ril.c  
  2. const RIL_RadioFunctions *RIL_Init(const struct RIL_Env *env, int argc, char **argv)  
  3. {  
  4.     //开启ril的线程，入口函数是mainLoop  
  5.     ret = pthread_create(&s_tid_mainloop, &attr, mainLoop, NULL);  
  6.     //把ril的回调函数返回出来  
  7.     return &s_callbacks;  
  8. }  

    我们来看入口函数：

[cpp] view plain copy
  1. static void * mainLoop(void *param)  
  2. {  
  3.     //初始化AT通道的关闭方法和超时方法  
  4.     at_set_on_reader_closed(onATReaderClosed);  
  5.     at_set_on_timeout(onATTimeout);  
  6.     for (;;) {  
  7.         //打开AT并把处理URC消息的方法onUnsolicited传进去  
  8.         ret = at_open(fd, onUnsolicited);  
  9.         RIL_requestTimedCallback(initializeCallback, NULL, &TIMEVAL_0);  
  10.         waitForClose();  
  11.     }  
  12. }  

    上面可以看到，不仅打开了AT通道，而且还设置了超时方法。当前线程在打开AT通道后，在waitForClose中阻塞等待，如果AT通道在检测超时后，将会主动的关闭当前的AT通道，此时将会激活waitForClose中的阻塞线程，然后waitForClose将会返回。而一旦waitForClose函数返回，将会再次进入for循环，重新打开AT通道。

    我们主要跟踪AT通道打开的过程，以及事件的处理流程：

[cpp] view plain copy
  1. @atchannel.c  
  2. int at_open(int fd, ATUnsolHandler h)  
  3. {  
  4.     //URC消息的处理方式：onUnsolicited()  @reference-ril.c  
  5.     s_fd = fd;  
  6.     //创建线程读取AT命令并处理Modem发过来的信息  
  7.     ret = pthread_create(&s_tid_reader, &attr, readerLoop, &attr);  
  8. }  

    看一下read线程的入口函数readerLoop：

[cpp] view plain copy
  1. static void *readerLoop(void *arg)  
  2. {  
  3.     for (;;) {  
  4.         //读取命令  
  5.         line = readline();  
  6.         if(isSMSUnsolicited(line)) {  
  7.             if (s_unsolHandler != NULL) {  
  8.                 //URC消息可以直接发送给RILJ  
  9.                 s_unsolHandler (line1, line2);  
  10.             }  
  11.         } else {  
  12.             processLine(line);  
  13.         }  
  14.     }  
  15.     //关闭read  
  16.     onReaderClosed();  
  17.     return NULL;  
  18. }  

    上面的readerLoop就是在不断侦测Modem上报的消息，然后根据是否是URC消息来采用不同的处理方式。至于具体的判断依据，在两个地方可以体现：1、通过isSMSUnsolicited判断（如果以CMT/CDS/CBM开头则判断成立）；2、也可以在processLine中判断（这是主要的判断依据）。

    我们简要说一下processLine判断URC消息的依据。我们知道，如果不是URC消息，那么就是我们主动发送的请求，Modem是作为回应给我们发的消息，而在我们给Modem发送消息时，会注册各种的回调函数和用于放置Modem返回值的指针sp_response。而如果是URC消息，那么就没有回调函数，而且sp_response是为空，reference正是通过判断sp_response的内容来达到区分URC消息的目的。
    在processLine中对于不同的消息有不同的处理流程：

[cpp] view plain copy
  1. static void processLine(const char *line)  
  2. {  
  3.     if (sp_response == NULL) {  
  4.         //URC消息处理  
  5.         handleUnsolicited(line);  
  6.     } else if (isFinalResponseSuccess(line)) {  
  7.         //非URC消息处理  
  8.         sp_response->success = 1;  
  9.         //发送回应消息给EventLoop  
  10.         handleFinalResponse(line);  
  11.     } else switch (s_type) {  
  12.         case NO_RESULT:  
  13.         case NUMERIC:  
  14.             //非URC消息处理  
  15.             if (sp_response->p_intermediates == NULL  
  16.                 && isdigit(line[0])  
  17.             ) {  
  18.                 addIntermediate(line);  
  19.             } else {  
  20.                 /* either we already have an intermediate response or 
  21.                    the line doesn't begin with a digit */  
  22.                 handleUnsolicited(line);  
  23.             }  
  24.             break;  
  25.     }  
  26. }  

    可以看到，URC消息是通过handleUnsolicited处理的，而非URC消息有两个地方处理。下面分别介绍两种处理方式：

2.2、URC消息处理流程

    我们看URC消息的处理函数：

[cpp] view plain copy
  1. @atchannel.c  
  2. static void handleUnsolicited(const char *line)  
  3. {  
  4.     s_unsolHandler(line, NULL);  
  5. }  

    这里的s_unsolHandler来自于at_open时的参数，也就是reference-ril.c中的onUnsolicited：

[cpp] view plain copy
  1. @reference-ril.c  
  2. static void onUnsolicited (const char *s, const char *sms_pdu)  
  3. {  
  4.     if (strStartsWith(s, "%CTZV:")) {  
  5.         //时区改变  
  6.         RIL_onUnsolicitedResponse (RIL_UNSOL_NITZ_TIME_RECEIVED,response, strlen(response));  
  7.     } else if (strStartsWith(s,"+CRING:")  
  8.                 || strStartsWith(s,"RING")  
  9.                 || strStartsWith(s,"NO CARRIER")  
  10.                 || strStartsWith(s,"+CCWA")  
  11.     ) {  
  12.         //通话状态改变  
  13.         RIL_onUnsolicitedResponse (RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, NULL, 0);  
  14.     } else if (strStartsWith(s,"+CREG:")|| strStartsWith(s,"+CGREG:")) {  
  15.         //网络注册状态改变  
  16.         RIL_onUnsolicitedResponse (RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED,NULL, 0);  
  17.     } else if (strStartsWith(s, "+CMT:")) {  
  18.         //新短信通知  
  19.         RIL_onUnsolicitedResponse (RIL_UNSOL_RESPONSE_NEW_SMS,sms_pdu, strlen(sms_pdu));  
  20.     } else if (strStartsWith(s, "+CDS:")) {  
  21.         //短信报告  
  22.         RIL_onUnsolicitedResponse (RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT,sms_pdu, strlen(sms_pdu));  
  23.     } else if (strStartsWith(s, "+CGEV:")) {  
  24.         RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL);  
  25.     }  
  26. }  

    可以看出，URC消息的处理流程基本上就是根据命令头的不同将其转化为不同的命令索引，然后调用RIL_onUnsolicitedResponse函数，而RIL_onUnsolicitedResponse的实现：

[cpp] view plain copy
  1. #define RIL_onUnsolicitedResponse(a,b,c) s_rilenv->OnUnsolicitedResponse(a,b,c)  

    说明这个函数调用的是s_rilenv变量的OnUnsolicitedResponse方法。那么s_rilenv是哪里初始化的呢？

    我们在rild.c中的main函数中对reference库初始化时是这样的形式：

[cpp] view plain copy
  1. funcs = rilInit(&s_rilEnv, argc, rilArgv);  

    上面的初始化过程将s_rilEnv全局变量传递给了reference，然后在reference-ril.c内部将这个值传给了s_rilenv，而s_rilEnv的各个处理函数是在ril.cpp中实现的。

    上面绕了一圈，还是把对消息的处理从动态库（也就是reference-ril.c文件）饶回到了ril.c文件中。这也符合整个RIL架构的设计理念：框架和处理方式由ril.c管理，差异化的AT命令由reference实现。

[cpp] view plain copy
  1. @ril.cpp  
  2. void RIL_onUnsolicitedResponse(int unsolResponse, void *data,  
  3.                                size_t datalen, RILId id)  
  4. {  
  5.     //得到当前命令的请求码  
  6.     unsolResponseIndex = unsolResponse - RIL_UNSOL_RESPONSE_BASE;  
  7.     //从ril_unsol_commands.h文件中得到命令的类型  
  8.     wakeType = s_unsolResponses[unsolResponseIndex].wakeType;  
  9.     //根据不同命令的不同类型进行解析   
  10.     switch (wakeType) {  
  11.         case WAKE_PARTIAL:  
  12.         case DONT_WAKE:  
  13.     }  
  14.     appendPrintBuf("[UNSL]< %s", requestToString(unsolResponse));  
  15.   
  16.     Parcel p;  
  17.     p.writeInt32 (RESPONSE_UNSOLICITED);  
  18.     p.writeInt32 (unsolResponse);  
  19.     //调用当前命令的打包函数进行数据打包  
  20.     ret = s_unsolResponses[unsolResponseIndex].responseFunction(p, data, datalen);  
  21.     //把数据发送到RILJ中  
  22.     ret = sendResponse(p,id);  
  23.   
  24.     if (shouldScheduleTimeout) {  
  25.     }  
  26.     return;  
  27. }  

    上面的处理过程分为2步：1、调用当前命令对应的打包函数进行数据打包；2、将数据发送给RILJ。

    数据打包的过程涉及到一个数组s_unsolResponses，他的详细作用在本文的最后一张有说明，这里简要介绍一下。s_unsolResponses是一个文件，文件中对所有的URC消息都有一个对应的数组相对应，每个数组分3部分：1、命令的请求码；2、命令的打包函数；3、命令的类型；我们要做的就是用当前Modem给出的命令，找到对应的请求码，然后得到相应的打包函数进行数据打包。
    而发送的过程就是调用sendResponse把Parcel数据发送给RILJ。
    在上面的过程中，用reference中通过AT头转换的命令值与RIL_UNSOL_RESPONSE_BASE相减得到在s_unsolResponses表中对应的命令索引。查找相应的wakeType类型去决定是否计算超时（shouldScheduleTimeout），之后就用s_unsolResponses中的responseFunction去解析命令，最后通过sendResponse将数据发送给RILJ：

[cpp] view plain copy
  1. static int sendResponse (Parcel &p) {  
  2.     return sendResponseRaw(p.data(), p.dataSize());  
  3. }  

    发送数据：

[cpp] view plain copy
  1. static int sendResponseRaw (const void *data, size_t dataSize) {  
  2.     //发送通道的Socket ID  
  3.     int fd = s_fdCommand;  
  4.     int ret;  
  5.     uint32_t header;  
  6.   
  7.     //将数据长度这个整数转换为适合Socket  传输的字节顺序  
  8.     header = htonl(dataSize);  
  9.   
  10.     //先发送一个关于数据大小的字节  
  11.     ret = blockingWrite(fd, (void *)&header, sizeof(header));  
  12.   
  13.     //再发送数据本身  
  14.     ret = blockingWrite(fd, data, dataSize);  
  15.   
  16.     return 0;  
  17. }  

    继续看发送过程：

[cpp] view plain copy
  1. static int blockingWrite(int fd, const void *buffer, size_t len) {  
  2.     size_t writeOffset = 0;  
  3.     const uint8_t *toWrite;  
  4.     toWrite = (const uint8_t *)buffer;  
  5.   
  6.     while (writeOffset < len) {  
  7.         ssize_t written;  
  8.         do {  
  9.             //发送数据到fd指定的句柄中，也就是RILJ对应的Socket通道  
  10.             written = write (fd, toWrite + writeOffset,len - writeOffset);  
  11.         } while (written < 0 && ((errno == EINTR) || (errno == EAGAIN)));  
  12.     }  
  13.     return 0;  
  14. }  

    这里注意到，发送的最终操作，就是把数据放到一个fd指向的句柄中，那么这个句柄从哪里来的呢？

[cpp] view plain copy
  1. #define SOCKET_NAME_RIL "rild"  
  2. //得到"rild"的Socket连接  
  3. s_fdListen = android_get_control_socket(SOCKET_NAME_RIL);  
  4. //accept的函数默认会阻塞进程，直到有一个客户连接建立后把可用的连接套接字返回  
  5. s_fdCommand = accept(s_fdListen, (sockaddr *) &peeraddr, &socklen);  

    上面的递归关系我们可以看出，s_fdCommand就是RILJ与RILC之间建立的Socket通道的套接字！因此我们可以通过这个通道发送数据给RILJ。

2.3、非URC消息处理流程

    上面介绍了URC消息的流程，下面分析一下更普遍的非URC消息的处理流程。
    前面说道，非URC消息就是一种回应。当上层通过AT向Modem发送请求后，会一直处于阻塞状态等待回应，一旦readerLoop得到了非URC的消息，就会去唤醒Event端等待的进程。
    我们在此主要介绍reference如何唤醒eventLoop端的线程。
    非URC消息的上报流程也是从processLine开始的：

[cpp] view plain copy
  1. @atchannel.c  
  2. static void processLine(const char *line)  
  3. {  
  4.     if (sp_response == NULL) {  
  5.     } else if (isFinalResponseSuccess(line)) {  
  6.         sp_response->success = 1;  
  7.         //发送回应消息给eventLoop  
  8.         handleFinalResponse(line);  
  9.     } else if (isFinalResponseError(line)) {  
  10.     } else if (s_smsPDU != NULL && 0 == strcmp(line, "> ")) {  
  11.     } else switch (s_type) {  
  12.         case NO_RESULT:  
  13.         case NUMERIC:  
  14.             if (sp_response->p_intermediates == NULL && isdigit(line[0])  
  15.             ) {  
  16.                 addIntermediate(line);  
  17.             } else {  
  18.                 handleUnsolicited(line);  
  19.             }  
  20.             break;  
  21.         case SINGLELINE:  
  22.             if (sp_response->p_intermediates == NULL  
  23.                 && strStartsWith (line, s_responsePrefix)  
  24.             ) {  
  25.                 addIntermediate(line);  
  26.             } else {  
  27.                 handleUnsolicited(line);  
  28.             }  
  29.             break;  
  30.         case MULTILINE:  
  31.         break;  
  32.     }  
  33. }  

    这里简要介绍以下Modem对于非URC消息的回复格式。消息一般大于2行，前几行是返回值的有效数据，最后一行是作为当前命令结束的标志位。如果是有效数据，那么当前数据就有一个s_type的类型与之相关联（从EventLoop发送给reference时决定）。因此就会在processLine中的switch中进入addIntermediate函数，而这个函数的作用就是把当前的数据放入到反馈数据的sp_response->p_intermediates里面。等到命令的最后，因为是标志位，就会走到processLine的handleFinalResponse中，将数据发送给Event侧。

    下面贴出涉及到的重要函数：

    a、将数据放到反馈数据中：addIntermediate

[cpp] view plain copy
  1. static void addIntermediate(const char *line)  
  2. {  
  3.     ATLine *p_new;  
  4.     p_new = (ATLine  *) malloc(sizeof(ATLine));  
  5.     p_new->line = strdup(line);  
  6.     p_new->p_next = sp_response->p_intermediates;  
  7.     //把有效的返回值放到sp_response->p_intermediates中  
  8.     sp_response->p_intermediates = p_new;  
  9. }  

    b、判断是否已经把所有有效数据传输完毕：isFinalResponseSuccess

[cpp] view plain copy
  1. //结束符  
  2. static const char * s_finalResponsesSuccess[] = {  
  3.     "OK",  
  4.     "CONNECT"  
  5. };  
  6. //判断  
  7. static int isFinalResponseSuccess(const char *line)  
  8. {  
  9.     size_t i;  
  10.     for (i = 0 ; i < NUM_ELEMS(s_finalResponsesSuccess) ; i++) {  
  11.         if (strStartsWith(line, s_finalResponsesSuccess[i])) {  
  12.             return 1;  
  13.         }  
  14.     }  
  15.     return 0;  
  16. }  

    c、发送数据给Event侧，取消Event侧阻塞的线程：handleFinalResponse

[cpp] view plain copy
  1. static void handleFinalResponse(const char *line)  
  2. {  
  3.     //把回应消息返回给eventLoop  
  4.     sp_response->finalResponse = strdup(line);  
  5.     //发信号给s_commandcond线程，使其脱离阻塞状态  
  6.     pthread_cond_signal(&s_commandcond);  
  7. }  

三、一个完整的过程

    经过上面的eventLoop和readerLoop过程分析，我们分别对eventLoop的机制和readerLoop中两种消息的处理有个大致的了解，但是还有一些问题我们没有解决，比如：
    1、eventLoop所构建的循环如何接收RILJ的消息？又如何通过reference将消息发送到Modem？
    2、上面说道reference接收到非URC消息后需要通知eventLoop读取消息，具体怎么通知eventLoop的？
    这些问题将在这一节中详细说明。我们用一个完整的数据流来把两个loop串起来。而一个完整的数据流应该包括以下四个步骤：
    1、Eventloop接收RILJ的请求，并负责把请求发送给reference库：Eventloop--->reference
    2、reference负责把命令转化为AT命令，然后发送给Modem：reference--->Modem
    3、reference通过readerLoop得到Modem回应后把数据返回给Eventloop:   Modem--->ReaderLoop
    4、Eventloop再把数据返回给RILJ:ReaderLoop--->Eventloop
    下面我们就分别介绍这4个步骤的详细流程。

3.1、Eventloop把RILJ命令发送给reference库。

    我们再次回到RILC层的入口处,前面两节介绍了Eventloop和reference，接下来就是RIL_register的入口：
[cpp] view plain copy
  1. @rild.c  
  2. int main(int argc, char **argv)  
  3. {  
  4.     //搭建EventLoop循环  
  5.     RIL_startEventLoop();  
  6.   
  7.     //对reference动态库进行初始化  
  8.     funcs = rilInit(&s_rilEnv, argc, rilArgv);  
  9.   
  10.     //注册reference  的回调函数  
  11.     RIL_register(funcs);  
  12. }  

    上面看到，当我们调用reference的初始化函数（也就是RIL_Init）后，将会得到一个RIL_RadioFunctions类型的返回值：

[cpp] view plain copy
  1. @reference-ril.c  
  2. static const RIL_RadioFunctions s_callbacks = {  
  3.     RIL_VERSION,  
  4.     onRequest,  
  5.     currentState,  
  6.     onSupports,  
  7.     onCancel,  
  8.     getVersion  
  9. };  

    这个变量的类型为：

[cpp] view plain copy
  1. typedef struct {  
  2.     int version;        //当前链接库的版本信息  
  3.     RIL_RequestFunc onRequest;  //用于Event侧向动态库发起请求  
  4.     RIL_RadioStateRequest onStateRequest;   //得到当前库的状态  
  5.     RIL_Supports supports;  //查询是否支持某个命令  
  6.     RIL_Cancel onCancel;       //取消一个Event的处理  
  7.     RIL_GetVersion getVersion;  //得到版本号  
  8. } RIL_RadioFunctions;  

    这些成员函数中最重要的是onRequest，当我们在Event侧向reference库发起请求时，就是用的这个入口函数。而我们将用这个对象去完成注册的过程。

[cpp] view plain copy
  1. @ril.cpp  
  2. //将reference中的回调函数注册给RIL的框架  
  3. void RIL_register (const RIL_RadioFunctions *callbacks) {  
  4.     //把返回值传给s_callbacks(全局变量)  
  5.     memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));  
  6.   
  7.     //#define SOCKET_NAME_RIL "rild"  打开RILC与RILJ之间的Socket通道  
  8.     s_fdListen = android_get_control_socket(SOCKET_NAME_RIL);  
  9.     ret = listen(s_fdListen, 4);  
  10.   
  11.     //用这个Socket通道句柄创建一个Event    
  12.     ril_event_set (&s_listen_event, s_fdListen, false, listenCallback, NULL);  
  13.   
  14.     //添加到Eventloop中  
  15.     rilEventAddWakeup (&s_listen_event);  
  16. }  

    在上面的注册函数中主要完成了两个任务：1、将我们从reference得到的回调函数callbacks传递给一个全局变量s_callbacks；2、打开Socket通道并添加句柄到Eventloop中。对于第二个任务，我们看到在注册的过程中，通过android_get_control_socket的方法打开了RILJ与RILC之间的Socket通道，而且这个通道的文件句柄为s_fdListen（全局变量），并用这个通道的句柄构建一个Event，然后添加到Eventloop中。并且为这个Event注册了的回调函数listenCallback。

    经过上面的过程，就在RILJ与EventLoop之间建立了沟通的渠道。
    还记得我们在Eventloop中提到如果检测到句柄池中的某个句柄有新数据的话，就会调用将timer_list和watch_table中的Event放入pending_list中，然后调用当前Event的回调函数：

[cpp] view plain copy
  1. @ril_event.cpp  
  2. static void firePending()  
  3. {  
  4.     struct ril_event * ev = pending_list.next;  
  5.     while (ev != &pending_list) {  
  6.         struct ril_event * next = ev->next;  
  7.         removeFromList(ev);  
  8.         //这里的func就是listenCallback  
  9.         ev->func(ev->fd, 0, ev->param);  
  10.         ev = next;  
  11.     }  
  12. }  

    对于RILJ中过来的Event，我们注册的回调函数是listenCallback：

[cpp] view plain copy
  1. @ril.cpp  
  2. static void listenCallback (int fd, short flags, void *param) {  
  3.     //从s_fdListen侦听套接字得到s_fdCommand（RILJ与RILC之间的流套接字）  
  4.     s_fdCommand = accept(s_fdListen, (sockaddr *) &peeraddr, &socklen);  
  5.   
  6.     //得到当前命令的选项值  
  7.     err = getsockopt(s_fdCommand, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds);  
  8.   
  9.     //对文件描述符s_fdCommand进行控制，当前是设置其非阻塞模式  
  10.     ret = fcntl(s_fdCommand, F_SETFL, O_NONBLOCK);  
  11.   
  12.     //再次把当前命令放入Eventloop  
  13.     ril_event_set (&s_commands_event, s_fdCommand, 1, processCommandsCallback, p_rs);  
  14.     rilEventAddWakeup (&s_commands_event);  
  15.   
  16.     //发送URC消息，通知RIL状态发生改变  
  17.     onNewCommandConnect();  
  18. }  

    上面的过程分为2步：1、把当前消息重新发送到Eventloop；2、发送URC消息，通知RILJ（RIL状态改变了）。我们先来看一下第二个过程：

[cpp] view plain copy
  1. static void onNewCommandConnect() {  
  2.     //给RILJ发送URC消息，RIL连接成功  
  3.     RIL_onUnsolicitedResponse(RIL_UNSOL_RIL_CONNECTED, &rilVer, sizeof(rilVer));  
  4.   
  5.     //给RILJ发送URC消息，告诉RILJ,Radio状态改变了  
  6.     RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED, NULL, 0);  
  7. }  

    我们再分析上面的第一个步骤，也就是把消息发送到Eventloop中的过程。当发送到Eventloop后，Eventloop就会调用当前Event的回调函数，现在的回调函数是processCommandsCallback：

[cpp] view plain copy
  1. static void processCommandsCallback(int fd, short flags, void *param) {  
  2.     for (;;) {  
  3.         ret = record_stream_get_next(p_rs, &p_record, &recordlen);  
  4.   
  5.         if (ret == 0 && p_record == NULL) {  
  6.             break;  
  7.         } else if (ret < 0) {  
  8.             break;  
  9.         } else if (ret == 0) { /* && p_record != NULL */  
  10.             //把RILJ层数据通过AT发送到Modem  
  11.             processCommandBuffer(p_record, recordlen);  
  12.         }  
  13.     }  
  14.   
  15.     if (ret == 0 || !(errno == EAGAIN || errno == EINTR)) {  
  16.         //命令已经发送完成，关闭当前命令的流套接字  
  17.         close(s_fdCommand);  
  18.         s_fdCommand = -1;  
  19.         //删掉当前Event  
  20.         ril_event_del(&s_commands_event);  
  21.         record_stream_free(p_rs);  
  22.         //重新添加RILJ与RILC之间的Socket  Event  
  23.         rilEventAddWakeup(&s_listen_event);  
  24.         onCommandsSocketClosed();  
  25.     }  
  26. }  

    上面看到，发送命令给Modem是通过processCommandBuffer实现的：

[cpp] view plain copy
  1. static int processCommandBuffer(void *buffer, size_t buflen) {  
  2.     Parcel p;  
  3.     int32_t request;  
  4.     int32_t token;  
  5.     RequestInfo *pRI;  
  6.   
  7.     p.setData((uint8_t *) buffer, buflen);  
  8.     //得到请求码和令牌  
  9.     status = p.readInt32(&request);  
  10.     status = p.readInt32 (&token);  
  11.   
  12.     pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));  
  13.     //设置当前请求的令牌  
  14.     pRI->token = token;  
  15.   
  16.     //s_commands中针对不同的命令对应不同的处理函数  
  17.     pRI->pCI = &(s_commands[request]);  
  18.   
  19.     //链表结构  
  20.     pRI->p_next = s_pendingRequests;  
  21.     s_pendingRequests = pRI;  
  22.   
  23.     //调用reference  中的  
  24.     pRI->pCI->dispatchFunction(p, pRI);  
  25.   
  26.     return 0;  
  27. }  

    首先说明一个很重要的标志位：token令牌；这个令牌可以看作当前请求的ID，当我们从Modem得到数据后需要根据不同的令牌找到当初的请求命令，然后做出相应的答复。

    这里还涉及到一个特殊的数组s_commands。他的作用和s_unsolResponses类似，详细说明在本文的最后一章，这里还是简单介绍一下他的作用：

    s_commands是一个数组，每个RILJ发送过来的命令在s_commands中都对应一个元素，而每个元素包含3个数据：

[cpp] view plain copy
  1. typedef struct {  
  2.     int requestNumber;  
  3.     void (*dispatchFunction) (Parcel &p, struct RequestInfo *pRI);  
  4.     int(*responseFunction) (Parcel &p, void *response, size_t responselen);  
  5. } CommandInfo;  

    其中requestNumber表示当前命令的编号；dispatchFunction的作用是，当前命令可以通过这个接口把数据发送到reference库；responseFunction的作用是：当Modem返回数据后reference侧可以用这个函数把数据进行打包，然后传递给Event侧。
    而在processCommandBuffer中要做的就是通过当前的命令号，找到对应的发送函数（dispatchFunction）和打包函数（responseFunction）。然后把这三个数据连同当前命令的令牌（当前命令的ID）构建一个在Event和reference侧通用的数据类型（RequestInfo）并把它发送给reference侧。
    假如我们从RILJ得到的命令号为RIL_REQUEST_GET_SIM_STATUS（得到当前SIM卡的状态），那么对应的，就需要调用当前命令的发送函数，而在s_commands中对于这条命令的描述为：
[cpp] view plain copy
  1. {RIL_REQUEST_GET_SIM_STATUS, dispatchVoid, responseSimStatus},  
    因此，它对应的发送函数就是dispatchVoid：
[cpp] view plain copy
  1. @ril.cpp  
  2. static void dispatchVoid (Parcel& p, RequestInfo *pRI) {  
  3.     //发送数据到Modem    
  4.     clearPrintBuf;  
  5.     //打印Log信息RLOGD("[%04d]> %s %s", token, requestToString(req), printBuf)  
  6.     printRequest(pRI->token, pRI->pCI->requestNumber);  
  7.     //s_callbacks是从reference注册过来的  
  8.     s_callbacks.onRequest(pRI->pCI->requestNumber, NULL, 0, pRI);  
  9. }  
    这里看到，将命令发送到reference库是通过s_callbacks的onRequest方法实现的，而且发送时会将命令号和ril_commands.h中对应的当前命令的信息一同发送。
    而关于s_callbacks这个全局变量，我们在这一节的最初就讲到，当我们调用reference中的RIL_Init完成初始化时，就会得到reference返回当前链接库提供的接口函数，而s_callbacks正是来自于这些接口：
[cpp] view plain copy
  1. @reference-ril.c  
  2. static const RIL_RadioFunctions s_callbacks = {  
  3.     RIL_VERSION,  
  4.     onRequest,  
  5.     currentState,  
  6.     onSupports,  
  7.     onCancel,  
  8.     getVersion  
  9. };  

    因此，当上面的Eventloop将数据通过s_callbacks.onRequest发送给reference的过程就是调用reference-ril.c中的onRequest的过程。

    之后，Eventloop就完成了下发命令的任务，接下来需要reference完成把命令发送给Modem的任务。

3.2、reference将Eventloop的数据发送到Modem

    上面说道，s_callbacks.onRequest其实就是reference-ril.c中的onRequest,经过这次调用，就将数据由Eventloop侧传到了reference侧。

[cpp] view plain copy
  1. @reference-ril.c  
  2. static void onRequest (int request, void *data, size_t datalen, RIL_Token t)  
  3. {  
  4.     ATResponse *p_response;  
  5.     RLOGD("onRequest: %s", requestToString(request));  
  6.   
  7.     //我们重点看RIL_REQUEST_GET_SIM_STATUS  
  8.     switch (request) {  
  9.         case RIL_REQUEST_GET_SIM_STATUS: {  
  10.             RIL_CardStatus_v6 *p_card_status;  
  11.             char *p_buffer;  
  12.             int buffer_size;  
  13.             //与Modem交互，发送命令并得到回应  
  14.             int result = getCardStatus(&p_card_status);  
  15.             //把回应传回给Eventloop  
  16.             RIL_onRequestComplete(t, result, p_buffer, buffer_size);  
  17.             freeCardStatus(p_card_status);  
  18.             break;  
  19.         }  
  20.         case RIL_REQUEST_GET_CURRENT_CALLS:  
  21.             //得到当前通话  
  22.             requestGetCurrentCalls(data, datalen, t);  
  23.             break;  
  24.         case RIL_REQUEST_DIAL:  
  25.             //拨号  
  26.             requestDial(data, datalen, t);  
  27.             break;  
  28.         case RIL_REQUEST_HANGUP:  
  29.             //挂起  
  30.             requestHangup(data, datalen, t);  
  31.     }  
  32. }  
    从onRequest可以看出，reference中对所有的命令请求进行判别，然后选择不同的处理方式。对于尝试得到SIM状态这个请求来说，不仅需要通过getCardStatus得到SIM卡状态，而且还需要调用RIL_onRequestComplete将得到的状态通过Eventloop返回给RILJ。我们先看给Modem发送数据的过程
[cpp] view plain copy
  1. static int getCardStatus(RIL_CardStatus_v6 **pp_card_status) {  
  2.     //SIM卡所有可能的状态  
  3.     static RIL_AppStatus app_status_array[] = {  
  4.         //SIM_ABSENT = 0        SIM不存在  
  5.         { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN,  
  6.           NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },  
  7.         // SIM_NOT_READY = 1    SIM未就绪  
  8.         { RIL_APPTYPE_SIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN,  
  9.           NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },  
  10.         // SIM_READY = 2        SIM就绪  
  11.         { RIL_APPTYPE_SIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY,  
  12.           NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },  
  13.         ....  
  14.   
  15.     };  
  16.     //查询SIM状态，将AT命令发送到Modem，然后得到Modem的数据  
  17.     int sim_status = getSIMStatus();  
  18.   
  19.     RIL_CardStatus_v6 *p_card_status = malloc(sizeof(RIL_CardStatus_v6));  
  20.   
  21.     if (num_apps != 0) {  
  22.         // Only support one app, gsm  
  23.         p_card_status->num_applications = 2;  
  24.         p_card_status->gsm_umts_subscription_app_index = 0;  
  25.         p_card_status->cdma_subscription_app_index = 1;  
  26.   
  27.         // Get the correct app status  
  28.         p_card_status->applications[0] = app_status_array[sim_status];  
  29.         p_card_status->applications[1] = app_status_array[sim_status + RUIM_ABSENT];  
  30.     }  
  31.   
  32.     *pp_card_status = p_card_status;  
  33.     //将状态返回给reference  
  34.     return RIL_E_SUCCESS;  
  35. }  
    继续看发送过程
[cpp] view plain copy
  1. static SIM_Status getSIMStatus()  
  2. {  
  3.     //将命令转换为AT命令发送到Modem,而modem的回应放到p_response中  
  4.     err = at_send_command_singleline("AT+CPIN?", "+CPIN:", &p_response);  
  5.   
  6.     //取得返回值  
  7.     cpinLine = p_response->p_intermediates->line;  
  8.     err = at_tok_start (&cpinLine);  
  9.     err = at_tok_nextstr(&cpinLine, &cpinResult);  
  10.   
  11.     //根据返回值得到当前SIM卡状态  
  12.     if (0 == strcmp (cpinResult, "SIM PIN")) {  
  13.         //PIN锁  
  14.         ret = SIM_PIN;  
  15.         goto done;  
  16.     } else if (0 == strcmp (cpinResult, "SIM PUK")) {  
  17.         //PUK锁  
  18.         ret = SIM_PUK;  
  19.         goto done;  
  20.     } else if (0 == strcmp (cpinResult, "PH-NET PIN")) {  
  21.         return SIM_NETWORK_PERSONALIZATION;  
  22.     } else if (0 != strcmp (cpinResult, "READY"))  {  
  23.         //SIM卡不存在  
  24.         ret = SIM_ABSENT;  
  25.         goto done;  
  26.     }  
  27. //返回结果  
  28. done:  
  29.     at_response_free(p_response);  
  30.     return ret;  
  31. }  
    继续看at_send_command_singleline的发送过程：
[cpp] view plain copy
  1. @atchannel.c  
  2. int at_send_command_singleline (const char *command,  
  3.                                 const char *responsePrefix,  
  4.                                  ATResponse **pp_outResponse)  
  5. {  
  6.     err = at_send_command_full (command, SINGLELINE, responsePrefix, NULL, 0, pp_outResponse);  
  7.   
  8.     return err;  
  9. }  
  10. static int at_send_command_full (const char *command, ATCommandType type,  
  11.                     const char *responsePrefix, const char *smspdu,  
  12.                     long long timeoutMsec, ATResponse **pp_outResponse)  
  13. {  
  14.     //发送  
  15.     err = at_send_command_full_nolock(command, type,  
  16.                     responsePrefix, smspdu,  
  17.                     timeoutMsec, pp_outResponse);  
  18.     return err;  
  19. }  
  20. 继续看   
  21. static int at_send_command_full_nolock (const char *command, ATCommandType type,  
  22.                     const char *responsePrefix, const char *smspdu,  
  23.                     long long timeoutMsec, ATResponse **pp_outResponse)  
  24. {  
  25.     //给Modem发消息AT  
  26.     err = writeline (command);  
  27.       
  28.     //创建新的sp_response作为回应  
  29.     sp_response = at_response_new();  
  30.   
  31.     //上面发送完消息后需要阻塞等待Modem回应  
  32.     while (sp_response->finalResponse == NULL && s_readerClosed == 0) {  
  33.         if (timeoutMsec != 0) {  
  34.             //线程进入阻塞状态，等待另一线程满足s_commandcond  后解除  
  35.             err = pthread_cond_timeout_np(&s_commandcond, &s_commandmutex, timeoutMsec);  
  36.         }  
  37.     }  
  38.   
  39.     if (pp_outResponse == NULL) {  
  40.         //释放sp_response  
  41.         at_response_free(sp_response);  
  42.     } else {  
  43.         reverseIntermediates(sp_response);  
  44.         //将回应发送给当初请求AT的线程  
  45.         *pp_outResponse = sp_response;  
  46.     }  
  47.     return err;  
  48. }  
    在上面的函数中，完成了两个重要动作：1、通过writeline发送数据到Modem；2、阻塞当前线程，等待Modem回应。我们先来看writeline的过程：
[cpp] view plain copy
  1. static int writeline (const char *s)  
  2. {  
  3.     size_t len = strlen(s);  
  4.     ssize_t written;  
  5.   
  6.     //Log信息  
  7.     RLOGD("AT> %s\n", s);  
  8.     while (cur < len) {  
  9.         do {  
  10.             //s_fd就是Modem与RILC之间的串口  
  11.             written = write (s_fd, s + cur, len - cur);  
  12.         } while (written < 0 && errno == EINTR);  
  13.   
  14.         cur += written;  
  15.     }  
  16.     do {  
  17.         //以r结尾  
  18.         written = write (s_fd, "\r" , 1);  
  19.     } while ((written < 0 && errno == EINTR) || (written == 0));  
  20.   
  21.     return 0;  
  22. }  
    经过上面的操作，就将一条命令传输到了Modem侧。
    上面说道，at_send_command_full_nolock函数的另一个作用是阻塞当前线程，等待Modem回应，那么，如何实现阻塞的过程？又需要在什么样的情况下解除阻塞状态？又是如何在解除阻塞时把Modem的数据读取出来呢？这一串的疑问我们在接下来的小节中讲解。

3.3、reference通过readerLoop得到Modem回应后把数据返回给Eventloop

    我们在上面的at_send_command_full_nolock函数中，调用writeline将命令写入Modem后，还做了一个很重要的动作，就是阻塞当前线程，等待Modem回应。我们再次回到at_send_command_full_nolock：
[cpp] view plain copy
  1. static int at_send_command_full_nolock (const char *command, ATCommandType type,  
  2.                     const char *responsePrefix, const char *smspdu,  
  3.                     long long timeoutMsec, ATResponse **pp_outResponse)  
  4. {  
  5.     //给Modem发消息AT  
  6.     err = writeline (command);  
  7.       
  8.     //创建新的sp_response作为回应  
  9.     sp_response = at_response_new();  
  10.   
  11.     //上面发送完消息后需要阻塞等待Modem回应  
  12.     while (sp_response->finalResponse == NULL && s_readerClosed == 0) {  
  13.         if (timeoutMsec != 0) {  
  14.             //线程进入阻塞状态，等待另一线程满足s_commandcond  后解除  
  15.             err = pthread_cond_timeout_np(&s_commandcond, &s_commandmutex, timeoutMsec);  
  16.         }  
  17.     }  
  18.   
  19.     if (pp_outResponse == NULL) {  
  20.         //释放sp_response  
  21.         at_response_free(sp_response);  
  22.     } else {  
  23.         reverseIntermediates(sp_response);  
  24.         //将回应发送给当初请求AT的线程  
  25.         *pp_outResponse = sp_response;  
  26.     }  
  27.     return err;  
  28. }  
    上面的sp_response是返回给RILC的数据。而while循环中就是在阻塞状态下等待Modem的回应。这里需要简要说明一下pthread_cond_timeout_np的作用，pthread_cond_timeout_np的第一个参数s_commandcond是一种条件变量，而条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。  
    在这里，为了等待s_commandcond条件变量而自动阻塞了当前线程。那么，只有当另一个线程通过pthread_cond_signal接口是s_commandcond条件满足时，当前阻塞的线程才会被唤醒。
    那么是在哪里去唤醒当前线程的呢？
    我们分析一下，当我们发送数据或命令给Modem的时候，阻塞了当前的线程，阻塞的目的就是等待Modem的回应，而如果Modem有数据上来，那么肯定是先被reference的ReaderLoop检测到并处理，因此，也应该是在ReaderLoop的消息处理中去唤醒当前阻塞的线程，而且应该把Modem的反馈传输给阻塞线程。
    我们直接来看ReaderLoop的处理函数，因为作为Modem的回应，当前消息一定不是URC消息，因此处理函数就是processLine：
[cpp] view plain copy
  1. @atchannel.c  
  2. static void processLine(const char *line)  
  3. {  
  4.     if (sp_response == NULL) {  
  5.     } else if (isFinalResponseSuccess(line)) {  
  6.         sp_response->success = 1;  
  7.         //发送回应消息给EventLoop  
  8.         handleFinalResponse(line);  
  9.     } else if (isFinalResponseError(line)) {  
  10.     } else if (s_smsPDU != NULL && 0 == strcmp(line, "> ")) {  
  11.     } else switch (s_type) {  
  12.         case NO_RESULT:  
  13.         case NUMERIC:  
  14.         case SINGLELINE:  
  15.             if (sp_response->p_intermediates == NULL  
  16.                 && strStartsWith (line, s_responsePrefix)  
  17.             ) {  
  18.                 addIntermediate(line);  
  19.             } else {  
  20.                 /* we already have an intermediate response */  
  21.                 handleUnsolicited(line);  
  22.             }  
  23.             break;  
  24.         case MULTILINE:  
  25.         break;  
  26.     }  
  27. }  
    上面在分析processLine时就说过，Modem给的数据可能有很多行，组后一行是OK的标志位，而之前的行都是有效数据。我们还知道，对于得到SIM卡状态这个请求，他的s_type是SINGLELINE（传递给reference时决定的）。
    因此，我们接受的Modem数据应该先被switch中的SINGLELINE处理，而这一步的处理就是把Modem的有效数据放到sp_response->p_intermediates中：
[cpp] view plain copy
  1. static void addIntermediate(const char *line)  
  2. {  
  3.     ATLine *p_new;  
  4.     p_new = (ATLine  *) malloc(sizeof(ATLine));  
  5.     p_new->line = strdup(line);  
  6.     p_new->p_next = sp_response->p_intermediates;  
  7.     sp_response->p_intermediates = p_new;  
  8. }  
    等有效数据处理完后，再次进入processLine时，遇到了标志位行，因此isFinalResponseSuccess判断成立，去唤醒另一端阻塞的线程：
[cpp] view plain copy
  1. static void handleFinalResponse(const char *line)  
  2. {  
  3.     //把回应消息返回给RIL  
  4.     sp_response->finalResponse = strdup(line);  
  5.     //s_commandcond条件变量的条件得到满足，将会唤醒相应的阻塞线程  
  6.     pthread_cond_signal(&s_commandcond);  
  7. }  
    到这里，完全符合我们的预期，也就是在ReaderLoop的处理过程中，满足条件变量，从而使等待在pthread_cond_timeout_np的线程脱离阻塞状态，同时，把Modem的回应（line）传递给sp_response->p_intermediates。
    此时，我们可以再次回到被阻塞的线程，看看接下来的数据传输过程:
[cpp] view plain copy
  1. @atchannel.c  
  2. static int at_send_command_full_nolock (const char *command, ATCommandType type,  
  3.                     const char *responsePrefix, const char *smspdu,  
  4.                     long long timeoutMsec, ATResponse **pp_outResponse)  
  5. {  
  6.     //给Modem发消息AT  
  7.     err = writeline (command);  
  8.       
  9.     //创建新的sp_response作为回应  
  10.     sp_response = at_response_new();  
  11.   
  12.     //上面发送完消息后需要阻塞等待Modem回应  
  13.     while (sp_response->finalResponse == NULL && s_readerClosed == 0) {  
  14.         if (timeoutMsec != 0) {  
  15.             //线程进入阻塞状态，等待另一线程满足s_commandcond后解除  
  16.             err = pthread_cond_timeout_np(&s_commandcond, &s_commandmutex, timeoutMsec);  
  17.         }  
  18.     }  
  19.   
  20.     if (pp_outResponse == NULL) {  
  21.         //释放sp_response  
  22.         at_response_free(sp_response);  
  23.     } else {  
  24.         reverseIntermediates(sp_response);  
  25.         //将回应发送给当初请求AT的线程  
  26.         *pp_outResponse = sp_response;  
  27.     }  
  28.     return err;  
  29. }  
    当这个函数从pthread_cond_timeout_np中唤醒后，如果当前的命令确实要求Modem给出相应的回应，就会把回应的数据放到pp_outResponse中，返回给上层使用。我们知道，当前的sp_response->finalResponse就是Modem给出的回应。接着，at_send_command_full_nolock就返回了。
    我们再次回顾一下当初调用到pthread_cond_timeout_np的路径：
    getSIMStatus()-->at_send_command_singleline()->at_send_command_full()->at_send_command_full_nolock();
    因此，我们再次回到getSIMStatus中查看：
[cpp] view plain copy
  1. static SIM_Status getSIMStatus()  
  2. {  
  3.     //将命令转换为AT命令发送到Modem,而modem的回应放到p_response中  
  4.     err = at_send_command_singleline("AT+CPIN?", "+CPIN:", &p_response);  
  5.   
  6.     //取得返回值  
  7.     cpinLine = p_response->p_intermediates->line;  
  8.     err = at_tok_start (&cpinLine);  
  9.     err = at_tok_nextstr(&cpinLine, &cpinResult);  
  10.   
  11.     //根据返回值得到当前SIM卡状态  
  12.     if (0 == strcmp (cpinResult, "SIM PIN")) {  
  13.         //PIN锁  
  14.         ret = SIM_PIN;  
  15.         goto done;  
  16.     } else if (0 == strcmp (cpinResult, "SIM PUK")) {  
  17.         //PUK锁  
  18.         ret = SIM_PUK;  
  19.         goto done;  
  20.     } else if (0 == strcmp (cpinResult, "PH-NET PIN")) {  
  21.         return SIM_NETWORK_PERSONALIZATION;  
  22.     } else if (0 != strcmp (cpinResult, "READY"))  {  
  23.         //SIM卡不存在  
  24.         ret = SIM_ABSENT;  
  25.         goto done;  
  26.     }  
  27. }  
    在getSIMStatus中，当我们从at_send_command_singleline中返回后，用Modem给的数据p_response->p_intermediates得到了当前SIM的状态。
    我们在往上层看，当初是在getCardStatus中调用getSIMStatus的：
[cpp] view plain copy
  1. static int getCardStatus(RIL_CardStatus_v6 **pp_card_status) {  
  2.     //SIM卡所有可能的状态  
  3.     static RIL_AppStatus app_status_array[] = {  
  4.         { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN,  
  5.           NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },  
  6.         { RIL_APPTYPE_SIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN,  
  7.           NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },  
  8.     };  
  9.   
  10.     //查询SIM状态，将AT命令发送到Modem，然后得到Modem的数据  
  11.     int sim_status = getSIMStatus();  
  12.     //得到返回值  
  13.     p_card_status->applications[0] = app_status_array[sim_status];  
  14.     p_card_status->applications[1] = app_status_array[sim_status + RUIM_ABSENT];  
  15.     //把返回值带回到上一级中  
  16.     *pp_card_status = p_card_status;  
  17.     return RIL_E_SUCCESS;  
  18. }  
    在这个函数中，我们通过getSIMStatus得到的int型数据，由app_status_array数组转换为各个更容易理解的状态，然后放入pp_card_status返回值中，返回给父一级。
[cpp] view plain copy
  1. @reference-ril.c  
  2. static void onRequest (int request, void *data, size_t datalen, RIL_Token t)  
  3. {  
  4.     switch (request) {  
  5.         case RIL_REQUEST_GET_SIM_STATUS: {  
  6.             RIL_CardStatus_v6 *p_card_status;  
  7.             char *p_buffer;  
  8.             int buffer_size;  
  9.             //与Modem交互，发送命令并得到回应  
  10.             int result = getCardStatus(&p_card_status);  
  11.             p_buffer = (char *)p_card_status;  
  12.             buffer_size = sizeof(*p_card_status);  
  13.             //把回应传回给Eventloop  
  14.             RIL_onRequestComplete(t, result, p_buffer, buffer_size);  
  15.             freeCardStatus(p_card_status);  
  16.             break;  
  17.         }  
  18.     }  
  19. }  
    这个函数就是当Eventloop中有请求时，我们把请求发送到注册的reference库的回调函数中，而reference的回调函数就是onRequest。在这里，当我们从getCardStatus返回后，就把数据转换为buffer，然后通过RIL_onRequestComplete重新返回给Eventloop，当我们去观察这个函数参数时，除了表示成功或失败的result和表示数据的buffer外，还有一个t，而这个t就是我们前面一再提到的令牌。当我们从RILJ发送数据时，就会把一个表示当前这个请求的的令牌传递下去，而当Modem返回数据后，我们再通过这个令牌找到当初发送的请求，然后把数据传递给他。接下来我们看这个函数的具体实现：
[cpp] view plain copy
  1. #define RIL_onRequestComplete(t, e, response, responselen) s_rilenv->OnRequestComplete(t,e, response, responselen)  
    我们看到，RIL_onRequestComplete就是s_rilenv的OnRequestComplete函数，而s_rilenv的来历我们在前面已经介绍过，他的各个处理函数都在ril.cpp中。
    因此，到这里，我们的流程就又走到了ril.cpp中的RIL_onRequestComplete里面。而从流程上来讲，我们就将从Modem得到的回应，又由reference库交接给了Event端。
    接下来要做的就是在Event侧把数据重新返回给RILJ。

3.4、Eventloop把数据返回给RILJ

    我们直接来看此时的接收函数：
[cpp] view plain copy
  1. @ril.cpp  
  2. void RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen) {  
  3.     RequestInfo *pRI;  
  4.     pRI = (RequestInfo *)t;  
  5.   
  6.     Parcel p;  
  7.     p.writeInt32 (RESPONSE_SOLICITED);  
  8.     p.writeInt32 (pRI->token);  
  9.     errorOffset = p.dataPosition();  
  10.     p.writeInt32 (e);  
  11.   
  12.     if (response != NULL) {  
  13.         //先调用当前请求的回调函数  
  14.         ret = pRI->pCI->responseFunction(p, response, responselen);  
  15.   
  16.         if (ret != 0) {  
  17.             p.setDataPosition(errorOffset);  
  18.             p.writeInt32 (ret);  
  19.         }  
  20.     }  
  21. 发送数据给RILJ  
  22.     sendResponse(p);  
  23. }  
    我们看到，在RILC发送数据给RILJ之前，会先调用当前命令的回应处理函数，也就是responseFunction，对将要传输的数据进行差异化处理，然后再通过sendResponse发送给RILJ。

    那么responseFunction函数的具体形式是什么呢？
    我们回顾一下，我们当初在接到RILJ的命令后，由Eventloop把命令交给reference之前,在processCommandBuffer中构建了用于在RILC层传输的RequestInfo数据类型，而构建这个数据的原理就是在ril_commands.h中查找当前命令所对应的两个回调函数，一个用于向reference传输时使用，另一个用于reference给Eventloop回应时使用。responseFunction指的就是第二个回调函数。

    {RIL_REQUEST_GET_SIM_STATUS, dispatchVoid, responseSimStatus},
    也就是说，发送到reference时我们需要调用dispatchVoid，而从reference接受Modem的回应时，我们就要从responseSimStatus进入了：

[cpp] view plain copy
  1. @ril.cpp  
  2. static int responseSimStatus(Parcel &p, void *response, size_t responselen) {  
  3.         RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response);  
  4.         p.writeInt32(p_cur->card_state);  
  5.         p.writeInt32(p_cur->universal_pin_state);  
  6.         p.writeInt32(p_cur->gsm_umts_subscription_app_index);  
  7.         p.writeInt32(p_cur->cdma_subscription_app_index);  
  8.         p.writeInt32(p_cur->ims_subscription_app_index);  
  9.   
  10.         sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications);  
  11. }  
    接下来：
[cpp] view plain copy
  1. static void sendSimStatusAppInfo(Parcel &p, int num_apps, RIL_AppStatus appStatus[]) {  
  2.         p.writeInt32(num_apps);  
  3.         startResponse;  
  4.         for (int i = 0; i < num_apps; i++) {  
  5.             p.writeInt32(appStatus[i].app_type);  
  6.             p.writeInt32(appStatus[i].app_state);  
  7.             p.writeInt32(appStatus[i].perso_substate);  
  8.             writeStringToParcel(p, (const char*)(appStatus[i].aid_ptr));  
  9.             writeStringToParcel(p, (const char*)(appStatus[i].app_label_ptr));  
  10.             p.writeInt32(appStatus[i].pin1_replaced);  
  11.             p.writeInt32(appStatus[i].pin1);  
  12.             p.writeInt32(appStatus[i].pin2);  
  13.         }  
  14.         closeResponse;  
  15. }  

    其实这里所谓的打包处理，不过是根据不同的命令，把相应的回应写入到给RILJ的返回数据包中。
    然后在RIL_onRequestComplete中调用sendResponse把数据发送到RILJ层。
    以上就是RIL数据传输的整个过程。
    现在，我们再来回顾一下在本文开始处展示的RIL层数据流向图，希望这次看到他时不会那么的陌生：



四、一些重要概念


4.1、s_commandcond

    我们知道，RIL是一个框架，并不会在意每个命令之间的差异，但是每个命令所发送的数据不同，要求的回应更是不同。而这个数组就是完成了从标准化到差异化的转换过程。
    先来看一下定义：
[cpp] view plain copy
  1. static CommandInfo s_commands[] = {  
  2.     #include "ril_commands.h"  
  3. };  
    以上这个变量定义在是一个数组，类型如下：
[cpp] view plain copy
  1. typedef struct {  
  2.     int requestNumber;  
  3.     void (*dispatchFunction) (Parcel &p, struct RequestInfo *pRI);  
  4.     int(*responseFunction) (Parcel &p, void *response, size_t responselen);  
  5. } CommandInfo;  
    这个结构体中有3个数据：requestNumber表示一个命令的请求码；dispatchFunction表示当前命令发送给reference库时的入口函数；而responseFunction表示reference给出应答后需要用这个函数对应答数据进行封装，然后传递给RILJ；
    主要内容如下：
[cpp] view plain copy
  1. {RIL_REQUEST_GET_SIM_STATUS, dispatchVoid, responseSimStatus},  
  2. {RIL_REQUEST_ENTER_SIM_PIN, dispatchStrings, responseInts},  
  3. {RIL_REQUEST_ENTER_SIM_PUK, dispatchStrings, responseInts},  
    结合到流程来说，当我们从Eventloop中读取一条RILJ发送的请求后，在Eventloop的发送最后（processCommandBuffer函数）根据当前命令去s_commands中查找相应的dispatchFunction和responseFunction，组成一个RequestInfo的数据。然后调用当前命令的dispatchFunction函数将RequestInfo数据发送给reference库。
    而当reference接收到Modem数据后，根据当前命令的RequestInfo信息，查找当前命令的应答回调（responseFunction）对回应数据进行封装，封装后调用统一的reference到Event侧的接口函数（RIL_onRequestComplete）把数据发送给Event侧，再由Event侧发送到RILJ。

4.2、s_unsolResponses

    对比上面的s_commands来看，这个变量就显得比较简单了。我们先来看一下他的定义：
[cpp] view plain copy
  1. static UnsolResponseInfo s_unsolResponses[] = {  
  2.     #include "ril_unsol_commands.h"  
  3. };  
    然后列出几个重要的数组内容
[cpp] view plain copy
  1. {RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED, responseVoid, WAKE_PARTIAL},  
  2. {RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, responseVoid, WAKE_PARTIAL},  
  3. {RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, responseVoid, WAKE_PARTIAL},  
    再来看数据类型：
[cpp] view plain copy
  1. typedef struct {  
  2.     int requestNumber;  
  3.     int (*responseFunction) (Parcel &p, void *response, size_t responselen);  
  4.     WakeType wakeType;  
  5. } UnsolResponseInfo;  
    这里我们看到，他和s_commands的区别就在于他的里面只有responseFunction而没有dispatchFunction。为什么会这样呢？原因就在于URC消息与非URC消息的区别上。
    上面我们讲到，非URC消息是由RILJ主动发起的并且需要接受Modem的数据；而URC消息是Modem主动上报的（比如网络状态改变的消息），因此没有发送的过程，只有接受消息的过程。因此不需要dispatchFunction。
    再次结合流程来看一下，当我们在reference的ReaderLoop中检测到Modem消息时，如果是URC消息，就在reference中根据AT命令头的不同转换为相应的命令号（onUnsolicited中完成），然后把数据发送给Event侧（RIL_onUnsolicitedResponse接收），在Event侧根据命令号的不同找到s_unsolResponses中对应的responseFunction，对数据进行不同的封装，然后发送给RILJ（仍在RIL_onUnsolicitedResponse中处理）。

4.3、RequestInfo

    这个数据类型是Event侧与reference侧协定的统一命令格式。所有的命令，当从Event侧发送到reference侧时，都要把他标准化为RequestInfo结构。
    数据结构：
[cpp] view plain copy
  1. typedef struct RequestInfo {  
  2.     int32_t token;  
  3.     CommandInfo *pCI;  
  4.     struct RequestInfo *p_next;  
  5.     char cancelled;  
  6.     char local;  
  7. } RequestInfo;  
    其中token是当前命令的令牌，相当于命令的ID。pCI的数据结构：
[cpp] view plain copy
  1. typedef struct {  
  2.     int requestNumber;  
  3.     void (*dispatchFunction) (Parcel &p, struct RequestInfo *pRI);  
  4.     int(*responseFunction) (Parcel &p, void *response, size_t responselen);  
  5. } CommandInfo;  
    这个数据表明了当前命令的3个很重要属性：1、当前命令的请求码；2、当前命令发送到reference侧的入口；3、当前命令从reference返回给Event侧时要调用responseFunction进行数据封装。


转至：http://blog.csdn.net/u010961631/article/details/9446377

tron
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android中RIL层详细分析
11-17
本文档对Android RIL部分的内容进行了介绍，其重点放在了Android RIL的原生代码部分。包括四个主题： 1.Android RIL框架介绍 2.Android RIL与WindowsMobile RIL 3.Android RIL porting 4.Android RIL的java框架
RIL层源码分析（原）
热门推荐
阿杜的专栏
07-24 1万+
写在前面     1、本文从宏观的角度去分析问题，因此忽略了一些非主线的函数。     2、同理，对于函数内部非主要的逻辑部分，也采取了省略。     3、受限于知识的积累和理解能力，文中描述如有分析不妥之处，希望能够得到大家更正。 从Main函数开始的故事     Android的智能机架构是应用处理器+基带芯片，也就是AP+Modem的模式，AP部分相当于CPU，Modem相当于网卡
Android Ril层浅析
无道子
12-09 1650
Android Ril层浅析          ril为Radio interface layer 的缩写, 翻译为协议转换层, 应用层通过ril层向串口发送命令,  串口之上为ril层, 串口之下为modem, ril层由rild进程负责, ril层代码目录为/hardware/ril          一, ril层向串口发送命令:           相关文件
（二） RIL 层分析
子夜的专栏
12-25 1023
Rild（RIL Interface Layer Daemon）是Init进程启动的一个本地服务，这个本地服务采用了socket的通讯方式。Android 给出了一个RIL实现框架。由于Android开发者使用的Modem是不一样的，各种指令格式，初始化序列都可能不一样，GSM和CDMA就差别更大 了，所以为了消除这些差别，Android设计者将ril做了一个抽象，使用一个虚拟电话的概念。这个虚拟
linux架构接口层教程,在LINUX平台上进行成功实现RIL层功能和框架层应用
weixin_36041939的博客
05-10 471
1.课题研究的背景和意义1.1 Android RIL简介Android RIL(Radio Interface Layer)提供了无线基带Modem与电话应用之间的抽象层.在Android RIL层中，完善的考虑了电话应用的各种情况，如：双SIM卡；电话，短信，彩信，PS DATA业务，PIN/PUK码等各种3G网络业务.RIL层在Android系统中，处于硬件抽象层，运行在一个独立的守护进程中...
Android源码Telephony 框架设计解析
01-15
一、RIL 3 二、Telephony中多卡及多运营商设计区分 6 1.telephony中的多卡 7 1)AP区分多卡 7 2)modem区分多卡 12 2.telephony中的多运营商设计 14 三、Telephony中AIDL模式设计 15 四、Telephony中观察者模式设计 16...
android精品源码
09-25
Android_RIL层剖析(官方翻译).doc Android与JUnit深入浅出.pdf Android中文翻译组——Android中文API合集（4）.pdf Android内存泄露调试.pdf android写的google map api 应用.zip Android实现GPS定位.pdf Android...
《深入理解Android》卷Ⅰ
04-30
2.3 Java层的MediaScanner分析 2.3.1 加载JNI库 2.3.2 Java的native函数和总结 2.4 JNI层MediaScanner的分析 2.4.1 注册JNI函数 2.4.2 数据类型转换 2.4.3 JNIEnv介绍 2.4.4 通过JNIEnv操作jobject 2.4.5 jstring...
深入理解Android卷1全
05-25
2.3 Java层的MediaScanner分析 / 16 2.3.1 加载JNI库 / 16 2.3.2 Java的native函数和总结 / 17 2.4 JNI层MediaScanner的分析 / 17 2.4.1 注册JNI函数 / 18 2.4.2 数据类型转换 / 22 2.4.3 JNIEnv介绍 / 24 2.4.4 ...
深入理解 Android Telephony原理剖析与最佳实践
05-05
第四部分（10~12章），对Android RIL的工作机制进行了深入的分析，包括对框架层中的RILJ运行机制的分析、对RILC系统结构及LibRIL运行机制的分析，以及对Reference-RIL框架的原理的分析；第五部分（13章），分析了...
移远4G模块最新ril库 V3.3.46版
09-03
支持android11
Andriod_7.x-arm64 RIL库_ril华为_华为909sRIL库_RIL_
10-04
这是华为909S的Android7.x RIL库
Android 8.0 RIL源码分析（二）
泊客
02-28 3251
非URC消息处理 之前分析到在at_send_command_full_nolock调用后会先发送消息给modem,然后阻塞当前线程等待modem返回消息。 因此也是在readerLoop的消息处理中去唤醒阻塞的线程，而且应该把数据直接返回给阻塞的线程，如之前ndroid 8.0 RIL框架分析，非URC消息会调用processLine方法。 1.这里跟进到processLine方法 ...
atchannel.c解析
运用之妙,存乎一心
03-09 5653
/* //device/system/reference-ril/atchannel.c ** ** Copyright 2006, The Android Open Source Project ** ** Licensed under the Apache License, Version 2.0 (the "License"); ** you may not use this file ex
MMS实现详细分析（BENQ M22模块*--（3）------MMS发送的无线网络连接协议分析
10-17 587
MMS发送的无线网络连接协议分析转载注明地址：http://hi.baidu.com/luv%5Fresplendent/blog/item/aa546efc91493987b901a0b3.html    MMS在进行发送前，要对无线模块进行无线网络连接，实现GPRS的拨号上网，无线网络连接成功后，才能利用无线模块基于WAP的方式对MMS进行发送，通过移动交换网络，最终发送到终端用户手机上。
Android电话系统rild-response analysis
ceko_wu的专栏
10-31 2112
本文将详细分析rild处理response的流程,包括一般的resonse和unsolicited response。 一、与request对应的response 1、Atchannel.c 启动readerloop，调用readline（），循环读取modem发来的消息 2、如果读到数据，调用processline（）进行处理，首先判断是否是unsolic
4G专网模块RIL层调试LOG分析
houyizi337825770的专栏
03-15 2933
系统版本:Android4.4D/RILJ ( 623): Starting RILReceiverI/RILJ ( 623): Connected to 'rild' socket =》RIL层log分析一般都是从rild已经连接开始D/RILJ ( 623): [UNSL]&lt; UNSOL_RIL_CONNECTED {9} =》一旦rild连接后,referen...
深入理解Android Telephony 之RILD机制分析
飞鸽传说的博客
01-01 3078
RILD负责modem和RILJ端的通信，信息分两种：unsolicited和solicited，前者是由modem主动上报的，诸如时区更新、通话状态、网络状态等消息，后者是RILJ端发请求并需要modem反馈的信息。RILJ与RILD之间的通信由主线程s_tid_dispatch负责监听，读取和分发，RILD与modem之间的通信由s_tid_mainloop和s_tid_reader负责写入和读
Android ril
最新发布
09-14
Android的RIL（Radio Interface Layer）是Android系统中与无线通信模块进行交互的接口层。RIL的本地代码位于Android/hardware/ril文件夹，包括三个子模块：rild、libril和reference-ril。 在MTK Android中，RIL也...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值