1 #include <map>
2 
3 #include "android_audio_policy_capengine_configuration_enums.h"
4 
5 namespace android {
6     namespace audio {
7         namespace policy {
8             namespace capengine {
9                 namespace configuration {
10                     const std::map<std::string, ParameterNameEnumType> ParameterNameEnumTypeString {
11                         { "volume_profile", ParameterNameEnumType::volume_profile },
12                         { "communication", ParameterNameEnumType::communication },
13                         { "ambient", ParameterNameEnumType::ambient },
14                         { "builtin_mic", ParameterNameEnumType::builtin_mic },
15                         { "bluetooth_sco_headset", ParameterNameEnumType::bluetooth_sco_headset },
16                         { "wired_headset", ParameterNameEnumType::wired_headset },
17                         { "hdmi", ParameterNameEnumType::hdmi },
18                         { "telephony_rx", ParameterNameEnumType::telephony_rx },
19                         { "back_mic", ParameterNameEnumType::back_mic },
20                         { "remote_submix", ParameterNameEnumType::remote_submix },
21                         { "anlg_dock_headset", ParameterNameEnumType::anlg_dock_headset },
22                         { "dgtl_dock_headset", ParameterNameEnumType::dgtl_dock_headset },
23                         { "usb_accessory", ParameterNameEnumType::usb_accessory },
24                         { "usb_device", ParameterNameEnumType::usb_device },
25                         { "fm_tuner", ParameterNameEnumType::fm_tuner },
26                         { "tv_tuner", ParameterNameEnumType::tv_tuner },
27                         { "line", ParameterNameEnumType::line },
28                         { "spdif", ParameterNameEnumType::spdif },
29                         { "bluetooth_a2dp", ParameterNameEnumType::bluetooth_a2dp },
30                         { "loopback", ParameterNameEnumType::loopback },
31                         { "ip", ParameterNameEnumType::ip },
32                         { "bus", ParameterNameEnumType::bus },
33                         { "proxy", ParameterNameEnumType::proxy },
34                         { "usb_headset", ParameterNameEnumType::usb_headset },
35                         { "bluetooth_ble", ParameterNameEnumType::bluetooth_ble },
36                         { "hdmi_arc", ParameterNameEnumType::hdmi_arc },
37                         { "echo_reference", ParameterNameEnumType::echo_reference },
38                         { "ble_headset", ParameterNameEnumType::ble_headset },
39                         { "stub", ParameterNameEnumType::stub },
40                         { "hdmi_earc", ParameterNameEnumType::hdmi_earc },
41                         { "device_address", ParameterNameEnumType::device_address },
42                         { "earpiece", ParameterNameEnumType::earpiece },
43                         { "speaker", ParameterNameEnumType::speaker },
44                         { "wired_headphone", ParameterNameEnumType::wired_headphone },
45                         { "bluetooth_sco", ParameterNameEnumType::bluetooth_sco },
46                         { "bluetooth_sco_carkit", ParameterNameEnumType::bluetooth_sco_carkit },
47                         { "bluetooth_a2dp_headphones", ParameterNameEnumType::bluetooth_a2dp_headphones },
48                         { "bluetooth_a2dp_speaker", ParameterNameEnumType::bluetooth_a2dp_speaker },
49                         { "telephony_tx", ParameterNameEnumType::telephony_tx },
50                         { "fm", ParameterNameEnumType::fm },
51                         { "aux_line", ParameterNameEnumType::aux_line },
52                         { "speaker_safe", ParameterNameEnumType::speaker_safe },
53                         { "hearing_aid", ParameterNameEnumType::hearing_aid },
54                         { "echo_canceller", ParameterNameEnumType::echo_canceller },
55                         { "ble_speaker", ParameterNameEnumType::ble_speaker },
56                         { "ble_broadcast", ParameterNameEnumType::ble_broadcast },
57                     };
58 
stringToParameterNameEnumType(const std::string & value)59                     ParameterNameEnumType stringToParameterNameEnumType(const std::string& value) {
60                         auto enumValue = ParameterNameEnumTypeString.find(value);
61                         return enumValue != ParameterNameEnumTypeString.end() ? enumValue->second : ParameterNameEnumType::UNKNOWN;
62                     }
63 
toString(ParameterNameEnumType o)64                     std::string toString(ParameterNameEnumType o) {
65                         switch (o) {
66                             case ParameterNameEnumType::volume_profile: return "volume_profile";
67                             case ParameterNameEnumType::communication: return "communication";
68                             case ParameterNameEnumType::ambient: return "ambient";
69                             case ParameterNameEnumType::builtin_mic: return "builtin_mic";
70                             case ParameterNameEnumType::bluetooth_sco_headset: return "bluetooth_sco_headset";
71                             case ParameterNameEnumType::wired_headset: return "wired_headset";
72                             case ParameterNameEnumType::hdmi: return "hdmi";
73                             case ParameterNameEnumType::telephony_rx: return "telephony_rx";
74                             case ParameterNameEnumType::back_mic: return "back_mic";
75                             case ParameterNameEnumType::remote_submix: return "remote_submix";
76                             case ParameterNameEnumType::anlg_dock_headset: return "anlg_dock_headset";
77                             case ParameterNameEnumType::dgtl_dock_headset: return "dgtl_dock_headset";
78                             case ParameterNameEnumType::usb_accessory: return "usb_accessory";
79                             case ParameterNameEnumType::usb_device: return "usb_device";
80                             case ParameterNameEnumType::fm_tuner: return "fm_tuner";
81                             case ParameterNameEnumType::tv_tuner: return "tv_tuner";
82                             case ParameterNameEnumType::line: return "line";
83                             case ParameterNameEnumType::spdif: return "spdif";
84                             case ParameterNameEnumType::bluetooth_a2dp: return "bluetooth_a2dp";
85                             case ParameterNameEnumType::loopback: return "loopback";
86                             case ParameterNameEnumType::ip: return "ip";
87                             case ParameterNameEnumType::bus: return "bus";
88                             case ParameterNameEnumType::proxy: return "proxy";
89                             case ParameterNameEnumType::usb_headset: return "usb_headset";
90                             case ParameterNameEnumType::bluetooth_ble: return "bluetooth_ble";
91                             case ParameterNameEnumType::hdmi_arc: return "hdmi_arc";
92                             case ParameterNameEnumType::echo_reference: return "echo_reference";
93                             case ParameterNameEnumType::ble_headset: return "ble_headset";
94                             case ParameterNameEnumType::stub: return "stub";
95                             case ParameterNameEnumType::hdmi_earc: return "hdmi_earc";
96                             case ParameterNameEnumType::device_address: return "device_address";
97                             case ParameterNameEnumType::earpiece: return "earpiece";
98                             case ParameterNameEnumType::speaker: return "speaker";
99                             case ParameterNameEnumType::wired_headphone: return "wired_headphone";
100                             case ParameterNameEnumType::bluetooth_sco: return "bluetooth_sco";
101                             case ParameterNameEnumType::bluetooth_sco_carkit: return "bluetooth_sco_carkit";
102                             case ParameterNameEnumType::bluetooth_a2dp_headphones: return "bluetooth_a2dp_headphones";
103                             case ParameterNameEnumType::bluetooth_a2dp_speaker: return "bluetooth_a2dp_speaker";
104                             case ParameterNameEnumType::telephony_tx: return "telephony_tx";
105                             case ParameterNameEnumType::fm: return "fm";
106                             case ParameterNameEnumType::aux_line: return "aux_line";
107                             case ParameterNameEnumType::speaker_safe: return "speaker_safe";
108                             case ParameterNameEnumType::hearing_aid: return "hearing_aid";
109                             case ParameterNameEnumType::echo_canceller: return "echo_canceller";
110                             case ParameterNameEnumType::ble_speaker: return "ble_speaker";
111                             case ParameterNameEnumType::ble_broadcast: return "ble_broadcast";
112                             default: return std::to_string(static_cast<int>(o));
113                         }
114                     }
115 
116                     const std::map<std::string, LangEnum> LangEnumString {
117                         { "", LangEnum::EMPTY },
118                     };
119 
stringToLangEnum(const std::string & value)120                     LangEnum stringToLangEnum(const std::string& value) {
121                         auto enumValue = LangEnumString.find(value);
122                         return enumValue != LangEnumString.end() ? enumValue->second : LangEnum::UNKNOWN;
123                     }
124 
toString(LangEnum o)125                     std::string toString(LangEnum o) {
126                         switch (o) {
127                             case LangEnum::EMPTY: return "";
128                             default: return std::to_string(static_cast<int>(o));
129                         }
130                     }
131 
132                     const std::map<std::string, SpaceEnum> SpaceEnumString {
133                         { "default", SpaceEnum::_default },
134                         { "preserve", SpaceEnum::preserve },
135                     };
136 
stringToSpaceEnum(const std::string & value)137                     SpaceEnum stringToSpaceEnum(const std::string& value) {
138                         auto enumValue = SpaceEnumString.find(value);
139                         return enumValue != SpaceEnumString.end() ? enumValue->second : SpaceEnum::UNKNOWN;
140                     }
141 
toString(SpaceEnum o)142                     std::string toString(SpaceEnum o) {
143                         switch (o) {
144                             case SpaceEnum::_default: return "default";
145                             case SpaceEnum::preserve: return "preserve";
146                             default: return std::to_string(static_cast<int>(o));
147                         }
148                     }
149 
150                     const std::map<std::string, MatchesWhenEnum> MatchesWhenEnumString {
151                         { "Is", MatchesWhenEnum::Is },
152                         { "IsNot", MatchesWhenEnum::IsNot },
153                         { "Includes", MatchesWhenEnum::Includes },
154                         { "Excludes", MatchesWhenEnum::Excludes },
155                     };
156 
stringToMatchesWhenEnum(const std::string & value)157                     MatchesWhenEnum stringToMatchesWhenEnum(const std::string& value) {
158                         auto enumValue = MatchesWhenEnumString.find(value);
159                         return enumValue != MatchesWhenEnumString.end() ? enumValue->second : MatchesWhenEnum::UNKNOWN;
160                     }
161 
toString(MatchesWhenEnum o)162                     std::string toString(MatchesWhenEnum o) {
163                         switch (o) {
164                             case MatchesWhenEnum::Is: return "Is";
165                             case MatchesWhenEnum::IsNot: return "IsNot";
166                             case MatchesWhenEnum::Includes: return "Includes";
167                             case MatchesWhenEnum::Excludes: return "Excludes";
168                             default: return std::to_string(static_cast<int>(o));
169                         }
170                     }
171 
172                     const std::map<std::string, TypeEnum> TypeEnumString {
173                         { "Any", TypeEnum::Any },
174                         { "All", TypeEnum::All },
175                     };
176 
stringToTypeEnum(const std::string & value)177                     TypeEnum stringToTypeEnum(const std::string& value) {
178                         auto enumValue = TypeEnumString.find(value);
179                         return enumValue != TypeEnumString.end() ? enumValue->second : TypeEnum::UNKNOWN;
180                     }
181 
toString(TypeEnum o)182                     std::string toString(TypeEnum o) {
183                         switch (o) {
184                             case TypeEnum::Any: return "Any";
185                             case TypeEnum::All: return "All";
186                             default: return std::to_string(static_cast<int>(o));
187                         }
188                     }
189 
190                 } // configuration
191             } // capengine
192         } // policy
193     } // audio
194 } // android
195