Merge "Add format check utils method for bcradio metadata" into main (2e0cae4d) · Commits · e / os / android_hardware_interfaces

broadcastradio/common/utilsaidl/include/broadcastradio-utils-aidl/Utils.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -143,6 +143,8 @@ ProgramSelector makeSelectorHd(uint64_t stationId, uint64_t subChannel, uint64_t

		bool satisfies(const ProgramFilter& filter, const ProgramSelector& sel);

		bool isValidMetadata(const Metadata& metadata);

		struct ProgramSelectorComparator {
		bool operator()(const ProgramSelector& lhs, const ProgramSelector& rhs) const;
		};

broadcastradio/common/utilsaidl/include/broadcastradio-utils-aidl/UtilsV2.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -28,6 +28,7 @@ namespace utils {

		bool isValidV2(const ProgramIdentifier& id);
		bool isValidV2(const ProgramSelector& sel);
		bool isValidMetadataV2(const Metadata& metadata);
		std::optional<std::string> getMetadataStringV2(const ProgramInfo& info, const Metadata::Tag& tag);

		} // namespace utils

broadcastradio/common/utilsaidl/src/Utils.cpp

+41 −2

Original line number	Diff line number	Diff line
		@@ -442,9 +442,9 @@ void updateProgramList(const ProgramListChunk& chunk, ProgramInfoSet* list) {
		}

		std::optional<std::string> getMetadataString(const ProgramInfo& info, const Metadata::Tag& tag) {
		auto isRdsPs = [tag](const Metadata& item) { return item.getTag() == tag; };
		auto hasMetadataType = [tag](const Metadata& item) { return item.getTag() == tag; };

		auto it = std::find_if(info.metadata.begin(), info.metadata.end(), isRdsPs);
		auto it = std::find_if(info.metadata.begin(), info.metadata.end(), hasMetadataType);
		if (it == info.metadata.end()) {
		return std::nullopt;
		}
		@@ -579,6 +579,45 @@ uint32_t getAmFmFrequency(const ProgramSelector& sel) {
		return getHdFrequency(sel);
		}

		bool isValidMetadata(const Metadata& metadata) {
		bool valid = true;

		auto expect = [&valid](bool condition, const std::string& message) {
		if (!condition) {
		valid = false;
		LOG(ERROR) << "metadata not valid, expected " << message;
		}
		};

		switch (metadata.getTag()) {
		case Metadata::rdsPty:
		expect(metadata.get<Metadata::rdsPty>() >= 0, "RDS PTY >= 0");
		expect(metadata.get<Metadata::rdsPty>() <= std::numeric_limits<uint8_t>::max(),
		"8bit RDS PTY");
		break;
		case Metadata::rbdsPty:
		expect(metadata.get<Metadata::rbdsPty>() >= 0, "RBDS PTY >= 0");
		expect(metadata.get<Metadata::rbdsPty>() <= std::numeric_limits<uint8_t>::max(),
		"8bit RBDS PTY");
		break;
		case Metadata::dabEnsembleNameShort:
		expect(metadata.get<Metadata::dabEnsembleNameShort>().size() <= 8,
		"Dab ensemble name abbreviated length <= 8");
		break;
		case Metadata::dabServiceNameShort:
		expect(metadata.get<Metadata::dabServiceNameShort>().size() <= 8,
		"Dab component name abbreviated length <= 8");
		break;
		case Metadata::dabComponentNameShort:
		expect(metadata.get<Metadata::dabComponentNameShort>().size() <= 8,
		"Dab component name abbreviated length <= 8");
		break;
		default:
		break;
		}
		return valid;
		}

		bool parseArgInt(const std::string& s, int* out) {
		return ::android::base::ParseInt(s, out);
		}

broadcastradio/common/utilsaidl/src/UtilsV2.cpp

+26 −2

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@
		#define LOG_TAG "BcRadioAidlDef.utilsV2"

		#include "broadcastradio-utils-aidl/UtilsV2.h"
		#include "broadcastradio-utils-aidl/Utils.h"

		#include <android-base/logging.h>
		#include <android-base/strings.h>
		@@ -137,10 +138,33 @@ bool isValidV2(const ProgramSelector& sel) {
		return isValidV2(sel.primaryId);
		}

		bool isValidMetadataV2(const Metadata& metadata) {
		if (!isValidMetadata(metadata)) {
		return false;
		}

		if (metadata.getTag() == Metadata::hdStationNameShort) {
		if (metadata.get<Metadata::hdStationNameShort>().size() > 12) {
		LOG(ERROR) << "metadata not valid, expected HD short name length <= 12";
		return false;
		}
		} else if (metadata.getTag() == Metadata::hdSubChannelsAvailable) {
		if (metadata.get<Metadata::hdSubChannelsAvailable>() < 0) {
		LOG(ERROR) << "metadata not valid, expected HD subchannels available >= 0";
		return false;
		} else if (metadata.get<Metadata::hdSubChannelsAvailable>() >
		std::numeric_limits<uint8_t>::max()) {
		LOG(ERROR) << "metadata not valid, expected 8bit HD subchannels available";
		return false;
		}
		}
		return true;
		}

		std::optional<std::string> getMetadataStringV2(const ProgramInfo& info, const Metadata::Tag& tag) {
		auto isRdsPs = [tag](const Metadata& item) { return item.getTag() == tag; };
		auto hasMetadataType = [tag](const Metadata& item) { return item.getTag() == tag; };

		auto it = std::find_if(info.metadata.begin(), info.metadata.end(), isRdsPs);
		auto it = std::find_if(info.metadata.begin(), info.metadata.end(), hasMetadataType);
		if (it == info.metadata.end()) {
		return std::nullopt;
		}

broadcastradio/common/utilsaidl/test/BroadcastRadioUtilsTest.cpp

+67 −0

Original line number	Diff line number	Diff line
		@@ -32,8 +32,75 @@ constexpr uint64_t kDabFrequencyKhz = 225648u;
		constexpr uint64_t kHdStationId = 0xA0000001u;
		constexpr uint64_t kHdSubChannel = 1u;
		constexpr uint64_t kHdFrequency = 97700u;

		struct IsValidMetadataTestCase {
		std::string name;
		Metadata metadata;
		bool valid;
		};

		std::vector<IsValidMetadataTestCase> getIsValidMetadataTestCases() {
		return std::vector<IsValidMetadataTestCase>({
		IsValidMetadataTestCase{.name = "valid_rds_pty",
		.metadata = Metadata::make<Metadata::rdsPty>(1),
		.valid = true},
		IsValidMetadataTestCase{.name = "negative_rds_pty",
		.metadata = Metadata::make<Metadata::rdsPty>(-1),
		.valid = false},
		IsValidMetadataTestCase{.name = "large_rds_pty",
		.metadata = Metadata::make<Metadata::rdsPty>(256),
		.valid = false},
		IsValidMetadataTestCase{.name = "valid_rbds_pty",
		.metadata = Metadata::make<Metadata::rbdsPty>(1),
		.valid = true},
		IsValidMetadataTestCase{.name = "negative_rbds_pty",
		.metadata = Metadata::make<Metadata::rbdsPty>(-1),
		.valid = false},
		IsValidMetadataTestCase{.name = "large_rbds_pty",
		.metadata = Metadata::make<Metadata::rbdsPty>(256),
		.valid = false},
		IsValidMetadataTestCase{
		.name = "valid_dab_ensemble_name_short",
		.metadata = Metadata::make<Metadata::dabEnsembleNameShort>("name"),
		.valid = true},
		IsValidMetadataTestCase{
		.name = "too_long_dab_ensemble_name_short",
		.metadata = Metadata::make<Metadata::dabEnsembleNameShort>("name_long"),
		.valid = false},
		IsValidMetadataTestCase{
		.name = "valid_dab_service_name_short",
		.metadata = Metadata::make<Metadata::dabServiceNameShort>("name"),
		.valid = true},
		IsValidMetadataTestCase{
		.name = "too_long_dab_service_name_short",
		.metadata = Metadata::make<Metadata::dabServiceNameShort>("name_long"),
		.valid = false},
		IsValidMetadataTestCase{
		.name = "valid_dab_component_name_short",
		.metadata = Metadata::make<Metadata::dabComponentNameShort>("name"),
		.valid = true},
		IsValidMetadataTestCase{
		.name = "too_long_dab_component_name_short",
		.metadata = Metadata::make<Metadata::dabComponentNameShort>("name_long"),
		.valid = false},
		});
		}
		} // namespace

		class IsValidMetadataTest : public testing::TestWithParam<IsValidMetadataTestCase> {};

		INSTANTIATE_TEST_SUITE_P(IsValidMetadataTests, IsValidMetadataTest,
		testing::ValuesIn(getIsValidMetadataTestCases()),
		[](const testing::TestParamInfo<IsValidMetadataTest::ParamType>& info) {
		return info.param.name;
		});

		TEST_P(IsValidMetadataTest, IsValidMetadata) {
		IsValidMetadataTestCase testParam = GetParam();

		ASSERT_EQ(utils::isValidMetadata(testParam.metadata), testParam.valid);
		}

		TEST(BroadcastRadioUtilsTest, HasIdWithPrimaryIdType) {
		ProgramSelector sel = utils::makeSelectorAmfm(kFmFrequencyKHz);