Merge "Implement TunerFrontendClientCallback in FrontendClient" (94912eb4) · Commits · e / os / android_frameworks_base

media/jni/tuner/FrontendClient.cpp

+202 −51

Original line number	Diff line number	Diff line
		@@ -21,18 +21,39 @@

		#include "FrontendClient.h"

		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;
		using ::android::hardware::tv::tuner::V1_0::FrontendAtscModulation;
		using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3Modulation;
		using ::android::hardware::tv::tuner::V1_0::FrontendDvbcAnnex;
		using ::android::hardware::tv::tuner::V1_0::FrontendDvbcModulation;
		using ::android::hardware::tv::tuner::V1_0::FrontendDvbsModulation;
		using ::android::hardware::tv::tuner::V1_0::FrontendDvbsStandard;
		using ::android::hardware::tv::tuner::V1_0::FrontendDvbtHierarchy;
		using ::android::hardware::tv::tuner::V1_0::FrontendDvbtStandard;
		using ::android::hardware::tv::tuner::V1_0::FrontendIsdbsModulation;
		using ::android::hardware::tv::tuner::V1_0::FrontendIsdbs3Modulation;
		using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtModulation;
		using ::android::hardware::tv::tuner::V1_0::FrontendScanAtsc3PlpInfo;
		using ::android::hardware::tv::tuner::V1_0::FrontendType;
		using ::android::hardware::tv::tuner::V1_1::Constant;
		using ::android::hardware::tv::tuner::V1_1::FrontendDtmbModulation;
		using ::android::hardware::tv::tuner::V1_1::FrontendDvbtConstellation;
		using ::android::hardware::tv::tuner::V1_1::FrontendModulation;

		namespace android {

		/////////////// FrontendClient ///////////////////////

		FrontendClient::FrontendClient(shared_ptr<ITunerFrontend> tunerFrontend, int id) {
		FrontendClient::FrontendClient(shared_ptr<ITunerFrontend> tunerFrontend, int id, int type) {
		mTunerFrontend = tunerFrontend;
		mAidlCallback = NULL;
		mHidlCallback = NULL;
		mId = id;
		mType = type;
		}

		FrontendClient::~FrontendClient() {
		@@ -42,11 +63,13 @@ FrontendClient::~FrontendClient() {
		mAidlCallback = NULL;
		mHidlCallback = NULL;
		mId = -1;
		mType = -1;
		}

		Result FrontendClient::setCallback(sp<FrontendClientCallback> frontendClientCallback) {
		if (mTunerFrontend != NULL) {
		mAidlCallback = ::ndk::SharedRefBase::make<TunerFrontendCallback>(frontendClientCallback);
		mAidlCallback->setFrontendType(mType);
		mTunerFrontend->setCallback(mAidlCallback);
		return Result::SUCCESS;
		}
		@@ -298,56 +321,21 @@ Status TunerFrontendCallback::onEvent(int frontendEventType) {
		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::onScanMessage(int messageType,
		const TunerFrontendScanMessage& message) {
		if (mFrontendClientCallback != NULL) {
		if (!is1_1ExtendedScanMessage(messageType)) {
		mFrontendClientCallback->onScanMessage(
		static_cast<FrontendScanMessageType>(messageType),
		getHalScanMessage(messageType, message));
		} else {
		mFrontendClientCallback->onScanMessageExt1_1(
		static_cast<FrontendScanMessageTypeExt1_1>(messageType),
		getHalScanMessageExt1_1(messageType, message));
		}

		Status TunerFrontendCallback::onAnalogSifStandard(int /sifStandandard/) {
		return Status::ok();
		}

		Status TunerFrontendCallback::onAtsc3PlpInfos(const vector<TunerAtsc3PlpInfo>& /atsc3PlpInfos/) {
		return Status::ok();
		return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE));
		}

		/////////////// IFrontendCallback ///////////////////////
		@@ -377,4 +365,167 @@ Return<void> HidlFrontendCallback::onScanMessageExt1_1(FrontendScanMessageTypeEx
		}
		return Void();
		}

		/////////////// FrontendClientCallback Helper Methods ///////////////////////

		FrontendScanMessage TunerFrontendCallback::getHalScanMessage(
		int messageType, const TunerFrontendScanMessage& message) {
		FrontendScanMessage scanMessage;
		switch (messageType) {
		case (int) FrontendScanMessageType::LOCKED:
		scanMessage.isLocked(message.get<TunerFrontendScanMessage::isLocked>());
		break;
		case (int) FrontendScanMessageType::END:
		scanMessage.isEnd(message.get<TunerFrontendScanMessage::isEnd>());
		break;
		case (int) FrontendScanMessageType::PROGRESS_PERCENT:
		scanMessage.progressPercent(message.get<TunerFrontendScanMessage::progressPercent>());
		break;
		case (int) FrontendScanMessageType::FREQUENCY: {
		vector<int> f = message.get<TunerFrontendScanMessage::frequencies>();
		hidl_vec<uint32_t> frequencies(begin(f), end(f));
		scanMessage.frequencies(frequencies);
		break;
		}
		case (int) FrontendScanMessageType::SYMBOL_RATE: {
		vector<int> s = message.get<TunerFrontendScanMessage::symbolRates>();
		hidl_vec<uint32_t> symbolRates(begin(s), end(s));
		scanMessage.symbolRates(symbolRates);
		break;
		}
		case (int) FrontendScanMessageType::HIERARCHY:
		scanMessage.hierarchy(static_cast<FrontendDvbtHierarchy>(
		message.get<TunerFrontendScanMessage::hierarchy>()));
		break;
		case (int) FrontendScanMessageType::ANALOG_TYPE:
		scanMessage.analogType(static_cast<FrontendAnalogType>(
		message.get<TunerFrontendScanMessage::analogType>()));
		break;
		case (int) FrontendScanMessageType::PLP_IDS: {
		vector<uint8_t> p = message.get<TunerFrontendScanMessage::plpIds>();
		hidl_vec<uint8_t> plpIds(begin(p), end(p));
		scanMessage.plpIds(plpIds);
		break;
		}
		case (int) FrontendScanMessageType::GROUP_IDS: {
		vector<uint8_t> g = message.get<TunerFrontendScanMessage::groupIds>();
		hidl_vec<uint8_t> groupIds(begin(g), end(g));
		scanMessage.groupIds(groupIds);
		break;
		}
		case (int) FrontendScanMessageType::INPUT_STREAM_IDS: {
		vector<char16_t> i = message.get<TunerFrontendScanMessage::inputStreamIds>();
		hidl_vec<uint16_t> inputStreamIds(begin(i), end(i));
		scanMessage.inputStreamIds(inputStreamIds);
		break;
		}
		case (int) FrontendScanMessageType::STANDARD: {
		FrontendScanMessage::Standard std;
		int standard = message.get<TunerFrontendScanMessage::std>();
		switch (mType) {
		case (int) FrontendType::DVBS:
		std.sStd(static_cast<FrontendDvbsStandard>(standard));
		scanMessage.std(std);
		break;
		case (int) FrontendType::DVBT:
		std.tStd(static_cast<FrontendDvbtStandard>(standard));
		scanMessage.std(std);
		break;
		case (int) FrontendType::ANALOG:
		std.sifStd(static_cast<FrontendAnalogSifStandard>(standard));
		scanMessage.std(std);
		break;
		default:
		break;
		}
		break;
		}
		case (int) FrontendScanMessageType::ATSC3_PLP_INFO: {
		vector<TunerFrontendScanAtsc3PlpInfo> plp =
		message.get<TunerFrontendScanMessage::atsc3PlpInfos>();
		hidl_vec<FrontendScanAtsc3PlpInfo> plpInfo;
		for (TunerFrontendScanAtsc3PlpInfo info : plp) {
		FrontendScanAtsc3PlpInfo p{
		.plpId = static_cast<uint8_t>(info.plpId),
		.bLlsFlag = info.llsFlag,
		};
		int size = plpInfo.size();
		plpInfo.resize(size + 1);
		plpInfo[size] = p;
		}
		scanMessage.atsc3PlpInfos(plpInfo);
		break;
		}
		default:
		break;
		}
		return scanMessage;
		}

		FrontendScanMessageExt1_1 TunerFrontendCallback::getHalScanMessageExt1_1(
		int messageType, const TunerFrontendScanMessage& message) {
		FrontendScanMessageExt1_1 scanMessage;
		switch (messageType) {
		case (int) FrontendScanMessageTypeExt1_1::HIGH_PRIORITY:
		scanMessage.isHighPriority(message.get<TunerFrontendScanMessage::isHighPriority>());
		break;
		case (int) FrontendScanMessageTypeExt1_1::DVBC_ANNEX:
		scanMessage.annex(static_cast<FrontendDvbcAnnex>(
		message.get<TunerFrontendScanMessage::annex>()));
		break;
		case (int) FrontendScanMessageTypeExt1_1::MODULATION: {
		FrontendModulation m;
		int modulation = message.get<TunerFrontendScanMessage::modulation>();
		switch (mType) {
		case (int) FrontendType::DVBC:
		m.dvbc(static_cast<FrontendDvbcModulation>(modulation));
		scanMessage.modulation(m);
		break;
		case (int) FrontendType::DVBS:
		m.dvbs(static_cast<FrontendDvbsModulation>(modulation));
		scanMessage.modulation(m);
		break;
		case (int) FrontendType::DVBT:
		m.dvbt(static_cast<FrontendDvbtConstellation>(modulation));
		scanMessage.modulation(m);
		break;
		case (int) FrontendType::ISDBS:
		m.isdbs(static_cast<FrontendIsdbsModulation>(modulation));
		scanMessage.modulation(m);
		break;
		case (int) FrontendType::ISDBS3:
		m.isdbs3(static_cast<FrontendIsdbs3Modulation>(modulation));
		scanMessage.modulation(m);
		break;
		case (int) FrontendType::ISDBT:
		m.isdbt(static_cast<FrontendIsdbtModulation>(modulation));
		scanMessage.modulation(m);
		break;
		case (int) FrontendType::ATSC:
		m.atsc(static_cast<FrontendAtscModulation>(modulation));
		scanMessage.modulation(m);
		break;
		case (int) FrontendType::ATSC3:
		m.atsc3(static_cast<FrontendAtsc3Modulation>(modulation));
		scanMessage.modulation(m);
		break;
		case (int) hardware::tv::tuner::V1_1::FrontendType::DTMB:
		m.dtmb(static_cast<FrontendDtmbModulation>(modulation));
		scanMessage.modulation(m);
		break;
		default:
		break;
		}
		break;
		}
		default:
		break;
		}
		return scanMessage;
		}

		bool TunerFrontendCallback::is1_1ExtendedScanMessage(int messageType) {
		return messageType >= (int)FrontendScanMessageTypeExt1_1::MODULATION
		&& messageType <= (int)FrontendScanMessageTypeExt1_1::HIGH_PRIORITY;
		}
		} // namespace android

media/jni/tuner/FrontendClient.h

+11 −26

Original line number	Diff line number	Diff line
		@@ -30,7 +30,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::TunerAtsc3PlpInfo;
		using ::aidl::android::media::tv::tuner::TunerFrontendScanMessage;

		using ::android::hardware::Return;
		using ::android::hardware::Void;
		@@ -63,34 +63,18 @@ public:

		Status onEvent(int frontendEventType);

		Status onLocked();
		Status onScanMessage(int messageType, const TunerFrontendScanMessage& message);

		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);
		void setFrontendType(int frontendType) { mType = frontendType; }

		private:
		FrontendScanMessage getHalScanMessage(int messageType, const TunerFrontendScanMessage& message);
		FrontendScanMessageExt1_1 getHalScanMessageExt1_1(int messageType,
		const TunerFrontendScanMessage& message);
		bool is1_1ExtendedScanMessage(int messageType);

		sp<FrontendClientCallback> mFrontendClientCallback;
		int mType;
		};

		struct HidlFrontendCallback : public IFrontendCallback {
		@@ -111,7 +95,7 @@ private:
		struct FrontendClient : public RefBase {

		public:
		FrontendClient(shared_ptr<ITunerFrontend> tunerFrontend, int id);
		FrontendClient(shared_ptr<ITunerFrontend> tunerFrontend, int id, int type);
		~FrontendClient();

		/**
		@@ -210,6 +194,7 @@ private:
		sp<HidlFrontendCallback> mHidlCallback;

		int mId;
		int mType;
		};
		} // namespace android

media/jni/tuner/TunerClient.cpp

+16 −2

Original line number	Diff line number	Diff line
		@@ -98,14 +98,28 @@ sp<FrontendClient> TunerClient::openFrontend(int frontendHandle) {
		// TODO: handle error code
		shared_ptr<ITunerFrontend> tunerFrontend;
		mTunerService->openFrontend(frontendHandle, &tunerFrontend);
		return new FrontendClient(tunerFrontend, frontendHandle);
		if (tunerFrontend == NULL) {
		return NULL;
		}
		int id;
		// TODO: handle error code
		tunerFrontend->getFrontendId(&id);
		TunerServiceFrontendInfo aidlFrontendInfo;
		// TODO: handle error code
		mTunerService->getFrontendInfo(id, &aidlFrontendInfo);
		return new FrontendClient(tunerFrontend, frontendHandle, aidlFrontendInfo.type);
		}

		if (mTuner != NULL) {
		int id = getResourceIdFromHandle(frontendHandle, FRONTEND);
		sp<IFrontend> hidlFrontend = openHidlFrontendById(id);
		if (hidlFrontend != NULL) {
		sp<FrontendClient> frontendClient = new FrontendClient(NULL, id);
		FrontendInfo hidlInfo;
		Result res = getHidlFrontendInfo(id, hidlInfo);
		if (res != Result::SUCCESS) {
		return NULL;
		}
		sp<FrontendClient> frontendClient = new FrontendClient(NULL, id, (int)hidlInfo.type);
		frontendClient->setHidlFrontend(hidlFrontend);
		return frontendClient;
		}