blob: 1d64bb0c28ebf17b5fd0c9450c5bb2f4896f5ed7 [file] [log] [blame] [edit]
/*
* Copyright (c) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "RILC"
#include <android/hardware/radio/1.1/IRadio.h>
#include <android/hardware/radio/1.1/IRadioResponse.h>
#include <android/hardware/radio/1.1/IRadioIndication.h>
#include <android/hardware/radio/1.1/types.h>
#include <hwbinder/IPCThreadState.h>
#include <hwbinder/ProcessState.h>
#include <telephony/ril.h>
#include <telephony/ril_mnc.h>
#include <telephony/ril_mcc.h>
#include <ril_service.h>
#include <hidl/HidlTransportSupport.h>
#include <utils/SystemClock.h>
#include <inttypes.h>
#define INVALID_HEX_CHAR 16
using namespace android::hardware::radio;
using namespace android::hardware::radio::V1_0;
using ::android::hardware::configureRpcThreadpool;
using ::android::hardware::joinRpcThreadpool;
using ::android::hardware::Return;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::hidl_array;
using ::android::hardware::Void;
using android::CommandInfo;
using android::RequestInfo;
using android::requestToString;
using android::sp;
#define BOOL_TO_INT(x) (x ? 1 : 0)
#define ATOI_NULL_HANDLED(x) (x ? atoi(x) : -1)
#define ATOI_NULL_HANDLED_DEF(x, defaultVal) (x ? atoi(x) : defaultVal)
#if defined(ANDROID_MULTI_SIM)
#define CALL_ONREQUEST(a, b, c, d, e) \
s_vendorFunctions->onRequest((a), (b), (c), (d), ((RIL_SOCKET_ID)(e)))
#define CALL_ONSTATEREQUEST(a) s_vendorFunctions->onStateRequest((RIL_SOCKET_ID)(a))
#else
#define CALL_ONREQUEST(a, b, c, d, e) s_vendorFunctions->onRequest((a), (b), (c), (d))
#define CALL_ONSTATEREQUEST(a) s_vendorFunctions->onStateRequest()
#endif
RIL_RadioFunctions *s_vendorFunctions = NULL;
static CommandInfo *s_commands;
struct RadioImpl;
#if (SIM_COUNT >= 2)
sp<RadioImpl> radioService[SIM_COUNT];
int64_t nitzTimeReceived[SIM_COUNT];
// counter used for synchronization. It is incremented every time response callbacks are updated.
volatile int32_t mCounterRadio[SIM_COUNT];
#else
sp<RadioImpl> radioService[1];
int64_t nitzTimeReceived[1];
// counter used for synchronization. It is incremented every time response callbacks are updated.
volatile int32_t mCounterRadio[1];
#endif
static pthread_rwlock_t radioServiceRwlock = PTHREAD_RWLOCK_INITIALIZER;
#if (SIM_COUNT >= 2)
static pthread_rwlock_t radioServiceRwlock2 = PTHREAD_RWLOCK_INITIALIZER;
#if (SIM_COUNT >= 3)
static pthread_rwlock_t radioServiceRwlock3 = PTHREAD_RWLOCK_INITIALIZER;
#if (SIM_COUNT >= 4)
static pthread_rwlock_t radioServiceRwlock4 = PTHREAD_RWLOCK_INITIALIZER;
#endif
#endif
#endif
void convertRilHardwareConfigListToHal(void *response, size_t responseLen,
hidl_vec<HardwareConfig>& records);
void convertRilRadioCapabilityToHal(void *response, size_t responseLen, RadioCapability& rc);
void convertRilLceDataInfoToHal(void *response, size_t responseLen, LceDataInfo& lce);
void convertRilSignalStrengthToHal(void *response, size_t responseLen,
SignalStrength& signalStrength);
void convertRilDataCallToHal(RIL_Data_Call_Response_v11 *dcResponse,
SetupDataCallResult& dcResult);
void convertRilDataCallListToHal(void *response, size_t responseLen,
hidl_vec<SetupDataCallResult>& dcResultList);
void convertRilCellInfoListToHal(void *response, size_t responseLen, hidl_vec<CellInfo>& records);
struct RadioImpl : public V1_1::IRadio {
int32_t mSlotId;
sp<IRadioResponse> mRadioResponse;
sp<IRadioIndication> mRadioIndication;
sp<V1_1::IRadioResponse> mRadioResponseV1_1;
sp<V1_1::IRadioIndication> mRadioIndicationV1_1;
Return<void> setResponseFunctions(
const ::android::sp<IRadioResponse>& radioResponse,
const ::android::sp<IRadioIndication>& radioIndication);
Return<void> getIccCardStatus(int32_t serial);
Return<void> supplyIccPinForApp(int32_t serial, const hidl_string& pin,
const hidl_string& aid);
Return<void> supplyIccPukForApp(int32_t serial, const hidl_string& puk,
const hidl_string& pin, const hidl_string& aid);
Return<void> supplyIccPin2ForApp(int32_t serial,
const hidl_string& pin2,
const hidl_string& aid);
Return<void> supplyIccPuk2ForApp(int32_t serial, const hidl_string& puk2,
const hidl_string& pin2, const hidl_string& aid);
Return<void> changeIccPinForApp(int32_t serial, const hidl_string& oldPin,
const hidl_string& newPin, const hidl_string& aid);
Return<void> changeIccPin2ForApp(int32_t serial, const hidl_string& oldPin2,
const hidl_string& newPin2, const hidl_string& aid);
Return<void> supplyNetworkDepersonalization(int32_t serial, const hidl_string& netPin);
Return<void> getCurrentCalls(int32_t serial);
Return<void> dial(int32_t serial, const Dial& dialInfo);
Return<void> getImsiForApp(int32_t serial,
const ::android::hardware::hidl_string& aid);
Return<void> hangup(int32_t serial, int32_t gsmIndex);
Return<void> hangupWaitingOrBackground(int32_t serial);
Return<void> hangupForegroundResumeBackground(int32_t serial);
Return<void> switchWaitingOrHoldingAndActive(int32_t serial);
Return<void> conference(int32_t serial);
Return<void> rejectCall(int32_t serial);
Return<void> getLastCallFailCause(int32_t serial);
Return<void> getSignalStrength(int32_t serial);
Return<void> getVoiceRegistrationState(int32_t serial);
Return<void> getDataRegistrationState(int32_t serial);
Return<void> getOperator(int32_t serial);
Return<void> setRadioPower(int32_t serial, bool on);
Return<void> sendDtmf(int32_t serial,
const ::android::hardware::hidl_string& s);
Return<void> sendSms(int32_t serial, const GsmSmsMessage& message);
Return<void> sendSMSExpectMore(int32_t serial, const GsmSmsMessage& message);
Return<void> setupDataCall(int32_t serial,
RadioTechnology radioTechnology,
const DataProfileInfo& profileInfo,
bool modemCognitive,
bool roamingAllowed,
bool isRoaming);
Return<void> iccIOForApp(int32_t serial,
const IccIo& iccIo);
Return<void> sendUssd(int32_t serial,
const ::android::hardware::hidl_string& ussd);
Return<void> cancelPendingUssd(int32_t serial);
Return<void> getClir(int32_t serial);
Return<void> setClir(int32_t serial, int32_t status);
Return<void> getCallForwardStatus(int32_t serial,
const CallForwardInfo& callInfo);
Return<void> setCallForward(int32_t serial,
const CallForwardInfo& callInfo);
Return<void> getCallWaiting(int32_t serial, int32_t serviceClass);
Return<void> setCallWaiting(int32_t serial, bool enable, int32_t serviceClass);
Return<void> acknowledgeLastIncomingGsmSms(int32_t serial,
bool success, SmsAcknowledgeFailCause cause);
Return<void> acceptCall(int32_t serial);
Return<void> deactivateDataCall(int32_t serial,
int32_t cid, bool reasonRadioShutDown);
Return<void> getFacilityLockForApp(int32_t serial,
const ::android::hardware::hidl_string& facility,
const ::android::hardware::hidl_string& password,
int32_t serviceClass,
const ::android::hardware::hidl_string& appId);
Return<void> setFacilityLockForApp(int32_t serial,
const ::android::hardware::hidl_string& facility,
bool lockState,
const ::android::hardware::hidl_string& password,
int32_t serviceClass,
const ::android::hardware::hidl_string& appId);
Return<void> setBarringPassword(int32_t serial,
const ::android::hardware::hidl_string& facility,
const ::android::hardware::hidl_string& oldPassword,
const ::android::hardware::hidl_string& newPassword);
Return<void> getNetworkSelectionMode(int32_t serial);
Return<void> setNetworkSelectionModeAutomatic(int32_t serial);
Return<void> setNetworkSelectionModeManual(int32_t serial,
const ::android::hardware::hidl_string& operatorNumeric);
Return<void> getAvailableNetworks(int32_t serial);
Return<void> startNetworkScan(int32_t serial, const V1_1::NetworkScanRequest& request);
Return<void> stopNetworkScan(int32_t serial);
Return<void> startDtmf(int32_t serial,
const ::android::hardware::hidl_string& s);
Return<void> stopDtmf(int32_t serial);
Return<void> getBasebandVersion(int32_t serial);
Return<void> separateConnection(int32_t serial, int32_t gsmIndex);
Return<void> setMute(int32_t serial, bool enable);
Return<void> getMute(int32_t serial);
Return<void> getClip(int32_t serial);
Return<void> getDataCallList(int32_t serial);
Return<void> setSuppServiceNotifications(int32_t serial, bool enable);
Return<void> writeSmsToSim(int32_t serial,
const SmsWriteArgs& smsWriteArgs);
Return<void> deleteSmsOnSim(int32_t serial, int32_t index);
Return<void> setBandMode(int32_t serial, RadioBandMode mode);
Return<void> getAvailableBandModes(int32_t serial);
Return<void> sendEnvelope(int32_t serial,
const ::android::hardware::hidl_string& command);
Return<void> sendTerminalResponseToSim(int32_t serial,
const ::android::hardware::hidl_string& commandResponse);
Return<void> handleStkCallSetupRequestFromSim(int32_t serial, bool accept);
Return<void> explicitCallTransfer(int32_t serial);
Return<void> setPreferredNetworkType(int32_t serial, PreferredNetworkType nwType);
Return<void> getPreferredNetworkType(int32_t serial);
Return<void> getNeighboringCids(int32_t serial);
Return<void> setLocationUpdates(int32_t serial, bool enable);
Return<void> setCdmaSubscriptionSource(int32_t serial,
CdmaSubscriptionSource cdmaSub);
Return<void> setCdmaRoamingPreference(int32_t serial, CdmaRoamingType type);
Return<void> getCdmaRoamingPreference(int32_t serial);
Return<void> setTTYMode(int32_t serial, TtyMode mode);
Return<void> getTTYMode(int32_t serial);
Return<void> setPreferredVoicePrivacy(int32_t serial, bool enable);
Return<void> getPreferredVoicePrivacy(int32_t serial);
Return<void> sendCDMAFeatureCode(int32_t serial,
const ::android::hardware::hidl_string& featureCode);
Return<void> sendBurstDtmf(int32_t serial,
const ::android::hardware::hidl_string& dtmf,
int32_t on,
int32_t off);
Return<void> sendCdmaSms(int32_t serial, const CdmaSmsMessage& sms);
Return<void> acknowledgeLastIncomingCdmaSms(int32_t serial,
const CdmaSmsAck& smsAck);
Return<void> getGsmBroadcastConfig(int32_t serial);
Return<void> setGsmBroadcastConfig(int32_t serial,
const hidl_vec<GsmBroadcastSmsConfigInfo>& configInfo);
Return<void> setGsmBroadcastActivation(int32_t serial, bool activate);
Return<void> getCdmaBroadcastConfig(int32_t serial);
Return<void> setCdmaBroadcastConfig(int32_t serial,
const hidl_vec<CdmaBroadcastSmsConfigInfo>& configInfo);
Return<void> setCdmaBroadcastActivation(int32_t serial, bool activate);
Return<void> getCDMASubscription(int32_t serial);
Return<void> writeSmsToRuim(int32_t serial, const CdmaSmsWriteArgs& cdmaSms);
Return<void> deleteSmsOnRuim(int32_t serial, int32_t index);
Return<void> getDeviceIdentity(int32_t serial);
Return<void> exitEmergencyCallbackMode(int32_t serial);
Return<void> getSmscAddress(int32_t serial);
Return<void> setSmscAddress(int32_t serial,
const ::android::hardware::hidl_string& smsc);
Return<void> reportSmsMemoryStatus(int32_t serial, bool available);
Return<void> reportStkServiceIsRunning(int32_t serial);
Return<void> getCdmaSubscriptionSource(int32_t serial);
Return<void> requestIsimAuthentication(int32_t serial,
const ::android::hardware::hidl_string& challenge);
Return<void> acknowledgeIncomingGsmSmsWithPdu(int32_t serial,
bool success,
const ::android::hardware::hidl_string& ackPdu);
Return<void> sendEnvelopeWithStatus(int32_t serial,
const ::android::hardware::hidl_string& contents);
Return<void> getVoiceRadioTechnology(int32_t serial);
Return<void> getCellInfoList(int32_t serial);
Return<void> setCellInfoListRate(int32_t serial, int32_t rate);
Return<void> setInitialAttachApn(int32_t serial, const DataProfileInfo& dataProfileInfo,
bool modemCognitive, bool isRoaming);
Return<void> getImsRegistrationState(int32_t serial);
Return<void> sendImsSms(int32_t serial, const ImsSmsMessage& message);
Return<void> iccTransmitApduBasicChannel(int32_t serial, const SimApdu& message);
Return<void> iccOpenLogicalChannel(int32_t serial,
const ::android::hardware::hidl_string& aid, int32_t p2);
Return<void> iccCloseLogicalChannel(int32_t serial, int32_t channelId);
Return<void> iccTransmitApduLogicalChannel(int32_t serial, const SimApdu& message);
Return<void> nvReadItem(int32_t serial, NvItem itemId);
Return<void> nvWriteItem(int32_t serial, const NvWriteItem& item);
Return<void> nvWriteCdmaPrl(int32_t serial,
const ::android::hardware::hidl_vec<uint8_t>& prl);
Return<void> nvResetConfig(int32_t serial, ResetNvType resetType);
Return<void> setUiccSubscription(int32_t serial, const SelectUiccSub& uiccSub);
Return<void> setDataAllowed(int32_t serial, bool allow);
Return<void> getHardwareConfig(int32_t serial);
Return<void> requestIccSimAuthentication(int32_t serial,
int32_t authContext,
const ::android::hardware::hidl_string& authData,
const ::android::hardware::hidl_string& aid);
Return<void> setDataProfile(int32_t serial,
const ::android::hardware::hidl_vec<DataProfileInfo>& profiles, bool isRoaming);
Return<void> requestShutdown(int32_t serial);
Return<void> getRadioCapability(int32_t serial);
Return<void> setRadioCapability(int32_t serial, const RadioCapability& rc);
Return<void> startLceService(int32_t serial, int32_t reportInterval, bool pullMode);
Return<void> stopLceService(int32_t serial);
Return<void> pullLceData(int32_t serial);
Return<void> getModemActivityInfo(int32_t serial);
Return<void> setAllowedCarriers(int32_t serial,
bool allAllowed,
const CarrierRestrictions& carriers);
Return<void> getAllowedCarriers(int32_t serial);
Return<void> sendDeviceState(int32_t serial, DeviceStateType deviceStateType, bool state);
Return<void> setIndicationFilter(int32_t serial, int32_t indicationFilter);
Return<void> startKeepalive(int32_t serial, const V1_1::KeepaliveRequest& keepalive);
Return<void> stopKeepalive(int32_t serial, int32_t sessionHandle);
Return<void> setSimCardPower(int32_t serial, bool powerUp);
Return<void> setSimCardPower_1_1(int32_t serial,
const V1_1::CardPowerState state);
Return<void> responseAcknowledgement();
Return<void> setCarrierInfoForImsiEncryption(int32_t serial,
const V1_1::ImsiEncryptionInfo& message);
void checkReturnStatus(Return<void>& ret);
};
void memsetAndFreeStrings(int numPointers, ...) {
va_list ap;
va_start(ap, numPointers);
for (int i = 0; i < numPointers; i++) {
char *ptr = va_arg(ap, char *);
if (ptr) {
#ifdef MEMSET_FREED
#define MAX_STRING_LENGTH 4096
memset(ptr, 0, strnlen(ptr, MAX_STRING_LENGTH));
#endif
free(ptr);
}
}
va_end(ap);
}
void sendErrorResponse(RequestInfo *pRI, RIL_Errno err) {
pRI->pCI->responseFunction((int) pRI->socket_id,
(int) RadioResponseType::SOLICITED, pRI->token, err, NULL, 0);
}
/**
* Copies over src to dest. If memory allocation fails, responseFunction() is called for the
* request with error RIL_E_NO_MEMORY. The size() method is used to determine the size of the
* destination buffer into which the HIDL string is copied. If there is a discrepancy between
* the string length reported by the size() method, and the length of the string returned by
* the c_str() method, the function will return false indicating a failure.
*
* Returns true on success, and false on failure.
*/
bool copyHidlStringToRil(char **dest, const hidl_string &src, RequestInfo *pRI, bool allowEmpty) {
size_t len = src.size();
if (len == 0 && !allowEmpty) {
*dest = NULL;
return true;
}
*dest = (char *) calloc(len + 1, sizeof(char));
if (*dest == NULL) {
RLOGE("Memory allocation failed for request %s", requestToString(pRI->pCI->requestNumber));
sendErrorResponse(pRI, RIL_E_NO_MEMORY);
return false;
}
if (strlcpy(*dest, src.c_str(), len + 1) >= (len + 1)) {
RLOGE("Copy of the HIDL string has been truncated, as "
"the string length reported by size() does not "
"match the length of string returned by c_str().");
free(*dest);
*dest = NULL;
sendErrorResponse(pRI, RIL_E_INTERNAL_ERR);
return false;
}
return true;
}
bool copyHidlStringToRil(char **dest, const hidl_string &src, RequestInfo *pRI) {
return copyHidlStringToRil(dest, src, pRI, false);
}
hidl_string convertCharPtrToHidlString(const char *ptr) {
hidl_string ret;
if (ptr != NULL) {
// TODO: replace this with strnlen
ret.setToExternal(ptr, strlen(ptr));
}
return ret;
}
bool dispatchVoid(int serial, int slotId, int request) {
RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
if (pRI == NULL) {
return false;
}
CALL_ONREQUEST(request, NULL, 0, pRI, slotId);
return true;
}
bool dispatchString(int serial, int slotId, int request, const char * str) {
RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
if (pRI == NULL) {
return false;
}
char *pString;
if (!copyHidlStringToRil(&pString, str, pRI)) {
return false;
}
CALL_ONREQUEST(request, pString, sizeof(char *), pRI, slotId);
memsetAndFreeStrings(1, pString);
return true;
}
bool dispatchStrings(int serial, int slotId, int request, bool allowEmpty, int countStrings, ...) {
RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
if (pRI == NULL) {
return false;
}
char **pStrings;
pStrings = (char **)calloc(countStrings, sizeof(char *));
if (pStrings == NULL) {
RLOGE("Memory allocation failed for request %s", requestToString(request));
sendErrorResponse(pRI, RIL_E_NO_MEMORY);
return false;
}
va_list ap;
va_start(ap, countStrings);
for (int i = 0; i < countStrings; i++) {
const char* str = va_arg(ap, const char *);
if (!copyHidlStringToRil(&pStrings[i], hidl_string(str), pRI, allowEmpty)) {
va_end(ap);
for (int j = 0; j < i; j++) {
memsetAndFreeStrings(1, pStrings[j]);
}
free(pStrings);
return false;
}
}
va_end(ap);
CALL_ONREQUEST(request, pStrings, countStrings * sizeof(char *), pRI, slotId);
if (pStrings != NULL) {
for (int i = 0 ; i < countStrings ; i++) {
memsetAndFreeStrings(1, pStrings[i]);
}
#ifdef MEMSET_FREED
memset(pStrings, 0, countStrings * sizeof(char *));
#endif
free(pStrings);
}
return true;
}
bool dispatchStrings(int serial, int slotId, int request, const hidl_vec<hidl_string>& data) {
RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
if (pRI == NULL) {
return false;
}
int countStrings = data.size();
char **pStrings;
pStrings = (char **)calloc(countStrings, sizeof(char *));
if (pStrings == NULL) {
RLOGE("Memory allocation failed for request %s", requestToString(request));
sendErrorResponse(pRI, RIL_E_NO_MEMORY);
return false;
}
for (int i = 0; i < countStrings; i++) {
if (!copyHidlStringToRil(&pStrings[i], data[i], pRI)) {
for (int j = 0; j < i; j++) {
memsetAndFreeStrings(1, pStrings[j]);
}
free(pStrings);
return false;
}
}
CALL_ONREQUEST(request, pStrings, countStrings * sizeof(char *), pRI, slotId);
if (pStrings != NULL) {
for (int i = 0 ; i < countStrings ; i++) {
memsetAndFreeStrings(1, pStrings[i]);
}
#ifdef MEMSET_FREED
memset(pStrings, 0, countStrings * sizeof(char *));
#endif
free(pStrings);
}
return true;
}
bool dispatchInts(int serial, int slotId, int request, int countInts, ...) {
RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
if (pRI == NULL) {
return false;
}
int *pInts = (int *)calloc(countInts, sizeof(int));
if (pInts == NULL) {
RLOGE("Memory allocation failed for request %s", requestToString(request));
sendErrorResponse(pRI, RIL_E_NO_MEMORY);
return false;
}
va_list ap;
va_start(ap, countInts);
for (int i = 0; i < countInts; i++) {
pInts[i] = va_arg(ap, int);
}
va_end(ap);
CALL_ONREQUEST(request, pInts, countInts * sizeof(int), pRI, slotId);
if (pInts != NULL) {
#ifdef MEMSET_FREED
memset(pInts, 0, countInts * sizeof(int));
#endif
free(pInts);
}
return true;
}
bool dispatchCallForwardStatus(int serial, int slotId, int request,
const CallForwardInfo& callInfo) {
RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
if (pRI == NULL) {
return false;
}
RIL_CallForwardInfo cf;
cf.status = (int) callInfo.status;
cf.reason = callInfo.reason;
cf.serviceClass = callInfo.serviceClass;
cf.toa = callInfo.toa;
cf.timeSeconds = callInfo.timeSeconds;
if (!copyHidlStringToRil(&cf.number, callInfo.number, pRI)) {
return false;
}
CALL_ONREQUEST(request, &cf, sizeof(cf), pRI, slotId);
memsetAndFreeStrings(1, cf.number);
return true;
}
bool dispatchRaw(int serial, int slotId, int request, const hidl_vec<uint8_t>& rawBytes) {
RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
if (pRI == NULL) {
return false;
}
const uint8_t *uData = rawBytes.data();
CALL_ONREQUEST(request, (void *) uData, rawBytes.size(), pRI, slotId);
return true;
}
bool dispatchIccApdu(int serial, int slotId, int request, const SimApdu& message) {
RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
if (pRI == NULL) {
return false;
}
RIL_SIM_APDU apdu = {};
apdu.sessionid = message.sessionId;
apdu.cla = message.cla;
apdu.instruction = message.instruction;
apdu.p1 = message.p1;
apdu.p2 = message.p2;
apdu.p3 = message.p3;
if (!copyHidlStringToRil(&apdu.data, message.data, pRI)) {
return false;
}
CALL_ONREQUEST(request, &apdu, sizeof(apdu), pRI, slotId);
memsetAndFreeStrings(1, apdu.data);
return true;
}
void checkReturnStatus(int32_t slotId, Return<void>& ret, bool isRadioService) {
if (ret.isOk() == false) {
RLOGE("checkReturnStatus: unable to call response/indication callback");
// Remote process hosting the callbacks must be dead. Reset the callback objects;
// there's no other recovery to be done here. When the client process is back up, it will
// call setResponseFunctions()
// Caller should already hold rdlock, release that first
// note the current counter to avoid overwriting updates made by another thread before
// write lock is acquired.
int counter = mCounterRadio[slotId];
pthread_rwlock_t *radioServiceRwlockPtr = radio::getRadioServiceRwlock(slotId);
int ret = pthread_rwlock_unlock(radioServiceRwlockPtr);
assert(ret == 0);
// acquire wrlock
ret = pthread_rwlock_wrlock(radioServiceRwlockPtr);
assert(ret == 0);
// make sure the counter value has not changed
if (counter == mCounterRadio[slotId]) {
radioService[slotId]->mRadioResponse = NULL;
radioService[slotId]->mRadioIndication = NULL;
radioService[slotId]->mRadioResponseV1_1 = NULL;
radioService[slotId]->mRadioIndicationV1_1 = NULL;
mCounterRadio[slotId]++;
} else {
RLOGE("checkReturnStatus: not resetting responseFunctions as they likely "
"got updated on another thread");
}
// release wrlock
ret = pthread_rwlock_unlock(radioServiceRwlockPtr);
assert(ret == 0);
// Reacquire rdlock
ret = pthread_rwlock_rdlock(radioServiceRwlockPtr);
assert(ret == 0);
}
}
void RadioImpl::checkReturnStatus(Return<void>& ret) {
::checkReturnStatus(mSlotId, ret, true);
}
Return<void> RadioImpl::setResponseFunctions(
const ::android::sp<IRadioResponse>& radioResponseParam,
const ::android::sp<IRadioIndication>& radioIndicationParam) {
RLOGD("setResponseFunctions");
pthread_rwlock_t *radioServiceRwlockPtr = radio::getRadioServiceRwlock(mSlotId);
int ret = pthread_rwlock_wrlock(radioServiceRwlockPtr);
assert(ret == 0);
mRadioResponse = radioResponseParam;
mRadioIndication = radioIndicationParam;
mRadioResponseV1_1 = V1_1::IRadioResponse::castFrom(mRadioResponse).withDefault(nullptr);
mRadioIndicationV1_1 = V1_1::IRadioIndication::castFrom(mRadioIndication).withDefault(nullptr);
if (mRadioResponseV1_1 == nullptr || mRadioIndicationV1_1 == nullptr) {
mRadioResponseV1_1 = nullptr;
mRadioIndicationV1_1 = nullptr;
}
mCounterRadio[mSlotId]++;
ret = pthread_rwlock_unlock(radioServiceRwlockPtr);
assert(ret == 0);
// client is connected. Send initial indications.
android::onNewCommandConnect((RIL_SOCKET_ID) mSlotId);
return Void();
}
Return<void> RadioImpl::getIccCardStatus(int32_t serial) {
#if VDBG
RLOGD("getIccCardStatus: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_SIM_STATUS);
return Void();
}
Return<void> RadioImpl::supplyIccPinForApp(int32_t serial, const hidl_string& pin,
const hidl_string& aid) {
#if VDBG
RLOGD("supplyIccPinForApp: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_ENTER_SIM_PIN, true,
2, pin.c_str(), aid.c_str());
return Void();
}
Return<void> RadioImpl::supplyIccPukForApp(int32_t serial, const hidl_string& puk,
const hidl_string& pin, const hidl_string& aid) {
#if VDBG
RLOGD("supplyIccPukForApp: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_ENTER_SIM_PUK, true,
3, puk.c_str(), pin.c_str(), aid.c_str());
return Void();
}
Return<void> RadioImpl::supplyIccPin2ForApp(int32_t serial, const hidl_string& pin2,
const hidl_string& aid) {
#if VDBG
RLOGD("supplyIccPin2ForApp: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_ENTER_SIM_PIN2, true,
2, pin2.c_str(), aid.c_str());
return Void();
}
Return<void> RadioImpl::supplyIccPuk2ForApp(int32_t serial, const hidl_string& puk2,
const hidl_string& pin2, const hidl_string& aid) {
#if VDBG
RLOGD("supplyIccPuk2ForApp: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_ENTER_SIM_PUK2, true,
3, puk2.c_str(), pin2.c_str(), aid.c_str());
return Void();
}
Return<void> RadioImpl::changeIccPinForApp(int32_t serial, const hidl_string& oldPin,
const hidl_string& newPin, const hidl_string& aid) {
#if VDBG
RLOGD("changeIccPinForApp: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_CHANGE_SIM_PIN, true,
3, oldPin.c_str(), newPin.c_str(), aid.c_str());
return Void();
}
Return<void> RadioImpl::changeIccPin2ForApp(int32_t serial, const hidl_string& oldPin2,
const hidl_string& newPin2, const hidl_string& aid) {
#if VDBG
RLOGD("changeIccPin2ForApp: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_CHANGE_SIM_PIN2, true,
3, oldPin2.c_str(), newPin2.c_str(), aid.c_str());
return Void();
}
Return<void> RadioImpl::supplyNetworkDepersonalization(int32_t serial,
const hidl_string& netPin) {
#if VDBG
RLOGD("supplyNetworkDepersonalization: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION, true,
1, netPin.c_str());
return Void();
}
Return<void> RadioImpl::getCurrentCalls(int32_t serial) {
#if VDBG
RLOGD("getCurrentCalls: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_CURRENT_CALLS);
return Void();
}
Return<void> RadioImpl::dial(int32_t serial, const Dial& dialInfo) {
#if VDBG
RLOGD("dial: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_DIAL);
if (pRI == NULL) {
return Void();
}
RIL_Dial dial = {};
RIL_UUS_Info uusInfo = {};
int32_t sizeOfDial = sizeof(dial);
if (!copyHidlStringToRil(&dial.address, dialInfo.address, pRI)) {
return Void();
}
dial.clir = (int) dialInfo.clir;
if (dialInfo.uusInfo.size() != 0) {
uusInfo.uusType = (RIL_UUS_Type) dialInfo.uusInfo[0].uusType;
uusInfo.uusDcs = (RIL_UUS_DCS) dialInfo.uusInfo[0].uusDcs;
if (dialInfo.uusInfo[0].uusData.size() == 0) {
uusInfo.uusData = NULL;
uusInfo.uusLength = 0;
} else {
if (!copyHidlStringToRil(&uusInfo.uusData, dialInfo.uusInfo[0].uusData, pRI)) {
memsetAndFreeStrings(1, dial.address);
return Void();
}
uusInfo.uusLength = dialInfo.uusInfo[0].uusData.size();
}
dial.uusInfo = &uusInfo;
}
CALL_ONREQUEST(RIL_REQUEST_DIAL, &dial, sizeOfDial, pRI, mSlotId);
memsetAndFreeStrings(2, dial.address, uusInfo.uusData);
return Void();
}
Return<void> RadioImpl::getImsiForApp(int32_t serial, const hidl_string& aid) {
#if VDBG
RLOGD("getImsiForApp: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_GET_IMSI, false,
1, aid.c_str());
return Void();
}
Return<void> RadioImpl::hangup(int32_t serial, int32_t gsmIndex) {
#if VDBG
RLOGD("hangup: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_HANGUP, 1, gsmIndex);
return Void();
}
Return<void> RadioImpl::hangupWaitingOrBackground(int32_t serial) {
#if VDBG
RLOGD("hangupWaitingOrBackground: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND);
return Void();
}
Return<void> RadioImpl::hangupForegroundResumeBackground(int32_t serial) {
#if VDBG
RLOGD("hangupForegroundResumeBackground: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND);
return Void();
}
Return<void> RadioImpl::switchWaitingOrHoldingAndActive(int32_t serial) {
#if VDBG
RLOGD("switchWaitingOrHoldingAndActive: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE);
return Void();
}
Return<void> RadioImpl::conference(int32_t serial) {
#if VDBG
RLOGD("conference: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_CONFERENCE);
return Void();
}
Return<void> RadioImpl::rejectCall(int32_t serial) {
#if VDBG
RLOGD("rejectCall: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_UDUB);
return Void();
}
Return<void> RadioImpl::getLastCallFailCause(int32_t serial) {
#if VDBG
RLOGD("getLastCallFailCause: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_LAST_CALL_FAIL_CAUSE);
return Void();
}
Return<void> RadioImpl::getSignalStrength(int32_t serial) {
#if VDBG
RLOGD("getSignalStrength: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_SIGNAL_STRENGTH);
return Void();
}
Return<void> RadioImpl::getVoiceRegistrationState(int32_t serial) {
#if VDBG
RLOGD("getVoiceRegistrationState: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_VOICE_REGISTRATION_STATE);
return Void();
}
Return<void> RadioImpl::getDataRegistrationState(int32_t serial) {
#if VDBG
RLOGD("getDataRegistrationState: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_DATA_REGISTRATION_STATE);
return Void();
}
Return<void> RadioImpl::getOperator(int32_t serial) {
#if VDBG
RLOGD("getOperator: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_OPERATOR);
return Void();
}
Return<void> RadioImpl::setRadioPower(int32_t serial, bool on) {
RLOGD("setRadioPower: serial %d on %d", serial, on);
dispatchInts(serial, mSlotId, RIL_REQUEST_RADIO_POWER, 1, BOOL_TO_INT(on));
return Void();
}
Return<void> RadioImpl::sendDtmf(int32_t serial, const hidl_string& s) {
#if VDBG
RLOGD("sendDtmf: serial %d", serial);
#endif
dispatchString(serial, mSlotId, RIL_REQUEST_DTMF, s.c_str());
return Void();
}
Return<void> RadioImpl::sendSms(int32_t serial, const GsmSmsMessage& message) {
#if VDBG
RLOGD("sendSms: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_SEND_SMS, false,
2, message.smscPdu.c_str(), message.pdu.c_str());
return Void();
}
Return<void> RadioImpl::sendSMSExpectMore(int32_t serial, const GsmSmsMessage& message) {
#if VDBG
RLOGD("sendSMSExpectMore: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_SEND_SMS_EXPECT_MORE, false,
2, message.smscPdu.c_str(), message.pdu.c_str());
return Void();
}
static bool convertMvnoTypeToString(MvnoType type, char *&str) {
switch (type) {
case MvnoType::IMSI:
str = (char *)"imsi";
return true;
case MvnoType::GID:
str = (char *)"gid";
return true;
case MvnoType::SPN:
str = (char *)"spn";
return true;
case MvnoType::NONE:
str = (char *)"";
return true;
}
return false;
}
Return<void> RadioImpl::setupDataCall(int32_t serial, RadioTechnology radioTechnology,
const DataProfileInfo& dataProfileInfo, bool modemCognitive,
bool roamingAllowed, bool isRoaming) {
#if VDBG
RLOGD("setupDataCall: serial %d", serial);
#endif
if (s_vendorFunctions->version >= 4 && s_vendorFunctions->version <= 14) {
const hidl_string &protocol =
(isRoaming ? dataProfileInfo.roamingProtocol : dataProfileInfo.protocol);
dispatchStrings(serial, mSlotId, RIL_REQUEST_SETUP_DATA_CALL, true, 7,
std::to_string((int) radioTechnology + 2).c_str(),
std::to_string((int) dataProfileInfo.profileId).c_str(),
dataProfileInfo.apn.c_str(),
dataProfileInfo.user.c_str(),
dataProfileInfo.password.c_str(),
std::to_string((int) dataProfileInfo.authType).c_str(),
protocol.c_str());
} else if (s_vendorFunctions->version >= 15) {
char *mvnoTypeStr = NULL;
if (!convertMvnoTypeToString(dataProfileInfo.mvnoType, mvnoTypeStr)) {
RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
RIL_REQUEST_SETUP_DATA_CALL);
if (pRI != NULL) {
sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
}
return Void();
}
dispatchStrings(serial, mSlotId, RIL_REQUEST_SETUP_DATA_CALL, true, 15,
std::to_string((int) radioTechnology + 2).c_str(),
std::to_string((int) dataProfileInfo.profileId).c_str(),
dataProfileInfo.apn.c_str(),
dataProfileInfo.user.c_str(),
dataProfileInfo.password.c_str(),
std::to_string((int) dataProfileInfo.authType).c_str(),
dataProfileInfo.protocol.c_str(),
dataProfileInfo.roamingProtocol.c_str(),
std::to_string(dataProfileInfo.supportedApnTypesBitmap).c_str(),
std::to_string(dataProfileInfo.bearerBitmap).c_str(),
modemCognitive ? "1" : "0",
std::to_string(dataProfileInfo.mtu).c_str(),
mvnoTypeStr,
dataProfileInfo.mvnoMatchData.c_str(),
roamingAllowed ? "1" : "0");
} else {
RLOGE("Unsupported RIL version %d, min version expected 4", s_vendorFunctions->version);
RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
RIL_REQUEST_SETUP_DATA_CALL);
if (pRI != NULL) {
sendErrorResponse(pRI, RIL_E_REQUEST_NOT_SUPPORTED);
}
}
return Void();
}
Return<void> RadioImpl::iccIOForApp(int32_t serial, const IccIo& iccIo) {
#if VDBG
RLOGD("iccIOForApp: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SIM_IO);
if (pRI == NULL) {
return Void();
}
RIL_SIM_IO_v6 rilIccIo = {};
rilIccIo.command = iccIo.command;
rilIccIo.fileid = iccIo.fileId;
if (!copyHidlStringToRil(&rilIccIo.path, iccIo.path, pRI)) {
return Void();
}
rilIccIo.p1 = iccIo.p1;
rilIccIo.p2 = iccIo.p2;
rilIccIo.p3 = iccIo.p3;
if (!copyHidlStringToRil(&rilIccIo.data, iccIo.data, pRI)) {
memsetAndFreeStrings(1, rilIccIo.path);
return Void();
}
if (!copyHidlStringToRil(&rilIccIo.pin2, iccIo.pin2, pRI)) {
memsetAndFreeStrings(2, rilIccIo.path, rilIccIo.data);
return Void();
}
if (!copyHidlStringToRil(&rilIccIo.aidPtr, iccIo.aid, pRI)) {
memsetAndFreeStrings(3, rilIccIo.path, rilIccIo.data, rilIccIo.pin2);
return Void();
}
CALL_ONREQUEST(RIL_REQUEST_SIM_IO, &rilIccIo, sizeof(rilIccIo), pRI, mSlotId);
memsetAndFreeStrings(4, rilIccIo.path, rilIccIo.data, rilIccIo.pin2, rilIccIo.aidPtr);
return Void();
}
Return<void> RadioImpl::sendUssd(int32_t serial, const hidl_string& ussd) {
#if VDBG
RLOGD("sendUssd: serial %d", serial);
#endif
dispatchString(serial, mSlotId, RIL_REQUEST_SEND_USSD, ussd.c_str());
return Void();
}
Return<void> RadioImpl::cancelPendingUssd(int32_t serial) {
#if VDBG
RLOGD("cancelPendingUssd: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_CANCEL_USSD);
return Void();
}
Return<void> RadioImpl::getClir(int32_t serial) {
#if VDBG
RLOGD("getClir: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_CLIR);
return Void();
}
Return<void> RadioImpl::setClir(int32_t serial, int32_t status) {
#if VDBG
RLOGD("setClir: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_SET_CLIR, 1, status);
return Void();
}
Return<void> RadioImpl::getCallForwardStatus(int32_t serial, const CallForwardInfo& callInfo) {
#if VDBG
RLOGD("getCallForwardStatus: serial %d", serial);
#endif
dispatchCallForwardStatus(serial, mSlotId, RIL_REQUEST_QUERY_CALL_FORWARD_STATUS,
callInfo);
return Void();
}
Return<void> RadioImpl::setCallForward(int32_t serial, const CallForwardInfo& callInfo) {
#if VDBG
RLOGD("setCallForward: serial %d", serial);
#endif
dispatchCallForwardStatus(serial, mSlotId, RIL_REQUEST_SET_CALL_FORWARD,
callInfo);
return Void();
}
Return<void> RadioImpl::getCallWaiting(int32_t serial, int32_t serviceClass) {
#if VDBG
RLOGD("getCallWaiting: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_QUERY_CALL_WAITING, 1, serviceClass);
return Void();
}
Return<void> RadioImpl::setCallWaiting(int32_t serial, bool enable, int32_t serviceClass) {
#if VDBG
RLOGD("setCallWaiting: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_SET_CALL_WAITING, 2, BOOL_TO_INT(enable),
serviceClass);
return Void();
}
Return<void> RadioImpl::acknowledgeLastIncomingGsmSms(int32_t serial,
bool success, SmsAcknowledgeFailCause cause) {
#if VDBG
RLOGD("acknowledgeLastIncomingGsmSms: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_SMS_ACKNOWLEDGE, 2, BOOL_TO_INT(success),
cause);
return Void();
}
Return<void> RadioImpl::acceptCall(int32_t serial) {
#if VDBG
RLOGD("acceptCall: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_ANSWER);
return Void();
}
Return<void> RadioImpl::deactivateDataCall(int32_t serial,
int32_t cid, bool reasonRadioShutDown) {
#if VDBG
RLOGD("deactivateDataCall: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_DEACTIVATE_DATA_CALL, false,
2, (std::to_string(cid)).c_str(), reasonRadioShutDown ? "1" : "0");
return Void();
}
Return<void> RadioImpl::getFacilityLockForApp(int32_t serial, const hidl_string& facility,
const hidl_string& password, int32_t serviceClass,
const hidl_string& appId) {
#if VDBG
RLOGD("getFacilityLockForApp: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_QUERY_FACILITY_LOCK, true,
4, facility.c_str(), password.c_str(),
(std::to_string(serviceClass)).c_str(), appId.c_str());
return Void();
}
Return<void> RadioImpl::setFacilityLockForApp(int32_t serial, const hidl_string& facility,
bool lockState, const hidl_string& password,
int32_t serviceClass, const hidl_string& appId) {
#if VDBG
RLOGD("setFacilityLockForApp: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_SET_FACILITY_LOCK, true,
5, facility.c_str(), lockState ? "1" : "0", password.c_str(),
(std::to_string(serviceClass)).c_str(), appId.c_str() );
return Void();
}
Return<void> RadioImpl::setBarringPassword(int32_t serial, const hidl_string& facility,
const hidl_string& oldPassword,
const hidl_string& newPassword) {
#if VDBG
RLOGD("setBarringPassword: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_CHANGE_BARRING_PASSWORD, true,
3, facility.c_str(), oldPassword.c_str(), newPassword.c_str());
return Void();
}
Return<void> RadioImpl::getNetworkSelectionMode(int32_t serial) {
#if VDBG
RLOGD("getNetworkSelectionMode: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE);
return Void();
}
Return<void> RadioImpl::setNetworkSelectionModeAutomatic(int32_t serial) {
#if VDBG
RLOGD("setNetworkSelectionModeAutomatic: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC);
return Void();
}
Return<void> RadioImpl::setNetworkSelectionModeManual(int32_t serial,
const hidl_string& operatorNumeric) {
#if VDBG
RLOGD("setNetworkSelectionModeManual: serial %d", serial);
#endif
dispatchString(serial, mSlotId, RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL,
operatorNumeric.c_str());
return Void();
}
Return<void> RadioImpl::getAvailableNetworks(int32_t serial) {
#if VDBG
RLOGD("getAvailableNetworks: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_QUERY_AVAILABLE_NETWORKS);
return Void();
}
Return<void> RadioImpl::startNetworkScan(int32_t serial, const V1_1::NetworkScanRequest& request) {
#if VDBG
RLOGD("startNetworkScan: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_START_NETWORK_SCAN);
if (pRI == NULL) {
return Void();
}
if (request.specifiers.size() > MAX_RADIO_ACCESS_NETWORKS) {
sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
return Void();
}
RIL_NetworkScanRequest scan_request = {};
scan_request.type = (RIL_ScanType) request.type;
scan_request.interval = request.interval;
scan_request.specifiers_length = request.specifiers.size();
for (size_t i = 0; i < request.specifiers.size(); ++i) {
if (request.specifiers[i].geranBands.size() > MAX_BANDS ||
request.specifiers[i].utranBands.size() > MAX_BANDS ||
request.specifiers[i].eutranBands.size() > MAX_BANDS ||
request.specifiers[i].channels.size() > MAX_CHANNELS) {
sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
return Void();
}
const V1_1::RadioAccessSpecifier& ras_from =
request.specifiers[i];
RIL_RadioAccessSpecifier& ras_to = scan_request.specifiers[i];
ras_to.radio_access_network = (RIL_RadioAccessNetworks) ras_from.radioAccessNetwork;
ras_to.channels_length = ras_from.channels.size();
std::copy(ras_from.channels.begin(), ras_from.channels.end(), ras_to.channels);
const std::vector<uint32_t> * bands = nullptr;
switch (request.specifiers[i].radioAccessNetwork) {
case V1_1::RadioAccessNetworks::GERAN:
ras_to.bands_length = ras_from.geranBands.size();
bands = (std::vector<uint32_t> *) &ras_from.geranBands;
break;
case V1_1::RadioAccessNetworks::UTRAN:
ras_to.bands_length = ras_from.utranBands.size();
bands = (std::vector<uint32_t> *) &ras_from.utranBands;
break;
case V1_1::RadioAccessNetworks::EUTRAN:
ras_to.bands_length = ras_from.eutranBands.size();
bands = (std::vector<uint32_t> *) &ras_from.eutranBands;
break;
default:
sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
return Void();
}
// safe to copy to geran_bands because it's a union member
for (size_t idx = 0; idx < ras_to.bands_length; ++idx) {
ras_to.bands.geran_bands[idx] = (RIL_GeranBands) (*bands)[idx];
}
}
CALL_ONREQUEST(RIL_REQUEST_START_NETWORK_SCAN, &scan_request, sizeof(scan_request), pRI,
mSlotId);
return Void();
}
Return<void> RadioImpl::stopNetworkScan(int32_t serial) {
#if VDBG
RLOGD("stopNetworkScan: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_STOP_NETWORK_SCAN);
return Void();
}
Return<void> RadioImpl::startDtmf(int32_t serial, const hidl_string& s) {
#if VDBG
RLOGD("startDtmf: serial %d", serial);
#endif
dispatchString(serial, mSlotId, RIL_REQUEST_DTMF_START,
s.c_str());
return Void();
}
Return<void> RadioImpl::stopDtmf(int32_t serial) {
#if VDBG
RLOGD("stopDtmf: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_DTMF_STOP);
return Void();
}
Return<void> RadioImpl::getBasebandVersion(int32_t serial) {
#if VDBG
RLOGD("getBasebandVersion: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_BASEBAND_VERSION);
return Void();
}
Return<void> RadioImpl::separateConnection(int32_t serial, int32_t gsmIndex) {
#if VDBG
RLOGD("separateConnection: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_SEPARATE_CONNECTION, 1, gsmIndex);
return Void();
}
Return<void> RadioImpl::setMute(int32_t serial, bool enable) {
#if VDBG
RLOGD("setMute: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_SET_MUTE, 1, BOOL_TO_INT(enable));
return Void();
}
Return<void> RadioImpl::getMute(int32_t serial) {
#if VDBG
RLOGD("getMute: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_MUTE);
return Void();
}
Return<void> RadioImpl::getClip(int32_t serial) {
#if VDBG
RLOGD("getClip: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_QUERY_CLIP);
return Void();
}
Return<void> RadioImpl::getDataCallList(int32_t serial) {
#if VDBG
RLOGD("getDataCallList: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_DATA_CALL_LIST);
return Void();
}
Return<void> RadioImpl::setSuppServiceNotifications(int32_t serial, bool enable) {
#if VDBG
RLOGD("setSuppServiceNotifications: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION, 1,
BOOL_TO_INT(enable));
return Void();
}
Return<void> RadioImpl::writeSmsToSim(int32_t serial, const SmsWriteArgs& smsWriteArgs) {
#if VDBG
RLOGD("writeSmsToSim: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_WRITE_SMS_TO_SIM);
if (pRI == NULL) {
return Void();
}
RIL_SMS_WriteArgs args;
args.status = (int) smsWriteArgs.status;
if (!copyHidlStringToRil(&args.pdu, smsWriteArgs.pdu, pRI)) {
return Void();
}
if (!copyHidlStringToRil(&args.smsc, smsWriteArgs.smsc, pRI)) {
memsetAndFreeStrings(1, args.pdu);
return Void();
}
CALL_ONREQUEST(RIL_REQUEST_WRITE_SMS_TO_SIM, &args, sizeof(args), pRI, mSlotId);
memsetAndFreeStrings(2, args.smsc, args.pdu);
return Void();
}
Return<void> RadioImpl::deleteSmsOnSim(int32_t serial, int32_t index) {
#if VDBG
RLOGD("deleteSmsOnSim: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_DELETE_SMS_ON_SIM, 1, index);
return Void();
}
Return<void> RadioImpl::setBandMode(int32_t serial, RadioBandMode mode) {
#if VDBG
RLOGD("setBandMode: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_SET_BAND_MODE, 1, mode);
return Void();
}
Return<void> RadioImpl::getAvailableBandModes(int32_t serial) {
#if VDBG
RLOGD("getAvailableBandModes: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE);
return Void();
}
Return<void> RadioImpl::sendEnvelope(int32_t serial, const hidl_string& command) {
#if VDBG
RLOGD("sendEnvelope: serial %d", serial);
#endif
dispatchString(serial, mSlotId, RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND,
command.c_str());
return Void();
}
Return<void> RadioImpl::sendTerminalResponseToSim(int32_t serial,
const hidl_string& commandResponse) {
#if VDBG
RLOGD("sendTerminalResponseToSim: serial %d", serial);
#endif
dispatchString(serial, mSlotId, RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE,
commandResponse.c_str());
return Void();
}
Return<void> RadioImpl::handleStkCallSetupRequestFromSim(int32_t serial, bool accept) {
#if VDBG
RLOGD("handleStkCallSetupRequestFromSim: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM,
1, BOOL_TO_INT(accept));
return Void();
}
Return<void> RadioImpl::explicitCallTransfer(int32_t serial) {
#if VDBG
RLOGD("explicitCallTransfer: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_EXPLICIT_CALL_TRANSFER);
return Void();
}
Return<void> RadioImpl::setPreferredNetworkType(int32_t serial, PreferredNetworkType nwType) {
#if VDBG
RLOGD("setPreferredNetworkType: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE, 1, nwType);
return Void();
}
Return<void> RadioImpl::getPreferredNetworkType(int32_t serial) {
#if VDBG
RLOGD("getPreferredNetworkType: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE);
return Void();
}
Return<void> RadioImpl::getNeighboringCids(int32_t serial) {
#if VDBG
RLOGD("getNeighboringCids: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_NEIGHBORING_CELL_IDS);
return Void();
}
Return<void> RadioImpl::setLocationUpdates(int32_t serial, bool enable) {
#if VDBG
RLOGD("setLocationUpdates: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_SET_LOCATION_UPDATES, 1, BOOL_TO_INT(enable));
return Void();
}
Return<void> RadioImpl::setCdmaSubscriptionSource(int32_t serial, CdmaSubscriptionSource cdmaSub) {
#if VDBG
RLOGD("setCdmaSubscriptionSource: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE, 1, cdmaSub);
return Void();
}
Return<void> RadioImpl::setCdmaRoamingPreference(int32_t serial, CdmaRoamingType type) {
#if VDBG
RLOGD("setCdmaRoamingPreference: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE, 1, type);
return Void();
}
Return<void> RadioImpl::getCdmaRoamingPreference(int32_t serial) {
#if VDBG
RLOGD("getCdmaRoamingPreference: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE);
return Void();
}
Return<void> RadioImpl::setTTYMode(int32_t serial, TtyMode mode) {
#if VDBG
RLOGD("setTTYMode: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_SET_TTY_MODE, 1, mode);
return Void();
}
Return<void> RadioImpl::getTTYMode(int32_t serial) {
#if VDBG
RLOGD("getTTYMode: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_QUERY_TTY_MODE);
return Void();
}
Return<void> RadioImpl::setPreferredVoicePrivacy(int32_t serial, bool enable) {
#if VDBG
RLOGD("setPreferredVoicePrivacy: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE,
1, BOOL_TO_INT(enable));
return Void();
}
Return<void> RadioImpl::getPreferredVoicePrivacy(int32_t serial) {
#if VDBG
RLOGD("getPreferredVoicePrivacy: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE);
return Void();
}
Return<void> RadioImpl::sendCDMAFeatureCode(int32_t serial, const hidl_string& featureCode) {
#if VDBG
RLOGD("sendCDMAFeatureCode: serial %d", serial);
#endif
dispatchString(serial, mSlotId, RIL_REQUEST_CDMA_FLASH,
featureCode.c_str());
return Void();
}
Return<void> RadioImpl::sendBurstDtmf(int32_t serial, const hidl_string& dtmf, int32_t on,
int32_t off) {
#if VDBG
RLOGD("sendBurstDtmf: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_CDMA_BURST_DTMF, false,
3, dtmf.c_str(), (std::to_string(on)).c_str(),
(std::to_string(off)).c_str());
return Void();
}
void constructCdmaSms(RIL_CDMA_SMS_Message &rcsm, const CdmaSmsMessage& sms) {
rcsm.uTeleserviceID = sms.teleserviceId;
rcsm.bIsServicePresent = BOOL_TO_INT(sms.isServicePresent);
rcsm.uServicecategory = sms.serviceCategory;
rcsm.sAddress.digit_mode = (RIL_CDMA_SMS_DigitMode) sms.address.digitMode;
rcsm.sAddress.number_mode = (RIL_CDMA_SMS_NumberMode) sms.address.numberMode;
rcsm.sAddress.number_type = (RIL_CDMA_SMS_NumberType) sms.address.numberType;
rcsm.sAddress.number_plan = (RIL_CDMA_SMS_NumberPlan) sms.address.numberPlan;
rcsm.sAddress.number_of_digits = sms.address.digits.size();
int digitLimit= MIN((rcsm.sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
for (int i = 0; i < digitLimit; i++) {
rcsm.sAddress.digits[i] = sms.address.digits[i];
}
rcsm.sSubAddress.subaddressType = (RIL_CDMA_SMS_SubaddressType) sms.subAddress.subaddressType;
rcsm.sSubAddress.odd = BOOL_TO_INT(sms.subAddress.odd);
rcsm.sSubAddress.number_of_digits = sms.subAddress.digits.size();
digitLimit= MIN((rcsm.sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
for (int i = 0; i < digitLimit; i++) {
rcsm.sSubAddress.digits[i] = sms.subAddress.digits[i];
}
rcsm.uBearerDataLen = sms.bearerData.size();
digitLimit= MIN((rcsm.uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
for (int i = 0; i < digitLimit; i++) {
rcsm.aBearerData[i] = sms.bearerData[i];
}
}
Return<void> RadioImpl::sendCdmaSms(int32_t serial, const CdmaSmsMessage& sms) {
#if VDBG
RLOGD("sendCdmaSms: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_CDMA_SEND_SMS);
if (pRI == NULL) {
return Void();
}
RIL_CDMA_SMS_Message rcsm = {};
constructCdmaSms(rcsm, sms);
CALL_ONREQUEST(pRI->pCI->requestNumber, &rcsm, sizeof(rcsm), pRI, mSlotId);
return Void();
}
Return<void> RadioImpl::acknowledgeLastIncomingCdmaSms(int32_t serial, const CdmaSmsAck& smsAck) {
#if VDBG
RLOGD("acknowledgeLastIncomingCdmaSms: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE);
if (pRI == NULL) {
return Void();
}
RIL_CDMA_SMS_Ack rcsa = {};
rcsa.uErrorClass = (RIL_CDMA_SMS_ErrorClass) smsAck.errorClass;
rcsa.uSMSCauseCode = smsAck.smsCauseCode;
CALL_ONREQUEST(pRI->pCI->requestNumber, &rcsa, sizeof(rcsa), pRI, mSlotId);
return Void();
}
Return<void> RadioImpl::getGsmBroadcastConfig(int32_t serial) {
#if VDBG
RLOGD("getGsmBroadcastConfig: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG);
return Void();
}
Return<void> RadioImpl::setGsmBroadcastConfig(int32_t serial,
const hidl_vec<GsmBroadcastSmsConfigInfo>&
configInfo) {
#if VDBG
RLOGD("setGsmBroadcastConfig: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG);
if (pRI == NULL) {
return Void();
}
uint32_t num = configInfo.size();
if (num > MAX_BROADCAST_SMS_CONFIG_INFO) {
RLOGE("setGsmBroadcastConfig: Invalid configInfo length %s",
requestToString(pRI->pCI->requestNumber));
sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
return Void();
}
auto gsmBci = new RIL_GSM_BroadcastSmsConfigInfo[num];
if (gsmBci == nullptr) {
sendErrorResponse(pRI, RIL_E_NO_MEMORY);
return Void();
}
std::vector<RIL_GSM_BroadcastSmsConfigInfo*> gsmBciPtrs(num);
for (uint32_t i = 0 ; i < num ; i++ ) {
gsmBciPtrs[i] = &gsmBci[i];
gsmBci[i].fromServiceId = configInfo[i].fromServiceId;
gsmBci[i].toServiceId = configInfo[i].toServiceId;
gsmBci[i].fromCodeScheme = configInfo[i].fromCodeScheme;
gsmBci[i].toCodeScheme = configInfo[i].toCodeScheme;
gsmBci[i].selected = BOOL_TO_INT(configInfo[i].selected);
}
CALL_ONREQUEST(pRI->pCI->requestNumber, gsmBciPtrs.data(),
num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *), pRI, mSlotId);
delete []gsmBci;
return Void();
}
Return<void> RadioImpl::setGsmBroadcastActivation(int32_t serial, bool activate) {
#if VDBG
RLOGD("setGsmBroadcastActivation: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_GSM_SMS_BROADCAST_ACTIVATION,
1, BOOL_TO_INT(!activate));
return Void();
}
Return<void> RadioImpl::getCdmaBroadcastConfig(int32_t serial) {
#if VDBG
RLOGD("getCdmaBroadcastConfig: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG);
return Void();
}
Return<void> RadioImpl::setCdmaBroadcastConfig(int32_t serial,
const hidl_vec<CdmaBroadcastSmsConfigInfo>&
configInfo) {
#if VDBG
RLOGD("setCdmaBroadcastConfig: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG);
if (pRI == NULL) {
return Void();
}
uint32_t num = configInfo.size();
if (num > MAX_BROADCAST_SMS_CONFIG_INFO) {
RLOGE("setCdmaBroadcastConfig: Invalid configInfo length %s",
requestToString(pRI->pCI->requestNumber));
sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
return Void();
}
auto cdmaBci = new RIL_CDMA_BroadcastSmsConfigInfo[num];
if (cdmaBci == nullptr) {
sendErrorResponse(pRI, RIL_E_NO_MEMORY);
return Void();
}
std::vector<RIL_CDMA_BroadcastSmsConfigInfo*> cdmaBciPtrs(num);
for (uint32_t i = 0 ; i < num ; i++ ) {
cdmaBciPtrs[i] = &cdmaBci[i];
cdmaBci[i].service_category = configInfo[i].serviceCategory;
cdmaBci[i].language = configInfo[i].language;
cdmaBci[i].selected = BOOL_TO_INT(configInfo[i].selected);
}
CALL_ONREQUEST(pRI->pCI->requestNumber, cdmaBciPtrs.data(),
num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *), pRI, mSlotId);
delete []cdmaBci;
return Void();
}
Return<void> RadioImpl::setCdmaBroadcastActivation(int32_t serial, bool activate) {
#if VDBG
RLOGD("setCdmaBroadcastActivation: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION,
1, BOOL_TO_INT(!activate));
return Void();
}
Return<void> RadioImpl::getCDMASubscription(int32_t serial) {
#if VDBG
RLOGD("getCDMASubscription: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_CDMA_SUBSCRIPTION);
return Void();
}
Return<void> RadioImpl::writeSmsToRuim(int32_t serial, const CdmaSmsWriteArgs& cdmaSms) {
#if VDBG
RLOGD("writeSmsToRuim: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM);
if (pRI == NULL) {
return Void();
}
RIL_CDMA_SMS_WriteArgs rcsw = {};
rcsw.status = (int) cdmaSms.status;
constructCdmaSms(rcsw.message, cdmaSms.message);
CALL_ONREQUEST(pRI->pCI->requestNumber, &rcsw, sizeof(rcsw), pRI, mSlotId);
return Void();
}
Return<void> RadioImpl::deleteSmsOnRuim(int32_t serial, int32_t index) {
#if VDBG
RLOGD("deleteSmsOnRuim: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM, 1, index);
return Void();
}
Return<void> RadioImpl::getDeviceIdentity(int32_t serial) {
#if VDBG
RLOGD("getDeviceIdentity: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_DEVICE_IDENTITY);
return Void();
}
Return<void> RadioImpl::exitEmergencyCallbackMode(int32_t serial) {
#if VDBG
RLOGD("exitEmergencyCallbackMode: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE);
return Void();
}
Return<void> RadioImpl::getSmscAddress(int32_t serial) {
#if VDBG
RLOGD("getSmscAddress: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_SMSC_ADDRESS);
return Void();
}
Return<void> RadioImpl::setSmscAddress(int32_t serial, const hidl_string& smsc) {
#if VDBG
RLOGD("setSmscAddress: serial %d", serial);
#endif
dispatchString(serial, mSlotId, RIL_REQUEST_SET_SMSC_ADDRESS,
smsc.c_str());
return Void();
}
Return<void> RadioImpl::reportSmsMemoryStatus(int32_t serial, bool available) {
#if VDBG
RLOGD("reportSmsMemoryStatus: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_REPORT_SMS_MEMORY_STATUS, 1,
BOOL_TO_INT(available));
return Void();
}
Return<void> RadioImpl::reportStkServiceIsRunning(int32_t serial) {
#if VDBG
RLOGD("reportStkServiceIsRunning: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING);
return Void();
}
Return<void> RadioImpl::getCdmaSubscriptionSource(int32_t serial) {
#if VDBG
RLOGD("getCdmaSubscriptionSource: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE);
return Void();
}
Return<void> RadioImpl::requestIsimAuthentication(int32_t serial, const hidl_string& challenge) {
#if VDBG
RLOGD("requestIsimAuthentication: serial %d", serial);
#endif
dispatchString(serial, mSlotId, RIL_REQUEST_ISIM_AUTHENTICATION,
challenge.c_str());
return Void();
}
Return<void> RadioImpl::acknowledgeIncomingGsmSmsWithPdu(int32_t serial, bool success,
const hidl_string& ackPdu) {
#if VDBG
RLOGD("acknowledgeIncomingGsmSmsWithPdu: serial %d", serial);
#endif
dispatchStrings(serial, mSlotId, RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU, false,
2, success ? "1" : "0", ackPdu.c_str());
return Void();
}
Return<void> RadioImpl::sendEnvelopeWithStatus(int32_t serial, const hidl_string& contents) {
#if VDBG
RLOGD("sendEnvelopeWithStatus: serial %d", serial);
#endif
dispatchString(serial, mSlotId, RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS,
contents.c_str());
return Void();
}
Return<void> RadioImpl::getVoiceRadioTechnology(int32_t serial) {
#if VDBG
RLOGD("getVoiceRadioTechnology: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_VOICE_RADIO_TECH);
return Void();
}
Return<void> RadioImpl::getCellInfoList(int32_t serial) {
#if VDBG
RLOGD("getCellInfoList: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_CELL_INFO_LIST);
return Void();
}
Return<void> RadioImpl::setCellInfoListRate(int32_t serial, int32_t rate) {
#if VDBG
RLOGD("setCellInfoListRate: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE, 1, rate);
return Void();
}
Return<void> RadioImpl::setInitialAttachApn(int32_t serial, const DataProfileInfo& dataProfileInfo,
bool modemCognitive, bool isRoaming) {
#if VDBG
RLOGD("setInitialAttachApn: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
RIL_REQUEST_SET_INITIAL_ATTACH_APN);
if (pRI == NULL) {
return Void();
}
if (s_vendorFunctions->version <= 14) {
RIL_InitialAttachApn iaa = {};
if (!copyHidlStringToRil(&iaa.apn, dataProfileInfo.apn, pRI, true)) {
return Void();
}
const hidl_string &protocol =
(isRoaming ? dataProfileInfo.roamingProtocol : dataProfileInfo.protocol);
if (!copyHidlStringToRil(&iaa.protocol, protocol, pRI)) {
memsetAndFreeStrings(1, iaa.apn);
return Void();
}
iaa.authtype = (int) dataProfileInfo.authType;
if (!copyHidlStringToRil(&iaa.username, dataProfileInfo.user, pRI)) {
memsetAndFreeStrings(2, iaa.apn, iaa.protocol);
return Void();
}
if (!copyHidlStringToRil(&iaa.password, dataProfileInfo.password, pRI)) {
memsetAndFreeStrings(3, iaa.apn, iaa.protocol, iaa.username);
return Void();
}
CALL_ONREQUEST(RIL_REQUEST_SET_INITIAL_ATTACH_APN, &iaa, sizeof(iaa), pRI, mSlotId);
memsetAndFreeStrings(4, iaa.apn, iaa.protocol, iaa.username, iaa.password);
} else {
RIL_InitialAttachApn_v15 iaa = {};
if (!copyHidlStringToRil(&iaa.apn, dataProfileInfo.apn, pRI, true)) {
return Void();
}
if (!copyHidlStringToRil(&iaa.protocol, dataProfileInfo.protocol, pRI)) {
memsetAndFreeStrings(1, iaa.apn);
return Void();
}
if (!copyHidlStringToRil(&iaa.roamingProtocol, dataProfileInfo.roamingProtocol, pRI)) {
memsetAndFreeStrings(2, iaa.apn, iaa.protocol);
return Void();
}
iaa.authtype = (int) dataProfileInfo.authType;
if (!copyHidlStringToRil(&iaa.username, dataProfileInfo.user, pRI)) {
memsetAndFreeStrings(3, iaa.apn, iaa.protocol, iaa.roamingProtocol);
return Void();
}
if (!copyHidlStringToRil(&iaa.password, dataProfileInfo.password, pRI)) {
memsetAndFreeStrings(4, iaa.apn, iaa.protocol, iaa.roamingProtocol, iaa.username);
return Void();
}
iaa.supportedTypesBitmask = dataProfileInfo.supportedApnTypesBitmap;
iaa.bearerBitmask = dataProfileInfo.bearerBitmap;
iaa.modemCognitive = BOOL_TO_INT(modemCognitive);
iaa.mtu = dataProfileInfo.mtu;
if (!convertMvnoTypeToString(dataProfileInfo.mvnoType, iaa.mvnoType)) {
sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
memsetAndFreeStrings(5, iaa.apn, iaa.protocol, iaa.roamingProtocol, iaa.username,
iaa.password);
return Void();
}
if (!copyHidlStringToRil(&iaa.mvnoMatchData, dataProfileInfo.mvnoMatchData, pRI)) {
memsetAndFreeStrings(5, iaa.apn, iaa.protocol, iaa.roamingProtocol, iaa.username,
iaa.password);
return Void();
}
CALL_ONREQUEST(RIL_REQUEST_SET_INITIAL_ATTACH_APN, &iaa, sizeof(iaa), pRI, mSlotId);
memsetAndFreeStrings(6, iaa.apn, iaa.protocol, iaa.roamingProtocol, iaa.username,
iaa.password, iaa.mvnoMatchData);
}
return Void();
}
Return<void> RadioImpl::getImsRegistrationState(int32_t serial) {
#if VDBG
RLOGD("getImsRegistrationState: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_IMS_REGISTRATION_STATE);
return Void();
}
bool dispatchImsGsmSms(const ImsSmsMessage& message, RequestInfo *pRI) {
RIL_IMS_SMS_Message rism = {};
char **pStrings;
int countStrings = 2;
int dataLen = sizeof(char *) * countStrings;
rism.tech = RADIO_TECH_3GPP;
rism.retry = BOOL_TO_INT(message.retry);
rism.messageRef = message.messageRef;
if (message.gsmMessage.size() != 1) {
RLOGE("dispatchImsGsmSms: Invalid len %s", requestToString(pRI->pCI->requestNumber));
sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
return false;
}
pStrings = (char **)calloc(countStrings, sizeof(char *));
if (pStrings == NULL) {
RLOGE("dispatchImsGsmSms: Memory allocation failed for request %s",
requestToString(pRI->pCI->requestNumber));
sendErrorResponse(pRI, RIL_E_NO_MEMORY);
return false;
}
if (!copyHidlStringToRil(&pStrings[0], message.gsmMessage[0].smscPdu, pRI)) {
#ifdef MEMSET_FREED
memset(pStrings, 0, dataLen);
#endif
free(pStrings);
return false;
}
if (!copyHidlStringToRil(&pStrings[1], message.gsmMessage[0].pdu, pRI)) {
memsetAndFreeStrings(1, pStrings[0]);
#ifdef MEMSET_FREED
memset(pStrings, 0, dataLen);
#endif
free(pStrings);
return false;
}
rism.message.gsmMessage = pStrings;
CALL_ONREQUEST(pRI->pCI->requestNumber, &rism, sizeof(RIL_RadioTechnologyFamily) +
sizeof(uint8_t) + sizeof(int32_t) + dataLen, pRI, pRI->socket_id);
for (int i = 0 ; i < countStrings ; i++) {
memsetAndFreeStrings(1, pStrings[i]);
}
#ifdef MEMSET_FREED
memset(pStrings, 0, dataLen);
#endif
free(pStrings);
return true;
}
struct ImsCdmaSms {
RIL_IMS_SMS_Message imsSms;
RIL_CDMA_SMS_Message cdmaSms;
};
bool dispatchImsCdmaSms(const ImsSmsMessage& message, RequestInfo *pRI) {
ImsCdmaSms temp = {};
if (message.cdmaMessage.size() != 1) {
RLOGE("dispatchImsCdmaSms: Invalid len %s", requestToString(pRI->pCI->requestNumber));
sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
return false;
}
temp.imsSms.tech = RADIO_TECH_3GPP2;
temp.imsSms.retry = BOOL_TO_INT(message.retry);
temp.imsSms.messageRef = message.messageRef;
temp.imsSms.message.cdmaMessage = &temp.cdmaSms;
constructCdmaSms(temp.cdmaSms, message.cdmaMessage[0]);
// Vendor code expects payload length to include actual msg payload
// (sizeof(RIL_CDMA_SMS_Message)) instead of (RIL_CDMA_SMS_Message *) + size of other fields in
// RIL_IMS_SMS_Message
int payloadLen = sizeof(RIL_RadioTechnologyFamily) + sizeof(uint8_t) + sizeof(int32_t)
+ sizeof(RIL_CDMA_SMS_Message);
CALL_ONREQUEST(pRI->pCI->requestNumber, &temp.imsSms, payloadLen, pRI, pRI->socket_id);
return true;
}
Return<void> RadioImpl::sendImsSms(int32_t serial, const ImsSmsMessage& message) {
#if VDBG
RLOGD("sendImsSms: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_IMS_SEND_SMS);
if (pRI == NULL) {
return Void();
}
if (RadioTechnologyFamily::THREE_GPP == message.tech) {
dispatchImsGsmSms(message, pRI);
} else if (RadioTechnologyFamily::THREE_GPP2 == message.tech) {
dispatchImsCdmaSms(message, pRI);
} else {
RLOGE("sendImsSms: Invalid radio tech %s",
requestToString(pRI->pCI->requestNumber));
sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
}
return Void();
}
Return<void> RadioImpl::iccTransmitApduBasicChannel(int32_t serial, const SimApdu& message) {
#if VDBG
RLOGD("iccTransmitApduBasicChannel: serial %d", serial);
#endif
dispatchIccApdu(serial, mSlotId, RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC, message);
return Void();
}
Return<void> RadioImpl::iccOpenLogicalChannel(int32_t serial, const hidl_string& aid, int32_t p2) {
#if VDBG
RLOGD("iccOpenLogicalChannel: serial %d", serial);
#endif
if (s_vendorFunctions->version < 15) {
dispatchString(serial, mSlotId, RIL_REQUEST_SIM_OPEN_CHANNEL, aid.c_str());
} else {
RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SIM_OPEN_CHANNEL);
if (pRI == NULL) {
return Void();
}
RIL_OpenChannelParams params = {};
params.p2 = p2;
if (!copyHidlStringToRil(&params.aidPtr, aid, pRI)) {
return Void();
}
CALL_ONREQUEST(pRI->pCI->requestNumber, &params, sizeof(params), pRI, mSlotId);
memsetAndFreeStrings(1, params.aidPtr);
}
return Void();
}
Return<void> RadioImpl::iccCloseLogicalChannel(int32_t serial, int32_t channelId) {
#if VDBG
RLOGD("iccCloseLogicalChannel: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_SIM_CLOSE_CHANNEL, 1, channelId);
return Void();
}
Return<void> RadioImpl::iccTransmitApduLogicalChannel(int32_t serial, const SimApdu& message) {
#if VDBG
RLOGD("iccTransmitApduLogicalChannel: serial %d", serial);
#endif
dispatchIccApdu(serial, mSlotId, RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL, message);
return Void();
}
Return<void> RadioImpl::nvReadItem(int32_t serial, NvItem itemId) {
#if VDBG
RLOGD("nvReadItem: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_NV_READ_ITEM);
if (pRI == NULL) {
return Void();
}
RIL_NV_ReadItem nvri = {};
nvri.itemID = (RIL_NV_Item) itemId;
CALL_ONREQUEST(pRI->pCI->requestNumber, &nvri, sizeof(nvri), pRI, mSlotId);
return Void();
}
Return<void> RadioImpl::nvWriteItem(int32_t serial, const NvWriteItem& item) {
#if VDBG
RLOGD("nvWriteItem: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_NV_WRITE_ITEM);
if (pRI == NULL) {
return Void();
}
RIL_NV_WriteItem nvwi = {};
nvwi.itemID = (RIL_NV_Item) item.itemId;
if (!copyHidlStringToRil(&nvwi.value, item.value, pRI)) {
return Void();
}
CALL_ONREQUEST(pRI->pCI->requestNumber, &nvwi, sizeof(nvwi), pRI, mSlotId);
memsetAndFreeStrings(1, nvwi.value);
return Void();
}
Return<void> RadioImpl::nvWriteCdmaPrl(int32_t serial, const hidl_vec<uint8_t>& prl) {
#if VDBG
RLOGD("nvWriteCdmaPrl: serial %d", serial);
#endif
dispatchRaw(serial, mSlotId, RIL_REQUEST_NV_WRITE_CDMA_PRL, prl);
return Void();
}
Return<void> RadioImpl::nvResetConfig(int32_t serial, ResetNvType resetType) {
int rilResetType = -1;
#if VDBG
RLOGD("nvResetConfig: serial %d", serial);
#endif
/* Convert ResetNvType to RIL.h values
* RIL_REQUEST_NV_RESET_CONFIG
* 1 - reload all NV items
* 2 - erase NV reset (SCRTN)
* 3 - factory reset (RTN)
*/
switch(resetType) {
case ResetNvType::RELOAD:
rilResetType = 1;
break;
case ResetNvType::ERASE:
rilResetType = 2;
break;
case ResetNvType::FACTORY_RESET:
rilResetType = 3;
break;
}
dispatchInts(serial, mSlotId, RIL_REQUEST_NV_RESET_CONFIG, 1, rilResetType);
return Void();
}
Return<void> RadioImpl::setUiccSubscription(int32_t serial, const SelectUiccSub& uiccSub) {
#if VDBG
RLOGD("setUiccSubscription: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
RIL_REQUEST_SET_UICC_SUBSCRIPTION);
if (pRI == NULL) {
return Void();
}
RIL_SelectUiccSub rilUiccSub = {};
rilUiccSub.slot = uiccSub.slot;
rilUiccSub.app_index = uiccSub.appIndex;
rilUiccSub.sub_type = (RIL_SubscriptionType) uiccSub.subType;
rilUiccSub.act_status = (RIL_UiccSubActStatus) uiccSub.actStatus;
CALL_ONREQUEST(pRI->pCI->requestNumber, &rilUiccSub, sizeof(rilUiccSub), pRI, mSlotId);
return Void();
}
Return<void> RadioImpl::setDataAllowed(int32_t serial, bool allow) {
#if VDBG
RLOGD("setDataAllowed: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_ALLOW_DATA, 1, BOOL_TO_INT(allow));
return Void();
}
Return<void> RadioImpl::getHardwareConfig(int32_t serial) {
#if VDBG
RLOGD("getHardwareConfig: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_HARDWARE_CONFIG);
return Void();
}
Return<void> RadioImpl::requestIccSimAuthentication(int32_t serial, int32_t authContext,
const hidl_string& authData, const hidl_string& aid) {
#if VDBG
RLOGD("requestIccSimAuthentication: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SIM_AUTHENTICATION);
if (pRI == NULL) {
return Void();
}
RIL_SimAuthentication pf = {};
pf.authContext = authContext;
if (!copyHidlStringToRil(&pf.authData, authData, pRI)) {
return Void();
}
if (!copyHidlStringToRil(&pf.aid, aid, pRI)) {
memsetAndFreeStrings(1, pf.authData);
return Void();
}
CALL_ONREQUEST(pRI->pCI->requestNumber, &pf, sizeof(pf), pRI, mSlotId);
memsetAndFreeStrings(2, pf.authData, pf.aid);
return Void();
}
/**
* @param numProfiles number of data profile
* @param dataProfiles the pointer to the actual data profiles. The acceptable type is
RIL_DataProfileInfo or RIL_DataProfileInfo_v15.
* @param dataProfilePtrs the pointer to the pointers that point to each data profile structure
* @param numfields number of string-type member in the data profile structure
* @param ... the variadic parameters are pointers to each string-type member
**/
template <typename T>
void freeSetDataProfileData(int numProfiles, T *dataProfiles, T **dataProfilePtrs,
int numfields, ...) {
va_list args;
va_start(args, numfields);
// Iterate through each string-type field that need to be free.
for (int i = 0; i < numfields; i++) {
// Iterate through each data profile and free that specific string-type field.
// The type 'char *T::*' is a type of pointer to a 'char *' member inside T structure.
char *T::*ptr = va_arg(args, char *T::*);
for (int j = 0; j < numProfiles; j++) {
memsetAndFreeStrings(1, dataProfiles[j].*ptr);
}
}
va_end(args);
#ifdef MEMSET_FREED
memset(dataProfiles, 0, numProfiles * sizeof(T));
memset(dataProfilePtrs, 0, numProfiles * sizeof(T *));
#endif
free(dataProfiles);
free(dataProfilePtrs);
}
Return<void> RadioImpl::setDataProfile(int32_t serial, const hidl_vec<DataProfileInfo>& profiles,
bool isRoaming) {
#if VDBG
RLOGD("setDataProfile: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SET_DATA_PROFILE);
if (pRI == NULL) {
return Void();
}
size_t num = profiles.size();
bool success = false;
if (s_vendorFunctions->version <= 14) {
RIL_DataProfileInfo *dataProfiles =
(RIL_DataProfileInfo *) calloc(num, sizeof(RIL_DataProfileInfo));
if (dataProfiles == NULL) {
RLOGE("Memory allocation failed for request %s",
requestToString(pRI->pCI->requestNumber));
sendErrorResponse(pRI, RIL_E_NO_MEMORY);
return Void();
}
RIL_DataProfileInfo **dataProfilePtrs =
(RIL_DataProfileInfo **) calloc(num, sizeof(RIL_DataProfileInfo *));
if (dataProfilePtrs == NULL) {
RLOGE("Memory allocation failed for request %s",
requestToString(pRI->pCI->requestNumber));
free(dataProfiles);
sendErrorResponse(pRI, RIL_E_NO_MEMORY);
return Void();
}
for (size_t i = 0; i < num; i++) {
dataProfilePtrs[i] = &dataProfiles[i];
success = copyHidlStringToRil(&dataProfiles[i].apn, profiles[i].apn, pRI, true);
const hidl_string &protocol =
(isRoaming ? profiles[i].roamingProtocol : profiles[i].protocol);
if (success && !copyHidlStringToRil(&dataProfiles[i].protocol, protocol, pRI, true)) {
success = false;
}
if (success && !copyHidlStringToRil(&dataProfiles[i].user, profiles[i].user, pRI,
true)) {
success = false;
}
if (success && !copyHidlStringToRil(&dataProfiles[i].password, profiles[i].password,
pRI, true)) {
success = false;
}
if (!success) {
freeSetDataProfileData(num, dataProfiles, dataProfilePtrs, 4,
&RIL_DataProfileInfo::apn, &RIL_DataProfileInfo::protocol,
&RIL_DataProfileInfo::user, &RIL_DataProfileInfo::password);
return Void();
}
dataProfiles[i].profileId = (RIL_DataProfile) profiles[i].profileId;
dataProfiles[i].authType = (int) profiles[i].authType;
dataProfiles[i].type = (int) profiles[i].type;
dataProfiles[i].maxConnsTime = profiles[i].maxConnsTime;
dataProfiles[i].maxConns = profiles[i].maxConns;
dataProfiles[i].waitTime = profiles[i].waitTime;
dataProfiles[i].enabled = BOOL_TO_INT(profiles[i].enabled);
}
CALL_ONREQUEST(RIL_REQUEST_SET_DATA_PROFILE, dataProfilePtrs,
num * sizeof(RIL_DataProfileInfo *), pRI, mSlotId);
freeSetDataProfileData(num, dataProfiles, dataProfilePtrs, 4,
&RIL_DataProfileInfo::apn, &RIL_DataProfileInfo::protocol,
&RIL_DataProfileInfo::user, &RIL_DataProfileInfo::password);
} else {
RIL_DataProfileInfo_v15 *dataProfiles =
(RIL_DataProfileInfo_v15 *) calloc(num, sizeof(RIL_DataProfileInfo_v15));
if (dataProfiles == NULL) {
RLOGE("Memory allocation failed for request %s",
requestToString(pRI->pCI->requestNumber));
sendErrorResponse(pRI, RIL_E_NO_MEMORY);
return Void();
}
RIL_DataProfileInfo_v15 **dataProfilePtrs =
(RIL_DataProfileInfo_v15 **) calloc(num, sizeof(RIL_DataProfileInfo_v15 *));
if (dataProfilePtrs == NULL) {
RLOGE("Memory allocation failed for request %s",
requestToString(pRI->pCI->requestNumber));
free(dataProfiles);
sendErrorResponse(pRI, RIL_E_NO_MEMORY);
return Void();
}
for (size_t i = 0; i < num; i++) {
dataProfilePtrs[i] = &dataProfiles[i];
success = copyHidlStringToRil(&dataProfiles[i].apn, profiles[i].apn, pRI, true);
if (success && !copyHidlStringToRil(&dataProfiles[i].protocol, profiles[i].protocol,
pRI)) {
success = false;
}
if (success && !copyHidlStringToRil(&dataProfiles[i].roamingProtocol,
profiles[i].roamingProtocol, pRI, true)) {
success = false;
}
if (success && !copyHidlStringToRil(&dataProfiles[i].user, profiles[i].user, pRI,
true)) {
success = false;
}
if (success && !copyHidlStringToRil(&dataProfiles[i].password, profiles[i].password,
pRI, true)) {
success = false;
}
if (success && !copyHidlStringToRil(&dataProfiles[i].mvnoMatchData,
profiles[i].mvnoMatchData, pRI, true)) {
success = false;
}
if (success && !convertMvnoTypeToString(profiles[i].mvnoType,
dataProfiles[i].mvnoType)) {
sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
success = false;
}
if (!success) {
freeSetDataProfileData(num, dataProfiles, dataProfilePtrs, 6,
&RIL_DataProfileInfo_v15::apn, &RIL_DataProfileInfo_v15::protocol,
&RIL_DataProfileInfo_v15::roamingProtocol, &RIL_DataProfileInfo_v15::user,
&RIL_DataProfileInfo_v15::password, &RIL_DataProfileInfo_v15::mvnoMatchData);
return Void();
}
dataProfiles[i].profileId = (RIL_DataProfile) profiles[i].profileId;
dataProfiles[i].authType = (int) profiles[i].authType;
dataProfiles[i].type = (int) profiles[i].type;
dataProfiles[i].maxConnsTime = profiles[i].maxConnsTime;
dataProfiles[i].maxConns = profiles[i].maxConns;
dataProfiles[i].waitTime = profiles[i].waitTime;
dataProfiles[i].enabled = BOOL_TO_INT(profiles[i].enabled);
dataProfiles[i].supportedTypesBitmask = profiles[i].supportedApnTypesBitmap;
dataProfiles[i].bearerBitmask = profiles[i].bearerBitmap;
dataProfiles[i].mtu = profiles[i].mtu;
}
CALL_ONREQUEST(RIL_REQUEST_SET_DATA_PROFILE, dataProfilePtrs,
num * sizeof(RIL_DataProfileInfo_v15 *), pRI, mSlotId);
freeSetDataProfileData(num, dataProfiles, dataProfilePtrs, 6,
&RIL_DataProfileInfo_v15::apn, &RIL_DataProfileInfo_v15::protocol,
&RIL_DataProfileInfo_v15::roamingProtocol, &RIL_DataProfileInfo_v15::user,
&RIL_DataProfileInfo_v15::password, &RIL_DataProfileInfo_v15::mvnoMatchData);
}
return Void();
}
Return<void> RadioImpl::requestShutdown(int32_t serial) {
#if VDBG
RLOGD("requestShutdown: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_SHUTDOWN);
return Void();
}
Return<void> RadioImpl::getRadioCapability(int32_t serial) {
#if VDBG
RLOGD("getRadioCapability: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_RADIO_CAPABILITY);
return Void();
}
Return<void> RadioImpl::setRadioCapability(int32_t serial, const RadioCapability& rc) {
#if VDBG
RLOGD("setRadioCapability: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SET_RADIO_CAPABILITY);
if (pRI == NULL) {
return Void();
}
RIL_RadioCapability rilRc = {};
// TODO : set rilRc.version using HIDL version ?
rilRc.session = rc.session;
rilRc.phase = (int) rc.phase;
rilRc.rat = (int) rc.raf;
rilRc.status = (int) rc.status;
strlcpy(rilRc.logicalModemUuid, rc.logicalModemUuid.c_str(), sizeof(rilRc.logicalModemUuid));
CALL_ONREQUEST(pRI->pCI->requestNumber, &rilRc, sizeof(rilRc), pRI, mSlotId);
return Void();
}
Return<void> RadioImpl::startLceService(int32_t serial, int32_t reportInterval, bool pullMode) {
#if VDBG
RLOGD("startLceService: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_START_LCE, 2, reportInterval,
BOOL_TO_INT(pullMode));
return Void();
}
Return<void> RadioImpl::stopLceService(int32_t serial) {
#if VDBG
RLOGD("stopLceService: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_STOP_LCE);
return Void();
}
Return<void> RadioImpl::pullLceData(int32_t serial) {
#if VDBG
RLOGD("pullLceData: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_PULL_LCEDATA);
return Void();
}
Return<void> RadioImpl::getModemActivityInfo(int32_t serial) {
#if VDBG
RLOGD("getModemActivityInfo: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_ACTIVITY_INFO);
return Void();
}
Return<void> RadioImpl::setAllowedCarriers(int32_t serial, bool allAllowed,
const CarrierRestrictions& carriers) {
#if VDBG
RLOGD("setAllowedCarriers: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
RIL_REQUEST_SET_CARRIER_RESTRICTIONS);
if (pRI == NULL) {
return Void();
}
RIL_CarrierRestrictions cr = {};
RIL_Carrier *allowedCarriers = NULL;
RIL_Carrier *excludedCarriers = NULL;
cr.len_allowed_carriers = carriers.allowedCarriers.size();
allowedCarriers = (RIL_Carrier *)calloc(cr.len_allowed_carriers, sizeof(RIL_Carrier));
if (allowedCarriers == NULL) {
RLOGE("setAllowedCarriers: Memory allocation failed for request %s",
requestToString(pRI->pCI->requestNumber));
sendErrorResponse(pRI, RIL_E_NO_MEMORY);
return Void();
}
cr.allowed_carriers = allowedCarriers;
cr.len_excluded_carriers = carriers.excludedCarriers.size();
excludedCarriers = (RIL_Carrier *)calloc(cr.len_excluded_carriers, sizeof(RIL_Carrier));
if (excludedCarriers == NULL) {
RLOGE("setAllowedCarriers: Memory allocation failed for request %s",
requestToString(pRI->pCI->requestNumber));
sendErrorResponse(pRI, RIL_E_NO_MEMORY);
#ifdef MEMSET_FREED
memset(allowedCarriers, 0, cr.len_allowed_carriers * sizeof(RIL_Carrier));
#endif
free(allowedCarriers);
return Void();
}
cr.excluded_carriers = excludedCarriers;
for (int i = 0; i < cr.len_allowed_carriers; i++) {
allowedCarriers[i].mcc = carriers.allowedCarriers[i].mcc.c_str();
allowedCarriers[i].mnc = carriers.allowedCarriers[i].mnc.c_str();
allowedCarriers[i].match_type = (RIL_CarrierMatchType) carriers.allowedCarriers[i].matchType;
allowedCarriers[i].match_data = carriers.allowedCarriers[i].matchData.c_str();
}
for (int i = 0; i < cr.len_excluded_carriers; i++) {
excludedCarriers[i].mcc = carriers.excludedCarriers[i].mcc.c_str();
excludedCarriers[i].mnc = carriers.excludedCarriers[i].mnc.c_str();
excludedCarriers[i].match_type =
(RIL_CarrierMatchType) carriers.excludedCarriers[i].matchType;
excludedCarriers[i].match_data = carriers.excludedCarriers[i].matchData.c_str();
}
CALL_ONREQUEST(pRI->pCI->requestNumber, &cr, sizeof(RIL_CarrierRestrictions), pRI, mSlotId);
#ifdef MEMSET_FREED
memset(allowedCarriers, 0, cr.len_allowed_carriers * sizeof(RIL_Carrier));
memset(excludedCarriers, 0, cr.len_excluded_carriers * sizeof(RIL_Carrier));
#endif
free(allowedCarriers);
free(excludedCarriers);
return Void();
}
Return<void> RadioImpl::getAllowedCarriers(int32_t serial) {
#if VDBG
RLOGD("getAllowedCarriers: serial %d", serial);
#endif
dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_CARRIER_RESTRICTIONS);
return Void();
}
Return<void> RadioImpl::sendDeviceState(int32_t serial, DeviceStateType deviceStateType,
bool state) {
#if VDBG
RLOGD("sendDeviceState: serial %d", serial);
#endif
if (s_vendorFunctions->version < 15) {
if (deviceStateType == DeviceStateType::LOW_DATA_EXPECTED) {
RLOGD("sendDeviceState: calling screen state %d", BOOL_TO_INT(!state));
dispatchInts(serial, mSlotId, RIL_REQUEST_SCREEN_STATE, 1, BOOL_TO_INT(!state));
} else {
RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
RIL_REQUEST_SEND_DEVICE_STATE);
sendErrorResponse(pRI, RIL_E_REQUEST_NOT_SUPPORTED);
}
return Void();
}
dispatchInts(serial, mSlotId, RIL_REQUEST_SEND_DEVICE_STATE, 2, (int) deviceStateType,
BOOL_TO_INT(state));
return Void();
}
Return<void> RadioImpl::setIndicationFilter(int32_t serial, int32_t indicationFilter) {
#if VDBG
RLOGD("setIndicationFilter: serial %d", serial);
#endif
if (s_vendorFunctions->version < 15) {
RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
RIL_REQUEST_SET_UNSOLICITED_RESPONSE_FILTER);
sendErrorResponse(pRI, RIL_E_REQUEST_NOT_SUPPORTED);
return Void();
}
dispatchInts(serial, mSlotId, RIL_REQUEST_SET_UNSOLICITED_RESPONSE_FILTER, 1, indicationFilter);
return Void();
}
Return<void> RadioImpl::setSimCardPower(int32_t serial, bool powerUp) {
#if VDBG
RLOGD("setSimCardPower: serial %d", serial);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_SET_SIM_CARD_POWER, 1, BOOL_TO_INT(powerUp));
return Void();
}
Return<void> RadioImpl::setSimCardPower_1_1(int32_t serial, const V1_1::CardPowerState state) {
#if VDBG
RLOGD("setSimCardPower_1_1: serial %d state %d", serial, state);
#endif
dispatchInts(serial, mSlotId, RIL_REQUEST_SET_SIM_CARD_POWER, 1, state);
return Void();
}
Return<void> RadioImpl::setCarrierInfoForImsiEncryption(int32_t serial,
const V1_1::ImsiEncryptionInfo& data) {
#if VDBG
RLOGD("setCarrierInfoForImsiEncryption: serial %d", serial);
#endif
RequestInfo *pRI = android::addRequestToList(