Merge "Add TunerTimeFilter/Lnb interface and add openLnb in TunerService" (c1a9aece) · Commits · e / os / android_frameworks_av

services/tuner/Android.bp

+1 −2

Original line number	Diff line number	Diff line
		@@ -64,8 +64,7 @@ cc_library {
		name: "libtunerservice",

		srcs: [
		"TunerService.cpp",
		"TunerFrontend.cpp"
		"Tuner*.cpp"
		],

		shared_libs: [

services/tuner/TunerFrontend.cpp

+20 −26

Original line number	Diff line number	Diff line
		@@ -17,7 +17,6 @@
		#define LOG_TAG "TunerFrontend"

		#include "TunerFrontend.h"
		#include "TunerService.h"

		using ::aidl::android::media::tv::tuner::TunerFrontendAtsc3PlpSettings;
		using ::aidl::android::media::tv::tuner::TunerFrontendScanAtsc3PlpInfo;
		@@ -73,26 +72,19 @@ using ::android::hardware::tv::tuner::V1_1::FrontendModulation;

		namespace android {

		TunerFrontend::TunerFrontend(sp<ITuner> tuner, int id) {
		mTuner = tuner;
		TunerFrontend::TunerFrontend(sp<IFrontend> frontend, int id) {
		mFrontend = frontend;
		mFrontend_1_1 = ::android::hardware::tv::tuner::V1_1::IFrontend::castFrom(mFrontend);
		mId = id;
		}

		if (mTuner != NULL) {
		Result status;
		mTuner->openFrontendById(mId, [&](Result result, const sp<IFrontend>& frontend) {
		mFrontend = frontend;
		status = result;
		});
		if (status != Result::SUCCESS) {
		TunerFrontend::~TunerFrontend() {
		mFrontend = NULL;
		}
		}
		mId = -1;
		}

		TunerFrontend::~TunerFrontend() {}

		Status TunerFrontend::setCallback(
		const std::shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) {
		const shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) {
		if (mFrontend == NULL) {
		ALOGE("IFrontend is not initialized");
		return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
		@@ -125,6 +117,7 @@ Status TunerFrontend::scan(const TunerFrontendSettings& settings, int frontendSc
		return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
		}

		// TODO: extend TunerFrontendSettings to use 1.1 types
		FrontendSettings frontendSettings;
		switch (settings.getTag()) {
		case TunerFrontendSettings::analog:
		@@ -308,8 +301,8 @@ Status TunerFrontend::close() {
		return Status::ok();
		}

		Status TunerFrontend::getStatus(const std::vector<int32_t>& /statusTypes/,
		std::vector<TunerFrontendStatus>* /_aidl_return/) {
		Status TunerFrontend::getStatus(const vector<int32_t>& /statusTypes/,
		vector<TunerFrontendStatus>* /_aidl_return/) {
		return Status::ok();
		}

		@@ -317,6 +310,7 @@ Status TunerFrontend::getFrontendId(int* _aidl_return) {
		*_aidl_return = mId;
		return Status::ok();
		}

		/////////////// FrontendCallback ///////////////////////

		Return<void> TunerFrontend::FrontendCallback::onEvent(FrontendEventType frontendEventType) {
		@@ -344,13 +338,13 @@ Return<void> TunerFrontend::FrontendCallback::onScanMessage(
		}
		case FrontendScanMessageType::FREQUENCY: {
		auto f = message.frequencies();
		std::vector<int> frequencies(std::begin(f), std::end(f));
		vector<int> frequencies(begin(f), end(f));
		scanMessage.set<TunerFrontendScanMessage::frequencies>(frequencies);
		break;
		}
		case FrontendScanMessageType::SYMBOL_RATE: {
		auto s = message.symbolRates();
		std::vector<int> symbolRates(std::begin(s), std::end(s));
		vector<int> symbolRates(begin(s), end(s));
		scanMessage.set<TunerFrontendScanMessage::symbolRates>(symbolRates);
		break;
		}
		@@ -364,19 +358,19 @@ Return<void> TunerFrontend::FrontendCallback::onScanMessage(
		}
		case FrontendScanMessageType::PLP_IDS: {
		auto p = message.plpIds();
		std::vector<uint8_t> plpIds(std::begin(p), std::end(p));
		vector<uint8_t> plpIds(begin(p), end(p));
		scanMessage.set<TunerFrontendScanMessage::plpIds>(plpIds);
		break;
		}
		case FrontendScanMessageType::GROUP_IDS: {
		auto g = message.groupIds();
		std::vector<uint8_t> groupIds(std::begin(g), std::end(g));
		vector<uint8_t> groupIds(begin(g), end(g));
		scanMessage.set<TunerFrontendScanMessage::groupIds>(groupIds);
		break;
		}
		case FrontendScanMessageType::INPUT_STREAM_IDS: {
		auto i = message.inputStreamIds();
		std::vector<char16_t> streamIds(std::begin(i), std::end(i));
		vector<char16_t> streamIds(begin(i), end(i));
		scanMessage.set<TunerFrontendScanMessage::inputStreamIds>(streamIds);
		break;
		}
		@@ -396,8 +390,8 @@ Return<void> TunerFrontend::FrontendCallback::onScanMessage(
		break;
		}
		case FrontendScanMessageType::ATSC3_PLP_INFO: {
		std::vector<FrontendScanAtsc3PlpInfo> plpInfos = message.atsc3PlpInfos();
		std::vector<TunerFrontendScanAtsc3PlpInfo> tunerPlpInfos;
		vector<FrontendScanAtsc3PlpInfo> plpInfos = message.atsc3PlpInfos();
		vector<TunerFrontendScanAtsc3PlpInfo> tunerPlpInfos;
		for (int i = 0; i < plpInfos.size(); i++) {
		auto info = plpInfos[i];
		int plpId = (int) info.plpId;
		@@ -463,7 +457,7 @@ Return<void> TunerFrontend::FrontendCallback::onScanMessageExt1_1(
		return Void();
		}

		////////////////////////////////////////////////////////////////////////////////
		/////////////// TunerFrontend Helper Methods ///////////////////////

		hidl_vec<FrontendAtsc3PlpSettings> TunerFrontend::getAtsc3PlpSettings(
		const TunerFrontendAtsc3Settings& settings) {

services/tuner/TunerFrontend.h

+11 −8

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/IFrontend.h>
		#include <android/hardware/tv/tuner/1.1/IFrontendCallback.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <utils/Log.h>
		@@ -41,20 +42,21 @@ 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::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;

		using namespace std;

		namespace android {

		class TunerFrontend : public BnTunerFrontend {

		public:
		TunerFrontend(sp<ITuner> tuner, int id);
		TunerFrontend(sp<IFrontend> frontend, int id);
		virtual ~TunerFrontend();
		Status setCallback(
		const std::shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) override;
		const shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) override;
		Status tune(const TunerFrontendSettings& settings) override;
		Status stopTune() override;
		Status scan(const TunerFrontendSettings& settings, int frontendScanType) override;
		@@ -62,12 +64,12 @@ public:
		Status setLnb(int lnbHandle) override;
		Status setLna(bool bEnable) override;
		Status close() override;
		Status getStatus(const std::vector<int32_t>& statusTypes,
		std::vector<TunerFrontendStatus>* _aidl_return) override;
		Status getStatus(const vector<int32_t>& statusTypes,
		vector<TunerFrontendStatus>* _aidl_return) override;
		Status getFrontendId(int* _aidl_return) override;

		struct FrontendCallback : public IFrontendCallback {
		FrontendCallback(const std::shared_ptr<ITunerFrontendCallback> tunerFrontendCallback)
		FrontendCallback(const shared_ptr<ITunerFrontendCallback> tunerFrontendCallback)
		: mTunerFrontendCallback(tunerFrontendCallback) {};

		virtual Return<void> onEvent(FrontendEventType frontendEventType);
		@@ -76,16 +78,17 @@ public:
		virtual Return<void> onScanMessageExt1_1(
		FrontendScanMessageTypeExt1_1 type, const FrontendScanMessageExt1_1& message);

		std::shared_ptr<ITunerFrontendCallback> mTunerFrontendCallback;
		shared_ptr<ITunerFrontendCallback> mTunerFrontendCallback;
		};

		private:
		hidl_vec<FrontendAtsc3PlpSettings> getAtsc3PlpSettings(
		const TunerFrontendAtsc3Settings& settings);
		FrontendDvbsCodeRate getDvbsCodeRate(const TunerFrontendDvbsCodeRate& codeRate);

		int mId;
		sp<ITuner> mTuner;
		sp<IFrontend> mFrontend;
		sp<::android::hardware::tv::tuner::V1_1::IFrontend> mFrontend_1_1;
		};

		} // namespace android

services/tuner/TunerLnb.cpp

0 → 100644

+91 −0

Original line number	Diff line number	Diff line
		/**
		* Copyright 2021, 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.
		*/

		#define LOG_TAG "TunerLnb"

		#include "TunerLnb.h"

		using ::android::hardware::tv::tuner::V1_0::Result;

		namespace android {

		TunerLnb::TunerLnb(sp<ILnb> lnb, int id) {
		mLnb = lnb;
		mId = id;
		}

		TunerLnb::~TunerLnb() {
		mLnb = NULL;
		mId = -1;
		}

		Status TunerLnb::setCallback(
		const shared_ptr<ITunerLnbCallback>& tunerLnbCallback) {
		if (mLnb == NULL) {
		ALOGE("ILnb is not initialized");
		return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
		}

		if (tunerLnbCallback == NULL) {
		return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_ARGUMENT));
		}

		sp<ILnbCallback> lnbCallback = new LnbCallback(tunerLnbCallback);
		Result status = mLnb->setCallback(lnbCallback);
		if (status == Result::SUCCESS) {
		return Status::ok();
		}

		return Status::fromServiceSpecificError(static_cast<int32_t>(status));
		}

		Status TunerLnb::setVoltage(int /voltage/) {
		return Status::ok();
		}

		Status TunerLnb::setTone(int /voltage/) {
		return Status::ok();
		}

		Status TunerLnb::setSatellitePosition(int /position/) {
		return Status::ok();
		}

		Status TunerLnb::sendDiseqcMessage(const vector<uint8_t>& /diseqcMessage/) {
		return Status::ok();
		}

		Status TunerLnb::close() {
		return Status::ok();
		}

		/////////////// ILnbCallback ///////////////////////

		Return<void> TunerLnb::LnbCallback::onEvent(const LnbEventType lnbEventType) {
		if (mTunerLnbCallback != NULL) {
		mTunerLnbCallback->onEvent((int)lnbEventType);
		}
		return Void();
		}

		Return<void> TunerLnb::LnbCallback::onDiseqcMessage(const hidl_vec<uint8_t>& diseqcMessage) {
		if (mTunerLnbCallback != NULL && diseqcMessage != NULL) {
		vector<uint8_t> msg(begin(diseqcMessage), end(diseqcMessage));
		mTunerLnbCallback->onDiseqcMessage(msg);
		}
		return Void();
		}
		} // namespace android

services/tuner/TunerLnb.h

0 → 100644

+69 −0

Original line number	Diff line number	Diff line
		/**
		* Copyright 2021, 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_TUNERFLNB_H
		#define ANDROID_MEDIA_TUNERFLNB_H

		#include <aidl/android/media/tv/tuner/BnTunerLnb.h>
		#include <android/hardware/tv/tuner/1.0/ILnb.h>
		#include <android/hardware/tv/tuner/1.0/ILnbCallback.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <utils/Log.h>

		using Status = ::ndk::ScopedAStatus;
		using ::aidl::android::media::tv::tuner::BnTunerLnb;
		using ::aidl::android::media::tv::tuner::ITunerLnbCallback;
		using ::android::hardware::Return;
		using ::android::hardware::Void;
		using ::android::hardware::hidl_vec;
		using ::android::hardware::tv::tuner::V1_0::ILnb;
		using ::android::hardware::tv::tuner::V1_0::ILnbCallback;
		using ::android::hardware::tv::tuner::V1_0::LnbEventType;

		using namespace std;

		namespace android {

		class TunerLnb : public BnTunerLnb {

		public:
		TunerLnb(sp<ILnb> lnb, int id);
		virtual ~TunerLnb();
		Status setCallback(const shared_ptr<ITunerLnbCallback>& tunerLnbCallback) override;
		Status setVoltage(int voltage) override;
		Status setTone(int voltage) override;
		Status setSatellitePosition(int position) override;
		Status sendDiseqcMessage(const vector<uint8_t>& diseqcMessage) override;
		Status close() override;

		struct LnbCallback : public ILnbCallback {
		LnbCallback(const shared_ptr<ITunerLnbCallback> tunerLnbCallback)
		: mTunerLnbCallback(tunerLnbCallback) {};

		virtual Return<void> onEvent(const LnbEventType lnbEventType);
		virtual Return<void> onDiseqcMessage(const hidl_vec<uint8_t>& diseqcMessage);

		shared_ptr<ITunerLnbCallback> mTunerLnbCallback;
		};

		private:
		int mId;
		sp<ILnb> mLnb;
		};

		} // namespace android

		#endif // ANDROID_MEDIA_TUNERFLNB_H