Default implementation for BroadcastRadio AIDL HAL (b2a6ca68) · Commits · e / os / android_hardware_interfaces

broadcastradio/aidl/default/Android.bp

0 → 100644

+54 −0

Original line number	Diff line number	Diff line
		//
		// Copyright (C) 2022 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.
		//

		package {
		// See: http://go/android-license-faq
		// A large-scale-change added 'default_applicable_licenses' to import
		// all of the 'license_kinds' from "hardware_interfaces_license"
		// to get the below license kinds:
		// SPDX-license-identifier-Apache-2.0
		default_applicable_licenses: ["hardware_interfaces_license"],
		}

		cc_binary {
		name: "android.hardware.broadcastradio-service.default",
		relative_install_path: "hw",
		init_rc: ["broadcastradio-default.rc"],
		vintf_fragments: ["broadcastradio-default.xml"],
		vendor: true,
		cflags: [
		"-Wall",
		"-Wextra",
		"-Werror",
		],
		srcs: [
		"BroadcastRadio.cpp",
		"main.cpp",
		"VirtualProgram.cpp",
		"VirtualRadio.cpp",
		],
		static_libs: [
		"android.hardware.broadcastradio@common-utils-aidl-lib",
		"android.hardware.broadcastradio@common-utils-lib",
		],
		shared_libs: [
		"android.hardware.broadcastradio-V1-ndk",
		"libbase",
		"libbinder_ndk",
		"liblog",
		"libcutils",
		],
		}

broadcastradio/aidl/default/BroadcastRadio.cpp

0 → 100644

+473 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.
		*/

		#include "BroadcastRadio.h"
		#include <broadcastradio-utils-aidl/Utils.h>
		#include "resources.h"

		#include <aidl/android/hardware/broadcastradio/IdentifierType.h>
		#include <aidl/android/hardware/broadcastradio/Result.h>

		#include <android-base/logging.h>

		namespace aidl::android::hardware::broadcastradio {

		using ::aidl::android::hardware::broadcastradio::utils::resultToInt;
		using ::aidl::android::hardware::broadcastradio::utils::tunesTo;
		using ::ndk::ScopedAStatus;
		using ::std::literals::chrono_literals::operator""ms;
		using ::std::literals::chrono_literals::operator""s;
		using ::std::lock_guard;
		using ::std::mutex;
		using ::std::string;
		using ::std::vector;

		namespace {

		inline constexpr std::chrono::milliseconds kSeekDelayTimeMs = 200ms;
		inline constexpr std::chrono::milliseconds kStepDelayTimeMs = 100ms;
		inline constexpr std::chrono::milliseconds kTuneDelayTimeMs = 150ms;
		inline constexpr std::chrono::seconds kListDelayTimeS = 1s;

		// clang-format off
		const AmFmRegionConfig kDefaultAmFmConfig = {
		{
		{87500, 108000, 100, 100}, // FM
		{153, 282, 3, 9}, // AM LW
		{531, 1620, 9, 9}, // AM MW
		{1600, 30000, 1, 5}, // AM SW
		},
		AmFmRegionConfig::DEEMPHASIS_D50,
		AmFmRegionConfig::RDS};
		// clang-format on

		Properties initProperties(const VirtualRadio& virtualRadio) {
		Properties prop = {};

		prop.maker = "Android";
		prop.product = virtualRadio.getName();
		prop.supportedIdentifierTypes = vector<IdentifierType>({
		IdentifierType::AMFM_FREQUENCY_KHZ,
		IdentifierType::RDS_PI,
		IdentifierType::HD_STATION_ID_EXT,
		IdentifierType::DAB_SID_EXT,
		});
		prop.vendorInfo = vector<VendorKeyValue>({
		{"com.android.sample", "sample"},
		});

		return prop;
		}

		// Makes ProgramInfo that does not point to any particular program
		ProgramInfo makeSampleProgramInfo(const ProgramSelector& selector) {
		ProgramInfo info = {};
		info.selector = selector;
		info.logicallyTunedTo =
		utils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ,
		utils::getId(selector, IdentifierType::AMFM_FREQUENCY_KHZ));
		info.physicallyTunedTo = info.logicallyTunedTo;
		return info;
		}

		} // namespace

		BroadcastRadio::BroadcastRadio(const VirtualRadio& virtualRadio)
		: mVirtualRadio(virtualRadio),
		mAmFmConfig(kDefaultAmFmConfig),
		mProperties(initProperties(virtualRadio)) {
		const auto& ranges = kDefaultAmFmConfig.ranges;
		if (ranges.size() > 0) {
		ProgramSelector sel = utils::makeSelectorAmfm(ranges[0].lowerBound);
		VirtualProgram virtualProgram = {};
		if (mVirtualRadio.getProgram(sel, &virtualProgram)) {
		mCurrentProgram = virtualProgram.selector;
		} else {
		mCurrentProgram = sel;
		}
		}
		}

		BroadcastRadio::~BroadcastRadio() {
		mThread.reset();
		}

		ScopedAStatus BroadcastRadio::getAmFmRegionConfig(bool full, AmFmRegionConfig* returnConfigs) {
		if (full) {
		*returnConfigs = {};
		returnConfigs->ranges = vector<AmFmBandRange>({
		{65000, 108000, 10, 0}, // FM
		{150, 30000, 1, 0}, // AM
		});
		returnConfigs->fmDeemphasis =
		AmFmRegionConfig::DEEMPHASIS_D50 \| AmFmRegionConfig::DEEMPHASIS_D75;
		returnConfigs->fmRds = AmFmRegionConfig::RDS \| AmFmRegionConfig::RBDS;
		return ScopedAStatus::ok();
		}
		lock_guard<mutex> lk(mMutex);
		*returnConfigs = mAmFmConfig;
		return ScopedAStatus::ok();
		}

		ScopedAStatus BroadcastRadio::getDabRegionConfig(vector<DabTableEntry>* returnConfigs) {
		*returnConfigs = {
		{"5A", 174928}, {"7D", 194064}, {"8A", 195936}, {"8B", 197648}, {"9A", 202928},
		{"9B", 204640}, {"9C", 206352}, {"10B", 211648}, {"10C", 213360}, {"10D", 215072},
		{"11A", 216928}, {"11B", 218640}, {"11C", 220352}, {"11D", 222064}, {"12A", 223936},
		{"12B", 225648}, {"12C", 227360}, {"12D", 229072},
		};
		return ScopedAStatus::ok();
		}

		ScopedAStatus BroadcastRadio::getImage(int32_t id, vector<uint8_t>* returnImage) {
		LOG(DEBUG) << __func__ << ": fetching image " << std::hex << id;

		if (id == resources::kDemoPngId) {
		*returnImage = vector<uint8_t>(resources::kDemoPng, std::end(resources::kDemoPng));
		return ScopedAStatus::ok();
		}

		LOG(WARNING) << __func__ << ": image of id " << std::hex << id << " doesn't exist";
		*returnImage = {};
		return ScopedAStatus::ok();
		}

		ScopedAStatus BroadcastRadio::getProperties(Properties* returnProperties) {
		lock_guard<mutex> lk(mMutex);
		*returnProperties = mProperties;
		return ScopedAStatus::ok();
		}

		ProgramInfo BroadcastRadio::tuneInternalLocked(const ProgramSelector& sel) {
		LOG(DEBUG) << __func__ << ": tune (internal) to " << sel.toString();

		VirtualProgram virtualProgram = {};
		ProgramInfo programInfo;
		if (mVirtualRadio.getProgram(sel, &virtualProgram)) {
		mCurrentProgram = virtualProgram.selector;
		programInfo = virtualProgram;
		} else {
		mCurrentProgram = sel;
		programInfo = makeSampleProgramInfo(sel);
		}
		mIsTuneCompleted = true;

		return programInfo;
		}

		ScopedAStatus BroadcastRadio::setTunerCallback(const std::shared_ptr<ITunerCallback>& callback) {
		LOG(DEBUG) << __func__ << ": setTunerCallback";

		if (callback == nullptr) {
		return ScopedAStatus::fromServiceSpecificErrorWithMessage(
		resultToInt(Result::INVALID_ARGUMENTS), "cannot set tuner callback to null");
		}

		lock_guard<mutex> lk(mMutex);
		mCallback = callback;

		return ScopedAStatus::ok();
		}

		ScopedAStatus BroadcastRadio::unsetTunerCallback() {
		LOG(DEBUG) << __func__ << ": unsetTunerCallback";

		lock_guard<mutex> lk(mMutex);
		mCallback = nullptr;

		return ScopedAStatus::ok();
		}

		ScopedAStatus BroadcastRadio::tune(const ProgramSelector& program) {
		LOG(DEBUG) << __func__ << ": tune to " << program.toString() << "...";

		lock_guard<mutex> lk(mMutex);
		if (mCallback == nullptr) {
		LOG(ERROR) << __func__ << ": callback is not registered.";
		return ScopedAStatus::fromServiceSpecificErrorWithMessage(
		resultToInt(Result::INVALID_STATE), "callback is not registered");
		}

		if (!utils::isSupported(mProperties, program)) {
		LOG(WARNING) << __func__ << ": selector not supported: " << program.toString();
		return ScopedAStatus::fromServiceSpecificErrorWithMessage(
		resultToInt(Result::NOT_SUPPORTED), "selector is not supported");
		}

		if (!utils::isValid(program)) {
		LOG(ERROR) << __func__ << ": selector is not valid: " << program.toString();
		return ScopedAStatus::fromServiceSpecificErrorWithMessage(
		resultToInt(Result::INVALID_ARGUMENTS), "selector is not valid");
		}

		cancelLocked();

		mIsTuneCompleted = false;
		std::shared_ptr<ITunerCallback> callback = mCallback;
		auto task = [this, program, callback]() {
		ProgramInfo programInfo = {};
		{
		lock_guard<mutex> lk(mMutex);
		programInfo = tuneInternalLocked(program);
		}
		callback->onCurrentProgramInfoChanged(programInfo);
		};
		mThread->schedule(task, kTuneDelayTimeMs);

		return ScopedAStatus::ok();
		}

		ScopedAStatus BroadcastRadio::seek(bool directionUp, bool skipSubChannel) {
		LOG(DEBUG) << __func__ << ": seek " << (directionUp ? "up" : "down") << " with skipSubChannel? "
		<< (skipSubChannel ? "yes" : "no") << "...";

		lock_guard<mutex> lk(mMutex);
		if (mCallback == nullptr) {
		LOG(ERROR) << __func__ << ": callback is not registered.";
		return ScopedAStatus::fromServiceSpecificErrorWithMessage(
		resultToInt(Result::INVALID_STATE), "callback is not registered");
		}

		cancelLocked();

		const auto& list = mVirtualRadio.getProgramList();
		std::shared_ptr<ITunerCallback> callback = mCallback;
		if (list.empty()) {
		mIsTuneCompleted = false;
		auto task = [callback]() {
		LOG(DEBUG) << "seek: program list is empty, seek couldn't stop";

		callback->onTuneFailed(Result::TIMEOUT, {});
		};
		mThread->schedule(task, kSeekDelayTimeMs);

		return ScopedAStatus::ok();
		}

		// The list is not sorted here since it has already stored in VirtualRadio.
		// If the list is not sorted in advance, it should be sorted here.
		const auto& current = mCurrentProgram;
		auto found = std::lower_bound(list.begin(), list.end(), VirtualProgram({current}));
		if (directionUp) {
		if (found < list.end() - 1) {
		if (tunesTo(current, found->selector)) found++;
		} else {
		found = list.begin();
		}
		} else {
		if (found > list.begin() && found != list.end()) {
		found--;
		} else {
		found = list.end() - 1;
		}
		}
		const ProgramSelector tuneTo = found->selector;

		mIsTuneCompleted = false;
		auto task = [this, tuneTo, callback]() {
		ProgramInfo programInfo = {};
		{
		lock_guard<mutex> lk(mMutex);
		programInfo = tuneInternalLocked(tuneTo);
		}
		callback->onCurrentProgramInfoChanged(programInfo);
		};
		mThread->schedule(task, kSeekDelayTimeMs);

		return ScopedAStatus::ok();
		}

		ScopedAStatus BroadcastRadio::step(bool directionUp) {
		LOG(DEBUG) << __func__ << ": step " << (directionUp ? "up" : "down") << "...";

		lock_guard<mutex> lk(mMutex);
		if (mCallback == nullptr) {
		LOG(ERROR) << __func__ << ": callback is not registered.";
		return ScopedAStatus::fromServiceSpecificErrorWithMessage(
		resultToInt(Result::INVALID_STATE), "callback is not registered");
		}

		cancelLocked();

		if (!utils::hasId(mCurrentProgram, IdentifierType::AMFM_FREQUENCY_KHZ)) {
		LOG(WARNING) << __func__ << ": can't step in anything else than AM/FM";
		return ScopedAStatus::fromServiceSpecificErrorWithMessage(
		resultToInt(Result::NOT_SUPPORTED), "cannot step in anything else than AM/FM");
		}

		int64_t stepTo = utils::getId(mCurrentProgram, IdentifierType::AMFM_FREQUENCY_KHZ);
		std::optional<AmFmBandRange> range = getAmFmRangeLocked();
		if (!range) {
		LOG(ERROR) << __func__ << ": can't find current band or tune operation is in process";
		ScopedAStatus::fromServiceSpecificErrorWithMessage(
		resultToInt(Result::INTERNAL_ERROR),
		"can't find current band or tune operation is in process");
		}

		if (directionUp) {
		stepTo += range->spacing;
		} else {
		stepTo -= range->spacing;
		}
		if (stepTo > range->upperBound) {
		stepTo = range->lowerBound;
		}
		if (stepTo < range->lowerBound) {
		stepTo = range->upperBound;
		}

		mIsTuneCompleted = false;
		std::shared_ptr<ITunerCallback> callback = mCallback;
		auto task = [this, stepTo, callback]() {
		ProgramInfo programInfo;
		{
		lock_guard<mutex> lk(mMutex);
		programInfo = tuneInternalLocked(utils::makeSelectorAmfm(stepTo));
		}
		callback->onCurrentProgramInfoChanged(programInfo);
		};
		mThread->schedule(task, kStepDelayTimeMs);

		return ScopedAStatus::ok();
		}

		void BroadcastRadio::cancelLocked() {
		LOG(DEBUG) << __func__ << ": cancelling current operations...";

		mThread->cancelAll();
		if (mCurrentProgram.primaryId.type != IdentifierType::INVALID) {
		mIsTuneCompleted = true;
		}
		}

		ScopedAStatus BroadcastRadio::cancel() {
		LOG(DEBUG) << __func__ << ": cancel pending tune, seek and step...";

		lock_guard<mutex> lk(mMutex);
		cancelLocked();

		return ScopedAStatus::ok();
		}

		ScopedAStatus BroadcastRadio::startProgramListUpdates(const ProgramFilter& filter) {
		LOG(DEBUG) << __func__ << ": requested program list updates, filter = " << filter.toString()
		<< "...";

		auto filterCb = [&filter](const VirtualProgram& program) {
		return utils::satisfies(filter, program.selector);
		};

		lock_guard<mutex> lk(mMutex);

		const auto& list = mVirtualRadio.getProgramList();
		vector<VirtualProgram> filteredList;
		std::copy_if(list.begin(), list.end(), std::back_inserter(filteredList), filterCb);

		auto task = [this, filteredList]() {
		std::shared_ptr<ITunerCallback> callback;
		{
		lock_guard<mutex> lk(mMutex);
		if (mCallback == nullptr) {
		LOG(WARNING) << "Callback is null when updating program List";
		return;
		}
		callback = mCallback;
		}

		ProgramListChunk chunk = {};
		chunk.purge = true;
		chunk.complete = true;
		chunk.modified = vector<ProgramInfo>(filteredList.begin(), filteredList.end());

		callback->onProgramListUpdated(chunk);
		};
		mThread->schedule(task, kListDelayTimeS);

		return ScopedAStatus::ok();
		}

		ScopedAStatus BroadcastRadio::stopProgramListUpdates() {
		LOG(DEBUG) << __func__ << ": requested program list updates to stop...";
		// TODO(b/243681584) Implement stop program list updates method
		return ScopedAStatus::ok();
		}

		ScopedAStatus BroadcastRadio::isConfigFlagSet(ConfigFlag flag, [[maybe_unused]] bool* returnIsSet) {
		LOG(DEBUG) << __func__ << ": flag = " << toString(flag);

		LOG(INFO) << __func__ << ": getting ConfigFlag is not supported";
		return ScopedAStatus::fromServiceSpecificErrorWithMessage(
		resultToInt(Result::NOT_SUPPORTED), "getting ConfigFlag is not supported");
		}

		ScopedAStatus BroadcastRadio::setConfigFlag(ConfigFlag flag, bool value) {
		LOG(DEBUG) << __func__ << ": flag = " << toString(flag) << ", value = " << value;

		LOG(INFO) << __func__ << ": setting ConfigFlag is not supported";
		return ScopedAStatus::fromServiceSpecificErrorWithMessage(
		resultToInt(Result::NOT_SUPPORTED), "setting ConfigFlag is not supported");
		}

		ScopedAStatus BroadcastRadio::setParameters(
		[[maybe_unused]] const vector<VendorKeyValue>& parameters,
		vector<VendorKeyValue>* returnParameters) {
		// TODO(b/243682330) Support vendor parameter functionality
		*returnParameters = {};
		return ScopedAStatus::ok();
		}

		ScopedAStatus BroadcastRadio::getParameters([[maybe_unused]] const vector<string>& keys,
		vector<VendorKeyValue>* returnParameters) {
		// TODO(b/243682330) Support vendor parameter functionality
		*returnParameters = {};
		return ScopedAStatus::ok();
		}

		std::optional<AmFmBandRange> BroadcastRadio::getAmFmRangeLocked() const {
		if (!mIsTuneCompleted) {
		LOG(WARNING) << __func__ << ": tune operation is in process";
		return {};
		}
		if (!utils::hasId(mCurrentProgram, IdentifierType::AMFM_FREQUENCY_KHZ)) {
		LOG(WARNING) << __func__ << ": current program does not has AMFM_FREQUENCY_KHZ identifier";
		return {};
		}

		int64_t freq = utils::getId(mCurrentProgram, IdentifierType::AMFM_FREQUENCY_KHZ);
		for (const auto& range : mAmFmConfig.ranges) {
		if (range.lowerBound <= freq && range.upperBound >= freq) {
		return range;
		}
		}

		return {};
		}

		ScopedAStatus BroadcastRadio::registerAnnouncementListener(
		[[maybe_unused]] const std::shared_ptr<IAnnouncementListener>& listener,
		const vector<AnnouncementType>& enabled, std::shared_ptr<ICloseHandle>* returnCloseHandle) {
		LOG(DEBUG) << __func__ << ": registering announcement listener for "
		<< utils::vectorToString(enabled);

		// TODO(b/243683842) Support announcement listener
		*returnCloseHandle = nullptr;
		LOG(INFO) << __func__ << ": registering announcementListener is not supported";
		return ScopedAStatus::fromServiceSpecificErrorWithMessage(
		resultToInt(Result::NOT_SUPPORTED),
		"registering announcementListener is not supported");
		}

		} // namespace aidl::android::hardware::broadcastradio

broadcastradio/aidl/default/BroadcastRadio.h

0 → 100644

+82 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.
		*/

		#pragma once

		#include "VirtualRadio.h"

		#include <aidl/android/hardware/broadcastradio/AmFmBandRange.h>
		#include <aidl/android/hardware/broadcastradio/AmFmRegionConfig.h>
		#include <aidl/android/hardware/broadcastradio/AnnouncementType.h>
		#include <aidl/android/hardware/broadcastradio/BnBroadcastRadio.h>
		#include <aidl/android/hardware/broadcastradio/DabTableEntry.h>
		#include <aidl/android/hardware/broadcastradio/IAnnouncementListener.h>
		#include <aidl/android/hardware/broadcastradio/ICloseHandle.h>
		#include <aidl/android/hardware/broadcastradio/ITunerCallback.h>
		#include <aidl/android/hardware/broadcastradio/Properties.h>
		#include <broadcastradio-utils/WorkerThread.h>

		#include <android-base/thread_annotations.h>

		#include <optional>

		namespace aidl::android::hardware::broadcastradio {

		class BroadcastRadio final : public BnBroadcastRadio {
		public:
		explicit BroadcastRadio(const VirtualRadio& virtualRadio);
		~BroadcastRadio();
		ndk::ScopedAStatus getAmFmRegionConfig(bool full, AmFmRegionConfig* returnConfigs) override;
		ndk::ScopedAStatus getDabRegionConfig(std::vector<DabTableEntry>* returnConfigs) override;
		ndk::ScopedAStatus getImage(int32_t id, std::vector<uint8_t>* returnImage) override;
		ndk::ScopedAStatus getProperties(Properties* returnProperties) override;

		ndk::ScopedAStatus setTunerCallback(const std::shared_ptr<ITunerCallback>& callback) override;
		ndk::ScopedAStatus unsetTunerCallback() override;
		ndk::ScopedAStatus tune(const ProgramSelector& program) override;
		ndk::ScopedAStatus seek(bool directionUp, bool skipSubChannel) override;
		ndk::ScopedAStatus step(bool directionUp) override;
		ndk::ScopedAStatus cancel() override;
		ndk::ScopedAStatus startProgramListUpdates(const ProgramFilter& filter) override;
		ndk::ScopedAStatus stopProgramListUpdates() override;
		ndk::ScopedAStatus isConfigFlagSet(ConfigFlag flag, bool* returnIsSet) override;
		ndk::ScopedAStatus setConfigFlag(ConfigFlag flag, bool in_value) override;
		ndk::ScopedAStatus setParameters(const std::vector<VendorKeyValue>& parameters,
		std::vector<VendorKeyValue>* returnParameters) override;
		ndk::ScopedAStatus getParameters(const std::vector<std::string>& keys,
		std::vector<VendorKeyValue>* returnParameters) override;
		ndk::ScopedAStatus registerAnnouncementListener(
		const std::shared_ptr<IAnnouncementListener>& listener,
		const std::vector<AnnouncementType>& enabled,
		std::shared_ptr<ICloseHandle>* returnCloseHandle) override;

		private:
		const VirtualRadio& mVirtualRadio;
		std::mutex mMutex;
		AmFmRegionConfig mAmFmConfig GUARDED_BY(mMutex);
		std::unique_ptr<::android::WorkerThread> mThread GUARDED_BY(mMutex) =
		std::unique_ptr<::android::WorkerThread>(new ::android::WorkerThread());
		bool mIsTuneCompleted GUARDED_BY(mMutex) = true;
		Properties mProperties GUARDED_BY(mMutex);
		ProgramSelector mCurrentProgram GUARDED_BY(mMutex) = {};
		std::shared_ptr<ITunerCallback> mCallback GUARDED_BY(mMutex);

		std::optional<AmFmBandRange> getAmFmRangeLocked() const;
		void cancelLocked();
		ProgramInfo tuneInternalLocked(const ProgramSelector& sel);
		};

		} // namespace aidl::android::hardware::broadcastradio

broadcastradio/aidl/default/VirtualProgram.cpp

0 → 100644

+100 −0

File added.

Preview size limit exceeded, changes collapsed.

broadcastradio/aidl/default/VirtualProgram.h

0 → 100644

+51 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.
		*/

		#pragma once

		#include <aidl/android/hardware/broadcastradio/IdentifierType.h>
		#include <aidl/android/hardware/broadcastradio/ProgramInfo.h>
		#include <aidl/android/hardware/broadcastradio/ProgramSelector.h>

		namespace aidl::android::hardware::broadcastradio {

		constexpr int kSignalQualityDigital = 100;
		constexpr int kSignalQualityNonDigital = 80;
		/**
		* A radio program mock.
		*
		* This represents broadcast waves flying over the air,
		* not an entry for a captured station in the radio tuner memory.
		*/
		struct VirtualProgram {
		ProgramSelector selector;

		std::string programName = "";
		std::string songArtist = "";
		std::string songTitle = "";

		operator ProgramInfo() const;

		/**
		* Defines order in which virtual programs appear on the "air" with
		* ITunerSession::scan().
		*
		* It's for default implementation purposes, may not be complete or correct.
		*/
		friend bool operator<(const VirtualProgram& lhs, const VirtualProgram& rhs);
		};

		} // namespace aidl::android::hardware::broadcastradio