From bf68a16af57a0bfe141159d7e4415372f9bedf6b Mon Sep 17 00:00:00 2001 From: Amy Zhang Date: Mon, 23 Nov 2020 17:42:40 -0800 Subject: [PATCH] Add an initial TunerClient/FrontendClient interface to interact between Tuner HIDL and Tuner JNI Test: make libmedia_tv_tuner Bug: 174095851 Change-Id: I8f1b0c79860eb4bf8d4d16595e8b798ad691288a --- media/java/android/media/tv/tuner/Tuner.java | 1 - media/jni/Android.bp | 4 + media/jni/android_media_tv_Tuner.cpp | 102 ++++------ media/jni/android_media_tv_Tuner.h | 6 +- media/jni/tuner/FrontendClient.cpp | 40 ++++ media/jni/tuner/FrontendClient.h | 65 ++++++ media/jni/tuner/TunerClient.cpp | 200 +++++++++++++++++++ media/jni/tuner/TunerClient.h | 118 +++++++++++ 8 files changed, 464 insertions(+), 72 deletions(-) create mode 100644 media/jni/tuner/FrontendClient.cpp create mode 100644 media/jni/tuner/FrontendClient.h create mode 100644 media/jni/tuner/TunerClient.cpp create mode 100644 media/jni/tuner/TunerClient.h diff --git a/media/java/android/media/tv/tuner/Tuner.java b/media/java/android/media/tv/tuner/Tuner.java index d094c2cd3c631..c89f181451187 100644 --- a/media/java/android/media/tv/tuner/Tuner.java +++ b/media/java/android/media/tv/tuner/Tuner.java @@ -546,7 +546,6 @@ public class Tuner implements AutoCloseable { */ private native Frontend nativeOpenFrontendByHandle(int handle); @Result - private native int nativeCloseFrontendByHandle(int handle); private native int nativeTune(int type, FrontendSettings settings); private native int nativeStopTune(); private native int nativeScan(int settingsType, FrontendSettings settings, int scanType); diff --git a/media/jni/Android.bp b/media/jni/Android.bp index c7fb50f616666..979f9eca48fd2 100644 --- a/media/jni/Android.bp +++ b/media/jni/Android.bp @@ -139,12 +139,15 @@ cc_library_shared { name: "libmedia_tv_tuner", srcs: [ "android_media_tv_Tuner.cpp", + "tuner/FrontendClient.cpp", + "tuner/TunerClient.cpp", ], shared_libs: [ "android.hardware.graphics.bufferqueue@2.0", "android.hardware.tv.tuner@1.0", "android.hardware.tv.tuner@1.1", + "libbinder_ndk", "libandroid_runtime", "libcutils", "libfmq", @@ -153,6 +156,7 @@ cc_library_shared { "libmedia", "libnativehelper", "libutils", + "tv_tuner_aidl_interface-ndk_platform", ], defaults: [ "libcodec2-impl-defaults", diff --git a/media/jni/android_media_tv_Tuner.cpp b/media/jni/android_media_tv_Tuner.cpp index 72dc32e7998fb..440d5bc2f1670 100644 --- a/media/jni/android_media_tv_Tuner.cpp +++ b/media/jni/android_media_tv_Tuner.cpp @@ -1172,7 +1172,7 @@ Return FrontendCallback::onScanMessageExt1_1(FrontendScanMessageTypeExt1_1 sp JTuner::mTuner; sp<::android::hardware::tv::tuner::V1_1::ITuner> JTuner::mTuner_1_1; -int JTuner::mTunerVersion = 0; +sp JTuner::mTunerClient; JTuner::JTuner(JNIEnv *env, jobject thiz) : mClass(NULL) { @@ -1181,9 +1181,13 @@ JTuner::JTuner(JNIEnv *env, jobject thiz) mClass = (jclass)env->NewGlobalRef(clazz); mObject = env->NewWeakGlobalRef(thiz); + // TODO: remove after migrate to client lib if (mTuner == NULL) { mTuner = getTunerService(); } + if (mTunerClient == NULL) { + mTunerClient = new TunerClient(); + } } JTuner::~JTuner() { @@ -1198,13 +1202,13 @@ JTuner::~JTuner() { env->DeleteWeakGlobalRef(mObject); env->DeleteGlobalRef(mClass); mTuner = NULL; + mTunerClient = NULL; mClass = NULL; mObject = NULL; } sp JTuner::getTunerService() { if (mTuner == nullptr) { - mTunerVersion = 0; mTuner_1_1 = ::android::hardware::tv::tuner::V1_1::ITuner::getService(); if (mTuner_1_1 == nullptr) { @@ -1212,12 +1216,9 @@ sp JTuner::getTunerService() { mTuner = ITuner::getService(); if (mTuner == nullptr) { ALOGW("Failed to get tuner 1.0 service."); - } else { - mTunerVersion = 1 << 16; } } else { mTuner = static_cast>(mTuner_1_1); - mTunerVersion = ((1 << 16) | 1); } } return mTuner; @@ -1225,15 +1226,13 @@ sp JTuner::getTunerService() { jint JTuner::getTunerVersion() { ALOGD("JTuner::getTunerVersion()"); - return (jint) mTunerVersion; + return (jint) mTunerClient->getHalTunerVersion(); } jobject JTuner::getFrontendIds() { ALOGD("JTuner::getFrontendIds()"); - mTuner->getFrontendIds([&](Result, const hidl_vec& frontendIds) { - mFeIds = frontendIds; - }); - if (mFeIds.size() == 0) { + vector ids = mTunerClient->getFrontendIds(); + if (ids.size() == 0) { ALOGW("Frontend isn't available"); return NULL; } @@ -1246,8 +1245,8 @@ jobject JTuner::getFrontendIds() { jclass integerClazz = env->FindClass("java/lang/Integer"); jmethodID intInit = env->GetMethodID(integerClazz, "", "(I)V"); - for (int i=0; i < mFeIds.size(); i++) { - jobject idObj = env->NewObject(integerClazz, intInit, mFeIds[i]); + for (int i=0; i < ids.size(); i++) { + jobject idObj = env->NewObject(integerClazz, intInit, ids[i]); env->CallBooleanMethod(obj, arrayListAdd, idObj); } return obj; @@ -1284,14 +1283,6 @@ jobject JTuner::openFrontendById(int id) { (jint) jId); } -jint JTuner::closeFrontendById(int id) { - if (mFe != NULL && mFeId == id) { - Result r = mFe->close(); - return (jint) r; - } - return (jint) Result::SUCCESS; -} - jobject JTuner::getAnalogFrontendCaps(JNIEnv *env, FrontendInfo::FrontendCapabilities& caps) { jclass clazz = env->FindClass("android/media/tv/tuner/frontend/AnalogFrontendCapabilities"); jmethodID capsInit = env->GetMethodID(clazz, "", "(II)V"); @@ -1402,37 +1393,26 @@ jobject JTuner::getDtmbFrontendCaps(JNIEnv *env, int id) { jclass clazz = env->FindClass("android/media/tv/tuner/frontend/DtmbFrontendCapabilities"); jmethodID capsInit = env->GetMethodID(clazz, "", "(IIIIII)V"); - if (mTuner_1_1 == NULL) { - ALOGD("1.1 Tuner is not found. Dtmb Frontend Caps are not supported."); + shared_ptr dtmbCaps = mTunerClient->getFrontendDtmbCapabilities(id); + if (dtmbCaps == NULL) { return NULL; } - Result result; - FrontendDtmbCapabilities dtmbCaps; - mTuner_1_1->getFrontendDtmbCapabilities(id, - [&](Result r, const FrontendDtmbCapabilities& caps) { - dtmbCaps = caps; - result = r; - }); - jint modulationCap = dtmbCaps.modulationCap; - jint transmissionModeCap = dtmbCaps.transmissionModeCap; - jint guardIntervalCap = dtmbCaps.guardIntervalCap; - jint interleaveModeCap = dtmbCaps.interleaveModeCap; - jint codeRateCap = dtmbCaps.codeRateCap; - jint bandwidthCap = dtmbCaps.bandwidthCap; + jint modulationCap = dtmbCaps->modulationCap; + jint transmissionModeCap = dtmbCaps->transmissionModeCap; + jint guardIntervalCap = dtmbCaps->guardIntervalCap; + jint interleaveModeCap = dtmbCaps->interleaveModeCap; + jint codeRateCap = dtmbCaps->codeRateCap; + jint bandwidthCap = dtmbCaps->bandwidthCap; return env->NewObject(clazz, capsInit, modulationCap, transmissionModeCap, guardIntervalCap, interleaveModeCap, codeRateCap, bandwidthCap); } jobject JTuner::getFrontendInfo(int id) { - FrontendInfo feInfo; - Result res; - mTuner->getFrontendInfo(id, [&](Result r, const FrontendInfo& info) { - feInfo = info; - res = r; - }); - if (res != Result::SUCCESS) { + shared_ptr feInfo; + feInfo = mTunerClient->getFrontendInfo(id); + if (feInfo == NULL) { return NULL; } @@ -1441,30 +1421,27 @@ jobject JTuner::getFrontendInfo(int id) { jmethodID infoInit = env->GetMethodID(clazz, "", "(IIIIIIII[ILandroid/media/tv/tuner/frontend/FrontendCapabilities;)V"); - jint type = (jint) feInfo.type; - jint minFrequency = feInfo.minFrequency; - jint maxFrequency = feInfo.maxFrequency; - jint minSymbolRate = feInfo.minSymbolRate; - jint maxSymbolRate = feInfo.maxSymbolRate; - jint acquireRange = feInfo.acquireRange; - jint exclusiveGroupId = feInfo.exclusiveGroupId; - jintArray statusCaps = env->NewIntArray(feInfo.statusCaps.size()); + jint type = (jint) feInfo->type; + jint minFrequency = feInfo->minFrequency; + jint maxFrequency = feInfo->maxFrequency; + jint minSymbolRate = feInfo->minSymbolRate; + jint maxSymbolRate = feInfo->maxSymbolRate; + jint acquireRange = feInfo->acquireRange; + jint exclusiveGroupId = feInfo->exclusiveGroupId; + jintArray statusCaps = env->NewIntArray(feInfo->statusCaps.size()); env->SetIntArrayRegion( - statusCaps, 0, feInfo.statusCaps.size(), - reinterpret_cast(&feInfo.statusCaps[0])); - FrontendInfo::FrontendCapabilities caps = feInfo.frontendCaps; + statusCaps, 0, feInfo->statusCaps.size(), + reinterpret_cast(&feInfo->statusCaps[0])); + FrontendInfo::FrontendCapabilities caps = feInfo->frontendCaps; jobject jcaps = NULL; - if (feInfo.type == static_cast( + if (feInfo->type == static_cast( ::android::hardware::tv::tuner::V1_1::FrontendType::DTMB)) { - if (mTuner_1_1 == NULL) { - return NULL; - } jcaps = getDtmbFrontendCaps(env, id); } - switch(feInfo.type) { + switch(feInfo->type) { case FrontendType::ANALOG: if (FrontendInfo::FrontendCapabilities::hidl_discriminator::analogCaps == caps.getDiscriminator()) { @@ -3426,13 +3403,6 @@ static jobject android_media_tv_Tuner_open_frontend_by_handle( return tuner->openFrontendById(id); } -static jint android_media_tv_Tuner_close_frontend_by_handle( - JNIEnv *env, jobject thiz, jint handle) { - sp tuner = getTuner(env, thiz); - uint32_t id = getResourceIdFromHandle(handle); - return tuner->closeFrontendById(id); -} - static int android_media_tv_Tuner_tune(JNIEnv *env, jobject thiz, jint type, jobject settings) { sp tuner = getTuner(env, thiz); FrontendSettings setting = getFrontendSettings(env, type, settings); @@ -4746,8 +4716,6 @@ static const JNINativeMethod gTunerMethods[] = { (void *)android_media_tv_Tuner_get_frontend_ids }, { "nativeOpenFrontendByHandle", "(I)Landroid/media/tv/tuner/Tuner$Frontend;", (void *)android_media_tv_Tuner_open_frontend_by_handle }, - { "nativeCloseFrontendByHandle", "(I)I", - (void *)android_media_tv_Tuner_close_frontend_by_handle }, { "nativeTune", "(ILandroid/media/tv/tuner/frontend/FrontendSettings;)I", (void *)android_media_tv_Tuner_tune }, { "nativeStopTune", "()I", (void *)android_media_tv_Tuner_stop_tune }, diff --git a/media/jni/android_media_tv_Tuner.h b/media/jni/android_media_tv_Tuner.h index e79b5c2e391ad..72e30bd17e9e8 100644 --- a/media/jni/android_media_tv_Tuner.h +++ b/media/jni/android_media_tv_Tuner.h @@ -34,6 +34,7 @@ #include #include +#include "tuner/TunerClient.h" #include "jni.h" using ::android::hardware::EventFlag; @@ -259,10 +260,7 @@ private: jweak mObject; static sp mTuner; static sp<::android::hardware::tv::tuner::V1_1::ITuner> mTuner_1_1; - // An integer that carries the Tuner version. The high 16 bits are the major version number - // while the low 16 bits are the minor version. Default value is unknown version 0. - static int mTunerVersion; - hidl_vec mFeIds; + static sp mTunerClient; sp mFe; sp<::android::hardware::tv::tuner::V1_1::IFrontend> mFe_1_1; int mFeId; diff --git a/media/jni/tuner/FrontendClient.cpp b/media/jni/tuner/FrontendClient.cpp new file mode 100644 index 0000000000000..322f01cd1e527 --- /dev/null +++ b/media/jni/tuner/FrontendClient.cpp @@ -0,0 +1,40 @@ +/* + * 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 +#include + +#include "FrontendClient.h" + +namespace android { + +FrontendClient::FrontendClient(shared_ptr tunerFrontend) { + mTunerFrontend = tunerFrontend; +} + +FrontendClient::~FrontendClient() { + mTunerFrontend = NULL; + mFrontend = NULL; + mFrontend_1_1 = NULL; +} + +void FrontendClient::setHidlFrontend(sp frontend) { + mFrontend = frontend; + mFrontend_1_1 = ::android::hardware::tv::tuner::V1_1::IFrontend::castFrom(mFrontend); +} +} diff --git a/media/jni/tuner/FrontendClient.h b/media/jni/tuner/FrontendClient.h new file mode 100644 index 0000000000000..56b5a9799a8ee --- /dev/null +++ b/media/jni/tuner/FrontendClient.h @@ -0,0 +1,65 @@ +/* + * 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. + */ + +#ifndef _ANDROID_MEDIA_TV_FRONTEND_CLIENT_H_ +#define _ANDROID_MEDIA_TV_FRONTEND_CLIENT_H_ + +#include +#include +#include +#include + +//#include "FrontendClientCallback" + +using ::aidl::android::media::tv::tuner::ITunerFrontend; + +using ::android::hardware::tv::tuner::V1_0::FrontendInfo; +using ::android::hardware::tv::tuner::V1_0::IFrontend; + +using namespace std; + +namespace android { + +struct FrontendClient : public RefBase { + FrontendClient(shared_ptr tunerFrontend); + ~FrontendClient(); + + void setHidlFrontend(sp frontend); + +private: + /** + * An AIDL Tuner Frontend Singleton assigned at the first time when the Tuner Client + * opens a frontend cient. Default null when the service does not exist. + */ + shared_ptr mTunerFrontend; + + /** + * A Frontend 1.0 HAL interface as a fall back interface when the Tuner Service does not exist. + * This is a temprary connection before the Tuner Framework fully migrates to the TunerService. + * Default null. + */ + sp mFrontend; + + /** + * A Frontend 1.1 HAL interface as a fall back interface when the Tuner Service does not exist. + * This is a temprary connection before the Tuner Framework fully migrates to the TunerService. + * Default null. + */ + sp<::android::hardware::tv::tuner::V1_1::IFrontend> mFrontend_1_1; +}; +} // namespace android + +#endif // _ANDROID_MEDIA_TV_FRONTEND_CLIENT_H_ diff --git a/media/jni/tuner/TunerClient.cpp b/media/jni/tuner/TunerClient.cpp new file mode 100644 index 0000000000000..4665f2b78bad6 --- /dev/null +++ b/media/jni/tuner/TunerClient.cpp @@ -0,0 +1,200 @@ +/* + * 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 "TunerClient" + +#include +#include +#include + +#include "TunerClient.h" + +using ::android::hardware::tv::tuner::V1_0::FrontendId; +using ::android::hardware::tv::tuner::V1_0::FrontendType; + +namespace android { + +sp TunerClient::mTuner; +sp<::android::hardware::tv::tuner::V1_1::ITuner> TunerClient::mTuner_1_1; +shared_ptr TunerClient::mTunerService; +int TunerClient::mTunerVersion; + +/////////////// TunerClient /////////////////////// + +TunerClient::TunerClient() { + // Get HIDL Tuner in migration stage. + getHidlTuner(); + // Connect with Tuner Service. + ::ndk::SpAIBinder binder(AServiceManager_getService("media.tuner")); + mTunerService = ITunerService::fromBinder(binder); + if (mTunerService == NULL) { + ALOGE("Failed to get tuner service"); + } +} + +TunerClient::~TunerClient() { + mTuner = NULL; + mTuner_1_1 = NULL; + mTunerVersion = 0; + mTunerService = NULL; +} + +vector TunerClient::getFrontendIds() { + vector ids; + // TODO: pending aidl interface + /*if (mTunerService != NULL) { + return mTunerService->getFrontendIds(); + }*/ + + if (mTuner != NULL) { + Result res; + mTuner->getFrontendIds([&](Result r, const hardware::hidl_vec& 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 TunerClient::openFrontend(int frontendHandle) { + if (mTunerService != NULL) { + // TODO: handle error code + shared_ptr tunerFrontend; + mTunerService->openFrontend(frontendHandle, &tunerFrontend); + return new FrontendClient(tunerFrontend); + } + + if (mTuner != NULL) { + sp hidlFrontend = openHidlFrontendByHandle(frontendHandle); + if (hidlFrontend != NULL) { + sp frontendClient = new FrontendClient(NULL); + frontendClient->setHidlFrontend(hidlFrontend); + return frontendClient; + } + } + + return NULL; +} + +shared_ptr TunerClient::getFrontendInfo(int id) { + if (mTunerService != NULL) { + TunerServiceFrontendInfo aidlFrontendInfo; + // TODO: handle error code + mTunerService->getFrontendInfo(id, &aidlFrontendInfo); + return make_shared(FrontendInfoAidlToHidl(aidlFrontendInfo)); + } + + if (mTuner != NULL) { + FrontendInfo hidlInfo; + Result res = getHidlFrontendInfo(id, hidlInfo); + if (res != Result::SUCCESS) { + return NULL; + } + return make_shared(hidlInfo); + } + + return NULL; +} + +shared_ptr TunerClient::getFrontendDtmbCapabilities(int id) { + // pending aidl interface + + 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(dtmbCaps); + } + } + + return NULL; +} + +/////////////// TunerClient Helper Methods /////////////////////// + +sp TunerClient::getHidlTuner() { + if (mTuner == NULL) { + mTunerVersion = 0; + 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 = 1 << 16; + } + } else { + mTuner = static_cast>(mTuner_1_1); + mTunerVersion = ((1 << 16) | 1); + } + } + return mTuner; +} + +sp TunerClient::openHidlFrontendByHandle(int frontendHandle) { + sp fe; + Result res; + uint32_t id = getResourceIdFromHandle(frontendHandle); + mTuner->openFrontendById(id, [&](Result r, const sp& 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; +} + +FrontendInfo TunerClient::FrontendInfoAidlToHidl(TunerServiceFrontendInfo aidlFrontendInfo) { + FrontendInfo hidlFrontendInfo { + .type = static_cast(aidlFrontendInfo.type), + .minFrequency = static_cast(aidlFrontendInfo.minFrequency), + .maxFrequency = static_cast(aidlFrontendInfo.maxFrequency), + .minSymbolRate = static_cast(aidlFrontendInfo.minSymbolRate), + .maxSymbolRate = static_cast(aidlFrontendInfo.maxSymbolRate), + .acquireRange = static_cast(aidlFrontendInfo.acquireRange), + .exclusiveGroupId = static_cast(aidlFrontendInfo.exclusiveGroupId), + }; + // TODO: handle Frontend caps + + return hidlFrontendInfo; +} +} // namespace android diff --git a/media/jni/tuner/TunerClient.h b/media/jni/tuner/TunerClient.h new file mode 100644 index 0000000000000..f2e78c9acbd3e --- /dev/null +++ b/media/jni/tuner/TunerClient.h @@ -0,0 +1,118 @@ +/* + * 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. + */ + +#ifndef _ANDROID_MEDIA_TV_TUNER_CLIENT_H_ +#define _ANDROID_MEDIA_TV_TUNER_CLIENT_H_ + +#include +#include +#include + +#include "FrontendClient.h" + +using ::aidl::android::media::tv::tuner::ITunerService; +using ::aidl::android::media::tv::tuner::TunerServiceFrontendInfo; + +using ::android::hardware::tv::tuner::V1_0::DemuxCapabilities; +using ::android::hardware::tv::tuner::V1_0::FrontendId; +using ::android::hardware::tv::tuner::V1_0::ITuner; +using ::android::hardware::tv::tuner::V1_0::Result; +using ::android::hardware::tv::tuner::V1_1::FrontendDtmbCapabilities; + +using namespace std; + +namespace android { + +struct TunerClient : public RefBase { + +public: + TunerClient(); + ~TunerClient(); + + /** + * Retrieve all the frontend ids. + * + * @return a list of the available frontend ids + */ + vector getFrontendIds(); + + /** + * Open a new interface of FrontendClient given a frontendHandle. + * + * @param frontendHandle the handle of the frontend granted by TRM. + * @return a newly created FrontendClient interface. + */ + sp openFrontend(int frontendHandle); + + /** + * Retrieve the granted frontend's information. + * + * @param id the id of the frontend granted by TRM. + * @return the information for the frontend. + */ + shared_ptr getFrontendInfo(int id); + + /** + * Retrieve the DTMB frontend's capabilities. + * + * @param id the id of the DTMB frontend. + * @return the capabilities of the frontend. + */ + shared_ptr getFrontendDtmbCapabilities(int id); + + /** + * Get the current Tuner HAL version. The high 16 bits are the major version number + * while the low 16 bits are the minor version. Default value is unknown version 0. + */ + int getHalTunerVersion() { return mTunerVersion; } + + static int getResourceIdFromHandle(int handle) { + return (handle & 0x00ff0000) >> 16; + } + +private: + /** + * An AIDL Tuner Service Singleton assigned at the first time the Tuner Client + * connects with the Tuner Service. Default null when the service does not exist. + */ + static shared_ptr mTunerService; + + /** + * A Tuner 1.0 HAL interface that is ready before connecting to the TunerService + * This is a temprary connection before the Tuner Framework fully migrates to the TunerService. + * Default null. + */ + static sp mTuner; + + /** + * A Tuner 1.1 HAL interface that is ready before connecting to the TunerService + * This is a temprary connection before the Tuner Framework fully migrates to the TunerService. + * Default null. + */ + static sp<::android::hardware::tv::tuner::V1_1::ITuner> mTuner_1_1; + + // An integer that carries the Tuner version. The high 16 bits are the major version number + // while the low 16 bits are the minor version. Default value is unknown version 0. + static int mTunerVersion; + + sp getHidlTuner(); + sp openHidlFrontendByHandle(int frontendHandle); + Result getHidlFrontendInfo(int id, FrontendInfo& info); + FrontendInfo FrontendInfoAidlToHidl(TunerServiceFrontendInfo aidlFrontendInfo); +}; +} // namespace android + +#endif // _ANDROID_MEDIA_TV_TUNER_CLIENT_H_