Merge "Support lazy tuner server" (62e86d92) · Commits · e / os / android_frameworks_av

services/tuner/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -17,7 +17,6 @@ aidl_interface {
		"android.hardware.common.fmq-V1",
		"android.hardware.tv.tuner-V1",
		],

		backend: {
		java: {
		enabled: false,

services/tuner/TunerDemux.cpp

+8 −66

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@
		#include <aidl/android/hardware/tv/tuner/Result.h>

		#include "TunerDvr.h"
		#include "TunerService.h"
		#include "TunerTimeFilter.h"

		using ::aidl::android::hardware::tv::tuner::IDvr;
		@@ -41,23 +42,20 @@ namespace media {
		namespace tv {
		namespace tuner {

		TunerDemux::TunerDemux(shared_ptr<IDemux> demux, int id) {
		TunerDemux::TunerDemux(const shared_ptr<IDemux> demux, const int id,
		const shared_ptr<TunerService> tuner) {
		mDemux = demux;
		mDemuxId = id;
		mTunerService = tuner;
		}

		TunerDemux::~TunerDemux() {
		mDemux = nullptr;
		mTunerService = nullptr;
		}

		::ndk::ScopedAStatus TunerDemux::setFrontendDataSource(
		const shared_ptr<ITunerFrontend>& in_frontend) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		int frontendId;
		in_frontend->getFrontendId(&frontendId);

		@@ -65,43 +63,26 @@ TunerDemux::~TunerDemux() {
		}

		::ndk::ScopedAStatus TunerDemux::setFrontendDataSourceById(int frontendId) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		return mDemux->setFrontendDataSource(frontendId);
		}

		::ndk::ScopedAStatus TunerDemux::openFilter(const DemuxFilterType& in_type, int32_t in_bufferSize,
		const shared_ptr<ITunerFilterCallback>& in_cb,
		shared_ptr<ITunerFilter>* _aidl_return) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		shared_ptr<IFilter> filter;
		shared_ptr<TunerFilter::FilterCallback> filterCb =
		::ndk::SharedRefBase::make<TunerFilter::FilterCallback>(in_cb);
		shared_ptr<IFilterCallback> cb = filterCb;
		auto status = mDemux->openFilter(in_type, in_bufferSize, cb, &filter);
		if (status.isOk()) {
		*_aidl_return = ::ndk::SharedRefBase::make<TunerFilter>(filter, filterCb, in_type);
		*_aidl_return =
		::ndk::SharedRefBase::make<TunerFilter>(filter, filterCb, in_type, mTunerService);
		}

		return status;
		}

		::ndk::ScopedAStatus TunerDemux::openTimeFilter(shared_ptr<ITunerTimeFilter>* _aidl_return) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		shared_ptr<ITimeFilter> filter;
		auto status = mDemux->openTimeFilter(&filter);
		if (status.isOk()) {
		@@ -113,35 +94,17 @@ TunerDemux::~TunerDemux() {

		::ndk::ScopedAStatus TunerDemux::getAvSyncHwId(const shared_ptr<ITunerFilter>& tunerFilter,
		int32_t* _aidl_return) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		shared_ptr<IFilter> halFilter = (static_cast<TunerFilter*>(tunerFilter.get()))->getHalFilter();
		return mDemux->getAvSyncHwId(halFilter, _aidl_return);
		}

		::ndk::ScopedAStatus TunerDemux::getAvSyncTime(int32_t avSyncHwId, int64_t* _aidl_return) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		return mDemux->getAvSyncTime(avSyncHwId, _aidl_return);
		}

		::ndk::ScopedAStatus TunerDemux::openDvr(DvrType in_dvbType, int32_t in_bufferSize,
		const shared_ptr<ITunerDvrCallback>& in_cb,
		shared_ptr<ITunerDvr>* _aidl_return) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		shared_ptr<IDvrCallback> callback = ::ndk::SharedRefBase::make<TunerDvr::DvrCallback>(in_cb);
		shared_ptr<IDvr> halDvr;
		auto res = mDemux->openDvr(in_dvbType, in_bufferSize, callback, &halDvr);
		@@ -153,36 +116,15 @@ TunerDemux::~TunerDemux() {
		}

		::ndk::ScopedAStatus TunerDemux::connectCiCam(int32_t ciCamId) {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		return mDemux->connectCiCam(ciCamId);
		}

		::ndk::ScopedAStatus TunerDemux::disconnectCiCam() {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		return mDemux->disconnectCiCam();
		}

		::ndk::ScopedAStatus TunerDemux::close() {
		if (mDemux == nullptr) {
		ALOGE("IDemux is not initialized.");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		auto res = mDemux->close();
		mDemux = nullptr;

		return res;
		return mDemux->close();
		}

		} // namespace tuner

services/tuner/TunerDemux.h

+5 −1

Original line number	Diff line number	Diff line
		@@ -32,10 +32,13 @@ namespace media {
		namespace tv {
		namespace tuner {

		class TunerService;

		class TunerDemux : public BnTunerDemux {

		public:
		TunerDemux(shared_ptr<IDemux> demux, int demuxId);
		TunerDemux(const shared_ptr<IDemux> demux, const int demuxId,
		const shared_ptr<TunerService> tuner);
		virtual ~TunerDemux();

		::ndk::ScopedAStatus setFrontendDataSource(
		@@ -60,6 +63,7 @@ public:
		private:
		shared_ptr<IDemux> mDemux;
		int mDemuxId;
		shared_ptr<TunerService> mTunerService;
		};

		} // namespace tuner

services/tuner/TunerDescrambler.cpp

+1 −34

Original line number	Diff line number	Diff line
		@@ -46,33 +46,15 @@ TunerDescrambler::~TunerDescrambler() {

		::ndk::ScopedAStatus TunerDescrambler::setDemuxSource(
		const shared_ptr<ITunerDemux>& in_tunerDemux) {
		if (mDescrambler == nullptr) {
		ALOGE("IDescrambler is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		return mDescrambler->setDemuxSource((static_cast<TunerDemux*>(in_tunerDemux.get()))->getId());
		}

		::ndk::ScopedAStatus TunerDescrambler::setKeyToken(const vector<uint8_t>& in_keyToken) {
		if (mDescrambler == nullptr) {
		ALOGE("IDescrambler is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		return mDescrambler->setKeyToken(in_keyToken);
		}

		::ndk::ScopedAStatus TunerDescrambler::addPid(
		const DemuxPid& in_pid, const shared_ptr<ITunerFilter>& in_optionalSourceFilter) {
		if (mDescrambler == nullptr) {
		ALOGE("IDescrambler is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		shared_ptr<IFilter> halFilter =
		(in_optionalSourceFilter == nullptr)
		? nullptr
		@@ -83,12 +65,6 @@ TunerDescrambler::~TunerDescrambler() {

		::ndk::ScopedAStatus TunerDescrambler::removePid(
		const DemuxPid& in_pid, const shared_ptr<ITunerFilter>& in_optionalSourceFilter) {
		if (mDescrambler == nullptr) {
		ALOGE("IDescrambler is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		shared_ptr<IFilter> halFilter =
		(in_optionalSourceFilter == nullptr)
		? nullptr
		@@ -98,16 +74,7 @@ TunerDescrambler::~TunerDescrambler() {
		}

		::ndk::ScopedAStatus TunerDescrambler::close() {
		if (mDescrambler == nullptr) {
		ALOGE("IDescrambler is not initialized.");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		auto res = mDescrambler->close();
		mDescrambler = nullptr;

		return res;
		return mDescrambler->close();
		}

		} // namespace tuner

services/tuner/TunerDvr.cpp

+1 −52

Original line number	Diff line number	Diff line
		@@ -41,32 +41,14 @@ TunerDvr::~TunerDvr() {
		}

		::ndk::ScopedAStatus TunerDvr::getQueueDesc(AidlMQDesc* _aidl_return) {
		if (mDvr == nullptr) {
		ALOGE("IDvr is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		return mDvr->getQueueDesc(_aidl_return);
		}

		::ndk::ScopedAStatus TunerDvr::configure(const DvrSettings& in_settings) {
		if (mDvr == nullptr) {
		ALOGE("IDvr is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		return mDvr->configure(in_settings);
		}

		::ndk::ScopedAStatus TunerDvr::attachFilter(const shared_ptr<ITunerFilter>& in_filter) {
		if (mDvr == nullptr) {
		ALOGE("IDvr is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		if (in_filter == nullptr) {
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::INVALID_ARGUMENT));
		@@ -82,12 +64,6 @@ TunerDvr::~TunerDvr() {
		}

		::ndk::ScopedAStatus TunerDvr::detachFilter(const shared_ptr<ITunerFilter>& in_filter) {
		if (mDvr == nullptr) {
		ALOGE("IDvr is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		if (in_filter == nullptr) {
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::INVALID_ARGUMENT));
		@@ -103,46 +79,19 @@ TunerDvr::~TunerDvr() {
		}

		::ndk::ScopedAStatus TunerDvr::start() {
		if (mDvr == nullptr) {
		ALOGE("IDvr is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		return mDvr->start();
		}

		::ndk::ScopedAStatus TunerDvr::stop() {
		if (mDvr == nullptr) {
		ALOGE("IDvr is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		return mDvr->stop();
		}

		::ndk::ScopedAStatus TunerDvr::flush() {
		if (mDvr == nullptr) {
		ALOGE("IDvr is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		return mDvr->flush();
		}

		::ndk::ScopedAStatus TunerDvr::close() {
		if (mDvr == nullptr) {
		ALOGE("IDvr is not initialized");
		return ::ndk::ScopedAStatus::fromServiceSpecificError(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		auto status = mDvr->close();
		mDvr = nullptr;

		return status;
		return mDvr->close();
		}

		/////////////// IDvrCallback ///////////////////////