Home | History | Annotate | Download | only in functional
      1 /*
      2  * Copyright (C) 2017 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 #include <radio_hidl_hal_utils_v1_0.h>
     18 
     19 CardStatus cardStatus;
     20 
     21 RadioResponse::RadioResponse(RadioHidlTest& parent) : parent(parent) {}
     22 
     23 Return<void> RadioResponse::getIccCardStatusResponse(const RadioResponseInfo& info,
     24                                                      const CardStatus& card_status) {
     25     rspInfo = info;
     26     cardStatus = card_status;
     27     parent.notify(info.serial);
     28     return Void();
     29 }
     30 
     31 Return<void> RadioResponse::supplyIccPinForAppResponse(const RadioResponseInfo& info,
     32                                                        int32_t /*remainingRetries*/) {
     33     rspInfo = info;
     34     parent.notify(info.serial);
     35     return Void();
     36 }
     37 
     38 Return<void> RadioResponse::supplyIccPukForAppResponse(const RadioResponseInfo& info,
     39                                                        int32_t /*remainingRetries*/) {
     40     rspInfo = info;
     41     parent.notify(info.serial);
     42     return Void();
     43 }
     44 
     45 Return<void> RadioResponse::supplyIccPin2ForAppResponse(const RadioResponseInfo& info,
     46                                                         int32_t /*remainingRetries*/) {
     47     rspInfo = info;
     48     parent.notify(info.serial);
     49     return Void();
     50 }
     51 
     52 Return<void> RadioResponse::supplyIccPuk2ForAppResponse(const RadioResponseInfo& info,
     53                                                         int32_t /*remainingRetries*/) {
     54     rspInfo = info;
     55     parent.notify(info.serial);
     56     return Void();
     57 }
     58 
     59 Return<void> RadioResponse::changeIccPinForAppResponse(const RadioResponseInfo& info,
     60                                                        int32_t /*remainingRetries*/) {
     61     rspInfo = info;
     62     parent.notify(info.serial);
     63     return Void();
     64 }
     65 
     66 Return<void> RadioResponse::changeIccPin2ForAppResponse(const RadioResponseInfo& info,
     67                                                         int32_t /*remainingRetries*/) {
     68     rspInfo = info;
     69     parent.notify(info.serial);
     70     return Void();
     71 }
     72 
     73 Return<void> RadioResponse::supplyNetworkDepersonalizationResponse(const RadioResponseInfo& info,
     74                                                                    int32_t /*remainingRetries*/) {
     75     rspInfo = info;
     76     parent.notify(info.serial);
     77     return Void();
     78 }
     79 
     80 Return<void> RadioResponse::getCurrentCallsResponse(
     81     const RadioResponseInfo& info, const ::android::hardware::hidl_vec<Call>& /*calls*/) {
     82     rspInfo = info;
     83     parent.notify(info.serial);
     84     return Void();
     85 }
     86 
     87 Return<void> RadioResponse::dialResponse(const RadioResponseInfo& info) {
     88     rspInfo = info;
     89     parent.notify(info.serial);
     90     return Void();
     91 }
     92 
     93 Return<void> RadioResponse::getIMSIForAppResponse(const RadioResponseInfo& info,
     94                                                   const ::android::hardware::hidl_string& imsi) {
     95     rspInfo = info;
     96     this->imsi = imsi;
     97     parent.notify(info.serial);
     98     return Void();
     99 }
    100 
    101 Return<void> RadioResponse::hangupConnectionResponse(const RadioResponseInfo& info) {
    102     rspInfo = info;
    103     parent.notify(info.serial);
    104     return Void();
    105 }
    106 
    107 Return<void> RadioResponse::hangupWaitingOrBackgroundResponse(const RadioResponseInfo& info) {
    108     rspInfo = info;
    109     parent.notify(info.serial);
    110     return Void();
    111 }
    112 
    113 Return<void> RadioResponse::hangupForegroundResumeBackgroundResponse(
    114     const RadioResponseInfo& info) {
    115     rspInfo = info;
    116     parent.notify(info.serial);
    117     return Void();
    118 }
    119 
    120 Return<void> RadioResponse::switchWaitingOrHoldingAndActiveResponse(const RadioResponseInfo& info) {
    121     rspInfo = info;
    122     parent.notify(info.serial);
    123     return Void();
    124 }
    125 
    126 Return<void> RadioResponse::conferenceResponse(const RadioResponseInfo& info) {
    127     rspInfo = info;
    128     parent.notify(info.serial);
    129     return Void();
    130 }
    131 
    132 Return<void> RadioResponse::rejectCallResponse(const RadioResponseInfo& info) {
    133     rspInfo = info;
    134     parent.notify(info.serial);
    135     return Void();
    136 }
    137 
    138 Return<void> RadioResponse::getLastCallFailCauseResponse(
    139     const RadioResponseInfo& info, const LastCallFailCauseInfo& /*failCauseInfo*/) {
    140     rspInfo = info;
    141     parent.notify(info.serial);
    142     return Void();
    143 }
    144 
    145 Return<void> RadioResponse::getSignalStrengthResponse(const RadioResponseInfo& info,
    146                                                       const SignalStrength& /*sig_strength*/) {
    147     rspInfo = info;
    148     parent.notify(info.serial);
    149     return Void();
    150 }
    151 
    152 Return<void> RadioResponse::getVoiceRegistrationStateResponse(
    153     const RadioResponseInfo& info, const VoiceRegStateResult& /*voiceRegResponse*/) {
    154     rspInfo = info;
    155     parent.notify(info.serial);
    156     return Void();
    157 }
    158 
    159 Return<void> RadioResponse::getDataRegistrationStateResponse(
    160     const RadioResponseInfo& info, const DataRegStateResult& /*dataRegResponse*/) {
    161     rspInfo = info;
    162     parent.notify(info.serial);
    163     return Void();
    164 }
    165 
    166 Return<void> RadioResponse::getOperatorResponse(
    167     const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*longName*/,
    168     const ::android::hardware::hidl_string& /*shortName*/,
    169     const ::android::hardware::hidl_string& /*numeric*/) {
    170     rspInfo = info;
    171     parent.notify(info.serial);
    172     return Void();
    173 }
    174 
    175 Return<void> RadioResponse::setRadioPowerResponse(const RadioResponseInfo& info) {
    176     rspInfo = info;
    177     parent.notify(info.serial);
    178     return Void();
    179 }
    180 
    181 Return<void> RadioResponse::sendDtmfResponse(const RadioResponseInfo& info) {
    182     rspInfo = info;
    183     parent.notify(info.serial);
    184     return Void();
    185 }
    186 
    187 Return<void> RadioResponse::sendSmsResponse(const RadioResponseInfo& info,
    188                                             const SendSmsResult& sms) {
    189     rspInfo = info;
    190     sendSmsResult = sms;
    191     parent.notify(info.serial);
    192     return Void();
    193 }
    194 
    195 Return<void> RadioResponse::sendSMSExpectMoreResponse(const RadioResponseInfo& info,
    196                                                       const SendSmsResult& sms) {
    197     rspInfo = info;
    198     sendSmsResult = sms;
    199     parent.notify(info.serial);
    200     return Void();
    201 }
    202 
    203 Return<void> RadioResponse::setupDataCallResponse(const RadioResponseInfo& info,
    204                                                   const SetupDataCallResult& /*dcResponse*/) {
    205     rspInfo = info;
    206     parent.notify(info.serial);
    207     return Void();
    208 }
    209 
    210 Return<void> RadioResponse::iccIOForAppResponse(const RadioResponseInfo& info,
    211                                                 const IccIoResult& iccIo) {
    212     rspInfo = info;
    213     this->iccIoResult = iccIo;
    214     parent.notify(info.serial);
    215     return Void();
    216 }
    217 
    218 Return<void> RadioResponse::sendUssdResponse(const RadioResponseInfo& info) {
    219     rspInfo = info;
    220     parent.notify(info.serial);
    221     return Void();
    222 }
    223 
    224 Return<void> RadioResponse::cancelPendingUssdResponse(const RadioResponseInfo& info) {
    225     rspInfo = info;
    226     parent.notify(info.serial);
    227     return Void();
    228 }
    229 
    230 Return<void> RadioResponse::getClirResponse(const RadioResponseInfo& info, int32_t /*n*/,
    231                                             int32_t /*m*/) {
    232     rspInfo = info;
    233     parent.notify(info.serial);
    234     return Void();
    235 }
    236 
    237 Return<void> RadioResponse::setClirResponse(const RadioResponseInfo& info) {
    238     rspInfo = info;
    239     parent.notify(info.serial);
    240     return Void();
    241 }
    242 
    243 Return<void> RadioResponse::getCallForwardStatusResponse(
    244     const RadioResponseInfo& info, const ::android::hardware::hidl_vec<CallForwardInfo>&
    245     /*callForwardInfos*/) {
    246     rspInfo = info;
    247     parent.notify(info.serial);
    248     return Void();
    249 }
    250 
    251 Return<void> RadioResponse::setCallForwardResponse(const RadioResponseInfo& info) {
    252     rspInfo = info;
    253     parent.notify(info.serial);
    254     return Void();
    255 }
    256 
    257 Return<void> RadioResponse::getCallWaitingResponse(const RadioResponseInfo& info, bool /*enable*/,
    258                                                    int32_t /*serviceClass*/) {
    259     rspInfo = info;
    260     parent.notify(info.serial);
    261     return Void();
    262 }
    263 
    264 Return<void> RadioResponse::setCallWaitingResponse(const RadioResponseInfo& info) {
    265     rspInfo = info;
    266     parent.notify(info.serial);
    267     return Void();
    268 }
    269 
    270 Return<void> RadioResponse::acknowledgeLastIncomingGsmSmsResponse(const RadioResponseInfo& info) {
    271     rspInfo = info;
    272     parent.notify(info.serial);
    273     return Void();
    274 }
    275 
    276 Return<void> RadioResponse::acceptCallResponse(const RadioResponseInfo& info) {
    277     rspInfo = info;
    278     parent.notify(info.serial);
    279     return Void();
    280 }
    281 
    282 Return<void> RadioResponse::deactivateDataCallResponse(const RadioResponseInfo& info) {
    283     rspInfo = info;
    284     parent.notify(info.serial);
    285     return Void();
    286 }
    287 
    288 Return<void> RadioResponse::getFacilityLockForAppResponse(const RadioResponseInfo& info,
    289                                                           int32_t /*response*/) {
    290     rspInfo = info;
    291     parent.notify(info.serial);
    292     return Void();
    293 }
    294 
    295 Return<void> RadioResponse::setFacilityLockForAppResponse(const RadioResponseInfo& info,
    296                                                           int32_t /*retry*/) {
    297     rspInfo = info;
    298     parent.notify(info.serial);
    299     return Void();
    300 }
    301 
    302 Return<void> RadioResponse::setBarringPasswordResponse(const RadioResponseInfo& info) {
    303     rspInfo = info;
    304     parent.notify(info.serial);
    305     return Void();
    306 }
    307 
    308 Return<void> RadioResponse::getNetworkSelectionModeResponse(const RadioResponseInfo& info,
    309                                                             bool /*manual*/) {
    310     rspInfo = info;
    311     parent.notify(info.serial);
    312     return Void();
    313 }
    314 
    315 Return<void> RadioResponse::setNetworkSelectionModeAutomaticResponse(
    316     const RadioResponseInfo& info) {
    317     rspInfo = info;
    318     parent.notify(info.serial);
    319     return Void();
    320 }
    321 
    322 Return<void> RadioResponse::setNetworkSelectionModeManualResponse(const RadioResponseInfo& info) {
    323     rspInfo = info;
    324     parent.notify(info.serial);
    325     return Void();
    326 }
    327 
    328 Return<void> RadioResponse::getAvailableNetworksResponse(
    329     const RadioResponseInfo& info,
    330     const ::android::hardware::hidl_vec<OperatorInfo>& /*networkInfos*/) {
    331     rspInfo = info;
    332     parent.notify(info.serial);
    333     return Void();
    334 }
    335 
    336 Return<void> RadioResponse::startDtmfResponse(const RadioResponseInfo& info) {
    337     rspInfo = info;
    338     parent.notify(info.serial);
    339     return Void();
    340 }
    341 
    342 Return<void> RadioResponse::stopDtmfResponse(const RadioResponseInfo& info) {
    343     rspInfo = info;
    344     parent.notify(info.serial);
    345     return Void();
    346 }
    347 
    348 Return<void> RadioResponse::getBasebandVersionResponse(
    349     const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*version*/) {
    350     rspInfo = info;
    351     parent.notify(info.serial);
    352     return Void();
    353 }
    354 
    355 Return<void> RadioResponse::separateConnectionResponse(const RadioResponseInfo& info) {
    356     rspInfo = info;
    357     parent.notify(info.serial);
    358     return Void();
    359 }
    360 
    361 Return<void> RadioResponse::setMuteResponse(const RadioResponseInfo& info) {
    362     rspInfo = info;
    363     parent.notify(info.serial);
    364     return Void();
    365 }
    366 
    367 Return<void> RadioResponse::getMuteResponse(const RadioResponseInfo& info, bool /*enable*/) {
    368     rspInfo = info;
    369     parent.notify(info.serial);
    370     return Void();
    371 }
    372 
    373 Return<void> RadioResponse::getClipResponse(const RadioResponseInfo& info, ClipStatus /*status*/) {
    374     rspInfo = info;
    375     parent.notify(info.serial);
    376     return Void();
    377 }
    378 
    379 Return<void> RadioResponse::getDataCallListResponse(
    380     const RadioResponseInfo& info,
    381     const ::android::hardware::hidl_vec<SetupDataCallResult>& /*dcResponse*/) {
    382     rspInfo = info;
    383     parent.notify(info.serial);
    384     return Void();
    385 }
    386 
    387 Return<void> RadioResponse::sendOemRilRequestRawResponse(
    388     const RadioResponseInfo& /*info*/, const ::android::hardware::hidl_vec<uint8_t>& /*data*/) {
    389     return Void();
    390 }
    391 
    392 Return<void> RadioResponse::sendOemRilRequestStringsResponse(
    393     const RadioResponseInfo& /*info*/,
    394     const ::android::hardware::hidl_vec< ::android::hardware::hidl_string>& /*data*/) {
    395     return Void();
    396 }
    397 
    398 Return<void> RadioResponse::setSuppServiceNotificationsResponse(const RadioResponseInfo& info) {
    399     rspInfo = info;
    400     parent.notify(info.serial);
    401     return Void();
    402 }
    403 
    404 Return<void> RadioResponse::writeSmsToSimResponse(const RadioResponseInfo& info, int32_t index) {
    405     rspInfo = info;
    406     writeSmsToSimIndex = index;
    407     parent.notify(info.serial);
    408     return Void();
    409 }
    410 
    411 Return<void> RadioResponse::deleteSmsOnSimResponse(const RadioResponseInfo& info) {
    412     rspInfo = info;
    413     parent.notify(info.serial);
    414     return Void();
    415 }
    416 
    417 Return<void> RadioResponse::setBandModeResponse(const RadioResponseInfo& info) {
    418     rspInfo = info;
    419     parent.notify(info.serial);
    420     return Void();
    421 }
    422 
    423 Return<void> RadioResponse::getAvailableBandModesResponse(
    424     const RadioResponseInfo& info,
    425     const ::android::hardware::hidl_vec<RadioBandMode>& /*bandModes*/) {
    426     rspInfo = info;
    427     parent.notify(info.serial);
    428     return Void();
    429 }
    430 
    431 Return<void> RadioResponse::sendEnvelopeResponse(
    432     const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*commandResponse*/) {
    433     rspInfo = info;
    434     parent.notify(info.serial);
    435     return Void();
    436 }
    437 
    438 Return<void> RadioResponse::sendTerminalResponseToSimResponse(const RadioResponseInfo& info) {
    439     rspInfo = info;
    440     parent.notify(info.serial);
    441     return Void();
    442 }
    443 
    444 Return<void> RadioResponse::handleStkCallSetupRequestFromSimResponse(
    445     const RadioResponseInfo& info) {
    446     rspInfo = info;
    447     parent.notify(info.serial);
    448     return Void();
    449 }
    450 
    451 Return<void> RadioResponse::explicitCallTransferResponse(const RadioResponseInfo& info) {
    452     rspInfo = info;
    453     parent.notify(info.serial);
    454     return Void();
    455 }
    456 
    457 Return<void> RadioResponse::setPreferredNetworkTypeResponse(const RadioResponseInfo& info) {
    458     rspInfo = info;
    459     parent.notify(info.serial);
    460     return Void();
    461 }
    462 
    463 Return<void> RadioResponse::getPreferredNetworkTypeResponse(const RadioResponseInfo& info,
    464                                                             PreferredNetworkType /*nw_type*/) {
    465     rspInfo = info;
    466     parent.notify(info.serial);
    467     return Void();
    468 }
    469 
    470 Return<void> RadioResponse::getNeighboringCidsResponse(
    471     const RadioResponseInfo& info,
    472     const ::android::hardware::hidl_vec<NeighboringCell>& /*cells*/) {
    473     rspInfo = info;
    474     parent.notify(info.serial);
    475     return Void();
    476 }
    477 
    478 Return<void> RadioResponse::setLocationUpdatesResponse(const RadioResponseInfo& info) {
    479     rspInfo = info;
    480     parent.notify(info.serial);
    481     return Void();
    482 }
    483 
    484 Return<void> RadioResponse::setCdmaSubscriptionSourceResponse(const RadioResponseInfo& info) {
    485     rspInfo = info;
    486     parent.notify(info.serial);
    487     return Void();
    488 }
    489 
    490 Return<void> RadioResponse::setCdmaRoamingPreferenceResponse(const RadioResponseInfo& info) {
    491     rspInfo = info;
    492     parent.notify(info.serial);
    493     return Void();
    494 }
    495 
    496 Return<void> RadioResponse::getCdmaRoamingPreferenceResponse(const RadioResponseInfo& info,
    497                                                              CdmaRoamingType /*type*/) {
    498     rspInfo = info;
    499     parent.notify(info.serial);
    500     return Void();
    501 }
    502 
    503 Return<void> RadioResponse::setTTYModeResponse(const RadioResponseInfo& info) {
    504     rspInfo = info;
    505     parent.notify(info.serial);
    506     return Void();
    507 }
    508 
    509 Return<void> RadioResponse::getTTYModeResponse(const RadioResponseInfo& info, TtyMode /*mode*/) {
    510     rspInfo = info;
    511     parent.notify(info.serial);
    512     return Void();
    513 }
    514 
    515 Return<void> RadioResponse::setPreferredVoicePrivacyResponse(const RadioResponseInfo& info) {
    516     rspInfo = info;
    517     parent.notify(info.serial);
    518     return Void();
    519 }
    520 
    521 Return<void> RadioResponse::getPreferredVoicePrivacyResponse(const RadioResponseInfo& info,
    522                                                              bool /*enable*/) {
    523     rspInfo = info;
    524     parent.notify(info.serial);
    525     return Void();
    526 }
    527 
    528 Return<void> RadioResponse::sendCDMAFeatureCodeResponse(const RadioResponseInfo& info) {
    529     rspInfo = info;
    530     parent.notify(info.serial);
    531     return Void();
    532 }
    533 
    534 Return<void> RadioResponse::sendBurstDtmfResponse(const RadioResponseInfo& info) {
    535     rspInfo = info;
    536     parent.notify(info.serial);
    537     return Void();
    538 }
    539 
    540 Return<void> RadioResponse::sendCdmaSmsResponse(const RadioResponseInfo& info,
    541                                                 const SendSmsResult& sms) {
    542     rspInfo = info;
    543     sendSmsResult = sms;
    544     parent.notify(info.serial);
    545     return Void();
    546 }
    547 
    548 Return<void> RadioResponse::acknowledgeLastIncomingCdmaSmsResponse(const RadioResponseInfo& info) {
    549     rspInfo = info;
    550     parent.notify(info.serial);
    551     return Void();
    552 }
    553 
    554 Return<void> RadioResponse::getGsmBroadcastConfigResponse(
    555     const RadioResponseInfo& info,
    556     const ::android::hardware::hidl_vec<GsmBroadcastSmsConfigInfo>& /*configs*/) {
    557     rspInfo = info;
    558     parent.notify(info.serial);
    559     return Void();
    560 }
    561 
    562 Return<void> RadioResponse::setGsmBroadcastConfigResponse(const RadioResponseInfo& info) {
    563     rspInfo = info;
    564     parent.notify(info.serial);
    565     return Void();
    566 }
    567 
    568 Return<void> RadioResponse::setGsmBroadcastActivationResponse(const RadioResponseInfo& info) {
    569     rspInfo = info;
    570     parent.notify(info.serial);
    571     return Void();
    572 }
    573 
    574 Return<void> RadioResponse::getCdmaBroadcastConfigResponse(
    575     const RadioResponseInfo& info,
    576     const ::android::hardware::hidl_vec<CdmaBroadcastSmsConfigInfo>& /*configs*/) {
    577     rspInfo = info;
    578     parent.notify(info.serial);
    579     return Void();
    580 }
    581 
    582 Return<void> RadioResponse::setCdmaBroadcastConfigResponse(const RadioResponseInfo& info) {
    583     rspInfo = info;
    584     parent.notify(info.serial);
    585     return Void();
    586 }
    587 
    588 Return<void> RadioResponse::setCdmaBroadcastActivationResponse(const RadioResponseInfo& info) {
    589     rspInfo = info;
    590     parent.notify(info.serial);
    591     return Void();
    592 }
    593 
    594 Return<void> RadioResponse::getCDMASubscriptionResponse(
    595     const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*mdn*/,
    596     const ::android::hardware::hidl_string& /*hSid*/,
    597     const ::android::hardware::hidl_string& /*hNid*/,
    598     const ::android::hardware::hidl_string& /*min*/,
    599     const ::android::hardware::hidl_string& /*prl*/) {
    600     rspInfo = info;
    601     parent.notify(info.serial);
    602     return Void();
    603 }
    604 
    605 Return<void> RadioResponse::writeSmsToRuimResponse(const RadioResponseInfo& info, uint32_t index) {
    606     rspInfo = info;
    607     writeSmsToRuimIndex = index;
    608     parent.notify(info.serial);
    609     return Void();
    610 }
    611 
    612 Return<void> RadioResponse::deleteSmsOnRuimResponse(const RadioResponseInfo& info) {
    613     rspInfo = info;
    614     parent.notify(info.serial);
    615     return Void();
    616 }
    617 
    618 Return<void> RadioResponse::getDeviceIdentityResponse(
    619     const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*imei*/,
    620     const ::android::hardware::hidl_string& /*imeisv*/,
    621     const ::android::hardware::hidl_string& /*esn*/,
    622     const ::android::hardware::hidl_string& /*meid*/) {
    623     rspInfo = info;
    624     parent.notify(info.serial);
    625     return Void();
    626 }
    627 
    628 Return<void> RadioResponse::exitEmergencyCallbackModeResponse(const RadioResponseInfo& info) {
    629     rspInfo = info;
    630     parent.notify(info.serial);
    631     return Void();
    632 }
    633 
    634 Return<void> RadioResponse::getSmscAddressResponse(const RadioResponseInfo& info,
    635                                                    const ::android::hardware::hidl_string& smsc) {
    636     rspInfo = info;
    637     smscAddress = smsc;
    638     parent.notify(info.serial);
    639     return Void();
    640 }
    641 
    642 Return<void> RadioResponse::setSmscAddressResponse(const RadioResponseInfo& info) {
    643     rspInfo = info;
    644     parent.notify(info.serial);
    645     return Void();
    646 }
    647 
    648 Return<void> RadioResponse::reportSmsMemoryStatusResponse(const RadioResponseInfo& info) {
    649     rspInfo = info;
    650     parent.notify(info.serial);
    651     return Void();
    652 }
    653 
    654 Return<void> RadioResponse::reportStkServiceIsRunningResponse(const RadioResponseInfo& info) {
    655     rspInfo = info;
    656     parent.notify(info.serial);
    657     return Void();
    658 }
    659 
    660 Return<void> RadioResponse::getCdmaSubscriptionSourceResponse(const RadioResponseInfo& info,
    661                                                               CdmaSubscriptionSource /*source*/) {
    662     rspInfo = info;
    663     parent.notify(info.serial);
    664     return Void();
    665 }
    666 
    667 Return<void> RadioResponse::requestIsimAuthenticationResponse(
    668     const RadioResponseInfo& info, const ::android::hardware::hidl_string& /*response*/) {
    669     rspInfo = info;
    670     parent.notify(info.serial);
    671     return Void();
    672 }
    673 
    674 Return<void> RadioResponse::acknowledgeIncomingGsmSmsWithPduResponse(
    675     const RadioResponseInfo& info) {
    676     rspInfo = info;
    677     parent.notify(info.serial);
    678     return Void();
    679 }
    680 
    681 Return<void> RadioResponse::sendEnvelopeWithStatusResponse(const RadioResponseInfo& info,
    682                                                            const IccIoResult& /*iccIo*/) {
    683     rspInfo = info;
    684     parent.notify(info.serial);
    685     return Void();
    686 }
    687 
    688 Return<void> RadioResponse::getVoiceRadioTechnologyResponse(const RadioResponseInfo& info,
    689                                                             RadioTechnology /*rat*/) {
    690     rspInfo = info;
    691     parent.notify(info.serial);
    692     return Void();
    693 }
    694 
    695 Return<void> RadioResponse::getCellInfoListResponse(
    696     const RadioResponseInfo& info, const ::android::hardware::hidl_vec<CellInfo>& /*cellInfo*/) {
    697     rspInfo = info;
    698     parent.notify(info.serial);
    699     return Void();
    700 }
    701 
    702 Return<void> RadioResponse::setCellInfoListRateResponse(const RadioResponseInfo& info) {
    703     rspInfo = info;
    704     parent.notify(info.serial);
    705     return Void();
    706 }
    707 
    708 Return<void> RadioResponse::setInitialAttachApnResponse(const RadioResponseInfo& info) {
    709     rspInfo = info;
    710     parent.notify(info.serial);
    711     return Void();
    712 }
    713 
    714 Return<void> RadioResponse::getImsRegistrationStateResponse(const RadioResponseInfo& info,
    715                                                             bool /*isRegistered*/,
    716                                                             RadioTechnologyFamily /*ratFamily*/) {
    717     rspInfo = info;
    718     parent.notify(info.serial);
    719     return Void();
    720 }
    721 
    722 Return<void> RadioResponse::sendImsSmsResponse(const RadioResponseInfo& info,
    723                                                const SendSmsResult& sms) {
    724     rspInfo = info;
    725     sendSmsResult = sms;
    726     parent.notify(info.serial);
    727     return Void();
    728 }
    729 
    730 Return<void> RadioResponse::iccTransmitApduBasicChannelResponse(const RadioResponseInfo& info,
    731                                                                 const IccIoResult& result) {
    732     rspInfo = info;
    733     this->iccIoResult = result;
    734     parent.notify(info.serial);
    735     return Void();
    736 }
    737 
    738 Return<void> RadioResponse::iccOpenLogicalChannelResponse(
    739     const RadioResponseInfo& info, int32_t channelId,
    740     const ::android::hardware::hidl_vec<int8_t>& /*selectResponse*/) {
    741     rspInfo = info;
    742     this->channelId = channelId;
    743     parent.notify(info.serial);
    744     return Void();
    745 }
    746 
    747 Return<void> RadioResponse::iccCloseLogicalChannelResponse(const RadioResponseInfo& info) {
    748     rspInfo = info;
    749     parent.notify(info.serial);
    750     return Void();
    751 }
    752 
    753 Return<void> RadioResponse::iccTransmitApduLogicalChannelResponse(const RadioResponseInfo& info,
    754                                                                   const IccIoResult& result) {
    755     rspInfo = info;
    756     this->iccIoResult = result;
    757     parent.notify(info.serial);
    758     return Void();
    759 }
    760 
    761 Return<void> RadioResponse::nvReadItemResponse(const RadioResponseInfo& info,
    762                                                const ::android::hardware::hidl_string& /*result*/) {
    763     rspInfo = info;
    764     parent.notify(info.serial);
    765     return Void();
    766 }
    767 
    768 Return<void> RadioResponse::nvWriteItemResponse(const RadioResponseInfo& info) {
    769     rspInfo = info;
    770     parent.notify(info.serial);
    771     return Void();
    772 }
    773 
    774 Return<void> RadioResponse::nvWriteCdmaPrlResponse(const RadioResponseInfo& info) {
    775     rspInfo = info;
    776     parent.notify(info.serial);
    777     return Void();
    778 }
    779 
    780 Return<void> RadioResponse::nvResetConfigResponse(const RadioResponseInfo& info) {
    781     rspInfo = info;
    782     parent.notify(info.serial);
    783     return Void();
    784 }
    785 
    786 Return<void> RadioResponse::setUiccSubscriptionResponse(const RadioResponseInfo& info) {
    787     rspInfo = info;
    788     parent.notify(info.serial);
    789     return Void();
    790 }
    791 
    792 Return<void> RadioResponse::setDataAllowedResponse(const RadioResponseInfo& info) {
    793     rspInfo = info;
    794     parent.notify(info.serial);
    795     return Void();
    796 }
    797 
    798 Return<void> RadioResponse::getHardwareConfigResponse(
    799     const RadioResponseInfo& info,
    800     const ::android::hardware::hidl_vec<HardwareConfig>& /*config*/) {
    801     rspInfo = info;
    802     parent.notify(info.serial);
    803     return Void();
    804 }
    805 
    806 Return<void> RadioResponse::requestIccSimAuthenticationResponse(const RadioResponseInfo& info,
    807                                                                 const IccIoResult& result) {
    808     rspInfo = info;
    809     this->iccIoResult = result;
    810     parent.notify(info.serial);
    811     return Void();
    812 }
    813 
    814 Return<void> RadioResponse::setDataProfileResponse(const RadioResponseInfo& info) {
    815     rspInfo = info;
    816     parent.notify(info.serial);
    817     return Void();
    818 }
    819 
    820 Return<void> RadioResponse::requestShutdownResponse(const RadioResponseInfo& info) {
    821     rspInfo = info;
    822     parent.notify(info.serial);
    823     return Void();
    824 }
    825 
    826 Return<void> RadioResponse::getRadioCapabilityResponse(const RadioResponseInfo& info,
    827                                                        const RadioCapability& /*rc*/) {
    828     rspInfo = info;
    829     parent.notify(info.serial);
    830     return Void();
    831 }
    832 
    833 Return<void> RadioResponse::setRadioCapabilityResponse(const RadioResponseInfo& info,
    834                                                        const RadioCapability& /*rc*/) {
    835     rspInfo = info;
    836     parent.notify(info.serial);
    837     return Void();
    838 }
    839 
    840 Return<void> RadioResponse::startLceServiceResponse(const RadioResponseInfo& info,
    841                                                     const LceStatusInfo& /*statusInfo*/) {
    842     rspInfo = info;
    843     parent.notify(info.serial);
    844     return Void();
    845 }
    846 
    847 Return<void> RadioResponse::stopLceServiceResponse(const RadioResponseInfo& info,
    848                                                    const LceStatusInfo& /*statusInfo*/) {
    849     rspInfo = info;
    850     parent.notify(info.serial);
    851     return Void();
    852 }
    853 
    854 Return<void> RadioResponse::pullLceDataResponse(const RadioResponseInfo& info,
    855                                                 const LceDataInfo& /*lceInfo*/) {
    856     rspInfo = info;
    857     parent.notify(info.serial);
    858     return Void();
    859 }
    860 
    861 Return<void> RadioResponse::getModemActivityInfoResponse(
    862     const RadioResponseInfo& info, const ActivityStatsInfo& /*activityInfo*/) {
    863     rspInfo = info;
    864     parent.notify(info.serial);
    865     return Void();
    866 }
    867 
    868 Return<void> RadioResponse::setAllowedCarriersResponse(const RadioResponseInfo& info,
    869                                                        int32_t /*numAllowed*/) {
    870     rspInfo = info;
    871     parent.notify(info.serial);
    872     return Void();
    873 }
    874 
    875 Return<void> RadioResponse::getAllowedCarriersResponse(const RadioResponseInfo& info,
    876                                                        bool /*allAllowed*/,
    877                                                        const CarrierRestrictions& /*carriers*/) {
    878     rspInfo = info;
    879     parent.notify(info.serial);
    880     return Void();
    881 }
    882 
    883 Return<void> RadioResponse::sendDeviceStateResponse(const RadioResponseInfo& info) {
    884     rspInfo = info;
    885     parent.notify(info.serial);
    886     return Void();
    887 }
    888 
    889 Return<void> RadioResponse::setIndicationFilterResponse(const RadioResponseInfo& info) {
    890     rspInfo = info;
    891     parent.notify(info.serial);
    892     return Void();
    893 }
    894 
    895 Return<void> RadioResponse::setSimCardPowerResponse(const RadioResponseInfo& info) {
    896     rspInfo = info;
    897     parent.notify(info.serial);
    898     return Void();
    899 }
    900 
    901 Return<void> RadioResponse::acknowledgeRequest(int32_t /*serial*/) {
    902     return Void();
    903 }
    904