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

@@ -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<uint8_t, kSynchronizedReadWrite>;
 

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<ITunerFrontend> 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> frontendClientCallback) {
+    if (mTunerFrontend != NULL) {
+        mAidlCallback = ::ndk::SharedRefBase::make<TunerFrontendCallback>(frontendClientCallback);
+        mTunerFrontend->setCallback(mAidlCallback);
+        return Result::SUCCESS;
+    }
+
+    mHidlCallback = new HidlFrontendCallback(frontendClientCallback);
+    return mFrontend->setCallback(mHidlCallback);
 }
 
 void FrontendClient::setHidlFrontend(sp<IFrontend> 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> 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::onLocked() {
+    return Status::ok();
+}
+
+Status TunerFrontendCallback::onScanStopped() {
+    return Status::ok();
+}
+
+Status TunerFrontendCallback::onProgress(int /*percent*/) {
+    return Status::ok();
+}
+
+Status TunerFrontendCallback::onFrequenciesReport(const vector<int>& /*frequency*/) {
+    return Status::ok();
+}
+
+Status TunerFrontendCallback::onSymbolRates(const vector<int>& /*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<int>& /*plpIds*/) {
+    return Status::ok();
+}
+
+Status TunerFrontendCallback::onGroupIds(const vector<int>& /*groupIds*/) {
+    return Status::ok();
+}
+
+Status TunerFrontendCallback::onInputStreamIds(const vector<int>& /*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<TunerAtsc3PlpInfo>& /*atsc3PlpInfos*/) {
+    return Status::ok();
+}
+
+/////////////// 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();
+}
+}  // namespace android

media/jni/tuner/FrontendClient.h

@@ -17,28 +17,120 @@
 #ifndef _ANDROID_MEDIA_TV_FRONTEND_CLIENT_H_
 #define _ANDROID_MEDIA_TV_FRONTEND_CLIENT_H_
 
+#include <aidl/android/media/tv/tuner/BnTunerFrontendCallback.h>
 #include <aidl/android/media/tv/tuner/ITunerFrontend.h>
 #include <android/hardware/tv/tuner/1.1/IFrontend.h>
 #include <android/hardware/tv/tuner/1.1/IFrontendCallback.h>
 #include <android/hardware/tv/tuner/1.1/types.h>
 
-//#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> frontendClientCallback);
+
+    Status onEvent(int frontendEventType);
+
+    Status onLocked();
+
+    Status onScanStopped();
+
+    Status onProgress(int percent);
+
+    Status onFrequenciesReport(const vector<int>& frequency);
+
+    Status onSymbolRates(const vector<int>& rates);
+
+    Status onHierarchy(int hierarchy);
+
+    Status onSignalType(int signalType);
+
+    Status onPlpIds(const vector<int>& plpIds);
+
+    Status onGroupIds(const vector<int>& groupIds);
+
+    Status onInputStreamIds(const vector<int>& inputStreamIds);
+
+    Status onDvbsStandard(int dvbsStandandard);
+
+    Status onAnalogSifStandard(int sifStandandard);
+
+    Status onAtsc3PlpInfos(const vector<TunerAtsc3PlpInfo>& atsc3PlpInfos);
+
+private:
+    sp<FrontendClientCallback> mFrontendClientCallback;
+};
+
+struct HidlFrontendCallback : public IFrontendCallback {
+
+public:
+    HidlFrontendCallback(sp<FrontendClientCallback> frontendClientCallback);
+
+    virtual Return<void> onEvent(FrontendEventType frontendEventType);
+    virtual Return<void> onScanMessage(
+            FrontendScanMessageType type, const FrontendScanMessage& message);
+    virtual Return<void> onScanMessageExt1_1(
+            FrontendScanMessageTypeExt1_1 type, const FrontendScanMessageExt1_1& messageExt);
+
+private:
+    sp<FrontendClientCallback> mFrontendClientCallback;
+};
+
 struct FrontendClient : public RefBase {
+
+public:
     FrontendClient(shared_ptr<ITunerFrontend> tunerFrontend);
     ~FrontendClient();
 
+    /**
+     * Set a FrontendClientCallback to receive frontend events and scan messages.
+     */
+    Result setCallback(sp<FrontendClientCallback> frontendClientCallback);
+
+    // TODO: remove after migration to Tuner Service is done.
     void setHidlFrontend(sp<IFrontend> 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<TunerFrontendCallback> mAidlCallback;
+    sp<HidlFrontendCallback> mHidlCallback;
 };
 }  // namespace android
 

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_