Migrate native tuner to new AIDL HAL.
After this change, tuner java and jni will not reply on HIDL anymore. It
also cleans up the the unused HIDL direct calls.
Bug: 191825295
Test: atest android.media.tv.tuner.cts
Change-Id: I0113565568119a79ed631b318cc8ccd32e0ae2ec
diff --git a/media/jni/tuner/TunerClient.cpp b/media/jni/tuner/TunerClient.cpp
index e05dba6..d19ee0d4 100644
--- a/media/jni/tuner/TunerClient.cpp
+++ b/media/jni/tuner/TunerClient.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright 2020 The Android Open Source Project
+ * Copyright 2021 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.
@@ -22,31 +22,20 @@
#include "TunerClient.h"
-using ::aidl::android::media::tv::tuner::TunerFrontendCapabilities;
-using ::aidl::android::media::tv::tuner::TunerFrontendDtmbCapabilities;
-using ::android::hardware::tv::tuner::V1_0::FrontendId;
-using ::android::hardware::tv::tuner::V1_0::FrontendStatusType;
-using ::android::hardware::tv::tuner::V1_0::FrontendType;
+using ::aidl::android::hardware::tv::tuner::FrontendStatusType;
+using ::aidl::android::hardware::tv::tuner::FrontendType;
namespace android {
-sp<ITuner> TunerClient::mTuner;
-sp<::android::hardware::tv::tuner::V1_1::ITuner> TunerClient::mTuner_1_1;
shared_ptr<ITunerService> TunerClient::mTunerService;
-int TunerClient::mTunerVersion;
+int32_t TunerClient::mTunerVersion;
/////////////// TunerClient ///////////////////////
TunerClient::TunerClient() {
- // Get HIDL Tuner in migration stage.
- getHidlTuner();
- if (mTuner != NULL) {
- updateTunerResources();
- }
- // Connect with Tuner Service.
::ndk::SpAIBinder binder(AServiceManager_getService("media.tuner"));
mTunerService = ITunerService::fromBinder(binder);
- if (mTunerService == NULL) {
+ if (mTunerService == nullptr) {
ALOGE("Failed to get tuner service");
} else {
mTunerService->getTunerHalVersion(&mTunerVersion);
@@ -54,575 +43,124 @@
}
TunerClient::~TunerClient() {
- mTuner = NULL;
- mTuner_1_1 = NULL;
mTunerVersion = 0;
- mTunerService = NULL;
+ mTunerService = nullptr;
}
-vector<FrontendId> TunerClient::getFrontendIds() {
- vector<FrontendId> ids;
+vector<int32_t> TunerClient::getFrontendIds() {
+ vector<int32_t> ids;
- if (mTunerService != NULL) {
- vector<int32_t> v;
- Status s = mTunerService->getFrontendIds(&v);
- if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS || v.size() == 0) {
+ if (mTunerService != nullptr) {
+ Status s = mTunerService->getFrontendIds(&ids);
+ if (!s.isOk()) {
ids.clear();
- return ids;
}
- for (int32_t id : v) {
- ids.push_back(static_cast<FrontendId>(id));
- }
- return ids;
- }
-
- if (mTuner != NULL) {
- Result res;
- mTuner->getFrontendIds([&](Result r, const hardware::hidl_vec<FrontendId>& frontendIds) {
- res = r;
- ids = frontendIds;
- });
- if (res != Result::SUCCESS || ids.size() == 0) {
- ALOGW("Frontend ids not available");
- ids.clear();
- return ids;
- }
- return ids;
}
return ids;
}
-
-sp<FrontendClient> TunerClient::openFrontend(int frontendHandle) {
- if (mTunerService != NULL) {
+sp<FrontendClient> TunerClient::openFrontend(int32_t frontendHandle) {
+ if (mTunerService != nullptr) {
shared_ptr<ITunerFrontend> tunerFrontend;
Status s = mTunerService->openFrontend(frontendHandle, &tunerFrontend);
- if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS
- || tunerFrontend == NULL) {
- return NULL;
+ if (!s.isOk() || tunerFrontend == nullptr) {
+ return nullptr;
}
- int id;
+ int32_t id;
s = tunerFrontend->getFrontendId(&id);
- if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
- return NULL;
+ if (!s.isOk()) {
+ tunerFrontend->close();
+ return nullptr;
}
- TunerFrontendInfo aidlFrontendInfo;
- s = mTunerService->getFrontendInfo(id, &aidlFrontendInfo);
- if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
- return NULL;
+ FrontendInfo frontendInfo;
+ s = mTunerService->getFrontendInfo(id, &frontendInfo);
+ if (!s.isOk()) {
+ tunerFrontend->close();
+ return nullptr;
}
- return new FrontendClient(tunerFrontend, aidlFrontendInfo.type);
+ return new FrontendClient(tunerFrontend, frontendInfo.type);
}
- if (mTuner != NULL) {
- int id = getResourceIdFromHandle(frontendHandle, FRONTEND);
- sp<IFrontend> hidlFrontend = openHidlFrontendById(id);
- if (hidlFrontend != NULL) {
- FrontendInfo hidlInfo;
- Result res = getHidlFrontendInfo(id, hidlInfo);
- if (res != Result::SUCCESS) {
- return NULL;
- }
- sp<FrontendClient> frontendClient = new FrontendClient(
- NULL, (int)hidlInfo.type);
- frontendClient->setHidlFrontend(hidlFrontend);
- frontendClient->setId(id);
- return frontendClient;
- }
- }
-
- return NULL;
+ return nullptr;
}
-shared_ptr<FrontendInfo> TunerClient::getFrontendInfo(int id) {
- if (mTunerService != NULL) {
- TunerFrontendInfo aidlFrontendInfo;
+shared_ptr<FrontendInfo> TunerClient::getFrontendInfo(int32_t id) {
+ if (mTunerService != nullptr) {
+ FrontendInfo aidlFrontendInfo;
Status s = mTunerService->getFrontendInfo(id, &aidlFrontendInfo);
- if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
- return NULL;
+ if (!s.isOk()) {
+ return nullptr;
}
- return make_shared<FrontendInfo>(frontendInfoAidlToHidl(aidlFrontendInfo));
+ return make_shared<FrontendInfo>(aidlFrontendInfo);
}
- if (mTuner != NULL) {
- FrontendInfo hidlInfo;
- Result res = getHidlFrontendInfo(id, hidlInfo);
- if (res != Result::SUCCESS) {
- return NULL;
- }
- return make_shared<FrontendInfo>(hidlInfo);
- }
-
- return NULL;
+ return nullptr;
}
-shared_ptr<FrontendDtmbCapabilities> TunerClient::getFrontendDtmbCapabilities(int id) {
- if (mTunerService != NULL) {
- TunerFrontendDtmbCapabilities dtmbCaps;
- Status s = mTunerService->getFrontendDtmbCapabilities(id, &dtmbCaps);
- if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
- return NULL;
- }
- FrontendDtmbCapabilities hidlCaps{
- .transmissionModeCap = static_cast<uint32_t>(dtmbCaps.transmissionModeCap),
- .bandwidthCap = static_cast<uint32_t>(dtmbCaps.bandwidthCap),
- .modulationCap = static_cast<uint32_t>(dtmbCaps.modulationCap),
- .codeRateCap = static_cast<uint32_t>(dtmbCaps.codeRateCap),
- .guardIntervalCap = static_cast<uint32_t>(dtmbCaps.guardIntervalCap),
- .interleaveModeCap = static_cast<uint32_t>(dtmbCaps.interleaveModeCap),
- };
- return make_shared<FrontendDtmbCapabilities>(hidlCaps);
- }
-
- if (mTuner_1_1 != NULL) {
- Result result;
- FrontendDtmbCapabilities dtmbCaps;
- mTuner_1_1->getFrontendDtmbCapabilities(id,
- [&](Result r, const FrontendDtmbCapabilities& caps) {
- dtmbCaps = caps;
- result = r;
- });
- if (result == Result::SUCCESS) {
- return make_shared<FrontendDtmbCapabilities>(dtmbCaps);
- }
- }
-
- return NULL;
-}
-
-sp<DemuxClient> TunerClient::openDemux(int demuxHandle) {
- if (mTunerService != NULL) {
+sp<DemuxClient> TunerClient::openDemux(int32_t demuxHandle) {
+ if (mTunerService != nullptr) {
shared_ptr<ITunerDemux> tunerDemux;
Status s = mTunerService->openDemux(demuxHandle, &tunerDemux);
- if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
- return NULL;
+ if (!s.isOk()) {
+ return nullptr;
}
return new DemuxClient(tunerDemux);
}
- if (mTuner != NULL) {
- sp<DemuxClient> demuxClient = new DemuxClient(NULL);
- int demuxId;
- sp<IDemux> hidlDemux = openHidlDemux(demuxId);
- if (hidlDemux != NULL) {
- demuxClient->setHidlDemux(hidlDemux);
- demuxClient->setId(demuxId);
- return demuxClient;
- }
- }
-
- return NULL;
+ return nullptr;
}
shared_ptr<DemuxCapabilities> TunerClient::getDemuxCaps() {
- if (mTunerService != NULL) {
- TunerDemuxCapabilities aidlCaps;
+ if (mTunerService != nullptr) {
+ DemuxCapabilities aidlCaps;
Status s = mTunerService->getDemuxCaps(&aidlCaps);
- if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
- return NULL;
+ if (!s.isOk()) {
+ return nullptr;
}
- return make_shared<DemuxCapabilities>(getHidlDemuxCaps(aidlCaps));
+ return make_shared<DemuxCapabilities>(aidlCaps);
}
- if (mTuner != NULL) {
- Result res;
- DemuxCapabilities caps;
- mTuner->getDemuxCaps([&](Result r, const DemuxCapabilities& demuxCaps) {
- caps = demuxCaps;
- res = r;
- });
- if (res == Result::SUCCESS) {
- return make_shared<DemuxCapabilities>(caps);
- }
- }
-
- return NULL;
+ return nullptr;
}
-sp<DescramblerClient> TunerClient::openDescrambler(int descramblerHandle) {
- if (mTunerService != NULL) {
+sp<DescramblerClient> TunerClient::openDescrambler(int32_t descramblerHandle) {
+ if (mTunerService != nullptr) {
shared_ptr<ITunerDescrambler> tunerDescrambler;
Status s = mTunerService->openDescrambler(descramblerHandle, &tunerDescrambler);
- if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
- return NULL;
+ if (!s.isOk()) {
+ return nullptr;
}
return new DescramblerClient(tunerDescrambler);
}
- if (mTuner != NULL) {
- sp<DescramblerClient> descramblerClient = new DescramblerClient(NULL);
- sp<IDescrambler> hidlDescrambler = openHidlDescrambler();
- if (hidlDescrambler != NULL) {
- descramblerClient->setHidlDescrambler(hidlDescrambler);
- return descramblerClient;
- }
- }
-
- return NULL;
+ return nullptr;
}
-sp<LnbClient> TunerClient::openLnb(int lnbHandle) {
- if (mTunerService != NULL) {
+sp<LnbClient> TunerClient::openLnb(int32_t lnbHandle) {
+ if (mTunerService != nullptr) {
shared_ptr<ITunerLnb> tunerLnb;
Status s = mTunerService->openLnb(lnbHandle, &tunerLnb);
- if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
- return NULL;
+ if (!s.isOk()) {
+ return nullptr;
}
return new LnbClient(tunerLnb);
}
- if (mTuner != NULL) {
- int id = getResourceIdFromHandle(lnbHandle, LNB);
- sp<LnbClient> lnbClient = new LnbClient(NULL);
- sp<ILnb> hidlLnb = openHidlLnbById(id);
- if (hidlLnb != NULL) {
- lnbClient->setHidlLnb(hidlLnb);
- lnbClient->setId(id);
- return lnbClient;
- }
- }
-
- return NULL;
+ return nullptr;
}
sp<LnbClient> TunerClient::openLnbByName(string lnbName) {
- if (mTunerService != NULL) {
+ if (mTunerService != nullptr) {
shared_ptr<ITunerLnb> tunerLnb;
Status s = mTunerService->openLnbByName(lnbName, &tunerLnb);
- if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
- return NULL;
+ if (!s.isOk()) {
+ return nullptr;
}
return new LnbClient(tunerLnb);
}
- if (mTuner != NULL) {
- sp<LnbClient> lnbClient = new LnbClient(NULL);
- LnbId id;
- sp<ILnb> hidlLnb = openHidlLnbByName(lnbName, id);
- if (hidlLnb != NULL) {
- lnbClient->setHidlLnb(hidlLnb);
- lnbClient->setId(id);
- return lnbClient;
- }
- }
-
- return NULL;
+ return nullptr;
}
-/////////////// TunerClient Helper Methods ///////////////////////
-
-void TunerClient::updateTunerResources() {
- if (mTuner == NULL) {
- return;
- }
-
- // Connect with Tuner Resource Manager.
- ::ndk::SpAIBinder binder(AServiceManager_getService("tv_tuner_resource_mgr"));
- mTunerResourceManager = ITunerResourceManager::fromBinder(binder);
-
- updateFrontendResources();
- updateLnbResources();
- // TODO: update Demux, Descrambler.
-}
-
-// TODO: remove after migration to Tuner Service is done.
-void TunerClient::updateFrontendResources() {
- vector<FrontendId> ids = getFrontendIds();
- if (ids.size() == 0) {
- return;
- }
- vector<TunerFrontendInfo> infos;
- for (int i = 0; i < ids.size(); i++) {
- shared_ptr<FrontendInfo> frontendInfo = getFrontendInfo((int)ids[i]);
- if (frontendInfo == NULL) {
- continue;
- }
- TunerFrontendInfo tunerFrontendInfo{
- .handle = getResourceHandleFromId((int)ids[i], FRONTEND),
- .type = static_cast<int>(frontendInfo->type),
- .exclusiveGroupId = static_cast<int>(frontendInfo->exclusiveGroupId),
- };
- infos.push_back(tunerFrontendInfo);
- }
- mTunerResourceManager->setFrontendInfoList(infos);
-}
-
-void TunerClient::updateLnbResources() {
- vector<int> handles = getLnbHandles();
- if (handles.size() == 0) {
- return;
- }
- mTunerResourceManager->setLnbInfoList(handles);
-}
-
-sp<ITuner> TunerClient::getHidlTuner() {
- if (mTuner == NULL) {
- mTunerVersion = TUNER_HAL_VERSION_UNKNOWN;
- mTuner_1_1 = ::android::hardware::tv::tuner::V1_1::ITuner::getService();
-
- if (mTuner_1_1 == NULL) {
- ALOGW("Failed to get tuner 1.1 service.");
- mTuner = ITuner::getService();
- if (mTuner == NULL) {
- ALOGW("Failed to get tuner 1.0 service.");
- } else {
- mTunerVersion = TUNER_HAL_VERSION_1_0;
- }
- } else {
- mTuner = static_cast<sp<ITuner>>(mTuner_1_1);
- mTunerVersion = TUNER_HAL_VERSION_1_1;
- }
- }
- return mTuner;
-}
-
-sp<IFrontend> TunerClient::openHidlFrontendById(int id) {
- sp<IFrontend> fe;
- Result res;
- mTuner->openFrontendById(id, [&](Result r, const sp<IFrontend>& frontend) {
- fe = frontend;
- res = r;
- });
- if (res != Result::SUCCESS || fe == nullptr) {
- ALOGE("Failed to open frontend");
- return NULL;
- }
- return fe;
-}
-
-Result TunerClient::getHidlFrontendInfo(int id, FrontendInfo& feInfo) {
- Result res;
- mTuner->getFrontendInfo(id, [&](Result r, const FrontendInfo& info) {
- feInfo = info;
- res = r;
- });
- return res;
-}
-
-sp<IDemux> TunerClient::openHidlDemux(int& demuxId) {
- sp<IDemux> demux;
- Result res;
-
- mTuner->openDemux([&](Result result, uint32_t id, const sp<IDemux>& demuxSp) {
- demux = demuxSp;
- demuxId = id;
- res = result;
- });
- if (res != Result::SUCCESS || demux == nullptr) {
- ALOGE("Failed to open demux");
- return NULL;
- }
- return demux;
-}
-
-sp<ILnb> TunerClient::openHidlLnbById(int id) {
- sp<ILnb> lnb;
- Result res;
-
- mTuner->openLnbById(id, [&](Result r, const sp<ILnb>& lnbSp) {
- res = r;
- lnb = lnbSp;
- });
- if (res != Result::SUCCESS || lnb == nullptr) {
- ALOGE("Failed to open lnb by id");
- return NULL;
- }
- return lnb;
-}
-
-sp<ILnb> TunerClient::openHidlLnbByName(string name, LnbId& lnbId) {
- sp<ILnb> lnb;
- Result res;
-
- mTuner->openLnbByName(name, [&](Result r, LnbId id, const sp<ILnb>& lnbSp) {
- res = r;
- lnb = lnbSp;
- lnbId = id;
- });
- if (res != Result::SUCCESS || lnb == nullptr) {
- ALOGE("Failed to open lnb by name");
- return NULL;
- }
- return lnb;
-}
-
-// TODO: remove after migration to Tuner Service is done.
-vector<int> TunerClient::getLnbHandles() {
- vector<int> lnbHandles;
- if (mTuner != NULL) {
- Result res;
- vector<LnbId> lnbIds;
- mTuner->getLnbIds([&](Result r, const hardware::hidl_vec<LnbId>& ids) {
- lnbIds = ids;
- res = r;
- });
- if (res != Result::SUCCESS || lnbIds.size() == 0) {
- ALOGW("Lnb isn't available");
- } else {
- for (int i = 0; i < lnbIds.size(); i++) {
- lnbHandles.push_back(getResourceHandleFromId((int)lnbIds[i], LNB));
- }
- }
- }
-
- return lnbHandles;
-}
-
-sp<IDescrambler> TunerClient::openHidlDescrambler() {
- sp<IDescrambler> descrambler;
- Result res;
-
- mTuner->openDescrambler([&](Result r, const sp<IDescrambler>& descramblerSp) {
- res = r;
- descrambler = descramblerSp;
- });
-
- if (res != Result::SUCCESS || descrambler == NULL) {
- return NULL;
- }
-
- return descrambler;
-}
-
-DemuxCapabilities TunerClient::getHidlDemuxCaps(TunerDemuxCapabilities& aidlCaps) {
- DemuxCapabilities caps{
- .numDemux = (uint32_t)aidlCaps.numDemux,
- .numRecord = (uint32_t)aidlCaps.numRecord,
- .numPlayback = (uint32_t)aidlCaps.numPlayback,
- .numTsFilter = (uint32_t)aidlCaps.numTsFilter,
- .numSectionFilter = (uint32_t)aidlCaps.numSectionFilter,
- .numAudioFilter = (uint32_t)aidlCaps.numAudioFilter,
- .numVideoFilter = (uint32_t)aidlCaps.numVideoFilter,
- .numPesFilter = (uint32_t)aidlCaps.numPesFilter,
- .numPcrFilter = (uint32_t)aidlCaps.numPcrFilter,
- .numBytesInSectionFilter = (uint32_t)aidlCaps.numBytesInSectionFilter,
- .filterCaps = (uint32_t)aidlCaps.filterCaps,
- .bTimeFilter = aidlCaps.bTimeFilter,
- };
- caps.linkCaps.resize(aidlCaps.linkCaps.size());
- copy(aidlCaps.linkCaps.begin(), aidlCaps.linkCaps.end(), caps.linkCaps.begin());
- return caps;
-}
-
-FrontendInfo TunerClient::frontendInfoAidlToHidl(TunerFrontendInfo aidlFrontendInfo) {
- FrontendInfo hidlFrontendInfo {
- .type = static_cast<FrontendType>(aidlFrontendInfo.type),
- .minFrequency = static_cast<uint32_t>(aidlFrontendInfo.minFrequency),
- .maxFrequency = static_cast<uint32_t>(aidlFrontendInfo.maxFrequency),
- .minSymbolRate = static_cast<uint32_t>(aidlFrontendInfo.minSymbolRate),
- .maxSymbolRate = static_cast<uint32_t>(aidlFrontendInfo.maxSymbolRate),
- .acquireRange = static_cast<uint32_t>(aidlFrontendInfo.acquireRange),
- .exclusiveGroupId = static_cast<uint32_t>(aidlFrontendInfo.exclusiveGroupId),
- };
-
- int size = aidlFrontendInfo.statusCaps.size();
- hidlFrontendInfo.statusCaps.resize(size);
- for (int i = 0; i < size; i++) {
- hidlFrontendInfo.statusCaps[i] =
- static_cast<FrontendStatusType>(aidlFrontendInfo.statusCaps[i]);
- }
-
- switch (aidlFrontendInfo.caps.getTag()) {
- case TunerFrontendCapabilities::analogCaps: {
- auto analog = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::analogCaps>();
- hidlFrontendInfo.frontendCaps.analogCaps({
- .typeCap = static_cast<uint32_t>(analog.typeCap),
- .sifStandardCap = static_cast<uint32_t>(analog.sifStandardCap),
- });
- break;
- }
- case TunerFrontendCapabilities::atscCaps: {
- auto atsc = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::atscCaps>();
- hidlFrontendInfo.frontendCaps.atscCaps({
- .modulationCap = static_cast<uint32_t>(atsc.modulationCap),
- });
- break;
- }
- case TunerFrontendCapabilities::atsc3Caps: {
- auto atsc3 = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::atsc3Caps>();
- hidlFrontendInfo.frontendCaps.atsc3Caps({
- .bandwidthCap = static_cast<uint32_t>(atsc3.bandwidthCap),
- .modulationCap = static_cast<uint32_t>(atsc3.modulationCap),
- .timeInterleaveModeCap = static_cast<uint32_t>(atsc3.timeInterleaveModeCap),
- .codeRateCap = static_cast<uint32_t>(atsc3.codeRateCap),
- .fecCap = static_cast<uint32_t>(atsc3.fecCap),
- .demodOutputFormatCap = static_cast<uint8_t>(atsc3.demodOutputFormatCap),
- });
- break;
- }
- case TunerFrontendCapabilities::cableCaps: {
- auto cable = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::cableCaps>();
- hidlFrontendInfo.frontendCaps.dvbcCaps({
- .modulationCap = static_cast<uint32_t>(cable.modulationCap),
- .fecCap = static_cast<uint64_t>(cable.codeRateCap),
- .annexCap = static_cast<uint8_t>(cable.annexCap),
- });
- break;
- }
- case TunerFrontendCapabilities::dvbsCaps: {
- auto dvbs = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::dvbsCaps>();
- hidlFrontendInfo.frontendCaps.dvbsCaps({
- .modulationCap = static_cast<int32_t>(dvbs.modulationCap),
- .innerfecCap = static_cast<uint64_t>(dvbs.codeRateCap),
- .standard = static_cast<uint8_t>(dvbs.standard),
- });
- break;
- }
- case TunerFrontendCapabilities::dvbtCaps: {
- auto dvbt = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::dvbtCaps>();
- hidlFrontendInfo.frontendCaps.dvbtCaps({
- .transmissionModeCap = static_cast<uint32_t>(dvbt.transmissionModeCap),
- .bandwidthCap = static_cast<uint32_t>(dvbt.bandwidthCap),
- .constellationCap = static_cast<uint32_t>(dvbt.constellationCap),
- .coderateCap = static_cast<uint32_t>(dvbt.codeRateCap),
- .hierarchyCap = static_cast<uint32_t>(dvbt.hierarchyCap),
- .guardIntervalCap = static_cast<uint32_t>(dvbt.guardIntervalCap),
- .isT2Supported = dvbt.isT2Supported,
- .isMisoSupported = dvbt.isMisoSupported,
- });
- break;
- }
- case TunerFrontendCapabilities::isdbsCaps: {
- auto isdbs = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::isdbsCaps>();
- hidlFrontendInfo.frontendCaps.isdbsCaps({
- .modulationCap = static_cast<uint32_t>(isdbs.modulationCap),
- .coderateCap = static_cast<uint32_t>(isdbs.codeRateCap),
- });
- break;
- }
- case TunerFrontendCapabilities::isdbs3Caps: {
- auto isdbs3 = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::isdbs3Caps>();
- hidlFrontendInfo.frontendCaps.isdbs3Caps({
- .modulationCap = static_cast<uint32_t>(isdbs3.modulationCap),
- .coderateCap = static_cast<uint32_t>(isdbs3.codeRateCap),
- });
- break;
- }
- case TunerFrontendCapabilities::isdbtCaps: {
- auto isdbt = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::isdbtCaps>();
- hidlFrontendInfo.frontendCaps.isdbtCaps({
- .modeCap = static_cast<uint32_t>(isdbt.modeCap),
- .bandwidthCap = static_cast<uint32_t>(isdbt.bandwidthCap),
- .modulationCap = static_cast<uint32_t>(isdbt.modulationCap),
- .coderateCap = static_cast<uint32_t>(isdbt.codeRateCap),
- .guardIntervalCap = static_cast<uint32_t>(isdbt.guardIntervalCap),
- });
- break;
- }
- }
- return hidlFrontendInfo;
-}
-
-// TODO: remove after migration to Tuner Service is done.
-int TunerClient::getResourceIdFromHandle(int handle, int /*resourceType*/) {
- return (handle & 0x00ff0000) >> 16;
-}
-
-// TODO: remove after migration to Tuner Service is done.
-int TunerClient::getResourceHandleFromId(int id, int resourceType) {
- return (resourceType & 0x000000ff) << 24
- | (id << 16)
- | (mResourceRequestCount++ & 0xffff);
-}
} // namespace android