inandroidSystemrildrunningAPon,APApplication byrildsendATInstructions toBP，BPAfter receiving the information through therildSent toAP. There are two means of communication between the AP and BP:

1.Solicited Response:AptoBpsend request,BpgiveApSending a reply, the AT command and the type of callback functions stored in an array Ril_commands.h file:

{Array index, callback requests, in response to the callback function}

2.unSolicited Response:BpInitiative toApSend event,The AT command and the type of callback functions stored in an array ofril_unsol_commands.h file:

{Array index, in response to the callback function, type}

AT mobile phone manufacturers use differentCommand is not exactly the same, in order to confidentiality,APversusBPBetween the various manufacturers to communicate through their relevant dynamic libraries.

RILModule consists ofrildDaemon,libril.so、librefrence.so three partscomposition:

  1.rildModule is compiled into an executable file, to achieve amainFunction as a wholerilEntry point of the module. Use during initializationdlopenturn onlibrefrence_ril.so, Which fetches and executesRIL_InitFunction, getRIL_RadioFunctionsPointer byRIL_register()Functions registered tolibril.soLibrary, its source code structure is as follows:

 2.libril.soIs a shared library, the work is mainly responsible for communication with the upper receivingrilRequest, and passed tolibrefrence_ril.soWhilelibrefrence_ril.soThe message is returned to the calling process, as shown in the source code is structured as follows:

3.librefrence_ril.so is achieved by the handset makers themselves, runs in rild processbydlopenWay to load, is responsible withmodemCommunication hardware, the conversion fromlibril.soThe request for theATCommand, while listeningModemFeedback tolibril.so

Android telephone system is divided into three parts, a variety of telephone related java application layer, Phone Service java layer, the upper layer was mainly the API, while communicating with a native, can be seen as a client telephone system, Native layer telephone service process RILD, is responsible for the upper layer provides services to various phone functions, to interact directly with the modem:

Android phone system design framework chart:

Because Modem Android developers to use is not the same, various instruction format, initialization sequences may be different, so in order to eliminate these differences, Android designers ril made an abstract concept of using a virtual phone, different modem-related AT commands or the communication protocol to the corresponding compiled dynamic link library .so files, Rild specific AT commands and responses by the synthesis resolver.

Android phone system code structure:

RILD frame design

In the android phone system, the native layer to achieve the service end of the telephone service, by the interaction RILD service and a modem, java layer implementation in a client calls, the paper introduces the server process RILD telephone system, the following isFIG RILD design framework:

RILD source code analysis

Followed by removal of the entire frame RILD source will be described in detail.

After the kernel startup is complete, it will start the first application process Init process, inInit process of android source code analysis process startsIn an article for the init process start the process of a detailed introduction. init.rc init process reads the file in the startup process to start some heavyweight native service, rild process is to start by configuring the init.rc.

RILD entry function analysis process

The next is a timing chart RILD given to start the process:

hardware\ril\rild\rild.c

1. parse command line arguments, reads libreference-ril.so library storage path by determining whether a different approach to the simulator;

2. dlopen manual loading libreference-ril.so library;

3. Start the event loop processing;

4. RIL_Init function to obtain the address from libreference-ril.so library, using the functionlibril.so libraryRIL_Env interface registration to libreference-ril.so library, while libreference-ril.so library RIL_RadioFunctions interface registers to the library to libril.so establish libril.so library and library libreference-ril.so communication bridge;

Start event loop processing eventLoop worker

[cpp] view plain copy

1. struct ril_event {  
2.     struct ril_event *next;  
3.     struct ril_event *prev;  
4.     int fd;  // file handle  
5.     int index; // The index in the event monitor table  
6.     bool persist; // If it is held, is not removed from the watch_list  
7.     struct timeval timeout; // task execution time  
8.     ril_event_cb func; // callback event handler  
9.     void *param; // callback parameters  
10. };  

inRildIn the process of several important events

[cpp] view plain copy

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 plain copy

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

It defined three event queue in the RILD for handling different events:

/Event Monitoring queue

static struct ril_event * watch_table[MAX_FD_EVENTS];

//Timed event queue

static struct ril_event timer_list;

//Processing the event queue

static struct ril_event pending_list; //Pending event queue, the event has been triggered, the callback handler needs event

Add an event

1. Add Wakeup Event

 

[cpp] view plain copy

1. static void rilEventAddWakeup(struct ril_event *ev) {  
2.     ril_event_add(ev); // add an event to the monitoring tables watch_table s_wakeupfd_event  
3.     triggerEvLoop(); // write the pipeline to be triggered in the event loop s_fdWakeupWrite  
4. }  

[cpp] view plain copy

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++) { // Traverse monitoring table watch_table  
6.         if (watch_table[i] == NULL) { // Find the index free from the monitoring list, then the task was added to the monitoring list  
7.             watch_table[i] = ev; // add events to monitor table  
8.             ev->index = i; // set index for the event in the monitoring tables index  
9.             dlog("~~~~ added at %d ~~~~", i);  
10.             dump_event(ev);  
11.             FD_SET(ev->fd, &readFds); Corresponding to the event handler // add a handler added to the pool readFds  
12.             if (ev->fd >= nfds) nfds = ev->fd+1; // handle to modify the maximum  
13.             dlog("~~~~ nfds = %d ~~~~", nfds);  
14.             break;  
15.         }  
16.     }  
17.     MUTEX_RELEASE();  
18.     dlog("~~~~ -ril_event_add ~~~~");  
19. }  

2. Add timed events

[cpp] view plain copy

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. }  

trigger event

[cpp] view plain copy

1. static void triggerEvLoop() {  
2.     int ret;  
3. 　　if (!pthread_equal(pthread_self(), s_tid_dispatch)) { // If the current thread ID is not equal to the event dispatch thread eventLoop thread ID  
4.       do {  
5.             ret = write (s_fdWakeupWrite, " ", 1); // write end of the pipe 1 to write a value to the trigger event loop eventLoop  
6.          } while (ret < 0 && errno == EINTR);  
7.     }  
8. }  

Handling Events

[cpp] view plain copy

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.         // wait to use the select function on the FDS, as long as the FDS data recording apparatus soon, it will select the corresponding flag bit and returns. readFDS records all events related to the device handle. readFDS the handle is in the AddEvent added.  
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(); // query execution time has come to the event from timer_list and added to the pending_list  
27.         processReadReadies(&rfds, n); // query data readable event from watch_table and added to pending_list in to deal with, if the event is not long-lasting event, it is deleted from the watch_table  
28.         // Traverse pending_list, call an event handler callback function to handle all events  
29.         firePending();  
30.     }  
31. }  

In eventLoop worker thread event loop processing incoming event and the timer expires, the entire processing flow as shown below:

First by Linux in select multi-channel I / O multiplexing handles handles all pool monitor when there is an event coming select returns otherwise blocked. When select returns, expressed an arrival event to handle the timeout events by calling processTimeouts function approach is traversing time_list list to check out events, and moved out event to pending_list the list, then call processReadReadies function to handle events triggered event handling is traversing watch_table list of queries trigger event, and trigger the move to pending_list the list, if the event is not long-lasting event, also need to be removed from the list watch_table, when the event finished two kinds of queries to be processed and after put into pending_list the list, call the function firePending be treated in the event centralized treatment, treatment to traverse the list, call the callback function for each event.

1. timeout event query

[cpp] view plain copy

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); // Get the current time  
9. 　　dlog("~~~~ Looking for timers <= %ds + %dus ~~~~", (int)now.tv_sec, (int)now.tv_usec);  
10. 　　// If the current time is greater than the timeout time of the event, then the event is removed from the timer_list added to pending_list  
11.     while ((tev != &timer_list) && (timercmp(&now, &tev->timeout, >))) {  
12.         dlog("~~~~ firing timer ~~~~");  
13.         next = tev->next;  
14.         removeFromList(tev); // remove the event from the timer_list  
15.         addToList(tev, &pending_list); // add the event to pending_list  
16.         tev = next;  
17.     }  
18.     MUTEX_RELEASE();  
19.     dlog("~~~~ -processTimeouts ~~~~");  
20. }  

2. A readable event query

[cpp] view plain copy

1. static void processReadReadies(fd_set * rfds, int n)  
2. {  
3.     dlog("~~~~ +processReadReadies (%d) ~~~~", n);  
4. 　　MUTEX_ACQUIRE();   
5. 　　// Traverse watch_table array, according to the n select returns a handle to find the corresponding event  
6.     for (int i = 0; (i < MAX_FD_EVENTS) && (n > 0); i++) {  
7.         struct ril_event * rev = watch_table[i]; // get the corresponding event  
8.         if (rev != NULL && FD_ISSET(rev->fd, rfds)) {  
9.             addToList(rev, &pending_list); // add the event to the pending_list  
10.             if (rev->persist == false) { // If the event is not persistent in the event also removed from watch_table  
11.                 removeWatch(rev, i);  
12.             }  
13.             n--;  
14.         }  
15.     }  
16.     MUTEX_RELEASE();  
17.     dlog("~~~~ -processReadReadies (%d) ~~~~", n);  
18. }  

3. Event Processing

[cpp] view plain copy

1. static void firePending()  
2. {  
3.     dlog("~~~~ +firePending ~~~~");  
4.     struct ril_event * ev = pending_list.next;  
5.     while (ev != &pending_list) { // Traverse pending_list list, all events are processed in a linked list  
6.         struct ril_event * next = ev->next;  
7.         removeFromList(ev); // event processed removed from the pending_list  
8.         ev->func(ev->fd, 0, ev->param); // Call the event handler callback function  
9.         ev = next;  
10.     }  
11.     dlog("~~~~ -firePending ~~~~");  
12. }  

RIL_Env defined

hardware\ril\include\telephony\ril.h

[cpp] view plain copy

1. struct RIL_Env {  
2.     // notify the processing result after the completion of the request interface DLL  
3. 　　void (*OnRequestComplete)(RIL_Token t, RIL_Errno e,void *response, size_t responselen);  
4.     // dynamic library unSolicited Response notification interface  
5. 　　void (*OnUnsolicitedResponse)(int unsolResponse, const void *data,size_t datalen);  
6.     // submit a timeout task to Rild Interface  
7.     void (*RequestTimedCallback) (RIL_TimedCallback callback,void *param, const struct timeval *relativeTime);  
8. };  

hardware\ril\rild\rild.c

s_rilEnv variable definitions:

[cpp] view plain copy

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

Implement the various interface functions RIL_Env in hardware \ ril \ libril \ ril.cpp in

1.RIL_onRequestComplete

[cpp] view plain copy

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. }  

By calling responseXXXThe underlying passed in response to the client process

2.RIL_onUnsolicitedResponse

[cpp] view plain copy

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. }  

This function handles modemVarious events received at the network, such as network signal changes from incoming calls, receive text messages and so on. Then passed to the client process.

3.RIL_requestTimedCallback

[cpp] view plain copy

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

[cpp] view plain copy

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 defined

Client toRildRequest transmission interface,Achieved by each mobile phone manufacturers.

hardware\ril\include\telephony\Ril.h 

[cpp] view plain copy

1. typedef struct {  
2.     int version; // Rild version  
3.     RIL_RequestFunc onRequest; // AP Request Interface  
4.     RIL_RadioStateRequest onStateRequest;// BP Status  
5.     RIL_Supports supports;  
6.     RIL_Cancel onCancel;  
7.     RIL_GetVersion getVersion;// dynamic library version  
8. } RIL_RadioFunctions;  

variable definitions:

[cpp] view plain copy

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

RIL_RadioFunctions implement various interface functions in hardware \ ril \ reference-ril \ reference-ril.c in

1.onRequest

[cpp] view plain copy

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. }  

For each RIL_REQUEST_XXXConverted to the corresponding requestATcommand,send tomodemAnd then wait for sleep, when receivedATcommandAfter the final response, the thread wakes up, the response to the client process.

2.currentState

[cpp] view plain copy

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

3.onSupports

[cpp] view plain copy

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

4.onCancel

[cpp] view plain copy

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

5.getVersion

[cpp] view plain copy

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

Registration RIL_Env Interface

Since the AT command differences among mobile phone manufacturers, mobile phone manufacturers therefore need to achieve interaction with the modem layer, provided in the form of a dynamic library. As an intermediate layer between the modem and the upper layer, i.e., to interact with the bottom also communicate with the upper layer, so it is necessary to define an interface adapter RILD a dynamic library,RIL_Env andInterface is RIL_RadioFunctionslibril.so andBridge librefrence.so communication.YesRildIsolated interface architecture for generic code and manufacturer code,RIL_EnvRealized by a common code, andRIL_RadioFunctionsIt is the code of vendor implementations.


RIL_InitThe main tasks:

1. tolibrefrence.so registrationlibril.so interface providedRIL_Env；

2. CreatemainLoopWorker, used to initializeATModule, and monitorATStatus of the module, onceATIt is closed, then reopened and initializeAT；

3. whenATAfter being opened,mainLoopWorker willRildSubmit a timed events, and triggerseventLoopTo complete themodemInitialization;

4. CreatereadLoopWorker thread for theATSerial read data;

5.returnlibrefrence.so interface providedRIL_RadioFunctions；

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

mainLoopWorker thread is used to initialize and monitorATModule, onceATModule is turned off, it opens automatically.

1. Open AT module

byat_openOpen the file descriptorfdofATSerial devices, and register a callback functionATUnsolHandler 

2.Add timed events RIL_requestTimedCallback

The timing to add a timer event in the event queue, the event handler is initializeCallback, for transmitting some of the ATCommand to initializeBPofmodem。

3.readLoop worker

Read loop parsing hair came from Modem response. If you encounter URC handleUnsolicited reported RIL_JAVA through. If you answered command, then there is a response by handleFinalResponse notice send_at_command results.