RIL 机制---消息从RIL到RILJ

8 RIL -->RILJ

8.1 上报消息处理

ril.cpp的RIL_onUnsolicitedResponse方法主要代码如下,

//得到当前命令的请求码  
    unsolResponseIndex = unsolResponse - RIL_UNSOL_RESPONSE_BASE;  
    //从ril_unsol_commands.h文件中得到命令的类型  
    wakeType = s_unsolResponses[unsolResponseIndex].wakeType;  
    //根据不同命令的不同类型进行解析   
    switch (wakeType) {  
        case WAKE_PARTIAL:  
        case DONT_WAKE:  
    }  
    appendPrintBuf("[UNSL]< %s", requestToString(unsolResponse));  
  
    Parcel p;  
    p.writeInt32 (RESPONSE_UNSOLICITED);  
    p.writeInt32 (unsolResponse);  
    //调用当前命令的打包函数进行数据打包  
    ret = s_unsolResponses[unsolResponseIndex].responseFunction(p, data, datalen);  
    //把数据发送到RILJ中  
    ret = sendResponse(p,id);  

1,调用s_unsolResponses将对应的方法进行打包。

2,调用sendResponse方法将数据发送到RILJ。

s_unsolResponses定义如下,

static UnsolResponseInfo s_unsolResponses[] = {
#include "ril_unsol_commands.h"
};

是一个文件,该文件部分内容如下,

{RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED, responseVoid, WAKE_PARTIAL},
{RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, responseVoid, WAKE_PARTIAL},
{RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, responseVoid, WAKE_PARTIAL},
{RIL_UNSOL_RESPONSE_NEW_SMS, responseString, WAKE_PARTIAL},

和5.2.2 章节的消息封装机制完全一样,只是上报消息和回应消息的区别。

8.2 回应消息处理

ril.cpp的RIL_onRequestComplete方法主要代码如下,

p.writeInt32 (RESPONSE_SOLICITED);
        p.writeInt32 (pRI->token);
        errorOffset = p.dataPosition();

        p.writeInt32 (e);

        if (response != NULL) {
            // there is a response payload, no matter success or not.
            ret = pRI->pCI->responseFunction(p, response, responselen);

            /* if an error occurred, rewind and mark it */
            if (ret != 0) {
                RLOGE ("responseFunction error, ret %d", ret);
                p.setDataPosition(errorOffset);
                p.writeInt32 (ret);
            }
        }

        if (e != RIL_E_SUCCESS) {
            appendPrintBuf("%s fails by %s", printBuf, failCauseToString(e));
        }

        if (fd < 0) {
            RLOGD ("RIL onRequestComplete: Command channel closed");
        }
        sendResponse(p, socket_id);

在RILC发送数据给RILJ之前，会先调用当前命令的回应处理方法，也就是responseFunction，

对将要传输的数据进行差异化处理，然后再通过sendResponse发送给RILJ。

消息封装机制在5.2.2 小节有详细的论述。RIL_REQUEST_DIAL消息对应的类型是responseVoid。该方法如下,

static int responseVoid(Parcel &p, void *response, size_t responselen) {
    startResponse;
    removeLastChar;
    return 0;
}

8.3 将消息发送给RILJ

回应消息和上报消息首先都对消息内容进行了封装打包,然后才进一步调用

sendResponse方法将数据发送到RILJ。其实这里所谓的打包处理，不过是根据不同的命令，

把相应的回应写入到给RILJ的返回数据包中。

sendResponse方法如下,

sendResponse (Parcel &p, RIL_SOCKET_ID socket_id) {
    printResponse;
    return sendResponseRaw(p.data(), p.dataSize(), socket_id);
}

sendResponseRaw方法如下,

int fd = s_ril_param_socket.fdCommand; //发送Socket
int ret;
uint32_t header;
pthread_mutex_t * writeMutexHook = &s_writeMutex;
•••
pthread_mutex_lock(writeMutexHook);
header = htonl(dataSize); //将数据长度这个整数转换为适合Socket  传输的字节顺序
ret = blockingWrite(fd, (void *)&header, sizeof(header));
    if (ret < 0) {
        pthread_mutex_unlock(writeMutexHook);
        return ret;
    }
    ret = blockingWrite(fd, data, dataSize); //发送一个关于数据大小的字节
    if (ret < 0) {
        pthread_mutex_unlock(writeMutexHook);
        return ret;
    }
    pthread_mutex_unlock(writeMutexHook);// 发送数据本身

和RILJ类似,首先发送数据的大小,然后发送数据。

Fd指向的Socket就是端口名为rild的Socket,和RILJ的Socket一致。

#define SOCKET_NAME_RIL "rild"

blockingWrite方法如下,

static int blockingWrite(int fd, const void *buffer, size_t len) {
    size_t writeOffset = 0;
    const uint8_t *toWrite;

    toWrite = (const uint8_t *)buffer;

    while (writeOffset < len) {
        ssize_t written;
        do {
            written = write (fd, toWrite + writeOffset,
                                len - writeOffset);
        } while (written < 0 && ((errno == EINTR) || (errno == EAGAIN)));

        if (written >= 0) {
            writeOffset += written;
        } else {   // written < 0
            RLOGE ("RIL Response: unexpected error on write errno:%d", errno);
            close(fd);
            return -1;
        }
    }
#if VDBG
    RLOGE("RIL Response bytes written:%d", writeOffset);
#endif
    return 0;
}

小结:

Modem上报的消息数据都经过了RIL封包处理,然后才发送到RILJ。