X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=libril%2Fril_service.cpp;h=443225a41c75b85feaf6b775b103dcadff5a412d;hb=988cd1f5d3;hp=843626768c32849dcd9bb5d60b480755b44c0106;hpb=797c1c2b6cb1b90ba43453659403ba8651d85187;p=android-x86%2Fhardware-ril.git diff --git a/libril/ril_service.cpp b/libril/ril_service.cpp index 8436267..443225a 100644 --- a/libril/ril_service.cpp +++ b/libril/ril_service.cpp @@ -40,6 +40,8 @@ using ::android::hardware::Return; using ::android::hardware::hidl_string; using ::android::hardware::hidl_vec; using ::android::hardware::hidl_array; +using ::android::hardware::radio::V1_1::NetworkScanRequest; +using ::android::hardware::radio::V1_1::KeepaliveRequest; using ::android::hardware::Void; using android::CommandInfo; using android::RequestInfo; @@ -234,6 +236,10 @@ struct RadioImpl : public ::android::hardware::radio::V1_1::IRadio { Return getAvailableNetworks(int32_t serial); + Return startNetworkScan(int32_t serial, const NetworkScanRequest& request); + + Return stopNetworkScan(int32_t serial); + Return startDtmf(int32_t serial, const ::android::hardware::hidl_string& s); @@ -422,6 +428,10 @@ struct RadioImpl : public ::android::hardware::radio::V1_1::IRadio { Return setIndicationFilter(int32_t serial, int32_t indicationFilter); + Return startKeepalive(int32_t serial, const KeepaliveRequest& keepalive); + + Return stopKeepalive(int32_t serial, int32_t sessionHandle); + Return setSimCardPower(int32_t serial, bool powerUp); Return setSimCardPower_1_1(int32_t serial, const ::android::hardware::radio::V1_1::CardPowerState state); @@ -429,8 +439,7 @@ struct RadioImpl : public ::android::hardware::radio::V1_1::IRadio { Return responseAcknowledgement(); Return setCarrierInfoForImsiEncryption(int32_t serial, - const ::android::hardware::hidl_vec& carrierKey, - const hidl_string& keyIdentifier); + const ::android::hardware::radio::V1_1::ImsiEncryptionInfo& message); void checkReturnStatus(Return& ret); }; @@ -1313,6 +1322,80 @@ Return RadioImpl::getAvailableNetworks(int32_t serial) { return Void(); } +Return RadioImpl::startNetworkScan(int32_t serial, const NetworkScanRequest& request) { +#if VDBG + RLOGD("startNetworkScan: serial %d", serial); +#endif + + RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_START_NETWORK_SCAN); + if (pRI == NULL) { + return Void(); + } + + if (request.specifiers.size() > MAX_RADIO_ACCESS_NETWORKS) { + sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS); + return Void(); + } + + RIL_NetworkScanRequest scan_request = {}; + + scan_request.type = (RIL_ScanType) request.type; + scan_request.interval = request.interval; + scan_request.specifiers_length = request.specifiers.size(); + for (size_t i = 0; i < request.specifiers.size(); ++i) { + if (request.specifiers[i].geranBands.size() > MAX_BANDS || + request.specifiers[i].utranBands.size() > MAX_BANDS || + request.specifiers[i].eutranBands.size() > MAX_BANDS || + request.specifiers[i].channels.size() > MAX_CHANNELS) { + sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS); + return Void(); + } + const ::android::hardware::radio::V1_1::RadioAccessSpecifier& ras_from = + request.specifiers[i]; + RIL_RadioAccessSpecifier& ras_to = scan_request.specifiers[i]; + + ras_to.radio_access_network = (RIL_RadioAccessNetworks) ras_from.radioAccessNetwork; + ras_to.channels_length = ras_from.channels.size(); + + std::copy(ras_from.channels.begin(), ras_from.channels.end(), ras_to.channels); + const std::vector * bands = nullptr; + switch (request.specifiers[i].radioAccessNetwork) { + case ::android::hardware::radio::V1_1::RadioAccessNetworks::GERAN: + ras_to.bands_length = ras_from.geranBands.size(); + bands = (std::vector *) &ras_from.geranBands; + break; + case ::android::hardware::radio::V1_1::RadioAccessNetworks::UTRAN: + ras_to.bands_length = ras_from.utranBands.size(); + bands = (std::vector *) &ras_from.utranBands; + break; + case ::android::hardware::radio::V1_1::RadioAccessNetworks::EUTRAN: + ras_to.bands_length = ras_from.eutranBands.size(); + bands = (std::vector *) &ras_from.eutranBands; + break; + default: + sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS); + return Void(); + } + // safe to copy to geran_bands because it's a union member + for (size_t idx = 0; idx < ras_to.bands_length; ++idx) { + ras_to.bands.geran_bands[idx] = (RIL_GeranBands) (*bands)[idx]; + } + } + + s_vendorFunctions->onRequest( + RIL_REQUEST_START_NETWORK_SCAN, &scan_request, sizeof(scan_request), pRI); + + return Void(); +} + +Return RadioImpl::stopNetworkScan(int32_t serial) { +#if VDBG + RLOGD("stopNetworkScan: serial %d", serial); +#endif + dispatchVoid(serial, mSlotId, RIL_REQUEST_STOP_NETWORK_SCAN); + return Void(); +} + Return RadioImpl::startDtmf(int32_t serial, const hidl_string& s) { #if VDBG RLOGD("startDtmf: serial %d", serial); @@ -2427,7 +2510,6 @@ Return RadioImpl::setDataProfile(int32_t serial, const hidl_vec OemHookImpl::sendRequestStrings(int32_t serial, } Return RadioImpl::setCarrierInfoForImsiEncryption(int32_t serial, - const ::android::hardware::hidl_vec& carrierKey, - const hidl_string& keyIdentifier) { + const ::android::hardware::radio::V1_1::ImsiEncryptionInfo& data) { RLOGD("setCarrierInfoForImsiEncryption: serial %d", serial); - dispatchRaw(serial, mSlotId, RIL_REQUEST_SET_CARRIER_INFO_IMSI_ENCRYPTION, carrierKey); + RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SET_CARRIER_INFO_IMSI_ENCRYPTION); + RIL_CarrierInfoForImsiEncryption imsiEncryption = {}; + + if (!copyHidlStringToRil(&imsiEncryption.mnc, data.mnc, pRI)) { + return Void(); + } + if (!copyHidlStringToRil(&imsiEncryption.mcc, data.mcc, pRI)) { + memsetAndFreeStrings(1, imsiEncryption.mnc); + return Void(); + } + if (!copyHidlStringToRil(&imsiEncryption.keyIdentifier, data.keyIdentifier, pRI)) { + memsetAndFreeStrings(2, imsiEncryption.mnc, imsiEncryption.mcc); + return Void(); + } + int32_t lSize = data.carrierKey.size(); + imsiEncryption.carrierKey = new uint8_t[lSize]; + memcpy(imsiEncryption.carrierKey, data.carrierKey.data(), lSize); + imsiEncryption.expirationTime = data.expirationTime; + s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &imsiEncryption, sizeof(RIL_CarrierInfoForImsiEncryption), pRI); + delete(imsiEncryption.carrierKey); return Void(); } +Return RadioImpl::startKeepalive(int32_t serial, const KeepaliveRequest& keepalive) { + RLOGD("startKeepalive: serial %d", serial); + return Void(); +} + +Return RadioImpl::stopKeepalive(int32_t serial, int32_t sessionHandle) { + RLOGD("stopKeepalive: serial %d", serial); + return Void(); +} + + /*************************************************************************************************** * RESPONSE FUNCTIONS * Functions above are used for requests going from framework to vendor code. The ones below are @@ -2789,11 +2900,14 @@ int radio::getIccCardStatusResponse(int slotId, RadioResponseInfo responseInfo = {}; populateResponseInfo(responseInfo, serial, responseType, e); CardStatus cardStatus = {}; - if (response == NULL || responseLen != sizeof(RIL_CardStatus_v6)) { + RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response); + if (response == NULL || responseLen != sizeof(RIL_CardStatus_v6) + || p_cur->gsm_umts_subscription_app_index >= p_cur->num_applications + || p_cur->cdma_subscription_app_index >= p_cur->num_applications + || p_cur->ims_subscription_app_index >= p_cur->num_applications) { RLOGE("getIccCardStatusResponse: Invalid response"); if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE; } else { - RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response); cardStatus.cardState = (CardState) p_cur->card_state; cardStatus.universalPinState = (PinState) p_cur->universal_pin_state; cardStatus.gsmUmtsSubscriptionAppIndex = p_cur->gsm_umts_subscription_app_index; @@ -3442,9 +3556,10 @@ void fillCellIdentityFromVoiceRegStateResponseString(CellIdentity &cellIdentity, case RIL_CELL_INFO_TYPE_CDMA:{ rilCellIdentity.cellIdentityCdma.basestationId = convertResponseStringEntryToInt(response, 4, numStrings); - rilCellIdentity.cellIdentityCdma.longitude = - convertResponseStringEntryToInt(response, 5, numStrings); + /* Order of Lat. and Long. swapped between RIL and HIDL interface versions. */ rilCellIdentity.cellIdentityCdma.latitude = + convertResponseStringEntryToInt(response, 5, numStrings); + rilCellIdentity.cellIdentityCdma.longitude = convertResponseStringEntryToInt(response, 6, numStrings); rilCellIdentity.cellIdentityCdma.systemId = convertResponseStringEntryToInt(response, 8, numStrings); @@ -6360,6 +6475,58 @@ int radio::setSimCardPowerResponse(int slotId, return 0; } +int radio::startNetworkScanResponse(int slotId, int responseType, int serial, RIL_Errno e, + void *response, size_t responseLen) { +#if VDBG + RLOGD("startNetworkScanResponse: serial %d", serial); +#endif + + if (radioService[slotId]->mRadioResponse != NULL) { + RadioResponseInfo responseInfo = {}; + populateResponseInfo(responseInfo, serial, responseType, e); + Return> ret = + ::android::hardware::radio::V1_1::IRadioResponse::castFrom( + radioService[slotId]->mRadioResponse); + if (ret.isOk()) { + sp<::android::hardware::radio::V1_1::IRadioResponse> radioResponseV1_1 = ret; + Return retStatus = radioResponseV1_1->startNetworkScanResponse(responseInfo); + radioService[slotId]->checkReturnStatus(retStatus); + } else { + RLOGD("startNetworkScanResponse: ret.isOK() == false for radioService[%d]", slotId); + } + } else { + RLOGE("startNetworkScanResponse: radioService[%d]->mRadioResponse == NULL", slotId); + } + + return 0; +} + +int radio::stopNetworkScanResponse(int slotId, int responseType, int serial, RIL_Errno e, + void *response, size_t responseLen) { +#if VDBG + RLOGD("stopNetworkScanResponse: serial %d", serial); +#endif + + if (radioService[slotId]->mRadioResponse != NULL) { + RadioResponseInfo responseInfo = {}; + populateResponseInfo(responseInfo, serial, responseType, e); + Return> ret = + ::android::hardware::radio::V1_1::IRadioResponse::castFrom( + radioService[slotId]->mRadioResponse); + if (ret.isOk()) { + sp<::android::hardware::radio::V1_1::IRadioResponse> radioResponseV1_1 = ret; + Return retStatus = radioResponseV1_1->stopNetworkScanResponse(responseInfo); + radioService[slotId]->checkReturnStatus(retStatus); + } else { + RLOGD("stopNetworkScanResponse: ret.isOK() == false for radioService[%d]", slotId); + } + } else { + RLOGE("stopNetworkScanResponse: radioService[%d]->mRadioResponse == NULL", slotId); + } + + return 0; +} + int radio::sendRequestRawResponse(int slotId, int responseType, int serial, RIL_Errno e, void *response, size_t responseLen) { @@ -8007,6 +8174,51 @@ int radio::modemResetInd(int slotId, return 0; } +int radio::networkScanResultInd(int slotId, + int indicationType, int token, RIL_Errno e, void *response, + size_t responseLen) { +#if VDBG + RLOGD("networkScanResultInd"); +#endif + if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) { + if (response == NULL || responseLen == 0) { + RLOGE("networkScanResultInd: invalid response"); + return 0; + } + RLOGD("networkScanResultInd"); + +#if VDBG + RLOGD("networkScanResultInd"); +#endif + + Return> ret = + ::android::hardware::radio::V1_1::IRadioIndication::castFrom( + radioService[slotId]->mRadioIndication); + if (ret.isOk()) { + RIL_NetworkScanResult *networkScanResult = (RIL_NetworkScanResult *) response; + + ::android::hardware::radio::V1_1::NetworkScanResult result; + result.status = + (::android::hardware::radio::V1_1::ScanStatus) networkScanResult->status; + result.error = (RadioError) e; + convertRilCellInfoListToHal( + networkScanResult->network_infos, + networkScanResult->network_infos_length * sizeof(RIL_CellInfo_v12), + result.networkInfos); + + sp<::android::hardware::radio::V1_1::IRadioIndication> radioIndicationV1_1 = ret; + Return retStatus = radioIndicationV1_1->networkScanResult( + convertIntToRadioIndicationType(indicationType), result); + radioService[slotId]->checkReturnStatus(retStatus); + } else { + RLOGE("networkScanResultInd: ret.isOk() == false for radioService[%d]", slotId); + } + } else { + RLOGE("networkScanResultInd: radioService[%d]->mRadioIndication == NULL", slotId); + } + return 0; +} + int radio::carrierInfoForImsiEncryption(int slotId, int indicationType, int token, RIL_Errno e, void *response, size_t responseLen) {