Refactor utils and VTS for HD radio HAL support
Refactored AIDL broadcast radio HAL utils library to both support
version 2 HAL and guarantee backward compatibility for version 1 HAL
implementation using version 1 utils lib. Updated VTS to support HAL
of both AIDL versions.
Bug: 280300929
Test: atest VtsHalBroadcastradioAidlTargetTest
Change-Id: I31e631c794f51c8df230b984837dfb4299864e5c
diff --git a/broadcastradio/aidl/vts/Android.bp b/broadcastradio/aidl/vts/Android.bp
index b60387e..87e48a9 100644
--- a/broadcastradio/aidl/vts/Android.bp
+++ b/broadcastradio/aidl/vts/Android.bp
@@ -35,8 +35,8 @@
"libxml2",
],
static_libs: [
- "android.hardware.broadcastradio-V1-ndk",
- "android.hardware.broadcastradio@common-utils-aidl-lib",
+ "android.hardware.broadcastradio-V2-ndk",
+ "android.hardware.broadcastradio@common-utils-aidl-lib-V2",
"android.hardware.broadcastradio@vts-utils-lib",
"libgmock",
],
diff --git a/broadcastradio/aidl/vts/src/VtsHalBroadcastradioAidlTargetTest.cpp b/broadcastradio/aidl/vts/src/VtsHalBroadcastradioAidlTargetTest.cpp
index 790d60b..72869cc 100644
--- a/broadcastradio/aidl/vts/src/VtsHalBroadcastradioAidlTargetTest.cpp
+++ b/broadcastradio/aidl/vts/src/VtsHalBroadcastradioAidlTargetTest.cpp
@@ -32,6 +32,7 @@
#include <aidl/Gtest.h>
#include <aidl/Vintf.h>
#include <broadcastradio-utils-aidl/Utils.h>
+#include <broadcastradio-utils-aidl/UtilsV2.h>
#include <cutils/bitops.h>
#include <gmock/gmock.h>
@@ -50,7 +51,6 @@
using ::aidl::android::hardware::broadcastradio::utils::resultToInt;
using ::ndk::ScopedAStatus;
using ::ndk::SharedRefBase;
-using ::std::string;
using ::std::vector;
using ::testing::_;
using ::testing::AnyNumber;
@@ -73,20 +73,29 @@
ConfigFlag::DAB_FM_SOFT_LINKING,
};
-void printSkipped(const string& msg) {
+constexpr int32_t kAidlVersion1 = 1;
+constexpr int32_t kAidlVersion2 = 2;
+
+void printSkipped(const std::string& msg) {
const auto testInfo = testing::UnitTest::GetInstance()->current_test_info();
LOG(INFO) << "[ SKIPPED ] " << testInfo->test_case_name() << "." << testInfo->name()
<< " with message: " << msg;
}
-bool isValidAmFmFreq(int64_t freq) {
+bool isValidAmFmFreq(int64_t freq, int aidlVersion) {
ProgramIdentifier id = bcutils::makeIdentifier(IdentifierType::AMFM_FREQUENCY_KHZ, freq);
- return bcutils::isValid(id);
+ if (aidlVersion == kAidlVersion1) {
+ return bcutils::isValid(id);
+ } else if (aidlVersion == kAidlVersion2) {
+ return bcutils::isValidV2(id);
+ }
+ LOG(ERROR) << "Unknown AIDL version " << aidlVersion;
+ return false;
}
-void validateRange(const AmFmBandRange& range) {
- EXPECT_TRUE(isValidAmFmFreq(range.lowerBound));
- EXPECT_TRUE(isValidAmFmFreq(range.upperBound));
+void validateRange(const AmFmBandRange& range, int aidlVersion) {
+ EXPECT_TRUE(isValidAmFmFreq(range.lowerBound, aidlVersion));
+ EXPECT_TRUE(isValidAmFmFreq(range.upperBound, aidlVersion));
EXPECT_LT(range.lowerBound, range.upperBound);
EXPECT_GT(range.spacing, 0u);
EXPECT_EQ((range.upperBound - range.lowerBound) % range.spacing, 0u);
@@ -142,7 +151,7 @@
class TunerCallbackImpl final : public BnTunerCallback {
public:
- TunerCallbackImpl();
+ explicit TunerCallbackImpl(int32_t aidlVersion);
ScopedAStatus onTuneFailed(Result result, const ProgramSelector& selector) override;
ScopedAStatus onCurrentProgramInfoChanged(const ProgramInfo& info) override;
ScopedAStatus onProgramListUpdated(const ProgramListChunk& chunk) override;
@@ -160,6 +169,7 @@
private:
std::mutex mLock;
+ int32_t mCallbackAidlVersion;
bool mAntennaConnectionState GUARDED_BY(mLock);
ProgramInfo mCurrentProgramInfo GUARDED_BY(mLock);
bcutils::ProgramInfoSet mProgramList GUARDED_BY(mLock);
@@ -171,7 +181,7 @@
MOCK_METHOD1(onListUpdated, ScopedAStatus(const vector<Announcement>&));
};
-class BroadcastRadioHalTest : public testing::TestWithParam<string> {
+class BroadcastRadioHalTest : public testing::TestWithParam<std::string> {
protected:
void SetUp() override;
void TearDown() override;
@@ -183,14 +193,17 @@
std::shared_ptr<IBroadcastRadio> mModule;
Properties mProperties;
std::shared_ptr<TunerCallbackImpl> mCallback;
+ int32_t mAidlVersion;
};
-MATCHER_P(InfoHasId, id, string(negation ? "does not contain" : "contains") + " " + id.toString()) {
+MATCHER_P(InfoHasId, id,
+ std::string(negation ? "does not contain" : "contains") + " " + id.toString()) {
vector<int> ids = bcutils::getAllIds(arg.selector, id.type);
return ids.end() != find(ids.begin(), ids.end(), id.value);
}
-TunerCallbackImpl::TunerCallbackImpl() {
+TunerCallbackImpl::TunerCallbackImpl(int32_t aidlVersion) {
+ mCallbackAidlVersion = aidlVersion;
mAntennaConnectionState = true;
}
@@ -230,7 +243,12 @@
physically > IdentifierType::SXM_CHANNEL);
if (logically == IdentifierType::AMFM_FREQUENCY_KHZ) {
- std::optional<string> ps = bcutils::getMetadataString(info, Metadata::rdsPs);
+ std::optional<std::string> ps;
+ if (mCallbackAidlVersion == kAidlVersion1) {
+ ps = bcutils::getMetadataString(info, Metadata::rdsPs);
+ } else {
+ ps = bcutils::getMetadataStringV2(info, Metadata::rdsPs);
+ }
if (ps.has_value()) {
EXPECT_NE(::android::base::Trim(*ps), "")
<< "Don't use empty RDS_PS as an indicator of missing RSD PS data.";
@@ -323,9 +341,13 @@
EXPECT_FALSE(mProperties.product.empty());
EXPECT_GT(mProperties.supportedIdentifierTypes.size(), 0u);
- mCallback = SharedRefBase::make<TunerCallbackImpl>();
+ // get AIDL HAL version
+ ASSERT_TRUE(mModule->getInterfaceVersion(&mAidlVersion).isOk());
+ EXPECT_GE(mAidlVersion, kAidlVersion1);
+ EXPECT_LE(mAidlVersion, kAidlVersion2);
// set callback
+ mCallback = SharedRefBase::make<TunerCallbackImpl>(mAidlVersion);
EXPECT_TRUE(mModule->setTunerCallback(mCallback).isOk());
}
@@ -443,7 +465,7 @@
EXPECT_GT(config.ranges.size(), 0u);
for (const auto& range : config.ranges) {
- validateRange(range);
+ validateRange(range, mAidlVersion);
EXPECT_EQ(range.seekSpacing % range.spacing, 0u);
EXPECT_GE(range.seekSpacing, range.spacing);
}
@@ -494,7 +516,7 @@
EXPECT_GT(config.ranges.size(), 0u);
for (const auto& range : config.ranges) {
- validateRange(range);
+ validateRange(range, mAidlVersion);
EXPECT_EQ(range.seekSpacing, 0u);
}
}
@@ -522,11 +544,17 @@
std::regex re("^[A-Z0-9][A-Z0-9 ]{0,5}[A-Z0-9]$");
for (const auto& entry : config) {
- EXPECT_TRUE(std::regex_match(string(entry.label), re));
+ EXPECT_TRUE(std::regex_match(std::string(entry.label), re));
ProgramIdentifier id =
bcutils::makeIdentifier(IdentifierType::DAB_FREQUENCY_KHZ, entry.frequencyKhz);
- EXPECT_TRUE(bcutils::isValid(id));
+ if (mAidlVersion == kAidlVersion1) {
+ EXPECT_TRUE(bcutils::isValid(id));
+ } else if (mAidlVersion == kAidlVersion2) {
+ EXPECT_TRUE(bcutils::isValidV2(id));
+ } else {
+ LOG(ERROR) << "Unknown callback AIDL version " << mAidlVersion;
+ }
}
}
@@ -1175,10 +1203,21 @@
continue;
}
- std::optional<string> name = bcutils::getMetadataString(program, Metadata::programName);
- if (!name) {
- name = bcutils::getMetadataString(program, Metadata::rdsPs);
+ std::optional<std::string> name;
+ if (mAidlVersion == kAidlVersion1) {
+ name = bcutils::getMetadataString(program, Metadata::programName);
+ if (!name) {
+ name = bcutils::getMetadataString(program, Metadata::rdsPs);
+ }
+ } else if (mAidlVersion == kAidlVersion2) {
+ name = bcutils::getMetadataStringV2(program, Metadata::programName);
+ if (!name) {
+ name = bcutils::getMetadataStringV2(program, Metadata::rdsPs);
+ }
+ } else {
+ LOG(ERROR) << "Unknown HAL AIDL version " << mAidlVersion;
}
+
ASSERT_TRUE(name.has_value());
ProgramIdentifier expectedId = bcutils::makeHdRadioStationName(*name);
diff --git a/broadcastradio/common/utilsaidl/Android.bp b/broadcastradio/common/utilsaidl/Android.bp
index fa6de19..4ec635b 100644
--- a/broadcastradio/common/utilsaidl/Android.bp
+++ b/broadcastradio/common/utilsaidl/Android.bp
@@ -25,6 +25,29 @@
cc_library_static {
name: "android.hardware.broadcastradio@common-utils-aidl-lib",
+ defaults: [
+ "VtsBroadcastRadioDefaults",
+ ],
+ shared_libs: [
+ "android.hardware.broadcastradio-V1-ndk",
+ ],
+}
+
+cc_library_static {
+ name: "android.hardware.broadcastradio@common-utils-aidl-lib-V2",
+ defaults: [
+ "VtsBroadcastRadioDefaults",
+ ],
+ srcs: [
+ "src/UtilsV2.cpp",
+ ],
+ shared_libs: [
+ "android.hardware.broadcastradio-V2-ndk",
+ ],
+}
+
+cc_defaults {
+ name: "VtsBroadcastRadioDefaults",
vendor_available: true,
relative_install_path: "hw",
cflags: [
@@ -37,11 +60,10 @@
"-std=c++1z",
],
srcs: [
- "Utils.cpp",
+ "src/Utils.cpp",
],
export_include_dirs: ["include"],
shared_libs: [
- "android.hardware.broadcastradio-V1-ndk",
"libbase",
],
static_libs: [
diff --git a/broadcastradio/common/utilsaidl/include/broadcastradio-utils-aidl/Utils.h b/broadcastradio/common/utilsaidl/include/broadcastradio-utils-aidl/Utils.h
index ee85a17..b6fb33f 100644
--- a/broadcastradio/common/utilsaidl/include/broadcastradio-utils-aidl/Utils.h
+++ b/broadcastradio/common/utilsaidl/include/broadcastradio-utils-aidl/Utils.h
@@ -17,7 +17,6 @@
#pragma once
#include <aidl/android/hardware/broadcastradio/IdentifierType.h>
-#include <aidl/android/hardware/broadcastradio/Metadata.h>
#include <aidl/android/hardware/broadcastradio/ProgramFilter.h>
#include <aidl/android/hardware/broadcastradio/ProgramIdentifier.h>
#include <aidl/android/hardware/broadcastradio/ProgramInfo.h>
diff --git a/broadcastradio/common/utilsaidl/include/broadcastradio-utils-aidl/UtilsV2.h b/broadcastradio/common/utilsaidl/include/broadcastradio-utils-aidl/UtilsV2.h
new file mode 100644
index 0000000..e411aa4
--- /dev/null
+++ b/broadcastradio/common/utilsaidl/include/broadcastradio-utils-aidl/UtilsV2.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2023 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/Metadata.h>
+#include <aidl/android/hardware/broadcastradio/ProgramIdentifier.h>
+#include <aidl/android/hardware/broadcastradio/ProgramInfo.h>
+#include <aidl/android/hardware/broadcastradio/ProgramSelector.h>
+
+namespace aidl::android::hardware::broadcastradio {
+
+namespace utils {
+
+bool isValidV2(const ProgramIdentifier& id);
+bool isValidV2(const ProgramSelector& sel);
+std::optional<std::string> getMetadataStringV2(const ProgramInfo& info, const Metadata::Tag& tag);
+
+} // namespace utils
+
+} // namespace aidl::android::hardware::broadcastradio
diff --git a/broadcastradio/common/utilsaidl/Utils.cpp b/broadcastradio/common/utilsaidl/src/Utils.cpp
similarity index 95%
rename from broadcastradio/common/utilsaidl/Utils.cpp
rename to broadcastradio/common/utilsaidl/src/Utils.cpp
index de4f529..2875318 100644
--- a/broadcastradio/common/utilsaidl/Utils.cpp
+++ b/broadcastradio/common/utilsaidl/src/Utils.cpp
@@ -31,7 +31,6 @@
namespace {
using ::android::base::EqualsIgnoreCase;
-using ::std::string;
using ::std::vector;
const int64_t kValueForNotFoundIdentifier = 0;
@@ -207,7 +206,7 @@
uint64_t val = static_cast<uint64_t>(id.value);
bool valid = true;
- auto expect = [&valid](bool condition, const string& message) {
+ auto expect = [&valid](bool condition, const std::string& message) {
if (!condition) {
valid = false;
LOG(ERROR) << "identifier not valid, expected " << message;
@@ -278,9 +277,9 @@
case IdentifierType::SXM_CHANNEL:
expect(val < 1000u, "SXM channel < 1000");
break;
- case IdentifierType::VENDOR_START:
- case IdentifierType::VENDOR_END:
- // skip
+ default:
+ expect(id.type >= IdentifierType::VENDOR_START && id.type <= IdentifierType::VENDOR_END,
+ "Undefined identifier type");
break;
}
@@ -452,10 +451,10 @@
return metadataString;
}
-ProgramIdentifier makeHdRadioStationName(const string& name) {
+ProgramIdentifier makeHdRadioStationName(const std::string& name) {
constexpr size_t maxlen = 8;
- string shortName;
+ std::string shortName;
shortName.reserve(maxlen);
const auto& loc = std::locale::classic();
@@ -484,7 +483,7 @@
return static_cast<IdentifierType>(typeAsInt);
}
-bool parseArgInt(const string& s, int* out) {
+bool parseArgInt(const std::string& s, int* out) {
return ::android::base::ParseInt(s, out);
}
@@ -492,7 +491,7 @@
return ::android::base::ParseInt(s, out);
}
-bool parseArgBool(const string& s, bool* out) {
+bool parseArgBool(const std::string& s, bool* out) {
if (EqualsIgnoreCase(s, "true")) {
*out = true;
} else if (EqualsIgnoreCase(s, "false")) {
@@ -503,7 +502,7 @@
return true;
}
-bool parseArgDirection(const string& s, bool* out) {
+bool parseArgDirection(const std::string& s, bool* out) {
if (EqualsIgnoreCase(s, "up")) {
*out = true;
} else if (EqualsIgnoreCase(s, "down")) {
@@ -514,8 +513,8 @@
return true;
}
-bool parseArgIdentifierTypeArray(const string& s, vector<IdentifierType>* out) {
- for (const string& val : ::android::base::Split(s, ",")) {
+bool parseArgIdentifierTypeArray(const std::string& s, vector<IdentifierType>* out) {
+ for (const std::string& val : ::android::base::Split(s, ",")) {
int outInt;
if (!parseArgInt(val, &outInt)) {
return false;
@@ -526,8 +525,8 @@
}
bool parseProgramIdentifierList(const std::string& s, vector<ProgramIdentifier>* out) {
- for (const string& idStr : ::android::base::Split(s, ",")) {
- const vector<string> idStrPair = ::android::base::Split(idStr, ":");
+ for (const std::string& idStr : ::android::base::Split(s, ",")) {
+ const vector<std::string> idStrPair = ::android::base::Split(idStr, ":");
if (idStrPair.size() != 2) {
return false;
}
diff --git a/broadcastradio/common/utilsaidl/src/UtilsV2.cpp b/broadcastradio/common/utilsaidl/src/UtilsV2.cpp
new file mode 100644
index 0000000..ef739df
--- /dev/null
+++ b/broadcastradio/common/utilsaidl/src/UtilsV2.cpp
@@ -0,0 +1,240 @@
+/*
+ * Copyright (C) 2023 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 "BcRadioAidlDef.utilsV2"
+
+#include "broadcastradio-utils-aidl/UtilsV2.h"
+
+#include <android-base/logging.h>
+#include <android-base/strings.h>
+
+namespace aidl::android::hardware::broadcastradio {
+
+namespace utils {
+
+bool isValidV2(const ProgramIdentifier& id) {
+ uint64_t val = static_cast<uint64_t>(id.value);
+ bool valid = true;
+
+ auto expect = [&valid](bool condition, const std::string& message) {
+ if (!condition) {
+ valid = false;
+ LOG(ERROR) << "identifier not valid, expected " << message;
+ }
+ };
+
+ switch (id.type) {
+ case IdentifierType::INVALID:
+ expect(false, "IdentifierType::INVALID");
+ break;
+ case IdentifierType::DAB_FREQUENCY_KHZ:
+ expect(val > 100000u, "f > 100MHz");
+ [[fallthrough]];
+ case IdentifierType::AMFM_FREQUENCY_KHZ:
+ case IdentifierType::DRMO_FREQUENCY_KHZ:
+ expect(val > 100u, "f > 100kHz");
+ expect(val < 10000000u, "f < 10GHz");
+ break;
+ case IdentifierType::RDS_PI:
+ expect(val != 0u, "RDS PI != 0");
+ expect(val <= 0xFFFFu, "16bit id");
+ break;
+ case IdentifierType::HD_STATION_ID_EXT: {
+ uint64_t stationId = val & 0xFFFFFFFF; // 32bit
+ val >>= 32;
+ uint64_t subchannel = val & 0xF; // 4bit
+ val >>= 4;
+ uint64_t freq = val & 0x3FFFF; // 18bit
+ expect(stationId != 0u, "HD station id != 0");
+ expect(subchannel < 8u, "HD subch < 8");
+ expect(freq > 100u, "f > 100kHz");
+ expect(freq < 10000000u, "f < 10GHz");
+ break;
+ }
+ case IdentifierType::HD_STATION_NAME: {
+ while (val > 0) {
+ char ch = static_cast<char>(val & 0xFF);
+ val >>= 8;
+ expect((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z'),
+ "HD_STATION_NAME does not match [A-Z0-9]+");
+ }
+ break;
+ }
+ case IdentifierType::DAB_SID_EXT: {
+ uint64_t sid = val & 0xFFFFFFFF; // 32bit
+ val >>= 32;
+ uint64_t ecc = val & 0xFF; // 8bit
+ expect(sid != 0u, "DAB SId != 0");
+ expect(ecc >= 0xA0u && ecc <= 0xF6u, "Invalid ECC, see ETSI TS 101 756 V2.1.1");
+ break;
+ }
+ case IdentifierType::DAB_ENSEMBLE:
+ expect(val != 0u, "DAB ensemble != 0");
+ expect(val <= 0xFFFFu, "16bit id");
+ break;
+ case IdentifierType::DAB_SCID:
+ expect(val > 0xFu, "12bit SCId (not 4bit SCIdS)");
+ expect(val <= 0xFFFu, "12bit id");
+ break;
+ case IdentifierType::DRMO_SERVICE_ID:
+ expect(val != 0u, "DRM SId != 0");
+ expect(val <= 0xFFFFFFu, "24bit id");
+ break;
+ case IdentifierType::SXM_SERVICE_ID:
+ expect(val != 0u, "SXM SId != 0");
+ expect(val <= 0xFFFFFFFFu, "32bit id");
+ break;
+ case IdentifierType::SXM_CHANNEL:
+ expect(val < 1000u, "SXM channel < 1000");
+ break;
+ case IdentifierType::HD_STATION_LOCATION: {
+ uint64_t latitudeBit = val & 0x1;
+ expect(latitudeBit == 1u, "Latitude comes first");
+ val >>= 27;
+ uint64_t latitudePad = val & 0x1Fu;
+ expect(latitudePad == 0u, "Latitude padding");
+ val >>= 5;
+ uint64_t longitudeBit = val & 0x1;
+ expect(longitudeBit == 1u, "Longitude comes next");
+ val >>= 27;
+ uint64_t longitudePad = val & 0x1Fu;
+ expect(longitudePad == 0u, "Latitude padding");
+ break;
+ }
+ default:
+ expect(id.type >= IdentifierType::VENDOR_START && id.type <= IdentifierType::VENDOR_END,
+ "Undefined identifier type");
+ break;
+ }
+
+ return valid;
+}
+
+bool isValidV2(const ProgramSelector& sel) {
+ if (sel.primaryId.type != IdentifierType::AMFM_FREQUENCY_KHZ &&
+ sel.primaryId.type != IdentifierType::RDS_PI &&
+ sel.primaryId.type != IdentifierType::HD_STATION_ID_EXT &&
+ sel.primaryId.type != IdentifierType::DAB_SID_EXT &&
+ sel.primaryId.type != IdentifierType::DRMO_SERVICE_ID &&
+ sel.primaryId.type != IdentifierType::SXM_SERVICE_ID &&
+ (sel.primaryId.type < IdentifierType::VENDOR_START ||
+ sel.primaryId.type > IdentifierType::VENDOR_END)) {
+ return false;
+ }
+ return isValidV2(sel.primaryId);
+}
+
+std::optional<std::string> getMetadataStringV2(const ProgramInfo& info, const Metadata::Tag& tag) {
+ auto isRdsPs = [tag](const Metadata& item) { return item.getTag() == tag; };
+
+ auto it = std::find_if(info.metadata.begin(), info.metadata.end(), isRdsPs);
+ if (it == info.metadata.end()) {
+ return std::nullopt;
+ }
+
+ std::string metadataString;
+ switch (it->getTag()) {
+ case Metadata::rdsPs:
+ metadataString = it->get<Metadata::rdsPs>();
+ break;
+ case Metadata::rdsPty:
+ metadataString = std::to_string(it->get<Metadata::rdsPty>());
+ break;
+ case Metadata::rbdsPty:
+ metadataString = std::to_string(it->get<Metadata::rbdsPty>());
+ break;
+ case Metadata::rdsRt:
+ metadataString = it->get<Metadata::rdsRt>();
+ break;
+ case Metadata::songTitle:
+ metadataString = it->get<Metadata::songTitle>();
+ break;
+ case Metadata::songArtist:
+ metadataString = it->get<Metadata::songArtist>();
+ break;
+ case Metadata::songAlbum:
+ metadataString = it->get<Metadata::songAlbum>();
+ break;
+ case Metadata::stationIcon:
+ metadataString = std::to_string(it->get<Metadata::stationIcon>());
+ break;
+ case Metadata::albumArt:
+ metadataString = std::to_string(it->get<Metadata::albumArt>());
+ break;
+ case Metadata::programName:
+ metadataString = it->get<Metadata::programName>();
+ break;
+ case Metadata::dabEnsembleName:
+ metadataString = it->get<Metadata::dabEnsembleName>();
+ break;
+ case Metadata::dabEnsembleNameShort:
+ metadataString = it->get<Metadata::dabEnsembleNameShort>();
+ break;
+ case Metadata::dabServiceName:
+ metadataString = it->get<Metadata::dabServiceName>();
+ break;
+ case Metadata::dabServiceNameShort:
+ metadataString = it->get<Metadata::dabServiceNameShort>();
+ break;
+ case Metadata::dabComponentName:
+ metadataString = it->get<Metadata::dabComponentName>();
+ break;
+ case Metadata::dabComponentNameShort:
+ metadataString = it->get<Metadata::dabComponentNameShort>();
+ break;
+ case Metadata::genre:
+ metadataString = it->get<Metadata::genre>();
+ break;
+ case Metadata::commentShortDescription:
+ metadataString = it->get<Metadata::commentShortDescription>();
+ break;
+ case Metadata::commentActualText:
+ metadataString = it->get<Metadata::commentActualText>();
+ break;
+ case Metadata::commercial:
+ metadataString = it->get<Metadata::commercial>();
+ break;
+ case Metadata::ufids: {
+ auto& ufids = it->get<Metadata::ufids>();
+ metadataString = "[";
+ for (const auto& ufid : ufids) {
+ metadataString += std::string(ufid) + ",";
+ }
+ if (ufids.empty()) {
+ metadataString += "]";
+ } else {
+ metadataString[metadataString.size() - 1] = ']';
+ }
+ } break;
+ case Metadata::hdStationNameShort:
+ metadataString = it->get<Metadata::hdStationNameShort>();
+ break;
+ case Metadata::hdStationNameLong:
+ metadataString = it->get<Metadata::hdStationNameLong>();
+ break;
+ case Metadata::hdSubChannelsAvailable:
+ metadataString = std::to_string(it->get<Metadata::hdSubChannelsAvailable>());
+ break;
+ default:
+ LOG(ERROR) << "Metadata " << it->toString() << " is not converted.";
+ return std::nullopt;
+ }
+ return metadataString;
+}
+
+} // namespace utils
+
+} // namespace aidl::android::hardware::broadcastradio