| /* |
| * Copyright 2020 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "FrontendClient" |
| |
| #include <android-base/logging.h> |
| #include <utils/Log.h> |
| |
| #include "FrontendClient.h" |
| |
| using ::aidl::android::media::tv::tuner::TunerFrontendScanAtsc3PlpInfo; |
| using ::aidl::android::media::tv::tuner::TunerFrontendUnionSettings; |
| |
| using ::android::hardware::tv::tuner::V1_0::FrontendAnalogSifStandard; |
| using ::android::hardware::tv::tuner::V1_0::FrontendAnalogType; |
| using ::android::hardware::tv::tuner::V1_0::FrontendAtscModulation; |
| using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3Bandwidth; |
| using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3Modulation; |
| using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3TimeInterleaveMode; |
| using ::android::hardware::tv::tuner::V1_0::FrontendDvbcAnnex; |
| using ::android::hardware::tv::tuner::V1_0::FrontendDvbcModulation; |
| using ::android::hardware::tv::tuner::V1_0::FrontendDvbcSpectralInversion; |
| using ::android::hardware::tv::tuner::V1_0::FrontendDvbsModulation; |
| using ::android::hardware::tv::tuner::V1_0::FrontendDvbsStandard; |
| using ::android::hardware::tv::tuner::V1_0::FrontendDvbsRolloff; |
| using ::android::hardware::tv::tuner::V1_0::FrontendDvbtBandwidth; |
| using ::android::hardware::tv::tuner::V1_0::FrontendDvbtGuardInterval; |
| using ::android::hardware::tv::tuner::V1_0::FrontendDvbtHierarchy; |
| using ::android::hardware::tv::tuner::V1_0::FrontendDvbtStandard; |
| using ::android::hardware::tv::tuner::V1_0::FrontendInnerFec; |
| using ::android::hardware::tv::tuner::V1_0::FrontendIsdbsModulation; |
| using ::android::hardware::tv::tuner::V1_0::FrontendIsdbsRolloff; |
| using ::android::hardware::tv::tuner::V1_0::FrontendIsdbs3Modulation; |
| using ::android::hardware::tv::tuner::V1_0::FrontendIsdbs3Rolloff; |
| using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtBandwidth; |
| using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtGuardInterval; |
| using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtMode; |
| using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtModulation; |
| using ::android::hardware::tv::tuner::V1_0::FrontendModulationStatus; |
| using ::android::hardware::tv::tuner::V1_0::FrontendScanAtsc3PlpInfo; |
| using ::android::hardware::tv::tuner::V1_0::FrontendStatusAtsc3PlpInfo; |
| using ::android::hardware::tv::tuner::V1_0::LnbVoltage; |
| using ::android::hardware::tv::tuner::V1_1::Constant; |
| using ::android::hardware::tv::tuner::V1_1::FrontendBandwidth; |
| using ::android::hardware::tv::tuner::V1_1::FrontendCableTimeInterleaveMode; |
| using ::android::hardware::tv::tuner::V1_1::FrontendDtmbBandwidth; |
| using ::android::hardware::tv::tuner::V1_1::FrontendDtmbGuardInterval; |
| using ::android::hardware::tv::tuner::V1_1::FrontendDtmbModulation; |
| using ::android::hardware::tv::tuner::V1_1::FrontendDtmbTimeInterleaveMode; |
| using ::android::hardware::tv::tuner::V1_1::FrontendDtmbTransmissionMode; |
| using ::android::hardware::tv::tuner::V1_1::FrontendDvbcBandwidth; |
| using ::android::hardware::tv::tuner::V1_1::FrontendDvbtConstellation; |
| using ::android::hardware::tv::tuner::V1_1::FrontendDvbtTransmissionMode; |
| using ::android::hardware::tv::tuner::V1_1::FrontendGuardInterval; |
| using ::android::hardware::tv::tuner::V1_1::FrontendInterleaveMode; |
| using ::android::hardware::tv::tuner::V1_1::FrontendModulation; |
| using ::android::hardware::tv::tuner::V1_1::FrontendRollOff; |
| using ::android::hardware::tv::tuner::V1_1::FrontendSpectralInversion; |
| using ::android::hardware::tv::tuner::V1_1::FrontendTransmissionMode; |
| using ::android::hardware::tv::tuner::V1_1::FrontendType; |
| |
| namespace android { |
| |
| /////////////// FrontendClient /////////////////////// |
| |
| FrontendClient::FrontendClient(shared_ptr<ITunerFrontend> tunerFrontend, int type) { |
| mTunerFrontend = tunerFrontend; |
| mType = type; |
| } |
| |
| FrontendClient::~FrontendClient() { |
| mTunerFrontend = NULL; |
| mFrontend = NULL; |
| mFrontend_1_1 = NULL; |
| mId = -1; |
| mType = -1; |
| } |
| |
| Result FrontendClient::setCallback(sp<FrontendClientCallback> frontendClientCallback) { |
| if (mTunerFrontend != NULL) { |
| shared_ptr<TunerFrontendCallback> aidlCallback = |
| ::ndk::SharedRefBase::make<TunerFrontendCallback>(frontendClientCallback); |
| aidlCallback->setFrontendType(mType); |
| Status s = mTunerFrontend->setCallback(aidlCallback); |
| return ClientHelper::getServiceSpecificErrorCode(s); |
| } |
| |
| sp<HidlFrontendCallback> hidlCallback = new HidlFrontendCallback(frontendClientCallback); |
| return mFrontend->setCallback(hidlCallback); |
| } |
| |
| void FrontendClient::setHidlFrontend(sp<IFrontend> frontend) { |
| mFrontend = frontend; |
| mFrontend_1_1 = ::android::hardware::tv::tuner::V1_1::IFrontend::castFrom(mFrontend); |
| } |
| |
| // TODO: move after migration is done |
| void FrontendClient::setId(int id) { |
| mId = id; |
| } |
| |
| Result FrontendClient::tune(const FrontendSettings& settings, |
| const FrontendSettingsExt1_1& settingsExt1_1) { |
| if (mTunerFrontend != NULL) { |
| TunerFrontendSettings tunerFeSettings = getAidlFrontendSettings(settings, settingsExt1_1); |
| Status s = mTunerFrontend->tune(tunerFeSettings); |
| return ClientHelper::getServiceSpecificErrorCode(s); |
| } |
| |
| Result result; |
| if (mFrontend_1_1 != NULL && validateExtendedSettings(settingsExt1_1)) { |
| result = mFrontend_1_1->tune_1_1(settings, settingsExt1_1); |
| return result; |
| } |
| |
| if (mFrontend != NULL) { |
| result = mFrontend->tune(settings); |
| return result; |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| Result FrontendClient::stopTune() { |
| if (mTunerFrontend != NULL) { |
| Status s = mTunerFrontend->stopTune(); |
| return ClientHelper::getServiceSpecificErrorCode(s); |
| } |
| |
| if (mFrontend != NULL) { |
| Result result = mFrontend->stopTune(); |
| return result; |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| Result FrontendClient::scan(const FrontendSettings& settings, FrontendScanType type, |
| const FrontendSettingsExt1_1& settingsExt1_1) { |
| if (mTunerFrontend != NULL) { |
| TunerFrontendSettings tunerFeSettings = getAidlFrontendSettings(settings, settingsExt1_1); |
| Status s = mTunerFrontend->scan(tunerFeSettings, (int)type); |
| return ClientHelper::getServiceSpecificErrorCode(s); |
| } |
| |
| Result result; |
| if (mFrontend_1_1 != NULL && validateExtendedSettings(settingsExt1_1)) { |
| result = mFrontend_1_1->scan_1_1(settings, type, settingsExt1_1); |
| return result; |
| } |
| |
| if (mFrontend != NULL) { |
| result = mFrontend->scan(settings, type); |
| return result; |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| Result FrontendClient::stopScan() { |
| if (mTunerFrontend != NULL) { |
| Status s = mTunerFrontend->stopScan(); |
| return ClientHelper::getServiceSpecificErrorCode(s); |
| } |
| |
| if (mFrontend != NULL) { |
| Result result = mFrontend->stopScan(); |
| return result; |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| vector<FrontendStatus> FrontendClient::getStatus(vector<FrontendStatusType> statusTypes) { |
| vector<FrontendStatus> status; |
| |
| if (mTunerFrontend != NULL) { |
| vector<TunerFrontendStatus> aidlStatus; |
| vector<int> types; |
| for (auto t : statusTypes) { |
| types.push_back((int)t); |
| } |
| Status s = mTunerFrontend->getStatus(types, &aidlStatus); |
| if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) { |
| return status; |
| } |
| return getHidlStatus(aidlStatus); |
| } |
| |
| if (mFrontend != NULL && statusTypes.size() > 0) { |
| Result res; |
| mFrontend->getStatus(statusTypes, |
| [&](Result r, const hidl_vec<FrontendStatus>& s) { |
| res = r; |
| status = s; |
| }); |
| if (res != Result::SUCCESS) { |
| status.clear(); |
| return status; |
| } |
| } |
| |
| return status; |
| } |
| |
| vector<FrontendStatusExt1_1> FrontendClient::getStatusExtended_1_1( |
| vector<FrontendStatusTypeExt1_1> statusTypes) { |
| vector<FrontendStatusExt1_1> status; |
| |
| if (mTunerFrontend != NULL) { |
| vector<TunerFrontendStatus> aidlStatus; |
| vector<int> types; |
| for (auto t : statusTypes) { |
| types.push_back((int)t); |
| } |
| Status s = mTunerFrontend->getStatusExtended_1_1(types, &aidlStatus); |
| if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) { |
| return status; |
| } |
| return getHidlStatusExt(aidlStatus); |
| } |
| |
| if (mFrontend_1_1 != NULL && statusTypes.size() > 0) { |
| Result res; |
| mFrontend_1_1->getStatusExt1_1(statusTypes, |
| [&](Result r, const hidl_vec<FrontendStatusExt1_1>& s) { |
| res = r; |
| status = s; |
| }); |
| if (res != Result::SUCCESS) { |
| status.clear(); |
| return status; |
| } |
| } |
| |
| return status; |
| } |
| |
| Result FrontendClient::setLnb(sp<LnbClient> lnbClient) { |
| if (mTunerFrontend != NULL) { |
| Status s = mTunerFrontend->setLnb(lnbClient->getAidlLnb()); |
| return ClientHelper::getServiceSpecificErrorCode(s); |
| } |
| |
| if (mFrontend != NULL) { |
| Result result = mFrontend->setLnb(lnbClient->getId()); |
| return result; |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| Result FrontendClient::setLna(bool bEnable) { |
| if (mTunerFrontend != NULL) { |
| Status s = mTunerFrontend->setLna(bEnable); |
| return ClientHelper::getServiceSpecificErrorCode(s); |
| } |
| |
| if (mFrontend != NULL) { |
| Result result = mFrontend->setLna(bEnable); |
| return result; |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| int FrontendClient::linkCiCamToFrontend(int ciCamId) { |
| int ltsId = (int)Constant::INVALID_LTS_ID; |
| |
| if (mTunerFrontend != NULL) { |
| Status s = mTunerFrontend->linkCiCamToFrontend(ciCamId, <sId); |
| if (ClientHelper::getServiceSpecificErrorCode(s) == Result::SUCCESS) { |
| return ltsId; |
| } |
| return (int)Constant::INVALID_LTS_ID; |
| } |
| |
| if (mFrontend_1_1 != NULL) { |
| Result res; |
| mFrontend_1_1->linkCiCam(static_cast<uint32_t>(ciCamId), |
| [&](Result r, uint32_t id) { |
| res = r; |
| ltsId = id; |
| }); |
| if (res != Result::SUCCESS) { |
| return (int)Constant::INVALID_LTS_ID; |
| } |
| } |
| |
| return ltsId; |
| } |
| |
| Result FrontendClient::unlinkCiCamToFrontend(int ciCamId) { |
| if (mTunerFrontend != NULL) { |
| Status s = mTunerFrontend->unlinkCiCamToFrontend(ciCamId); |
| return ClientHelper::getServiceSpecificErrorCode(s); |
| } |
| |
| if (mFrontend_1_1 != NULL) { |
| return mFrontend_1_1->unlinkCiCam(static_cast<uint32_t>(ciCamId)); |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| Result FrontendClient::close() { |
| if (mTunerFrontend != NULL) { |
| Status s = mTunerFrontend->close(); |
| mTunerFrontend = NULL; |
| return ClientHelper::getServiceSpecificErrorCode(s); |
| } |
| |
| if (mFrontend != NULL) { |
| Result result = mFrontend->close(); |
| mFrontend = NULL; |
| mFrontend_1_1 = NULL; |
| return result; |
| } |
| |
| return Result::INVALID_STATE; |
| } |
| |
| /////////////// TunerFrontend Helper Methods /////////////////////// |
| |
| shared_ptr<ITunerFrontend> FrontendClient::getAidlFrontend() { |
| return mTunerFrontend; |
| } |
| |
| int FrontendClient::getId() { |
| if (mTunerFrontend != NULL) { |
| Status s = mTunerFrontend->getFrontendId(&mId); |
| if (ClientHelper::getServiceSpecificErrorCode(s) == Result::SUCCESS) { |
| return mId; |
| } |
| ALOGE("Failed to getFrontendId from Tuner Frontend"); |
| return -1; |
| } |
| |
| if (mFrontend != NULL) { |
| return mId; |
| } |
| |
| return -1; |
| } |
| |
| vector<FrontendStatus> FrontendClient::getHidlStatus(vector<TunerFrontendStatus>& aidlStatus) { |
| vector<FrontendStatus> hidlStatus; |
| for (TunerFrontendStatus s : aidlStatus) { |
| FrontendStatus status = FrontendStatus(); |
| switch (s.getTag()) { |
| case TunerFrontendStatus::isDemodLocked: { |
| status.isDemodLocked(s.get<TunerFrontendStatus::isDemodLocked>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::snr: { |
| status.snr(s.get<TunerFrontendStatus::snr>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::ber: { |
| status.ber((uint32_t)s.get<TunerFrontendStatus::ber>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::per: { |
| status.per((uint32_t)s.get<TunerFrontendStatus::per>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::preBer: { |
| status.preBer((uint32_t)s.get<TunerFrontendStatus::preBer>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::signalQuality: { |
| status.signalQuality((uint32_t)s.get<TunerFrontendStatus::signalQuality>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::signalStrength: { |
| status.signalStrength(s.get<TunerFrontendStatus::signalStrength>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::symbolRate: { |
| status.symbolRate((uint32_t)s.get<TunerFrontendStatus::symbolRate>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::innerFec: { |
| status.innerFec(static_cast<FrontendInnerFec>( |
| s.get<TunerFrontendStatus::innerFec>())); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::modulation: { |
| auto aidlMod = s.get<TunerFrontendStatus::modulation>(); |
| FrontendModulationStatus modulation; |
| switch (mType) { |
| case (int)FrontendType::DVBC: |
| modulation.dvbc(static_cast<FrontendDvbcModulation>(aidlMod)); |
| status.modulation(modulation); |
| hidlStatus.push_back(status); |
| break; |
| case (int)FrontendType::DVBS: |
| modulation.dvbs(static_cast<FrontendDvbsModulation>(aidlMod)); |
| status.modulation(modulation); |
| hidlStatus.push_back(status); |
| break; |
| case (int)FrontendType::ISDBS: |
| modulation.isdbs(static_cast<FrontendIsdbsModulation>(aidlMod)); |
| status.modulation(modulation); |
| hidlStatus.push_back(status); |
| break; |
| case (int)FrontendType::ISDBS3: |
| modulation.isdbs3(static_cast<FrontendIsdbs3Modulation>(aidlMod)); |
| status.modulation(modulation); |
| hidlStatus.push_back(status); |
| break; |
| case (int)FrontendType::ISDBT: |
| modulation.isdbt(static_cast<FrontendIsdbtModulation>(aidlMod)); |
| status.modulation(modulation); |
| hidlStatus.push_back(status); |
| break; |
| default: |
| break; |
| } |
| break; |
| } |
| case TunerFrontendStatus::inversion: { |
| status.inversion(static_cast<FrontendDvbcSpectralInversion>( |
| s.get<TunerFrontendStatus::inversion>())); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::lnbVoltage: { |
| status.lnbVoltage(static_cast<LnbVoltage>( |
| s.get<TunerFrontendStatus::lnbVoltage>())); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::plpId: { |
| status.plpId((uint8_t)s.get<TunerFrontendStatus::plpId>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::isEWBS: { |
| status.isEWBS(s.get<TunerFrontendStatus::isEWBS>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::agc: { |
| status.agc((uint8_t)s.get<TunerFrontendStatus::agc>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::isLnaOn: { |
| status.isLnaOn(s.get<TunerFrontendStatus::isLnaOn>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::isLayerError: { |
| auto aidlE = s.get<TunerFrontendStatus::isLayerError>(); |
| hidl_vec<bool> e(aidlE.begin(), aidlE.end()); |
| status.isLayerError(e); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::mer: { |
| status.mer(s.get<TunerFrontendStatus::mer>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::freqOffset: { |
| status.freqOffset(s.get<TunerFrontendStatus::freqOffset>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::hierarchy: { |
| status.hierarchy(static_cast<FrontendDvbtHierarchy>( |
| s.get<TunerFrontendStatus::hierarchy>())); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::isRfLocked: { |
| status.isRfLocked(s.get<TunerFrontendStatus::isRfLocked>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::plpInfo: { |
| int size = s.get<TunerFrontendStatus::plpInfo>().size(); |
| hidl_vec<FrontendStatusAtsc3PlpInfo> info(size); |
| for (int i = 0; i < size; i++) { |
| auto aidlInfo = s.get<TunerFrontendStatus::plpInfo>()[i]; |
| info[i] = { |
| .plpId = (uint8_t)aidlInfo.plpId, |
| .isLocked = aidlInfo.isLocked, |
| .uec = (uint32_t)aidlInfo.uec, |
| }; |
| } |
| status.plpInfo(info); |
| hidlStatus.push_back(status); |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| return hidlStatus; |
| } |
| |
| vector<FrontendStatusExt1_1> FrontendClient::getHidlStatusExt( |
| vector<TunerFrontendStatus>& aidlStatus) { |
| vector<FrontendStatusExt1_1> hidlStatus; |
| for (TunerFrontendStatus s : aidlStatus) { |
| FrontendStatusExt1_1 status; |
| switch (s.getTag()) { |
| case TunerFrontendStatus::modulations: { |
| vector<FrontendModulation> ms; |
| for (auto aidlMod : s.get<TunerFrontendStatus::modulations>()) { |
| FrontendModulation m; |
| switch (mType) { |
| case (int)FrontendType::DVBC: |
| m.dvbc(static_cast<FrontendDvbcModulation>(aidlMod)); |
| ms.push_back(m); |
| break; |
| case (int)FrontendType::DVBS: |
| m.dvbs(static_cast<FrontendDvbsModulation>(aidlMod)); |
| ms.push_back(m); |
| break; |
| case (int)FrontendType::DVBT: |
| m.dvbt(static_cast<FrontendDvbtConstellation>(aidlMod)); |
| ms.push_back(m); |
| break; |
| case (int)FrontendType::ISDBS: |
| m.isdbs(static_cast<FrontendIsdbsModulation>(aidlMod)); |
| ms.push_back(m); |
| break; |
| case (int)FrontendType::ISDBS3: |
| m.isdbs3(static_cast<FrontendIsdbs3Modulation>(aidlMod)); |
| ms.push_back(m); |
| break; |
| case (int)FrontendType::ISDBT: |
| m.isdbt(static_cast<FrontendIsdbtModulation>(aidlMod)); |
| ms.push_back(m); |
| break; |
| case (int)FrontendType::ATSC: |
| m.atsc(static_cast<FrontendAtscModulation>(aidlMod)); |
| ms.push_back(m); |
| break; |
| case (int)FrontendType::ATSC3: |
| m.atsc3(static_cast<FrontendAtsc3Modulation>(aidlMod)); |
| ms.push_back(m); |
| break; |
| case (int)FrontendType::DTMB: |
| m.dtmb(static_cast<FrontendDtmbModulation>(aidlMod)); |
| ms.push_back(m); |
| break; |
| default: |
| break; |
| } |
| } |
| if (ms.size() > 0) { |
| status.modulations(ms); |
| hidlStatus.push_back(status); |
| } |
| break; |
| } |
| case TunerFrontendStatus::bers: { |
| auto aidlB = s.get<TunerFrontendStatus::bers>(); |
| hidl_vec<uint32_t> b(aidlB.begin(), aidlB.end()); |
| status.bers(b); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::codeRates: { |
| vector<hardware::tv::tuner::V1_1::FrontendInnerFec> codeRates; |
| for (auto aidlCodeRate : s.get<TunerFrontendStatus::codeRates>()) { |
| codeRates.push_back( |
| static_cast<hardware::tv::tuner::V1_1::FrontendInnerFec>(aidlCodeRate)); |
| } |
| if (codeRates.size() > 0) { |
| status.codeRates(codeRates); |
| hidlStatus.push_back(status); |
| } |
| break; |
| } |
| case TunerFrontendStatus::bandwidth: { |
| auto aidlBand = s.get<TunerFrontendStatus::bandwidth>(); |
| FrontendBandwidth band; |
| switch (mType) { |
| case (int)FrontendType::ATSC3: |
| band.atsc3(static_cast<FrontendAtsc3Bandwidth>(aidlBand)); |
| status.bandwidth(band); |
| hidlStatus.push_back(status); |
| break; |
| case (int)FrontendType::DVBC: |
| band.dvbc(static_cast<FrontendDvbcBandwidth>(aidlBand)); |
| status.bandwidth(band); |
| hidlStatus.push_back(status); |
| break; |
| case (int)FrontendType::DVBT: |
| band.dvbt(static_cast<FrontendDvbtBandwidth>(aidlBand)); |
| status.bandwidth(band); |
| hidlStatus.push_back(status); |
| break; |
| case (int)FrontendType::ISDBT: |
| band.isdbt(static_cast<FrontendIsdbtBandwidth>(aidlBand)); |
| status.bandwidth(band); |
| hidlStatus.push_back(status); |
| break; |
| case (int)FrontendType::DTMB: |
| band.dtmb(static_cast<FrontendDtmbBandwidth>(aidlBand)); |
| status.bandwidth(band); |
| hidlStatus.push_back(status); |
| break; |
| default: |
| break; |
| } |
| break; |
| } |
| case TunerFrontendStatus::interval: { |
| auto aidlInter = s.get<TunerFrontendStatus::interval>(); |
| FrontendGuardInterval inter; |
| switch (mType) { |
| case (int)FrontendType::DVBT: |
| inter.dvbt(static_cast<FrontendDvbtGuardInterval>(aidlInter)); |
| status.interval(inter); |
| hidlStatus.push_back(status); |
| break; |
| case (int)FrontendType::ISDBT: |
| inter.isdbt(static_cast<FrontendIsdbtGuardInterval>(aidlInter)); |
| status.interval(inter); |
| hidlStatus.push_back(status); |
| break; |
| case (int)FrontendType::DTMB: |
| inter.dtmb(static_cast<FrontendDtmbGuardInterval>(aidlInter)); |
| status.interval(inter); |
| hidlStatus.push_back(status); |
| break; |
| default: |
| break; |
| } |
| break; |
| } |
| case TunerFrontendStatus::transmissionMode: { |
| auto aidlTran = s.get<TunerFrontendStatus::transmissionMode>(); |
| FrontendTransmissionMode trans; |
| switch (mType) { |
| case (int)FrontendType::DVBT: |
| trans.dvbt(static_cast<FrontendDvbtTransmissionMode>(aidlTran)); |
| status.transmissionMode(trans); |
| hidlStatus.push_back(status); |
| break; |
| case (int)FrontendType::ISDBT: |
| trans.isdbt(static_cast<FrontendIsdbtMode>(aidlTran)); |
| status.transmissionMode(trans); |
| hidlStatus.push_back(status); |
| break; |
| case (int)FrontendType::DTMB: |
| trans.dtmb(static_cast<FrontendDtmbTransmissionMode>(aidlTran)); |
| status.transmissionMode(trans); |
| hidlStatus.push_back(status); |
| break; |
| default: |
| break; |
| } |
| break; |
| } |
| case TunerFrontendStatus::uec: { |
| status.uec((uint32_t)s.get<TunerFrontendStatus::uec>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::systemId: { |
| status.systemId((uint16_t)s.get<TunerFrontendStatus::systemId>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::interleaving: { |
| vector<FrontendInterleaveMode> modes; |
| for (auto aidlInter : s.get<TunerFrontendStatus::interleaving>()) { |
| FrontendInterleaveMode mode; |
| switch (mType) { |
| case (int)FrontendType::DVBC: |
| mode.dvbc(static_cast<FrontendCableTimeInterleaveMode>(aidlInter)); |
| modes.push_back(mode); |
| break; |
| case (int)FrontendType::ATSC3: |
| mode.atsc3(static_cast<FrontendAtsc3TimeInterleaveMode>(aidlInter)); |
| modes.push_back(mode); |
| break; |
| case (int)FrontendType::DTMB: |
| mode.dtmb(static_cast<FrontendDtmbTimeInterleaveMode>(aidlInter)); |
| modes.push_back(mode); |
| break; |
| default: |
| break; |
| } |
| } |
| if (modes.size() > 0) { |
| status.interleaving(modes); |
| hidlStatus.push_back(status); |
| } |
| break; |
| } |
| case TunerFrontendStatus::isdbtSegment: { |
| auto aidlSeg = s.get<TunerFrontendStatus::isdbtSegment>(); |
| hidl_vec<uint8_t> s(aidlSeg.begin(), aidlSeg.end()); |
| status.isdbtSegment(s); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::tsDataRate: { |
| auto aidlTs = s.get<TunerFrontendStatus::tsDataRate>(); |
| hidl_vec<uint32_t> ts(aidlTs.begin(), aidlTs.end()); |
| status.tsDataRate(ts); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::rollOff: { |
| auto aidlRoll = s.get<TunerFrontendStatus::rollOff>(); |
| FrontendRollOff roll; |
| switch (mType) { |
| case (int)FrontendType::DVBS: |
| roll.dvbs(static_cast<FrontendDvbsRolloff>(aidlRoll)); |
| status.rollOff(roll); |
| hidlStatus.push_back(status); |
| break; |
| case (int)FrontendType::ISDBS: |
| roll.isdbs(static_cast<FrontendIsdbsRolloff>(aidlRoll)); |
| status.rollOff(roll); |
| hidlStatus.push_back(status); |
| break; |
| case (int)FrontendType::ISDBS3: |
| roll.isdbs3(static_cast<FrontendIsdbs3Rolloff>(aidlRoll)); |
| status.rollOff(roll); |
| hidlStatus.push_back(status); |
| break; |
| default: |
| break; |
| } |
| break; |
| } |
| case TunerFrontendStatus::isMiso: { |
| status.isMiso(s.get<TunerFrontendStatus::isMiso>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::isLinear: { |
| status.isLinear(s.get<TunerFrontendStatus::isLinear>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| case TunerFrontendStatus::isShortFrames: { |
| status.isShortFrames(s.get<TunerFrontendStatus::isShortFrames>()); |
| hidlStatus.push_back(status); |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| return hidlStatus; |
| } |
| |
| TunerFrontendSettings FrontendClient::getAidlFrontendSettings(const FrontendSettings& settings, |
| const FrontendSettingsExt1_1& settingsExt1_1) { |
| bool isExtended = validateExtendedSettings(settingsExt1_1); |
| TunerFrontendSettings s{ |
| .isExtended = isExtended, |
| .endFrequency = (int) settingsExt1_1.endFrequency, |
| .inversion = (int) settingsExt1_1.inversion, |
| }; |
| |
| if (settingsExt1_1.settingExt.getDiscriminator() |
| == FrontendSettingsExt1_1::SettingsExt::hidl_discriminator::dtmb) { |
| s.settings.set<TunerFrontendUnionSettings::dtmb>(getAidlDtmbSettings(settingsExt1_1)); |
| return s; |
| } |
| |
| switch (settings.getDiscriminator()) { |
| case FrontendSettings::hidl_discriminator::analog: { |
| s.settings.set<TunerFrontendUnionSettings::analog>( |
| getAidlAnalogSettings(settings, settingsExt1_1)); |
| break; |
| } |
| case FrontendSettings::hidl_discriminator::atsc: { |
| s.settings.set<TunerFrontendUnionSettings::atsc>(getAidlAtscSettings(settings)); |
| break; |
| } |
| case FrontendSettings::hidl_discriminator::atsc3: { |
| s.settings.set<TunerFrontendUnionSettings::atsc3>(getAidlAtsc3Settings(settings)); |
| break; |
| } |
| case FrontendSettings::hidl_discriminator::dvbs: { |
| s.settings.set<TunerFrontendUnionSettings::dvbs>( |
| getAidlDvbsSettings(settings, settingsExt1_1)); |
| break; |
| } |
| case FrontendSettings::hidl_discriminator::dvbc: { |
| s.settings.set<TunerFrontendUnionSettings::cable>( |
| getAidlCableSettings(settings, settingsExt1_1)); |
| break; |
| } |
| case FrontendSettings::hidl_discriminator::dvbt: { |
| s.settings.set<TunerFrontendUnionSettings::dvbt>( |
| getAidlDvbtSettings(settings, settingsExt1_1)); |
| break; |
| } |
| case FrontendSettings::hidl_discriminator::isdbs: { |
| s.settings.set<TunerFrontendUnionSettings::isdbs>(getAidlIsdbsSettings(settings)); |
| break; |
| } |
| case FrontendSettings::hidl_discriminator::isdbs3: { |
| s.settings.set<TunerFrontendUnionSettings::isdbs3>(getAidlIsdbs3Settings(settings)); |
| break; |
| } |
| case FrontendSettings::hidl_discriminator::isdbt: { |
| s.settings.set<TunerFrontendUnionSettings::isdbt>(getAidlIsdbtSettings(settings)); |
| break; |
| } |
| default: |
| break; |
| } |
| return s; |
| } |
| |
| TunerFrontendAnalogSettings FrontendClient::getAidlAnalogSettings(const FrontendSettings& settings, |
| const FrontendSettingsExt1_1& settingsExt1_1) { |
| TunerFrontendAnalogSettings analogSettings{ |
| .frequency = (int)settings.analog().frequency, |
| .signalType = (int)settings.analog().type, |
| .sifStandard = (int)settings.analog().sifStandard, |
| }; |
| if (settingsExt1_1.settingExt.getDiscriminator() |
| == FrontendSettingsExt1_1::SettingsExt::hidl_discriminator::analog) { |
| analogSettings.isExtended = true; |
| analogSettings.aftFlag = (int)settingsExt1_1.settingExt.analog().aftFlag; |
| } else { |
| analogSettings.isExtended = false; |
| } |
| return analogSettings; |
| } |
| |
| TunerFrontendDvbsSettings FrontendClient::getAidlDvbsSettings(const FrontendSettings& settings, |
| const FrontendSettingsExt1_1& settingsExt1_1) { |
| TunerFrontendDvbsSettings dvbsSettings{ |
| .frequency = (int)settings.dvbs().frequency, |
| .modulation = (int)settings.dvbs().modulation, |
| .codeRate = { |
| .fec = (long)settings.dvbs().coderate.fec, |
| .isLinear = settings.dvbs().coderate.isLinear, |
| .isShortFrames = settings.dvbs().coderate.isShortFrames, |
| .bitsPer1000Symbol = (int)settings.dvbs().coderate.bitsPer1000Symbol, |
| }, |
| .symbolRate = (int)settings.dvbs().symbolRate, |
| .rolloff = (int)settings.dvbs().rolloff, |
| .pilot = (int)settings.dvbs().pilot, |
| .inputStreamId = (int)settings.dvbs().inputStreamId, |
| .standard = (int)settings.dvbs().standard, |
| .vcm = (int)settings.dvbs().vcmMode, |
| }; |
| if (settingsExt1_1.settingExt.getDiscriminator() |
| == FrontendSettingsExt1_1::SettingsExt::hidl_discriminator::dvbs) { |
| dvbsSettings.isExtended = true; |
| dvbsSettings.scanType = (int)settingsExt1_1.settingExt.dvbs().scanType; |
| dvbsSettings.isDiseqcRxMessage = settingsExt1_1.settingExt.dvbs().isDiseqcRxMessage; |
| } else { |
| dvbsSettings.isExtended = false; |
| } |
| return dvbsSettings; |
| } |
| |
| TunerFrontendCableSettings FrontendClient::getAidlCableSettings(const FrontendSettings& settings, |
| const FrontendSettingsExt1_1& settingsExt1_1) { |
| TunerFrontendCableSettings cableSettings{ |
| .frequency = (int)settings.dvbc().frequency, |
| .modulation = (int)settings.dvbc().modulation, |
| .innerFec = (long)settings.dvbc().fec, |
| .symbolRate = (int)settings.dvbc().symbolRate, |
| .outerFec = (int)settings.dvbc().outerFec, |
| .annex = (int)settings.dvbc().annex, |
| .spectralInversion = (int)settings.dvbc().spectralInversion, |
| }; |
| if (settingsExt1_1.settingExt.getDiscriminator() |
| == FrontendSettingsExt1_1::SettingsExt::hidl_discriminator::dvbc) { |
| cableSettings.isExtended = true; |
| cableSettings.interleaveMode = (int)settingsExt1_1.settingExt.dvbc().interleaveMode; |
| cableSettings.bandwidth = (int)settingsExt1_1.settingExt.dvbc().bandwidth; |
| } else { |
| cableSettings.isExtended = false; |
| } |
| return cableSettings; |
| } |
| |
| TunerFrontendDvbtSettings FrontendClient::getAidlDvbtSettings(const FrontendSettings& settings, |
| const FrontendSettingsExt1_1& settingsExt1_1) { |
| TunerFrontendDvbtSettings dvbtSettings{ |
| .frequency = (int)settings.dvbt().frequency, |
| .transmissionMode = (int)settings.dvbt().transmissionMode, |
| .bandwidth = (int)settings.dvbt().bandwidth, |
| .constellation = (int)settings.dvbt().constellation, |
| .hierarchy = (int)settings.dvbt().hierarchy, |
| .hpCodeRate = (int)settings.dvbt().hpCoderate, |
| .lpCodeRate = (int)settings.dvbt().lpCoderate, |
| .guardInterval = (int)settings.dvbt().guardInterval, |
| .isHighPriority = settings.dvbt().isHighPriority, |
| .standard = (int)settings.dvbt().standard, |
| .isMiso = settings.dvbt().isMiso, |
| .plpMode = (int)settings.dvbt().plpMode, |
| .plpId = (int)settings.dvbt().plpId, |
| .plpGroupId = (int)settings.dvbt().plpGroupId, |
| }; |
| if (settingsExt1_1.settingExt.getDiscriminator() |
| == FrontendSettingsExt1_1::SettingsExt::hidl_discriminator::dvbt) { |
| dvbtSettings.isExtended = true; |
| dvbtSettings.constellation = (int)settingsExt1_1.settingExt.dvbt().constellation; |
| dvbtSettings.transmissionMode = |
| (int)settingsExt1_1.settingExt.dvbt().transmissionMode; |
| } else { |
| dvbtSettings.isExtended = false; |
| } |
| return dvbtSettings; |
| } |
| |
| TunerFrontendDtmbSettings FrontendClient::getAidlDtmbSettings( |
| const FrontendSettingsExt1_1& settingsExt1_1) { |
| TunerFrontendDtmbSettings dtmbSettings{ |
| .frequency = (int)settingsExt1_1.settingExt.dtmb().frequency, |
| .transmissionMode = (int)settingsExt1_1.settingExt.dtmb().transmissionMode, |
| .bandwidth = (int)settingsExt1_1.settingExt.dtmb().bandwidth, |
| .modulation = (int)settingsExt1_1.settingExt.dtmb().modulation, |
| .codeRate = (int)settingsExt1_1.settingExt.dtmb().codeRate, |
| .guardInterval = (int)settingsExt1_1.settingExt.dtmb().guardInterval, |
| .interleaveMode = (int)settingsExt1_1.settingExt.dtmb().interleaveMode, |
| }; |
| return dtmbSettings; |
| } |
| |
| TunerFrontendAtscSettings FrontendClient::getAidlAtscSettings(const FrontendSettings& settings) { |
| TunerFrontendAtscSettings atscSettings{ |
| .frequency = (int)settings.atsc().frequency, |
| .modulation = (int)settings.atsc().modulation, |
| }; |
| return atscSettings; |
| } |
| |
| TunerFrontendAtsc3Settings FrontendClient::getAidlAtsc3Settings(const FrontendSettings& settings) { |
| TunerFrontendAtsc3Settings atsc3Settings{ |
| .frequency = (int)settings.atsc3().frequency, |
| .bandwidth = (int)settings.atsc3().bandwidth, |
| .demodOutputFormat = (int)settings.atsc3().demodOutputFormat, |
| }; |
| atsc3Settings.plpSettings.resize(settings.atsc3().plpSettings.size()); |
| for (auto plpSetting : settings.atsc3().plpSettings) { |
| atsc3Settings.plpSettings.push_back({ |
| .plpId = (int)plpSetting.plpId, |
| .modulation = (int)plpSetting.modulation, |
| .interleaveMode = (int)plpSetting.interleaveMode, |
| .codeRate = (int)plpSetting.codeRate, |
| .fec = (int)plpSetting.fec, |
| }); |
| } |
| return atsc3Settings; |
| } |
| |
| TunerFrontendIsdbsSettings FrontendClient::getAidlIsdbsSettings(const FrontendSettings& settings) { |
| TunerFrontendIsdbsSettings isdbsSettings{ |
| .frequency = (int)settings.isdbs().frequency, |
| .streamId = (char16_t)settings.isdbs().streamId, |
| .streamIdType = (int)settings.isdbs().streamIdType, |
| .modulation = (int)settings.isdbs().modulation, |
| .codeRate = (int)settings.isdbs().coderate, |
| .symbolRate = (int)settings.isdbs().symbolRate, |
| .rolloff = (int)settings.isdbs().rolloff, |
| }; |
| return isdbsSettings; |
| } |
| |
| TunerFrontendIsdbs3Settings FrontendClient::getAidlIsdbs3Settings( |
| const FrontendSettings& settings) { |
| TunerFrontendIsdbs3Settings isdbs3Settings{ |
| .frequency = (int)settings.isdbs3().frequency, |
| .streamId = (char16_t)settings.isdbs3().streamId, |
| .streamIdType = (int)settings.isdbs3().streamIdType, |
| .modulation = (int)settings.isdbs3().modulation, |
| .codeRate = (int)settings.isdbs3().coderate, |
| .symbolRate = (int)settings.isdbs3().symbolRate, |
| .rolloff = (int)settings.isdbs3().rolloff, |
| }; |
| return isdbs3Settings; |
| } |
| |
| TunerFrontendIsdbtSettings FrontendClient::getAidlIsdbtSettings(const FrontendSettings& settings) { |
| TunerFrontendIsdbtSettings isdbtSettings{ |
| .frequency = (int)settings.isdbt().frequency, |
| .modulation = (int)settings.isdbt().modulation, |
| .bandwidth = (int)settings.isdbt().bandwidth, |
| .mode = (int)settings.isdbt().mode, |
| .codeRate = (int)settings.isdbt().coderate, |
| .guardInterval = (int)settings.isdbt().guardInterval, |
| .serviceAreaId = (int)settings.isdbt().serviceAreaId, |
| }; |
| return isdbtSettings; |
| } |
| |
| bool FrontendClient::validateExtendedSettings(const FrontendSettingsExt1_1& settingsExt1_1) { |
| return settingsExt1_1.endFrequency != (uint32_t)Constant::INVALID_FRONTEND_SETTING_FREQUENCY |
| || settingsExt1_1.inversion != FrontendSpectralInversion::UNDEFINED |
| || settingsExt1_1.settingExt.getDiscriminator() |
| != FrontendSettingsExt1_1::SettingsExt::hidl_discriminator::noinit; |
| } |
| |
| /////////////// TunerFrontendCallback /////////////////////// |
| |
| TunerFrontendCallback::TunerFrontendCallback(sp<FrontendClientCallback> frontendClientCallback) |
| : mFrontendClientCallback(frontendClientCallback) {} |
| |
| Status TunerFrontendCallback::onEvent(int frontendEventType) { |
| if (mFrontendClientCallback != NULL) { |
| mFrontendClientCallback->onEvent(static_cast<FrontendEventType>(frontendEventType)); |
| return Status::ok(); |
| } |
| return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE)); |
| } |
| |
| Status TunerFrontendCallback::onScanMessage(int messageType, |
| const TunerFrontendScanMessage& message) { |
| if (mFrontendClientCallback != NULL) { |
| if (!is1_1ExtendedScanMessage(messageType)) { |
| mFrontendClientCallback->onScanMessage( |
| static_cast<FrontendScanMessageType>(messageType), |
| getHalScanMessage(messageType, message)); |
| } else { |
| mFrontendClientCallback->onScanMessageExt1_1( |
| static_cast<FrontendScanMessageTypeExt1_1>(messageType), |
| getHalScanMessageExt1_1(messageType, message)); |
| } |
| return Status::ok(); |
| } |
| return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE)); |
| } |
| |
| /////////////// IFrontendCallback /////////////////////// |
| |
| HidlFrontendCallback::HidlFrontendCallback(sp<FrontendClientCallback> frontendClientCallback) |
| : mFrontendClientCallback(frontendClientCallback) {} |
| |
| Return<void> HidlFrontendCallback::onEvent(FrontendEventType frontendEventType) { |
| if (mFrontendClientCallback != NULL) { |
| mFrontendClientCallback->onEvent(frontendEventType); |
| } |
| return Void(); |
| } |
| |
| Return<void> HidlFrontendCallback::onScanMessage(FrontendScanMessageType type, |
| const FrontendScanMessage& message) { |
| if (mFrontendClientCallback != NULL) { |
| mFrontendClientCallback->onScanMessage(type, message); |
| } |
| return Void(); |
| } |
| |
| Return<void> HidlFrontendCallback::onScanMessageExt1_1(FrontendScanMessageTypeExt1_1 type, |
| const FrontendScanMessageExt1_1& message) { |
| if (mFrontendClientCallback != NULL) { |
| mFrontendClientCallback->onScanMessageExt1_1(type, message); |
| } |
| return Void(); |
| } |
| |
| /////////////// FrontendClientCallback Helper Methods /////////////////////// |
| |
| FrontendScanMessage TunerFrontendCallback::getHalScanMessage( |
| int messageType, const TunerFrontendScanMessage& message) { |
| FrontendScanMessage scanMessage; |
| switch (messageType) { |
| case (int) FrontendScanMessageType::LOCKED: |
| scanMessage.isLocked(message.get<TunerFrontendScanMessage::isLocked>()); |
| break; |
| case (int) FrontendScanMessageType::END: |
| scanMessage.isEnd(message.get<TunerFrontendScanMessage::isEnd>()); |
| break; |
| case (int) FrontendScanMessageType::PROGRESS_PERCENT: |
| scanMessage.progressPercent(message.get<TunerFrontendScanMessage::progressPercent>()); |
| break; |
| case (int) FrontendScanMessageType::FREQUENCY: { |
| vector<int> f = message.get<TunerFrontendScanMessage::frequencies>(); |
| hidl_vec<uint32_t> frequencies(begin(f), end(f)); |
| scanMessage.frequencies(frequencies); |
| break; |
| } |
| case (int) FrontendScanMessageType::SYMBOL_RATE: { |
| vector<int> s = message.get<TunerFrontendScanMessage::symbolRates>(); |
| hidl_vec<uint32_t> symbolRates(begin(s), end(s)); |
| scanMessage.symbolRates(symbolRates); |
| break; |
| } |
| case (int) FrontendScanMessageType::HIERARCHY: |
| scanMessage.hierarchy(static_cast<FrontendDvbtHierarchy>( |
| message.get<TunerFrontendScanMessage::hierarchy>())); |
| break; |
| case (int) FrontendScanMessageType::ANALOG_TYPE: |
| scanMessage.analogType(static_cast<FrontendAnalogType>( |
| message.get<TunerFrontendScanMessage::analogType>())); |
| break; |
| case (int) FrontendScanMessageType::PLP_IDS: { |
| vector<uint8_t> p = message.get<TunerFrontendScanMessage::plpIds>(); |
| hidl_vec<uint8_t> plpIds(begin(p), end(p)); |
| scanMessage.plpIds(plpIds); |
| break; |
| } |
| case (int) FrontendScanMessageType::GROUP_IDS: { |
| vector<uint8_t> g = message.get<TunerFrontendScanMessage::groupIds>(); |
| hidl_vec<uint8_t> groupIds(begin(g), end(g)); |
| scanMessage.groupIds(groupIds); |
| break; |
| } |
| case (int) FrontendScanMessageType::INPUT_STREAM_IDS: { |
| vector<char16_t> i = message.get<TunerFrontendScanMessage::inputStreamIds>(); |
| hidl_vec<uint16_t> inputStreamIds(begin(i), end(i)); |
| scanMessage.inputStreamIds(inputStreamIds); |
| break; |
| } |
| case (int) FrontendScanMessageType::STANDARD: { |
| FrontendScanMessage::Standard std; |
| int standard = message.get<TunerFrontendScanMessage::std>(); |
| switch (mType) { |
| case (int) FrontendType::DVBS: |
| std.sStd(static_cast<FrontendDvbsStandard>(standard)); |
| scanMessage.std(std); |
| break; |
| case (int) FrontendType::DVBT: |
| std.tStd(static_cast<FrontendDvbtStandard>(standard)); |
| scanMessage.std(std); |
| break; |
| case (int) FrontendType::ANALOG: |
| std.sifStd(static_cast<FrontendAnalogSifStandard>(standard)); |
| scanMessage.std(std); |
| break; |
| default: |
| break; |
| } |
| break; |
| } |
| case (int) FrontendScanMessageType::ATSC3_PLP_INFO: { |
| vector<TunerFrontendScanAtsc3PlpInfo> plp = |
| message.get<TunerFrontendScanMessage::atsc3PlpInfos>(); |
| hidl_vec<FrontendScanAtsc3PlpInfo> plpInfo; |
| int size = plp.size(); |
| plpInfo.resize(size); |
| for (int i = 0; i < size; i++) { |
| auto info = message.get<TunerFrontendScanMessage::atsc3PlpInfos>()[i]; |
| FrontendScanAtsc3PlpInfo p{ |
| .plpId = static_cast<uint8_t>(info.plpId), |
| .bLlsFlag = info.llsFlag, |
| }; |
| plpInfo[i] = p; |
| } |
| scanMessage.atsc3PlpInfos(plpInfo); |
| break; |
| } |
| default: |
| break; |
| } |
| return scanMessage; |
| } |
| |
| FrontendScanMessageExt1_1 TunerFrontendCallback::getHalScanMessageExt1_1( |
| int messageType, const TunerFrontendScanMessage& message) { |
| FrontendScanMessageExt1_1 scanMessage; |
| switch (messageType) { |
| case (int) FrontendScanMessageTypeExt1_1::HIGH_PRIORITY: |
| scanMessage.isHighPriority(message.get<TunerFrontendScanMessage::isHighPriority>()); |
| break; |
| case (int) FrontendScanMessageTypeExt1_1::DVBC_ANNEX: |
| scanMessage.annex(static_cast<FrontendDvbcAnnex>( |
| message.get<TunerFrontendScanMessage::annex>())); |
| break; |
| case (int) FrontendScanMessageTypeExt1_1::MODULATION: { |
| FrontendModulation m; |
| int modulation = message.get<TunerFrontendScanMessage::modulation>(); |
| switch (mType) { |
| case (int) FrontendType::DVBC: |
| m.dvbc(static_cast<FrontendDvbcModulation>(modulation)); |
| scanMessage.modulation(m); |
| break; |
| case (int) FrontendType::DVBS: |
| m.dvbs(static_cast<FrontendDvbsModulation>(modulation)); |
| scanMessage.modulation(m); |
| break; |
| case (int) FrontendType::DVBT: |
| m.dvbt(static_cast<FrontendDvbtConstellation>(modulation)); |
| scanMessage.modulation(m); |
| break; |
| case (int) FrontendType::ISDBS: |
| m.isdbs(static_cast<FrontendIsdbsModulation>(modulation)); |
| scanMessage.modulation(m); |
| break; |
| case (int) FrontendType::ISDBS3: |
| m.isdbs3(static_cast<FrontendIsdbs3Modulation>(modulation)); |
| scanMessage.modulation(m); |
| break; |
| case (int) FrontendType::ISDBT: |
| m.isdbt(static_cast<FrontendIsdbtModulation>(modulation)); |
| scanMessage.modulation(m); |
| break; |
| case (int) FrontendType::ATSC: |
| m.atsc(static_cast<FrontendAtscModulation>(modulation)); |
| scanMessage.modulation(m); |
| break; |
| case (int) FrontendType::ATSC3: |
| m.atsc3(static_cast<FrontendAtsc3Modulation>(modulation)); |
| scanMessage.modulation(m); |
| break; |
| case (int) hardware::tv::tuner::V1_1::FrontendType::DTMB: |
| m.dtmb(static_cast<FrontendDtmbModulation>(modulation)); |
| scanMessage.modulation(m); |
| break; |
| default: |
| break; |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| return scanMessage; |
| } |
| |
| bool TunerFrontendCallback::is1_1ExtendedScanMessage(int messageType) { |
| return messageType >= (int)FrontendScanMessageTypeExt1_1::MODULATION |
| && messageType <= (int)FrontendScanMessageTypeExt1_1::HIGH_PRIORITY; |
| } |
| } // namespace android |
