Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 16:50:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge "Revert "Audio CAP: Address ANAPIC comments, Part 3."" into main

Browse Source
This commit is contained in:
Priyanka Advani (xWF)
2024-11-20 19:00:16 +00:00
committed by Gerrit Code Review
parent 1d3cc6de6d 50f4e8a966
commit 38141be0fb
7 changed files with 94 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
audio/aidl/common/include/Utils.h
View File

@@ -63,6 +63,31 @@ constexpr std::array<::aidl::android::media::audio::common::AudioMode, 5> kValid
::aidl::android::media::audio::common::AudioMode::CALL_SCREEN,
};
constexpr std::array<::aidl::android::media::audio::common::AudioPolicyForcedConfig, 17>
kValidAudioPolicyForcedConfig = {
::aidl::android::media::audio::common::AudioPolicyForcedConfig::NONE,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::SPEAKER,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::HEADPHONES,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::BT_SCO,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::BT_A2DP,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::WIRED_ACCESSORY,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::BT_CAR_DOCK,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::BT_DESK_DOCK,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::ANALOG_DOCK,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::DIGITAL_DOCK,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::NO_BT_A2DP,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::SYSTEM_ENFORCED,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::
HDMI_SYSTEM_AUDIO_ENFORCED,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::
ENCODED_SURROUND_NEVER,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::
ENCODED_SURROUND_ALWAYS,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::
ENCODED_SURROUND_MANUAL,
::aidl::android::media::audio::common::AudioPolicyForcedConfig::BT_BLE,
};
constexpr bool iequals(const std::string& str1, const std::string& str2) {
return str1.length() == str2.length() &&
!fasticmp<strncmp>(str1.c_str(), str2.c_str(), str1.length());
@@ -143,6 +168,12 @@ constexpr bool isValidAudioMode(::aidl::android::media::audio::common::AudioMode
kValidAudioModes.end();
}
constexpr bool isValidAudioPolicyForcedConfig(
::aidl::android::media::audio::common::AudioPolicyForcedConfig config) {
return std::find(kValidAudioPolicyForcedConfig.begin(), kValidAudioPolicyForcedConfig.end(),
config) != kValidAudioPolicyForcedConfig.end();
}
static inline bool maybeVendorExtension(const std::string& s) {
// Only checks whether the string starts with the "vendor prefix".
static const std::string vendorPrefix = "VX_";

4
audio/aidl/default/CapEngineConfigXmlConverter.cpp
View File

@@ -96,8 +96,8 @@ ConversionResult<AudioHalCapRule::CriterionRule> convertCriterionRuleToAidl(
} else if (!fastcmp<strncmp>(criterionName.c_str(), kXsdcForceConfigForUse,
strlen(kXsdcForceConfigForUse))) {
AudioHalCapCriterionV2::ForceConfigForUse value;
value.values.emplace_back(
VALUE_OR_RETURN(convertForceUseToAidl(criterionName, criterionValue)));
value.forceUse = VALUE_OR_RETURN(convertForceUseCriterionToAidl(criterionName));
value.values.emplace_back(VALUE_OR_RETURN(convertForcedConfigToAidl(criterionValue)));
rule.criterionAndValue = AudioHalCapCriterionV2::make<Tag::forceConfigForUse>(value);
} else {
LOG(ERROR) << __func__ << " unrecognized criterion " << criterionName;

131
audio/aidl/default/XsdcConversion.cpp
View File

@@ -1,19 +1,3 @@
/*
* Copyright (C) 2024 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 <inttypes.h>
#include <unordered_set>
@@ -21,7 +5,6 @@
#define LOG_TAG "AHAL_Config"
#include <android-base/logging.h>
#include <android-base/strings.h>
#include <android/binder_enums.h>
#include <aidl/android/media/audio/common/AudioPort.h>
#include <aidl/android/media/audio/common/AudioPortConfig.h>
@@ -37,7 +20,9 @@
using aidl::android::hardware::audio::common::iequals;
using aidl::android::hardware::audio::common::isValidAudioMode;
using aidl::android::hardware::audio::common::isValidAudioPolicyForcedConfig;
using aidl::android::hardware::audio::common::kValidAudioModes;
using aidl::android::hardware::audio::common::kValidAudioPolicyForcedConfig;
using aidl::android::media::audio::common::AudioChannelLayout;
using aidl::android::media::audio::common::AudioContentType;
using aidl::android::media::audio::common::AudioDevice;
@@ -64,10 +49,9 @@ using aidl::android::media::audio::common::AudioProfile;
using aidl::android::media::audio::common::AudioSource;
using aidl::android::media::audio::common::AudioStreamType;
using aidl::android::media::audio::common::AudioUsage;
using android::BAD_VALUE;
using android::base::unexpected;
using android::utilities::convertTo;
using ndk::enum_range;
using ::android::BAD_VALUE;
using ::android::base::unexpected;
using ::android::utilities::convertTo;
namespace ap_xsd = android::audio::policy::configuration;
namespace eng_xsd = android::audio::policy::engine::configuration;
@@ -547,6 +531,18 @@ ConversionResult<std::unique_ptr<Module::Configuration>> convertModuleConfigToAi
return result;
}
ConversionResult<AudioPolicyForcedConfig> convertForcedConfigToAidl(
const std::string& xsdcForcedConfigCriterionType) {
const auto it = std::find_if(
kValidAudioPolicyForcedConfig.begin(), kValidAudioPolicyForcedConfig.end(),
[&](const auto& config) { return toString(config) == xsdcForcedConfigCriterionType; });
if (it == kValidAudioPolicyForcedConfig.end()) {
LOG(ERROR) << __func__ << " invalid forced config " << xsdcForcedConfigCriterionType;
return unexpected(BAD_VALUE);
}
return *it;
}
ConversionResult<AudioMode> convertTelephonyModeToAidl(const std::string& xsdcModeCriterionType) {
const auto it = std::find_if(kValidAudioModes.begin(), kValidAudioModes.end(),
[&xsdcModeCriterionType](const auto& mode) {
@@ -641,16 +637,6 @@ ConversionResult<std::vector<AudioDeviceAddress>> convertDeviceAddressesToAidl(
return aidlDeviceAddresses;
}
ConversionResult<AudioMode> convertAudioModeToAidl(const std::string& xsdcAudioModeType) {
const auto it = std::find_if(enum_range<AudioMode>().begin(), enum_range<AudioMode>().end(),
[&](const auto v) { return toString(v) == xsdcAudioModeType; });
if (it == enum_range<AudioMode>().end()) {
LOG(ERROR) << __func__ << " invalid audio mode " << xsdcAudioModeType;
return unexpected(BAD_VALUE);
}
return *it;
}
ConversionResult<std::vector<AudioMode>> convertTelephonyModesToAidl(
const eng_xsd::CriterionTypeType& xsdcTelephonyModeCriterionType) {
if (xsdcTelephonyModeCriterionType.getValues().empty()) {
@@ -661,97 +647,71 @@ ConversionResult<std::vector<AudioMode>> convertTelephonyModesToAidl(
for (eng_xsd::ValuesType xsdcValues : xsdcTelephonyModeCriterionType.getValues()) {
aidlAudioModes.reserve(xsdcValues.getValue().size());
for (const eng_xsd::ValueType& xsdcValue : xsdcValues.getValue()) {
aidlAudioModes.push_back(
VALUE_OR_RETURN(convertAudioModeToAidl(xsdcValue.getLiteral())));
int integerValue = xsdcValue.getNumerical();
if (!isValidAudioMode(AudioMode(integerValue))) {
LOG(ERROR) << __func__ << " invalid audio mode " << integerValue;
return unexpected(BAD_VALUE);
}
aidlAudioModes.push_back(AudioMode(integerValue));
}
}
return aidlAudioModes;
}
ConversionResult<std::vector<AudioPolicyForceUse>> convertForceUseConfigsToAidl(
const std::string& criterionValue,
ConversionResult<std::vector<AudioPolicyForcedConfig>> convertForcedConfigsToAidl(
const eng_xsd::CriterionTypeType& xsdcForcedConfigCriterionType) {
if (xsdcForcedConfigCriterionType.getValues().empty()) {
LOG(ERROR) << __func__ << " no values provided";
return unexpected(BAD_VALUE);
}
std::vector<AudioPolicyForceUse> aidlForcedConfigs;
std::vector<AudioPolicyForcedConfig> aidlForcedConfigs;
for (eng_xsd::ValuesType xsdcValues : xsdcForcedConfigCriterionType.getValues()) {
aidlForcedConfigs.reserve(xsdcValues.getValue().size());
for (const eng_xsd::ValueType& xsdcValue : xsdcValues.getValue()) {
aidlForcedConfigs.push_back(
VALUE_OR_RETURN(convertForceUseToAidl(criterionValue, xsdcValue.getLiteral())));
int integerValue = xsdcValue.getNumerical();
if (!isValidAudioPolicyForcedConfig(AudioPolicyForcedConfig(integerValue))) {
LOG(ERROR) << __func__ << " invalid forced config mode " << integerValue;
return unexpected(BAD_VALUE);
}
aidlForcedConfigs.push_back(AudioPolicyForcedConfig(integerValue));
}
}
return aidlForcedConfigs;
}
template <typename T>
ConversionResult<T> convertForceUseForcedConfigToAidl(
const std::string& xsdcForcedConfigCriterionType) {
const auto it = std::find_if(enum_range<T>().begin(), enum_range<T>().end(), [&](const auto v) {
return toString(v) == xsdcForcedConfigCriterionType;
});
if (it == enum_range<T>().end()) {
LOG(ERROR) << __func__ << " invalid forced config " << xsdcForcedConfigCriterionType;
return unexpected(BAD_VALUE);
}
return *it;
}
ConversionResult<AudioPolicyForceUse> convertForceUseToAidl(const std::string& xsdcCriterionName,
const std::string& xsdcCriterionValue) {
ConversionResult<AudioPolicyForceUse> convertForceUseCriterionToAidl(
const std::string& xsdcCriterionName) {
if (!fastcmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForCommunication,
strlen(kXsdcForceConfigForCommunication))) {
const auto deviceCategory = VALUE_OR_RETURN(
convertForceUseForcedConfigToAidl<AudioPolicyForceUse::CommunicationDeviceCategory>(
xsdcCriterionValue));
return AudioPolicyForceUse::make<AudioPolicyForceUse::forCommunication>(deviceCategory);
strlen(kXsdcForceConfigForCommunication))) {
return AudioPolicyForceUse::COMMUNICATION;
}
if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForMedia,
strlen(kXsdcForceConfigForMedia))) {
const auto deviceCategory = VALUE_OR_RETURN(
convertForceUseForcedConfigToAidl<AudioPolicyForceUse::MediaDeviceCategory>(
xsdcCriterionValue));
return AudioPolicyForceUse::make<AudioPolicyForceUse::forMedia>(deviceCategory);
return AudioPolicyForceUse::MEDIA;
}
if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForRecord,
strlen(kXsdcForceConfigForRecord))) {
const auto deviceCategory = VALUE_OR_RETURN(
convertForceUseForcedConfigToAidl<AudioPolicyForceUse::CommunicationDeviceCategory>(
xsdcCriterionValue));
return AudioPolicyForceUse::make<AudioPolicyForceUse::forRecord>(deviceCategory);
return AudioPolicyForceUse::RECORD;
}
if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForDock,
strlen(kXsdcForceConfigForDock))) {
const auto dockType =
VALUE_OR_RETURN(convertForceUseForcedConfigToAidl<AudioPolicyForceUse::DockType>(
xsdcCriterionValue));
return AudioPolicyForceUse::make<AudioPolicyForceUse::dock>(dockType);
strlen(kXsdcForceConfigForDock))) {
return AudioPolicyForceUse::DOCK;
}
if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForSystem,
strlen(kXsdcForceConfigForSystem))) {
return AudioPolicyForceUse::make<AudioPolicyForceUse::systemSounds>(xsdcCriterionValue ==
"SYSTEM_ENFORCED");
return AudioPolicyForceUse::SYSTEM;
}
if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForHdmiSystemAudio,
strlen(kXsdcForceConfigForHdmiSystemAudio))) {
return AudioPolicyForceUse::make<AudioPolicyForceUse::hdmiSystemAudio>(
xsdcCriterionValue == "HDMI_SYSTEM_AUDIO_ENFORCED");
return AudioPolicyForceUse::HDMI_SYSTEM_AUDIO;
}
if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForEncodedSurround,
strlen(kXsdcForceConfigForEncodedSurround))) {
const auto encodedSurround = VALUE_OR_RETURN(
convertForceUseForcedConfigToAidl<AudioPolicyForceUse::EncodedSurroundConfig>(
xsdcCriterionValue));
return AudioPolicyForceUse::make<AudioPolicyForceUse::encodedSurround>(encodedSurround);
return AudioPolicyForceUse::ENCODED_SURROUND;
}
if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForVibrateRinging,
strlen(kXsdcForceConfigForVibrateRinging))) {
const auto deviceCategory = VALUE_OR_RETURN(
convertForceUseForcedConfigToAidl<AudioPolicyForceUse::CommunicationDeviceCategory>(
xsdcCriterionValue));
return AudioPolicyForceUse::make<AudioPolicyForceUse::forVibrateRinging>(deviceCategory);
return AudioPolicyForceUse::VIBRATE_RINGING;
}
LOG(ERROR) << __func__ << " unrecognized force use " << xsdcCriterionName;
return unexpected(BAD_VALUE);
@@ -787,8 +747,9 @@ ConversionResult<AudioHalCapCriterionV2> convertCapCriterionV2ToAidl(
}
if (!fastcmp<strncmp>(xsdcCriterion.getName().c_str(), kXsdcForceConfigForUse,
strlen(kXsdcForceConfigForUse))) {
return AudioHalCapCriterionV2::make<Tag::forceConfigForUse>(VALUE_OR_RETURN(
convertForceUseConfigsToAidl(xsdcCriterion.getName(), xsdcCriterionType)));
return AudioHalCapCriterionV2::make<Tag::forceConfigForUse>(
VALUE_OR_RETURN(convertForceUseCriterionToAidl(xsdcCriterion.getName())),
VALUE_OR_RETURN(convertForcedConfigsToAidl(xsdcCriterionType)));
}
LOG(ERROR) << __func__ << " unrecognized criterion " << xsdcCriterion.getName();
return unexpected(BAD_VALUE);

41
audio/aidl/default/config/audioPolicy/engine/api/current.txt
View File

@@ -148,45 +148,6 @@ package android.audio.policy.engine.configuration {
method public void setValue(@Nullable java.util.List<android.audio.policy.engine.configuration.FlagType>);
}
public enum ForcedConfigCommunicationDeviceType {
method @NonNull public String getRawName();
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigCommunicationDeviceType BT_BLE;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigCommunicationDeviceType BT_SCO;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigCommunicationDeviceType NONE;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigCommunicationDeviceType SPEAKER;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigCommunicationDeviceType WIRED_ACCESSORY;
}
public enum ForcedConfigDockType {
method @NonNull public String getRawName();
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigDockType ANALOG_DOCK;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigDockType BT_CAR_DOCK;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigDockType BT_DESK_DOCK;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigDockType DIGITAL_DOCK;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigDockType NONE;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigDockType WIRED_ACCESSORY;
}
public enum ForcedConfigMediaDeviceType {
method @NonNull public String getRawName();
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigMediaDeviceType ANALOG_DOCK;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigMediaDeviceType BT_A2DP;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigMediaDeviceType DIGITAL_DOCK;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigMediaDeviceType HEADPHONES;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigMediaDeviceType NONE;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigMediaDeviceType NO_BT_A2DP;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigMediaDeviceType SPEAKER;
enum_constant public static final android.audio.policy.engine.configuration.ForcedConfigMediaDeviceType WIRED_ACCESSORY;
}
public enum ForcedEncodingSourroundConfigType {
method @NonNull public String getRawName();
enum_constant public static final android.audio.policy.engine.configuration.ForcedEncodingSourroundConfigType ALWAYS;
enum_constant public static final android.audio.policy.engine.configuration.ForcedEncodingSourroundConfigType MANUAL;
enum_constant public static final android.audio.policy.engine.configuration.ForcedEncodingSourroundConfigType NEVER;
enum_constant public static final android.audio.policy.engine.configuration.ForcedEncodingSourroundConfigType UNSPECIFIED;
}
public enum PfwCriterionTypeEnum {
method @NonNull public String getRawName();
enum_constant public static final android.audio.policy.engine.configuration.PfwCriterionTypeEnum exclusive;
@@ -283,8 +244,10 @@ package android.audio.policy.engine.configuration {
ctor public ValueType();
method @Nullable public String getAndroid_type();
method @Nullable public String getLiteral();
method @Nullable public long getNumerical();
method public void setAndroid_type(@Nullable String);
method public void setLiteral(@Nullable String);
method public void setNumerical(@Nullable long);
}
public class ValuesType {

51
audio/aidl/default/config/audioPolicy/engine/audio_policy_engine_configuration.xsd
View File

@@ -191,9 +191,10 @@
<xs:complexType name="valueType">
<xs:annotation>
<xs:documentation xml:lang="en">
Criterion type is provided as a pair of 'human readable' string (referred as the
literal part, that will allow to express 'human readable' rules and an optional
android type.
Criterion type is provided as a tuple of 'human readable' string (referred as the
literal part, that will allow to express 'human readable' rules, numerical value
associated in order to improve performances of the parameter framework library used,
and an optional android type.
This android type is reserved for device type mapping with parameter framework
representation on a bitfield (Only one bit is expected to represent a device) and
android representation of a type that may use several bits.
@@ -202,6 +203,7 @@
</xs:documentation>
</xs:annotation>
<xs:attribute name="literal" type="xs:string" use="required"/>
<xs:attribute name="numerical" type="xs:long" use="required"/>
<xs:attribute name="android_type" type="longDecimalOrHexType" use="optional"/>
</xs:complexType>
@@ -407,49 +409,6 @@
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="forcedConfigCommunicationDeviceType">
<xs:restriction base="xs:string">
<xs:enumeration value="NONE"/>
<xs:enumeration value="SPEAKER"/>
<xs:enumeration value="BT_SCO"/>
<xs:enumeration value="BT_BLE"/>
<xs:enumeration value="WIRED_ACCESSORY"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="forcedConfigMediaDeviceType">
<xs:restriction base="xs:string">
<xs:enumeration value="NONE"/>
<xs:enumeration value="SPEAKER"/>
<xs:enumeration value="HEADPHONES"/>
<xs:enumeration value="BT_A2DP"/>
<xs:enumeration value="ANALOG_DOCK"/>
<xs:enumeration value="DIGITAL_DOCK"/>
<xs:enumeration value="WIRED_ACCESSORY"/>
<xs:enumeration value="NO_BT_A2DP"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="forcedConfigDockType">
<xs:restriction base="xs:string">
<xs:enumeration value="NONE"/>
<xs:enumeration value="BT_CAR_DOCK"/>
<xs:enumeration value="BT_DESK_DOCK"/>
<xs:enumeration value="ANALOG_DOCK"/>
<xs:enumeration value="DIGITAL_DOCK"/>
<xs:enumeration value="WIRED_ACCESSORY"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="forcedEncodingSourroundConfigType">
<xs:restriction base="xs:string">
<xs:enumeration value="UNSPECIFIED"/>
<xs:enumeration value="NEVER"/>
<xs:enumeration value="ALWAYS"/>
<xs:enumeration value="MANUAL"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="sourceEnumType">
<xs:restriction base="xs:string">
<xs:enumeration value="AUDIO_SOURCE_DEFAULT"/>

24
audio/aidl/default/include/core-impl/XsdcConversion.h
View File

@@ -1,20 +1,6 @@
/*
* Copyright (C) 2024 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 <string>
#include <unordered_map>
#include <unordered_set>
#include <aidl/android/media/audio/common/AudioHalCapCriterion.h>
#include <aidl/android/media/audio/common/AudioHalCapCriterionType.h>
@@ -35,8 +21,10 @@ namespace aidlaudiocommon = ::aidl::android::media::audio::common;
static constexpr const char kXsdcForceConfigForUse[] = "ForceUseFor";
ConversionResult<aidlaudiocommon::AudioPolicyForceUse> convertForceUseToAidl(
const std::string& xsdcCriterionName, const std::string& xsdcCriterionValue);
ConversionResult<aidlaudiocommon::AudioPolicyForceUse> convertForceUseCriterionToAidl(
const std::string& xsdcCriterionName);
ConversionResult<aidlaudiocommon::AudioPolicyForcedConfig> convertForcedConfigToAidl(
const std::string& xsdcForcedConfigCriterionType);
ConversionResult<aidlaudiocommon::AudioDeviceAddress> convertDeviceAddressToAidl(
const std::string& xsdcAddress);
ConversionResult<aidlaudiocommon::AudioMode> convertTelephonyModeToAidl(

6
audio/aidl/vts/VtsHalAudioCoreConfigTargetTest.cpp
View File

@@ -577,7 +577,7 @@ class AudioCoreConfig : public testing::TestWithParam<std::string> {
void ValidateCapSpecificConfig(const AudioHalEngineConfig::CapSpecificConfig& capCfg) {
EXPECT_TRUE(capCfg.criteriaV2.has_value());
std::unordered_set<AudioHalCapCriterionV2::Tag> criterionTagSet;
std::unordered_set<AudioPolicyForceUse::Tag> forceUseCriterionUseSet;
std::unordered_set<AudioPolicyForceUse> forceUseCriterionUseSet;
for (const auto& criterion : capCfg.criteriaV2.value()) {
EXPECT_TRUE(criterion.has_value());
if (criterion.value().getTag() != AudioHalCapCriterionV2::forceConfigForUse) {
@@ -585,9 +585,7 @@ class AudioCoreConfig : public testing::TestWithParam<std::string> {
} else {
auto forceUseCriterion =
criterion.value().get<AudioHalCapCriterionV2::forceConfigForUse>();
ASSERT_FALSE(forceUseCriterion.values.empty());
EXPECT_TRUE(forceUseCriterionUseSet.insert(forceUseCriterion.values[0].getTag())
.second);
EXPECT_TRUE(forceUseCriterionUseSet.insert(forceUseCriterion.forceUse).second);
}
EXPECT_NO_FATAL_FAILURE(ValidateAudioHalCapCriterion(criterion.value()));
}