Add FilterClientCallback implementation (b74185b3) · Commits · e / os / android_frameworks_base

media/jni/tuner/DemuxClient.cpp

+61 −6

Original line number	Diff line number	Diff line
		@@ -44,26 +44,59 @@ void DemuxClient::setHidlDemux(sp<IDemux> demux) {
		mDemux = demux;
		}

		Result DemuxClient::setFrontendDataSource(sp<FrontendClient> tunerFrontend) {
		Result DemuxClient::setFrontendDataSource(sp<FrontendClient> frontendClient) {
		// TODO: pending aidl interface
		/*if (mTunerDemux != NULL) {
		// TODO: handle error message
		mTunerDemux->setFrontendDataSource(tunerFrontend->getAidlFrontend());
		mTunerDemux->setFrontendDataSource(frontendClient->getAidlFrontend());
		return (int) Result::SUCCESS;
		}*/

		if (mDemux != NULL) {
		Result res = mDemux->setFrontendDataSource(tunerFrontend->getId());
		Result res = mDemux->setFrontendDataSource(frontendClient->getId());
		return res;
		}

		return Result::INVALID_STATE;
		}

		//FilterClient openFilter(int mainType, int subType, int bufferSize, FilterClientCallback cb);
		sp<FilterClient> DemuxClient::openFilter(DemuxFilterType type, int bufferSize,
		sp<FilterClientCallback> cb) {
		// TODO: pending aidl interface

		if (mDemux != NULL) {
		sp<HidlFilterCallback> callback = new HidlFilterCallback(cb);
		sp<IFilter> hidlFilter = openHidlFilter(type, bufferSize, callback);
		if (hidlFilter != NULL) {
		sp<FilterClient> filterClient = new FilterClient();
		filterClient->setHidlFilter(hidlFilter);
		return filterClient;
		}
		}

		// TODO: handle share av memory handle

		int DemuxClient::getAvSyncHwId(FilterClient /tunerFilter/) {
		return 0;
		return NULL;
		}

		int DemuxClient::getAvSyncHwId(sp<FilterClient> filterClient) {
		// pending aidl interface

		if (mDemux != NULL) {
		uint32_t avSyncHwId;
		Result res;
		sp<IFilter> halFilter = filterClient->getHalFilter();
		mDemux->getAvSyncHwId(halFilter,
		[&](Result r, uint32_t id) {
		res = r;
		avSyncHwId = id;
		});
		if (res == Result::SUCCESS) {
		return (int) avSyncHwId;
		}
		}

		return -1;
		}

		long DemuxClient::getAvSyncTime(int avSyncHwId) {
		@@ -120,4 +153,26 @@ Result DemuxClient::close() {

		return Result::INVALID_STATE;
		}

		/////////////// DemuxClient Helper Methods ///////////////////////

		sp<IFilter> DemuxClient::openHidlFilter(DemuxFilterType type, int bufferSize,
		sp<HidlFilterCallback> callback) {
		if (mDemux == NULL) {
		return NULL;
		}

		sp<IFilter> hidlFilter;
		Result res;
		mDemux->openFilter(type, bufferSize, callback,
		[&](Result r, const sp<IFilter>& filter) {
		hidlFilter = filter;
		res = r;
		});
		if (res != Result::SUCCESS \|\| hidlFilter == NULL) {
		return NULL;
		}

		return hidlFilter;
		}
		} // namespace android

media/jni/tuner/DemuxClient.h

+7 −3

Original line number	Diff line number	Diff line
		@@ -22,10 +22,12 @@
		#include <android/hardware/tv/tuner/1.1/types.h>

		#include "FilterClient.h"
		#include "FilterClientCallback.h"
		#include "FrontendClient.h"

		//using ::aidl::android::media::tv::tuner::ITunerDemux;

		using ::android::hardware::tv::tuner::V1_0::DemuxFilterType;
		using ::android::hardware::tv::tuner::V1_0::IDemux;

		using namespace std;
		@@ -44,19 +46,19 @@ public:
		/**
		* Set a frontend resource as data input of the demux.
		*/
		Result setFrontendDataSource(sp<FrontendClient> tunerFrontend);
		Result setFrontendDataSource(sp<FrontendClient> frontendClient);

		/**
		* Open a new filter client.
		*/
		//FilterClient openFilter(int mainType, int subType, int bufferSize, FilterClientCallback cb);
		sp<FilterClient> openFilter(DemuxFilterType type, int bufferSize, sp<FilterClientCallback> cb);

		// TODO: handle TimeFilterClient

		/**
		* Get hardware sync ID for audio and video.
		*/
		int getAvSyncHwId(FilterClient tunerFilter);
		int getAvSyncHwId(sp<FilterClient> filterClient);

		/**
		* Get current time stamp to use for A/V sync.
		@@ -85,6 +87,8 @@ public:
		Result close();

		private:
		sp<IFilter> openHidlFilter(DemuxFilterType type, int bufferSize, sp<HidlFilterCallback> cb);

		/**
		* An AIDL Tuner Demux Singleton assigned at the first time the Tuner Client
		* opens a demux. Default null when demux is not opened.

media/jni/tuner/FilterClient.cpp

+28 −7

Original line number	Diff line number	Diff line
		@@ -14,7 +14,7 @@
		* limitations under the License.
		*/

		#define LOG_TAG "FrontendClient"
		#define LOG_TAG "FilterClient"

		#include <android-base/logging.h>
		#include <utils/Log.h>
		@@ -25,10 +25,6 @@ using ::android::hardware::tv::tuner::V1_0::DemuxQueueNotifyBits;

		namespace android {

		//shared_ptr<ITunerFilter> FilterClient::mTunerFilter;
		sp<IFilter> FilterClient::mFilter;
		sp<::android::hardware::tv::tuner::V1_1::IFilter> FilterClient::mFilter_1_1;

		/////////////// FilterClient ///////////////////////

		// TODO: pending aidl interface
		@@ -49,8 +45,6 @@ void FilterClient::setHidlFilter(sp<IFilter> filter) {
		mFilter_1_1 = ::android::hardware::tv::tuner::V1_1::IFilter::castFrom(mFilter);
		}

		//Result setCallback(FilterClientCallback filterClientCallback);

		int FilterClient::read(uint8_t* buffer, int size) {
		// TODO: pending aidl interface

		@@ -199,6 +193,33 @@ Result FilterClient::close() {
		return Result::INVALID_STATE;
		}

		/////////////// IFilterCallback ///////////////////////

		HidlFilterCallback::HidlFilterCallback(sp<FilterClientCallback> filterClientCallback)
		: mFilterClientCallback(filterClientCallback) {}

		Return<void> HidlFilterCallback::onFilterStatus(const DemuxFilterStatus status) {
		if (mFilterClientCallback != NULL) {
		mFilterClientCallback->onFilterStatus(status);
		}
		return Void();
		}

		Return<void> HidlFilterCallback::onFilterEvent(const DemuxFilterEvent& filterEvent) {
		if (mFilterClientCallback != NULL) {
		mFilterClientCallback->onFilterEvent(filterEvent);
		}
		return Void();
		}

		Return<void> HidlFilterCallback::onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,
		const DemuxFilterEventExt& filterEventExt) {
		if (mFilterClientCallback != NULL) {
		mFilterClientCallback->onFilterEvent_1_1(filterEvent, filterEventExt);
		}
		return Void();
		}

		/////////////// FilterClient Helper Methods ///////////////////////

		Result FilterClient::getFilterMq() {

media/jni/tuner/FilterClient.h

+38 −9

Original line number	Diff line number	Diff line
		@@ -19,21 +19,25 @@

		//#include <aidl/android/media/tv/tuner/ITunerFilter.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>
		#include <fmq/MessageQueue.h>

		//#include "FilterClientCallback.h"
		#include "FilterClientCallback.h"

		//using ::aidl::android::media::tv::tuner::ITunerFilter;

		using ::android::hardware::EventFlag;
		using ::android::hardware::MessageQueue;
		using ::android::hardware::MQDescriptorSync;
		using ::android::hardware::Return;
		using ::android::hardware::Void;
		using ::android::hardware::hidl_handle;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterSettings;
		using ::android::hardware::tv::tuner::V1_0::IFilter;
		using ::android::hardware::tv::tuner::V1_0::Result;
		using ::android::hardware::tv::tuner::V1_1::AvStreamType;
		using ::android::hardware::tv::tuner::V1_1::IFilterCallback;

		using namespace std;

		@@ -41,6 +45,32 @@ using MQ = MessageQueue<uint8_t, kSynchronizedReadWrite>;

		namespace android {

		// TODO: pending aidl interface
		/*class TunerFilterCallback : public BnTunerFilterCallback {

		public:
		TunerFilterCallback(sp<FilterClientCallback> filterClientCallback);

		Status onFilterEvent(vector<TunerDemuxFilterEvent> events);
		Status onFilterStatus(int status);

		private:
		sp<FilterClientCallback> mFilterClientCallback;
		};*/

		struct HidlFilterCallback : public IFilterCallback {

		public:
		HidlFilterCallback(sp<FilterClientCallback> filterClientCallback);
		virtual Return<void> onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,
		const DemuxFilterEventExt& filterEventExt);
		virtual Return<void> onFilterEvent(const DemuxFilterEvent& filterEvent);
		virtual Return<void> onFilterStatus(const DemuxFilterStatus status);

		private:
		sp<FilterClientCallback> mFilterClientCallback;
		};

		struct FilterClient : public RefBase {

		public:
		@@ -51,11 +81,6 @@ public:
		// TODO: remove after migration to Tuner Service is done.
		void setHidlFilter(sp<IFilter> filter);

		/**
		* Set the filter client callback.
		*/
		//Result setCallback(FilterClientCallback filterClientCallback);

		/**
		* Read size of data from filter FMQ into buffer.
		*
		@@ -142,24 +167,28 @@ private:
		* opens a filter. Default null when Tuner Service does not exist.
		*/
		// TODO: pending on aidl interface
		//static shared_ptr<ITunerFilter> mTunerFilter;
		//shared_ptr<ITunerFilter> mTunerFilter;

		/**
		* A 1.0 Filter HAL interface that is ready before migrating to the TunerFilter.
		* This is a temprary interface before Tuner Framework migrates to use TunerService.
		* Default null when the HAL service does not exist.
		*/
		static sp<IFilter> mFilter;
		sp<IFilter> mFilter;

		/**
		* A 1.1 Filter HAL interface that is ready before migrating to the TunerFilter.
		* This is a temprary interface before Tuner Framework migrates to use TunerService.
		* Default null when the HAL service does not exist.
		*/
		static sp<::android::hardware::tv::tuner::V1_1::IFilter> mFilter_1_1;
		sp<::android::hardware::tv::tuner::V1_1::IFilter> mFilter_1_1;

		unique_ptr<MQ> mFilterMQ;
		EventFlag* mFilterMQEventFlag;

		sp<FilterClientCallback> mCallback;
		//shared_ptr<TunerFilterCallback> mAidlCallback;
		sp<HidlFilterCallback> mHidlCallback;
		};
		} // namespace android

media/jni/tuner/FilterClientCallback.h

0 → 100644

+36 −0

Original line number	Diff line number	Diff line
		/*
		* 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_FILTER_CLIENT_CALLBACK_H_
		#define _ANDROID_MEDIA_TV_FILTER_CLIENT_CALLBACK_H_

		using ::android::hardware::tv::tuner::V1_0::DemuxFilterEvent;
		using ::android::hardware::tv::tuner::V1_0::DemuxFilterStatus;
		using ::android::hardware::tv::tuner::V1_1::DemuxFilterEventExt;

		using namespace std;

		namespace android {

		struct FilterClientCallback : public RefBase {
		virtual void onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,
		const DemuxFilterEventExt& filterEventExt);
		virtual void onFilterEvent(const DemuxFilterEvent& filterEvent);
		virtual void onFilterStatus(const DemuxFilterStatus status);
		};
		} // namespace android

		#endif // _ANDROID_MEDIA_TV_FILTER_CLIENT_CALLBACK_H_
		No newline at end of file