1 /*
2 * Copyright (C) 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "AudioTypes.h"
18 #include "MediaMetricsConstants.h"
19 #include "StringUtils.h"
20 #include <audio_utils/StringUtils.h>
21 #include <media/TypeConverter.h> // requires libmedia_helper to get the Audio code.
22 #include <stats_media_metrics.h> // statsd
23
24 namespace android::mediametrics::types {
25
getAudioCallerNameMap()26 const std::unordered_map<std::string, int32_t>& getAudioCallerNameMap() {
27 // DO NOT MODIFY VALUES (OK to add new ones).
28 // This may be found in frameworks/av/media/libmediametrics/include/MediaMetricsConstants.h
29 static std::unordered_map<std::string, int32_t> map{
30 {"unknown", 0}, // callerName not set
31 {"aaudio", 1}, // Native AAudio
32 {"java", 2}, // Java API layer
33 {"media", 3}, // libmedia (mediaplayer)
34 {"opensles", 4}, // Open SLES
35 {"rtp", 5}, // RTP communication
36 {"soundpool", 6}, // SoundPool
37 {"tonegenerator", 7}, // dial tones
38 // R values above.
39 };
40 return map;
41 }
42
43 // A map in case we need to return a flag for input devices.
44 // This is 64 bits (and hence not the same as audio_device_t) because we need extra
45 // bits to represent new devices.
46 // NOT USED FOR R. We do not use int64 flags.
47 // This can be out of date for now, as it is unused even for string validation
48 // (instead TypeConverter<InputDeviceTraits> is used).
getAudioDeviceInMap()49 const std::unordered_map<std::string, int64_t>& getAudioDeviceInMap() {
50 // DO NOT MODIFY VALUES (OK to add new ones). This does NOT match audio_device_t.
51 static std::unordered_map<std::string, int64_t> map{
52 {"AUDIO_DEVICE_IN_COMMUNICATION", 1LL << 0},
53 {"AUDIO_DEVICE_IN_AMBIENT", 1LL << 1},
54 {"AUDIO_DEVICE_IN_BUILTIN_MIC", 1LL << 2},
55 {"AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET", 1LL << 3},
56 {"AUDIO_DEVICE_IN_WIRED_HEADSET", 1LL << 4},
57 {"AUDIO_DEVICE_IN_AUX_DIGITAL", 1LL << 5},
58 {"AUDIO_DEVICE_IN_HDMI", 1LL << 5}, // HDMI == AUX_DIGITAL (6 reserved)
59 {"AUDIO_DEVICE_IN_VOICE_CALL", 1LL << 7},
60 {"AUDIO_DEVICE_IN_TELEPHONY_RX", 1LL << 7}, // TELEPHONY_RX == VOICE_CALL (8 reserved)
61 {"AUDIO_DEVICE_IN_BACK_MIC", 1LL << 9},
62 {"AUDIO_DEVICE_IN_REMOTE_SUBMIX", 1LL << 10},
63 {"AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET", 1LL << 11},
64 {"AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET", 1LL << 12},
65 {"AUDIO_DEVICE_IN_USB_ACCESSORY", 1LL << 13},
66 {"AUDIO_DEVICE_IN_USB_DEVICE", 1LL << 14},
67 {"AUDIO_DEVICE_IN_FM_TUNER", 1LL << 15},
68 {"AUDIO_DEVICE_IN_TV_TUNER", 1LL << 16},
69 {"AUDIO_DEVICE_IN_LINE", 1LL << 17},
70 {"AUDIO_DEVICE_IN_SPDIF", 1LL << 18},
71 {"AUDIO_DEVICE_IN_BLUETOOTH_A2DP", 1LL << 19},
72 {"AUDIO_DEVICE_IN_LOOPBACK", 1LL << 20},
73 {"AUDIO_DEVICE_IN_IP", 1LL << 21},
74 {"AUDIO_DEVICE_IN_BUS", 1LL << 22},
75 {"AUDIO_DEVICE_IN_PROXY", 1LL << 23},
76 {"AUDIO_DEVICE_IN_USB_HEADSET", 1LL << 24},
77 {"AUDIO_DEVICE_IN_BLUETOOTH_BLE", 1LL << 25},
78 {"AUDIO_DEVICE_IN_HDMI_ARC", 1LL << 26},
79 {"AUDIO_DEVICE_IN_ECHO_REFERENCE", 1LL << 27},
80 {"AUDIO_DEVICE_IN_DEFAULT", 1LL << 28},
81 // R values above.
82 {"AUDIO_DEVICE_IN_BLE_HEADSET", 1LL << 29},
83 {"AUDIO_DEVICE_IN_HDMI_EARC", 1LL << 30},
84 };
85 return map;
86 }
87
88 // A map in case we need to return a flag for output devices.
89 // This is 64 bits (and hence not the same as audio_device_t) because we need extra
90 // bits to represent new devices.
91 // NOT USED FOR R. We do not use int64 flags.
92 // This can be out of date for now, as it is unused even for string validation
93 // (instead TypeConverter<OutputDeviceTraits> is used).
getAudioDeviceOutMap()94 const std::unordered_map<std::string, int64_t>& getAudioDeviceOutMap() {
95 // DO NOT MODIFY VALUES (OK to add new ones). This does NOT match audio_device_t.
96 static std::unordered_map<std::string, int64_t> map{
97 {"AUDIO_DEVICE_OUT_EARPIECE", 1LL << 0},
98 {"AUDIO_DEVICE_OUT_SPEAKER", 1LL << 1},
99 {"AUDIO_DEVICE_OUT_WIRED_HEADSET", 1LL << 2},
100 {"AUDIO_DEVICE_OUT_WIRED_HEADPHONE", 1LL << 3},
101 {"AUDIO_DEVICE_OUT_BLUETOOTH_SCO", 1LL << 4},
102 {"AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET", 1LL << 5},
103 {"AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT", 1LL << 6},
104 {"AUDIO_DEVICE_OUT_BLUETOOTH_A2DP", 1LL << 7},
105 {"AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES", 1LL << 8},
106 {"AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER", 1LL << 9},
107 {"AUDIO_DEVICE_OUT_AUX_DIGITAL", 1LL << 10},
108 {"AUDIO_DEVICE_OUT_HDMI", 1LL << 10}, // HDMI == AUX_DIGITAL (11 reserved)
109 {"AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET", 1LL << 12},
110 {"AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET", 1LL << 13},
111 {"AUDIO_DEVICE_OUT_USB_ACCESSORY", 1LL << 14},
112 {"AUDIO_DEVICE_OUT_USB_DEVICE", 1LL << 15},
113 {"AUDIO_DEVICE_OUT_REMOTE_SUBMIX", 1LL << 16},
114 {"AUDIO_DEVICE_OUT_TELEPHONY_TX", 1LL << 17},
115 {"AUDIO_DEVICE_OUT_LINE", 1LL << 18},
116 {"AUDIO_DEVICE_OUT_HDMI_ARC", 1LL << 19},
117 {"AUDIO_DEVICE_OUT_SPDIF", 1LL << 20},
118 {"AUDIO_DEVICE_OUT_FM", 1LL << 21},
119 {"AUDIO_DEVICE_OUT_AUX_LINE", 1LL << 22},
120 {"AUDIO_DEVICE_OUT_SPEAKER_SAFE", 1LL << 23},
121 {"AUDIO_DEVICE_OUT_IP", 1LL << 24},
122 {"AUDIO_DEVICE_OUT_BUS", 1LL << 25},
123 {"AUDIO_DEVICE_OUT_PROXY", 1LL << 26},
124 {"AUDIO_DEVICE_OUT_USB_HEADSET", 1LL << 27},
125 {"AUDIO_DEVICE_OUT_HEARING_AID", 1LL << 28},
126 {"AUDIO_DEVICE_OUT_ECHO_CANCELLER", 1LL << 29},
127 {"AUDIO_DEVICE_OUT_DEFAULT", 1LL << 30},
128 // R values above.
129 {"AUDIO_DEVICE_OUT_BLE_HEADSET", 1LL << 31},
130 {"AUDIO_DEVICE_OUT_BLE_SPEAKER", 1LL << 32},
131 {"AUDIO_DEVICE_OUT_HDMI_EARC", 1LL << 33},
132 // S values above
133 {"AUDIO_DEVICE_OUT_BLE_BROADCAST", 1LL << 34},
134 // T values above
135 };
136 return map;
137 }
138
139 // A map for the Java AudioDeviceInfo types to internal (native) output devices.
getAudioDeviceOutCompactMap()140 const std::unordered_map<std::string, int32_t>& getAudioDeviceOutCompactMap() {
141 // DO NOT MODIFY VALUES (OK to add new ones).
142 static std::unordered_map<std::string, int32_t> map{
143 // should "unknown" go to AUDIO_DEVICE_NONE?
144 {"earpiece", AUDIO_DEVICE_OUT_EARPIECE},
145 {"speaker", AUDIO_DEVICE_OUT_SPEAKER},
146 {"headset", AUDIO_DEVICE_OUT_WIRED_HEADSET},
147 {"headphone", AUDIO_DEVICE_OUT_WIRED_HEADPHONE},
148 {"bt_sco", AUDIO_DEVICE_OUT_BLUETOOTH_SCO},
149 {"bt_sco_hs", AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET},
150 {"bt_sco_carkit", AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT},
151 {"bt_a2dp", AUDIO_DEVICE_OUT_BLUETOOTH_A2DP},
152 {"bt_a2dp_hp", AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES},
153 {"bt_a2dp_spk", AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER},
154 {"aux_digital", AUDIO_DEVICE_OUT_AUX_DIGITAL},
155 {"hdmi", AUDIO_DEVICE_OUT_HDMI},
156 {"analog_dock", AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET},
157 {"digital_dock", AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET},
158 {"usb_accessory", AUDIO_DEVICE_OUT_USB_ACCESSORY},
159 {"usb_device", AUDIO_DEVICE_OUT_USB_DEVICE},
160 {"remote_submix", AUDIO_DEVICE_OUT_REMOTE_SUBMIX},
161 {"telephony_tx", AUDIO_DEVICE_OUT_TELEPHONY_TX},
162 {"line", AUDIO_DEVICE_OUT_LINE},
163 {"hdmi_arc", AUDIO_DEVICE_OUT_HDMI_ARC},
164 {"hdmi_earc", AUDIO_DEVICE_OUT_HDMI_EARC},
165 {"spdif", AUDIO_DEVICE_OUT_SPDIF},
166 {"fm_transmitter", AUDIO_DEVICE_OUT_FM},
167 {"aux_line", AUDIO_DEVICE_OUT_AUX_LINE},
168 {"speaker_safe", AUDIO_DEVICE_OUT_SPEAKER_SAFE},
169 {"ip", AUDIO_DEVICE_OUT_IP},
170 {"bus", AUDIO_DEVICE_OUT_BUS},
171 {"proxy", AUDIO_DEVICE_OUT_PROXY},
172 {"usb_headset", AUDIO_DEVICE_OUT_USB_HEADSET},
173 {"hearing_aid_out", AUDIO_DEVICE_OUT_HEARING_AID},
174 {"echo_canceller", AUDIO_DEVICE_OUT_ECHO_CANCELLER},
175 // default does not exist
176 {"ble_headset", AUDIO_DEVICE_OUT_BLE_HEADSET},
177 {"ble_speaker", AUDIO_DEVICE_OUT_BLE_SPEAKER},
178 {"ble_broadcast", AUDIO_DEVICE_OUT_BLE_BROADCAST},
179 };
180 return map;
181 }
182
183 // A map for the Java AudioDeviceInfo types.
184 // This uses generated statsd enums.proto constants.
getAudioDeviceInfoTypeMap()185 const std::unordered_map<std::string, int32_t>& getAudioDeviceInfoTypeMap() {
186 // DO NOT MODIFY VALUES (OK to add new ones).
187 static std::unordered_map<std::string, int32_t> map{
188 {"unknown", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_UNKNOWN},
189 {"earpiece", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BUILTIN_EARPIECE},
190 {"speaker", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BUILTIN_SPEAKER},
191 {"headset", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_WIRED_HEADSET},
192 {"headphone", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_WIRED_HEADPHONES}, // sic
193 {"bt_sco", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLUETOOTH_SCO},
194 {"bt_sco_hs", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLUETOOTH_SCO},
195 {"bt_sco_carkit", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLUETOOTH_SCO},
196 {"bt_a2dp", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLUETOOTH_A2DP},
197 {"bt_a2dp_hp", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLUETOOTH_A2DP},
198 {"bt_a2dp_spk", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLUETOOTH_A2DP},
199 {"aux_digital", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_HDMI},
200 {"hdmi", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_HDMI},
201 {"analog_dock", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_DOCK},
202 {"digital_dock", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_DOCK},
203 {"usb_accessory", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_USB_ACCESSORY},
204 {"usb_device", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_USB_DEVICE},
205 {"usb_headset", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_USB_HEADSET},
206 {"remote_submix", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_REMOTE_SUBMIX},
207 {"telephony_tx", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_TELEPHONY},
208 {"line", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_LINE_ANALOG},
209 {"hdmi_arc", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_HDMI_ARC},
210 {"hdmi_earc", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_HDMI_EARC},
211 {"spdif", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_LINE_DIGITAL},
212 {"fm_transmitter", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_FM},
213 {"aux_line", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_AUX_LINE},
214 {"speaker_safe", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BUILTIN_SPEAKER_SAFE},
215 {"ip", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_IP},
216 {"bus", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BUS},
217 {"proxy", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_UNKNOWN /* AUDIO_DEVICE_INFO_TYPE_PROXY */},
218 {"hearing_aid_out", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_HEARING_AID},
219 {"echo_canceller", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_ECHO_REFERENCE}, // sic
220 {"ble_headset", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLE_HEADSET},
221 {"ble_speaker", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLE_SPEAKER},
222 {"ble_broadcast", stats::media_metrics::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLE_BROADCAST},
223 };
224 return map;
225 }
226
getAudioThreadTypeMap()227 const std::unordered_map<std::string, int32_t>& getAudioThreadTypeMap() {
228 // DO NOT MODIFY VALUES (OK to add new ones).
229 // This may be found in frameworks/av/services/audioflinger/Threads.h
230 static std::unordered_map<std::string, int32_t> map{
231 // UNKNOWN is -1
232 {"MIXER", 0}, // Thread class is MixerThread
233 {"DIRECT", 1}, // Thread class is DirectOutputThread
234 {"DUPLICATING", 2}, // Thread class is DuplicatingThread
235 {"RECORD", 3}, // Thread class is RecordThread
236 {"OFFLOAD", 4}, // Thread class is OffloadThread
237 {"MMAP_PLAYBACK", 5}, // Thread class for MMAP playback stream
238 {"MMAP_CAPTURE", 6}, // Thread class for MMAP capture stream
239 // R values above.
240 {"SPATIALIZER", 7}, // Thread class for SpatializerThread
241 // S values above.
242 };
243 return map;
244 }
245
getAudioTrackTraitsMap()246 const std::unordered_map<std::string, int32_t>& getAudioTrackTraitsMap() {
247 // DO NOT MODIFY VALUES (OK to add new ones).
248 static std::unordered_map<std::string, int32_t> map{
249 {"static", (1 << 0)}, // A static track
250 // R values above.
251 };
252 return map;
253 }
254
getAAudioDirection()255 const std::unordered_map<std::string, int32_t>& getAAudioDirection() {
256 // DO NOT MODIFY VALUES(OK to add new ones).
257 // This may be found in frameworks/av/media/libaaudio/include/aaudio/AAudio.h
258 static std::unordered_map<std::string, int32_t> map {
259 // UNKNOWN is 0
260 {"AAUDIO_DIRECTION_OUTPUT", 1 /* AAUDIO_DIRECTION_OUTPUT + 1 */},
261 {"AAUDIO_DIRECTION_INPUT", 2 /* AAUDIO_DIRECTION_INPUT + 1*/},
262 };
263 return map;
264 }
265
getAAudioPerformanceMode()266 const std::unordered_map<std::string, int32_t>& getAAudioPerformanceMode() {
267 // DO NOT MODIFY VALUES(OK to add new ones).
268 // This may be found in frameworks/av/media/libaaudio/include/aaudio/AAudio.h
269 static std::unordered_map<std::string, int32_t> map {
270 // UNKNOWN is 0
271 {"AAUDIO_PERFORMANCE_MODE_NONE", 10},
272 {"AAUDIO_PERFORMANCE_MODE_POWER_SAVING", 11},
273 {"AAUDIO_PERFORMANCE_MODE_LOW_LATENCY", 12},
274 };
275 return map;
276 }
277
getAAudioSharingMode()278 const std::unordered_map<std::string, int32_t>& getAAudioSharingMode() {
279 // DO NOT MODIFY VALUES(OK to add new ones).
280 // This may be found in frameworks/av/media/libaaudio/include/aaudio/AAudio.h
281 static std::unordered_map<std::string, int32_t> map {
282 // UNKNOWN is 0
283 {"AAUDIO_SHARING_MODE_EXCLUSIVE", 1 /* AAUDIO_SHARING_MODE_EXCLUSIVE + 1 */},
284 {"AAUDIO_SHARING_MODE_SHARED", 2 /* AAUDIO_SHARING_MODE_SHARED + 1 */},
285 };
286 return map;
287 }
288
getHeadTrackingModeMap()289 const std::unordered_map<std::string, int32_t>& getHeadTrackingModeMap() {
290 // DO NOT MODIFY VALUES(OK to add new ones).
291 // frameworks/base/media/java/android/media/Spatializer.java
292 // frameworks/av/media/libaudioclient/aidl/android/media/SpatializerHeadTrackingMode.aidl
293 static std::unordered_map<std::string, int32_t> map {
294 {"OTHER", 0},
295 {"DISABLED", -1},
296 {"RELATIVE_WORLD", 1},
297 {"RELATIVE_SCREEN", 2},
298 };
299 return map;
300 }
301
getSpatializerLevelMap()302 const std::unordered_map<std::string, int32_t>& getSpatializerLevelMap() {
303 // DO NOT MODIFY VALUES(OK to add new ones).
304 // frameworks/base/media/java/android/media/Spatializer.java
305 // frameworks/av/media/libaudioclient/aidl/android/media/SpatializerHeadTrackingMode.aidl
306 static std::unordered_map<std::string, int32_t> map {
307 {"NONE", 0},
308 {"SPATIALIZER_MULTICHANNEL", 1},
309 {"SPATIALIZER_MCHAN_BED_PLUS_OBJECTS", 2},
310 };
311 return map;
312 }
313
getSpatializerModeMap()314 const std::unordered_map<std::string, int32_t>& getSpatializerModeMap() {
315 // DO NOT MODIFY VALUES(OK to add new ones).
316 // frameworks/av/media/libaudioclient/aidl/android/media/SpatializationMode.aidl
317 static std::unordered_map<std::string, int32_t> map {
318 {"SPATIALIZER_BINAURAL", 0},
319 {"SPATIALIZER_TRANSAURAL", 1},
320 };
321 return map;
322 }
323
getStatusMap()324 const std::unordered_map<std::string, int32_t>& getStatusMap() {
325 // DO NOT MODIFY VALUES(OK to add new ones).
326 static std::unordered_map<std::string, int32_t> map {
327 {"",
328 stats::media_metrics::MEDIAMETRICS_AUDIO_TRACK_STATUS_REPORTED__STATUS__NO_ERROR},
329 {AMEDIAMETRICS_PROP_STATUS_VALUE_OK,
330 stats::media_metrics::MEDIAMETRICS_AUDIO_TRACK_STATUS_REPORTED__STATUS__NO_ERROR},
331 {AMEDIAMETRICS_PROP_STATUS_VALUE_ARGUMENT,
332 stats::media_metrics::MEDIAMETRICS_AUDIO_TRACK_STATUS_REPORTED__STATUS__ERROR_ARGUMENT},
333 {AMEDIAMETRICS_PROP_STATUS_VALUE_IO,
334 stats::media_metrics::MEDIAMETRICS_AUDIO_TRACK_STATUS_REPORTED__STATUS__ERROR_IO},
335 {AMEDIAMETRICS_PROP_STATUS_VALUE_MEMORY,
336 stats::media_metrics::MEDIAMETRICS_AUDIO_TRACK_STATUS_REPORTED__STATUS__ERROR_MEMORY},
337 {AMEDIAMETRICS_PROP_STATUS_VALUE_SECURITY,
338 stats::media_metrics::MEDIAMETRICS_AUDIO_TRACK_STATUS_REPORTED__STATUS__ERROR_SECURITY},
339 {AMEDIAMETRICS_PROP_STATUS_VALUE_STATE,
340 stats::media_metrics::MEDIAMETRICS_AUDIO_TRACK_STATUS_REPORTED__STATUS__ERROR_STATE},
341 {AMEDIAMETRICS_PROP_STATUS_VALUE_TIMEOUT,
342 stats::media_metrics::MEDIAMETRICS_AUDIO_TRACK_STATUS_REPORTED__STATUS__ERROR_TIMEOUT},
343 {AMEDIAMETRICS_PROP_STATUS_VALUE_UNKNOWN,
344 stats::media_metrics::MEDIAMETRICS_AUDIO_TRACK_STATUS_REPORTED__STATUS__ERROR_UNKNOWN},
345 };
346 return map;
347 }
348
349 // Helper: Create the corresponding int32 from string flags split with '|'.
350 template <typename Traits>
int32FromFlags(const std::string & flags)351 int32_t int32FromFlags(const std::string &flags)
352 {
353 const auto result = audio_utils::stringutils::split(flags, "|");
354 int32_t intFlags = 0;
355 for (const auto& flag : result) {
356 typename Traits::Type value;
357 if (!TypeConverter<Traits>::fromString(flag, value)) {
358 break;
359 }
360 intFlags |= value;
361 }
362 return intFlags;
363 }
364
365 template <typename Traits>
stringFromFlags(const std::string & flags,size_t len)366 std::string stringFromFlags(const std::string &flags, size_t len)
367 {
368 const auto result = audio_utils::stringutils::split(flags, "|");
369 std::string sFlags;
370 for (const auto& flag : result) {
371 typename Traits::Type value;
372 if (!TypeConverter<Traits>::fromString(flag, value)) {
373 break;
374 }
375 if (len >= flag.size()) continue;
376 if (!sFlags.empty()) sFlags += "|";
377 sFlags += flag.c_str() + len;
378 }
379 return sFlags;
380 }
381
382 template <typename M>
validateStringFromMap(const std::string & str,const M & map)383 std::string validateStringFromMap(const std::string &str, const M& map)
384 {
385 if (str.empty()) return {};
386
387 const auto result = audio_utils::stringutils::split(str, "|");
388 std::stringstream ss;
389 for (const auto &s : result) {
390 if (map.count(s) > 0) {
391 if (ss.tellp() > 0) ss << "|";
392 ss << s;
393 }
394 }
395 return ss.str();
396 }
397
398 template <typename M>
flagsFromMap(const std::string & str,const M & map)399 typename M::mapped_type flagsFromMap(const std::string &str, const M& map)
400 {
401 if (str.empty()) return {};
402
403 const auto result = audio_utils::stringutils::split(str, "|");
404 typename M::mapped_type value{};
405 for (const auto &s : result) {
406 auto it = map.find(s);
407 if (it == map.end()) continue;
408 value |= it->second;
409 }
410 return value;
411 }
412
vectorFromMap(const std::string & str,const std::unordered_map<std::string,int32_t> & map)413 std::vector<int32_t> vectorFromMap(
414 const std::string &str, const std::unordered_map<std::string, int32_t>& map)
415 {
416 std::vector<int32_t> v;
417
418 if (str.empty()) return v;
419
420 const auto result = audio_utils::stringutils::split(str, "|");
421 for (const auto &s : result) {
422 auto it = map.find(s);
423 if (it == map.end()) continue;
424 v.push_back(it->second);
425 }
426 return v;
427 }
428
channelMaskVectorFromString(const std::string & s)429 std::vector<int64_t> channelMaskVectorFromString(const std::string &s)
430 {
431 std::vector<int64_t> v;
432
433 const auto result = audio_utils::stringutils::split(s, "|");
434 for (const auto &mask : result) {
435 // 0 if undetected or if actually 0.
436 int64_t int64Mask = strtoll(mask.c_str(), nullptr, 0);
437 v.push_back(int64Mask);
438 }
439 return v;
440 }
441
442 template <>
lookup(const std::string & contentType)443 int32_t lookup<CONTENT_TYPE>(const std::string &contentType)
444 {
445 AudioContentTraits::Type value;
446 if (!TypeConverter<AudioContentTraits>::fromString(contentType, value)) {
447 value = AUDIO_CONTENT_TYPE_UNKNOWN;
448 }
449 return (int32_t)value;
450 }
451
452 template <>
lookup(const std::string & contentType)453 std::string lookup<CONTENT_TYPE>(const std::string &contentType)
454 {
455 AudioContentTraits::Type value;
456 if (!TypeConverter<AudioContentTraits>::fromString(contentType, value)) {
457 return "";
458 }
459 return contentType.c_str() + sizeof("AUDIO_CONTENT_TYPE");
460 }
461
462 template <>
lookup(const std::string & encoding)463 int32_t lookup<ENCODING>(const std::string &encoding)
464 {
465 FormatTraits::Type value;
466 if (!TypeConverter<FormatTraits>::fromString(encoding, value)) {
467 value = AUDIO_FORMAT_INVALID;
468 }
469 return (int32_t)value;
470 }
471
472 template <>
lookup(const std::string & encoding)473 std::string lookup<ENCODING>(const std::string &encoding)
474 {
475 FormatTraits::Type value;
476 if (!TypeConverter<FormatTraits>::fromString(encoding, value)) {
477 return "";
478 }
479 return encoding.c_str() + sizeof("AUDIO_FORMAT");
480 }
481
482 template <>
lookup(const std::string & inputFlag)483 int32_t lookup<INPUT_FLAG>(const std::string &inputFlag)
484 {
485 return int32FromFlags<InputFlagTraits>(inputFlag);
486 }
487
488 template <>
lookup(const std::string & inputFlag)489 std::string lookup<INPUT_FLAG>(const std::string &inputFlag)
490 {
491 return stringFromFlags<InputFlagTraits>(inputFlag, sizeof("AUDIO_INPUT_FLAG"));
492 }
493
494 template <>
lookup(const std::string & outputFlag)495 int32_t lookup<OUTPUT_FLAG>(const std::string &outputFlag)
496 {
497 return int32FromFlags<OutputFlagTraits>(outputFlag);
498 }
499
500 template <>
lookup(const std::string & outputFlag)501 std::string lookup<OUTPUT_FLAG>(const std::string &outputFlag)
502 {
503 return stringFromFlags<OutputFlagTraits>(outputFlag, sizeof("AUDIO_OUTPUT_FLAG"));
504 }
505
506 template <>
lookup(const std::string & sourceType)507 int32_t lookup<SOURCE_TYPE>(const std::string &sourceType)
508 {
509 SourceTraits::Type value;
510 if (!TypeConverter<SourceTraits>::fromString(sourceType, value)) {
511 value = AUDIO_SOURCE_DEFAULT;
512 }
513 return (int32_t)value;
514 }
515
516 template <>
lookup(const std::string & sourceType)517 std::string lookup<SOURCE_TYPE>(const std::string &sourceType)
518 {
519 SourceTraits::Type value;
520 if (!TypeConverter<SourceTraits>::fromString(sourceType, value)) {
521 return "";
522 }
523 return sourceType.c_str() + sizeof("AUDIO_SOURCE");
524 }
525
526 template <>
lookup(const std::string & streamType)527 int32_t lookup<STREAM_TYPE>(const std::string &streamType)
528 {
529 StreamTraits::Type value;
530 if (!TypeConverter<StreamTraits>::fromString(streamType, value)) {
531 value = AUDIO_STREAM_DEFAULT;
532 }
533 return (int32_t)value;
534 }
535
536 template <>
lookup(const std::string & streamType)537 std::string lookup<STREAM_TYPE>(const std::string &streamType)
538 {
539 StreamTraits::Type value;
540 if (!TypeConverter<StreamTraits>::fromString(streamType, value)) {
541 return "";
542 }
543 return streamType.c_str() + sizeof("AUDIO_STREAM");
544 }
545
546 template <>
lookup(const std::string & usage)547 int32_t lookup<USAGE>(const std::string &usage)
548 {
549 UsageTraits::Type value;
550 if (!TypeConverter<UsageTraits>::fromString(usage, value)) {
551 value = AUDIO_USAGE_UNKNOWN;
552 }
553 return (int32_t)value;
554 }
555
556 template <>
lookup(const std::string & usage)557 std::string lookup<USAGE>(const std::string &usage)
558 {
559 UsageTraits::Type value;
560 if (!TypeConverter<UsageTraits>::fromString(usage, value)) {
561 return "";
562 }
563 return usage.c_str() + sizeof("AUDIO_USAGE");
564 }
565
566 template <>
lookup(const std::string & inputDevice)567 int64_t lookup<INPUT_DEVICE>(const std::string &inputDevice)
568 {
569 // NOT USED FOR R.
570 // Returns a set of bits, each one representing a device in inputDevice.
571 // This is a 64 bit integer, not the same as audio_device_t.
572 return flagsFromMap(inputDevice, getAudioDeviceInMap());
573 }
574
575 template <>
lookup(const std::string & inputDevice)576 std::string lookup<INPUT_DEVICE>(const std::string &inputDevice)
577 {
578 return stringFromFlags<InputDeviceTraits>(inputDevice, sizeof("AUDIO_DEVICE_IN"));
579 }
580
581 template <>
lookup(const std::string & outputDevice)582 int64_t lookup<OUTPUT_DEVICE>(const std::string &outputDevice)
583 {
584 // NOT USED FOR R.
585 // Returns a set of bits, each one representing a device in outputDevice.
586 // This is a 64 bit integer, not the same as audio_device_t.
587 return flagsFromMap(outputDevice, getAudioDeviceOutMap());
588 }
589
590 template <>
lookup(const std::string & outputDevice)591 std::string lookup<OUTPUT_DEVICE>(const std::string &outputDevice)
592 {
593 return stringFromFlags<OutputDeviceTraits>(outputDevice, sizeof("AUDIO_DEVICE_OUT"));
594 }
595
596 template <>
lookup(const std::string & audioDeviceInfoType)597 int32_t lookup<AUDIO_DEVICE_INFO_TYPE>(const std::string& audioDeviceInfoType)
598 {
599 auto& map = getAudioDeviceInfoTypeMap();
600 auto it = map.find(audioDeviceInfoType);
601 if (it == map.end()) {
602 return 0;
603 }
604 return it->second;
605 }
606
607 template <>
lookup(const std::string & callerName)608 int32_t lookup<CALLER_NAME>(const std::string &callerName)
609 {
610 auto& map = getAudioCallerNameMap();
611 auto it = map.find(callerName);
612 if (it == map.end()) {
613 return 0; // return unknown
614 }
615 return it->second;
616 }
617
618 template <>
lookup(const std::string & callerName)619 std::string lookup<CALLER_NAME>(const std::string &callerName)
620 {
621 auto& map = getAudioCallerNameMap();
622 auto it = map.find(callerName);
623 if (it == map.end()) {
624 return "";
625 }
626 return callerName;
627 }
628
629 template <>
lookup(const std::string & headTrackingMode)630 int32_t lookup<HEAD_TRACKING_MODE>(const std::string& headTrackingMode)
631 {
632 auto& map = getHeadTrackingModeMap();
633 auto it = map.find(headTrackingMode);
634 if (it == map.end()) {
635 return 0;
636 }
637 return it->second;
638 }
639
640 template <>
lookup(const std::string & spatializerLevel)641 int32_t lookup<SPATIALIZER_LEVEL>(const std::string& spatializerLevel)
642 {
643 auto& map = getSpatializerLevelMap();
644 auto it = map.find(spatializerLevel);
645 if (it == map.end()) {
646 return 0;
647 }
648 return it->second;
649 }
650
651 template <>
lookup(const std::string & spatializerMode)652 int32_t lookup<SPATIALIZER_MODE>(const std::string& spatializerMode)
653 {
654 auto& map = getSpatializerModeMap();
655 auto it = map.find(spatializerMode);
656 if (it == map.end()) {
657 return 0;
658 }
659 return it->second;
660 }
661
662 template <>
lookup(const std::string & status)663 int32_t lookup<STATUS>(const std::string &status)
664 {
665 auto& map = getStatusMap();
666 auto it = map.find(status);
667 if (it == map.end()) {
668 return stats::media_metrics::MEDIAMETRICS_AUDIO_TRACK_STATUS_REPORTED__STATUS__ERROR_UNKNOWN;
669 }
670 return it->second;
671 }
672
673 template <>
lookup(const std::string & threadType)674 int32_t lookup<THREAD_TYPE>(const std::string &threadType)
675 {
676 auto& map = getAudioThreadTypeMap();
677 auto it = map.find(threadType);
678 if (it == map.end()) {
679 return -1; // note this as an illegal thread value as we don't have unknown here.
680 }
681 return it->second;
682 }
683
684 template <>
lookup(const std::string & threadType)685 std::string lookup<THREAD_TYPE>(const std::string &threadType)
686 {
687 auto& map = getAudioThreadTypeMap();
688 auto it = map.find(threadType);
689 if (it == map.end()) {
690 return "";
691 }
692 return threadType;
693 }
694
isInputThreadType(const std::string & threadType)695 bool isInputThreadType(const std::string &threadType)
696 {
697 return threadType == "RECORD" || threadType == "MMAP_CAPTURE";
698 }
699
700 template <>
lookup(const std::string & traits)701 std::string lookup<TRACK_TRAITS>(const std::string &traits)
702 {
703 return validateStringFromMap(traits, getAudioTrackTraitsMap());
704 }
705
706 template <>
lookup(const std::string & traits)707 int32_t lookup<TRACK_TRAITS>(const std::string &traits)
708 {
709 return flagsFromMap(traits, getAudioTrackTraitsMap());
710 }
711
712 template <>
lookup(const std::string & direction)713 std::string lookup<AAUDIO_DIRECTION>(const std::string &direction)
714 {
715 auto& map = getAAudioDirection();
716 auto it = map.find(direction);
717 if (it == map.end()) {
718 return "";
719 }
720 return direction;
721 }
722
723 template <>
lookup(const std::string & direction)724 int32_t lookup<AAUDIO_DIRECTION>(const std::string &direction)
725 {
726 auto& map = getAAudioDirection();
727 auto it = map.find(direction);
728 if (it == map.end()) {
729 return 0; // return unknown
730 }
731 return it->second;
732 }
733
734 template <>
lookup(const std::string & performanceMode)735 std::string lookup<AAUDIO_PERFORMANCE_MODE>(const std::string &performanceMode)
736 {
737 auto& map = getAAudioPerformanceMode();
738 auto it = map.find(performanceMode);
739 if (it == map.end()) {
740 return "";
741 }
742 return performanceMode;
743 }
744
745 template <>
lookup(const std::string & performanceMode)746 int32_t lookup<AAUDIO_PERFORMANCE_MODE>(const std::string &performanceMode)
747 {
748 auto& map = getAAudioPerformanceMode();
749 auto it = map.find(performanceMode);
750 if (it == map.end()) {
751 return 0; // return unknown
752 }
753 return it->second;
754 }
755
756 template <>
lookup(const std::string & sharingMode)757 std::string lookup<AAUDIO_SHARING_MODE>(const std::string &sharingMode)
758 {
759 auto& map = getAAudioSharingMode();
760 auto it = map.find(sharingMode);
761 if (it == map.end()) {
762 return "";
763 }
764 return sharingMode;
765 }
766
767 template <>
lookup(const std::string & sharingMode)768 int32_t lookup<AAUDIO_SHARING_MODE>(const std::string &sharingMode)
769 {
770 auto& map = getAAudioSharingMode();
771 auto it = map.find(sharingMode);
772 if (it == map.end()) {
773 return 0; // return unknown
774 }
775 return it->second;
776 }
777
778 } // namespace android::mediametrics::types
779