1 #include <map> 2 3 #include "android_audio_policy_engine_configuration_enums.h" 4 5 namespace android { 6 namespace audio { 7 namespace policy { 8 namespace engine { 9 namespace configuration { 10 const std::map<std::string, Version> VersionString { 11 { "1.0", Version::_1_0 }, 12 }; 13 stringToVersion(const std::string & value)14 Version stringToVersion(const std::string& value) { 15 auto enumValue = VersionString.find(value); 16 return enumValue != VersionString.end() ? enumValue->second : Version::UNKNOWN; 17 } 18 toString(Version o)19 std::string toString(Version o) { 20 switch (o) { 21 case Version::_1_0: return "1.0"; 22 default: return std::to_string(static_cast<int>(o)); 23 } 24 } 25 26 const std::map<std::string, Stream> StreamString { 27 { "AUDIO_STREAM_DEFAULT", Stream::AUDIO_STREAM_DEFAULT }, 28 { "AUDIO_STREAM_VOICE_CALL", Stream::AUDIO_STREAM_VOICE_CALL }, 29 { "AUDIO_STREAM_SYSTEM", Stream::AUDIO_STREAM_SYSTEM }, 30 { "AUDIO_STREAM_RING", Stream::AUDIO_STREAM_RING }, 31 { "AUDIO_STREAM_MUSIC", Stream::AUDIO_STREAM_MUSIC }, 32 { "AUDIO_STREAM_ALARM", Stream::AUDIO_STREAM_ALARM }, 33 { "AUDIO_STREAM_NOTIFICATION", Stream::AUDIO_STREAM_NOTIFICATION }, 34 { "AUDIO_STREAM_BLUETOOTH_SCO", Stream::AUDIO_STREAM_BLUETOOTH_SCO }, 35 { "AUDIO_STREAM_ENFORCED_AUDIBLE", Stream::AUDIO_STREAM_ENFORCED_AUDIBLE }, 36 { "AUDIO_STREAM_DTMF", Stream::AUDIO_STREAM_DTMF }, 37 { "AUDIO_STREAM_TTS", Stream::AUDIO_STREAM_TTS }, 38 { "AUDIO_STREAM_ACCESSIBILITY", Stream::AUDIO_STREAM_ACCESSIBILITY }, 39 { "AUDIO_STREAM_ASSISTANT", Stream::AUDIO_STREAM_ASSISTANT }, 40 }; 41 stringToStream(const std::string & value)42 Stream stringToStream(const std::string& value) { 43 auto enumValue = StreamString.find(value); 44 return enumValue != StreamString.end() ? enumValue->second : Stream::UNKNOWN; 45 } 46 toString(Stream o)47 std::string toString(Stream o) { 48 switch (o) { 49 case Stream::AUDIO_STREAM_DEFAULT: return "AUDIO_STREAM_DEFAULT"; 50 case Stream::AUDIO_STREAM_VOICE_CALL: return "AUDIO_STREAM_VOICE_CALL"; 51 case Stream::AUDIO_STREAM_SYSTEM: return "AUDIO_STREAM_SYSTEM"; 52 case Stream::AUDIO_STREAM_RING: return "AUDIO_STREAM_RING"; 53 case Stream::AUDIO_STREAM_MUSIC: return "AUDIO_STREAM_MUSIC"; 54 case Stream::AUDIO_STREAM_ALARM: return "AUDIO_STREAM_ALARM"; 55 case Stream::AUDIO_STREAM_NOTIFICATION: return "AUDIO_STREAM_NOTIFICATION"; 56 case Stream::AUDIO_STREAM_BLUETOOTH_SCO: return "AUDIO_STREAM_BLUETOOTH_SCO"; 57 case Stream::AUDIO_STREAM_ENFORCED_AUDIBLE: return "AUDIO_STREAM_ENFORCED_AUDIBLE"; 58 case Stream::AUDIO_STREAM_DTMF: return "AUDIO_STREAM_DTMF"; 59 case Stream::AUDIO_STREAM_TTS: return "AUDIO_STREAM_TTS"; 60 case Stream::AUDIO_STREAM_ACCESSIBILITY: return "AUDIO_STREAM_ACCESSIBILITY"; 61 case Stream::AUDIO_STREAM_ASSISTANT: return "AUDIO_STREAM_ASSISTANT"; 62 default: return std::to_string(static_cast<int>(o)); 63 } 64 } 65 66 const std::map<std::string, DeviceCategory> DeviceCategoryString { 67 { "DEVICE_CATEGORY_HEADSET", DeviceCategory::DEVICE_CATEGORY_HEADSET }, 68 { "DEVICE_CATEGORY_SPEAKER", DeviceCategory::DEVICE_CATEGORY_SPEAKER }, 69 { "DEVICE_CATEGORY_EARPIECE", DeviceCategory::DEVICE_CATEGORY_EARPIECE }, 70 { "DEVICE_CATEGORY_EXT_MEDIA", DeviceCategory::DEVICE_CATEGORY_EXT_MEDIA }, 71 { "DEVICE_CATEGORY_HEARING_AID", DeviceCategory::DEVICE_CATEGORY_HEARING_AID }, 72 }; 73 stringToDeviceCategory(const std::string & value)74 DeviceCategory stringToDeviceCategory(const std::string& value) { 75 auto enumValue = DeviceCategoryString.find(value); 76 return enumValue != DeviceCategoryString.end() ? enumValue->second : DeviceCategory::UNKNOWN; 77 } 78 toString(DeviceCategory o)79 std::string toString(DeviceCategory o) { 80 switch (o) { 81 case DeviceCategory::DEVICE_CATEGORY_HEADSET: return "DEVICE_CATEGORY_HEADSET"; 82 case DeviceCategory::DEVICE_CATEGORY_SPEAKER: return "DEVICE_CATEGORY_SPEAKER"; 83 case DeviceCategory::DEVICE_CATEGORY_EARPIECE: return "DEVICE_CATEGORY_EARPIECE"; 84 case DeviceCategory::DEVICE_CATEGORY_EXT_MEDIA: return "DEVICE_CATEGORY_EXT_MEDIA"; 85 case DeviceCategory::DEVICE_CATEGORY_HEARING_AID: return "DEVICE_CATEGORY_HEARING_AID"; 86 default: return std::to_string(static_cast<int>(o)); 87 } 88 } 89 90 const std::map<std::string, ContentType> ContentTypeString { 91 { "AUDIO_CONTENT_TYPE_UNKNOWN", ContentType::AUDIO_CONTENT_TYPE_UNKNOWN }, 92 { "AUDIO_CONTENT_TYPE_SPEECH", ContentType::AUDIO_CONTENT_TYPE_SPEECH }, 93 { "AUDIO_CONTENT_TYPE_MUSIC", ContentType::AUDIO_CONTENT_TYPE_MUSIC }, 94 { "AUDIO_CONTENT_TYPE_MOVIE", ContentType::AUDIO_CONTENT_TYPE_MOVIE }, 95 { "AUDIO_CONTENT_TYPE_SONIFICATION", ContentType::AUDIO_CONTENT_TYPE_SONIFICATION }, 96 }; 97 stringToContentType(const std::string & value)98 ContentType stringToContentType(const std::string& value) { 99 auto enumValue = ContentTypeString.find(value); 100 return enumValue != ContentTypeString.end() ? enumValue->second : ContentType::UNKNOWN; 101 } 102 toString(ContentType o)103 std::string toString(ContentType o) { 104 switch (o) { 105 case ContentType::AUDIO_CONTENT_TYPE_UNKNOWN: return "AUDIO_CONTENT_TYPE_UNKNOWN"; 106 case ContentType::AUDIO_CONTENT_TYPE_SPEECH: return "AUDIO_CONTENT_TYPE_SPEECH"; 107 case ContentType::AUDIO_CONTENT_TYPE_MUSIC: return "AUDIO_CONTENT_TYPE_MUSIC"; 108 case ContentType::AUDIO_CONTENT_TYPE_MOVIE: return "AUDIO_CONTENT_TYPE_MOVIE"; 109 case ContentType::AUDIO_CONTENT_TYPE_SONIFICATION: return "AUDIO_CONTENT_TYPE_SONIFICATION"; 110 default: return std::to_string(static_cast<int>(o)); 111 } 112 } 113 114 const std::map<std::string, UsageEnumType> UsageEnumTypeString { 115 { "AUDIO_USAGE_UNKNOWN", UsageEnumType::AUDIO_USAGE_UNKNOWN }, 116 { "AUDIO_USAGE_MEDIA", UsageEnumType::AUDIO_USAGE_MEDIA }, 117 { "AUDIO_USAGE_VOICE_COMMUNICATION", UsageEnumType::AUDIO_USAGE_VOICE_COMMUNICATION }, 118 { "AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING", UsageEnumType::AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING }, 119 { "AUDIO_USAGE_ALARM", UsageEnumType::AUDIO_USAGE_ALARM }, 120 { "AUDIO_USAGE_NOTIFICATION", UsageEnumType::AUDIO_USAGE_NOTIFICATION }, 121 { "AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE", UsageEnumType::AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE }, 122 { "AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST", UsageEnumType::AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST }, 123 { "AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT", UsageEnumType::AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT }, 124 { "AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED", UsageEnumType::AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED }, 125 { "AUDIO_USAGE_NOTIFICATION_EVENT", UsageEnumType::AUDIO_USAGE_NOTIFICATION_EVENT }, 126 { "AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY", UsageEnumType::AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY }, 127 { "AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE", UsageEnumType::AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE }, 128 { "AUDIO_USAGE_ASSISTANCE_SONIFICATION", UsageEnumType::AUDIO_USAGE_ASSISTANCE_SONIFICATION }, 129 { "AUDIO_USAGE_GAME", UsageEnumType::AUDIO_USAGE_GAME }, 130 { "AUDIO_USAGE_VIRTUAL_SOURCE", UsageEnumType::AUDIO_USAGE_VIRTUAL_SOURCE }, 131 { "AUDIO_USAGE_ASSISTANT", UsageEnumType::AUDIO_USAGE_ASSISTANT }, 132 { "AUDIO_USAGE_CALL_ASSISTANT", UsageEnumType::AUDIO_USAGE_CALL_ASSISTANT }, 133 { "AUDIO_USAGE_EMERGENCY", UsageEnumType::AUDIO_USAGE_EMERGENCY }, 134 { "AUDIO_USAGE_SAFETY", UsageEnumType::AUDIO_USAGE_SAFETY }, 135 { "AUDIO_USAGE_VEHICLE_STATUS", UsageEnumType::AUDIO_USAGE_VEHICLE_STATUS }, 136 { "AUDIO_USAGE_ANNOUNCEMENT", UsageEnumType::AUDIO_USAGE_ANNOUNCEMENT }, 137 { "AUDIO_USAGE_SPEAKER_CLEANUP", UsageEnumType::AUDIO_USAGE_SPEAKER_CLEANUP }, 138 }; 139 stringToUsageEnumType(const std::string & value)140 UsageEnumType stringToUsageEnumType(const std::string& value) { 141 auto enumValue = UsageEnumTypeString.find(value); 142 return enumValue != UsageEnumTypeString.end() ? enumValue->second : UsageEnumType::UNKNOWN; 143 } 144 toString(UsageEnumType o)145 std::string toString(UsageEnumType o) { 146 switch (o) { 147 case UsageEnumType::AUDIO_USAGE_UNKNOWN: return "AUDIO_USAGE_UNKNOWN"; 148 case UsageEnumType::AUDIO_USAGE_MEDIA: return "AUDIO_USAGE_MEDIA"; 149 case UsageEnumType::AUDIO_USAGE_VOICE_COMMUNICATION: return "AUDIO_USAGE_VOICE_COMMUNICATION"; 150 case UsageEnumType::AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING: return "AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING"; 151 case UsageEnumType::AUDIO_USAGE_ALARM: return "AUDIO_USAGE_ALARM"; 152 case UsageEnumType::AUDIO_USAGE_NOTIFICATION: return "AUDIO_USAGE_NOTIFICATION"; 153 case UsageEnumType::AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE: return "AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE"; 154 case UsageEnumType::AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST: return "AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST"; 155 case UsageEnumType::AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT: return "AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT"; 156 case UsageEnumType::AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED: return "AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED"; 157 case UsageEnumType::AUDIO_USAGE_NOTIFICATION_EVENT: return "AUDIO_USAGE_NOTIFICATION_EVENT"; 158 case UsageEnumType::AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY: return "AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY"; 159 case UsageEnumType::AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE: return "AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE"; 160 case UsageEnumType::AUDIO_USAGE_ASSISTANCE_SONIFICATION: return "AUDIO_USAGE_ASSISTANCE_SONIFICATION"; 161 case UsageEnumType::AUDIO_USAGE_GAME: return "AUDIO_USAGE_GAME"; 162 case UsageEnumType::AUDIO_USAGE_VIRTUAL_SOURCE: return "AUDIO_USAGE_VIRTUAL_SOURCE"; 163 case UsageEnumType::AUDIO_USAGE_ASSISTANT: return "AUDIO_USAGE_ASSISTANT"; 164 case UsageEnumType::AUDIO_USAGE_CALL_ASSISTANT: return "AUDIO_USAGE_CALL_ASSISTANT"; 165 case UsageEnumType::AUDIO_USAGE_EMERGENCY: return "AUDIO_USAGE_EMERGENCY"; 166 case UsageEnumType::AUDIO_USAGE_SAFETY: return "AUDIO_USAGE_SAFETY"; 167 case UsageEnumType::AUDIO_USAGE_VEHICLE_STATUS: return "AUDIO_USAGE_VEHICLE_STATUS"; 168 case UsageEnumType::AUDIO_USAGE_ANNOUNCEMENT: return "AUDIO_USAGE_ANNOUNCEMENT"; 169 case UsageEnumType::AUDIO_USAGE_SPEAKER_CLEANUP: return "AUDIO_USAGE_SPEAKER_CLEANUP"; 170 default: return std::to_string(static_cast<int>(o)); 171 } 172 } 173 174 const std::map<std::string, FlagType> FlagTypeString { 175 { "AUDIO_FLAG_NONE", FlagType::AUDIO_FLAG_NONE }, 176 { "AUDIO_FLAG_AUDIBILITY_ENFORCED", FlagType::AUDIO_FLAG_AUDIBILITY_ENFORCED }, 177 { "AUDIO_FLAG_SECURE", FlagType::AUDIO_FLAG_SECURE }, 178 { "AUDIO_FLAG_SCO", FlagType::AUDIO_FLAG_SCO }, 179 { "AUDIO_FLAG_BEACON", FlagType::AUDIO_FLAG_BEACON }, 180 { "AUDIO_FLAG_HW_AV_SYNC", FlagType::AUDIO_FLAG_HW_AV_SYNC }, 181 { "AUDIO_FLAG_HW_HOTWORD", FlagType::AUDIO_FLAG_HW_HOTWORD }, 182 { "AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY", FlagType::AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY }, 183 { "AUDIO_FLAG_BYPASS_MUTE", FlagType::AUDIO_FLAG_BYPASS_MUTE }, 184 { "AUDIO_FLAG_LOW_LATENCY", FlagType::AUDIO_FLAG_LOW_LATENCY }, 185 { "AUDIO_FLAG_DEEP_BUFFER", FlagType::AUDIO_FLAG_DEEP_BUFFER }, 186 { "AUDIO_FLAG_NO_MEDIA_PROJECTION", FlagType::AUDIO_FLAG_NO_MEDIA_PROJECTION }, 187 { "AUDIO_FLAG_MUTE_HAPTIC", FlagType::AUDIO_FLAG_MUTE_HAPTIC }, 188 { "AUDIO_FLAG_NO_SYSTEM_CAPTURE", FlagType::AUDIO_FLAG_NO_SYSTEM_CAPTURE }, 189 { "AUDIO_FLAG_CAPTURE_PRIVATE", FlagType::AUDIO_FLAG_CAPTURE_PRIVATE }, 190 }; 191 stringToFlagType(const std::string & value)192 FlagType stringToFlagType(const std::string& value) { 193 auto enumValue = FlagTypeString.find(value); 194 return enumValue != FlagTypeString.end() ? enumValue->second : FlagType::UNKNOWN; 195 } 196 toString(FlagType o)197 std::string toString(FlagType o) { 198 switch (o) { 199 case FlagType::AUDIO_FLAG_NONE: return "AUDIO_FLAG_NONE"; 200 case FlagType::AUDIO_FLAG_AUDIBILITY_ENFORCED: return "AUDIO_FLAG_AUDIBILITY_ENFORCED"; 201 case FlagType::AUDIO_FLAG_SECURE: return "AUDIO_FLAG_SECURE"; 202 case FlagType::AUDIO_FLAG_SCO: return "AUDIO_FLAG_SCO"; 203 case FlagType::AUDIO_FLAG_BEACON: return "AUDIO_FLAG_BEACON"; 204 case FlagType::AUDIO_FLAG_HW_AV_SYNC: return "AUDIO_FLAG_HW_AV_SYNC"; 205 case FlagType::AUDIO_FLAG_HW_HOTWORD: return "AUDIO_FLAG_HW_HOTWORD"; 206 case FlagType::AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY: return "AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY"; 207 case FlagType::AUDIO_FLAG_BYPASS_MUTE: return "AUDIO_FLAG_BYPASS_MUTE"; 208 case FlagType::AUDIO_FLAG_LOW_LATENCY: return "AUDIO_FLAG_LOW_LATENCY"; 209 case FlagType::AUDIO_FLAG_DEEP_BUFFER: return "AUDIO_FLAG_DEEP_BUFFER"; 210 case FlagType::AUDIO_FLAG_NO_MEDIA_PROJECTION: return "AUDIO_FLAG_NO_MEDIA_PROJECTION"; 211 case FlagType::AUDIO_FLAG_MUTE_HAPTIC: return "AUDIO_FLAG_MUTE_HAPTIC"; 212 case FlagType::AUDIO_FLAG_NO_SYSTEM_CAPTURE: return "AUDIO_FLAG_NO_SYSTEM_CAPTURE"; 213 case FlagType::AUDIO_FLAG_CAPTURE_PRIVATE: return "AUDIO_FLAG_CAPTURE_PRIVATE"; 214 default: return std::to_string(static_cast<int>(o)); 215 } 216 } 217 218 const std::map<std::string, ForcedConfigCommunicationDeviceType> ForcedConfigCommunicationDeviceTypeString { 219 { "NONE", ForcedConfigCommunicationDeviceType::NONE }, 220 { "SPEAKER", ForcedConfigCommunicationDeviceType::SPEAKER }, 221 { "BT_SCO", ForcedConfigCommunicationDeviceType::BT_SCO }, 222 { "BT_BLE", ForcedConfigCommunicationDeviceType::BT_BLE }, 223 { "WIRED_ACCESSORY", ForcedConfigCommunicationDeviceType::WIRED_ACCESSORY }, 224 }; 225 stringToForcedConfigCommunicationDeviceType(const std::string & value)226 ForcedConfigCommunicationDeviceType stringToForcedConfigCommunicationDeviceType(const std::string& value) { 227 auto enumValue = ForcedConfigCommunicationDeviceTypeString.find(value); 228 return enumValue != ForcedConfigCommunicationDeviceTypeString.end() ? enumValue->second : ForcedConfigCommunicationDeviceType::UNKNOWN; 229 } 230 toString(ForcedConfigCommunicationDeviceType o)231 std::string toString(ForcedConfigCommunicationDeviceType o) { 232 switch (o) { 233 case ForcedConfigCommunicationDeviceType::NONE: return "NONE"; 234 case ForcedConfigCommunicationDeviceType::SPEAKER: return "SPEAKER"; 235 case ForcedConfigCommunicationDeviceType::BT_SCO: return "BT_SCO"; 236 case ForcedConfigCommunicationDeviceType::BT_BLE: return "BT_BLE"; 237 case ForcedConfigCommunicationDeviceType::WIRED_ACCESSORY: return "WIRED_ACCESSORY"; 238 default: return std::to_string(static_cast<int>(o)); 239 } 240 } 241 242 const std::map<std::string, ForcedConfigMediaDeviceType> ForcedConfigMediaDeviceTypeString { 243 { "NONE", ForcedConfigMediaDeviceType::NONE }, 244 { "SPEAKER", ForcedConfigMediaDeviceType::SPEAKER }, 245 { "HEADPHONES", ForcedConfigMediaDeviceType::HEADPHONES }, 246 { "BT_A2DP", ForcedConfigMediaDeviceType::BT_A2DP }, 247 { "ANALOG_DOCK", ForcedConfigMediaDeviceType::ANALOG_DOCK }, 248 { "DIGITAL_DOCK", ForcedConfigMediaDeviceType::DIGITAL_DOCK }, 249 { "WIRED_ACCESSORY", ForcedConfigMediaDeviceType::WIRED_ACCESSORY }, 250 { "NO_BT_A2DP", ForcedConfigMediaDeviceType::NO_BT_A2DP }, 251 }; 252 stringToForcedConfigMediaDeviceType(const std::string & value)253 ForcedConfigMediaDeviceType stringToForcedConfigMediaDeviceType(const std::string& value) { 254 auto enumValue = ForcedConfigMediaDeviceTypeString.find(value); 255 return enumValue != ForcedConfigMediaDeviceTypeString.end() ? enumValue->second : ForcedConfigMediaDeviceType::UNKNOWN; 256 } 257 toString(ForcedConfigMediaDeviceType o)258 std::string toString(ForcedConfigMediaDeviceType o) { 259 switch (o) { 260 case ForcedConfigMediaDeviceType::NONE: return "NONE"; 261 case ForcedConfigMediaDeviceType::SPEAKER: return "SPEAKER"; 262 case ForcedConfigMediaDeviceType::HEADPHONES: return "HEADPHONES"; 263 case ForcedConfigMediaDeviceType::BT_A2DP: return "BT_A2DP"; 264 case ForcedConfigMediaDeviceType::ANALOG_DOCK: return "ANALOG_DOCK"; 265 case ForcedConfigMediaDeviceType::DIGITAL_DOCK: return "DIGITAL_DOCK"; 266 case ForcedConfigMediaDeviceType::WIRED_ACCESSORY: return "WIRED_ACCESSORY"; 267 case ForcedConfigMediaDeviceType::NO_BT_A2DP: return "NO_BT_A2DP"; 268 default: return std::to_string(static_cast<int>(o)); 269 } 270 } 271 272 const std::map<std::string, ForcedConfigDockType> ForcedConfigDockTypeString { 273 { "NONE", ForcedConfigDockType::NONE }, 274 { "BT_CAR_DOCK", ForcedConfigDockType::BT_CAR_DOCK }, 275 { "BT_DESK_DOCK", ForcedConfigDockType::BT_DESK_DOCK }, 276 { "ANALOG_DOCK", ForcedConfigDockType::ANALOG_DOCK }, 277 { "DIGITAL_DOCK", ForcedConfigDockType::DIGITAL_DOCK }, 278 { "WIRED_ACCESSORY", ForcedConfigDockType::WIRED_ACCESSORY }, 279 }; 280 stringToForcedConfigDockType(const std::string & value)281 ForcedConfigDockType stringToForcedConfigDockType(const std::string& value) { 282 auto enumValue = ForcedConfigDockTypeString.find(value); 283 return enumValue != ForcedConfigDockTypeString.end() ? enumValue->second : ForcedConfigDockType::UNKNOWN; 284 } 285 toString(ForcedConfigDockType o)286 std::string toString(ForcedConfigDockType o) { 287 switch (o) { 288 case ForcedConfigDockType::NONE: return "NONE"; 289 case ForcedConfigDockType::BT_CAR_DOCK: return "BT_CAR_DOCK"; 290 case ForcedConfigDockType::BT_DESK_DOCK: return "BT_DESK_DOCK"; 291 case ForcedConfigDockType::ANALOG_DOCK: return "ANALOG_DOCK"; 292 case ForcedConfigDockType::DIGITAL_DOCK: return "DIGITAL_DOCK"; 293 case ForcedConfigDockType::WIRED_ACCESSORY: return "WIRED_ACCESSORY"; 294 default: return std::to_string(static_cast<int>(o)); 295 } 296 } 297 298 const std::map<std::string, ForcedEncodingSourroundConfigType> ForcedEncodingSourroundConfigTypeString { 299 { "UNSPECIFIED", ForcedEncodingSourroundConfigType::UNSPECIFIED }, 300 { "NEVER", ForcedEncodingSourroundConfigType::NEVER }, 301 { "ALWAYS", ForcedEncodingSourroundConfigType::ALWAYS }, 302 { "MANUAL", ForcedEncodingSourroundConfigType::MANUAL }, 303 }; 304 stringToForcedEncodingSourroundConfigType(const std::string & value)305 ForcedEncodingSourroundConfigType stringToForcedEncodingSourroundConfigType(const std::string& value) { 306 auto enumValue = ForcedEncodingSourroundConfigTypeString.find(value); 307 return enumValue != ForcedEncodingSourroundConfigTypeString.end() ? enumValue->second : ForcedEncodingSourroundConfigType::UNKNOWN; 308 } 309 toString(ForcedEncodingSourroundConfigType o)310 std::string toString(ForcedEncodingSourroundConfigType o) { 311 switch (o) { 312 case ForcedEncodingSourroundConfigType::UNSPECIFIED: return "UNSPECIFIED"; 313 case ForcedEncodingSourroundConfigType::NEVER: return "NEVER"; 314 case ForcedEncodingSourroundConfigType::ALWAYS: return "ALWAYS"; 315 case ForcedEncodingSourroundConfigType::MANUAL: return "MANUAL"; 316 default: return std::to_string(static_cast<int>(o)); 317 } 318 } 319 320 const std::map<std::string, SourceEnumType> SourceEnumTypeString { 321 { "AUDIO_SOURCE_DEFAULT", SourceEnumType::AUDIO_SOURCE_DEFAULT }, 322 { "AUDIO_SOURCE_MIC", SourceEnumType::AUDIO_SOURCE_MIC }, 323 { "AUDIO_SOURCE_VOICE_UPLINK", SourceEnumType::AUDIO_SOURCE_VOICE_UPLINK }, 324 { "AUDIO_SOURCE_VOICE_DOWNLINK", SourceEnumType::AUDIO_SOURCE_VOICE_DOWNLINK }, 325 { "AUDIO_SOURCE_VOICE_CALL", SourceEnumType::AUDIO_SOURCE_VOICE_CALL }, 326 { "AUDIO_SOURCE_CAMCORDER", SourceEnumType::AUDIO_SOURCE_CAMCORDER }, 327 { "AUDIO_SOURCE_VOICE_RECOGNITION", SourceEnumType::AUDIO_SOURCE_VOICE_RECOGNITION }, 328 { "AUDIO_SOURCE_VOICE_COMMUNICATION", SourceEnumType::AUDIO_SOURCE_VOICE_COMMUNICATION }, 329 { "AUDIO_SOURCE_REMOTE_SUBMIX", SourceEnumType::AUDIO_SOURCE_REMOTE_SUBMIX }, 330 { "AUDIO_SOURCE_UNPROCESSED", SourceEnumType::AUDIO_SOURCE_UNPROCESSED }, 331 { "AUDIO_SOURCE_VOICE_PERFORMANCE", SourceEnumType::AUDIO_SOURCE_VOICE_PERFORMANCE }, 332 { "AUDIO_SOURCE_ECHO_REFERENCE", SourceEnumType::AUDIO_SOURCE_ECHO_REFERENCE }, 333 { "AUDIO_SOURCE_FM_TUNER", SourceEnumType::AUDIO_SOURCE_FM_TUNER }, 334 }; 335 stringToSourceEnumType(const std::string & value)336 SourceEnumType stringToSourceEnumType(const std::string& value) { 337 auto enumValue = SourceEnumTypeString.find(value); 338 return enumValue != SourceEnumTypeString.end() ? enumValue->second : SourceEnumType::UNKNOWN; 339 } 340 toString(SourceEnumType o)341 std::string toString(SourceEnumType o) { 342 switch (o) { 343 case SourceEnumType::AUDIO_SOURCE_DEFAULT: return "AUDIO_SOURCE_DEFAULT"; 344 case SourceEnumType::AUDIO_SOURCE_MIC: return "AUDIO_SOURCE_MIC"; 345 case SourceEnumType::AUDIO_SOURCE_VOICE_UPLINK: return "AUDIO_SOURCE_VOICE_UPLINK"; 346 case SourceEnumType::AUDIO_SOURCE_VOICE_DOWNLINK: return "AUDIO_SOURCE_VOICE_DOWNLINK"; 347 case SourceEnumType::AUDIO_SOURCE_VOICE_CALL: return "AUDIO_SOURCE_VOICE_CALL"; 348 case SourceEnumType::AUDIO_SOURCE_CAMCORDER: return "AUDIO_SOURCE_CAMCORDER"; 349 case SourceEnumType::AUDIO_SOURCE_VOICE_RECOGNITION: return "AUDIO_SOURCE_VOICE_RECOGNITION"; 350 case SourceEnumType::AUDIO_SOURCE_VOICE_COMMUNICATION: return "AUDIO_SOURCE_VOICE_COMMUNICATION"; 351 case SourceEnumType::AUDIO_SOURCE_REMOTE_SUBMIX: return "AUDIO_SOURCE_REMOTE_SUBMIX"; 352 case SourceEnumType::AUDIO_SOURCE_UNPROCESSED: return "AUDIO_SOURCE_UNPROCESSED"; 353 case SourceEnumType::AUDIO_SOURCE_VOICE_PERFORMANCE: return "AUDIO_SOURCE_VOICE_PERFORMANCE"; 354 case SourceEnumType::AUDIO_SOURCE_ECHO_REFERENCE: return "AUDIO_SOURCE_ECHO_REFERENCE"; 355 case SourceEnumType::AUDIO_SOURCE_FM_TUNER: return "AUDIO_SOURCE_FM_TUNER"; 356 default: return std::to_string(static_cast<int>(o)); 357 } 358 } 359 360 const std::map<std::string, PfwCriterionTypeEnum> PfwCriterionTypeEnumString { 361 { "inclusive", PfwCriterionTypeEnum::inclusive }, 362 { "exclusive", PfwCriterionTypeEnum::exclusive }, 363 }; 364 stringToPfwCriterionTypeEnum(const std::string & value)365 PfwCriterionTypeEnum stringToPfwCriterionTypeEnum(const std::string& value) { 366 auto enumValue = PfwCriterionTypeEnumString.find(value); 367 return enumValue != PfwCriterionTypeEnumString.end() ? enumValue->second : PfwCriterionTypeEnum::UNKNOWN; 368 } 369 toString(PfwCriterionTypeEnum o)370 std::string toString(PfwCriterionTypeEnum o) { 371 switch (o) { 372 case PfwCriterionTypeEnum::inclusive: return "inclusive"; 373 case PfwCriterionTypeEnum::exclusive: return "exclusive"; 374 default: return std::to_string(static_cast<int>(o)); 375 } 376 } 377 378 } // configuration 379 } // engine 380 } // policy 381 } // audio 382 } // android 383