android ril 代码逻辑分析

--Ril.h------------------------------------------------------------ typedef struct {
    int version;        /* set to RIL_VERSION */
    RIL_RequestFunc onRequest;
    RIL_RadioStateRequest onStateRequest;
    RIL_Supports supports;
    RIL_Cancel onCancel;
    RIL_GetVersion getVersion;
} RIL_RadioFunctions;
struct RIL_Env {
void (*OnRequestComplete)(RIL_Token t, RIL_Errno e,
                           void *response, size_t responselen);

void (*OnUnsolicitedResponse)(int unsolResponse, const void *data,
                                    size_t datalen);
void* (*RequestTimedCallback) (RIL_TimedCallback callback,
                                   void *param, const struct timeval *relativeTime);
void (*RemoveTimedCallback) (void *callbackInfo);
};

const RIL_RadioFunctions * RIL_Init(const struct RIL_Env *env, int argc, char **argv);

void RIL_register (const RIL_RadioFunctions *callbacks);
void RIL_onRequestComplete(RIL_Token t, RIL_Errno e,
                           void *response, size_t responselen);
void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
                                size_t datalen);
void* RIL_requestTimedCallback (RIL_TimedCallback callback,
                                void *param, const struct timeval *relativeTime);
void RIL_removeTimedCallback(void *callbackInfo); --Rild--------------------------------------------------------------------- static struct RIL_Env s_rilEnv = {
    RIL_onRequestComplete,
    RIL_onUnsolicitedResponse,
    RIL_requestTimedCallback,
    RIL_removeTimedCallback
};
int main(int argc, char **argv)
{ const RIL_RadioFunctions *(*rilInit)(const struct RIL_Env *, int, char **);
    const RIL_RadioFunctions *funcs;
dlHandle = dlopen(rilLibPath, RTLD_NOW);    RIL_startEventLoop(); rilInit = (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))dlsym(dlHandle, " RIL_Init"); funcs = rilInit(& s_rilEnv, argc, rilArgv);

     RIL_register(funcs); while(1) {
        // sleep(UINT32_MAX) seems to return immediately on bionic
        sleep(0x00ffffff);
    } } --libRil------------------------------------------------------------ RIL_RadioFunctions s_callbacks = {0, NULL, NULL, NULL, NULL, NULL};
static int s_registerCalled = 0;

static pthread_t s_tid_dispatch;
static pthread_t s_tid_reader;
static int s_started = 0;

static int s_fdListen = -1;
static int s_fdCommand = -1;
static int s_fdDebug = -1;

static int s_fdWakeupRead;
static int s_fdWakeupWrite;

static struct ril_event s_commands_event; // socket fd for writing to client
static struct ril_event s_wakeupfd_event; // wakeup fd for reading
static struct ril_event s_listen_event; // socket fd for linstening
static struct ril_event s_wake_timeout_event;
static struct ril_event s_debug_event; // socket fd for debug linstening
extern "C" void RIL_register (const RIL_RadioFunctions *callbacks) {    RIL_startEventLoop();
   s_fdListen = android_get_control_socket(SOCKET_NAME_RIL); ret = listen(s_fdListen, 4); /* note: non-persistent so we can accept only one connection at a time */
     ril_event_set (& s_listen_event, s_fdListen, false,
                 listenCallback, NULL);
     rilEventAddWakeup (&s_listen_event);
   s_fdDebug = android_get_control_socket(SOCKET_NAME_RIL_DEBUG); ret = listen(s_fdDebug, 4);
     ril_event_set (& s_debug_event, s_fdDebug, true,
                 debugCallback, NULL);

     rilEventAddWakeup (&s_debug_event); } extern "C" void RIL_startEventLoop(void) {
    int ret;
    pthread_attr_t attr;

    /* spin up eventLoop thread and wait for it to get started */
    s_started = 0;
    pthread_mutex_lock(&s_startupMutex);

    pthread_attr_init (&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    ret = pthread_create(&s_tid_dispatch, &attr, eventLoop, NULL);

    while (s_started == 0) {
        pthread_cond_wait(&s_startupCond, &s_startupMutex);
    }

    pthread_mutex_unlock(&s_startupMutex);
} static void *eventLoop (void *param) { {    ril_event_init (); pthread_mutex_lock(&s_startupMutex);

    s_started = 1;
    pthread_cond_broadcast(&s_startupCond);

    pthread_mutex_unlock(&s_startupMutex);

    ret = pipe(filedes);

s_fdWakeupRead = filedes[0];
    s_fdWakeupWrite = filedes[1];

    fcntl(s_fdWakeupRead, F_SETFL, O_NONBLOCK);

     ril_event_set (& s_wakeupfd_event , s_fdWakeupRead, true,
                 processWakeupCallback , NULL);

     rilEventAddWakeup (& s_wakeupfd_event );

    // Only returns on error
     ril_event_loop ();
} void ril_event_loop()
{
for (;;) {
memcpy(&rfds, &readFds, sizeof(fd_set));            calcNextTimeout (&tv)         n = select( nfds, & rfds, NULL, NULL, ptv);
// Check for timeouts
         processTimeouts();
        // Check for read-ready
         processReadReadies(&rfds, n);
        // Fire away
         firePending();
    }
}
static void processTimeouts()
{
    MUTEX_ACQUIRE();
while ((tev != & timer_list) && (timercmp(&now, &tev->timeout, >))) {
next = tev->next;
         removeFromList(tev);
         addToList(tev, &pending_list);
        tev = next;
    }
    MUTEX_RELEASE();
}

static void processReadReadies(fd_set * rfds, int n)
{
MUTEX_ACQUIRE();
for (int i = 0; (i < MAX_FD_EVENTS) && (n > 0); i++) {
        struct ril_event * rev = watch_table[i];
        if (rev != NULL && FD_ISSET(rev->fd, rfds)) {
             addToList(rev, &pending_list);
            if (rev->persist == false) {
                 removeWatch(rev, i);
            }
            n--;
        }
    }
    MUTEX_RELEASE();
}

static void firePending()
{
    struct ril_event * ev = pending_list.next;
    while (ev != &pending_list) {
        struct ril_event * next = ev->next;
         removeFromList(ev);
         ev->func(ev->fd, 0, ev->param);
        ev = next;
    }
} void ril_event_init()
{
    MUTEX_INIT();
    FD_ZERO(& readFds);
    init_list(& timer_list);
    init_list(& pending_list);
    memset( watch_table, 0, sizeof(watch_table)); } // listener for s_fdListen static void listenCallback (int fd, short flags, void *param) {    s_fdCommand = accept(s_fdListen, (sockaddr *) &peeraddr, &socklen); ret = fcntl(s_fdCommand, F_SETFL, O_NONBLOCK); p_rs = record_stream_new(s_fdCommand, MAX_COMMAND_BYTES);

     ril_event_set (& s_commands_event, s_fdCommand, 1,
         processCommandsCallback, p_rs);

     rilEventAddWakeup (&s_commands_event);

    onNewCommandConnect(); } static void rilEventAddWakeup(struct ril_event *ev) {
     ril_event_add(ev); // Add event to watch list
     triggerEvLoop(); // trigger event loop to wakeup
} // Add event to watch list
void ril_event_add(struct ril_event * ev)
{
    MUTEX_ACQUIRE();
    for (int i = 0; i < MAX_FD_EVENTS; i++) {
        if (watch_table[i] == NULL) {
             watch_table[i] = ev;
            ev->index = i;
   FD_SET( ev->fd, & readFds);
            if (ev->fd >= nfds) nfds = ev->fd+1;
   break;
        }
    }
    MUTEX_RELEASE();
} // listener for s_fdCommand static void processCommandsCallback(int fd, short flags, void *param) { ret = record_stream_get_next(p_rs, &p_record, &recordlen);    processCommandBuffer(p_record, recordlen);    close(s_fdCommand);
        s_fdCommand = -1;    ril_event_del(&s_commands_event); // Remove event from watch or timer list

        record_stream_free(p_rs);

        /* start listening for new connections again */
         rilEventAddWakeup(&s_listen_event);

        onCommandsSocketClosed(); } static CommandInfo s_commands[] = {
#include "ril_commands.h" // there are dispatch and reponse mapping here for Request from Client
}; static int processCommandBuffer(void *buffer, size_t buflen) { pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo)); pRI->pCI = &( s_commands[request]); pRI->pCI-> dispatchFunction(p, pRI); } // dispathc Dail to Reference-ril, it is synchronization operation static void dispatchDial (Parcel &p, RequestInfo *pRI) { s_callbacks. onRequest( pRI->pCI->requestNumber, &dial, sizeOfDial, pRI); } // called by Reference-ril for one Request, and reponse to Client(app) extern "C" void
RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen) { pRI = (RequestInfo *)t; ret = pRI->pCI-> responseFunction(p, response, responselen);    sendResponse(p); } // // called by Reference-ril for one unsolicited response extern "C"
void RIL_onUnsolicitedResponse(int unsolResponse, void *data, size_t datalen) { ret = s_unsolResponses[ unsolResponseIndex]
                . responseFunction(p, data, datalen); ret = sendResponse(p); } extern "C" void *
RIL_requestTimedCallback (RIL_TimedCallback callback, void *param,
                                const struct timeval *relativeTime) {
   return internalRequestTimedCallback (callback, param, relativeTime);
}

extern "C" void
RIL_removeTimedCallback (void *callbackInfo) {
    internalRemoveTimedCallback(callbackInfo);
} --reference-ril------------------------------------------------------------ pthread_t s_tid_mainloop; int main (int argc, char **argv)
{
     RIL_register(&s_callbacks);

     mainLoop(NULL);

    return 0;
} const RIL_RadioFunctions * RIL_Init(const struct RIL_Env *env, int argc, char **argv)
{    s_rilenv = env;
    pthread_attr_init (&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    ret = pthread_create(& s_tid_mainloop, &attr, mainLoop, NULL);

    return & s_callbacks;
}
#else /* RIL_SHLIB */ static void * mainLoop(void *param) { for (;;) { ret = at_open(fd, onUnsolicited);
         RIL_requestTimedCallback(initializeCallback, NULL, &TIMEVAL_0);

        // Give initializeCallback a chance to dispatched, since
        // we don't presently have a cancellation mechanism
         sleep(1);

         waitForClose(); } } static pthread_t s_tid_reader;
static int s_fd = -1;    /* fd of the AT channel */
static ATUnsolHandler s_unsolHandler;

/* for input buffering */

static char s_ATBuffer[MAX_AT_RESPONSE+1];
static char *s_ATBufferCur = s_ATBuffer;

static int s_ackPowerIoctl; /* true if TTY has android byte-count
                                handshake for low power*/
static int s_readCount = 0; int at_open(int fd, ATUnsolHandler h)
{
    pthread_attr_init (&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

    ret = pthread_create(& s_tid_reader, &attr, readerLoop, &attr); } static void * readerLoop(void *arg) { for (;;) { // Reads a line from the AT channel, returns NULL on timeout.
line = readline();

        if (line == NULL) {
            break;
        }
             processLine(line);
    }
    onReaderClosed();
} static void processLine(const char *line) { pthread_mutex_lock(& s_commandmutex); if (sp_response == NULL) {
        /* no command pending */
         handleUnsolicited(line);
    } else if (isFinalResponseSuccess(line)) {
        sp_response->success = 1;
         handleFinalResponse(line);
    } else if (isFinalResponseError(line)) {
        sp_response->success = 0;
         handleFinalResponse(line);
    } else if (s_smsPDU != NULL && 0 == strcmp(line, "> ")) {
        writeCtrlZ(s_smsPDU);
        s_smsPDU = NULL;
    } else switch (s_type) {
        case NO_RESULT:
             handleUnsolicited(line);
            break; case .... break; default: /* this should never be reached */
            LOGE("Unsupported AT command type %d\n", s_type);
             handleUnsolicited(line);
        break; } pthread_mutex_unlock(& s_commandmutex); } static void handleUnsolicited(const char *line)
{
    if (s_unsolHandler != NULL) {
         s_unsolHandler(line, NULL);
    }
} /**
* Called by atchannel when an unsolicited line appears
* This is called on atchannel's reader thread. AT commands may
* not be issued here
*/
static void onUnsolicited (const char *s, const char *sms_pdu) } else if ( strStartsWith(s,"+CRING:")
                || strStartsWith(s,"RING")
                || strStartsWith(s,"NO CARRIER")
                || strStartsWith(s,"+CCWA")
    ) {
         RIL_onUnsolicitedResponse (
             RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED,
            NULL, 0);
#ifdef WORKAROUND_FAKE_CGEV
        RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); //TODO use new function
#endif /* WORKAROUND_FAKE_CGEV */
    } else if ( strStartsWith(s,"+CREG:")
                || strStartsWith(s,"+CGREG:")
    ) {
         RIL_onUnsolicitedResponse (
             RIL_UNSOL_RESPONSE_NETWORK_STATE_CHANGED,
            NULL, 0);
#ifdef WORKAROUND_FAKE_CGEV
        RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL);
#endif /* WORKAROUND_FAKE_CGEV */
    } else if ( strStartsWith(s, "+CMT:")) {
         RIL_onUnsolicitedResponse (
             RIL_UNSOL_RESPONSE_NEW_SMS,
            sms_pdu, strlen(sms_pdu));
    } else if ( strStartsWith(s, "+CDS:")) {
         RIL_onUnsolicitedResponse (
             RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT,
            sms_pdu, strlen(sms_pdu));
    } } /** assumes s_commandmutex is held */
static void handleFinalResponse(const char *line)
{
    sp_response->finalResponse = strdup(line);

     pthread_cond_signal(& s_commandcond);
}
/*** Callback methods from the RIL library to us ***/
* Call from RIL to us to make a RIL_REQUEST
*
* Must be completed with a call to RIL_onRequestComplete()
*
* RIL_onRequestComplete() may be called from any thread, before or after
* this function returns.
*
* Will always be called from the same thread, so returning here implies
* that the radio is ready to process another command (whether or not
* the previous command has completed).
*/ static void onRequest (int request, void *data, size_t datalen, RIL_Token t) { switch (request) { case RIL_REQUEST_SEND_SMS:
             requestSendSMS(data, datalen, t);
            break;
        case RIL_REQUEST_CDMA_SEND_SMS:
             requestCdmaSendSMS(data, datalen, t);
            break;
        case RIL_REQUEST_SETUP_DATA_CALL:
             requestSetupDataCall(data, datalen, t);
            break;
        case RIL_REQUEST_GET_DATA_CALL_PROFILE:
             requestGetDataCallProfile(data, datalen, t);
            break;
        case RIL_REQUEST_SMS_ACKNOWLEDGE:
             requestSMSAcknowledge(data, datalen, t);
            break; case RIL_REQUEST_GET_CURRENT_CALLS:
             requestGetCurrentCalls(data, datalen, t);
            break;
        case RIL_REQUEST_DIAL:
             requestDial(data, datalen, t);
            break;
        case RIL_REQUEST_HANGUP:
             requestHangup(data, datalen, t);
            break; case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND:
            // 3GPP 22.030 6.5.5
            // "Releases all held calls or sets User Determined User Busy
            // (UDUB) for a waiting call."
             at_send_command("AT+CHLD=0", NULL);

            /* success or failure is ignored by the upper layer here.
               it will call GET_CURRENT_CALLS and determine success that way */
             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
            break;
        case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND:
            // 3GPP 22.030 6.5.5
            // "Releases all active calls (if any exist) and accepts
            // the other (held or waiting) call."
             at_send_command("AT+CHLD=1", NULL);

            /* success or failure is ignored by the upper layer here.
               it will call GET_CURRENT_CALLS and determine success that way */
             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
            break;
        case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE:
            // 3GPP 22.030 6.5.5
            // "Places all active calls (if any exist) on hold and accepts
            // the other (held or waiting) call."
             at_send_command("AT+CHLD=2", NULL);           case ...                break;    default:
            LOGD("Request not supported. Tech: %d",TECH(sMdmInfo));
             RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
            break;
    } } static void requestDial(void *data, size_t datalen, RIL_Token t) { ret = at_send_command(cmd, NULL); /* success or failure is ignored by the upper layer here.
       it will call GET_CURRENT_CALLS and determine success that way */    RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); } int at_send_command (const char *command, ATResponse **pp_outResponse)
{
err = at_send_command_full (command, NO_RESULT, NULL,
                                    NULL, 0, pp_outResponse);
} static int at_send_command_full (const char *command, ATCommandType type,
                    const char *responsePrefix, const char *smspdu,
                    long long timeoutMsec, ATResponse **pp_outResponse)
{ if (0 != pthread_equal( s_tid_reader, pthread_self())) {
        /* cannot be called from reader thread */
        return AT_ERROR_INVALID_THREAD;
    } pthread_mutex_lock(& s_commandmutex);
    err = at_send_command_full_nolock(command, type,
                    responsePrefix, smspdu,
                    timeoutMsec, pp_outResponse);

    pthread_mutex_unlock(& s_commandmutex); } static int at_send_command_full_nolock (const char *command, ATCommandType type,
                    const char *responsePrefix, const char *smspdu,
                    long long timeoutMsec, ATResponse **pp_outResponse) { err = writeline ( command);
   while (sp_response->finalResponse == NULL && s_readerClosed == 0) {
        if (timeoutMsec != 0) {
#ifdef USE_NP
            err = pthread_cond_timeout_np(&s_commandcond, &s_commandmutex, timeoutMsec);
#else
            err = pthread_cond_timedwait(&s_commandcond, &s_commandmutex, &ts);
#endif /*USE_NP*/
        } else { // this thread will be wake up by handleFinalResponse()
            err = pthread_cond_wait(& s_commandcond, & s_commandmutex);
        }
    }
at_response_free(sp_response); }

更多相关文章

随机推荐