From a673468ed91c1d9377d5ae92eb88f9308002c1ff Mon Sep 17 00:00:00 2001 From: Amy Zhang Date: Mon, 30 Nov 2020 16:14:38 -0800 Subject: Add a FrontendClientCallback struct and enable callbacks in FrontendClient Test: make libmedia_tv_tuner Bug: 174095851 Change-Id: I7b4c7f7a862835a7bb780ed52220e4f262c3cf98 --- media/jni/android_media_tv_Tuner.h | 1 - media/jni/tuner/FrontendClient.cpp | 171 +++++++++++++++++++++++++++++++ media/jni/tuner/FrontendClient.h | 97 +++++++++++++++++- media/jni/tuner/FrontendClientCallback.h | 38 +++++++ 4 files changed, 305 insertions(+), 2 deletions(-) create mode 100644 media/jni/tuner/FrontendClientCallback.h diff --git a/media/jni/android_media_tv_Tuner.h b/media/jni/android_media_tv_Tuner.h index 72e30bd17e9e..bec834cac238 100644 --- a/media/jni/android_media_tv_Tuner.h +++ b/media/jni/android_media_tv_Tuner.h @@ -77,7 +77,6 @@ using ::android::hardware::tv::tuner::V1_1::DemuxFilterEventExt; using ::android::hardware::tv::tuner::V1_1::DemuxFilterMonitorEvent; using ::android::hardware::tv::tuner::V1_1::FrontendScanMessageExt1_1; using ::android::hardware::tv::tuner::V1_1::FrontendScanMessageTypeExt1_1; -using ::android::hardware::tv::tuner::V1_1::IFrontendCallback; using MQ = MessageQueue; diff --git a/media/jni/tuner/FrontendClient.cpp b/media/jni/tuner/FrontendClient.cpp index 322f01cd1e52..63a46dceb942 100644 --- a/media/jni/tuner/FrontendClient.cpp +++ b/media/jni/tuner/FrontendClient.cpp @@ -21,20 +21,191 @@ #include "FrontendClient.h" +using ::aidl::android::media::tv::tuner::TunerFrontendSettings; + namespace android { +/////////////// FrontendClient /////////////////////// + FrontendClient::FrontendClient(shared_ptr tunerFrontend) { mTunerFrontend = tunerFrontend; + mAidlCallback = NULL; + mHidlCallback = NULL; } FrontendClient::~FrontendClient() { mTunerFrontend = NULL; mFrontend = NULL; mFrontend_1_1 = NULL; + mAidlCallback = NULL; + mHidlCallback = NULL; +} + +Result FrontendClient::setCallback(sp frontendClientCallback) { + if (mTunerFrontend != NULL) { + mAidlCallback = ::ndk::SharedRefBase::make(frontendClientCallback); + mTunerFrontend->setCallback(mAidlCallback); + return Result::SUCCESS; + } + + mHidlCallback = new HidlFrontendCallback(frontendClientCallback); + return mFrontend->setCallback(mHidlCallback); } void FrontendClient::setHidlFrontend(sp frontend) { mFrontend = frontend; mFrontend_1_1 = ::android::hardware::tv::tuner::V1_1::IFrontend::castFrom(mFrontend); } + +Result FrontendClient::tune(const FrontendSettings& settings, + const FrontendSettingsExt1_1& settingsExt1_1) { + if (mTunerFrontend != NULL) { + // TODO: parse hidl settings to aidl settings + // TODO: aidl frontend settings to include Tuner HAL 1.1 settings + TunerFrontendSettings settings; + // TODO: handle error message. + mTunerFrontend->tune(settings); + return Result::SUCCESS; + } + + Result result; + if (mFrontend_1_1 != NULL) { + 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) { + // TODO: handle error message. + mTunerFrontend->stopTune(); + return Result::SUCCESS; + } + + if (mFrontend != NULL) { + Result result = mFrontend->stopTune(); + return result; + } + + return Result::INVALID_STATE; +} + +Result FrontendClient::close() { + if (mTunerFrontend != NULL) { + // TODO: handle error message. + mTunerFrontend->close(); + return Result::SUCCESS; + } + + if (mFrontend != NULL) { + Result result = mFrontend->close(); + if (result == Result::SUCCESS) { + mFrontend = NULL; + mFrontend_1_1 = NULL; + } + return result; + } + + return Result::INVALID_STATE; +} + +/////////////// TunerFrontendCallback /////////////////////// + +TunerFrontendCallback::TunerFrontendCallback(sp frontendClientCallback) + : mFrontendClientCallback(frontendClientCallback) {} + +Status TunerFrontendCallback::onEvent(int frontendEventType) { + if (mFrontendClientCallback != NULL) { + mFrontendClientCallback->onEvent(static_cast(frontendEventType)); + return Status::ok(); + } + return Status::fromServiceSpecificError(static_cast(Result::INVALID_STATE)); +} + +Status TunerFrontendCallback::onLocked() { + return Status::ok(); +} + +Status TunerFrontendCallback::onScanStopped() { + return Status::ok(); +} + +Status TunerFrontendCallback::onProgress(int /*percent*/) { + return Status::ok(); +} + +Status TunerFrontendCallback::onFrequenciesReport(const vector& /*frequency*/) { + return Status::ok(); +} + +Status TunerFrontendCallback::onSymbolRates(const vector& /*rates*/) { + return Status::ok(); +} + +Status TunerFrontendCallback::onHierarchy(int /*hierarchy*/) { + return Status::ok(); +} + +Status TunerFrontendCallback::onSignalType(int /*signalType*/) { + return Status::ok(); +} + +Status TunerFrontendCallback::onPlpIds(const vector& /*plpIds*/) { + return Status::ok(); +} + +Status TunerFrontendCallback::onGroupIds(const vector& /*groupIds*/) { + return Status::ok(); +} + +Status TunerFrontendCallback::onInputStreamIds(const vector& /*inputStreamIds*/) { + return Status::ok(); +} + +Status TunerFrontendCallback::onDvbsStandard(int /*dvbsStandandard*/) { + return Status::ok(); +} + +Status TunerFrontendCallback::onAnalogSifStandard(int /*sifStandandard*/) { + return Status::ok(); +} + +Status TunerFrontendCallback::onAtsc3PlpInfos(const vector& /*atsc3PlpInfos*/) { + return Status::ok(); +} + +/////////////// IFrontendCallback /////////////////////// + +HidlFrontendCallback::HidlFrontendCallback(sp frontendClientCallback) + : mFrontendClientCallback(frontendClientCallback) {} + +Return HidlFrontendCallback::onEvent(FrontendEventType frontendEventType) { + if (mFrontendClientCallback != NULL) { + mFrontendClientCallback->onEvent(frontendEventType); + } + return Void(); +} + +Return HidlFrontendCallback::onScanMessage(FrontendScanMessageType type, + const FrontendScanMessage& message) { + if (mFrontendClientCallback != NULL) { + mFrontendClientCallback->onScanMessage(type, message); + } + return Void(); +} + +Return HidlFrontendCallback::onScanMessageExt1_1(FrontendScanMessageTypeExt1_1 type, + const FrontendScanMessageExt1_1& message) { + if (mFrontendClientCallback != NULL) { + mFrontendClientCallback->onScanMessageExt1_1(type, message); + } + return Void(); } +} // namespace android diff --git a/media/jni/tuner/FrontendClient.h b/media/jni/tuner/FrontendClient.h index 56b5a9799a8e..e19d360839a2 100644 --- a/media/jni/tuner/FrontendClient.h +++ b/media/jni/tuner/FrontendClient.h @@ -17,28 +17,120 @@ #ifndef _ANDROID_MEDIA_TV_FRONTEND_CLIENT_H_ #define _ANDROID_MEDIA_TV_FRONTEND_CLIENT_H_ +#include #include #include #include #include -//#include "FrontendClientCallback" +#include "FrontendClientCallback.h" +using Status = ::ndk::ScopedAStatus; + +using ::aidl::android::media::tv::tuner::BnTunerFrontendCallback; using ::aidl::android::media::tv::tuner::ITunerFrontend; +using ::aidl::android::media::tv::tuner::TunerAtsc3PlpInfo; +using ::android::hardware::Return; +using ::android::hardware::Void; using ::android::hardware::tv::tuner::V1_0::FrontendInfo; +using ::android::hardware::tv::tuner::V1_0::FrontendEventType; +using ::android::hardware::tv::tuner::V1_0::FrontendScanMessage; +using ::android::hardware::tv::tuner::V1_0::FrontendScanMessageType; +using ::android::hardware::tv::tuner::V1_0::FrontendSettings; using ::android::hardware::tv::tuner::V1_0::IFrontend; +using ::android::hardware::tv::tuner::V1_0::Result; + +using ::android::hardware::tv::tuner::V1_1::FrontendScanMessageExt1_1; +using ::android::hardware::tv::tuner::V1_1::FrontendScanMessageTypeExt1_1; +using ::android::hardware::tv::tuner::V1_1::FrontendSettingsExt1_1; +using ::android::hardware::tv::tuner::V1_1::IFrontendCallback; using namespace std; namespace android { +class TunerFrontendCallback : public BnTunerFrontendCallback { + +public: + TunerFrontendCallback(sp frontendClientCallback); + + Status onEvent(int frontendEventType); + + Status onLocked(); + + Status onScanStopped(); + + Status onProgress(int percent); + + Status onFrequenciesReport(const vector& frequency); + + Status onSymbolRates(const vector& rates); + + Status onHierarchy(int hierarchy); + + Status onSignalType(int signalType); + + Status onPlpIds(const vector& plpIds); + + Status onGroupIds(const vector& groupIds); + + Status onInputStreamIds(const vector& inputStreamIds); + + Status onDvbsStandard(int dvbsStandandard); + + Status onAnalogSifStandard(int sifStandandard); + + Status onAtsc3PlpInfos(const vector& atsc3PlpInfos); + +private: + sp mFrontendClientCallback; +}; + +struct HidlFrontendCallback : public IFrontendCallback { + +public: + HidlFrontendCallback(sp frontendClientCallback); + + virtual Return onEvent(FrontendEventType frontendEventType); + virtual Return onScanMessage( + FrontendScanMessageType type, const FrontendScanMessage& message); + virtual Return onScanMessageExt1_1( + FrontendScanMessageTypeExt1_1 type, const FrontendScanMessageExt1_1& messageExt); + +private: + sp mFrontendClientCallback; +}; + struct FrontendClient : public RefBase { + +public: FrontendClient(shared_ptr tunerFrontend); ~FrontendClient(); + /** + * Set a FrontendClientCallback to receive frontend events and scan messages. + */ + Result setCallback(sp frontendClientCallback); + + // TODO: remove after migration to Tuner Service is done. void setHidlFrontend(sp frontend); + /** + * Tuner Frontend with Frontend Settings. + */ + Result tune(const FrontendSettings& settings, const FrontendSettingsExt1_1& settingsExt1_1); + + /** + * Stop tune Frontend. + */ + Result stopTune(); + + /** + * Close Frontend. + */ + Result close(); + private: /** * An AIDL Tuner Frontend Singleton assigned at the first time when the Tuner Client @@ -59,6 +151,9 @@ private: * Default null. */ sp<::android::hardware::tv::tuner::V1_1::IFrontend> mFrontend_1_1; + + shared_ptr mAidlCallback; + sp mHidlCallback; }; } // namespace android diff --git a/media/jni/tuner/FrontendClientCallback.h b/media/jni/tuner/FrontendClientCallback.h new file mode 100644 index 000000000000..c4d38be900ce --- /dev/null +++ b/media/jni/tuner/FrontendClientCallback.h @@ -0,0 +1,38 @@ +/* + * 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_CALLBACK_H_ +#define _ANDROID_MEDIA_TV_FRONTEND_CLIENT_CALLBACK_H_ + +using ::android::hardware::tv::tuner::V1_0::FrontendEventType; +using ::android::hardware::tv::tuner::V1_0::FrontendScanMessage; +using ::android::hardware::tv::tuner::V1_0::FrontendScanMessageType; +using ::android::hardware::tv::tuner::V1_1::FrontendScanMessageExt1_1; +using ::android::hardware::tv::tuner::V1_1::FrontendScanMessageTypeExt1_1; + +using namespace std; + +namespace android { + +struct FrontendClientCallback : public RefBase { + virtual void onEvent(FrontendEventType frontendEventType); + virtual void onScanMessage(FrontendScanMessageType type, const FrontendScanMessage& message); + virtual void onScanMessageExt1_1( + FrontendScanMessageTypeExt1_1 type, const FrontendScanMessageExt1_1& messageExt); +}; +} // namespace android + +#endif // _ANDROID_MEDIA_TV_FRONTEND_CLIENT_CALLBACK_H_ \ No newline at end of file -- cgit v1.2.3-59-g8ed1b