libril/ril_service.cpp

   1 /*
   2  * Copyright (c) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #define LOG_TAG "RILC"
  18
  19 #include <android/hardware/radio/1.0/IRadio.h>
  20 #include <android/hardware/radio/deprecated/1.0/IOemHook.h>
  21
  22 #include <hwbinder/IPCThreadState.h>
  23 #include <hwbinder/ProcessState.h>
  24 #include <ril_service.h>
  25 #include <hidl/HidlTransportSupport.h>
  26 #include <utils/SystemClock.h>
  27 #include <inttypes.h>
  28
  29 #define INVALID_HEX_CHAR 16
  30
  31 // Enable verbose logging
  32 #define VDBG 0
  33
  34 using namespace android::hardware::radio::V1_0;
  35 using namespace android::hardware::radio::deprecated::V1_0;
  36 using ::android::hardware::configureRpcThreadpool;
  37 using ::android::hardware::joinRpcThreadpool;
  38 using ::android::hardware::Return;
  39 using ::android::hardware::hidl_string;
  40 using ::android::hardware::hidl_vec;
  41 using ::android::hardware::hidl_array;
  42 using ::android::hardware::Void;
  43 using android::CommandInfo;
  44 using android::RequestInfo;
  45 using android::requestToString;
  46 using android::sp;
  47
  48 #define BOOL_TO_INT(x) (x ? 1 : 0)
  49 #define ATOI_NULL_HANDLED(x) (x ? atoi(x) : -1)
  50 #define ATOI_NULL_HANDLED_DEF(x, defaultVal) (x ? atoi(x) : defaultVal)
  51
  52 RIL_RadioFunctions *s_vendorFunctions = NULL;
  53 static CommandInfo *s_commands;
  54
  55 struct RadioImpl;
  56 struct OemHookImpl;
  57
  58 #if (SIM_COUNT >= 2)
  59 sp<RadioImpl> radioService[SIM_COUNT];
  60 sp<OemHookImpl> oemHookService[SIM_COUNT];
  61 // counter used for synchronization. It is incremented every time response callbacks are updated.
  62 volatile int32_t mCounterRadio[SIM_COUNT];
  63 volatile int32_t mCounterOemHook[SIM_COUNT];
  64 #else
  65 sp<RadioImpl> radioService[1];
  66 sp<OemHookImpl> oemHookService[1];
  67 // counter used for synchronization. It is incremented every time response callbacks are updated.
  68 volatile int32_t mCounterRadio[1];
  69 volatile int32_t mCounterOemHook[1];
  70 #endif
  71
  72 static pthread_rwlock_t radioServiceRwlock = PTHREAD_RWLOCK_INITIALIZER;
  73
  74 #if (SIM_COUNT >= 2)
  75 static pthread_rwlock_t radioServiceRwlock2 = PTHREAD_RWLOCK_INITIALIZER;
  76 #if (SIM_COUNT >= 3)
  77 static pthread_rwlock_t radioServiceRwlock3 = PTHREAD_RWLOCK_INITIALIZER;
  78 #if (SIM_COUNT >= 4)
  79 static pthread_rwlock_t radioServiceRwlock4 = PTHREAD_RWLOCK_INITIALIZER;
  80 #endif
  81 #endif
  82 #endif
  83
  84 void convertRilHardwareConfigListToHal(void *response, size_t responseLen,
  85         hidl_vec<HardwareConfig>& records);
  86
  87 void convertRilRadioCapabilityToHal(void *response, size_t responseLen, RadioCapability& rc);
  88
  89 void convertRilLceDataInfoToHal(void *response, size_t responseLen, LceDataInfo& lce);
  90
  91 void convertRilSignalStrengthToHal(void *response, size_t responseLen,
  92         SignalStrength& signalStrength);
  93
  94 void convertRilDataCallToHal(RIL_Data_Call_Response_v11 *dcResponse,
  95         SetupDataCallResult& dcResult);
  96
  97 void convertRilDataCallListToHal(void *response, size_t responseLen,
  98         hidl_vec<SetupDataCallResult>& dcResultList);
  99
 100 void convertRilCellInfoListToHal(void *response, size_t responseLen, hidl_vec<CellInfo>& records);
 101
 102 struct RadioImpl : public IRadio {
 103     int32_t mSlotId;
 104     sp<IRadioResponse> mRadioResponse;
 105     sp<IRadioIndication> mRadioIndication;
 106
 107     Return<void> setResponseFunctions(
 108             const ::android::sp<IRadioResponse>& radioResponse,
 109             const ::android::sp<IRadioIndication>& radioIndication);
 110
 111     Return<void> getIccCardStatus(int32_t serial);
 112
 113     Return<void> supplyIccPinForApp(int32_t serial, const hidl_string& pin,
 114             const hidl_string& aid);
 115
 116     Return<void> supplyIccPukForApp(int32_t serial, const hidl_string& puk,
 117             const hidl_string& pin, const hidl_string& aid);
 118
 119     Return<void> supplyIccPin2ForApp(int32_t serial,
 120             const hidl_string& pin2,
 121             const hidl_string& aid);
 122
 123     Return<void> supplyIccPuk2ForApp(int32_t serial, const hidl_string& puk2,
 124             const hidl_string& pin2, const hidl_string& aid);
 125
 126     Return<void> changeIccPinForApp(int32_t serial, const hidl_string& oldPin,
 127             const hidl_string& newPin, const hidl_string& aid);
 128
 129     Return<void> changeIccPin2ForApp(int32_t serial, const hidl_string& oldPin2,
 130             const hidl_string& newPin2, const hidl_string& aid);
 131
 132     Return<void> supplyNetworkDepersonalization(int32_t serial, const hidl_string& netPin);
 133
 134     Return<void> getCurrentCalls(int32_t serial);
 135
 136     Return<void> dial(int32_t serial, const Dial& dialInfo);
 137
 138     Return<void> getImsiForApp(int32_t serial,
 139             const ::android::hardware::hidl_string& aid);
 140
 141     Return<void> hangup(int32_t serial, int32_t gsmIndex);
 142
 143     Return<void> hangupWaitingOrBackground(int32_t serial);
 144
 145     Return<void> hangupForegroundResumeBackground(int32_t serial);
 146
 147     Return<void> switchWaitingOrHoldingAndActive(int32_t serial);
 148
 149     Return<void> conference(int32_t serial);
 150
 151     Return<void> rejectCall(int32_t serial);
 152
 153     Return<void> getLastCallFailCause(int32_t serial);
 154
 155     Return<void> getSignalStrength(int32_t serial);
 156
 157     Return<void> getVoiceRegistrationState(int32_t serial);
 158
 159     Return<void> getDataRegistrationState(int32_t serial);
 160
 161     Return<void> getOperator(int32_t serial);
 162
 163     Return<void> setRadioPower(int32_t serial, bool on);
 164
 165     Return<void> sendDtmf(int32_t serial,
 166             const ::android::hardware::hidl_string& s);
 167
 168     Return<void> sendSms(int32_t serial, const GsmSmsMessage& message);
 169
 170     Return<void> sendSMSExpectMore(int32_t serial, const GsmSmsMessage& message);
 171
 172     Return<void> setupDataCall(int32_t serial,
 173             RadioTechnology radioTechnology,
 174             const DataProfileInfo& profileInfo,
 175             bool modemCognitive,
 176             bool roamingAllowed,
 177             bool isRoaming);
 178
 179     Return<void> iccIOForApp(int32_t serial,
 180             const IccIo& iccIo);
 181
 182     Return<void> sendUssd(int32_t serial,
 183             const ::android::hardware::hidl_string& ussd);
 184
 185     Return<void> cancelPendingUssd(int32_t serial);
 186
 187     Return<void> getClir(int32_t serial);
 188
 189     Return<void> setClir(int32_t serial, int32_t status);
 190
 191     Return<void> getCallForwardStatus(int32_t serial,
 192             const CallForwardInfo& callInfo);
 193
 194     Return<void> setCallForward(int32_t serial,
 195             const CallForwardInfo& callInfo);
 196
 197     Return<void> getCallWaiting(int32_t serial, int32_t serviceClass);
 198
 199     Return<void> setCallWaiting(int32_t serial, bool enable, int32_t serviceClass);
 200
 201     Return<void> acknowledgeLastIncomingGsmSms(int32_t serial,
 202             bool success, SmsAcknowledgeFailCause cause);
 203
 204     Return<void> acceptCall(int32_t serial);
 205
 206     Return<void> deactivateDataCall(int32_t serial,
 207             int32_t cid, bool reasonRadioShutDown);
 208
 209     Return<void> getFacilityLockForApp(int32_t serial,
 210             const ::android::hardware::hidl_string& facility,
 211             const ::android::hardware::hidl_string& password,
 212             int32_t serviceClass,
 213             const ::android::hardware::hidl_string& appId);
 214
 215     Return<void> setFacilityLockForApp(int32_t serial,
 216             const ::android::hardware::hidl_string& facility,
 217             bool lockState,
 218             const ::android::hardware::hidl_string& password,
 219             int32_t serviceClass,
 220             const ::android::hardware::hidl_string& appId);
 221
 222     Return<void> setBarringPassword(int32_t serial,
 223             const ::android::hardware::hidl_string& facility,
 224             const ::android::hardware::hidl_string& oldPassword,
 225             const ::android::hardware::hidl_string& newPassword);
 226
 227     Return<void> getNetworkSelectionMode(int32_t serial);
 228
 229     Return<void> setNetworkSelectionModeAutomatic(int32_t serial);
 230
 231     Return<void> setNetworkSelectionModeManual(int32_t serial,
 232             const ::android::hardware::hidl_string& operatorNumeric);
 233
 234     Return<void> getAvailableNetworks(int32_t serial);
 235
 236     Return<void> startDtmf(int32_t serial,
 237             const ::android::hardware::hidl_string& s);
 238
 239     Return<void> stopDtmf(int32_t serial);
 240
 241     Return<void> getBasebandVersion(int32_t serial);
 242
 243     Return<void> separateConnection(int32_t serial, int32_t gsmIndex);
 244
 245     Return<void> setMute(int32_t serial, bool enable);
 246
 247     Return<void> getMute(int32_t serial);
 248
 249     Return<void> getClip(int32_t serial);
 250
 251     Return<void> getDataCallList(int32_t serial);
 252
 253     Return<void> setSuppServiceNotifications(int32_t serial, bool enable);
 254
 255     Return<void> writeSmsToSim(int32_t serial,
 256             const SmsWriteArgs& smsWriteArgs);
 257
 258     Return<void> deleteSmsOnSim(int32_t serial, int32_t index);
 259
 260     Return<void> setBandMode(int32_t serial, RadioBandMode mode);
 261
 262     Return<void> getAvailableBandModes(int32_t serial);
 263
 264     Return<void> sendEnvelope(int32_t serial,
 265             const ::android::hardware::hidl_string& command);
 266
 267     Return<void> sendTerminalResponseToSim(int32_t serial,
 268             const ::android::hardware::hidl_string& commandResponse);
 269
 270     Return<void> handleStkCallSetupRequestFromSim(int32_t serial, bool accept);
 271
 272     Return<void> explicitCallTransfer(int32_t serial);
 273
 274     Return<void> setPreferredNetworkType(int32_t serial, PreferredNetworkType nwType);
 275
 276     Return<void> getPreferredNetworkType(int32_t serial);
 277
 278     Return<void> getNeighboringCids(int32_t serial);
 279
 280     Return<void> setLocationUpdates(int32_t serial, bool enable);
 281
 282     Return<void> setCdmaSubscriptionSource(int32_t serial,
 283             CdmaSubscriptionSource cdmaSub);
 284
 285     Return<void> setCdmaRoamingPreference(int32_t serial, CdmaRoamingType type);
 286
 287     Return<void> getCdmaRoamingPreference(int32_t serial);
 288
 289     Return<void> setTTYMode(int32_t serial, TtyMode mode);
 290
 291     Return<void> getTTYMode(int32_t serial);
 292
 293     Return<void> setPreferredVoicePrivacy(int32_t serial, bool enable);
 294
 295     Return<void> getPreferredVoicePrivacy(int32_t serial);
 296
 297     Return<void> sendCDMAFeatureCode(int32_t serial,
 298             const ::android::hardware::hidl_string& featureCode);
 299
 300     Return<void> sendBurstDtmf(int32_t serial,
 301             const ::android::hardware::hidl_string& dtmf,
 302             int32_t on,
 303             int32_t off);
 304
 305     Return<void> sendCdmaSms(int32_t serial, const CdmaSmsMessage& sms);
 306
 307     Return<void> acknowledgeLastIncomingCdmaSms(int32_t serial,
 308             const CdmaSmsAck& smsAck);
 309
 310     Return<void> getGsmBroadcastConfig(int32_t serial);
 311
 312     Return<void> setGsmBroadcastConfig(int32_t serial,
 313             const hidl_vec<GsmBroadcastSmsConfigInfo>& configInfo);
 314
 315     Return<void> setGsmBroadcastActivation(int32_t serial, bool activate);
 316
 317     Return<void> getCdmaBroadcastConfig(int32_t serial);
 318
 319     Return<void> setCdmaBroadcastConfig(int32_t serial,
 320             const hidl_vec<CdmaBroadcastSmsConfigInfo>& configInfo);
 321
 322     Return<void> setCdmaBroadcastActivation(int32_t serial, bool activate);
 323
 324     Return<void> getCDMASubscription(int32_t serial);
 325
 326     Return<void> writeSmsToRuim(int32_t serial, const CdmaSmsWriteArgs& cdmaSms);
 327
 328     Return<void> deleteSmsOnRuim(int32_t serial, int32_t index);
 329
 330     Return<void> getDeviceIdentity(int32_t serial);
 331
 332     Return<void> exitEmergencyCallbackMode(int32_t serial);
 333
 334     Return<void> getSmscAddress(int32_t serial);
 335
 336     Return<void> setSmscAddress(int32_t serial,
 337             const ::android::hardware::hidl_string& smsc);
 338
 339     Return<void> reportSmsMemoryStatus(int32_t serial, bool available);
 340
 341     Return<void> reportStkServiceIsRunning(int32_t serial);
 342
 343     Return<void> getCdmaSubscriptionSource(int32_t serial);
 344
 345     Return<void> requestIsimAuthentication(int32_t serial,
 346             const ::android::hardware::hidl_string& challenge);
 347
 348     Return<void> acknowledgeIncomingGsmSmsWithPdu(int32_t serial,
 349             bool success,
 350             const ::android::hardware::hidl_string& ackPdu);
 351
 352     Return<void> sendEnvelopeWithStatus(int32_t serial,
 353             const ::android::hardware::hidl_string& contents);
 354
 355     Return<void> getVoiceRadioTechnology(int32_t serial);
 356
 357     Return<void> getCellInfoList(int32_t serial);
 358
 359     Return<void> setCellInfoListRate(int32_t serial, int32_t rate);
 360
 361     Return<void> setInitialAttachApn(int32_t serial, const DataProfileInfo& dataProfileInfo,
 362             bool modemCognitive, bool isRoaming);
 363
 364     Return<void> getImsRegistrationState(int32_t serial);
 365
 366     Return<void> sendImsSms(int32_t serial, const ImsSmsMessage& message);
 367
 368     Return<void> iccTransmitApduBasicChannel(int32_t serial, const SimApdu& message);
 369
 370     Return<void> iccOpenLogicalChannel(int32_t serial,
 371             const ::android::hardware::hidl_string& aid, int32_t p2);
 372
 373     Return<void> iccCloseLogicalChannel(int32_t serial, int32_t channelId);
 374
 375     Return<void> iccTransmitApduLogicalChannel(int32_t serial, const SimApdu& message);
 376
 377     Return<void> nvReadItem(int32_t serial, NvItem itemId);
 378
 379     Return<void> nvWriteItem(int32_t serial, const NvWriteItem& item);
 380
 381     Return<void> nvWriteCdmaPrl(int32_t serial,
 382             const ::android::hardware::hidl_vec<uint8_t>& prl);
 383
 384     Return<void> nvResetConfig(int32_t serial, ResetNvType resetType);
 385
 386     Return<void> setUiccSubscription(int32_t serial, const SelectUiccSub& uiccSub);
 387
 388     Return<void> setDataAllowed(int32_t serial, bool allow);
 389
 390     Return<void> getHardwareConfig(int32_t serial);
 391
 392     Return<void> requestIccSimAuthentication(int32_t serial,
 393             int32_t authContext,
 394             const ::android::hardware::hidl_string& authData,
 395             const ::android::hardware::hidl_string& aid);
 396
 397     Return<void> setDataProfile(int32_t serial,
 398             const ::android::hardware::hidl_vec<DataProfileInfo>& profiles, bool isRoaming);
 399
 400     Return<void> requestShutdown(int32_t serial);
 401
 402     Return<void> getRadioCapability(int32_t serial);
 403
 404     Return<void> setRadioCapability(int32_t serial, const RadioCapability& rc);
 405
 406     Return<void> startLceService(int32_t serial, int32_t reportInterval, bool pullMode);
 407
 408     Return<void> stopLceService(int32_t serial);
 409
 410     Return<void> pullLceData(int32_t serial);
 411
 412     Return<void> getModemActivityInfo(int32_t serial);
 413
 414     Return<void> setAllowedCarriers(int32_t serial,
 415             bool allAllowed,
 416             const CarrierRestrictions& carriers);
 417
 418     Return<void> getAllowedCarriers(int32_t serial);
 419
 420     Return<void> sendDeviceState(int32_t serial, DeviceStateType deviceStateType, bool state);
 421
 422     Return<void> setIndicationFilter(int32_t serial, int32_t indicationFilter);
 423
 424     Return<void> setSimCardPower(int32_t serial, bool powerUp);
 425
 426     Return<void> responseAcknowledgement();
 427
 428     void checkReturnStatus(Return<void>& ret);
 429 };
 430
 431 struct OemHookImpl : public IOemHook {
 432     int32_t mSlotId;
 433     sp<IOemHookResponse> mOemHookResponse;
 434     sp<IOemHookIndication> mOemHookIndication;
 435
 436     Return<void> setResponseFunctions(
 437             const ::android::sp<IOemHookResponse>& oemHookResponse,
 438             const ::android::sp<IOemHookIndication>& oemHookIndication);
 439
 440     Return<void> sendRequestRaw(int32_t serial,
 441             const ::android::hardware::hidl_vec<uint8_t>& data);
 442
 443     Return<void> sendRequestStrings(int32_t serial,
 444             const ::android::hardware::hidl_vec<::android::hardware::hidl_string>& data);
 445 };
 446
 447 void memsetAndFreeStrings(int numPointers, ...) {
 448     va_list ap;
 449     va_start(ap, numPointers);
 450     for (int i = 0; i < numPointers; i++) {
 451         char *ptr = va_arg(ap, char *);
 452         if (ptr) {
 453 #ifdef MEMSET_FREED
 454 #define MAX_STRING_LENGTH 4096
 455             memset(ptr, 0, strnlen(ptr, MAX_STRING_LENGTH));
 456 #endif
 457             free(ptr);
 458         }
 459     }
 460     va_end(ap);
 461 }
 462
 463 void sendErrorResponse(RequestInfo *pRI, RIL_Errno err) {
 464     pRI->pCI->responseFunction((int) pRI->socket_id,
 465             (int) RadioResponseType::SOLICITED, pRI->token, err, NULL, 0);
 466 }
 467
 468 /**
 469  * Copies over src to dest. If memory allocation fails, responseFunction() is called for the
 470  * request with error RIL_E_NO_MEMORY.
 471  * Returns true on success, and false on failure.
 472  */
 473 bool copyHidlStringToRil(char **dest, const hidl_string &src, RequestInfo *pRI) {
 474     size_t len = src.size();
 475     if (len == 0) {
 476         *dest = NULL;
 477         return true;
 478     }
 479     *dest = (char *) calloc(len + 1, sizeof(char));
 480     if (*dest == NULL) {
 481         RLOGE("Memory allocation failed for request %s", requestToString(pRI->pCI->requestNumber));
 482         sendErrorResponse(pRI, RIL_E_NO_MEMORY);
 483         return false;
 484     }
 485     strncpy(*dest, src.c_str(), len + 1);
 486     return true;
 487 }
 488
 489 hidl_string convertCharPtrToHidlString(const char *ptr) {
 490     hidl_string ret;
 491     if (ptr != NULL) {
 492         // TODO: replace this with strnlen
 493         ret.setToExternal(ptr, strlen(ptr));
 494     }
 495     return ret;
 496 }
 497
 498 bool dispatchVoid(int serial, int slotId, int request) {
 499     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 500     if (pRI == NULL) {
 501         return false;
 502     }
 503     s_vendorFunctions->onRequest(request, NULL, 0, pRI);
 504     return true;
 505 }
 506
 507 bool dispatchString(int serial, int slotId, int request, const char * str) {
 508     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 509     if (pRI == NULL) {
 510         return false;
 511     }
 512
 513     char *pString;
 514     if (!copyHidlStringToRil(&pString, str, pRI)) {
 515         return false;
 516     }
 517
 518     s_vendorFunctions->onRequest(request, pString, sizeof(char *), pRI);
 519
 520     memsetAndFreeStrings(1, pString);
 521     return true;
 522 }
 523
 524 bool dispatchStrings(int serial, int slotId, int request, int countStrings, ...) {
 525     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 526     if (pRI == NULL) {
 527         return false;
 528     }
 529
 530     char **pStrings;
 531     pStrings = (char **)calloc(countStrings, sizeof(char *));
 532     if (pStrings == NULL) {
 533         RLOGE("Memory allocation failed for request %s", requestToString(request));
 534         sendErrorResponse(pRI, RIL_E_NO_MEMORY);
 535         return false;
 536     }
 537     va_list ap;
 538     va_start(ap, countStrings);
 539     for (int i = 0; i < countStrings; i++) {
 540         const char* str = va_arg(ap, const char *);
 541         if (!copyHidlStringToRil(&pStrings[i], hidl_string(str), pRI)) {
 542             va_end(ap);
 543             for (int j = 0; j < i; j++) {
 544                 memsetAndFreeStrings(1, pStrings[j]);
 545             }
 546             free(pStrings);
 547             return false;
 548         }
 549     }
 550     va_end(ap);
 551
 552     s_vendorFunctions->onRequest(request, pStrings, countStrings * sizeof(char *), pRI);
 553
 554     if (pStrings != NULL) {
 555         for (int i = 0 ; i < countStrings ; i++) {
 556             memsetAndFreeStrings(1, pStrings[i]);
 557         }
 558
 559 #ifdef MEMSET_FREED
 560         memset(pStrings, 0, countStrings * sizeof(char *));
 561 #endif
 562         free(pStrings);
 563     }
 564     return true;
 565 }
 566
 567 bool dispatchStrings(int serial, int slotId, int request, const hidl_vec<hidl_string>& data) {
 568     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 569     if (pRI == NULL) {
 570         return false;
 571     }
 572
 573     int countStrings = data.size();
 574     char **pStrings;
 575     pStrings = (char **)calloc(countStrings, sizeof(char *));
 576     if (pStrings == NULL) {
 577         RLOGE("Memory allocation failed for request %s", requestToString(request));
 578         sendErrorResponse(pRI, RIL_E_NO_MEMORY);
 579         return false;
 580     }
 581
 582     for (int i = 0; i < countStrings; i++) {
 583         if (!copyHidlStringToRil(&pStrings[i], data[i], pRI)) {
 584             for (int j = 0; j < i; j++) {
 585                 memsetAndFreeStrings(1, pStrings[j]);
 586             }
 587             free(pStrings);
 588             return false;
 589         }
 590     }
 591
 592     s_vendorFunctions->onRequest(request, pStrings, countStrings * sizeof(char *), pRI);
 593
 594     if (pStrings != NULL) {
 595         for (int i = 0 ; i < countStrings ; i++) {
 596             memsetAndFreeStrings(1, pStrings[i]);
 597         }
 598
 599 #ifdef MEMSET_FREED
 600         memset(pStrings, 0, countStrings * sizeof(char *));
 601 #endif
 602         free(pStrings);
 603     }
 604     return true;
 605 }
 606
 607 bool dispatchInts(int serial, int slotId, int request, int countInts, ...) {
 608     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 609     if (pRI == NULL) {
 610         return false;
 611     }
 612
 613     int *pInts = (int *)calloc(countInts, sizeof(int));
 614
 615     if (pInts == NULL) {
 616         RLOGE("Memory allocation failed for request %s", requestToString(request));
 617         sendErrorResponse(pRI, RIL_E_NO_MEMORY);
 618         return false;
 619     }
 620     va_list ap;
 621     va_start(ap, countInts);
 622     for (int i = 0; i < countInts; i++) {
 623         pInts[i] = va_arg(ap, int);
 624     }
 625     va_end(ap);
 626
 627     s_vendorFunctions->onRequest(request, pInts, countInts * sizeof(int), pRI);
 628
 629     if (pInts != NULL) {
 630 #ifdef MEMSET_FREED
 631         memset(pInts, 0, countInts * sizeof(int));
 632 #endif
 633         free(pInts);
 634     }
 635     return true;
 636 }
 637
 638 bool dispatchCallForwardStatus(int serial, int slotId, int request,
 639                               const CallForwardInfo& callInfo) {
 640     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 641     if (pRI == NULL) {
 642         return false;
 643     }
 644
 645     RIL_CallForwardInfo cf;
 646     cf.status = (int) callInfo.status;
 647     cf.reason = callInfo.reason;
 648     cf.serviceClass = callInfo.serviceClass;
 649     cf.toa = callInfo.toa;
 650     cf.timeSeconds = callInfo.timeSeconds;
 651
 652     if (!copyHidlStringToRil(&cf.number, callInfo.number, pRI)) {
 653         return false;
 654     }
 655
 656     s_vendorFunctions->onRequest(request, &cf, sizeof(cf), pRI);
 657
 658     memsetAndFreeStrings(1, cf.number);
 659
 660     return true;
 661 }
 662
 663 bool dispatchRaw(int serial, int slotId, int request, const hidl_vec<uint8_t>& rawBytes) {
 664     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 665     if (pRI == NULL) {
 666         return false;
 667     }
 668
 669     const uint8_t *uData = rawBytes.data();
 670
 671     s_vendorFunctions->onRequest(request, (void *) uData, rawBytes.size(), pRI);
 672
 673     return true;
 674 }
 675
 676 bool dispatchIccApdu(int serial, int slotId, int request, const SimApdu& message) {
 677     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 678     if (pRI == NULL) {
 679         return false;
 680     }
 681
 682     RIL_SIM_APDU apdu = {};
 683
 684     apdu.sessionid = message.sessionId;
 685     apdu.cla = message.cla;
 686     apdu.instruction = message.instruction;
 687     apdu.p1 = message.p1;
 688     apdu.p2 = message.p2;
 689     apdu.p3 = message.p3;
 690
 691     if (!copyHidlStringToRil(&apdu.data, message.data, pRI)) {
 692         return false;
 693     }
 694
 695     s_vendorFunctions->onRequest(request, &apdu, sizeof(apdu), pRI);
 696
 697     memsetAndFreeStrings(1, apdu.data);
 698
 699     return true;
 700 }
 701
 702 void checkReturnStatus(int32_t slotId, Return<void>& ret, bool isRadioService) {
 703     if (ret.isOk() == false) {
 704         RLOGE("checkReturnStatus: unable to call response/indication callback");
 705         // Remote process hosting the callbacks must be dead. Reset the callback objects;
 706         // there's no other recovery to be done here. When the client process is back up, it will
 707         // call setResponseFunctions()
 708
 709         // Caller should already hold rdlock, release that first
 710         // note the current counter to avoid overwriting updates made by another thread before
 711         // write lock is acquired.
 712         int counter = isRadioService ? mCounterRadio[slotId] : mCounterOemHook[slotId];
 713         pthread_rwlock_t *radioServiceRwlockPtr = radio::getRadioServiceRwlock(slotId);
 714         int ret = pthread_rwlock_unlock(radioServiceRwlockPtr);
 715         assert(ret == 0);
 716
 717         // acquire wrlock
 718         ret = pthread_rwlock_wrlock(radioServiceRwlockPtr);
 719         assert(ret == 0);
 720
 721         // make sure the counter value has not changed
 722         if (counter == (isRadioService ? mCounterRadio[slotId] : mCounterOemHook[slotId])) {
 723             if (isRadioService) {
 724                 radioService[slotId]->mRadioResponse = NULL;
 725                 radioService[slotId]->mRadioIndication = NULL;
 726             } else {
 727                 oemHookService[slotId]->mOemHookResponse = NULL;
 728                 oemHookService[slotId]->mOemHookIndication = NULL;
 729             }
 730             isRadioService ? mCounterRadio[slotId]++ : mCounterOemHook[slotId]++;
 731         } else {
 732             RLOGE("checkReturnStatus: not resetting responseFunctions as they likely "
 733                     "got updated on another thread");
 734         }
 735
 736         // release wrlock
 737         ret = pthread_rwlock_unlock(radioServiceRwlockPtr);
 738         assert(ret == 0);
 739
 740         // Reacquire rdlock
 741         ret = pthread_rwlock_rdlock(radioServiceRwlockPtr);
 742         assert(ret == 0);
 743     }
 744 }
 745
 746 void RadioImpl::checkReturnStatus(Return<void>& ret) {
 747     ::checkReturnStatus(mSlotId, ret, true);
 748 }
 749
 750 Return<void> RadioImpl::setResponseFunctions(
 751         const ::android::sp<IRadioResponse>& radioResponseParam,
 752         const ::android::sp<IRadioIndication>& radioIndicationParam) {
 753     RLOGD("setResponseFunctions");
 754
 755     pthread_rwlock_t *radioServiceRwlockPtr = radio::getRadioServiceRwlock(mSlotId);
 756     int ret = pthread_rwlock_wrlock(radioServiceRwlockPtr);
 757     assert(ret == 0);
 758
 759     mRadioResponse = radioResponseParam;
 760     mRadioIndication = radioIndicationParam;
 761     mCounterRadio[mSlotId]++;
 762
 763     ret = pthread_rwlock_unlock(radioServiceRwlockPtr);
 764     assert(ret == 0);
 765
 766     // client is connected. Send initial indications.
 767     android::onNewCommandConnect((RIL_SOCKET_ID) mSlotId);
 768
 769     return Void();
 770 }
 771
 772 Return<void> RadioImpl::getIccCardStatus(int32_t serial) {
 773 #if VDBG
 774     RLOGD("getIccCardStatus: serial %d", serial);
 775 #endif
 776     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_SIM_STATUS);
 777     return Void();
 778 }
 779
 780 Return<void> RadioImpl::supplyIccPinForApp(int32_t serial, const hidl_string& pin,
 781         const hidl_string& aid) {
 782 #if VDBG
 783     RLOGD("supplyIccPinForApp: serial %d", serial);
 784 #endif
 785     dispatchStrings(serial, mSlotId, RIL_REQUEST_ENTER_SIM_PIN,
 786             2, pin.c_str(), aid.c_str());
 787     return Void();
 788 }
 789
 790 Return<void> RadioImpl::supplyIccPukForApp(int32_t serial, const hidl_string& puk,
 791                                            const hidl_string& pin, const hidl_string& aid) {
 792 #if VDBG
 793     RLOGD("supplyIccPukForApp: serial %d", serial);
 794 #endif
 795     dispatchStrings(serial, mSlotId, RIL_REQUEST_ENTER_SIM_PUK,
 796             3, puk.c_str(), pin.c_str(), aid.c_str());
 797     return Void();
 798 }
 799
 800 Return<void> RadioImpl::supplyIccPin2ForApp(int32_t serial, const hidl_string& pin2,
 801                                             const hidl_string& aid) {
 802 #if VDBG
 803     RLOGD("supplyIccPin2ForApp: serial %d", serial);
 804 #endif
 805     dispatchStrings(serial, mSlotId, RIL_REQUEST_ENTER_SIM_PIN2,
 806             2, pin2.c_str(), aid.c_str());
 807     return Void();
 808 }
 809
 810 Return<void> RadioImpl::supplyIccPuk2ForApp(int32_t serial, const hidl_string& puk2,
 811                                             const hidl_string& pin2, const hidl_string& aid) {
 812 #if VDBG
 813     RLOGD("supplyIccPuk2ForApp: serial %d", serial);
 814 #endif
 815     dispatchStrings(serial, mSlotId, RIL_REQUEST_ENTER_SIM_PUK2,
 816             3, puk2.c_str(), pin2.c_str(), aid.c_str());
 817     return Void();
 818 }
 819
 820 Return<void> RadioImpl::changeIccPinForApp(int32_t serial, const hidl_string& oldPin,
 821                                            const hidl_string& newPin, const hidl_string& aid) {
 822 #if VDBG
 823     RLOGD("changeIccPinForApp: serial %d", serial);
 824 #endif
 825     dispatchStrings(serial, mSlotId, RIL_REQUEST_CHANGE_SIM_PIN,
 826             3, oldPin.c_str(), newPin.c_str(), aid.c_str());
 827     return Void();
 828 }
 829
 830 Return<void> RadioImpl::changeIccPin2ForApp(int32_t serial, const hidl_string& oldPin2,
 831                                             const hidl_string& newPin2, const hidl_string& aid) {
 832 #if VDBG
 833     RLOGD("changeIccPin2ForApp: serial %d", serial);
 834 #endif
 835     dispatchStrings(serial, mSlotId, RIL_REQUEST_CHANGE_SIM_PIN2,
 836             3, oldPin2.c_str(), newPin2.c_str(), aid.c_str());
 837     return Void();
 838 }
 839
 840 Return<void> RadioImpl::supplyNetworkDepersonalization(int32_t serial,
 841                                                        const hidl_string& netPin) {
 842 #if VDBG
 843     RLOGD("supplyNetworkDepersonalization: serial %d", serial);
 844 #endif
 845     dispatchStrings(serial, mSlotId, RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION,
 846             1, netPin.c_str());
 847     return Void();
 848 }
 849
 850 Return<void> RadioImpl::getCurrentCalls(int32_t serial) {
 851 #if VDBG
 852     RLOGD("getCurrentCalls: serial %d", serial);
 853 #endif
 854     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_CURRENT_CALLS);
 855     return Void();
 856 }
 857
 858 Return<void> RadioImpl::dial(int32_t serial, const Dial& dialInfo) {
 859 #if VDBG
 860     RLOGD("dial: serial %d", serial);
 861 #endif
 862     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_DIAL);
 863     if (pRI == NULL) {
 864         return Void();
 865     }
 866     RIL_Dial dial = {};
 867     RIL_UUS_Info uusInfo = {};
 868     int32_t sizeOfDial = sizeof(dial);
 869
 870     if (!copyHidlStringToRil(&dial.address, dialInfo.address, pRI)) {
 871         return Void();
 872     }
 873     dial.clir = (int) dialInfo.clir;
 874
 875     if (dialInfo.uusInfo.size() != 0) {
 876         uusInfo.uusType = (RIL_UUS_Type) dialInfo.uusInfo[0].uusType;
 877         uusInfo.uusDcs = (RIL_UUS_DCS) dialInfo.uusInfo[0].uusDcs;
 878
 879         if (dialInfo.uusInfo[0].uusData.size() == 0) {
 880             uusInfo.uusData = NULL;
 881             uusInfo.uusLength = 0;
 882         } else {
 883             if (!copyHidlStringToRil(&uusInfo.uusData, dialInfo.uusInfo[0].uusData, pRI)) {
 884                 memsetAndFreeStrings(1, dial.address);
 885                 return Void();
 886             }
 887             uusInfo.uusLength = dialInfo.uusInfo[0].uusData.size();
 888         }
 889
 890         dial.uusInfo = &uusInfo;
 891     }
 892
 893     s_vendorFunctions->onRequest(RIL_REQUEST_DIAL, &dial, sizeOfDial, pRI);
 894
 895     memsetAndFreeStrings(2, dial.address, uusInfo.uusData);
 896
 897     return Void();
 898 }
 899
 900 Return<void> RadioImpl::getImsiForApp(int32_t serial, const hidl_string& aid) {
 901 #if VDBG
 902     RLOGD("getImsiForApp: serial %d", serial);
 903 #endif
 904     dispatchStrings(serial, mSlotId, RIL_REQUEST_GET_IMSI,
 905             1, aid.c_str());
 906     return Void();
 907 }
 908
 909 Return<void> RadioImpl::hangup(int32_t serial, int32_t gsmIndex) {
 910 #if VDBG
 911     RLOGD("hangup: serial %d", serial);
 912 #endif
 913     dispatchInts(serial, mSlotId, RIL_REQUEST_HANGUP, 1, gsmIndex);
 914     return Void();
 915 }
 916
 917 Return<void> RadioImpl::hangupWaitingOrBackground(int32_t serial) {
 918 #if VDBG
 919     RLOGD("hangupWaitingOrBackground: serial %d", serial);
 920 #endif
 921     dispatchVoid(serial, mSlotId, RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND);
 922     return Void();
 923 }
 924
 925 Return<void> RadioImpl::hangupForegroundResumeBackground(int32_t serial) {
 926 #if VDBG
 927     RLOGD("hangupForegroundResumeBackground: serial %d", serial);
 928 #endif
 929     dispatchVoid(serial, mSlotId, RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND);
 930     return Void();
 931 }
 932
 933 Return<void> RadioImpl::switchWaitingOrHoldingAndActive(int32_t serial) {
 934 #if VDBG
 935     RLOGD("switchWaitingOrHoldingAndActive: serial %d", serial);
 936 #endif
 937     dispatchVoid(serial, mSlotId, RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE);
 938     return Void();
 939 }
 940
 941 Return<void> RadioImpl::conference(int32_t serial) {
 942 #if VDBG
 943     RLOGD("conference: serial %d", serial);
 944 #endif
 945     dispatchVoid(serial, mSlotId, RIL_REQUEST_CONFERENCE);
 946     return Void();
 947 }
 948
 949 Return<void> RadioImpl::rejectCall(int32_t serial) {
 950 #if VDBG
 951     RLOGD("rejectCall: serial %d", serial);
 952 #endif
 953     dispatchVoid(serial, mSlotId, RIL_REQUEST_UDUB);
 954     return Void();
 955 }
 956
 957 Return<void> RadioImpl::getLastCallFailCause(int32_t serial) {
 958 #if VDBG
 959     RLOGD("getLastCallFailCause: serial %d", serial);
 960 #endif
 961     dispatchVoid(serial, mSlotId, RIL_REQUEST_LAST_CALL_FAIL_CAUSE);
 962     return Void();
 963 }
 964
 965 Return<void> RadioImpl::getSignalStrength(int32_t serial) {
 966 #if VDBG
 967     RLOGD("getSignalStrength: serial %d", serial);
 968 #endif
 969     dispatchVoid(serial, mSlotId, RIL_REQUEST_SIGNAL_STRENGTH);
 970     return Void();
 971 }
 972
 973 Return<void> RadioImpl::getVoiceRegistrationState(int32_t serial) {
 974 #if VDBG
 975     RLOGD("getVoiceRegistrationState: serial %d", serial);
 976 #endif
 977     dispatchVoid(serial, mSlotId, RIL_REQUEST_VOICE_REGISTRATION_STATE);
 978     return Void();
 979 }
 980
 981 Return<void> RadioImpl::getDataRegistrationState(int32_t serial) {
 982 #if VDBG
 983     RLOGD("getDataRegistrationState: serial %d", serial);
 984 #endif
 985     dispatchVoid(serial, mSlotId, RIL_REQUEST_DATA_REGISTRATION_STATE);
 986     return Void();
 987 }
 988
 989 Return<void> RadioImpl::getOperator(int32_t serial) {
 990 #if VDBG
 991     RLOGD("getOperator: serial %d", serial);
 992 #endif
 993     dispatchVoid(serial, mSlotId, RIL_REQUEST_OPERATOR);
 994     return Void();
 995 }
 996
 997 Return<void> RadioImpl::setRadioPower(int32_t serial, bool on) {
 998     RLOGD("setRadioPower: serial %d on %d", serial, on);
 999     dispatchInts(serial, mSlotId, RIL_REQUEST_RADIO_POWER, 1, BOOL_TO_INT(on));
1000     return Void();
1001 }
1002
1003 Return<void> RadioImpl::sendDtmf(int32_t serial, const hidl_string& s) {
1004 #if VDBG
1005     RLOGD("sendDtmf: serial %d", serial);
1006 #endif
1007     dispatchString(serial, mSlotId, RIL_REQUEST_DTMF, s.c_str());
1008     return Void();
1009 }
1010
1011 Return<void> RadioImpl::sendSms(int32_t serial, const GsmSmsMessage& message) {
1012 #if VDBG
1013     RLOGD("sendSms: serial %d", serial);
1014 #endif
1015     dispatchStrings(serial, mSlotId, RIL_REQUEST_SEND_SMS,
1016             2, message.smscPdu.c_str(), message.pdu.c_str());
1017     return Void();
1018 }
1019
1020 Return<void> RadioImpl::sendSMSExpectMore(int32_t serial, const GsmSmsMessage& message) {
1021 #if VDBG
1022     RLOGD("sendSMSExpectMore: serial %d", serial);
1023 #endif
1024     dispatchStrings(serial, mSlotId, RIL_REQUEST_SEND_SMS_EXPECT_MORE,
1025             2, message.smscPdu.c_str(), message.pdu.c_str());
1026     return Void();
1027 }
1028
1029 static bool convertMvnoTypeToString(MvnoType type, char *&str) {
1030     switch (type) {
1031         case MvnoType::IMSI:
1032             str = (char *)"imsi";
1033             return true;
1034         case MvnoType::GID:
1035             str = (char *)"gid";
1036             return true;
1037         case MvnoType::SPN:
1038             str = (char *)"spn";
1039             return true;
1040         case MvnoType::NONE:
1041             str = (char *)"";
1042             return true;
1043     }
1044     return false;
1045 }
1046
1047 Return<void> RadioImpl::setupDataCall(int32_t serial, RadioTechnology radioTechnology,
1048                                       const DataProfileInfo& dataProfileInfo, bool modemCognitive,
1049                                       bool roamingAllowed, bool isRoaming) {
1050
1051 #if VDBG
1052     RLOGD("setupDataCall: serial %d", serial);
1053 #endif
1054
1055     if (s_vendorFunctions->version >= 4 && s_vendorFunctions->version <= 14) {
1056         const hidl_string &protocol =
1057                 (isRoaming ? dataProfileInfo.roamingProtocol : dataProfileInfo.protocol);
1058         dispatchStrings(serial, mSlotId, RIL_REQUEST_SETUP_DATA_CALL, 7,
1059             std::to_string((int) radioTechnology + 2).c_str(),
1060             std::to_string((int) dataProfileInfo.profileId).c_str(),
1061             dataProfileInfo.apn.c_str(),
1062             dataProfileInfo.user.c_str(),
1063             dataProfileInfo.password.c_str(),
1064             std::to_string((int) dataProfileInfo.authType).c_str(),
1065             protocol.c_str());
1066     } else if (s_vendorFunctions->version >= 15) {
1067         char *mvnoTypeStr = NULL;
1068         if (!convertMvnoTypeToString(dataProfileInfo.mvnoType, mvnoTypeStr)) {
1069             RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
1070                     RIL_REQUEST_SETUP_DATA_CALL);
1071             if (pRI != NULL) {
1072                 sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
1073             }
1074             return Void();
1075         }
1076         dispatchStrings(serial, mSlotId, RIL_REQUEST_SETUP_DATA_CALL, 15,
1077             std::to_string((int) radioTechnology + 2).c_str(),
1078             std::to_string((int) dataProfileInfo.profileId).c_str(),
1079             dataProfileInfo.apn.c_str(),
1080             dataProfileInfo.user.c_str(),
1081             dataProfileInfo.password.c_str(),
1082             std::to_string((int) dataProfileInfo.authType).c_str(),
1083             dataProfileInfo.protocol.c_str(),
1084             dataProfileInfo.roamingProtocol.c_str(),
1085             std::to_string(dataProfileInfo.supportedApnTypesBitmap).c_str(),
1086             std::to_string(dataProfileInfo.bearerBitmap).c_str(),
1087             modemCognitive ? "1" : "0",
1088             std::to_string(dataProfileInfo.mtu).c_str(),
1089             mvnoTypeStr,
1090             dataProfileInfo.mvnoMatchData.c_str(),
1091             roamingAllowed ? "1" : "0");
1092     } else {
1093         RLOGE("Unsupported RIL version %d, min version expected 4", s_vendorFunctions->version);
1094         RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
1095                 RIL_REQUEST_SETUP_DATA_CALL);
1096         if (pRI != NULL) {
1097             sendErrorResponse(pRI, RIL_E_REQUEST_NOT_SUPPORTED);
1098         }
1099     }
1100     return Void();
1101 }
1102
1103 Return<void> RadioImpl::iccIOForApp(int32_t serial, const IccIo& iccIo) {
1104 #if VDBG
1105     RLOGD("iccIOForApp: serial %d", serial);
1106 #endif
1107     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SIM_IO);
1108     if (pRI == NULL) {
1109         return Void();
1110     }
1111
1112     RIL_SIM_IO_v6 rilIccIo = {};
1113     rilIccIo.command = iccIo.command;
1114     rilIccIo.fileid = iccIo.fileId;
1115     if (!copyHidlStringToRil(&rilIccIo.path, iccIo.path, pRI)) {
1116         return Void();
1117     }
1118
1119     rilIccIo.p1 = iccIo.p1;
1120     rilIccIo.p2 = iccIo.p2;
1121     rilIccIo.p3 = iccIo.p3;
1122
1123     if (!copyHidlStringToRil(&rilIccIo.data, iccIo.data, pRI)) {
1124         memsetAndFreeStrings(1, rilIccIo.path);
1125         return Void();
1126     }
1127
1128     if (!copyHidlStringToRil(&rilIccIo.pin2, iccIo.pin2, pRI)) {
1129         memsetAndFreeStrings(2, rilIccIo.path, rilIccIo.data);
1130         return Void();
1131     }
1132
1133     if (!copyHidlStringToRil(&rilIccIo.aidPtr, iccIo.aid, pRI)) {
1134         memsetAndFreeStrings(3, rilIccIo.path, rilIccIo.data, rilIccIo.pin2);
1135         return Void();
1136     }
1137
1138     s_vendorFunctions->onRequest(RIL_REQUEST_SIM_IO, &rilIccIo, sizeof(rilIccIo), pRI);
1139
1140     memsetAndFreeStrings(4, rilIccIo.path, rilIccIo.data, rilIccIo.pin2, rilIccIo.aidPtr);
1141
1142     return Void();
1143 }
1144
1145 Return<void> RadioImpl::sendUssd(int32_t serial, const hidl_string& ussd) {
1146 #if VDBG
1147     RLOGD("sendUssd: serial %d", serial);
1148 #endif
1149     dispatchString(serial, mSlotId, RIL_REQUEST_SEND_USSD, ussd.c_str());
1150     return Void();
1151 }
1152
1153 Return<void> RadioImpl::cancelPendingUssd(int32_t serial) {
1154 #if VDBG
1155     RLOGD("cancelPendingUssd: serial %d", serial);
1156 #endif
1157     dispatchVoid(serial, mSlotId, RIL_REQUEST_CANCEL_USSD);
1158     return Void();
1159 }
1160
1161 Return<void> RadioImpl::getClir(int32_t serial) {
1162 #if VDBG
1163     RLOGD("getClir: serial %d", serial);
1164 #endif
1165     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_CLIR);
1166     return Void();
1167 }
1168
1169 Return<void> RadioImpl::setClir(int32_t serial, int32_t status) {
1170 #if VDBG
1171     RLOGD("setClir: serial %d", serial);
1172 #endif
1173     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_CLIR, 1, status);
1174     return Void();
1175 }
1176
1177 Return<void> RadioImpl::getCallForwardStatus(int32_t serial, const CallForwardInfo& callInfo) {
1178 #if VDBG
1179     RLOGD("getCallForwardStatus: serial %d", serial);
1180 #endif
1181     dispatchCallForwardStatus(serial, mSlotId, RIL_REQUEST_QUERY_CALL_FORWARD_STATUS,
1182             callInfo);
1183     return Void();
1184 }
1185
1186 Return<void> RadioImpl::setCallForward(int32_t serial, const CallForwardInfo& callInfo) {
1187 #if VDBG
1188     RLOGD("setCallForward: serial %d", serial);
1189 #endif
1190     dispatchCallForwardStatus(serial, mSlotId, RIL_REQUEST_SET_CALL_FORWARD,
1191             callInfo);
1192     return Void();
1193 }
1194
1195 Return<void> RadioImpl::getCallWaiting(int32_t serial, int32_t serviceClass) {
1196 #if VDBG
1197     RLOGD("getCallWaiting: serial %d", serial);
1198 #endif
1199     dispatchInts(serial, mSlotId, RIL_REQUEST_QUERY_CALL_WAITING, 1, serviceClass);
1200     return Void();
1201 }
1202
1203 Return<void> RadioImpl::setCallWaiting(int32_t serial, bool enable, int32_t serviceClass) {
1204 #if VDBG
1205     RLOGD("setCallWaiting: serial %d", serial);
1206 #endif
1207     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_CALL_WAITING, 2, BOOL_TO_INT(enable),
1208             serviceClass);
1209     return Void();
1210 }
1211
1212 Return<void> RadioImpl::acknowledgeLastIncomingGsmSms(int32_t serial,
1213                                                       bool success, SmsAcknowledgeFailCause cause) {
1214 #if VDBG
1215     RLOGD("acknowledgeLastIncomingGsmSms: serial %d", serial);
1216 #endif
1217     dispatchInts(serial, mSlotId, RIL_REQUEST_SMS_ACKNOWLEDGE, 2, BOOL_TO_INT(success),
1218             cause);
1219     return Void();
1220 }
1221
1222 Return<void> RadioImpl::acceptCall(int32_t serial) {
1223 #if VDBG
1224     RLOGD("acceptCall: serial %d", serial);
1225 #endif
1226     dispatchVoid(serial, mSlotId, RIL_REQUEST_ANSWER);
1227     return Void();
1228 }
1229
1230 Return<void> RadioImpl::deactivateDataCall(int32_t serial,
1231                                            int32_t cid, bool reasonRadioShutDown) {
1232 #if VDBG
1233     RLOGD("deactivateDataCall: serial %d", serial);
1234 #endif
1235     dispatchStrings(serial, mSlotId, RIL_REQUEST_DEACTIVATE_DATA_CALL,
1236             2, (std::to_string(cid)).c_str(), reasonRadioShutDown ? "1" : "0");
1237     return Void();
1238 }
1239
1240 Return<void> RadioImpl::getFacilityLockForApp(int32_t serial, const hidl_string& facility,
1241                                               const hidl_string& password, int32_t serviceClass,
1242                                               const hidl_string& appId) {
1243 #if VDBG
1244     RLOGD("getFacilityLockForApp: serial %d", serial);
1245 #endif
1246     dispatchStrings(serial, mSlotId, RIL_REQUEST_QUERY_FACILITY_LOCK,
1247             4, facility.c_str(), password.c_str(),
1248             (std::to_string(serviceClass)).c_str(), appId.c_str());
1249     return Void();
1250 }
1251
1252 Return<void> RadioImpl::setFacilityLockForApp(int32_t serial, const hidl_string& facility,
1253                                               bool lockState, const hidl_string& password,
1254                                               int32_t serviceClass, const hidl_string& appId) {
1255 #if VDBG
1256     RLOGD("setFacilityLockForApp: serial %d", serial);
1257 #endif
1258     dispatchStrings(serial, mSlotId, RIL_REQUEST_SET_FACILITY_LOCK,
1259             5, facility.c_str(), lockState ? "1" : "0", password.c_str(),
1260             (std::to_string(serviceClass)).c_str(), appId.c_str() );
1261     return Void();
1262 }
1263
1264 Return<void> RadioImpl::setBarringPassword(int32_t serial, const hidl_string& facility,
1265                                            const hidl_string& oldPassword,
1266                                            const hidl_string& newPassword) {
1267 #if VDBG
1268     RLOGD("setBarringPassword: serial %d", serial);
1269 #endif
1270     dispatchStrings(serial, mSlotId, RIL_REQUEST_CHANGE_BARRING_PASSWORD,
1271             2, oldPassword.c_str(), newPassword.c_str());
1272     return Void();
1273 }
1274
1275 Return<void> RadioImpl::getNetworkSelectionMode(int32_t serial) {
1276 #if VDBG
1277     RLOGD("getNetworkSelectionMode: serial %d", serial);
1278 #endif
1279     dispatchVoid(serial, mSlotId, RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE);
1280     return Void();
1281 }
1282
1283 Return<void> RadioImpl::setNetworkSelectionModeAutomatic(int32_t serial) {
1284 #if VDBG
1285     RLOGD("setNetworkSelectionModeAutomatic: serial %d", serial);
1286 #endif
1287     dispatchVoid(serial, mSlotId, RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC);
1288     return Void();
1289 }
1290
1291 Return<void> RadioImpl::setNetworkSelectionModeManual(int32_t serial,
1292                                                       const hidl_string& operatorNumeric) {
1293 #if VDBG
1294     RLOGD("setNetworkSelectionModeManual: serial %d", serial);
1295 #endif
1296     dispatchString(serial, mSlotId, RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL,
1297             operatorNumeric.c_str());
1298     return Void();
1299 }
1300
1301 Return<void> RadioImpl::getAvailableNetworks(int32_t serial) {
1302 #if VDBG
1303     RLOGD("getAvailableNetworks: serial %d", serial);
1304 #endif
1305     dispatchVoid(serial, mSlotId, RIL_REQUEST_QUERY_AVAILABLE_NETWORKS);
1306     return Void();
1307 }
1308
1309 Return<void> RadioImpl::startDtmf(int32_t serial, const hidl_string& s) {
1310 #if VDBG
1311     RLOGD("startDtmf: serial %d", serial);
1312 #endif
1313     dispatchString(serial, mSlotId, RIL_REQUEST_DTMF_START,
1314             s.c_str());
1315     return Void();
1316 }
1317
1318 Return<void> RadioImpl::stopDtmf(int32_t serial) {
1319 #if VDBG
1320     RLOGD("stopDtmf: serial %d", serial);
1321 #endif
1322     dispatchVoid(serial, mSlotId, RIL_REQUEST_DTMF_STOP);
1323     return Void();
1324 }
1325
1326 Return<void> RadioImpl::getBasebandVersion(int32_t serial) {
1327 #if VDBG
1328     RLOGD("getBasebandVersion: serial %d", serial);
1329 #endif
1330     dispatchVoid(serial, mSlotId, RIL_REQUEST_BASEBAND_VERSION);
1331     return Void();
1332 }
1333
1334 Return<void> RadioImpl::separateConnection(int32_t serial, int32_t gsmIndex) {
1335 #if VDBG
1336     RLOGD("separateConnection: serial %d", serial);
1337 #endif
1338     dispatchInts(serial, mSlotId, RIL_REQUEST_SEPARATE_CONNECTION, 1, gsmIndex);
1339     return Void();
1340 }
1341
1342 Return<void> RadioImpl::setMute(int32_t serial, bool enable) {
1343 #if VDBG
1344     RLOGD("setMute: serial %d", serial);
1345 #endif
1346     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_MUTE, 1, BOOL_TO_INT(enable));
1347     return Void();
1348 }
1349
1350 Return<void> RadioImpl::getMute(int32_t serial) {
1351 #if VDBG
1352     RLOGD("getMute: serial %d", serial);
1353 #endif
1354     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_MUTE);
1355     return Void();
1356 }
1357
1358 Return<void> RadioImpl::getClip(int32_t serial) {
1359 #if VDBG
1360     RLOGD("getClip: serial %d", serial);
1361 #endif
1362     dispatchVoid(serial, mSlotId, RIL_REQUEST_QUERY_CLIP);
1363     return Void();
1364 }
1365
1366 Return<void> RadioImpl::getDataCallList(int32_t serial) {
1367 #if VDBG
1368     RLOGD("getDataCallList: serial %d", serial);
1369 #endif
1370     dispatchVoid(serial, mSlotId, RIL_REQUEST_DATA_CALL_LIST);
1371     return Void();
1372 }
1373
1374 Return<void> RadioImpl::setSuppServiceNotifications(int32_t serial, bool enable) {
1375 #if VDBG
1376     RLOGD("setSuppServiceNotifications: serial %d", serial);
1377 #endif
1378     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION, 1,
1379             BOOL_TO_INT(enable));
1380     return Void();
1381 }
1382
1383 Return<void> RadioImpl::writeSmsToSim(int32_t serial, const SmsWriteArgs& smsWriteArgs) {
1384 #if VDBG
1385     RLOGD("writeSmsToSim: serial %d", serial);
1386 #endif
1387     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_WRITE_SMS_TO_SIM);
1388     if (pRI == NULL) {
1389         return Void();
1390     }
1391
1392     RIL_SMS_WriteArgs args;
1393     args.status = (int) smsWriteArgs.status;
1394
1395     int len;
1396     if (!copyHidlStringToRil(&args.pdu, smsWriteArgs.pdu, pRI)) {
1397         return Void();
1398     }
1399
1400     if (!copyHidlStringToRil(&args.smsc, smsWriteArgs.smsc, pRI)) {
1401         memsetAndFreeStrings(1, args.pdu);
1402         return Void();
1403     }
1404
1405     s_vendorFunctions->onRequest(RIL_REQUEST_WRITE_SMS_TO_SIM, &args, sizeof(args), pRI);
1406
1407     memsetAndFreeStrings(2, args.smsc, args.pdu);
1408
1409     return Void();
1410 }
1411
1412 Return<void> RadioImpl::deleteSmsOnSim(int32_t serial, int32_t index) {
1413 #if VDBG
1414     RLOGD("deleteSmsOnSim: serial %d", serial);
1415 #endif
1416     dispatchInts(serial, mSlotId, RIL_REQUEST_DELETE_SMS_ON_SIM, 1, index);
1417     return Void();
1418 }
1419
1420 Return<void> RadioImpl::setBandMode(int32_t serial, RadioBandMode mode) {
1421 #if VDBG
1422     RLOGD("setBandMode: serial %d", serial);
1423 #endif
1424     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_BAND_MODE, 1, mode);
1425     return Void();
1426 }
1427
1428 Return<void> RadioImpl::getAvailableBandModes(int32_t serial) {
1429 #if VDBG
1430     RLOGD("getAvailableBandModes: serial %d", serial);
1431 #endif
1432     dispatchVoid(serial, mSlotId, RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE);
1433     return Void();
1434 }
1435
1436 Return<void> RadioImpl::sendEnvelope(int32_t serial, const hidl_string& command) {
1437 #if VDBG
1438     RLOGD("sendEnvelope: serial %d", serial);
1439 #endif
1440     dispatchString(serial, mSlotId, RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND,
1441             command.c_str());
1442     return Void();
1443 }
1444
1445 Return<void> RadioImpl::sendTerminalResponseToSim(int32_t serial,
1446                                                   const hidl_string& commandResponse) {
1447 #if VDBG
1448     RLOGD("sendTerminalResponseToSim: serial %d", serial);
1449 #endif
1450     dispatchString(serial, mSlotId, RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE,
1451             commandResponse.c_str());
1452     return Void();
1453 }
1454
1455 Return<void> RadioImpl::handleStkCallSetupRequestFromSim(int32_t serial, bool accept) {
1456 #if VDBG
1457     RLOGD("handleStkCallSetupRequestFromSim: serial %d", serial);
1458 #endif
1459     dispatchInts(serial, mSlotId, RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM,
1460             1, BOOL_TO_INT(accept));
1461     return Void();
1462 }
1463
1464 Return<void> RadioImpl::explicitCallTransfer(int32_t serial) {
1465 #if VDBG
1466     RLOGD("explicitCallTransfer: serial %d", serial);
1467 #endif
1468     dispatchVoid(serial, mSlotId, RIL_REQUEST_EXPLICIT_CALL_TRANSFER);
1469     return Void();
1470 }
1471
1472 Return<void> RadioImpl::setPreferredNetworkType(int32_t serial, PreferredNetworkType nwType) {
1473 #if VDBG
1474     RLOGD("setPreferredNetworkType: serial %d", serial);
1475 #endif
1476     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE, 1, nwType);
1477     return Void();
1478 }
1479
1480 Return<void> RadioImpl::getPreferredNetworkType(int32_t serial) {
1481 #if VDBG
1482     RLOGD("getPreferredNetworkType: serial %d", serial);
1483 #endif
1484     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE);
1485     return Void();
1486 }
1487
1488 Return<void> RadioImpl::getNeighboringCids(int32_t serial) {
1489 #if VDBG
1490     RLOGD("getNeighboringCids: serial %d", serial);
1491 #endif
1492     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_NEIGHBORING_CELL_IDS);
1493     return Void();
1494 }
1495
1496 Return<void> RadioImpl::setLocationUpdates(int32_t serial, bool enable) {
1497 #if VDBG
1498     RLOGD("setLocationUpdates: serial %d", serial);
1499 #endif
1500     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_LOCATION_UPDATES, 1, BOOL_TO_INT(enable));
1501     return Void();
1502 }
1503
1504 Return<void> RadioImpl::setCdmaSubscriptionSource(int32_t serial, CdmaSubscriptionSource cdmaSub) {
1505 #if VDBG
1506     RLOGD("setCdmaSubscriptionSource: serial %d", serial);
1507 #endif
1508     dispatchInts(serial, mSlotId, RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE, 1, cdmaSub);
1509     return Void();
1510 }
1511
1512 Return<void> RadioImpl::setCdmaRoamingPreference(int32_t serial, CdmaRoamingType type) {
1513 #if VDBG
1514     RLOGD("setCdmaRoamingPreference: serial %d", serial);
1515 #endif
1516     dispatchInts(serial, mSlotId, RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE, 1, type);
1517     return Void();
1518 }
1519
1520 Return<void> RadioImpl::getCdmaRoamingPreference(int32_t serial) {
1521 #if VDBG
1522     RLOGD("getCdmaRoamingPreference: serial %d", serial);
1523 #endif
1524     dispatchVoid(serial, mSlotId, RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE);
1525     return Void();
1526 }
1527
1528 Return<void> RadioImpl::setTTYMode(int32_t serial, TtyMode mode) {
1529 #if VDBG
1530     RLOGD("setTTYMode: serial %d", serial);
1531 #endif
1532     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_TTY_MODE, 1, mode);
1533     return Void();
1534 }
1535
1536 Return<void> RadioImpl::getTTYMode(int32_t serial) {
1537 #if VDBG
1538     RLOGD("getTTYMode: serial %d", serial);
1539 #endif
1540     dispatchVoid(serial, mSlotId, RIL_REQUEST_QUERY_TTY_MODE);
1541     return Void();
1542 }
1543
1544 Return<void> RadioImpl::setPreferredVoicePrivacy(int32_t serial, bool enable) {
1545 #if VDBG
1546     RLOGD("setPreferredVoicePrivacy: serial %d", serial);
1547 #endif
1548     dispatchInts(serial, mSlotId, RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE,
1549             1, BOOL_TO_INT(enable));
1550     return Void();
1551 }
1552
1553 Return<void> RadioImpl::getPreferredVoicePrivacy(int32_t serial) {
1554 #if VDBG
1555     RLOGD("getPreferredVoicePrivacy: serial %d", serial);
1556 #endif
1557     dispatchVoid(serial, mSlotId, RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE);
1558     return Void();
1559 }
1560
1561 Return<void> RadioImpl::sendCDMAFeatureCode(int32_t serial, const hidl_string& featureCode) {
1562 #if VDBG
1563     RLOGD("sendCDMAFeatureCode: serial %d", serial);
1564 #endif
1565     dispatchString(serial, mSlotId, RIL_REQUEST_CDMA_FLASH,
1566             featureCode.c_str());
1567     return Void();
1568 }
1569
1570 Return<void> RadioImpl::sendBurstDtmf(int32_t serial, const hidl_string& dtmf, int32_t on,
1571                                       int32_t off) {
1572 #if VDBG
1573     RLOGD("sendBurstDtmf: serial %d", serial);
1574 #endif
1575     dispatchStrings(serial, mSlotId, RIL_REQUEST_CDMA_BURST_DTMF,
1576             3, dtmf.c_str(), (std::to_string(on)).c_str(),
1577             (std::to_string(off)).c_str());
1578     return Void();
1579 }
1580
1581 void constructCdmaSms(RIL_CDMA_SMS_Message &rcsm, const CdmaSmsMessage& sms) {
1582     rcsm.uTeleserviceID = sms.teleserviceId;
1583     rcsm.bIsServicePresent = BOOL_TO_INT(sms.isServicePresent);
1584     rcsm.uServicecategory = sms.serviceCategory;
1585     rcsm.sAddress.digit_mode = (RIL_CDMA_SMS_DigitMode) sms.address.digitMode;
1586     rcsm.sAddress.number_mode = (RIL_CDMA_SMS_NumberMode) sms.address.numberMode;
1587     rcsm.sAddress.number_type = (RIL_CDMA_SMS_NumberType) sms.address.numberType;
1588     rcsm.sAddress.number_plan = (RIL_CDMA_SMS_NumberPlan) sms.address.numberPlan;
1589
1590     rcsm.sAddress.number_of_digits = sms.address.digits.size();
1591     int digitLimit= MIN((rcsm.sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
1592     for (int i = 0; i < digitLimit; i++) {
1593         rcsm.sAddress.digits[i] = sms.address.digits[i];
1594     }
1595
1596     rcsm.sSubAddress.subaddressType = (RIL_CDMA_SMS_SubaddressType) sms.subAddress.subaddressType;
1597     rcsm.sSubAddress.odd = BOOL_TO_INT(sms.subAddress.odd);
1598
1599     rcsm.sSubAddress.number_of_digits = sms.subAddress.digits.size();
1600     digitLimit= MIN((rcsm.sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
1601     for (int i = 0; i < digitLimit; i++) {
1602         rcsm.sSubAddress.digits[i] = sms.subAddress.digits[i];
1603     }
1604
1605     rcsm.uBearerDataLen = sms.bearerData.size();
1606     digitLimit= MIN((rcsm.uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
1607     for (int i = 0; i < digitLimit; i++) {
1608         rcsm.aBearerData[i] = sms.bearerData[i];
1609     }
1610 }
1611
1612 Return<void> RadioImpl::sendCdmaSms(int32_t serial, const CdmaSmsMessage& sms) {
1613 #if VDBG
1614     RLOGD("sendCdmaSms: serial %d", serial);
1615 #endif
1616     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_CDMA_SEND_SMS);
1617     if (pRI == NULL) {
1618         return Void();
1619     }
1620
1621     RIL_CDMA_SMS_Message rcsm = {};
1622     constructCdmaSms(rcsm, sms);
1623
1624     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &rcsm, sizeof(rcsm), pRI);
1625     return Void();
1626 }
1627
1628 Return<void> RadioImpl::acknowledgeLastIncomingCdmaSms(int32_t serial, const CdmaSmsAck& smsAck) {
1629 #if VDBG
1630     RLOGD("acknowledgeLastIncomingCdmaSms: serial %d", serial);
1631 #endif
1632     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE);
1633     if (pRI == NULL) {
1634         return Void();
1635     }
1636
1637     RIL_CDMA_SMS_Ack rcsa = {};
1638
1639     rcsa.uErrorClass = (RIL_CDMA_SMS_ErrorClass) smsAck.errorClass;
1640     rcsa.uSMSCauseCode = smsAck.smsCauseCode;
1641
1642     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &rcsa, sizeof(rcsa), pRI);
1643     return Void();
1644 }
1645
1646 Return<void> RadioImpl::getGsmBroadcastConfig(int32_t serial) {
1647 #if VDBG
1648     RLOGD("getGsmBroadcastConfig: serial %d", serial);
1649 #endif
1650     dispatchVoid(serial, mSlotId, RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG);
1651     return Void();
1652 }
1653
1654 Return<void> RadioImpl::setGsmBroadcastConfig(int32_t serial,
1655                                               const hidl_vec<GsmBroadcastSmsConfigInfo>&
1656                                               configInfo) {
1657 #if VDBG
1658     RLOGD("setGsmBroadcastConfig: serial %d", serial);
1659 #endif
1660     RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
1661             RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG);
1662     if (pRI == NULL) {
1663         return Void();
1664     }
1665
1666     int num = configInfo.size();
1667     RIL_GSM_BroadcastSmsConfigInfo gsmBci[num];
1668     RIL_GSM_BroadcastSmsConfigInfo *gsmBciPtrs[num];
1669
1670     for (int i = 0 ; i < num ; i++ ) {
1671         gsmBciPtrs[i] = &gsmBci[i];
1672         gsmBci[i].fromServiceId = configInfo[i].fromServiceId;
1673         gsmBci[i].toServiceId = configInfo[i].toServiceId;
1674         gsmBci[i].fromCodeScheme = configInfo[i].fromCodeScheme;
1675         gsmBci[i].toCodeScheme = configInfo[i].toCodeScheme;
1676         gsmBci[i].selected = BOOL_TO_INT(configInfo[i].selected);
1677     }
1678
1679     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, gsmBciPtrs,
1680             num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *), pRI);
1681     return Void();
1682 }
1683
1684 Return<void> RadioImpl::setGsmBroadcastActivation(int32_t serial, bool activate) {
1685 #if VDBG
1686     RLOGD("setGsmBroadcastActivation: serial %d", serial);
1687 #endif
1688     dispatchInts(serial, mSlotId, RIL_REQUEST_GSM_SMS_BROADCAST_ACTIVATION,
1689             1, BOOL_TO_INT(!activate));
1690     return Void();
1691 }
1692
1693 Return<void> RadioImpl::getCdmaBroadcastConfig(int32_t serial) {
1694 #if VDBG
1695     RLOGD("getCdmaBroadcastConfig: serial %d", serial);
1696 #endif
1697     dispatchVoid(serial, mSlotId, RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG);
1698     return Void();
1699 }
1700
1701 Return<void> RadioImpl::setCdmaBroadcastConfig(int32_t serial,
1702                                                const hidl_vec<CdmaBroadcastSmsConfigInfo>&
1703                                                configInfo) {
1704 #if VDBG
1705     RLOGD("setCdmaBroadcastConfig: serial %d", serial);
1706 #endif
1707     RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
1708             RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG);
1709     if (pRI == NULL) {
1710         return Void();
1711     }
1712
1713     int num = configInfo.size();
1714     RIL_CDMA_BroadcastSmsConfigInfo cdmaBci[num];
1715     RIL_CDMA_BroadcastSmsConfigInfo *cdmaBciPtrs[num];
1716
1717     for (int i = 0 ; i < num ; i++ ) {
1718         cdmaBciPtrs[i] = &cdmaBci[i];
1719         cdmaBci[i].service_category = configInfo[i].serviceCategory;
1720         cdmaBci[i].language = configInfo[i].language;
1721         cdmaBci[i].selected = BOOL_TO_INT(configInfo[i].selected);
1722     }
1723
1724     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, cdmaBciPtrs,
1725             num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *), pRI);
1726     return Void();
1727 }
1728
1729 Return<void> RadioImpl::setCdmaBroadcastActivation(int32_t serial, bool activate) {
1730 #if VDBG
1731     RLOGD("setCdmaBroadcastActivation: serial %d", serial);
1732 #endif
1733     dispatchInts(serial, mSlotId, RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION,
1734             1, BOOL_TO_INT(!activate));
1735     return Void();
1736 }
1737
1738 Return<void> RadioImpl::getCDMASubscription(int32_t serial) {
1739 #if VDBG
1740     RLOGD("getCDMASubscription: serial %d", serial);
1741 #endif
1742     dispatchVoid(serial, mSlotId, RIL_REQUEST_CDMA_SUBSCRIPTION);
1743     return Void();
1744 }
1745
1746 Return<void> RadioImpl::writeSmsToRuim(int32_t serial, const CdmaSmsWriteArgs& cdmaSms) {
1747 #if VDBG
1748     RLOGD("writeSmsToRuim: serial %d", serial);
1749 #endif
1750     RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
1751             RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM);
1752     if (pRI == NULL) {
1753         return Void();
1754     }
1755
1756     RIL_CDMA_SMS_WriteArgs rcsw = {};
1757     rcsw.status = (int) cdmaSms.status;
1758     constructCdmaSms(rcsw.message, cdmaSms.message);
1759
1760     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &rcsw, sizeof(rcsw), pRI);
1761     return Void();
1762 }
1763
1764 Return<void> RadioImpl::deleteSmsOnRuim(int32_t serial, int32_t index) {
1765 #if VDBG
1766     RLOGD("deleteSmsOnRuim: serial %d", serial);
1767 #endif
1768     dispatchInts(serial, mSlotId, RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM, 1, index);
1769     return Void();
1770 }
1771
1772 Return<void> RadioImpl::getDeviceIdentity(int32_t serial) {
1773 #if VDBG
1774     RLOGD("getDeviceIdentity: serial %d", serial);
1775 #endif
1776     dispatchVoid(serial, mSlotId, RIL_REQUEST_DEVICE_IDENTITY);
1777     return Void();
1778 }
1779
1780 Return<void> RadioImpl::exitEmergencyCallbackMode(int32_t serial) {
1781 #if VDBG
1782     RLOGD("exitEmergencyCallbackMode: serial %d", serial);
1783 #endif
1784     dispatchVoid(serial, mSlotId, RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE);
1785     return Void();
1786 }
1787
1788 Return<void> RadioImpl::getSmscAddress(int32_t serial) {
1789 #if VDBG
1790     RLOGD("getSmscAddress: serial %d", serial);
1791 #endif
1792     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_SMSC_ADDRESS);
1793     return Void();
1794 }
1795
1796 Return<void> RadioImpl::setSmscAddress(int32_t serial, const hidl_string& smsc) {
1797 #if VDBG
1798     RLOGD("setSmscAddress: serial %d", serial);
1799 #endif
1800     dispatchString(serial, mSlotId, RIL_REQUEST_SET_SMSC_ADDRESS,
1801             smsc.c_str());
1802     return Void();
1803 }
1804
1805 Return<void> RadioImpl::reportSmsMemoryStatus(int32_t serial, bool available) {
1806 #if VDBG
1807     RLOGD("reportSmsMemoryStatus: serial %d", serial);
1808 #endif
1809     dispatchInts(serial, mSlotId, RIL_REQUEST_REPORT_SMS_MEMORY_STATUS, 1,
1810             BOOL_TO_INT(available));
1811     return Void();
1812 }
1813
1814 Return<void> RadioImpl::reportStkServiceIsRunning(int32_t serial) {
1815 #if VDBG
1816     RLOGD("reportStkServiceIsRunning: serial %d", serial);
1817 #endif
1818     dispatchVoid(serial, mSlotId, RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING);
1819     return Void();
1820 }
1821
1822 Return<void> RadioImpl::getCdmaSubscriptionSource(int32_t serial) {
1823 #if VDBG
1824     RLOGD("getCdmaSubscriptionSource: serial %d", serial);
1825 #endif
1826     dispatchVoid(serial, mSlotId, RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE);
1827     return Void();
1828 }
1829
1830 Return<void> RadioImpl::requestIsimAuthentication(int32_t serial, const hidl_string& challenge) {
1831 #if VDBG
1832     RLOGD("requestIsimAuthentication: serial %d", serial);
1833 #endif
1834     dispatchString(serial, mSlotId, RIL_REQUEST_ISIM_AUTHENTICATION,
1835             challenge.c_str());
1836     return Void();
1837 }
1838
1839 Return<void> RadioImpl::acknowledgeIncomingGsmSmsWithPdu(int32_t serial, bool success,
1840                                                          const hidl_string& ackPdu) {
1841 #if VDBG
1842     RLOGD("acknowledgeIncomingGsmSmsWithPdu: serial %d", serial);
1843 #endif
1844     dispatchStrings(serial, mSlotId, RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU,
1845             2, success ? "1" : "0", ackPdu.c_str());
1846     return Void();
1847 }
1848
1849 Return<void> RadioImpl::sendEnvelopeWithStatus(int32_t serial, const hidl_string& contents) {
1850 #if VDBG
1851     RLOGD("sendEnvelopeWithStatus: serial %d", serial);
1852 #endif
1853     dispatchString(serial, mSlotId, RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS,
1854             contents.c_str());
1855     return Void();
1856 }
1857
1858 Return<void> RadioImpl::getVoiceRadioTechnology(int32_t serial) {
1859 #if VDBG
1860     RLOGD("getVoiceRadioTechnology: serial %d", serial);
1861 #endif
1862     dispatchVoid(serial, mSlotId, RIL_REQUEST_VOICE_RADIO_TECH);
1863     return Void();
1864 }
1865
1866 Return<void> RadioImpl::getCellInfoList(int32_t serial) {
1867 #if VDBG
1868     RLOGD("getCellInfoList: serial %d", serial);
1869 #endif
1870     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_CELL_INFO_LIST);
1871     return Void();
1872 }
1873
1874 Return<void> RadioImpl::setCellInfoListRate(int32_t serial, int32_t rate) {
1875 #if VDBG
1876     RLOGD("setCellInfoListRate: serial %d", serial);
1877 #endif
1878     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE, 1, rate);
1879     return Void();
1880 }
1881
1882 Return<void> RadioImpl::setInitialAttachApn(int32_t serial, const DataProfileInfo& dataProfileInfo,
1883                                             bool modemCognitive, bool isRoaming) {
1884 #if VDBG
1885     RLOGD("setInitialAttachApn: serial %d", serial);
1886 #endif
1887     RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
1888             RIL_REQUEST_SET_INITIAL_ATTACH_APN);
1889     if (pRI == NULL) {
1890         return Void();
1891     }
1892
1893     if (s_vendorFunctions->version <= 14) {
1894         RIL_InitialAttachApn iaa = {};
1895
1896         if (!copyHidlStringToRil(&iaa.apn, dataProfileInfo.apn, pRI)) {
1897             return Void();
1898         }
1899
1900         const hidl_string &protocol =
1901                 (isRoaming ? dataProfileInfo.roamingProtocol : dataProfileInfo.protocol);
1902
1903         if (!copyHidlStringToRil(&iaa.protocol, protocol, pRI)) {
1904             memsetAndFreeStrings(1, iaa.apn);
1905             return Void();
1906         }
1907         iaa.authtype = (int) dataProfileInfo.authType;
1908         if (!copyHidlStringToRil(&iaa.username, dataProfileInfo.user, pRI)) {
1909             memsetAndFreeStrings(2, iaa.apn, iaa.protocol);
1910             return Void();
1911         }
1912         if (!copyHidlStringToRil(&iaa.password, dataProfileInfo.password, pRI)) {
1913             memsetAndFreeStrings(3, iaa.apn, iaa.protocol, iaa.username);
1914             return Void();
1915         }
1916
1917         s_vendorFunctions->onRequest(RIL_REQUEST_SET_INITIAL_ATTACH_APN, &iaa, sizeof(iaa), pRI);
1918
1919         memsetAndFreeStrings(4, iaa.apn, iaa.protocol, iaa.username, iaa.password);
1920     } else {
1921         RIL_InitialAttachApn_v15 iaa = {};
1922
1923         if (!copyHidlStringToRil(&iaa.apn, dataProfileInfo.apn, pRI)) {
1924             return Void();
1925         }
1926         if (!copyHidlStringToRil(&iaa.protocol, dataProfileInfo.protocol, pRI)) {
1927             memsetAndFreeStrings(1, iaa.apn);
1928             return Void();
1929         }
1930         if (!copyHidlStringToRil(&iaa.roamingProtocol, dataProfileInfo.roamingProtocol, pRI)) {
1931             memsetAndFreeStrings(2, iaa.apn, iaa.protocol);
1932             return Void();
1933         }
1934         iaa.authtype = (int) dataProfileInfo.authType;
1935         if (!copyHidlStringToRil(&iaa.username, dataProfileInfo.user, pRI)) {
1936             memsetAndFreeStrings(3, iaa.apn, iaa.protocol, iaa.roamingProtocol);
1937             return Void();
1938         }
1939         if (!copyHidlStringToRil(&iaa.password, dataProfileInfo.password, pRI)) {
1940             memsetAndFreeStrings(4, iaa.apn, iaa.protocol, iaa.roamingProtocol, iaa.username);
1941             return Void();
1942         }
1943         iaa.supportedTypesBitmask = dataProfileInfo.supportedApnTypesBitmap;
1944         iaa.bearerBitmask = dataProfileInfo.bearerBitmap;
1945         iaa.modemCognitive = BOOL_TO_INT(modemCognitive);
1946         iaa.mtu = dataProfileInfo.mtu;
1947
1948         if (!convertMvnoTypeToString(dataProfileInfo.mvnoType, iaa.mvnoType)) {
1949             sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
1950             memsetAndFreeStrings(5, iaa.apn, iaa.protocol, iaa.roamingProtocol, iaa.username,
1951                     iaa.password);
1952             return Void();
1953         }
1954
1955         if (!copyHidlStringToRil(&iaa.mvnoMatchData, dataProfileInfo.mvnoMatchData, pRI)) {
1956             memsetAndFreeStrings(5, iaa.apn, iaa.protocol, iaa.roamingProtocol, iaa.username,
1957                     iaa.password);
1958             return Void();
1959         }
1960
1961         s_vendorFunctions->onRequest(RIL_REQUEST_SET_INITIAL_ATTACH_APN, &iaa, sizeof(iaa), pRI);
1962
1963         memsetAndFreeStrings(6, iaa.apn, iaa.protocol, iaa.roamingProtocol, iaa.username,
1964                 iaa.password, iaa.mvnoMatchData);
1965     }
1966
1967     return Void();
1968 }
1969
1970 Return<void> RadioImpl::getImsRegistrationState(int32_t serial) {
1971 #if VDBG
1972     RLOGD("getImsRegistrationState: serial %d", serial);
1973 #endif
1974     dispatchVoid(serial, mSlotId, RIL_REQUEST_IMS_REGISTRATION_STATE);
1975     return Void();
1976 }
1977
1978 bool dispatchImsGsmSms(const ImsSmsMessage& message, RequestInfo *pRI) {
1979     RIL_IMS_SMS_Message rism = {};
1980     char **pStrings;
1981     int countStrings = 2;
1982     int dataLen = sizeof(char *) * countStrings;
1983
1984     rism.tech = RADIO_TECH_3GPP;
1985     rism.retry = BOOL_TO_INT(message.retry);
1986     rism.messageRef = message.messageRef;
1987
1988     if (message.gsmMessage.size() != 1) {
1989         RLOGE("dispatchImsGsmSms: Invalid len %s", requestToString(pRI->pCI->requestNumber));
1990         sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
1991         return false;
1992     }
1993
1994     pStrings = (char **)calloc(countStrings, sizeof(char *));
1995     if (pStrings == NULL) {
1996         RLOGE("dispatchImsGsmSms: Memory allocation failed for request %s",
1997                 requestToString(pRI->pCI->requestNumber));
1998         sendErrorResponse(pRI, RIL_E_NO_MEMORY);
1999         return false;
2000     }
2001
2002     if (!copyHidlStringToRil(&pStrings[0], message.gsmMessage[0].smscPdu, pRI)) {
2003 #ifdef MEMSET_FREED
2004         memset(pStrings, 0, dataLen);
2005 #endif
2006         free(pStrings);
2007         return false;
2008     }
2009
2010     if (!copyHidlStringToRil(&pStrings[1], message.gsmMessage[0].pdu, pRI)) {
2011         memsetAndFreeStrings(1, pStrings[0]);
2012 #ifdef MEMSET_FREED
2013         memset(pStrings, 0, dataLen);
2014 #endif
2015         free(pStrings);
2016         return false;
2017     }
2018
2019     rism.message.gsmMessage = pStrings;
2020     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &rism, sizeof(RIL_RadioTechnologyFamily) +
2021             sizeof(uint8_t) + sizeof(int32_t) + dataLen, pRI);
2022
2023     for (int i = 0 ; i < countStrings ; i++) {
2024         memsetAndFreeStrings(1, pStrings[i]);
2025     }
2026
2027 #ifdef MEMSET_FREED
2028     memset(pStrings, 0, dataLen);
2029 #endif
2030     free(pStrings);
2031
2032     return true;
2033 }
2034
2035 bool dispatchImsCdmaSms(const ImsSmsMessage& message, RequestInfo *pRI) {
2036     RIL_IMS_SMS_Message rism = {};
2037     RIL_CDMA_SMS_Message rcsm = {};
2038
2039     if (message.cdmaMessage.size() != 1) {
2040         RLOGE("dispatchImsCdmaSms: Invalid len %s", requestToString(pRI->pCI->requestNumber));
2041         sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
2042         return false;
2043     }
2044
2045     rism.tech = RADIO_TECH_3GPP2;
2046     rism.retry = BOOL_TO_INT(message.retry);
2047     rism.messageRef = message.messageRef;
2048     rism.message.cdmaMessage = &rcsm;
2049
2050     constructCdmaSms(rcsm, message.cdmaMessage[0]);
2051
2052     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &rism, sizeof(RIL_RadioTechnologyFamily) +
2053             sizeof(uint8_t) + sizeof(int32_t) + sizeof(rcsm), pRI);
2054
2055     return true;
2056 }
2057
2058 Return<void> RadioImpl::sendImsSms(int32_t serial, const ImsSmsMessage& message) {
2059 #if VDBG
2060     RLOGD("sendImsSms: serial %d", serial);
2061 #endif
2062     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_IMS_SEND_SMS);
2063     if (pRI == NULL) {
2064         return Void();
2065     }
2066
2067     RIL_RadioTechnologyFamily format = (RIL_RadioTechnologyFamily) message.tech;
2068
2069     if (RADIO_TECH_3GPP == format) {
2070         dispatchImsGsmSms(message, pRI);
2071     } else if (RADIO_TECH_3GPP2 == format) {
2072         dispatchImsCdmaSms(message, pRI);
2073     } else {
2074         RLOGE("sendImsSms: Invalid radio tech %s",
2075                 requestToString(pRI->pCI->requestNumber));
2076         sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
2077     }
2078     return Void();
2079 }
2080
2081 Return<void> RadioImpl::iccTransmitApduBasicChannel(int32_t serial, const SimApdu& message) {
2082 #if VDBG
2083     RLOGD("iccTransmitApduBasicChannel: serial %d", serial);
2084 #endif
2085     dispatchIccApdu(serial, mSlotId, RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC, message);
2086     return Void();
2087 }
2088
2089 Return<void> RadioImpl::iccOpenLogicalChannel(int32_t serial, const hidl_string& aid, int32_t p2) {
2090 #if VDBG
2091     RLOGD("iccOpenLogicalChannel: serial %d", serial);
2092 #endif
2093     if (s_vendorFunctions->version < 15) {
2094         dispatchString(serial, mSlotId, RIL_REQUEST_SIM_OPEN_CHANNEL, aid.c_str());
2095     } else {
2096         RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SIM_OPEN_CHANNEL);
2097         if (pRI == NULL) {
2098             return Void();
2099         }
2100
2101         RIL_OpenChannelParams params = {};
2102
2103         params.p2 = p2;
2104
2105         if (!copyHidlStringToRil(&params.aidPtr, aid, pRI)) {
2106             return Void();
2107         }
2108
2109         s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &params, sizeof(params), pRI);
2110
2111         memsetAndFreeStrings(1, params.aidPtr);
2112     }
2113     return Void();
2114 }
2115
2116 Return<void> RadioImpl::iccCloseLogicalChannel(int32_t serial, int32_t channelId) {
2117 #if VDBG
2118     RLOGD("iccCloseLogicalChannel: serial %d", serial);
2119 #endif
2120     dispatchInts(serial, mSlotId, RIL_REQUEST_SIM_CLOSE_CHANNEL, 1, channelId);
2121     return Void();
2122 }
2123
2124 Return<void> RadioImpl::iccTransmitApduLogicalChannel(int32_t serial, const SimApdu& message) {
2125 #if VDBG
2126     RLOGD("iccTransmitApduLogicalChannel: serial %d", serial);
2127 #endif
2128     dispatchIccApdu(serial, mSlotId, RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL, message);
2129     return Void();
2130 }
2131
2132 Return<void> RadioImpl::nvReadItem(int32_t serial, NvItem itemId) {
2133 #if VDBG
2134     RLOGD("nvReadItem: serial %d", serial);
2135 #endif
2136     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_NV_READ_ITEM);
2137     if (pRI == NULL) {
2138         return Void();
2139     }
2140
2141     RIL_NV_ReadItem nvri = {};
2142     nvri.itemID = (RIL_NV_Item) itemId;
2143
2144     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &nvri, sizeof(nvri), pRI);
2145     return Void();
2146 }
2147
2148 Return<void> RadioImpl::nvWriteItem(int32_t serial, const NvWriteItem& item) {
2149 #if VDBG
2150     RLOGD("nvWriteItem: serial %d", serial);
2151 #endif
2152     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_NV_WRITE_ITEM);
2153     if (pRI == NULL) {
2154         return Void();
2155     }
2156
2157     RIL_NV_WriteItem nvwi = {};
2158
2159     nvwi.itemID = (RIL_NV_Item) item.itemId;
2160
2161     if (!copyHidlStringToRil(&nvwi.value, item.value, pRI)) {
2162         return Void();
2163     }
2164
2165     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &nvwi, sizeof(nvwi), pRI);
2166
2167     memsetAndFreeStrings(1, nvwi.value);
2168     return Void();
2169 }
2170
2171 Return<void> RadioImpl::nvWriteCdmaPrl(int32_t serial, const hidl_vec<uint8_t>& prl) {
2172 #if VDBG
2173     RLOGD("nvWriteCdmaPrl: serial %d", serial);
2174 #endif
2175     dispatchRaw(serial, mSlotId, RIL_REQUEST_NV_WRITE_CDMA_PRL, prl);
2176     return Void();
2177 }
2178
2179 Return<void> RadioImpl::nvResetConfig(int32_t serial, ResetNvType resetType) {
2180 #if VDBG
2181     RLOGD("nvResetConfig: serial %d", serial);
2182 #endif
2183     dispatchInts(serial, mSlotId, RIL_REQUEST_NV_RESET_CONFIG, 1, (int) resetType);
2184     return Void();
2185 }
2186
2187 Return<void> RadioImpl::setUiccSubscription(int32_t serial, const SelectUiccSub& uiccSub) {
2188 #if VDBG
2189     RLOGD("setUiccSubscription: serial %d", serial);
2190 #endif
2191     RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
2192             RIL_REQUEST_SET_UICC_SUBSCRIPTION);
2193     if (pRI == NULL) {
2194         return Void();
2195     }
2196
2197     RIL_SelectUiccSub rilUiccSub = {};
2198
2199     rilUiccSub.slot = uiccSub.slot;
2200     rilUiccSub.app_index = uiccSub.appIndex;
2201     rilUiccSub.sub_type = (RIL_SubscriptionType) uiccSub.subType;
2202     rilUiccSub.act_status = (RIL_UiccSubActStatus) uiccSub.actStatus;
2203
2204     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &rilUiccSub, sizeof(rilUiccSub), pRI);
2205     return Void();
2206 }
2207
2208 Return<void> RadioImpl::setDataAllowed(int32_t serial, bool allow) {
2209 #if VDBG
2210     RLOGD("setDataAllowed: serial %d", serial);
2211 #endif
2212     dispatchInts(serial, mSlotId, RIL_REQUEST_ALLOW_DATA, 1, BOOL_TO_INT(allow));
2213     return Void();
2214 }
2215
2216 Return<void> RadioImpl::getHardwareConfig(int32_t serial) {
2217 #if VDBG
2218     RLOGD("getHardwareConfig: serial %d", serial);
2219 #endif
2220     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_HARDWARE_CONFIG);
2221     return Void();
2222 }
2223
2224 Return<void> RadioImpl::requestIccSimAuthentication(int32_t serial, int32_t authContext,
2225         const hidl_string& authData, const hidl_string& aid) {
2226 #if VDBG
2227     RLOGD("requestIccSimAuthentication: serial %d", serial);
2228 #endif
2229     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SIM_AUTHENTICATION);
2230     if (pRI == NULL) {
2231         return Void();
2232     }
2233
2234     RIL_SimAuthentication pf = {};
2235
2236     pf.authContext = authContext;
2237
2238     int len;
2239     if (!copyHidlStringToRil(&pf.authData, authData, pRI)) {
2240         return Void();
2241     }
2242
2243     if (!copyHidlStringToRil(&pf.aid, aid, pRI)) {
2244         memsetAndFreeStrings(1, pf.authData);
2245         return Void();
2246     }
2247
2248     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &pf, sizeof(pf), pRI);
2249
2250     memsetAndFreeStrings(2, pf.authData, pf.aid);
2251     return Void();
2252 }
2253
2254 /**
2255  * @param numProfiles number of data profile
2256  * @param dataProfiles the pointer to the actual data profiles. The acceptable type is
2257           RIL_DataProfileInfo or RIL_DataProfileInfo_v15.
2258  * @param dataProfilePtrs the pointer to the pointers that point to each data profile structure
2259  * @param numfields number of string-type member in the data profile structure
2260  * @param ... the variadic parameters are pointers to each string-type member
2261  **/
2262 template <typename T>
2263 void freeSetDataProfileData(int numProfiles, T *dataProfiles, T **dataProfilePtrs,
2264                             int numfields, ...) {
2265     va_list args;
2266     va_start(args, numfields);
2267
2268     // Iterate through each string-type field that need to be free.
2269     for (int i = 0; i < numfields; i++) {
2270         // Iterate through each data profile and free that specific string-type field.
2271         // The type 'char *T::*' is a type of pointer to a 'char *' member inside T structure.
2272         char *T::*ptr = va_arg(args, char *T::*);
2273         for (int j = 0; j < numProfiles; j++) {
2274             memsetAndFreeStrings(1, dataProfiles[j].*ptr);
2275         }
2276     }
2277
2278     va_end(args);
2279
2280 #ifdef MEMSET_FREED
2281     memset(dataProfiles, 0, numProfiles * sizeof(T));
2282     memset(dataProfilePtrs, 0, numProfiles * sizeof(T *));
2283 #endif
2284     free(dataProfiles);
2285     free(dataProfilePtrs);
2286 }
2287
2288 Return<void> RadioImpl::setDataProfile(int32_t serial, const hidl_vec<DataProfileInfo>& profiles,
2289                                        bool isRoaming) {
2290 #if VDBG
2291     RLOGD("setDataProfile: serial %d", serial);
2292 #endif
2293     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SET_DATA_PROFILE);
2294     if (pRI == NULL) {
2295         return Void();
2296     }
2297
2298     size_t num = profiles.size();
2299     bool success = false;
2300
2301     if (s_vendorFunctions->version <= 14) {
2302
2303         RIL_DataProfileInfo *dataProfiles =
2304             (RIL_DataProfileInfo *) calloc(num, sizeof(RIL_DataProfileInfo));
2305
2306         if (dataProfiles == NULL) {
2307             RLOGE("Memory allocation failed for request %s",
2308                     requestToString(pRI->pCI->requestNumber));
2309             sendErrorResponse(pRI, RIL_E_NO_MEMORY);
2310             return Void();
2311         }
2312
2313         RIL_DataProfileInfo **dataProfilePtrs =
2314             (RIL_DataProfileInfo **) calloc(num, sizeof(RIL_DataProfileInfo *));
2315         if (dataProfilePtrs == NULL) {
2316             RLOGE("Memory allocation failed for request %s",
2317                     requestToString(pRI->pCI->requestNumber));
2318             free(dataProfiles);
2319             sendErrorResponse(pRI, RIL_E_NO_MEMORY);
2320             return Void();
2321         }
2322
2323         for (size_t i = 0; i < num; i++) {
2324             dataProfilePtrs[i] = &dataProfiles[i];
2325
2326             success = copyHidlStringToRil(&dataProfiles[i].apn, profiles[i].apn, pRI);
2327
2328             const hidl_string &protocol =
2329                     (isRoaming ? profiles[i].roamingProtocol : profiles[i].protocol);
2330
2331             if (success && !copyHidlStringToRil(&dataProfiles[i].protocol, protocol, pRI)) {
2332                 success = false;
2333             }
2334
2335             if (success && !copyHidlStringToRil(&dataProfiles[i].user, profiles[i].user, pRI)) {
2336                 success = false;
2337             }
2338             if (success && !copyHidlStringToRil(&dataProfiles[i].password, profiles[i].password,
2339                     pRI)) {
2340                 success = false;
2341             }
2342
2343             if (!success) {
2344                 freeSetDataProfileData(num, dataProfiles, dataProfilePtrs, 4,
2345                     &RIL_DataProfileInfo::apn, &RIL_DataProfileInfo::protocol,
2346                     &RIL_DataProfileInfo::user, &RIL_DataProfileInfo::password);
2347                 return Void();
2348             }
2349
2350             dataProfiles[i].profileId = (RIL_DataProfile) profiles[i].profileId;
2351             dataProfiles[i].authType = (int) profiles[i].authType;
2352             dataProfiles[i].type = (int) profiles[i].type;
2353             dataProfiles[i].maxConnsTime = profiles[i].maxConnsTime;
2354             dataProfiles[i].maxConns = profiles[i].maxConns;
2355             dataProfiles[i].waitTime = profiles[i].waitTime;
2356             dataProfiles[i].enabled = BOOL_TO_INT(profiles[i].enabled);
2357         }
2358
2359         s_vendorFunctions->onRequest(RIL_REQUEST_SET_DATA_PROFILE, dataProfilePtrs,
2360                 num * sizeof(RIL_DataProfileInfo *), pRI);
2361
2362         freeSetDataProfileData(num, dataProfiles, dataProfilePtrs, 4,
2363                 &RIL_DataProfileInfo::apn, &RIL_DataProfileInfo::protocol,
2364                 &RIL_DataProfileInfo::user, &RIL_DataProfileInfo::password);
2365     } else {
2366         RIL_DataProfileInfo_v15 *dataProfiles =
2367             (RIL_DataProfileInfo_v15 *) calloc(num, sizeof(RIL_DataProfileInfo_v15));
2368
2369         if (dataProfiles == NULL) {
2370             RLOGE("Memory allocation failed for request %s",
2371                     requestToString(pRI->pCI->requestNumber));
2372             sendErrorResponse(pRI, RIL_E_NO_MEMORY);
2373             return Void();
2374         }
2375
2376         RIL_DataProfileInfo_v15 **dataProfilePtrs =
2377             (RIL_DataProfileInfo_v15 **) calloc(num, sizeof(RIL_DataProfileInfo_v15 *));
2378         if (dataProfilePtrs == NULL) {
2379             RLOGE("Memory allocation failed for request %s",
2380                     requestToString(pRI->pCI->requestNumber));
2381             free(dataProfiles);
2382             sendErrorResponse(pRI, RIL_E_NO_MEMORY);
2383             return Void();
2384         }
2385
2386         for (size_t i = 0; i < num; i++) {
2387             dataProfilePtrs[i] = &dataProfiles[i];
2388
2389             success = copyHidlStringToRil(&dataProfiles[i].apn, profiles[i].apn, pRI);
2390             if (success && !copyHidlStringToRil(&dataProfiles[i].protocol, profiles[i].protocol,
2391                     pRI)) {
2392                 success = false;
2393             }
2394             if (success && !copyHidlStringToRil(&dataProfiles[i].roamingProtocol,
2395                     profiles[i].roamingProtocol, pRI)) {
2396                 success = false;
2397             }
2398             if (success && !copyHidlStringToRil(&dataProfiles[i].user, profiles[i].user, pRI)) {
2399                 success = false;
2400             }
2401             if (success && !copyHidlStringToRil(&dataProfiles[i].password, profiles[i].password,
2402                     pRI)) {
2403                 success = false;
2404             }
2405
2406             if (success && !copyHidlStringToRil(&dataProfiles[i].mvnoMatchData,
2407                     profiles[i].mvnoMatchData, pRI)) {
2408                 success = false;
2409             }
2410
2411             if (success && !convertMvnoTypeToString(profiles[i].mvnoType,
2412                     dataProfiles[i].mvnoType)) {
2413                 sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
2414                 success = false;
2415             }
2416
2417             if (!success) {
2418                 freeSetDataProfileData(num, dataProfiles, dataProfilePtrs, 6,
2419                     &RIL_DataProfileInfo_v15::apn, &RIL_DataProfileInfo_v15::protocol,
2420                     &RIL_DataProfileInfo_v15::roamingProtocol, &RIL_DataProfileInfo_v15::user,
2421                     &RIL_DataProfileInfo_v15::password, &RIL_DataProfileInfo_v15::mvnoMatchData);
2422                 return Void();
2423             }
2424
2425             dataProfiles[i].profileId = (RIL_DataProfile) profiles[i].profileId;
2426             dataProfiles[i].authType = (int) profiles[i].authType;
2427             dataProfiles[i].type = (int) profiles[i].type;
2428             dataProfiles[i].maxConnsTime = profiles[i].maxConnsTime;
2429             dataProfiles[i].maxConns = profiles[i].maxConns;
2430             dataProfiles[i].waitTime = profiles[i].waitTime;
2431             dataProfiles[i].enabled = BOOL_TO_INT(profiles[i].enabled);
2432             dataProfiles[i].supportedTypesBitmask = profiles[i].supportedApnTypesBitmap;
2433             dataProfiles[i].bearerBitmask = profiles[i].bearerBitmap;
2434             dataProfiles[i].mtu = profiles[i].mtu;
2435         }
2436
2437         s_vendorFunctions->onRequest(RIL_REQUEST_SET_DATA_PROFILE, dataProfilePtrs,
2438                 num * sizeof(RIL_DataProfileInfo_v15 *), pRI);
2439
2440         freeSetDataProfileData(num, dataProfiles, dataProfilePtrs, 6,
2441                 &RIL_DataProfileInfo_v15::apn, &RIL_DataProfileInfo_v15::protocol,
2442                 &RIL_DataProfileInfo_v15::roamingProtocol, &RIL_DataProfileInfo_v15::user,
2443                 &RIL_DataProfileInfo_v15::password, &RIL_DataProfileInfo_v15::mvnoMatchData);
2444     }
2445
2446     return Void();
2447 }
2448
2449 Return<void> RadioImpl::requestShutdown(int32_t serial) {
2450 #if VDBG
2451     RLOGD("requestShutdown: serial %d", serial);
2452 #endif
2453     dispatchVoid(serial, mSlotId, RIL_REQUEST_SHUTDOWN);
2454     return Void();
2455 }
2456
2457 Return<void> RadioImpl::getRadioCapability(int32_t serial) {
2458 #if VDBG
2459     RLOGD("getRadioCapability: serial %d", serial);
2460 #endif
2461     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_RADIO_CAPABILITY);
2462     return Void();
2463 }
2464
2465 Return<void> RadioImpl::setRadioCapability(int32_t serial, const RadioCapability& rc) {
2466 #if VDBG
2467     RLOGD("setRadioCapability: serial %d", serial);
2468 #endif
2469     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SET_RADIO_CAPABILITY);
2470     if (pRI == NULL) {
2471         return Void();
2472     }
2473
2474     RIL_RadioCapability rilRc = {};
2475
2476     // TODO : set rilRc.version using HIDL version ?
2477     rilRc.session = rc.session;
2478     rilRc.phase = (int) rc.phase;
2479     rilRc.rat = (int) rc.raf;
2480     rilRc.status = (int) rc.status;
2481     strncpy(rilRc.logicalModemUuid, rc.logicalModemUuid.c_str(), MAX_UUID_LENGTH);
2482
2483     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &rilRc, sizeof(rilRc), pRI);
2484
2485     return Void();
2486 }
2487
2488 Return<void> RadioImpl::startLceService(int32_t serial, int32_t reportInterval, bool pullMode) {
2489 #if VDBG
2490     RLOGD("startLceService: serial %d", serial);
2491 #endif
2492     dispatchInts(serial, mSlotId, RIL_REQUEST_START_LCE, 2, reportInterval,
2493             BOOL_TO_INT(pullMode));
2494     return Void();
2495 }
2496
2497 Return<void> RadioImpl::stopLceService(int32_t serial) {
2498 #if VDBG
2499     RLOGD("stopLceService: serial %d", serial);
2500 #endif
2501     dispatchVoid(serial, mSlotId, RIL_REQUEST_STOP_LCE);
2502     return Void();
2503 }
2504
2505 Return<void> RadioImpl::pullLceData(int32_t serial) {
2506 #if VDBG
2507     RLOGD("pullLceData: serial %d", serial);
2508 #endif
2509     dispatchVoid(serial, mSlotId, RIL_REQUEST_PULL_LCEDATA);
2510     return Void();
2511 }
2512
2513 Return<void> RadioImpl::getModemActivityInfo(int32_t serial) {
2514 #if VDBG
2515     RLOGD("getModemActivityInfo: serial %d", serial);
2516 #endif
2517     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_ACTIVITY_INFO);
2518     return Void();
2519 }
2520
2521 Return<void> RadioImpl::setAllowedCarriers(int32_t serial, bool allAllowed,
2522                                            const CarrierRestrictions& carriers) {
2523 #if VDBG
2524     RLOGD("setAllowedCarriers: serial %d", serial);
2525 #endif
2526     RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
2527             RIL_REQUEST_SET_CARRIER_RESTRICTIONS);
2528     if (pRI == NULL) {
2529         return Void();
2530     }
2531
2532     RIL_CarrierRestrictions cr = {};
2533     RIL_Carrier *allowedCarriers = NULL;
2534     RIL_Carrier *excludedCarriers = NULL;
2535
2536     cr.len_allowed_carriers = carriers.allowedCarriers.size();
2537     allowedCarriers = (RIL_Carrier *)calloc(cr.len_allowed_carriers, sizeof(RIL_Carrier));
2538     if (allowedCarriers == NULL) {
2539         RLOGE("setAllowedCarriers: Memory allocation failed for request %s",
2540                 requestToString(pRI->pCI->requestNumber));
2541         sendErrorResponse(pRI, RIL_E_NO_MEMORY);
2542         return Void();
2543     }
2544     cr.allowed_carriers = allowedCarriers;
2545
2546     cr.len_excluded_carriers = carriers.excludedCarriers.size();
2547     excludedCarriers = (RIL_Carrier *)calloc(cr.len_excluded_carriers, sizeof(RIL_Carrier));
2548     if (excludedCarriers == NULL) {
2549         RLOGE("setAllowedCarriers: Memory allocation failed for request %s",
2550                 requestToString(pRI->pCI->requestNumber));
2551         sendErrorResponse(pRI, RIL_E_NO_MEMORY);
2552 #ifdef MEMSET_FREED
2553         memset(allowedCarriers, 0, cr.len_allowed_carriers * sizeof(RIL_Carrier));
2554 #endif
2555         free(allowedCarriers);
2556         return Void();
2557     }
2558     cr.excluded_carriers = excludedCarriers;
2559
2560     for (int i = 0; i < cr.len_allowed_carriers; i++) {
2561         allowedCarriers[i].mcc = carriers.allowedCarriers[i].mcc.c_str();
2562         allowedCarriers[i].mnc = carriers.allowedCarriers[i].mnc.c_str();
2563         allowedCarriers[i].match_type = (RIL_CarrierMatchType) carriers.allowedCarriers[i].matchType;
2564         allowedCarriers[i].match_data = carriers.allowedCarriers[i].matchData.c_str();
2565     }
2566
2567     for (int i = 0; i < cr.len_excluded_carriers; i++) {
2568         excludedCarriers[i].mcc = carriers.excludedCarriers[i].mcc.c_str();
2569         excludedCarriers[i].mnc = carriers.excludedCarriers[i].mnc.c_str();
2570         excludedCarriers[i].match_type =
2571                 (RIL_CarrierMatchType) carriers.excludedCarriers[i].matchType;
2572         excludedCarriers[i].match_data = carriers.excludedCarriers[i].matchData.c_str();
2573     }
2574
2575     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &cr, sizeof(RIL_CarrierRestrictions), pRI);
2576
2577 #ifdef MEMSET_FREED
2578     memset(allowedCarriers, 0, cr.len_allowed_carriers * sizeof(RIL_Carrier));
2579     memset(excludedCarriers, 0, cr.len_excluded_carriers * sizeof(RIL_Carrier));
2580 #endif
2581     free(allowedCarriers);
2582     free(excludedCarriers);
2583     return Void();
2584 }
2585
2586 Return<void> RadioImpl::getAllowedCarriers(int32_t serial) {
2587 #if VDBG
2588     RLOGD("getAllowedCarriers: serial %d", serial);
2589 #endif
2590     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_CARRIER_RESTRICTIONS);
2591     return Void();
2592 }
2593
2594 Return<void> RadioImpl::sendDeviceState(int32_t serial, DeviceStateType deviceStateType,
2595                                         bool state) {
2596 #if VDBG
2597     RLOGD("sendDeviceState: serial %d", serial);
2598 #endif
2599     if (s_vendorFunctions->version < 15) {
2600         if (deviceStateType ==  DeviceStateType::LOW_DATA_EXPECTED) {
2601             RLOGD("sendDeviceState: calling screen state %d", BOOL_TO_INT(!state));
2602             dispatchInts(serial, mSlotId, RIL_REQUEST_SCREEN_STATE, 1, BOOL_TO_INT(!state));
2603         } else {
2604             RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
2605                     RIL_REQUEST_SEND_DEVICE_STATE);
2606             sendErrorResponse(pRI, RIL_E_REQUEST_NOT_SUPPORTED);
2607         }
2608         return Void();
2609     }
2610     dispatchInts(serial, mSlotId, RIL_REQUEST_SEND_DEVICE_STATE, 2, (int) deviceStateType,
2611             BOOL_TO_INT(state));
2612     return Void();
2613 }
2614
2615 Return<void> RadioImpl::setIndicationFilter(int32_t serial, int32_t indicationFilter) {
2616 #if VDBG
2617     RLOGD("setIndicationFilter: serial %d", serial);
2618 #endif
2619     if (s_vendorFunctions->version < 15) {
2620         RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
2621                 RIL_REQUEST_SET_UNSOLICITED_RESPONSE_FILTER);
2622         sendErrorResponse(pRI, RIL_E_REQUEST_NOT_SUPPORTED);
2623         return Void();
2624     }
2625     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_UNSOLICITED_RESPONSE_FILTER, 1, indicationFilter);
2626     return Void();
2627 }
2628
2629 Return<void> RadioImpl::setSimCardPower(int32_t serial, bool powerUp) {
2630 #if VDBG
2631     RLOGD("setSimCardPower: serial %d", serial);
2632 #endif
2633     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_SIM_CARD_POWER, 1, BOOL_TO_INT(powerUp));
2634     return Void();
2635 }
2636
2637 Return<void> RadioImpl::responseAcknowledgement() {
2638     android::releaseWakeLock();
2639     return Void();
2640 }
2641
2642 Return<void> OemHookImpl::setResponseFunctions(
2643         const ::android::sp<IOemHookResponse>& oemHookResponseParam,
2644         const ::android::sp<IOemHookIndication>& oemHookIndicationParam) {
2645 #if VDBG
2646     RLOGD("OemHookImpl::setResponseFunctions");
2647 #endif
2648
2649     pthread_rwlock_t *radioServiceRwlockPtr = radio::getRadioServiceRwlock(mSlotId);
2650     int ret = pthread_rwlock_wrlock(radioServiceRwlockPtr);
2651     assert(ret == 0);
2652
2653     mOemHookResponse = oemHookResponseParam;
2654     mOemHookIndication = oemHookIndicationParam;
2655     mCounterOemHook[mSlotId]++;
2656
2657     ret = pthread_rwlock_unlock(radioServiceRwlockPtr);
2658     assert(ret == 0);
2659
2660     return Void();
2661 }
2662
2663 Return<void> OemHookImpl::sendRequestRaw(int32_t serial, const hidl_vec<uint8_t>& data) {
2664 #if VDBG
2665     RLOGD("OemHookImpl::sendRequestRaw: serial %d", serial);
2666 #endif
2667     dispatchRaw(serial, mSlotId, RIL_REQUEST_OEM_HOOK_RAW, data);
2668     return Void();
2669 }
2670
2671 Return<void> OemHookImpl::sendRequestStrings(int32_t serial,
2672         const hidl_vec<hidl_string>& data) {
2673 #if VDBG
2674     RLOGD("OemHookImpl::sendRequestStrings: serial %d", serial);
2675 #endif
2676     dispatchStrings(serial, mSlotId, RIL_REQUEST_OEM_HOOK_STRINGS, data);
2677     return Void();
2678 }
2679
2680 /***************************************************************************************************
2681  * RESPONSE FUNCTIONS
2682  * Functions above are used for requests going from framework to vendor code. The ones below are
2683  * responses for those requests coming back from the vendor code.
2684  **************************************************************************************************/
2685
2686 void radio::acknowledgeRequest(int slotId, int serial) {
2687     if (radioService[slotId]->mRadioResponse != NULL) {
2688         Return<void> retStatus = radioService[slotId]->mRadioResponse->acknowledgeRequest(serial);
2689         radioService[slotId]->checkReturnStatus(retStatus);
2690     } else {
2691         RLOGE("acknowledgeRequest: radioService[%d]->mRadioResponse == NULL", slotId);
2692     }
2693 }
2694
2695 void populateResponseInfo(RadioResponseInfo& responseInfo, int serial, int responseType,
2696                          RIL_Errno e) {
2697     responseInfo.serial = serial;
2698     switch (responseType) {
2699         case RESPONSE_SOLICITED:
2700             responseInfo.type = RadioResponseType::SOLICITED;
2701             break;
2702         case RESPONSE_SOLICITED_ACK_EXP:
2703             responseInfo.type = RadioResponseType::SOLICITED_ACK_EXP;
2704             break;
2705     }
2706     responseInfo.error = (RadioError) e;
2707 }
2708
2709 int responseIntOrEmpty(RadioResponseInfo& responseInfo, int serial, int responseType, RIL_Errno e,
2710                void *response, size_t responseLen) {
2711     populateResponseInfo(responseInfo, serial, responseType, e);
2712     int ret = -1;
2713
2714     if (response == NULL && responseLen == 0) {
2715         // Earlier RILs did not send a response for some cases although the interface
2716         // expected an integer as response. Do not return error if response is empty. Instead
2717         // Return -1 in those cases to maintain backward compatibility.
2718     } else if (response == NULL || responseLen != sizeof(int)) {
2719         RLOGE("responseIntOrEmpty: Invalid response");
2720         if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
2721     } else {
2722         int *p_int = (int *) response;
2723         ret = p_int[0];
2724     }
2725     return ret;
2726 }
2727
2728 int responseInt(RadioResponseInfo& responseInfo, int serial, int responseType, RIL_Errno e,
2729                void *response, size_t responseLen) {
2730     populateResponseInfo(responseInfo, serial, responseType, e);
2731     int ret = -1;
2732
2733     if (response == NULL || responseLen != sizeof(int)) {
2734         RLOGE("responseInt: Invalid response");
2735         if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
2736     } else {
2737         int *p_int = (int *) response;
2738         ret = p_int[0];
2739     }
2740     return ret;
2741 }
2742
2743 int radio::getIccCardStatusResponse(int slotId,
2744                                    int responseType, int serial, RIL_Errno e,
2745                                    void *response, size_t responseLen) {
2746     if (radioService[slotId]->mRadioResponse != NULL) {
2747         RadioResponseInfo responseInfo = {};
2748         populateResponseInfo(responseInfo, serial, responseType, e);
2749         CardStatus cardStatus = {};
2750         if (response == NULL || responseLen != sizeof(RIL_CardStatus_v6)) {
2751             RLOGE("getIccCardStatusResponse: Invalid response");
2752             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
2753         } else {
2754             RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response);
2755             cardStatus.cardState = (CardState) p_cur->card_state;
2756             cardStatus.universalPinState = (PinState) p_cur->universal_pin_state;
2757             cardStatus.gsmUmtsSubscriptionAppIndex = p_cur->gsm_umts_subscription_app_index;
2758             cardStatus.cdmaSubscriptionAppIndex = p_cur->cdma_subscription_app_index;
2759             cardStatus.imsSubscriptionAppIndex = p_cur->ims_subscription_app_index;
2760
2761             RIL_AppStatus *rilAppStatus = p_cur->applications;
2762             cardStatus.applications.resize(p_cur->num_applications);
2763             AppStatus *appStatus = cardStatus.applications.data();
2764 #if VDBG
2765             RLOGD("getIccCardStatusResponse: num_applications %d", p_cur->num_applications);
2766 #endif
2767             for (int i = 0; i < p_cur->num_applications; i++) {
2768                 appStatus[i].appType = (AppType) rilAppStatus[i].app_type;
2769                 appStatus[i].appState = (AppState) rilAppStatus[i].app_state;
2770                 appStatus[i].persoSubstate = (PersoSubstate) rilAppStatus[i].perso_substate;
2771                 appStatus[i].aidPtr = convertCharPtrToHidlString(rilAppStatus[i].aid_ptr);
2772                 appStatus[i].appLabelPtr = convertCharPtrToHidlString(
2773                         rilAppStatus[i].app_label_ptr);
2774                 appStatus[i].pin1Replaced = rilAppStatus[i].pin1_replaced;
2775                 appStatus[i].pin1 = (PinState) rilAppStatus[i].pin1;
2776                 appStatus[i].pin2 = (PinState) rilAppStatus[i].pin2;
2777             }
2778         }
2779
2780         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2781                 getIccCardStatusResponse(responseInfo, cardStatus);
2782         radioService[slotId]->checkReturnStatus(retStatus);
2783     } else {
2784         RLOGE("getIccCardStatusResponse: radioService[%d]->mRadioResponse == NULL", slotId);
2785     }
2786
2787     return 0;
2788 }
2789
2790 int radio::supplyIccPinForAppResponse(int slotId,
2791                                      int responseType, int serial, RIL_Errno e,
2792                                      void *response, size_t responseLen) {
2793 #if VDBG
2794     RLOGD("supplyIccPinForAppResponse: serial %d", serial);
2795 #endif
2796
2797     if (radioService[slotId]->mRadioResponse != NULL) {
2798         RadioResponseInfo responseInfo = {};
2799         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
2800         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2801                 supplyIccPinForAppResponse(responseInfo, ret);
2802         radioService[slotId]->checkReturnStatus(retStatus);
2803     } else {
2804         RLOGE("supplyIccPinForAppResponse: radioService[%d]->mRadioResponse == NULL",
2805                 slotId);
2806     }
2807
2808     return 0;
2809 }
2810
2811 int radio::supplyIccPukForAppResponse(int slotId,
2812                                      int responseType, int serial, RIL_Errno e,
2813                                      void *response, size_t responseLen) {
2814 #if VDBG
2815     RLOGD("supplyIccPukForAppResponse: serial %d", serial);
2816 #endif
2817
2818     if (radioService[slotId]->mRadioResponse != NULL) {
2819         RadioResponseInfo responseInfo = {};
2820         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
2821         Return<void> retStatus = radioService[slotId]->mRadioResponse->supplyIccPukForAppResponse(
2822                 responseInfo, ret);
2823         radioService[slotId]->checkReturnStatus(retStatus);
2824     } else {
2825         RLOGE("supplyIccPukForAppResponse: radioService[%d]->mRadioResponse == NULL",
2826                 slotId);
2827     }
2828
2829     return 0;
2830 }
2831
2832 int radio::supplyIccPin2ForAppResponse(int slotId,
2833                                       int responseType, int serial, RIL_Errno e,
2834                                       void *response, size_t responseLen) {
2835 #if VDBG
2836     RLOGD("supplyIccPin2ForAppResponse: serial %d", serial);
2837 #endif
2838
2839     if (radioService[slotId]->mRadioResponse != NULL) {
2840         RadioResponseInfo responseInfo = {};
2841         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
2842         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2843                 supplyIccPin2ForAppResponse(responseInfo, ret);
2844         radioService[slotId]->checkReturnStatus(retStatus);
2845     } else {
2846         RLOGE("supplyIccPin2ForAppResponse: radioService[%d]->mRadioResponse == NULL",
2847                 slotId);
2848     }
2849
2850     return 0;
2851 }
2852
2853 int radio::supplyIccPuk2ForAppResponse(int slotId,
2854                                       int responseType, int serial, RIL_Errno e,
2855                                       void *response, size_t responseLen) {
2856 #if VDBG
2857     RLOGD("supplyIccPuk2ForAppResponse: serial %d", serial);
2858 #endif
2859
2860     if (radioService[slotId]->mRadioResponse != NULL) {
2861         RadioResponseInfo responseInfo = {};
2862         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
2863         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2864                 supplyIccPuk2ForAppResponse(responseInfo, ret);
2865         radioService[slotId]->checkReturnStatus(retStatus);
2866     } else {
2867         RLOGE("supplyIccPuk2ForAppResponse: radioService[%d]->mRadioResponse == NULL",
2868                 slotId);
2869     }
2870
2871     return 0;
2872 }
2873
2874 int radio::changeIccPinForAppResponse(int slotId,
2875                                      int responseType, int serial, RIL_Errno e,
2876                                      void *response, size_t responseLen) {
2877 #if VDBG
2878     RLOGD("changeIccPinForAppResponse: serial %d", serial);
2879 #endif
2880
2881     if (radioService[slotId]->mRadioResponse != NULL) {
2882         RadioResponseInfo responseInfo = {};
2883         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
2884         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2885                 changeIccPinForAppResponse(responseInfo, ret);
2886         radioService[slotId]->checkReturnStatus(retStatus);
2887     } else {
2888         RLOGE("changeIccPinForAppResponse: radioService[%d]->mRadioResponse == NULL",
2889                 slotId);
2890     }
2891
2892     return 0;
2893 }
2894
2895 int radio::changeIccPin2ForAppResponse(int slotId,
2896                                       int responseType, int serial, RIL_Errno e,
2897                                       void *response, size_t responseLen) {
2898 #if VDBG
2899     RLOGD("changeIccPin2ForAppResponse: serial %d", serial);
2900 #endif
2901
2902     if (radioService[slotId]->mRadioResponse != NULL) {
2903         RadioResponseInfo responseInfo = {};
2904         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
2905         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2906                 changeIccPin2ForAppResponse(responseInfo, ret);
2907         radioService[slotId]->checkReturnStatus(retStatus);
2908     } else {
2909         RLOGE("changeIccPin2ForAppResponse: radioService[%d]->mRadioResponse == NULL",
2910                 slotId);
2911     }
2912
2913     return 0;
2914 }
2915
2916 int radio::supplyNetworkDepersonalizationResponse(int slotId,
2917                                                  int responseType, int serial, RIL_Errno e,
2918                                                  void *response, size_t responseLen) {
2919 #if VDBG
2920     RLOGD("supplyNetworkDepersonalizationResponse: serial %d", serial);
2921 #endif
2922
2923     if (radioService[slotId]->mRadioResponse != NULL) {
2924         RadioResponseInfo responseInfo = {};
2925         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
2926         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2927                 supplyNetworkDepersonalizationResponse(responseInfo, ret);
2928         radioService[slotId]->checkReturnStatus(retStatus);
2929     } else {
2930         RLOGE("supplyNetworkDepersonalizationResponse: radioService[%d]->mRadioResponse == "
2931                 "NULL", slotId);
2932     }
2933
2934     return 0;
2935 }
2936
2937 int radio::getCurrentCallsResponse(int slotId,
2938                                   int responseType, int serial, RIL_Errno e,
2939                                   void *response, size_t responseLen) {
2940 #if VDBG
2941     RLOGD("getCurrentCallsResponse: serial %d", serial);
2942 #endif
2943
2944     if (radioService[slotId]->mRadioResponse != NULL) {
2945         RadioResponseInfo responseInfo = {};
2946         populateResponseInfo(responseInfo, serial, responseType, e);
2947
2948         hidl_vec<Call> calls;
2949         if (response == NULL || (responseLen % sizeof(RIL_Call *)) != 0) {
2950             RLOGE("getCurrentCallsResponse: Invalid response");
2951             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
2952         } else {
2953             int num = responseLen / sizeof(RIL_Call *);
2954             calls.resize(num);
2955
2956             for (int i = 0 ; i < num ; i++) {
2957                 RIL_Call *p_cur = ((RIL_Call **) response)[i];
2958                 /* each call info */
2959                 calls[i].state = (CallState) p_cur->state;
2960                 calls[i].index = p_cur->index;
2961                 calls[i].toa = p_cur->toa;
2962                 calls[i].isMpty = p_cur->isMpty;
2963                 calls[i].isMT = p_cur->isMT;
2964                 calls[i].als = p_cur->als;
2965                 calls[i].isVoice = p_cur->isVoice;
2966                 calls[i].isVoicePrivacy = p_cur->isVoicePrivacy;
2967                 calls[i].number = convertCharPtrToHidlString(p_cur->number);
2968                 calls[i].numberPresentation = (CallPresentation) p_cur->numberPresentation;
2969                 calls[i].name = convertCharPtrToHidlString(p_cur->name);
2970                 calls[i].namePresentation = (CallPresentation) p_cur->namePresentation;
2971                 if (p_cur->uusInfo != NULL && p_cur->uusInfo->uusData != NULL) {
2972                     RIL_UUS_Info *uusInfo = p_cur->uusInfo;
2973                     calls[i].uusInfo[0].uusType = (UusType) uusInfo->uusType;
2974                     calls[i].uusInfo[0].uusDcs = (UusDcs) uusInfo->uusDcs;
2975                     // convert uusInfo->uusData to a null-terminated string
2976                     char *nullTermStr = strndup(uusInfo->uusData, uusInfo->uusLength);
2977                     calls[i].uusInfo[0].uusData = nullTermStr;
2978                     free(nullTermStr);
2979                 }
2980             }
2981         }
2982
2983         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2984                 getCurrentCallsResponse(responseInfo, calls);
2985         radioService[slotId]->checkReturnStatus(retStatus);
2986     } else {
2987         RLOGE("getCurrentCallsResponse: radioService[%d]->mRadioResponse == NULL", slotId);
2988     }
2989
2990     return 0;
2991 }
2992
2993 int radio::dialResponse(int slotId,
2994                        int responseType, int serial, RIL_Errno e, void *response,
2995                        size_t responseLen) {
2996 #if VDBG
2997     RLOGD("dialResponse: serial %d", serial);
2998 #endif
2999
3000     if (radioService[slotId]->mRadioResponse != NULL) {
3001         RadioResponseInfo responseInfo = {};
3002         populateResponseInfo(responseInfo, serial, responseType, e);
3003         Return<void> retStatus = radioService[slotId]->mRadioResponse->dialResponse(responseInfo);
3004         radioService[slotId]->checkReturnStatus(retStatus);
3005     } else {
3006         RLOGE("dialResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3007     }
3008
3009     return 0;
3010 }
3011
3012 int radio::getIMSIForAppResponse(int slotId,
3013                                 int responseType, int serial, RIL_Errno e, void *response,
3014                                 size_t responseLen) {
3015 #if VDBG
3016     RLOGD("getIMSIForAppResponse: serial %d", serial);
3017 #endif
3018
3019     if (radioService[slotId]->mRadioResponse != NULL) {
3020         RadioResponseInfo responseInfo = {};
3021         populateResponseInfo(responseInfo, serial, responseType, e);
3022         Return<void> retStatus = radioService[slotId]->mRadioResponse->getIMSIForAppResponse(
3023                 responseInfo, convertCharPtrToHidlString((char *) response));
3024         radioService[slotId]->checkReturnStatus(retStatus);
3025     } else {
3026         RLOGE("getIMSIForAppResponse: radioService[%d]->mRadioResponse == NULL",
3027                 slotId);
3028     }
3029
3030     return 0;
3031 }
3032
3033 int radio::hangupConnectionResponse(int slotId,
3034                                    int responseType, int serial, RIL_Errno e,
3035                                    void *response, size_t responseLen) {
3036 #if VDBG
3037     RLOGD("hangupConnectionResponse: serial %d", serial);
3038 #endif
3039
3040     if (radioService[slotId]->mRadioResponse != NULL) {
3041         RadioResponseInfo responseInfo = {};
3042         populateResponseInfo(responseInfo, serial, responseType, e);
3043         Return<void> retStatus = radioService[slotId]->mRadioResponse->hangupConnectionResponse(
3044                 responseInfo);
3045         radioService[slotId]->checkReturnStatus(retStatus);
3046     } else {
3047         RLOGE("hangupConnectionResponse: radioService[%d]->mRadioResponse == NULL",
3048                 slotId);
3049     }
3050
3051     return 0;
3052 }
3053
3054 int radio::hangupWaitingOrBackgroundResponse(int slotId,
3055                                             int responseType, int serial, RIL_Errno e,
3056                                             void *response, size_t responseLen) {
3057 #if VDBG
3058     RLOGD("hangupWaitingOrBackgroundResponse: serial %d", serial);
3059 #endif
3060
3061     if (radioService[slotId]->mRadioResponse != NULL) {
3062         RadioResponseInfo responseInfo = {};
3063         populateResponseInfo(responseInfo, serial, responseType, e);
3064         Return<void> retStatus =
3065                 radioService[slotId]->mRadioResponse->hangupWaitingOrBackgroundResponse(
3066                 responseInfo);
3067         radioService[slotId]->checkReturnStatus(retStatus);
3068     } else {
3069         RLOGE("hangupWaitingOrBackgroundResponse: radioService[%d]->mRadioResponse == NULL",
3070                 slotId);
3071     }
3072
3073     return 0;
3074 }
3075
3076 int radio::hangupForegroundResumeBackgroundResponse(int slotId, int responseType, int serial,
3077                                                     RIL_Errno e, void *response,
3078                                                     size_t responseLen) {
3079 #if VDBG
3080     RLOGD("hangupWaitingOrBackgroundResponse: serial %d", serial);
3081 #endif
3082
3083     if (radioService[slotId]->mRadioResponse != NULL) {
3084         RadioResponseInfo responseInfo = {};
3085         populateResponseInfo(responseInfo, serial, responseType, e);
3086         Return<void> retStatus =
3087                 radioService[slotId]->mRadioResponse->hangupWaitingOrBackgroundResponse(
3088                 responseInfo);
3089         radioService[slotId]->checkReturnStatus(retStatus);
3090     } else {
3091         RLOGE("hangupWaitingOrBackgroundResponse: radioService[%d]->mRadioResponse == NULL",
3092                 slotId);
3093     }
3094
3095     return 0;
3096 }
3097
3098 int radio::switchWaitingOrHoldingAndActiveResponse(int slotId, int responseType, int serial,
3099                                                    RIL_Errno e, void *response,
3100                                                    size_t responseLen) {
3101 #if VDBG
3102     RLOGD("switchWaitingOrHoldingAndActiveResponse: serial %d", serial);
3103 #endif
3104
3105     if (radioService[slotId]->mRadioResponse != NULL) {
3106         RadioResponseInfo responseInfo = {};
3107         populateResponseInfo(responseInfo, serial, responseType, e);
3108         Return<void> retStatus =
3109                 radioService[slotId]->mRadioResponse->switchWaitingOrHoldingAndActiveResponse(
3110                 responseInfo);
3111         radioService[slotId]->checkReturnStatus(retStatus);
3112     } else {
3113         RLOGE("switchWaitingOrHoldingAndActiveResponse: radioService[%d]->mRadioResponse "
3114                 "== NULL", slotId);
3115     }
3116
3117     return 0;
3118 }
3119
3120 int radio::conferenceResponse(int slotId, int responseType,
3121                              int serial, RIL_Errno e, void *response, size_t responseLen) {
3122 #if VDBG
3123     RLOGD("conferenceResponse: serial %d", serial);
3124 #endif
3125
3126     if (radioService[slotId]->mRadioResponse != NULL) {
3127         RadioResponseInfo responseInfo = {};
3128         populateResponseInfo(responseInfo, serial, responseType, e);
3129         Return<void> retStatus = radioService[slotId]->mRadioResponse->conferenceResponse(
3130                 responseInfo);
3131         radioService[slotId]->checkReturnStatus(retStatus);
3132     } else {
3133         RLOGE("conferenceResponse: radioService[%d]->mRadioResponse == NULL",
3134                 slotId);
3135     }
3136
3137     return 0;
3138 }
3139
3140 int radio::rejectCallResponse(int slotId, int responseType,
3141                              int serial, RIL_Errno e, void *response, size_t responseLen) {
3142 #if VDBG
3143     RLOGD("rejectCallResponse: serial %d", serial);
3144 #endif
3145
3146     if (radioService[slotId]->mRadioResponse != NULL) {
3147         RadioResponseInfo responseInfo = {};
3148         populateResponseInfo(responseInfo, serial, responseType, e);
3149         Return<void> retStatus = radioService[slotId]->mRadioResponse->rejectCallResponse(
3150                 responseInfo);
3151         radioService[slotId]->checkReturnStatus(retStatus);
3152     } else {
3153         RLOGE("rejectCallResponse: radioService[%d]->mRadioResponse == NULL",
3154                 slotId);
3155     }
3156
3157     return 0;
3158 }
3159
3160 int radio::getLastCallFailCauseResponse(int slotId,
3161                                        int responseType, int serial, RIL_Errno e, void *response,
3162                                        size_t responseLen) {
3163 #if VDBG
3164     RLOGD("getLastCallFailCauseResponse: serial %d", serial);
3165 #endif
3166
3167     if (radioService[slotId]->mRadioResponse != NULL) {
3168         RadioResponseInfo responseInfo = {};
3169         populateResponseInfo(responseInfo, serial, responseType, e);
3170
3171         LastCallFailCauseInfo info = {};
3172         info.vendorCause = hidl_string();
3173         if (response == NULL) {
3174             RLOGE("getCurrentCallsResponse Invalid response: NULL");
3175             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3176         } else if (responseLen == sizeof(int)) {
3177             int *pInt = (int *) response;
3178             info.causeCode = (LastCallFailCause) pInt[0];
3179         } else if (responseLen == sizeof(RIL_LastCallFailCauseInfo))  {
3180             RIL_LastCallFailCauseInfo *pFailCauseInfo = (RIL_LastCallFailCauseInfo *) response;
3181             info.causeCode = (LastCallFailCause) pFailCauseInfo->cause_code;
3182             info.vendorCause = convertCharPtrToHidlString(pFailCauseInfo->vendor_cause);
3183         } else {
3184             RLOGE("getCurrentCallsResponse Invalid response: NULL");
3185             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3186         }
3187
3188         Return<void> retStatus = radioService[slotId]->mRadioResponse->getLastCallFailCauseResponse(
3189                 responseInfo, info);
3190         radioService[slotId]->checkReturnStatus(retStatus);
3191     } else {
3192         RLOGE("getLastCallFailCauseResponse: radioService[%d]->mRadioResponse == NULL",
3193                 slotId);
3194     }
3195
3196     return 0;
3197 }
3198
3199 int radio::getSignalStrengthResponse(int slotId,
3200                                      int responseType, int serial, RIL_Errno e,
3201                                      void *response, size_t responseLen) {
3202 #if VDBG
3203     RLOGD("getSignalStrengthResponse: serial %d", serial);
3204 #endif
3205
3206     if (radioService[slotId]->mRadioResponse != NULL) {
3207         RadioResponseInfo responseInfo = {};
3208         populateResponseInfo(responseInfo, serial, responseType, e);
3209         SignalStrength signalStrength = {};
3210         if (response == NULL || responseLen != sizeof(RIL_SignalStrength_v10)) {
3211             RLOGE("getSignalStrengthResponse: Invalid response");
3212             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3213         } else {
3214             convertRilSignalStrengthToHal(response, responseLen, signalStrength);
3215         }
3216
3217         Return<void> retStatus = radioService[slotId]->mRadioResponse->getSignalStrengthResponse(
3218                 responseInfo, signalStrength);
3219         radioService[slotId]->checkReturnStatus(retStatus);
3220     } else {
3221         RLOGE("getSignalStrengthResponse: radioService[%d]->mRadioResponse == NULL",
3222                 slotId);
3223     }
3224
3225     return 0;
3226 }
3227
3228 RIL_CellInfoType getCellInfoTypeRadioTechnology(char *rat) {
3229     if (rat == NULL) {
3230         return RIL_CELL_INFO_TYPE_NONE;
3231     }
3232
3233     int radioTech = atoi(rat);
3234
3235     switch(radioTech) {
3236
3237         case RADIO_TECH_GPRS:
3238         case RADIO_TECH_EDGE:
3239         case RADIO_TECH_GSM: {
3240             return RIL_CELL_INFO_TYPE_GSM;
3241         }
3242
3243         case RADIO_TECH_UMTS:
3244         case RADIO_TECH_HSDPA:
3245         case RADIO_TECH_HSUPA:
3246         case RADIO_TECH_HSPA:
3247         case RADIO_TECH_HSPAP: {
3248             return RIL_CELL_INFO_TYPE_WCDMA;
3249         }
3250
3251         case RADIO_TECH_IS95A:
3252         case RADIO_TECH_IS95B:
3253         case RADIO_TECH_1xRTT:
3254         case RADIO_TECH_EVDO_0:
3255         case RADIO_TECH_EVDO_A:
3256         case RADIO_TECH_EVDO_B:
3257         case RADIO_TECH_EHRPD: {
3258             return RIL_CELL_INFO_TYPE_CDMA;
3259         }
3260
3261         case RADIO_TECH_LTE:
3262         case RADIO_TECH_LTE_CA: {
3263             return RIL_CELL_INFO_TYPE_LTE;
3264         }
3265
3266         case RADIO_TECH_TD_SCDMA: {
3267             return RIL_CELL_INFO_TYPE_TD_SCDMA;
3268         }
3269
3270         default: {
3271             break;
3272         }
3273     }
3274
3275     return RIL_CELL_INFO_TYPE_NONE;
3276
3277 }
3278
3279 void fillCellIdentityResponse(CellIdentity &cellIdentity, RIL_CellIdentity_v16 &rilCellIdentity) {
3280
3281     cellIdentity.cellIdentityGsm.resize(0);
3282     cellIdentity.cellIdentityWcdma.resize(0);
3283     cellIdentity.cellIdentityCdma.resize(0);
3284     cellIdentity.cellIdentityTdscdma.resize(0);
3285     cellIdentity.cellIdentityLte.resize(0);
3286     cellIdentity.cellInfoType = (CellInfoType)rilCellIdentity.cellInfoType;
3287     switch(rilCellIdentity.cellInfoType) {
3288
3289         case RIL_CELL_INFO_TYPE_GSM: {
3290             cellIdentity.cellIdentityGsm.resize(1);
3291             cellIdentity.cellIdentityGsm[0].mcc =
3292                     std::to_string(rilCellIdentity.cellIdentityGsm.mcc);
3293             cellIdentity.cellIdentityGsm[0].mnc =
3294                     std::to_string(rilCellIdentity.cellIdentityGsm.mnc);
3295             cellIdentity.cellIdentityGsm[0].lac = rilCellIdentity.cellIdentityGsm.lac;
3296             cellIdentity.cellIdentityGsm[0].cid = rilCellIdentity.cellIdentityGsm.cid;
3297             cellIdentity.cellIdentityGsm[0].arfcn = rilCellIdentity.cellIdentityGsm.arfcn;
3298             cellIdentity.cellIdentityGsm[0].bsic = rilCellIdentity.cellIdentityGsm.bsic;
3299             break;
3300         }
3301
3302         case RIL_CELL_INFO_TYPE_WCDMA: {
3303             cellIdentity.cellIdentityWcdma.resize(1);
3304             cellIdentity.cellIdentityWcdma[0].mcc =
3305                     std::to_string(rilCellIdentity.cellIdentityWcdma.mcc);
3306             cellIdentity.cellIdentityWcdma[0].mnc =
3307                     std::to_string(rilCellIdentity.cellIdentityWcdma.mnc);
3308             cellIdentity.cellIdentityWcdma[0].lac = rilCellIdentity.cellIdentityWcdma.lac;
3309             cellIdentity.cellIdentityWcdma[0].cid = rilCellIdentity.cellIdentityWcdma.cid;
3310             cellIdentity.cellIdentityWcdma[0].psc = rilCellIdentity.cellIdentityWcdma.psc;
3311             cellIdentity.cellIdentityWcdma[0].uarfcn = rilCellIdentity.cellIdentityWcdma.uarfcn;
3312             break;
3313         }
3314
3315         case RIL_CELL_INFO_TYPE_CDMA: {
3316             cellIdentity.cellIdentityCdma.resize(1);
3317             cellIdentity.cellIdentityCdma[0].networkId = rilCellIdentity.cellIdentityCdma.networkId;
3318             cellIdentity.cellIdentityCdma[0].systemId = rilCellIdentity.cellIdentityCdma.systemId;
3319             cellIdentity.cellIdentityCdma[0].baseStationId =
3320                     rilCellIdentity.cellIdentityCdma.basestationId;
3321             cellIdentity.cellIdentityCdma[0].longitude = rilCellIdentity.cellIdentityCdma.longitude;
3322             cellIdentity.cellIdentityCdma[0].latitude = rilCellIdentity.cellIdentityCdma.latitude;
3323             break;
3324         }
3325
3326         case RIL_CELL_INFO_TYPE_LTE: {
3327             cellIdentity.cellIdentityLte.resize(1);
3328             cellIdentity.cellIdentityLte[0].mcc =
3329                     std::to_string(rilCellIdentity.cellIdentityLte.mcc);
3330             cellIdentity.cellIdentityLte[0].mnc =
3331                     std::to_string(rilCellIdentity.cellIdentityLte.mnc);
3332             cellIdentity.cellIdentityLte[0].ci = rilCellIdentity.cellIdentityLte.ci;
3333             cellIdentity.cellIdentityLte[0].pci = rilCellIdentity.cellIdentityLte.pci;
3334             cellIdentity.cellIdentityLte[0].tac = rilCellIdentity.cellIdentityLte.tac;
3335             cellIdentity.cellIdentityLte[0].earfcn = rilCellIdentity.cellIdentityLte.earfcn;
3336             break;
3337         }
3338
3339         case RIL_CELL_INFO_TYPE_TD_SCDMA: {
3340             cellIdentity.cellIdentityTdscdma.resize(1);
3341             cellIdentity.cellIdentityTdscdma[0].mcc =
3342                     std::to_string(rilCellIdentity.cellIdentityTdscdma.mcc);
3343             cellIdentity.cellIdentityTdscdma[0].mnc =
3344                     std::to_string(rilCellIdentity.cellIdentityTdscdma.mnc);
3345             cellIdentity.cellIdentityTdscdma[0].lac = rilCellIdentity.cellIdentityTdscdma.lac;
3346             cellIdentity.cellIdentityTdscdma[0].cid = rilCellIdentity.cellIdentityTdscdma.cid;
3347             cellIdentity.cellIdentityTdscdma[0].cpid = rilCellIdentity.cellIdentityTdscdma.cpid;
3348             break;
3349         }
3350
3351         default: {
3352             break;
3353         }
3354     }
3355 }
3356
3357 int convertResponseStringEntryToInt(char **response, int index, int numStrings) {
3358     if ((response != NULL) &&  (numStrings > index) && (response[index] != NULL)) {
3359         return atoi(response[index]);
3360     }
3361
3362     return -1;
3363 }
3364
3365 void fillCellIdentityFromVoiceRegStateResponseString(CellIdentity &cellIdentity,
3366         int numStrings, char** response) {
3367
3368     RIL_CellIdentity_v16 rilCellIdentity;
3369     memset(&rilCellIdentity, -1, sizeof(RIL_CellIdentity_v16));
3370
3371     rilCellIdentity.cellInfoType = getCellInfoTypeRadioTechnology(response[3]);
3372     switch(rilCellIdentity.cellInfoType) {
3373
3374         case RIL_CELL_INFO_TYPE_GSM: {
3375             rilCellIdentity.cellIdentityGsm.lac =
3376                     convertResponseStringEntryToInt(response, 1, numStrings);
3377             rilCellIdentity.cellIdentityGsm.cid =
3378                     convertResponseStringEntryToInt(response, 2, numStrings);
3379             break;
3380         }
3381
3382         case RIL_CELL_INFO_TYPE_WCDMA: {
3383             rilCellIdentity.cellIdentityWcdma.lac =
3384                     convertResponseStringEntryToInt(response, 1, numStrings);
3385             rilCellIdentity.cellIdentityWcdma.cid =
3386                     convertResponseStringEntryToInt(response, 2, numStrings);
3387             rilCellIdentity.cellIdentityWcdma.psc =
3388                     convertResponseStringEntryToInt(response, 14, numStrings);
3389             break;
3390         }
3391
3392         case RIL_CELL_INFO_TYPE_TD_SCDMA:{
3393             rilCellIdentity.cellIdentityTdscdma.lac =
3394                     convertResponseStringEntryToInt(response, 1, numStrings);
3395             rilCellIdentity.cellIdentityTdscdma.cid =
3396                     convertResponseStringEntryToInt(response, 2, numStrings);
3397             break;
3398         }
3399
3400         case RIL_CELL_INFO_TYPE_CDMA:{
3401             rilCellIdentity.cellIdentityCdma.basestationId =
3402                     convertResponseStringEntryToInt(response, 4, numStrings);
3403             rilCellIdentity.cellIdentityCdma.longitude =
3404                     convertResponseStringEntryToInt(response, 5, numStrings);
3405             rilCellIdentity.cellIdentityCdma.latitude =
3406                     convertResponseStringEntryToInt(response, 6, numStrings);
3407             rilCellIdentity.cellIdentityCdma.systemId =
3408                     convertResponseStringEntryToInt(response, 8, numStrings);
3409             rilCellIdentity.cellIdentityCdma.networkId =
3410                     convertResponseStringEntryToInt(response, 9, numStrings);
3411             break;
3412         }
3413
3414         case RIL_CELL_INFO_TYPE_LTE:{
3415             rilCellIdentity.cellIdentityLte.tac =
3416                     convertResponseStringEntryToInt(response, 1, numStrings);
3417             rilCellIdentity.cellIdentityLte.ci =
3418                     convertResponseStringEntryToInt(response, 2, numStrings);
3419             break;
3420         }
3421
3422         default: {
3423             break;
3424         }
3425     }
3426
3427     fillCellIdentityResponse(cellIdentity, rilCellIdentity);
3428 }
3429
3430 void fillCellIdentityFromDataRegStateResponseString(CellIdentity &cellIdentity,
3431         int numStrings, char** response) {
3432
3433     RIL_CellIdentity_v16 rilCellIdentity;
3434     memset(&rilCellIdentity, -1, sizeof(RIL_CellIdentity_v16));
3435
3436     rilCellIdentity.cellInfoType = getCellInfoTypeRadioTechnology(response[3]);
3437     switch(rilCellIdentity.cellInfoType) {
3438         case RIL_CELL_INFO_TYPE_GSM: {
3439             rilCellIdentity.cellIdentityGsm.lac =
3440                     convertResponseStringEntryToInt(response, 1, numStrings);
3441             rilCellIdentity.cellIdentityGsm.cid =
3442                     convertResponseStringEntryToInt(response, 2, numStrings);
3443             break;
3444         }
3445         case RIL_CELL_INFO_TYPE_WCDMA: {
3446             rilCellIdentity.cellIdentityWcdma.lac =
3447                     convertResponseStringEntryToInt(response, 1, numStrings);
3448             rilCellIdentity.cellIdentityWcdma.cid =
3449                     convertResponseStringEntryToInt(response, 2, numStrings);
3450             break;
3451         }
3452         case RIL_CELL_INFO_TYPE_TD_SCDMA:{
3453             rilCellIdentity.cellIdentityTdscdma.lac =
3454                     convertResponseStringEntryToInt(response, 1, numStrings);
3455             rilCellIdentity.cellIdentityTdscdma.cid =
3456                     convertResponseStringEntryToInt(response, 2, numStrings);
3457             break;
3458         }
3459         case RIL_CELL_INFO_TYPE_LTE: {
3460             rilCellIdentity.cellIdentityLte.tac =
3461                     convertResponseStringEntryToInt(response, 6, numStrings);
3462             rilCellIdentity.cellIdentityLte.pci =
3463                     convertResponseStringEntryToInt(response, 7, numStrings);
3464             rilCellIdentity.cellIdentityLte.ci =
3465                     convertResponseStringEntryToInt(response, 8, numStrings);
3466             break;
3467         }
3468         default: {
3469             break;
3470         }
3471     }
3472
3473     fillCellIdentityResponse(cellIdentity, rilCellIdentity);
3474 }
3475
3476 int radio::getVoiceRegistrationStateResponse(int slotId,
3477                                             int responseType, int serial, RIL_Errno e,
3478                                             void *response, size_t responseLen) {
3479 #if VDBG
3480     RLOGD("getVoiceRegistrationStateResponse: serial %d", serial);
3481 #endif
3482
3483     if (radioService[slotId]->mRadioResponse != NULL) {
3484         RadioResponseInfo responseInfo = {};
3485         populateResponseInfo(responseInfo, serial, responseType, e);
3486
3487         VoiceRegStateResult voiceRegResponse = {};
3488         int numStrings = responseLen / sizeof(char *);
3489         if (response == NULL) {
3490                RLOGE("getVoiceRegistrationStateResponse Invalid response: NULL");
3491                if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3492         } else if (s_vendorFunctions->version <= 14) {
3493             if (numStrings != 15) {
3494                 RLOGE("getVoiceRegistrationStateResponse Invalid response: NULL");
3495                 if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3496             } else {
3497                 char **resp = (char **) response;
3498                 voiceRegResponse.regState = (RegState) ATOI_NULL_HANDLED_DEF(resp[0], 4);
3499                 voiceRegResponse.rat = ATOI_NULL_HANDLED(resp[3]);
3500                 voiceRegResponse.cssSupported = ATOI_NULL_HANDLED_DEF(resp[7], 0);
3501                 voiceRegResponse.roamingIndicator = ATOI_NULL_HANDLED(resp[10]);
3502                 voiceRegResponse.systemIsInPrl = ATOI_NULL_HANDLED_DEF(resp[11], 0);
3503                 voiceRegResponse.defaultRoamingIndicator = ATOI_NULL_HANDLED_DEF(resp[12], 0);
3504                 voiceRegResponse.reasonForDenial = ATOI_NULL_HANDLED_DEF(resp[13], 0);
3505                 fillCellIdentityFromVoiceRegStateResponseString(voiceRegResponse.cellIdentity,
3506                         numStrings, resp);
3507             }
3508         } else {
3509             RIL_VoiceRegistrationStateResponse *voiceRegState =
3510                     (RIL_VoiceRegistrationStateResponse *)response;
3511
3512             if (responseLen != sizeof(RIL_VoiceRegistrationStateResponse)) {
3513                 RLOGE("getVoiceRegistrationStateResponse Invalid response: NULL");
3514                 if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3515             } else {
3516                 voiceRegResponse.regState = (RegState) voiceRegState->regState;
3517                 voiceRegResponse.rat = voiceRegState->rat;;
3518                 voiceRegResponse.cssSupported = voiceRegState->cssSupported;
3519                 voiceRegResponse.roamingIndicator = voiceRegState->roamingIndicator;
3520                 voiceRegResponse.systemIsInPrl = voiceRegState->systemIsInPrl;
3521                 voiceRegResponse.defaultRoamingIndicator = voiceRegState->defaultRoamingIndicator;
3522                 voiceRegResponse.reasonForDenial = voiceRegState->reasonForDenial;
3523                 fillCellIdentityResponse(voiceRegResponse.cellIdentity,
3524                         voiceRegState->cellIdentity);
3525             }
3526         }
3527
3528         Return<void> retStatus =
3529                 radioService[slotId]->mRadioResponse->getVoiceRegistrationStateResponse(
3530                 responseInfo, voiceRegResponse);
3531         radioService[slotId]->checkReturnStatus(retStatus);
3532     } else {
3533         RLOGE("getVoiceRegistrationStateResponse: radioService[%d]->mRadioResponse == NULL",
3534                 slotId);
3535     }
3536
3537     return 0;
3538 }
3539
3540 int radio::getDataRegistrationStateResponse(int slotId,
3541                                            int responseType, int serial, RIL_Errno e,
3542                                            void *response, size_t responseLen) {
3543 #if VDBG
3544     RLOGD("getDataRegistrationStateResponse: serial %d", serial);
3545 #endif
3546
3547     if (radioService[slotId]->mRadioResponse != NULL) {
3548         RadioResponseInfo responseInfo = {};
3549         populateResponseInfo(responseInfo, serial, responseType, e);
3550         DataRegStateResult dataRegResponse = {};
3551         if (response == NULL) {
3552             RLOGE("getDataRegistrationStateResponse Invalid response: NULL");
3553             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3554         } else if (s_vendorFunctions->version <= 14) {
3555             int numStrings = responseLen / sizeof(char *);
3556             if ((numStrings != 6) && (numStrings != 11)) {
3557                 RLOGE("getDataRegistrationStateResponse Invalid response: NULL");
3558                 if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3559             } else {
3560                 char **resp = (char **) response;
3561                 dataRegResponse.regState = (RegState) ATOI_NULL_HANDLED_DEF(resp[0], 4);
3562                 dataRegResponse.rat =  ATOI_NULL_HANDLED_DEF(resp[3], 0);
3563                 dataRegResponse.reasonDataDenied =  ATOI_NULL_HANDLED(resp[4]);
3564                 dataRegResponse.maxDataCalls =  ATOI_NULL_HANDLED_DEF(resp[5], 1);
3565                 fillCellIdentityFromDataRegStateResponseString(dataRegResponse.cellIdentity,
3566                         numStrings, resp);
3567             }
3568         } else {
3569             RIL_DataRegistrationStateResponse *dataRegState =
3570                     (RIL_DataRegistrationStateResponse *)response;
3571
3572             if (responseLen != sizeof(RIL_DataRegistrationStateResponse)) {
3573                 RLOGE("getDataRegistrationStateResponse Invalid response: NULL");
3574                 if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3575             } else {
3576                 dataRegResponse.regState = (RegState) dataRegState->regState;
3577                 dataRegResponse.rat = dataRegState->rat;;
3578                 dataRegResponse.reasonDataDenied = dataRegState->reasonDataDenied;
3579                 dataRegResponse.maxDataCalls = dataRegState->maxDataCalls;
3580                 fillCellIdentityResponse(dataRegResponse.cellIdentity, dataRegState->cellIdentity);
3581             }
3582         }
3583
3584         Return<void> retStatus =
3585                 radioService[slotId]->mRadioResponse->getDataRegistrationStateResponse(responseInfo,
3586                 dataRegResponse);
3587         radioService[slotId]->checkReturnStatus(retStatus);
3588     } else {
3589         RLOGE("getDataRegistrationStateResponse: radioService[%d]->mRadioResponse == NULL",
3590                 slotId);
3591     }
3592
3593     return 0;
3594 }
3595
3596 int radio::getOperatorResponse(int slotId,
3597                               int responseType, int serial, RIL_Errno e, void *response,
3598                               size_t responseLen) {
3599 #if VDBG
3600     RLOGD("getOperatorResponse: serial %d", serial);
3601 #endif
3602
3603     if (radioService[slotId]->mRadioResponse != NULL) {
3604         RadioResponseInfo responseInfo = {};
3605         populateResponseInfo(responseInfo, serial, responseType, e);
3606         hidl_string longName;
3607         hidl_string shortName;
3608         hidl_string numeric;
3609         int numStrings = responseLen / sizeof(char *);
3610         if (response == NULL || numStrings != 3) {
3611             RLOGE("getOperatorResponse Invalid response: NULL");
3612             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3613
3614         } else {
3615             char **resp = (char **) response;
3616             longName = convertCharPtrToHidlString(resp[0]);
3617             shortName = convertCharPtrToHidlString(resp[1]);
3618             numeric = convertCharPtrToHidlString(resp[2]);
3619         }
3620         Return<void> retStatus = radioService[slotId]->mRadioResponse->getOperatorResponse(
3621                 responseInfo, longName, shortName, numeric);
3622         radioService[slotId]->checkReturnStatus(retStatus);
3623     } else {
3624         RLOGE("getOperatorResponse: radioService[%d]->mRadioResponse == NULL",
3625                 slotId);
3626     }
3627
3628     return 0;
3629 }
3630
3631 int radio::setRadioPowerResponse(int slotId,
3632                                 int responseType, int serial, RIL_Errno e, void *response,
3633                                 size_t responseLen) {
3634     RLOGD("setRadioPowerResponse: serial %d", serial);
3635
3636     if (radioService[slotId]->mRadioResponse != NULL) {
3637         RadioResponseInfo responseInfo = {};
3638         populateResponseInfo(responseInfo, serial, responseType, e);
3639         Return<void> retStatus = radioService[slotId]->mRadioResponse->setRadioPowerResponse(
3640                 responseInfo);
3641         radioService[slotId]->checkReturnStatus(retStatus);
3642     } else {
3643         RLOGE("setRadioPowerResponse: radioService[%d]->mRadioResponse == NULL",
3644                 slotId);
3645     }
3646
3647     return 0;
3648 }
3649
3650 int radio::sendDtmfResponse(int slotId,
3651                            int responseType, int serial, RIL_Errno e, void *response,
3652                            size_t responseLen) {
3653 #if VDBG
3654     RLOGD("sendDtmfResponse: serial %d", serial);
3655 #endif
3656
3657     if (radioService[slotId]->mRadioResponse != NULL) {
3658         RadioResponseInfo responseInfo = {};
3659         populateResponseInfo(responseInfo, serial, responseType, e);
3660         Return<void> retStatus = radioService[slotId]->mRadioResponse->sendDtmfResponse(
3661                 responseInfo);
3662         radioService[slotId]->checkReturnStatus(retStatus);
3663     } else {
3664         RLOGE("sendDtmfResponse: radioService[%d]->mRadioResponse == NULL",
3665                 slotId);
3666     }
3667
3668     return 0;
3669 }
3670
3671 SendSmsResult makeSendSmsResult(RadioResponseInfo& responseInfo, int serial, int responseType,
3672                                 RIL_Errno e, void *response, size_t responseLen) {
3673     populateResponseInfo(responseInfo, serial, responseType, e);
3674     SendSmsResult result = {};
3675
3676     if (response == NULL || responseLen != sizeof(RIL_SMS_Response)) {
3677         RLOGE("Invalid response: NULL");
3678         if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3679         result.ackPDU = hidl_string();
3680     } else {
3681         RIL_SMS_Response *resp = (RIL_SMS_Response *) response;
3682         result.messageRef = resp->messageRef;
3683         result.ackPDU = convertCharPtrToHidlString(resp->ackPDU);
3684         result.errorCode = resp->errorCode;
3685     }
3686     return result;
3687 }
3688
3689 int radio::sendSmsResponse(int slotId,
3690                           int responseType, int serial, RIL_Errno e, void *response,
3691                           size_t responseLen) {
3692 #if VDBG
3693     RLOGD("sendSmsResponse: serial %d", serial);
3694 #endif
3695
3696     if (radioService[slotId]->mRadioResponse != NULL) {
3697         RadioResponseInfo responseInfo = {};
3698         SendSmsResult result = makeSendSmsResult(responseInfo, serial, responseType, e, response,
3699                 responseLen);
3700
3701         Return<void> retStatus = radioService[slotId]->mRadioResponse->sendSmsResponse(responseInfo,
3702                 result);
3703         radioService[slotId]->checkReturnStatus(retStatus);
3704     } else {
3705         RLOGE("sendSmsResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3706     }
3707
3708     return 0;
3709 }
3710
3711 int radio::sendSMSExpectMoreResponse(int slotId,
3712                                     int responseType, int serial, RIL_Errno e, void *response,
3713                                     size_t responseLen) {
3714 #if VDBG
3715     RLOGD("sendSMSExpectMoreResponse: serial %d", serial);
3716 #endif
3717
3718     if (radioService[slotId]->mRadioResponse != NULL) {
3719         RadioResponseInfo responseInfo = {};
3720         SendSmsResult result = makeSendSmsResult(responseInfo, serial, responseType, e, response,
3721                 responseLen);
3722
3723         Return<void> retStatus = radioService[slotId]->mRadioResponse->sendSMSExpectMoreResponse(
3724                 responseInfo, result);
3725         radioService[slotId]->checkReturnStatus(retStatus);
3726     } else {
3727         RLOGE("sendSMSExpectMoreResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3728     }
3729
3730     return 0;
3731 }
3732
3733 int radio::setupDataCallResponse(int slotId,
3734                                  int responseType, int serial, RIL_Errno e, void *response,
3735                                  size_t responseLen) {
3736 #if VDBG
3737     RLOGD("setupDataCallResponse: serial %d", serial);
3738 #endif
3739
3740     if (radioService[slotId]->mRadioResponse != NULL) {
3741         RadioResponseInfo responseInfo = {};
3742         populateResponseInfo(responseInfo, serial, responseType, e);
3743
3744         SetupDataCallResult result = {};
3745         if (response == NULL || responseLen != sizeof(RIL_Data_Call_Response_v11)) {
3746             RLOGE("setupDataCallResponse: Invalid response");
3747             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3748             result.status = DataCallFailCause::ERROR_UNSPECIFIED;
3749             result.type = hidl_string();
3750             result.ifname = hidl_string();
3751             result.addresses = hidl_string();
3752             result.dnses = hidl_string();
3753             result.gateways = hidl_string();
3754             result.pcscf = hidl_string();
3755         } else {
3756             convertRilDataCallToHal((RIL_Data_Call_Response_v11 *) response, result);
3757         }
3758
3759         Return<void> retStatus = radioService[slotId]->mRadioResponse->setupDataCallResponse(
3760                 responseInfo, result);
3761         radioService[slotId]->checkReturnStatus(retStatus);
3762     } else {
3763         RLOGE("setupDataCallResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3764     }
3765
3766     return 0;
3767 }
3768
3769 IccIoResult responseIccIo(RadioResponseInfo& responseInfo, int serial, int responseType,
3770                            RIL_Errno e, void *response, size_t responseLen) {
3771     populateResponseInfo(responseInfo, serial, responseType, e);
3772     IccIoResult result = {};
3773
3774     if (response == NULL || responseLen != sizeof(RIL_SIM_IO_Response)) {
3775         RLOGE("Invalid response: NULL");
3776         if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3777         result.simResponse = hidl_string();
3778     } else {
3779         RIL_SIM_IO_Response *resp = (RIL_SIM_IO_Response *) response;
3780         result.sw1 = resp->sw1;
3781         result.sw2 = resp->sw2;
3782         result.simResponse = convertCharPtrToHidlString(resp->simResponse);
3783     }
3784     return result;
3785 }
3786
3787 int radio::iccIOForAppResponse(int slotId,
3788                       int responseType, int serial, RIL_Errno e, void *response,
3789                       size_t responseLen) {
3790 #if VDBG
3791     RLOGD("iccIOForAppResponse: serial %d", serial);
3792 #endif
3793
3794     if (radioService[slotId]->mRadioResponse != NULL) {
3795         RadioResponseInfo responseInfo = {};
3796         IccIoResult result = responseIccIo(responseInfo, serial, responseType, e, response,
3797                 responseLen);
3798
3799         Return<void> retStatus = radioService[slotId]->mRadioResponse->iccIOForAppResponse(
3800                 responseInfo, result);
3801         radioService[slotId]->checkReturnStatus(retStatus);
3802     } else {
3803         RLOGE("iccIOForAppResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3804     }
3805
3806     return 0;
3807 }
3808
3809 int radio::sendUssdResponse(int slotId,
3810                            int responseType, int serial, RIL_Errno e, void *response,
3811                            size_t responseLen) {
3812 #if VDBG
3813     RLOGD("sendUssdResponse: serial %d", serial);
3814 #endif
3815
3816     if (radioService[slotId]->mRadioResponse != NULL) {
3817         RadioResponseInfo responseInfo = {};
3818         populateResponseInfo(responseInfo, serial, responseType, e);
3819         Return<void> retStatus = radioService[slotId]->mRadioResponse->sendUssdResponse(
3820                 responseInfo);
3821         radioService[slotId]->checkReturnStatus(retStatus);
3822     } else {
3823         RLOGE("sendUssdResponse: radioService[%d]->mRadioResponse == NULL",
3824                 slotId);
3825     }
3826
3827     return 0;
3828 }
3829
3830 int radio::cancelPendingUssdResponse(int slotId,
3831                                     int responseType, int serial, RIL_Errno e, void *response,
3832                                     size_t responseLen) {
3833 #if VDBG
3834     RLOGD("cancelPendingUssdResponse: serial %d", serial);
3835 #endif
3836
3837     if (radioService[slotId]->mRadioResponse != NULL) {
3838         RadioResponseInfo responseInfo = {};
3839         populateResponseInfo(responseInfo, serial, responseType, e);
3840         Return<void> retStatus = radioService[slotId]->mRadioResponse->cancelPendingUssdResponse(
3841                 responseInfo);
3842         radioService[slotId]->checkReturnStatus(retStatus);
3843     } else {
3844         RLOGE("cancelPendingUssdResponse: radioService[%d]->mRadioResponse == NULL",
3845                 slotId);
3846     }
3847
3848     return 0;
3849 }
3850
3851 int radio::getClirResponse(int slotId,
3852                               int responseType, int serial, RIL_Errno e, void *response,
3853                               size_t responseLen) {
3854 #if VDBG
3855     RLOGD("getClirResponse: serial %d", serial);
3856 #endif
3857
3858     if (radioService[slotId]->mRadioResponse != NULL) {
3859         RadioResponseInfo responseInfo = {};
3860         populateResponseInfo(responseInfo, serial, responseType, e);
3861         int n = -1, m = -1;
3862         int numInts = responseLen / sizeof(int);
3863         if (response == NULL || numInts != 2) {
3864             RLOGE("getClirResponse Invalid response: NULL");
3865             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3866         } else {
3867             int *pInt = (int *) response;
3868             n = pInt[0];
3869             m = pInt[1];
3870         }
3871         Return<void> retStatus = radioService[slotId]->mRadioResponse->getClirResponse(responseInfo,
3872                 n, m);
3873         radioService[slotId]->checkReturnStatus(retStatus);
3874     } else {
3875         RLOGE("getClirResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3876     }
3877
3878     return 0;
3879 }
3880
3881 int radio::setClirResponse(int slotId,
3882                           int responseType, int serial, RIL_Errno e, void *response,
3883                           size_t responseLen) {
3884 #if VDBG
3885     RLOGD("setClirResponse: serial %d", serial);
3886 #endif
3887
3888     if (radioService[slotId]->mRadioResponse != NULL) {
3889         RadioResponseInfo responseInfo = {};
3890         populateResponseInfo(responseInfo, serial, responseType, e);
3891         Return<void> retStatus = radioService[slotId]->mRadioResponse->setClirResponse(
3892                 responseInfo);
3893         radioService[slotId]->checkReturnStatus(retStatus);
3894     } else {
3895         RLOGE("setClirResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3896     }
3897
3898     return 0;
3899 }
3900
3901 int radio::getCallForwardStatusResponse(int slotId,
3902                                        int responseType, int serial, RIL_Errno e,
3903                                        void *response, size_t responseLen) {
3904 #if VDBG
3905     RLOGD("getCallForwardStatusResponse: serial %d", serial);
3906 #endif
3907
3908     if (radioService[slotId]->mRadioResponse != NULL) {
3909         RadioResponseInfo responseInfo = {};
3910         populateResponseInfo(responseInfo, serial, responseType, e);
3911         hidl_vec<CallForwardInfo> callForwardInfos;
3912
3913         if (response == NULL || responseLen % sizeof(RIL_CallForwardInfo *) != 0) {
3914             RLOGE("getCallForwardStatusResponse Invalid response: NULL");
3915             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3916         } else {
3917             int num = responseLen / sizeof(RIL_CallForwardInfo *);
3918             callForwardInfos.resize(num);
3919             for (int i = 0 ; i < num; i++) {
3920                 RIL_CallForwardInfo *resp = ((RIL_CallForwardInfo **) response)[i];
3921                 callForwardInfos[i].status = (CallForwardInfoStatus) resp->status;
3922                 callForwardInfos[i].reason = resp->reason;
3923                 callForwardInfos[i].serviceClass = resp->serviceClass;
3924                 callForwardInfos[i].toa = resp->toa;
3925                 callForwardInfos[i].number = convertCharPtrToHidlString(resp->number);
3926                 callForwardInfos[i].timeSeconds = resp->timeSeconds;
3927             }
3928         }
3929
3930         Return<void> retStatus = radioService[slotId]->mRadioResponse->getCallForwardStatusResponse(
3931                 responseInfo, callForwardInfos);
3932         radioService[slotId]->checkReturnStatus(retStatus);
3933     } else {
3934         RLOGE("getCallForwardStatusResponse: radioService[%d]->mRadioResponse == NULL",
3935                 slotId);
3936     }
3937
3938     return 0;
3939 }
3940
3941 int radio::setCallForwardResponse(int slotId,
3942                                  int responseType, int serial, RIL_Errno e, void *response,
3943                                  size_t responseLen) {
3944 #if VDBG
3945     RLOGD("setCallForwardResponse: serial %d", serial);
3946 #endif
3947
3948     if (radioService[slotId]->mRadioResponse != NULL) {
3949         RadioResponseInfo responseInfo = {};
3950         populateResponseInfo(responseInfo, serial, responseType, e);
3951         Return<void> retStatus = radioService[slotId]->mRadioResponse->setCallForwardResponse(
3952                 responseInfo);
3953         radioService[slotId]->checkReturnStatus(retStatus);
3954     } else {
3955         RLOGE("setCallForwardResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3956     }
3957
3958     return 0;
3959 }
3960
3961 int radio::getCallWaitingResponse(int slotId,
3962                                  int responseType, int serial, RIL_Errno e, void *response,
3963                                  size_t responseLen) {
3964 #if VDBG
3965     RLOGD("getCallWaitingResponse: serial %d", serial);
3966 #endif
3967
3968     if (radioService[slotId]->mRadioResponse != NULL) {
3969         RadioResponseInfo responseInfo = {};
3970         populateResponseInfo(responseInfo, serial, responseType, e);
3971         bool enable = false;
3972         int serviceClass = -1;
3973         int numInts = responseLen / sizeof(int);
3974         if (response == NULL || numInts != 2) {
3975             RLOGE("getCallWaitingResponse Invalid response: NULL");
3976             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3977         } else {
3978             int *pInt = (int *) response;
3979             enable = pInt[0] == 1 ? true : false;
3980             serviceClass = pInt[1];
3981         }
3982         Return<void> retStatus = radioService[slotId]->mRadioResponse->getCallWaitingResponse(
3983                 responseInfo, enable, serviceClass);
3984         radioService[slotId]->checkReturnStatus(retStatus);
3985     } else {
3986         RLOGE("getCallWaitingResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3987     }
3988
3989     return 0;
3990 }
3991
3992 int radio::setCallWaitingResponse(int slotId,
3993                                  int responseType, int serial, RIL_Errno e, void *response,
3994                                  size_t responseLen) {
3995 #if VDBG
3996     RLOGD("setCallWaitingResponse: serial %d", serial);
3997 #endif
3998
3999     if (radioService[slotId]->mRadioResponse != NULL) {
4000         RadioResponseInfo responseInfo = {};
4001         populateResponseInfo(responseInfo, serial, responseType, e);
4002         Return<void> retStatus = radioService[slotId]->mRadioResponse->setCallWaitingResponse(
4003                 responseInfo);
4004         radioService[slotId]->checkReturnStatus(retStatus);
4005     } else {
4006         RLOGE("setCallWaitingResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4007     }
4008
4009     return 0;
4010 }
4011
4012 int radio::acknowledgeLastIncomingGsmSmsResponse(int slotId,
4013                                                 int responseType, int serial, RIL_Errno e,
4014                                                 void *response, size_t responseLen) {
4015 #if VDBG
4016     RLOGD("acknowledgeLastIncomingGsmSmsResponse: serial %d", serial);
4017 #endif
4018
4019     if (radioService[slotId]->mRadioResponse != NULL) {
4020         RadioResponseInfo responseInfo = {};
4021         populateResponseInfo(responseInfo, serial, responseType, e);
4022         Return<void> retStatus =
4023                 radioService[slotId]->mRadioResponse->acknowledgeLastIncomingGsmSmsResponse(
4024                 responseInfo);
4025         radioService[slotId]->checkReturnStatus(retStatus);
4026     } else {
4027         RLOGE("acknowledgeLastIncomingGsmSmsResponse: radioService[%d]->mRadioResponse "
4028                 "== NULL", slotId);
4029     }
4030
4031     return 0;
4032 }
4033
4034 int radio::acceptCallResponse(int slotId,
4035                              int responseType, int serial, RIL_Errno e,
4036                              void *response, size_t responseLen) {
4037 #if VDBG
4038     RLOGD("acceptCallResponse: serial %d", serial);
4039 #endif
4040
4041     if (radioService[slotId]->mRadioResponse != NULL) {
4042         RadioResponseInfo responseInfo = {};
4043         populateResponseInfo(responseInfo, serial, responseType, e);
4044         Return<void> retStatus = radioService[slotId]->mRadioResponse->acceptCallResponse(
4045                 responseInfo);
4046         radioService[slotId]->checkReturnStatus(retStatus);
4047     } else {
4048         RLOGE("acceptCallResponse: radioService[%d]->mRadioResponse == NULL",
4049                 slotId);
4050     }
4051
4052     return 0;
4053 }
4054
4055 int radio::deactivateDataCallResponse(int slotId,
4056                                                 int responseType, int serial, RIL_Errno e,
4057                                                 void *response, size_t responseLen) {
4058 #if VDBG
4059     RLOGD("deactivateDataCallResponse: serial %d", serial);
4060 #endif
4061
4062     if (radioService[slotId]->mRadioResponse != NULL) {
4063         RadioResponseInfo responseInfo = {};
4064         populateResponseInfo(responseInfo, serial, responseType, e);
4065         Return<void> retStatus = radioService[slotId]->mRadioResponse->deactivateDataCallResponse(
4066                 responseInfo);
4067         radioService[slotId]->checkReturnStatus(retStatus);
4068     } else {
4069         RLOGE("deactivateDataCallResponse: radioService[%d]->mRadioResponse == NULL",
4070                 slotId);
4071     }
4072
4073     return 0;
4074 }
4075
4076 int radio::getFacilityLockForAppResponse(int slotId,
4077                                         int responseType, int serial, RIL_Errno e,
4078                                         void *response, size_t responseLen) {
4079 #if VDBG
4080     RLOGD("getFacilityLockForAppResponse: serial %d", serial);
4081 #endif
4082
4083     if (radioService[slotId]->mRadioResponse != NULL) {
4084         RadioResponseInfo responseInfo = {};
4085         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
4086         Return<void> retStatus = radioService[slotId]->mRadioResponse->
4087                 getFacilityLockForAppResponse(responseInfo, ret);
4088         radioService[slotId]->checkReturnStatus(retStatus);
4089     } else {
4090         RLOGE("getFacilityLockForAppResponse: radioService[%d]->mRadioResponse == NULL",
4091                 slotId);
4092     }
4093
4094     return 0;
4095 }
4096
4097 int radio::setFacilityLockForAppResponse(int slotId,
4098                                       int responseType, int serial, RIL_Errno e,
4099                                       void *response, size_t responseLen) {
4100 #if VDBG
4101     RLOGD("setFacilityLockForAppResponse: serial %d", serial);
4102 #endif
4103
4104     if (radioService[slotId]->mRadioResponse != NULL) {
4105         RadioResponseInfo responseInfo = {};
4106         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
4107         Return<void> retStatus
4108                 = radioService[slotId]->mRadioResponse->setFacilityLockForAppResponse(responseInfo,
4109                 ret);
4110         radioService[slotId]->checkReturnStatus(retStatus);
4111     } else {
4112         RLOGE("setFacilityLockForAppResponse: radioService[%d]->mRadioResponse == NULL",
4113                 slotId);
4114     }
4115
4116     return 0;
4117 }
4118
4119 int radio::setBarringPasswordResponse(int slotId,
4120                              int responseType, int serial, RIL_Errno e,
4121                              void *response, size_t responseLen) {
4122 #if VDBG
4123     RLOGD("acceptCallResponse: serial %d", serial);
4124 #endif
4125
4126     if (radioService[slotId]->mRadioResponse != NULL) {
4127         RadioResponseInfo responseInfo = {};
4128         populateResponseInfo(responseInfo, serial, responseType, e);
4129         Return<void> retStatus
4130                 = radioService[slotId]->mRadioResponse->setBarringPasswordResponse(responseInfo);
4131         radioService[slotId]->checkReturnStatus(retStatus);
4132     } else {
4133         RLOGE("setBarringPasswordResponse: radioService[%d]->mRadioResponse == NULL",
4134                 slotId);
4135     }
4136
4137     return 0;
4138 }
4139
4140 int radio::getNetworkSelectionModeResponse(int slotId,
4141                                           int responseType, int serial, RIL_Errno e, void *response,
4142                                           size_t responseLen) {
4143 #if VDBG
4144     RLOGD("getNetworkSelectionModeResponse: serial %d", serial);
4145 #endif
4146
4147     if (radioService[slotId]->mRadioResponse != NULL) {
4148         RadioResponseInfo responseInfo = {};
4149         populateResponseInfo(responseInfo, serial, responseType, e);
4150         bool manual = false;
4151         int serviceClass;
4152         if (response == NULL || responseLen != sizeof(int)) {
4153             RLOGE("getNetworkSelectionModeResponse Invalid response: NULL");
4154             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4155         } else {
4156             int *pInt = (int *) response;
4157             manual = pInt[0] == 1 ? true : false;
4158         }
4159         Return<void> retStatus
4160                 = radioService[slotId]->mRadioResponse->getNetworkSelectionModeResponse(
4161                 responseInfo,
4162                 manual);
4163         radioService[slotId]->checkReturnStatus(retStatus);
4164     } else {
4165         RLOGE("getNetworkSelectionModeResponse: radioService[%d]->mRadioResponse == NULL",
4166                 slotId);
4167     }
4168
4169     return 0;
4170 }
4171
4172 int radio::setNetworkSelectionModeAutomaticResponse(int slotId, int responseType, int serial,
4173                                                     RIL_Errno e, void *response,
4174                                                     size_t responseLen) {
4175 #if VDBG
4176     RLOGD("setNetworkSelectionModeAutomaticResponse: serial %d", serial);
4177 #endif
4178
4179     if (radioService[slotId]->mRadioResponse != NULL) {
4180         RadioResponseInfo responseInfo = {};
4181         populateResponseInfo(responseInfo, serial, responseType, e);
4182         Return<void> retStatus
4183                 = radioService[slotId]->mRadioResponse->setNetworkSelectionModeAutomaticResponse(
4184                 responseInfo);
4185         radioService[slotId]->checkReturnStatus(retStatus);
4186     } else {
4187         RLOGE("setNetworkSelectionModeAutomaticResponse: radioService[%d]->mRadioResponse "
4188                 "== NULL", slotId);
4189     }
4190
4191     return 0;
4192 }
4193
4194 int radio::setNetworkSelectionModeManualResponse(int slotId,
4195                              int responseType, int serial, RIL_Errno e,
4196                              void *response, size_t responseLen) {
4197 #if VDBG
4198     RLOGD("setNetworkSelectionModeManualResponse: serial %d", serial);
4199 #endif
4200
4201     if (radioService[slotId]->mRadioResponse != NULL) {
4202         RadioResponseInfo responseInfo = {};
4203         populateResponseInfo(responseInfo, serial, responseType, e);
4204         Return<void> retStatus
4205                 = radioService[slotId]->mRadioResponse->setNetworkSelectionModeManualResponse(
4206                 responseInfo);
4207         radioService[slotId]->checkReturnStatus(retStatus);
4208     } else {
4209         RLOGE("acceptCallResponse: radioService[%d]->setNetworkSelectionModeManualResponse "
4210                 "== NULL", slotId);
4211     }
4212
4213     return 0;
4214 }
4215
4216 int convertOperatorStatusToInt(const char *str) {
4217     if (strncmp("unknown", str, 9) == 0) {
4218         return (int) OperatorStatus::UNKNOWN;
4219     } else if (strncmp("available", str, 9) == 0) {
4220         return (int) OperatorStatus::AVAILABLE;
4221     } else if (strncmp("current", str, 9) == 0) {
4222         return (int) OperatorStatus::CURRENT;
4223     } else if (strncmp("forbidden", str, 9) == 0) {
4224         return (int) OperatorStatus::FORBIDDEN;
4225     } else {
4226         return -1;
4227     }
4228 }
4229
4230 int radio::getAvailableNetworksResponse(int slotId,
4231                               int responseType, int serial, RIL_Errno e, void *response,
4232                               size_t responseLen) {
4233 #if VDBG
4234     RLOGD("getAvailableNetworksResponse: serial %d", serial);
4235 #endif
4236
4237     if (radioService[slotId]->mRadioResponse != NULL) {
4238         RadioResponseInfo responseInfo = {};
4239         populateResponseInfo(responseInfo, serial, responseType, e);
4240         hidl_vec<OperatorInfo> networks;
4241         if (response == NULL || responseLen % (4 * sizeof(char *))!= 0) {
4242             RLOGE("getAvailableNetworksResponse Invalid response: NULL");
4243             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4244         } else {
4245             char **resp = (char **) response;
4246             int numStrings = responseLen / sizeof(char *);
4247             networks.resize(numStrings/4);
4248             for (int i = 0, j = 0; i < numStrings; i = i + 4, j++) {
4249                 networks[j].alphaLong = convertCharPtrToHidlString(resp[i]);
4250                 networks[j].alphaShort = convertCharPtrToHidlString(resp[i + 1]);
4251                 networks[j].operatorNumeric = convertCharPtrToHidlString(resp[i + 2]);
4252                 int status = convertOperatorStatusToInt(resp[i + 3]);
4253                 if (status == -1) {
4254                     if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4255                 } else {
4256                     networks[j].status = (OperatorStatus) status;
4257                 }
4258             }
4259         }
4260         Return<void> retStatus
4261                 = radioService[slotId]->mRadioResponse->getAvailableNetworksResponse(responseInfo,
4262                 networks);
4263         radioService[slotId]->checkReturnStatus(retStatus);
4264     } else {
4265         RLOGE("getAvailableNetworksResponse: radioService[%d]->mRadioResponse == NULL",
4266                 slotId);
4267     }
4268
4269     return 0;
4270 }
4271
4272 int radio::startDtmfResponse(int slotId,
4273                             int responseType, int serial, RIL_Errno e,
4274                             void *response, size_t responseLen) {
4275 #if VDBG
4276     RLOGD("startDtmfResponse: serial %d", serial);
4277 #endif
4278
4279     if (radioService[slotId]->mRadioResponse != NULL) {
4280         RadioResponseInfo responseInfo = {};
4281         populateResponseInfo(responseInfo, serial, responseType, e);
4282         Return<void> retStatus
4283                 = radioService[slotId]->mRadioResponse->startDtmfResponse(responseInfo);
4284         radioService[slotId]->checkReturnStatus(retStatus);
4285     } else {
4286         RLOGE("startDtmfResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4287     }
4288
4289     return 0;
4290 }
4291
4292 int radio::stopDtmfResponse(int slotId,
4293                            int responseType, int serial, RIL_Errno e,
4294                            void *response, size_t responseLen) {
4295 #if VDBG
4296     RLOGD("stopDtmfResponse: serial %d", serial);
4297 #endif
4298
4299     if (radioService[slotId]->mRadioResponse != NULL) {
4300         RadioResponseInfo responseInfo = {};
4301         populateResponseInfo(responseInfo, serial, responseType, e);
4302         Return<void> retStatus
4303                 = radioService[slotId]->mRadioResponse->stopDtmfResponse(responseInfo);
4304         radioService[slotId]->checkReturnStatus(retStatus);
4305     } else {
4306         RLOGE("stopDtmfResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4307     }
4308
4309     return 0;
4310 }
4311
4312 int radio::getBasebandVersionResponse(int slotId,
4313                                      int responseType, int serial, RIL_Errno e,
4314                                      void *response, size_t responseLen) {
4315 #if VDBG
4316     RLOGD("getBasebandVersionResponse: serial %d", serial);
4317 #endif
4318
4319     if (radioService[slotId]->mRadioResponse != NULL) {
4320         RadioResponseInfo responseInfo = {};
4321         populateResponseInfo(responseInfo, serial, responseType, e);
4322         Return<void> retStatus
4323                 = radioService[slotId]->mRadioResponse->getBasebandVersionResponse(responseInfo,
4324                 convertCharPtrToHidlString((char *) response));
4325         radioService[slotId]->checkReturnStatus(retStatus);
4326     } else {
4327         RLOGE("getBasebandVersionResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4328     }
4329
4330     return 0;
4331 }
4332
4333 int radio::separateConnectionResponse(int slotId,
4334                                      int responseType, int serial, RIL_Errno e,
4335                                      void *response, size_t responseLen) {
4336 #if VDBG
4337     RLOGD("separateConnectionResponse: serial %d", serial);
4338 #endif
4339
4340     if (radioService[slotId]->mRadioResponse != NULL) {
4341         RadioResponseInfo responseInfo = {};
4342         populateResponseInfo(responseInfo, serial, responseType, e);
4343         Return<void> retStatus
4344                 = radioService[slotId]->mRadioResponse->separateConnectionResponse(responseInfo);
4345         radioService[slotId]->checkReturnStatus(retStatus);
4346     } else {
4347         RLOGE("separateConnectionResponse: radioService[%d]->mRadioResponse == NULL",
4348                 slotId);
4349     }
4350
4351     return 0;
4352 }
4353
4354 int radio::setMuteResponse(int slotId,
4355                           int responseType, int serial, RIL_Errno e,
4356                           void *response, size_t responseLen) {
4357 #if VDBG
4358     RLOGD("setMuteResponse: serial %d", serial);
4359 #endif
4360
4361     if (radioService[slotId]->mRadioResponse != NULL) {
4362         RadioResponseInfo responseInfo = {};
4363         populateResponseInfo(responseInfo, serial, responseType, e);
4364         Return<void> retStatus
4365                 = radioService[slotId]->mRadioResponse->setMuteResponse(responseInfo);
4366         radioService[slotId]->checkReturnStatus(retStatus);
4367     } else {
4368         RLOGE("setMuteResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4369     }
4370
4371     return 0;
4372 }
4373
4374 int radio::getMuteResponse(int slotId,
4375                           int responseType, int serial, RIL_Errno e, void *response,
4376                           size_t responseLen) {
4377 #if VDBG
4378     RLOGD("getMuteResponse: serial %d", serial);
4379 #endif
4380
4381     if (radioService[slotId]->mRadioResponse != NULL) {
4382         RadioResponseInfo responseInfo = {};
4383         populateResponseInfo(responseInfo, serial, responseType, e);
4384         bool enable = false;
4385         int serviceClass;
4386         if (response == NULL || responseLen != sizeof(int)) {
4387             RLOGE("getMuteResponse Invalid response: NULL");
4388             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4389         } else {
4390             int *pInt = (int *) response;
4391             enable = pInt[0] == 1 ? true : false;
4392         }
4393         Return<void> retStatus = radioService[slotId]->mRadioResponse->getMuteResponse(responseInfo,
4394                 enable);
4395         radioService[slotId]->checkReturnStatus(retStatus);
4396     } else {
4397         RLOGE("getMuteResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4398     }
4399
4400     return 0;
4401 }
4402
4403 int radio::getClipResponse(int slotId,
4404                           int responseType, int serial, RIL_Errno e,
4405                           void *response, size_t responseLen) {
4406 #if VDBG
4407     RLOGD("getClipResponse: serial %d", serial);
4408 #endif
4409
4410     if (radioService[slotId]->mRadioResponse != NULL) {
4411         RadioResponseInfo responseInfo = {};
4412         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
4413         Return<void> retStatus = radioService[slotId]->mRadioResponse->getClipResponse(responseInfo,
4414                 (ClipStatus) ret);
4415         radioService[slotId]->checkReturnStatus(retStatus);
4416     } else {
4417         RLOGE("getClipResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4418     }
4419
4420     return 0;
4421 }
4422
4423 int radio::getDataCallListResponse(int slotId,
4424                                    int responseType, int serial, RIL_Errno e,
4425                                    void *response, size_t responseLen) {
4426 #if VDBG
4427     RLOGD("getDataCallListResponse: serial %d", serial);
4428 #endif
4429
4430     if (radioService[slotId]->mRadioResponse != NULL) {
4431         RadioResponseInfo responseInfo = {};
4432         populateResponseInfo(responseInfo, serial, responseType, e);
4433
4434         hidl_vec<SetupDataCallResult> ret;
4435         if (response == NULL || responseLen % sizeof(RIL_Data_Call_Response_v11) != 0) {
4436             RLOGE("getDataCallListResponse: invalid response");
4437             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4438         } else {
4439             convertRilDataCallListToHal(response, responseLen, ret);
4440         }
4441
4442         Return<void> retStatus = radioService[slotId]->mRadioResponse->getDataCallListResponse(
4443                 responseInfo, ret);
4444         radioService[slotId]->checkReturnStatus(retStatus);
4445     } else {
4446         RLOGE("getDataCallListResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4447     }
4448
4449     return 0;
4450 }
4451
4452 int radio::setSuppServiceNotificationsResponse(int slotId,
4453                                               int responseType, int serial, RIL_Errno e,
4454                                               void *response, size_t responseLen) {
4455 #if VDBG
4456     RLOGD("setSuppServiceNotificationsResponse: serial %d", serial);
4457 #endif
4458
4459     if (radioService[slotId]->mRadioResponse != NULL) {
4460         RadioResponseInfo responseInfo = {};
4461         populateResponseInfo(responseInfo, serial, responseType, e);
4462         Return<void> retStatus
4463                 = radioService[slotId]->mRadioResponse->setSuppServiceNotificationsResponse(
4464                 responseInfo);
4465         radioService[slotId]->checkReturnStatus(retStatus);
4466     } else {
4467         RLOGE("setSuppServiceNotificationsResponse: radioService[%d]->mRadioResponse "
4468                 "== NULL", slotId);
4469     }
4470
4471     return 0;
4472 }
4473
4474 int radio::deleteSmsOnSimResponse(int slotId,
4475                                  int responseType, int serial, RIL_Errno e,
4476                                  void *response, size_t responseLen) {
4477 #if VDBG
4478     RLOGD("deleteSmsOnSimResponse: serial %d", serial);
4479 #endif
4480
4481     if (radioService[slotId]->mRadioResponse != NULL) {
4482         RadioResponseInfo responseInfo = {};
4483         populateResponseInfo(responseInfo, serial, responseType, e);
4484         Return<void> retStatus
4485                 = radioService[slotId]->mRadioResponse->deleteSmsOnSimResponse(responseInfo);
4486         radioService[slotId]->checkReturnStatus(retStatus);
4487     } else {
4488         RLOGE("deleteSmsOnSimResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4489     }
4490
4491     return 0;
4492 }
4493
4494 int radio::setBandModeResponse(int slotId,
4495                               int responseType, int serial, RIL_Errno e,
4496                               void *response, size_t responseLen) {
4497 #if VDBG
4498     RLOGD("setBandModeResponse: serial %d", serial);
4499 #endif
4500
4501     if (radioService[slotId]->mRadioResponse != NULL) {
4502         RadioResponseInfo responseInfo = {};
4503         populateResponseInfo(responseInfo, serial, responseType, e);
4504         Return<void> retStatus
4505                 = radioService[slotId]->mRadioResponse->setBandModeResponse(responseInfo);
4506         radioService[slotId]->checkReturnStatus(retStatus);
4507     } else {
4508         RLOGE("setBandModeResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4509     }
4510
4511     return 0;
4512 }
4513
4514 int radio::writeSmsToSimResponse(int slotId,
4515                                 int responseType, int serial, RIL_Errno e,
4516                                 void *response, size_t responseLen) {
4517 #if VDBG
4518     RLOGD("writeSmsToSimResponse: serial %d", serial);
4519 #endif
4520
4521     if (radioService[slotId]->mRadioResponse != NULL) {
4522         RadioResponseInfo responseInfo = {};
4523         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
4524         Return<void> retStatus
4525                 = radioService[slotId]->mRadioResponse->writeSmsToSimResponse(responseInfo, ret);
4526         radioService[slotId]->checkReturnStatus(retStatus);
4527     } else {
4528         RLOGE("writeSmsToSimResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4529     }
4530
4531     return 0;
4532 }
4533
4534 int radio::getAvailableBandModesResponse(int slotId,
4535                                         int responseType, int serial, RIL_Errno e, void *response,
4536                                         size_t responseLen) {
4537 #if VDBG
4538     RLOGD("getAvailableBandModesResponse: serial %d", serial);
4539 #endif
4540
4541     if (radioService[slotId]->mRadioResponse != NULL) {
4542         RadioResponseInfo responseInfo = {};
4543         populateResponseInfo(responseInfo, serial, responseType, e);
4544         hidl_vec<RadioBandMode> modes;
4545         if (response == NULL || responseLen % sizeof(int) != 0) {
4546             RLOGE("getAvailableBandModesResponse Invalid response: NULL");
4547             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4548         } else {
4549             int *pInt = (int *) response;
4550             int numInts = responseLen / sizeof(int);
4551             modes.resize(numInts);
4552             for (int i = 0; i < numInts; i++) {
4553                 modes[i] = (RadioBandMode) pInt[i];
4554             }
4555         }
4556         Return<void> retStatus
4557                 = radioService[slotId]->mRadioResponse->getAvailableBandModesResponse(responseInfo,
4558                 modes);
4559         radioService[slotId]->checkReturnStatus(retStatus);
4560     } else {
4561         RLOGE("getAvailableBandModesResponse: radioService[%d]->mRadioResponse == NULL",
4562                 slotId);
4563     }
4564
4565     return 0;
4566 }
4567
4568 int radio::sendEnvelopeResponse(int slotId,
4569                                int responseType, int serial, RIL_Errno e,
4570                                void *response, size_t responseLen) {
4571 #if VDBG
4572     RLOGD("sendEnvelopeResponse: serial %d", serial);
4573 #endif
4574
4575     if (radioService[slotId]->mRadioResponse != NULL) {
4576         RadioResponseInfo responseInfo = {};
4577         populateResponseInfo(responseInfo, serial, responseType, e);
4578         Return<void> retStatus
4579                 = radioService[slotId]->mRadioResponse->sendEnvelopeResponse(responseInfo,
4580                 convertCharPtrToHidlString((char *) response));
4581         radioService[slotId]->checkReturnStatus(retStatus);
4582     } else {
4583         RLOGE("sendEnvelopeResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4584     }
4585
4586     return 0;
4587 }
4588
4589 int radio::sendTerminalResponseToSimResponse(int slotId,
4590                                             int responseType, int serial, RIL_Errno e,
4591                                             void *response, size_t responseLen) {
4592 #if VDBG
4593     RLOGD("sendTerminalResponseToSimResponse: serial %d", serial);
4594 #endif
4595
4596     if (radioService[slotId]->mRadioResponse != NULL) {
4597         RadioResponseInfo responseInfo = {};
4598         populateResponseInfo(responseInfo, serial, responseType, e);
4599         Return<void> retStatus
4600                 = radioService[slotId]->mRadioResponse->sendTerminalResponseToSimResponse(
4601                 responseInfo);
4602         radioService[slotId]->checkReturnStatus(retStatus);
4603     } else {
4604         RLOGE("sendTerminalResponseToSimResponse: radioService[%d]->mRadioResponse == NULL",
4605                 slotId);
4606     }
4607
4608     return 0;
4609 }
4610
4611 int radio::handleStkCallSetupRequestFromSimResponse(int slotId,
4612                                                    int responseType, int serial,
4613                                                    RIL_Errno e, void *response,
4614                                                    size_t responseLen) {
4615 #if VDBG
4616     RLOGD("handleStkCallSetupRequestFromSimResponse: serial %d", serial);
4617 #endif
4618
4619     if (radioService[slotId]->mRadioResponse != NULL) {
4620         RadioResponseInfo responseInfo = {};
4621         populateResponseInfo(responseInfo, serial, responseType, e);
4622         Return<void> retStatus
4623                 = radioService[slotId]->mRadioResponse->handleStkCallSetupRequestFromSimResponse(
4624                 responseInfo);
4625         radioService[slotId]->checkReturnStatus(retStatus);
4626     } else {
4627         RLOGE("handleStkCallSetupRequestFromSimResponse: radioService[%d]->mRadioResponse "
4628                 "== NULL", slotId);
4629     }
4630
4631     return 0;
4632 }
4633
4634 int radio::explicitCallTransferResponse(int slotId,
4635                                        int responseType, int serial, RIL_Errno e,
4636                                        void *response, size_t responseLen) {
4637 #if VDBG
4638     RLOGD("explicitCallTransferResponse: serial %d", serial);
4639 #endif
4640
4641     if (radioService[slotId]->mRadioResponse != NULL) {
4642         RadioResponseInfo responseInfo = {};
4643         populateResponseInfo(responseInfo, serial, responseType, e);
4644         Return<void> retStatus
4645                 = radioService[slotId]->mRadioResponse->explicitCallTransferResponse(responseInfo);
4646         radioService[slotId]->checkReturnStatus(retStatus);
4647     } else {
4648         RLOGE("explicitCallTransferResponse: radioService[%d]->mRadioResponse == NULL",
4649                 slotId);
4650     }
4651
4652     return 0;
4653 }
4654
4655 int radio::setPreferredNetworkTypeResponse(int slotId,
4656                                  int responseType, int serial, RIL_Errno e,
4657                                  void *response, size_t responseLen) {
4658 #if VDBG
4659     RLOGD("setPreferredNetworkTypeResponse: serial %d", serial);
4660 #endif
4661
4662     if (radioService[slotId]->mRadioResponse != NULL) {
4663         RadioResponseInfo responseInfo = {};
4664         populateResponseInfo(responseInfo, serial, responseType, e);
4665         Return<void> retStatus
4666                 = radioService[slotId]->mRadioResponse->setPreferredNetworkTypeResponse(
4667                 responseInfo);
4668         radioService[slotId]->checkReturnStatus(retStatus);
4669     } else {
4670         RLOGE("setPreferredNetworkTypeResponse: radioService[%d]->mRadioResponse == NULL",
4671                 slotId);
4672     }
4673
4674     return 0;
4675 }
4676
4677
4678 int radio::getPreferredNetworkTypeResponse(int slotId,
4679                                           int responseType, int serial, RIL_Errno e,
4680                                           void *response, size_t responseLen) {
4681 #if VDBG
4682     RLOGD("getPreferredNetworkTypeResponse: serial %d", serial);
4683 #endif
4684
4685     if (radioService[slotId]->mRadioResponse != NULL) {
4686         RadioResponseInfo responseInfo = {};
4687         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
4688         Return<void> retStatus
4689                 = radioService[slotId]->mRadioResponse->getPreferredNetworkTypeResponse(
4690                 responseInfo, (PreferredNetworkType) ret);
4691         radioService[slotId]->checkReturnStatus(retStatus);
4692     } else {
4693         RLOGE("getPreferredNetworkTypeResponse: radioService[%d]->mRadioResponse == NULL",
4694                 slotId);
4695     }
4696
4697     return 0;
4698 }
4699
4700 int radio::getNeighboringCidsResponse(int slotId,
4701                                      int responseType, int serial, RIL_Errno e,
4702                                      void *response, size_t responseLen) {
4703 #if VDBG
4704     RLOGD("getNeighboringCidsResponse: serial %d", serial);
4705 #endif
4706
4707     if (radioService[slotId]->mRadioResponse != NULL) {
4708         RadioResponseInfo responseInfo = {};
4709         populateResponseInfo(responseInfo, serial, responseType, e);
4710         hidl_vec<NeighboringCell> cells;
4711
4712         if (response == NULL || responseLen % sizeof(RIL_NeighboringCell *) != 0) {
4713             RLOGE("getNeighboringCidsResponse Invalid response: NULL");
4714             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4715         } else {
4716             int num = responseLen / sizeof(RIL_NeighboringCell *);
4717             cells.resize(num);
4718             for (int i = 0 ; i < num; i++) {
4719                 RIL_NeighboringCell *resp = ((RIL_NeighboringCell **) response)[i];
4720                 cells[i].cid = convertCharPtrToHidlString(resp->cid);
4721                 cells[i].rssi = resp->rssi;
4722             }
4723         }
4724
4725         Return<void> retStatus
4726                 = radioService[slotId]->mRadioResponse->getNeighboringCidsResponse(responseInfo,
4727                 cells);
4728         radioService[slotId]->checkReturnStatus(retStatus);
4729     } else {
4730         RLOGE("getNeighboringCidsResponse: radioService[%d]->mRadioResponse == NULL",
4731                 slotId);
4732     }
4733
4734     return 0;
4735 }
4736
4737 int radio::setLocationUpdatesResponse(int slotId,
4738                                      int responseType, int serial, RIL_Errno e,
4739                                      void *response, size_t responseLen) {
4740 #if VDBG
4741     RLOGD("setLocationUpdatesResponse: serial %d", serial);
4742 #endif
4743
4744     if (radioService[slotId]->mRadioResponse != NULL) {
4745         RadioResponseInfo responseInfo = {};
4746         populateResponseInfo(responseInfo, serial, responseType, e);
4747         Return<void> retStatus
4748                 = radioService[slotId]->mRadioResponse->setLocationUpdatesResponse(responseInfo);
4749         radioService[slotId]->checkReturnStatus(retStatus);
4750     } else {
4751         RLOGE("setLocationUpdatesResponse: radioService[%d]->mRadioResponse == NULL",
4752                 slotId);
4753     }
4754
4755     return 0;
4756 }
4757
4758 int radio::setCdmaSubscriptionSourceResponse(int slotId,
4759                                  int responseType, int serial, RIL_Errno e,
4760                                  void *response, size_t responseLen) {
4761 #if VDBG
4762     RLOGD("setCdmaSubscriptionSourceResponse: serial %d", serial);
4763 #endif
4764
4765     if (radioService[slotId]->mRadioResponse != NULL) {
4766         RadioResponseInfo responseInfo = {};
4767         populateResponseInfo(responseInfo, serial, responseType, e);
4768         Return<void> retStatus
4769                 = radioService[slotId]->mRadioResponse->setCdmaSubscriptionSourceResponse(
4770                 responseInfo);
4771         radioService[slotId]->checkReturnStatus(retStatus);
4772     } else {
4773         RLOGE("setCdmaSubscriptionSourceResponse: radioService[%d]->mRadioResponse == NULL",
4774                 slotId);
4775     }
4776
4777     return 0;
4778 }
4779
4780 int radio::setCdmaRoamingPreferenceResponse(int slotId,
4781                                  int responseType, int serial, RIL_Errno e,
4782                                  void *response, size_t responseLen) {
4783 #if VDBG
4784     RLOGD("setCdmaRoamingPreferenceResponse: serial %d", serial);
4785 #endif
4786
4787     if (radioService[slotId]->mRadioResponse != NULL) {
4788         RadioResponseInfo responseInfo = {};
4789         populateResponseInfo(responseInfo, serial, responseType, e);
4790         Return<void> retStatus
4791                 = radioService[slotId]->mRadioResponse->setCdmaRoamingPreferenceResponse(
4792                 responseInfo);
4793         radioService[slotId]->checkReturnStatus(retStatus);
4794     } else {
4795         RLOGE("setCdmaRoamingPreferenceResponse: radioService[%d]->mRadioResponse == NULL",
4796                 slotId);
4797     }
4798
4799     return 0;
4800 }
4801
4802 int radio::getCdmaRoamingPreferenceResponse(int slotId,
4803                                            int responseType, int serial, RIL_Errno e,
4804                                            void *response, size_t responseLen) {
4805 #if VDBG
4806     RLOGD("getCdmaRoamingPreferenceResponse: serial %d", serial);
4807 #endif
4808
4809     if (radioService[slotId]->mRadioResponse != NULL) {
4810         RadioResponseInfo responseInfo = {};
4811         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
4812         Return<void> retStatus
4813                 = radioService[slotId]->mRadioResponse->getCdmaRoamingPreferenceResponse(
4814                 responseInfo, (CdmaRoamingType) ret);
4815         radioService[slotId]->checkReturnStatus(retStatus);
4816     } else {
4817         RLOGE("getCdmaRoamingPreferenceResponse: radioService[%d]->mRadioResponse == NULL",
4818                 slotId);
4819     }
4820
4821     return 0;
4822 }
4823
4824 int radio::setTTYModeResponse(int slotId,
4825                              int responseType, int serial, RIL_Errno e,
4826                              void *response, size_t responseLen) {
4827 #if VDBG
4828     RLOGD("setTTYModeResponse: serial %d", serial);
4829 #endif
4830
4831     if (radioService[slotId]->mRadioResponse != NULL) {
4832         RadioResponseInfo responseInfo = {};
4833         populateResponseInfo(responseInfo, serial, responseType, e);
4834         Return<void> retStatus
4835                 = radioService[slotId]->mRadioResponse->setTTYModeResponse(responseInfo);
4836         radioService[slotId]->checkReturnStatus(retStatus);
4837     } else {
4838         RLOGE("setTTYModeResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4839     }
4840
4841     return 0;
4842 }
4843
4844 int radio::getTTYModeResponse(int slotId,
4845                              int responseType, int serial, RIL_Errno e,
4846                              void *response, size_t responseLen) {
4847 #if VDBG
4848     RLOGD("getTTYModeResponse: serial %d", serial);
4849 #endif
4850
4851     if (radioService[slotId]->mRadioResponse != NULL) {
4852         RadioResponseInfo responseInfo = {};
4853         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
4854         Return<void> retStatus
4855                 = radioService[slotId]->mRadioResponse->getTTYModeResponse(responseInfo,
4856                 (TtyMode) ret);
4857         radioService[slotId]->checkReturnStatus(retStatus);
4858     } else {
4859         RLOGE("getTTYModeResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4860     }
4861
4862     return 0;
4863 }
4864
4865 int radio::setPreferredVoicePrivacyResponse(int slotId,
4866                                  int responseType, int serial, RIL_Errno e,
4867                                  void *response, size_t responseLen) {
4868 #if VDBG
4869     RLOGD("setPreferredVoicePrivacyResponse: serial %d", serial);
4870 #endif
4871
4872     if (radioService[slotId]->mRadioResponse != NULL) {
4873         RadioResponseInfo responseInfo = {};
4874         populateResponseInfo(responseInfo, serial, responseType, e);
4875         Return<void> retStatus
4876                 = radioService[slotId]->mRadioResponse->setPreferredVoicePrivacyResponse(
4877                 responseInfo);
4878         radioService[slotId]->checkReturnStatus(retStatus);
4879     } else {
4880         RLOGE("setPreferredVoicePrivacyResponse: radioService[%d]->mRadioResponse == NULL",
4881                 slotId);
4882     }
4883
4884     return 0;
4885 }
4886
4887 int radio::getPreferredVoicePrivacyResponse(int slotId,
4888                                            int responseType, int serial, RIL_Errno e,
4889                                            void *response, size_t responseLen) {
4890 #if VDBG
4891     RLOGD("getPreferredVoicePrivacyResponse: serial %d", serial);
4892 #endif
4893
4894     if (radioService[slotId]->mRadioResponse != NULL) {
4895         RadioResponseInfo responseInfo = {};
4896         populateResponseInfo(responseInfo, serial, responseType, e);
4897         bool enable = false;
4898         int numInts = responseLen / sizeof(int);
4899         if (response == NULL || numInts != 1) {
4900             RLOGE("getPreferredVoicePrivacyResponse Invalid response: NULL");
4901             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4902         } else {
4903             int *pInt = (int *) response;
4904             enable = pInt[0] == 1 ? true : false;
4905         }
4906         Return<void> retStatus
4907                 = radioService[slotId]->mRadioResponse->getPreferredVoicePrivacyResponse(
4908                 responseInfo, enable);
4909         radioService[slotId]->checkReturnStatus(retStatus);
4910     } else {
4911         RLOGE("getPreferredVoicePrivacyResponse: radioService[%d]->mRadioResponse == NULL",
4912                 slotId);
4913     }
4914
4915     return 0;
4916 }
4917
4918 int radio::sendCDMAFeatureCodeResponse(int slotId,
4919                                  int responseType, int serial, RIL_Errno e,
4920                                  void *response, size_t responseLen) {
4921 #if VDBG
4922     RLOGD("sendCDMAFeatureCodeResponse: serial %d", serial);
4923 #endif
4924
4925     if (radioService[slotId]->mRadioResponse != NULL) {
4926         RadioResponseInfo responseInfo = {};
4927         populateResponseInfo(responseInfo, serial, responseType, e);
4928         Return<void> retStatus
4929                 = radioService[slotId]->mRadioResponse->sendCDMAFeatureCodeResponse(responseInfo);
4930         radioService[slotId]->checkReturnStatus(retStatus);
4931     } else {
4932         RLOGE("sendCDMAFeatureCodeResponse: radioService[%d]->mRadioResponse == NULL",
4933                 slotId);
4934     }
4935
4936     return 0;
4937 }
4938
4939 int radio::sendBurstDtmfResponse(int slotId,
4940                                  int responseType, int serial, RIL_Errno e,
4941                                  void *response, size_t responseLen) {
4942 #if VDBG
4943     RLOGD("sendBurstDtmfResponse: serial %d", serial);
4944 #endif
4945
4946     if (radioService[slotId]->mRadioResponse != NULL) {
4947         RadioResponseInfo responseInfo = {};
4948         populateResponseInfo(responseInfo, serial, responseType, e);
4949         Return<void> retStatus
4950                 = radioService[slotId]->mRadioResponse->sendBurstDtmfResponse(responseInfo);
4951         radioService[slotId]->checkReturnStatus(retStatus);
4952     } else {
4953         RLOGE("sendBurstDtmfResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4954     }
4955
4956     return 0;
4957 }
4958
4959 int radio::sendCdmaSmsResponse(int slotId,
4960                               int responseType, int serial, RIL_Errno e, void *response,
4961                               size_t responseLen) {
4962 #if VDBG
4963     RLOGD("sendCdmaSmsResponse: serial %d", serial);
4964 #endif
4965
4966     if (radioService[slotId]->mRadioResponse != NULL) {
4967         RadioResponseInfo responseInfo = {};
4968         SendSmsResult result = makeSendSmsResult(responseInfo, serial, responseType, e, response,
4969                 responseLen);
4970
4971         Return<void> retStatus
4972                 = radioService[slotId]->mRadioResponse->sendCdmaSmsResponse(responseInfo, result);
4973         radioService[slotId]->checkReturnStatus(retStatus);
4974     } else {
4975         RLOGE("sendCdmaSmsResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4976     }
4977
4978     return 0;
4979 }
4980
4981 int radio::acknowledgeLastIncomingCdmaSmsResponse(int slotId,
4982                                                  int responseType, int serial, RIL_Errno e,
4983                                                  void *response, size_t responseLen) {
4984 #if VDBG
4985     RLOGD("acknowledgeLastIncomingCdmaSmsResponse: serial %d", serial);
4986 #endif
4987
4988     if (radioService[slotId]->mRadioResponse != NULL) {
4989         RadioResponseInfo responseInfo = {};
4990         populateResponseInfo(responseInfo, serial, responseType, e);
4991         Return<void> retStatus
4992                 = radioService[slotId]->mRadioResponse->acknowledgeLastIncomingCdmaSmsResponse(
4993                 responseInfo);
4994         radioService[slotId]->checkReturnStatus(retStatus);
4995     } else {
4996         RLOGE("acknowledgeLastIncomingCdmaSmsResponse: radioService[%d]->mRadioResponse "
4997                 "== NULL", slotId);
4998     }
4999
5000     return 0;
5001 }
5002
5003 int radio::getGsmBroadcastConfigResponse(int slotId,
5004                                         int responseType, int serial, RIL_Errno e,
5005                                         void *response, size_t responseLen) {
5006 #if VDBG
5007     RLOGD("getGsmBroadcastConfigResponse: serial %d", serial);
5008 #endif
5009
5010     if (radioService[slotId]->mRadioResponse != NULL) {
5011         RadioResponseInfo responseInfo = {};
5012         populateResponseInfo(responseInfo, serial, responseType, e);
5013         hidl_vec<GsmBroadcastSmsConfigInfo> configs;
5014
5015         if (response == NULL || responseLen % sizeof(RIL_GSM_BroadcastSmsConfigInfo *) != 0) {
5016             RLOGE("getGsmBroadcastConfigResponse Invalid response: NULL");
5017             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5018         } else {
5019             int num = responseLen / sizeof(RIL_GSM_BroadcastSmsConfigInfo *);
5020             configs.resize(num);
5021             for (int i = 0 ; i < num; i++) {
5022                 RIL_GSM_BroadcastSmsConfigInfo *resp =
5023                         ((RIL_GSM_BroadcastSmsConfigInfo **) response)[i];
5024                 configs[i].fromServiceId = resp->fromServiceId;
5025                 configs[i].toServiceId = resp->toServiceId;
5026                 configs[i].fromCodeScheme = resp->fromCodeScheme;
5027                 configs[i].toCodeScheme = resp->toCodeScheme;
5028                 configs[i].selected = resp->selected == 1 ? true : false;
5029             }
5030         }
5031
5032         Return<void> retStatus
5033                 = radioService[slotId]->mRadioResponse->getGsmBroadcastConfigResponse(responseInfo,
5034                 configs);
5035         radioService[slotId]->checkReturnStatus(retStatus);
5036     } else {
5037         RLOGE("getGsmBroadcastConfigResponse: radioService[%d]->mRadioResponse == NULL",
5038                 slotId);
5039     }
5040
5041     return 0;
5042 }
5043
5044 int radio::setGsmBroadcastConfigResponse(int slotId,
5045                                         int responseType, int serial, RIL_Errno e,
5046                                         void *response, size_t responseLen) {
5047 #if VDBG
5048     RLOGD("setGsmBroadcastConfigResponse: serial %d", serial);
5049 #endif
5050
5051     if (radioService[slotId]->mRadioResponse != NULL) {
5052         RadioResponseInfo responseInfo = {};
5053         populateResponseInfo(responseInfo, serial, responseType, e);
5054         Return<void> retStatus
5055                 = radioService[slotId]->mRadioResponse->setGsmBroadcastConfigResponse(responseInfo);
5056         radioService[slotId]->checkReturnStatus(retStatus);
5057     } else {
5058         RLOGE("setGsmBroadcastConfigResponse: radioService[%d]->mRadioResponse == NULL",
5059                 slotId);
5060     }
5061
5062     return 0;
5063 }
5064
5065 int radio::setGsmBroadcastActivationResponse(int slotId,
5066                                             int responseType, int serial, RIL_Errno e,
5067                                             void *response, size_t responseLen) {
5068 #if VDBG
5069     RLOGD("setGsmBroadcastActivationResponse: serial %d", serial);
5070 #endif
5071
5072     if (radioService[slotId]->mRadioResponse != NULL) {
5073         RadioResponseInfo responseInfo = {};
5074         populateResponseInfo(responseInfo, serial, responseType, e);
5075         Return<void> retStatus
5076                 = radioService[slotId]->mRadioResponse->setGsmBroadcastActivationResponse(
5077                 responseInfo);
5078         radioService[slotId]->checkReturnStatus(retStatus);
5079     } else {
5080         RLOGE("setGsmBroadcastActivationResponse: radioService[%d]->mRadioResponse == NULL",
5081                 slotId);
5082     }
5083
5084     return 0;
5085 }
5086
5087 int radio::getCdmaBroadcastConfigResponse(int slotId,
5088                                          int responseType, int serial, RIL_Errno e,
5089                                          void *response, size_t responseLen) {
5090 #if VDBG
5091     RLOGD("getCdmaBroadcastConfigResponse: serial %d", serial);
5092 #endif
5093
5094     if (radioService[slotId]->mRadioResponse != NULL) {
5095         RadioResponseInfo responseInfo = {};
5096         populateResponseInfo(responseInfo, serial, responseType, e);
5097         hidl_vec<CdmaBroadcastSmsConfigInfo> configs;
5098
5099         if (response == NULL || responseLen % sizeof(RIL_CDMA_BroadcastSmsConfigInfo *) != 0) {
5100             RLOGE("getCdmaBroadcastConfigResponse Invalid response: NULL");
5101             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5102         } else {
5103             int num = responseLen / sizeof(RIL_CDMA_BroadcastSmsConfigInfo *);
5104             configs.resize(num);
5105             for (int i = 0 ; i < num; i++) {
5106                 RIL_CDMA_BroadcastSmsConfigInfo *resp =
5107                         ((RIL_CDMA_BroadcastSmsConfigInfo **) response)[i];
5108                 configs[i].serviceCategory = resp->service_category;
5109                 configs[i].language = resp->language;
5110                 configs[i].selected = resp->selected == 1 ? true : false;
5111             }
5112         }
5113
5114         Return<void> retStatus
5115                 = radioService[slotId]->mRadioResponse->getCdmaBroadcastConfigResponse(responseInfo,
5116                 configs);
5117         radioService[slotId]->checkReturnStatus(retStatus);
5118     } else {
5119         RLOGE("getCdmaBroadcastConfigResponse: radioService[%d]->mRadioResponse == NULL",
5120                 slotId);
5121     }
5122
5123     return 0;
5124 }
5125
5126 int radio::setCdmaBroadcastConfigResponse(int slotId,
5127                                          int responseType, int serial, RIL_Errno e,
5128                                          void *response, size_t responseLen) {
5129 #if VDBG
5130     RLOGD("setCdmaBroadcastConfigResponse: serial %d", serial);
5131 #endif
5132
5133     if (radioService[slotId]->mRadioResponse != NULL) {
5134         RadioResponseInfo responseInfo = {};
5135         populateResponseInfo(responseInfo, serial, responseType, e);
5136         Return<void> retStatus
5137                 = radioService[slotId]->mRadioResponse->setCdmaBroadcastConfigResponse(
5138                 responseInfo);
5139         radioService[slotId]->checkReturnStatus(retStatus);
5140     } else {
5141         RLOGE("setCdmaBroadcastConfigResponse: radioService[%d]->mRadioResponse == NULL",
5142                 slotId);
5143     }
5144
5145     return 0;
5146 }
5147
5148 int radio::setCdmaBroadcastActivationResponse(int slotId,
5149                                              int responseType, int serial, RIL_Errno e,
5150                                              void *response, size_t responseLen) {
5151 #if VDBG
5152     RLOGD("setCdmaBroadcastActivationResponse: serial %d", serial);
5153 #endif
5154
5155     if (radioService[slotId]->mRadioResponse != NULL) {
5156         RadioResponseInfo responseInfo = {};
5157         populateResponseInfo(responseInfo, serial, responseType, e);
5158         Return<void> retStatus
5159                 = radioService[slotId]->mRadioResponse->setCdmaBroadcastActivationResponse(
5160                 responseInfo);
5161         radioService[slotId]->checkReturnStatus(retStatus);
5162     } else {
5163         RLOGE("setCdmaBroadcastActivationResponse: radioService[%d]->mRadioResponse == NULL",
5164                 slotId);
5165     }
5166
5167     return 0;
5168 }
5169
5170 int radio::getCDMASubscriptionResponse(int slotId,
5171                                       int responseType, int serial, RIL_Errno e, void *response,
5172                                       size_t responseLen) {
5173 #if VDBG
5174     RLOGD("getCDMASubscriptionResponse: serial %d", serial);
5175 #endif
5176
5177     if (radioService[slotId]->mRadioResponse != NULL) {
5178         RadioResponseInfo responseInfo = {};
5179         populateResponseInfo(responseInfo, serial, responseType, e);
5180
5181         int numStrings = responseLen / sizeof(char *);
5182         hidl_string emptyString;
5183         if (response == NULL || numStrings != 5) {
5184             RLOGE("getOperatorResponse Invalid response: NULL");
5185             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5186             Return<void> retStatus
5187                     = radioService[slotId]->mRadioResponse->getCDMASubscriptionResponse(
5188                     responseInfo, emptyString, emptyString, emptyString, emptyString, emptyString);
5189             radioService[slotId]->checkReturnStatus(retStatus);
5190         } else {
5191             char **resp = (char **) response;
5192             Return<void> retStatus
5193                     = radioService[slotId]->mRadioResponse->getCDMASubscriptionResponse(
5194                     responseInfo,
5195                     convertCharPtrToHidlString(resp[0]),
5196                     convertCharPtrToHidlString(resp[1]),
5197                     convertCharPtrToHidlString(resp[2]),
5198                     convertCharPtrToHidlString(resp[3]),
5199                     convertCharPtrToHidlString(resp[4]));
5200             radioService[slotId]->checkReturnStatus(retStatus);
5201         }
5202     } else {
5203         RLOGE("getCDMASubscriptionResponse: radioService[%d]->mRadioResponse == NULL",
5204                 slotId);
5205     }
5206
5207     return 0;
5208 }
5209
5210 int radio::writeSmsToRuimResponse(int slotId,
5211                                  int responseType, int serial, RIL_Errno e,
5212                                  void *response, size_t responseLen) {
5213 #if VDBG
5214     RLOGD("writeSmsToRuimResponse: serial %d", serial);
5215 #endif
5216
5217     if (radioService[slotId]->mRadioResponse != NULL) {
5218         RadioResponseInfo responseInfo = {};
5219         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
5220         Return<void> retStatus
5221                 = radioService[slotId]->mRadioResponse->writeSmsToRuimResponse(responseInfo, ret);
5222         radioService[slotId]->checkReturnStatus(retStatus);
5223     } else {
5224         RLOGE("writeSmsToRuimResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5225     }
5226
5227     return 0;
5228 }
5229
5230 int radio::deleteSmsOnRuimResponse(int slotId,
5231                                   int responseType, int serial, RIL_Errno e,
5232                                   void *response, size_t responseLen) {
5233 #if VDBG
5234     RLOGD("deleteSmsOnRuimResponse: serial %d", serial);
5235 #endif
5236
5237     if (radioService[slotId]->mRadioResponse != NULL) {
5238         RadioResponseInfo responseInfo = {};
5239         populateResponseInfo(responseInfo, serial, responseType, e);
5240         Return<void> retStatus
5241                 = radioService[slotId]->mRadioResponse->deleteSmsOnRuimResponse(responseInfo);
5242         radioService[slotId]->checkReturnStatus(retStatus);
5243     } else {
5244         RLOGE("deleteSmsOnRuimResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5245     }
5246
5247     return 0;
5248 }
5249
5250 int radio::getDeviceIdentityResponse(int slotId,
5251                                     int responseType, int serial, RIL_Errno e, void *response,
5252                                     size_t responseLen) {
5253 #if VDBG
5254     RLOGD("getDeviceIdentityResponse: serial %d", serial);
5255 #endif
5256
5257     if (radioService[slotId]->mRadioResponse != NULL) {
5258         RadioResponseInfo responseInfo = {};
5259         populateResponseInfo(responseInfo, serial, responseType, e);
5260
5261         int numStrings = responseLen / sizeof(char *);
5262         hidl_string emptyString;
5263         if (response == NULL || numStrings != 4) {
5264             RLOGE("getDeviceIdentityResponse Invalid response: NULL");
5265             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5266             Return<void> retStatus
5267                     = radioService[slotId]->mRadioResponse->getDeviceIdentityResponse(responseInfo,
5268                     emptyString, emptyString, emptyString, emptyString);
5269             radioService[slotId]->checkReturnStatus(retStatus);
5270         } else {
5271             char **resp = (char **) response;
5272             Return<void> retStatus
5273                     = radioService[slotId]->mRadioResponse->getDeviceIdentityResponse(responseInfo,
5274                     convertCharPtrToHidlString(resp[0]),
5275                     convertCharPtrToHidlString(resp[1]),
5276                     convertCharPtrToHidlString(resp[2]),
5277                     convertCharPtrToHidlString(resp[3]));
5278             radioService[slotId]->checkReturnStatus(retStatus);
5279         }
5280     } else {
5281         RLOGE("getDeviceIdentityResponse: radioService[%d]->mRadioResponse == NULL",
5282                 slotId);
5283     }
5284
5285     return 0;
5286 }
5287
5288 int radio::exitEmergencyCallbackModeResponse(int slotId,
5289                                             int responseType, int serial, RIL_Errno e,
5290                                             void *response, size_t responseLen) {
5291 #if VDBG
5292     RLOGD("exitEmergencyCallbackModeResponse: serial %d", serial);
5293 #endif
5294
5295     if (radioService[slotId]->mRadioResponse != NULL) {
5296         RadioResponseInfo responseInfo = {};
5297         populateResponseInfo(responseInfo, serial, responseType, e);
5298         Return<void> retStatus
5299                 = radioService[slotId]->mRadioResponse->exitEmergencyCallbackModeResponse(
5300                 responseInfo);
5301         radioService[slotId]->checkReturnStatus(retStatus);
5302     } else {
5303         RLOGE("exitEmergencyCallbackModeResponse: radioService[%d]->mRadioResponse == NULL",
5304                 slotId);
5305     }
5306
5307     return 0;
5308 }
5309
5310 int radio::getSmscAddressResponse(int slotId,
5311                                   int responseType, int serial, RIL_Errno e,
5312                                   void *response, size_t responseLen) {
5313 #if VDBG
5314     RLOGD("getSmscAddressResponse: serial %d", serial);
5315 #endif
5316
5317     if (radioService[slotId]->mRadioResponse != NULL) {
5318         RadioResponseInfo responseInfo = {};
5319         populateResponseInfo(responseInfo, serial, responseType, e);
5320         Return<void> retStatus
5321                 = radioService[slotId]->mRadioResponse->getSmscAddressResponse(responseInfo,
5322                 convertCharPtrToHidlString((char *) response));
5323         radioService[slotId]->checkReturnStatus(retStatus);
5324     } else {
5325         RLOGE("getSmscAddressResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5326     }
5327
5328     return 0;
5329 }
5330
5331 int radio::setSmscAddressResponse(int slotId,
5332                                              int responseType, int serial, RIL_Errno e,
5333                                              void *response, size_t responseLen) {
5334 #if VDBG
5335     RLOGD("setSmscAddressResponse: serial %d", serial);
5336 #endif
5337
5338     if (radioService[slotId]->mRadioResponse != NULL) {
5339         RadioResponseInfo responseInfo = {};
5340         populateResponseInfo(responseInfo, serial, responseType, e);
5341         Return<void> retStatus
5342                 = radioService[slotId]->mRadioResponse->setSmscAddressResponse(responseInfo);
5343         radioService[slotId]->checkReturnStatus(retStatus);
5344     } else {
5345         RLOGE("setSmscAddressResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5346     }
5347
5348     return 0;
5349 }
5350
5351 int radio::reportSmsMemoryStatusResponse(int slotId,
5352                                         int responseType, int serial, RIL_Errno e,
5353                                         void *response, size_t responseLen) {
5354 #if VDBG
5355     RLOGD("reportSmsMemoryStatusResponse: serial %d", serial);
5356 #endif
5357
5358     if (radioService[slotId]->mRadioResponse != NULL) {
5359         RadioResponseInfo responseInfo = {};
5360         populateResponseInfo(responseInfo, serial, responseType, e);
5361         Return<void> retStatus
5362                 = radioService[slotId]->mRadioResponse->reportSmsMemoryStatusResponse(responseInfo);
5363         radioService[slotId]->checkReturnStatus(retStatus);
5364     } else {
5365         RLOGE("reportSmsMemoryStatusResponse: radioService[%d]->mRadioResponse == NULL",
5366                 slotId);
5367     }
5368
5369     return 0;
5370 }
5371
5372 int radio::reportStkServiceIsRunningResponse(int slotId,
5373                                              int responseType, int serial, RIL_Errno e,
5374                                              void *response, size_t responseLen) {
5375 #if VDBG
5376     RLOGD("reportStkServiceIsRunningResponse: serial %d", serial);
5377 #endif
5378
5379     if (radioService[slotId]->mRadioResponse != NULL) {
5380         RadioResponseInfo responseInfo = {};
5381         populateResponseInfo(responseInfo, serial, responseType, e);
5382         Return<void> retStatus = radioService[slotId]->mRadioResponse->
5383                 reportStkServiceIsRunningResponse(responseInfo);
5384         radioService[slotId]->checkReturnStatus(retStatus);
5385     } else {
5386         RLOGE("reportStkServiceIsRunningResponse: radioService[%d]->mRadioResponse == NULL",
5387                 slotId);
5388     }
5389
5390     return 0;
5391 }
5392
5393 int radio::getCdmaSubscriptionSourceResponse(int slotId,
5394                                             int responseType, int serial, RIL_Errno e,
5395                                             void *response, size_t responseLen) {
5396 #if VDBG
5397     RLOGD("getCdmaSubscriptionSourceResponse: serial %d", serial);
5398 #endif
5399
5400     if (radioService[slotId]->mRadioResponse != NULL) {
5401         RadioResponseInfo responseInfo = {};
5402         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
5403         Return<void> retStatus
5404                 = radioService[slotId]->mRadioResponse->getCdmaSubscriptionSourceResponse(
5405                 responseInfo, (CdmaSubscriptionSource) ret);
5406         radioService[slotId]->checkReturnStatus(retStatus);
5407     } else {
5408         RLOGE("getCdmaSubscriptionSourceResponse: radioService[%d]->mRadioResponse == NULL",
5409                 slotId);
5410     }
5411
5412     return 0;
5413 }
5414
5415 int radio::requestIsimAuthenticationResponse(int slotId,
5416                                             int responseType, int serial, RIL_Errno e,
5417                                             void *response, size_t responseLen) {
5418 #if VDBG
5419     RLOGD("requestIsimAuthenticationResponse: serial %d", serial);
5420 #endif
5421
5422     if (radioService[slotId]->mRadioResponse != NULL) {
5423         RadioResponseInfo responseInfo = {};
5424         populateResponseInfo(responseInfo, serial, responseType, e);
5425         Return<void> retStatus
5426                 = radioService[slotId]->mRadioResponse->requestIsimAuthenticationResponse(
5427                 responseInfo,
5428                 convertCharPtrToHidlString((char *) response));
5429         radioService[slotId]->checkReturnStatus(retStatus);
5430     } else {
5431         RLOGE("requestIsimAuthenticationResponse: radioService[%d]->mRadioResponse == NULL",
5432                 slotId);
5433     }
5434
5435     return 0;
5436 }
5437
5438 int radio::acknowledgeIncomingGsmSmsWithPduResponse(int slotId,
5439                                                    int responseType,
5440                                                    int serial, RIL_Errno e, void *response,
5441                                                    size_t responseLen) {
5442 #if VDBG
5443     RLOGD("acknowledgeIncomingGsmSmsWithPduResponse: serial %d", serial);
5444 #endif
5445
5446     if (radioService[slotId]->mRadioResponse != NULL) {
5447         RadioResponseInfo responseInfo = {};
5448         populateResponseInfo(responseInfo, serial, responseType, e);
5449         Return<void> retStatus
5450                 = radioService[slotId]->mRadioResponse->acknowledgeIncomingGsmSmsWithPduResponse(
5451                 responseInfo);
5452         radioService[slotId]->checkReturnStatus(retStatus);
5453     } else {
5454         RLOGE("acknowledgeIncomingGsmSmsWithPduResponse: radioService[%d]->mRadioResponse "
5455                 "== NULL", slotId);
5456     }
5457
5458     return 0;
5459 }
5460
5461 int radio::sendEnvelopeWithStatusResponse(int slotId,
5462                                          int responseType, int serial, RIL_Errno e, void *response,
5463                                          size_t responseLen) {
5464 #if VDBG
5465     RLOGD("sendEnvelopeWithStatusResponse: serial %d", serial);
5466 #endif
5467
5468     if (radioService[slotId]->mRadioResponse != NULL) {
5469         RadioResponseInfo responseInfo = {};
5470         IccIoResult result = responseIccIo(responseInfo, serial, responseType, e,
5471                 response, responseLen);
5472
5473         Return<void> retStatus
5474                 = radioService[slotId]->mRadioResponse->sendEnvelopeWithStatusResponse(responseInfo,
5475                 result);
5476         radioService[slotId]->checkReturnStatus(retStatus);
5477     } else {
5478         RLOGE("sendEnvelopeWithStatusResponse: radioService[%d]->mRadioResponse == NULL",
5479                 slotId);
5480     }
5481
5482     return 0;
5483 }
5484
5485 int radio::getVoiceRadioTechnologyResponse(int slotId,
5486                                           int responseType, int serial, RIL_Errno e,
5487                                           void *response, size_t responseLen) {
5488 #if VDBG
5489     RLOGD("getVoiceRadioTechnologyResponse: serial %d", serial);
5490 #endif
5491
5492     if (radioService[slotId]->mRadioResponse != NULL) {
5493         RadioResponseInfo responseInfo = {};
5494         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
5495         Return<void> retStatus
5496                 = radioService[slotId]->mRadioResponse->getVoiceRadioTechnologyResponse(
5497                 responseInfo, (RadioTechnology) ret);
5498         radioService[slotId]->checkReturnStatus(retStatus);
5499     } else {
5500         RLOGE("getVoiceRadioTechnologyResponse: radioService[%d]->mRadioResponse == NULL",
5501                 slotId);
5502     }
5503
5504     return 0;
5505 }
5506
5507 int radio::getCellInfoListResponse(int slotId,
5508                                    int responseType,
5509                                    int serial, RIL_Errno e, void *response,
5510                                    size_t responseLen) {
5511 #if VDBG
5512     RLOGD("getCellInfoListResponse: serial %d", serial);
5513 #endif
5514
5515     if (radioService[slotId]->mRadioResponse != NULL) {
5516         RadioResponseInfo responseInfo = {};
5517         populateResponseInfo(responseInfo, serial, responseType, e);
5518
5519         hidl_vec<CellInfo> ret;
5520         if (response == NULL || responseLen % sizeof(RIL_CellInfo_v12) != 0) {
5521             RLOGE("getCellInfoListResponse: Invalid response");
5522             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5523         } else {
5524             convertRilCellInfoListToHal(response, responseLen, ret);
5525         }
5526
5527         Return<void> retStatus = radioService[slotId]->mRadioResponse->getCellInfoListResponse(
5528                 responseInfo, ret);
5529         radioService[slotId]->checkReturnStatus(retStatus);
5530     } else {
5531         RLOGE("getCellInfoListResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5532     }
5533
5534     return 0;
5535 }
5536
5537 int radio::setCellInfoListRateResponse(int slotId,
5538                                        int responseType,
5539                                        int serial, RIL_Errno e, void *response,
5540                                        size_t responseLen) {
5541 #if VDBG
5542     RLOGD("setCellInfoListRateResponse: serial %d", serial);
5543 #endif
5544
5545     if (radioService[slotId]->mRadioResponse != NULL) {
5546         RadioResponseInfo responseInfo = {};
5547         populateResponseInfo(responseInfo, serial, responseType, e);
5548         Return<void> retStatus
5549                 = radioService[slotId]->mRadioResponse->setCellInfoListRateResponse(responseInfo);
5550         radioService[slotId]->checkReturnStatus(retStatus);
5551     } else {
5552         RLOGE("setCellInfoListRateResponse: radioService[%d]->mRadioResponse == NULL",
5553                 slotId);
5554     }
5555
5556     return 0;
5557 }
5558
5559 int radio::setInitialAttachApnResponse(int slotId,
5560                                        int responseType, int serial, RIL_Errno e,
5561                                        void *response, size_t responseLen) {
5562 #if VDBG
5563     RLOGD("setInitialAttachApnResponse: serial %d", serial);
5564 #endif
5565
5566     if (radioService[slotId]->mRadioResponse != NULL) {
5567         RadioResponseInfo responseInfo = {};
5568         populateResponseInfo(responseInfo, serial, responseType, e);
5569         Return<void> retStatus
5570                 = radioService[slotId]->mRadioResponse->setInitialAttachApnResponse(responseInfo);
5571         radioService[slotId]->checkReturnStatus(retStatus);
5572     } else {
5573         RLOGE("setInitialAttachApnResponse: radioService[%d]->mRadioResponse == NULL",
5574                 slotId);
5575     }
5576
5577     return 0;
5578 }
5579
5580 int radio::getImsRegistrationStateResponse(int slotId,
5581                                            int responseType, int serial, RIL_Errno e,
5582                                            void *response, size_t responseLen) {
5583 #if VDBG
5584     RLOGD("getImsRegistrationStateResponse: serial %d", serial);
5585 #endif
5586
5587     if (radioService[slotId]->mRadioResponse != NULL) {
5588         RadioResponseInfo responseInfo = {};
5589         populateResponseInfo(responseInfo, serial, responseType, e);
5590         bool isRegistered = false;
5591         int ratFamily = 0;
5592         int numInts = responseLen / sizeof(int);
5593         if (response == NULL || numInts != 2) {
5594             RLOGE("getImsRegistrationStateResponse Invalid response: NULL");
5595             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5596         } else {
5597             int *pInt = (int *) response;
5598             isRegistered = pInt[0] == 1 ? true : false;
5599             ratFamily = pInt[1];
5600         }
5601         Return<void> retStatus
5602                 = radioService[slotId]->mRadioResponse->getImsRegistrationStateResponse(
5603                 responseInfo, isRegistered, (RadioTechnologyFamily) ratFamily);
5604         radioService[slotId]->checkReturnStatus(retStatus);
5605     } else {
5606         RLOGE("getImsRegistrationStateResponse: radioService[%d]->mRadioResponse == NULL",
5607                 slotId);
5608     }
5609
5610     return 0;
5611 }
5612
5613 int radio::sendImsSmsResponse(int slotId,
5614                               int responseType, int serial, RIL_Errno e, void *response,
5615                               size_t responseLen) {
5616 #if VDBG
5617     RLOGD("sendImsSmsResponse: serial %d", serial);
5618 #endif
5619
5620     if (radioService[slotId]->mRadioResponse != NULL) {
5621         RadioResponseInfo responseInfo = {};
5622         SendSmsResult result = makeSendSmsResult(responseInfo, serial, responseType, e, response,
5623                 responseLen);
5624
5625         Return<void> retStatus
5626                 = radioService[slotId]->mRadioResponse->sendImsSmsResponse(responseInfo, result);
5627         radioService[slotId]->checkReturnStatus(retStatus);
5628     } else {
5629         RLOGE("sendSmsResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5630     }
5631
5632     return 0;
5633 }
5634
5635 int radio::iccTransmitApduBasicChannelResponse(int slotId,
5636                                                int responseType, int serial, RIL_Errno e,
5637                                                void *response, size_t responseLen) {
5638 #if VDBG
5639     RLOGD("iccTransmitApduBasicChannelResponse: serial %d", serial);
5640 #endif
5641
5642     if (radioService[slotId]->mRadioResponse != NULL) {
5643         RadioResponseInfo responseInfo = {};
5644         IccIoResult result = responseIccIo(responseInfo, serial, responseType, e, response,
5645                 responseLen);
5646
5647         Return<void> retStatus
5648                 = radioService[slotId]->mRadioResponse->iccTransmitApduBasicChannelResponse(
5649                 responseInfo, result);
5650         radioService[slotId]->checkReturnStatus(retStatus);
5651     } else {
5652         RLOGE("iccTransmitApduBasicChannelResponse: radioService[%d]->mRadioResponse "
5653                 "== NULL", slotId);
5654     }
5655
5656     return 0;
5657 }
5658
5659 int radio::iccOpenLogicalChannelResponse(int slotId,
5660                                          int responseType, int serial, RIL_Errno e, void *response,
5661                                          size_t responseLen) {
5662 #if VDBG
5663     RLOGD("iccOpenLogicalChannelResponse: serial %d", serial);
5664 #endif
5665
5666     if (radioService[slotId]->mRadioResponse != NULL) {
5667         RadioResponseInfo responseInfo = {};
5668         populateResponseInfo(responseInfo, serial, responseType, e);
5669         int channelId = -1;
5670         hidl_vec<int8_t> selectResponse;
5671         int numInts = responseLen / sizeof(int);
5672         if (response == NULL || responseLen % sizeof(int) != 0) {
5673             RLOGE("iccOpenLogicalChannelResponse Invalid response: NULL");
5674             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5675         } else {
5676             int *pInt = (int *) response;
5677             channelId = pInt[0];
5678             selectResponse.resize(numInts - 1);
5679             for (int i = 1; i < numInts; i++) {
5680                 selectResponse[i - 1] = (int8_t) pInt[i];
5681             }
5682         }
5683         Return<void> retStatus
5684                 = radioService[slotId]->mRadioResponse->iccOpenLogicalChannelResponse(responseInfo,
5685                 channelId, selectResponse);
5686         radioService[slotId]->checkReturnStatus(retStatus);
5687     } else {
5688         RLOGE("iccOpenLogicalChannelResponse: radioService[%d]->mRadioResponse == NULL",
5689                 slotId);
5690     }
5691
5692     return 0;
5693 }
5694
5695 int radio::iccCloseLogicalChannelResponse(int slotId,
5696                                           int responseType, int serial, RIL_Errno e,
5697                                           void *response, size_t responseLen) {
5698 #if VDBG
5699     RLOGD("iccCloseLogicalChannelResponse: serial %d", serial);
5700 #endif
5701
5702     if (radioService[slotId]->mRadioResponse != NULL) {
5703         RadioResponseInfo responseInfo = {};
5704         populateResponseInfo(responseInfo, serial, responseType, e);
5705         Return<void> retStatus
5706                 = radioService[slotId]->mRadioResponse->iccCloseLogicalChannelResponse(
5707                 responseInfo);
5708         radioService[slotId]->checkReturnStatus(retStatus);
5709     } else {
5710         RLOGE("iccCloseLogicalChannelResponse: radioService[%d]->mRadioResponse == NULL",
5711                 slotId);
5712     }
5713
5714     return 0;
5715 }
5716
5717 int radio::iccTransmitApduLogicalChannelResponse(int slotId,
5718                                                  int responseType, int serial, RIL_Errno e,
5719                                                  void *response, size_t responseLen) {
5720 #if VDBG
5721     RLOGD("iccTransmitApduLogicalChannelResponse: serial %d", serial);
5722 #endif
5723
5724     if (radioService[slotId]->mRadioResponse != NULL) {
5725         RadioResponseInfo responseInfo = {};
5726         IccIoResult result = responseIccIo(responseInfo, serial, responseType, e, response,
5727                 responseLen);
5728
5729         Return<void> retStatus
5730                 = radioService[slotId]->mRadioResponse->iccTransmitApduLogicalChannelResponse(
5731                 responseInfo, result);
5732         radioService[slotId]->checkReturnStatus(retStatus);
5733     } else {
5734         RLOGE("iccTransmitApduLogicalChannelResponse: radioService[%d]->mRadioResponse "
5735                 "== NULL", slotId);
5736     }
5737
5738     return 0;
5739 }
5740
5741 int radio::nvReadItemResponse(int slotId,
5742                               int responseType, int serial, RIL_Errno e,
5743                               void *response, size_t responseLen) {
5744 #if VDBG
5745     RLOGD("nvReadItemResponse: serial %d", serial);
5746 #endif
5747
5748     if (radioService[slotId]->mRadioResponse != NULL) {
5749         RadioResponseInfo responseInfo = {};
5750         populateResponseInfo(responseInfo, serial, responseType, e);
5751         Return<void> retStatus = radioService[slotId]->mRadioResponse->nvReadItemResponse(
5752                 responseInfo,
5753                 convertCharPtrToHidlString((char *) response));
5754         radioService[slotId]->checkReturnStatus(retStatus);
5755     } else {
5756         RLOGE("nvReadItemResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5757     }
5758
5759     return 0;
5760 }
5761
5762 int radio::nvWriteItemResponse(int slotId,
5763                                int responseType, int serial, RIL_Errno e,
5764                                void *response, size_t responseLen) {
5765 #if VDBG
5766     RLOGD("nvWriteItemResponse: serial %d", serial);
5767 #endif
5768
5769     if (radioService[slotId]->mRadioResponse != NULL) {
5770         RadioResponseInfo responseInfo = {};
5771         populateResponseInfo(responseInfo, serial, responseType, e);
5772         Return<void> retStatus
5773                 = radioService[slotId]->mRadioResponse->nvWriteItemResponse(responseInfo);
5774         radioService[slotId]->checkReturnStatus(retStatus);
5775     } else {
5776         RLOGE("nvWriteItemResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5777     }
5778
5779     return 0;
5780 }
5781
5782 int radio::nvWriteCdmaPrlResponse(int slotId,
5783                                   int responseType, int serial, RIL_Errno e,
5784                                   void *response, size_t responseLen) {
5785 #if VDBG
5786     RLOGD("nvWriteCdmaPrlResponse: serial %d", serial);
5787 #endif
5788
5789     if (radioService[slotId]->mRadioResponse != NULL) {
5790         RadioResponseInfo responseInfo = {};
5791         populateResponseInfo(responseInfo, serial, responseType, e);
5792         Return<void> retStatus
5793                 = radioService[slotId]->mRadioResponse->nvWriteCdmaPrlResponse(responseInfo);
5794         radioService[slotId]->checkReturnStatus(retStatus);
5795     } else {
5796         RLOGE("nvWriteCdmaPrlResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5797     }
5798
5799     return 0;
5800 }
5801
5802 int radio::nvResetConfigResponse(int slotId,
5803                                  int responseType, int serial, RIL_Errno e,
5804                                  void *response, size_t responseLen) {
5805 #if VDBG
5806     RLOGD("nvResetConfigResponse: serial %d", serial);
5807 #endif
5808
5809     if (radioService[slotId]->mRadioResponse != NULL) {
5810         RadioResponseInfo responseInfo = {};
5811         populateResponseInfo(responseInfo, serial, responseType, e);
5812         Return<void> retStatus
5813                 = radioService[slotId]->mRadioResponse->nvResetConfigResponse(responseInfo);
5814         radioService[slotId]->checkReturnStatus(retStatus);
5815     } else {
5816         RLOGE("nvResetConfigResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5817     }
5818
5819     return 0;
5820 }
5821
5822 int radio::setUiccSubscriptionResponse(int slotId,
5823                                        int responseType, int serial, RIL_Errno e,
5824                                        void *response, size_t responseLen) {
5825 #if VDBG
5826     RLOGD("setUiccSubscriptionResponse: serial %d", serial);
5827 #endif
5828
5829     if (radioService[slotId]->mRadioResponse != NULL) {
5830         RadioResponseInfo responseInfo = {};
5831         populateResponseInfo(responseInfo, serial, responseType, e);
5832         Return<void> retStatus
5833                 = radioService[slotId]->mRadioResponse->setUiccSubscriptionResponse(responseInfo);
5834         radioService[slotId]->checkReturnStatus(retStatus);
5835     } else {
5836         RLOGE("setUiccSubscriptionResponse: radioService[%d]->mRadioResponse == NULL",
5837                 slotId);
5838     }
5839
5840     return 0;
5841 }
5842
5843 int radio::setDataAllowedResponse(int slotId,
5844                                   int responseType, int serial, RIL_Errno e,
5845                                   void *response, size_t responseLen) {
5846 #if VDBG
5847     RLOGD("setDataAllowedResponse: serial %d", serial);
5848 #endif
5849
5850     if (radioService[slotId]->mRadioResponse != NULL) {
5851         RadioResponseInfo responseInfo = {};
5852         populateResponseInfo(responseInfo, serial, responseType, e);
5853         Return<void> retStatus
5854                 = radioService[slotId]->mRadioResponse->setDataAllowedResponse(responseInfo);
5855         radioService[slotId]->checkReturnStatus(retStatus);
5856     } else {
5857         RLOGE("setDataAllowedResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5858     }
5859
5860     return 0;
5861 }
5862
5863 int radio::getHardwareConfigResponse(int slotId,
5864                                      int responseType, int serial, RIL_Errno e,
5865                                      void *response, size_t responseLen) {
5866 #if VDBG
5867     RLOGD("getHardwareConfigResponse: serial %d", serial);
5868 #endif
5869
5870     if (radioService[slotId]->mRadioResponse != NULL) {
5871         RadioResponseInfo responseInfo = {};
5872         populateResponseInfo(responseInfo, serial, responseType, e);
5873
5874         hidl_vec<HardwareConfig> result;
5875         if (response == NULL || responseLen % sizeof(RIL_HardwareConfig) != 0) {
5876             RLOGE("hardwareConfigChangedInd: invalid response");
5877             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5878         } else {
5879             convertRilHardwareConfigListToHal(response, responseLen, result);
5880         }
5881
5882         Return<void> retStatus = radioService[slotId]->mRadioResponse->getHardwareConfigResponse(
5883                 responseInfo, result);
5884         radioService[slotId]->checkReturnStatus(retStatus);
5885     } else {
5886         RLOGE("getHardwareConfigResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5887     }
5888
5889     return 0;
5890 }
5891
5892 int radio::requestIccSimAuthenticationResponse(int slotId,
5893                                                int responseType, int serial, RIL_Errno e,
5894                                                void *response, size_t responseLen) {
5895 #if VDBG
5896     RLOGD("requestIccSimAuthenticationResponse: serial %d", serial);
5897 #endif
5898
5899     if (radioService[slotId]->mRadioResponse != NULL) {
5900         RadioResponseInfo responseInfo = {};
5901         IccIoResult result = responseIccIo(responseInfo, serial, responseType, e, response,
5902                 responseLen);
5903
5904         Return<void> retStatus
5905                 = radioService[slotId]->mRadioResponse->requestIccSimAuthenticationResponse(
5906                 responseInfo, result);
5907         radioService[slotId]->checkReturnStatus(retStatus);
5908     } else {
5909         RLOGE("requestIccSimAuthenticationResponse: radioService[%d]->mRadioResponse "
5910                 "== NULL", slotId);
5911     }
5912
5913     return 0;
5914 }
5915
5916 int radio::setDataProfileResponse(int slotId,
5917                                   int responseType, int serial, RIL_Errno e,
5918                                   void *response, size_t responseLen) {
5919 #if VDBG
5920     RLOGD("setDataProfileResponse: serial %d", serial);
5921 #endif
5922
5923     if (radioService[slotId]->mRadioResponse != NULL) {
5924         RadioResponseInfo responseInfo = {};
5925         populateResponseInfo(responseInfo, serial, responseType, e);
5926         Return<void> retStatus
5927                 = radioService[slotId]->mRadioResponse->setDataProfileResponse(responseInfo);
5928         radioService[slotId]->checkReturnStatus(retStatus);
5929     } else {
5930         RLOGE("setDataProfileResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5931     }
5932
5933     return 0;
5934 }
5935
5936 int radio::requestShutdownResponse(int slotId,
5937                                   int responseType, int serial, RIL_Errno e,
5938                                   void *response, size_t responseLen) {
5939 #if VDBG
5940     RLOGD("requestShutdownResponse: serial %d", serial);
5941 #endif
5942
5943     if (radioService[slotId]->mRadioResponse != NULL) {
5944         RadioResponseInfo responseInfo = {};
5945         populateResponseInfo(responseInfo, serial, responseType, e);
5946         Return<void> retStatus
5947                 = radioService[slotId]->mRadioResponse->requestShutdownResponse(responseInfo);
5948         radioService[slotId]->checkReturnStatus(retStatus);
5949     } else {
5950         RLOGE("requestShutdownResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5951     }
5952
5953     return 0;
5954 }
5955
5956 void responseRadioCapability(RadioResponseInfo& responseInfo, int serial,
5957         int responseType, RIL_Errno e, void *response, size_t responseLen, RadioCapability& rc) {
5958     populateResponseInfo(responseInfo, serial, responseType, e);
5959
5960     if (response == NULL || responseLen != sizeof(RIL_RadioCapability)) {
5961         RLOGE("responseRadioCapability: Invalid response");
5962         if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5963         rc.logicalModemUuid = hidl_string();
5964     } else {
5965         convertRilRadioCapabilityToHal(response, responseLen, rc);
5966     }
5967 }
5968
5969 int radio::getRadioCapabilityResponse(int slotId,
5970                                      int responseType, int serial, RIL_Errno e,
5971                                      void *response, size_t responseLen) {
5972 #if VDBG
5973     RLOGD("getRadioCapabilityResponse: serial %d", serial);
5974 #endif
5975
5976     if (radioService[slotId]->mRadioResponse != NULL) {
5977         RadioResponseInfo responseInfo = {};
5978         RadioCapability result = {};
5979         responseRadioCapability(responseInfo, serial, responseType, e, response, responseLen,
5980                 result);
5981         Return<void> retStatus = radioService[slotId]->mRadioResponse->getRadioCapabilityResponse(
5982                 responseInfo, result);
5983         radioService[slotId]->checkReturnStatus(retStatus);
5984     } else {
5985         RLOGE("getRadioCapabilityResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5986     }
5987
5988     return 0;
5989 }
5990
5991 int radio::setRadioCapabilityResponse(int slotId,
5992                                      int responseType, int serial, RIL_Errno e,
5993                                      void *response, size_t responseLen) {
5994 #if VDBG
5995     RLOGD("setRadioCapabilityResponse: serial %d", serial);
5996 #endif
5997
5998     if (radioService[slotId]->mRadioResponse != NULL) {
5999         RadioResponseInfo responseInfo = {};
6000         RadioCapability result = {};
6001         responseRadioCapability(responseInfo, serial, responseType, e, response, responseLen,
6002                 result);
6003         Return<void> retStatus = radioService[slotId]->mRadioResponse->setRadioCapabilityResponse(
6004                 responseInfo, result);
6005         radioService[slotId]->checkReturnStatus(retStatus);
6006     } else {
6007         RLOGE("setRadioCapabilityResponse: radioService[%d]->mRadioResponse == NULL", slotId);
6008     }
6009
6010     return 0;
6011 }
6012
6013 LceStatusInfo responseLceStatusInfo(RadioResponseInfo& responseInfo, int serial, int responseType,
6014                                     RIL_Errno e, void *response, size_t responseLen) {
6015     populateResponseInfo(responseInfo, serial, responseType, e);
6016     LceStatusInfo result = {};
6017
6018     if (response == NULL || responseLen != sizeof(RIL_LceStatusInfo)) {
6019         RLOGE("Invalid response: NULL");
6020         if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
6021     } else {
6022         RIL_LceStatusInfo *resp = (RIL_LceStatusInfo *) response;
6023         result.lceStatus = (LceStatus) resp->lce_status;
6024         result.actualIntervalMs = (uint8_t) resp->actual_interval_ms;
6025     }
6026     return result;
6027 }
6028
6029 int radio::startLceServiceResponse(int slotId,
6030                                    int responseType, int serial, RIL_Errno e,
6031                                    void *response, size_t responseLen) {
6032 #if VDBG
6033     RLOGD("startLceServiceResponse: serial %d", serial);
6034 #endif
6035
6036     if (radioService[slotId]->mRadioResponse != NULL) {
6037         RadioResponseInfo responseInfo = {};
6038         LceStatusInfo result = responseLceStatusInfo(responseInfo, serial, responseType, e,
6039                 response, responseLen);
6040
6041         Return<void> retStatus
6042                 = radioService[slotId]->mRadioResponse->startLceServiceResponse(responseInfo,
6043                 result);
6044         radioService[slotId]->checkReturnStatus(retStatus);
6045     } else {
6046         RLOGE("startLceServiceResponse: radioService[%d]->mRadioResponse == NULL", slotId);
6047     }
6048
6049     return 0;
6050 }
6051
6052 int radio::stopLceServiceResponse(int slotId,
6053                                   int responseType, int serial, RIL_Errno e,
6054                                   void *response, size_t responseLen) {
6055 #if VDBG
6056     RLOGD("stopLceServiceResponse: serial %d", serial);
6057 #endif
6058
6059     if (radioService[slotId]->mRadioResponse != NULL) {
6060         RadioResponseInfo responseInfo = {};
6061         LceStatusInfo result = responseLceStatusInfo(responseInfo, serial, responseType, e,
6062                 response, responseLen);
6063
6064         Return<void> retStatus
6065                 = radioService[slotId]->mRadioResponse->stopLceServiceResponse(responseInfo,
6066                 result);
6067         radioService[slotId]->checkReturnStatus(retStatus);
6068     } else {
6069         RLOGE("stopLceServiceResponse: radioService[%d]->mRadioResponse == NULL", slotId);
6070     }
6071
6072     return 0;
6073 }
6074
6075 int radio::pullLceDataResponse(int slotId,
6076                                int responseType, int serial, RIL_Errno e,
6077                                void *response, size_t responseLen) {
6078 #if VDBG
6079     RLOGD("pullLceDataResponse: serial %d", serial);
6080 #endif
6081
6082     if (radioService[slotId]->mRadioResponse != NULL) {
6083         RadioResponseInfo responseInfo = {};
6084         populateResponseInfo(responseInfo, serial, responseType, e);
6085
6086         LceDataInfo result = {};
6087         if (response == NULL || responseLen != sizeof(RIL_LceDataInfo)) {
6088             RLOGE("pullLceDataResponse: Invalid response");
6089             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
6090         } else {
6091             convertRilLceDataInfoToHal(response, responseLen, result);
6092         }
6093
6094         Return<void> retStatus = radioService[slotId]->mRadioResponse->pullLceDataResponse(
6095                 responseInfo, result);
6096         radioService[slotId]->checkReturnStatus(retStatus);
6097     } else {
6098         RLOGE("pullLceDataResponse: radioService[%d]->mRadioResponse == NULL", slotId);
6099     }
6100
6101     return 0;
6102 }
6103
6104 int radio::getModemActivityInfoResponse(int slotId,
6105                                         int responseType, int serial, RIL_Errno e,
6106                                         void *response, size_t responseLen) {
6107 #if VDBG
6108     RLOGD("getModemActivityInfoResponse: serial %d", serial);
6109 #endif
6110
6111     if (radioService[slotId]->mRadioResponse != NULL) {
6112         RadioResponseInfo responseInfo = {};
6113         populateResponseInfo(responseInfo, serial, responseType, e);
6114         ActivityStatsInfo info;
6115         if (response == NULL || responseLen != sizeof(RIL_ActivityStatsInfo)) {
6116             RLOGE("getModemActivityInfoResponse Invalid response: NULL");
6117             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
6118         } else {
6119             RIL_ActivityStatsInfo *resp = (RIL_ActivityStatsInfo *)response;
6120             info.sleepModeTimeMs = resp->sleep_mode_time_ms;
6121             info.idleModeTimeMs = resp->idle_mode_time_ms;
6122             for(int i = 0; i < RIL_NUM_TX_POWER_LEVELS; i++) {
6123                 info.txmModetimeMs[i] = resp->tx_mode_time_ms[i];
6124             }
6125             info.rxModeTimeMs = resp->rx_mode_time_ms;
6126         }
6127
6128         Return<void> retStatus
6129                 = radioService[slotId]->mRadioResponse->getModemActivityInfoResponse(responseInfo,
6130                 info);
6131         radioService[slotId]->checkReturnStatus(retStatus);
6132     } else {
6133         RLOGE("getModemActivityInfoResponse: radioService[%d]->mRadioResponse == NULL",
6134                 slotId);
6135     }
6136
6137     return 0;
6138 }
6139
6140 int radio::setAllowedCarriersResponse(int slotId,
6141                                       int responseType, int serial, RIL_Errno e,
6142                                       void *response, size_t responseLen) {
6143 #if VDBG
6144     RLOGD("setAllowedCarriersResponse: serial %d", serial);
6145 #endif
6146
6147     if (radioService[slotId]->mRadioResponse != NULL) {
6148         RadioResponseInfo responseInfo = {};
6149         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
6150         Return<void> retStatus
6151                 = radioService[slotId]->mRadioResponse->setAllowedCarriersResponse(responseInfo,
6152                 ret);
6153         radioService[slotId]->checkReturnStatus(retStatus);
6154     } else {
6155         RLOGE("setAllowedCarriersResponse: radioService[%d]->mRadioResponse == NULL",
6156                 slotId);
6157     }
6158
6159     return 0;
6160 }
6161
6162 int radio::getAllowedCarriersResponse(int slotId,
6163                                       int responseType, int serial, RIL_Errno e,
6164                                       void *response, size_t responseLen) {
6165 #if VDBG
6166     RLOGD("getAllowedCarriersResponse: serial %d", serial);
6167 #endif
6168
6169     if (radioService[slotId]->mRadioResponse != NULL) {
6170         RadioResponseInfo responseInfo = {};
6171         populateResponseInfo(responseInfo, serial, responseType, e);
6172         CarrierRestrictions carrierInfo = {};
6173         bool allAllowed = true;
6174         if (response == NULL || responseLen != sizeof(RIL_CarrierRestrictions)) {
6175             RLOGE("getAllowedCarriersResponse Invalid response: NULL");
6176             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
6177         } else {
6178             RIL_CarrierRestrictions *pCr = (RIL_CarrierRestrictions *)response;
6179             if (pCr->len_allowed_carriers > 0 || pCr->len_excluded_carriers > 0) {
6180                 allAllowed = false;
6181             }
6182
6183             carrierInfo.allowedCarriers.resize(pCr->len_allowed_carriers);
6184             for(int i = 0; i < pCr->len_allowed_carriers; i++) {
6185                 RIL_Carrier *carrier = pCr->allowed_carriers + i;
6186                 carrierInfo.allowedCarriers[i].mcc = convertCharPtrToHidlString(carrier->mcc);
6187                 carrierInfo.allowedCarriers[i].mnc = convertCharPtrToHidlString(carrier->mnc);
6188                 carrierInfo.allowedCarriers[i].matchType = (CarrierMatchType) carrier->match_type;
6189                 carrierInfo.allowedCarriers[i].matchData =
6190                         convertCharPtrToHidlString(carrier->match_data);
6191             }
6192
6193             carrierInfo.excludedCarriers.resize(pCr->len_excluded_carriers);
6194             for(int i = 0; i < pCr->len_excluded_carriers; i++) {
6195                 RIL_Carrier *carrier = pCr->excluded_carriers + i;
6196                 carrierInfo.excludedCarriers[i].mcc = convertCharPtrToHidlString(carrier->mcc);
6197                 carrierInfo.excludedCarriers[i].mnc = convertCharPtrToHidlString(carrier->mnc);
6198                 carrierInfo.excludedCarriers[i].matchType = (CarrierMatchType) carrier->match_type;
6199                 carrierInfo.excludedCarriers[i].matchData =
6200                         convertCharPtrToHidlString(carrier->match_data);
6201             }
6202         }
6203
6204         Return<void> retStatus
6205                 = radioService[slotId]->mRadioResponse->getAllowedCarriersResponse(responseInfo,
6206                 allAllowed, carrierInfo);
6207         radioService[slotId]->checkReturnStatus(retStatus);
6208     } else {
6209         RLOGE("getAllowedCarriersResponse: radioService[%d]->mRadioResponse == NULL",
6210                 slotId);
6211     }
6212
6213     return 0;
6214 }
6215
6216 int radio::sendDeviceStateResponse(int slotId,
6217                               int responseType, int serial, RIL_Errno e,
6218                               void *response, size_t responselen) {
6219 #if VDBG
6220     RLOGD("sendDeviceStateResponse: serial %d", serial);
6221 #endif
6222
6223     if (radioService[slotId]->mRadioResponse != NULL) {
6224         RadioResponseInfo responseInfo = {};
6225         populateResponseInfo(responseInfo, serial, responseType, e);
6226         Return<void> retStatus
6227                 = radioService[slotId]->mRadioResponse->sendDeviceStateResponse(responseInfo);
6228         radioService[slotId]->checkReturnStatus(retStatus);
6229     } else {
6230         RLOGE("sendDeviceStateResponse: radioService[%d]->mRadioResponse == NULL", slotId);
6231     }
6232
6233     return 0;
6234 }
6235
6236 int radio::setIndicationFilterResponse(int slotId,
6237                               int responseType, int serial, RIL_Errno e,
6238                               void *response, size_t responselen) {
6239 #if VDBG
6240     RLOGD("setIndicationFilterResponse: serial %d", serial);
6241 #endif
6242
6243     if (radioService[slotId]->mRadioResponse != NULL) {
6244         RadioResponseInfo responseInfo = {};
6245         populateResponseInfo(responseInfo, serial, responseType, e);
6246         Return<void> retStatus
6247                 = radioService[slotId]->mRadioResponse->setIndicationFilterResponse(responseInfo);
6248         radioService[slotId]->checkReturnStatus(retStatus);
6249     } else {
6250         RLOGE("setIndicationFilterResponse: radioService[%d]->mRadioResponse == NULL",
6251                 slotId);
6252     }
6253
6254     return 0;
6255 }
6256
6257
6258 int radio::setSimCardPowerResponse(int slotId,
6259                                    int responseType, int serial, RIL_Errno e,
6260                                    void *response, size_t responseLen) {
6261 #if VDBG
6262     RLOGD("setSimCardPowerResponse: serial %d", serial);
6263 #endif
6264
6265     if (radioService[slotId]->mRadioResponse != NULL) {
6266         RadioResponseInfo responseInfo = {};
6267         populateResponseInfo(responseInfo, serial, responseType, e);
6268         Return<void> retStatus
6269                 = radioService[slotId]->mRadioResponse->setSimCardPowerResponse(responseInfo);
6270         radioService[slotId]->checkReturnStatus(retStatus);
6271     } else {
6272         RLOGE("setSimCardPowerResponse: radioService[%d]->mRadioResponse == NULL", slotId);
6273     }
6274
6275     return 0;
6276 }
6277
6278 int radio::sendRequestRawResponse(int slotId,
6279                                   int responseType, int serial, RIL_Errno e,
6280                                   void *response, size_t responseLen) {
6281 #if VDBG
6282    RLOGD("sendRequestRawResponse: serial %d", serial);
6283 #endif
6284
6285     if (oemHookService[slotId]->mOemHookResponse != NULL) {
6286         RadioResponseInfo responseInfo = {};
6287         populateResponseInfo(responseInfo, serial, responseType, e);
6288         hidl_vec<uint8_t> data;
6289
6290         if (response == NULL) {
6291             RLOGE("sendRequestRawResponse: Invalid response");
6292             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
6293         } else {
6294             data.setToExternal((uint8_t *) response, responseLen);
6295         }
6296         Return<void> retStatus = oemHookService[slotId]->mOemHookResponse->
6297                 sendRequestRawResponse(responseInfo, data);
6298         checkReturnStatus(slotId, retStatus, false);
6299     } else {
6300         RLOGE("sendRequestRawResponse: oemHookService[%d]->mOemHookResponse == NULL",
6301                 slotId);
6302     }
6303
6304     return 0;
6305 }
6306
6307 int radio::sendRequestStringsResponse(int slotId,
6308                                       int responseType, int serial, RIL_Errno e,
6309                                       void *response, size_t responseLen) {
6310 #if VDBG
6311     RLOGD("sendRequestStringsResponse: serial %d", serial);
6312 #endif
6313
6314     if (oemHookService[slotId]->mOemHookResponse != NULL) {
6315         RadioResponseInfo responseInfo = {};
6316         populateResponseInfo(responseInfo, serial, responseType, e);
6317         hidl_vec<hidl_string> data;
6318
6319         if (response == NULL || responseLen % sizeof(char *) != 0) {
6320             RLOGE("sendRequestStringsResponse Invalid response: NULL");
6321             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
6322         } else {
6323             char **resp = (char **) response;
6324             int numStrings = responseLen / sizeof(char *);
6325             data.resize(numStrings);
6326             for (int i = 0; i < numStrings; i++) {
6327                 data[i] = convertCharPtrToHidlString(resp[i]);
6328             }
6329         }
6330         Return<void> retStatus
6331                 = oemHookService[slotId]->mOemHookResponse->sendRequestStringsResponse(
6332                 responseInfo, data);
6333         checkReturnStatus(slotId, retStatus, false);
6334     } else {
6335         RLOGE("sendRequestStringsResponse: oemHookService[%d]->mOemHookResponse == "
6336                 "NULL", slotId);
6337     }
6338
6339     return 0;
6340 }
6341
6342 // Radio Indication functions
6343
6344 RadioIndicationType convertIntToRadioIndicationType(int indicationType) {
6345     return indicationType == RESPONSE_UNSOLICITED ? (RadioIndicationType::UNSOLICITED) :
6346             (RadioIndicationType::UNSOLICITED_ACK_EXP);
6347 }
6348
6349 int radio::radioStateChangedInd(int slotId,
6350                                  int indicationType, int token, RIL_Errno e, void *response,
6351                                  size_t responseLen) {
6352     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6353         RadioState radioState = (RadioState) s_vendorFunctions->onStateRequest();
6354         RLOGD("radioStateChangedInd: radioState %d", radioState);
6355         Return<void> retStatus = radioService[slotId]->mRadioIndication->radioStateChanged(
6356                 convertIntToRadioIndicationType(indicationType), radioState);
6357         radioService[slotId]->checkReturnStatus(retStatus);
6358     } else {
6359         RLOGE("radioStateChangedInd: radioService[%d]->mRadioIndication == NULL", slotId);
6360     }
6361
6362     return 0;
6363 }
6364
6365 int radio::callStateChangedInd(int slotId,
6366                                int indicationType, int token, RIL_Errno e, void *response,
6367                                size_t responseLen) {
6368     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6369 #if VDBG
6370         RLOGD("callStateChangedInd");
6371 #endif
6372         Return<void> retStatus = radioService[slotId]->mRadioIndication->callStateChanged(
6373                 convertIntToRadioIndicationType(indicationType));
6374         radioService[slotId]->checkReturnStatus(retStatus);
6375     } else {
6376         RLOGE("callStateChangedInd: radioService[%d]->mRadioIndication == NULL", slotId);
6377     }
6378
6379     return 0;
6380 }
6381
6382 int radio::networkStateChangedInd(int slotId,
6383                                   int indicationType, int token, RIL_Errno e, void *response,
6384                                   size_t responseLen) {
6385     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6386 #if VDBG
6387         RLOGD("networkStateChangedInd");
6388 #endif
6389         Return<void> retStatus = radioService[slotId]->mRadioIndication->networkStateChanged(
6390                 convertIntToRadioIndicationType(indicationType));
6391         radioService[slotId]->checkReturnStatus(retStatus);
6392     } else {
6393         RLOGE("networkStateChangedInd: radioService[%d]->mRadioIndication == NULL",
6394                 slotId);
6395     }
6396
6397     return 0;
6398 }
6399
6400 uint8_t hexCharToInt(uint8_t c) {
6401     if (c >= '0' && c <= '9') return (c - '0');
6402     if (c >= 'A' && c <= 'F') return (c - 'A' + 10);
6403     if (c >= 'a' && c <= 'f') return (c - 'a' + 10);
6404
6405     return INVALID_HEX_CHAR;
6406 }
6407
6408 uint8_t * convertHexStringToBytes(void *response, size_t responseLen) {
6409     if (responseLen % 2 != 0) {
6410         return NULL;
6411     }
6412
6413     uint8_t *bytes = (uint8_t *)calloc(responseLen/2, sizeof(uint8_t));
6414     if (bytes == NULL) {
6415         RLOGE("convertHexStringToBytes: cannot allocate memory for bytes string");
6416         return NULL;
6417     }
6418     uint8_t *hexString = (uint8_t *)response;
6419
6420     for (size_t i = 0; i < responseLen; i += 2) {
6421         uint8_t hexChar1 = hexCharToInt(hexString[i]);
6422         uint8_t hexChar2 = hexCharToInt(hexString[i + 1]);
6423
6424         if (hexChar1 == INVALID_HEX_CHAR || hexChar2 == INVALID_HEX_CHAR) {
6425             RLOGE("convertHexStringToBytes: invalid hex char %d %d",
6426                     hexString[i], hexString[i + 1]);
6427             free(bytes);
6428             return NULL;
6429         }
6430         bytes[i/2] = ((hexChar1 << 4) | hexChar2);
6431     }
6432
6433     return bytes;
6434 }
6435
6436 int radio::newSmsInd(int slotId, int indicationType,
6437                      int token, RIL_Errno e, void *response, size_t responseLen) {
6438     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6439         if (response == NULL || responseLen == 0) {
6440             RLOGE("newSmsInd: invalid response");
6441             return 0;
6442         }
6443
6444         uint8_t *bytes = convertHexStringToBytes(response, responseLen);
6445         if (bytes == NULL) {
6446             RLOGE("newSmsInd: convertHexStringToBytes failed");
6447             return 0;
6448         }
6449
6450         hidl_vec<uint8_t> pdu;
6451         pdu.setToExternal(bytes, responseLen/2);
6452 #if VDBG
6453         RLOGD("newSmsInd");
6454 #endif
6455         Return<void> retStatus = radioService[slotId]->mRadioIndication->newSms(
6456                 convertIntToRadioIndicationType(indicationType), pdu);
6457         radioService[slotId]->checkReturnStatus(retStatus);
6458         free(bytes);
6459     } else {
6460         RLOGE("newSmsInd: radioService[%d]->mRadioIndication == NULL", slotId);
6461     }
6462
6463     return 0;
6464 }
6465
6466 int radio::newSmsStatusReportInd(int slotId,
6467                                  int indicationType, int token, RIL_Errno e, void *response,
6468                                  size_t responseLen) {
6469     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6470         if (response == NULL || responseLen == 0) {
6471             RLOGE("newSmsStatusReportInd: invalid response");
6472             return 0;
6473         }
6474
6475         uint8_t *bytes = convertHexStringToBytes(response, responseLen);
6476         if (bytes == NULL) {
6477             RLOGE("newSmsStatusReportInd: convertHexStringToBytes failed");
6478             return 0;
6479         }
6480
6481         hidl_vec<uint8_t> pdu;
6482         pdu.setToExternal(bytes, responseLen/2);
6483 #if VDBG
6484         RLOGD("newSmsStatusReportInd");
6485 #endif
6486         Return<void> retStatus = radioService[slotId]->mRadioIndication->newSmsStatusReport(
6487                 convertIntToRadioIndicationType(indicationType), pdu);
6488         radioService[slotId]->checkReturnStatus(retStatus);
6489         free(bytes);
6490     } else {
6491         RLOGE("newSmsStatusReportInd: radioService[%d]->mRadioIndication == NULL", slotId);
6492     }
6493
6494     return 0;
6495 }
6496
6497 int radio::newSmsOnSimInd(int slotId, int indicationType,
6498                           int token, RIL_Errno e, void *response, size_t responseLen) {
6499     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6500         if (response == NULL || responseLen != sizeof(int)) {
6501             RLOGE("newSmsOnSimInd: invalid response");
6502             return 0;
6503         }
6504         int32_t recordNumber = ((int32_t *) response)[0];
6505 #if VDBG
6506         RLOGD("newSmsOnSimInd: slotIndex %d", recordNumber);
6507 #endif
6508         Return<void> retStatus = radioService[slotId]->mRadioIndication->newSmsOnSim(
6509                 convertIntToRadioIndicationType(indicationType), recordNumber);
6510         radioService[slotId]->checkReturnStatus(retStatus);
6511     } else {
6512         RLOGE("newSmsOnSimInd: radioService[%d]->mRadioIndication == NULL", slotId);
6513     }
6514
6515     return 0;
6516 }
6517
6518 int radio::onUssdInd(int slotId, int indicationType,
6519                      int token, RIL_Errno e, void *response, size_t responseLen) {
6520     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6521         if (response == NULL || responseLen != 2 * sizeof(char *)) {
6522             RLOGE("onUssdInd: invalid response");
6523             return 0;
6524         }
6525         char **strings = (char **) response;
6526         char *mode = strings[0];
6527         hidl_string msg = convertCharPtrToHidlString(strings[1]);
6528         UssdModeType modeType = (UssdModeType) atoi(mode);
6529 #if VDBG
6530         RLOGD("onUssdInd: mode %s", mode);
6531 #endif
6532         Return<void> retStatus = radioService[slotId]->mRadioIndication->onUssd(
6533                 convertIntToRadioIndicationType(indicationType), modeType, msg);
6534         radioService[slotId]->checkReturnStatus(retStatus);
6535     } else {
6536         RLOGE("onUssdInd: radioService[%d]->mRadioIndication == NULL", slotId);
6537     }
6538
6539     return 0;
6540 }
6541
6542 int radio::nitzTimeReceivedInd(int slotId,
6543                                int indicationType, int token, RIL_Errno e, void *response,
6544                                size_t responseLen) {
6545     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6546         if (response == NULL || responseLen == 0) {
6547             RLOGE("nitzTimeReceivedInd: invalid response");
6548             return 0;
6549         }
6550         hidl_string nitzTime = convertCharPtrToHidlString((char *) response);
6551         int64_t timeReceived = android::elapsedRealtime();
6552 #if VDBG
6553         RLOGD("nitzTimeReceivedInd: nitzTime %s receivedTime %" PRId64, nitzTime.c_str(),
6554                 timeReceived);
6555 #endif
6556         Return<void> retStatus = radioService[slotId]->mRadioIndication->nitzTimeReceived(
6557                 convertIntToRadioIndicationType(indicationType), nitzTime, timeReceived);
6558         radioService[slotId]->checkReturnStatus(retStatus);
6559     } else {
6560         RLOGE("nitzTimeReceivedInd: radioService[%d]->mRadioIndication == NULL", slotId);
6561         return -1;
6562     }
6563
6564     return 0;
6565 }
6566
6567 void convertRilSignalStrengthToHal(void *response, size_t responseLen,
6568         SignalStrength& signalStrength) {
6569     RIL_SignalStrength_v10 *rilSignalStrength = (RIL_SignalStrength_v10 *) response;
6570
6571     // Fixup LTE for backwards compatibility
6572     // signalStrength: -1 -> 99
6573     if (rilSignalStrength->LTE_SignalStrength.signalStrength == -1) {
6574         rilSignalStrength->LTE_SignalStrength.signalStrength = 99;
6575     }
6576     // rsrp: -1 -> INT_MAX all other negative value to positive.
6577     // So remap here
6578     if (rilSignalStrength->LTE_SignalStrength.rsrp == -1) {
6579         rilSignalStrength->LTE_SignalStrength.rsrp = INT_MAX;
6580     } else if (rilSignalStrength->LTE_SignalStrength.rsrp < -1) {
6581         rilSignalStrength->LTE_SignalStrength.rsrp = -rilSignalStrength->LTE_SignalStrength.rsrp;
6582     }
6583     // rsrq: -1 -> INT_MAX
6584     if (rilSignalStrength->LTE_SignalStrength.rsrq == -1) {
6585         rilSignalStrength->LTE_SignalStrength.rsrq = INT_MAX;
6586     }
6587     // Not remapping rssnr is already using INT_MAX
6588     // cqi: -1 -> INT_MAX
6589     if (rilSignalStrength->LTE_SignalStrength.cqi == -1) {
6590         rilSignalStrength->LTE_SignalStrength.cqi = INT_MAX;
6591     }
6592
6593     signalStrength.gw.signalStrength = rilSignalStrength->GW_SignalStrength.signalStrength;
6594     signalStrength.gw.bitErrorRate = rilSignalStrength->GW_SignalStrength.bitErrorRate;
6595     signalStrength.cdma.dbm = rilSignalStrength->CDMA_SignalStrength.dbm;
6596     signalStrength.cdma.ecio = rilSignalStrength->CDMA_SignalStrength.ecio;
6597     signalStrength.evdo.dbm = rilSignalStrength->EVDO_SignalStrength.dbm;
6598     signalStrength.evdo.ecio = rilSignalStrength->EVDO_SignalStrength.ecio;
6599     signalStrength.evdo.signalNoiseRatio =
6600             rilSignalStrength->EVDO_SignalStrength.signalNoiseRatio;
6601     signalStrength.lte.signalStrength = rilSignalStrength->LTE_SignalStrength.signalStrength;
6602     signalStrength.lte.rsrp = rilSignalStrength->LTE_SignalStrength.rsrp;
6603     signalStrength.lte.rsrq = rilSignalStrength->LTE_SignalStrength.rsrq;
6604     signalStrength.lte.rssnr = rilSignalStrength->LTE_SignalStrength.rssnr;
6605     signalStrength.lte.cqi = rilSignalStrength->LTE_SignalStrength.cqi;
6606     signalStrength.lte.timingAdvance = rilSignalStrength->LTE_SignalStrength.timingAdvance;
6607     signalStrength.tdScdma.rscp = rilSignalStrength->TD_SCDMA_SignalStrength.rscp;
6608 }
6609
6610 int radio::currentSignalStrengthInd(int slotId,
6611                                     int indicationType, int token, RIL_Errno e,
6612                                     void *response, size_t responseLen) {
6613     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6614         if (response == NULL || responseLen != sizeof(RIL_SignalStrength_v10)) {
6615             RLOGE("currentSignalStrengthInd: invalid response");
6616             return 0;
6617         }
6618
6619         SignalStrength signalStrength = {};
6620         convertRilSignalStrengthToHal(response, responseLen, signalStrength);
6621
6622 #if VDBG
6623         RLOGD("currentSignalStrengthInd");
6624 #endif
6625         Return<void> retStatus = radioService[slotId]->mRadioIndication->currentSignalStrength(
6626                 convertIntToRadioIndicationType(indicationType), signalStrength);
6627         radioService[slotId]->checkReturnStatus(retStatus);
6628     } else {
6629         RLOGE("currentSignalStrengthInd: radioService[%d]->mRadioIndication == NULL",
6630                 slotId);
6631     }
6632
6633     return 0;
6634 }
6635
6636 void convertRilDataCallToHal(RIL_Data_Call_Response_v11 *dcResponse,
6637         SetupDataCallResult& dcResult) {
6638     dcResult.status = (DataCallFailCause) dcResponse->status;
6639     dcResult.suggestedRetryTime = dcResponse->suggestedRetryTime;
6640     dcResult.cid = dcResponse->cid;
6641     dcResult.active = dcResponse->active;
6642     dcResult.type = convertCharPtrToHidlString(dcResponse->type);
6643     dcResult.ifname = convertCharPtrToHidlString(dcResponse->ifname);
6644     dcResult.addresses = convertCharPtrToHidlString(dcResponse->addresses);
6645     dcResult.dnses = convertCharPtrToHidlString(dcResponse->dnses);
6646     dcResult.gateways = convertCharPtrToHidlString(dcResponse->gateways);
6647     dcResult.pcscf = convertCharPtrToHidlString(dcResponse->pcscf);
6648     dcResult.mtu = dcResponse->mtu;
6649 }
6650
6651 void convertRilDataCallListToHal(void *response, size_t responseLen,
6652         hidl_vec<SetupDataCallResult>& dcResultList) {
6653     int num = responseLen / sizeof(RIL_Data_Call_Response_v11);
6654
6655     RIL_Data_Call_Response_v11 *dcResponse = (RIL_Data_Call_Response_v11 *) response;
6656     dcResultList.resize(num);
6657     for (int i = 0; i < num; i++) {
6658         convertRilDataCallToHal(&dcResponse[i], dcResultList[i]);
6659     }
6660 }
6661
6662 int radio::dataCallListChangedInd(int slotId,
6663                                   int indicationType, int token, RIL_Errno e, void *response,
6664                                   size_t responseLen) {
6665     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6666         if (response == NULL || responseLen % sizeof(RIL_Data_Call_Response_v11) != 0) {
6667             RLOGE("dataCallListChangedInd: invalid response");
6668             return 0;
6669         }
6670         hidl_vec<SetupDataCallResult> dcList;
6671         convertRilDataCallListToHal(response, responseLen, dcList);
6672 #if VDBG
6673         RLOGD("dataCallListChangedInd");
6674 #endif
6675         Return<void> retStatus = radioService[slotId]->mRadioIndication->dataCallListChanged(
6676                 convertIntToRadioIndicationType(indicationType), dcList);
6677         radioService[slotId]->checkReturnStatus(retStatus);
6678     } else {
6679         RLOGE("dataCallListChangedInd: radioService[%d]->mRadioIndication == NULL", slotId);
6680     }
6681
6682     return 0;
6683 }
6684
6685 int radio::suppSvcNotifyInd(int slotId, int indicationType,
6686                             int token, RIL_Errno e, void *response, size_t responseLen) {
6687     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6688         if (response == NULL || responseLen != sizeof(RIL_SuppSvcNotification)) {
6689             RLOGE("suppSvcNotifyInd: invalid response");
6690             return 0;
6691         }
6692
6693         SuppSvcNotification suppSvc = {};
6694         RIL_SuppSvcNotification *ssn = (RIL_SuppSvcNotification *) response;
6695         suppSvc.isMT = ssn->notificationType;
6696         suppSvc.code = ssn->code;
6697         suppSvc.index = ssn->index;
6698         suppSvc.type = ssn->type;
6699         suppSvc.number = convertCharPtrToHidlString(ssn->number);
6700
6701 #if VDBG
6702         RLOGD("suppSvcNotifyInd: isMT %d code %d index %d type %d",
6703                 suppSvc.isMT, suppSvc.code, suppSvc.index, suppSvc.type);
6704 #endif
6705         Return<void> retStatus = radioService[slotId]->mRadioIndication->suppSvcNotify(
6706                 convertIntToRadioIndicationType(indicationType), suppSvc);
6707         radioService[slotId]->checkReturnStatus(retStatus);
6708     } else {
6709         RLOGE("suppSvcNotifyInd: radioService[%d]->mRadioIndication == NULL", slotId);
6710     }
6711
6712     return 0;
6713 }
6714
6715 int radio::stkSessionEndInd(int slotId, int indicationType,
6716                             int token, RIL_Errno e, void *response, size_t responseLen) {
6717     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6718 #if VDBG
6719         RLOGD("stkSessionEndInd");
6720 #endif
6721         Return<void> retStatus = radioService[slotId]->mRadioIndication->stkSessionEnd(
6722                 convertIntToRadioIndicationType(indicationType));
6723         radioService[slotId]->checkReturnStatus(retStatus);
6724     } else {
6725         RLOGE("stkSessionEndInd: radioService[%d]->mRadioIndication == NULL", slotId);
6726     }
6727
6728     return 0;
6729 }
6730
6731 int radio::stkProactiveCommandInd(int slotId,
6732                                   int indicationType, int token, RIL_Errno e, void *response,
6733                                   size_t responseLen) {
6734     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6735         if (response == NULL || responseLen == 0) {
6736             RLOGE("stkProactiveCommandInd: invalid response");
6737             return 0;
6738         }
6739 #if VDBG
6740         RLOGD("stkProactiveCommandInd");
6741 #endif
6742         Return<void> retStatus = radioService[slotId]->mRadioIndication->stkProactiveCommand(
6743                 convertIntToRadioIndicationType(indicationType),
6744                 convertCharPtrToHidlString((char *) response));
6745         radioService[slotId]->checkReturnStatus(retStatus);
6746     } else {
6747         RLOGE("stkProactiveCommandInd: radioService[%d]->mRadioIndication == NULL", slotId);
6748     }
6749
6750     return 0;
6751 }
6752
6753 int radio::stkEventNotifyInd(int slotId, int indicationType,
6754                              int token, RIL_Errno e, void *response, size_t responseLen) {
6755     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6756         if (response == NULL || responseLen == 0) {
6757             RLOGE("stkEventNotifyInd: invalid response");
6758             return 0;
6759         }
6760 #if VDBG
6761         RLOGD("stkEventNotifyInd");
6762 #endif
6763         Return<void> retStatus = radioService[slotId]->mRadioIndication->stkEventNotify(
6764                 convertIntToRadioIndicationType(indicationType),
6765                 convertCharPtrToHidlString((char *) response));
6766         radioService[slotId]->checkReturnStatus(retStatus);
6767     } else {
6768         RLOGE("stkEventNotifyInd: radioService[%d]->mRadioIndication == NULL", slotId);
6769     }
6770
6771     return 0;
6772 }
6773
6774 int radio::stkCallSetupInd(int slotId, int indicationType,
6775                            int token, RIL_Errno e, void *response, size_t responseLen) {
6776     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6777         if (response == NULL || responseLen != sizeof(int)) {
6778             RLOGE("stkCallSetupInd: invalid response");
6779             return 0;
6780         }
6781         int32_t timeout = ((int32_t *) response)[0];
6782 #if VDBG
6783         RLOGD("stkCallSetupInd: timeout %d", timeout);
6784 #endif
6785         Return<void> retStatus = radioService[slotId]->mRadioIndication->stkCallSetup(
6786                 convertIntToRadioIndicationType(indicationType), timeout);
6787         radioService[slotId]->checkReturnStatus(retStatus);
6788     } else {
6789         RLOGE("stkCallSetupInd: radioService[%d]->mRadioIndication == NULL", slotId);
6790     }
6791
6792     return 0;
6793 }
6794
6795 int radio::simSmsStorageFullInd(int slotId,
6796                                 int indicationType, int token, RIL_Errno e, void *response,
6797                                 size_t responseLen) {
6798     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6799 #if VDBG
6800         RLOGD("simSmsStorageFullInd");
6801 #endif
6802         Return<void> retStatus = radioService[slotId]->mRadioIndication->simSmsStorageFull(
6803                 convertIntToRadioIndicationType(indicationType));
6804         radioService[slotId]->checkReturnStatus(retStatus);
6805     } else {
6806         RLOGE("simSmsStorageFullInd: radioService[%d]->mRadioIndication == NULL", slotId);
6807     }
6808
6809     return 0;
6810 }
6811
6812 int radio::simRefreshInd(int slotId, int indicationType,
6813                          int token, RIL_Errno e, void *response, size_t responseLen) {
6814     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6815         if (response == NULL || responseLen != sizeof(RIL_SimRefreshResponse_v7)) {
6816             RLOGE("simRefreshInd: invalid response");
6817             return 0;
6818         }
6819
6820         SimRefreshResult refreshResult = {};
6821         RIL_SimRefreshResponse_v7 *simRefreshResponse = ((RIL_SimRefreshResponse_v7 *) response);
6822         refreshResult.type =
6823                 (android::hardware::radio::V1_0::SimRefreshType) simRefreshResponse->result;
6824         refreshResult.efId = simRefreshResponse->ef_id;
6825         refreshResult.aid = convertCharPtrToHidlString(simRefreshResponse->aid);
6826
6827 #if VDBG
6828         RLOGD("simRefreshInd: type %d efId %d", refreshResult.type, refreshResult.efId);
6829 #endif
6830         Return<void> retStatus = radioService[slotId]->mRadioIndication->simRefresh(
6831                 convertIntToRadioIndicationType(indicationType), refreshResult);
6832         radioService[slotId]->checkReturnStatus(retStatus);
6833     } else {
6834         RLOGE("simRefreshInd: radioService[%d]->mRadioIndication == NULL", slotId);
6835     }
6836
6837     return 0;
6838 }
6839
6840 void convertRilCdmaSignalInfoRecordToHal(RIL_CDMA_SignalInfoRecord *signalInfoRecord,
6841         CdmaSignalInfoRecord& record) {
6842     record.isPresent = signalInfoRecord->isPresent;
6843     record.signalType = signalInfoRecord->signalType;
6844     record.alertPitch = signalInfoRecord->alertPitch;
6845     record.signal = signalInfoRecord->signal;
6846 }
6847
6848 int radio::callRingInd(int slotId, int indicationType,
6849                        int token, RIL_Errno e, void *response, size_t responseLen) {
6850     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6851         bool isGsm;
6852         CdmaSignalInfoRecord record = {};
6853         if (response == NULL || responseLen == 0) {
6854             isGsm = true;
6855         } else {
6856             isGsm = false;
6857             if (responseLen != sizeof (RIL_CDMA_SignalInfoRecord)) {
6858                 RLOGE("callRingInd: invalid response");
6859                 return 0;
6860             }
6861             convertRilCdmaSignalInfoRecordToHal((RIL_CDMA_SignalInfoRecord *) response, record);
6862         }
6863
6864 #if VDBG
6865         RLOGD("callRingInd: isGsm %d", isGsm);
6866 #endif
6867         Return<void> retStatus = radioService[slotId]->mRadioIndication->callRing(
6868                 convertIntToRadioIndicationType(indicationType), isGsm, record);
6869         radioService[slotId]->checkReturnStatus(retStatus);
6870     } else {
6871         RLOGE("callRingInd: radioService[%d]->mRadioIndication == NULL", slotId);
6872     }
6873
6874     return 0;
6875 }
6876
6877 int radio::simStatusChangedInd(int slotId,
6878                                int indicationType, int token, RIL_Errno e, void *response,
6879                                size_t responseLen) {
6880     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6881 #if VDBG
6882         RLOGD("simStatusChangedInd");
6883 #endif
6884         Return<void> retStatus = radioService[slotId]->mRadioIndication->simStatusChanged(
6885                 convertIntToRadioIndicationType(indicationType));
6886         radioService[slotId]->checkReturnStatus(retStatus);
6887     } else {
6888         RLOGE("simStatusChangedInd: radioService[%d]->mRadioIndication == NULL", slotId);
6889     }
6890
6891     return 0;
6892 }
6893
6894 int radio::cdmaNewSmsInd(int slotId, int indicationType,
6895                          int token, RIL_Errno e, void *response, size_t responseLen) {
6896     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6897         if (response == NULL || responseLen != sizeof(RIL_CDMA_SMS_Message)) {
6898             RLOGE("cdmaNewSmsInd: invalid response");
6899             return 0;
6900         }
6901
6902         CdmaSmsMessage msg = {};
6903         RIL_CDMA_SMS_Message *rilMsg = (RIL_CDMA_SMS_Message *) response;
6904         msg.teleserviceId = rilMsg->uTeleserviceID;
6905         msg.isServicePresent = rilMsg->bIsServicePresent;
6906         msg.serviceCategory = rilMsg->uServicecategory;
6907         msg.address.digitMode =
6908                 (android::hardware::radio::V1_0::CdmaSmsDigitMode) rilMsg->sAddress.digit_mode;
6909         msg.address.numberMode =
6910                 (android::hardware::radio::V1_0::CdmaSmsNumberMode) rilMsg->sAddress.number_mode;
6911         msg.address.numberType =
6912                 (android::hardware::radio::V1_0::CdmaSmsNumberType) rilMsg->sAddress.number_type;
6913         msg.address.numberPlan =
6914                 (android::hardware::radio::V1_0::CdmaSmsNumberPlan) rilMsg->sAddress.number_plan;
6915
6916         int digitLimit = MIN((rilMsg->sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
6917         msg.address.digits.setToExternal(rilMsg->sAddress.digits, digitLimit);
6918
6919         msg.subAddress.subaddressType = (android::hardware::radio::V1_0::CdmaSmsSubaddressType)
6920                 rilMsg->sSubAddress.subaddressType;
6921         msg.subAddress.odd = rilMsg->sSubAddress.odd;
6922
6923         digitLimit= MIN((rilMsg->sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
6924         msg.subAddress.digits.setToExternal(rilMsg->sSubAddress.digits, digitLimit);
6925
6926         digitLimit = MIN((rilMsg->uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
6927         msg.bearerData.setToExternal(rilMsg->aBearerData, digitLimit);
6928
6929 #if VDBG
6930         RLOGD("cdmaNewSmsInd");
6931 #endif
6932         Return<void> retStatus = radioService[slotId]->mRadioIndication->cdmaNewSms(
6933                 convertIntToRadioIndicationType(indicationType), msg);
6934         radioService[slotId]->checkReturnStatus(retStatus);
6935     } else {
6936         RLOGE("cdmaNewSmsInd: radioService[%d]->mRadioIndication == NULL", slotId);
6937     }
6938
6939     return 0;
6940 }
6941
6942 int radio::newBroadcastSmsInd(int slotId,
6943                               int indicationType, int token, RIL_Errno e, void *response,
6944                               size_t responseLen) {
6945     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6946         if (response == NULL || responseLen == 0) {
6947             RLOGE("newBroadcastSmsInd: invalid response");
6948             return 0;
6949         }
6950
6951         hidl_vec<uint8_t> data;
6952         data.setToExternal((uint8_t *) response, responseLen);
6953 #if VDBG
6954         RLOGD("newBroadcastSmsInd");
6955 #endif
6956         Return<void> retStatus = radioService[slotId]->mRadioIndication->newBroadcastSms(
6957                 convertIntToRadioIndicationType(indicationType), data);
6958         radioService[slotId]->checkReturnStatus(retStatus);
6959     } else {
6960         RLOGE("newBroadcastSmsInd: radioService[%d]->mRadioIndication == NULL", slotId);
6961     }
6962
6963     return 0;
6964 }
6965
6966 int radio::cdmaRuimSmsStorageFullInd(int slotId,
6967                                      int indicationType, int token, RIL_Errno e, void *response,
6968                                      size_t responseLen) {
6969     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6970 #if VDBG
6971         RLOGD("cdmaRuimSmsStorageFullInd");
6972 #endif
6973         Return<void> retStatus = radioService[slotId]->mRadioIndication->cdmaRuimSmsStorageFull(
6974                 convertIntToRadioIndicationType(indicationType));
6975         radioService[slotId]->checkReturnStatus(retStatus);
6976     } else {
6977         RLOGE("cdmaRuimSmsStorageFullInd: radioService[%d]->mRadioIndication == NULL",
6978                 slotId);
6979     }
6980
6981     return 0;
6982 }
6983
6984 int radio::restrictedStateChangedInd(int slotId,
6985                                      int indicationType, int token, RIL_Errno e, void *response,
6986                                      size_t responseLen) {
6987     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6988         if (response == NULL || responseLen != sizeof(int)) {
6989             RLOGE("restrictedStateChangedInd: invalid response");
6990             return 0;
6991         }
6992         int32_t state = ((int32_t *) response)[0];
6993 #if VDBG
6994         RLOGD("restrictedStateChangedInd: state %d", state);
6995 #endif
6996         Return<void> retStatus = radioService[slotId]->mRadioIndication->restrictedStateChanged(
6997                 convertIntToRadioIndicationType(indicationType), (PhoneRestrictedState) state);
6998         radioService[slotId]->checkReturnStatus(retStatus);
6999     } else {
7000         RLOGE("restrictedStateChangedInd: radioService[%d]->mRadioIndication == NULL",
7001                 slotId);
7002     }
7003
7004     return 0;
7005 }
7006
7007 int radio::enterEmergencyCallbackModeInd(int slotId,
7008                                          int indicationType, int token, RIL_Errno e, void *response,
7009                                          size_t responseLen) {
7010     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7011 #if VDBG
7012         RLOGD("enterEmergencyCallbackModeInd");
7013 #endif
7014         Return<void> retStatus = radioService[slotId]->mRadioIndication->enterEmergencyCallbackMode(
7015                 convertIntToRadioIndicationType(indicationType));
7016         radioService[slotId]->checkReturnStatus(retStatus);
7017     } else {
7018         RLOGE("enterEmergencyCallbackModeInd: radioService[%d]->mRadioIndication == NULL",
7019                 slotId);
7020     }
7021
7022     return 0;
7023 }
7024
7025 int radio::cdmaCallWaitingInd(int slotId,
7026                               int indicationType, int token, RIL_Errno e, void *response,
7027                               size_t responseLen) {
7028     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7029         if (response == NULL || responseLen != sizeof(RIL_CDMA_CallWaiting_v6)) {
7030             RLOGE("cdmaCallWaitingInd: invalid response");
7031             return 0;
7032         }
7033
7034         CdmaCallWaiting callWaitingRecord = {};
7035         RIL_CDMA_CallWaiting_v6 *callWaitingRil = ((RIL_CDMA_CallWaiting_v6 *) response);
7036         callWaitingRecord.number = convertCharPtrToHidlString(callWaitingRil->number);
7037         callWaitingRecord.numberPresentation =
7038                 (CdmaCallWaitingNumberPresentation) callWaitingRil->numberPresentation;
7039         callWaitingRecord.name = convertCharPtrToHidlString(callWaitingRil->name);
7040         convertRilCdmaSignalInfoRecordToHal(&callWaitingRil->signalInfoRecord,
7041                 callWaitingRecord.signalInfoRecord);
7042         callWaitingRecord.numberType = (CdmaCallWaitingNumberType) callWaitingRil->number_type;
7043         callWaitingRecord.numberPlan = (CdmaCallWaitingNumberPlan) callWaitingRil->number_plan;
7044
7045 #if VDBG
7046         RLOGD("cdmaCallWaitingInd");
7047 #endif
7048         Return<void> retStatus = radioService[slotId]->mRadioIndication->cdmaCallWaiting(
7049                 convertIntToRadioIndicationType(indicationType), callWaitingRecord);
7050         radioService[slotId]->checkReturnStatus(retStatus);
7051     } else {
7052         RLOGE("cdmaCallWaitingInd: radioService[%d]->mRadioIndication == NULL", slotId);
7053     }
7054
7055     return 0;
7056 }
7057
7058 int radio::cdmaOtaProvisionStatusInd(int slotId,
7059                                      int indicationType, int token, RIL_Errno e, void *response,
7060                                      size_t responseLen) {
7061     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7062         if (response == NULL || responseLen != sizeof(int)) {
7063             RLOGE("cdmaOtaProvisionStatusInd: invalid response");
7064             return 0;
7065         }
7066         int32_t status = ((int32_t *) response)[0];
7067 #if VDBG
7068         RLOGD("cdmaOtaProvisionStatusInd: status %d", status);
7069 #endif
7070         Return<void> retStatus = radioService[slotId]->mRadioIndication->cdmaOtaProvisionStatus(
7071                 convertIntToRadioIndicationType(indicationType), (CdmaOtaProvisionStatus) status);
7072         radioService[slotId]->checkReturnStatus(retStatus);
7073     } else {
7074         RLOGE("cdmaOtaProvisionStatusInd: radioService[%d]->mRadioIndication == NULL",
7075                 slotId);
7076     }
7077
7078     return 0;
7079 }
7080
7081 int radio::cdmaInfoRecInd(int slotId,
7082                           int indicationType, int token, RIL_Errno e, void *response,
7083                           size_t responseLen) {
7084     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7085         if (response == NULL || responseLen != sizeof(RIL_CDMA_InformationRecords)) {
7086             RLOGE("cdmaInfoRecInd: invalid response");
7087             return 0;
7088         }
7089
7090         CdmaInformationRecords records = {};
7091         RIL_CDMA_InformationRecords *recordsRil = (RIL_CDMA_InformationRecords *) response;
7092
7093         char* string8 = NULL;
7094         int num = MIN(recordsRil->numberOfInfoRecs, RIL_CDMA_MAX_NUMBER_OF_INFO_RECS);
7095         if (recordsRil->numberOfInfoRecs > RIL_CDMA_MAX_NUMBER_OF_INFO_RECS) {
7096             RLOGE("cdmaInfoRecInd: received %d recs which is more than %d, dropping "
7097                     "additional ones", recordsRil->numberOfInfoRecs,
7098                     RIL_CDMA_MAX_NUMBER_OF_INFO_RECS);
7099         }
7100         records.infoRec.resize(num);
7101         for (int i = 0 ; i < num ; i++) {
7102             CdmaInformationRecord *record = &records.infoRec[i];
7103             RIL_CDMA_InformationRecord *infoRec = &recordsRil->infoRec[i];
7104             record->name = (CdmaInfoRecName) infoRec->name;
7105             // All vectors should be size 0 except one which will be size 1. Set everything to
7106             // size 0 initially.
7107             record->display.resize(0);
7108             record->number.resize(0);
7109             record->signal.resize(0);
7110             record->redir.resize(0);
7111             record->lineCtrl.resize(0);
7112             record->clir.resize(0);
7113             record->audioCtrl.resize(0);
7114             switch (infoRec->name) {
7115                 case RIL_CDMA_DISPLAY_INFO_REC:
7116                 case RIL_CDMA_EXTENDED_DISPLAY_INFO_REC: {
7117                     if (infoRec->rec.display.alpha_len > CDMA_ALPHA_INFO_BUFFER_LENGTH) {
7118                         RLOGE("cdmaInfoRecInd: invalid display info response length %d "
7119                                 "expected not more than %d", (int) infoRec->rec.display.alpha_len,
7120                                 CDMA_ALPHA_INFO_BUFFER_LENGTH);
7121                         return 0;
7122                     }
7123                     string8 = (char*) malloc((infoRec->rec.display.alpha_len + 1) * sizeof(char));
7124                     if (string8 == NULL) {
7125                         RLOGE("cdmaInfoRecInd: Memory allocation failed for "
7126                                 "responseCdmaInformationRecords");
7127                         return 0;
7128                     }
7129                     memcpy(string8, infoRec->rec.display.alpha_buf, infoRec->rec.display.alpha_len);
7130                     string8[(int)infoRec->rec.display.alpha_len] = '\0';
7131
7132                     record->display.resize(1);
7133                     record->display[0].alphaBuf = string8;
7134                     free(string8);
7135                     string8 = NULL;
7136                     break;
7137                 }
7138
7139                 case RIL_CDMA_CALLED_PARTY_NUMBER_INFO_REC:
7140                 case RIL_CDMA_CALLING_PARTY_NUMBER_INFO_REC:
7141                 case RIL_CDMA_CONNECTED_NUMBER_INFO_REC: {
7142                     if (infoRec->rec.number.len > CDMA_NUMBER_INFO_BUFFER_LENGTH) {
7143                         RLOGE("cdmaInfoRecInd: invalid display info response length %d "
7144                                 "expected not more than %d", (int) infoRec->rec.number.len,
7145                                 CDMA_NUMBER_INFO_BUFFER_LENGTH);
7146                         return 0;
7147                     }
7148                     string8 = (char*) malloc((infoRec->rec.number.len + 1) * sizeof(char));
7149                     if (string8 == NULL) {
7150                         RLOGE("cdmaInfoRecInd: Memory allocation failed for "
7151                                 "responseCdmaInformationRecords");
7152                         return 0;
7153                     }
7154                     memcpy(string8, infoRec->rec.number.buf, infoRec->rec.number.len);
7155                     string8[(int)infoRec->rec.number.len] = '\0';
7156
7157                     record->number.resize(1);
7158                     record->number[0].number = string8;
7159                     free(string8);
7160                     string8 = NULL;
7161                     record->number[0].numberType = infoRec->rec.number.number_type;
7162                     record->number[0].numberPlan = infoRec->rec.number.number_plan;
7163                     record->number[0].pi = infoRec->rec.number.pi;
7164                     record->number[0].si = infoRec->rec.number.si;
7165                     break;
7166                 }
7167
7168                 case RIL_CDMA_SIGNAL_INFO_REC: {
7169                     record->signal.resize(1);
7170                     record->signal[0].isPresent = infoRec->rec.signal.isPresent;
7171                     record->signal[0].signalType = infoRec->rec.signal.signalType;
7172                     record->signal[0].alertPitch = infoRec->rec.signal.alertPitch;
7173                     record->signal[0].signal = infoRec->rec.signal.signal;
7174                     break;
7175                 }
7176
7177                 case RIL_CDMA_REDIRECTING_NUMBER_INFO_REC: {
7178                     if (infoRec->rec.redir.redirectingNumber.len >
7179                                                   CDMA_NUMBER_INFO_BUFFER_LENGTH) {
7180                         RLOGE("cdmaInfoRecInd: invalid display info response length %d "
7181                                 "expected not more than %d\n",
7182                                 (int)infoRec->rec.redir.redirectingNumber.len,
7183                                 CDMA_NUMBER_INFO_BUFFER_LENGTH);
7184                         return 0;
7185                     }
7186                     string8 = (char*) malloc((infoRec->rec.redir.redirectingNumber.len + 1) *
7187                             sizeof(char));
7188                     if (string8 == NULL) {
7189                         RLOGE("cdmaInfoRecInd: Memory allocation failed for "
7190                                 "responseCdmaInformationRecords");
7191                         return 0;
7192                     }
7193                     memcpy(string8, infoRec->rec.redir.redirectingNumber.buf,
7194                             infoRec->rec.redir.redirectingNumber.len);
7195                     string8[(int)infoRec->rec.redir.redirectingNumber.len] = '\0';
7196
7197                     record->redir.resize(1);
7198                     record->redir[0].redirectingNumber.number = string8;
7199                     free(string8);
7200                     string8 = NULL;
7201                     record->redir[0].redirectingNumber.numberType =
7202                             infoRec->rec.redir.redirectingNumber.number_type;
7203                     record->redir[0].redirectingNumber.numberPlan =
7204                             infoRec->rec.redir.redirectingNumber.number_plan;
7205                     record->redir[0].redirectingNumber.pi = infoRec->rec.redir.redirectingNumber.pi;
7206                     record->redir[0].redirectingNumber.si = infoRec->rec.redir.redirectingNumber.si;
7207                     record->redir[0].redirectingReason =
7208                             (CdmaRedirectingReason) infoRec->rec.redir.redirectingReason;
7209                     break;
7210                 }
7211
7212                 case RIL_CDMA_LINE_CONTROL_INFO_REC: {
7213                     record->lineCtrl.resize(1);
7214                     record->lineCtrl[0].lineCtrlPolarityIncluded =
7215                             infoRec->rec.lineCtrl.lineCtrlPolarityIncluded;
7216                     record->lineCtrl[0].lineCtrlToggle = infoRec->rec.lineCtrl.lineCtrlToggle;
7217                     record->lineCtrl[0].lineCtrlReverse = infoRec->rec.lineCtrl.lineCtrlReverse;
7218                     record->lineCtrl[0].lineCtrlPowerDenial =
7219                             infoRec->rec.lineCtrl.lineCtrlPowerDenial;
7220                     break;
7221                 }
7222
7223                 case RIL_CDMA_T53_CLIR_INFO_REC: {
7224                     record->clir.resize(1);
7225                     record->clir[0].cause = infoRec->rec.clir.cause;
7226                     break;
7227                 }
7228
7229                 case RIL_CDMA_T53_AUDIO_CONTROL_INFO_REC: {
7230                     record->audioCtrl.resize(1);
7231                     record->audioCtrl[0].upLink = infoRec->rec.audioCtrl.upLink;
7232                     record->audioCtrl[0].downLink = infoRec->rec.audioCtrl.downLink;
7233                     break;
7234                 }
7235
7236                 case RIL_CDMA_T53_RELEASE_INFO_REC:
7237                     RLOGE("cdmaInfoRecInd: RIL_CDMA_T53_RELEASE_INFO_REC: INVALID");
7238                     return 0;
7239
7240                 default:
7241                     RLOGE("cdmaInfoRecInd: Incorrect name value");
7242                     return 0;
7243             }
7244         }
7245
7246 #if VDBG
7247         RLOGD("cdmaInfoRecInd");
7248 #endif
7249         Return<void> retStatus = radioService[slotId]->mRadioIndication->cdmaInfoRec(
7250                 convertIntToRadioIndicationType(indicationType), records);
7251         radioService[slotId]->checkReturnStatus(retStatus);
7252     } else {
7253         RLOGE("cdmaInfoRecInd: radioService[%d]->mRadioIndication == NULL", slotId);
7254     }
7255
7256     return 0;
7257 }
7258
7259 int radio::indicateRingbackToneInd(int slotId,
7260                                    int indicationType, int token, RIL_Errno e, void *response,
7261                                    size_t responseLen) {
7262     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7263         if (response == NULL || responseLen != sizeof(int)) {
7264             RLOGE("indicateRingbackToneInd: invalid response");
7265             return 0;
7266         }
7267         bool start = ((int32_t *) response)[0];
7268 #if VDBG
7269         RLOGD("indicateRingbackToneInd: start %d", start);
7270 #endif
7271         Return<void> retStatus = radioService[slotId]->mRadioIndication->indicateRingbackTone(
7272                 convertIntToRadioIndicationType(indicationType), start);
7273         radioService[slotId]->checkReturnStatus(retStatus);
7274     } else {
7275         RLOGE("indicateRingbackToneInd: radioService[%d]->mRadioIndication == NULL", slotId);
7276     }
7277
7278     return 0;
7279 }
7280
7281 int radio::resendIncallMuteInd(int slotId,
7282                                int indicationType, int token, RIL_Errno e, void *response,
7283                                size_t responseLen) {
7284     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7285 #if VDBG
7286         RLOGD("resendIncallMuteInd");
7287 #endif
7288         Return<void> retStatus = radioService[slotId]->mRadioIndication->resendIncallMute(
7289                 convertIntToRadioIndicationType(indicationType));
7290         radioService[slotId]->checkReturnStatus(retStatus);
7291     } else {
7292         RLOGE("resendIncallMuteInd: radioService[%d]->mRadioIndication == NULL", slotId);
7293     }
7294
7295     return 0;
7296 }
7297
7298 int radio::cdmaSubscriptionSourceChangedInd(int slotId,
7299                                             int indicationType, int token, RIL_Errno e,
7300                                             void *response, size_t responseLen) {
7301     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7302         if (response == NULL || responseLen != sizeof(int)) {
7303             RLOGE("cdmaSubscriptionSourceChangedInd: invalid response");
7304             return 0;
7305         }
7306         int32_t cdmaSource = ((int32_t *) response)[0];
7307 #if VDBG
7308         RLOGD("cdmaSubscriptionSourceChangedInd: cdmaSource %d", cdmaSource);
7309 #endif
7310         Return<void> retStatus = radioService[slotId]->mRadioIndication->
7311                 cdmaSubscriptionSourceChanged(convertIntToRadioIndicationType(indicationType),
7312                 (CdmaSubscriptionSource) cdmaSource);
7313         radioService[slotId]->checkReturnStatus(retStatus);
7314     } else {
7315         RLOGE("cdmaSubscriptionSourceChangedInd: radioService[%d]->mRadioIndication == NULL",
7316                 slotId);
7317     }
7318
7319     return 0;
7320 }
7321
7322 int radio::cdmaPrlChangedInd(int slotId,
7323                              int indicationType, int token, RIL_Errno e, void *response,
7324                              size_t responseLen) {
7325     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7326         if (response == NULL || responseLen != sizeof(int)) {
7327             RLOGE("cdmaPrlChangedInd: invalid response");
7328             return 0;
7329         }
7330         int32_t version = ((int32_t *) response)[0];
7331 #if VDBG
7332         RLOGD("cdmaPrlChangedInd: version %d", version);
7333 #endif
7334         Return<void> retStatus = radioService[slotId]->mRadioIndication->cdmaPrlChanged(
7335                 convertIntToRadioIndicationType(indicationType), version);
7336         radioService[slotId]->checkReturnStatus(retStatus);
7337     } else {
7338         RLOGE("cdmaPrlChangedInd: radioService[%d]->mRadioIndication == NULL", slotId);
7339     }
7340
7341     return 0;
7342 }
7343
7344 int radio::exitEmergencyCallbackModeInd(int slotId,
7345                                         int indicationType, int token, RIL_Errno e, void *response,
7346                                         size_t responseLen) {
7347     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7348 #if VDBG
7349         RLOGD("exitEmergencyCallbackModeInd");
7350 #endif
7351         Return<void> retStatus = radioService[slotId]->mRadioIndication->exitEmergencyCallbackMode(
7352                 convertIntToRadioIndicationType(indicationType));
7353         radioService[slotId]->checkReturnStatus(retStatus);
7354     } else {
7355         RLOGE("exitEmergencyCallbackModeInd: radioService[%d]->mRadioIndication == NULL",
7356                 slotId);
7357     }
7358
7359     return 0;
7360 }
7361
7362 int radio::rilConnectedInd(int slotId,
7363                            int indicationType, int token, RIL_Errno e, void *response,
7364                            size_t responseLen) {
7365     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7366         RLOGD("rilConnectedInd");
7367         Return<void> retStatus = radioService[slotId]->mRadioIndication->rilConnected(
7368                 convertIntToRadioIndicationType(indicationType));
7369         radioService[slotId]->checkReturnStatus(retStatus);
7370     } else {
7371         RLOGE("rilConnectedInd: radioService[%d]->mRadioIndication == NULL", slotId);
7372     }
7373
7374     return 0;
7375 }
7376
7377 int radio::voiceRadioTechChangedInd(int slotId,
7378                                     int indicationType, int token, RIL_Errno e, void *response,
7379                                     size_t responseLen) {
7380     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7381         if (response == NULL || responseLen != sizeof(int)) {
7382             RLOGE("voiceRadioTechChangedInd: invalid response");
7383             return 0;
7384         }
7385         int32_t rat = ((int32_t *) response)[0];
7386 #if VDBG
7387         RLOGD("voiceRadioTechChangedInd: rat %d", rat);
7388 #endif
7389         Return<void> retStatus = radioService[slotId]->mRadioIndication->voiceRadioTechChanged(
7390                 convertIntToRadioIndicationType(indicationType), (RadioTechnology) rat);
7391         radioService[slotId]->checkReturnStatus(retStatus);
7392     } else {
7393         RLOGE("voiceRadioTechChangedInd: radioService[%d]->mRadioIndication == NULL",
7394                 slotId);
7395     }
7396
7397     return 0;
7398 }
7399
7400 void convertRilCellInfoListToHal(void *response, size_t responseLen, hidl_vec<CellInfo>& records) {
7401     int num = responseLen / sizeof(RIL_CellInfo_v12);
7402     records.resize(num);
7403
7404     RIL_CellInfo_v12 *rillCellInfo = (RIL_CellInfo_v12 *) response;
7405     for (int i = 0; i < num; i++) {
7406         records[i].cellInfoType = (CellInfoType) rillCellInfo->cellInfoType;
7407         records[i].registered = rillCellInfo->registered;
7408         records[i].timeStampType = (TimeStampType) rillCellInfo->timeStampType;
7409         records[i].timeStamp = rillCellInfo->timeStamp;
7410         // All vectors should be size 0 except one which will be size 1. Set everything to
7411         // size 0 initially.
7412         records[i].gsm.resize(0);
7413         records[i].wcdma.resize(0);
7414         records[i].cdma.resize(0);
7415         records[i].lte.resize(0);
7416         records[i].tdscdma.resize(0);
7417         switch(rillCellInfo->cellInfoType) {
7418             case RIL_CELL_INFO_TYPE_GSM: {
7419                 records[i].gsm.resize(1);
7420                 CellInfoGsm *cellInfoGsm = &records[i].gsm[0];
7421                 cellInfoGsm->cellIdentityGsm.mcc =
7422                         std::to_string(rillCellInfo->CellInfo.gsm.cellIdentityGsm.mcc);
7423                 cellInfoGsm->cellIdentityGsm.mnc =
7424                         std::to_string(rillCellInfo->CellInfo.gsm.cellIdentityGsm.mnc);
7425                 cellInfoGsm->cellIdentityGsm.lac =
7426                         rillCellInfo->CellInfo.gsm.cellIdentityGsm.lac;
7427                 cellInfoGsm->cellIdentityGsm.cid =
7428                         rillCellInfo->CellInfo.gsm.cellIdentityGsm.cid;
7429                 cellInfoGsm->cellIdentityGsm.arfcn =
7430                         rillCellInfo->CellInfo.gsm.cellIdentityGsm.arfcn;
7431                 cellInfoGsm->cellIdentityGsm.bsic =
7432                         rillCellInfo->CellInfo.gsm.cellIdentityGsm.bsic;
7433                 cellInfoGsm->signalStrengthGsm.signalStrength =
7434                         rillCellInfo->CellInfo.gsm.signalStrengthGsm.signalStrength;
7435                 cellInfoGsm->signalStrengthGsm.bitErrorRate =
7436                         rillCellInfo->CellInfo.gsm.signalStrengthGsm.bitErrorRate;
7437                 cellInfoGsm->signalStrengthGsm.timingAdvance =
7438                         rillCellInfo->CellInfo.gsm.signalStrengthGsm.timingAdvance;
7439                 break;
7440             }
7441
7442             case RIL_CELL_INFO_TYPE_WCDMA: {
7443                 records[i].wcdma.resize(1);
7444                 CellInfoWcdma *cellInfoWcdma = &records[i].wcdma[0];
7445                 cellInfoWcdma->cellIdentityWcdma.mcc =
7446                         std::to_string(rillCellInfo->CellInfo.wcdma.cellIdentityWcdma.mcc);
7447                 cellInfoWcdma->cellIdentityWcdma.mnc =
7448                         std::to_string(rillCellInfo->CellInfo.wcdma.cellIdentityWcdma.mnc);
7449                 cellInfoWcdma->cellIdentityWcdma.lac =
7450                         rillCellInfo->CellInfo.wcdma.cellIdentityWcdma.lac;
7451                 cellInfoWcdma->cellIdentityWcdma.cid =
7452                         rillCellInfo->CellInfo.wcdma.cellIdentityWcdma.cid;
7453                 cellInfoWcdma->cellIdentityWcdma.psc =
7454                         rillCellInfo->CellInfo.wcdma.cellIdentityWcdma.psc;
7455                 cellInfoWcdma->cellIdentityWcdma.uarfcn =
7456                         rillCellInfo->CellInfo.wcdma.cellIdentityWcdma.uarfcn;
7457                 cellInfoWcdma->signalStrengthWcdma.signalStrength =
7458                         rillCellInfo->CellInfo.wcdma.signalStrengthWcdma.signalStrength;
7459                 cellInfoWcdma->signalStrengthWcdma.bitErrorRate =
7460                         rillCellInfo->CellInfo.wcdma.signalStrengthWcdma.bitErrorRate;
7461                 break;
7462             }
7463
7464             case RIL_CELL_INFO_TYPE_CDMA: {
7465                 records[i].cdma.resize(1);
7466                 CellInfoCdma *cellInfoCdma = &records[i].cdma[0];
7467                 cellInfoCdma->cellIdentityCdma.networkId =
7468                         rillCellInfo->CellInfo.cdma.cellIdentityCdma.networkId;
7469                 cellInfoCdma->cellIdentityCdma.systemId =
7470                         rillCellInfo->CellInfo.cdma.cellIdentityCdma.systemId;
7471                 cellInfoCdma->cellIdentityCdma.baseStationId =
7472                         rillCellInfo->CellInfo.cdma.cellIdentityCdma.basestationId;
7473                 cellInfoCdma->cellIdentityCdma.longitude =
7474                         rillCellInfo->CellInfo.cdma.cellIdentityCdma.longitude;
7475                 cellInfoCdma->cellIdentityCdma.latitude =
7476                         rillCellInfo->CellInfo.cdma.cellIdentityCdma.latitude;
7477                 cellInfoCdma->signalStrengthCdma.dbm =
7478                         rillCellInfo->CellInfo.cdma.signalStrengthCdma.dbm;
7479                 cellInfoCdma->signalStrengthCdma.ecio =
7480                         rillCellInfo->CellInfo.cdma.signalStrengthCdma.ecio;
7481                 cellInfoCdma->signalStrengthEvdo.dbm =
7482                         rillCellInfo->CellInfo.cdma.signalStrengthEvdo.dbm;
7483                 cellInfoCdma->signalStrengthEvdo.ecio =
7484                         rillCellInfo->CellInfo.cdma.signalStrengthEvdo.ecio;
7485                 cellInfoCdma->signalStrengthEvdo.signalNoiseRatio =
7486                         rillCellInfo->CellInfo.cdma.signalStrengthEvdo.signalNoiseRatio;
7487                 break;
7488             }
7489
7490             case RIL_CELL_INFO_TYPE_LTE: {
7491                 records[i].lte.resize(1);
7492                 CellInfoLte *cellInfoLte = &records[i].lte[0];
7493                 cellInfoLte->cellIdentityLte.mcc =
7494                         std::to_string(rillCellInfo->CellInfo.lte.cellIdentityLte.mcc);
7495                 cellInfoLte->cellIdentityLte.mnc =
7496                         std::to_string(rillCellInfo->CellInfo.lte.cellIdentityLte.mnc);
7497                 cellInfoLte->cellIdentityLte.ci =
7498                         rillCellInfo->CellInfo.lte.cellIdentityLte.ci;
7499                 cellInfoLte->cellIdentityLte.pci =
7500                         rillCellInfo->CellInfo.lte.cellIdentityLte.pci;
7501                 cellInfoLte->cellIdentityLte.tac =
7502                         rillCellInfo->CellInfo.lte.cellIdentityLte.tac;
7503                 cellInfoLte->cellIdentityLte.earfcn =
7504                         rillCellInfo->CellInfo.lte.cellIdentityLte.earfcn;
7505                 cellInfoLte->signalStrengthLte.signalStrength =
7506                         rillCellInfo->CellInfo.lte.signalStrengthLte.signalStrength;
7507                 cellInfoLte->signalStrengthLte.rsrp =
7508                         rillCellInfo->CellInfo.lte.signalStrengthLte.rsrp;
7509                 cellInfoLte->signalStrengthLte.rsrq =
7510                         rillCellInfo->CellInfo.lte.signalStrengthLte.rsrq;
7511                 cellInfoLte->signalStrengthLte.rssnr =
7512                         rillCellInfo->CellInfo.lte.signalStrengthLte.rssnr;
7513                 cellInfoLte->signalStrengthLte.cqi =
7514                         rillCellInfo->CellInfo.lte.signalStrengthLte.cqi;
7515                 cellInfoLte->signalStrengthLte.timingAdvance =
7516                         rillCellInfo->CellInfo.lte.signalStrengthLte.timingAdvance;
7517                 break;
7518             }
7519
7520             case RIL_CELL_INFO_TYPE_TD_SCDMA: {
7521                 records[i].tdscdma.resize(1);
7522                 CellInfoTdscdma *cellInfoTdscdma = &records[i].tdscdma[0];
7523                 cellInfoTdscdma->cellIdentityTdscdma.mcc =
7524                         std::to_string(rillCellInfo->CellInfo.tdscdma.cellIdentityTdscdma.mcc);
7525                 cellInfoTdscdma->cellIdentityTdscdma.mnc =
7526                         std::to_string(rillCellInfo->CellInfo.tdscdma.cellIdentityTdscdma.mnc);
7527                 cellInfoTdscdma->cellIdentityTdscdma.lac =
7528                         rillCellInfo->CellInfo.tdscdma.cellIdentityTdscdma.lac;
7529                 cellInfoTdscdma->cellIdentityTdscdma.cid =
7530                         rillCellInfo->CellInfo.tdscdma.cellIdentityTdscdma.cid;
7531                 cellInfoTdscdma->cellIdentityTdscdma.cpid =
7532                         rillCellInfo->CellInfo.tdscdma.cellIdentityTdscdma.cpid;
7533                 cellInfoTdscdma->signalStrengthTdscdma.rscp =
7534                         rillCellInfo->CellInfo.tdscdma.signalStrengthTdscdma.rscp;
7535                 break;
7536             }
7537             default: {
7538                 break;
7539             }
7540         }
7541         rillCellInfo += 1;
7542     }
7543 }
7544
7545 int radio::cellInfoListInd(int slotId,
7546                            int indicationType, int token, RIL_Errno e, void *response,
7547                            size_t responseLen) {
7548     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7549         if (response == NULL || responseLen % sizeof(RIL_CellInfo_v12) != 0) {
7550             RLOGE("cellInfoListInd: invalid response");
7551             return 0;
7552         }
7553
7554         hidl_vec<CellInfo> records;
7555         convertRilCellInfoListToHal(response, responseLen, records);
7556
7557 #if VDBG
7558         RLOGD("cellInfoListInd");
7559 #endif
7560         Return<void> retStatus = radioService[slotId]->mRadioIndication->cellInfoList(
7561                 convertIntToRadioIndicationType(indicationType), records);
7562         radioService[slotId]->checkReturnStatus(retStatus);
7563     } else {
7564         RLOGE("cellInfoListInd: radioService[%d]->mRadioIndication == NULL", slotId);
7565     }
7566
7567     return 0;
7568 }
7569
7570 int radio::imsNetworkStateChangedInd(int slotId,
7571                                      int indicationType, int token, RIL_Errno e, void *response,
7572                                      size_t responseLen) {
7573     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7574 #if VDBG
7575         RLOGD("imsNetworkStateChangedInd");
7576 #endif
7577         Return<void> retStatus = radioService[slotId]->mRadioIndication->imsNetworkStateChanged(
7578                 convertIntToRadioIndicationType(indicationType));
7579         radioService[slotId]->checkReturnStatus(retStatus);
7580     } else {
7581         RLOGE("imsNetworkStateChangedInd: radioService[%d]->mRadioIndication == NULL",
7582                 slotId);
7583     }
7584
7585     return 0;
7586 }
7587
7588 int radio::subscriptionStatusChangedInd(int slotId,
7589                                         int indicationType, int token, RIL_Errno e, void *response,
7590                                         size_t responseLen) {
7591     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7592         if (response == NULL || responseLen != sizeof(int)) {
7593             RLOGE("subscriptionStatusChangedInd: invalid response");
7594             return 0;
7595         }
7596         bool activate = ((int32_t *) response)[0];
7597 #if VDBG
7598         RLOGD("subscriptionStatusChangedInd: activate %d", activate);
7599 #endif
7600         Return<void> retStatus = radioService[slotId]->mRadioIndication->subscriptionStatusChanged(
7601                 convertIntToRadioIndicationType(indicationType), activate);
7602         radioService[slotId]->checkReturnStatus(retStatus);
7603     } else {
7604         RLOGE("subscriptionStatusChangedInd: radioService[%d]->mRadioIndication == NULL",
7605                 slotId);
7606     }
7607
7608     return 0;
7609 }
7610
7611 int radio::srvccStateNotifyInd(int slotId,
7612                                int indicationType, int token, RIL_Errno e, void *response,
7613                                size_t responseLen) {
7614     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7615         if (response == NULL || responseLen != sizeof(int)) {
7616             RLOGE("srvccStateNotifyInd: invalid response");
7617             return 0;
7618         }
7619         int32_t state = ((int32_t *) response)[0];
7620 #if VDBG
7621         RLOGD("srvccStateNotifyInd: rat %d", state);
7622 #endif
7623         Return<void> retStatus = radioService[slotId]->mRadioIndication->srvccStateNotify(
7624                 convertIntToRadioIndicationType(indicationType), (SrvccState) state);
7625         radioService[slotId]->checkReturnStatus(retStatus);
7626     } else {
7627         RLOGE("srvccStateNotifyInd: radioService[%d]->mRadioIndication == NULL", slotId);
7628     }
7629
7630     return 0;
7631 }
7632
7633 void convertRilHardwareConfigListToHal(void *response, size_t responseLen,
7634         hidl_vec<HardwareConfig>& records) {
7635     int num = responseLen / sizeof(RIL_HardwareConfig);
7636     records.resize(num);
7637
7638     RIL_HardwareConfig *rilHardwareConfig = (RIL_HardwareConfig *) response;
7639     for (int i = 0; i < num; i++) {
7640         records[i].type = (HardwareConfigType) rilHardwareConfig[i].type;
7641         records[i].uuid = convertCharPtrToHidlString(rilHardwareConfig[i].uuid);
7642         records[i].state = (HardwareConfigState) rilHardwareConfig[i].state;
7643         switch (rilHardwareConfig[i].type) {
7644             case RIL_HARDWARE_CONFIG_MODEM: {
7645                 records[i].modem.resize(1);
7646                 records[i].sim.resize(0);
7647                 HardwareConfigModem *hwConfigModem = &records[i].modem[0];
7648                 hwConfigModem->rat = rilHardwareConfig[i].cfg.modem.rat;
7649                 hwConfigModem->maxVoice = rilHardwareConfig[i].cfg.modem.maxVoice;
7650                 hwConfigModem->maxData = rilHardwareConfig[i].cfg.modem.maxData;
7651                 hwConfigModem->maxStandby = rilHardwareConfig[i].cfg.modem.maxStandby;
7652                 break;
7653             }
7654
7655             case RIL_HARDWARE_CONFIG_SIM: {
7656                 records[i].sim.resize(1);
7657                 records[i].modem.resize(0);
7658                 records[i].sim[0].modemUuid =
7659                         convertCharPtrToHidlString(rilHardwareConfig[i].cfg.sim.modemUuid);
7660                 break;
7661             }
7662         }
7663     }
7664 }
7665
7666 int radio::hardwareConfigChangedInd(int slotId,
7667                                     int indicationType, int token, RIL_Errno e, void *response,
7668                                     size_t responseLen) {
7669     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7670         if (response == NULL || responseLen % sizeof(RIL_HardwareConfig) != 0) {
7671             RLOGE("hardwareConfigChangedInd: invalid response");
7672             return 0;
7673         }
7674
7675         hidl_vec<HardwareConfig> configs;
7676         convertRilHardwareConfigListToHal(response, responseLen, configs);
7677
7678 #if VDBG
7679         RLOGD("hardwareConfigChangedInd");
7680 #endif
7681         Return<void> retStatus = radioService[slotId]->mRadioIndication->hardwareConfigChanged(
7682                 convertIntToRadioIndicationType(indicationType), configs);
7683         radioService[slotId]->checkReturnStatus(retStatus);
7684     } else {
7685         RLOGE("hardwareConfigChangedInd: radioService[%d]->mRadioIndication == NULL",
7686                 slotId);
7687     }
7688
7689     return 0;
7690 }
7691
7692 void convertRilRadioCapabilityToHal(void *response, size_t responseLen, RadioCapability& rc) {
7693     RIL_RadioCapability *rilRadioCapability = (RIL_RadioCapability *) response;
7694     rc.session = rilRadioCapability->session;
7695     rc.phase = (android::hardware::radio::V1_0::RadioCapabilityPhase) rilRadioCapability->phase;
7696     rc.raf = rilRadioCapability->rat;
7697     rc.logicalModemUuid = convertCharPtrToHidlString(rilRadioCapability->logicalModemUuid);
7698     rc.status = (android::hardware::radio::V1_0::RadioCapabilityStatus) rilRadioCapability->status;
7699 }
7700
7701 int radio::radioCapabilityIndicationInd(int slotId,
7702                                         int indicationType, int token, RIL_Errno e, void *response,
7703                                         size_t responseLen) {
7704     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7705         if (response == NULL || responseLen != sizeof(RIL_RadioCapability)) {
7706             RLOGE("radioCapabilityIndicationInd: invalid response");
7707             return 0;
7708         }
7709
7710         RadioCapability rc = {};
7711         convertRilRadioCapabilityToHal(response, responseLen, rc);
7712
7713 #if VDBG
7714         RLOGD("radioCapabilityIndicationInd");
7715 #endif
7716         Return<void> retStatus = radioService[slotId]->mRadioIndication->radioCapabilityIndication(
7717                 convertIntToRadioIndicationType(indicationType), rc);
7718         radioService[slotId]->checkReturnStatus(retStatus);
7719     } else {
7720         RLOGE("radioCapabilityIndicationInd: radioService[%d]->mRadioIndication == NULL",
7721                 slotId);
7722     }
7723
7724     return 0;
7725 }
7726
7727 bool isServiceTypeCfQuery(RIL_SsServiceType serType, RIL_SsRequestType reqType) {
7728     if ((reqType == SS_INTERROGATION) &&
7729         (serType == SS_CFU ||
7730          serType == SS_CF_BUSY ||
7731          serType == SS_CF_NO_REPLY ||
7732          serType == SS_CF_NOT_REACHABLE ||
7733          serType == SS_CF_ALL ||
7734          serType == SS_CF_ALL_CONDITIONAL)) {
7735         return true;
7736     }
7737     return false;
7738 }
7739
7740 int radio::onSupplementaryServiceIndicationInd(int slotId,
7741                                                int indicationType, int token, RIL_Errno e,
7742                                                void *response, size_t responseLen) {
7743     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7744         if (response == NULL || responseLen != sizeof(RIL_StkCcUnsolSsResponse)) {
7745             RLOGE("onSupplementaryServiceIndicationInd: invalid response");
7746             return 0;
7747         }
7748
7749         RIL_StkCcUnsolSsResponse *rilSsResponse = (RIL_StkCcUnsolSsResponse *) response;
7750         StkCcUnsolSsResult ss = {};
7751         ss.serviceType = (SsServiceType) rilSsResponse->serviceType;
7752         ss.requestType = (SsRequestType) rilSsResponse->requestType;
7753         ss.teleserviceType = (SsTeleserviceType) rilSsResponse->teleserviceType;
7754         ss.serviceClass = rilSsResponse->serviceClass;
7755         ss.result = (RadioError) rilSsResponse->result;
7756
7757         if (isServiceTypeCfQuery(rilSsResponse->serviceType, rilSsResponse->requestType)) {
7758 #if VDBG
7759             RLOGD("onSupplementaryServiceIndicationInd CF type, num of Cf elements %d",
7760                     rilSsResponse->cfData.numValidIndexes);
7761 #endif
7762             if (rilSsResponse->cfData.numValidIndexes > NUM_SERVICE_CLASSES) {
7763                 RLOGE("onSupplementaryServiceIndicationInd numValidIndexes is greater than "
7764                         "max value %d, truncating it to max value", NUM_SERVICE_CLASSES);
7765                 rilSsResponse->cfData.numValidIndexes = NUM_SERVICE_CLASSES;
7766             }
7767
7768             ss.cfData.resize(1);
7769             ss.ssInfo.resize(0);
7770
7771             /* number of call info's */
7772             ss.cfData[0].cfInfo.resize(rilSsResponse->cfData.numValidIndexes);
7773
7774             for (int i = 0; i < rilSsResponse->cfData.numValidIndexes; i++) {
7775                  RIL_CallForwardInfo cf = rilSsResponse->cfData.cfInfo[i];
7776                  CallForwardInfo *cfInfo = &ss.cfData[0].cfInfo[i];
7777
7778                  cfInfo->status = (CallForwardInfoStatus) cf.status;
7779                  cfInfo->reason = cf.reason;
7780                  cfInfo->serviceClass = cf.serviceClass;
7781                  cfInfo->toa = cf.toa;
7782                  cfInfo->number = convertCharPtrToHidlString(cf.number);
7783                  cfInfo->timeSeconds = cf.timeSeconds;
7784 #if VDBG
7785                  RLOGD("onSupplementaryServiceIndicationInd: "
7786                         "Data: %d,reason=%d,cls=%d,toa=%d,num=%s,tout=%d],", cf.status,
7787                         cf.reason, cf.serviceClass, cf.toa, (char*)cf.number, cf.timeSeconds);
7788 #endif
7789             }
7790         } else {
7791             ss.ssInfo.resize(1);
7792             ss.cfData.resize(0);
7793
7794             /* each int */
7795             ss.ssInfo[0].ssInfo.resize(SS_INFO_MAX);
7796             for (int i = 0; i < SS_INFO_MAX; i++) {
7797 #if VDBG
7798                  RLOGD("onSupplementaryServiceIndicationInd: Data: %d",
7799                         rilSsResponse->ssInfo[i]);
7800 #endif
7801                  ss.ssInfo[0].ssInfo[i] = rilSsResponse->ssInfo[i];
7802             }
7803         }
7804
7805 #if VDBG
7806         RLOGD("onSupplementaryServiceIndicationInd");
7807 #endif
7808         Return<void> retStatus = radioService[slotId]->mRadioIndication->
7809                 onSupplementaryServiceIndication(convertIntToRadioIndicationType(indicationType),
7810                 ss);
7811         radioService[slotId]->checkReturnStatus(retStatus);
7812     } else {
7813         RLOGE("onSupplementaryServiceIndicationInd: "
7814                 "radioService[%d]->mRadioIndication == NULL", slotId);
7815     }
7816
7817     return 0;
7818 }
7819
7820 int radio::stkCallControlAlphaNotifyInd(int slotId,
7821                                         int indicationType, int token, RIL_Errno e, void *response,
7822                                         size_t responseLen) {
7823     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7824         if (response == NULL || responseLen == 0) {
7825             RLOGE("stkCallControlAlphaNotifyInd: invalid response");
7826             return 0;
7827         }
7828 #if VDBG
7829         RLOGD("stkCallControlAlphaNotifyInd");
7830 #endif
7831         Return<void> retStatus = radioService[slotId]->mRadioIndication->stkCallControlAlphaNotify(
7832                 convertIntToRadioIndicationType(indicationType),
7833                 convertCharPtrToHidlString((char *) response));
7834         radioService[slotId]->checkReturnStatus(retStatus);
7835     } else {
7836         RLOGE("stkCallControlAlphaNotifyInd: radioService[%d]->mRadioIndication == NULL",
7837                 slotId);
7838     }
7839
7840     return 0;
7841 }
7842
7843 void convertRilLceDataInfoToHal(void *response, size_t responseLen, LceDataInfo& lce) {
7844     RIL_LceDataInfo *rilLceDataInfo = (RIL_LceDataInfo *)response;
7845     lce.lastHopCapacityKbps = rilLceDataInfo->last_hop_capacity_kbps;
7846     lce.confidenceLevel = rilLceDataInfo->confidence_level;
7847     lce.lceSuspended = rilLceDataInfo->lce_suspended;
7848 }
7849
7850 int radio::lceDataInd(int slotId,
7851                       int indicationType, int token, RIL_Errno e, void *response,
7852                       size_t responseLen) {
7853     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7854         if (response == NULL || responseLen != sizeof(RIL_LceDataInfo)) {
7855             RLOGE("lceDataInd: invalid response");
7856             return 0;
7857         }
7858
7859         LceDataInfo lce = {};
7860         convertRilLceDataInfoToHal(response, responseLen, lce);
7861 #if VDBG
7862         RLOGD("lceDataInd");
7863 #endif
7864         Return<void> retStatus = radioService[slotId]->mRadioIndication->lceData(
7865                 convertIntToRadioIndicationType(indicationType), lce);
7866         radioService[slotId]->checkReturnStatus(retStatus);
7867     } else {
7868         RLOGE("lceDataInd: radioService[%d]->mRadioIndication == NULL", slotId);
7869     }
7870
7871     return 0;
7872 }
7873
7874 int radio::pcoDataInd(int slotId,
7875                       int indicationType, int token, RIL_Errno e, void *response,
7876                       size_t responseLen) {
7877     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7878         if (response == NULL || responseLen != sizeof(RIL_PCO_Data)) {
7879             RLOGE("pcoDataInd: invalid response");
7880             return 0;
7881         }
7882
7883         PcoDataInfo pco = {};
7884         RIL_PCO_Data *rilPcoData = (RIL_PCO_Data *)response;
7885         pco.cid = rilPcoData->cid;
7886         pco.bearerProto = convertCharPtrToHidlString(rilPcoData->bearer_proto);
7887         pco.pcoId = rilPcoData->pco_id;
7888         pco.contents.setToExternal((uint8_t *) rilPcoData->contents, rilPcoData->contents_length);
7889
7890 #if VDBG
7891         RLOGD("pcoDataInd");
7892 #endif
7893         Return<void> retStatus = radioService[slotId]->mRadioIndication->pcoData(
7894                 convertIntToRadioIndicationType(indicationType), pco);
7895         radioService[slotId]->checkReturnStatus(retStatus);
7896     } else {
7897         RLOGE("pcoDataInd: radioService[%d]->mRadioIndication == NULL", slotId);
7898     }
7899
7900     return 0;
7901 }
7902
7903 int radio::modemResetInd(int slotId,
7904                          int indicationType, int token, RIL_Errno e, void *response,
7905                          size_t responseLen) {
7906     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7907         if (response == NULL || responseLen == 0) {
7908             RLOGE("modemResetInd: invalid response");
7909             return 0;
7910         }
7911 #if VDBG
7912         RLOGD("modemResetInd");
7913 #endif
7914         Return<void> retStatus = radioService[slotId]->mRadioIndication->modemReset(
7915                 convertIntToRadioIndicationType(indicationType),
7916                 convertCharPtrToHidlString((char *) response));
7917         radioService[slotId]->checkReturnStatus(retStatus);
7918     } else {
7919         RLOGE("modemResetInd: radioService[%d]->mRadioIndication == NULL", slotId);
7920     }
7921
7922     return 0;
7923 }
7924
7925 int radio::oemHookRawInd(int slotId,
7926                          int indicationType, int token, RIL_Errno e, void *response,
7927                          size_t responseLen) {
7928     if (oemHookService[slotId] != NULL && oemHookService[slotId]->mOemHookIndication != NULL) {
7929         if (response == NULL || responseLen == 0) {
7930             RLOGE("oemHookRawInd: invalid response");
7931             return 0;
7932         }
7933
7934         hidl_vec<uint8_t> data;
7935         data.setToExternal((uint8_t *) response, responseLen);
7936 #if VDBG
7937         RLOGD("oemHookRawInd");
7938 #endif
7939         Return<void> retStatus = oemHookService[slotId]->mOemHookIndication->oemHookRaw(
7940                 convertIntToRadioIndicationType(indicationType), data);
7941         checkReturnStatus(slotId, retStatus, false);
7942     } else {
7943         RLOGE("oemHookRawInd: oemHookService[%d]->mOemHookIndication == NULL", slotId);
7944     }
7945
7946     return 0;
7947 }
7948
7949 void radio::registerService(RIL_RadioFunctions *callbacks, CommandInfo *commands) {
7950     using namespace android::hardware;
7951     int simCount = 1;
7952     const char *serviceNames[] = {
7953             android::RIL_getServiceName()
7954             #if (SIM_COUNT >= 2)
7955             , RIL2_SERVICE_NAME
7956             #if (SIM_COUNT >= 3)
7957             , RIL3_SERVICE_NAME
7958             #if (SIM_COUNT >= 4)
7959             , RIL4_SERVICE_NAME
7960             #endif
7961             #endif
7962             #endif
7963             };
7964
7965     #if (SIM_COUNT >= 2)
7966     simCount = SIM_COUNT;
7967     #endif
7968
7969     configureRpcThreadpool(1, true /* callerWillJoin */);
7970     for (int i = 0; i < simCount; i++) {
7971         pthread_rwlock_t *radioServiceRwlockPtr = getRadioServiceRwlock(i);
7972         int ret = pthread_rwlock_wrlock(radioServiceRwlockPtr);
7973         assert(ret == 0);
7974
7975         radioService[i] = new RadioImpl;
7976         radioService[i]->mSlotId = i;
7977         oemHookService[i] = new OemHookImpl;
7978         oemHookService[i]->mSlotId = i;
7979         RLOGD("registerService: starting IRadio %s", serviceNames[i]);
7980         android::status_t status = radioService[i]->registerAsService(serviceNames[i]);
7981         status = oemHookService[i]->registerAsService(serviceNames[i]);
7982
7983         ret = pthread_rwlock_unlock(radioServiceRwlockPtr);
7984         assert(ret == 0);
7985     }
7986
7987     s_vendorFunctions = callbacks;
7988     s_commands = commands;
7989 }
7990
7991 void rilc_thread_pool() {
7992     joinRpcThreadpool();
7993 }
7994
7995 pthread_rwlock_t * radio::getRadioServiceRwlock(int slotId) {
7996     pthread_rwlock_t *radioServiceRwlockPtr = &radioServiceRwlock;
7997
7998     #if (SIM_COUNT >= 2)
7999     if (slotId == 2) radioServiceRwlockPtr = &radioServiceRwlock2;
8000     #if (SIM_COUNT >= 3)
8001     if (slotId == 3) radioServiceRwlockPtr = &radioServiceRwlock3;
8002     #if (SIM_COUNT >= 4)
8003     if (slotId == 4) radioServiceRwlockPtr = &radioServiceRwlock4;
8004     #endif
8005     #endif
8006     #endif
8007
8008     return radioServiceRwlockPtr;
8009 }