1 /*
2 * Copyright (c) 2023 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
28 using namespace std;
29 using OHOS::HiviewDFX::HiLog;
30 using OHOS::HiviewDFX::HiLogLabel;
31
32 namespace OHOS {
33 namespace AudioStandard {
34
35 napi_ref NapiAudioEnum::sConstructor_ = nullptr;
36 unique_ptr<AudioParameters> NapiAudioEnum::sAudioParameters_ = nullptr;
37
38 napi_ref NapiAudioEnum::audioChannel_ = nullptr;
39 napi_ref NapiAudioEnum::samplingRate_ = nullptr;
40 napi_ref NapiAudioEnum::encodingType_ = nullptr;
41 napi_ref NapiAudioEnum::contentType_ = nullptr;
42 napi_ref NapiAudioEnum::streamUsage_ = nullptr;
43 napi_ref NapiAudioEnum::deviceRole_ = nullptr;
44 napi_ref NapiAudioEnum::deviceType_ = nullptr;
45 napi_ref NapiAudioEnum::sourceType_ = nullptr;
46 napi_ref NapiAudioEnum::volumeAdjustType_ = nullptr;
47 napi_ref NapiAudioEnum::channelBlendMode_ = nullptr;
48 napi_ref NapiAudioEnum::audioRendererRate_ = nullptr;
49 napi_ref NapiAudioEnum::interruptEventType_ = nullptr;
50 napi_ref NapiAudioEnum::interruptForceType_ = nullptr;
51 napi_ref NapiAudioEnum::interruptHintType_ = nullptr;
52 napi_ref NapiAudioEnum::audioState_ = nullptr;
53 napi_ref NapiAudioEnum::sampleFormat_ = nullptr;
54 napi_ref NapiAudioEnum::audioEffectMode_ = nullptr;
55 napi_ref NapiAudioEnum::audioPrivacyType_ = nullptr;
56 napi_ref NapiAudioEnum::audioVolumeTypeRef_ = nullptr;
57 napi_ref NapiAudioEnum::deviceFlagRef_ = nullptr;
58 napi_ref NapiAudioEnum::activeDeviceTypeRef_ = nullptr;
59 napi_ref NapiAudioEnum::audioRingModeRef_ = nullptr;
60 napi_ref NapiAudioEnum::deviceChangeType_ = nullptr;
61 napi_ref NapiAudioEnum::interruptActionType_ = nullptr;
62 napi_ref NapiAudioEnum::audioScene_ = nullptr;
63 napi_ref NapiAudioEnum::interruptMode_ = nullptr;
64 napi_ref NapiAudioEnum::focusType_ = nullptr;
65 napi_ref NapiAudioEnum::connectTypeRef_ = nullptr;
66 napi_ref NapiAudioEnum::audioErrors_ = nullptr;
67 napi_ref NapiAudioEnum::communicationDeviceType_ = nullptr;
68 napi_ref NapiAudioEnum::interruptRequestType_ = nullptr;
69 napi_ref NapiAudioEnum::interruptRequestResultType_ = nullptr;
70 napi_ref NapiAudioEnum::toneType_ = nullptr;
71 napi_ref NapiAudioEnum::audioDviceUsage_ = nullptr;
72 napi_ref NapiAudioEnum::audioSpatialDeivceType_ = nullptr;
73 napi_ref NapiAudioEnum::audioChannelLayout_ = nullptr;
74 napi_ref NapiAudioEnum::audioStreamDeviceChangeReason_ = nullptr;
75 napi_ref NapiAudioEnum::spatializationSceneType_ = nullptr;
76 napi_ref NapiAudioEnum::asrNoiseSuppressionMode_ = nullptr;
77 napi_ref NapiAudioEnum::asrAecMode_ = nullptr;
78 napi_ref NapiAudioEnum::asrWhisperDetectionMode_ = nullptr;
79 napi_ref NapiAudioEnum::asrVoiceControlMode_ = nullptr;
80 napi_ref NapiAudioEnum::asrVoiceMuteMode_ = nullptr;
81 napi_ref NapiAudioEnum::audioDataCallbackResult_ = nullptr;
82 napi_ref NapiAudioEnum::concurrencyMode_ = nullptr;
83 napi_ref NapiAudioEnum::reason_ = nullptr;
84 napi_ref NapiAudioEnum::policyType_ = nullptr;
85
86 static const std::string NAPI_AUDIO_ENUM_CLASS_NAME = "AudioEnum";
87
88 const std::map<std::string, int32_t> NapiAudioEnum::audioChannelMap = {
89 {"CHANNEL_1", MONO},
90 {"CHANNEL_2", STEREO},
91 {"CHANNEL_3", CHANNEL_3},
92 {"CHANNEL_4", CHANNEL_4},
93 {"CHANNEL_5", CHANNEL_5},
94 {"CHANNEL_6", CHANNEL_6},
95 {"CHANNEL_7", CHANNEL_7},
96 {"CHANNEL_8", CHANNEL_8},
97 {"CHANNEL_9", CHANNEL_9},
98 {"CHANNEL_10", CHANNEL_10},
99 {"CHANNEL_12", CHANNEL_12},
100 {"CHANNEL_14", CHANNEL_14},
101 {"CHANNEL_16", CHANNEL_16},
102 };
103
104 const std::map<std::string, int32_t> NapiAudioEnum::samplingRateMap = {
105 {"SAMPLE_RATE_8000", SAMPLE_RATE_8000},
106 {"SAMPLE_RATE_11025", SAMPLE_RATE_11025},
107 {"SAMPLE_RATE_12000", SAMPLE_RATE_12000},
108 {"SAMPLE_RATE_16000", SAMPLE_RATE_16000},
109 {"SAMPLE_RATE_22050", SAMPLE_RATE_22050},
110 {"SAMPLE_RATE_24000", SAMPLE_RATE_24000},
111 {"SAMPLE_RATE_32000", SAMPLE_RATE_32000},
112 {"SAMPLE_RATE_44100", SAMPLE_RATE_44100},
113 {"SAMPLE_RATE_48000", SAMPLE_RATE_48000},
114 {"SAMPLE_RATE_64000", SAMPLE_RATE_64000},
115 {"SAMPLE_RATE_88200", SAMPLE_RATE_88200},
116 {"SAMPLE_RATE_96000", SAMPLE_RATE_96000},
117 {"SAMPLE_RATE_176400", SAMPLE_RATE_176400},
118 {"SAMPLE_RATE_192000", SAMPLE_RATE_192000},
119 };
120
121 const std::map<std::string, int32_t> NapiAudioEnum::encodingTypeMap = {
122 {"ENCODING_TYPE_INVALID", ENCODING_INVALID},
123 {"ENCODING_TYPE_RAW", ENCODING_PCM}
124 };
125
126 const std::map<std::string, int32_t> NapiAudioEnum::contentTypeMap = {
127 {"CONTENT_TYPE_UNKNOWN", CONTENT_TYPE_UNKNOWN},
128 {"CONTENT_TYPE_SPEECH", CONTENT_TYPE_SPEECH},
129 {"CONTENT_TYPE_MUSIC", CONTENT_TYPE_MUSIC},
130 {"CONTENT_TYPE_MOVIE", CONTENT_TYPE_MOVIE},
131 {"CONTENT_TYPE_SONIFICATION", CONTENT_TYPE_SONIFICATION},
132 {"CONTENT_TYPE_RINGTONE", CONTENT_TYPE_RINGTONE},
133 {"CONTENT_TYPE_ULTRASONIC", CONTENT_TYPE_ULTRASONIC}
134 };
135
136 const std::map<std::string, int32_t> NapiAudioEnum::streamUsageMap = {
137 {"STREAM_USAGE_UNKNOWN", STREAM_USAGE_UNKNOWN},
138 {"STREAM_USAGE_MEDIA", STREAM_USAGE_MEDIA},
139 {"STREAM_USAGE_MUSIC", STREAM_USAGE_MUSIC},
140 {"STREAM_USAGE_VOICE_COMMUNICATION", STREAM_USAGE_VOICE_COMMUNICATION},
141 {"STREAM_USAGE_VOICE_ASSISTANT", STREAM_USAGE_VOICE_ASSISTANT},
142 {"STREAM_USAGE_ALARM", STREAM_USAGE_ALARM},
143 {"STREAM_USAGE_VOICE_MESSAGE", STREAM_USAGE_VOICE_MESSAGE},
144 {"STREAM_USAGE_VOICE_CALL_ASSISTANT", STREAM_USAGE_VOICE_CALL_ASSISTANT},
145 {"STREAM_USAGE_NOTIFICATION_RINGTONE", STREAM_USAGE_NOTIFICATION_RINGTONE},
146 {"STREAM_USAGE_RINGTONE", STREAM_USAGE_RINGTONE},
147 {"STREAM_USAGE_NOTIFICATION", STREAM_USAGE_NOTIFICATION},
148 {"STREAM_USAGE_ACCESSIBILITY", STREAM_USAGE_ACCESSIBILITY},
149 {"STREAM_USAGE_SYSTEM", STREAM_USAGE_SYSTEM},
150 {"STREAM_USAGE_MOVIE", STREAM_USAGE_MOVIE},
151 {"STREAM_USAGE_GAME", STREAM_USAGE_GAME},
152 {"STREAM_USAGE_AUDIOBOOK", STREAM_USAGE_AUDIOBOOK},
153 {"STREAM_USAGE_NAVIGATION", STREAM_USAGE_NAVIGATION},
154 {"STREAM_USAGE_DTMF", STREAM_USAGE_DTMF},
155 {"STREAM_USAGE_ENFORCED_TONE", STREAM_USAGE_ENFORCED_TONE},
156 {"STREAM_USAGE_ULTRASONIC", STREAM_USAGE_ULTRASONIC},
157 {"STREAM_USAGE_VIDEO_COMMUNICATION", STREAM_USAGE_VIDEO_COMMUNICATION}
158 };
159
160 const std::map<std::string, int32_t> NapiAudioEnum::deviceRoleMap = {
161 {"DEVICE_ROLE_NONE", DEVICE_ROLE_NONE},
162 {"INPUT_DEVICE", INPUT_DEVICE},
163 {"OUTPUT_DEVICE", OUTPUT_DEVICE},
164 {"DEVICE_ROLE_MAX", DEVICE_ROLE_MAX}
165 };
166
167 const std::map<std::string, int32_t> NapiAudioEnum::deviceTypeMap = {
168 {"NONE", DEVICE_TYPE_NONE},
169 {"INVALID", DEVICE_TYPE_INVALID},
170 {"EARPIECE", DEVICE_TYPE_EARPIECE},
171 {"SPEAKER", DEVICE_TYPE_SPEAKER},
172 {"WIRED_HEADSET", DEVICE_TYPE_WIRED_HEADSET},
173 {"WIRED_HEADPHONES", DEVICE_TYPE_WIRED_HEADPHONES},
174 {"BLUETOOTH_SCO", DEVICE_TYPE_BLUETOOTH_SCO},
175 {"BLUETOOTH_A2DP", DEVICE_TYPE_BLUETOOTH_A2DP},
176 {"MIC", DEVICE_TYPE_MIC},
177 {"WAKEUP", DEVICE_TYPE_WAKEUP},
178 {"USB_HEADSET", DEVICE_TYPE_USB_HEADSET},
179 {"DISPLAY_PORT", DEVICE_TYPE_DP},
180 {"REMOTE_CAST", DEVICE_TYPE_REMOTE_CAST},
181 {"DEFAULT", DEVICE_TYPE_DEFAULT},
182 {"MAX", DEVICE_TYPE_MAX},
183 };
184
185 const std::map<std::string, int32_t> NapiAudioEnum::sourceTypeMap = {
186 {"SOURCE_TYPE_INVALID", SOURCE_TYPE_INVALID},
187 {"SOURCE_TYPE_MIC", SOURCE_TYPE_MIC},
188 {"SOURCE_TYPE_CAMCORDER", SOURCE_TYPE_CAMCORDER},
189 {"SOURCE_TYPE_WAKEUP", SOURCE_TYPE_WAKEUP},
190 {"SOURCE_TYPE_VOICE_RECOGNITION", SOURCE_TYPE_VOICE_RECOGNITION},
191 {"SOURCE_TYPE_PLAYBACK_CAPTURE", SOURCE_TYPE_PLAYBACK_CAPTURE},
192 {"SOURCE_TYPE_VOICE_COMMUNICATION", SOURCE_TYPE_VOICE_COMMUNICATION},
193 {"SOURCE_TYPE_VOICE_CALL", SOURCE_TYPE_VOICE_CALL},
194 {"SOURCE_TYPE_VOICE_MESSAGE", SOURCE_TYPE_VOICE_MESSAGE},
195 {"SOURCE_TYPE_REMOTE_CAST", SOURCE_TYPE_REMOTE_CAST},
196 {"SOURCE_TYPE_VOICE_TRANSCRIPTION", SOURCE_TYPE_VOICE_TRANSCRIPTION}
197 };
198
199 const std::map<std::string, int32_t> NapiAudioEnum::volumeAdjustTypeMap = {
200 {"VOLUME_UP", VOLUME_UP},
201 {"VOLUME_DOWN", VOLUME_DOWN},
202 };
203
204 const std::map<std::string, int32_t> NapiAudioEnum::channelBlendModeMap = {
205 {"MODE_DEFAULT", MODE_DEFAULT},
206 {"MODE_BLEND_LR", MODE_BLEND_LR},
207 {"MODE_ALL_LEFT", MODE_ALL_LEFT},
208 {"MODE_ALL_RIGHT", MODE_ALL_RIGHT},
209 };
210
211 const std::map<std::string, int32_t> NapiAudioEnum::rendererRateMap = {
212 {"RENDER_RATE_NORMAL", RENDER_RATE_NORMAL},
213 {"RENDER_RATE_DOUBLE", RENDER_RATE_DOUBLE},
214 {"RENDER_RATE_HALF", RENDER_RATE_HALF}
215 };
216
217 const std::map<std::string, int32_t> NapiAudioEnum::interruptEventTypeMap = {
218 {"INTERRUPT_TYPE_BEGIN", INTERRUPT_TYPE_BEGIN},
219 {"INTERRUPT_TYPE_END", INTERRUPT_TYPE_END}
220 };
221
222 const std::map<std::string, int32_t> NapiAudioEnum::interruptForceTypeMap = {
223 {"INTERRUPT_FORCE", INTERRUPT_FORCE},
224 {"INTERRUPT_SHARE", INTERRUPT_SHARE},
225 };
226
227 const std::map<std::string, int32_t> NapiAudioEnum::interruptHintTypeMap = {
228 {"INTERRUPT_HINT_NONE", INTERRUPT_HINT_NONE},
229 {"INTERRUPT_HINT_PAUSE", INTERRUPT_HINT_PAUSE},
230 {"INTERRUPT_HINT_RESUME", INTERRUPT_HINT_RESUME},
231 {"INTERRUPT_HINT_STOP", INTERRUPT_HINT_STOP},
232 {"INTERRUPT_HINT_DUCK", INTERRUPT_HINT_DUCK},
233 {"INTERRUPT_HINT_UNDUCK", INTERRUPT_HINT_UNDUCK}
234 };
235
236 const std::map<std::string, int32_t> NapiAudioEnum::audioSampleFormatMap = {
237 {"SAMPLE_FORMAT_INVALID", NapiAudioEnum::SAMPLE_FORMAT_INVALID},
238 {"SAMPLE_FORMAT_U8", NapiAudioEnum::SAMPLE_FORMAT_U8},
239 {"SAMPLE_FORMAT_S16LE", NapiAudioEnum::SAMPLE_FORMAT_S16LE},
240 {"SAMPLE_FORMAT_S24LE", NapiAudioEnum::SAMPLE_FORMAT_S24LE},
241 {"SAMPLE_FORMAT_S32LE", NapiAudioEnum::SAMPLE_FORMAT_S32LE},
242 {"SAMPLE_FORMAT_F32LE", NapiAudioEnum::SAMPLE_FORMAT_F32LE}
243 };
244
245 const std::map<std::string, int32_t> NapiAudioEnum::audioStateMap = {
246 {"STATE_INVALID", RENDERER_INVALID},
247 {"STATE_NEW", RENDERER_NEW},
248 {"STATE_PREPARED", RENDERER_PREPARED},
249 {"STATE_RUNNING", RENDERER_RUNNING},
250 {"STATE_STOPPED", RENDERER_STOPPED},
251 {"STATE_RELEASED", RENDERER_RELEASED},
252 {"STATE_PAUSED", RENDERER_PAUSED}
253 };
254
255 const std::map<std::string, int32_t> NapiAudioEnum::effectModeMap = {
256 {"EFFECT_NONE", EFFECT_NONE},
257 {"EFFECT_DEFAULT", EFFECT_DEFAULT}
258 };
259
260 const std::map<std::string, int32_t> NapiAudioEnum::audioPrivacyTypeMap = {
261 {"PRIVACY_TYPE_PUBLIC", PRIVACY_TYPE_PUBLIC},
262 {"PRIVACY_TYPE_PRIVATE", PRIVACY_TYPE_PRIVATE}
263 };
264
265 const std::map<std::string, int32_t> NapiAudioEnum::deviceChangeTypeMap = {
266 {"CONNECT", CONNECT},
267 {"DISCONNECT", DISCONNECT}
268 };
269
270 const std::map<std::string, int32_t> NapiAudioEnum::audioSceneMap = {
271 {"AUDIO_SCENE_DEFAULT", AUDIO_SCENE_DEFAULT},
272 {"AUDIO_SCENE_RINGING", AUDIO_SCENE_RINGING},
273 {"AUDIO_SCENE_PHONE_CALL", AUDIO_SCENE_PHONE_CALL},
274 {"AUDIO_SCENE_VOICE_CHAT", AUDIO_SCENE_PHONE_CHAT}
275 };
276
277 const std::map<std::string, int32_t> NapiAudioEnum::interruptActionTypeMap = {
278 {"TYPE_ACTIVATED", TYPE_ACTIVATED},
279 {"TYPE_INTERRUPT", TYPE_INTERRUPT}
280 };
281
282 const std::map<std::string, int32_t> NapiAudioEnum::audioVolumeTypeMap = {
283 {"VOICE_CALL", NapiAudioEnum::VOICE_CALL},
284 {"RINGTONE", NapiAudioEnum::RINGTONE},
285 {"MEDIA", NapiAudioEnum::MEDIA},
286 {"VOICE_ASSISTANT", NapiAudioEnum::VOICE_ASSISTANT},
287 {"ALARM", NapiAudioEnum::ALARM},
288 {"ACCESSIBILITY", NapiAudioEnum::ACCESSIBILITY},
289 {"ULTRASONIC", NapiAudioEnum::ULTRASONIC},
290 {"ALL", NapiAudioEnum::ALL}
291 };
292
293 const std::map<std::string, int32_t> NapiAudioEnum::activeDeviceTypeMap = {
294 {"SPEAKER", SPEAKER},
295 {"BLUETOOTH_SCO", BLUETOOTH_SCO}
296 };
297
298 const std::map<std::string, int32_t> NapiAudioEnum::interruptModeMap = {
299 {"SHARE_MODE", NapiAudioEnum::SHARE_MODE},
300 {"INDEPENDENT_MODE", NapiAudioEnum::INDEPENDENT_MODE}
301 };
302
303 const std::map<std::string, int32_t> NapiAudioEnum::focusTypeMap = {
304 {"FOCUS_TYPE_RECORDING", NapiAudioEnum::FOCUS_TYPE_RECORDING}
305 };
306
307 const std::map<std::string, int32_t> NapiAudioEnum::audioErrorsMap = {
308 {"ERROR_INVALID_PARAM", ERROR_INVALID_PARAM},
309 {"ERROR_NO_MEMORY", ERROR_NO_MEMORY},
310 {"ERROR_ILLEGAL_STATE", ERROR_ILLEGAL_STATE},
311 {"ERROR_UNSUPPORTED", ERROR_UNSUPPORTED},
312 {"ERROR_TIMEOUT", ERROR_TIMEOUT},
313 {"ERROR_STREAM_LIMIT", ERROR_STREAM_LIMIT},
314 {"ERROR_SYSTEM", ERROR_SYSTEM}
315 };
316
317 const std::map<std::string, int32_t> NapiAudioEnum::communicationDeviceTypeMap = {
318 {"SPEAKER", COMMUNICATION_SPEAKER},
319 };
320
321 const std::map<std::string, int32_t> NapiAudioEnum::interruptRequestTypeMap = {
322 {"INTERRUPT_REQUEST_TYPE_DEFAULT", INTERRUPT_REQUEST_TYPE_DEFAULT},
323 };
324
325 const std::map<std::string, int32_t> NapiAudioEnum::interruptRequestResultTypeMap = {
326 {"INTERRUPT_REQUEST_GRANT", INTERRUPT_REQUEST_GRANT},
327 {"INTERRUPT_REQUEST_REJECT", INTERRUPT_REQUEST_REJECT},
328 };
329
330 const std::map<std::string, int32_t> NapiAudioEnum::deviceFlagMap = {
331 {"NONE_DEVICES_FLAG", NONE_DEVICES_FLAG},
332 {"OUTPUT_DEVICES_FLAG", OUTPUT_DEVICES_FLAG},
333 {"INPUT_DEVICES_FLAG", INPUT_DEVICES_FLAG},
334 {"ALL_DEVICES_FLAG", ALL_DEVICES_FLAG},
335 {"DISTRIBUTED_OUTPUT_DEVICES_FLAG", DISTRIBUTED_OUTPUT_DEVICES_FLAG},
336 {"DISTRIBUTED_INPUT_DEVICES_FLAG", DISTRIBUTED_INPUT_DEVICES_FLAG},
337 {"ALL_DISTRIBUTED_DEVICES_FLAG", ALL_DISTRIBUTED_DEVICES_FLAG}
338 };
339
340 const std::map<std::string, int32_t> NapiAudioEnum::connectTypeMap = {
341 {"CONNECT_TYPE_LOCAL", CONNECT_TYPE_LOCAL},
342 {"CONNECT_TYPE_DISTRIBUTED", CONNECT_TYPE_DISTRIBUTED}
343 };
344
345 const std::map<std::string, int32_t> NapiAudioEnum::audioRingModeMap = {
346 {"RINGER_MODE_SILENT", NapiAudioEnum::RINGER_MODE_SILENT},
347 {"RINGER_MODE_VIBRATE", NapiAudioEnum::RINGER_MODE_VIBRATE},
348 {"RINGER_MODE_NORMAL", NapiAudioEnum::RINGER_MODE_NORMAL}
349 };
350
351 const std::map<std::string, int32_t> NapiAudioEnum::toneTypeMap = {
352 {"TONE_TYPE_DIAL_0", TONE_TYPE_DIAL_0},
353 {"TONE_TYPE_DIAL_1", TONE_TYPE_DIAL_1},
354 {"TONE_TYPE_DIAL_2", TONE_TYPE_DIAL_2},
355 {"TONE_TYPE_DIAL_3", TONE_TYPE_DIAL_3},
356 {"TONE_TYPE_DIAL_4", TONE_TYPE_DIAL_4},
357 {"TONE_TYPE_DIAL_5", TONE_TYPE_DIAL_5},
358 {"TONE_TYPE_DIAL_6", TONE_TYPE_DIAL_6},
359 {"TONE_TYPE_DIAL_7", TONE_TYPE_DIAL_7},
360 {"TONE_TYPE_DIAL_8", TONE_TYPE_DIAL_8},
361 {"TONE_TYPE_DIAL_9", TONE_TYPE_DIAL_9},
362 {"TONE_TYPE_DIAL_S", TONE_TYPE_DIAL_S},
363 {"TONE_TYPE_DIAL_P", TONE_TYPE_DIAL_P},
364 {"TONE_TYPE_DIAL_A", TONE_TYPE_DIAL_A},
365 {"TONE_TYPE_DIAL_B", TONE_TYPE_DIAL_B},
366 {"TONE_TYPE_DIAL_C", TONE_TYPE_DIAL_C},
367 {"TONE_TYPE_DIAL_D", TONE_TYPE_DIAL_D},
368 {"TONE_TYPE_COMMON_SUPERVISORY_DIAL", TONE_TYPE_COMMON_SUPERVISORY_DIAL},
369 {"TONE_TYPE_COMMON_SUPERVISORY_BUSY", TONE_TYPE_COMMON_SUPERVISORY_BUSY},
370 {"TONE_TYPE_COMMON_SUPERVISORY_CONGESTION", TONE_TYPE_COMMON_SUPERVISORY_CONGESTION},
371 {"TONE_TYPE_COMMON_SUPERVISORY_RADIO_ACK", TONE_TYPE_COMMON_SUPERVISORY_RADIO_ACK},
372 {"TONE_TYPE_COMMON_SUPERVISORY_RADIO_NOT_AVAILABLE", TONE_TYPE_COMMON_SUPERVISORY_RADIO_NOT_AVAILABLE},
373 {"TONE_TYPE_COMMON_SUPERVISORY_CALL_WAITING", TONE_TYPE_COMMON_SUPERVISORY_CALL_WAITING},
374 {"TONE_TYPE_COMMON_SUPERVISORY_RINGTONE", TONE_TYPE_COMMON_SUPERVISORY_RINGTONE},
375 {"TONE_TYPE_COMMON_PROPRIETARY_BEEP", TONE_TYPE_COMMON_PROPRIETARY_BEEP},
376 {"TONE_TYPE_COMMON_PROPRIETARY_ACK", TONE_TYPE_COMMON_PROPRIETARY_ACK},
377 {"TONE_TYPE_COMMON_PROPRIETARY_PROMPT", TONE_TYPE_COMMON_PROPRIETARY_PROMPT},
378 {"TONE_TYPE_COMMON_PROPRIETARY_DOUBLE_BEEP", TONE_TYPE_COMMON_PROPRIETARY_DOUBLE_BEEP},
379 };
380
381 const std::map<std::string, int32_t> NapiAudioEnum::audioDeviceUsageMap = {
382 {"MEDIA_OUTPUT_DEVICES", MEDIA_OUTPUT_DEVICES },
383 {"MEDIA_INPUT_DEVICES", MEDIA_INPUT_DEVICES},
384 {"ALL_MEDIA_DEVICES", ALL_MEDIA_DEVICES},
385 {"CALL_OUTPUT_DEVICES", CALL_OUTPUT_DEVICES},
386 {"CALL_INPUT_DEVICES", CALL_INPUT_DEVICES},
387 {"ALL_CALL_DEVICES", ALL_CALL_DEVICES},
388 };
389
390 const std::map<std::string, int32_t> NapiAudioEnum::policyTypeMap = {
391 {"EDM", EDM_POLICY_TYPE},
392 {"PRIVACY", PRIVACY_POLCIY_TYPE},
393 {"TEMPORARY", TEMPORARY_POLCIY_TYPE},
394 };
395
396 const std::map<std::string, int32_t> NapiAudioEnum::audioDeviceChangeReasonMap = {
397 {"REASON_UNKNOWN", static_cast<int32_t>(AudioStreamDeviceChangeReason::UNKNOWN)},
398 {"REASON_NEW_DEVICE_AVAILABLE", static_cast<int32_t>(AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE)},
399 {"REASON_OLD_DEVICE_UNAVAILABLE", static_cast<int32_t>(AudioStreamDeviceChangeReason::OLD_DEVICE_UNAVALIABLE)},
400 {"REASON_OVERRODE", static_cast<int32_t>(AudioStreamDeviceChangeReason::OVERRODE)},
401 };
402
403 const std::map<std::string, int32_t> NapiAudioEnum::audioSpatialDeivceTypeMap = {
404 {"SPATIAL_DEVICE_TYPE_NONE", EARPHONE_TYPE_NONE },
405 {"SPATIAL_DEVICE_TYPE_IN_EAR_HEADPHONE", EARPHONE_TYPE_INEAR},
406 {"SPATIAL_DEVICE_TYPE_HALF_IN_EAR_HEADPHONE", EARPHONE_TYPE_HALF_INEAR},
407 {"SPATIAL_DEVICE_TYPE_OVER_EAR_HEADPHONE", EARPHONE_TYPE_HEADPHONE},
408 {"SPATIAL_DEVICE_TYPE_GLASSES", EARPHONE_TYPE_GLASSES},
409 {"SPATIAL_DEVICE_TYPE_OTHERS", EARPHONE_TYPE_OTHERS},
410 };
411
412 const std::map<std::string, uint64_t> NapiAudioEnum::audioChannelLayoutMap = {
413 {"CH_LAYOUT_UNKNOWN", CH_LAYOUT_UNKNOWN},
414 {"CH_LAYOUT_MONO", CH_LAYOUT_MONO},
415 {"CH_LAYOUT_STEREO", CH_LAYOUT_STEREO},
416 {"CH_LAYOUT_STEREO_DOWNMIX", CH_LAYOUT_STEREO_DOWNMIX},
417 {"CH_LAYOUT_2POINT1", CH_LAYOUT_2POINT1},
418 {"CH_LAYOUT_3POINT0", CH_LAYOUT_3POINT0},
419 {"CH_LAYOUT_SURROUND", CH_LAYOUT_SURROUND},
420 {"CH_LAYOUT_3POINT1", CH_LAYOUT_3POINT1},
421 {"CH_LAYOUT_4POINT0", CH_LAYOUT_4POINT0},
422 {"CH_LAYOUT_QUAD_SIDE", CH_LAYOUT_QUAD_SIDE},
423 {"CH_LAYOUT_QUAD", CH_LAYOUT_QUAD},
424 {"CH_LAYOUT_2POINT0POINT2", CH_LAYOUT_2POINT0POINT2},
425 {"CH_LAYOUT_4POINT1", CH_LAYOUT_4POINT1},
426 {"CH_LAYOUT_5POINT0", CH_LAYOUT_5POINT0},
427 {"CH_LAYOUT_5POINT0_BACK", CH_LAYOUT_5POINT0_BACK},
428 {"CH_LAYOUT_2POINT1POINT2", CH_LAYOUT_2POINT1POINT2},
429 {"CH_LAYOUT_3POINT0POINT2", CH_LAYOUT_3POINT0POINT2},
430 {"CH_LAYOUT_5POINT1", CH_LAYOUT_5POINT1},
431 {"CH_LAYOUT_5POINT1_BACK", CH_LAYOUT_5POINT1_BACK},
432 {"CH_LAYOUT_6POINT0", CH_LAYOUT_6POINT0},
433 {"CH_LAYOUT_HEXAGONAL", CH_LAYOUT_HEXAGONAL},
434 {"CH_LAYOUT_3POINT1POINT2", CH_LAYOUT_3POINT1POINT2},
435 {"CH_LAYOUT_6POINT0_FRONT", CH_LAYOUT_6POINT0_FRONT},
436 {"CH_LAYOUT_6POINT1", CH_LAYOUT_6POINT1},
437 {"CH_LAYOUT_6POINT1_BACK", CH_LAYOUT_6POINT1_BACK},
438 {"CH_LAYOUT_6POINT1_FRONT", CH_LAYOUT_6POINT1_FRONT},
439 {"CH_LAYOUT_7POINT0", CH_LAYOUT_7POINT0},
440 {"CH_LAYOUT_7POINT0_FRONT", CH_LAYOUT_7POINT0_FRONT},
441 {"CH_LAYOUT_7POINT1", CH_LAYOUT_7POINT1},
442 {"CH_LAYOUT_OCTAGONAL", CH_LAYOUT_OCTAGONAL},
443 {"CH_LAYOUT_5POINT1POINT2", CH_LAYOUT_5POINT1POINT2},
444 {"CH_LAYOUT_7POINT1_WIDE", CH_LAYOUT_7POINT1_WIDE},
445 {"CH_LAYOUT_7POINT1_WIDE_BACK", CH_LAYOUT_7POINT1_WIDE_BACK},
446 {"CH_LAYOUT_5POINT1POINT4", CH_LAYOUT_5POINT1POINT4},
447 {"CH_LAYOUT_7POINT1POINT2", CH_LAYOUT_7POINT1POINT2},
448 {"CH_LAYOUT_7POINT1POINT4", CH_LAYOUT_7POINT1POINT4},
449 {"CH_LAYOUT_10POINT2", CH_LAYOUT_10POINT2},
450 {"CH_LAYOUT_9POINT1POINT4", CH_LAYOUT_9POINT1POINT4},
451 {"CH_LAYOUT_9POINT1POINT6", CH_LAYOUT_9POINT1POINT6},
452 {"CH_LAYOUT_HEXADECAGONAL", CH_LAYOUT_HEXADECAGONAL},
453 {"CH_LAYOUT_AMB_ORDER1_ACN_N3D", CH_LAYOUT_HOA_ORDER1_ACN_N3D},
454 {"CH_LAYOUT_AMB_ORDER1_ACN_SN3D", CH_LAYOUT_HOA_ORDER1_ACN_SN3D},
455 {"CH_LAYOUT_AMB_ORDER1_FUMA", CH_LAYOUT_HOA_ORDER1_FUMA},
456 {"CH_LAYOUT_AMB_ORDER2_ACN_N3D", CH_LAYOUT_HOA_ORDER2_ACN_N3D},
457 {"CH_LAYOUT_AMB_ORDER2_ACN_SN3D", CH_LAYOUT_HOA_ORDER2_ACN_SN3D},
458 {"CH_LAYOUT_AMB_ORDER2_FUMA", CH_LAYOUT_HOA_ORDER2_FUMA},
459 {"CH_LAYOUT_AMB_ORDER3_ACN_N3D", CH_LAYOUT_HOA_ORDER3_ACN_N3D},
460 {"CH_LAYOUT_AMB_ORDER3_ACN_SN3D", CH_LAYOUT_HOA_ORDER3_ACN_SN3D},
461 {"CH_LAYOUT_AMB_ORDER3_FUMA", CH_LAYOUT_HOA_ORDER3_FUMA},
462 };
463
464 const std::map<std::string, int32_t> NapiAudioEnum::spatializationSceneTypeMap = {
465 {"DEFAULT", SPATIALIZATION_SCENE_TYPE_DEFAULT },
466 {"MUSIC", SPATIALIZATION_SCENE_TYPE_MUSIC},
467 {"MOVIE", SPATIALIZATION_SCENE_TYPE_MOVIE},
468 {"AUDIOBOOK", SPATIALIZATION_SCENE_TYPE_AUDIOBOOK},
469 };
470
471 const std::map<std::string, int32_t> NapiAudioEnum::asrNoiseSuppressionModeMap = {
472 {"BYPASS", static_cast<int32_t>(AsrNoiseSuppressionMode::BYPASS)},
473 {"STANDARD", static_cast<int32_t>(AsrNoiseSuppressionMode::STANDARD)},
474 {"NEAR_FIELD", static_cast<int32_t>(AsrNoiseSuppressionMode::NEAR_FIELD)},
475 {"FAR_FIELD", static_cast<int32_t>(AsrNoiseSuppressionMode::FAR_FIELD)},
476 };
477
478 const std::map<std::string, int32_t> NapiAudioEnum::asrAecModeMap = {
479 {"BYPASS", static_cast<int32_t>(AsrAecMode::BYPASS)},
480 {"STANDARD", static_cast<int32_t>(AsrAecMode::STANDARD)}
481 };
482
483 const std::map<std::string, int32_t> NapiAudioEnum::asrWhisperDetectionModeMap = {
484 {"BYPASS", static_cast<int32_t>(AsrWhisperDetectionMode::BYPASS)},
485 {"STANDARD", static_cast<int32_t>(AsrWhisperDetectionMode::STANDARD)}
486 };
487
488 const std::map<std::string, int32_t> NapiAudioEnum::asrVoiceControlModeMap = {
489 {"AUDIO_2_VOICETX", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_2_VOICETX)},
490 {"AUDIO_MIX_2_VOICETX", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_MIX_2_VOICETX)},
491 {"AUDIO_2_VOICE_TX_EX", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_2_VOICE_TX_EX)},
492 {"AUDIO_MIX_2_VOICE_TX_EX", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_MIX_2_VOICE_TX_EX)},
493 {"AUDIO_SUPPRESSION_OPPOSITE", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_SUPPRESSION_OPPOSITE)},
494 {"AUDIO_SUPPRESSION_LOCAL", static_cast<int32_t>(AsrVoiceControlMode::AUDIO_SUPPRESSION_LOCAL)},
495 {"VOICE_TXRX_DECREASE", static_cast<int32_t>(AsrVoiceControlMode::VOICE_TXRX_DECREASE)}
496 };
497
498 const std::map<std::string, int32_t> NapiAudioEnum::asrVoiceMuteModeMap = {
499 {"OUTPUT_MUTE", static_cast<int32_t>(AsrVoiceMuteMode::OUTPUT_MUTE)},
500 {"INPUT_MUTE", static_cast<int32_t>(AsrVoiceMuteMode::INPUT_MUTE)},
501 {"TTS_MUTE", static_cast<int32_t>(AsrVoiceMuteMode::TTS_MUTE)},
502 {"CALL_MUTE", static_cast<int32_t>(AsrVoiceMuteMode::CALL_MUTE)},
503 {"OUTPUT_MUTE_EX", static_cast<int32_t>(AsrVoiceMuteMode::OUTPUT_MUTE_EX)}
504 };
505
506 const std::map<std::string, int32_t> NapiAudioEnum::audioDataCallbackResultMap = {
507 {"INVALID", NapiAudioEnum::CALLBACK_RESULT_INVALID},
508 {"VALID", NapiAudioEnum::CALLBACK_RESULT_VALID}
509 };
510
511 const std::map<std::string, int32_t> NapiAudioEnum::concurrencyModeMap = {
512 {"CONCURRENCY_DEFAULT", static_cast<int32_t>(AudioConcurrencyMode::DEFAULT)},
513 {"CONCURRENCY_MIX_WITH_OTHERS", static_cast<int32_t>(AudioConcurrencyMode::MIX_WITH_OTHERS)},
514 {"CONCURRENCY_DUCK_OTHERS", static_cast<int32_t>(AudioConcurrencyMode::DUCK_OTHERS)},
515 {"CONCURRENCY_PAUSE_OTHERS", static_cast<int32_t>(AudioConcurrencyMode::PAUSE_OTHERS)}
516 };
517
518 const std::map<std::string, int32_t> NapiAudioEnum::reasonMap = {
519 {"DEACTIVATED_LOWER_PRIORITY", static_cast<int32_t>(AudioSessionDeactiveReason::LOW_PRIORITY)},
520 {"DEACTIVATED_TIMEOUT", static_cast<int32_t>(AudioSessionDeactiveReason::TIMEOUT)}
521 };
522
NapiAudioEnum()523 NapiAudioEnum::NapiAudioEnum()
524 : env_(nullptr) {
525 }
526
~NapiAudioEnum()527 NapiAudioEnum::~NapiAudioEnum()
528 {
529 audioParameters_ = nullptr;
530 }
531
Destructor(napi_env env,void * nativeObject,void * finalizeHint)532 void NapiAudioEnum::Destructor(napi_env env, void *nativeObject, void *finalizeHint)
533 {
534 if (nativeObject != nullptr) {
535 auto obj = static_cast<NapiAudioEnum *>(nativeObject);
536 delete obj;
537 }
538 }
539
CreateEnumObject(const napi_env & env,const std::map<std::string,int32_t> & map,napi_ref & ref)540 napi_value NapiAudioEnum::CreateEnumObject(const napi_env &env, const std::map<std::string, int32_t> &map,
541 napi_ref &ref)
542 {
543 std::string propName;
544 napi_value result = nullptr;
545 napi_status status = napi_create_object(env, &result);
546 if (status != napi_ok) {
547 goto error;
548 }
549
550 for (const auto &iter : map) {
551 propName = iter.first;
552 status = NapiParamUtils::SetValueInt32(env, propName, iter.second, result);
553 CHECK_AND_BREAK_LOG(status == napi_ok, "Failed to add named prop!");
554 propName.clear();
555 }
556 if (status != napi_ok) {
557 goto error;
558 }
559 status = napi_create_reference(env, result, REFERENCE_CREATION_COUNT, &ref);
560 if (status != napi_ok) {
561 goto error;
562 }
563 return result;
564
565 error:
566 AUDIO_ERR_LOG("create Enum Object failed");
567 napi_get_undefined(env, &result);
568 return result;
569 }
570
CreateEnumInt64Object(const napi_env & env,const std::map<std::string,uint64_t> & map,napi_ref & ref)571 napi_value NapiAudioEnum::CreateEnumInt64Object(const napi_env &env, const std::map<std::string, uint64_t> &map,
572 napi_ref &ref)
573 {
574 std::string propName;
575 napi_value result = nullptr;
576 napi_status status = napi_create_object(env, &result);
577 if (status != napi_ok) {
578 goto error;
579 }
580
581 for (const auto &iter : map) {
582 propName = iter.first;
583 status = NapiParamUtils::SetValueInt64(env, propName, iter.second, result);
584 CHECK_AND_BREAK_LOG(status == napi_ok, "Failed to add named prop!");
585 propName.clear();
586 }
587 if (status != napi_ok) {
588 goto error;
589 }
590 status = napi_create_reference(env, result, REFERENCE_CREATION_COUNT, &ref);
591 if (status != napi_ok) {
592 goto error;
593 }
594 return result;
595
596 error:
597 AUDIO_ERR_LOG("create Enum Object failed");
598 napi_get_undefined(env, &result);
599 return result;
600 }
601
CreateLocalNetworkIdObject(napi_env env)602 napi_value NapiAudioEnum::CreateLocalNetworkIdObject(napi_env env)
603 {
604 napi_value result = nullptr;
605 napi_create_string_utf8(env, LOCAL_NETWORK_ID.c_str(), NAPI_AUTO_LENGTH, &result);
606 return result;
607 }
608
CreateDefaultVolumeGroupIdObject(napi_env env)609 napi_value NapiAudioEnum::CreateDefaultVolumeGroupIdObject(napi_env env)
610 {
611 napi_value defaultVolumeGroupId;
612 napi_create_int32(env, DEFAULT_VOLUME_GROUP_ID, &defaultVolumeGroupId);
613 return defaultVolumeGroupId;
614 }
615
CreateDefaultInterruptIdObject(napi_env env)616 napi_value NapiAudioEnum::CreateDefaultInterruptIdObject(napi_env env)
617 {
618 napi_value defaultInterruptId;
619 napi_create_int32(env, DEFAULT_VOLUME_INTERRUPT_ID, &defaultInterruptId);
620 return defaultInterruptId;
621 }
622
InitAudioExternEnum(napi_env env,napi_value exports)623 napi_status NapiAudioEnum::InitAudioExternEnum(napi_env env, napi_value exports)
624 {
625 napi_property_descriptor static_prop[] = {
626 DECLARE_NAPI_PROPERTY("AudioSpatialDeviceType", CreateEnumObject(env,
627 audioSpatialDeivceTypeMap, audioSpatialDeivceType_)),
628 DECLARE_NAPI_PROPERTY("AudioChannelLayout", CreateEnumInt64Object(env,
629 audioChannelLayoutMap, audioChannelLayout_)),
630 DECLARE_NAPI_PROPERTY("AudioStreamDeviceChangeReason",
631 CreateEnumObject(env, audioDeviceChangeReasonMap, audioStreamDeviceChangeReason_)),
632 DECLARE_NAPI_PROPERTY("AudioSpatializationSceneType", CreateEnumObject(env,
633 spatializationSceneTypeMap, spatializationSceneType_)),
634 DECLARE_NAPI_PROPERTY("AsrNoiseSuppressionMode", CreateEnumObject(env, asrNoiseSuppressionModeMap,
635 asrNoiseSuppressionMode_)),
636 DECLARE_NAPI_PROPERTY("AsrAecMode", CreateEnumObject(env, asrAecModeMap, asrAecMode_)),
637 DECLARE_NAPI_PROPERTY("AsrWhisperDetectionMode", CreateEnumObject(env,
638 asrWhisperDetectionModeMap, asrWhisperDetectionMode_)),
639 DECLARE_NAPI_PROPERTY("AsrVoiceControlMode", CreateEnumObject(env,
640 asrVoiceControlModeMap, asrVoiceControlMode_)),
641 DECLARE_NAPI_PROPERTY("AsrVoiceMuteMode", CreateEnumObject(env, asrVoiceMuteModeMap, asrVoiceMuteMode_)),
642 };
643 napi_status status =
644 napi_define_properties(env, exports, sizeof(static_prop) / sizeof(static_prop[0]), static_prop);
645 return status;
646 }
647
InitAudioEnum(napi_env env,napi_value exports)648 napi_status NapiAudioEnum::InitAudioEnum(napi_env env, napi_value exports)
649 {
650 napi_property_descriptor static_prop[] = {
651 DECLARE_NAPI_PROPERTY("AudioChannel", CreateEnumObject(env, audioChannelMap, audioChannel_)),
652 DECLARE_NAPI_PROPERTY("AudioSamplingRate", CreateEnumObject(env, samplingRateMap, samplingRate_)),
653 DECLARE_NAPI_PROPERTY("AudioEncodingType", CreateEnumObject(env, encodingTypeMap, encodingType_)),
654 DECLARE_NAPI_PROPERTY("ContentType", CreateEnumObject(env, contentTypeMap, contentType_)),
655 DECLARE_NAPI_PROPERTY("StreamUsage", CreateEnumObject(env, streamUsageMap, streamUsage_)),
656 DECLARE_NAPI_PROPERTY("DeviceRole", CreateEnumObject(env, deviceRoleMap, deviceRole_)),
657 DECLARE_NAPI_PROPERTY("DeviceType", CreateEnumObject(env, deviceTypeMap, deviceType_)),
658 DECLARE_NAPI_PROPERTY("SourceType", CreateEnumObject(env, sourceTypeMap, sourceType_)),
659 DECLARE_NAPI_PROPERTY("VolumeAdjustType", CreateEnumObject(env, volumeAdjustTypeMap, volumeAdjustType_)),
660 DECLARE_NAPI_PROPERTY("ChannelBlendMode", CreateEnumObject(env, channelBlendModeMap, channelBlendMode_)),
661 DECLARE_NAPI_PROPERTY("AudioRendererRate", CreateEnumObject(env, rendererRateMap, audioRendererRate_)),
662 DECLARE_NAPI_PROPERTY("InterruptType", CreateEnumObject(env, interruptEventTypeMap, interruptEventType_)),
663 DECLARE_NAPI_PROPERTY("InterruptForceType", CreateEnumObject(env, interruptForceTypeMap, interruptForceType_)),
664 DECLARE_NAPI_PROPERTY("InterruptHint", CreateEnumObject(env, interruptHintTypeMap, interruptHintType_)),
665 DECLARE_NAPI_PROPERTY("AudioState", CreateEnumObject(env, audioStateMap, audioState_)),
666 DECLARE_NAPI_PROPERTY("AudioSampleFormat", CreateEnumObject(env, audioSampleFormatMap, sampleFormat_)),
667 DECLARE_NAPI_PROPERTY("AudioEffectMode", CreateEnumObject(env, effectModeMap, audioEffectMode_)),
668 DECLARE_NAPI_PROPERTY("AudioPrivacyType", CreateEnumObject(env, audioPrivacyTypeMap, audioPrivacyType_)),
669 DECLARE_NAPI_PROPERTY("AudioVolumeType", CreateEnumObject(env, audioVolumeTypeMap, audioVolumeTypeRef_)),
670 DECLARE_NAPI_PROPERTY("DeviceFlag", CreateEnumObject(env, deviceFlagMap, deviceFlagRef_)),
671 DECLARE_NAPI_PROPERTY("ActiveDeviceType", CreateEnumObject(env, activeDeviceTypeMap, activeDeviceTypeRef_)),
672 DECLARE_NAPI_PROPERTY("ConnectType", CreateEnumObject(env, connectTypeMap, connectTypeRef_)),
673 DECLARE_NAPI_PROPERTY("AudioRingMode", CreateEnumObject(env, audioRingModeMap, audioRingModeRef_)),
674 DECLARE_NAPI_PROPERTY("AudioScene", CreateEnumObject(env, audioSceneMap, audioScene_)),
675 DECLARE_NAPI_PROPERTY("DeviceChangeType", CreateEnumObject(env, deviceChangeTypeMap, deviceChangeType_)),
676 DECLARE_NAPI_PROPERTY("InterruptActionType",
677 CreateEnumObject(env, interruptActionTypeMap, interruptActionType_)),
678 DECLARE_NAPI_PROPERTY("InterruptMode", CreateEnumObject(env, interruptModeMap, interruptMode_)),
679 DECLARE_NAPI_PROPERTY("FocusType", CreateEnumObject(env, focusTypeMap, focusType_)),
680 DECLARE_NAPI_PROPERTY("LOCAL_NETWORK_ID", CreateLocalNetworkIdObject(env)),
681 DECLARE_NAPI_PROPERTY("DEFAULT_VOLUME_GROUP_ID", CreateDefaultVolumeGroupIdObject(env)),
682 DECLARE_NAPI_PROPERTY("DEFAULT_INTERRUPT_GROUP_ID", CreateDefaultInterruptIdObject(env)),
683 DECLARE_NAPI_PROPERTY("AudioErrors", CreateEnumObject(env, audioErrorsMap, audioErrors_)),
684 DECLARE_NAPI_PROPERTY("CommunicationDeviceType",
685 CreateEnumObject(env, communicationDeviceTypeMap, communicationDeviceType_)),
686 DECLARE_NAPI_PROPERTY("InterruptRequestType",
687 CreateEnumObject(env, interruptRequestTypeMap, interruptRequestType_)),
688 DECLARE_NAPI_PROPERTY("InterruptRequestResultType",
689 CreateEnumObject(env, interruptRequestResultTypeMap, interruptRequestResultType_)),
690 DECLARE_NAPI_PROPERTY("ToneType", CreateEnumObject(env, toneTypeMap, toneType_)),
691 DECLARE_NAPI_PROPERTY("DeviceUsage", CreateEnumObject(env, audioDeviceUsageMap, audioDviceUsage_)),
692 DECLARE_NAPI_PROPERTY("AudioDataCallbackResult",
693 CreateEnumObject(env, audioDataCallbackResultMap, audioDataCallbackResult_)),
694 DECLARE_NAPI_PROPERTY("AudioConcurrencyMode",
695 CreateEnumObject(env, concurrencyModeMap, concurrencyMode_)),
696 DECLARE_NAPI_PROPERTY("AudioSessionDeactivatedReason", CreateEnumObject(env, reasonMap, reason_)),
697 DECLARE_NAPI_PROPERTY("PolicyType", CreateEnumObject(env, policyTypeMap, policyType_)),
698 };
699 return napi_define_properties(env, exports, sizeof(static_prop) / sizeof(static_prop[0]), static_prop);
700 }
701
Init(napi_env env,napi_value exports)702 napi_value NapiAudioEnum::Init(napi_env env, napi_value exports)
703 {
704 AUDIO_DEBUG_LOG("NapiAudioEnum::Init()");
705 napi_value constructor;
706 napi_value result = nullptr;
707 napi_get_undefined(env, &result);
708
709 napi_property_descriptor audio_parameters_properties[] = {
710 DECLARE_NAPI_GETTER_SETTER("format", GetAudioSampleFormat, SetAudioSampleFormat),
711 DECLARE_NAPI_GETTER_SETTER("channels", GetAudioChannel, SetAudioChannel),
712 DECLARE_NAPI_GETTER_SETTER("samplingRate", GetAudioSamplingRate, SetAudioSamplingRate),
713 DECLARE_NAPI_GETTER_SETTER("encoding", GetAudioEncodingType, SetAudioEncodingType),
714 DECLARE_NAPI_GETTER_SETTER("contentType", GetContentType, SetContentType),
715 DECLARE_NAPI_GETTER_SETTER("usage", GetStreamUsage, SetStreamUsage),
716 DECLARE_NAPI_GETTER_SETTER("deviceRole", GetDeviceRole, SetDeviceRole),
717 DECLARE_NAPI_GETTER_SETTER("deviceType", GetDeviceType, SetDeviceType)
718 };
719
720 napi_status status = napi_define_class(env, NAPI_AUDIO_ENUM_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct,
721 nullptr, sizeof(audio_parameters_properties) / sizeof(audio_parameters_properties[0]),
722 audio_parameters_properties, &constructor);
723 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "napi_define_class fail");
724
725 status = napi_create_reference(env, constructor, REFERENCE_CREATION_COUNT, &sConstructor_);
726 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "napi_create_reference fail");
727 status = napi_set_named_property(env, exports, NAPI_AUDIO_ENUM_CLASS_NAME.c_str(), constructor);
728 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "napi_set_named_property fail");
729 status = InitAudioEnum(env, exports);
730 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "InitAudioEnum failed");
731 status = InitAudioExternEnum(env, exports);
732 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "InitAudioExternEnum failed");
733
734 return exports;
735 }
736
Construct(napi_env env,napi_callback_info info)737 napi_value NapiAudioEnum::Construct(napi_env env, napi_callback_info info)
738 {
739 napi_value jsThis = nullptr;
740 size_t argCount = 0;
741 unique_ptr<NapiAudioEnum> obj = nullptr;
742
743 napi_status status = napi_get_cb_info(env, info, &argCount, nullptr, &jsThis, nullptr);
744 if (status != napi_ok) {
745 AUDIO_ERR_LOG("Construct:napi_get_cb_info failed!");
746 goto error;
747 }
748
749 obj = make_unique<NapiAudioEnum>();
750 if (obj == nullptr) {
751 AUDIO_ERR_LOG("obj make_unique failed,no memery.");
752 goto error;
753 }
754 obj->env_ = env;
755 obj->audioParameters_ = move(sAudioParameters_);
756 status = napi_wrap(env, jsThis, static_cast<void*>(obj.get()), NapiAudioEnum::Destructor, nullptr, nullptr);
757 if (status != napi_ok) {
758 goto error;
759 }
760 obj.release();
761 return jsThis;
762
763 error:
764 napi_get_undefined(env, &jsThis);
765 return jsThis;
766 }
767
SetValue(napi_env env,napi_callback_info info,napi_value * args,napi_value & result)768 NapiAudioEnum* NapiAudioEnum::SetValue(napi_env env, napi_callback_info info, napi_value *args, napi_value &result)
769 {
770 NapiAudioEnum *napiAudioEnum = nullptr;
771 size_t argc = 1;
772 napi_value jsThis = nullptr;
773 napi_get_undefined(env, &result);
774
775 napi_status status = napi_get_cb_info(env, info, &argc, args, &jsThis, nullptr);
776 if (status != napi_ok || jsThis == nullptr || argc < 1) {
777 AUDIO_ERR_LOG("SetValue fail to napi_get_cb_info");
778 return nullptr;
779 }
780
781 status = napi_unwrap(env, jsThis, (void **)&napiAudioEnum);
782 CHECK_AND_RETURN_RET_LOG(status == napi_ok, napiAudioEnum, "napi_unwrap failed");
783
784 napi_valuetype valueType = napi_undefined;
785 if (napi_typeof(env, args[0], &valueType) != napi_ok || valueType != napi_number) {
786 AUDIO_ERR_LOG("SetValue fail: wrong data type");
787 }
788 return napiAudioEnum;
789 }
790
GetValue(napi_env env,napi_callback_info info)791 NapiAudioEnum* NapiAudioEnum::GetValue(napi_env env, napi_callback_info info)
792 {
793 NapiAudioEnum *napiAudioEnum = nullptr;
794 size_t argc = 0;
795 napi_value jsThis = nullptr;
796
797 napi_status status = napi_get_cb_info(env, info, &argc, nullptr, &jsThis, nullptr);
798 if (status != napi_ok || jsThis == nullptr) {
799 AUDIO_ERR_LOG("GetValue fail to napi_get_cb_info");
800 return nullptr;
801 }
802
803 status = napi_unwrap(env, jsThis, (void **)&napiAudioEnum);
804 CHECK_AND_RETURN_RET_LOG(status == napi_ok, napiAudioEnum, "napi_unwrap failed");
805 if (!((napiAudioEnum != nullptr) && (napiAudioEnum->audioParameters_ != nullptr))) {
806 AUDIO_ERR_LOG("GetValue fail to napi_unwrap");
807 }
808 return napiAudioEnum;
809 }
810
GetAudioSampleFormat(napi_env env,napi_callback_info info)811 napi_value NapiAudioEnum::GetAudioSampleFormat(napi_env env, napi_callback_info info)
812 {
813 AudioSampleFormat audioSampleFormat;
814 napi_value jsResult = nullptr;
815 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
816
817 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
818 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
819 audioSampleFormat = napiAudioEnum->audioParameters_->format;
820 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(audioSampleFormat), jsResult);
821 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetAudioSampleFormat fail");
822 return jsResult;
823 }
824
SetAudioSampleFormat(napi_env env,napi_callback_info info)825 napi_value NapiAudioEnum::SetAudioSampleFormat(napi_env env, napi_callback_info info)
826 {
827 napi_value jsResult = nullptr;
828 napi_value args[1] = { nullptr };
829 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
830 int32_t audioSampleFormat;
831 napi_status status = NapiParamUtils::GetValueInt32(env, audioSampleFormat, args[0]);
832 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
833
834 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
835 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
836 napiAudioEnum->audioParameters_->format = static_cast<AudioSampleFormat>(audioSampleFormat);
837
838 return jsResult;
839 }
840
GetAudioChannel(napi_env env,napi_callback_info info)841 napi_value NapiAudioEnum::GetAudioChannel(napi_env env, napi_callback_info info)
842 {
843 AudioChannel audioChannel;
844 napi_value jsResult = nullptr;
845 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
846
847 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
848 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
849 audioChannel = napiAudioEnum->audioParameters_->channels;
850 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(audioChannel), jsResult);
851 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetAudioChannel fail");
852
853 return jsResult;
854 }
855
SetAudioChannel(napi_env env,napi_callback_info info)856 napi_value NapiAudioEnum::SetAudioChannel(napi_env env, napi_callback_info info)
857 {
858 napi_value jsResult = nullptr;
859 napi_value args[1] = { nullptr };
860 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
861 int32_t audioChannel;
862 napi_status status = NapiParamUtils::GetValueInt32(env, audioChannel, args[0]);
863 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
864
865 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
866 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
867 napiAudioEnum->audioParameters_->channels = static_cast<AudioChannel>(audioChannel);
868
869 return jsResult;
870 }
871
GetAudioSamplingRate(napi_env env,napi_callback_info info)872 napi_value NapiAudioEnum::GetAudioSamplingRate(napi_env env, napi_callback_info info)
873 {
874 AudioSamplingRate samplingRate;
875 napi_value jsResult = nullptr;
876 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
877
878 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
879 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
880 samplingRate = napiAudioEnum->audioParameters_->samplingRate;
881 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(samplingRate), jsResult);
882 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetAudioSamplingRate fail");
883
884 return jsResult;
885 }
886
SetAudioSamplingRate(napi_env env,napi_callback_info info)887 napi_value NapiAudioEnum::SetAudioSamplingRate(napi_env env, napi_callback_info info)
888 {
889 napi_value jsResult = nullptr;
890 napi_value args[1] = { nullptr };
891 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
892 int32_t samplingRate;
893 napi_status status = NapiParamUtils::GetValueInt32(env, samplingRate, args[0]);
894 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
895
896 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
897 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
898 napiAudioEnum->audioParameters_->samplingRate = static_cast<AudioSamplingRate>(samplingRate);
899
900 return jsResult;
901 }
902
GetAudioEncodingType(napi_env env,napi_callback_info info)903 napi_value NapiAudioEnum::GetAudioEncodingType(napi_env env, napi_callback_info info)
904 {
905 AudioEncodingType encodingType;
906 napi_value jsResult = nullptr;
907 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
908
909 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
910 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
911 encodingType = napiAudioEnum->audioParameters_->encoding;
912 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(encodingType), jsResult);
913 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetAudioEncodingType fail");
914
915 return jsResult;
916 }
917
SetAudioEncodingType(napi_env env,napi_callback_info info)918 napi_value NapiAudioEnum::SetAudioEncodingType(napi_env env, napi_callback_info info)
919 {
920 napi_value jsResult = nullptr;
921 napi_value args[1] = { nullptr };
922 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
923 int32_t encodingType;
924 napi_status status = NapiParamUtils::GetValueInt32(env, encodingType, args[0]);
925 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
926
927 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
928 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
929 napiAudioEnum->audioParameters_->encoding = static_cast<AudioEncodingType>(encodingType);
930
931 return jsResult;
932 }
933
GetContentType(napi_env env,napi_callback_info info)934 napi_value NapiAudioEnum::GetContentType(napi_env env, napi_callback_info info)
935 {
936 ContentType contentType;
937 napi_value jsResult = nullptr;
938 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
939
940 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
941 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
942 contentType = napiAudioEnum->audioParameters_->contentType;
943 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(contentType), jsResult);
944 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetContentType fail");
945
946 return jsResult;
947 }
948
SetContentType(napi_env env,napi_callback_info info)949 napi_value NapiAudioEnum::SetContentType(napi_env env, napi_callback_info info)
950 {
951 napi_value jsResult = nullptr;
952 napi_value args[1] = { nullptr };
953 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
954 int32_t contentType;
955 napi_status status = NapiParamUtils::GetValueInt32(env, contentType, args[0]);
956 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
957
958 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
959 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
960 napiAudioEnum->audioParameters_->contentType = static_cast<ContentType>(contentType);
961
962 return jsResult;
963 }
964
GetStreamUsage(napi_env env,napi_callback_info info)965 napi_value NapiAudioEnum::GetStreamUsage(napi_env env, napi_callback_info info)
966 {
967 StreamUsage usage;
968 napi_value jsResult = nullptr;
969 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
970
971 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
972 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
973 usage = napiAudioEnum->audioParameters_->usage;
974 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(usage), jsResult);
975 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetStreamUsage fail");
976
977 return jsResult;
978 }
979
SetStreamUsage(napi_env env,napi_callback_info info)980 napi_value NapiAudioEnum::SetStreamUsage(napi_env env, napi_callback_info info)
981 {
982 napi_value jsResult = nullptr;
983 napi_value args[1] = { nullptr };
984 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
985 int32_t usage;
986 napi_status status = NapiParamUtils::GetValueInt32(env, usage, args[0]);
987 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
988
989 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
990 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
991 napiAudioEnum->audioParameters_->usage = static_cast<StreamUsage>(usage);
992
993 return jsResult;
994 }
995
GetDeviceRole(napi_env env,napi_callback_info info)996 napi_value NapiAudioEnum::GetDeviceRole(napi_env env, napi_callback_info info)
997 {
998 DeviceRole deviceRole;
999 napi_value jsResult = nullptr;
1000 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
1001
1002 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
1003 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
1004 deviceRole = napiAudioEnum->audioParameters_->deviceRole;
1005 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(deviceRole), jsResult);
1006 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetDeviceRole fail");
1007
1008 return jsResult;
1009 }
1010
SetDeviceRole(napi_env env,napi_callback_info info)1011 napi_value NapiAudioEnum::SetDeviceRole(napi_env env, napi_callback_info info)
1012 {
1013 napi_value jsResult = nullptr;
1014 napi_value args[1] = { nullptr };
1015 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
1016 int32_t deviceRole;
1017 napi_status status = NapiParamUtils::GetValueInt32(env, deviceRole, args[0]);
1018 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
1019
1020 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
1021 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
1022 napiAudioEnum->audioParameters_->deviceRole = static_cast<DeviceRole>(deviceRole);
1023
1024 return jsResult;
1025 }
1026
GetDeviceType(napi_env env,napi_callback_info info)1027 napi_value NapiAudioEnum::GetDeviceType(napi_env env, napi_callback_info info)
1028 {
1029 DeviceType deviceType;
1030 napi_value jsResult = nullptr;
1031 NapiAudioEnum *napiAudioEnum = GetValue(env, info);
1032
1033 CHECK_AND_RETURN_RET_LOG(napiAudioEnum != nullptr, jsResult, "napiAudioEnum is nullptr");
1034 CHECK_AND_RETURN_RET_LOG(napiAudioEnum->audioParameters_ != nullptr, jsResult, "audioParameters_ is nullptr");
1035 deviceType = napiAudioEnum->audioParameters_->deviceType;
1036 napi_status status = NapiParamUtils::SetValueInt32(env, static_cast<int32_t>(deviceType), jsResult);
1037 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetDeviceType fail");
1038
1039 return jsResult;
1040 }
1041
SetDeviceType(napi_env env,napi_callback_info info)1042 napi_value NapiAudioEnum::SetDeviceType(napi_env env, napi_callback_info info)
1043 {
1044 napi_value jsResult = nullptr;
1045 napi_value args[1] = { nullptr };
1046 NapiAudioEnum *napiAudioEnum = SetValue(env, info, args, jsResult);
1047 int32_t deviceType;
1048 napi_status status = NapiParamUtils::GetValueInt32(env, deviceType, args[0]);
1049 CHECK_AND_RETURN_RET_LOG(status == napi_ok, jsResult, "GetValueInt32 fail");
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 napiAudioEnum->audioParameters_->deviceType = static_cast<DeviceType>(deviceType);
1054
1055 return jsResult;
1056 }
1057
IsLegalInputArgumentInterruptMode(int32_t interruptMode)1058 bool NapiAudioEnum::IsLegalInputArgumentInterruptMode(int32_t interruptMode)
1059 {
1060 bool result = false;
1061 switch (interruptMode) {
1062 case InterruptMode::SHARE_MODE:
1063 case InterruptMode::INDEPENDENT_MODE:
1064 result = true;
1065 break;
1066 default:
1067 result = false;
1068 break;
1069 }
1070 return result;
1071 }
1072
IsLegalInputArgumentAudioEffectMode(int32_t audioEffectMode)1073 bool NapiAudioEnum::IsLegalInputArgumentAudioEffectMode(int32_t audioEffectMode)
1074 {
1075 bool result = false;
1076 switch (audioEffectMode) {
1077 case AudioEffectMode::EFFECT_NONE:
1078 case AudioEffectMode::EFFECT_DEFAULT:
1079 result = true;
1080 break;
1081 default:
1082 result = false;
1083 break;
1084 }
1085 return result;
1086 }
1087
IsLegalInputArgumentChannelBlendMode(int32_t blendMode)1088 bool NapiAudioEnum::IsLegalInputArgumentChannelBlendMode(int32_t blendMode)
1089 {
1090 bool result = false;
1091 switch (blendMode) {
1092 case ChannelBlendMode::MODE_DEFAULT:
1093 case ChannelBlendMode::MODE_BLEND_LR:
1094 case ChannelBlendMode::MODE_ALL_LEFT:
1095 case ChannelBlendMode::MODE_ALL_RIGHT:
1096 result = true;
1097 break;
1098 default:
1099 result = false;
1100 break;
1101 }
1102 return result;
1103 }
1104
IsLegalCapturerType(int32_t type)1105 bool NapiAudioEnum::IsLegalCapturerType(int32_t type)
1106 {
1107 bool result = false;
1108 switch (type) {
1109 case TYPE_INVALID:
1110 case TYPE_MIC:
1111 case TYPE_VOICE_RECOGNITION:
1112 case TYPE_PLAYBACK_CAPTURE:
1113 case TYPE_WAKEUP:
1114 case TYPE_COMMUNICATION:
1115 case TYPE_VOICE_CALL:
1116 case TYPE_MESSAGE:
1117 case TYPE_REMOTE_CAST:
1118 case TYPE_VOICE_TRANSCRIPTION:
1119 case TYPE_CAMCORDER:
1120 result = true;
1121 break;
1122 default:
1123 result = false;
1124 break;
1125 }
1126 return result;
1127 }
1128
IsLegalInputArgumentVolType(int32_t inputType)1129 bool NapiAudioEnum::IsLegalInputArgumentVolType(int32_t inputType)
1130 {
1131 bool result = false;
1132 switch (inputType) {
1133 case AudioJsVolumeType::RINGTONE:
1134 case AudioJsVolumeType::MEDIA:
1135 case AudioJsVolumeType::VOICE_CALL:
1136 case AudioJsVolumeType::VOICE_ASSISTANT:
1137 case AudioJsVolumeType::ALARM:
1138 case AudioJsVolumeType::ACCESSIBILITY:
1139 case AudioJsVolumeType::ULTRASONIC:
1140 case AudioJsVolumeType::ALL:
1141 result = true;
1142 break;
1143 default:
1144 result = false;
1145 break;
1146 }
1147 return result;
1148 }
1149
IsLegalInputArgumentRingMode(int32_t ringMode)1150 bool NapiAudioEnum::IsLegalInputArgumentRingMode(int32_t ringMode)
1151 {
1152 bool result = false;
1153 switch (ringMode) {
1154 case AudioRingMode::RINGER_MODE_SILENT:
1155 case AudioRingMode::RINGER_MODE_VIBRATE:
1156 case AudioRingMode::RINGER_MODE_NORMAL:
1157 result = true;
1158 break;
1159 default:
1160 result = false;
1161 break;
1162 }
1163 return result;
1164 }
1165
IsLegalInputArgumentVolumeAdjustType(int32_t adjustType)1166 bool NapiAudioEnum::IsLegalInputArgumentVolumeAdjustType(int32_t adjustType)
1167 {
1168 bool result = false;
1169 switch (adjustType) {
1170 case VolumeAdjustType::VOLUME_UP:
1171 case VolumeAdjustType::VOLUME_DOWN:
1172 result = true;
1173 break;
1174 default:
1175 result = false;
1176 break;
1177 }
1178 return result;
1179 }
1180
IsLegalInputArgumentDeviceType(int32_t deviceType)1181 bool NapiAudioEnum::IsLegalInputArgumentDeviceType(int32_t deviceType)
1182 {
1183 bool result = false;
1184 switch (deviceType) {
1185 case DeviceType::DEVICE_TYPE_EARPIECE:
1186 case DeviceType::DEVICE_TYPE_SPEAKER:
1187 case DeviceType::DEVICE_TYPE_WIRED_HEADSET:
1188 case DeviceType::DEVICE_TYPE_WIRED_HEADPHONES:
1189 case DeviceType::DEVICE_TYPE_BLUETOOTH_SCO:
1190 case DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP:
1191 case DeviceType::DEVICE_TYPE_MIC:
1192 case DeviceType::DEVICE_TYPE_USB_HEADSET:
1193 case DeviceType::DEVICE_TYPE_FILE_SINK:
1194 case DeviceType::DEVICE_TYPE_FILE_SOURCE:
1195 result = true;
1196 break;
1197 default:
1198 result = false;
1199 break;
1200 }
1201 return result;
1202 }
1203
IsLegalInputArgumentDefaultOutputDeviceType(int32_t deviceType)1204 bool NapiAudioEnum::IsLegalInputArgumentDefaultOutputDeviceType(int32_t deviceType)
1205 {
1206 bool result = false;
1207 switch (deviceType) {
1208 case DeviceType::DEVICE_TYPE_EARPIECE:
1209 case DeviceType::DEVICE_TYPE_SPEAKER:
1210 case DeviceType::DEVICE_TYPE_DEFAULT:
1211 result = true;
1212 break;
1213 default:
1214 result = false;
1215 break;
1216 }
1217 return result;
1218 }
1219
GetJsAudioVolumeType(AudioStreamType volumeType)1220 int32_t NapiAudioEnum::GetJsAudioVolumeType(AudioStreamType volumeType)
1221 {
1222 int32_t result = MEDIA;
1223 switch (volumeType) {
1224 case AudioStreamType::STREAM_VOICE_CALL:
1225 case AudioStreamType::STREAM_VOICE_MESSAGE:
1226 case AudioStreamType::STREAM_VOICE_COMMUNICATION:
1227 case AudioStreamType::STREAM_VOICE_CALL_ASSISTANT:
1228 result = NapiAudioEnum::VOICE_CALL;
1229 break;
1230 case AudioStreamType::STREAM_RING:
1231 case AudioStreamType::STREAM_SYSTEM:
1232 case AudioStreamType::STREAM_NOTIFICATION:
1233 case AudioStreamType::STREAM_SYSTEM_ENFORCED:
1234 case AudioStreamType::STREAM_DTMF:
1235 result = NapiAudioEnum::RINGTONE;
1236 break;
1237 case AudioStreamType::STREAM_MUSIC:
1238 case AudioStreamType::STREAM_MEDIA:
1239 case AudioStreamType::STREAM_MOVIE:
1240 case AudioStreamType::STREAM_GAME:
1241 case AudioStreamType::STREAM_SPEECH:
1242 case AudioStreamType::STREAM_NAVIGATION:
1243 case AudioStreamType::STREAM_CAMCORDER:
1244 result = NapiAudioEnum::MEDIA;
1245 break;
1246 case AudioStreamType::STREAM_ALARM:
1247 result = NapiAudioEnum::ALARM;
1248 break;
1249 case AudioStreamType::STREAM_ACCESSIBILITY:
1250 result = NapiAudioEnum::ACCESSIBILITY;
1251 break;
1252 case AudioStreamType::STREAM_VOICE_ASSISTANT:
1253 result = NapiAudioEnum::VOICE_ASSISTANT;
1254 break;
1255 case AudioStreamType::STREAM_ULTRASONIC:
1256 result = NapiAudioEnum::ULTRASONIC;
1257 break;
1258 default:
1259 result = NapiAudioEnum::MEDIA;
1260 break;
1261 }
1262 return result;
1263 }
1264
IsLegalInputArgumentCommunicationDeviceType(int32_t communicationDeviceType)1265 bool NapiAudioEnum::IsLegalInputArgumentCommunicationDeviceType(int32_t communicationDeviceType)
1266 {
1267 bool result = false;
1268 switch (communicationDeviceType) {
1269 case CommunicationDeviceType::COMMUNICATION_SPEAKER:
1270 result = true;
1271 break;
1272 default:
1273 result = false;
1274 break;
1275 }
1276 return result;
1277 }
1278
IsLegalInputArgumentDeviceFlag(int32_t deviceFlag)1279 bool NapiAudioEnum::IsLegalInputArgumentDeviceFlag(int32_t deviceFlag)
1280 {
1281 bool result = false;
1282 switch (deviceFlag) {
1283 case DeviceFlag::NONE_DEVICES_FLAG:
1284 case DeviceFlag::OUTPUT_DEVICES_FLAG:
1285 case DeviceFlag::INPUT_DEVICES_FLAG:
1286 case DeviceFlag::ALL_DEVICES_FLAG:
1287 case DeviceFlag::DISTRIBUTED_OUTPUT_DEVICES_FLAG:
1288 case DeviceFlag::DISTRIBUTED_INPUT_DEVICES_FLAG:
1289 case DeviceFlag::ALL_DISTRIBUTED_DEVICES_FLAG:
1290 case DeviceFlag::ALL_L_D_DEVICES_FLAG:
1291 result = true;
1292 break;
1293 default:
1294 result = false;
1295 break;
1296 }
1297 return result;
1298 }
1299
IsLegalInputArgumentActiveDeviceType(int32_t activeDeviceFlag)1300 bool NapiAudioEnum::IsLegalInputArgumentActiveDeviceType(int32_t activeDeviceFlag)
1301 {
1302 bool result = false;
1303 switch (activeDeviceFlag) {
1304 case ActiveDeviceType::SPEAKER:
1305 case ActiveDeviceType::BLUETOOTH_SCO:
1306 result = true;
1307 break;
1308 default:
1309 result = false;
1310 break;
1311 }
1312 return result;
1313 }
1314
IsValidSourceType(int32_t intValue)1315 bool NapiAudioEnum::IsValidSourceType(int32_t intValue)
1316 {
1317 SourceType sourceTypeValue = static_cast<SourceType>(intValue);
1318 switch (sourceTypeValue) {
1319 case SourceType::SOURCE_TYPE_MIC:
1320 case SourceType::SOURCE_TYPE_PLAYBACK_CAPTURE:
1321 case SourceType::SOURCE_TYPE_ULTRASONIC:
1322 case SourceType::SOURCE_TYPE_VOICE_COMMUNICATION:
1323 case SourceType::SOURCE_TYPE_VOICE_RECOGNITION:
1324 case SourceType::SOURCE_TYPE_WAKEUP:
1325 case SourceType::SOURCE_TYPE_VOICE_CALL:
1326 case SourceType::SOURCE_TYPE_VOICE_MESSAGE:
1327 case SourceType::SOURCE_TYPE_REMOTE_CAST:
1328 case SourceType::SOURCE_TYPE_VOICE_TRANSCRIPTION:
1329 case SourceType::SOURCE_TYPE_CAMCORDER:
1330 return true;
1331 default:
1332 return false;
1333 }
1334 }
1335
IsLegalDeviceUsage(int32_t usage)1336 bool NapiAudioEnum::IsLegalDeviceUsage(int32_t usage)
1337 {
1338 bool result = false;
1339 switch (usage) {
1340 case AudioDeviceUsage::MEDIA_OUTPUT_DEVICES:
1341 case AudioDeviceUsage::MEDIA_INPUT_DEVICES:
1342 case AudioDeviceUsage::ALL_MEDIA_DEVICES:
1343 case AudioDeviceUsage::CALL_OUTPUT_DEVICES:
1344 case AudioDeviceUsage::CALL_INPUT_DEVICES:
1345 case AudioDeviceUsage::ALL_CALL_DEVICES:
1346 result = true;
1347 break;
1348 default:
1349 result = false;
1350 break;
1351 }
1352 return result;
1353 }
1354
1355
IsLegalInputArgumentStreamUsage(int32_t streamUsage)1356 bool NapiAudioEnum::IsLegalInputArgumentStreamUsage(int32_t streamUsage)
1357 {
1358 bool result = false;
1359 switch (streamUsage) {
1360 case STREAM_USAGE_UNKNOWN:
1361 case STREAM_USAGE_MEDIA:
1362 case STREAM_USAGE_VOICE_COMMUNICATION:
1363 case STREAM_USAGE_VOICE_ASSISTANT:
1364 case STREAM_USAGE_ALARM:
1365 case STREAM_USAGE_VOICE_MESSAGE:
1366 case STREAM_USAGE_NOTIFICATION_RINGTONE:
1367 case STREAM_USAGE_NOTIFICATION:
1368 case STREAM_USAGE_ACCESSIBILITY:
1369 case STREAM_USAGE_SYSTEM:
1370 case STREAM_USAGE_MOVIE:
1371 case STREAM_USAGE_GAME:
1372 case STREAM_USAGE_AUDIOBOOK:
1373 case STREAM_USAGE_NAVIGATION:
1374 case STREAM_USAGE_DTMF:
1375 case STREAM_USAGE_ENFORCED_TONE:
1376 case STREAM_USAGE_ULTRASONIC:
1377 case STREAM_USAGE_VIDEO_COMMUNICATION:
1378 case STREAM_USAGE_VOICE_CALL_ASSISTANT:
1379 result = true;
1380 break;
1381 default:
1382 result = false;
1383 break;
1384 }
1385 return result;
1386 }
1387
IsLegalOutputDeviceType(int32_t deviceType)1388 bool NapiAudioEnum::IsLegalOutputDeviceType(int32_t deviceType)
1389 {
1390 bool result = false;
1391 switch (deviceType) {
1392 case DeviceType::DEVICE_TYPE_EARPIECE:
1393 case DeviceType::DEVICE_TYPE_SPEAKER:
1394 case DeviceType::DEVICE_TYPE_WIRED_HEADSET:
1395 case DeviceType::DEVICE_TYPE_WIRED_HEADPHONES:
1396 case DeviceType::DEVICE_TYPE_BLUETOOTH_SCO:
1397 case DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP:
1398 case DeviceType::DEVICE_TYPE_DP:
1399 case DeviceType::DEVICE_TYPE_USB_HEADSET:
1400 case DeviceType::DEVICE_TYPE_USB_ARM_HEADSET:
1401 case DeviceType::DEVICE_TYPE_REMOTE_CAST:
1402 result = true;
1403 break;
1404 default:
1405 result = false;
1406 break;
1407 }
1408 return result;
1409 }
1410
GetNativeAudioVolumeType(int32_t volumeType)1411 AudioVolumeType NapiAudioEnum::GetNativeAudioVolumeType(int32_t volumeType)
1412 {
1413 AudioVolumeType result = STREAM_MUSIC;
1414
1415 switch (volumeType) {
1416 case NapiAudioEnum::VOICE_CALL:
1417 result = STREAM_VOICE_CALL;
1418 break;
1419 case NapiAudioEnum::RINGTONE:
1420 result = STREAM_RING;
1421 break;
1422 case NapiAudioEnum::MEDIA:
1423 result = STREAM_MUSIC;
1424 break;
1425 case NapiAudioEnum::ALARM:
1426 result = STREAM_ALARM;
1427 break;
1428 case NapiAudioEnum::ACCESSIBILITY:
1429 result = STREAM_ACCESSIBILITY;
1430 break;
1431 case NapiAudioEnum::VOICE_ASSISTANT:
1432 result = STREAM_VOICE_ASSISTANT;
1433 break;
1434 case NapiAudioEnum::ULTRASONIC:
1435 result = STREAM_ULTRASONIC;
1436 break;
1437 case NapiAudioEnum::ALL:
1438 result = STREAM_ALL;
1439 break;
1440 default:
1441 result = STREAM_MUSIC;
1442 AUDIO_ERR_LOG("GetNativeAudioVolumeType: Unknown volume type, Set it to default MEDIA!");
1443 break;
1444 }
1445
1446 return result;
1447 }
1448
GetNativeAudioRingerMode(int32_t ringMode)1449 AudioRingerMode NapiAudioEnum::GetNativeAudioRingerMode(int32_t ringMode)
1450 {
1451 AudioRingerMode result = AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL;
1452
1453 switch (ringMode) {
1454 case NapiAudioEnum::RINGER_MODE_SILENT:
1455 result = AudioStandard::AudioRingerMode::RINGER_MODE_SILENT;
1456 break;
1457 case NapiAudioEnum::RINGER_MODE_VIBRATE:
1458 result = AudioStandard::AudioRingerMode::RINGER_MODE_VIBRATE;
1459 break;
1460 case NapiAudioEnum::RINGER_MODE_NORMAL:
1461 result = AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL;
1462 break;
1463 default:
1464 result = AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL;
1465 AUDIO_ERR_LOG("Unknown ringer mode requested by JS, Set it to default RINGER_MODE_NORMAL!");
1466 break;
1467 }
1468
1469 return result;
1470 }
1471
GetJsAudioRingMode(int32_t ringerMode)1472 NapiAudioEnum::AudioRingMode NapiAudioEnum::GetJsAudioRingMode(int32_t ringerMode)
1473 {
1474 NapiAudioEnum::AudioRingMode result = NapiAudioEnum::AudioRingMode::RINGER_MODE_NORMAL;
1475
1476 switch (ringerMode) {
1477 case AudioStandard::AudioRingerMode::RINGER_MODE_SILENT:
1478 result = NapiAudioEnum::RINGER_MODE_SILENT;
1479 break;
1480 case AudioStandard::AudioRingerMode::RINGER_MODE_VIBRATE:
1481 result = NapiAudioEnum::RINGER_MODE_VIBRATE;
1482 break;
1483 case AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL:
1484 result = NapiAudioEnum::RINGER_MODE_NORMAL;
1485 break;
1486 default:
1487 result = NapiAudioEnum::RINGER_MODE_NORMAL;
1488 AUDIO_ERR_LOG("Unknown ringer mode returned from native, Set it to default RINGER_MODE_NORMAL!");
1489 break;
1490 }
1491
1492 return result;
1493 }
1494
GetNativeFocusType(int32_t focusType)1495 AudioStandard::FocusType NapiAudioEnum::GetNativeFocusType(int32_t focusType)
1496 {
1497 AudioStandard::FocusType result = AudioStandard::FocusType::FOCUS_TYPE_RECORDING;
1498 switch (focusType) {
1499 case NapiAudioEnum::FocusType::FOCUS_TYPE_RECORDING:
1500 result = AudioStandard::FocusType::FOCUS_TYPE_RECORDING;
1501 break;
1502 default:
1503 AUDIO_ERR_LOG("Unknown focusType type, Set it to default FOCUS_TYPE_RECORDING!");
1504 break;
1505 }
1506
1507 return result;
1508 }
1509
GetNativeInterruptMode(int32_t interruptMode)1510 AudioStandard::InterruptMode NapiAudioEnum::GetNativeInterruptMode(int32_t interruptMode)
1511 {
1512 AudioStandard::InterruptMode result;
1513 switch (interruptMode) {
1514 case NapiAudioEnum::InterruptMode::SHARE_MODE:
1515 result = AudioStandard::InterruptMode::SHARE_MODE;
1516 break;
1517 case NapiAudioEnum::InterruptMode::INDEPENDENT_MODE:
1518 result = AudioStandard::InterruptMode::INDEPENDENT_MODE;
1519 break;
1520 default:
1521 result = AudioStandard::InterruptMode::SHARE_MODE;
1522 AUDIO_ERR_LOG("Unknown interruptMode type, Set it to default SHARE_MODE!");
1523 break;
1524 }
1525 return result;
1526 }
1527
IsLegalInputArgumentSpatializationSceneType(int32_t spatializationSceneType)1528 bool NapiAudioEnum::IsLegalInputArgumentSpatializationSceneType(int32_t spatializationSceneType)
1529 {
1530 bool result = false;
1531 switch (spatializationSceneType) {
1532 case AudioSpatializationSceneType::SPATIALIZATION_SCENE_TYPE_DEFAULT:
1533 case AudioSpatializationSceneType::SPATIALIZATION_SCENE_TYPE_MUSIC:
1534 case AudioSpatializationSceneType::SPATIALIZATION_SCENE_TYPE_MOVIE:
1535 case AudioSpatializationSceneType::SPATIALIZATION_SCENE_TYPE_AUDIOBOOK:
1536 result = true;
1537 break;
1538 default:
1539 result = false;
1540 break;
1541 }
1542 return result;
1543 }
1544 } // namespace AudioStandard
1545 } // namespace OHOS
1546