1 /*
2 * Copyright (c) 2023-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #ifndef LOG_TAG
16 #define LOG_TAG "NapiAudioEnum"
17 #endif
18
19 #include "napi_audio_enum.h"
20 #include "audio_renderer.h"
21 #include "audio_errors.h"
22 #include "audio_stream_manager.h"
23 #include "audio_interrupt_info.h"
24 #include "audio_session_device_info.h"
25 #include "audio_device_info.h"
26 #include "napi_param_utils.h"
27 #include "audio_asr.h"
28 #if !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
29 #include "parameters.h"
30 #endif
31 using namespace std;
32 using OHOS::HiviewDFX::HiLog;
33 using OHOS::HiviewDFX::HiLogLabel;
34
35 namespace OHOS {
36 namespace AudioStandard {
37 constexpr int32_t DEFAULT_VOLUME_INTERRUPT_ID = 1;
38 napi_ref NapiAudioEnum::sConstructor_ = nullptr;
39 unique_ptr<AudioParameters> NapiAudioEnum::sAudioParameters_ = nullptr;
40
41 static const std::string NAPI_AUDIO_ENUM_CLASS_NAME = "AudioEnum";
42
43 const std::map<std::string, int32_t> NapiAudioEnum::audioChannelMap = {
44 {"CHANNEL_1", MONO},
45 {"CHANNEL_2", STEREO},
46 {"CHANNEL_3", CHANNEL_3},
47 {"CHANNEL_4", CHANNEL_4},
48 {"CHANNEL_5", CHANNEL_5},
49 {"CHANNEL_6", CHANNEL_6},
50 {"CHANNEL_7", CHANNEL_7},
51 {"CHANNEL_8", CHANNEL_8},
52 {"CHANNEL_9", CHANNEL_9},
53 {"CHANNEL_10", CHANNEL_10},
54 {"CHANNEL_12", CHANNEL_12},
55 {"CHANNEL_14", CHANNEL_14},
56 {"CHANNEL_16", CHANNEL_16},
57 };
58
59 const std::map<std::string, int32_t> NapiAudioEnum::samplingRateMap = {
60 {"SAMPLE_RATE_8000", SAMPLE_RATE_8000},
61 {"SAMPLE_RATE_11025", SAMPLE_RATE_11025},
62 {"SAMPLE_RATE_12000", SAMPLE_RATE_12000},
63 {"SAMPLE_RATE_16000", SAMPLE_RATE_16000},
64 {"SAMPLE_RATE_22050", SAMPLE_RATE_22050},
65 {"SAMPLE_RATE_24000", SAMPLE_RATE_24000},
66 {"SAMPLE_RATE_32000", SAMPLE_RATE_32000},
67 {"SAMPLE_RATE_44100", SAMPLE_RATE_44100},
68 {"SAMPLE_RATE_48000", SAMPLE_RATE_48000},
69 {"SAMPLE_RATE_64000", SAMPLE_RATE_64000},
70 {"SAMPLE_RATE_88200", SAMPLE_RATE_88200},
71 {"SAMPLE_RATE_96000", SAMPLE_RATE_96000},
72 {"SAMPLE_RATE_176400", SAMPLE_RATE_176400},
73 {"SAMPLE_RATE_192000", SAMPLE_RATE_192000},
74 };
75
76 const std::map<std::string, int32_t> NapiAudioEnum::encodingTypeMap = {
77 {"ENCODING_TYPE_INVALID", ENCODING_INVALID},
78 {"ENCODING_TYPE_RAW", ENCODING_PCM}
79 };
80
81 const std::map<std::string, int32_t> NapiAudioEnum::contentTypeMap = {
82 {"CONTENT_TYPE_UNKNOWN", CONTENT_TYPE_UNKNOWN},
83 {"CONTENT_TYPE_SPEECH", CONTENT_TYPE_SPEECH},
84 {"CONTENT_TYPE_MUSIC", CONTENT_TYPE_MUSIC},
85 {"CONTENT_TYPE_MOVIE", CONTENT_TYPE_MOVIE},
86 {"CONTENT_TYPE_SONIFICATION", CONTENT_TYPE_SONIFICATION},
87 {"CONTENT_TYPE_RINGTONE", CONTENT_TYPE_RINGTONE},
88 {"CONTENT_TYPE_ULTRASONIC", CONTENT_TYPE_ULTRASONIC}
89 };
90
91 const std::map<std::string, int32_t> NapiAudioEnum::audioVolumeModeMap = {
92 {"SYSTEM_GLOBAL", AUDIOSTREAM_VOLUMEMODE_SYSTEM_GLOBAL},
93 {"APP_INDIVIDUAL", AUDIOSTREAM_VOLUMEMODE_APP_INDIVIDUAL}
94 };
95
96 const std::map<std::string, int32_t> NapiAudioEnum::streamUsageMap = {
97 {"STREAM_USAGE_UNKNOWN", STREAM_USAGE_UNKNOWN},
98 {"STREAM_USAGE_MEDIA", STREAM_USAGE_MEDIA},
99 {"STREAM_USAGE_MUSIC", STREAM_USAGE_MUSIC},
100 {"STREAM_USAGE_VOICE_COMMUNICATION", STREAM_USAGE_VOICE_COMMUNICATION},
101 {"STREAM_USAGE_VOICE_ASSISTANT", STREAM_USAGE_VOICE_ASSISTANT},
102 {"STREAM_USAGE_ALARM", STREAM_USAGE_ALARM},
103 {"STREAM_USAGE_VOICE_MESSAGE", STREAM_USAGE_VOICE_MESSAGE},
104 {"STREAM_USAGE_VOICE_CALL_ASSISTANT", STREAM_USAGE_VOICE_CALL_ASSISTANT},
105 {"STREAM_USAGE_NOTIFICATION_RINGTONE", STREAM_USAGE_NOTIFICATION_RINGTONE},
106 {"STREAM_USAGE_RINGTONE", STREAM_USAGE_RINGTONE},
107 {"STREAM_USAGE_NOTIFICATION", STREAM_USAGE_NOTIFICATION},
108 {"STREAM_USAGE_ACCESSIBILITY", STREAM_USAGE_ACCESSIBILITY},
109 {"STREAM_USAGE_SYSTEM", STREAM_USAGE_SYSTEM},
110 {"STREAM_USAGE_MOVIE", STREAM_USAGE_MOVIE},
111 {"STREAM_USAGE_GAME", STREAM_USAGE_GAME},
112 {"STREAM_USAGE_AUDIOBOOK", STREAM_USAGE_AUDIOBOOK},
113 {"STREAM_USAGE_NAVIGATION", STREAM_USAGE_NAVIGATION},
114 {"STREAM_USAGE_DTMF", STREAM_USAGE_DTMF},
115 {"STREAM_USAGE_ENFORCED_TONE", STREAM_USAGE_ENFORCED_TONE},
116 {"STREAM_USAGE_ULTRASONIC", STREAM_USAGE_ULTRASONIC},
117 {"STREAM_USAGE_VIDEO_COMMUNICATION", STREAM_USAGE_VIDEO_COMMUNICATION}
118 };
119
120 const std::map<std::string, int32_t> NapiAudioEnum::deviceRoleMap = {
121 {"DEVICE_ROLE_NONE", DEVICE_ROLE_NONE},
122 {"INPUT_DEVICE", INPUT_DEVICE},
123 {"OUTPUT_DEVICE", OUTPUT_DEVICE},
124 {"DEVICE_ROLE_MAX", DEVICE_ROLE_MAX}
125 };
126
127 const std::map<std::string, int32_t> NapiAudioEnum::deviceTypeMap = {
128 {"NONE", DEVICE_TYPE_NONE},
129 {"INVALID", DEVICE_TYPE_INVALID},
130 {"EARPIECE", DEVICE_TYPE_EARPIECE},
131 {"SPEAKER", DEVICE_TYPE_SPEAKER},
132 {"WIRED_HEADSET", DEVICE_TYPE_WIRED_HEADSET},
133 {"WIRED_HEADPHONES", DEVICE_TYPE_WIRED_HEADPHONES},
134 {"BLUETOOTH_SCO", DEVICE_TYPE_BLUETOOTH_SCO},
135 {"BLUETOOTH_A2DP", DEVICE_TYPE_BLUETOOTH_A2DP},
136 {"NEARLINK", DEVICE_TYPE_NEARLINK},
137 {"HEARING_AID", DEVICE_TYPE_HEARING_AID},
138 {"MIC", DEVICE_TYPE_MIC},
139 {"WAKEUP", DEVICE_TYPE_WAKEUP},
140 {"USB_HEADSET", DEVICE_TYPE_USB_HEADSET},
141 {"DISPLAY_PORT", DEVICE_TYPE_DP},
142 {"REMOTE_CAST", DEVICE_TYPE_REMOTE_CAST},
143 {"USB_DEVICE", DEVICE_TYPE_USB_DEVICE},
144 {"HDMI", DEVICE_TYPE_HDMI},
145 {"LINE_DIGITAL", DEVICE_TYPE_LINE_DIGITAL},
146 {"REMOTE_DAUDIO", DEVICE_TYPE_REMOTE_DAUDIO},
147 {"ACCESSORY", DEVICE_TYPE_ACCESSORY},
148 {"DEFAULT", DEVICE_TYPE_DEFAULT},
149 {"MAX", DEVICE_TYPE_MAX},
150 };
151
152 const std::map<std::string, int32_t> NapiAudioEnum::sourceTypeMap = {
153 {"SOURCE_TYPE_INVALID", SOURCE_TYPE_INVALID},
154 {"SOURCE_TYPE_MIC", SOURCE_TYPE_MIC},
155 {"SOURCE_TYPE_CAMCORDER", SOURCE_TYPE_CAMCORDER},
156 {"SOURCE_TYPE_WAKEUP", SOURCE_TYPE_WAKEUP},
157 {"SOURCE_TYPE_VOICE_RECOGNITION", SOURCE_TYPE_VOICE_RECOGNITION},
158 {"SOURCE_TYPE_PLAYBACK_CAPTURE", SOURCE_TYPE_PLAYBACK_CAPTURE},
159 {"SOURCE_TYPE_VOICE_COMMUNICATION", SOURCE_TYPE_VOICE_COMMUNICATION},
160 {"SOURCE_TYPE_VOICE_CALL", SOURCE_TYPE_VOICE_CALL},
161 {"SOURCE_TYPE_VOICE_MESSAGE", SOURCE_TYPE_VOICE_MESSAGE},
162 {"SOURCE_TYPE_REMOTE_CAST", SOURCE_TYPE_REMOTE_CAST},
163 {"SOURCE_TYPE_VOICE_TRANSCRIPTION", SOURCE_TYPE_VOICE_TRANSCRIPTION},
164 {"SOURCE_TYPE_UNPROCESSED", SOURCE_TYPE_UNPROCESSED},
165 {"SOURCE_TYPE_LIVE", SOURCE_TYPE_LIVE},
166 };
167
168 const std::map<std::string, int32_t> NapiAudioEnum::volumeAdjustTypeMap = {
169 {"VOLUME_UP", VOLUME_UP},
170 {"VOLUME_DOWN", VOLUME_DOWN},
171 };
172
173 const std::map<std::string, int32_t> NapiAudioEnum::channelBlendModeMap = {
174 {"MODE_DEFAULT", MODE_DEFAULT},
175 {"MODE_BLEND_LR", MODE_BLEND_LR},
176 {"MODE_ALL_LEFT", MODE_ALL_LEFT},
177 {"MODE_ALL_RIGHT", MODE_ALL_RIGHT},
178 };
179
180 const std::map<std::string, int32_t> NapiAudioEnum::rendererRateMap = {
181 {"RENDER_RATE_NORMAL", RENDER_RATE_NORMAL},
182 {"RENDER_RATE_DOUBLE", RENDER_RATE_DOUBLE},
183 {"RENDER_RATE_HALF", RENDER_RATE_HALF}
184 };
185
186 const std::map<std::string, int32_t> NapiAudioEnum::interruptEventTypeMap = {
187 {"INTERRUPT_TYPE_BEGIN", INTERRUPT_TYPE_BEGIN},
188 {"INTERRUPT_TYPE_END", INTERRUPT_TYPE_END}
189 };
190
191 const std::map<std::string, int32_t> NapiAudioEnum::interruptForceTypeMap = {
192 {"INTERRUPT_FORCE", INTERRUPT_FORCE},
193 {"INTERRUPT_SHARE", INTERRUPT_SHARE},
194 };
195
196 const std::map<std::string, int32_t> NapiAudioEnum::interruptHintTypeMap = {
197 {"INTERRUPT_HINT_NONE", INTERRUPT_HINT_NONE},
198 {"INTERRUPT_HINT_PAUSE", INTERRUPT_HINT_PAUSE},
199 {"INTERRUPT_HINT_RESUME", INTERRUPT_HINT_RESUME},
200 {"INTERRUPT_HINT_STOP", INTERRUPT_HINT_STOP},
201 {"INTERRUPT_HINT_DUCK", INTERRUPT_HINT_DUCK},
202 {"INTERRUPT_HINT_UNDUCK", INTERRUPT_HINT_UNDUCK},
203 {"INTERRUPT_HINT_MUTE", INTERRUPT_HINT_MUTE},
204 {"INTERRUPT_HINT_UNMUTE", INTERRUPT_HINT_UNMUTE},
205 };
206
207 const std::map<std::string, int32_t> NapiAudioEnum::audioSampleFormatMap = {
208 {"SAMPLE_FORMAT_INVALID", NapiAudioEnum::SAMPLE_FORMAT_INVALID},
209 {"SAMPLE_FORMAT_U8", NapiAudioEnum::SAMPLE_FORMAT_U8},
210 {"SAMPLE_FORMAT_S16LE", NapiAudioEnum::SAMPLE_FORMAT_S16LE},
211 {"SAMPLE_FORMAT_S24LE", NapiAudioEnum::SAMPLE_FORMAT_S24LE},
212 {"SAMPLE_FORMAT_S32LE", NapiAudioEnum::SAMPLE_FORMAT_S32LE},
213 {"SAMPLE_FORMAT_F32LE", NapiAudioEnum::SAMPLE_FORMAT_F32LE}
214 };
215
216 const std::map<std::string, int32_t> NapiAudioEnum::audioStateMap = {
217 {"STATE_INVALID", RENDERER_INVALID},
218 {"STATE_NEW", RENDERER_NEW},
219 {"STATE_PREPARED", RENDERER_PREPARED},
220 {"STATE_RUNNING", RENDERER_RUNNING},
221 {"STATE_STOPPED", RENDERER_STOPPED},
222 {"STATE_RELEASED", RENDERER_RELEASED},
223 {"STATE_PAUSED", RENDERER_PAUSED}
224 };
225
226 const std::map<std::string, int32_t> NapiAudioEnum::effectModeMap = {
227 {"EFFECT_NONE", EFFECT_NONE},
228 {"EFFECT_DEFAULT", EFFECT_DEFAULT}
229 };
230
231 const std::map<std::string, int32_t> NapiAudioEnum::audioPrivacyTypeMap = {
232 {"PRIVACY_TYPE_PUBLIC", PRIVACY_TYPE_PUBLIC},
233 {"PRIVACY_TYPE_PRIVATE", PRIVACY_TYPE_PRIVATE}
234 };
235
236 const std::map<std::string, int32_t> NapiAudioEnum::deviceChangeTypeMap = {
237 {"CONNECT", CONNECT},
238 {"DISCONNECT", DISCONNECT}
239 };
240
241 const std::map<std::string, int32_t> NapiAudioEnum::audioSceneMap = {
242 {"AUDIO_SCENE_DEFAULT", AUDIO_SCENE_DEFAULT},
243 {"AUDIO_SCENE_RINGING", AUDIO_SCENE_RINGING},
244 {"AUDIO_SCENE_PHONE_CALL", AUDIO_SCENE_PHONE_CALL},
245 {"AUDIO_SCENE_VOICE_CHAT", AUDIO_SCENE_PHONE_CHAT}
246 };
247
248 const std::map<std::string, int32_t> NapiAudioEnum::interruptActionTypeMap = {
249 {"TYPE_ACTIVATED", TYPE_ACTIVATED},
250 {"TYPE_INTERRUPT", TYPE_INTERRUPT}
251 };
252
253 const std::map<std::string, int32_t> NapiAudioEnum::audioVolumeTypeMap = {
254 {"VOICE_CALL", NapiAudioEnum::VOICE_CALL},
255 {"RINGTONE", NapiAudioEnum::RINGTONE},
256 {"MEDIA", NapiAudioEnum::MEDIA},
257 {"VOICE_ASSISTANT", NapiAudioEnum::VOICE_ASSISTANT},
258 {"ALARM", NapiAudioEnum::ALARM},
259 {"ACCESSIBILITY", NapiAudioEnum::ACCESSIBILITY},
260 {"SYSTEM", NapiAudioEnum::SYSTEM},
261 {"ULTRASONIC", NapiAudioEnum::ULTRASONIC},
262 {"ALL", NapiAudioEnum::ALL}
263 };
264
265 const std::map<std::string, int32_t> NapiAudioEnum::activeDeviceTypeMap = {
266 {"SPEAKER", DeviceType::DEVICE_TYPE_SPEAKER},
267 {"BLUETOOTH_SCO", DeviceType::DEVICE_TYPE_BLUETOOTH_SCO}
268 };
269
270 const std::map<std::string, int32_t> NapiAudioEnum::interruptModeMap = {
271 {"SHARE_MODE", NapiAudioEnum::SHARE_MODE},
272 {"INDEPENDENT_MODE", NapiAudioEnum::INDEPENDENT_MODE}
273 };
274
275 const std::map<std::string, int32_t> NapiAudioEnum::focusTypeMap = {
276 {"FOCUS_TYPE_RECORDING", NapiAudioEnum::FOCUS_TYPE_RECORDING}
277 };
278
279 const std::map<std::string, int32_t> NapiAudioEnum::audioErrorsMap = {
280 {"ERROR_INVALID_PARAM", ERROR_INVALID_PARAM},
281 {"ERROR_NO_MEMORY", ERROR_NO_MEMORY},
282 {"ERROR_ILLEGAL_STATE", ERROR_ILLEGAL_STATE},
283 {"ERROR_UNSUPPORTED", ERROR_UNSUPPORTED},
284 {"ERROR_TIMEOUT", ERROR_TIMEOUT},
285 {"ERROR_STREAM_LIMIT", ERROR_STREAM_LIMIT},
286 {"ERROR_SYSTEM", ERROR_SYSTEM}
287 };
288
289 const std::map<std::string, int32_t> NapiAudioEnum::communicationDeviceTypeMap = {
290 {"SPEAKER", DeviceType::DEVICE_TYPE_SPEAKER},
291 };
292
293 const std::map<std::string, int32_t> NapiAudioEnum::interruptRequestTypeMap = {
294 {"INTERRUPT_REQUEST_TYPE_DEFAULT", INTERRUPT_REQUEST_TYPE_DEFAULT},
295 };
296
297 const std::map<std::string, int32_t> NapiAudioEnum::interruptRequestResultTypeMap = {
298 {"INTERRUPT_REQUEST_GRANT", INTERRUPT_REQUEST_GRANT},
299 {"INTERRUPT_REQUEST_REJECT", INTERRUPT_REQUEST_REJECT},
300 };
301
302 const std::map<std::string, int32_t> NapiAudioEnum::deviceFlagMap = {
303 {"NONE_DEVICES_FLAG", NONE_DEVICES_FLAG},
304 {"OUTPUT_DEVICES_FLAG", OUTPUT_DEVICES_FLAG},
305 {"INPUT_DEVICES_FLAG", INPUT_DEVICES_FLAG},
306 {"ALL_DEVICES_FLAG", ALL_DEVICES_FLAG},
307 {"DISTRIBUTED_OUTPUT_DEVICES_FLAG", DISTRIBUTED_OUTPUT_DEVICES_FLAG},
308 {"DISTRIBUTED_INPUT_DEVICES_FLAG", DISTRIBUTED_INPUT_DEVICES_FLAG},
309 {"ALL_DISTRIBUTED_DEVICES_FLAG", ALL_DISTRIBUTED_DEVICES_FLAG}
310 };
311
312 const std::map<std::string, int32_t> NapiAudioEnum::connectTypeMap = {
313 {"CONNECT_TYPE_LOCAL", CONNECT_TYPE_LOCAL},
314 {"CONNECT_TYPE_DISTRIBUTED", CONNECT_TYPE_DISTRIBUTED}
315 };
316
317 const std::map<std::string, int32_t> NapiAudioEnum::audioRingModeMap = {
318 {"RINGER_MODE_SILENT", NapiAudioEnum::RINGER_MODE_SILENT},
319 {"RINGER_MODE_VIBRATE", NapiAudioEnum::RINGER_MODE_VIBRATE},
320 {"RINGER_MODE_NORMAL", NapiAudioEnum::RINGER_MODE_NORMAL}
321 };
322
323 const std::map<std::string, int32_t> NapiAudioEnum::toneTypeMap = {
324 {"TONE_TYPE_DIAL_0", TONE_TYPE_DIAL_0},
325 {"TONE_TYPE_DIAL_1", TONE_TYPE_DIAL_1},
326 {"TONE_TYPE_DIAL_2", TONE_TYPE_DIAL_2},
327 {"TONE_TYPE_DIAL_3", TONE_TYPE_DIAL_3},
328 {"TONE_TYPE_DIAL_4", TONE_TYPE_DIAL_4},
329 {"TONE_TYPE_DIAL_5", TONE_TYPE_DIAL_5},
330 {"TONE_TYPE_DIAL_6", TONE_TYPE_DIAL_6},
331 {"TONE_TYPE_DIAL_7", TONE_TYPE_DIAL_7},
332 {"TONE_TYPE_DIAL_8", TONE_TYPE_DIAL_8},
333 {"TONE_TYPE_DIAL_9", TONE_TYPE_DIAL_9},
334 {"TONE_TYPE_DIAL_S", TONE_TYPE_DIAL_S},
335 {"TONE_TYPE_DIAL_P", TONE_TYPE_DIAL_P},
336 {"TONE_TYPE_DIAL_A", TONE_TYPE_DIAL_A},
337 {"TONE_TYPE_DIAL_B", TONE_TYPE_DIAL_B},
338 {"TONE_TYPE_DIAL_C", TONE_TYPE_DIAL_C},
339 {"TONE_TYPE_DIAL_D", TONE_TYPE_DIAL_D},
340 {"TONE_TYPE_COMMON_SUPERVISORY_DIAL", TONE_TYPE_COMMON_SUPERVISORY_DIAL},
341 {"TONE_TYPE_COMMON_SUPERVISORY_BUSY", TONE_TYPE_COMMON_SUPERVISORY_BUSY},
342 {"TONE_TYPE_COMMON_SUPERVISORY_CONGESTION", TONE_TYPE_COMMON_SUPERVISORY_CONGESTION},
343 {"TONE_TYPE_COMMON_SUPERVISORY_RADIO_ACK", TONE_TYPE_COMMON_SUPERVISORY_RADIO_ACK},
344 {"TONE_TYPE_COMMON_SUPERVISORY_RADIO_NOT_AVAILABLE", TONE_TYPE_COMMON_SUPERVISORY_RADIO_NOT_AVAILABLE},
345 {"TONE_TYPE_COMMON_SUPERVISORY_CALL_WAITING", TONE_TYPE_COMMON_SUPERVISORY_CALL_WAITING},
346 {"TONE_TYPE_COMMON_SUPERVISORY_RINGTONE", TONE_TYPE_COMMON_SUPERVISORY_RINGTONE},
347 {"TONE_TYPE_COMMON_SUPERVISORY_CALL_HOLDING", TONE_TYPE_COMMON_SUPERVISORY_CALL_HOLDING},
348 {"TONE_TYPE_COMMON_PROPRIETARY_BEEP", TONE_TYPE_COMMON_PROPRIETARY_BEEP},
349 {"TONE_TYPE_COMMON_PROPRIETARY_ACK", TONE_TYPE_COMMON_PROPRIETARY_ACK},
350 {"TONE_TYPE_COMMON_PROPRIETARY_PROMPT", TONE_TYPE_COMMON_PROPRIETARY_PROMPT},
351 {"TONE_TYPE_COMMON_PROPRIETARY_DOUBLE_BEEP", TONE_TYPE_COMMON_PROPRIETARY_DOUBLE_BEEP},
352 };
353
354 const std::map<std::string, int32_t> NapiAudioEnum::audioDeviceUsageMap = {
355 {"MEDIA_OUTPUT_DEVICES", MEDIA_OUTPUT_DEVICES },
356 {"MEDIA_INPUT_DEVICES", MEDIA_INPUT_DEVICES},
357 {"ALL_MEDIA_DEVICES", ALL_MEDIA_DEVICES},
358 {"CALL_OUTPUT_DEVICES", CALL_OUTPUT_DEVICES},
359 {"CALL_INPUT_DEVICES", CALL_INPUT_DEVICES},
360 {"ALL_CALL_DEVICES", ALL_CALL_DEVICES},
361 };
362
363 const std::map<std::string, int32_t> NapiAudioEnum::policyTypeMap = {
364 {"EDM", EDM_POLICY_TYPE},
365 {"PRIVACY", PRIVACY_POLCIY_TYPE},
366 {"TEMPORARY", TEMPORARY_POLCIY_TYPE},
367 };
368
369 const std::map<std::string, int32_t> NapiAudioEnum::audioDeviceChangeReasonMap = {
370 {"REASON_UNKNOWN", static_cast<int32_t>(AudioStreamDeviceChangeReason::UNKNOWN)},
371 {"REASON_NEW_DEVICE_AVAILABLE", static_cast<int32_t>(AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE)},
372 {"REASON_OLD_DEVICE_UNAVAILABLE", static_cast<int32_t>(AudioStreamDeviceChangeReason::OLD_DEVICE_UNAVALIABLE)},
373 {"REASON_OVERRODE", static_cast<int32_t>(AudioStreamDeviceChangeReason::OVERRODE)},
374 {"REASON_SESSION_ACTIVATED", static_cast<int32_t>(AudioStreamDeviceChangeReason::AUDIO_SESSION_ACTIVATE)},
375 {"REASON_STREAM_PRIORITY_CHANGED", static_cast<int32_t>(AudioStreamDeviceChangeReason::STREAM_PRIORITY_CHANGED)},
376 };
377
378 const std::map<std::string, int32_t> NapiAudioEnum::audioSpatialDeivceTypeMap = {
379 {"SPATIAL_DEVICE_TYPE_NONE", EARPHONE_TYPE_NONE },
380 {"SPATIAL_DEVICE_TYPE_IN_EAR_HEADPHONE", EARPHONE_TYPE_INEAR},
381 {"SPATIAL_DEVICE_TYPE_HALF_IN_EAR_HEADPHONE", EARPHONE_TYPE_HALF_INEAR},
382 {"SPATIAL_DEVICE_TYPE_OVER_EAR_HEADPHONE", EARPHONE_TYPE_HEADPHONE},
383 {"SPATIAL_DEVICE_TYPE_GLASSES", EARPHONE_TYPE_GLASSES},
384 {"SPATIAL_DEVICE_TYPE_OTHERS", EARPHONE_TYPE_OTHERS},
385 };
386
387 const std::map<std::string, uint64_t> NapiAudioEnum::audioChannelLayoutMap = {
388 {"CH_LAYOUT_UNKNOWN", CH_LAYOUT_UNKNOWN},
389 {"CH_LAYOUT_MONO", CH_LAYOUT_MONO},
390 {"CH_LAYOUT_STEREO", CH_LAYOUT_STEREO},
391 {"CH_LAYOUT_STEREO_DOWNMIX", CH_LAYOUT_STEREO_DOWNMIX},
392 {"CH_LAYOUT_2POINT1", CH_LAYOUT_2POINT1},
393 {"CH_LAYOUT_3POINT0", CH_LAYOUT_3POINT0},
394 {"CH_LAYOUT_SURROUND", CH_LAYOUT_SURROUND},
395 {"CH_LAYOUT_3POINT1", CH_LAYOUT_3POINT1},
396 {"CH_LAYOUT_4POINT0", CH_LAYOUT_4POINT0},
397 {"CH_LAYOUT_QUAD_SIDE", CH_LAYOUT_QUAD_SIDE},
398 {"CH_LAYOUT_QUAD", CH_LAYOUT_QUAD},
399 {"CH_LAYOUT_2POINT0POINT2", CH_LAYOUT_2POINT0POINT2},
400 {"CH_LAYOUT_4POINT1", CH_LAYOUT_4POINT1},
401 {"CH_LAYOUT_5POINT0", CH_LAYOUT_5POINT0},
402 {"CH_LAYOUT_5POINT0_BACK", CH_LAYOUT_5POINT0_BACK},
403 {"CH_LAYOUT_2POINT1POINT2", CH_LAYOUT_2POINT1POINT2},
404 {"CH_LAYOUT_3POINT0POINT2", CH_LAYOUT_3POINT0POINT2},
405 {"CH_LAYOUT_5POINT1", CH_LAYOUT_5POINT1},
406 {"CH_LAYOUT_5POINT1_BACK", CH_LAYOUT_5POINT1_BACK},
407 {"CH_LAYOUT_6POINT0", CH_LAYOUT_6POINT0},
408 {"CH_LAYOUT_HEXAGONAL", CH_LAYOUT_HEXAGONAL},
409 {"CH_LAYOUT_3POINT1POINT2", CH_LAYOUT_3POINT1POINT2},
410 {"CH_LAYOUT_6POINT0_FRONT", CH_LAYOUT_6POINT0_FRONT},
411 {"CH_LAYOUT_6POINT1", CH_LAYOUT_6POINT1},
412 {"CH_LAYOUT_6POINT1_BACK", CH_LAYOUT_6POINT1_BACK},
413 {"CH_LAYOUT_6POINT1_FRONT", CH_LAYOUT_6POINT1_FRONT},
414 {"CH_LAYOUT_7POINT0", CH_LAYOUT_7POINT0},
415 {"CH_LAYOUT_7POINT0_FRONT", CH_LAYOUT_7POINT0_FRONT},
416 {"CH_LAYOUT_7POINT1", CH_LAYOUT_7POINT1},
417 {"CH_LAYOUT_OCTAGONAL", CH_LAYOUT_OCTAGONAL},
418 {"CH_LAYOUT_5POINT1POINT2", CH_LAYOUT_5POINT1POINT2},
419 {"CH_LAYOUT_7POINT1_WIDE", CH_LAYOUT_7POINT1_WIDE},
420 {"CH_LAYOUT_7POINT1_WIDE_BACK", CH_LAYOUT_7POINT1_WIDE_BACK},
421 {"CH_LAYOUT_5POINT1POINT4", CH_LAYOUT_5POINT1POINT4},
422 {"CH_LAYOUT_7POINT1POINT2", CH_LAYOUT_7POINT1POINT2},
423 {"CH_LAYOUT_7POINT1POINT4", CH_LAYOUT_7POINT1POINT4},
424 {"CH_LAYOUT_10POINT2", CH_LAYOUT_10POINT2},
425 {"CH_LAYOUT_9POINT1POINT4", CH_LAYOUT_9POINT1POINT4},
426 {"CH_LAYOUT_9POINT1POINT6", CH_LAYOUT_9POINT1POINT6},
427 {"CH_LAYOUT_HEXADECAGONAL", CH_LAYOUT_HEXADECAGONAL},
428 {"CH_LAYOUT_AMB_ORDER1_ACN_N3D", CH_LAYOUT_HOA_ORDER1_ACN_N3D},
429 {"CH_LAYOUT_AMB_ORDER1_ACN_SN3D", CH_LAYOUT_HOA_ORDER1_ACN_SN3D},
430 {"CH_LAYOUT_AMB_ORDER1_FUMA", CH_LAYOUT_HOA_ORDER1_FUMA},
431 {"CH_LAYOUT_AMB_ORDER2_ACN_N3D", CH_LAYOUT_HOA_ORDER2_ACN_N3D},
432 {"CH_LAYOUT_AMB_ORDER2_ACN_SN3D", CH_LAYOUT_HOA_ORDER2_ACN_SN3D},
433 {"CH_LAYOUT_AMB_ORDER2_FUMA", CH_LAYOUT_HOA_ORDER2_FUMA},
434 {"CH_LAYOUT_AMB_ORDER3_ACN_N3D", CH_LAYOUT_HOA_ORDER3_ACN_N3D},
435 {"CH_LAYOUT_AMB_ORDER3_ACN_SN3D", CH_LAYOUT_HOA_ORDER3_ACN_SN3D},
436 {"CH_LAYOUT_AMB_ORDER3_FUMA", CH_LAYOUT_HOA_ORDER3_FUMA},
437 };
438
439 const std::map<std::string, int32_t> NapiAudioEnum::spatializationSceneTypeMap = {
440 {"DEFAULT", SPATIALIZATION_SCENE_TYPE_DEFAULT },
441 {"MUSIC", SPATIALIZATION_SCENE_TYPE_MUSIC},
442 {"MOVIE", SPATIALIZATION_SCENE_TYPE_MOVIE},
443 {"AUDIOBOOK", SPATIALIZATION_SCENE_TYPE_AUDIOBOOK},
444 };
445
446 const std::map<std::string, int32_t> NapiAudioEnum::asrNoiseSuppressionModeMap = {
447 {"BYPASS", static_cast<int32_t>(AsrNoiseSuppressionMode::BYPASS)},
448 {"STANDARD", static_cast<int32_t>(AsrNoiseSuppressionMode::STANDARD)},
449 {"NEAR_FIELD", static_cast<int32_t>(AsrNoiseSuppressionMode::NEAR_FIELD)},
450 {"FAR_FIELD", static_cast<int32_t>(AsrNoiseSuppressionMode::FAR_FIELD)},
451 {"FULL_DUPLEX_STANDARD", static_cast<int32_t>(AsrNoiseSuppressionMode::FULL_DUPLEX_STANDARD)},
452 {"FULL_DUPLEX_NEAR_FIELD", static_cast<int32_t>(AsrNoiseSuppressionMode::FULL_DUPLEX_NEAR_FIELD)},
453 {"ASR_WHISPER_MODE", static_cast<int32_t>(AsrNoiseSuppressionMode::ASR_WHISPER_MODE)}
454 };
455
456 const std::map<std::string, int32_t> NapiAudioEnum::asrAecModeMap = {
457 {"BYPASS", static_cast<int32_t>(AsrAecMode::BYPASS)},
458 {"STANDARD", static_cast<int32_t>(AsrAecMode::STANDARD)},
459 {"EXPAND", static_cast<int32_t>(AsrAecMode::EXPAND)},
460 {"FOLDED", static_cast<int32_t>(AsrAecMode::FOLDED)}
461 };
462
463 const std::map<std::string, int32_t> NapiAudioEnum::asrWhisperDetectionModeMap = {
464 {"BYPASS", static_cast<int32_t>(AsrWhisperDetectionMode::BYPASS)},
465 {"STANDARD", static_cast<int32_t>(AsrWhisperDetectionMode::STANDARD)}
466 };
467
468 const std::map<std::string, int32_t> NapiAudioEnum::asrVoiceControlModeMap = {
469 {"AUDIO_2_VOICETX", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_2_VOICETX)},
470 {"AUDIO_MIX_2_VOICETX", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_MIX_2_VOICETX)},
471 {"AUDIO_2_VOICE_TX_EX", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_2_VOICE_TX_EX)},
472 {"AUDIO_MIX_2_VOICE_TX_EX", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_MIX_2_VOICE_TX_EX)},
473 {"AUDIO_SUPPRESSION_OPPOSITE", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_SUPPRESSION_OPPOSITE)},
474 {"AUDIO_SUPPRESSION_LOCAL", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_SUPPRESSION_LOCAL)},
475 {"VOICE_TXRX_DECREASE", static_cast<int32_t>(AsrVoiceControlMode::VOICE_TXRX_DECREASE)}
476 };
477
478 const std::map<std::string, int32_t> NapiAudioEnum::asrVoiceMuteModeMap = {
479 {"OUTPUT_MUTE", static_cast<int32_t>(AsrVoiceMuteMode::OUTPUT_MUTE)},
480 {"INPUT_MUTE", static_cast<int32_t>(AsrVoiceMuteMode::INPUT_MUTE)},
481 {"TTS_MUTE", static_cast<int32_t>(AsrVoiceMuteMode::TTS_MUTE)},
482 {"CALL_MUTE", static_cast<int32_t>(AsrVoiceMuteMode::CALL_MUTE)},
483 {"OUTPUT_MUTE_EX", static_cast<int32_t>(AsrVoiceMuteMode::OUTPUT_MUTE_EX)}
484 };
485
486 const std::map<std::string, int32_t> NapiAudioEnum::audioDataCallbackResultMap = {
487 {"INVALID", NapiAudioEnum::CALLBACK_RESULT_INVALID},
488 {"VALID", NapiAudioEnum::CALLBACK_RESULT_VALID}
489 };
490
491 const std::map<std::string, int32_t> NapiAudioEnum::concurrencyModeMap = {
492 {"CONCURRENCY_DEFAULT", static_cast<int32_t>(AudioConcurrencyMode::DEFAULT)},
493 {"CONCURRENCY_MIX_WITH_OTHERS", static_cast<int32_t>(AudioConcurrencyMode::MIX_WITH_OTHERS)},
494 {"CONCURRENCY_DUCK_OTHERS", static_cast<int32_t>(AudioConcurrencyMode::DUCK_OTHERS)},
495 {"CONCURRENCY_PAUSE_OTHERS", static_cast<int32_t>(AudioConcurrencyMode::PAUSE_OTHERS)}
496 };
497
498 const std::map<std::string, int32_t> NapiAudioEnum::reasonMap = {
499 {"DEACTIVATED_LOWER_PRIORITY", static_cast<int32_t>(AudioSessionDeactiveReason::LOW_PRIORITY)},
500 {"DEACTIVATED_TIMEOUT", static_cast<int32_t>(AudioSessionDeactiveReason::TIMEOUT)}
501 };
502
503 const std::map<std::string, int32_t> NapiAudioEnum::audioLoopbackModeMap = {
504 {"HARDWARE", LOOPBACK_MODE_HARDWARE},
505 };
506
507 const std::map<std::string, int32_t> NapiAudioEnum::audioLoopbackStatusMap = {
508 {"UNAVAILABLE_DEVICE", LOOPBACK_UNAVAILABLE_DEVICE},
509 {"UNAVAILABLE_SCENE", LOOPBACK_UNAVAILABLE_SCENE},
510 {"AVAILABLE_IDLE", LOOPBACK_AVAILABLE_IDLE},
511 {"AVAILABLE_RUNNING", LOOPBACK_AVAILABLE_RUNNING},
512 };
513
514 const std::map<std::string, int32_t> NapiAudioEnum::audioLoopbackReverbPresetMap = {
515 {"ORIGINAL", REVERB_PRESET_ORIGINAL},
516 {"KTV", REVERB_PRESET_KTV},
517 {"THEATRE", REVERB_PRESET_THEATRE},
518 {"CONCERT", REVERB_PRESET_CONCERT},
519 };
520
521
522 const std::map<std::string, int32_t> NapiAudioEnum::audioLoopbackEqualizerPresetMap = {
523 {"FLAT", EQUALIZER_PRESET_FLAT},
524 {"FULL", EQUALIZER_PRESET_FULL},
525 {"BRIGHT", EQUALIZER_PRESET_BRIGHT},
526 };
527
528 const std::map<std::string, int32_t> NapiAudioEnum::audioSessionSceneMap = {
529 {"AUDIO_SESSION_SCENE_MEDIA", static_cast<int32_t>(AudioSessionScene::MEDIA)},
530 {"AUDIO_SESSION_SCENE_GAME", static_cast<int32_t>(AudioSessionScene::GAME)},
531 {"AUDIO_SESSION_SCENE_VOICE_COMMUNICATION", static_cast<int32_t>(AudioSessionScene::VOICE_COMMUNICATION)},
532 };
533
534 const std::map<std::string, int32_t> NapiAudioEnum::audioSessionStateChangeHintMap = {
535 {"AUDIO_SESSION_STATE_CHANGE_HINT_RESUME", static_cast<int32_t>(AudioSessionStateChangeHint::RESUME)},
536 {"AUDIO_SESSION_STATE_CHANGE_HINT_PAUSE", static_cast<int32_t>(AudioSessionStateChangeHint::PAUSE)},
537 {"AUDIO_SESSION_STATE_CHANGE_HINT_STOP", static_cast<int32_t>(AudioSessionStateChangeHint::STOP)},
538 {"AUDIO_SESSION_STATE_CHANGE_HINT_TIME_OUT_STOP",
539 static_cast<int32_t>(AudioSessionStateChangeHint::TIME_OUT_STOP)},
540 {"AUDIO_SESSION_STATE_CHANGE_HINT_DUCK", static_cast<int32_t>(AudioSessionStateChangeHint::DUCK)},
541 {"AUDIO_SESSION_STATE_CHANGE_HINT_UNDUCK", static_cast<int32_t>(AudioSessionStateChangeHint::UNDUCK)},
542 };
543
544 const std::map<std::string, int32_t> NapiAudioEnum::outputDeviceChangeRecommendedActionMap = {
545 {"DEVICE_CHANGE_RECOMMEND_TO_CONTINUE",
546 static_cast<int32_t>(OutputDeviceChangeRecommendedAction::RECOMMEND_TO_CONTINUE)},
547 {"DEVICE_CHANGE_RECOMMEND_TO_STOP", static_cast<int32_t>(OutputDeviceChangeRecommendedAction::RECOMMEND_TO_STOP)},
548 };
549
NapiAudioEnum()550 NapiAudioEnum::NapiAudioEnum()
551 : env_(nullptr) {
552 }
553
~NapiAudioEnum()554 NapiAudioEnum::~NapiAudioEnum()
555 {
556 audioParameters_ = nullptr;
557 }
558
Destructor(napi_env env,void * nativeObject,void * finalizeHint)559 void NapiAudioEnum::Destructor(napi_env env, void *nativeObject, void *finalizeHint)
560 {
561 if (nativeObject != nullptr) {
562 auto obj = static_cast<NapiAudioEnum *>(nativeObject);
563 delete obj;
564 }
565 }
566
CreateEnumObject(const napi_env & env,const std::map<std::string,int32_t> & map)567 napi_value NapiAudioEnum::CreateEnumObject(const napi_env &env, const std::map<std::string, int32_t> &map)
568 {
569 napi_value enumObject = nullptr;
570 napi_status status = napi_create_object(env, &enumObject);
571 if (status != napi_ok) {
572 goto error;
573 }
574 for (const auto &iter : map) {
575 napi_value prop = nullptr;
576 if (napi_create_int32(env, iter.second, &prop) == napi_ok) {
577 napi_set_named_property(env, enumObject, (iter.first).c_str(), prop);
578 }
579 }
580 return enumObject;
581
582 error:
583 AUDIO_ERR_LOG("create Enum Object failed");
584 napi_get_undefined(env, &enumObject);
585 return enumObject;
586 }
587
CreateEnumInt64Object(const napi_env & env,const std::map<std::string,uint64_t> & map)588 napi_value NapiAudioEnum::CreateEnumInt64Object(const napi_env &env, const std::map<std::string, uint64_t> &map)
589 {
590 napi_value enumObject = nullptr;
591 napi_status status = napi_create_object(env, &enumObject);
592 if (status != napi_ok) {
593 goto error;
594 }
595 for (const auto &iter : map) {
596 napi_value prop = nullptr;
597 if (napi_create_int64(env, iter.second, &prop) == napi_ok) {
598 napi_set_named_property(env, enumObject, (iter.first).c_str(), prop);
599 }
600 }
601 return enumObject;
602
603 error:
604 AUDIO_ERR_LOG("create Enum Object failed");
605 napi_get_undefined(env, &enumObject);
606 return enumObject;
607 }
608
CreateLocalNetworkIdObject(napi_env env)609 napi_value NapiAudioEnum::CreateLocalNetworkIdObject(napi_env env)
610 {
611 napi_value result = nullptr;
612 napi_create_string_utf8(env, LOCAL_NETWORK_ID, NAPI_AUTO_LENGTH, &result);
613 return result;
614 }
615
CreateDefaultVolumeGroupIdObject(napi_env env)616 napi_value NapiAudioEnum::CreateDefaultVolumeGroupIdObject(napi_env env)
617 {
618 napi_value defaultVolumeGroupId;
619 napi_create_int32(env, DEFAULT_VOLUME_GROUP_ID, &defaultVolumeGroupId);
620 return defaultVolumeGroupId;
621 }
622
CreateDefaultInterruptIdObject(napi_env env)623 napi_value NapiAudioEnum::CreateDefaultInterruptIdObject(napi_env env)
624 {
625 napi_value defaultInterruptId;
626 napi_create_int32(env, DEFAULT_VOLUME_INTERRUPT_ID, &defaultInterruptId);
627 return defaultInterruptId;
628 }
629
InitAudioExternEnum(napi_env env,napi_value exports)630 napi_status NapiAudioEnum::InitAudioExternEnum(napi_env env, napi_value exports)
631 {
632 napi_property_descriptor static_prop[] = {
633 DECLARE_NAPI_PROPERTY("AudioSpatialDeviceType", CreateEnumObject(env,
634 audioSpatialDeivceTypeMap)),
635 DECLARE_NAPI_PROPERTY("AudioChannelLayout", CreateEnumInt64Object(env,
636 audioChannelLayoutMap)),
637 DECLARE_NAPI_PROPERTY("AudioStreamDeviceChangeReason",
638 CreateEnumObject(env, audioDeviceChangeReasonMap)),
639 DECLARE_NAPI_PROPERTY("AudioSpatializationSceneType", CreateEnumObject(env,
640 spatializationSceneTypeMap)),
641 DECLARE_NAPI_PROPERTY("AsrNoiseSuppressionMode", CreateEnumObject(env, asrNoiseSuppressionModeMap)),
642 DECLARE_NAPI_PROPERTY("AsrAecMode", CreateEnumObject(env, asrAecModeMap)),
643 DECLARE_NAPI_PROPERTY("AsrWhisperDetectionMode", CreateEnumObject(env,
644 asrWhisperDetectionModeMap)),
645 DECLARE_NAPI_PROPERTY("AsrVoiceControlMode", CreateEnumObject(env,
646 asrVoiceControlModeMap)),
647 DECLARE_NAPI_PROPERTY("AsrVoiceMuteMode", CreateEnumObject(env, asrVoiceMuteModeMap)),
648 };
649 napi_status status =
650 napi_define_properties(env, exports, sizeof(static_prop) / sizeof(static_prop[0]), static_prop);
651 return status;
652 }
653
InitAudioEnum(napi_env env,napi_value exports)654 napi_status NapiAudioEnum::InitAudioEnum(napi_env env, napi_value exports)
655 {
656 napi_property_descriptor static_prop[] = {
657 DECLARE_NAPI_PROPERTY("AudioChannel", CreateEnumObject(env, audioChannelMap)),
658 DECLARE_NAPI_PROPERTY("AudioSamplingRate", CreateEnumObject(env, samplingRateMap)),
659 DECLARE_NAPI_PROPERTY("AudioEncodingType", CreateEnumObject(env, encodingTypeMap)),
660 DECLARE_NAPI_PROPERTY("ContentType", CreateEnumObject(env, contentTypeMap)),
661 DECLARE_NAPI_PROPERTY("StreamUsage", CreateEnumObject(env, streamUsageMap)),
662 DECLARE_NAPI_PROPERTY("AudioVolumeMode", CreateEnumObject(env, audioVolumeModeMap)),
663 DECLARE_NAPI_PROPERTY("DeviceRole", CreateEnumObject(env, deviceRoleMap)),
664 DECLARE_NAPI_PROPERTY("DeviceType", CreateEnumObject(env, deviceTypeMap)),
665 DECLARE_NAPI_PROPERTY("SourceType", CreateEnumObject(env, sourceTypeMap)),
666 DECLARE_NAPI_PROPERTY("VolumeAdjustType", CreateEnumObject(env, volumeAdjustTypeMap)),
667 DECLARE_NAPI_PROPERTY("ChannelBlendMode", CreateEnumObject(env, channelBlendModeMap)),
668 DECLARE_NAPI_PROPERTY("AudioRendererRate", CreateEnumObject(env, rendererRateMap)),
669 DECLARE_NAPI_PROPERTY("InterruptType", CreateEnumObject(env, interruptEventTypeMap)),
670 DECLARE_NAPI_PROPERTY("InterruptForceType", CreateEnumObject(env, interruptForceTypeMap)),
671 DECLARE_NAPI_PROPERTY("InterruptHint", CreateEnumObject(env, interruptHintTypeMap)),
672 DECLARE_NAPI_PROPERTY("AudioState", CreateEnumObject(env, audioStateMap)),
673 DECLARE_NAPI_PROPERTY("AudioSampleFormat", CreateEnumObject(env, audioSampleFormatMap)),
674 DECLARE_NAPI_PROPERTY("AudioEffectMode", CreateEnumObject(env, effectModeMap)),
675 DECLARE_NAPI_PROPERTY("AudioPrivacyType", CreateEnumObject(env, audioPrivacyTypeMap)),
676 DECLARE_NAPI_PROPERTY("AudioVolumeType", CreateEnumObject(env, audioVolumeTypeMap)),
677 DECLARE_NAPI_PROPERTY("DeviceFlag", CreateEnumObject(env, deviceFlagMap)),
678 DECLARE_NAPI_PROPERTY("ActiveDeviceType", CreateEnumObject(env, activeDeviceTypeMap)),
679 DECLARE_NAPI_PROPERTY("ConnectType", CreateEnumObject(env, connectTypeMap)),
680 DECLARE_NAPI_PROPERTY("AudioRingMode", CreateEnumObject(env, audioRingModeMap)),
681 DECLARE_NAPI_PROPERTY("AudioScene", CreateEnumObject(env, audioSceneMap)),
682 DECLARE_NAPI_PROPERTY("DeviceChangeType", CreateEnumObject(env, deviceChangeTypeMap)),
683 DECLARE_NAPI_PROPERTY("InterruptActionType",
684 CreateEnumObject(env, interruptActionTypeMap)),
685 DECLARE_NAPI_PROPERTY("InterruptMode", CreateEnumObject(env, interruptModeMap)),
686 DECLARE_NAPI_PROPERTY("FocusType", CreateEnumObject(env, focusTypeMap)),
687 DECLARE_NAPI_PROPERTY("LOCAL_NETWORK_ID", CreateLocalNetworkIdObject(env)),
688 DECLARE_NAPI_PROPERTY("DEFAULT_VOLUME_GROUP_ID", CreateDefaultVolumeGroupIdObject(env)),
689 DECLARE_NAPI_PROPERTY("DEFAULT_INTERRUPT_GROUP_ID", CreateDefaultInterruptIdObject(env)),
690 DECLARE_NAPI_PROPERTY("AudioErrors", CreateEnumObject(env, audioErrorsMap)),
691 DECLARE_NAPI_PROPERTY("CommunicationDeviceType",
692 CreateEnumObject(env, communicationDeviceTypeMap)),
693 DECLARE_NAPI_PROPERTY("InterruptRequestType",
694 CreateEnumObject(env, interruptRequestTypeMap)),
695 DECLARE_NAPI_PROPERTY("InterruptRequestResultType",
696 CreateEnumObject(env, interruptRequestResultTypeMap)),
697 DECLARE_NAPI_PROPERTY("ToneType", CreateEnumObject(env, toneTypeMap)),
698 DECLARE_NAPI_PROPERTY("DeviceUsage", CreateEnumObject(env, audioDeviceUsageMap)),
699 DECLARE_NAPI_PROPERTY("AudioDataCallbackResult",
700 CreateEnumObject(env, audioDataCallbackResultMap)),
701 DECLARE_NAPI_PROPERTY("AudioConcurrencyMode",
702 CreateEnumObject(env, concurrencyModeMap)),
703 DECLARE_NAPI_PROPERTY("AudioSessionDeactivatedReason", CreateEnumObject(env, reasonMap)),
704 DECLARE_NAPI_PROPERTY("PolicyType", CreateEnumObject(env, policyTypeMap)),
705 DECLARE_NAPI_PROPERTY("AudioLoopbackMode", CreateEnumObject(env, audioLoopbackModeMap)),
706 DECLARE_NAPI_PROPERTY("AudioLoopbackStatus",
707 CreateEnumObject(env, audioLoopbackStatusMap)),
708 DECLARE_NAPI_PROPERTY("AudioLoopbackReverbPreset",
709 CreateEnumObject(env, audioLoopbackReverbPresetMap)),
710 DECLARE_NAPI_PROPERTY("AudioLoopbackEqualizerPreset",
711 CreateEnumObject(env, audioLoopbackEqualizerPresetMap)),
712 DECLARE_NAPI_PROPERTY("AudioSessionScene", CreateEnumObject(env, audioSessionSceneMap)),
713 DECLARE_NAPI_PROPERTY("AudioSessionStateChangeHint",
714 CreateEnumObject(env, audioSessionStateChangeHintMap)),
715 DECLARE_NAPI_PROPERTY("OutputDeviceChangeRecommendedAction",
716 CreateEnumObject(env, outputDeviceChangeRecommendedActionMap)),
717 };
718 return napi_define_properties(env, exports, sizeof(static_prop) / sizeof(static_prop[0]), static_prop);
719 }
720
Init(napi_env env,napi_value exports)721 napi_value NapiAudioEnum::Init(napi_env env, napi_value exports)
722 {
723 AUDIO_DEBUG_LOG("NapiAudioEnum::Init()");
724 napi_value constructor;
725 napi_value result = nullptr;
726 napi_get_undefined(env, &result);
727
728 napi_property_descriptor audio_parameters_properties[] = {
729 DECLARE_NAPI_GETTER_SETTER("format", GetAudioSampleFormat, SetAudioSampleFormat),
730 DECLARE_NAPI_GETTER_SETTER("channels", GetAudioChannel, SetAudioChannel),
731 DECLARE_NAPI_GETTER_SETTER("samplingRate", GetAudioSamplingRate, SetAudioSamplingRate),
732 DECLARE_NAPI_GETTER_SETTER("encoding", GetAudioEncodingType, SetAudioEncodingType),
733 DECLARE_NAPI_GETTER_SETTER("contentType", GetContentType, SetContentType),
734 DECLARE_NAPI_GETTER_SETTER("usage", GetStreamUsage, SetStreamUsage),
735 DECLARE_NAPI_GETTER_SETTER("deviceRole", GetDeviceRole, SetDeviceRole),
736 DECLARE_NAPI_GETTER_SETTER("deviceType", GetDeviceType, SetDeviceType),
737 DECLARE_NAPI_GETTER_SETTER("mode", GetVolumeMode, SetVolumeMode)
738 };
739
740 napi_status status = napi_define_class(env, NAPI_AUDIO_ENUM_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct,
741 nullptr, sizeof(audio_parameters_properties) / sizeof(audio_parameters_properties[0]),
742 audio_parameters_properties, &constructor);
743 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "napi_define_class fail");
744
745 status = napi_create_reference(env, constructor, REFERENCE_CREATION_COUNT, &sConstructor_);
746 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "napi_create_reference fail");
747 status = napi_set_named_property(env, exports, NAPI_AUDIO_ENUM_CLASS_NAME.c_str(), constructor);
748 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "napi_set_named_property fail");
749 status = InitAudioEnum(env, exports);
750 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "InitAudioEnum failed");
751 status = InitAudioExternEnum(env, exports);
752 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "InitAudioExternEnum failed");
753
754 return exports;
755 }
756
Construct(napi_env env,napi_callback_info info)757 napi_value NapiAudioEnum::Construct(napi_env env, napi_callback_info info)
758 {
759 napi_value jsThis = nullptr;
760 size_t argCount = 0;
761 unique_ptr<NapiAudioEnum> obj = nullptr;
762
763 napi_status status = napi_get_cb_info(env, info, &argCount, nullptr, &jsThis, nullptr);
764 if (status != napi_ok) {
765 AUDIO_ERR_LOG("Construct:napi_get_cb_info failed!");
766 goto error;
767 }
768
769 obj = make_unique<NapiAudioEnum>();
770 if (obj == nullptr) {
771 AUDIO_ERR_LOG("obj make_unique failed,no memery.");
772 goto error;
773 }
774 obj->env_ = env;
775 obj->audioParameters_ = move(sAudioParameters_);
776 status = napi_wrap(env, jsThis, static_cast<void*>(obj.get()), NapiAudioEnum::Destructor, nullptr, nullptr);
777 if (status != napi_ok) {
778 goto error;
779 }
780 obj.release();
781 return jsThis;
782
783 error:
784 napi_get_undefined(env, &jsThis);
785 return jsThis;
786 }
787
SetValue(napi_env env,napi_callback_info info,napi_value * args,napi_value & result)788 NapiAudioEnum* NapiAudioEnum::SetValue(napi_env env, napi_callback_info info, napi_value *args, napi_value &result)
789 {
790 NapiAudioEnum *napiAudioEnum = nullptr;
791 size_t argc = 1;
792 napi_value jsThis = nullptr;
793 napi_get_undefined(env, &result);
794
795 napi_status status = napi_get_cb_info(env, info, &argc, args, &jsThis, nullptr);
796 if (status != napi_ok || jsThis == nullptr || argc < 1) {
797 AUDIO_ERR_LOG("SetValue fail to napi_get_cb_info");
798 return nullptr;
799 }
800
801 status = napi_unwrap(env, jsThis, (void **)&napiAudioEnum);
802 CHECK_AND_RETURN_RET_LOG(status == napi_ok, napiAudioEnum, "napi_unwrap failed");
803
804 napi_valuetype valueType = napi_undefined;
805 if (napi_typeof(env, args[0], &valueType) != napi_ok || valueType != napi_number) {
806 AUDIO_ERR_LOG("SetValue fail: wrong data type");
807 }
808 return napiAudioEnum;
809 }
810
GetValue(napi_env env,napi_callback_info info)811 NapiAudioEnum* NapiAudioEnum::GetValue(napi_env env, napi_callback_info info)
812 {
813 NapiAudioEnum *napiAudioEnum = nullptr;
814 size_t argc = 0;
815 napi_value jsThis = nullptr;
816
817 napi_status status = napi_get_cb_info(env, info, &argc, nullptr, &jsThis, nullptr);
818 if (status != napi_ok || jsThis == nullptr) {
819 AUDIO_ERR_LOG("GetValue fail to napi_get_cb_info");
820 return nullptr;
821 }
822
823 status = napi_unwrap(env, jsThis, (void **)&napiAudioEnum);
824 CHECK_AND_RETURN_RET_LOG(status == napi_ok, napiAudioEnum, "napi_unwrap failed");
825 if (!((napiAudioEnum != nullptr) && (napiAudioEnum->audioParameters_ != nullptr))) {
826 AUDIO_ERR_LOG("GetValue fail to napi_unwrap");
827 }
828 return napiAudioEnum;
829 }
830
GetAudioSampleFormat(napi_env env,napi_callback_info info)831 napi_value NapiAudioEnum::GetAudioSampleFormat(napi_env env, napi_callback_info info)
832 {
833 AudioSampleFormat audioSampleFormat;
834 napi_value jsResult = nullptr;
835 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
836
837 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
838 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
839 audioSampleFormat = napiAudioEnum->audioParameters_->format;
840 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(audioSampleFormat), jsResult);
841 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetAudioSampleFormat fail");
842 return jsResult;
843 }
844
SetAudioSampleFormat(napi_env env,napi_callback_info info)845 napi_value NapiAudioEnum::SetAudioSampleFormat(napi_env env, napi_callback_info info)
846 {
847 napi_value jsResult = nullptr;
848 napi_value args[1] = { nullptr };
849 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
850 int32_t audioSampleFormat;
851 napi_status status = NapiParamUtils::GetValueInt32(env, audioSampleFormat, args[0]);
852 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
853
854 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
855 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
856 napiAudioEnum->audioParameters_->format = static_cast<AudioSampleFormat>(audioSampleFormat);
857
858 return jsResult;
859 }
860
GetAudioChannel(napi_env env,napi_callback_info info)861 napi_value NapiAudioEnum::GetAudioChannel(napi_env env, napi_callback_info info)
862 {
863 AudioChannel audioChannel;
864 napi_value jsResult = nullptr;
865 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
866
867 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
868 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
869 audioChannel = napiAudioEnum->audioParameters_->channels;
870 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(audioChannel), jsResult);
871 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetAudioChannel fail");
872
873 return jsResult;
874 }
875
SetAudioChannel(napi_env env,napi_callback_info info)876 napi_value NapiAudioEnum::SetAudioChannel(napi_env env, napi_callback_info info)
877 {
878 napi_value jsResult = nullptr;
879 napi_value args[1] = { nullptr };
880 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
881 int32_t audioChannel;
882 napi_status status = NapiParamUtils::GetValueInt32(env, audioChannel, args[0]);
883 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
884
885 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
886 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
887 napiAudioEnum->audioParameters_->channels = static_cast<AudioChannel>(audioChannel);
888
889 return jsResult;
890 }
891
GetAudioSamplingRate(napi_env env,napi_callback_info info)892 napi_value NapiAudioEnum::GetAudioSamplingRate(napi_env env, napi_callback_info info)
893 {
894 AudioSamplingRate samplingRate;
895 napi_value jsResult = nullptr;
896 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
897
898 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
899 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
900 samplingRate = napiAudioEnum->audioParameters_->samplingRate;
901 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(samplingRate), jsResult);
902 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetAudioSamplingRate fail");
903
904 return jsResult;
905 }
906
SetAudioSamplingRate(napi_env env,napi_callback_info info)907 napi_value NapiAudioEnum::SetAudioSamplingRate(napi_env env, napi_callback_info info)
908 {
909 napi_value jsResult = nullptr;
910 napi_value args[1] = { nullptr };
911 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
912 int32_t samplingRate;
913 napi_status status = NapiParamUtils::GetValueInt32(env, samplingRate, args[0]);
914 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
915
916 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
917 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
918 napiAudioEnum->audioParameters_->samplingRate = static_cast<AudioSamplingRate>(samplingRate);
919
920 return jsResult;
921 }
922
GetAudioEncodingType(napi_env env,napi_callback_info info)923 napi_value NapiAudioEnum::GetAudioEncodingType(napi_env env, napi_callback_info info)
924 {
925 AudioEncodingType encodingType;
926 napi_value jsResult = nullptr;
927 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
928
929 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
930 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
931 encodingType = napiAudioEnum->audioParameters_->encoding;
932 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(encodingType), jsResult);
933 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetAudioEncodingType fail");
934
935 return jsResult;
936 }
937
SetAudioEncodingType(napi_env env,napi_callback_info info)938 napi_value NapiAudioEnum::SetAudioEncodingType(napi_env env, napi_callback_info info)
939 {
940 napi_value jsResult = nullptr;
941 napi_value args[1] = { nullptr };
942 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
943 int32_t encodingType;
944 napi_status status = NapiParamUtils::GetValueInt32(env, encodingType, args[0]);
945 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
946
947 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
948 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
949 napiAudioEnum->audioParameters_->encoding = static_cast<AudioEncodingType>(encodingType);
950
951 return jsResult;
952 }
953
GetContentType(napi_env env,napi_callback_info info)954 napi_value NapiAudioEnum::GetContentType(napi_env env, napi_callback_info info)
955 {
956 ContentType contentType;
957 napi_value jsResult = nullptr;
958 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
959
960 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
961 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
962 contentType = napiAudioEnum->audioParameters_->contentType;
963 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(contentType), jsResult);
964 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetContentType fail");
965
966 return jsResult;
967 }
968
SetContentType(napi_env env,napi_callback_info info)969 napi_value NapiAudioEnum::SetContentType(napi_env env, napi_callback_info info)
970 {
971 napi_value jsResult = nullptr;
972 napi_value args[1] = { nullptr };
973 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
974 int32_t contentType;
975 napi_status status = NapiParamUtils::GetValueInt32(env, contentType, args[0]);
976 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
977
978 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
979 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
980 napiAudioEnum->audioParameters_->contentType = static_cast<ContentType>(contentType);
981
982 return jsResult;
983 }
984
GetStreamUsage(napi_env env,napi_callback_info info)985 napi_value NapiAudioEnum::GetStreamUsage(napi_env env, napi_callback_info info)
986 {
987 StreamUsage usage;
988 napi_value jsResult = nullptr;
989 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
990
991 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
992 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
993 usage = napiAudioEnum->audioParameters_->usage;
994 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(usage), jsResult);
995 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetStreamUsage fail");
996
997 return jsResult;
998 }
999
GetVolumeMode(napi_env env,napi_callback_info info)1000 napi_value NapiAudioEnum::GetVolumeMode(napi_env env, napi_callback_info info)
1001 {
1002 AudioVolumeMode mode;
1003 napi_value jsResult = nullptr;
1004 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
1005 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
1006 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
1007 mode = napiAudioEnum->audioParameters_->mode;
1008 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(mode), jsResult);
1009 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetVolumeMode fail");
1010
1011 return jsResult;
1012 }
1013
SetVolumeMode(napi_env env,napi_callback_info info)1014 napi_value NapiAudioEnum::SetVolumeMode(napi_env env, napi_callback_info info)
1015 {
1016 napi_value jsResult = nullptr;
1017 napi_value args[1] = { nullptr };
1018 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
1019 int32_t mode;
1020 napi_status status = NapiParamUtils::GetValueInt32(env, mode, args[0]);
1021 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
1022
1023 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
1024 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
1025 napiAudioEnum->audioParameters_->mode = static_cast<AudioVolumeMode>(mode);
1026 return jsResult;
1027 }
1028
SetStreamUsage(napi_env env,napi_callback_info info)1029 napi_value NapiAudioEnum::SetStreamUsage(napi_env env, napi_callback_info info)
1030 {
1031 napi_value jsResult = nullptr;
1032 napi_value args[1] = { nullptr };
1033 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
1034 int32_t usage;
1035 napi_status status = NapiParamUtils::GetValueInt32(env, usage, args[0]);
1036 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
1037
1038 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
1039 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
1040 napiAudioEnum->audioParameters_->usage = static_cast<StreamUsage>(usage);
1041
1042 return jsResult;
1043 }
1044
GetDeviceRole(napi_env env,napi_callback_info info)1045 napi_value NapiAudioEnum::GetDeviceRole(napi_env env, napi_callback_info info)
1046 {
1047 DeviceRole deviceRole;
1048 napi_value jsResult = nullptr;
1049 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
1050
1051 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
1052 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
1053 deviceRole = napiAudioEnum->audioParameters_->deviceRole;
1054 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(deviceRole), jsResult);
1055 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetDeviceRole fail");
1056
1057 return jsResult;
1058 }
1059
SetDeviceRole(napi_env env,napi_callback_info info)1060 napi_value NapiAudioEnum::SetDeviceRole(napi_env env, napi_callback_info info)
1061 {
1062 napi_value jsResult = nullptr;
1063 napi_value args[1] = { nullptr };
1064 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
1065 int32_t deviceRole;
1066 napi_status status = NapiParamUtils::GetValueInt32(env, deviceRole, args[0]);
1067 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
1068
1069 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
1070 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
1071 napiAudioEnum->audioParameters_->deviceRole = static_cast<DeviceRole>(deviceRole);
1072
1073 return jsResult;
1074 }
1075
GetDeviceType(napi_env env,napi_callback_info info)1076 napi_value NapiAudioEnum::GetDeviceType(napi_env env, napi_callback_info info)
1077 {
1078 DeviceType deviceType;
1079 napi_value jsResult = nullptr;
1080 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
1081
1082 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
1083 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
1084 deviceType = napiAudioEnum->audioParameters_->deviceType;
1085 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(deviceType), jsResult);
1086 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetDeviceType fail");
1087
1088 return jsResult;
1089 }
1090
SetDeviceType(napi_env env,napi_callback_info info)1091 napi_value NapiAudioEnum::SetDeviceType(napi_env env, napi_callback_info info)
1092 {
1093 napi_value jsResult = nullptr;
1094 napi_value args[1] = { nullptr };
1095 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
1096 int32_t deviceType;
1097 napi_status status = NapiParamUtils::GetValueInt32(env, deviceType, args[0]);
1098 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
1099
1100 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
1101 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
1102 napiAudioEnum->audioParameters_->deviceType = static_cast<DeviceType>(deviceType);
1103
1104 return jsResult;
1105 }
1106
IsLegalInputArgumentInterruptMode(int32_t interruptMode)1107 bool NapiAudioEnum::IsLegalInputArgumentInterruptMode(int32_t interruptMode)
1108 {
1109 bool result = false;
1110 switch (interruptMode) {
1111 case InterruptMode::SHARE_MODE:
1112 case InterruptMode::INDEPENDENT_MODE:
1113 result = true;
1114 break;
1115 default:
1116 result = false;
1117 break;
1118 }
1119 return result;
1120 }
1121
IsLegalInputArgumentAudioEffectMode(int32_t audioEffectMode)1122 bool NapiAudioEnum::IsLegalInputArgumentAudioEffectMode(int32_t audioEffectMode)
1123 {
1124 bool result = false;
1125 switch (audioEffectMode) {
1126 case AudioEffectMode::EFFECT_NONE:
1127 case AudioEffectMode::EFFECT_DEFAULT:
1128 result = true;
1129 break;
1130 default:
1131 result = false;
1132 break;
1133 }
1134 return result;
1135 }
1136
IsLegalInputArgumentChannelBlendMode(int32_t blendMode)1137 bool NapiAudioEnum::IsLegalInputArgumentChannelBlendMode(int32_t blendMode)
1138 {
1139 bool result = false;
1140 switch (blendMode) {
1141 case ChannelBlendMode::MODE_DEFAULT:
1142 case ChannelBlendMode::MODE_BLEND_LR:
1143 case ChannelBlendMode::MODE_ALL_LEFT:
1144 case ChannelBlendMode::MODE_ALL_RIGHT:
1145 result = true;
1146 break;
1147 default:
1148 result = false;
1149 break;
1150 }
1151 return result;
1152 }
1153
IsLegalCapturerType(int32_t type)1154 bool NapiAudioEnum::IsLegalCapturerType(int32_t type)
1155 {
1156 bool result = false;
1157 switch (type) {
1158 case TYPE_INVALID:
1159 case TYPE_MIC:
1160 case TYPE_VOICE_RECOGNITION:
1161 case TYPE_PLAYBACK_CAPTURE:
1162 case TYPE_WAKEUP:
1163 case TYPE_COMMUNICATION:
1164 case TYPE_VOICE_CALL:
1165 case TYPE_MESSAGE:
1166 case TYPE_REMOTE_CAST:
1167 case TYPE_VOICE_TRANSCRIPTION:
1168 case TYPE_CAMCORDER:
1169 case TYPE_UNPROCESSED:
1170 case TYPE_LIVE:
1171 result = true;
1172 break;
1173 default:
1174 result = false;
1175 break;
1176 }
1177 return result;
1178 }
1179
IsLegalInputArgumentVolType(int32_t inputType)1180 bool NapiAudioEnum::IsLegalInputArgumentVolType(int32_t inputType)
1181 {
1182 bool result = false;
1183 switch (inputType) {
1184 case AudioJsVolumeType::RINGTONE:
1185 case AudioJsVolumeType::MEDIA:
1186 case AudioJsVolumeType::VOICE_CALL:
1187 case AudioJsVolumeType::VOICE_ASSISTANT:
1188 case AudioJsVolumeType::ALARM:
1189 case AudioJsVolumeType::SYSTEM:
1190 case AudioJsVolumeType::ACCESSIBILITY:
1191 case AudioJsVolumeType::ULTRASONIC:
1192 case AudioJsVolumeType::NOTIFICATION:
1193 case AudioJsVolumeType::NAVIGATION:
1194 case AudioJsVolumeType::ALL:
1195 result = true;
1196 break;
1197 default:
1198 result = false;
1199 break;
1200 }
1201 return result;
1202 }
1203
IsLegalInputArgumentRingMode(int32_t ringMode)1204 bool NapiAudioEnum::IsLegalInputArgumentRingMode(int32_t ringMode)
1205 {
1206 bool result = false;
1207 switch (ringMode) {
1208 case AudioRingMode::RINGER_MODE_SILENT:
1209 case AudioRingMode::RINGER_MODE_VIBRATE:
1210 case AudioRingMode::RINGER_MODE_NORMAL:
1211 result = true;
1212 break;
1213 default:
1214 result = false;
1215 break;
1216 }
1217 return result;
1218 }
1219
IsLegalInputArgumentVolumeAdjustType(int32_t adjustType)1220 bool NapiAudioEnum::IsLegalInputArgumentVolumeAdjustType(int32_t adjustType)
1221 {
1222 bool result = false;
1223 switch (adjustType) {
1224 case VolumeAdjustType::VOLUME_UP:
1225 case VolumeAdjustType::VOLUME_DOWN:
1226 result = true;
1227 break;
1228 default:
1229 result = false;
1230 break;
1231 }
1232 return result;
1233 }
1234
IsLegalInputArgumentDeviceType(int32_t deviceType)1235 bool NapiAudioEnum::IsLegalInputArgumentDeviceType(int32_t deviceType)
1236 {
1237 for (const auto &iter : NapiAudioEnum::deviceTypeMap) {
1238 if (deviceType == iter.second && deviceType != DeviceType::DEVICE_TYPE_NONE &&
1239 deviceType != DeviceType::DEVICE_TYPE_INVALID && deviceType != DeviceType::DEVICE_TYPE_MAX) {
1240 return true;
1241 }
1242 }
1243 return false;
1244 }
1245
IsLegalInputArgumentDefaultOutputDeviceType(int32_t deviceType)1246 bool NapiAudioEnum::IsLegalInputArgumentDefaultOutputDeviceType(int32_t deviceType)
1247 {
1248 bool result = false;
1249 switch (deviceType) {
1250 case DeviceType::DEVICE_TYPE_EARPIECE:
1251 case DeviceType::DEVICE_TYPE_SPEAKER:
1252 case DeviceType::DEVICE_TYPE_DEFAULT:
1253 result = true;
1254 break;
1255 default:
1256 result = false;
1257 break;
1258 }
1259 return result;
1260 }
1261
GetJsAudioVolumeMode(AudioVolumeMode volumeMode)1262 int32_t NapiAudioEnum::GetJsAudioVolumeMode(AudioVolumeMode volumeMode)
1263 {
1264 int32_t result = NapiAudioEnum::SYSTEM_GLOBAL;
1265 switch (volumeMode) {
1266 case AudioVolumeMode::AUDIOSTREAM_VOLUMEMODE_SYSTEM_GLOBAL:
1267 result = NapiAudioEnum::SYSTEM_GLOBAL;
1268 break;
1269 case AudioVolumeMode::AUDIOSTREAM_VOLUMEMODE_APP_INDIVIDUAL:
1270 result = NapiAudioEnum::APP_INDIVIDUAL;
1271 break;
1272 default:
1273 result = NapiAudioEnum::SYSTEM_GLOBAL;
1274 break;
1275 }
1276 return result;
1277 }
1278
GetJsAudioVolumeType(AudioStreamType volumeType)1279 int32_t NapiAudioEnum::GetJsAudioVolumeType(AudioStreamType volumeType)
1280 {
1281 int32_t result = MEDIA;
1282 switch (volumeType) {
1283 case AudioStreamType::STREAM_VOICE_CALL:
1284 case AudioStreamType::STREAM_VOICE_COMMUNICATION:
1285 case AudioStreamType::STREAM_VOICE_CALL_ASSISTANT:
1286 result = NapiAudioEnum::VOICE_CALL;
1287 break;
1288 case AudioStreamType::STREAM_RING:
1289 case AudioStreamType::STREAM_DTMF:
1290 result = NapiAudioEnum::RINGTONE;
1291 break;
1292 case AudioStreamType::STREAM_MUSIC:
1293 case AudioStreamType::STREAM_MEDIA:
1294 case AudioStreamType::STREAM_MOVIE:
1295 case AudioStreamType::STREAM_GAME:
1296 case AudioStreamType::STREAM_SPEECH:
1297 case AudioStreamType::STREAM_NAVIGATION:
1298 case AudioStreamType::STREAM_CAMCORDER:
1299 case AudioStreamType::STREAM_VOICE_MESSAGE:
1300 result = NapiAudioEnum::MEDIA;
1301 break;
1302 case AudioStreamType::STREAM_ALARM:
1303 result = NapiAudioEnum::ALARM;
1304 break;
1305 case AudioStreamType::STREAM_ACCESSIBILITY:
1306 result = NapiAudioEnum::ACCESSIBILITY;
1307 break;
1308 case AudioStreamType::STREAM_VOICE_ASSISTANT:
1309 result = NapiAudioEnum::VOICE_ASSISTANT;
1310 break;
1311 case AudioStreamType::STREAM_ULTRASONIC:
1312 result = NapiAudioEnum::ULTRASONIC;
1313 break;
1314 case AudioStreamType::STREAM_SYSTEM:
1315 case AudioStreamType::STREAM_NOTIFICATION:
1316 case AudioStreamType::STREAM_SYSTEM_ENFORCED:
1317 #if !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
1318 result = (system::GetBoolParameter("const.multimedia.audio.fwk_ec.enable", 0))?
1319 NapiAudioEnum::SYSTEM : NapiAudioEnum::RINGTONE;
1320 #else
1321 result = NapiAudioEnum::RINGTONE;
1322 #endif
1323 break;
1324 default:
1325 result = NapiAudioEnum::MEDIA;
1326 break;
1327 }
1328 return result;
1329 }
1330
GetJsStreamUsage(StreamUsage streamUsage)1331 int32_t NapiAudioEnum::GetJsStreamUsage(StreamUsage streamUsage)
1332 {
1333 int32_t result = NapiAudioEnum::USAGE_UNKNOW;
1334 switch (streamUsage) {
1335 case StreamUsage::STREAM_USAGE_UNKNOWN:
1336 result = NapiAudioEnum::USAGE_UNKNOW;
1337 break;
1338 case StreamUsage::STREAM_USAGE_MUSIC:
1339 result = NapiAudioEnum::USAGE_MUSIC;
1340 break;
1341 case StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION:
1342 result = NapiAudioEnum::USAGE_VOICE_COMMUNICATION;
1343 break;
1344 case StreamUsage::STREAM_USAGE_VOICE_ASSISTANT:
1345 result = NapiAudioEnum::USAGE_VOICE_ASSISTANT;
1346 break;
1347 case StreamUsage::STREAM_USAGE_ALARM:
1348 result = NapiAudioEnum::USAGE_ALARM;
1349 break;
1350 case StreamUsage::STREAM_USAGE_VOICE_MESSAGE:
1351 result = NapiAudioEnum::USAGE_VOICE_MESSAGE;
1352 break;
1353 case StreamUsage::STREAM_USAGE_RINGTONE:
1354 result = NapiAudioEnum::USAGE_RINGTONE;
1355 break;
1356 case StreamUsage::STREAM_USAGE_NOTIFICATION:
1357 result = NapiAudioEnum::USAGE_NOTIFICATION;
1358 break;
1359 case StreamUsage::STREAM_USAGE_ACCESSIBILITY:
1360 result = NapiAudioEnum::USAGE_ACCESSIBILITY;
1361 break;
1362 case StreamUsage::STREAM_USAGE_SYSTEM:
1363 result = NapiAudioEnum::USAGE_SYSTEM;
1364 break;
1365 case StreamUsage::STREAM_USAGE_MOVIE:
1366 result = NapiAudioEnum::USAGE_MOVIE;
1367 break;
1368 default:
1369 result = GetJsStreamUsageFir(streamUsage);
1370 break;
1371 }
1372 return result;
1373 }
1374
GetJsStreamUsageFir(StreamUsage streamUsage)1375 int32_t NapiAudioEnum::GetJsStreamUsageFir(StreamUsage streamUsage)
1376 {
1377 int32_t result = NapiAudioEnum::USAGE_UNKNOW;
1378 switch (streamUsage) {
1379 case StreamUsage::STREAM_USAGE_GAME:
1380 result = NapiAudioEnum::USAGE_GAME;
1381 break;
1382 case StreamUsage::STREAM_USAGE_AUDIOBOOK:
1383 result = NapiAudioEnum::USAGE_AUDIOBOOK;
1384 break;
1385 case StreamUsage::STREAM_USAGE_NAVIGATION:
1386 result = NapiAudioEnum::USAGE_NAVIGATION;
1387 break;
1388 case StreamUsage::STREAM_USAGE_DTMF:
1389 result = NapiAudioEnum::USAGE_DTMF;
1390 break;
1391 case StreamUsage::STREAM_USAGE_ENFORCED_TONE:
1392 result = NapiAudioEnum::USAGE_ENFORCED_TONE;
1393 break;
1394 case StreamUsage::STREAM_USAGE_ULTRASONIC:
1395 result = NapiAudioEnum::USAGE_ULTRASONIC;
1396 break;
1397 case StreamUsage::STREAM_USAGE_VIDEO_COMMUNICATION:
1398 result = NapiAudioEnum::USAGE_VIDEO_COMMUNICATION;
1399 break;
1400 case StreamUsage::STREAM_USAGE_RANGING:
1401 case StreamUsage::STREAM_USAGE_VOICE_MODEM_COMMUNICATION:
1402 case StreamUsage::STREAM_USAGE_VOICE_RINGTONE:
1403 case StreamUsage::STREAM_USAGE_VOICE_CALL_ASSISTANT:
1404 result = NapiAudioEnum::USAGE_VOICE_CALL_ASSISTANT;
1405 break;
1406 default:
1407 result = NapiAudioEnum::USAGE_UNKNOW;
1408 break;
1409 }
1410 return result;
1411 }
1412
IsLegalInputArgumentCommunicationDeviceType(int32_t communicationDeviceType)1413 bool NapiAudioEnum::IsLegalInputArgumentCommunicationDeviceType(int32_t communicationDeviceType)
1414 {
1415 bool result = false;
1416 switch (communicationDeviceType) {
1417 case DeviceType::DEVICE_TYPE_SPEAKER:
1418 result = true;
1419 break;
1420 default:
1421 result = false;
1422 break;
1423 }
1424 return result;
1425 }
1426
IsLegalInputArgumentDeviceFlag(int32_t deviceFlag)1427 bool NapiAudioEnum::IsLegalInputArgumentDeviceFlag(int32_t deviceFlag)
1428 {
1429 bool result = false;
1430 switch (deviceFlag) {
1431 case DeviceFlag::NONE_DEVICES_FLAG:
1432 case DeviceFlag::OUTPUT_DEVICES_FLAG:
1433 case DeviceFlag::INPUT_DEVICES_FLAG:
1434 case DeviceFlag::ALL_DEVICES_FLAG:
1435 case DeviceFlag::DISTRIBUTED_OUTPUT_DEVICES_FLAG:
1436 case DeviceFlag::DISTRIBUTED_INPUT_DEVICES_FLAG:
1437 case DeviceFlag::ALL_DISTRIBUTED_DEVICES_FLAG:
1438 case DeviceFlag::ALL_L_D_DEVICES_FLAG:
1439 result = true;
1440 break;
1441 default:
1442 result = false;
1443 break;
1444 }
1445 return result;
1446 }
1447
IsLegalInputArgumentActiveDeviceType(int32_t activeDeviceFlag)1448 bool NapiAudioEnum::IsLegalInputArgumentActiveDeviceType(int32_t activeDeviceFlag)
1449 {
1450 bool result = false;
1451 switch (activeDeviceFlag) {
1452 case DeviceType::DEVICE_TYPE_SPEAKER:
1453 case DeviceType::DEVICE_TYPE_BLUETOOTH_SCO:
1454 result = true;
1455 break;
1456 default:
1457 result = false;
1458 break;
1459 }
1460 return result;
1461 }
1462
IsValidSourceType(int32_t intValue)1463 bool NapiAudioEnum::IsValidSourceType(int32_t intValue)
1464 {
1465 SourceType sourceTypeValue = static_cast<SourceType>(intValue);
1466 switch (sourceTypeValue) {
1467 case SourceType::SOURCE_TYPE_MIC:
1468 case SourceType::SOURCE_TYPE_PLAYBACK_CAPTURE:
1469 case SourceType::SOURCE_TYPE_ULTRASONIC:
1470 case SourceType::SOURCE_TYPE_VOICE_COMMUNICATION:
1471 case SourceType::SOURCE_TYPE_VOICE_RECOGNITION:
1472 case SourceType::SOURCE_TYPE_WAKEUP:
1473 case SourceType::SOURCE_TYPE_VOICE_CALL:
1474 case SourceType::SOURCE_TYPE_VOICE_MESSAGE:
1475 case SourceType::SOURCE_TYPE_REMOTE_CAST:
1476 case SourceType::SOURCE_TYPE_VOICE_TRANSCRIPTION:
1477 case SourceType::SOURCE_TYPE_CAMCORDER:
1478 case SourceType::SOURCE_TYPE_UNPROCESSED:
1479 case SourceType::SOURCE_TYPE_LIVE:
1480 return true;
1481 default:
1482 return false;
1483 }
1484 }
1485
IsLegalDeviceUsage(int32_t usage)1486 bool NapiAudioEnum::IsLegalDeviceUsage(int32_t usage)
1487 {
1488 bool result = false;
1489 switch (usage) {
1490 case AudioDeviceUsage::MEDIA_OUTPUT_DEVICES:
1491 case AudioDeviceUsage::MEDIA_INPUT_DEVICES:
1492 case AudioDeviceUsage::ALL_MEDIA_DEVICES:
1493 case AudioDeviceUsage::CALL_OUTPUT_DEVICES:
1494 case AudioDeviceUsage::CALL_INPUT_DEVICES:
1495 case AudioDeviceUsage::ALL_CALL_DEVICES:
1496 result = true;
1497 break;
1498 default:
1499 result = false;
1500 break;
1501 }
1502 return result;
1503 }
1504
IsLegalInputArgumentVolumeMode(int32_t volumeMode)1505 bool NapiAudioEnum::IsLegalInputArgumentVolumeMode(int32_t volumeMode)
1506 {
1507 bool result = false;
1508 switch (volumeMode) {
1509 case AUDIOSTREAM_VOLUMEMODE_SYSTEM_GLOBAL:
1510 case AUDIOSTREAM_VOLUMEMODE_APP_INDIVIDUAL:
1511 result = true;
1512 break;
1513 default:
1514 result = false;
1515 break;
1516 }
1517 return result;
1518 }
1519
IsLegalInputArgumentStreamUsage(int32_t streamUsage)1520 bool NapiAudioEnum::IsLegalInputArgumentStreamUsage(int32_t streamUsage)
1521 {
1522 bool result = false;
1523 switch (streamUsage) {
1524 case STREAM_USAGE_UNKNOWN:
1525 case STREAM_USAGE_MEDIA:
1526 case STREAM_USAGE_VOICE_COMMUNICATION:
1527 case STREAM_USAGE_VOICE_ASSISTANT:
1528 case STREAM_USAGE_ALARM:
1529 case STREAM_USAGE_VOICE_MESSAGE:
1530 case STREAM_USAGE_NOTIFICATION_RINGTONE:
1531 case STREAM_USAGE_NOTIFICATION:
1532 case STREAM_USAGE_ACCESSIBILITY:
1533 case STREAM_USAGE_SYSTEM:
1534 case STREAM_USAGE_MOVIE:
1535 case STREAM_USAGE_GAME:
1536 case STREAM_USAGE_AUDIOBOOK:
1537 case STREAM_USAGE_NAVIGATION:
1538 case STREAM_USAGE_DTMF:
1539 case STREAM_USAGE_ENFORCED_TONE:
1540 case STREAM_USAGE_ULTRASONIC:
1541 case STREAM_USAGE_VIDEO_COMMUNICATION:
1542 case STREAM_USAGE_VOICE_CALL_ASSISTANT:
1543 result = true;
1544 break;
1545 default:
1546 result = false;
1547 break;
1548 }
1549 return result;
1550 }
1551
IsLegalOutputDeviceType(int32_t deviceType)1552 bool NapiAudioEnum::IsLegalOutputDeviceType(int32_t deviceType)
1553 {
1554 bool result = false;
1555 switch (deviceType) {
1556 case DeviceType::DEVICE_TYPE_EARPIECE:
1557 case DeviceType::DEVICE_TYPE_SPEAKER:
1558 case DeviceType::DEVICE_TYPE_WIRED_HEADSET:
1559 case DeviceType::DEVICE_TYPE_WIRED_HEADPHONES:
1560 case DeviceType::DEVICE_TYPE_BLUETOOTH_SCO:
1561 case DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP:
1562 case DeviceType::DEVICE_TYPE_DP:
1563 case DeviceType::DEVICE_TYPE_USB_HEADSET:
1564 case DeviceType::DEVICE_TYPE_USB_ARM_HEADSET:
1565 case DeviceType::DEVICE_TYPE_REMOTE_CAST:
1566 case DeviceType::DEVICE_TYPE_USB_DEVICE:
1567 case DeviceType::DEVICE_TYPE_HDMI:
1568 case DeviceType::DEVICE_TYPE_LINE_DIGITAL:
1569 case DeviceType::DEVICE_TYPE_REMOTE_DAUDIO:
1570 case DeviceType::DEVICE_TYPE_NEARLINK:
1571 case DeviceType::DEVICE_TYPE_HEARING_AID:
1572 result = true;
1573 break;
1574 default:
1575 result = false;
1576 break;
1577 }
1578 return result;
1579 }
1580
GetNativeAudioVolumeType(int32_t volumeType)1581 AudioVolumeType NapiAudioEnum::GetNativeAudioVolumeType(int32_t volumeType)
1582 {
1583 AudioVolumeType result = STREAM_MUSIC;
1584
1585 switch (volumeType) {
1586 case NapiAudioEnum::VOICE_CALL:
1587 result = STREAM_VOICE_CALL;
1588 break;
1589 case NapiAudioEnum::RINGTONE:
1590 result = STREAM_RING;
1591 break;
1592 case NapiAudioEnum::MEDIA:
1593 result = STREAM_MUSIC;
1594 break;
1595 case NapiAudioEnum::ALARM:
1596 result = STREAM_ALARM;
1597 break;
1598 case NapiAudioEnum::ACCESSIBILITY:
1599 result = STREAM_ACCESSIBILITY;
1600 break;
1601 case NapiAudioEnum::VOICE_ASSISTANT:
1602 result = STREAM_VOICE_ASSISTANT;
1603 break;
1604 case NapiAudioEnum::ULTRASONIC:
1605 result = STREAM_ULTRASONIC;
1606 break;
1607 case NapiAudioEnum::SYSTEM:
1608 result = STREAM_SYSTEM;
1609 break;
1610 case NapiAudioEnum::NOTIFICATION:
1611 result = STREAM_RING;
1612 break;
1613 case NapiAudioEnum::NAVIGATION:
1614 result = STREAM_MUSIC;
1615 break;
1616 case NapiAudioEnum::ALL:
1617 result = STREAM_ALL;
1618 break;
1619 default:
1620 result = STREAM_MUSIC;
1621 AUDIO_ERR_LOG("GetNativeAudioVolumeType: Unknown volume type, Set it to default MEDIA!");
1622 break;
1623 }
1624
1625 return result;
1626 }
1627
GetNativeStreamUsage(int32_t streamUsage)1628 StreamUsage NapiAudioEnum::GetNativeStreamUsage(int32_t streamUsage)
1629 {
1630 StreamUsage result = STREAM_USAGE_UNKNOWN;
1631
1632 switch (streamUsage) {
1633 case NapiAudioEnum::USAGE_UNKNOW:
1634 result = STREAM_USAGE_UNKNOWN;
1635 break;
1636 case NapiAudioEnum::USAGE_MUSIC:
1637 result = STREAM_USAGE_MUSIC;
1638 break;
1639 case NapiAudioEnum::USAGE_VOICE_COMMUNICATION:
1640 result = STREAM_USAGE_VOICE_COMMUNICATION;
1641 break;
1642 case NapiAudioEnum::USAGE_VOICE_ASSISTANT:
1643 result = STREAM_USAGE_VOICE_ASSISTANT;
1644 break;
1645 case NapiAudioEnum::USAGE_ALARM:
1646 result = STREAM_USAGE_ALARM;
1647 break;
1648 case NapiAudioEnum::USAGE_VOICE_MESSAGE:
1649 result = STREAM_USAGE_VOICE_MESSAGE;
1650 break;
1651 case NapiAudioEnum::USAGE_RINGTONE:
1652 result = STREAM_USAGE_RINGTONE;
1653 break;
1654 case NapiAudioEnum::USAGE_NOTIFICATION:
1655 result = STREAM_USAGE_NOTIFICATION;
1656 break;
1657 case NapiAudioEnum::USAGE_ACCESSIBILITY:
1658 result = STREAM_USAGE_ACCESSIBILITY;
1659 break;
1660 case NapiAudioEnum::USAGE_SYSTEM:
1661 result = STREAM_USAGE_SYSTEM;
1662 break;
1663 case NapiAudioEnum::USAGE_MOVIE:
1664 result = STREAM_USAGE_MOVIE;
1665 break;
1666 default:
1667 result = GetNativeStreamUsageFir(streamUsage);
1668 break;
1669 }
1670
1671 return result;
1672 }
1673
GetNativeStreamUsageFir(int32_t streamUsage)1674 StreamUsage NapiAudioEnum::GetNativeStreamUsageFir(int32_t streamUsage)
1675 {
1676 StreamUsage result = STREAM_USAGE_UNKNOWN;
1677
1678 switch (streamUsage) {
1679 case NapiAudioEnum::USAGE_GAME:
1680 result = STREAM_USAGE_GAME;
1681 break;
1682 case NapiAudioEnum::USAGE_AUDIOBOOK:
1683 result = STREAM_USAGE_AUDIOBOOK;
1684 break;
1685 case NapiAudioEnum::USAGE_NAVIGATION:
1686 result = STREAM_USAGE_NAVIGATION;
1687 break;
1688 case NapiAudioEnum::USAGE_DTMF:
1689 result = STREAM_USAGE_DTMF;
1690 break;
1691 case NapiAudioEnum::USAGE_ENFORCED_TONE:
1692 result = STREAM_USAGE_ENFORCED_TONE;
1693 break;
1694 case NapiAudioEnum::USAGE_ULTRASONIC:
1695 result = STREAM_USAGE_ULTRASONIC;
1696 break;
1697 case NapiAudioEnum::USAGE_VIDEO_COMMUNICATION:
1698 result = STREAM_USAGE_VIDEO_COMMUNICATION;
1699 break;
1700 case NapiAudioEnum::USAGE_VOICE_CALL_ASSISTANT:
1701 result = STREAM_USAGE_VOICE_CALL_ASSISTANT;
1702 break;
1703 case NapiAudioEnum::USAGE_MAX:
1704 result = STREAM_USAGE_MAX;
1705 break;
1706 default:
1707 result = STREAM_USAGE_INVALID;
1708 break;
1709 }
1710
1711 return result;
1712 }
1713
GetNativeAudioRingerMode(int32_t ringMode)1714 AudioRingerMode NapiAudioEnum::GetNativeAudioRingerMode(int32_t ringMode)
1715 {
1716 AudioRingerMode result = AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL;
1717
1718 switch (ringMode) {
1719 case NapiAudioEnum::RINGER_MODE_SILENT:
1720 result = AudioStandard::AudioRingerMode::RINGER_MODE_SILENT;
1721 break;
1722 case NapiAudioEnum::RINGER_MODE_VIBRATE:
1723 result = AudioStandard::AudioRingerMode::RINGER_MODE_VIBRATE;
1724 break;
1725 case NapiAudioEnum::RINGER_MODE_NORMAL:
1726 result = AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL;
1727 break;
1728 default:
1729 result = AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL;
1730 AUDIO_ERR_LOG("Unknown ringer mode requested by JS, Set it to default RINGER_MODE_NORMAL!");
1731 break;
1732 }
1733
1734 return result;
1735 }
1736
GetJsAudioRingMode(int32_t ringerMode)1737 NapiAudioEnum::AudioRingMode NapiAudioEnum::GetJsAudioRingMode(int32_t ringerMode)
1738 {
1739 NapiAudioEnum::AudioRingMode result = NapiAudioEnum::AudioRingMode::RINGER_MODE_NORMAL;
1740
1741 switch (ringerMode) {
1742 case AudioStandard::AudioRingerMode::RINGER_MODE_SILENT:
1743 result = NapiAudioEnum::RINGER_MODE_SILENT;
1744 break;
1745 case AudioStandard::AudioRingerMode::RINGER_MODE_VIBRATE:
1746 result = NapiAudioEnum::RINGER_MODE_VIBRATE;
1747 break;
1748 case AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL:
1749 result = NapiAudioEnum::RINGER_MODE_NORMAL;
1750 break;
1751 default:
1752 result = NapiAudioEnum::RINGER_MODE_NORMAL;
1753 AUDIO_ERR_LOG("Unknown ringer mode returned from native, Set it to default RINGER_MODE_NORMAL!");
1754 break;
1755 }
1756
1757 return result;
1758 }
1759
GetNativeFocusType(int32_t focusType)1760 AudioStandard::FocusType NapiAudioEnum::GetNativeFocusType(int32_t focusType)
1761 {
1762 AudioStandard::FocusType result = AudioStandard::FocusType::FOCUS_TYPE_RECORDING;
1763 switch (focusType) {
1764 case NapiAudioEnum::FocusType::FOCUS_TYPE_RECORDING:
1765 result = AudioStandard::FocusType::FOCUS_TYPE_RECORDING;
1766 break;
1767 default:
1768 AUDIO_ERR_LOG("Unknown focusType type, Set it to default FOCUS_TYPE_RECORDING!");
1769 break;
1770 }
1771
1772 return result;
1773 }
1774
GetNativeInterruptMode(int32_t interruptMode)1775 AudioStandard::InterruptMode NapiAudioEnum::GetNativeInterruptMode(int32_t interruptMode)
1776 {
1777 AudioStandard::InterruptMode result;
1778 switch (interruptMode) {
1779 case NapiAudioEnum::InterruptMode::SHARE_MODE:
1780 result = AudioStandard::InterruptMode::SHARE_MODE;
1781 break;
1782 case NapiAudioEnum::InterruptMode::INDEPENDENT_MODE:
1783 result = AudioStandard::InterruptMode::INDEPENDENT_MODE;
1784 break;
1785 default:
1786 result = AudioStandard::InterruptMode::SHARE_MODE;
1787 AUDIO_ERR_LOG("Unknown interruptMode type, Set it to default SHARE_MODE!");
1788 break;
1789 }
1790 return result;
1791 }
1792
IsLegalInputArgumentSpatializationSceneType(int32_t spatializationSceneType)1793 bool NapiAudioEnum::IsLegalInputArgumentSpatializationSceneType(int32_t spatializationSceneType)
1794 {
1795 bool result = false;
1796 switch (spatializationSceneType) {
1797 case AudioSpatializationSceneType::SPATIALIZATION_SCENE_TYPE_DEFAULT:
1798 case AudioSpatializationSceneType::SPATIALIZATION_SCENE_TYPE_MUSIC:
1799 case AudioSpatializationSceneType::SPATIALIZATION_SCENE_TYPE_MOVIE:
1800 case AudioSpatializationSceneType::SPATIALIZATION_SCENE_TYPE_AUDIOBOOK:
1801 result = true;
1802 break;
1803 default:
1804 result = false;
1805 break;
1806 }
1807 return result;
1808 }
1809
GetJsAudioScene(AudioScene audioScene)1810 AudioScene NapiAudioEnum::GetJsAudioScene(AudioScene audioScene)
1811 {
1812 AudioScene newAudioScene = AudioScene::AUDIO_SCENE_DEFAULT;
1813 switch (audioScene) {
1814 case AudioScene::AUDIO_SCENE_DEFAULT:
1815 case AudioScene::AUDIO_SCENE_RINGING:
1816 case AudioScene::AUDIO_SCENE_PHONE_CALL:
1817 case AudioScene::AUDIO_SCENE_PHONE_CHAT:
1818 newAudioScene = audioScene;
1819 break;
1820 case AudioScene::AUDIO_SCENE_VOICE_RINGING:
1821 newAudioScene = AudioScene::AUDIO_SCENE_RINGING;
1822 break;
1823 default:
1824 newAudioScene = AudioScene::AUDIO_SCENE_DEFAULT;
1825 AUDIO_ERR_LOG("Unknown audio scene, Set it to default AUDIO_SCENE_DEFAULT!");
1826 break;
1827 }
1828 return newAudioScene;
1829 }
1830
IsLegalCapturerState(int32_t state)1831 bool NapiAudioEnum::IsLegalCapturerState(int32_t state)
1832 {
1833 bool result = false;
1834 switch (state) {
1835 case CapturerState::CAPTURER_INVALID:
1836 case CapturerState::CAPTURER_NEW:
1837 case CapturerState::CAPTURER_PREPARED:
1838 case CapturerState::CAPTURER_RUNNING:
1839 case CapturerState::CAPTURER_STOPPED:
1840 case CapturerState::CAPTURER_RELEASED:
1841 case CapturerState::CAPTURER_PAUSED:
1842 result = true;
1843 break;
1844 default:
1845 result = false;
1846 break;
1847 }
1848 return result;
1849 }
1850
IsLegalInputArgumentAudioLoopbackMode(int32_t inputMode)1851 bool NapiAudioEnum::IsLegalInputArgumentAudioLoopbackMode(int32_t inputMode)
1852 {
1853 bool result = false;
1854 switch (inputMode) {
1855 case AudioLoopbackModeNapi::LOOPBACK_MODE_HARDWARE:
1856 result = true;
1857 break;
1858 default:
1859 result = false;
1860 break;
1861 }
1862 return result;
1863 }
1864
IsLegalInputArgumentAudioLoopbackReverbPreset(int32_t preset)1865 bool NapiAudioEnum::IsLegalInputArgumentAudioLoopbackReverbPreset(int32_t preset)
1866 {
1867 bool result = false;
1868 switch (preset) {
1869 case AudioLoopbackReverbPreset::REVERB_PRESET_ORIGINAL:
1870 case AudioLoopbackReverbPreset::REVERB_PRESET_KTV:
1871 case AudioLoopbackReverbPreset::REVERB_PRESET_THEATRE:
1872 case AudioLoopbackReverbPreset::REVERB_PRESET_CONCERT:
1873 result = true;
1874 break;
1875 default:
1876 result = false;
1877 break;
1878 }
1879 return result;
1880 }
1881
IsLegalInputArgumentAudioLoopbackEqualizerPreset(int32_t preset)1882 bool NapiAudioEnum::IsLegalInputArgumentAudioLoopbackEqualizerPreset(int32_t preset)
1883 {
1884 bool result = false;
1885 switch (preset) {
1886 case AudioLoopbackEqualizerPreset::EQUALIZER_PRESET_FLAT:
1887 case AudioLoopbackEqualizerPreset::EQUALIZER_PRESET_FULL:
1888 case AudioLoopbackEqualizerPreset::EQUALIZER_PRESET_BRIGHT:
1889 result = true;
1890 break;
1891 default:
1892 result = false;
1893 break;
1894 }
1895 return result;
1896 }
1897
1898
IsLegalInputArgumentSessionScene(int32_t scene)1899 bool NapiAudioEnum::IsLegalInputArgumentSessionScene(int32_t scene)
1900 {
1901 bool result = false;
1902 switch (scene) {
1903 case static_cast<int32_t>(AudioSessionScene::MEDIA):
1904 case static_cast<int32_t>(AudioSessionScene::GAME):
1905 case static_cast<int32_t>(AudioSessionScene::VOICE_COMMUNICATION):
1906 result = true;
1907 break;
1908 default:
1909 result = false;
1910 break;
1911 }
1912 return result;
1913 }
1914 } // namespace AudioStandard
1915 } // namespace OHOS
1916