Merge "Audio CAP: Address ANAPIC comments, Part 3." into main (15a250af) · Commits · e / os / android_hardware_interfaces

audio/aidl/common/include/Utils.h

+0 −31

Original line number	Original line	Diff line number	Diff line
	@@ -63,31 +63,6 @@ constexpr std::array<::aidl::android::media::audio::common::AudioMode, 5> kValid
	::aidl::android::media::audio::common::AudioMode::CALL_SCREEN,		::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) {		constexpr bool iequals(const std::string& str1, const std::string& str2) {
	return str1.length() == str2.length() &&		return str1.length() == str2.length() &&
	!fasticmp<strncmp>(str1.c_str(), str2.c_str(), str1.length());		!fasticmp<strncmp>(str1.c_str(), str2.c_str(), str1.length());
	@@ -168,12 +143,6 @@ constexpr bool isValidAudioMode(::aidl::android::media::audio::common::AudioMode
	kValidAudioModes.end();		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) {		static inline bool maybeVendorExtension(const std::string& s) {
	// Only checks whether the string starts with the "vendor prefix".		// Only checks whether the string starts with the "vendor prefix".
	static const std::string vendorPrefix = "VX_";		static const std::string vendorPrefix = "VX_";

audio/aidl/default/CapEngineConfigXmlConverter.cpp

+2 −2

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

audio/aidl/default/XsdcConversion.cpp

+85 −46

Original line number	Original line	Diff line number	Diff line
			/*
			* 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 <inttypes.h>

	#include <unordered_set>		#include <unordered_set>
	@@ -5,6 +21,7 @@
	#define LOG_TAG "AHAL_Config"		#define LOG_TAG "AHAL_Config"
	#include <android-base/logging.h>		#include <android-base/logging.h>
	#include <android-base/strings.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/AudioPort.h>
	#include <aidl/android/media/audio/common/AudioPortConfig.h>		#include <aidl/android/media/audio/common/AudioPortConfig.h>
	@@ -20,9 +37,7 @@

	using aidl::android::hardware::audio::common::iequals;		using aidl::android::hardware::audio::common::iequals;
	using aidl::android::hardware::audio::common::isValidAudioMode;		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::kValidAudioModes;
	using aidl::android::hardware::audio::common::kValidAudioPolicyForcedConfig;
	using aidl::android::media::audio::common::AudioChannelLayout;		using aidl::android::media::audio::common::AudioChannelLayout;
	using aidl::android::media::audio::common::AudioContentType;		using aidl::android::media::audio::common::AudioContentType;
	using aidl::android::media::audio::common::AudioDevice;		using aidl::android::media::audio::common::AudioDevice;
	@@ -49,9 +64,10 @@ using aidl::android::media::audio::common::AudioProfile;
	using aidl::android::media::audio::common::AudioSource;		using aidl::android::media::audio::common::AudioSource;
	using aidl::android::media::audio::common::AudioStreamType;		using aidl::android::media::audio::common::AudioStreamType;
	using aidl::android::media::audio::common::AudioUsage;		using aidl::android::media::audio::common::AudioUsage;
	using ::android::BAD_VALUE;		using android::BAD_VALUE;
	using ::android::base::unexpected;		using android::base::unexpected;
	using ::android::utilities::convertTo;		using android::utilities::convertTo;
			using ndk::enum_range;

	namespace ap_xsd = android::audio::policy::configuration;		namespace ap_xsd = android::audio::policy::configuration;
	namespace eng_xsd = android::audio::policy::engine::configuration;		namespace eng_xsd = android::audio::policy::engine::configuration;
	@@ -531,18 +547,6 @@ ConversionResult<std::unique_ptr<Module::Configuration>> convertModuleConfigToAi
	return result;		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) {		ConversionResult<AudioMode> convertTelephonyModeToAidl(const std::string& xsdcModeCriterionType) {
	const auto it = std::find_if(kValidAudioModes.begin(), kValidAudioModes.end(),		const auto it = std::find_if(kValidAudioModes.begin(), kValidAudioModes.end(),
	[&xsdcModeCriterionType](const auto& mode) {		[&xsdcModeCriterionType](const auto& mode) {
	@@ -637,6 +641,16 @@ ConversionResult<std::vector<AudioDeviceAddress>> convertDeviceAddressesToAidl(
	return aidlDeviceAddresses;		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(		ConversionResult<std::vector<AudioMode>> convertTelephonyModesToAidl(
	const eng_xsd::CriterionTypeType& xsdcTelephonyModeCriterionType) {		const eng_xsd::CriterionTypeType& xsdcTelephonyModeCriterionType) {
	if (xsdcTelephonyModeCriterionType.getValues().empty()) {		if (xsdcTelephonyModeCriterionType.getValues().empty()) {
	@@ -647,71 +661,97 @@ ConversionResult<std::vector<AudioMode>> convertTelephonyModesToAidl(
	for (eng_xsd::ValuesType xsdcValues : xsdcTelephonyModeCriterionType.getValues()) {		for (eng_xsd::ValuesType xsdcValues : xsdcTelephonyModeCriterionType.getValues()) {
	aidlAudioModes.reserve(xsdcValues.getValue().size());		aidlAudioModes.reserve(xsdcValues.getValue().size());
	for (const eng_xsd::ValueType& xsdcValue : xsdcValues.getValue()) {		for (const eng_xsd::ValueType& xsdcValue : xsdcValues.getValue()) {
	int integerValue = xsdcValue.getNumerical();		aidlAudioModes.push_back(
	if (!isValidAudioMode(AudioMode(integerValue))) {		VALUE_OR_RETURN(convertAudioModeToAidl(xsdcValue.getLiteral())));
	LOG(ERROR) << __func__ << " invalid audio mode " << integerValue;
	return unexpected(BAD_VALUE);
	}
	aidlAudioModes.push_back(AudioMode(integerValue));
	}		}
	}		}
	return aidlAudioModes;		return aidlAudioModes;
	}		}

	ConversionResult<std::vector<AudioPolicyForcedConfig>> convertForcedConfigsToAidl(		ConversionResult<std::vector<AudioPolicyForceUse>> convertForceUseConfigsToAidl(
			const std::string& criterionValue,
	const eng_xsd::CriterionTypeType& xsdcForcedConfigCriterionType) {		const eng_xsd::CriterionTypeType& xsdcForcedConfigCriterionType) {
	if (xsdcForcedConfigCriterionType.getValues().empty()) {		if (xsdcForcedConfigCriterionType.getValues().empty()) {
	LOG(ERROR) << __func__ << " no values provided";		LOG(ERROR) << __func__ << " no values provided";
	return unexpected(BAD_VALUE);		return unexpected(BAD_VALUE);
	}		}
	std::vector<AudioPolicyForcedConfig> aidlForcedConfigs;		std::vector<AudioPolicyForceUse> aidlForcedConfigs;
	for (eng_xsd::ValuesType xsdcValues : xsdcForcedConfigCriterionType.getValues()) {		for (eng_xsd::ValuesType xsdcValues : xsdcForcedConfigCriterionType.getValues()) {
	aidlForcedConfigs.reserve(xsdcValues.getValue().size());		aidlForcedConfigs.reserve(xsdcValues.getValue().size());
	for (const eng_xsd::ValueType& xsdcValue : xsdcValues.getValue()) {		for (const eng_xsd::ValueType& xsdcValue : xsdcValues.getValue()) {
	int integerValue = xsdcValue.getNumerical();		aidlForcedConfigs.push_back(
	if (!isValidAudioPolicyForcedConfig(AudioPolicyForcedConfig(integerValue))) {		VALUE_OR_RETURN(convertForceUseToAidl(criterionValue, xsdcValue.getLiteral())));
	LOG(ERROR) << __func__ << " invalid forced config mode " << integerValue;
	return unexpected(BAD_VALUE);
	}
	aidlForcedConfigs.push_back(AudioPolicyForcedConfig(integerValue));
	}		}
	}		}
	return aidlForcedConfigs;		return aidlForcedConfigs;
	}		}

	ConversionResult<AudioPolicyForceUse> convertForceUseCriterionToAidl(		template <typename T>
	const std::string& xsdcCriterionName) {		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) {
	if (!fastcmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForCommunication,		if (!fastcmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForCommunication,
	strlen(kXsdcForceConfigForCommunication))) {		strlen(kXsdcForceConfigForCommunication))) {
	return AudioPolicyForceUse::COMMUNICATION;		const auto deviceCategory = VALUE_OR_RETURN(
			convertForceUseForcedConfigToAidl<AudioPolicyForceUse::CommunicationDeviceCategory>(
			xsdcCriterionValue));
			return AudioPolicyForceUse::make<AudioPolicyForceUse::forCommunication>(deviceCategory);
	}		}
	if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForMedia,		if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForMedia,
	strlen(kXsdcForceConfigForMedia))) {		strlen(kXsdcForceConfigForMedia))) {
	return AudioPolicyForceUse::MEDIA;		const auto deviceCategory = VALUE_OR_RETURN(
			convertForceUseForcedConfigToAidl<AudioPolicyForceUse::MediaDeviceCategory>(
			xsdcCriterionValue));
			return AudioPolicyForceUse::make<AudioPolicyForceUse::forMedia>(deviceCategory);
	}		}
	if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForRecord,		if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForRecord,
	strlen(kXsdcForceConfigForRecord))) {		strlen(kXsdcForceConfigForRecord))) {
	return AudioPolicyForceUse::RECORD;		const auto deviceCategory = VALUE_OR_RETURN(
			convertForceUseForcedConfigToAidl<AudioPolicyForceUse::CommunicationDeviceCategory>(
			xsdcCriterionValue));
			return AudioPolicyForceUse::make<AudioPolicyForceUse::forRecord>(deviceCategory);
	}		}
	if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForDock,		if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForDock,
	strlen(kXsdcForceConfigForDock))) {		strlen(kXsdcForceConfigForDock))) {
	return AudioPolicyForceUse::DOCK;		const auto dockType =
			VALUE_OR_RETURN(convertForceUseForcedConfigToAidl<AudioPolicyForceUse::DockType>(
			xsdcCriterionValue));
			return AudioPolicyForceUse::make<AudioPolicyForceUse::dock>(dockType);
	}		}
	if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForSystem,		if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForSystem,
	strlen(kXsdcForceConfigForSystem))) {		strlen(kXsdcForceConfigForSystem))) {
	return AudioPolicyForceUse::SYSTEM;		return AudioPolicyForceUse::make<AudioPolicyForceUse::systemSounds>(xsdcCriterionValue ==
			"SYSTEM_ENFORCED");
	}		}
	if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForHdmiSystemAudio,		if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForHdmiSystemAudio,
	strlen(kXsdcForceConfigForHdmiSystemAudio))) {		strlen(kXsdcForceConfigForHdmiSystemAudio))) {
	return AudioPolicyForceUse::HDMI_SYSTEM_AUDIO;		return AudioPolicyForceUse::make<AudioPolicyForceUse::hdmiSystemAudio>(
			xsdcCriterionValue == "HDMI_SYSTEM_AUDIO_ENFORCED");
	}		}
	if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForEncodedSurround,		if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForEncodedSurround,
	strlen(kXsdcForceConfigForEncodedSurround))) {		strlen(kXsdcForceConfigForEncodedSurround))) {
	return AudioPolicyForceUse::ENCODED_SURROUND;		const auto encodedSurround = VALUE_OR_RETURN(
			convertForceUseForcedConfigToAidl<AudioPolicyForceUse::EncodedSurroundConfig>(
			xsdcCriterionValue));
			return AudioPolicyForceUse::make<AudioPolicyForceUse::encodedSurround>(encodedSurround);
	}		}
	if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForVibrateRinging,		if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), kXsdcForceConfigForVibrateRinging,
	strlen(kXsdcForceConfigForVibrateRinging))) {		strlen(kXsdcForceConfigForVibrateRinging))) {
	return AudioPolicyForceUse::VIBRATE_RINGING;		const auto deviceCategory = VALUE_OR_RETURN(
			convertForceUseForcedConfigToAidl<AudioPolicyForceUse::CommunicationDeviceCategory>(
			xsdcCriterionValue));
			return AudioPolicyForceUse::make<AudioPolicyForceUse::forVibrateRinging>(deviceCategory);
	}		}
	LOG(ERROR) << __func__ << " unrecognized force use " << xsdcCriterionName;		LOG(ERROR) << __func__ << " unrecognized force use " << xsdcCriterionName;
	return unexpected(BAD_VALUE);		return unexpected(BAD_VALUE);
	@@ -747,9 +787,8 @@ ConversionResult<AudioHalCapCriterionV2> convertCapCriterionV2ToAidl(
	}		}
	if (!fastcmp<strncmp>(xsdcCriterion.getName().c_str(), kXsdcForceConfigForUse,		if (!fastcmp<strncmp>(xsdcCriterion.getName().c_str(), kXsdcForceConfigForUse,
	strlen(kXsdcForceConfigForUse))) {		strlen(kXsdcForceConfigForUse))) {
	return AudioHalCapCriterionV2::make<Tag::forceConfigForUse>(		return AudioHalCapCriterionV2::make<Tag::forceConfigForUse>(VALUE_OR_RETURN(
	VALUE_OR_RETURN(convertForceUseCriterionToAidl(xsdcCriterion.getName())),		convertForceUseConfigsToAidl(xsdcCriterion.getName(), xsdcCriterionType)));
	VALUE_OR_RETURN(convertForcedConfigsToAidl(xsdcCriterionType)));
	}		}
	LOG(ERROR) << __func__ << " unrecognized criterion " << xsdcCriterion.getName();		LOG(ERROR) << __func__ << " unrecognized criterion " << xsdcCriterion.getName();
	return unexpected(BAD_VALUE);		return unexpected(BAD_VALUE);

audio/aidl/default/config/audioPolicy/engine/api/current.txt

+39 −2

Original line number	Original line	Diff line number	Diff line
	@@ -148,6 +148,45 @@ package android.audio.policy.engine.configuration {
	method public void setValue(@Nullable java.util.List<android.audio.policy.engine.configuration.FlagType>);		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 {		public enum PfwCriterionTypeEnum {
	method @NonNull public String getRawName();		method @NonNull public String getRawName();
	enum_constant public static final android.audio.policy.engine.configuration.PfwCriterionTypeEnum exclusive;		enum_constant public static final android.audio.policy.engine.configuration.PfwCriterionTypeEnum exclusive;
	@@ -244,10 +283,8 @@ package android.audio.policy.engine.configuration {
	ctor public ValueType();		ctor public ValueType();
	method @Nullable public String getAndroid_type();		method @Nullable public String getAndroid_type();
	method @Nullable public String getLiteral();		method @Nullable public String getLiteral();
	method @Nullable public long getNumerical();
	method public void setAndroid_type(@Nullable String);		method public void setAndroid_type(@Nullable String);
	method public void setLiteral(@Nullable String);		method public void setLiteral(@Nullable String);
	method public void setNumerical(@Nullable long);
	}		}

	public class ValuesType {		public class ValuesType {

audio/aidl/default/config/audioPolicy/engine/audio_policy_engine_configuration.xsd

+46 −5

Original line number	Original line	Diff line number	Diff line
	@@ -191,10 +191,9 @@
	<xs:complexType name="valueType">		<xs:complexType name="valueType">
	<xs:annotation>		<xs:annotation>
	<xs:documentation xml:lang="en">		<xs:documentation xml:lang="en">
	Criterion type is provided as a tuple of 'human readable' string (referred as the		Criterion type is provided as a pair of 'human readable' string (referred as the
	literal part, that will allow to express 'human readable' rules, numerical value		literal part, that will allow to express 'human readable' rules and an optional
	associated in order to improve performances of the parameter framework library used,		android type.
	and an optional android type.
	This android type is reserved for device type mapping with parameter framework		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		representation on a bitfield (Only one bit is expected to represent a device) and
	android representation of a type that may use several bits.		android representation of a type that may use several bits.
	@@ -203,7 +202,6 @@
	</xs:documentation>		</xs:documentation>
	</xs:annotation>		</xs:annotation>
	<xs:attribute name="literal" type="xs:string" use="required"/>		<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:attribute name="android_type" type="longDecimalOrHexType" use="optional"/>
	</xs:complexType>		</xs:complexType>

	@@ -409,6 +407,49 @@
	</xs:restriction>		</xs:restriction>
	</xs:simpleType>		</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:simpleType name="sourceEnumType">
	<xs:restriction base="xs:string">		<xs:restriction base="xs:string">
	<xs:enumeration value="AUDIO_SOURCE_DEFAULT"/>		<xs:enumeration value="AUDIO_SOURCE_DEFAULT"/>