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