Merge "Connect MediaEvents core path between TunerService and TunerClient" into sc-dev am: cea46d1ff1

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/13437707

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: I6e5cb5f59da81375ffa9c7cddc2852d54bc78e74

media/jni/Android.bp

@@ -166,6 +166,11 @@ cc_library_shared {
         "tv_tuner_aidl_interface-ndk_platform",
         "tv_tuner_resource_manager_aidl_interface-ndk_platform"
     ],
+
+    static_libs: [
+        "libaidlcommonsupport",
+    ],
+
     defaults: [
         "libcodec2-impl-defaults",
     ],

media/jni/android_media_tv_Tuner.cpp

@@ -1458,7 +1458,7 @@ int JTuner::tune(const FrontendSettings& settings, const FrontendSettingsExt1_1&
         ALOGE("frontend is not initialized");
         return (int)Result::INVALID_STATE;
     }
-    return (int) mFeClient->tune(settings,settingsExt1_1);
+    return (int) mFeClient->tune(settings, settingsExt1_1);
 }
 
 int JTuner::stopTune() {

media/jni/tuner/DemuxClient.cpp

@@ -142,7 +142,16 @@ long DemuxClient::getAvSyncTime(int avSyncHwId) {
 }
 
 sp<DvrClient> DemuxClient::openDvr(DvrType dvbType, int bufferSize, sp<DvrClientCallback> cb) {
-    // TODO: pending aidl interface
+    if (mTunerDemux != NULL) {
+        shared_ptr<ITunerDvr> tunerDvr;
+        shared_ptr<TunerDvrCallback> callback =
+                ::ndk::SharedRefBase::make<TunerDvrCallback>(cb);
+        Status s = mTunerDemux->openDvr((int)dvbType, bufferSize, callback, &tunerDvr);
+        if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
+            return NULL;
+        }
+        return new DvrClient(tunerDvr);
+    }
 
     if (mDemux != NULL) {
         sp<HidlDvrCallback> callback = new HidlDvrCallback(cb);
@@ -178,7 +187,10 @@ Result DemuxClient::disconnectCiCam() {
 }
 
 Result DemuxClient::close() {
-    // TODO: pending aidl interface
+    if (mTunerDemux != NULL) {
+        Status s = mTunerDemux->close();
+        return ClientHelper::getServiceSpecificErrorCode(s);
+    }
 
     if (mDemux != NULL) {
         Result res = mDemux->close();

media/jni/tuner/DvrClient.cpp

@@ -210,14 +210,13 @@ Result DvrClient::configure(DvrSettings settings) {
             return res;
         }
 
-        AidlMQDesc* aidlMqDesc = NULL;
+        AidlMQDesc aidlMqDesc;
-        s = mTunerDvr->getQueueDesc(aidlMqDesc);
+        s = mTunerDvr->getQueueDesc(&aidlMqDesc);
         res = ClientHelper::getServiceSpecificErrorCode(s);
         if (res != Result::SUCCESS) {
             return res;
         }
-
+        mDvrMQ = new (nothrow) AidlMQ(aidlMqDesc);
-        mDvrMQ = new (nothrow) AidlMQ(*aidlMqDesc);
         EventFlag::createEventFlag(mDvrMQ->getEventFlagWord(), &mDvrMQEventFlag);
         return res;
     }

media/jni/tuner/FilterClient.cpp

@@ -16,14 +16,21 @@
 
 #define LOG_TAG "FilterClient"
 
+#include <aidlcommonsupport/NativeHandle.h>
 #include <android-base/logging.h>
 #include <utils/Log.h>
 
 #include "FilterClient.h"
 
+using ::aidl::android::media::tv::tuner::TunerFilterAvSettings;
+using ::aidl::android::media::tv::tuner::TunerFilterSharedHandleInfo;
+using ::aidl::android::media::tv::tuner::TunerFilterTsConfiguration;
+
 using ::android::hardware::tv::tuner::V1_0::DemuxQueueNotifyBits;
 using ::android::hardware::tv::tuner::V1_0::DemuxFilterMainType;
 using ::android::hardware::tv::tuner::V1_0::DemuxMmtpFilterType;
+using ::android::hardware::tv::tuner::V1_0::DemuxStreamId;
+using ::android::hardware::tv::tuner::V1_0::DemuxTsFilterSettings;
 using ::android::hardware::tv::tuner::V1_0::DemuxTsFilterType;
 
 namespace android {
@@ -48,7 +55,6 @@ FilterClient::~FilterClient() {
 void FilterClient::setHidlFilter(sp<IFilter> filter) {
     mFilter = filter;
     mFilter_1_1 = ::android::hardware::tv::tuner::V1_1::IFilter::castFrom(mFilter);
-    handleAvShareMemory();
 }
 
 int FilterClient::read(uint8_t* buffer, int size) {
@@ -66,23 +72,20 @@ int FilterClient::read(uint8_t* buffer, int size) {
 }
 
 SharedHandleInfo FilterClient::getAvSharedHandleInfo() {
+    handleAvShareMemory();
     SharedHandleInfo info{
-        .sharedHandle = NULL,
+        .sharedHandle = mAvSharedHandle,
-        .size = 0,
+        .size = mAvSharedMemSize,
     };
 
-    // TODO: pending aidl interface
-
-    if (mFilter_1_1 != NULL) {
-        info.sharedHandle = mAvSharedHandle;
-        info.size = mAvSharedMemSize;
-    }
-
     return info;
 }
 
 Result FilterClient::configure(DemuxFilterSettings configure) {
-    // TODO: pending aidl interface
+    if (mTunerFilter != NULL) {
+        Status s = mTunerFilter->configure(getAidlFilterSettings(configure));
+        return ClientHelper::getServiceSpecificErrorCode(s);
+    }
 
     if (mFilter != NULL) {
         return mFilter->configure(configure);
@@ -122,7 +125,10 @@ Result FilterClient::configureAvStreamType(AvStreamType avStreamType) {
 }
 
 Result FilterClient::start() {
-    // TODO: pending aidl interface
+    if (mTunerFilter != NULL) {
+        Status s = mTunerFilter->start();
+        return ClientHelper::getServiceSpecificErrorCode(s);
+    }
 
     if (mFilter != NULL) {
         return mFilter->start();
@@ -132,7 +138,10 @@ Result FilterClient::start() {
 }
 
 Result FilterClient::stop() {
-    // TODO: pending aidl interface
+    if (mTunerFilter != NULL) {
+        Status s = mTunerFilter->stop();
+        return ClientHelper::getServiceSpecificErrorCode(s);
+    }
 
     if (mFilter != NULL) {
         return mFilter->stop();
@@ -142,7 +151,10 @@ Result FilterClient::stop() {
 }
 
 Result FilterClient::flush() {
-    // TODO: pending aidl interface
+    if (mTunerFilter != NULL) {
+        Status s = mTunerFilter->flush();
+        return ClientHelper::getServiceSpecificErrorCode(s);
+    }
 
     if (mFilter != NULL) {
         return mFilter->flush();
@@ -192,7 +204,10 @@ Result FilterClient::getId64Bit(uint64_t& id) {
 }
 
 Result FilterClient::releaseAvHandle(native_handle_t* handle, uint64_t avDataId) {
-    // TODO: pending aidl interface
+    if (mTunerFilter != NULL) {
+        Status s = mTunerFilter->releaseAvHandle(makeToAidl(handle), avDataId);
+        return ClientHelper::getServiceSpecificErrorCode(s);
+    }
 
     if (mFilter != NULL) {
         return mFilter->releaseAvHandle(hidl_handle(handle), avDataId);
@@ -216,13 +231,18 @@ Result FilterClient::setDataSource(sp<FilterClient> filterClient){
 }
 
 Result FilterClient::close() {
-    // TODO: pending aidl interface
+    if (mTunerFilter != NULL) {
+        Status s = mTunerFilter->close();
+        closeAvSharedMemory();
+        return ClientHelper::getServiceSpecificErrorCode(s);
+    }
 
     if (mFilter != NULL) {
         Result res = mFilter->close();
         if (res == Result::SUCCESS) {
             mFilter = NULL;
         }
+        closeAvSharedMemory();
         return res;
     }
 
@@ -269,13 +289,103 @@ Status TunerFilterCallback::onFilterStatus(int status) {
     return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE));
 }
 
-Status TunerFilterCallback::onFilterEvent(vector<TunerFilterEvent>* /*filterEvent*/) {
+Status TunerFilterCallback::onFilterEvent(const vector<TunerFilterEvent>& filterEvents) {
-    // TODO: complete onFilterEvent
+    if (mFilterClientCallback == NULL) {
+        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE));
+    }
+
+    DemuxFilterEvent event;
+    DemuxFilterEventExt eventExt;
+    getHidlFilterEvent(filterEvents, event, eventExt);
+    if (eventExt.events.size() > 0) {
+        mFilterClientCallback->onFilterEvent_1_1(event, eventExt);
+    } else {
+        mFilterClientCallback->onFilterEvent(event);
+    }
+
     return Status::ok();
 }
 
 /////////////// FilterClient Helper Methods ///////////////////////
 
+TunerFilterConfiguration FilterClient::getAidlFilterSettings(DemuxFilterSettings configure) {
+    TunerFilterConfiguration config;
+    // TODO: complete filter setting conversion
+    switch (configure.getDiscriminator()) {
+        case DemuxFilterSettings::hidl_discriminator::ts: {
+            TunerFilterSettings filterSettings;
+            switch (configure.ts().filterSettings.getDiscriminator()) {
+                case DemuxTsFilterSettings::FilterSettings::hidl_discriminator::av: {
+                    TunerFilterAvSettings av{
+                        .isPassthrough = configure.ts().filterSettings.av().isPassthrough,
+                    };
+                    filterSettings.set<TunerFilterSettings::av>(av);
+                    break;
+                }
+                default:
+                    break;
+            }
+
+            TunerFilterTsConfiguration ts{
+                .tpid = configure.ts().tpid,
+                .filterSettings = filterSettings,
+            };
+            config.set<TunerFilterConfiguration::ts>(ts);
+
+            return config;
+        }
+        case DemuxFilterSettings::hidl_discriminator::mmtp:
+            break;
+        case DemuxFilterSettings::hidl_discriminator::ip:
+            break;
+        case DemuxFilterSettings::hidl_discriminator::tlv:
+            break;
+        default:
+            break;
+    }
+    return config;
+}
+
+
+void TunerFilterCallback::getHidlFilterEvent(const vector<TunerFilterEvent>& filterEvents,
+        DemuxFilterEvent& event, DemuxFilterEventExt& /*eventExt*/) {
+    // TODO: finish handling extended evets and other filter event types
+    switch (filterEvents[0].getTag()) {
+        case  TunerFilterEvent::media: {
+            for (int i = 0; i < filterEvents.size(); i++) {
+                hidl_handle handle = hidl_handle(
+                        makeFromAidl(filterEvents[i].get<TunerFilterEvent::media>().avMemory));
+                int size = event.events.size();
+                event.events.resize(size + 1);
+                event.events[size].media({
+                    .avMemory = handle,
+                    .streamId = static_cast<DemuxStreamId>(
+                            filterEvents[i].get<TunerFilterEvent::media>().streamId),
+                    .isPtsPresent =
+                            filterEvents[i].get<TunerFilterEvent::media>().isPtsPresent,
+                    .pts = static_cast<uint64_t>(
+                            filterEvents[i].get<TunerFilterEvent::media>().pts),
+                    .dataLength = static_cast<uint32_t>(
+                            filterEvents[i].get<TunerFilterEvent::media>().dataLength),
+                    .offset = static_cast<uint32_t>(
+                            filterEvents[i].get<TunerFilterEvent::media>().offset),
+                    .isSecureMemory =
+                            filterEvents[i].get<TunerFilterEvent::media>().isSecureMemory,
+                    .avDataId = static_cast<uint64_t>(
+                            filterEvents[i].get<TunerFilterEvent::media>().avDataId),
+                    .mpuSequenceNumber = static_cast<uint32_t>(
+                            filterEvents[i].get<TunerFilterEvent::media>().offset),
+                    .isPesPrivateData =
+                            filterEvents[i].get<TunerFilterEvent::media>().isPesPrivateData,
+                });
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}
+
 Result FilterClient::getFilterMq() {
     if (mFilter == NULL) {
         return Result::INVALID_STATE;
@@ -333,6 +443,20 @@ void FilterClient::checkIsMediaFilter(DemuxFilterType type) {
 }
 
 void FilterClient::handleAvShareMemory() {
+    if (mAvSharedHandle != NULL) {
+        return;
+    }
+
+    if (mTunerFilter != NULL && mIsMediaFilter) {
+        TunerFilterSharedHandleInfo aidlHandleInfo;
+        Status s = mTunerFilter->getAvSharedHandleInfo(&aidlHandleInfo);
+        if (ClientHelper::getServiceSpecificErrorCode(s) == Result::SUCCESS) {
+            mAvSharedHandle = native_handle_clone(makeFromAidl(aidlHandleInfo.handle));
+            mAvSharedMemSize = aidlHandleInfo.size;
+        }
+        return;
+    }
+
     if (mFilter_1_1 != NULL && mIsMediaFilter) {
         mFilter_1_1->getAvSharedHandle([&](Result r, hidl_handle avMemory, uint64_t avMemSize) {
             if (r == Result::SUCCESS) {
@@ -342,4 +466,10 @@ void FilterClient::handleAvShareMemory() {
         });
     }
 }
+
+void FilterClient::closeAvSharedMemory() {
+    native_handle_close(mAvSharedHandle);
+    native_handle_delete(mAvSharedHandle);
+    mAvSharedMemSize = 0;
+}
 }  // namespace android

media/jni/tuner/FilterClient.h

@@ -20,6 +20,8 @@
 #include <aidl/android/media/tv/tuner/ITunerFilter.h>
 #include <aidl/android/media/tv/tuner/BnTunerFilterCallback.h>
 #include <aidl/android/media/tv/tuner/TunerFilterEvent.h>
+#include <aidl/android/media/tv/tuner/TunerFilterSettings.h>
+#include <aidlcommonsupport/NativeHandle.h>
 #include <android/hardware/tv/tuner/1.1/IFilter.h>
 #include <android/hardware/tv/tuner/1.1/IFilterCallback.h>
 #include <android/hardware/tv/tuner/1.1/types.h>
@@ -31,7 +33,9 @@
 using Status = ::ndk::ScopedAStatus;
 using ::aidl::android::media::tv::tuner::BnTunerFilterCallback;
 using ::aidl::android::media::tv::tuner::ITunerFilter;
+using ::aidl::android::media::tv::tuner::TunerFilterConfiguration;
 using ::aidl::android::media::tv::tuner::TunerFilterEvent;
+using ::aidl::android::media::tv::tuner::TunerFilterSettings;
 
 using ::android::hardware::EventFlag;
 using ::android::hardware::MessageQueue;
@@ -61,11 +65,13 @@ class TunerFilterCallback : public BnTunerFilterCallback {
 
 public:
     TunerFilterCallback(sp<FilterClientCallback> filterClientCallback);
-    // TODO: complete TunerFilterCallback
     Status onFilterStatus(int status);
-    Status onFilterEvent(vector<TunerFilterEvent>* filterEvent);
+    Status onFilterEvent(const vector<TunerFilterEvent>& filterEvents);
 
 private:
+    void getHidlFilterEvent(const vector<TunerFilterEvent>& filterEvents,
+            DemuxFilterEvent& event, DemuxFilterEventExt& eventExt);
+
     sp<FilterClientCallback> mFilterClientCallback;
 };
 
@@ -174,10 +180,12 @@ public:
     Result close();
 
 private:
+    TunerFilterConfiguration getAidlFilterSettings(DemuxFilterSettings configure);
     Result getFilterMq();
     int copyData(uint8_t* buffer, int size);
     void checkIsMediaFilter(DemuxFilterType type);
     void handleAvShareMemory();
+    void closeAvSharedMemory();
 
     /**
      * An AIDL Tuner Filter Singleton assigned at the first time when the Tuner Client

media/jni/tuner/FrontendClient.cpp

@@ -21,8 +21,8 @@
 
 #include "FrontendClient.h"
 
+using ::aidl::android::media::tv::tuner::TunerFrontendDvbtSettings;
 using ::aidl::android::media::tv::tuner::TunerFrontendScanAtsc3PlpInfo;
-using ::aidl::android::media::tv::tuner::TunerFrontendSettings;
 
 using ::android::hardware::tv::tuner::V1_0::FrontendAnalogSifStandard;
 using ::android::hardware::tv::tuner::V1_0::FrontendAnalogType;
@@ -86,10 +86,9 @@ void FrontendClient::setHidlFrontend(sp<IFrontend> frontend) {
 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;
+        TunerFrontendSettings tunerFeSettings = getAidlFrontendSettings(settings, settingsExt1_1);
-        Status s = mTunerFrontend->tune(settings);
+        Status s = mTunerFrontend->tune(tunerFeSettings);
         return ClientHelper::getServiceSpecificErrorCode(s);
     }
 
@@ -124,10 +123,9 @@ Result FrontendClient::stopTune() {
 Result FrontendClient::scan(const FrontendSettings& settings, FrontendScanType type,
         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;
+        TunerFrontendSettings tunerFeSettings = getAidlFrontendSettings(settings, settingsExt1_1);
-        Status s = mTunerFrontend->scan(settings, (int)type);
+        Status s = mTunerFrontend->scan(tunerFeSettings, (int)type);
         return ClientHelper::getServiceSpecificErrorCode(s);
     }
 
@@ -279,7 +277,6 @@ Result FrontendClient::unlinkCiCamToFrontend(int ciCamId) {
 
 Result FrontendClient::close() {
     if (mTunerFrontend != NULL) {
-        // TODO: handle error message.
         Status s = mTunerFrontend->close();
         return ClientHelper::getServiceSpecificErrorCode(s);
     }
@@ -304,6 +301,61 @@ int FrontendClient::getId() {
     return mId;
 }
 
+TunerFrontendSettings FrontendClient::getAidlFrontendSettings(const FrontendSettings& settings,
+        const FrontendSettingsExt1_1& /*settingsExt1_1*/) {
+    // TODO: complete hidl to aidl frontend settings conversion
+    TunerFrontendSettings s;
+    switch (settings.getDiscriminator()) {
+        case FrontendSettings::hidl_discriminator::analog: {
+            break;
+        }
+        case FrontendSettings::hidl_discriminator::atsc: {
+            break;
+        }
+        case FrontendSettings::hidl_discriminator::atsc3: {
+            break;
+        }
+        case FrontendSettings::hidl_discriminator::dvbs: {
+            break;
+        }
+        case FrontendSettings::hidl_discriminator::dvbc: {
+            break;
+        }
+        case FrontendSettings::hidl_discriminator::dvbt: {
+            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,
+            };
+            s.set<TunerFrontendSettings::dvbt>(dvbtSettings);
+            break;
+        }
+        case FrontendSettings::hidl_discriminator::isdbs: {
+            break;
+        }
+        case FrontendSettings::hidl_discriminator::isdbs3: {
+            break;
+        }
+        case FrontendSettings::hidl_discriminator::isdbt: {
+            break;
+        }
+        default:
+            break;
+    }
+    return s;
+}
+
 /////////////// TunerFrontendCallback ///////////////////////
 
 TunerFrontendCallback::TunerFrontendCallback(sp<FrontendClientCallback> frontendClientCallback)

media/jni/tuner/FrontendClient.h

@@ -32,6 +32,7 @@ using Status = ::ndk::ScopedAStatus;
 using ::aidl::android::media::tv::tuner::BnTunerFrontendCallback;
 using ::aidl::android::media::tv::tuner::ITunerFrontend;
 using ::aidl::android::media::tv::tuner::TunerFrontendScanMessage;
+using ::aidl::android::media::tv::tuner::TunerFrontendSettings;
 
 using ::android::hardware::Return;
 using ::android::hardware::Void;
@@ -171,6 +172,9 @@ public:
     int getId();
 
 private:
+    TunerFrontendSettings getAidlFrontendSettings(const FrontendSettings& settings,
+            const FrontendSettingsExt1_1& settingsExt1_1);
+
     /**
      * 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.

media/jni/tuner/TunerClient.cpp

@@ -235,7 +235,8 @@ sp<DescramblerClient> TunerClient::openDescrambler(int /*descramblerHandle*/) {
         }
     }
 
-    return NULL;}
+    return NULL;
+}
 
 sp<LnbClient> TunerClient::openLnb(int lnbHandle) {
     if (mTunerService != NULL) {