Merge "Change Tuner Frontend Callback to align with the aidl callback interface" (5b5b07bc) · Commits · e / os / android_frameworks_av

services/tuner/Android.bp

+2 −28

Original line number	Diff line number	Diff line
		filegroup {
		name: "tv_tuner_aidl",
		srcs: [
		"aidl/android/media/tv/tuner/ITunerFrontend.aidl",
		"aidl/android/media/tv/tuner/ITunerFrontendCallback.aidl",
		"aidl/android/media/tv/tuner/ITunerService.aidl",
		"aidl/android/media/tv/tuner/TunerAtsc3PlpInfo.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendAnalogCapabilities.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendAtscCapabilities.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendAtsc3Capabilities.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendCableCapabilities.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendCapabilities.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendDvbsCapabilities.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendDvbtCapabilities.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendIsdbsCapabilities.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendIsdbs3Capabilities.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendIsdbtCapabilities.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendAnalogSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendAtsc3PlpSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendAtsc3Settings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendAtscSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendCableSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendDvbsCodeRate.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendDvbsSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendDvbtSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendIsdbs3Settings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendIsdbsSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendIsdbtSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendSettings.aidl",
		"aidl/android/media/tv/tuner/TunerFrontendStatus.aidl",
		"aidl/android/media/tv/tuner/TunerServiceFrontendInfo.aidl",
		"aidl/android/media/tv/tuner/*.aidl",
		],
		path: "aidl",
		}
		@@ -67,6 +40,7 @@ cc_library {

		shared_libs: [
		"android.hardware.tv.tuner@1.0",
		"android.hardware.tv.tuner@1.1",
		"libbase",
		"libbinder_ndk",
		"libcutils",

services/tuner/TunerFrontend.cpp

+75 −29

Original line number	Diff line number	Diff line
		@@ -19,8 +19,8 @@
		#include "TunerFrontend.h"
		#include "TunerService.h"

		using ::aidl::android::media::tv::tuner::TunerAtsc3PlpInfo;
		using ::aidl::android::media::tv::tuner::TunerFrontendAtsc3PlpSettings;
		using ::aidl::android::media::tv::tuner::TunerFrontendScanAtsc3PlpInfo;
		using ::android::hardware::tv::tuner::V1_0::FrontendAnalogSifStandard;
		using ::android::hardware::tv::tuner::V1_0::FrontendAnalogType;
		using ::android::hardware::tv::tuner::V1_0::FrontendAtscModulation;
		@@ -69,12 +69,13 @@ using ::android::hardware::tv::tuner::V1_0::FrontendScanAtsc3PlpInfo;
		using ::android::hardware::tv::tuner::V1_0::FrontendScanType;
		using ::android::hardware::tv::tuner::V1_0::FrontendSettings;;
		using ::android::hardware::tv::tuner::V1_0::Result;
		using ::android::hardware::tv::tuner::V1_1::FrontendModulation;

		namespace android {

		TunerFrontend::TunerFrontend(sp<ITuner> tuner, int frontendHandle) {
		TunerFrontend::TunerFrontend(sp<ITuner> tuner, int id) {
		mTuner = tuner;
		mId = TunerService::getResourceIdFromHandle(frontendHandle);
		mId = id;

		if (mTuner != NULL) {
		Result status;
		@@ -312,6 +313,10 @@ Status TunerFrontend::getStatus(const std::vector<int32_t>& /statusTypes/,
		return Status::ok();
		}

		Status TunerFrontend::getFrontendId(int* _aidl_return) {
		*_aidl_return = mId;
		return Status::ok();
		}
		/////////////// FrontendCallback ///////////////////////

		Return<void> TunerFrontend::FrontendCallback::onEvent(FrontendEventType frontendEventType) {
		@@ -323,59 +328,56 @@ Return<void> TunerFrontend::FrontendCallback::onEvent(FrontendEventType frontend
		Return<void> TunerFrontend::FrontendCallback::onScanMessage(
		FrontendScanMessageType type, const FrontendScanMessage& message) {
		ALOGD("FrontendCallback::onScanMessage, type=%d", type);
		TunerFrontendScanMessage scanMessage;
		switch(type) {
		case FrontendScanMessageType::LOCKED: {
		if (message.isLocked()) {
		mTunerFrontendCallback->onLocked();
		}
		scanMessage.set<TunerFrontendScanMessage::isLocked>(message.isLocked());
		break;
		}
		case FrontendScanMessageType::END: {
		if (message.isEnd()) {
		mTunerFrontendCallback->onScanStopped();
		}
		scanMessage.set<TunerFrontendScanMessage::isEnd>(message.isEnd());
		break;
		}
		case FrontendScanMessageType::PROGRESS_PERCENT: {
		mTunerFrontendCallback->onProgress((int)message.progressPercent());
		scanMessage.set<TunerFrontendScanMessage::progressPercent>(message.progressPercent());
		break;
		}
		case FrontendScanMessageType::FREQUENCY: {
		auto f = message.frequencies();
		std::vector<int32_t> frequencies(std::begin(f), std::end(f));
		mTunerFrontendCallback->onFrequenciesReport(frequencies);
		std::vector<int> frequencies(std::begin(f), std::end(f));
		scanMessage.set<TunerFrontendScanMessage::frequencies>(frequencies);
		break;
		}
		case FrontendScanMessageType::SYMBOL_RATE: {
		auto s = message.symbolRates();
		std::vector<int32_t> symbolRates(std::begin(s), std::end(s));
		mTunerFrontendCallback->onSymbolRates(symbolRates);
		std::vector<int> symbolRates(std::begin(s), std::end(s));
		scanMessage.set<TunerFrontendScanMessage::symbolRates>(symbolRates);
		break;
		}
		case FrontendScanMessageType::HIERARCHY: {
		mTunerFrontendCallback->onHierarchy((int)message.hierarchy());
		scanMessage.set<TunerFrontendScanMessage::hierarchy>((int)message.hierarchy());
		break;
		}
		case FrontendScanMessageType::ANALOG_TYPE: {
		mTunerFrontendCallback->onSignalType((int)message.analogType());
		scanMessage.set<TunerFrontendScanMessage::analogType>((int)message.analogType());
		break;
		}
		case FrontendScanMessageType::PLP_IDS: {
		auto p = message.plpIds();
		std::vector<int32_t> plpIds(std::begin(p), std::end(p));
		mTunerFrontendCallback->onPlpIds(plpIds);
		std::vector<uint8_t> plpIds(std::begin(p), std::end(p));
		scanMessage.set<TunerFrontendScanMessage::plpIds>(plpIds);
		break;
		}
		case FrontendScanMessageType::GROUP_IDS: {
		auto g = message.groupIds();
		std::vector<int32_t> groupIds(std::begin(g), std::end(g));
		mTunerFrontendCallback->onGroupIds(groupIds);
		std::vector<uint8_t> groupIds(std::begin(g), std::end(g));
		scanMessage.set<TunerFrontendScanMessage::groupIds>(groupIds);
		break;
		}
		case FrontendScanMessageType::INPUT_STREAM_IDS: {
		auto i = message.inputStreamIds();
		std::vector<int32_t> streamIds(std::begin(i), std::end(i));
		mTunerFrontendCallback->onInputStreamIds(streamIds);
		std::vector<char16_t> streamIds(std::begin(i), std::end(i));
		scanMessage.set<TunerFrontendScanMessage::inputStreamIds>(streamIds);
		break;
		}
		case FrontendScanMessageType::STANDARD: {
		@@ -383,37 +385,81 @@ Return<void> TunerFrontend::FrontendCallback::onScanMessage(
		int standard;
		if (std.getDiscriminator() == FrontendScanMessage::Standard::hidl_discriminator::sStd) {
		standard = (int) std.sStd();
		mTunerFrontendCallback->onDvbsStandard(standard);
		} else if (std.getDiscriminator() ==
		FrontendScanMessage::Standard::hidl_discriminator::tStd) {
		standard = (int) std.tStd();
		mTunerFrontendCallback->onDvbsStandard(standard);
		} else if (std.getDiscriminator() ==
		FrontendScanMessage::Standard::hidl_discriminator::sifStd) {
		standard = (int) std.sifStd();
		mTunerFrontendCallback->onAnalogSifStandard(standard);
		}
		scanMessage.set<TunerFrontendScanMessage::std>(standard);
		break;
		}
		case FrontendScanMessageType::ATSC3_PLP_INFO: {
		std::vector<FrontendScanAtsc3PlpInfo> plpInfos = message.atsc3PlpInfos();
		std::vector<TunerAtsc3PlpInfo> tunerPlpInfos;
		std::vector<TunerFrontendScanAtsc3PlpInfo> tunerPlpInfos;
		for (int i = 0; i < plpInfos.size(); i++) {
		auto info = plpInfos[i];
		int plpId = (int) info.plpId;
		bool lls = (bool) info.bLlsFlag;
		TunerAtsc3PlpInfo plpInfo{
		TunerFrontendScanAtsc3PlpInfo plpInfo{
		.plpId = plpId,
		.llsFlag = lls,
		};
		tunerPlpInfos.push_back(plpInfo);
		}
		mTunerFrontendCallback->onAtsc3PlpInfos(tunerPlpInfos);
		scanMessage.set<TunerFrontendScanMessage::atsc3PlpInfos>(tunerPlpInfos);
		break;
		}
		default:
		break;
		}
		mTunerFrontendCallback->onScanMessage((int)type, scanMessage);
		return Void();
		}

		Return<void> TunerFrontend::FrontendCallback::onScanMessageExt1_1(
		FrontendScanMessageTypeExt1_1 type, const FrontendScanMessageExt1_1& message) {
		ALOGD("onScanMessageExt1_1::onScanMessage, type=%d", type);
		TunerFrontendScanMessage scanMessage;
		switch(type) {
		case FrontendScanMessageTypeExt1_1::MODULATION: {
		FrontendModulation m = message.modulation();
		int modulation;
		if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::dvbc) {
		modulation = (int) m.dvbc();
		} else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::dvbt) {
		modulation = (int) m.dvbt();
		} else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::dvbs) {
		modulation = (int) m.dvbs();
		} else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::isdbs) {
		modulation = (int) m.isdbs();
		} else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::isdbs3) {
		modulation = (int) m.isdbs3();
		} else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::isdbt) {
		modulation = (int) m.isdbt();
		} else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::atsc) {
		modulation = (int) m.atsc();
		} else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::atsc3) {
		modulation = (int) m.atsc3();
		} else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::dtmb) {
		modulation = (int) m.dtmb();
		}
		scanMessage.set<TunerFrontendScanMessage::modulation>(modulation);
		break;
		}
		case FrontendScanMessageTypeExt1_1::DVBC_ANNEX: {
		scanMessage.set<TunerFrontendScanMessage::annex>((int)message.annex());
		break;
		}
		case FrontendScanMessageTypeExt1_1::HIGH_PRIORITY: {
		scanMessage.set<TunerFrontendScanMessage::isHighPriority>(message.isHighPriority());
		break;
		}
		default:
		break;
		}
		mTunerFrontendCallback->onScanMessage((int)type, scanMessage);
		return Void();
		}

services/tuner/TunerFrontend.h

+9 −3

Original line number	Diff line number	Diff line
		@@ -19,6 +19,7 @@

		#include <aidl/android/media/tv/tuner/BnTunerFrontend.h>
		#include <android/hardware/tv/tuner/1.0/ITuner.h>
		#include <android/hardware/tv/tuner/1.1/IFrontendCallback.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <utils/Log.h>

		@@ -27,6 +28,7 @@ using ::aidl::android::media::tv::tuner::BnTunerFrontend;
		using ::aidl::android::media::tv::tuner::ITunerFrontendCallback;
		using ::aidl::android::media::tv::tuner::TunerFrontendAtsc3Settings;
		using ::aidl::android::media::tv::tuner::TunerFrontendDvbsCodeRate;
		using ::aidl::android::media::tv::tuner::TunerFrontendScanMessage;
		using ::aidl::android::media::tv::tuner::TunerFrontendSettings;
		using ::aidl::android::media::tv::tuner::TunerFrontendStatus;
		using ::android::hardware::Return;
		@@ -39,16 +41,17 @@ using ::android::hardware::tv::tuner::V1_0::FrontendId;
		using ::android::hardware::tv::tuner::V1_0::FrontendScanMessage;
		using ::android::hardware::tv::tuner::V1_0::FrontendScanMessageType;
		using ::android::hardware::tv::tuner::V1_0::IFrontend;
		using ::android::hardware::tv::tuner::V1_0::IFrontendCallback;
		using ::android::hardware::tv::tuner::V1_0::ITuner;

		using ::android::hardware::tv::tuner::V1_1::IFrontendCallback;
		using ::android::hardware::tv::tuner::V1_1::FrontendScanMessageExt1_1;
		using ::android::hardware::tv::tuner::V1_1::FrontendScanMessageTypeExt1_1;

		namespace android {

		class TunerFrontend : public BnTunerFrontend {

		public:
		TunerFrontend(sp<ITuner> tuner, int frontendHandle);
		TunerFrontend(sp<ITuner> tuner, int id);
		virtual ~TunerFrontend();
		Status setCallback(
		const std::shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) override;
		@@ -61,6 +64,7 @@ public:
		Status close() override;
		Status getStatus(const std::vector<int32_t>& statusTypes,
		std::vector<TunerFrontendStatus>* _aidl_return) override;
		Status getFrontendId(int* _aidl_return) override;

		struct FrontendCallback : public IFrontendCallback {
		FrontendCallback(const std::shared_ptr<ITunerFrontendCallback> tunerFrontendCallback)
		@@ -69,6 +73,8 @@ public:
		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& message);

		std::shared_ptr<ITunerFrontendCallback> mTunerFrontendCallback;
		};

services/tuner/TunerService.cpp

+2 −1

Original line number	Diff line number	Diff line
		@@ -252,7 +252,8 @@ Status TunerService::openFrontend(
		static_cast<int32_t>(Result::UNAVAILABLE));
		}

		*_aidl_return = ::ndk::SharedRefBase::make<TunerFrontend>(mTuner, frontendHandle);
		int id = getResourceIdFromHandle(frontendHandle);
		*_aidl_return = ::ndk::SharedRefBase::make<TunerFrontend>(mTuner, id);
		return Status::ok();
		}

services/tuner/TunerService.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -80,6 +80,7 @@ public:
		TunerService();
		virtual ~TunerService();

		// TODO: create a map between resource id and handles.
		static int getResourceIdFromHandle(int resourceHandle) {
		return (resourceHandle & 0x00ff0000) >> 16;
		}