#define LOG_TAG "RILC"
#include <hardware_legacy/power.h>
-
#include <telephony/ril.h>
#include <telephony/ril_cdma_sms.h>
#include <cutils/sockets.h>
#include <pthread.h>
#include <binder/Parcel.h>
#include <cutils/jstring.h>
-
#include <sys/types.h>
#include <sys/limits.h>
+#include <sys/system_properties.h>
#include <pwd.h>
-
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <assert.h>
#include <netinet/in.h>
#include <cutils/properties.h>
+#include <RilSapSocket.h>
-#include <ril_event.h>
+extern "C" void
+RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen);
+extern "C" void
+RIL_onRequestAck(RIL_Token t);
namespace android {
#define PHONE_PROCESS "radio"
+#define BLUETOOTH_PROCESS "bluetooth"
#define SOCKET_NAME_RIL "rild"
+#define SOCKET2_NAME_RIL "rild2"
+#define SOCKET3_NAME_RIL "rild3"
+#define SOCKET4_NAME_RIL "rild4"
+
#define SOCKET_NAME_RIL_DEBUG "rild-debug"
#define ANDROID_WAKE_LOCK_NAME "radio-interface"
+#define ANDROID_WAKE_LOCK_SECS 0
+#define ANDROID_WAKE_LOCK_USECS 200000
#define PROPERTY_RIL_IMPL "gsm.version.ril-impl"
/* Constants for response types */
#define RESPONSE_SOLICITED 0
#define RESPONSE_UNSOLICITED 1
+#define RESPONSE_SOLICITED_ACK 2
+#define RESPONSE_SOLICITED_ACK_EXP 3
+#define RESPONSE_UNSOLICITED_ACK_EXP 4
/* Negative values for private RIL errno's */
#define RIL_ERRNO_INVALID_RESPONSE -1
// request, response, and unsolicited msg print macro
#define PRINTBUF_SIZE 8096
+// Enable verbose logging
+#define VDBG 0
+
// Enable RILC log
#define RILC_LOG 0
struct RequestInfo *p_next;
char cancelled;
char local; // responses to local commands do not go back to command process
+ RIL_SOCKET_ID socket_id;
+ int wasAckSent; // Indicates whether an ack was sent earlier
} RequestInfo;
typedef struct UserCallbackInfo {
struct UserCallbackInfo *p_next;
} UserCallbackInfo;
+extern "C" const char * requestToString(int request);
+extern "C" const char * failCauseToString(RIL_Errno);
+extern "C" const char * callStateToString(RIL_CallState);
+extern "C" const char * radioStateToString(RIL_RadioState);
+extern "C" const char * rilSocketIdToString(RIL_SOCKET_ID socket_id);
+extern "C"
+char rild[MAX_SOCKET_NAME_LENGTH] = SOCKET_NAME_RIL;
/*******************************************************************/
RIL_RadioFunctions s_callbacks = {0, NULL, NULL, NULL, NULL, NULL};
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_fdDebug_socket2 = -1;
static int s_fdWakeupRead;
static int s_fdWakeupWrite;
+int s_wakelock_count = 0;
+
static struct ril_event s_commands_event;
static struct ril_event s_wakeupfd_event;
static struct ril_event s_listen_event;
+static SocketListenParam s_ril_param_socket;
+
+static pthread_mutex_t s_pendingRequestsMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t s_writeMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t s_wakeLockCountMutex = PTHREAD_MUTEX_INITIALIZER;
+static RequestInfo *s_pendingRequests = NULL;
+
+#if (SIM_COUNT >= 2)
+static struct ril_event s_commands_event_socket2;
+static struct ril_event s_listen_event_socket2;
+static SocketListenParam s_ril_param_socket2;
+
+static pthread_mutex_t s_pendingRequestsMutex_socket2 = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t s_writeMutex_socket2 = PTHREAD_MUTEX_INITIALIZER;
+static RequestInfo *s_pendingRequests_socket2 = NULL;
+#endif
+
+#if (SIM_COUNT >= 3)
+static struct ril_event s_commands_event_socket3;
+static struct ril_event s_listen_event_socket3;
+static SocketListenParam s_ril_param_socket3;
+
+static pthread_mutex_t s_pendingRequestsMutex_socket3 = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t s_writeMutex_socket3 = PTHREAD_MUTEX_INITIALIZER;
+static RequestInfo *s_pendingRequests_socket3 = NULL;
+#endif
+
+#if (SIM_COUNT >= 4)
+static struct ril_event s_commands_event_socket4;
+static struct ril_event s_listen_event_socket4;
+static SocketListenParam s_ril_param_socket4;
+
+static pthread_mutex_t s_pendingRequestsMutex_socket4 = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t s_writeMutex_socket4 = PTHREAD_MUTEX_INITIALIZER;
+static RequestInfo *s_pendingRequests_socket4 = NULL;
+#endif
+
static struct ril_event s_wake_timeout_event;
static struct ril_event s_debug_event;
-static const struct timeval TIMEVAL_WAKE_TIMEOUT = {1,0};
+static const struct timeval TIMEVAL_WAKE_TIMEOUT = {ANDROID_WAKE_LOCK_SECS,ANDROID_WAKE_LOCK_USECS};
+
-static pthread_mutex_t s_pendingRequestsMutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t s_writeMutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t s_startupMutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t s_startupCond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t s_dispatchMutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t s_dispatchCond = PTHREAD_COND_INITIALIZER;
-static RequestInfo *s_pendingRequests = NULL;
-
static RequestInfo *s_toDispatchHead = NULL;
static RequestInfo *s_toDispatchTail = NULL;
#endif
/*******************************************************************/
+static int sendResponse (Parcel &p, RIL_SOCKET_ID socket_id);
static void dispatchVoid (Parcel& p, RequestInfo *pRI);
static void dispatchString (Parcel& p, RequestInfo *pRI);
static void dispatchGsmBrSmsCnf(Parcel &p, RequestInfo *pRI);
static void dispatchCdmaBrSmsCnf(Parcel &p, RequestInfo *pRI);
static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI);
+static void dispatchNVReadItem(Parcel &p, RequestInfo *pRI);
+static void dispatchNVWriteItem(Parcel &p, RequestInfo *pRI);
+static void dispatchUiccSubscripton(Parcel &p, RequestInfo *pRI);
+static void dispatchSimAuthentication(Parcel &p, RequestInfo *pRI);
+static void dispatchDataProfile(Parcel &p, RequestInfo *pRI);
+static void dispatchRadioCapability(Parcel &p, RequestInfo *pRI);
static int responseInts(Parcel &p, void *response, size_t responselen);
+static int responseFailCause(Parcel &p, void *response, size_t responselen);
static int responseStrings(Parcel &p, void *response, size_t responselen);
static int responseString(Parcel &p, void *response, size_t responselen);
static int responseVoid(Parcel &p, void *response, size_t responselen);
static int responseCdmaCallWaiting(Parcel &p,void *response, size_t responselen);
static int responseSimRefresh(Parcel &p, void *response, size_t responselen);
static int responseCellInfoList(Parcel &p, void *response, size_t responselen);
+static int responseHardwareConfig(Parcel &p, void *response, size_t responselen);
+static int responseDcRtInfo(Parcel &p, void *response, size_t responselen);
+static int responseRadioCapability(Parcel &p, void *response, size_t responselen);
+static int responseSSData(Parcel &p, void *response, size_t responselen);
+static int responseLceStatus(Parcel &p, void *response, size_t responselen);
+static int responseLceData(Parcel &p, void *response, size_t responselen);
+static int responseActivityData(Parcel &p, void *response, size_t responselen);
static int decodeVoiceRadioTechnology (RIL_RadioState radioState);
static int decodeCdmaSubscriptionSource (RIL_RadioState radioState);
static RIL_RadioState processRadioState(RIL_RadioState newRadioState);
+static void grabPartialWakeLock();
+static void releaseWakeLock();
+static void wakeTimeoutCallback(void *);
-extern "C" const char * requestToString(int request);
-extern "C" const char * failCauseToString(RIL_Errno);
-extern "C" const char * callStateToString(RIL_CallState);
-extern "C" const char * radioStateToString(RIL_RadioState);
+static bool isServiceTypeCfQuery(RIL_SsServiceType serType, RIL_SsRequestType reqType);
+
+static bool isDebuggable();
#ifdef RIL_SHLIB
-extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, void *data,
+#if defined(ANDROID_MULTI_SIM)
+extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
+ size_t datalen, RIL_SOCKET_ID socket_id);
+#else
+extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
size_t datalen);
#endif
+#endif
+
+#if defined(ANDROID_MULTI_SIM)
+#define RIL_UNSOL_RESPONSE(a, b, c, d) RIL_onUnsolicitedResponse((a), (b), (c), (d))
+#define CALL_ONREQUEST(a, b, c, d, e) s_callbacks.onRequest((a), (b), (c), (d), (e))
+#define CALL_ONSTATEREQUEST(a) s_callbacks.onStateRequest(a)
+#else
+#define RIL_UNSOL_RESPONSE(a, b, c, d) RIL_onUnsolicitedResponse((a), (b), (c))
+#define CALL_ONREQUEST(a, b, c, d, e) s_callbacks.onRequest((a), (b), (c), (d))
+#define CALL_ONSTATEREQUEST(a) s_callbacks.onStateRequest()
+#endif
static UserCallbackInfo * internalRequestTimedCallback
(RIL_TimedCallback callback, void *param,
*/
int simRuimStatus = -1;
+static char * RIL_getRilSocketName() {
+ return rild;
+}
+
+extern "C"
+void RIL_setRilSocketName(const char * s) {
+ strncpy(rild, s, MAX_SOCKET_NAME_LENGTH);
+}
+
static char *
strdupReadString(Parcel &p) {
size_t stringlen;
return strndup16to8(s16, stringlen);
}
+static status_t
+readStringFromParcelInplace(Parcel &p, char *str, size_t maxLen) {
+ size_t s16Len;
+ const char16_t *s16;
+
+ s16 = p.readString16Inplace(&s16Len);
+ if (s16 == NULL) {
+ return NO_MEMORY;
+ }
+ size_t strLen = strnlen16to8(s16, s16Len);
+ if ((strLen + 1) > maxLen) {
+ return NO_MEMORY;
+ }
+ if (strncpy16to8(str, s16, strLen) == NULL) {
+ return NO_MEMORY;
+ } else {
+ return NO_ERROR;
+ }
+}
+
static void writeStringToParcel(Parcel &p, const char *s) {
char16_t *s16;
size_t s16_len;
* is not sent back up to the command process
*/
static void
-issueLocalRequest(int request, void *data, int len) {
+issueLocalRequest(int request, void *data, int len, RIL_SOCKET_ID socket_id) {
RequestInfo *pRI;
int ret;
+ /* Hook for current context */
+ /* pendingRequestsMutextHook refer to &s_pendingRequestsMutex */
+ pthread_mutex_t* pendingRequestsMutexHook = &s_pendingRequestsMutex;
+ /* pendingRequestsHook refer to &s_pendingRequests */
+ RequestInfo** pendingRequestsHook = &s_pendingRequests;
+
+#if (SIM_COUNT == 2)
+ if (socket_id == RIL_SOCKET_2) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2;
+ pendingRequestsHook = &s_pendingRequests_socket2;
+ }
+#endif
pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
pRI->local = 1;
pRI->token = 0xffffffff; // token is not used in this context
pRI->pCI = &(s_commands[request]);
+ pRI->socket_id = socket_id;
- ret = pthread_mutex_lock(&s_pendingRequestsMutex);
+ ret = pthread_mutex_lock(pendingRequestsMutexHook);
assert (ret == 0);
- pRI->p_next = s_pendingRequests;
- s_pendingRequests = pRI;
+ pRI->p_next = *pendingRequestsHook;
+ *pendingRequestsHook = pRI;
- ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
+ ret = pthread_mutex_unlock(pendingRequestsMutexHook);
assert (ret == 0);
RLOGD("C[locl]> %s", requestToString(request));
- s_callbacks.onRequest(request, data, len, pRI);
+ CALL_ONREQUEST(request, data, len, pRI, pRI->socket_id);
}
static int
-processCommandBuffer(void *buffer, size_t buflen) {
+processCommandBuffer(void *buffer, size_t buflen, RIL_SOCKET_ID socket_id) {
Parcel p;
status_t status;
int32_t request;
int32_t token;
RequestInfo *pRI;
int ret;
+ /* Hook for current context */
+ /* pendingRequestsMutextHook refer to &s_pendingRequestsMutex */
+ pthread_mutex_t* pendingRequestsMutexHook = &s_pendingRequestsMutex;
+ /* pendingRequestsHook refer to &s_pendingRequests */
+ RequestInfo** pendingRequestsHook = &s_pendingRequests;
p.setData((uint8_t *) buffer, buflen);
status = p.readInt32(&request);
status = p.readInt32 (&token);
+#if (SIM_COUNT >= 2)
+ if (socket_id == RIL_SOCKET_2) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2;
+ pendingRequestsHook = &s_pendingRequests_socket2;
+ }
+#if (SIM_COUNT >= 3)
+ else if (socket_id == RIL_SOCKET_3) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket3;
+ pendingRequestsHook = &s_pendingRequests_socket3;
+ }
+#endif
+#if (SIM_COUNT >= 4)
+ else if (socket_id == RIL_SOCKET_4) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket4;
+ pendingRequestsHook = &s_pendingRequests_socket4;
+ }
+#endif
+#endif
+
if (status != NO_ERROR) {
RLOGE("invalid request block");
return 0;
}
if (request < 1 || request >= (int32_t)NUM_ELEMS(s_commands)) {
+ Parcel pErr;
RLOGE("unsupported request code %d token %d", request, token);
// FIXME this should perhaps return a response
+ pErr.writeInt32 (RESPONSE_SOLICITED);
+ pErr.writeInt32 (token);
+ pErr.writeInt32 (RIL_E_GENERIC_FAILURE);
+
+ sendResponse(pErr, socket_id);
+ return 0;
+ }
+
+ // Received an Ack for the previous result sent to RIL.java,
+ // so release wakelock and exit
+ if (request == RIL_RESPONSE_ACKNOWLEDGEMENT) {
+ releaseWakeLock();
return 0;
}
pRI->token = token;
pRI->pCI = &(s_commands[request]);
+ pRI->socket_id = socket_id;
- ret = pthread_mutex_lock(&s_pendingRequestsMutex);
+ ret = pthread_mutex_lock(pendingRequestsMutexHook);
assert (ret == 0);
- pRI->p_next = s_pendingRequests;
- s_pendingRequests = pRI;
+ pRI->p_next = *pendingRequestsHook;
+ *pendingRequestsHook = pRI;
- ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
+ ret = pthread_mutex_unlock(pendingRequestsMutexHook);
assert (ret == 0);
/* sLastDispatchedToken = token; */
dispatchVoid (Parcel& p, RequestInfo *pRI) {
clearPrintBuf;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, NULL, 0, pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, NULL, 0, pRI, pRI->socket_id);
}
/** Callee expects const char * */
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, string8,
- sizeof(char *), pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, string8,
+ sizeof(char *), pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memsetString(string8);
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, pStrings, datalen, pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, pStrings, datalen, pRI, pRI->socket_id);
if (pStrings != NULL) {
for (int i = 0 ; i < countStrings ; i++) {
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, const_cast<int *>(pInts),
- datalen, pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, const_cast<int *>(pInts),
+ datalen, pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memset(pInts, 0, datalen);
int32_t t;
status_t status;
+ RLOGD("dispatchSmsWrite");
memset (&args, 0, sizeof(args));
status = p.readInt32(&t);
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, &args, sizeof(args), pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &args, sizeof(args), pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memsetString (args.pdu);
int32_t uusPresent;
status_t status;
+ RLOGD("dispatchDial");
memset (&dial, 0, sizeof(dial));
dial.address = strdupReadString(p);
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, &dial, sizeOfDial, pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &dial, sizeOfDial, pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memsetString (dial.address);
int size;
status_t status;
+#if VDBG
+ RLOGD("dispatchSIM_IO");
+#endif
memset (&simIO, 0, sizeof(simIO));
// note we only check status at the end
}
size = (s_callbacks.version < 6) ? sizeof(simIO.v5) : sizeof(simIO.v6);
- s_callbacks.onRequest(pRI->pCI->requestNumber, &simIO, size, pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &simIO, size, pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memsetString (simIO.v6.path);
status_t status;
RIL_SIM_APDU apdu;
+#if VDBG
+ RLOGD("dispatchSIM_APDU");
+#endif
memset (&apdu, 0, sizeof(RIL_SIM_APDU));
// Note we only check status at the end. Any single failure leads to
goto invalid;
}
- s_callbacks.onRequest(pRI->pCI->requestNumber, &apdu, sizeof(RIL_SIM_APDU), pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &apdu, sizeof(RIL_SIM_APDU), pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memsetString(apdu.data);
int32_t t;
status_t status;
+ RLOGD("dispatchCallForward");
memset (&cff, 0, sizeof(cff));
// note we only check status at the end
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, &cff, sizeof(cff), pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &cff, sizeof(cff), pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memsetString(cff.number);
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, const_cast<void *>(data), len, pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, const_cast<void *>(data), len, pRI, pRI->socket_id);
return;
invalid:
dispatchCdmaSms(Parcel &p, RequestInfo *pRI) {
RIL_CDMA_SMS_Message rcsm;
- ALOGD("dispatchCdmaSms");
+ RLOGD("dispatchCdmaSms");
if (NO_ERROR != constructCdmaSms(p, pRI, rcsm)) {
goto invalid;
}
- s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsm, sizeof(rcsm),pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &rcsm, sizeof(rcsm),pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memset(&rcsm, 0, sizeof(rcsm));
RIL_IMS_SMS_Message rism;
RIL_CDMA_SMS_Message rcsm;
- ALOGD("dispatchImsCdmaSms: retry=%d, messageRef=%d", retry, messageRef);
+ RLOGD("dispatchImsCdmaSms: retry=%d, messageRef=%d", retry, messageRef);
if (NO_ERROR != constructCdmaSms(p, pRI, rcsm)) {
goto invalid;
rism.messageRef = messageRef;
rism.message.cdmaMessage = &rcsm;
- s_callbacks.onRequest(pRI->pCI->requestNumber, &rism,
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &rism,
sizeof(RIL_RadioTechnologyFamily)+sizeof(uint8_t)+sizeof(int32_t)
- +sizeof(rcsm),pRI);
+ +sizeof(rcsm),pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memset(&rcsm, 0, sizeof(rcsm));
status_t status;
size_t datalen;
char **pStrings;
- ALOGD("dispatchImsGsmSms: retry=%d, messageRef=%d", retry, messageRef);
+ RLOGD("dispatchImsGsmSms: retry=%d, messageRef=%d", retry, messageRef);
status = p.readInt32 (&countStrings);
rism.messageRef = messageRef;
startRequest;
- appendPrintBuf("%sformat=%d,", printBuf, rism.format);
+ appendPrintBuf("%stech=%d, retry=%d, messageRef=%d, ", printBuf,
+ (int)rism.tech, (int)rism.retry, rism.messageRef);
if (countStrings == 0) {
// just some non-null pointer
pStrings = (char **)alloca(sizeof(char *));
printRequest(pRI->token, pRI->pCI->requestNumber);
rism.message.gsmMessage = pStrings;
- s_callbacks.onRequest(pRI->pCI->requestNumber, &rism,
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &rism,
sizeof(RIL_RadioTechnologyFamily)+sizeof(uint8_t)+sizeof(int32_t)
- +datalen, pRI);
+ +datalen, pRI, pRI->socket_id);
if (pStrings != NULL) {
for (int i = 0 ; i < countStrings ; i++) {
uint8_t retry;
int32_t messageRef;
- ALOGD("dispatchImsSms");
+ RLOGD("dispatchImsSms");
if (status != NO_ERROR) {
goto invalid;
}
status_t status;
int32_t digitCount;
+ RLOGD("dispatchCdmaSmsAck");
memset(&rcsa, 0, sizeof(rcsa));
status = p.readInt32(&t);
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsa, sizeof(rcsa),pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &rcsa, sizeof(rcsa),pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memset(&rcsa, 0, sizeof(rcsa));
goto invalid;
}
- s_callbacks.onRequest(pRI->pCI->requestNumber,
+ CALL_ONREQUEST(pRI->pCI->requestNumber,
gsmBciPtrs,
num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *),
- pRI);
+ pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memset(gsmBci, 0, num * sizeof(RIL_GSM_BroadcastSmsConfigInfo));
goto invalid;
}
- s_callbacks.onRequest(pRI->pCI->requestNumber,
+ CALL_ONREQUEST(pRI->pCI->requestNumber,
cdmaBciPtrs,
num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *),
- pRI);
+ pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memset(cdmaBci, 0, num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo));
uint8_t uct;
status_t status;
int32_t digitCount;
+ int32_t digitLimit;
memset(&rcsw, 0, sizeof(rcsw));
status = p.read(&uct,sizeof(uct));
rcsw.message.sAddress.number_of_digits = (uint8_t) uct;
- for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_ADDRESS_MAX; digitCount ++) {
+ digitLimit = MIN((rcsw.message.sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
+
+ for(digitCount = 0 ; digitCount < digitLimit; digitCount ++) {
status = p.read(&uct,sizeof(uct));
rcsw.message.sAddress.digits[digitCount] = (uint8_t) uct;
}
status = p.read(&uct,sizeof(uct));
rcsw.message.sSubAddress.number_of_digits = (uint8_t) uct;
- for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_SUBADDRESS_MAX; digitCount ++) {
+ digitLimit = MIN((rcsw.message.sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
+
+ for(digitCount = 0 ; digitCount < digitLimit; digitCount ++) {
status = p.read(&uct,sizeof(uct));
rcsw.message.sSubAddress.digits[digitCount] = (uint8_t) uct;
}
status = p.readInt32(&t);
rcsw.message.uBearerDataLen = (int) t;
- for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_BEARER_DATA_MAX; digitCount ++) {
+ digitLimit = MIN((rcsw.message.uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
+
+ for(digitCount = 0 ; digitCount < digitLimit; digitCount ++) {
status = p.read(&uct, sizeof(uct));
rcsw.message.aBearerData[digitCount] = (uint8_t) uct;
}
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsw, sizeof(rcsw),pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &rcsw, sizeof(rcsw),pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memset(&rcsw, 0, sizeof(rcsw));
// When all RILs handle this request, this function can be removed and
// the request can be sent directly to the RIL using dispatchVoid.
static void dispatchVoiceRadioTech(Parcel& p, RequestInfo *pRI) {
- RIL_RadioState state = s_callbacks.onStateRequest();
+ RIL_RadioState state = CALL_ONSTATEREQUEST((RIL_SOCKET_ID)pRI->socket_id);
if ((RADIO_STATE_UNAVAILABLE == state) || (RADIO_STATE_OFF == state)) {
RIL_onRequestComplete(pRI, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
// When all RILs handle this request, this function can be removed and
// the request can be sent directly to the RIL using dispatchVoid.
static void dispatchCdmaSubscriptionSource(Parcel& p, RequestInfo *pRI) {
- RIL_RadioState state = s_callbacks.onStateRequest();
+ RIL_RadioState state = CALL_ONSTATEREQUEST((RIL_SOCKET_ID)pRI->socket_id);
if ((RADIO_STATE_UNAVAILABLE == state) || (RADIO_STATE_OFF == state)) {
RIL_onRequestComplete(pRI, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
pf.password = strdupReadString(p);
startRequest;
- appendPrintBuf("%sapn=%s, protocol=%s, auth_type=%d, username=%s, password=%s",
- printBuf, pf.apn, pf.protocol, pf.auth_type, pf.username, pf.password);
+ appendPrintBuf("%sapn=%s, protocol=%s, authtype=%d, username=%s, password=%s",
+ printBuf, pf.apn, pf.protocol, pf.authtype, pf.username, pf.password);
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
if (status != NO_ERROR) {
goto invalid;
}
- s_callbacks.onRequest(pRI->pCI->requestNumber, &pf, sizeof(pf), pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &pf, sizeof(pf), pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memsetString(pf.apn);
return;
}
-static int
-blockingWrite(int fd, const void *buffer, size_t len) {
- size_t writeOffset = 0;
- const uint8_t *toWrite;
+static void dispatchNVReadItem(Parcel &p, RequestInfo *pRI) {
+ RIL_NV_ReadItem nvri;
+ int32_t t;
+ status_t status;
- toWrite = (const uint8_t *)buffer;
+ memset(&nvri, 0, sizeof(nvri));
- while (writeOffset < len) {
- ssize_t written;
- do {
- written = write (fd, toWrite + writeOffset,
- len - writeOffset);
- } while (written < 0 && ((errno == EINTR) || (errno == EAGAIN)));
+ status = p.readInt32(&t);
+ nvri.itemID = (RIL_NV_Item) t;
- if (written >= 0) {
- writeOffset += written;
- } else { // written < 0
- RLOGE ("RIL Response: unexpected error on write errno:%d", errno);
- close(fd);
- return -1;
- }
+ if (status != NO_ERROR) {
+ goto invalid;
}
- return 0;
+ startRequest;
+ appendPrintBuf("%snvri.itemID=%d, ", printBuf, nvri.itemID);
+ closeRequest;
+
+ printRequest(pRI->token, pRI->pCI->requestNumber);
+
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &nvri, sizeof(nvri), pRI, pRI->socket_id);
+
+#ifdef MEMSET_FREED
+ memset(&nvri, 0, sizeof(nvri));
+#endif
+
+ return;
+
+invalid:
+ invalidCommandBlock(pRI);
+ return;
}
-static int
-sendResponseRaw (const void *data, size_t dataSize) {
- int fd = s_fdCommand;
- int ret;
- uint32_t header;
+static void dispatchNVWriteItem(Parcel &p, RequestInfo *pRI) {
+ RIL_NV_WriteItem nvwi;
+ int32_t t;
+ status_t status;
- if (s_fdCommand < 0) {
- return -1;
- }
+ memset(&nvwi, 0, sizeof(nvwi));
- if (dataSize > MAX_COMMAND_BYTES) {
- RLOGE("RIL: packet larger than %u (%u)",
- MAX_COMMAND_BYTES, (unsigned int )dataSize);
+ status = p.readInt32(&t);
+ nvwi.itemID = (RIL_NV_Item) t;
- return -1;
+ nvwi.value = strdupReadString(p);
+
+ if (status != NO_ERROR || nvwi.value == NULL) {
+ goto invalid;
}
- pthread_mutex_lock(&s_writeMutex);
+ startRequest;
+ appendPrintBuf("%snvwi.itemID=%d, value=%s, ", printBuf, nvwi.itemID,
+ nvwi.value);
+ closeRequest;
- header = htonl(dataSize);
+ printRequest(pRI->token, pRI->pCI->requestNumber);
- ret = blockingWrite(fd, (void *)&header, sizeof(header));
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &nvwi, sizeof(nvwi), pRI, pRI->socket_id);
- if (ret < 0) {
- pthread_mutex_unlock(&s_writeMutex);
- return ret;
- }
+#ifdef MEMSET_FREED
+ memsetString(nvwi.value);
+#endif
- ret = blockingWrite(fd, data, dataSize);
+ free(nvwi.value);
- if (ret < 0) {
- pthread_mutex_unlock(&s_writeMutex);
- return ret;
- }
+#ifdef MEMSET_FREED
+ memset(&nvwi, 0, sizeof(nvwi));
+#endif
- pthread_mutex_unlock(&s_writeMutex);
+ return;
- return 0;
+invalid:
+ invalidCommandBlock(pRI);
+ return;
}
-static int
-sendResponse (Parcel &p) {
- printResponse;
- return sendResponseRaw(p.data(), p.dataSize());
-}
-/** response is an int* pointing to an array of ints*/
+static void dispatchUiccSubscripton(Parcel &p, RequestInfo *pRI) {
+ RIL_SelectUiccSub uicc_sub;
+ status_t status;
+ int32_t t;
+ memset(&uicc_sub, 0, sizeof(uicc_sub));
-static int
-responseInts(Parcel &p, void *response, size_t responselen) {
- int numInts;
+ status = p.readInt32(&t);
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+ uicc_sub.slot = (int) t;
- if (response == NULL && responselen != 0) {
- RLOGE("invalid response: NULL");
- return RIL_ERRNO_INVALID_RESPONSE;
+ status = p.readInt32(&t);
+ if (status != NO_ERROR) {
+ goto invalid;
}
- if (responselen % sizeof(int) != 0) {
- RLOGE("invalid response length %d expected multiple of %d\n",
- (int)responselen, (int)sizeof(int));
- return RIL_ERRNO_INVALID_RESPONSE;
+ uicc_sub.app_index = (int) t;
+
+ status = p.readInt32(&t);
+ if (status != NO_ERROR) {
+ goto invalid;
}
+ uicc_sub.sub_type = (RIL_SubscriptionType) t;
- int *p_int = (int *) response;
+ status = p.readInt32(&t);
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+ uicc_sub.act_status = (RIL_UiccSubActStatus) t;
- numInts = responselen / sizeof(int *);
- p.writeInt32 (numInts);
+ startRequest;
+ appendPrintBuf("slot=%d, app_index=%d, act_status = %d", uicc_sub.slot, uicc_sub.app_index,
+ uicc_sub.act_status);
+ RLOGD("dispatchUiccSubscription, slot=%d, app_index=%d, act_status = %d", uicc_sub.slot,
+ uicc_sub.app_index, uicc_sub.act_status);
+ closeRequest;
+ printRequest(pRI->token, pRI->pCI->requestNumber);
- /* each int*/
- startResponse;
- for (int i = 0 ; i < numInts ; i++) {
- appendPrintBuf("%s%d,", printBuf, p_int[i]);
- p.writeInt32(p_int[i]);
- }
- removeLastChar;
- closeResponse;
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &uicc_sub, sizeof(uicc_sub), pRI, pRI->socket_id);
- return 0;
-}
+#ifdef MEMSET_FREED
+ memset(&uicc_sub, 0, sizeof(uicc_sub));
+#endif
+ return;
-/** response is a char **, pointing to an array of char *'s
- The parcel will begin with the version */
-static int responseStringsWithVersion(int version, Parcel &p, void *response, size_t responselen) {
- p.writeInt32(version);
- return responseStrings(p, response, responselen);
+invalid:
+ invalidCommandBlock(pRI);
+ return;
}
-/** response is a char **, pointing to an array of char *'s */
-static int responseStrings(Parcel &p, void *response, size_t responselen) {
- int numStrings;
+static void dispatchSimAuthentication(Parcel &p, RequestInfo *pRI)
+{
+ RIL_SimAuthentication pf;
+ int32_t t;
+ status_t status;
- if (response == NULL && responselen != 0) {
- RLOGE("invalid response: NULL");
- return RIL_ERRNO_INVALID_RESPONSE;
- }
- if (responselen % sizeof(char *) != 0) {
- RLOGE("invalid response length %d expected multiple of %d\n",
- (int)responselen, (int)sizeof(char *));
- return RIL_ERRNO_INVALID_RESPONSE;
- }
+ memset(&pf, 0, sizeof(pf));
- if (response == NULL) {
- p.writeInt32 (0);
- } else {
- char **p_cur = (char **) response;
+ status = p.readInt32(&t);
+ pf.authContext = (int) t;
+ pf.authData = strdupReadString(p);
+ pf.aid = strdupReadString(p);
- numStrings = responselen / sizeof(char *);
- p.writeInt32 (numStrings);
+ startRequest;
+ appendPrintBuf("authContext=%s, authData=%s, aid=%s", pf.authContext, pf.authData, pf.aid);
+ closeRequest;
+ printRequest(pRI->token, pRI->pCI->requestNumber);
- /* each string*/
- startResponse;
- for (int i = 0 ; i < numStrings ; i++) {
- appendPrintBuf("%s%s,", printBuf, (char*)p_cur[i]);
- writeStringToParcel (p, p_cur[i]);
- }
- removeLastChar;
- closeResponse;
+ if (status != NO_ERROR) {
+ goto invalid;
}
- return 0;
-}
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &pf, sizeof(pf), pRI, pRI->socket_id);
+#ifdef MEMSET_FREED
+ memsetString(pf.authData);
+ memsetString(pf.aid);
+#endif
-/**
- * NULL strings are accepted
- * FIXME currently ignores responselen
- */
-static int responseString(Parcel &p, void *response, size_t responselen) {
- /* one string only */
- startResponse;
- appendPrintBuf("%s%s", printBuf, (char*)response);
- closeResponse;
+ free(pf.authData);
+ free(pf.aid);
- writeStringToParcel(p, (const char *)response);
+#ifdef MEMSET_FREED
+ memset(&pf, 0, sizeof(pf));
+#endif
+
+ return;
+invalid:
+ invalidCommandBlock(pRI);
+ return;
+}
+
+static void dispatchDataProfile(Parcel &p, RequestInfo *pRI) {
+ int32_t t;
+ status_t status;
+ int32_t num;
+
+ status = p.readInt32(&num);
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+
+ {
+ RIL_DataProfileInfo dataProfiles[num];
+ RIL_DataProfileInfo *dataProfilePtrs[num];
+
+ startRequest;
+ for (int i = 0 ; i < num ; i++ ) {
+ dataProfilePtrs[i] = &dataProfiles[i];
+
+ status = p.readInt32(&t);
+ dataProfiles[i].profileId = (int) t;
+
+ dataProfiles[i].apn = strdupReadString(p);
+ dataProfiles[i].protocol = strdupReadString(p);
+ status = p.readInt32(&t);
+ dataProfiles[i].authType = (int) t;
+
+ dataProfiles[i].user = strdupReadString(p);
+ dataProfiles[i].password = strdupReadString(p);
+
+ status = p.readInt32(&t);
+ dataProfiles[i].type = (int) t;
+
+ status = p.readInt32(&t);
+ dataProfiles[i].maxConnsTime = (int) t;
+ status = p.readInt32(&t);
+ dataProfiles[i].maxConns = (int) t;
+ status = p.readInt32(&t);
+ dataProfiles[i].waitTime = (int) t;
+
+ status = p.readInt32(&t);
+ dataProfiles[i].enabled = (int) t;
+
+ appendPrintBuf("%s [%d: profileId=%d, apn =%s, protocol =%s, authType =%d, \
+ user =%s, password =%s, type =%d, maxConnsTime =%d, maxConns =%d, \
+ waitTime =%d, enabled =%d]", printBuf, i, dataProfiles[i].profileId,
+ dataProfiles[i].apn, dataProfiles[i].protocol, dataProfiles[i].authType,
+ dataProfiles[i].user, dataProfiles[i].password, dataProfiles[i].type,
+ dataProfiles[i].maxConnsTime, dataProfiles[i].maxConns,
+ dataProfiles[i].waitTime, dataProfiles[i].enabled);
+ }
+ closeRequest;
+ printRequest(pRI->token, pRI->pCI->requestNumber);
+
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+ CALL_ONREQUEST(pRI->pCI->requestNumber,
+ dataProfilePtrs,
+ num * sizeof(RIL_DataProfileInfo *),
+ pRI, pRI->socket_id);
+
+#ifdef MEMSET_FREED
+ memset(dataProfiles, 0, num * sizeof(RIL_DataProfileInfo));
+ memset(dataProfilePtrs, 0, num * sizeof(RIL_DataProfileInfo *));
+#endif
+ }
+
+ return;
+
+invalid:
+ invalidCommandBlock(pRI);
+ return;
+}
+
+static void dispatchRadioCapability(Parcel &p, RequestInfo *pRI){
+ RIL_RadioCapability rc;
+ int32_t t;
+ status_t status;
+
+ memset (&rc, 0, sizeof(RIL_RadioCapability));
+
+ status = p.readInt32(&t);
+ rc.version = (int)t;
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+
+ status = p.readInt32(&t);
+ rc.session= (int)t;
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+
+ status = p.readInt32(&t);
+ rc.phase= (int)t;
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+
+ status = p.readInt32(&t);
+ rc.rat = (int)t;
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+
+ status = readStringFromParcelInplace(p, rc.logicalModemUuid, sizeof(rc.logicalModemUuid));
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+
+ status = p.readInt32(&t);
+ rc.status = (int)t;
+
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+
+ startRequest;
+ appendPrintBuf("%s [version:%d, session:%d, phase:%d, rat:%d, \
+ logicalModemUuid:%s, status:%d", printBuf, rc.version, rc.session,
+ rc.phase, rc.rat, rc.logicalModemUuid, rc.session);
+
+ closeRequest;
+ printRequest(pRI->token, pRI->pCI->requestNumber);
+
+ CALL_ONREQUEST(pRI->pCI->requestNumber,
+ &rc,
+ sizeof(RIL_RadioCapability),
+ pRI, pRI->socket_id);
+ return;
+invalid:
+ invalidCommandBlock(pRI);
+ return;
+}
+
+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;
+}
+
+static int
+sendResponseRaw (const void *data, size_t dataSize, RIL_SOCKET_ID socket_id) {
+ int fd = s_ril_param_socket.fdCommand;
+ int ret;
+ uint32_t header;
+ pthread_mutex_t * writeMutexHook = &s_writeMutex;
+
+#if VDBG
+ RLOGE("Send Response to %s", rilSocketIdToString(socket_id));
+#endif
+
+#if (SIM_COUNT >= 2)
+ if (socket_id == RIL_SOCKET_2) {
+ fd = s_ril_param_socket2.fdCommand;
+ writeMutexHook = &s_writeMutex_socket2;
+ }
+#if (SIM_COUNT >= 3)
+ else if (socket_id == RIL_SOCKET_3) {
+ fd = s_ril_param_socket3.fdCommand;
+ writeMutexHook = &s_writeMutex_socket3;
+ }
+#endif
+#if (SIM_COUNT >= 4)
+ else if (socket_id == RIL_SOCKET_4) {
+ fd = s_ril_param_socket4.fdCommand;
+ writeMutexHook = &s_writeMutex_socket4;
+ }
+#endif
+#endif
+ if (fd < 0) {
+ return -1;
+ }
+
+ if (dataSize > MAX_COMMAND_BYTES) {
+ RLOGE("RIL: packet larger than %u (%u)",
+ MAX_COMMAND_BYTES, (unsigned int )dataSize);
+
+ return -1;
+ }
+
+ pthread_mutex_lock(writeMutexHook);
+
+ header = htonl(dataSize);
+
+ 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);
+
+ return 0;
+}
+
+static int
+sendResponse (Parcel &p, RIL_SOCKET_ID socket_id) {
+ printResponse;
+ return sendResponseRaw(p.data(), p.dataSize(), socket_id);
+}
+
+/** response is an int* pointing to an array of ints */
+
+static int
+responseInts(Parcel &p, void *response, size_t responselen) {
+ int numInts;
+
+ if (response == NULL && responselen != 0) {
+ RLOGE("invalid response: NULL");
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+ if (responselen % sizeof(int) != 0) {
+ RLOGE("responseInts: invalid response length %d expected multiple of %d\n",
+ (int)responselen, (int)sizeof(int));
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ int *p_int = (int *) response;
+
+ numInts = responselen / sizeof(int);
+ p.writeInt32 (numInts);
+
+ /* each int*/
+ startResponse;
+ for (int i = 0 ; i < numInts ; i++) {
+ appendPrintBuf("%s%d,", printBuf, p_int[i]);
+ p.writeInt32(p_int[i]);
+ }
+ removeLastChar;
+ closeResponse;
+
+ return 0;
+}
+
+// Response is an int or RIL_LastCallFailCauseInfo.
+// Currently, only Shamu plans to use RIL_LastCallFailCauseInfo.
+// TODO(yjl): Let all implementations use RIL_LastCallFailCauseInfo.
+static int responseFailCause(Parcel &p, void *response, size_t responselen) {
+ if (response == NULL && responselen != 0) {
+ RLOGE("invalid response: NULL");
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ if (responselen == sizeof(int)) {
+ startResponse;
+ int *p_int = (int *) response;
+ appendPrintBuf("%s%d,", printBuf, p_int[0]);
+ p.writeInt32(p_int[0]);
+ removeLastChar;
+ closeResponse;
+ } else if (responselen == sizeof(RIL_LastCallFailCauseInfo)) {
+ startResponse;
+ RIL_LastCallFailCauseInfo *p_fail_cause_info = (RIL_LastCallFailCauseInfo *) response;
+ appendPrintBuf("%s[cause_code=%d,vendor_cause=%s]", printBuf, p_fail_cause_info->cause_code,
+ p_fail_cause_info->vendor_cause);
+ p.writeInt32(p_fail_cause_info->cause_code);
+ writeStringToParcel(p, p_fail_cause_info->vendor_cause);
+ removeLastChar;
+ closeResponse;
+ } else {
+ RLOGE("responseFailCause: invalid response length %d expected an int or "
+ "RIL_LastCallFailCauseInfo", (int)responselen);
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ return 0;
+}
+
+/** response is a char **, pointing to an array of char *'s
+ The parcel will begin with the version */
+static int responseStringsWithVersion(int version, Parcel &p, void *response, size_t responselen) {
+ p.writeInt32(version);
+ return responseStrings(p, response, responselen);
+}
+
+/** response is a char **, pointing to an array of char *'s */
+static int responseStrings(Parcel &p, void *response, size_t responselen) {
+ int numStrings;
+
+ if (response == NULL && responselen != 0) {
+ RLOGE("invalid response: NULL");
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+ if (responselen % sizeof(char *) != 0) {
+ RLOGE("responseStrings: invalid response length %d expected multiple of %d\n",
+ (int)responselen, (int)sizeof(char *));
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ if (response == NULL) {
+ p.writeInt32 (0);
+ } else {
+ char **p_cur = (char **) response;
+
+ numStrings = responselen / sizeof(char *);
+ p.writeInt32 (numStrings);
+
+ /* each string*/
+ startResponse;
+ for (int i = 0 ; i < numStrings ; i++) {
+ appendPrintBuf("%s%s,", printBuf, (char*)p_cur[i]);
+ writeStringToParcel (p, p_cur[i]);
+ }
+ removeLastChar;
+ closeResponse;
+ }
+ return 0;
+}
+
+
+/**
+ * NULL strings are accepted
+ * FIXME currently ignores responselen
+ */
+static int responseString(Parcel &p, void *response, size_t responselen) {
+ /* one string only */
+ startResponse;
+ appendPrintBuf("%s%s", printBuf, (char*)response);
+ closeResponse;
+
+ writeStringToParcel(p, (const char *)response);
return 0;
}
}
if (responselen % sizeof (RIL_Call *) != 0) {
- RLOGE("invalid response length %d expected multiple of %d\n",
+ RLOGE("responseCallList: invalid response length %d expected multiple of %d\n",
(int)responselen, (int)sizeof (RIL_Call *));
return RIL_ERRNO_INVALID_RESPONSE;
}
}
if (responselen % sizeof(RIL_Data_Call_Response_v4) != 0) {
- RLOGE("invalid response length %d expected multiple of %d",
+ RLOGE("responseDataCallListV4: invalid response length %d expected multiple of %d",
(int)responselen, (int)sizeof(RIL_Data_Call_Response_v4));
return RIL_ERRNO_INVALID_RESPONSE;
}
+ // Write version
+ p.writeInt32(4);
+
int num = responselen / sizeof(RIL_Data_Call_Response_v4);
p.writeInt32(num);
return 0;
}
-static int responseDataCallList(Parcel &p, void *response, size_t responselen)
+static int responseDataCallListV6(Parcel &p, void *response, size_t responselen)
{
+ if (response == NULL && responselen != 0) {
+ RLOGE("invalid response: NULL");
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ if (responselen % sizeof(RIL_Data_Call_Response_v6) != 0) {
+ RLOGE("responseDataCallListV6: invalid response length %d expected multiple of %d",
+ (int)responselen, (int)sizeof(RIL_Data_Call_Response_v6));
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
// Write version
- p.writeInt32(s_callbacks.version);
+ p.writeInt32(6);
- if (s_callbacks.version < 5) {
- return responseDataCallListV4(p, response, responselen);
- } else {
- if (response == NULL && responselen != 0) {
- RLOGE("invalid response: NULL");
- return RIL_ERRNO_INVALID_RESPONSE;
- }
+ int num = responselen / sizeof(RIL_Data_Call_Response_v6);
+ p.writeInt32(num);
- if (responselen % sizeof(RIL_Data_Call_Response_v6) != 0) {
- RLOGE("invalid response length %d expected multiple of %d",
- (int)responselen, (int)sizeof(RIL_Data_Call_Response_v6));
- return RIL_ERRNO_INVALID_RESPONSE;
- }
+ RIL_Data_Call_Response_v6 *p_cur = (RIL_Data_Call_Response_v6 *) response;
+ startResponse;
+ int i;
+ for (i = 0; i < num; i++) {
+ p.writeInt32((int)p_cur[i].status);
+ p.writeInt32(p_cur[i].suggestedRetryTime);
+ p.writeInt32(p_cur[i].cid);
+ p.writeInt32(p_cur[i].active);
+ writeStringToParcel(p, p_cur[i].type);
+ writeStringToParcel(p, p_cur[i].ifname);
+ writeStringToParcel(p, p_cur[i].addresses);
+ writeStringToParcel(p, p_cur[i].dnses);
+ writeStringToParcel(p, p_cur[i].gateways);
+ appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s],", printBuf,
+ p_cur[i].status,
+ p_cur[i].suggestedRetryTime,
+ p_cur[i].cid,
+ (p_cur[i].active==0)?"down":"up",
+ (char*)p_cur[i].type,
+ (char*)p_cur[i].ifname,
+ (char*)p_cur[i].addresses,
+ (char*)p_cur[i].dnses,
+ (char*)p_cur[i].gateways);
+ }
+ removeLastChar;
+ closeResponse;
- int num = responselen / sizeof(RIL_Data_Call_Response_v6);
- p.writeInt32(num);
+ return 0;
+}
- RIL_Data_Call_Response_v6 *p_cur = (RIL_Data_Call_Response_v6 *) response;
- startResponse;
- int i;
- for (i = 0; i < num; i++) {
- p.writeInt32((int)p_cur[i].status);
- p.writeInt32(p_cur[i].suggestedRetryTime);
- p.writeInt32(p_cur[i].cid);
- p.writeInt32(p_cur[i].active);
- writeStringToParcel(p, p_cur[i].type);
- writeStringToParcel(p, p_cur[i].ifname);
- writeStringToParcel(p, p_cur[i].addresses);
- writeStringToParcel(p, p_cur[i].dnses);
- writeStringToParcel(p, p_cur[i].gateways);
- appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s],", printBuf,
- p_cur[i].status,
- p_cur[i].suggestedRetryTime,
- p_cur[i].cid,
- (p_cur[i].active==0)?"down":"up",
- (char*)p_cur[i].type,
- (char*)p_cur[i].ifname,
- (char*)p_cur[i].addresses,
- (char*)p_cur[i].dnses,
- (char*)p_cur[i].gateways);
- }
- removeLastChar;
- closeResponse;
+static int responseDataCallListV9(Parcel &p, void *response, size_t responselen)
+{
+ if (response == NULL && responselen != 0) {
+ RLOGE("invalid response: NULL");
+ return RIL_ERRNO_INVALID_RESPONSE;
}
+ if (responselen % sizeof(RIL_Data_Call_Response_v9) != 0) {
+ RLOGE("responseDataCallListV9: invalid response length %d expected multiple of %d",
+ (int)responselen, (int)sizeof(RIL_Data_Call_Response_v9));
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ // Write version
+ p.writeInt32(10);
+
+ int num = responselen / sizeof(RIL_Data_Call_Response_v9);
+ p.writeInt32(num);
+
+ RIL_Data_Call_Response_v9 *p_cur = (RIL_Data_Call_Response_v9 *) response;
+ startResponse;
+ int i;
+ for (i = 0; i < num; i++) {
+ p.writeInt32((int)p_cur[i].status);
+ p.writeInt32(p_cur[i].suggestedRetryTime);
+ p.writeInt32(p_cur[i].cid);
+ p.writeInt32(p_cur[i].active);
+ writeStringToParcel(p, p_cur[i].type);
+ writeStringToParcel(p, p_cur[i].ifname);
+ writeStringToParcel(p, p_cur[i].addresses);
+ writeStringToParcel(p, p_cur[i].dnses);
+ writeStringToParcel(p, p_cur[i].gateways);
+ writeStringToParcel(p, p_cur[i].pcscf);
+ appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s,%s],", printBuf,
+ p_cur[i].status,
+ p_cur[i].suggestedRetryTime,
+ p_cur[i].cid,
+ (p_cur[i].active==0)?"down":"up",
+ (char*)p_cur[i].type,
+ (char*)p_cur[i].ifname,
+ (char*)p_cur[i].addresses,
+ (char*)p_cur[i].dnses,
+ (char*)p_cur[i].gateways,
+ (char*)p_cur[i].pcscf);
+ }
+ removeLastChar;
+ closeResponse;
+
+ return 0;
+}
+
+static int responseDataCallListV11(Parcel &p, void *response, size_t responselen) {
+ if (response == NULL && responselen != 0) {
+ RLOGE("invalid response: NULL");
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ if (responselen % sizeof(RIL_Data_Call_Response_v11) != 0) {
+ RLOGE("invalid response length %d expected multiple of %d",
+ (int)responselen, (int)sizeof(RIL_Data_Call_Response_v11));
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ // Write version
+ p.writeInt32(11);
+
+ int num = responselen / sizeof(RIL_Data_Call_Response_v11);
+ p.writeInt32(num);
+
+ RIL_Data_Call_Response_v11 *p_cur = (RIL_Data_Call_Response_v11 *) response;
+ startResponse;
+ int i;
+ for (i = 0; i < num; i++) {
+ p.writeInt32((int)p_cur[i].status);
+ p.writeInt32(p_cur[i].suggestedRetryTime);
+ p.writeInt32(p_cur[i].cid);
+ p.writeInt32(p_cur[i].active);
+ writeStringToParcel(p, p_cur[i].type);
+ writeStringToParcel(p, p_cur[i].ifname);
+ writeStringToParcel(p, p_cur[i].addresses);
+ writeStringToParcel(p, p_cur[i].dnses);
+ writeStringToParcel(p, p_cur[i].gateways);
+ writeStringToParcel(p, p_cur[i].pcscf);
+ p.writeInt32(p_cur[i].mtu);
+ appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s,%s,mtu=%d],", printBuf,
+ p_cur[i].status,
+ p_cur[i].suggestedRetryTime,
+ p_cur[i].cid,
+ (p_cur[i].active==0)?"down":"up",
+ (char*)p_cur[i].type,
+ (char*)p_cur[i].ifname,
+ (char*)p_cur[i].addresses,
+ (char*)p_cur[i].dnses,
+ (char*)p_cur[i].gateways,
+ (char*)p_cur[i].pcscf,
+ p_cur[i].mtu);
+ }
+ removeLastChar;
+ closeResponse;
+
return 0;
}
+static int responseDataCallList(Parcel &p, void *response, size_t responselen)
+{
+ if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) {
+ if (s_callbacks.version < 5) {
+ RLOGD("responseDataCallList: v4");
+ return responseDataCallListV4(p, response, responselen);
+ } else if (responselen % sizeof(RIL_Data_Call_Response_v6) == 0) {
+ return responseDataCallListV6(p, response, responselen);
+ } else if (responselen % sizeof(RIL_Data_Call_Response_v9) == 0) {
+ return responseDataCallListV9(p, response, responselen);
+ } else {
+ return responseDataCallListV11(p, response, responselen);
+ }
+ } else { // RIL version >= 13
+ if (responselen % sizeof(RIL_Data_Call_Response_v11) != 0) {
+ RLOGE("Data structure expected is RIL_Data_Call_Response_v11");
+ if (!isDebuggable()) {
+ return RIL_ERRNO_INVALID_RESPONSE;
+ } else {
+ assert(0);
+ }
+ }
+ return responseDataCallListV11(p, response, responselen);
+ }
+}
+
static int responseSetupDataCall(Parcel &p, void *response, size_t responselen)
{
if (s_callbacks.version < 5) {
}
if (responselen % sizeof(RIL_CallForwardInfo *) != 0) {
- RLOGE("invalid response length %d expected multiple of %d",
+ RLOGE("responseCallForwards: invalid response length %d expected multiple of %d",
(int)responselen, (int)sizeof(RIL_CallForwardInfo *));
return RIL_ERRNO_INVALID_RESPONSE;
}
}
if (responselen % sizeof (RIL_NeighboringCell *) != 0) {
- RLOGE("invalid response length %d expected multiple of %d\n",
+ RLOGE("responseCellList: invalid response length %d expected multiple of %d\n",
(int)responselen, (int)sizeof (RIL_NeighboringCell *));
return RIL_ERRNO_INVALID_RESPONSE;
}
}
if (responselen != sizeof (RIL_CDMA_InformationRecords)) {
- RLOGE("invalid response length %d expected multiple of %d\n",
+ RLOGE("responseCdmaInformationRecords: invalid response length %d expected multiple of %d\n",
(int)responselen, (int)sizeof (RIL_CDMA_InformationRecords *));
return RIL_ERRNO_INVALID_RESPONSE;
}
return 0;
}
+static void responseRilSignalStrengthV5(Parcel &p, RIL_SignalStrength_v10 *p_cur) {
+ p.writeInt32(p_cur->GW_SignalStrength.signalStrength);
+ p.writeInt32(p_cur->GW_SignalStrength.bitErrorRate);
+ p.writeInt32(p_cur->CDMA_SignalStrength.dbm);
+ p.writeInt32(p_cur->CDMA_SignalStrength.ecio);
+ p.writeInt32(p_cur->EVDO_SignalStrength.dbm);
+ p.writeInt32(p_cur->EVDO_SignalStrength.ecio);
+ p.writeInt32(p_cur->EVDO_SignalStrength.signalNoiseRatio);
+}
+
+static void responseRilSignalStrengthV6Extra(Parcel &p, RIL_SignalStrength_v10 *p_cur) {
+ /*
+ * Fixup LTE for backwards compatibility
+ */
+ // signalStrength: -1 -> 99
+ if (p_cur->LTE_SignalStrength.signalStrength == -1) {
+ p_cur->LTE_SignalStrength.signalStrength = 99;
+ }
+ // rsrp: -1 -> INT_MAX all other negative value to positive.
+ // So remap here
+ if (p_cur->LTE_SignalStrength.rsrp == -1) {
+ p_cur->LTE_SignalStrength.rsrp = INT_MAX;
+ } else if (p_cur->LTE_SignalStrength.rsrp < -1) {
+ p_cur->LTE_SignalStrength.rsrp = -p_cur->LTE_SignalStrength.rsrp;
+ }
+ // rsrq: -1 -> INT_MAX
+ if (p_cur->LTE_SignalStrength.rsrq == -1) {
+ p_cur->LTE_SignalStrength.rsrq = INT_MAX;
+ }
+ // Not remapping rssnr is already using INT_MAX
+
+ // cqi: -1 -> INT_MAX
+ if (p_cur->LTE_SignalStrength.cqi == -1) {
+ p_cur->LTE_SignalStrength.cqi = INT_MAX;
+ }
+
+ p.writeInt32(p_cur->LTE_SignalStrength.signalStrength);
+ p.writeInt32(p_cur->LTE_SignalStrength.rsrp);
+ p.writeInt32(p_cur->LTE_SignalStrength.rsrq);
+ p.writeInt32(p_cur->LTE_SignalStrength.rssnr);
+ p.writeInt32(p_cur->LTE_SignalStrength.cqi);
+}
+
+static void responseRilSignalStrengthV10(Parcel &p, RIL_SignalStrength_v10 *p_cur) {
+ responseRilSignalStrengthV5(p, p_cur);
+ responseRilSignalStrengthV6Extra(p, p_cur);
+ p.writeInt32(p_cur->TD_SCDMA_SignalStrength.rscp);
+}
+
static int responseRilSignalStrength(Parcel &p,
void *response, size_t responselen) {
if (response == NULL && responselen != 0) {
return RIL_ERRNO_INVALID_RESPONSE;
}
- if (responselen >= sizeof (RIL_SignalStrength_v5)) {
- RIL_SignalStrength_v6 *p_cur = ((RIL_SignalStrength_v6 *) response);
-
- p.writeInt32(p_cur->GW_SignalStrength.signalStrength);
- p.writeInt32(p_cur->GW_SignalStrength.bitErrorRate);
- p.writeInt32(p_cur->CDMA_SignalStrength.dbm);
- p.writeInt32(p_cur->CDMA_SignalStrength.ecio);
- p.writeInt32(p_cur->EVDO_SignalStrength.dbm);
- p.writeInt32(p_cur->EVDO_SignalStrength.ecio);
- p.writeInt32(p_cur->EVDO_SignalStrength.signalNoiseRatio);
- if (responselen >= sizeof (RIL_SignalStrength_v6)) {
- /*
- * Fixup LTE for backwards compatibility
- */
- if (s_callbacks.version <= 6) {
- // signalStrength: -1 -> 99
- if (p_cur->LTE_SignalStrength.signalStrength == -1) {
- p_cur->LTE_SignalStrength.signalStrength = 99;
- }
- // rsrp: -1 -> INT_MAX all other negative value to positive.
- // So remap here
- if (p_cur->LTE_SignalStrength.rsrp == -1) {
- p_cur->LTE_SignalStrength.rsrp = INT_MAX;
- } else if (p_cur->LTE_SignalStrength.rsrp < -1) {
- p_cur->LTE_SignalStrength.rsrp = -p_cur->LTE_SignalStrength.rsrp;
- }
- // rsrq: -1 -> INT_MAX
- if (p_cur->LTE_SignalStrength.rsrq == -1) {
- p_cur->LTE_SignalStrength.rsrq = INT_MAX;
- }
- // Not remapping rssnr is already using INT_MAX
+ if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) {
+ if (responselen >= sizeof (RIL_SignalStrength_v5)) {
+ RIL_SignalStrength_v10 *p_cur = ((RIL_SignalStrength_v10 *) response);
+
+ responseRilSignalStrengthV5(p, p_cur);
- // cqi: -1 -> INT_MAX
- if (p_cur->LTE_SignalStrength.cqi == -1) {
- p_cur->LTE_SignalStrength.cqi = INT_MAX;
+ if (responselen >= sizeof (RIL_SignalStrength_v6)) {
+ responseRilSignalStrengthV6Extra(p, p_cur);
+ if (responselen >= sizeof (RIL_SignalStrength_v10)) {
+ p.writeInt32(p_cur->TD_SCDMA_SignalStrength.rscp);
+ } else {
+ p.writeInt32(INT_MAX);
}
+ } else {
+ p.writeInt32(99);
+ p.writeInt32(INT_MAX);
+ p.writeInt32(INT_MAX);
+ p.writeInt32(INT_MAX);
+ p.writeInt32(INT_MAX);
+ p.writeInt32(INT_MAX);
}
- p.writeInt32(p_cur->LTE_SignalStrength.signalStrength);
- p.writeInt32(p_cur->LTE_SignalStrength.rsrp);
- p.writeInt32(p_cur->LTE_SignalStrength.rsrq);
- p.writeInt32(p_cur->LTE_SignalStrength.rssnr);
- p.writeInt32(p_cur->LTE_SignalStrength.cqi);
} else {
- p.writeInt32(99);
- p.writeInt32(INT_MAX);
- p.writeInt32(INT_MAX);
- p.writeInt32(INT_MAX);
- p.writeInt32(INT_MAX);
+ RLOGE("invalid response length");
+ return RIL_ERRNO_INVALID_RESPONSE;
}
-
- startResponse;
- appendPrintBuf("%s[signalStrength=%d,bitErrorRate=%d,\
- CDMA_SS.dbm=%d,CDMA_SSecio=%d,\
- EVDO_SS.dbm=%d,EVDO_SS.ecio=%d,\
- EVDO_SS.signalNoiseRatio=%d,\
- LTE_SS.signalStrength=%d,LTE_SS.rsrp=%d,LTE_SS.rsrq=%d,\
- LTE_SS.rssnr=%d,LTE_SS.cqi=%d]",
- printBuf,
- p_cur->GW_SignalStrength.signalStrength,
- p_cur->GW_SignalStrength.bitErrorRate,
- p_cur->CDMA_SignalStrength.dbm,
- p_cur->CDMA_SignalStrength.ecio,
- p_cur->EVDO_SignalStrength.dbm,
- p_cur->EVDO_SignalStrength.ecio,
- p_cur->EVDO_SignalStrength.signalNoiseRatio,
- p_cur->LTE_SignalStrength.signalStrength,
- p_cur->LTE_SignalStrength.rsrp,
- p_cur->LTE_SignalStrength.rsrq,
- p_cur->LTE_SignalStrength.rssnr,
- p_cur->LTE_SignalStrength.cqi);
- closeResponse;
-
- } else {
- RLOGE("invalid response length");
- return RIL_ERRNO_INVALID_RESPONSE;
+ } else { // RIL version >= 13
+ if (responselen % sizeof(RIL_SignalStrength_v10) != 0) {
+ RLOGE("Data structure expected is RIL_SignalStrength_v10");
+ if (!isDebuggable()) {
+ return RIL_ERRNO_INVALID_RESPONSE;
+ } else {
+ assert(0);
+ }
+ }
+ RIL_SignalStrength_v10 *p_cur = ((RIL_SignalStrength_v10 *) response);
+ responseRilSignalStrengthV10(p, p_cur);
}
-
+ startResponse;
+ appendPrintBuf("%s[signalStrength=%d,bitErrorRate=%d,\
+ CDMA_SS.dbm=%d,CDMA_SSecio=%d,\
+ EVDO_SS.dbm=%d,EVDO_SS.ecio=%d,\
+ EVDO_SS.signalNoiseRatio=%d,\
+ LTE_SS.signalStrength=%d,LTE_SS.rsrp=%d,LTE_SS.rsrq=%d,\
+ LTE_SS.rssnr=%d,LTE_SS.cqi=%d,TDSCDMA_SS.rscp=%d]",
+ printBuf,
+ p_cur->GW_SignalStrength.signalStrength,
+ p_cur->GW_SignalStrength.bitErrorRate,
+ p_cur->CDMA_SignalStrength.dbm,
+ p_cur->CDMA_SignalStrength.ecio,
+ p_cur->EVDO_SignalStrength.dbm,
+ p_cur->EVDO_SignalStrength.ecio,
+ p_cur->EVDO_SignalStrength.signalNoiseRatio,
+ p_cur->LTE_SignalStrength.signalStrength,
+ p_cur->LTE_SignalStrength.rsrp,
+ p_cur->LTE_SignalStrength.rsrq,
+ p_cur->LTE_SignalStrength.rssnr,
+ p_cur->LTE_SignalStrength.cqi,
+ p_cur->TD_SCDMA_SignalStrength.rscp);
+ closeResponse;
return 0;
}
writeStringToParcel(p, p_cur->name);
marshallSignalInfoRecord(p, p_cur->signalInfoRecord);
- if (responselen >= sizeof(RIL_CDMA_CallWaiting_v6)) {
+ if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) {
+ if (responselen >= sizeof(RIL_CDMA_CallWaiting_v6)) {
+ p.writeInt32(p_cur->number_type);
+ p.writeInt32(p_cur->number_plan);
+ } else {
+ p.writeInt32(0);
+ p.writeInt32(0);
+ }
+ } else { // RIL version >= 13
+ if (responselen % sizeof(RIL_CDMA_CallWaiting_v6) != 0) {
+ RLOGE("Data structure expected is RIL_CDMA_CallWaiting_v6");
+ if (!isDebuggable()) {
+ return RIL_ERRNO_INVALID_RESPONSE;
+ } else {
+ assert(0);
+ }
+ }
p.writeInt32(p_cur->number_type);
p.writeInt32(p_cur->number_plan);
- } else {
- p.writeInt32(0);
- p.writeInt32(0);
}
startResponse;
return 0;
}
+static void responseSimRefreshV7(Parcel &p, void *response) {
+ RIL_SimRefreshResponse_v7 *p_cur = ((RIL_SimRefreshResponse_v7 *) response);
+ p.writeInt32(p_cur->result);
+ p.writeInt32(p_cur->ef_id);
+ writeStringToParcel(p, p_cur->aid);
+
+ appendPrintBuf("%sresult=%d, ef_id=%d, aid=%s",
+ printBuf,
+ p_cur->result,
+ p_cur->ef_id,
+ p_cur->aid);
+
+}
+
static int responseSimRefresh(Parcel &p, void *response, size_t responselen) {
if (response == NULL && responselen != 0) {
RLOGE("responseSimRefresh: invalid response: NULL");
}
startResponse;
- if (s_callbacks.version == 7) {
- RIL_SimRefreshResponse_v7 *p_cur = ((RIL_SimRefreshResponse_v7 *) response);
- p.writeInt32(p_cur->result);
- p.writeInt32(p_cur->ef_id);
- writeStringToParcel(p, p_cur->aid);
-
- appendPrintBuf("%sresult=%d, ef_id=%d, aid=%s",
- printBuf,
- p_cur->result,
- p_cur->ef_id,
- p_cur->aid);
- } else {
- int *p_cur = ((int *) response);
- p.writeInt32(p_cur[0]);
- p.writeInt32(p_cur[1]);
- writeStringToParcel(p, NULL);
+ if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) {
+ if (s_callbacks.version >= 7) {
+ responseSimRefreshV7(p, response);
+ } else {
+ int *p_cur = ((int *) response);
+ p.writeInt32(p_cur[0]);
+ p.writeInt32(p_cur[1]);
+ writeStringToParcel(p, NULL);
+
+ appendPrintBuf("%sresult=%d, ef_id=%d",
+ printBuf,
+ p_cur[0],
+ p_cur[1]);
+ }
+ } else { // RIL version >= 13
+ if (responselen % sizeof(RIL_SimRefreshResponse_v7) != 0) {
+ RLOGE("Data structure expected is RIL_SimRefreshResponse_v7");
+ if (!isDebuggable()) {
+ return RIL_ERRNO_INVALID_RESPONSE;
+ } else {
+ assert(0);
+ }
+ }
+ responseSimRefreshV7(p, response);
- appendPrintBuf("%sresult=%d, ef_id=%d",
- printBuf,
- p_cur[0],
- p_cur[1]);
}
closeResponse;
return 0;
}
-static int responseCellInfoList(Parcel &p, void *response, size_t responselen)
-{
+static int responseCellInfoListV6(Parcel &p, void *response, size_t responselen) {
if (response == NULL && responselen != 0) {
RLOGE("invalid response: NULL");
return RIL_ERRNO_INVALID_RESPONSE;
}
if (responselen % sizeof(RIL_CellInfo) != 0) {
- RLOGE("invalid response length %d expected multiple of %d",
+ RLOGE("responseCellInfoList: invalid response length %d expected multiple of %d",
(int)responselen, (int)sizeof(RIL_CellInfo));
return RIL_ERRNO_INVALID_RESPONSE;
}
p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.timingAdvance);
break;
}
+ case RIL_CELL_INFO_TYPE_TD_SCDMA: {
+ appendPrintBuf("%s TDSCDMA id: mcc=%d,mnc=%d,lac=%d,cid=%d,cpid=%d,", printBuf,
+ p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mcc,
+ p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mnc,
+ p_cur->CellInfo.tdscdma.cellIdentityTdscdma.lac,
+ p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cid,
+ p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cpid);
+ appendPrintBuf("%s tdscdmaSS: rscp=%d],", printBuf,
+ p_cur->CellInfo.tdscdma.signalStrengthTdscdma.rscp);
+
+ p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mcc);
+ p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mnc);
+ p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.lac);
+ p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cid);
+ p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cpid);
+ p.writeInt32(p_cur->CellInfo.tdscdma.signalStrengthTdscdma.rscp);
+ break;
+ }
+ }
+ p_cur += 1;
+ }
+ removeLastChar;
+ closeResponse;
+
+ return 0;
+}
+
+static int responseCellInfoListV12(Parcel &p, void *response, size_t responselen) {
+ if (response == NULL && responselen != 0) {
+ RLOGE("invalid response: NULL");
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ if (responselen % sizeof(RIL_CellInfo_v12) != 0) {
+ RLOGE("responseCellInfoList: invalid response length %d expected multiple of %d",
+ (int)responselen, (int)sizeof(RIL_CellInfo_v12));
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ int num = responselen / sizeof(RIL_CellInfo_v12);
+ p.writeInt32(num);
+
+ RIL_CellInfo_v12 *p_cur = (RIL_CellInfo_v12 *) response;
+ startResponse;
+ int i;
+ for (i = 0; i < num; i++) {
+ appendPrintBuf("%s[%d: type=%d,registered=%d,timeStampType=%d,timeStamp=%lld", printBuf, i,
+ p_cur->cellInfoType, p_cur->registered, p_cur->timeStampType, p_cur->timeStamp);
+ RLOGE("[%d: type=%d,registered=%d,timeStampType=%d,timeStamp=%lld", i,
+ p_cur->cellInfoType, p_cur->registered, p_cur->timeStampType, p_cur->timeStamp);
+ p.writeInt32((int)p_cur->cellInfoType);
+ p.writeInt32(p_cur->registered);
+ p.writeInt32(p_cur->timeStampType);
+ p.writeInt64(p_cur->timeStamp);
+ switch(p_cur->cellInfoType) {
+ case RIL_CELL_INFO_TYPE_GSM: {
+ appendPrintBuf("%s GSM id: mcc=%d,mnc=%d,lac=%d,cid=%d,arfcn=%d,bsic=%x", printBuf,
+ p_cur->CellInfo.gsm.cellIdentityGsm.mcc,
+ p_cur->CellInfo.gsm.cellIdentityGsm.mnc,
+ p_cur->CellInfo.gsm.cellIdentityGsm.lac,
+ p_cur->CellInfo.gsm.cellIdentityGsm.cid,
+ p_cur->CellInfo.gsm.cellIdentityGsm.arfcn,
+ p_cur->CellInfo.gsm.cellIdentityGsm.bsic);
+ RLOGE("GSM id: mcc=%d,mnc=%d,lac=%d,cid=%d,arfcn=%d,bsic=%x",
+ p_cur->CellInfo.gsm.cellIdentityGsm.mcc,
+ p_cur->CellInfo.gsm.cellIdentityGsm.mnc,
+ p_cur->CellInfo.gsm.cellIdentityGsm.lac,
+ p_cur->CellInfo.gsm.cellIdentityGsm.cid,
+ p_cur->CellInfo.gsm.cellIdentityGsm.arfcn,
+ p_cur->CellInfo.gsm.cellIdentityGsm.bsic);
+ RLOGE("gsmSS: ss=%d,ber=%d, ta=%d],",
+ p_cur->CellInfo.gsm.signalStrengthGsm.signalStrength,
+ p_cur->CellInfo.gsm.signalStrengthGsm.bitErrorRate,
+ p_cur->CellInfo.gsm.signalStrengthGsm.timingAdvance);
+ appendPrintBuf("%s gsmSS: ss=%d,ber=%d, ta=%d],", printBuf,
+ p_cur->CellInfo.gsm.signalStrengthGsm.signalStrength,
+ p_cur->CellInfo.gsm.signalStrengthGsm.bitErrorRate,
+ p_cur->CellInfo.gsm.signalStrengthGsm.timingAdvance);
+
+ p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.mcc);
+ p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.mnc);
+ p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.lac);
+ p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.cid);
+ p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.arfcn);
+ p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.bsic);
+ p.writeInt32(p_cur->CellInfo.gsm.signalStrengthGsm.signalStrength);
+ p.writeInt32(p_cur->CellInfo.gsm.signalStrengthGsm.bitErrorRate);
+ p.writeInt32(p_cur->CellInfo.gsm.signalStrengthGsm.timingAdvance);
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_WCDMA: {
+ RLOGE("WCDMA id: mcc=%d,mnc=%d,lac=%d,cid=%d,psc=%d,uarfcn=%d",
+ p_cur->CellInfo.wcdma.cellIdentityWcdma.mcc,
+ p_cur->CellInfo.wcdma.cellIdentityWcdma.mnc,
+ p_cur->CellInfo.wcdma.cellIdentityWcdma.lac,
+ p_cur->CellInfo.wcdma.cellIdentityWcdma.cid,
+ p_cur->CellInfo.wcdma.cellIdentityWcdma.psc,
+ p_cur->CellInfo.wcdma.cellIdentityWcdma.uarfcn);
+ RLOGE("wcdmaSS: ss=%d,ber=%d],",
+ p_cur->CellInfo.wcdma.signalStrengthWcdma.signalStrength,
+ p_cur->CellInfo.wcdma.signalStrengthWcdma.bitErrorRate);
+ appendPrintBuf("%s WCDMA id: mcc=%d,mnc=%d,lac=%d,cid=%d,psc=%d,uarfcn=%d", printBuf,
+ p_cur->CellInfo.wcdma.cellIdentityWcdma.mcc,
+ p_cur->CellInfo.wcdma.cellIdentityWcdma.mnc,
+ p_cur->CellInfo.wcdma.cellIdentityWcdma.lac,
+ p_cur->CellInfo.wcdma.cellIdentityWcdma.cid,
+ p_cur->CellInfo.wcdma.cellIdentityWcdma.psc,
+ p_cur->CellInfo.wcdma.cellIdentityWcdma.uarfcn);
+ appendPrintBuf("%s wcdmaSS: ss=%d,ber=%d],", printBuf,
+ p_cur->CellInfo.wcdma.signalStrengthWcdma.signalStrength,
+ p_cur->CellInfo.wcdma.signalStrengthWcdma.bitErrorRate);
+
+ p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.mcc);
+ p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.mnc);
+ p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.lac);
+ p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.cid);
+ p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.psc);
+ p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.uarfcn);
+ p.writeInt32(p_cur->CellInfo.wcdma.signalStrengthWcdma.signalStrength);
+ p.writeInt32(p_cur->CellInfo.wcdma.signalStrengthWcdma.bitErrorRate);
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_CDMA: {
+ RLOGE("CDMA id: nId=%d,sId=%d,bsId=%d,long=%d,lat=%d",
+ p_cur->CellInfo.cdma.cellIdentityCdma.networkId,
+ p_cur->CellInfo.cdma.cellIdentityCdma.systemId,
+ p_cur->CellInfo.cdma.cellIdentityCdma.basestationId,
+ p_cur->CellInfo.cdma.cellIdentityCdma.longitude,
+ p_cur->CellInfo.cdma.cellIdentityCdma.latitude);
+
+ appendPrintBuf("%s CDMA id: nId=%d,sId=%d,bsId=%d,long=%d,lat=%d", printBuf,
+ p_cur->CellInfo.cdma.cellIdentityCdma.networkId,
+ p_cur->CellInfo.cdma.cellIdentityCdma.systemId,
+ p_cur->CellInfo.cdma.cellIdentityCdma.basestationId,
+ p_cur->CellInfo.cdma.cellIdentityCdma.longitude,
+ p_cur->CellInfo.cdma.cellIdentityCdma.latitude);
+
+ p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.networkId);
+ p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.systemId);
+ p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.basestationId);
+ p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.longitude);
+ p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.latitude);
+
+ RLOGE("cdmaSS: dbm=%d ecio=%d evdoSS: dbm=%d,ecio=%d,snr=%d",
+ p_cur->CellInfo.cdma.signalStrengthCdma.dbm,
+ p_cur->CellInfo.cdma.signalStrengthCdma.ecio,
+ p_cur->CellInfo.cdma.signalStrengthEvdo.dbm,
+ p_cur->CellInfo.cdma.signalStrengthEvdo.ecio,
+ p_cur->CellInfo.cdma.signalStrengthEvdo.signalNoiseRatio);
+
+ appendPrintBuf("%s cdmaSS: dbm=%d ecio=%d evdoSS: dbm=%d,ecio=%d,snr=%d", printBuf,
+ p_cur->CellInfo.cdma.signalStrengthCdma.dbm,
+ p_cur->CellInfo.cdma.signalStrengthCdma.ecio,
+ p_cur->CellInfo.cdma.signalStrengthEvdo.dbm,
+ p_cur->CellInfo.cdma.signalStrengthEvdo.ecio,
+ p_cur->CellInfo.cdma.signalStrengthEvdo.signalNoiseRatio);
+
+ p.writeInt32(p_cur->CellInfo.cdma.signalStrengthCdma.dbm);
+ p.writeInt32(p_cur->CellInfo.cdma.signalStrengthCdma.ecio);
+ p.writeInt32(p_cur->CellInfo.cdma.signalStrengthEvdo.dbm);
+ p.writeInt32(p_cur->CellInfo.cdma.signalStrengthEvdo.ecio);
+ p.writeInt32(p_cur->CellInfo.cdma.signalStrengthEvdo.signalNoiseRatio);
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_LTE: {
+ RLOGE("LTE id: mcc=%d,mnc=%d,ci=%d,pci=%d,tac=%d,earfcn=%d",
+ p_cur->CellInfo.lte.cellIdentityLte.mcc,
+ p_cur->CellInfo.lte.cellIdentityLte.mnc,
+ p_cur->CellInfo.lte.cellIdentityLte.ci,
+ p_cur->CellInfo.lte.cellIdentityLte.pci,
+ p_cur->CellInfo.lte.cellIdentityLte.tac,
+ p_cur->CellInfo.lte.cellIdentityLte.earfcn);
+
+ appendPrintBuf("%s LTE id: mcc=%d,mnc=%d,ci=%d,pci=%d,tac=%d,earfcn=%d", printBuf,
+ p_cur->CellInfo.lte.cellIdentityLte.mcc,
+ p_cur->CellInfo.lte.cellIdentityLte.mnc,
+ p_cur->CellInfo.lte.cellIdentityLte.ci,
+ p_cur->CellInfo.lte.cellIdentityLte.pci,
+ p_cur->CellInfo.lte.cellIdentityLte.tac,
+ p_cur->CellInfo.lte.cellIdentityLte.earfcn);
+
+ p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.mcc);
+ p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.mnc);
+ p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.ci);
+ p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.pci);
+ p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.tac);
+ p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.earfcn);
+
+ RLOGE("lteSS: ss=%d,rsrp=%d,rsrq=%d,rssnr=%d,cqi=%d,ta=%d",
+ p_cur->CellInfo.lte.signalStrengthLte.signalStrength,
+ p_cur->CellInfo.lte.signalStrengthLte.rsrp,
+ p_cur->CellInfo.lte.signalStrengthLte.rsrq,
+ p_cur->CellInfo.lte.signalStrengthLte.rssnr,
+ p_cur->CellInfo.lte.signalStrengthLte.cqi,
+ p_cur->CellInfo.lte.signalStrengthLte.timingAdvance);
+ appendPrintBuf("%s lteSS: ss=%d,rsrp=%d,rsrq=%d,rssnr=%d,cqi=%d,ta=%d", printBuf,
+ p_cur->CellInfo.lte.signalStrengthLte.signalStrength,
+ p_cur->CellInfo.lte.signalStrengthLte.rsrp,
+ p_cur->CellInfo.lte.signalStrengthLte.rsrq,
+ p_cur->CellInfo.lte.signalStrengthLte.rssnr,
+ p_cur->CellInfo.lte.signalStrengthLte.cqi,
+ p_cur->CellInfo.lte.signalStrengthLte.timingAdvance);
+ p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.signalStrength);
+ p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rsrp);
+ p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rsrq);
+ p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rssnr);
+ p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.cqi);
+ p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.timingAdvance);
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_TD_SCDMA: {
+ appendPrintBuf("%s TDSCDMA id: mcc=%d,mnc=%d,lac=%d,cid=%d,cpid=%d,", printBuf,
+ p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mcc,
+ p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mnc,
+ p_cur->CellInfo.tdscdma.cellIdentityTdscdma.lac,
+ p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cid,
+ p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cpid);
+ appendPrintBuf("%s tdscdmaSS: rscp=%d],", printBuf,
+ p_cur->CellInfo.tdscdma.signalStrengthTdscdma.rscp);
+
+ p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mcc);
+ p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mnc);
+ p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.lac);
+ p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cid);
+ p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cpid);
+ p.writeInt32(p_cur->CellInfo.tdscdma.signalStrengthTdscdma.rscp);
+ break;
+ }
}
p_cur += 1;
}
removeLastChar;
closeResponse;
+ return 0;
+}
+
+static int responseCellInfoList(Parcel &p, void *response, size_t responselen)
+{
+ if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) {
+ if (s_callbacks.version < 12) {
+ RLOGD("responseCellInfoList: v6");
+ return responseCellInfoListV6(p, response, responselen);
+ } else {
+ RLOGD("responseCellInfoList: v12");
+ return responseCellInfoListV12(p, response, responselen);
+ }
+ } else { // RIL version >= 13
+ if (responselen % sizeof(RIL_CellInfo_v12) != 0) {
+ RLOGE("Data structure expected is RIL_CellInfo_v12");
+ if (!isDebuggable()) {
+ return RIL_ERRNO_INVALID_RESPONSE;
+ } else {
+ assert(0);
+ }
+ }
+ return responseCellInfoListV12(p, response, responselen);
+ }
+
+ return 0;
+}
+
+static int responseHardwareConfig(Parcel &p, void *response, size_t responselen)
+{
+ if (response == NULL && responselen != 0) {
+ RLOGE("invalid response: NULL");
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ if (responselen % sizeof(RIL_HardwareConfig) != 0) {
+ RLOGE("responseHardwareConfig: invalid response length %d expected multiple of %d",
+ (int)responselen, (int)sizeof(RIL_HardwareConfig));
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ int num = responselen / sizeof(RIL_HardwareConfig);
+ int i;
+ RIL_HardwareConfig *p_cur = (RIL_HardwareConfig *) response;
+
+ p.writeInt32(num);
+
+ startResponse;
+ for (i = 0; i < num; i++) {
+ switch (p_cur[i].type) {
+ case RIL_HARDWARE_CONFIG_MODEM: {
+ writeStringToParcel(p, p_cur[i].uuid);
+ p.writeInt32((int)p_cur[i].state);
+ p.writeInt32(p_cur[i].cfg.modem.rat);
+ p.writeInt32(p_cur[i].cfg.modem.maxVoice);
+ p.writeInt32(p_cur[i].cfg.modem.maxData);
+ p.writeInt32(p_cur[i].cfg.modem.maxStandby);
+
+ appendPrintBuf("%s modem: uuid=%s,state=%d,rat=%08x,maxV=%d,maxD=%d,maxS=%d", printBuf,
+ p_cur[i].uuid, (int)p_cur[i].state, p_cur[i].cfg.modem.rat,
+ p_cur[i].cfg.modem.maxVoice, p_cur[i].cfg.modem.maxData, p_cur[i].cfg.modem.maxStandby);
+ break;
+ }
+ case RIL_HARDWARE_CONFIG_SIM: {
+ writeStringToParcel(p, p_cur[i].uuid);
+ p.writeInt32((int)p_cur[i].state);
+ writeStringToParcel(p, p_cur[i].cfg.sim.modemUuid);
+
+ appendPrintBuf("%s sim: uuid=%s,state=%d,modem-uuid=%s", printBuf,
+ p_cur[i].uuid, (int)p_cur[i].state, p_cur[i].cfg.sim.modemUuid);
+ break;
+ }
+ }
+ }
+ removeLastChar;
+ closeResponse;
+ return 0;
+}
+
+static int responseRadioCapability(Parcel &p, void *response, size_t responselen) {
+ if (response == NULL) {
+ RLOGE("invalid response: NULL");
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ if (responselen != sizeof (RIL_RadioCapability) ) {
+ RLOGE("invalid response length was %d expected %d",
+ (int)responselen, (int)sizeof (RIL_SIM_IO_Response));
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ RIL_RadioCapability *p_cur = (RIL_RadioCapability *) response;
+ p.writeInt32(p_cur->version);
+ p.writeInt32(p_cur->session);
+ p.writeInt32(p_cur->phase);
+ p.writeInt32(p_cur->rat);
+ writeStringToParcel(p, p_cur->logicalModemUuid);
+ p.writeInt32(p_cur->status);
+
+ startResponse;
+ appendPrintBuf("%s[version=%d,session=%d,phase=%d,\
+ rat=%s,logicalModemUuid=%s,status=%d]",
+ printBuf,
+ p_cur->version,
+ p_cur->session,
+ p_cur->phase,
+ p_cur->rat,
+ p_cur->logicalModemUuid,
+ p_cur->status);
+ closeResponse;
+ return 0;
+}
+
+static int responseSSData(Parcel &p, void *response, size_t responselen) {
+ RLOGD("In responseSSData");
+ int num;
+
+ if (response == NULL && responselen != 0) {
+ RLOGE("invalid response length was %d expected %d",
+ (int)responselen, (int)sizeof (RIL_SIM_IO_Response));
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ if (responselen != sizeof(RIL_StkCcUnsolSsResponse)) {
+ RLOGE("invalid response length %d, expected %d",
+ (int)responselen, (int)sizeof(RIL_StkCcUnsolSsResponse));
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ startResponse;
+ RIL_StkCcUnsolSsResponse *p_cur = (RIL_StkCcUnsolSsResponse *) response;
+ p.writeInt32(p_cur->serviceType);
+ p.writeInt32(p_cur->requestType);
+ p.writeInt32(p_cur->teleserviceType);
+ p.writeInt32(p_cur->serviceClass);
+ p.writeInt32(p_cur->result);
+
+ if (isServiceTypeCfQuery(p_cur->serviceType, p_cur->requestType)) {
+ RLOGD("responseSSData CF type, num of Cf elements %d", p_cur->cfData.numValidIndexes);
+ if (p_cur->cfData.numValidIndexes > NUM_SERVICE_CLASSES) {
+ RLOGE("numValidIndexes is greater than max value %d, "
+ "truncating it to max value", NUM_SERVICE_CLASSES);
+ p_cur->cfData.numValidIndexes = NUM_SERVICE_CLASSES;
+ }
+ /* number of call info's */
+ p.writeInt32(p_cur->cfData.numValidIndexes);
+
+ for (int i = 0; i < p_cur->cfData.numValidIndexes; i++) {
+ RIL_CallForwardInfo cf = p_cur->cfData.cfInfo[i];
+
+ p.writeInt32(cf.status);
+ p.writeInt32(cf.reason);
+ p.writeInt32(cf.serviceClass);
+ p.writeInt32(cf.toa);
+ writeStringToParcel(p, cf.number);
+ p.writeInt32(cf.timeSeconds);
+ appendPrintBuf("%s[%s,reason=%d,cls=%d,toa=%d,%s,tout=%d],", printBuf,
+ (cf.status==1)?"enable":"disable", cf.reason, cf.serviceClass, cf.toa,
+ (char*)cf.number, cf.timeSeconds);
+ RLOGD("Data: %d,reason=%d,cls=%d,toa=%d,num=%s,tout=%d],", cf.status,
+ cf.reason, cf.serviceClass, cf.toa, (char*)cf.number, cf.timeSeconds);
+ }
+ } else {
+ p.writeInt32 (SS_INFO_MAX);
+
+ /* each int*/
+ for (int i = 0; i < SS_INFO_MAX; i++) {
+ appendPrintBuf("%s%d,", printBuf, p_cur->ssInfo[i]);
+ RLOGD("Data: %d",p_cur->ssInfo[i]);
+ p.writeInt32(p_cur->ssInfo[i]);
+ }
+ }
+ removeLastChar;
+ closeResponse;
return 0;
}
+static bool isServiceTypeCfQuery(RIL_SsServiceType serType, RIL_SsRequestType reqType) {
+ if ((reqType == SS_INTERROGATION) &&
+ (serType == SS_CFU ||
+ serType == SS_CF_BUSY ||
+ serType == SS_CF_NO_REPLY ||
+ serType == SS_CF_NOT_REACHABLE ||
+ serType == SS_CF_ALL ||
+ serType == SS_CF_ALL_CONDITIONAL)) {
+ return true;
+ }
+ return false;
+}
+
static void triggerEvLoop() {
int ret;
if (!pthread_equal(pthread_self(), s_tid_dispatch)) {
closeResponse;
}
-static int responseSimStatus(Parcel &p, void *response, size_t responselen) {
- int i;
+static void responseSimStatusV5(Parcel &p, void *response) {
+ RIL_CardStatus_v5 *p_cur = ((RIL_CardStatus_v5 *) response);
- if (response == NULL && responselen != 0) {
- RLOGE("invalid response: NULL");
- return RIL_ERRNO_INVALID_RESPONSE;
- }
+ p.writeInt32(p_cur->card_state);
+ p.writeInt32(p_cur->universal_pin_state);
+ p.writeInt32(p_cur->gsm_umts_subscription_app_index);
+ p.writeInt32(p_cur->cdma_subscription_app_index);
- if (responselen == sizeof (RIL_CardStatus_v6)) {
- RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response);
+ sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications);
+}
- p.writeInt32(p_cur->card_state);
- p.writeInt32(p_cur->universal_pin_state);
- p.writeInt32(p_cur->gsm_umts_subscription_app_index);
- p.writeInt32(p_cur->cdma_subscription_app_index);
- p.writeInt32(p_cur->ims_subscription_app_index);
+static void responseSimStatusV6(Parcel &p, void *response) {
+ RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response);
- sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications);
- } else if (responselen == sizeof (RIL_CardStatus_v5)) {
- RIL_CardStatus_v5 *p_cur = ((RIL_CardStatus_v5 *) response);
+ p.writeInt32(p_cur->card_state);
+ p.writeInt32(p_cur->universal_pin_state);
+ p.writeInt32(p_cur->gsm_umts_subscription_app_index);
+ p.writeInt32(p_cur->cdma_subscription_app_index);
+ p.writeInt32(p_cur->ims_subscription_app_index);
- p.writeInt32(p_cur->card_state);
- p.writeInt32(p_cur->universal_pin_state);
- p.writeInt32(p_cur->gsm_umts_subscription_app_index);
- p.writeInt32(p_cur->cdma_subscription_app_index);
- p.writeInt32(-1);
+ sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications);
+}
- sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications);
- } else {
- RLOGE("responseSimStatus: A RilCardStatus_v6 or _v5 expected\n");
+static int responseSimStatus(Parcel &p, void *response, size_t responselen) {
+ int i;
+
+ if (response == NULL && responselen != 0) {
+ RLOGE("invalid response: NULL");
return RIL_ERRNO_INVALID_RESPONSE;
}
+ if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) {
+ if (responselen == sizeof (RIL_CardStatus_v6)) {
+ responseSimStatusV6(p, response);
+ } else if (responselen == sizeof (RIL_CardStatus_v5)) {
+ responseSimStatusV5(p, response);
+ } else {
+ RLOGE("responseSimStatus: A RilCardStatus_v6 or _v5 expected\n");
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+ } else { // RIL version >= 13
+ if (responselen % sizeof(RIL_CardStatus_v6) != 0) {
+ RLOGE("Data structure expected is RIL_CardStatus_v6");
+ if (!isDebuggable()) {
+ return RIL_ERRNO_INVALID_RESPONSE;
+ } else {
+ assert(0);
+ }
+ }
+ responseSimStatusV6(p, response);
+ }
+
return 0;
}
return 0;
}
+static int responseDcRtInfo(Parcel &p, void *response, size_t responselen)
+{
+ int num = responselen / sizeof(RIL_DcRtInfo);
+ if ((responselen % sizeof(RIL_DcRtInfo) != 0) || (num != 1)) {
+ RLOGE("responseDcRtInfo: invalid response length %d expected multiple of %d",
+ (int)responselen, (int)sizeof(RIL_DcRtInfo));
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ startResponse;
+ RIL_DcRtInfo *pDcRtInfo = (RIL_DcRtInfo *)response;
+ p.writeInt64(pDcRtInfo->time);
+ p.writeInt32(pDcRtInfo->powerState);
+ appendPrintBuf("%s[time=%d,powerState=%d]", printBuf,
+ pDcRtInfo->time,
+ pDcRtInfo->powerState);
+ closeResponse;
+
+ return 0;
+}
+
+static int responseLceStatus(Parcel &p, void *response, size_t responselen) {
+ if (response == NULL || responselen != sizeof(RIL_LceStatusInfo)) {
+ if (response == NULL) {
+ RLOGE("invalid response: NULL");
+ }
+ else {
+ RLOGE("responseLceStatus: invalid response length %d expecting len: d%",
+ sizeof(RIL_LceStatusInfo), responselen);
+ }
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ RIL_LceStatusInfo *p_cur = (RIL_LceStatusInfo *)response;
+ p.write((void *)p_cur, 1); // p_cur->lce_status takes one byte.
+ p.writeInt32(p_cur->actual_interval_ms);
+
+ startResponse;
+ appendPrintBuf("LCE Status: %d, actual_interval_ms: %d",
+ p_cur->lce_status, p_cur->actual_interval_ms);
+ closeResponse;
+
+ return 0;
+}
+
+static int responseLceData(Parcel &p, void *response, size_t responselen) {
+ if (response == NULL || responselen != sizeof(RIL_LceDataInfo)) {
+ if (response == NULL) {
+ RLOGE("invalid response: NULL");
+ }
+ else {
+ RLOGE("responseLceData: invalid response length %d expecting len: d%",
+ sizeof(RIL_LceDataInfo), responselen);
+ }
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ RIL_LceDataInfo *p_cur = (RIL_LceDataInfo *)response;
+ p.writeInt32(p_cur->last_hop_capacity_kbps);
+
+ /* p_cur->confidence_level and p_cur->lce_suspended take 1 byte each.*/
+ p.write((void *)&(p_cur->confidence_level), 1);
+ p.write((void *)&(p_cur->lce_suspended), 1);
+
+ startResponse;
+ appendPrintBuf("LCE info received: capacity %d confidence level %d
+ and suspended %d",
+ p_cur->last_hop_capacity_kbps, p_cur->confidence_level,
+ p_cur->lce_suspended);
+ closeResponse;
+
+ return 0;
+}
+
+static int responseActivityData(Parcel &p, void *response, size_t responselen) {
+ if (response == NULL || responselen != sizeof(RIL_ActivityStatsInfo)) {
+ if (response == NULL) {
+ RLOGE("invalid response: NULL");
+ }
+ else {
+ RLOGE("responseActivityData: invalid response length %d expecting len: d%",
+ sizeof(RIL_ActivityStatsInfo), responselen);
+ }
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ RIL_ActivityStatsInfo *p_cur = (RIL_ActivityStatsInfo *)response;
+ p.writeInt32(p_cur->sleep_mode_time_ms);
+ p.writeInt32(p_cur->idle_mode_time_ms);
+ for(int i = 0; i < RIL_NUM_TX_POWER_LEVELS; i++) {
+ p.writeInt32(p_cur->tx_mode_time_ms[i]);
+ }
+ p.writeInt32(p_cur->rx_mode_time_ms);
+
+ startResponse;
+ appendPrintBuf("Modem activity info received: sleep_mode_time_ms %d idle_mode_time_ms %d
+ tx_mode_time_ms %d %d %d %d %d and rx_mode_time_ms %d",
+ p_cur->sleep_mode_time_ms, p_cur->idle_mode_time_ms, p_cur->tx_mode_time_ms[0],
+ p_cur->tx_mode_time_ms[1], p_cur->tx_mode_time_ms[2], p_cur->tx_mode_time_ms[3],
+ p_cur->tx_mode_time_ms[4], p_cur->rx_mode_time_ms);
+ closeResponse;
+
+ return 0;
+}
+
/**
* A write on the wakeup fd is done just to pop us out of select()
* We empty the buffer here and then ril_event will reset the timers on the
} while (ret > 0 || (ret < 0 && errno == EINTR));
}
-static void onCommandsSocketClosed() {
+static void onCommandsSocketClosed(RIL_SOCKET_ID socket_id) {
int ret;
RequestInfo *p_cur;
-
+ /* Hook for current context
+ pendingRequestsMutextHook refer to &s_pendingRequestsMutex */
+ pthread_mutex_t * pendingRequestsMutexHook = &s_pendingRequestsMutex;
+ /* pendingRequestsHook refer to &s_pendingRequests */
+ RequestInfo ** pendingRequestsHook = &s_pendingRequests;
+
+#if (SIM_COUNT >= 2)
+ if (socket_id == RIL_SOCKET_2) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2;
+ pendingRequestsHook = &s_pendingRequests_socket2;
+ }
+#if (SIM_COUNT >= 3)
+ else if (socket_id == RIL_SOCKET_3) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket3;
+ pendingRequestsHook = &s_pendingRequests_socket3;
+ }
+#endif
+#if (SIM_COUNT >= 4)
+ else if (socket_id == RIL_SOCKET_4) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket4;
+ pendingRequestsHook = &s_pendingRequests_socket4;
+ }
+#endif
+#endif
/* mark pending requests as "cancelled" so we dont report responses */
-
- ret = pthread_mutex_lock(&s_pendingRequestsMutex);
+ ret = pthread_mutex_lock(pendingRequestsMutexHook);
assert (ret == 0);
- p_cur = s_pendingRequests;
+ p_cur = *pendingRequestsHook;
- for (p_cur = s_pendingRequests
+ for (p_cur = *pendingRequestsHook
; p_cur != NULL
; p_cur = p_cur->p_next
) {
p_cur->cancelled = 1;
}
- ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
+ ret = pthread_mutex_unlock(pendingRequestsMutexHook);
assert (ret == 0);
}
void *p_record;
size_t recordlen;
int ret;
+ SocketListenParam *p_info = (SocketListenParam *)param;
- assert(fd == s_fdCommand);
+ assert(fd == p_info->fdCommand);
- p_rs = (RecordStream *)param;
+ p_rs = p_info->p_rs;
for (;;) {
/* loop until EAGAIN/EINTR, end of stream, or other error */
} else if (ret < 0) {
break;
} else if (ret == 0) { /* && p_record != NULL */
- processCommandBuffer(p_record, recordlen);
+ processCommandBuffer(p_record, recordlen, p_info->socket_id);
}
}
RLOGW("EOS. Closing command socket.");
}
- close(s_fdCommand);
- s_fdCommand = -1;
+ close(fd);
+ p_info->fdCommand = -1;
- ril_event_del(&s_commands_event);
+ ril_event_del(p_info->commands_event);
record_stream_free(p_rs);
/* start listening for new connections again */
rilEventAddWakeup(&s_listen_event);
- onCommandsSocketClosed();
+ onCommandsSocketClosed(p_info->socket_id);
}
}
-static void onNewCommandConnect() {
+static void onNewCommandConnect(RIL_SOCKET_ID socket_id) {
// Inform we are connected and the ril version
int rilVer = s_callbacks.version;
- RIL_onUnsolicitedResponse(RIL_UNSOL_RIL_CONNECTED,
- &rilVer, sizeof(rilVer));
+ RIL_UNSOL_RESPONSE(RIL_UNSOL_RIL_CONNECTED,
+ &rilVer, sizeof(rilVer), socket_id);
// implicit radio state changed
- RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
- NULL, 0);
+ RIL_UNSOL_RESPONSE(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
+ NULL, 0, socket_id);
// Send last NITZ time data, in case it was missed
if (s_lastNITZTimeData != NULL) {
- sendResponseRaw(s_lastNITZTimeData, s_lastNITZTimeDataSize);
+ sendResponseRaw(s_lastNITZTimeData, s_lastNITZTimeDataSize, socket_id);
free(s_lastNITZTimeData);
s_lastNITZTimeData = NULL;
int ret;
int err;
int is_phone_socket;
+ int fdCommand = -1;
+ char* processName;
RecordStream *p_rs;
+ MySocketListenParam* listenParam;
+ RilSocket *sapSocket = NULL;
+ socketClient *sClient = NULL;
+
+ SocketListenParam *p_info = (SocketListenParam *)param;
+
+ if(RIL_SAP_SOCKET == p_info->type) {
+ listenParam = (MySocketListenParam *)param;
+ sapSocket = listenParam->socket;
+ }
struct sockaddr_un peeraddr;
socklen_t socklen = sizeof (peeraddr);
struct passwd *pwd = NULL;
- assert (s_fdCommand < 0);
- assert (fd == s_fdListen);
+ if(NULL == sapSocket) {
+ assert (*p_info->fdCommand < 0);
+ assert (fd == *p_info->fdListen);
+ processName = PHONE_PROCESS;
+ } else {
+ assert (sapSocket->commandFd < 0);
+ assert (fd == sapSocket->listenFd);
+ processName = BLUETOOTH_PROCESS;
+ }
+
- s_fdCommand = accept(s_fdListen, (sockaddr *) &peeraddr, &socklen);
+ fdCommand = accept(fd, (sockaddr *) &peeraddr, &socklen);
- if (s_fdCommand < 0 ) {
+ if (fdCommand < 0 ) {
RLOGE("Error on accept() errno:%d", errno);
/* start listening for new connections again */
- rilEventAddWakeup(&s_listen_event);
- return;
+ if(NULL == sapSocket) {
+ rilEventAddWakeup(p_info->listen_event);
+ } else {
+ rilEventAddWakeup(sapSocket->getListenEvent());
+ }
+ return;
}
/* check the credential of the other side and only accept socket from
errno = 0;
is_phone_socket = 0;
- err = getsockopt(s_fdCommand, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds);
+ err = getsockopt(fdCommand, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds);
if (err == 0 && szCreds > 0) {
errno = 0;
pwd = getpwuid(creds.uid);
if (pwd != NULL) {
- if (strcmp(pwd->pw_name, PHONE_PROCESS) == 0) {
+ if (strcmp(pwd->pw_name, processName) == 0) {
is_phone_socket = 1;
} else {
RLOGE("RILD can't accept socket from process %s", pwd->pw_name);
RLOGD("Error on getsockopt() errno: %d", errno);
}
- if ( !is_phone_socket ) {
- RLOGE("RILD must accept socket from %s", PHONE_PROCESS);
+ if (!is_phone_socket) {
+ RLOGE("RILD must accept socket from %s", processName);
+
+ close(fdCommand);
+ fdCommand = -1;
- close(s_fdCommand);
- s_fdCommand = -1;
+ if(NULL == sapSocket) {
+ onCommandsSocketClosed(p_info->socket_id);
- onCommandsSocketClosed();
+ /* start listening for new connections again */
+ rilEventAddWakeup(p_info->listen_event);
+ } else {
+ sapSocket->onCommandsSocketClosed();
- /* start listening for new connections again */
- rilEventAddWakeup(&s_listen_event);
+ /* start listening for new connections again */
+ rilEventAddWakeup(sapSocket->getListenEvent());
+ }
- return;
+ return;
}
- ret = fcntl(s_fdCommand, F_SETFL, O_NONBLOCK);
+ ret = fcntl(fdCommand, F_SETFL, O_NONBLOCK);
if (ret < 0) {
RLOGE ("Error setting O_NONBLOCK errno:%d", errno);
}
- RLOGI("libril: new connection");
+ if(NULL == sapSocket) {
+ RLOGI("libril: new connection to %s", rilSocketIdToString(p_info->socket_id));
+
+ p_info->fdCommand = fdCommand;
+ p_rs = record_stream_new(p_info->fdCommand, MAX_COMMAND_BYTES);
+ p_info->p_rs = p_rs;
- p_rs = record_stream_new(s_fdCommand, MAX_COMMAND_BYTES);
+ ril_event_set (p_info->commands_event, p_info->fdCommand, 1,
+ p_info->processCommandsCallback, p_info);
+ rilEventAddWakeup (p_info->commands_event);
- ril_event_set (&s_commands_event, s_fdCommand, 1,
- processCommandsCallback, p_rs);
+ onNewCommandConnect(p_info->socket_id);
+ } else {
+ RLOGI("libril: new connection");
- rilEventAddWakeup (&s_commands_event);
+ sapSocket->setCommandFd(fdCommand);
+ p_rs = record_stream_new(sapSocket->getCommandFd(), MAX_COMMAND_BYTES);
+ sClient = new socketClient(sapSocket,p_rs);
+ ril_event_set (sapSocket->getCallbackEvent(), sapSocket->getCommandFd(), 1,
+ sapSocket->getCommandCb(), sClient);
- onNewCommandConnect();
+ rilEventAddWakeup(sapSocket->getCallbackEvent());
+ sapSocket->onNewCommandConnect();
+ }
}
static void freeDebugCallbackArgs(int number, char **args) {
int hangupData[1] = {1};
int number;
char **args;
+ RIL_SOCKET_ID socket_id = RIL_SOCKET_1;
+ int sim_id = 0;
+
+ RLOGI("debugCallback for socket %s", rilSocketIdToString(socket_id));
acceptFD = accept (fd, (sockaddr *) &peeraddr, &socklen);
}
char * buf = args[i];
buf[len] = 0;
+ if ((i+1) == number) {
+ /* The last argument should be sim id 0(SIM1)~3(SIM4) */
+ sim_id = atoi(args[i]);
+ switch (sim_id) {
+ case 0:
+ socket_id = RIL_SOCKET_1;
+ break;
+ #if (SIM_COUNT >= 2)
+ case 1:
+ socket_id = RIL_SOCKET_2;
+ break;
+ #endif
+ #if (SIM_COUNT >= 3)
+ case 2:
+ socket_id = RIL_SOCKET_3;
+ break;
+ #endif
+ #if (SIM_COUNT >= 4)
+ case 3:
+ socket_id = RIL_SOCKET_4;
+ break;
+ #endif
+ default:
+ socket_id = RIL_SOCKET_1;
+ break;
+ }
+ }
}
switch (atoi(args[0])) {
case 0:
RLOGI ("Connection on debug port: issuing reset.");
- issueLocalRequest(RIL_REQUEST_RESET_RADIO, NULL, 0);
+ issueLocalRequest(RIL_REQUEST_RESET_RADIO, NULL, 0, socket_id);
break;
case 1:
RLOGI ("Connection on debug port: issuing radio power off.");
data = 0;
- issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int));
+ issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int), socket_id);
// Close the socket
- close(s_fdCommand);
- s_fdCommand = -1;
+ if (socket_id == RIL_SOCKET_1 && s_ril_param_socket.fdCommand > 0) {
+ close(s_ril_param_socket.fdCommand);
+ s_ril_param_socket.fdCommand = -1;
+ }
+ #if (SIM_COUNT == 2)
+ else if (socket_id == RIL_SOCKET_2 && s_ril_param_socket2.fdCommand > 0) {
+ close(s_ril_param_socket2.fdCommand);
+ s_ril_param_socket2.fdCommand = -1;
+ }
+ #endif
break;
case 2:
RLOGI ("Debug port: issuing unsolicited voice network change.");
- RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED,
- NULL, 0);
+ RIL_UNSOL_RESPONSE(RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, NULL, 0, socket_id);
break;
case 3:
RLOGI ("Debug port: QXDM log enable.");
qxdm_data[4] = 0; // log_mask
qxdm_data[5] = 8; // log_max_fileindex
issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data,
- 6 * sizeof(int));
+ 6 * sizeof(int), socket_id);
break;
case 4:
RLOGI ("Debug port: QXDM log disable.");
qxdm_data[4] = 0;
qxdm_data[5] = 8;
issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data,
- 6 * sizeof(int));
+ 6 * sizeof(int), socket_id);
break;
case 5:
RLOGI("Debug port: Radio On");
data = 1;
- issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int));
+ issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int), socket_id);
sleep(2);
// Set network selection automatic.
- issueLocalRequest(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, NULL, 0);
+ issueLocalRequest(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, NULL, 0, socket_id);
break;
case 6:
RLOGI("Debug port: Setup Data Call, Apn :%s\n", args[1]);
actData[0] = args[1];
issueLocalRequest(RIL_REQUEST_SETUP_DATA_CALL, &actData,
- sizeof(actData));
+ sizeof(actData), socket_id);
break;
case 7:
RLOGI("Debug port: Deactivate Data Call");
issueLocalRequest(RIL_REQUEST_DEACTIVATE_DATA_CALL, &deactData,
- sizeof(deactData));
+ sizeof(deactData), socket_id);
break;
case 8:
RLOGI("Debug port: Dial Call");
dialData.clir = 0;
dialData.address = args[1];
- issueLocalRequest(RIL_REQUEST_DIAL, &dialData, sizeof(dialData));
+ issueLocalRequest(RIL_REQUEST_DIAL, &dialData, sizeof(dialData), socket_id);
break;
case 9:
RLOGI("Debug port: Answer Call");
- issueLocalRequest(RIL_REQUEST_ANSWER, NULL, 0);
+ issueLocalRequest(RIL_REQUEST_ANSWER, NULL, 0, socket_id);
break;
case 10:
RLOGI("Debug port: End Call");
issueLocalRequest(RIL_REQUEST_HANGUP, &hangupData,
- sizeof(hangupData));
+ sizeof(hangupData), socket_id);
break;
default:
RLOGE ("Invalid request");
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_t attr;
+ pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- ret = pthread_create(&s_tid_dispatch, &attr, eventLoop, NULL);
+
+ int result = pthread_create(&s_tid_dispatch, &attr, eventLoop, NULL);
+ if (result != 0) {
+ RLOGE("Failed to create dispatch thread: %s", strerror(result));
+ goto done;
+ }
while (s_started == 0) {
pthread_cond_wait(&s_startupCond, &s_startupMutex);
}
+done:
pthread_mutex_unlock(&s_startupMutex);
-
- if (ret < 0) {
- RLOGE("Failed to create dispatch thread errno:%d", errno);
- return;
- }
}
// Used for testing purpose only.
memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
}
+static void startListen(RIL_SOCKET_ID socket_id, SocketListenParam* socket_listen_p) {
+ int fdListen = -1;
+ int ret;
+ char socket_name[10];
+
+ memset(socket_name, 0, sizeof(char)*10);
+
+ switch(socket_id) {
+ case RIL_SOCKET_1:
+ strncpy(socket_name, RIL_getRilSocketName(), 9);
+ break;
+ #if (SIM_COUNT >= 2)
+ case RIL_SOCKET_2:
+ strncpy(socket_name, SOCKET2_NAME_RIL, 9);
+ break;
+ #endif
+ #if (SIM_COUNT >= 3)
+ case RIL_SOCKET_3:
+ strncpy(socket_name, SOCKET3_NAME_RIL, 9);
+ break;
+ #endif
+ #if (SIM_COUNT >= 4)
+ case RIL_SOCKET_4:
+ strncpy(socket_name, SOCKET4_NAME_RIL, 9);
+ break;
+ #endif
+ default:
+ RLOGE("Socket id is wrong!!");
+ return;
+ }
+
+ RLOGI("Start to listen %s", rilSocketIdToString(socket_id));
+
+ fdListen = android_get_control_socket(socket_name);
+ if (fdListen < 0) {
+ RLOGE("Failed to get socket %s", socket_name);
+ exit(-1);
+ }
+
+ ret = listen(fdListen, 4);
+
+ if (ret < 0) {
+ RLOGE("Failed to listen on control socket '%d': %s",
+ fdListen, strerror(errno));
+ exit(-1);
+ }
+ socket_listen_p->fdListen = fdListen;
+
+ /* note: non-persistent so we can accept only one connection at a time */
+ ril_event_set (socket_listen_p->listen_event, fdListen, false,
+ listenCallback, socket_listen_p);
+
+ rilEventAddWakeup (socket_listen_p->listen_event);
+}
+
extern "C" void
RIL_register (const RIL_RadioFunctions *callbacks) {
int ret;
int flags;
+ RLOGI("SIM_COUNT: %d", SIM_COUNT);
+
if (callbacks == NULL) {
RLOGE("RIL_register: RIL_RadioFunctions * null");
return;
callbacks->version, RIL_VERSION_MIN);
return;
}
- if (callbacks->version > RIL_VERSION) {
- RLOGE("RIL_register: version %d is too new, max version is %d",
- callbacks->version, RIL_VERSION);
- return;
- }
+
RLOGE("RIL_register: RIL version %d", callbacks->version);
if (s_registerCalled > 0) {
memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
+ /* Initialize socket1 parameters */
+ s_ril_param_socket = {
+ RIL_SOCKET_1, /* socket_id */
+ -1, /* fdListen */
+ -1, /* fdCommand */
+ PHONE_PROCESS, /* processName */
+ &s_commands_event, /* commands_event */
+ &s_listen_event, /* listen_event */
+ processCommandsCallback, /* processCommandsCallback */
+ NULL /* p_rs */
+ };
+
+#if (SIM_COUNT >= 2)
+ s_ril_param_socket2 = {
+ RIL_SOCKET_2, /* socket_id */
+ -1, /* fdListen */
+ -1, /* fdCommand */
+ PHONE_PROCESS, /* processName */
+ &s_commands_event_socket2, /* commands_event */
+ &s_listen_event_socket2, /* listen_event */
+ processCommandsCallback, /* processCommandsCallback */
+ NULL /* p_rs */
+ };
+#endif
+
+#if (SIM_COUNT >= 3)
+ s_ril_param_socket3 = {
+ RIL_SOCKET_3, /* socket_id */
+ -1, /* fdListen */
+ -1, /* fdCommand */
+ PHONE_PROCESS, /* processName */
+ &s_commands_event_socket3, /* commands_event */
+ &s_listen_event_socket3, /* listen_event */
+ processCommandsCallback, /* processCommandsCallback */
+ NULL /* p_rs */
+ };
+#endif
+
+#if (SIM_COUNT >= 4)
+ s_ril_param_socket4 = {
+ RIL_SOCKET_4, /* socket_id */
+ -1, /* fdListen */
+ -1, /* fdCommand */
+ PHONE_PROCESS, /* processName */
+ &s_commands_event_socket4, /* commands_event */
+ &s_listen_event_socket4, /* listen_event */
+ processCommandsCallback, /* processCommandsCallback */
+ NULL /* p_rs */
+ };
+#endif
+
+
s_registerCalled = 1;
+ RLOGI("s_registerCalled flag set, %d", s_started);
// Little self-check
for (int i = 0; i < (int)NUM_ELEMS(s_commands); i++) {
RIL_startEventLoop();
}
- // start listen socket
-
-#if 0
- ret = socket_local_server (SOCKET_NAME_RIL,
- ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
-
- if (ret < 0) {
- RLOGE("Unable to bind socket errno:%d", errno);
- exit (-1);
- }
- s_fdListen = ret;
-
-#else
- s_fdListen = android_get_control_socket(SOCKET_NAME_RIL);
- if (s_fdListen < 0) {
- RLOGE("Failed to get socket '" SOCKET_NAME_RIL "'");
- exit(-1);
- }
-
- ret = listen(s_fdListen, 4);
+ // start listen socket1
+ startListen(RIL_SOCKET_1, &s_ril_param_socket);
- if (ret < 0) {
- RLOGE("Failed to listen on control socket '%d': %s",
- s_fdListen, strerror(errno));
- exit(-1);
- }
-#endif
+#if (SIM_COUNT >= 2)
+ // start listen socket2
+ startListen(RIL_SOCKET_2, &s_ril_param_socket2);
+#endif /* (SIM_COUNT == 2) */
+#if (SIM_COUNT >= 3)
+ // start listen socket3
+ startListen(RIL_SOCKET_3, &s_ril_param_socket3);
+#endif /* (SIM_COUNT == 3) */
- /* note: non-persistent so we can accept only one connection at a time */
- ril_event_set (&s_listen_event, s_fdListen, false,
- listenCallback, NULL);
+#if (SIM_COUNT >= 4)
+ // start listen socket4
+ startListen(RIL_SOCKET_4, &s_ril_param_socket4);
+#endif /* (SIM_COUNT == 4) */
- rilEventAddWakeup (&s_listen_event);
#if 1
// start debug interface socket
- s_fdDebug = android_get_control_socket(SOCKET_NAME_RIL_DEBUG);
+ char *inst = NULL;
+ if (strlen(RIL_getRilSocketName()) >= strlen(SOCKET_NAME_RIL)) {
+ inst = RIL_getRilSocketName() + strlen(SOCKET_NAME_RIL);
+ }
+
+ char rildebug[MAX_DEBUG_SOCKET_NAME_LENGTH] = SOCKET_NAME_RIL_DEBUG;
+ if (inst != NULL) {
+ strlcat(rildebug, inst, MAX_DEBUG_SOCKET_NAME_LENGTH);
+ }
+
+ s_fdDebug = android_get_control_socket(rildebug);
if (s_fdDebug < 0) {
- RLOGE("Failed to get socket '" SOCKET_NAME_RIL_DEBUG "' errno:%d", errno);
+ RLOGE("Failed to get socket : %s errno:%d", rildebug, errno);
exit(-1);
}
}
+extern "C" void
+RIL_register_socket (RIL_RadioFunctions *(*Init)(const struct RIL_Env *, int, char **),RIL_SOCKET_TYPE socketType, int argc, char **argv) {
+
+ RIL_RadioFunctions* UimFuncs = NULL;
+
+ if(Init) {
+ UimFuncs = Init(&RilSapSocket::uimRilEnv, argc, argv);
+
+ switch(socketType) {
+ case RIL_SAP_SOCKET:
+ RilSapSocket::initSapSocket("sap_uim_socket1", UimFuncs);
+
+#if (SIM_COUNT >= 2)
+ RilSapSocket::initSapSocket("sap_uim_socket2", UimFuncs);
+#endif
+
+#if (SIM_COUNT >= 3)
+ RilSapSocket::initSapSocket("sap_uim_socket3", UimFuncs);
+#endif
+
+#if (SIM_COUNT >= 4)
+ RilSapSocket::initSapSocket("sap_uim_socket4", UimFuncs);
+#endif
+ }
+ }
+}
+
+// Check and remove RequestInfo if its a response and not just ack sent back
static int
-checkAndDequeueRequestInfo(struct RequestInfo *pRI) {
+checkAndDequeueRequestInfoIfAck(struct RequestInfo *pRI, bool isAck) {
int ret = 0;
+ /* Hook for current context
+ pendingRequestsMutextHook refer to &s_pendingRequestsMutex */
+ pthread_mutex_t* pendingRequestsMutexHook = &s_pendingRequestsMutex;
+ /* pendingRequestsHook refer to &s_pendingRequests */
+ RequestInfo ** pendingRequestsHook = &s_pendingRequests;
if (pRI == NULL) {
return 0;
}
- pthread_mutex_lock(&s_pendingRequestsMutex);
+#if (SIM_COUNT >= 2)
+ if (pRI->socket_id == RIL_SOCKET_2) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2;
+ pendingRequestsHook = &s_pendingRequests_socket2;
+ }
+#if (SIM_COUNT >= 3)
+ if (pRI->socket_id == RIL_SOCKET_3) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket3;
+ pendingRequestsHook = &s_pendingRequests_socket3;
+ }
+#endif
+#if (SIM_COUNT >= 4)
+ if (pRI->socket_id == RIL_SOCKET_4) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket4;
+ pendingRequestsHook = &s_pendingRequests_socket4;
+ }
+#endif
+#endif
+ pthread_mutex_lock(pendingRequestsMutexHook);
- for(RequestInfo **ppCur = &s_pendingRequests
+ for(RequestInfo **ppCur = pendingRequestsHook
; *ppCur != NULL
; ppCur = &((*ppCur)->p_next)
) {
if (pRI == *ppCur) {
ret = 1;
-
- *ppCur = (*ppCur)->p_next;
+ if (isAck) { // Async ack
+ if (pRI->wasAckSent == 1) {
+ RLOGD("Ack was already sent for %s", requestToString(pRI->pCI->requestNumber));
+ } else {
+ pRI->wasAckSent = 1;
+ }
+ } else {
+ *ppCur = (*ppCur)->p_next;
+ }
break;
}
}
- pthread_mutex_unlock(&s_pendingRequestsMutex);
+ pthread_mutex_unlock(pendingRequestsMutexHook);
return ret;
}
+static int findFd(int socket_id) {
+ int fd = s_ril_param_socket.fdCommand;
+#if (SIM_COUNT >= 2)
+ if (socket_id == RIL_SOCKET_2) {
+ fd = s_ril_param_socket2.fdCommand;
+ }
+#if (SIM_COUNT >= 3)
+ if (socket_id == RIL_SOCKET_3) {
+ fd = s_ril_param_socket3.fdCommand;
+ }
+#endif
+#if (SIM_COUNT >= 4)
+ if (socket_id == RIL_SOCKET_4) {
+ fd = s_ril_param_socket4.fdCommand;
+ }
+#endif
+#endif
+ return fd;
+}
+
+extern "C" void
+RIL_onRequestAck(RIL_Token t) {
+ RequestInfo *pRI;
+ int ret, fd;
+
+ size_t errorOffset;
+ RIL_SOCKET_ID socket_id = RIL_SOCKET_1;
+
+ pRI = (RequestInfo *)t;
+
+ if (!checkAndDequeueRequestInfoIfAck(pRI, true)) {
+ RLOGE ("RIL_onRequestAck: invalid RIL_Token");
+ return;
+ }
+
+ socket_id = pRI->socket_id;
+ fd = findFd(socket_id);
+
+#if VDBG
+ RLOGD("Request Ack, %s", rilSocketIdToString(socket_id));
+#endif
+
+ appendPrintBuf("Ack [%04d]< %s", pRI->token, requestToString(pRI->pCI->requestNumber));
+
+ if (pRI->cancelled == 0) {
+ Parcel p;
+
+ p.writeInt32 (RESPONSE_SOLICITED_ACK);
+ p.writeInt32 (pRI->token);
+
+ if (fd < 0) {
+ RLOGD ("RIL onRequestComplete: Command channel closed");
+ }
+
+ sendResponse(p, socket_id);
+ }
+}
extern "C" void
RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen) {
RequestInfo *pRI;
int ret;
+ int fd;
size_t errorOffset;
+ RIL_SOCKET_ID socket_id = RIL_SOCKET_1;
pRI = (RequestInfo *)t;
- if (!checkAndDequeueRequestInfo(pRI)) {
+ if (!checkAndDequeueRequestInfoIfAck(pRI, false)) {
RLOGE ("RIL_onRequestComplete: invalid RIL_Token");
return;
}
+ socket_id = pRI->socket_id;
+ fd = findFd(socket_id);
+
+#if VDBG
+ RLOGD("RequestComplete, %s", rilSocketIdToString(socket_id));
+#endif
+
if (pRI->local > 0) {
// Locally issued command...void only!
// response does not go back up the command socket
if (pRI->cancelled == 0) {
Parcel p;
- p.writeInt32 (RESPONSE_SOLICITED);
+ if (s_callbacks.version >= 13 && pRI->wasAckSent == 1) {
+ // If ack was already sent, then this call is an asynchronous response. So we need to
+ // send id indicating that we expect an ack from RIL.java as we acquire wakelock here.
+ p.writeInt32 (RESPONSE_SOLICITED_ACK_EXP);
+ grabPartialWakeLock();
+ } else {
+ p.writeInt32 (RESPONSE_SOLICITED);
+ }
p.writeInt32 (pRI->token);
errorOffset = p.dataPosition();
/* if an error occurred, rewind and mark it */
if (ret != 0) {
+ RLOGE ("responseFunction error, ret %d", ret);
p.setDataPosition(errorOffset);
p.writeInt32 (ret);
}
appendPrintBuf("%s fails by %s", printBuf, failCauseToString(e));
}
- if (s_fdCommand < 0) {
+ if (fd < 0) {
RLOGD ("RIL onRequestComplete: Command channel closed");
}
- sendResponse(p);
+ sendResponse(p, socket_id);
}
done:
free(pRI);
}
-
static void
grabPartialWakeLock() {
- acquire_wake_lock(PARTIAL_WAKE_LOCK, ANDROID_WAKE_LOCK_NAME);
+ if (s_callbacks.version >= 13) {
+ int ret;
+ ret = pthread_mutex_lock(&s_wakeLockCountMutex);
+ assert(ret == 0);
+ acquire_wake_lock(PARTIAL_WAKE_LOCK, ANDROID_WAKE_LOCK_NAME);
+ s_wakelock_count++;
+ if (s_last_wake_timeout_info != NULL) {
+ s_last_wake_timeout_info->userParam = (void *)1;
+ }
+
+ s_last_wake_timeout_info
+ = internalRequestTimedCallback(wakeTimeoutCallback, NULL, &TIMEVAL_WAKE_TIMEOUT);
+
+ ret = pthread_mutex_unlock(&s_wakeLockCountMutex);
+ assert(ret == 0);
+ } else {
+ acquire_wake_lock(PARTIAL_WAKE_LOCK, ANDROID_WAKE_LOCK_NAME);
+ }
}
static void
releaseWakeLock() {
- release_wake_lock(ANDROID_WAKE_LOCK_NAME);
+ if (s_callbacks.version >= 13) {
+ int ret;
+ ret = pthread_mutex_lock(&s_wakeLockCountMutex);
+ assert(ret == 0);
+
+ if (s_wakelock_count > 1) {
+ s_wakelock_count--;
+ } else {
+ s_wakelock_count = 0;
+ release_wake_lock(ANDROID_WAKE_LOCK_NAME);
+ if (s_last_wake_timeout_info != NULL) {
+ s_last_wake_timeout_info->userParam = (void *)1;
+ }
+ }
+
+ ret = pthread_mutex_unlock(&s_wakeLockCountMutex);
+ assert(ret == 0);
+ } else {
+ release_wake_lock(ANDROID_WAKE_LOCK_NAME);
+ }
}
/**
static void
wakeTimeoutCallback (void *param) {
// We're using "param != NULL" as a cancellation mechanism
- if (param == NULL) {
- //RLOGD("wakeTimeout: releasing wake lock");
-
- releaseWakeLock();
+ if (s_callbacks.version >= 13) {
+ if (param == NULL) {
+ int ret;
+ ret = pthread_mutex_lock(&s_wakeLockCountMutex);
+ assert(ret == 0);
+ s_wakelock_count = 0;
+ release_wake_lock(ANDROID_WAKE_LOCK_NAME);
+ ret = pthread_mutex_unlock(&s_wakeLockCountMutex);
+ assert(ret == 0);
+ }
} else {
- //RLOGD("wakeTimeout: releasing wake lock CANCELLED");
+ if (param == NULL) {
+ releaseWakeLock();
+ }
}
}
* returned when telephony framework requests them
*/
static RIL_RadioState
-processRadioState(RIL_RadioState newRadioState) {
+processRadioState(RIL_RadioState newRadioState, RIL_SOCKET_ID socket_id) {
if((newRadioState > RADIO_STATE_UNAVAILABLE) && (newRadioState < RADIO_STATE_ON)) {
int newVoiceRadioTech;
newVoiceRadioTech = decodeVoiceRadioTechnology(newRadioState);
if(newVoiceRadioTech != voiceRadioTech) {
voiceRadioTech = newVoiceRadioTech;
- RIL_onUnsolicitedResponse (RIL_UNSOL_VOICE_RADIO_TECH_CHANGED,
- &voiceRadioTech, sizeof(voiceRadioTech));
+ RIL_UNSOL_RESPONSE(RIL_UNSOL_VOICE_RADIO_TECH_CHANGED,
+ &voiceRadioTech, sizeof(voiceRadioTech), socket_id);
}
if(is3gpp2(newVoiceRadioTech)) {
newCdmaSubscriptionSource = decodeCdmaSubscriptionSource(newRadioState);
if(newCdmaSubscriptionSource != cdmaSubscriptionSource) {
cdmaSubscriptionSource = newCdmaSubscriptionSource;
- RIL_onUnsolicitedResponse (RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED,
- &cdmaSubscriptionSource, sizeof(cdmaSubscriptionSource));
+ RIL_UNSOL_RESPONSE(RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED,
+ &cdmaSubscriptionSource, sizeof(cdmaSubscriptionSource), socket_id);
}
}
newSimStatus = decodeSimStatus(newRadioState);
if(newSimStatus != simRuimStatus) {
simRuimStatus = newSimStatus;
- RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0);
+ RIL_UNSOL_RESPONSE(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0, socket_id);
}
/* Send RADIO_ON to telephony */
return newRadioState;
}
+
+#if defined(ANDROID_MULTI_SIM)
+extern "C"
+void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
+ size_t datalen, RIL_SOCKET_ID socket_id)
+#else
extern "C"
void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
size_t datalen)
+#endif
{
int unsolResponseIndex;
int ret;
int64_t timeReceived = 0;
bool shouldScheduleTimeout = false;
RIL_RadioState newState;
+ RIL_SOCKET_ID soc_id = RIL_SOCKET_1;
+
+#if defined(ANDROID_MULTI_SIM)
+ soc_id = socket_id;
+#endif
+
if (s_registerCalled == 0) {
// Ignore RIL_onUnsolicitedResponse before RIL_register
appendPrintBuf("[UNSL]< %s", requestToString(unsolResponse));
Parcel p;
-
- p.writeInt32 (RESPONSE_UNSOLICITED);
+ if (s_callbacks.version >= 13
+ && s_unsolResponses[unsolResponseIndex].wakeType == WAKE_PARTIAL) {
+ p.writeInt32 (RESPONSE_UNSOLICITED_ACK_EXP);
+ } else {
+ p.writeInt32 (RESPONSE_UNSOLICITED);
+ }
p.writeInt32 (unsolResponse);
ret = s_unsolResponses[unsolResponseIndex]
// some things get more payload
switch(unsolResponse) {
case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED:
- newState = processRadioState(s_callbacks.onStateRequest());
+ newState = processRadioState(CALL_ONSTATEREQUEST(soc_id), soc_id);
p.writeInt32(newState);
appendPrintBuf("%s {%s}", printBuf,
- radioStateToString(s_callbacks.onStateRequest()));
+ radioStateToString(CALL_ONSTATEREQUEST(soc_id)));
break;
break;
}
- ret = sendResponse(p);
+#if VDBG
+ RLOGI("%s UNSOLICITED: %s length:%d", rilSocketIdToString(soc_id), requestToString(unsolResponse), p.dataSize());
+#endif
+ ret = sendResponse(p, soc_id);
if (ret != 0 && unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) {
// Unfortunately, NITZ time is not poll/update like everything
memcpy(s_lastNITZTimeData, p.data(), p.dataSize());
}
- // For now, we automatically go back to sleep after TIMEVAL_WAKE_TIMEOUT
- // FIXME The java code should handshake here to release wake lock
+ if (s_callbacks.version < 13) {
+ if (shouldScheduleTimeout) {
+ // Cancel the previous request
+ if (s_last_wake_timeout_info != NULL) {
+ s_last_wake_timeout_info->userParam = (void *)1;
+ }
- if (shouldScheduleTimeout) {
- // Cancel the previous request
- if (s_last_wake_timeout_info != NULL) {
- s_last_wake_timeout_info->userParam = (void *)1;
+ s_last_wake_timeout_info
+ = internalRequestTimedCallback(wakeTimeoutCallback, NULL,
+ &TIMEVAL_WAKE_TIMEOUT);
}
-
- s_last_wake_timeout_info
- = internalRequestTimedCallback(wakeTimeoutCallback, NULL,
- &TIMEVAL_WAKE_TIMEOUT);
}
// Normal exit
case RIL_E_SUBSCRIPTION_NOT_AVAILABLE:return "E_SUBSCRIPTION_NOT_AVAILABLE";
case RIL_E_MODE_NOT_SUPPORTED:return "E_MODE_NOT_SUPPORTED";
#endif
+ case RIL_E_FDN_CHECK_FAILURE: return "E_FDN_CHECK_FAILURE";
+ case RIL_E_MISSING_RESOURCE: return "E_MISSING_RESOURCE";
+ case RIL_E_NO_SUCH_ELEMENT: return "E_NO_SUCH_ELEMENT";
+ case RIL_E_DIAL_MODIFIED_TO_USSD: return "E_DIAL_MODIFIED_TO_USSD";
+ case RIL_E_DIAL_MODIFIED_TO_SS: return "E_DIAL_MODIFIED_TO_SS";
+ case RIL_E_DIAL_MODIFIED_TO_DIAL: return "E_DIAL_MODIFIED_TO_DIAL";
+ case RIL_E_USSD_MODIFIED_TO_DIAL: return "E_USSD_MODIFIED_TO_DIAL";
+ case RIL_E_USSD_MODIFIED_TO_SS: return "E_USSD_MODIFIED_TO_SS";
+ case RIL_E_USSD_MODIFIED_TO_USSD: return "E_USSD_MODIFIED_TO_USSD";
+ case RIL_E_SS_MODIFIED_TO_DIAL: return "E_SS_MODIFIED_TO_DIAL";
+ case RIL_E_SS_MODIFIED_TO_USSD: return "E_SS_MODIFIED_TO_USSD";
+ case RIL_E_SUBSCRIPTION_NOT_SUPPORTED: return "E_SUBSCRIPTION_NOT_SUPPORTED";
+ case RIL_E_SS_MODIFIED_TO_SS: return "E_SS_MODIFIED_TO_SS";
+ case RIL_E_LCE_NOT_SUPPORTED: return "E_LCE_NOT_SUPPORTED";
+ case RIL_E_NO_MEMORY: return "E_NO_MEMORY";
+ case RIL_E_INTERNAL_ERR: return "E_INTERNAL_ERR";
+ case RIL_E_SYSTEM_ERR: return "E_SYSTEM_ERR";
+ case RIL_E_MODEM_ERR: return "E_MODEM_ERR";
+ case RIL_E_INVALID_STATE: return "E_INVALID_STATE";
+ case RIL_E_NO_RESOURCES: return "E_NO_RESOURCES";
+ case RIL_E_SIM_ERR: return "E_SIM_ERR";
+ case RIL_E_INVALID_ARGUMENTS: return "E_INVALID_ARGUMENTS";
+ case RIL_E_INVALID_SIM_STATE: return "E_INVALID_SIM_STATE";
+ case RIL_E_INVALID_MODEM_STATE: return "E_INVALID_MODEM_STATE";
+ case RIL_E_INVALID_CALL_ID: return "E_INVALID_CALL_ID";
+ case RIL_E_NO_SMS_TO_ACK: return "E_NO_SMS_TO_ACK";
+ case RIL_E_NETWORK_ERR: return "E_NETWORK_ERR";
+ case RIL_E_REQUEST_RATE_LIMITED: return "E_REQUEST_RATE_LIMITED";
+ case RIL_E_SIM_BUSY: return "E_SIM_BUSY";
+ case RIL_E_SIM_FULL: return "E_SIM_FULL";
+ case RIL_E_NETWORK_REJECT: return "E_NETWORK_REJECT";
+ case RIL_E_OPERATION_NOT_ALLOWED: return "E_OPERATION_NOT_ALLOWED";
+ case RIL_E_EMPTY_RECORD: "E_EMPTY_RECORD";
+ case RIL_E_OEM_ERROR_1: return "E_OEM_ERROR_1";
+ case RIL_E_OEM_ERROR_2: return "E_OEM_ERROR_2";
+ case RIL_E_OEM_ERROR_3: return "E_OEM_ERROR_3";
+ case RIL_E_OEM_ERROR_4: return "E_OEM_ERROR_4";
+ case RIL_E_OEM_ERROR_5: return "E_OEM_ERROR_5";
+ case RIL_E_OEM_ERROR_6: return "E_OEM_ERROR_6";
+ case RIL_E_OEM_ERROR_7: return "E_OEM_ERROR_7";
+ case RIL_E_OEM_ERROR_8: return "E_OEM_ERROR_8";
+ case RIL_E_OEM_ERROR_9: return "E_OEM_ERROR_9";
+ case RIL_E_OEM_ERROR_10: return "E_OEM_ERROR_10";
+ case RIL_E_OEM_ERROR_11: return "E_OEM_ERROR_11";
+ case RIL_E_OEM_ERROR_12: return "E_OEM_ERROR_12";
+ case RIL_E_OEM_ERROR_13: return "E_OEM_ERROR_13";
+ case RIL_E_OEM_ERROR_14: return "E_OEM_ERROR_14";
+ case RIL_E_OEM_ERROR_15: return "E_OEM_ERROR_15";
+ case RIL_E_OEM_ERROR_16: return "E_OEM_ERROR_16";
+ case RIL_E_OEM_ERROR_17: return "E_OEM_ERROR_17";
+ case RIL_E_OEM_ERROR_18: return "E_OEM_ERROR_18";
+ case RIL_E_OEM_ERROR_19: return "E_OEM_ERROR_19";
+ case RIL_E_OEM_ERROR_20: return "E_OEM_ERROR_20";
+ case RIL_E_OEM_ERROR_21: return "E_OEM_ERROR_21";
+ case RIL_E_OEM_ERROR_22: return "E_OEM_ERROR_22";
+ case RIL_E_OEM_ERROR_23: return "E_OEM_ERROR_23";
+ case RIL_E_OEM_ERROR_24: return "E_OEM_ERROR_24";
+ case RIL_E_OEM_ERROR_25: return "E_OEM_ERROR_25";
default: return "<unknown error>";
}
}
case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU: return "RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU";
case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS: return "RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS";
case RIL_REQUEST_VOICE_RADIO_TECH: return "VOICE_RADIO_TECH";
+ case RIL_REQUEST_WRITE_SMS_TO_SIM: return "WRITE_SMS_TO_SIM";
case RIL_REQUEST_GET_CELL_INFO_LIST: return"GET_CELL_INFO_LIST";
case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: return"SET_UNSOL_CELL_INFO_LIST_RATE";
case RIL_REQUEST_SET_INITIAL_ATTACH_APN: return "RIL_REQUEST_SET_INITIAL_ATTACH_APN";
case RIL_REQUEST_SIM_OPEN_CHANNEL: return "SIM_OPEN_CHANNEL";
case RIL_REQUEST_SIM_CLOSE_CHANNEL: return "SIM_CLOSE_CHANNEL";
case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: return "SIM_TRANSMIT_APDU_CHANNEL";
+ case RIL_REQUEST_GET_RADIO_CAPABILITY: return "RIL_REQUEST_GET_RADIO_CAPABILITY";
+ case RIL_REQUEST_SET_RADIO_CAPABILITY: return "RIL_REQUEST_SET_RADIO_CAPABILITY";
+ case RIL_REQUEST_SET_UICC_SUBSCRIPTION: return "SET_UICC_SUBSCRIPTION";
+ case RIL_REQUEST_ALLOW_DATA: return "ALLOW_DATA";
+ case RIL_REQUEST_GET_HARDWARE_CONFIG: return "GET_HARDWARE_CONFIG";
+ case RIL_REQUEST_SIM_AUTHENTICATION: return "SIM_AUTHENTICATION";
+ case RIL_REQUEST_GET_DC_RT_INFO: return "GET_DC_RT_INFO";
+ case RIL_REQUEST_SET_DC_RT_INFO_RATE: return "SET_DC_RT_INFO_RATE";
+ case RIL_REQUEST_SET_DATA_PROFILE: return "SET_DATA_PROFILE";
case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST(obsolete)";
case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED";
case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH";
+ case RIL_UNSOL_SUPP_SVC_NOTIFICATION: return "UNSOL_SUPP_SVC_NOTIFICATION";
case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END";
case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND";
case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY";
case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: return "UNSOL_VOICE_RADIO_TECH_CHANGED";
case RIL_UNSOL_CELL_INFO_LIST: return "UNSOL_CELL_INFO_LIST";
case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED: return "RESPONSE_IMS_NETWORK_STATE_CHANGED";
+ case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED: return "UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED";
+ case RIL_UNSOL_SRVCC_STATE_NOTIFY: return "UNSOL_SRVCC_STATE_NOTIFY";
+ case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: return "HARDWARE_CONFIG_CHANGED";
+ case RIL_UNSOL_DC_RT_INFO_CHANGED: return "UNSOL_DC_RT_INFO_CHANGED";
+ case RIL_REQUEST_SHUTDOWN: return "SHUTDOWN";
+ case RIL_UNSOL_RADIO_CAPABILITY: return "RIL_UNSOL_RADIO_CAPABILITY";
+ case RIL_RESPONSE_ACKNOWLEDGEMENT: return "RIL_RESPONSE_ACKNOWLEDGEMENT";
default: return "<unknown request>";
}
}
+const char *
+rilSocketIdToString(RIL_SOCKET_ID socket_id)
+{
+ switch(socket_id) {
+ case RIL_SOCKET_1:
+ return "RIL_SOCKET_1";
+#if (SIM_COUNT >= 2)
+ case RIL_SOCKET_2:
+ return "RIL_SOCKET_2";
+#endif
+#if (SIM_COUNT >= 3)
+ case RIL_SOCKET_3:
+ return "RIL_SOCKET_3";
+#endif
+#if (SIM_COUNT >= 4)
+ case RIL_SOCKET_4:
+ return "RIL_SOCKET_4";
+#endif
+ default:
+ return "not a valid RIL";
+ }
+}
+
+/*
+ * Returns true for a debuggable build.
+ */
+static bool isDebuggable() {
+ char debuggable[PROP_VALUE_MAX];
+ property_get("ro.debuggable", debuggable, "0");
+ if (strcmp(debuggable, "1") == 0) {
+ return true;
+ }
+ return false;
+}
+
} /* namespace android */
+
+void rilEventAddWakeup_helper(struct ril_event *ev) {
+ android::rilEventAddWakeup(ev);
+}
+
+void listenCallback_helper(int fd, short flags, void *param) {
+ android::listenCallback(fd, flags, param);
+}
+
+int blockingWrite_helper(int fd, void *buffer, size_t len) {
+ return android::blockingWrite(fd, buffer, len);
+}
OSDN Git Service
