Merge "Revert^2 "Audio CAP: Address ANAPIC comments, Part 3."" into main (38ea9b05) · Commits · e / os / android_hardware_interfaces

audio/aidl/common/include/Utils.h

+0 −32

Original line number	Diff line number	Diff line
		@@ -29,7 +29,6 @@
		#include <aidl/android/media/audio/common/AudioIoFlags.h>
		#include <aidl/android/media/audio/common/AudioMode.h>
		#include <aidl/android/media/audio/common/AudioOutputFlags.h>
		#include <aidl/android/media/audio/common/AudioPolicyForcedConfig.h>
		#include <aidl/android/media/audio/common/PcmType.h>
		#include <android/binder_auto_utils.h>
		#include <utils/FastStrcmp.h>
		@@ -63,31 +62,6 @@ 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());
		@@ -168,12 +142,6 @@ 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_";

audio/aidl/default/CapEngineConfigXmlConverter.cpp

+2 −2

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

audio/aidl/default/XsdcConversion.cpp

+85 −47

Original line number	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 <unordered_set>
		@@ -5,6 +21,7 @@
		#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>
		@@ -20,9 +37,7 @@

		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;
		@@ -38,7 +53,6 @@ using aidl::android::media::audio::common::AudioHalCapCriterionV2;
		using aidl::android::media::audio::common::AudioHalVolumeCurve;
		using aidl::android::media::audio::common::AudioIoFlags;
		using aidl::android::media::audio::common::AudioMode;
		using aidl::android::media::audio::common::AudioPolicyForcedConfig;
		using aidl::android::media::audio::common::AudioPolicyForceUse;
		using aidl::android::media::audio::common::AudioPort;
		using aidl::android::media::audio::common::AudioPortConfig;
		@@ -49,9 +63,10 @@ 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 android::BAD_VALUE;
		using android::base::unexpected;
		using android::utilities::convertTo;
		using ndk::enum_range;

		namespace ap_xsd = android::audio::policy::configuration;
		namespace eng_xsd = android::audio::policy::engine::configuration;
		@@ -531,18 +546,6 @@ 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) {
		@@ -637,6 +640,16 @@ 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()) {
		@@ -647,71 +660,97 @@ 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()) {
		int integerValue = xsdcValue.getNumerical();
		if (!isValidAudioMode(AudioMode(integerValue))) {
		LOG(ERROR) << __func__ << " invalid audio mode " << integerValue;
		return unexpected(BAD_VALUE);
		}
		aidlAudioModes.push_back(AudioMode(integerValue));
		aidlAudioModes.push_back(
		VALUE_OR_RETURN(convertAudioModeToAidl(xsdcValue.getLiteral())));
		}
		}
		return aidlAudioModes;
		}

		ConversionResult<std::vector<AudioPolicyForcedConfig>> convertForcedConfigsToAidl(
		ConversionResult<std::vector<AudioPolicyForceUse>> convertForceUseConfigsToAidl(
		const std::string& criterionValue,
		const eng_xsd::CriterionTypeType& xsdcForcedConfigCriterionType) {
		if (xsdcForcedConfigCriterionType.getValues().empty()) {
		LOG(ERROR) << __func__ << " no values provided";
		return unexpected(BAD_VALUE);
		}
		std::vector<AudioPolicyForcedConfig> aidlForcedConfigs;
		std::vector<AudioPolicyForceUse> aidlForcedConfigs;
		for (eng_xsd::ValuesType xsdcValues : xsdcForcedConfigCriterionType.getValues()) {
		aidlForcedConfigs.reserve(xsdcValues.getValue().size());
		for (const eng_xsd::ValueType& xsdcValue : xsdcValues.getValue()) {
		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));
		aidlForcedConfigs.push_back(
		VALUE_OR_RETURN(convertForceUseToAidl(criterionValue, xsdcValue.getLiteral())));
		}
		}
		return aidlForcedConfigs;
		}

		ConversionResult<AudioPolicyForceUse> convertForceUseCriterionToAidl(
		const std::string& xsdcCriterionName) {
		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) {
		if (!fastcmp<strncmp>(xsdcCriterionName.c_str(), 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,
		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,
		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,
		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,
		strlen(kXsdcForceConfigForSystem))) {
		return AudioPolicyForceUse::SYSTEM;
		return AudioPolicyForceUse::make<AudioPolicyForceUse::systemSounds>(xsdcCriterionValue ==
		"SYSTEM_ENFORCED");
		}
		if (!fasticmp<strncmp>(xsdcCriterionName.c_str(), 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,
		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,
		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;
		return unexpected(BAD_VALUE);
		@@ -747,9 +786,8 @@ ConversionResult<AudioHalCapCriterionV2> convertCapCriterionV2ToAidl(
		}
		if (!fastcmp<strncmp>(xsdcCriterion.getName().c_str(), kXsdcForceConfigForUse,
		strlen(kXsdcForceConfigForUse))) {
		return AudioHalCapCriterionV2::make<Tag::forceConfigForUse>(
		VALUE_OR_RETURN(convertForceUseCriterionToAidl(xsdcCriterion.getName())),
		VALUE_OR_RETURN(convertForcedConfigsToAidl(xsdcCriterionType)));
		return AudioHalCapCriterionV2::make<Tag::forceConfigForUse>(VALUE_OR_RETURN(
		convertForceUseConfigsToAidl(xsdcCriterion.getName(), xsdcCriterionType)));
		}
		LOG(ERROR) << __func__ << " unrecognized criterion " << xsdcCriterion.getName();
		return unexpected(BAD_VALUE);

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

+39 −2

Original line number	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>);
		}

		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;
		@@ -244,10 +283,8 @@ 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 {

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

+46 −5

Original line number	Diff line number	Diff line
		@@ -191,10 +191,9 @@
		<xs:complexType name="valueType">
		<xs:annotation>
		<xs:documentation xml:lang="en">
		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.
		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.
		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.
		@@ -203,7 +202,6 @@
		</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>

		@@ -409,6 +407,49 @@
		</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"/>