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_device_info.h"
25 #include "napi_param_utils.h"
26 #include "audio_asr.h"
27 #if !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
28 #include "parameters.h"
29 #endif
30 using namespace std;
31 using OHOS::HiviewDFX::HiLog;
32 using OHOS::HiviewDFX::HiLogLabel;
33
34 namespace OHOS {
35 namespace AudioStandard {
36 constexpr int32_t DEFAULT_VOLUME_INTERRUPT_ID = 1;
37 napi_ref NapiAudioEnum::sConstructor_ = nullptr;
38 unique_ptr<AudioParameters> NapiAudioEnum::sAudioParameters_ = nullptr;
39
40 napi_ref NapiAudioEnum::audioChannel_ = nullptr;
41 napi_ref NapiAudioEnum::samplingRate_ = nullptr;
42 napi_ref NapiAudioEnum::encodingType_ = nullptr;
43 napi_ref NapiAudioEnum::contentType_ = nullptr;
44 napi_ref NapiAudioEnum::streamUsage_ = nullptr;
45 napi_ref NapiAudioEnum::audioVolumeMode_ = nullptr;
46 napi_ref NapiAudioEnum::deviceRole_ = nullptr;
47 napi_ref NapiAudioEnum::deviceType_ = nullptr;
48 napi_ref NapiAudioEnum::sourceType_ = nullptr;
49 napi_ref NapiAudioEnum::volumeAdjustType_ = nullptr;
50 napi_ref NapiAudioEnum::channelBlendMode_ = nullptr;
51 napi_ref NapiAudioEnum::audioRendererRate_ = nullptr;
52 napi_ref NapiAudioEnum::interruptEventType_ = nullptr;
53 napi_ref NapiAudioEnum::interruptForceType_ = nullptr;
54 napi_ref NapiAudioEnum::interruptHintType_ = nullptr;
55 napi_ref NapiAudioEnum::audioState_ = nullptr;
56 napi_ref NapiAudioEnum::sampleFormat_ = nullptr;
57 napi_ref NapiAudioEnum::audioEffectMode_ = nullptr;
58 napi_ref NapiAudioEnum::audioPrivacyType_ = nullptr;
59 napi_ref NapiAudioEnum::audioVolumeTypeRef_ = nullptr;
60 napi_ref NapiAudioEnum::deviceFlagRef_ = nullptr;
61 napi_ref NapiAudioEnum::activeDeviceTypeRef_ = nullptr;
62 napi_ref NapiAudioEnum::audioRingModeRef_ = nullptr;
63 napi_ref NapiAudioEnum::deviceChangeType_ = nullptr;
64 napi_ref NapiAudioEnum::interruptActionType_ = nullptr;
65 napi_ref NapiAudioEnum::audioScene_ = nullptr;
66 napi_ref NapiAudioEnum::interruptMode_ = nullptr;
67 napi_ref NapiAudioEnum::focusType_ = nullptr;
68 napi_ref NapiAudioEnum::connectTypeRef_ = nullptr;
69 napi_ref NapiAudioEnum::audioErrors_ = nullptr;
70 napi_ref NapiAudioEnum::communicationDeviceType_ = nullptr;
71 napi_ref NapiAudioEnum::interruptRequestType_ = nullptr;
72 napi_ref NapiAudioEnum::interruptRequestResultType_ = nullptr;
73 napi_ref NapiAudioEnum::toneType_ = nullptr;
74 napi_ref NapiAudioEnum::audioDviceUsage_ = nullptr;
75 napi_ref NapiAudioEnum::audioSpatialDeivceType_ = nullptr;
76 napi_ref NapiAudioEnum::audioChannelLayout_ = nullptr;
77 napi_ref NapiAudioEnum::audioStreamDeviceChangeReason_ = nullptr;
78 napi_ref NapiAudioEnum::spatializationSceneType_ = nullptr;
79 napi_ref NapiAudioEnum::asrNoiseSuppressionMode_ = nullptr;
80 napi_ref NapiAudioEnum::asrAecMode_ = nullptr;
81 napi_ref NapiAudioEnum::asrWhisperDetectionMode_ = nullptr;
82 napi_ref NapiAudioEnum::asrVoiceControlMode_ = nullptr;
83 napi_ref NapiAudioEnum::asrVoiceMuteMode_ = nullptr;
84 napi_ref NapiAudioEnum::audioDataCallbackResult_ = nullptr;
85 napi_ref NapiAudioEnum::concurrencyMode_ = nullptr;
86 napi_ref NapiAudioEnum::reason_ = nullptr;
87 napi_ref NapiAudioEnum::policyType_ = nullptr;
88
89 static const std::string NAPI_AUDIO_ENUM_CLASS_NAME = "AudioEnum";
90
91 const std::map<std::string, int32_t> NapiAudioEnum::audioChannelMap = {
92 {"CHANNEL_1", MONO},
93 {"CHANNEL_2", STEREO},
94 {"CHANNEL_3", CHANNEL_3},
95 {"CHANNEL_4", CHANNEL_4},
96 {"CHANNEL_5", CHANNEL_5},
97 {"CHANNEL_6", CHANNEL_6},
98 {"CHANNEL_7", CHANNEL_7},
99 {"CHANNEL_8", CHANNEL_8},
100 {"CHANNEL_9", CHANNEL_9},
101 {"CHANNEL_10", CHANNEL_10},
102 {"CHANNEL_12", CHANNEL_12},
103 {"CHANNEL_14", CHANNEL_14},
104 {"CHANNEL_16", CHANNEL_16},
105 };
106
107 const std::map<std::string, int32_t> NapiAudioEnum::samplingRateMap = {
108 {"SAMPLE_RATE_8000", SAMPLE_RATE_8000},
109 {"SAMPLE_RATE_11025", SAMPLE_RATE_11025},
110 {"SAMPLE_RATE_12000", SAMPLE_RATE_12000},
111 {"SAMPLE_RATE_16000", SAMPLE_RATE_16000},
112 {"SAMPLE_RATE_22050", SAMPLE_RATE_22050},
113 {"SAMPLE_RATE_24000", SAMPLE_RATE_24000},
114 {"SAMPLE_RATE_32000", SAMPLE_RATE_32000},
115 {"SAMPLE_RATE_44100", SAMPLE_RATE_44100},
116 {"SAMPLE_RATE_48000", SAMPLE_RATE_48000},
117 {"SAMPLE_RATE_64000", SAMPLE_RATE_64000},
118 {"SAMPLE_RATE_88200", SAMPLE_RATE_88200},
119 {"SAMPLE_RATE_96000", SAMPLE_RATE_96000},
120 {"SAMPLE_RATE_176400", SAMPLE_RATE_176400},
121 {"SAMPLE_RATE_192000", SAMPLE_RATE_192000},
122 };
123
124 const std::map<std::string, int32_t> NapiAudioEnum::encodingTypeMap = {
125 {"ENCODING_TYPE_INVALID", ENCODING_INVALID},
126 {"ENCODING_TYPE_RAW", ENCODING_PCM}
127 };
128
129 const std::map<std::string, int32_t> NapiAudioEnum::contentTypeMap = {
130 {"CONTENT_TYPE_UNKNOWN", CONTENT_TYPE_UNKNOWN},
131 {"CONTENT_TYPE_SPEECH", CONTENT_TYPE_SPEECH},
132 {"CONTENT_TYPE_MUSIC", CONTENT_TYPE_MUSIC},
133 {"CONTENT_TYPE_MOVIE", CONTENT_TYPE_MOVIE},
134 {"CONTENT_TYPE_SONIFICATION", CONTENT_TYPE_SONIFICATION},
135 {"CONTENT_TYPE_RINGTONE", CONTENT_TYPE_RINGTONE},
136 {"CONTENT_TYPE_ULTRASONIC", CONTENT_TYPE_ULTRASONIC}
137 };
138
139 const std::map<std::string, int32_t> NapiAudioEnum::audioVolumeModeMap = {
140 {"SYSTEM_GLOBAL", AUDIOSTREAM_VOLUMEMODE_SYSTEM_GLOBAL},
141 {"APP_INDIVIDUAL", AUDIOSTREAM_VOLUMEMODE_APP_INDIVIDUAL}
142 };
143
144 const std::map<std::string, int32_t> NapiAudioEnum::streamUsageMap = {
145 {"STREAM_USAGE_UNKNOWN", STREAM_USAGE_UNKNOWN},
146 {"STREAM_USAGE_MEDIA", STREAM_USAGE_MEDIA},
147 {"STREAM_USAGE_MUSIC", STREAM_USAGE_MUSIC},
148 {"STREAM_USAGE_VOICE_COMMUNICATION", STREAM_USAGE_VOICE_COMMUNICATION},
149 {"STREAM_USAGE_VOICE_ASSISTANT", STREAM_USAGE_VOICE_ASSISTANT},
150 {"STREAM_USAGE_ALARM", STREAM_USAGE_ALARM},
151 {"STREAM_USAGE_VOICE_MESSAGE", STREAM_USAGE_VOICE_MESSAGE},
152 {"STREAM_USAGE_VOICE_CALL_ASSISTANT", STREAM_USAGE_VOICE_CALL_ASSISTANT},
153 {"STREAM_USAGE_NOTIFICATION_RINGTONE", STREAM_USAGE_NOTIFICATION_RINGTONE},
154 {"STREAM_USAGE_RINGTONE", STREAM_USAGE_RINGTONE},
155 {"STREAM_USAGE_NOTIFICATION", STREAM_USAGE_NOTIFICATION},
156 {"STREAM_USAGE_ACCESSIBILITY", STREAM_USAGE_ACCESSIBILITY},
157 {"STREAM_USAGE_SYSTEM", STREAM_USAGE_SYSTEM},
158 {"STREAM_USAGE_MOVIE", STREAM_USAGE_MOVIE},
159 {"STREAM_USAGE_GAME", STREAM_USAGE_GAME},
160 {"STREAM_USAGE_AUDIOBOOK", STREAM_USAGE_AUDIOBOOK},
161 {"STREAM_USAGE_NAVIGATION", STREAM_USAGE_NAVIGATION},
162 {"STREAM_USAGE_DTMF", STREAM_USAGE_DTMF},
163 {"STREAM_USAGE_ENFORCED_TONE", STREAM_USAGE_ENFORCED_TONE},
164 {"STREAM_USAGE_ULTRASONIC", STREAM_USAGE_ULTRASONIC},
165 {"STREAM_USAGE_VIDEO_COMMUNICATION", STREAM_USAGE_VIDEO_COMMUNICATION}
166 };
167
168 const std::map<std::string, int32_t> NapiAudioEnum::deviceRoleMap = {
169 {"DEVICE_ROLE_NONE", DEVICE_ROLE_NONE},
170 {"INPUT_DEVICE", INPUT_DEVICE},
171 {"OUTPUT_DEVICE", OUTPUT_DEVICE},
172 {"DEVICE_ROLE_MAX", DEVICE_ROLE_MAX}
173 };
174
175 const std::map<std::string, int32_t> NapiAudioEnum::deviceTypeMap = {
176 {"NONE", DEVICE_TYPE_NONE},
177 {"INVALID", DEVICE_TYPE_INVALID},
178 {"EARPIECE", DEVICE_TYPE_EARPIECE},
179 {"SPEAKER", DEVICE_TYPE_SPEAKER},
180 {"WIRED_HEADSET", DEVICE_TYPE_WIRED_HEADSET},
181 {"WIRED_HEADPHONES", DEVICE_TYPE_WIRED_HEADPHONES},
182 {"BLUETOOTH_SCO", DEVICE_TYPE_BLUETOOTH_SCO},
183 {"BLUETOOTH_A2DP", DEVICE_TYPE_BLUETOOTH_A2DP},
184 {"MIC", DEVICE_TYPE_MIC},
185 {"WAKEUP", DEVICE_TYPE_WAKEUP},
186 {"USB_HEADSET", DEVICE_TYPE_USB_HEADSET},
187 {"DISPLAY_PORT", DEVICE_TYPE_DP},
188 {"REMOTE_CAST", DEVICE_TYPE_REMOTE_CAST},
189 {"USB_DEVICE", DEVICE_TYPE_USB_DEVICE},
190 {"HDMI", DEVICE_TYPE_HDMI},
191 {"LINE_DIGITAL", DEVICE_TYPE_LINE_DIGITAL},
192 {"REMOTE_DAUDIO", DEVICE_TYPE_REMOTE_DAUDIO},
193 {"DEFAULT", DEVICE_TYPE_DEFAULT},
194 {"MAX", DEVICE_TYPE_MAX},
195 };
196
197 const std::map<std::string, int32_t> NapiAudioEnum::sourceTypeMap = {
198 {"SOURCE_TYPE_INVALID", SOURCE_TYPE_INVALID},
199 {"SOURCE_TYPE_MIC", SOURCE_TYPE_MIC},
200 {"SOURCE_TYPE_CAMCORDER", SOURCE_TYPE_CAMCORDER},
201 {"SOURCE_TYPE_WAKEUP", SOURCE_TYPE_WAKEUP},
202 {"SOURCE_TYPE_VOICE_RECOGNITION", SOURCE_TYPE_VOICE_RECOGNITION},
203 {"SOURCE_TYPE_PLAYBACK_CAPTURE", SOURCE_TYPE_PLAYBACK_CAPTURE},
204 {"SOURCE_TYPE_VOICE_COMMUNICATION", SOURCE_TYPE_VOICE_COMMUNICATION},
205 {"SOURCE_TYPE_VOICE_CALL", SOURCE_TYPE_VOICE_CALL},
206 {"SOURCE_TYPE_VOICE_MESSAGE", SOURCE_TYPE_VOICE_MESSAGE},
207 {"SOURCE_TYPE_REMOTE_CAST", SOURCE_TYPE_REMOTE_CAST},
208 {"SOURCE_TYPE_VOICE_TRANSCRIPTION", SOURCE_TYPE_VOICE_TRANSCRIPTION},
209 {"SOURCE_TYPE_UNPROCESSED", SOURCE_TYPE_UNPROCESSED},
210 };
211
212 const std::map<std::string, int32_t> NapiAudioEnum::volumeAdjustTypeMap = {
213 {"VOLUME_UP", VOLUME_UP},
214 {"VOLUME_DOWN", VOLUME_DOWN},
215 };
216
217 const std::map<std::string, int32_t> NapiAudioEnum::channelBlendModeMap = {
218 {"MODE_DEFAULT", MODE_DEFAULT},
219 {"MODE_BLEND_LR", MODE_BLEND_LR},
220 {"MODE_ALL_LEFT", MODE_ALL_LEFT},
221 {"MODE_ALL_RIGHT", MODE_ALL_RIGHT},
222 };
223
224 const std::map<std::string, int32_t> NapiAudioEnum::rendererRateMap = {
225 {"RENDER_RATE_NORMAL", RENDER_RATE_NORMAL},
226 {"RENDER_RATE_DOUBLE", RENDER_RATE_DOUBLE},
227 {"RENDER_RATE_HALF", RENDER_RATE_HALF}
228 };
229
230 const std::map<std::string, int32_t> NapiAudioEnum::interruptEventTypeMap = {
231 {"INTERRUPT_TYPE_BEGIN", INTERRUPT_TYPE_BEGIN},
232 {"INTERRUPT_TYPE_END", INTERRUPT_TYPE_END}
233 };
234
235 const std::map<std::string, int32_t> NapiAudioEnum::interruptForceTypeMap = {
236 {"INTERRUPT_FORCE", INTERRUPT_FORCE},
237 {"INTERRUPT_SHARE", INTERRUPT_SHARE},
238 };
239
240 const std::map<std::string, int32_t> NapiAudioEnum::interruptHintTypeMap = {
241 {"INTERRUPT_HINT_NONE", INTERRUPT_HINT_NONE},
242 {"INTERRUPT_HINT_PAUSE", INTERRUPT_HINT_PAUSE},
243 {"INTERRUPT_HINT_RESUME", INTERRUPT_HINT_RESUME},
244 {"INTERRUPT_HINT_STOP", INTERRUPT_HINT_STOP},
245 {"INTERRUPT_HINT_DUCK", INTERRUPT_HINT_DUCK},
246 {"INTERRUPT_HINT_UNDUCK", INTERRUPT_HINT_UNDUCK}
247 };
248
249 const std::map<std::string, int32_t> NapiAudioEnum::audioSampleFormatMap = {
250 {"SAMPLE_FORMAT_INVALID", NapiAudioEnum::SAMPLE_FORMAT_INVALID},
251 {"SAMPLE_FORMAT_U8", NapiAudioEnum::SAMPLE_FORMAT_U8},
252 {"SAMPLE_FORMAT_S16LE", NapiAudioEnum::SAMPLE_FORMAT_S16LE},
253 {"SAMPLE_FORMAT_S24LE", NapiAudioEnum::SAMPLE_FORMAT_S24LE},
254 {"SAMPLE_FORMAT_S32LE", NapiAudioEnum::SAMPLE_FORMAT_S32LE},
255 {"SAMPLE_FORMAT_F32LE", NapiAudioEnum::SAMPLE_FORMAT_F32LE}
256 };
257
258 const std::map<std::string, int32_t> NapiAudioEnum::audioStateMap = {
259 {"STATE_INVALID", RENDERER_INVALID},
260 {"STATE_NEW", RENDERER_NEW},
261 {"STATE_PREPARED", RENDERER_PREPARED},
262 {"STATE_RUNNING", RENDERER_RUNNING},
263 {"STATE_STOPPED", RENDERER_STOPPED},
264 {"STATE_RELEASED", RENDERER_RELEASED},
265 {"STATE_PAUSED", RENDERER_PAUSED}
266 };
267
268 const std::map<std::string, int32_t> NapiAudioEnum::effectModeMap = {
269 {"EFFECT_NONE", EFFECT_NONE},
270 {"EFFECT_DEFAULT", EFFECT_DEFAULT}
271 };
272
273 const std::map<std::string, int32_t> NapiAudioEnum::audioPrivacyTypeMap = {
274 {"PRIVACY_TYPE_PUBLIC", PRIVACY_TYPE_PUBLIC},
275 {"PRIVACY_TYPE_PRIVATE", PRIVACY_TYPE_PRIVATE}
276 };
277
278 const std::map<std::string, int32_t> NapiAudioEnum::deviceChangeTypeMap = {
279 {"CONNECT", CONNECT},
280 {"DISCONNECT", DISCONNECT}
281 };
282
283 const std::map<std::string, int32_t> NapiAudioEnum::audioSceneMap = {
284 {"AUDIO_SCENE_DEFAULT", AUDIO_SCENE_DEFAULT},
285 {"AUDIO_SCENE_RINGING", AUDIO_SCENE_RINGING},
286 {"AUDIO_SCENE_PHONE_CALL", AUDIO_SCENE_PHONE_CALL},
287 {"AUDIO_SCENE_VOICE_CHAT", AUDIO_SCENE_PHONE_CHAT}
288 };
289
290 const std::map<std::string, int32_t> NapiAudioEnum::interruptActionTypeMap = {
291 {"TYPE_ACTIVATED", TYPE_ACTIVATED},
292 {"TYPE_INTERRUPT", TYPE_INTERRUPT}
293 };
294
295 const std::map<std::string, int32_t> NapiAudioEnum::audioVolumeTypeMap = {
296 {"VOICE_CALL", NapiAudioEnum::VOICE_CALL},
297 {"RINGTONE", NapiAudioEnum::RINGTONE},
298 {"MEDIA", NapiAudioEnum::MEDIA},
299 {"VOICE_ASSISTANT", NapiAudioEnum::VOICE_ASSISTANT},
300 {"ALARM", NapiAudioEnum::ALARM},
301 {"ACCESSIBILITY", NapiAudioEnum::ACCESSIBILITY},
302 {"ULTRASONIC", NapiAudioEnum::ULTRASONIC},
303 {"ALL", NapiAudioEnum::ALL}
304 };
305
306 const std::map<std::string, int32_t> NapiAudioEnum::activeDeviceTypeMap = {
307 {"SPEAKER", DeviceType::DEVICE_TYPE_SPEAKER},
308 {"BLUETOOTH_SCO", DeviceType::DEVICE_TYPE_BLUETOOTH_SCO}
309 };
310
311 const std::map<std::string, int32_t> NapiAudioEnum::interruptModeMap = {
312 {"SHARE_MODE", NapiAudioEnum::SHARE_MODE},
313 {"INDEPENDENT_MODE", NapiAudioEnum::INDEPENDENT_MODE}
314 };
315
316 const std::map<std::string, int32_t> NapiAudioEnum::focusTypeMap = {
317 {"FOCUS_TYPE_RECORDING", NapiAudioEnum::FOCUS_TYPE_RECORDING}
318 };
319
320 const std::map<std::string, int32_t> NapiAudioEnum::audioErrorsMap = {
321 {"ERROR_INVALID_PARAM", ERROR_INVALID_PARAM},
322 {"ERROR_NO_MEMORY", ERROR_NO_MEMORY},
323 {"ERROR_ILLEGAL_STATE", ERROR_ILLEGAL_STATE},
324 {"ERROR_UNSUPPORTED", ERROR_UNSUPPORTED},
325 {"ERROR_TIMEOUT", ERROR_TIMEOUT},
326 {"ERROR_STREAM_LIMIT", ERROR_STREAM_LIMIT},
327 {"ERROR_SYSTEM", ERROR_SYSTEM}
328 };
329
330 const std::map<std::string, int32_t> NapiAudioEnum::communicationDeviceTypeMap = {
331 {"SPEAKER", DeviceType::DEVICE_TYPE_SPEAKER},
332 };
333
334 const std::map<std::string, int32_t> NapiAudioEnum::interruptRequestTypeMap = {
335 {"INTERRUPT_REQUEST_TYPE_DEFAULT", INTERRUPT_REQUEST_TYPE_DEFAULT},
336 };
337
338 const std::map<std::string, int32_t> NapiAudioEnum::interruptRequestResultTypeMap = {
339 {"INTERRUPT_REQUEST_GRANT", INTERRUPT_REQUEST_GRANT},
340 {"INTERRUPT_REQUEST_REJECT", INTERRUPT_REQUEST_REJECT},
341 };
342
343 const std::map<std::string, int32_t> NapiAudioEnum::deviceFlagMap = {
344 {"NONE_DEVICES_FLAG", NONE_DEVICES_FLAG},
345 {"OUTPUT_DEVICES_FLAG", OUTPUT_DEVICES_FLAG},
346 {"INPUT_DEVICES_FLAG", INPUT_DEVICES_FLAG},
347 {"ALL_DEVICES_FLAG", ALL_DEVICES_FLAG},
348 {"DISTRIBUTED_OUTPUT_DEVICES_FLAG", DISTRIBUTED_OUTPUT_DEVICES_FLAG},
349 {"DISTRIBUTED_INPUT_DEVICES_FLAG", DISTRIBUTED_INPUT_DEVICES_FLAG},
350 {"ALL_DISTRIBUTED_DEVICES_FLAG", ALL_DISTRIBUTED_DEVICES_FLAG}
351 };
352
353 const std::map<std::string, int32_t> NapiAudioEnum::connectTypeMap = {
354 {"CONNECT_TYPE_LOCAL", CONNECT_TYPE_LOCAL},
355 {"CONNECT_TYPE_DISTRIBUTED", CONNECT_TYPE_DISTRIBUTED}
356 };
357
358 const std::map<std::string, int32_t> NapiAudioEnum::audioRingModeMap = {
359 {"RINGER_MODE_SILENT", NapiAudioEnum::RINGER_MODE_SILENT},
360 {"RINGER_MODE_VIBRATE", NapiAudioEnum::RINGER_MODE_VIBRATE},
361 {"RINGER_MODE_NORMAL", NapiAudioEnum::RINGER_MODE_NORMAL}
362 };
363
364 const std::map<std::string, int32_t> NapiAudioEnum::toneTypeMap = {
365 {"TONE_TYPE_DIAL_0", TONE_TYPE_DIAL_0},
366 {"TONE_TYPE_DIAL_1", TONE_TYPE_DIAL_1},
367 {"TONE_TYPE_DIAL_2", TONE_TYPE_DIAL_2},
368 {"TONE_TYPE_DIAL_3", TONE_TYPE_DIAL_3},
369 {"TONE_TYPE_DIAL_4", TONE_TYPE_DIAL_4},
370 {"TONE_TYPE_DIAL_5", TONE_TYPE_DIAL_5},
371 {"TONE_TYPE_DIAL_6", TONE_TYPE_DIAL_6},
372 {"TONE_TYPE_DIAL_7", TONE_TYPE_DIAL_7},
373 {"TONE_TYPE_DIAL_8", TONE_TYPE_DIAL_8},
374 {"TONE_TYPE_DIAL_9", TONE_TYPE_DIAL_9},
375 {"TONE_TYPE_DIAL_S", TONE_TYPE_DIAL_S},
376 {"TONE_TYPE_DIAL_P", TONE_TYPE_DIAL_P},
377 {"TONE_TYPE_DIAL_A", TONE_TYPE_DIAL_A},
378 {"TONE_TYPE_DIAL_B", TONE_TYPE_DIAL_B},
379 {"TONE_TYPE_DIAL_C", TONE_TYPE_DIAL_C},
380 {"TONE_TYPE_DIAL_D", TONE_TYPE_DIAL_D},
381 {"TONE_TYPE_COMMON_SUPERVISORY_DIAL", TONE_TYPE_COMMON_SUPERVISORY_DIAL},
382 {"TONE_TYPE_COMMON_SUPERVISORY_BUSY", TONE_TYPE_COMMON_SUPERVISORY_BUSY},
383 {"TONE_TYPE_COMMON_SUPERVISORY_CONGESTION", TONE_TYPE_COMMON_SUPERVISORY_CONGESTION},
384 {"TONE_TYPE_COMMON_SUPERVISORY_RADIO_ACK", TONE_TYPE_COMMON_SUPERVISORY_RADIO_ACK},
385 {"TONE_TYPE_COMMON_SUPERVISORY_RADIO_NOT_AVAILABLE", TONE_TYPE_COMMON_SUPERVISORY_RADIO_NOT_AVAILABLE},
386 {"TONE_TYPE_COMMON_SUPERVISORY_CALL_WAITING", TONE_TYPE_COMMON_SUPERVISORY_CALL_WAITING},
387 {"TONE_TYPE_COMMON_SUPERVISORY_RINGTONE", TONE_TYPE_COMMON_SUPERVISORY_RINGTONE},
388 {"TONE_TYPE_COMMON_SUPERVISORY_CALL_HOLDING", TONE_TYPE_COMMON_SUPERVISORY_CALL_HOLDING},
389 {"TONE_TYPE_COMMON_PROPRIETARY_BEEP", TONE_TYPE_COMMON_PROPRIETARY_BEEP},
390 {"TONE_TYPE_COMMON_PROPRIETARY_ACK", TONE_TYPE_COMMON_PROPRIETARY_ACK},
391 {"TONE_TYPE_COMMON_PROPRIETARY_PROMPT", TONE_TYPE_COMMON_PROPRIETARY_PROMPT},
392 {"TONE_TYPE_COMMON_PROPRIETARY_DOUBLE_BEEP", TONE_TYPE_COMMON_PROPRIETARY_DOUBLE_BEEP},
393 };
394
395 const std::map<std::string, int32_t> NapiAudioEnum::audioDeviceUsageMap = {
396 {"MEDIA_OUTPUT_DEVICES", MEDIA_OUTPUT_DEVICES },
397 {"MEDIA_INPUT_DEVICES", MEDIA_INPUT_DEVICES},
398 {"ALL_MEDIA_DEVICES", ALL_MEDIA_DEVICES},
399 {"CALL_OUTPUT_DEVICES", CALL_OUTPUT_DEVICES},
400 {"CALL_INPUT_DEVICES", CALL_INPUT_DEVICES},
401 {"ALL_CALL_DEVICES", ALL_CALL_DEVICES},
402 };
403
404 const std::map<std::string, int32_t> NapiAudioEnum::policyTypeMap = {
405 {"EDM", EDM_POLICY_TYPE},
406 {"PRIVACY", PRIVACY_POLCIY_TYPE},
407 {"TEMPORARY", TEMPORARY_POLCIY_TYPE},
408 };
409
410 const std::map<std::string, int32_t> NapiAudioEnum::audioDeviceChangeReasonMap = {
411 {"REASON_UNKNOWN", static_cast<int32_t>(AudioStreamDeviceChangeReason::UNKNOWN)},
412 {"REASON_NEW_DEVICE_AVAILABLE", static_cast<int32_t>(AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE)},
413 {"REASON_OLD_DEVICE_UNAVAILABLE", static_cast<int32_t>(AudioStreamDeviceChangeReason::OLD_DEVICE_UNAVALIABLE)},
414 {"REASON_OVERRODE", static_cast<int32_t>(AudioStreamDeviceChangeReason::OVERRODE)},
415 };
416
417 const std::map<std::string, int32_t> NapiAudioEnum::audioSpatialDeivceTypeMap = {
418 {"SPATIAL_DEVICE_TYPE_NONE", EARPHONE_TYPE_NONE },
419 {"SPATIAL_DEVICE_TYPE_IN_EAR_HEADPHONE", EARPHONE_TYPE_INEAR},
420 {"SPATIAL_DEVICE_TYPE_HALF_IN_EAR_HEADPHONE", EARPHONE_TYPE_HALF_INEAR},
421 {"SPATIAL_DEVICE_TYPE_OVER_EAR_HEADPHONE", EARPHONE_TYPE_HEADPHONE},
422 {"SPATIAL_DEVICE_TYPE_GLASSES", EARPHONE_TYPE_GLASSES},
423 {"SPATIAL_DEVICE_TYPE_OTHERS", EARPHONE_TYPE_OTHERS},
424 };
425
426 const std::map<std::string, uint64_t> NapiAudioEnum::audioChannelLayoutMap = {
427 {"CH_LAYOUT_UNKNOWN", CH_LAYOUT_UNKNOWN},
428 {"CH_LAYOUT_MONO", CH_LAYOUT_MONO},
429 {"CH_LAYOUT_STEREO", CH_LAYOUT_STEREO},
430 {"CH_LAYOUT_STEREO_DOWNMIX", CH_LAYOUT_STEREO_DOWNMIX},
431 {"CH_LAYOUT_2POINT1", CH_LAYOUT_2POINT1},
432 {"CH_LAYOUT_3POINT0", CH_LAYOUT_3POINT0},
433 {"CH_LAYOUT_SURROUND", CH_LAYOUT_SURROUND},
434 {"CH_LAYOUT_3POINT1", CH_LAYOUT_3POINT1},
435 {"CH_LAYOUT_4POINT0", CH_LAYOUT_4POINT0},
436 {"CH_LAYOUT_QUAD_SIDE", CH_LAYOUT_QUAD_SIDE},
437 {"CH_LAYOUT_QUAD", CH_LAYOUT_QUAD},
438 {"CH_LAYOUT_2POINT0POINT2", CH_LAYOUT_2POINT0POINT2},
439 {"CH_LAYOUT_4POINT1", CH_LAYOUT_4POINT1},
440 {"CH_LAYOUT_5POINT0", CH_LAYOUT_5POINT0},
441 {"CH_LAYOUT_5POINT0_BACK", CH_LAYOUT_5POINT0_BACK},
442 {"CH_LAYOUT_2POINT1POINT2", CH_LAYOUT_2POINT1POINT2},
443 {"CH_LAYOUT_3POINT0POINT2", CH_LAYOUT_3POINT0POINT2},
444 {"CH_LAYOUT_5POINT1", CH_LAYOUT_5POINT1},
445 {"CH_LAYOUT_5POINT1_BACK", CH_LAYOUT_5POINT1_BACK},
446 {"CH_LAYOUT_6POINT0", CH_LAYOUT_6POINT0},
447 {"CH_LAYOUT_HEXAGONAL", CH_LAYOUT_HEXAGONAL},
448 {"CH_LAYOUT_3POINT1POINT2", CH_LAYOUT_3POINT1POINT2},
449 {"CH_LAYOUT_6POINT0_FRONT", CH_LAYOUT_6POINT0_FRONT},
450 {"CH_LAYOUT_6POINT1", CH_LAYOUT_6POINT1},
451 {"CH_LAYOUT_6POINT1_BACK", CH_LAYOUT_6POINT1_BACK},
452 {"CH_LAYOUT_6POINT1_FRONT", CH_LAYOUT_6POINT1_FRONT},
453 {"CH_LAYOUT_7POINT0", CH_LAYOUT_7POINT0},
454 {"CH_LAYOUT_7POINT0_FRONT", CH_LAYOUT_7POINT0_FRONT},
455 {"CH_LAYOUT_7POINT1", CH_LAYOUT_7POINT1},
456 {"CH_LAYOUT_OCTAGONAL", CH_LAYOUT_OCTAGONAL},
457 {"CH_LAYOUT_5POINT1POINT2", CH_LAYOUT_5POINT1POINT2},
458 {"CH_LAYOUT_7POINT1_WIDE", CH_LAYOUT_7POINT1_WIDE},
459 {"CH_LAYOUT_7POINT1_WIDE_BACK", CH_LAYOUT_7POINT1_WIDE_BACK},
460 {"CH_LAYOUT_5POINT1POINT4", CH_LAYOUT_5POINT1POINT4},
461 {"CH_LAYOUT_7POINT1POINT2", CH_LAYOUT_7POINT1POINT2},
462 {"CH_LAYOUT_7POINT1POINT4", CH_LAYOUT_7POINT1POINT4},
463 {"CH_LAYOUT_10POINT2", CH_LAYOUT_10POINT2},
464 {"CH_LAYOUT_9POINT1POINT4", CH_LAYOUT_9POINT1POINT4},
465 {"CH_LAYOUT_9POINT1POINT6", CH_LAYOUT_9POINT1POINT6},
466 {"CH_LAYOUT_HEXADECAGONAL", CH_LAYOUT_HEXADECAGONAL},
467 {"CH_LAYOUT_AMB_ORDER1_ACN_N3D", CH_LAYOUT_HOA_ORDER1_ACN_N3D},
468 {"CH_LAYOUT_AMB_ORDER1_ACN_SN3D", CH_LAYOUT_HOA_ORDER1_ACN_SN3D},
469 {"CH_LAYOUT_AMB_ORDER1_FUMA", CH_LAYOUT_HOA_ORDER1_FUMA},
470 {"CH_LAYOUT_AMB_ORDER2_ACN_N3D", CH_LAYOUT_HOA_ORDER2_ACN_N3D},
471 {"CH_LAYOUT_AMB_ORDER2_ACN_SN3D", CH_LAYOUT_HOA_ORDER2_ACN_SN3D},
472 {"CH_LAYOUT_AMB_ORDER2_FUMA", CH_LAYOUT_HOA_ORDER2_FUMA},
473 {"CH_LAYOUT_AMB_ORDER3_ACN_N3D", CH_LAYOUT_HOA_ORDER3_ACN_N3D},
474 {"CH_LAYOUT_AMB_ORDER3_ACN_SN3D", CH_LAYOUT_HOA_ORDER3_ACN_SN3D},
475 {"CH_LAYOUT_AMB_ORDER3_FUMA", CH_LAYOUT_HOA_ORDER3_FUMA},
476 };
477
478 const std::map<std::string, int32_t> NapiAudioEnum::spatializationSceneTypeMap = {
479 {"DEFAULT", SPATIALIZATION_SCENE_TYPE_DEFAULT },
480 {"MUSIC", SPATIALIZATION_SCENE_TYPE_MUSIC},
481 {"MOVIE", SPATIALIZATION_SCENE_TYPE_MOVIE},
482 {"AUDIOBOOK", SPATIALIZATION_SCENE_TYPE_AUDIOBOOK},
483 };
484
485 const std::map<std::string, int32_t> NapiAudioEnum::asrNoiseSuppressionModeMap = {
486 {"BYPASS", static_cast<int32_t>(AsrNoiseSuppressionMode::BYPASS)},
487 {"STANDARD", static_cast<int32_t>(AsrNoiseSuppressionMode::STANDARD)},
488 {"NEAR_FIELD", static_cast<int32_t>(AsrNoiseSuppressionMode::NEAR_FIELD)},
489 {"FAR_FIELD", static_cast<int32_t>(AsrNoiseSuppressionMode::FAR_FIELD)},
490 {"FULL_DUPLEX_STANDARD", static_cast<int32_t>(AsrNoiseSuppressionMode::FULL_DUPLEX_STANDARD)},
491 {"FULL_DUPLEX_NEAR_FIELD", static_cast<int32_t>(AsrNoiseSuppressionMode::FULL_DUPLEX_NEAR_FIELD)},
492 };
493
494 const std::map<std::string, int32_t> NapiAudioEnum::asrAecModeMap = {
495 {"BYPASS", static_cast<int32_t>(AsrAecMode::BYPASS)},
496 {"STANDARD", static_cast<int32_t>(AsrAecMode::STANDARD)},
497 {"EXPAND", static_cast<int32_t>(AsrAecMode::EXPAND)},
498 {"FOLDED", static_cast<int32_t>(AsrAecMode::FOLDED)}
499 };
500
501 const std::map<std::string, int32_t> NapiAudioEnum::asrWhisperDetectionModeMap = {
502 {"BYPASS", static_cast<int32_t>(AsrWhisperDetectionMode::BYPASS)},
503 {"STANDARD", static_cast<int32_t>(AsrWhisperDetectionMode::STANDARD)}
504 };
505
506 const std::map<std::string, int32_t> NapiAudioEnum::asrVoiceControlModeMap = {
507 {"AUDIO_2_VOICETX", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_2_VOICETX)},
508 {"AUDIO_MIX_2_VOICETX", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_MIX_2_VOICETX)},
509 {"AUDIO_2_VOICE_TX_EX", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_2_VOICE_TX_EX)},
510 {"AUDIO_MIX_2_VOICE_TX_EX", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_MIX_2_VOICE_TX_EX)},
511 {"AUDIO_SUPPRESSION_OPPOSITE", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_SUPPRESSION_OPPOSITE)},
512 {"AUDIO_SUPPRESSION_LOCAL", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_SUPPRESSION_LOCAL)},
513 {"VOICE_TXRX_DECREASE", static_cast<int32_t>(AsrVoiceControlMode::VOICE_TXRX_DECREASE)}
514 };
515
516 const std::map<std::string, int32_t> NapiAudioEnum::asrVoiceMuteModeMap = {
517 {"OUTPUT_MUTE", static_cast<int32_t>(AsrVoiceMuteMode::OUTPUT_MUTE)},
518 {"INPUT_MUTE", static_cast<int32_t>(AsrVoiceMuteMode::INPUT_MUTE)},
519 {"TTS_MUTE", static_cast<int32_t>(AsrVoiceMuteMode::TTS_MUTE)},
520 {"CALL_MUTE", static_cast<int32_t>(AsrVoiceMuteMode::CALL_MUTE)},
521 {"OUTPUT_MUTE_EX", static_cast<int32_t>(AsrVoiceMuteMode::OUTPUT_MUTE_EX)}
522 };
523
524 const std::map<std::string, int32_t> NapiAudioEnum::audioDataCallbackResultMap = {
525 {"INVALID", NapiAudioEnum::CALLBACK_RESULT_INVALID},
526 {"VALID", NapiAudioEnum::CALLBACK_RESULT_VALID}
527 };
528
529 const std::map<std::string, int32_t> NapiAudioEnum::concurrencyModeMap = {
530 {"CONCURRENCY_DEFAULT", static_cast<int32_t>(AudioConcurrencyMode::DEFAULT)},
531 {"CONCURRENCY_MIX_WITH_OTHERS", static_cast<int32_t>(AudioConcurrencyMode::MIX_WITH_OTHERS)},
532 {"CONCURRENCY_DUCK_OTHERS", static_cast<int32_t>(AudioConcurrencyMode::DUCK_OTHERS)},
533 {"CONCURRENCY_PAUSE_OTHERS", static_cast<int32_t>(AudioConcurrencyMode::PAUSE_OTHERS)}
534 };
535
536 const std::map<std::string, int32_t> NapiAudioEnum::reasonMap = {
537 {"DEACTIVATED_LOWER_PRIORITY", static_cast<int32_t>(AudioSessionDeactiveReason::LOW_PRIORITY)},
538 {"DEACTIVATED_TIMEOUT", static_cast<int32_t>(AudioSessionDeactiveReason::TIMEOUT)}
539 };
540
NapiAudioEnum()541 NapiAudioEnum::NapiAudioEnum()
542 : env_(nullptr) {
543 }
544
~NapiAudioEnum()545 NapiAudioEnum::~NapiAudioEnum()
546 {
547 audioParameters_ = nullptr;
548 }
549
Destructor(napi_env env,void * nativeObject,void * finalizeHint)550 void NapiAudioEnum::Destructor(napi_env env, void *nativeObject, void *finalizeHint)
551 {
552 if (nativeObject != nullptr) {
553 auto obj = static_cast<NapiAudioEnum *>(nativeObject);
554 delete obj;
555 }
556 }
557
CreateEnumObject(const napi_env & env,const std::map<std::string,int32_t> & map,napi_ref & ref)558 napi_value NapiAudioEnum::CreateEnumObject(const napi_env &env, const std::map<std::string, int32_t> &map,
559 napi_ref &ref)
560 {
561 std::string propName;
562 napi_value result = nullptr;
563 napi_status status = napi_create_object(env, &result);
564 if (status != napi_ok) {
565 goto error;
566 }
567
568 for (const auto &iter : map) {
569 propName = iter.first;
570 status = NapiParamUtils::SetValueInt32(env, propName, iter.second, result);
571 CHECK_AND_BREAK_LOG(status == napi_ok, "Failed to add named prop!");
572 propName.clear();
573 }
574 if (status != napi_ok) {
575 goto error;
576 }
577 status = napi_create_reference(env, result, REFERENCE_CREATION_COUNT, &ref);
578 if (status != napi_ok) {
579 goto error;
580 }
581 return result;
582
583 error:
584 AUDIO_ERR_LOG("create Enum Object failed");
585 napi_get_undefined(env, &result);
586 return result;
587 }
588
CreateEnumInt64Object(const napi_env & env,const std::map<std::string,uint64_t> & map,napi_ref & ref)589 napi_value NapiAudioEnum::CreateEnumInt64Object(const napi_env &env, const std::map<std::string, uint64_t> &map,
590 napi_ref &ref)
591 {
592 std::string propName;
593 napi_value result = nullptr;
594 napi_status status = napi_create_object(env, &result);
595 if (status != napi_ok) {
596 goto error;
597 }
598
599 for (const auto &iter : map) {
600 propName = iter.first;
601 status = NapiParamUtils::SetValueInt64(env, propName, iter.second, result);
602 CHECK_AND_BREAK_LOG(status == napi_ok, "Failed to add named prop!");
603 propName.clear();
604 }
605 if (status != napi_ok) {
606 goto error;
607 }
608 status = napi_create_reference(env, result, REFERENCE_CREATION_COUNT, &ref);
609 if (status != napi_ok) {
610 goto error;
611 }
612 return result;
613
614 error:
615 AUDIO_ERR_LOG("create Enum Object failed");
616 napi_get_undefined(env, &result);
617 return result;
618 }
619
CreateLocalNetworkIdObject(napi_env env)620 napi_value NapiAudioEnum::CreateLocalNetworkIdObject(napi_env env)
621 {
622 napi_value result = nullptr;
623 napi_create_string_utf8(env, LOCAL_NETWORK_ID, NAPI_AUTO_LENGTH, &result);
624 return result;
625 }
626
CreateDefaultVolumeGroupIdObject(napi_env env)627 napi_value NapiAudioEnum::CreateDefaultVolumeGroupIdObject(napi_env env)
628 {
629 napi_value defaultVolumeGroupId;
630 napi_create_int32(env, DEFAULT_VOLUME_GROUP_ID, &defaultVolumeGroupId);
631 return defaultVolumeGroupId;
632 }
633
CreateDefaultInterruptIdObject(napi_env env)634 napi_value NapiAudioEnum::CreateDefaultInterruptIdObject(napi_env env)
635 {
636 napi_value defaultInterruptId;
637 napi_create_int32(env, DEFAULT_VOLUME_INTERRUPT_ID, &defaultInterruptId);
638 return defaultInterruptId;
639 }
640
InitAudioExternEnum(napi_env env,napi_value exports)641 napi_status NapiAudioEnum::InitAudioExternEnum(napi_env env, napi_value exports)
642 {
643 napi_property_descriptor static_prop[] = {
644 DECLARE_NAPI_PROPERTY("AudioSpatialDeviceType", CreateEnumObject(env,
645 audioSpatialDeivceTypeMap, audioSpatialDeivceType_)),
646 DECLARE_NAPI_PROPERTY("AudioChannelLayout", CreateEnumInt64Object(env,
647 audioChannelLayoutMap, audioChannelLayout_)),
648 DECLARE_NAPI_PROPERTY("AudioStreamDeviceChangeReason",
649 CreateEnumObject(env, audioDeviceChangeReasonMap, audioStreamDeviceChangeReason_)),
650 DECLARE_NAPI_PROPERTY("AudioSpatializationSceneType", CreateEnumObject(env,
651 spatializationSceneTypeMap, spatializationSceneType_)),
652 DECLARE_NAPI_PROPERTY("AsrNoiseSuppressionMode", CreateEnumObject(env, asrNoiseSuppressionModeMap,
653 asrNoiseSuppressionMode_)),
654 DECLARE_NAPI_PROPERTY("AsrAecMode", CreateEnumObject(env, asrAecModeMap, asrAecMode_)),
655 DECLARE_NAPI_PROPERTY("AsrWhisperDetectionMode", CreateEnumObject(env,
656 asrWhisperDetectionModeMap, asrWhisperDetectionMode_)),
657 DECLARE_NAPI_PROPERTY("AsrVoiceControlMode", CreateEnumObject(env,
658 asrVoiceControlModeMap, asrVoiceControlMode_)),
659 DECLARE_NAPI_PROPERTY("AsrVoiceMuteMode", CreateEnumObject(env, asrVoiceMuteModeMap, asrVoiceMuteMode_)),
660 };
661 napi_status status =
662 napi_define_properties(env, exports, sizeof(static_prop) / sizeof(static_prop[0]), static_prop);
663 return status;
664 }
665
InitAudioEnum(napi_env env,napi_value exports)666 napi_status NapiAudioEnum::InitAudioEnum(napi_env env, napi_value exports)
667 {
668 napi_property_descriptor static_prop[] = {
669 DECLARE_NAPI_PROPERTY("AudioChannel", CreateEnumObject(env, audioChannelMap, audioChannel_)),
670 DECLARE_NAPI_PROPERTY("AudioSamplingRate", CreateEnumObject(env, samplingRateMap, samplingRate_)),
671 DECLARE_NAPI_PROPERTY("AudioEncodingType", CreateEnumObject(env, encodingTypeMap, encodingType_)),
672 DECLARE_NAPI_PROPERTY("ContentType", CreateEnumObject(env, contentTypeMap, contentType_)),
673 DECLARE_NAPI_PROPERTY("StreamUsage", CreateEnumObject(env, streamUsageMap, streamUsage_)),
674 DECLARE_NAPI_PROPERTY("AudioVolumeMode", CreateEnumObject(env, audioVolumeModeMap, audioVolumeMode_)),
675 DECLARE_NAPI_PROPERTY("DeviceRole", CreateEnumObject(env, deviceRoleMap, deviceRole_)),
676 DECLARE_NAPI_PROPERTY("DeviceType", CreateEnumObject(env, deviceTypeMap, deviceType_)),
677 DECLARE_NAPI_PROPERTY("SourceType", CreateEnumObject(env, sourceTypeMap, sourceType_)),
678 DECLARE_NAPI_PROPERTY("VolumeAdjustType", CreateEnumObject(env, volumeAdjustTypeMap, volumeAdjustType_)),
679 DECLARE_NAPI_PROPERTY("ChannelBlendMode", CreateEnumObject(env, channelBlendModeMap, channelBlendMode_)),
680 DECLARE_NAPI_PROPERTY("AudioRendererRate", CreateEnumObject(env, rendererRateMap, audioRendererRate_)),
681 DECLARE_NAPI_PROPERTY("InterruptType", CreateEnumObject(env, interruptEventTypeMap, interruptEventType_)),
682 DECLARE_NAPI_PROPERTY("InterruptForceType", CreateEnumObject(env, interruptForceTypeMap, interruptForceType_)),
683 DECLARE_NAPI_PROPERTY("InterruptHint", CreateEnumObject(env, interruptHintTypeMap, interruptHintType_)),
684 DECLARE_NAPI_PROPERTY("AudioState", CreateEnumObject(env, audioStateMap, audioState_)),
685 DECLARE_NAPI_PROPERTY("AudioSampleFormat", CreateEnumObject(env, audioSampleFormatMap, sampleFormat_)),
686 DECLARE_NAPI_PROPERTY("AudioEffectMode", CreateEnumObject(env, effectModeMap, audioEffectMode_)),
687 DECLARE_NAPI_PROPERTY("AudioPrivacyType", CreateEnumObject(env, audioPrivacyTypeMap, audioPrivacyType_)),
688 DECLARE_NAPI_PROPERTY("AudioVolumeType", CreateEnumObject(env, audioVolumeTypeMap, audioVolumeTypeRef_)),
689 DECLARE_NAPI_PROPERTY("DeviceFlag", CreateEnumObject(env, deviceFlagMap, deviceFlagRef_)),
690 DECLARE_NAPI_PROPERTY("ActiveDeviceType", CreateEnumObject(env, activeDeviceTypeMap, activeDeviceTypeRef_)),
691 DECLARE_NAPI_PROPERTY("ConnectType", CreateEnumObject(env, connectTypeMap, connectTypeRef_)),
692 DECLARE_NAPI_PROPERTY("AudioRingMode", CreateEnumObject(env, audioRingModeMap, audioRingModeRef_)),
693 DECLARE_NAPI_PROPERTY("AudioScene", CreateEnumObject(env, audioSceneMap, audioScene_)),
694 DECLARE_NAPI_PROPERTY("DeviceChangeType", CreateEnumObject(env, deviceChangeTypeMap, deviceChangeType_)),
695 DECLARE_NAPI_PROPERTY("InterruptActionType",
696 CreateEnumObject(env, interruptActionTypeMap, interruptActionType_)),
697 DECLARE_NAPI_PROPERTY("InterruptMode", CreateEnumObject(env, interruptModeMap, interruptMode_)),
698 DECLARE_NAPI_PROPERTY("FocusType", CreateEnumObject(env, focusTypeMap, focusType_)),
699 DECLARE_NAPI_PROPERTY("LOCAL_NETWORK_ID", CreateLocalNetworkIdObject(env)),
700 DECLARE_NAPI_PROPERTY("DEFAULT_VOLUME_GROUP_ID", CreateDefaultVolumeGroupIdObject(env)),
701 DECLARE_NAPI_PROPERTY("DEFAULT_INTERRUPT_GROUP_ID", CreateDefaultInterruptIdObject(env)),
702 DECLARE_NAPI_PROPERTY("AudioErrors", CreateEnumObject(env, audioErrorsMap, audioErrors_)),
703 DECLARE_NAPI_PROPERTY("CommunicationDeviceType",
704 CreateEnumObject(env, communicationDeviceTypeMap, communicationDeviceType_)),
705 DECLARE_NAPI_PROPERTY("InterruptRequestType",
706 CreateEnumObject(env, interruptRequestTypeMap, interruptRequestType_)),
707 DECLARE_NAPI_PROPERTY("InterruptRequestResultType",
708 CreateEnumObject(env, interruptRequestResultTypeMap, interruptRequestResultType_)),
709 DECLARE_NAPI_PROPERTY("ToneType", CreateEnumObject(env, toneTypeMap, toneType_)),
710 DECLARE_NAPI_PROPERTY("DeviceUsage", CreateEnumObject(env, audioDeviceUsageMap, audioDviceUsage_)),
711 DECLARE_NAPI_PROPERTY("AudioDataCallbackResult",
712 CreateEnumObject(env, audioDataCallbackResultMap, audioDataCallbackResult_)),
713 DECLARE_NAPI_PROPERTY("AudioConcurrencyMode",
714 CreateEnumObject(env, concurrencyModeMap, concurrencyMode_)),
715 DECLARE_NAPI_PROPERTY("AudioSessionDeactivatedReason", CreateEnumObject(env, reasonMap, reason_)),
716 DECLARE_NAPI_PROPERTY("PolicyType", CreateEnumObject(env, policyTypeMap, policyType_)),
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 result = true;
1171 break;
1172 default:
1173 result = false;
1174 break;
1175 }
1176 return result;
1177 }
1178
IsLegalInputArgumentVolType(int32_t inputType)1179 bool NapiAudioEnum::IsLegalInputArgumentVolType(int32_t inputType)
1180 {
1181 bool result = false;
1182 switch (inputType) {
1183 case AudioJsVolumeType::RINGTONE:
1184 case AudioJsVolumeType::MEDIA:
1185 case AudioJsVolumeType::VOICE_CALL:
1186 case AudioJsVolumeType::VOICE_ASSISTANT:
1187 case AudioJsVolumeType::ALARM:
1188 case AudioJsVolumeType::SYSTEM:
1189 case AudioJsVolumeType::ACCESSIBILITY:
1190 case AudioJsVolumeType::ULTRASONIC:
1191 case AudioJsVolumeType::ALL:
1192 result = true;
1193 break;
1194 default:
1195 result = false;
1196 break;
1197 }
1198 return result;
1199 }
1200
IsLegalInputArgumentRingMode(int32_t ringMode)1201 bool NapiAudioEnum::IsLegalInputArgumentRingMode(int32_t ringMode)
1202 {
1203 bool result = false;
1204 switch (ringMode) {
1205 case AudioRingMode::RINGER_MODE_SILENT:
1206 case AudioRingMode::RINGER_MODE_VIBRATE:
1207 case AudioRingMode::RINGER_MODE_NORMAL:
1208 result = true;
1209 break;
1210 default:
1211 result = false;
1212 break;
1213 }
1214 return result;
1215 }
1216
IsLegalInputArgumentVolumeAdjustType(int32_t adjustType)1217 bool NapiAudioEnum::IsLegalInputArgumentVolumeAdjustType(int32_t adjustType)
1218 {
1219 bool result = false;
1220 switch (adjustType) {
1221 case VolumeAdjustType::VOLUME_UP:
1222 case VolumeAdjustType::VOLUME_DOWN:
1223 result = true;
1224 break;
1225 default:
1226 result = false;
1227 break;
1228 }
1229 return result;
1230 }
1231
IsLegalInputArgumentDeviceType(int32_t deviceType)1232 bool NapiAudioEnum::IsLegalInputArgumentDeviceType(int32_t deviceType)
1233 {
1234 for (const auto &iter : NapiAudioEnum::deviceTypeMap) {
1235 if (deviceType == iter.second && deviceType != DeviceType::DEVICE_TYPE_NONE &&
1236 deviceType != DeviceType::DEVICE_TYPE_INVALID && deviceType != DeviceType::DEVICE_TYPE_MAX) {
1237 return true;
1238 }
1239 }
1240 return false;
1241 }
1242
IsLegalInputArgumentDefaultOutputDeviceType(int32_t deviceType)1243 bool NapiAudioEnum::IsLegalInputArgumentDefaultOutputDeviceType(int32_t deviceType)
1244 {
1245 bool result = false;
1246 switch (deviceType) {
1247 case DeviceType::DEVICE_TYPE_EARPIECE:
1248 case DeviceType::DEVICE_TYPE_SPEAKER:
1249 case DeviceType::DEVICE_TYPE_DEFAULT:
1250 result = true;
1251 break;
1252 default:
1253 result = false;
1254 break;
1255 }
1256 return result;
1257 }
1258
GetJsAudioVolumeMode(AudioVolumeMode volumeMode)1259 int32_t NapiAudioEnum::GetJsAudioVolumeMode(AudioVolumeMode volumeMode)
1260 {
1261 int32_t result = NapiAudioEnum::SYSTEM_GLOBAL;
1262 switch (volumeMode) {
1263 case AudioVolumeMode::AUDIOSTREAM_VOLUMEMODE_SYSTEM_GLOBAL:
1264 result = NapiAudioEnum::SYSTEM_GLOBAL;
1265 break;
1266 case AudioVolumeMode::AUDIOSTREAM_VOLUMEMODE_APP_INDIVIDUAL:
1267 result = NapiAudioEnum::APP_INDIVIDUAL;
1268 break;
1269 default:
1270 result = NapiAudioEnum::SYSTEM_GLOBAL;
1271 break;
1272 }
1273 return result;
1274 }
1275
GetJsAudioVolumeType(AudioStreamType volumeType)1276 int32_t NapiAudioEnum::GetJsAudioVolumeType(AudioStreamType volumeType)
1277 {
1278 int32_t result = MEDIA;
1279 switch (volumeType) {
1280 case AudioStreamType::STREAM_VOICE_CALL:
1281 case AudioStreamType::STREAM_VOICE_COMMUNICATION:
1282 case AudioStreamType::STREAM_VOICE_CALL_ASSISTANT:
1283 result = NapiAudioEnum::VOICE_CALL;
1284 break;
1285 case AudioStreamType::STREAM_RING:
1286 case AudioStreamType::STREAM_DTMF:
1287 result = NapiAudioEnum::RINGTONE;
1288 break;
1289 case AudioStreamType::STREAM_MUSIC:
1290 case AudioStreamType::STREAM_MEDIA:
1291 case AudioStreamType::STREAM_MOVIE:
1292 case AudioStreamType::STREAM_GAME:
1293 case AudioStreamType::STREAM_SPEECH:
1294 case AudioStreamType::STREAM_NAVIGATION:
1295 case AudioStreamType::STREAM_CAMCORDER:
1296 case AudioStreamType::STREAM_VOICE_MESSAGE:
1297 result = NapiAudioEnum::MEDIA;
1298 break;
1299 case AudioStreamType::STREAM_ALARM:
1300 result = NapiAudioEnum::ALARM;
1301 break;
1302 case AudioStreamType::STREAM_ACCESSIBILITY:
1303 result = NapiAudioEnum::ACCESSIBILITY;
1304 break;
1305 case AudioStreamType::STREAM_VOICE_ASSISTANT:
1306 result = NapiAudioEnum::VOICE_ASSISTANT;
1307 break;
1308 case AudioStreamType::STREAM_ULTRASONIC:
1309 result = NapiAudioEnum::ULTRASONIC;
1310 break;
1311 case AudioStreamType::STREAM_SYSTEM:
1312 case AudioStreamType::STREAM_NOTIFICATION:
1313 case AudioStreamType::STREAM_SYSTEM_ENFORCED:
1314 #if !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
1315 result = (system::GetBoolParameter("const.multimedia.audio.fwk_ec.enable", 0))?
1316 NapiAudioEnum::SYSTEM : NapiAudioEnum::RINGTONE;
1317 #else
1318 result = NapiAudioEnum::RINGTONE;
1319 #endif
1320 break;
1321 default:
1322 result = NapiAudioEnum::MEDIA;
1323 break;
1324 }
1325 return result;
1326 }
1327
IsLegalInputArgumentCommunicationDeviceType(int32_t communicationDeviceType)1328 bool NapiAudioEnum::IsLegalInputArgumentCommunicationDeviceType(int32_t communicationDeviceType)
1329 {
1330 bool result = false;
1331 switch (communicationDeviceType) {
1332 case DeviceType::DEVICE_TYPE_SPEAKER:
1333 result = true;
1334 break;
1335 default:
1336 result = false;
1337 break;
1338 }
1339 return result;
1340 }
1341
IsLegalInputArgumentDeviceFlag(int32_t deviceFlag)1342 bool NapiAudioEnum::IsLegalInputArgumentDeviceFlag(int32_t deviceFlag)
1343 {
1344 bool result = false;
1345 switch (deviceFlag) {
1346 case DeviceFlag::NONE_DEVICES_FLAG:
1347 case DeviceFlag::OUTPUT_DEVICES_FLAG:
1348 case DeviceFlag::INPUT_DEVICES_FLAG:
1349 case DeviceFlag::ALL_DEVICES_FLAG:
1350 case DeviceFlag::DISTRIBUTED_OUTPUT_DEVICES_FLAG:
1351 case DeviceFlag::DISTRIBUTED_INPUT_DEVICES_FLAG:
1352 case DeviceFlag::ALL_DISTRIBUTED_DEVICES_FLAG:
1353 case DeviceFlag::ALL_L_D_DEVICES_FLAG:
1354 result = true;
1355 break;
1356 default:
1357 result = false;
1358 break;
1359 }
1360 return result;
1361 }
1362
IsLegalInputArgumentActiveDeviceType(int32_t activeDeviceFlag)1363 bool NapiAudioEnum::IsLegalInputArgumentActiveDeviceType(int32_t activeDeviceFlag)
1364 {
1365 bool result = false;
1366 switch (activeDeviceFlag) {
1367 case DeviceType::DEVICE_TYPE_SPEAKER:
1368 case DeviceType::DEVICE_TYPE_BLUETOOTH_SCO:
1369 result = true;
1370 break;
1371 default:
1372 result = false;
1373 break;
1374 }
1375 return result;
1376 }
1377
IsValidSourceType(int32_t intValue)1378 bool NapiAudioEnum::IsValidSourceType(int32_t intValue)
1379 {
1380 SourceType sourceTypeValue = static_cast<SourceType>(intValue);
1381 switch (sourceTypeValue) {
1382 case SourceType::SOURCE_TYPE_MIC:
1383 case SourceType::SOURCE_TYPE_PLAYBACK_CAPTURE:
1384 case SourceType::SOURCE_TYPE_ULTRASONIC:
1385 case SourceType::SOURCE_TYPE_VOICE_COMMUNICATION:
1386 case SourceType::SOURCE_TYPE_VOICE_RECOGNITION:
1387 case SourceType::SOURCE_TYPE_WAKEUP:
1388 case SourceType::SOURCE_TYPE_VOICE_CALL:
1389 case SourceType::SOURCE_TYPE_VOICE_MESSAGE:
1390 case SourceType::SOURCE_TYPE_REMOTE_CAST:
1391 case SourceType::SOURCE_TYPE_VOICE_TRANSCRIPTION:
1392 case SourceType::SOURCE_TYPE_CAMCORDER:
1393 case SourceType::SOURCE_TYPE_UNPROCESSED:
1394 return true;
1395 default:
1396 return false;
1397 }
1398 }
1399
IsLegalDeviceUsage(int32_t usage)1400 bool NapiAudioEnum::IsLegalDeviceUsage(int32_t usage)
1401 {
1402 bool result = false;
1403 switch (usage) {
1404 case AudioDeviceUsage::MEDIA_OUTPUT_DEVICES:
1405 case AudioDeviceUsage::MEDIA_INPUT_DEVICES:
1406 case AudioDeviceUsage::ALL_MEDIA_DEVICES:
1407 case AudioDeviceUsage::CALL_OUTPUT_DEVICES:
1408 case AudioDeviceUsage::CALL_INPUT_DEVICES:
1409 case AudioDeviceUsage::ALL_CALL_DEVICES:
1410 result = true;
1411 break;
1412 default:
1413 result = false;
1414 break;
1415 }
1416 return result;
1417 }
1418
IsLegalInputArgumentVolumeMode(int32_t volumeMode)1419 bool NapiAudioEnum::IsLegalInputArgumentVolumeMode(int32_t volumeMode)
1420 {
1421 bool result = false;
1422 switch (volumeMode) {
1423 case AUDIOSTREAM_VOLUMEMODE_SYSTEM_GLOBAL:
1424 case AUDIOSTREAM_VOLUMEMODE_APP_INDIVIDUAL:
1425 result = true;
1426 break;
1427 default:
1428 result = false;
1429 break;
1430 }
1431 return result;
1432 }
1433
IsLegalInputArgumentStreamUsage(int32_t streamUsage)1434 bool NapiAudioEnum::IsLegalInputArgumentStreamUsage(int32_t streamUsage)
1435 {
1436 bool result = false;
1437 switch (streamUsage) {
1438 case STREAM_USAGE_UNKNOWN:
1439 case STREAM_USAGE_MEDIA:
1440 case STREAM_USAGE_VOICE_COMMUNICATION:
1441 case STREAM_USAGE_VOICE_ASSISTANT:
1442 case STREAM_USAGE_ALARM:
1443 case STREAM_USAGE_VOICE_MESSAGE:
1444 case STREAM_USAGE_NOTIFICATION_RINGTONE:
1445 case STREAM_USAGE_NOTIFICATION:
1446 case STREAM_USAGE_ACCESSIBILITY:
1447 case STREAM_USAGE_SYSTEM:
1448 case STREAM_USAGE_MOVIE:
1449 case STREAM_USAGE_GAME:
1450 case STREAM_USAGE_AUDIOBOOK:
1451 case STREAM_USAGE_NAVIGATION:
1452 case STREAM_USAGE_DTMF:
1453 case STREAM_USAGE_ENFORCED_TONE:
1454 case STREAM_USAGE_ULTRASONIC:
1455 case STREAM_USAGE_VIDEO_COMMUNICATION:
1456 case STREAM_USAGE_VOICE_CALL_ASSISTANT:
1457 result = true;
1458 break;
1459 default:
1460 result = false;
1461 break;
1462 }
1463 return result;
1464 }
1465
IsLegalOutputDeviceType(int32_t deviceType)1466 bool NapiAudioEnum::IsLegalOutputDeviceType(int32_t deviceType)
1467 {
1468 bool result = false;
1469 switch (deviceType) {
1470 case DeviceType::DEVICE_TYPE_EARPIECE:
1471 case DeviceType::DEVICE_TYPE_SPEAKER:
1472 case DeviceType::DEVICE_TYPE_WIRED_HEADSET:
1473 case DeviceType::DEVICE_TYPE_WIRED_HEADPHONES:
1474 case DeviceType::DEVICE_TYPE_BLUETOOTH_SCO:
1475 case DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP:
1476 case DeviceType::DEVICE_TYPE_DP:
1477 case DeviceType::DEVICE_TYPE_USB_HEADSET:
1478 case DeviceType::DEVICE_TYPE_USB_ARM_HEADSET:
1479 case DeviceType::DEVICE_TYPE_REMOTE_CAST:
1480 case DeviceType::DEVICE_TYPE_USB_DEVICE:
1481 case DeviceType::DEVICE_TYPE_HDMI:
1482 case DeviceType::DEVICE_TYPE_REMOTE_DAUDIO:
1483 result = true;
1484 break;
1485 default:
1486 result = false;
1487 break;
1488 }
1489 return result;
1490 }
1491
GetNativeAudioVolumeType(int32_t volumeType)1492 AudioVolumeType NapiAudioEnum::GetNativeAudioVolumeType(int32_t volumeType)
1493 {
1494 AudioVolumeType result = STREAM_MUSIC;
1495
1496 switch (volumeType) {
1497 case NapiAudioEnum::VOICE_CALL:
1498 result = STREAM_VOICE_CALL;
1499 break;
1500 case NapiAudioEnum::RINGTONE:
1501 result = STREAM_RING;
1502 break;
1503 case NapiAudioEnum::MEDIA:
1504 result = STREAM_MUSIC;
1505 break;
1506 case NapiAudioEnum::ALARM:
1507 result = STREAM_ALARM;
1508 break;
1509 case NapiAudioEnum::ACCESSIBILITY:
1510 result = STREAM_ACCESSIBILITY;
1511 break;
1512 case NapiAudioEnum::VOICE_ASSISTANT:
1513 result = STREAM_VOICE_ASSISTANT;
1514 break;
1515 case NapiAudioEnum::ULTRASONIC:
1516 result = STREAM_ULTRASONIC;
1517 break;
1518 case NapiAudioEnum::SYSTEM:
1519 result = STREAM_SYSTEM;
1520 break;
1521 case NapiAudioEnum::ALL:
1522 result = STREAM_ALL;
1523 break;
1524 default:
1525 result = STREAM_MUSIC;
1526 AUDIO_ERR_LOG("GetNativeAudioVolumeType: Unknown volume type, Set it to default MEDIA!");
1527 break;
1528 }
1529
1530 return result;
1531 }
1532
GetNativeAudioRingerMode(int32_t ringMode)1533 AudioRingerMode NapiAudioEnum::GetNativeAudioRingerMode(int32_t ringMode)
1534 {
1535 AudioRingerMode result = AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL;
1536
1537 switch (ringMode) {
1538 case NapiAudioEnum::RINGER_MODE_SILENT:
1539 result = AudioStandard::AudioRingerMode::RINGER_MODE_SILENT;
1540 break;
1541 case NapiAudioEnum::RINGER_MODE_VIBRATE:
1542 result = AudioStandard::AudioRingerMode::RINGER_MODE_VIBRATE;
1543 break;
1544 case NapiAudioEnum::RINGER_MODE_NORMAL:
1545 result = AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL;
1546 break;
1547 default:
1548 result = AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL;
1549 AUDIO_ERR_LOG("Unknown ringer mode requested by JS, Set it to default RINGER_MODE_NORMAL!");
1550 break;
1551 }
1552
1553 return result;
1554 }
1555
GetJsAudioRingMode(int32_t ringerMode)1556 NapiAudioEnum::AudioRingMode NapiAudioEnum::GetJsAudioRingMode(int32_t ringerMode)
1557 {
1558 NapiAudioEnum::AudioRingMode result = NapiAudioEnum::AudioRingMode::RINGER_MODE_NORMAL;
1559
1560 switch (ringerMode) {
1561 case AudioStandard::AudioRingerMode::RINGER_MODE_SILENT:
1562 result = NapiAudioEnum::RINGER_MODE_SILENT;
1563 break;
1564 case AudioStandard::AudioRingerMode::RINGER_MODE_VIBRATE:
1565 result = NapiAudioEnum::RINGER_MODE_VIBRATE;
1566 break;
1567 case AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL:
1568 result = NapiAudioEnum::RINGER_MODE_NORMAL;
1569 break;
1570 default:
1571 result = NapiAudioEnum::RINGER_MODE_NORMAL;
1572 AUDIO_ERR_LOG("Unknown ringer mode returned from native, Set it to default RINGER_MODE_NORMAL!");
1573 break;
1574 }
1575
1576 return result;
1577 }
1578
GetNativeFocusType(int32_t focusType)1579 AudioStandard::FocusType NapiAudioEnum::GetNativeFocusType(int32_t focusType)
1580 {
1581 AudioStandard::FocusType result = AudioStandard::FocusType::FOCUS_TYPE_RECORDING;
1582 switch (focusType) {
1583 case NapiAudioEnum::FocusType::FOCUS_TYPE_RECORDING:
1584 result = AudioStandard::FocusType::FOCUS_TYPE_RECORDING;
1585 break;
1586 default:
1587 AUDIO_ERR_LOG("Unknown focusType type, Set it to default FOCUS_TYPE_RECORDING!");
1588 break;
1589 }
1590
1591 return result;
1592 }
1593
GetNativeInterruptMode(int32_t interruptMode)1594 AudioStandard::InterruptMode NapiAudioEnum::GetNativeInterruptMode(int32_t interruptMode)
1595 {
1596 AudioStandard::InterruptMode result;
1597 switch (interruptMode) {
1598 case NapiAudioEnum::InterruptMode::SHARE_MODE:
1599 result = AudioStandard::InterruptMode::SHARE_MODE;
1600 break;
1601 case NapiAudioEnum::InterruptMode::INDEPENDENT_MODE:
1602 result = AudioStandard::InterruptMode::INDEPENDENT_MODE;
1603 break;
1604 default:
1605 result = AudioStandard::InterruptMode::SHARE_MODE;
1606 AUDIO_ERR_LOG("Unknown interruptMode type, Set it to default SHARE_MODE!");
1607 break;
1608 }
1609 return result;
1610 }
1611
IsLegalInputArgumentSpatializationSceneType(int32_t spatializationSceneType)1612 bool NapiAudioEnum::IsLegalInputArgumentSpatializationSceneType(int32_t spatializationSceneType)
1613 {
1614 bool result = false;
1615 switch (spatializationSceneType) {
1616 case AudioSpatializationSceneType::SPATIALIZATION_SCENE_TYPE_DEFAULT:
1617 case AudioSpatializationSceneType::SPATIALIZATION_SCENE_TYPE_MUSIC:
1618 case AudioSpatializationSceneType::SPATIALIZATION_SCENE_TYPE_MOVIE:
1619 case AudioSpatializationSceneType::SPATIALIZATION_SCENE_TYPE_AUDIOBOOK:
1620 result = true;
1621 break;
1622 default:
1623 result = false;
1624 break;
1625 }
1626 return result;
1627 }
1628 } // namespace AudioStandard
1629 } // namespace OHOS
1630