在android系统中rild运行在AP上，AP上的应用通过rild发送AT指令给BP，BP接收到信息后又通过rild传送给AP。AP与BP之间有两种通信方式：

1.Solicited Response:Ap向Bp发送请求，Bp给Ap发送回复,该类型的AT指令及其回调函数以数组的形式存放在Ril_commands.h文件中：

    {数组中的索引号，请求回调函数，响应回调函数}

2.unSolicited Response:Bp主动给Ap发送事件,该类型的AT指令及其回调函数以数组的形式存放在ril_unsol_commands.h文件中：

    {数组中的索引号，响应回调函数，类型}

不同手机厂商使用的AT命令不完全相同，为了保密，AP与BP之间通过各厂商自己的相关动态库来通信。

RIL模块由rild守护进程、libril.so、librefrence.so三部分组成：

  1.rild模块被编译为一个可执行文件，实现一个main函数作为整个ril模块的入口点。在初始化时使用dlopen打开librefrence_ril.so，从中取出并执行RIL_Init函数，得到RIL_RadioFunctions指针，通过RIL_register()函数注册到libril.so库中，其源码结构如下：

 2.libril.so是共享库，主要负责同上层的通信工作，接收ril的请求，并传递给librefrence_ril.so，同时将librefrence_ril.so返回的消息送给调用进程，源码结构如下所示：

3.librefrence_ril.so是由各手机厂商自己实现，在rild进程运行中通过dlopen方式加载，主要负责跟modem硬件通信，转换来自libril.so的请求为AT命令，同时监听Modem的反馈信息给libril.so

Android的电话系统主要分为三个部分，java层的各种电话相关应用，java层的Phone Service，主要为上层提供API，同时与native进行通信，可以看做为电话系统的客户端，native层的电话服务进程RILD，负责为上层提供各种电话功能服务，直接与modem进行交互：

Android电话系统设计框架图：

由于Android 开发者使用的Modem 是不一样的，各种指令格式，初始化序列都可能不一样，所以为了消除这些差别，Android 设计者将ril 做了一个抽象，使用一个虚拟电话的概念，不同modem相关的AT指令或者通信协议编译成相应的动态链接库.so文件，Rild 是具体的AT 指令合成者和应答解析者。

Android电话系统代码结构图：

RILD框架设计

在android的电话系统中，在native层实现了电话服务的服务端，由RILD服务与modem的交互，在java层实现电话的客户端，本文主要介绍电话系统的服务端RILD进程，以下是RILD的设计框架图：

RILD源码分析

接下来通过源码对RILD的整个框架进行详细介绍。

在kernel启动完成后，将启动第一个应用进程Init进程，在android之Init进程启动过程源码分析一文中对init进程的启动流程进行了详细的介绍。init进程在启动过程中将读取init.rc文件来启动一些重量级的native服务，rild进程就是通过配置在init.rc中来启动的。

RILD进程入口函数分析

接下来给出的是RILD进程启动的时序图：

hardware\ril\rild\rild.c

在main函数中主要完成以下工作:

1.解析命令行参数，通过判断是否为模拟器采取不同的方式来读取libreference-ril.so库的存放路径；

2.使用dlopen手动装载libreference-ril.so库；

3.启动事件循环处理；

4.从libreference-ril.so库中取得RIL_Init函数地址，并使用该函数将libril.so库中的RIL_Env接口注册到libreference-ril.so库，同时将libreference-ril.so库中的RIL_RadioFunctions接口注册到到libril.so库中，建立起libril.so库与libreference-ril.so库通信桥梁；

启动事件循环处理eventLoop工作线程

[cpp] view plaincopy

 

1. struct ril_event {  
2.     struct ril_event *next;  
3.     struct ril_event *prev;  
4.     int fd;  //文件句柄  
5.     int index; //该事件在监控表中的索引   
6.     bool persist; //如果是保持的，则不从watch_list 中删除  
7.     struct timeval timeout; //任务执行时间  
8.     ril_event_cb func; //回调事件处理函数  
9.     void *param; //回调时参数  
10. };  

在Rild进程中的几个重要事件有

[cpp] view plaincopy

 

1. static struct ril_event s_commands_event;  
2. ril_event_set (&s_commands_event, s_fdCommand, 1,processCommandsCallback, p_rs)  
3.   
4. static struct ril_event s_wakeupfd_event;  
5. ril_event_set (&s_wakeupfd_event, s_fdWakeupRead, true,processWakeupCallback, NULL)  
6.   
7. static struct ril_event s_listen_event;  
8. ril_event_set (&s_listen_event, s_fdListen, false,listenCallback, NULL)  
9.   
10. static struct ril_event s_wake_timeout_event;  
11. ril_timer_add(&(p_info->event), &myRelativeTime)；  

[cpp] view plaincopy

 

1. static struct ril_event s_debug_event;  
2. ril_event_set (&s_debug_event, s_fdDebug, true,debugCallback, NULL)  

在RILD中定义了三个事件队列，用于处理不同的事件：

/事件监控队列

static struct ril_event * watch_table[MAX_FD_EVENTS];

//定时事件队列

static struct ril_event timer_list;

//处理事件队列

static struct ril_event pending_list; //待处理事件队列，事件已经触发，需要所回调处理的事件

添加事件

1.添加Wakeup 事件

 

[cpp] view plaincopy

 

1. static void rilEventAddWakeup(struct ril_event *ev) {  
2.     ril_event_add(ev); //向监控表watch_table添加一个s_wakeupfd_event事件  
3.     triggerEvLoop(); //向管道s_fdWakeupWrite中写入之来触发事件循环  
4. }  

[cpp] view plaincopy

 

1. void ril_event_add(struct ril_event * ev)  
2. {  
3.     dlog("~~~~ +ril_event_add ~~~~");  
4.     MUTEX_ACQUIRE();  
5.     for (int i = 0; i < MAX_FD_EVENTS; i++) { //遍历监控表watch_table  
6.         if (watch_table[i] == NULL) { //从监控表中查找空闲的索引，然后把该任务加入到监控表中  
7.             watch_table[i] = ev; //向监控表中添加事件  
8.             ev->index = i; //事件的索引设置为在监控表中的索引  
9.             dlog("~~~~ added at %d ~~~~", i);  
10.             dump_event(ev);  
11.             FD_SET(ev->fd, &readFds); //将添加的事件对应的句柄添加到句柄池readFds中  
12.             if (ev->fd >= nfds) nfds = ev->fd+1; //修改句柄最大值  
13.             dlog("~~~~ nfds = %d ~~~~", nfds);  
14.             break;  
15.         }  
16.     }  
17.     MUTEX_RELEASE();  
18.     dlog("~~~~ -ril_event_add ~~~~");  
19. }  

2.添加定时事件

[cpp] view plaincopy

 

1. void ril_timer_add(struct ril_event * ev, struct timeval * tv)  
2. {  
3.     dlog("~~~~ +ril_timer_add ~~~~");  
4.     MUTEX_ACQUIRE();  
5.     struct ril_event * list;  
6.     if (tv != NULL) {  
7.         list = timer_list.next;  
8.         ev->fd = -1; // make sure fd is invalid  
9.         struct timeval now;  
10.         getNow(&now);  
11.         timeradd(&now, tv, &ev->timeout);  
12.         // keep list sorted  
13.         while (timercmp(&list->timeout, &ev->timeout, < ) && (list != &timer_list)) {  
14.             list = list->next;  
15.         }  
16.         // list now points to the first event older than ev  
17.         addToList(ev, list);  
18.     }  
19.     MUTEX_RELEASE();  
20.     dlog("~~~~ -ril_timer_add ~~~~");  
21. }  

触发事件

[cpp] view plaincopy

 

1. static void triggerEvLoop() {  
2.     int ret;  
3. 　　if (!pthread_equal(pthread_self(), s_tid_dispatch)) { //如果当前线程ID不等于事件分发线程eventLoop的线程ID  
4.       do {  
5.             ret = write (s_fdWakeupWrite, " ", 1); //向管道写端写入值1来触发eventLoop事件循环  
6.          } while (ret < 0 && errno == EINTR);  
7.     }  
8. }  

处理事件

[cpp] view plaincopy

 

1. void ril_event_loop()  
2. {  
3.     int n;  
4.     fd_set rfds;  
5.     struct timeval tv;  
6.     struct timeval * ptv;  
7.     for (;;) {  
8.         memcpy(&rfds, &readFds, sizeof(fd_set));  
9.         if (-1 == calcNextTimeout(&tv)) {  
10.             dlog("~~~~ no timers; blocking indefinitely ~~~~");  
11.             ptv = NULL;  
12.         } else {  
13.             dlog("~~~~ blocking for %ds + %dus ~~~~", (int)tv.tv_sec, (int)tv.tv_usec);  
14.             ptv = &tv;  
15.         }  
16.         //使用select 函数等待在FDS 上,只要FDS 中记录的设备有数据到来，select 就会设置相应的标志位并返回。readFDS 记录了所有的事件相关设备句柄。readFDS 中句柄是在在AddEvent 加入的。  
17.         printReadies(&rfds);  
18.         n = select(nfds, &rfds, NULL, NULL, ptv);   
19.         printReadies(&rfds);  
20.         dlog("~~~~ %d events fired ~~~~", n);  
21.         if (n < 0) {  
22.             if (errno == EINTR) continue;  
23.             LOGE("ril_event: select error (%d)", errno);  
24.             return;  
25.         }  
26.         processTimeouts(); //从timer_list中查询执行时间已到的事件，并添加到pending_list中  
27.         processReadReadies(&rfds, n); //从watch_table中查询数据可读的事件，并添加到pending_list中去处理，如果该事件不是持久事件，则同时从watch_table中删除  
28.         //遍历pending_list，调用事件处理回调函数处理所有事件  
29.         firePending();  
30.     }  
31. }  

在eventLoop工作线程中，循环处理到来的事件及定时结束事件，整个处理流程如下图所示：

首先通过Linux中的select多路I/O复用对句柄池中的所有句柄进行监控，当有事件到来时select返回，否则阻塞。当select返回时，表示有事件的到来，通过调用processTimeouts函数来处理超时事件，处理方式是遍历time_list链表以查询超时事件，并将超时事件移入到pending_list链表中，接着调用processReadReadies函数来处理触发的事件，处理方式为遍历watch_table列表以查询触发的事件，并将触发的事件移入到pending_list链表中，如果该事件不是持久事件，还需要从watch_table列表中移除，当查询完两种待处理的事件并放入到pending_list链表中后，调用firePending函数对待处理的事件进行集中处理，处理方式为遍历链表，调用每一个事件的回调函数。

 

 1.超时事件查询

[cpp] view plaincopy

 

1. static void processTimeouts()  
2. {  
3.     dlog("~~~~ +processTimeouts ~~~~");  
4.     MUTEX_ACQUIRE();  
5.     struct timeval now;  
6.     struct ril_event * tev = timer_list.next;  
7.     struct ril_event * next;  
8.     getNow(&now); //获取当前时间  
9. 　　dlog("~~~~ Looking for timers <= %ds + %dus ~~~~", (int)now.tv_sec, (int)now.tv_usec);  
10. 　　//如果当前时间大于事件的超时时间，则将该事件从timer_list中移除，添加到pending_list  
11.     while ((tev != &timer_list) && (timercmp(&now, &tev->timeout, >))) {  
12.         dlog("~~~~ firing timer ~~~~");  
13.         next = tev->next;  
14.         removeFromList(tev); //从timer_list中移除事件  
15.         addToList(tev, &pending_list); //将事件添加到pending_list  
16.         tev = next;  
17.     }  
18.     MUTEX_RELEASE();  
19.     dlog("~~~~ -processTimeouts ~~~~");  
20. }  

2.可读事件查询

[cpp] view plaincopy

 

1. static void processReadReadies(fd_set * rfds, int n)  
2. {  
3.     dlog("~~~~ +processReadReadies (%d) ~~~~", n);  
4. 　　MUTEX_ACQUIRE();   
5. 　　//遍历watch_table数组，根据select返回的句柄n查找对应的事件  
6.     for (int i = 0; (i < MAX_FD_EVENTS) && (n > 0); i++) {  
7.         struct ril_event * rev = watch_table[i]; //得到相应的事件  
8.         if (rev != NULL && FD_ISSET(rev->fd, rfds)) {  
9.             addToList(rev, &pending_list); //将该事件添加到pending_list中  
10.             if (rev->persist == false) { //如果该事件不是持久事件还要从watch_table中移除  
11.                 removeWatch(rev, i);  
12.             }  
13.             n--;  
14.         }  
15.     }  
16.     MUTEX_RELEASE();  
17.     dlog("~~~~ -processReadReadies (%d) ~~~~", n);  
18. }  

3.事件处理

[cpp] view plaincopy

 

1. static void firePending()  
2. {  
3.     dlog("~~~~ +firePending ~~~~");  
4.     struct ril_event * ev = pending_list.next;  
5.     while (ev != &pending_list) { //遍历pending_list链表，处理链表中的所有事件  
6.         struct ril_event * next = ev->next;  
7.         removeFromList(ev); //将处理完的事件从pending_list中移除  
8.         ev->func(ev->fd, 0, ev->param); //调用事件处理的回调函数  
9.         ev = next;  
10.     }  
11.     dlog("~~~~ -firePending ~~~~");  
12. }  

RIL_Env定义

hardware\ril\include\telephony\ril.h

[cpp] view plaincopy

 

1. struct RIL_Env {  
2.     //动态库完成请求后通知处理结果的接口  
3. 　　void (*OnRequestComplete)(RIL_Token t, RIL_Errno e,void *response, size_t responselen);  
4.     //动态库unSolicited Response通知接口  
5. 　　void (*OnUnsolicitedResponse)(int unsolResponse, const void *data,size_t datalen);  
6.     //向Rild提交一个超时任务的接口  
7.     void (*RequestTimedCallback) (RIL_TimedCallback callback,void *param, const struct timeval *relativeTime);  
8. };  

hardware\ril\rild\rild.c

s_rilEnv变量定义：

[cpp] view plaincopy

 

1. static struct RIL_Env s_rilEnv = {  
2.     RIL_onRequestComplete,  
3.     RIL_onUnsolicitedResponse,  
4.     RIL_requestTimedCallback  
5. };  

在hardware\ril\libril\ril.cpp中实现了RIL_Env的各个接口函数

1.RIL_onRequestComplete

[cpp] view plaincopy

 

1. extern "C" void RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen) {  
2.     RequestInfo *pRI;  
3.     int ret;  
4.     size_t errorOffset;  
5.     pRI = (RequestInfo *)t;  
6.     if (!checkAndDequeueRequestInfo(pRI)) {  
7.         LOGE ("RIL_onRequestComplete: invalid RIL_Token");  
8.         return;  
9.     }  
10.     if (pRI->local > 0) {  
11.         // Locally issued command...void only!  
12.         // response does not go back up the command socket  
13.         LOGD("C[locl]< %s", requestToString(pRI->pCI->requestNumber));  
14.         goto done;  
15.     }  
16.     appendPrintBuf("[%04d]< %s",pRI->token, requestToString(pRI->pCI->requestNumber));  
17.     if (pRI->cancelled == 0) {  
18.         Parcel p;  
19.         p.writeInt32 (RESPONSE_SOLICITED);  
20.         p.writeInt32 (pRI->token);  
21.         errorOffset = p.dataPosition();  
22.         p.writeInt32 (e);  
23.         if (response != NULL) {  
24.             // there is a response payload, no matter success or not.  
25.             ret = pRI->pCI->responseFunction(p, response, responselen);  
26.             /* if an error occurred, rewind and mark it */  
27.             if (ret != 0) {  
28.                 p.setDataPosition(errorOffset);  
29.                 p.writeInt32 (ret);  
30.             }  
31.         }  
32.         if (e != RIL_E_SUCCESS) {  
33.             appendPrintBuf("%s fails by %s", printBuf, failCauseToString(e));  
34.         }  
35.         if (s_fdCommand < 0) {  
36.             LOGD ("RIL onRequestComplete: Command channel closed");  
37.         }  
38.         sendResponse(p);  
39.     }  
40. done:  
41.     free(pRI);  
42. }  

通过调用responseXXX将底层响应传给客户进程

2.RIL_onUnsolicitedResponse

[cpp] view plaincopy

 

1. extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, void *data,  
2.                                 size_t datalen)  
3. {  
4.     int unsolResponseIndex;  
5.     int ret;  
6.     int64_t timeReceived = 0;  
7.     bool shouldScheduleTimeout = false;  
8.     if (s_registerCalled == 0) {  
9.         // Ignore RIL_onUnsolicitedResponse before RIL_register  
10.         LOGW("RIL_onUnsolicitedResponse called before RIL_register");  
11.         return;  
12.     }  
13.     unsolResponseIndex = unsolResponse - RIL_UNSOL_RESPONSE_BASE;  
14.     if ((unsolResponseIndex < 0)  
15.         || (unsolResponseIndex >= (int32_t)NUM_ELEMS(s_unsolResponses))) {  
16.         LOGE("unsupported unsolicited response code %d", unsolResponse);  
17.         return;  
18.     }  
19.     // Grab a wake lock if needed for this reponse,  
20.     // as we exit we‘ll either release it immediately  
21.     // or set a timer to release it later.  
22.     switch (s_unsolResponses[unsolResponseIndex].wakeType) {  
23.         case WAKE_PARTIAL:  
24.             grabPartialWakeLock();  
25.             shouldScheduleTimeout = true;  
26.         break;  
27.         case DONT_WAKE:  
28.         default:  
29.             // No wake lock is grabed so don‘t set timeout  
30.             shouldScheduleTimeout = false;  
31.             break;  
32.     }  
33.     // Mark the time this was received, doing this  
34.     // after grabing the wakelock incase getting  
35.     // the elapsedRealTime might cause us to goto  
36.     // sleep.  
37.     if (unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) {  
38.         timeReceived = elapsedRealtime();  
39.     }  
40.     appendPrintBuf("[UNSL]< %s", requestToString(unsolResponse));  
41.     Parcel p;  
42.     p.writeInt32 (RESPONSE_UNSOLICITED);  
43.     p.writeInt32 (unsolResponse);  
44.     ret = s_unsolResponses[unsolResponseIndex].responseFunction(p, data, datalen);  
45.     if (ret != 0) {  
46.         // Problem with the response. Don‘t continue;  
47.         goto error_exit;  
48.     }  
49.     // some things get more payload  
50.     switch(unsolResponse) {  
51.         case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED:  
52.             p.writeInt32(s_callbacks.onStateRequest());  
53.             appendPrintBuf("%s {%s}", printBuf,  
54.                 radioStateToString(s_callbacks.onStateRequest()));  
55.         break;  
56.         case RIL_UNSOL_NITZ_TIME_RECEIVED:  
57.             // Store the time that this was received so the  
58.             // handler of this message can account for  
59.             // the time it takes to arrive and process. In  
60.             // particular the system has been known to sleep  
61.             // before this message can be processed.  
62.             p.writeInt64(timeReceived);  
63.         break;  
64.     }  
65.     ret = sendResponse(p);  
66.     if (ret != 0 && unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) {  
67.         // Unfortunately, NITZ time is not poll/update like everything  
68.         // else in the system. So, if the upstream client isn‘t connected,  
69.         // keep a copy of the last NITZ response (with receive time noted  
70.         // above) around so we can deliver it when it is connected  
71.         if (s_lastNITZTimeData != NULL) {  
72.             free (s_lastNITZTimeData);  
73.             s_lastNITZTimeData = NULL;  
74.         }  
75.         s_lastNITZTimeData = malloc(p.dataSize());  
76.         s_lastNITZTimeDataSize = p.dataSize();  
77.         memcpy(s_lastNITZTimeData, p.data(), p.dataSize());  
78.     }  
79.     // For now, we automatically go back to sleep after TIMEVAL_WAKE_TIMEOUT  
80.     // FIXME The java code should handshake here to release wake lock  
81.     if (shouldScheduleTimeout) {  
82.         // Cancel the previous request  
83.         if (s_last_wake_timeout_info != NULL) {  
84.             s_last_wake_timeout_info->userParam = (void *)1;  
85.         }  
86.         s_last_wake_timeout_info= internalRequestTimedCallback(wakeTimeoutCallback, NULL,  
87.                                             &TIMEVAL_WAKE_TIMEOUT);  
88.     }  
89.     return;  
90. error_exit:  
91.     if (shouldScheduleTimeout) {  
92.         releaseWakeLock();  
93.     }  
94. }  

这个函数处理modem从网络端接收到的各种事件，如网络信号变化，拨入的电话，收到短信等。然后传给客户进程。

3.RIL_requestTimedCallback

[cpp] view plaincopy

 

1. extern "C" void RIL_requestTimedCallback (RIL_TimedCallback callback, void *param,  
2.                                 const struct timeval *relativeTime) {  
3.     internalRequestTimedCallback (callback, param, relativeTime);  
4. }  

[cpp] view plaincopy

 

1. static UserCallbackInfo *internalRequestTimedCallback (RIL_TimedCallback callback, void *param,  
2.                                 const struct timeval *relativeTime)  
3. {  
4.     struct timeval myRelativeTime;  
5.     UserCallbackInfo *p_info;  
6.     p_info = (UserCallbackInfo *) malloc (sizeof(UserCallbackInfo));  
7.     p_info->p_callback = callback;  
8.     p_info->userParam = param;  
9.     if (relativeTime == NULL) {  
10.         /* treat null parameter as a 0 relative time */  
11.         memset (&myRelativeTime, 0, sizeof(myRelativeTime));  
12.     } else {  
13.         /* FIXME I think event_add‘s tv param is really const anyway */  
14.         memcpy (&myRelativeTime, relativeTime, sizeof(myRelativeTime));  
15.     }  
16.     ril_event_set(&(p_info->event), -1, false, userTimerCallback, p_info);  
17.     ril_timer_add(&(p_info->event), &myRelativeTime);  
18.     triggerEvLoop();  
19.     return p_info;  
20. }  

RIL_RadioFunctions定义

客户端向Rild发送请求的接口，由各手机厂商实现。

hardware\ril\include\telephony\Ril.h 

[cpp] view plaincopy

 

1. typedef struct {  
2.     int version; //Rild版本  
3.     RIL_RequestFunc onRequest; //AP请求接口  
4.     RIL_RadioStateRequest onStateRequest;//BP状态查询  
5.     RIL_Supports supports;  
6.     RIL_Cancel onCancel;  
7.     RIL_GetVersion getVersion;//动态库版本  
8. } RIL_RadioFunctions;  

变量定义：

[cpp] view plaincopy

 

1. static const RIL_RadioFunctions s_callbacks = {  
2.     RIL_VERSION,  
3.     onRequest,  
4.     currentState,  
5.     onSupports,  
6.     onCancel,  
7.     getVersion  
8. };  

在hardware\ril\reference-ril\reference-ril.c中实现了RIL_RadioFunctions的各个接口函数

1.onRequest

[cpp] view plaincopy

 

1. static void onRequest (int request, void *data, size_t datalen, RIL_Token t)  
2. {  
3.     ATResponse *p_response;  
4.     int err;  
5.     LOGD("onRequest: %s", requestToString(request));  
6.     /* Ignore all requests except RIL_REQUEST_GET_SIM_STATUS 
7.      * when RADIO_STATE_UNAVAILABLE. 
8.      */  
9.     if (sState == RADIO_STATE_UNAVAILABLE  
10.         && request != RIL_REQUEST_GET_SIM_STATUS  
11.     ) {  
12.         RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);  
13.         return;  
14.     }  
15.     /* Ignore all non-power requests when RADIO_STATE_OFF 
16.      * (except RIL_REQUEST_GET_SIM_STATUS) 
17.      */  
18.     if (sState == RADIO_STATE_OFF&& !(request == RIL_REQUEST_RADIO_POWER  
19.             || request == RIL_REQUEST_GET_SIM_STATUS)  
20.     ) {  
21.         RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);  
22.         return;  
23.     }  
24.     switch (request) {  
25.         case RIL_REQUEST_GET_SIM_STATUS: {  
26.             RIL_CardStatus *p_card_status;  
27.             char *p_buffer;  
28.             int buffer_size;  
29.             int result = getCardStatus(&p_card_status);  
30.             if (result == RIL_E_SUCCESS) {  
31.                 p_buffer = (char *)p_card_status;  
32.                 buffer_size = sizeof(*p_card_status);  
33.             } else {  
34.                 p_buffer = NULL;  
35.                 buffer_size = 0;  
36.             }  
37.             RIL_onRequestComplete(t, result, p_buffer, buffer_size);  
38.             freeCardStatus(p_card_status);  
39.             break;  
40.         }  
41.         case RIL_REQUEST_GET_CURRENT_CALLS:  
42.             requestGetCurrentCalls(data, datalen, t);  
43.             break;  
44.         case RIL_REQUEST_DIAL:  
45.             requestDial(data, datalen, t);  
46.             break;  
47.         case RIL_REQUEST_HANGUP:  
48.             requestHangup(data, datalen, t);  
49.             break;  
50.         case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND:  
51.             // 3GPP 22.030 6.5.5  
52.             // "Releases all held calls or sets User Determined User Busy  
53.             //  (UDUB) for a waiting call."  
54.             at_send_command("AT+CHLD=0", NULL);  
55.             /* success or failure is ignored by the upper layer here. 
56.                it will call GET_CURRENT_CALLS and determine success that way */  
57.             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);  
58.             break;  
59.         case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND:  
60.             // 3GPP 22.030 6.5.5  
61.             // "Releases all active calls (if any exist) and accepts  
62.             //  the other (held or waiting) call."  
63.             at_send_command("AT+CHLD=1", NULL);  
64.             /* success or failure is ignored by the upper layer here. 
65.                it will call GET_CURRENT_CALLS and determine success that way */  
66.             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);  
67.             break;  
68.         case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE:  
69.             // 3GPP 22.030 6.5.5  
70.             // "Places all active calls (if any exist) on hold and accepts  
71.             //  the other (held or waiting) call."  
72.             at_send_command("AT+CHLD=2", NULL);  
73.   
74. #ifdef WORKAROUND_ERRONEOUS_ANSWER  
75.             s_expectAnswer = 1;  
76. #endif /* WORKAROUND_ERRONEOUS_ANSWER */  
77.             /* success or failure is ignored by the upper layer here. 
78.                it will call GET_CURRENT_CALLS and determine success that way */  
79.             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);  
80.             break;  
81.         case RIL_REQUEST_ANSWER:  
82.             at_send_command("ATA", NULL);  
83. #ifdef WORKAROUND_ERRONEOUS_ANSWER  
84.             s_expectAnswer = 1;  
85. #endif /* WORKAROUND_ERRONEOUS_ANSWER */  
86.             /* success or failure is ignored by the upper layer here. 
87.                it will call GET_CURRENT_CALLS and determine success that way */  
88.             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);  
89.             break;  
90.         case RIL_REQUEST_CONFERENCE:  
91.             // 3GPP 22.030 6.5.5  
92.             // "Adds a held call to the conversation"  
93.             at_send_command("AT+CHLD=3", NULL);  
94.             /* success or failure is ignored by the upper layer here. 
95.                it will call GET_CURRENT_CALLS and determine success that way */  
96.             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);  
97.             break;  
98.         case RIL_REQUEST_UDUB:  
99.             /* user determined user busy */  
100.             /* sometimes used: ATH */  
101.             at_send_command("ATH", NULL);  
102.             /* success or failure is ignored by the upper layer here. 
103.                it will call GET_CURRENT_CALLS and determine success that way */  
104.             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);  
105.             break;  
106.         case RIL_REQUEST_SEPARATE_CONNECTION:  
107.             {  
108.                 char  cmd[12];  
109.                 int   party = ((int*)data)[0];  
110.                 // Make sure that party is in a valid range.  
111.                 // (Note: The Telephony middle layer imposes a range of 1 to 7.  
112.                 // It‘s sufficient for us to just make sure it‘s single digit.)  
113.                 if (party > 0 && party < 10) {  
114.                     sprintf(cmd, "AT+CHLD=2%d", party);  
115.                     at_send_command(cmd, NULL);  
116.                     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);  
117.                 } else {  
118.                     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);  
119.                 }  
120.             }  
121.             break;  
122.         case RIL_REQUEST_SIGNAL_STRENGTH:  
123.             requestSignalStrength(data, datalen, t);  
124.             break;  
125.         case RIL_REQUEST_REGISTRATION_STATE:  
126.         case RIL_REQUEST_GPRS_REGISTRATION_STATE:  
127.             requestRegistrationState(request, data, datalen, t);  
128.             break;  
129.         case RIL_REQUEST_OPERATOR:  
130.             requestOperator(data, datalen, t);  
131.             break;  
132.         case RIL_REQUEST_RADIO_POWER:  
133.             requestRadioPower(data, datalen, t);  
134.             break;  
135.         case RIL_REQUEST_DTMF: {  
136.             char c = ((char *)data)[0];  
137.             char *cmd;  
138.             asprintf(&cmd, "AT+VTS=%c", (int)c);  
139.             at_send_command(cmd, NULL);  
140.             free(cmd);  
141.             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);  
142.             break;  
143.         }  
144.         case RIL_REQUEST_SEND_SMS:  
145.             requestSendSMS(data, datalen, t);  
146.             break;  
147.         case RIL_REQUEST_SETUP_DATA_CALL:  
148.             requestSetupDataCall(data, datalen, t);  
149.             break;  
150.         case RIL_REQUEST_SMS_ACKNOWLEDGE:  
151.             requestSMSAcknowledge(data, datalen, t);  
152.             break;  
153.         case RIL_REQUEST_GET_IMSI:  
154.             p_response = NULL;  
155.             err = at_send_command_numeric("AT+CIMI", &p_response);  
156.             if (err < 0 || p_response->success == 0) {  
157.                 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);  
158.             } else {  
159.                 RIL_onRequestComplete(t, RIL_E_SUCCESS,  
160.                     p_response->p_intermediates->line, sizeof(char *));  
161.             }  
162.             at_response_free(p_response);  
163.             break;  
164.         case RIL_REQUEST_GET_IMEI:  
165.             p_response = NULL;  
166.             err = at_send_command_numeric("AT+CGSN", &p_response);  
167.   
168.             if (err < 0 || p_response->success == 0) {  
169.                 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);  
170.             } else {  
171.                 RIL_onRequestComplete(t, RIL_E_SUCCESS,  
172.                     p_response->p_intermediates->line, sizeof(char *));  
173.             }  
174.             at_response_free(p_response);  
175.             break;  
176.         case RIL_REQUEST_SIM_IO:  
177.             requestSIM_IO(data,datalen,t);  
178.             break;  
179.         case RIL_REQUEST_SEND_USSD:  
180.             requestSendUSSD(data, datalen, t);  
181.             break;  
182.         case RIL_REQUEST_CANCEL_USSD:  
183.             p_response = NULL;  
184.             err = at_send_command_numeric("AT+CUSD=2", &p_response);  
185.             if (err < 0 || p_response->success == 0) {  
186.                 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);  
187.             } else {  
188.                 RIL_onRequestComplete(t, RIL_E_SUCCESS,  
189.                     p_response->p_intermediates->line, sizeof(char *));  
190.             }  
191.             at_response_free(p_response);  
192.             break;  
193.         case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC:  
194.             at_send_command("AT+COPS=0", NULL);  
195.             break;  
196.         case RIL_REQUEST_DATA_CALL_LIST:  
197.             requestDataCallList(data, datalen, t);  
198.             break;  
199.         case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE:  
200.             requestQueryNetworkSelectionMode(data, datalen, t);  
201.             break;  
202.         case RIL_REQUEST_OEM_HOOK_RAW:  
203.             // echo back data  
204.             RIL_onRequestComplete(t, RIL_E_SUCCESS, data, datalen);  
205.             break;  
206.         case RIL_REQUEST_OEM_HOOK_STRINGS: {  
207.             int i;  
208.             const char ** cur;  
209.             LOGD("got OEM_HOOK_STRINGS: 0x%8p %lu", data, (long)datalen);  
210.             for (i = (datalen / sizeof (char *)), cur = (const char **)data ;  
211.                     i > 0 ; cur++, i --) {  
212.                 LOGD("> ‘%s‘", *cur);  
213.             }  
214.             // echo back strings  
215.             RIL_onRequestComplete(t, RIL_E_SUCCESS, data, datalen);  
216.             break;  
217.         }  
218.         case RIL_REQUEST_WRITE_SMS_TO_SIM:  
219.             requestWriteSmsToSim(data, datalen, t);  
220.             break;  
221.         case RIL_REQUEST_DELETE_SMS_ON_SIM: {  
222.             char * cmd;  
223.             p_response = NULL;  
224.             asprintf(&cmd, "AT+CMGD=%d", ((int *)data)[0]);  
225.             err = at_send_command(cmd, &p_response);  
226.             free(cmd);  
227.             if (err < 0 || p_response->success == 0) {  
228.                 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);  
229.             } else {  
230.                 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);  
231.             }  
232.             at_response_free(p_response);  
233.             break;  
234.         }  
235.         case RIL_REQUEST_ENTER_SIM_PIN:  
236.         case RIL_REQUEST_ENTER_SIM_PUK:  
237.         case RIL_REQUEST_ENTER_SIM_PIN2:  
238.         case RIL_REQUEST_ENTER_SIM_PUK2:  
239.         case RIL_REQUEST_CHANGE_SIM_PIN:  
240.         case RIL_REQUEST_CHANGE_SIM_PIN2:  
241.             requestEnterSimPin(data, datalen, t);  
242.             break;  
243.         case RIL_REQUEST_GSM_SMS_BROADCAST_ACTIVATION:  
244.             requestSmsBroadcastActivation(0,data, datalen, t);  
245.             break;  
246.         case RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG:  
247.              LOGD("onRequest RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG");  
248.             requestSetSmsBroadcastConfig(0,data, datalen, t);  
249.             break;  
250.         case RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG:  
251.             requestGetSmsBroadcastConfig(0,data, datalen, t);  
252.             break;  
253.         default:  
254.             RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);  
255.             break;  
256.     }  
257. }  

对每一个RIL_REQUEST_XXX请求转化成相应的ATcommand，发送给modem，然后睡眠等待，当收到ATcommand的最终响应后，线程被唤醒，将响应传给客户端进程。

2.currentState

[cpp] view plaincopy

 

1. static RIL_RadioState currentState()  
2. {  
3.     return sState;  
4. }  

3.onSupports

[cpp] view plaincopy

 

1. static int onSupports (int requestCode)  
2. {  
3.     //@@@ todo  
4.     return 1;  
5. }  

4.onCancel

[cpp] view plaincopy

 

1. static void onCancel (RIL_Token t)  
2. {  
3.     //@@@todo  
4. }  

5.getVersion

[cpp] view plaincopy

 

1. static const char * getVersion(void)  
2. {  
3.     return "android reference-ril 1.0";  
4. }  

注册RIL_Env接口

由于各手机厂商的AT指令差异，因此与modem交互层需要各手机厂商实现，以动态库的形式提供。作为介于modem与上层的中间层，即要与底层交互也要与上层通信，因此就需要定义一个接口来衔接RILD与动态库，RIL_Env和RIL_RadioFunctions接口就是libril.so与librefrence.so通信的桥梁。是Rild架构中用于隔离通用代码和厂商代码的接口，RIL_Env由通用代码实现，而RIL_RadioFunctions则是由厂商代码实现。


RIL_Init的主要任务：

1. 向librefrence.so注册libril.so提供的接口RIL_Env；

2. 创建一个mainLoop工作线程，用于初始化AT模块，并监控AT模块的状态，一旦AT被关闭，则重新打开并初始化AT；

3. 当AT被打开后，mainLoop工作线程将向Rild提交一个定时事件，并触发eventLoop来完成对modem的初始化；

4. 创建一个readLoop工作线程，用于从AT串口中读取数据；

5.返回librefrence.so提供的接口RIL_RadioFunctions；

hardware\ril\reference-ril\reference-ril.c

mainLoop工作线程是用来初始化并监控AT模块的，一旦AT模块被关闭，就自动打开。

1.打开AT模块

通过at_open打开文件描述符为fd的AT串口设备，并注册回调函数ATUnsolHandler 

2.添加定时事件RIL_requestTimedCallback

向定时事件队列中添加一个定时事件，该事件的处理函数为initializeCallback，用于发送一些AT指令来初始化BP的modem。

3.readLoop工作线程

Read loop 解析从Modem 发过来的回应。如果遇到URC 则通过handleUnsolicited 上报的RIL_JAVA。如果是命令的应答，则通过handleFinalResponse 通知send_at_command 有应答结果。

[cpp] view plaincopy

 

1. static void *readerLoop(void *arg)  
2. {  
3.     for (;;) {  
4.         const char * line;  
5.         line = readline();  
6.         if (line == NULL) {  
7.             break;  
8.         }  
9.         if(isSMSUnsolicited(line)) { //判断是否是SMS 通知  
10.             char *line1;  
11.             const char *line2;  
12.             line1 = strdup(line);  
13.             line2 = readline();  
14.             if (line2 == NULL) {  
15.                 break;  
16.             }  
17.             if (s_unsolHandler != NULL) {  
18.                 s_unsolHandler (line1, line2); //回调通知SMS  
19.             }  
20.             free(line1);  
21.         } else {  
22.             processLine(line); //处理接收到的数据，根据line中的指令调用不同的回调函数  
23.         }  
24. #ifdef HAVE_ANDROID_OS  
25.         if (s_ackPowerIoctl > 0) {  
26.             /* acknowledge that bytes have been read and processed */  
27.             ioctl(s_fd, OMAP_CSMI_TTY_ACK, &s_readCount);  
28.             s_readCount = 0;  
29.         }  
30. #endif /*HAVE_ANDROID_OS*/  
31.     }  
32.     onReaderClosed();  
33.     return NULL;  
34. }  

注册RIL_RadioFunctions接口

hardware\ril\libril\ril.cpp

[cpp] view plaincopy

 

1. extern "C" void RIL_register (const RIL_RadioFunctions *callbacks) {  
2.     int ret;  
3. 　　int flags;  
4. 　　//版本验证  
5.     if (callbacks == NULL || ((callbacks->version != RIL_VERSION)&& (callbacks->version < 2))) {   
6.         return;  
7.     }  
8.     if (callbacks->version < RIL_VERSION) {  
9.         LOGE ("RIL_register: upgrade RIL to version %d current version=%d",  
10.               RIL_VERSION, callbacks->version);  
11.     }  
12.     if (s_registerCalled > 0) {  
13.         LOGE("RIL_register has been called more than once. "Subsequent call ignored");  
14.         return;  
15. 　　}  
16.     //将reference-ril.c中定义的RIL_RadioFunctions注册到ril.cpp中  
17.     memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));  
18.     s_registerCalled = 1;  
19.     for (int i = 0; i < (int)NUM_ELEMS(s_commands); i++) {  
20.         assert(i == s_commands[i].requestNumber); //序号验证  
21.     }  
22.     for (int i = 0; i < (int)NUM_ELEMS(s_unsolResponses); i++) {  
23.         assert(i + RIL_UNSOL_RESPONSE_BASE== s_unsolResponses[i].requestNumber);  
24.     }  
25.     // old standalone impl wants it here.  
26.     if (s_started == 0) {  
27.         RIL_startEventLoop();  
28.     }  
29. 　　// 得到名为rild的socket句柄  
30. 　　s_fdListen = android_get_control_socket(SOCKET_NAME_RIL);  
31.     if (s_fdListen < 0) {  
32.         LOGE("Failed to get socket ‘" SOCKET_NAME_RIL "‘");  
33.         exit(-1);  
34. 　　}  
35. 　　// 监听该socket  
36.     ret = listen(s_fdListen, 4);  
37.     if (ret < 0) {  
38.         LOGE("Failed to listen on control socket ‘%d‘: %s",s_fdListen, strerror(errno));  
39.         exit(-1);  
40.     }  
41.     /* 设置s_listen_event事件，一旦有客户端连接，即s_fdListen可读就会导致eventLoop工作线程中的select返回，因为该事件不是持久的，因此调用为listenCallback处理完后，将从watch_table移除该事件，所以Rild只支持一个客户端连接*/  
42. 　　ril_event_set (&s_listen_event, s_fdListen, false,listenCallback, NULL);  
43.     /* 添加s_listen_event事件，并触发eventLoop工作线程 */  
44.     rilEventAddWakeup (&s_listen_event);  
45. #if 1  
46.     // 得到调试socket的句柄rild-debug  
47.     s_fdDebug = android_get_control_socket(SOCKET_NAME_RIL_DEBUG);  
48.     if (s_fdDebug < 0) {  
49.         LOGE("Failed to get socket ‘" SOCKET_NAME_RIL_DEBUG "‘ errno:%d", errno);  
50.         exit(-1);  
51. 　　}  
52. 　　//监听该socket  
53.     ret = listen(s_fdDebug, 4);  
54.     if (ret < 0) {  
55.         LOGE("Failed to listen on ril debug socket ‘%d‘: %s",s_fdDebug, strerror(errno));  
56.         exit(-1);  
57. 　　}  
58.     /* 设置s_debug_event事件 */  
59.     ril_event_set (&s_debug_event, s_fdDebug, true,debugCallback, NULL);  
60.     /* 添加s_debug_event事件，并触发eventLoop工作线程  */  
61.     rilEventAddWakeup (&s_debug_event);  
62. #endif  
63. }  

打开监听端口，接收来自客户端进程的命令请求，当与客户进程连接建立时调用listenCallback函数，创建单独线程监视并处理所有事件源。

1.客户端连接处理

s_listen_event事件用于处理上层客户端的socket连接，当得到socket连接请求时，eventLoop工作线程里的select返回并自动调用listenCallback回调函数进行处理：

[cpp] view plaincopy

 

1. tatic void listenCallback (int fd, short flags, void *param) {  
2.     int ret;  
3.     int err;  
4.     int is_phone_socket;  
5.     RecordStream *p_rs;  
6.     commthread_data_t *user_data = NULL;  
7.     user_data =(commthread_data_t *)malloc(sizeof(commthread_data_t));  
8.     struct sockaddr_un peeraddr;  
9.     socklen_t socklen = sizeof (peeraddr);  
10.     struct ucred creds;  
11.     socklen_t szCreds = sizeof(creds);  
12.     struct passwd *pwd = NULL;  
13.     assert (s_fdCommand < 0);  
14. 　　assert (fd == s_fdListen);  
15. 　　//接收一个客户端的连接，并将该socket连接保存在变量s_fdCommand中  
16.     s_fdCommand = accept(s_fdListen, (sockaddr *) &peeraddr, &socklen);  
17.     if (s_fdCommand < 0 ) {  
18.         LOGE("Error on accept() errno:%d", errno);  
19.         /* start listening for new connections again */  
20.         rilEventAddWakeup(&s_listen_event);  
21.           return;  
22.     }  
23.     /* 对客户端权限判断，判断是否是进程组ID为radio的进程发起的连接*/  
24.     errno = 0;  
25.     is_phone_socket = 0;  
26.     err = getsockopt(s_fdCommand, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds);  
27.     if (err == 0 && szCreds > 0) {  
28.         errno = 0;  
29.         pwd = getpwuid(creds.uid);  
30.         if (pwd != NULL) {  
31.             if (strcmp(pwd->pw_name, PHONE_PROCESS) == 0) {  
32.                 is_phone_socket = 1;  
33.             } else {  
34.                 LOGE("RILD can‘t accept socket from process %s", pwd->pw_name);  
35.             }  
36.         } else {  
37.             LOGE("Error on getpwuid() errno: %d", errno);  
38.         }  
39.     } else {  
40.         LOGD("Error on getsockopt() errno: %d", errno);  
41.     }  
42.       
43.     if ( !is_phone_socket ) {  
44.       LOGE("RILD must accept socket from %s", PHONE_PROCESS);  
45.       close(s_fdCommand);  
46.       s_fdCommand = -1;  
47.       onCommandsSocketClosed();  
48.       /* start listening for new connections again */  
49.       rilEventAddWakeup(&s_listen_event);  
50.       return;  
51.     }  
52. #if 0  
53.     if(s_dualSimMode) {  
54.         if(s_sim_num == 0) {  
55.             property_get(SIM_POWER_PROPERTY, prop, "0");  
56.             if(!strcmp(prop, "0")) {  
57.                 property_set(SIM_POWER_PROPERTY, "1");  
58.                 s_callbacks.powerSIM(NULL);  
59.             }  
60.         } else if(s_sim_num == 1) {  
61.             property_get(SIM_POWER_PROPERTY1, prop, "0");  
62.             if(!strcmp(prop, "0")) {  
63.                 property_set(SIM_POWER_PROPERTY1, "1");  
64.                 s_callbacks.powerSIM(NULL);  
65.             }  
66.         }  
67.     } else {  
68.         property_get(SIM_POWER_PROPERTY, prop, "0");  
69.         if(!strcmp(prop, "0")) {  
70.             property_set(SIM_POWER_PROPERTY, "1");  
71.             s_callbacks.powerSIM(NULL);  
72.         }  
73.     }  
74. #endif  
75.     //p_rs为RecordStream类型，它内部会分配一个缓冲区来存储客户端发送过来的数据  
76. 　　p_rs = record_stream_new(s_fdCommand, MAX_COMMAND_BYTES);  
77. 　　//添加一个针对接收到的客户端连接的处理事件，从而在eventLoop工作线程中处理该客户端的各种请求  
78.     ril_event_set (&s_commands_event, s_fdCommand, 1,processCommandsCallback, p_rs);  
79.     rilEventAddWakeup (&s_commands_event);  
80.     onNewCommandConnect();  
81. }  

2.客户端通信处理

在listenCallback中首先接收客户端的连接请求，并验证客户端的权限，同时将该客户端以事件的形式添加到eventLoop工作线程中进行监控，当该客户端有数据请求时，eventLoop工作线程从select中返回，并自动调用processCommandsCallback回调函数：

[cpp] view plaincopy

 

1. static void processCommandsCallback(int fd, short flags, void *param) {  
2.     RecordStream *p_rs;  
3.     void *p_record;  
4.     size_t recordlen;  
5.     int ret;  
6.     assert(fd == s_fdCommand);  
7.     p_rs = (RecordStream *)param;  
8. 　　for (;;) { //循环处理客户端发送过来的AT命令  
9. 　　    //读取一条AT命令  
10.         ret = record_stream_get_next(p_rs, &p_record, &recordlen);  
11.         if (ret == 0 && p_record == NULL) {  
12.             break;  
13.         } else if (ret < 0) {  
14.             break;  
15.         } else if (ret == 0) { /* && p_record != NULL */  
16.             //处理客户端发送过来的AT命令  
17.             processCommandBuffer(p_record, recordlen);  
18.         }  
19.     }  
20.     if (ret == 0 || !(errno == EAGAIN || errno == EINTR)) {  
21.         if (ret != 0) {  
22.             LOGE("error on reading command socket errno:%d\n", errno);  
23.         } else {  
24.             LOGW("EOS.  Closing command socket.");  
25.         }  
26.         close(s_fdCommand);  
27.         s_fdCommand = -1;  
28.         ril_event_del(&s_commands_event);  
29.         record_stream_free(p_rs);  
30.         rilEventAddWakeup(&s_listen_event);  
31.         onCommandsSocketClosed();  
32.     }  
33. }  

通过processCommandBuffer函数来处理每一条AT命令：

[cpp] view plaincopy

 

1. static int processCommandBuffer(void *buffer, size_t buflen) {  
2.     Parcel p;  
3.     status_t status;  
4.     int32_t request;  
5.     int32_t token;  
6.     RequestInfo *pRI;  
7.     int ret;  
8.     p.setData((uint8_t *) buffer, buflen);  
9.     // status checked at end  
10.     status = p.readInt32(&request);  
11.     status = p.readInt32 (&token);  
12.     if (status != NO_ERROR) {  
13.         LOGE("invalid request block");  
14.         return 0;  
15.     }  
16.     if (request < 1 || request >= (int32_t)NUM_ELEMS(s_commands)) {  
17.         LOGE("unsupported request code %d token %d", request, token);  
18.         return 0;  
19.     }  
20.     pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));  
21.     pRI->token = token; //AT命令标号  
22.     pRI->pCI = &(s_commands[request]); //根据request找到s_commands命令数组中的指定AT命令  
23.     ret = pthread_mutex_lock(&s_pendingRequestsMutex);  
24.     assert (ret == 0);  
25.     pRI->p_next = s_pendingRequests;  
26.     s_pendingRequests = pRI;  
27.     ret = pthread_mutex_unlock(&s_pendingRequestsMutex);  
28. 　　assert (ret == 0);  
29. 　　//调用指定AT命令的dispatch函数，根据接收来自客户进程的命令和参数，调用onRequest进行处理。  
30.     pRI->pCI->dispatchFunction(p, pRI);  
31.     return 0;  
32. }  

打电话的AT命令：{RIL_REQUEST_DIAL, dispatchDial, responseVoid},

发短信的AT命令：{RIL_REQUEST_SEND_SMS, dispatchStrings, responseSMS},

3.电话拨打流程

 

[cpp] view plaincopy

 

1. static void dispatchDial (Parcel &p, RequestInfo *pRI) {  
2. 　　RIL_Dial dial; //RIL_Dial存储了打电话的所有信息  
3.     RIL_UUS_Info uusInfo;   
4.     int32_t sizeOfDial;  
5.     int32_t t;  
6.     .................. //初始化dial变量    
7. 　　s_callbacks.onRequest(pRI->pCI->requestNumber, &dial, sizeOfDial, pRI);  
8. 　　.................  
9.     return;  
10. }  

s_callbacks.onRequest其实就是调用RIL_RadioFunctions中的onRequest函数，该函数在前面已介绍过了。

[cpp] view plaincopy

 

1. static void onRequest (int request, void *data, size_t datalen, RIL_Token t)  
2. {  
3.     switch (request) {  
4.         case RIL_REQUEST_DIAL:  
5.             requestDial(data, datalen, t);  
6.             break;  
7.     }  
8. }  

[cpp] view plaincopy

 

1. static void requestDial(void *data, size_t datalen, RIL_Token t)  
2. {  
3.     RIL_Dial *p_dial;  
4.     char *cmd;  
5.     const char *clir;  
6.     int ret;  
7.     p_dial = (RIL_Dial *)data;  
8.     switch (p_dial->clir) {  
9.         case 1: clir = "I"; break;  /*invocation*/  
10.         case 2: clir = "i"; break;  /*suppression*/  
11.         default:  
12.         case 0: clir = ""; break;   /*subscription default*/  
13. 　　}  
14. 　　//向串口发送AT指令  
15.     ret = at_send_command(cmd, NULL);  
16. 　　free(cmd);  
17. 　　//通知请求结果  
18.     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);  
19. }  

向AT发送完拨号指令后，通过RIL_onRequestComplete返回处理结果，RIL_onRequestComplete实际上是RIL_Env中的OnRequestComplete函数，在前面我们也介绍过了

[cpp] view plaincopy

 

1. extern "C" void RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen) {  
2.     RequestInfo *pRI;  
3.     int ret;  
4.     size_t errorOffset;  
5. 　　pRI = (RequestInfo *)t;  
6. 　　//该请求已经处理，需要从请求队列中移除该请求  
7.     if (!checkAndDequeueRequestInfo(pRI)) {  
8.         LOGE ("RIL_onRequestComplete: invalid RIL_Token");  
9.         return;  
10.     }  
11.     if (pRI->local > 0) {  
12.         ...........  
13.         sendResponse(p);  
14.     }  
15. done:  
16.     free(pRI);  
17. }  

 

[cpp] view plaincopy

 

1. static int sendResponse (Parcel &p) {  
2.     return sendResponseRaw(p.data(), p.dataSize()); //将结果发送给JAVA RIL客户端  
3. }  

 

[cpp] view plaincopy

 

1. static int sendResponseRaw (const void *data, size_t dataSize) {  
2.     int fd = s_fdCommand;  
3.     int ret;  
4.     uint32_t header;  
5.     if (s_fdCommand < 0) {  
6.         return -1;  
7.     }  
8.     if (dataSize > MAX_COMMAND_BYTES) {  
9.         return -1;  
10.     }  
11.     pthread_mutex_lock(&s_writeMutex);  
12.     header = htonl(dataSize);  
13.     ret = blockingWrite(fd, (void *)&header, sizeof(header));  
14.     if (ret < 0) {  
15.         pthread_mutex_unlock(&s_writeMutex);  
16.         return ret;  
17.     }  
18.     ret = blockingWrite(fd, data, dataSize);  
19.     if (ret < 0) {  
20.         pthread_mutex_unlock(&s_writeMutex);  
21.         return ret;  
22.     }  
23.     pthread_mutex_unlock(&s_writeMutex);  
24.     return 0;  
25. }  

拨打电话的时序图如下：

Rild通过onRequest向动态库提交一个请求，然后返回，动态库处理完请求后，处理结果通过回调接口通知客户端

Android 电话系统框架介绍,布布扣,bubuko.com

Android 电话系统框架介绍