• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2023-2025 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #ifndef LOG_TAG
16 #define LOG_TAG "NapiAudioManager"
17 #endif
18 
19 #include "napi_audio_manager.h"
20 #include "napi_audio_routing_manager.h"
21 #include "napi_audio_stream_manager.h"
22 #include "napi_audio_volume_manager.h"
23 #include "napi_audio_interrupt_manager.h"
24 #include "napi_audio_spatialization_manager.h"
25 #include "napi_audio_enum.h"
26 #include "napi_audio_error.h"
27 #include "napi_param_utils.h"
28 #include "audio_errors.h"
29 #include "audio_manager_log.h"
30 #ifdef FEATURE_HIVIEW_ENABLE
31 #if !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
32 #include "xpower_event_js.h"
33 #endif
34 #endif
35 #include "napi_audio_manager_callbacks.h"
36 #include "napi_audio_ringermode_callback.h"
37 #include "napi_audio_manager_interrupt_callback.h"
38 #include "napi_audio_volume_key_event.h"
39 #if !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
40 #include "napi_audio_effect_manager.h"
41 #include "napi_audio_session_manager.h"
42 #endif
43 
44 namespace OHOS {
45 namespace AudioStandard {
46 using namespace std;
47 using namespace HiviewDFX;
48 static __thread napi_ref g_managerConstructor = nullptr;
49 
NapiAudioManager()50 NapiAudioManager::NapiAudioManager()
51     : audioMngr_(nullptr), env_(nullptr) {}
52 
~NapiAudioManager()53 NapiAudioManager::~NapiAudioManager()
54 {
55     AUDIO_DEBUG_LOG("NapiAudioManager::~NapiAudioManager()");
56 }
57 
GetParamWithSync(const napi_env & env,napi_callback_info info,size_t & argc,napi_value * args)58 NapiAudioManager* NapiAudioManager::GetParamWithSync(const napi_env &env, napi_callback_info info,
59     size_t &argc, napi_value *args)
60 {
61     napi_status status;
62     NapiAudioManager *napiAudioManager = nullptr;
63     napi_value jsThis = nullptr;
64 
65     status = napi_get_cb_info(env, info, &argc, args, &jsThis, nullptr);
66     CHECK_AND_RETURN_RET_LOG(status == napi_ok && jsThis != nullptr, nullptr,
67         "GetParamWithSync fail to napi_get_cb_info");
68 
69     status = napi_unwrap(env, jsThis, (void **)&napiAudioManager);
70     CHECK_AND_RETURN_RET_LOG(status == napi_ok, nullptr, "napi_unwrap failed");
71     CHECK_AND_RETURN_RET_LOG(napiAudioManager != nullptr && napiAudioManager->audioMngr_ !=
72         nullptr, napiAudioManager, "GetParamWithSync fail to napi_unwrap");
73     return napiAudioManager;
74 }
75 
CheckContextStatus(std::shared_ptr<AudioManagerAsyncContext> context)76 bool NapiAudioManager::CheckContextStatus(std::shared_ptr<AudioManagerAsyncContext> context)
77 {
78     CHECK_AND_RETURN_RET_LOG(context != nullptr, false, "context object is nullptr.");
79     if (context->native == nullptr) {
80         context->SignError(NAPI_ERR_SYSTEM);
81         AUDIO_ERR_LOG("context object state is error.");
82         return false;
83     }
84     return true;
85 }
86 
CheckAudioManagerStatus(NapiAudioManager * napi,std::shared_ptr<AudioManagerAsyncContext> context)87 bool NapiAudioManager::CheckAudioManagerStatus(NapiAudioManager *napi,
88     std::shared_ptr<AudioManagerAsyncContext> context)
89 {
90     CHECK_AND_RETURN_RET_LOG(napi != nullptr, false, "napi object is nullptr.");
91     if (napi->audioMngr_ == nullptr) {
92         context->SignError(NAPI_ERR_SYSTEM);
93         AUDIO_ERR_LOG("audioMngr_ is nullptr.");
94         return false;
95     }
96     return true;
97 }
98 
InitNapiAudioManager(napi_env env,napi_value & constructor)99 napi_status NapiAudioManager::InitNapiAudioManager(napi_env env, napi_value &constructor)
100 {
101     napi_property_descriptor audio_svc_mngr_properties[] = {
102         DECLARE_NAPI_FUNCTION("setVolume", SetVolume),
103         DECLARE_NAPI_FUNCTION("getVolume", GetVolume),
104         DECLARE_NAPI_FUNCTION("getMaxVolume", GetMaxVolume),
105         DECLARE_NAPI_FUNCTION("getMinVolume", GetMinVolume),
106         DECLARE_NAPI_FUNCTION("getDevices", GetDevices),
107         DECLARE_NAPI_FUNCTION("mute", SetStreamMute),
108         DECLARE_NAPI_FUNCTION("isMute", IsStreamMute),
109         DECLARE_NAPI_FUNCTION("isActive", IsStreamActive),
110         DECLARE_NAPI_FUNCTION("setRingerMode", SetRingerMode),
111         DECLARE_NAPI_FUNCTION("getRingerMode", GetRingerMode),
112         DECLARE_NAPI_FUNCTION("setAudioScene", SetAudioScene),
113         DECLARE_NAPI_FUNCTION("getAudioScene", GetAudioScene),
114         DECLARE_NAPI_FUNCTION("getAudioSceneSync", GetAudioSceneSync),
115         DECLARE_NAPI_FUNCTION("setDeviceActive", SetDeviceActive),
116         DECLARE_NAPI_FUNCTION("isDeviceActive", IsDeviceActive),
117         DECLARE_NAPI_FUNCTION("setAudioParameter", SetAudioParameter),
118         DECLARE_NAPI_FUNCTION("getAudioParameter", GetAudioParameter),
119         DECLARE_NAPI_FUNCTION("setExtraParameters", SetExtraParameters),
120         DECLARE_NAPI_FUNCTION("getExtraParameters", GetExtraParameters),
121         DECLARE_NAPI_FUNCTION("setMicrophoneMute", SetMicrophoneMute),
122         DECLARE_NAPI_FUNCTION("isMicrophoneMute", IsMicrophoneMute),
123         DECLARE_NAPI_FUNCTION("requestIndependentInterrupt", RequestIndependentInterrupt),
124         DECLARE_NAPI_FUNCTION("abandonIndependentInterrupt", AbandonIndependentInterrupt),
125         DECLARE_NAPI_FUNCTION("on", On),
126         DECLARE_NAPI_FUNCTION("off", Off),
127         DECLARE_NAPI_FUNCTION("getStreamManager", GetStreamManager),
128 #if !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
129         DECLARE_NAPI_FUNCTION("getSessionManager", GetSessionManager),
130         DECLARE_NAPI_FUNCTION("getEffectManager", GetEffectManager),
131 #endif
132         DECLARE_NAPI_FUNCTION("getRoutingManager", GetRoutingManager),
133         DECLARE_NAPI_FUNCTION("getVolumeManager", GetVolumeManager),
134         DECLARE_NAPI_FUNCTION("getInterruptManager", GetInterruptManager),
135         DECLARE_NAPI_FUNCTION("getSpatializationManager", GetSpatializationManager),
136         DECLARE_NAPI_FUNCTION("disableSafeMediaVolume", DisableSafeMediaVolume),
137     };
138 
139     napi_status status = napi_define_class(env, NAPI_AUDIO_MNGR_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH,
140         Construct, nullptr,
141         sizeof(audio_svc_mngr_properties) / sizeof(audio_svc_mngr_properties[PARAM0]),
142         audio_svc_mngr_properties, &constructor);
143     return status;
144 }
145 
Init(napi_env env,napi_value exports)146 napi_value NapiAudioManager::Init(napi_env env, napi_value exports)
147 {
148     AUDIO_DEBUG_LOG("Init");
149     napi_status status;
150     napi_value constructor;
151     napi_value result = nullptr;
152     const int32_t refCount = 1;
153 
154     napi_property_descriptor static_prop[] = {
155         DECLARE_NAPI_STATIC_FUNCTION("getAudioManager", GetAudioManager),
156     };
157 
158     status = InitNapiAudioManager(env, constructor);
159     CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "InitNapiAudioRenderer fail");
160 
161     status = napi_create_reference(env, constructor, refCount, &g_managerConstructor);
162     CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "napi_create_reference fail");
163     status = napi_set_named_property(env, exports, NAPI_AUDIO_MNGR_CLASS_NAME.c_str(), constructor);
164     CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "napi_set_named_property fail");
165     status = napi_define_properties(env, exports, sizeof(static_prop) / sizeof(static_prop[PARAM0]),
166         static_prop);
167     CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "napi_define_properties fail");
168     return exports;
169 }
170 
Destructor(napi_env env,void * nativeObject,void * finalizeHint)171 void NapiAudioManager::Destructor(napi_env env, void *nativeObject, void *finalizeHint)
172 {
173     if (nativeObject == nullptr) {
174         AUDIO_WARNING_LOG("Native object is null");
175         return;
176     }
177     auto obj = static_cast<NapiAudioManager*>(nativeObject);
178     ObjectRefMap<NapiAudioManager>::DecreaseRef(obj);
179     AUDIO_INFO_LOG("Decrease obj count");
180 }
181 
Construct(napi_env env,napi_callback_info info)182 napi_value NapiAudioManager::Construct(napi_env env, napi_callback_info info)
183 {
184     napi_status status;
185     napi_value jsThis;
186     napi_value undefinedResult = nullptr;
187     NapiParamUtils::GetUndefinedValue(env);
188     size_t argCount = PARAM0;
189 
190     status = napi_get_cb_info(env, info, &argCount, nullptr, &jsThis, nullptr);
191     if (status == napi_ok) {
192         unique_ptr<NapiAudioManager> managerNapi = make_unique<NapiAudioManager>();
193         if (managerNapi != nullptr) {
194             ObjectRefMap<NapiAudioManager>::Insert(managerNapi.get());
195             managerNapi->env_ = env;
196             managerNapi->audioMngr_ = AudioSystemManager::GetInstance();
197             managerNapi->cachedClientId_ = getpid();
198 
199             status = napi_wrap(env, jsThis, static_cast<void*>(managerNapi.get()),
200                                NapiAudioManager::Destructor, nullptr, nullptr);
201             if (status != napi_ok) {
202                 ObjectRefMap<NapiAudioManager>::Erase(managerNapi.get());
203                 return undefinedResult;
204             }
205             managerNapi.release();
206             return jsThis;
207         }
208     }
209     return undefinedResult;
210 }
211 
CreateAudioManagerWrapper(napi_env env)212 napi_value NapiAudioManager::CreateAudioManagerWrapper(napi_env env)
213 {
214     napi_status status;
215     napi_value result = nullptr;
216     napi_value constructor;
217 
218     status = napi_get_reference_value(env, g_managerConstructor, &constructor);
219     if (status != napi_ok) {
220         AUDIO_ERR_LOG("Failed in CreateAudioManagerWrapper, %{public}d", status);
221         goto fail;
222     }
223     status = napi_new_instance(env, constructor, 0, nullptr, &result);
224     if (status != napi_ok) {
225         AUDIO_ERR_LOG("napi_new_instance failed, status:%{public}d", status);
226         goto fail;
227     }
228     return result;
229 
230 fail:
231     napi_get_undefined(env, &result);
232     return result;
233 }
234 
GetAudioManager(napi_env env,napi_callback_info info)235 napi_value NapiAudioManager::GetAudioManager(napi_env env, napi_callback_info info)
236 {
237     napi_status status;
238     size_t argCount = PARAM0;
239 
240     status = napi_get_cb_info(env, info, &argCount, nullptr, nullptr, nullptr);
241     if (status != napi_ok || argCount != 0) {
242         AUDIO_ERR_LOG("Invalid arguments!");
243         return nullptr;
244     }
245 
246     return NapiAudioManager::CreateAudioManagerWrapper(env);
247 }
248 
GetStreamManager(napi_env env,napi_callback_info info)249 napi_value NapiAudioManager::GetStreamManager(napi_env env, napi_callback_info info)
250 {
251     napi_status status;
252     size_t argCount = PARAM0;
253 
254     status = napi_get_cb_info(env, info, &argCount, nullptr, nullptr, nullptr);
255     if (status != napi_ok || argCount != 0) {
256         AUDIO_ERR_LOG("Invalid arguments!");
257         return nullptr;
258     }
259 
260     return NapiAudioStreamMgr::CreateStreamManagerWrapper(env);
261 }
262 
263 #if !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
GetEffectManager(napi_env env,napi_callback_info info)264 napi_value NapiAudioManager::GetEffectManager(napi_env env, napi_callback_info info)
265 {
266     napi_status status;
267     size_t argCount = PARAM0;
268 
269     status = napi_get_cb_info(env, info, &argCount, nullptr, nullptr, nullptr);
270     if (status != napi_ok || argCount != 0) {
271         AUDIO_ERR_LOG("Invalid arguments!");
272         return nullptr;
273     }
274 
275     return NapiAudioEffectMgr::CreateEffectManagerWrapper(env);
276 }
277 
GetSessionManager(napi_env env,napi_callback_info info)278 napi_value NapiAudioManager::GetSessionManager(napi_env env, napi_callback_info info)
279 {
280     napi_status status;
281     size_t argCount = PARAM0;
282 
283     status = napi_get_cb_info(env, info, &argCount, nullptr, nullptr, nullptr);
284     if (status != napi_ok || argCount != 0) {
285         AUDIO_ERR_LOG("Invalid arguments!");
286         return nullptr;
287     }
288 
289     return NapiAudioSessionMgr::CreateSessionManagerWrapper(env);
290 }
291 #endif
292 
GetRoutingManager(napi_env env,napi_callback_info info)293 napi_value NapiAudioManager::GetRoutingManager(napi_env env, napi_callback_info info)
294 {
295     napi_status status;
296     size_t argCount = PARAM0;
297 
298     status = napi_get_cb_info(env, info, &argCount, nullptr, nullptr, nullptr);
299     if (status != napi_ok || argCount != 0) {
300         AUDIO_ERR_LOG("Invalid arguments!");
301         return nullptr;
302     }
303 
304     return NapiAudioRoutingManager::CreateRoutingManagerWrapper(env);
305 }
306 
GetVolumeManager(napi_env env,napi_callback_info info)307 napi_value NapiAudioManager::GetVolumeManager(napi_env env, napi_callback_info info)
308 {
309     napi_status status;
310     size_t argCount = PARAM0;
311 
312     status = napi_get_cb_info(env, info, &argCount, nullptr, nullptr, nullptr);
313     if (status != napi_ok || argCount != 0) {
314         AUDIO_ERR_LOG("Invalid arguments!");
315         return nullptr;
316     }
317 
318     return NapiAudioVolumeManager::CreateVolumeManagerWrapper(env);
319 }
320 
GetInterruptManager(napi_env env,napi_callback_info info)321 napi_value NapiAudioManager::GetInterruptManager(napi_env env, napi_callback_info info)
322 {
323     napi_status status;
324     size_t argCount = PARAM0;
325 
326     status = napi_get_cb_info(env, info, &argCount, nullptr, nullptr, nullptr);
327     if (status != napi_ok || argCount != 0) {
328         AUDIO_ERR_LOG("Invalid arguments!");
329         return nullptr;
330     }
331 
332     return NapiAudioInterruptManager::CreateInterruptManagerWrapper(env);
333 }
334 
GetSpatializationManager(napi_env env,napi_callback_info info)335 napi_value NapiAudioManager::GetSpatializationManager(napi_env env, napi_callback_info info)
336 {
337     napi_status status;
338     size_t argCount = 0;
339 
340     status = napi_get_cb_info(env, info, &argCount, nullptr, nullptr, nullptr);
341     if (status != napi_ok || argCount != 0) {
342         AUDIO_ERR_LOG("Invalid arguments!");
343         return nullptr;
344     }
345 
346     return NapiAudioSpatializationManager::CreateSpatializationManagerWrapper(env);
347 }
348 
SetVolume(napi_env env,napi_callback_info info)349 napi_value NapiAudioManager::SetVolume(napi_env env, napi_callback_info info)
350 {
351     auto context = std::make_shared<AudioManagerAsyncContext>();
352     if (context == nullptr) {
353         AUDIO_ERR_LOG("SetVolume failed : no memory");
354         NapiAudioError::ThrowError(env, "SetVolume failed : no memory", NAPI_ERR_NO_MEMORY);
355         return NapiParamUtils::GetUndefinedValue(env);
356     }
357 
358     auto inputParser = [env, context](size_t argc, napi_value *argv) {
359         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_TWO, "invalid arguments",
360             NAPI_ERR_INVALID_PARAM);
361         context->status = NapiParamUtils::GetValueInt32(env, context->volType, argv[PARAM0]);
362         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get volType failed",
363             NAPI_ERR_INVALID_PARAM);
364         NAPI_CHECK_ARGS_RETURN_VOID(context, NapiAudioEnum::IsLegalInputArgumentVolType(context->volType),
365             "get volType unsupport", NAPI_ERR_UNSUPPORTED);
366         context->status = NapiParamUtils::GetValueInt32(env, context->volLevel, argv[PARAM1]);
367         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get volLevel failed",
368             NAPI_ERR_INVALID_PARAM);
369     };
370     context->GetCbInfo(env, info, inputParser);
371 #ifdef FEATURE_HIVIEW_ENABLE
372 #if !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
373     HiviewDFX::ReportXPowerJsStackSysEvent(env, "VOLUME_CHANGE", "SRC=Audio");
374 #endif
375 #endif
376 
377     auto executor = [context]() {
378         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
379         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
380         ObjectRefMap objectGuard(obj);
381         auto *napiAudioManager = objectGuard.GetPtr();
382         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
383             "audio manager state is error.");
384         context->intValue = napiAudioManager->audioMngr_->SetVolume(
385             NapiAudioEnum::GetNativeAudioVolumeType(context->volType), context->volLevel);
386         if (context->intValue != SUCCESS) {
387             context->SignError(context->intValue);
388         }
389     };
390 
391     auto complete = [env](napi_value &output) {
392         output = NapiParamUtils::GetUndefinedValue(env);
393     };
394     return NapiAsyncWork::Enqueue(env, context, "SetVolume", executor, complete);
395 }
396 
GetVolume(napi_env env,napi_callback_info info)397 napi_value NapiAudioManager::GetVolume(napi_env env, napi_callback_info info)
398 {
399     auto context = std::make_shared<AudioManagerAsyncContext>();
400     if (context == nullptr) {
401         AUDIO_ERR_LOG("GetVolume failed : no memory");
402         NapiAudioError::ThrowError(env, "GetVolume failed : no memory", NAPI_ERR_NO_MEMORY);
403         return NapiParamUtils::GetUndefinedValue(env);
404     }
405 
406     auto inputParser = [env, context](size_t argc, napi_value *argv) {
407         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
408             NAPI_ERR_INVALID_PARAM);
409         context->status = NapiParamUtils::GetValueInt32(env, context->volType, argv[PARAM0]);
410         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get volType failed",
411             NAPI_ERR_INVALID_PARAM);
412         NAPI_CHECK_ARGS_RETURN_VOID(context, NapiAudioEnum::IsLegalInputArgumentVolType(context->volType),
413             "get volType unsupport", NAPI_ERR_UNSUPPORTED);
414     };
415     context->GetCbInfo(env, info, inputParser);
416 
417     auto executor = [context]() {
418         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
419         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
420         ObjectRefMap objectGuard(obj);
421         auto *napiAudioManager = objectGuard.GetPtr();
422         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
423             "audio manager state is error.");
424         context->volLevel = napiAudioManager->audioMngr_->GetVolume(
425             NapiAudioEnum::GetNativeAudioVolumeType(context->volType));
426     };
427 
428     auto complete = [env, context](napi_value &output) {
429         NapiParamUtils::SetValueInt32(env, context->volLevel, output);
430     };
431     return NapiAsyncWork::Enqueue(env, context, "GetVolume", executor, complete);
432 }
433 
GetMaxVolume(napi_env env,napi_callback_info info)434 napi_value NapiAudioManager::GetMaxVolume(napi_env env, napi_callback_info info)
435 {
436     auto context = std::make_shared<AudioManagerAsyncContext>();
437     if (context == nullptr) {
438         AUDIO_ERR_LOG("GetMaxVolume failed : no memory");
439         NapiAudioError::ThrowError(env, "GetMaxVolume failed : no memory", NAPI_ERR_NO_MEMORY);
440         return NapiParamUtils::GetUndefinedValue(env);
441     }
442 
443     auto inputParser = [env, context](size_t argc, napi_value *argv) {
444         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
445             NAPI_ERR_INVALID_PARAM);
446         context->status = NapiParamUtils::GetValueInt32(env, context->volType, argv[PARAM0]);
447         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get volType failed",
448             NAPI_ERR_INVALID_PARAM);
449         NAPI_CHECK_ARGS_RETURN_VOID(context, NapiAudioEnum::IsLegalInputArgumentVolType(context->volType),
450             "get volType unsupport", NAPI_ERR_UNSUPPORTED);
451     };
452     context->GetCbInfo(env, info, inputParser);
453 
454     auto executor = [context]() {
455         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
456         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
457         ObjectRefMap objectGuard(obj);
458         auto *napiAudioManager = objectGuard.GetPtr();
459         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
460             "audio manager state is error.");
461         context->intValue = napiAudioManager->audioMngr_->GetMaxVolume(
462             NapiAudioEnum::GetNativeAudioVolumeType(context->volType));
463     };
464 
465     auto complete = [env, context](napi_value &output) {
466         NapiParamUtils::SetValueInt32(env, context->intValue, output);
467     };
468     return NapiAsyncWork::Enqueue(env, context, "GetMaxVolume", executor, complete);
469 }
470 
GetMinVolume(napi_env env,napi_callback_info info)471 napi_value NapiAudioManager::GetMinVolume(napi_env env, napi_callback_info info)
472 {
473     auto context = std::make_shared<AudioManagerAsyncContext>();
474     if (context == nullptr) {
475         AUDIO_ERR_LOG("GetMinVolume failed : no memory");
476         NapiAudioError::ThrowError(env, "GetMinVolume failed : no memory", NAPI_ERR_NO_MEMORY);
477         return NapiParamUtils::GetUndefinedValue(env);
478     }
479 
480     auto inputParser = [env, context](size_t argc, napi_value *argv) {
481         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
482             NAPI_ERR_INVALID_PARAM);
483         context->status = NapiParamUtils::GetValueInt32(env, context->volType, argv[PARAM0]);
484         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get volType failed",
485             NAPI_ERR_INVALID_PARAM);
486         NAPI_CHECK_ARGS_RETURN_VOID(context, NapiAudioEnum::IsLegalInputArgumentVolType(context->volType),
487             "get volType unsupport", NAPI_ERR_UNSUPPORTED);
488     };
489     context->GetCbInfo(env, info, inputParser);
490 
491     auto executor = [context]() {
492         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
493         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
494         ObjectRefMap objectGuard(obj);
495         auto *napiAudioManager = objectGuard.GetPtr();
496         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
497             "audio manager state is error.");
498         context->intValue = napiAudioManager->audioMngr_->GetMinVolume(
499             NapiAudioEnum::GetNativeAudioVolumeType(context->volType));
500     };
501 
502     auto complete = [env, context](napi_value &output) {
503         NapiParamUtils::SetValueInt32(env, context->intValue, output);
504     };
505     return NapiAsyncWork::Enqueue(env, context, "GetMinVolume", executor, complete);
506 }
507 
GetDevices(napi_env env,napi_callback_info info)508 napi_value NapiAudioManager::GetDevices(napi_env env, napi_callback_info info)
509 {
510     auto context = std::make_shared<AudioManagerAsyncContext>();
511     if (context == nullptr) {
512         AUDIO_ERR_LOG("GetDevices failed : no memory");
513         NapiAudioError::ThrowError(env, "GetDevices failed : no memory", NAPI_ERR_NO_MEMORY);
514         return NapiParamUtils::GetUndefinedValue(env);
515     }
516 
517     auto inputParser = [env, context](size_t argc, napi_value *argv) {
518         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
519             NAPI_ERR_INVALID_PARAM);
520         context->status = NapiParamUtils::GetValueInt32(env, context->deviceFlag, argv[PARAM0]);
521         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get deviceFlag failed",
522             NAPI_ERR_INVALID_PARAM);
523         NAPI_CHECK_ARGS_RETURN_VOID(context, NapiAudioEnum::IsLegalInputArgumentDeviceFlag(context->deviceFlag),
524             "get deviceFlag unsupport", NAPI_ERR_UNSUPPORTED);
525     };
526     context->GetCbInfo(env, info, inputParser);
527 
528     auto executor = [context]() {
529         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
530         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
531         ObjectRefMap objectGuard(obj);
532         auto *napiAudioManager = objectGuard.GetPtr();
533         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
534             "audio manager state is error.");
535         context->deviceDescriptors = napiAudioManager->audioMngr_->GetDevices(
536             static_cast<DeviceFlag>(context->deviceFlag));
537     };
538 
539     auto complete = [env, context](napi_value &output) {
540         NapiParamUtils::SetDeviceDescriptors(env, context->deviceDescriptors, output);
541     };
542     return NapiAsyncWork::Enqueue(env, context, "GetDevices", executor, complete);
543 }
544 
SetStreamMute(napi_env env,napi_callback_info info)545 napi_value NapiAudioManager::SetStreamMute(napi_env env, napi_callback_info info)
546 {
547     auto context = std::make_shared<AudioManagerAsyncContext>();
548     if (context == nullptr) {
549         AUDIO_ERR_LOG("SetStreamMute failed : no memory");
550         NapiAudioError::ThrowError(env, "SetStreamMute failed : no memory", NAPI_ERR_NO_MEMORY);
551         return NapiParamUtils::GetUndefinedValue(env);
552     }
553 
554     auto inputParser = [env, context](size_t argc, napi_value *argv) {
555         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_TWO, "invalid arguments",
556             NAPI_ERR_INVALID_PARAM);
557         context->status = NapiParamUtils::GetValueInt32(env, context->volType, argv[PARAM0]);
558         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get volType failed",
559             NAPI_ERR_INVALID_PARAM);
560         NAPI_CHECK_ARGS_RETURN_VOID(context, NapiAudioEnum::IsLegalInputArgumentVolType(context->volType),
561             "get volType unsupport", NAPI_ERR_UNSUPPORTED);
562         context->status = NapiParamUtils::GetValueBoolean(env, context->isMute, argv[PARAM1]);
563         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get ismute failed",
564             NAPI_ERR_INVALID_PARAM);
565     };
566     context->GetCbInfo(env, info, inputParser);
567 
568     auto executor = [context]() {
569         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
570         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
571         ObjectRefMap objectGuard(obj);
572         auto *napiAudioManager = objectGuard.GetPtr();
573         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
574             "audio manager state is error.");
575         context->intValue = napiAudioManager->audioMngr_->SetMute(
576             NapiAudioEnum::GetNativeAudioVolumeType(context->volType), context->isMute);
577         NAPI_CHECK_ARGS_RETURN_VOID(context, context->intValue == SUCCESS, "SetMute failed",
578             NAPI_ERR_SYSTEM);
579     };
580 
581     auto complete = [env](napi_value &output) {
582         output = NapiParamUtils::GetUndefinedValue(env);
583     };
584     return NapiAsyncWork::Enqueue(env, context, "SetStreamMute", executor, complete);
585 }
586 
IsStreamMute(napi_env env,napi_callback_info info)587 napi_value NapiAudioManager::IsStreamMute(napi_env env, napi_callback_info info)
588 {
589     auto context = std::make_shared<AudioManagerAsyncContext>();
590     if (context == nullptr) {
591         AUDIO_ERR_LOG("IsStreamMute failed : no memory");
592         NapiAudioError::ThrowError(env, "IsStreamMute failed : no memory", NAPI_ERR_NO_MEMORY);
593         return NapiParamUtils::GetUndefinedValue(env);
594     }
595 
596     auto inputParser = [env, context](size_t argc, napi_value *argv) {
597         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
598             NAPI_ERR_INVALID_PARAM);
599         context->status = NapiParamUtils::GetValueInt32(env, context->volType, argv[PARAM0]);
600         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get volType failed",
601             NAPI_ERR_INVALID_PARAM);
602         NAPI_CHECK_ARGS_RETURN_VOID(context, NapiAudioEnum::IsLegalInputArgumentVolType(context->volType),
603             "get volType unsupport", NAPI_ERR_UNSUPPORTED);
604     };
605     context->GetCbInfo(env, info, inputParser);
606 
607     auto executor = [context]() {
608         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
609         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
610         ObjectRefMap objectGuard(obj);
611         auto *napiAudioManager = objectGuard.GetPtr();
612         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
613             "audio manager state is error.");
614         context->isMute = napiAudioManager->audioMngr_->IsStreamMute(
615             NapiAudioEnum::GetNativeAudioVolumeType(context->volType));
616     };
617 
618     auto complete = [env, context](napi_value &output) {
619         NapiParamUtils::SetValueBoolean(env, context->isMute, output);
620     };
621     return NapiAsyncWork::Enqueue(env, context, "IsStreamMute", executor, complete);
622 }
623 
IsStreamActive(napi_env env,napi_callback_info info)624 napi_value NapiAudioManager::IsStreamActive(napi_env env, napi_callback_info info)
625 {
626     auto context = std::make_shared<AudioManagerAsyncContext>();
627     if (context == nullptr) {
628         AUDIO_ERR_LOG("IsStreamActive failed : no memory");
629         NapiAudioError::ThrowError(env, "IsStreamActive failed : no memory", NAPI_ERR_NO_MEMORY);
630         return NapiParamUtils::GetUndefinedValue(env);
631     }
632 
633     auto inputParser = [env, context](size_t argc, napi_value *argv) {
634         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
635             NAPI_ERR_INVALID_PARAM);
636         context->status = NapiParamUtils::GetValueInt32(env, context->volType, argv[PARAM0]);
637         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get volType failed",
638             NAPI_ERR_INVALID_PARAM);
639         NAPI_CHECK_ARGS_RETURN_VOID(context, NapiAudioEnum::IsLegalInputArgumentVolType(context->volType),
640             "get volType unsupport", NAPI_ERR_UNSUPPORTED);
641     };
642     context->GetCbInfo(env, info, inputParser);
643 
644     auto executor = [context]() {
645         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
646         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
647         ObjectRefMap objectGuard(obj);
648         auto *napiAudioManager = objectGuard.GetPtr();
649         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
650             "audio manager state is error.");
651         context->isActive = napiAudioManager->audioMngr_->IsStreamActive(
652             NapiAudioEnum::GetNativeAudioVolumeType(context->volType));
653     };
654 
655     auto complete = [env, context](napi_value &output) {
656         NapiParamUtils::SetValueBoolean(env, context->isActive, output);
657     };
658     return NapiAsyncWork::Enqueue(env, context, "IsStreamActive", executor, complete);
659 }
660 
SetRingerMode(napi_env env,napi_callback_info info)661 napi_value NapiAudioManager::SetRingerMode(napi_env env, napi_callback_info info)
662 {
663     auto context = std::make_shared<AudioManagerAsyncContext>();
664     if (context == nullptr) {
665         AUDIO_ERR_LOG("SetRingerMode failed : no memory");
666         NapiAudioError::ThrowError(env, "SetRingerMode failed : no memory", NAPI_ERR_NO_MEMORY);
667         return NapiParamUtils::GetUndefinedValue(env);
668     }
669 
670     auto inputParser = [env, context](size_t argc, napi_value *argv) {
671         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
672             NAPI_ERR_INVALID_PARAM);
673         context->status = NapiParamUtils::GetValueInt32(env, context->ringMode, argv[PARAM0]);
674         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get ringMode failed",
675             NAPI_ERR_INVALID_PARAM);
676         NAPI_CHECK_ARGS_RETURN_VOID(context, NapiAudioEnum::IsLegalInputArgumentRingMode(context->ringMode),
677             "get ringMode unsupport", NAPI_ERR_UNSUPPORTED);
678     };
679     context->GetCbInfo(env, info, inputParser);
680 
681     auto executor = [context]() {
682         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
683         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
684         ObjectRefMap objectGuard(obj);
685         auto *napiAudioManager = objectGuard.GetPtr();
686         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
687             "audio manager state is error.");
688         napiAudioManager->audioMngr_->SetRingerMode(
689             NapiAudioEnum::GetNativeAudioRingerMode(context->ringMode));
690     };
691 
692     auto complete = [env](napi_value &output) {
693         output = NapiParamUtils::GetUndefinedValue(env);
694     };
695     return NapiAsyncWork::Enqueue(env, context, "SetRingerMode", executor, complete);
696 }
697 
GetRingerMode(napi_env env,napi_callback_info info)698 napi_value NapiAudioManager::GetRingerMode(napi_env env, napi_callback_info info)
699 {
700     auto context = std::make_shared<AudioManagerAsyncContext>();
701     if (context == nullptr) {
702         AUDIO_ERR_LOG("SetRingerMode failed : no memory");
703         NapiAudioError::ThrowError(env, "SetRingerMode failed : no memory", NAPI_ERR_NO_MEMORY);
704         return NapiParamUtils::GetUndefinedValue(env);
705     }
706 
707     context->GetCbInfo(env, info);
708 
709     auto executor = [context]() {
710         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
711         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
712         ObjectRefMap objectGuard(obj);
713         auto *napiAudioManager = objectGuard.GetPtr();
714         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
715             "audio manager state is error.");
716         context->ringMode = NapiAudioEnum::GetJsAudioRingMode(napiAudioManager->audioMngr_->GetRingerMode());
717     };
718 
719     auto complete = [env, context](napi_value &output) {
720         NapiParamUtils::SetValueInt32(env, context->ringMode, output);
721     };
722     return NapiAsyncWork::Enqueue(env, context, "GetRingerMode", executor, complete);
723 }
724 
SetAudioScene(napi_env env,napi_callback_info info)725 napi_value NapiAudioManager::SetAudioScene(napi_env env, napi_callback_info info)
726 {
727     auto context = std::make_shared<AudioManagerAsyncContext>();
728     if (context == nullptr) {
729         AUDIO_ERR_LOG("SetAudioScene failed : no memory");
730         NapiAudioError::ThrowError(env, "SetAudioScene failed : no memory", NAPI_ERR_NO_MEMORY);
731         return NapiParamUtils::GetUndefinedValue(env);
732     }
733 
734     auto inputParser = [env, context](size_t argc, napi_value *argv) {
735         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
736             NAPI_ERR_INVALID_PARAM);
737         context->status = NapiParamUtils::GetValueInt32(env, context->scene, argv[PARAM0]);
738         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get scene failed",
739             NAPI_ERR_INVALID_PARAM);
740     };
741     context->GetCbInfo(env, info, inputParser);
742 
743     auto executor = [context]() {
744         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
745         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
746         ObjectRefMap objectGuard(obj);
747         auto *napiAudioManager = objectGuard.GetPtr();
748         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
749             "audio manager state is error.");
750         context->intValue = napiAudioManager->audioMngr_->SetAudioScene(static_cast<AudioScene>(context->scene));
751         NAPI_CHECK_ARGS_RETURN_VOID(context, context->intValue == SUCCESS, "SetAudioScene failed",
752             NAPI_ERR_SYSTEM);
753     };
754 
755     auto complete = [env](napi_value &output) {
756         output = NapiParamUtils::GetUndefinedValue(env);
757     };
758     return NapiAsyncWork::Enqueue(env, context, "SetAudioScene", executor, complete);
759 }
760 
GetAudioScene(napi_env env,napi_callback_info info)761 napi_value NapiAudioManager::GetAudioScene(napi_env env, napi_callback_info info)
762 {
763     auto context = std::make_shared<AudioManagerAsyncContext>();
764     if (context == nullptr) {
765         AUDIO_ERR_LOG("GetAudioScene failed : no memory");
766         NapiAudioError::ThrowError(env, "GetAudioScene failed : no memory", NAPI_ERR_NO_MEMORY);
767         return NapiParamUtils::GetUndefinedValue(env);
768     }
769 
770     context->GetCbInfo(env, info);
771 
772     auto executor = [context]() {
773         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
774         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
775         ObjectRefMap objectGuard(obj);
776         auto *napiAudioManager = objectGuard.GetPtr();
777         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
778             "audio manager state is error.");
779         AudioScene audioScene = napiAudioManager->audioMngr_->GetAudioScene();
780         if (audioScene == AUDIO_SCENE_VOICE_RINGING) {
781             audioScene = AUDIO_SCENE_RINGING;
782         }
783         context->intValue = audioScene;
784     };
785 
786     auto complete = [env, context](napi_value &output) {
787         NapiParamUtils::SetValueInt32(env, context->intValue, output);
788     };
789     return NapiAsyncWork::Enqueue(env, context, "GetAudioScene", executor, complete);
790 }
791 
GetAudioSceneSync(napi_env env,napi_callback_info info)792 napi_value NapiAudioManager::GetAudioSceneSync(napi_env env, napi_callback_info info)
793 {
794     AUDIO_INFO_LOG("GetRenderRateSync");
795     napi_value result = nullptr;
796     size_t argc = PARAM0;
797     auto *napiAudioManager = GetParamWithSync(env, info, argc, nullptr);
798     if (argc > PARAM0) {
799         NapiAudioError::ThrowError(env, NAPI_ERROR_INVALID_PARAM);
800         return result;
801     }
802     CHECK_AND_RETURN_RET_LOG(napiAudioManager != nullptr, result, "napiAudioManager is nullptr");
803     CHECK_AND_RETURN_RET_LOG(napiAudioManager->audioMngr_ != nullptr, result, "audioMngr_ is nullptr");
804     AudioScene audioScene = napiAudioManager->audioMngr_->GetAudioScene();
805     if (audioScene == AUDIO_SCENE_VOICE_RINGING) {
806         audioScene = AUDIO_SCENE_RINGING;
807     }
808     NapiParamUtils::SetValueInt32(env, audioScene, result);
809     return result;
810 }
811 
SetDeviceActive(napi_env env,napi_callback_info info)812 napi_value NapiAudioManager::SetDeviceActive(napi_env env, napi_callback_info info)
813 {
814     auto context = std::make_shared<AudioManagerAsyncContext>();
815     if (context == nullptr) {
816         AUDIO_ERR_LOG("SetDeviceActive failed : no memory");
817         NapiAudioError::ThrowError(env, "SetDeviceActive failed : no memory", NAPI_ERR_NO_MEMORY);
818         return NapiParamUtils::GetUndefinedValue(env);
819     }
820 
821     auto inputParser = [env, context](size_t argc, napi_value *argv) {
822         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_TWO, "invalid arguments",
823             NAPI_ERR_INVALID_PARAM);
824         context->status = NapiParamUtils::GetValueInt32(env, context->deviceType, argv[PARAM0]);
825         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get deviceType failed",
826             NAPI_ERR_INVALID_PARAM);
827         NAPI_CHECK_ARGS_RETURN_VOID(context, NapiAudioEnum::IsLegalInputArgumentActiveDeviceType(context->deviceType),
828             "invaild deviceType", NAPI_ERR_UNSUPPORTED);
829         context->status = NapiParamUtils::GetValueBoolean(env, context->isActive, argv[PARAM1]);
830         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get isActive failed",
831             NAPI_ERR_INVALID_PARAM);
832     };
833     context->GetCbInfo(env, info, inputParser);
834 
835     auto executor = [context]() {
836         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
837         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
838         ObjectRefMap objectGuard(obj);
839         auto *napiAudioManager = objectGuard.GetPtr();
840         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
841             "audio manager state is error.");
842         context->intValue = napiAudioManager->audioMngr_->SetDeviceActive(
843             static_cast<DeviceType>(context->deviceType), context->isActive);
844         NAPI_CHECK_ARGS_RETURN_VOID(context, context->intValue == SUCCESS, "SetDeviceActive failed",
845             NAPI_ERR_SYSTEM);
846     };
847 
848     auto complete = [env](napi_value &output) {
849         output = NapiParamUtils::GetUndefinedValue(env);
850     };
851     return NapiAsyncWork::Enqueue(env, context, "SetDeviceActive", executor, complete);
852 }
853 
IsDeviceActive(napi_env env,napi_callback_info info)854 napi_value NapiAudioManager::IsDeviceActive(napi_env env, napi_callback_info info)
855 {
856     auto context = std::make_shared<AudioManagerAsyncContext>();
857     if (context == nullptr) {
858         AUDIO_ERR_LOG("IsDeviceActive failed : no memory");
859         NapiAudioError::ThrowError(env, "IsDeviceActive failed : no memory", NAPI_ERR_NO_MEMORY);
860         return NapiParamUtils::GetUndefinedValue(env);
861     }
862 
863     auto inputParser = [env, context](size_t argc, napi_value *argv) {
864         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
865             NAPI_ERR_INVALID_PARAM);
866         context->status = NapiParamUtils::GetValueInt32(env, context->deviceType, argv[PARAM0]);
867         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get deviceType failed",
868             NAPI_ERR_INVALID_PARAM);
869         NAPI_CHECK_ARGS_RETURN_VOID(context, NapiAudioEnum::IsLegalInputArgumentActiveDeviceType(context->deviceType),
870             "invaild deviceType", NAPI_ERR_UNSUPPORTED);
871     };
872     context->GetCbInfo(env, info, inputParser);
873 
874     auto executor = [context]() {
875         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
876         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
877         ObjectRefMap objectGuard(obj);
878         auto *napiAudioManager = objectGuard.GetPtr();
879         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
880             "audio manager state is error.");
881         context->isActive = napiAudioManager->audioMngr_->IsDeviceActive(
882             static_cast<DeviceType>(context->deviceType));
883     };
884 
885     auto complete = [env, context](napi_value &output) {
886         NapiParamUtils::SetValueBoolean(env, context->isActive, output);
887     };
888     return NapiAsyncWork::Enqueue(env, context, "IsDeviceActive", executor, complete);
889 }
890 
SetAudioParameter(napi_env env,napi_callback_info info)891 napi_value NapiAudioManager::SetAudioParameter(napi_env env, napi_callback_info info)
892 {
893     auto context = std::make_shared<AudioManagerAsyncContext>();
894     if (context == nullptr) {
895         AUDIO_ERR_LOG("SetAudioParameter failed : no memory");
896         NapiAudioError::ThrowError(env, "SetAudioParameter failed : no memory", NAPI_ERR_NO_MEMORY);
897         return NapiParamUtils::GetUndefinedValue(env);
898     }
899 
900     auto inputParser = [env, context](size_t argc, napi_value *argv) {
901         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_TWO, "invalid arguments",
902             NAPI_ERR_INVALID_PARAM);
903         context->key = NapiParamUtils::GetStringArgument(env, argv[PARAM0]);
904         NAPI_CHECK_ARGS_RETURN_VOID(context, !context->key.empty(), "get key failed",
905             NAPI_ERR_INVALID_PARAM);
906         context->valueStr = NapiParamUtils::GetStringArgument(env, argv[PARAM1]);
907         NAPI_CHECK_ARGS_RETURN_VOID(context, !context->valueStr.empty(), "get valueStr failed",
908             NAPI_ERR_INVALID_PARAM);
909     };
910     context->GetCbInfo(env, info, inputParser);
911 
912     auto executor = [context]() {
913         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
914         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
915         ObjectRefMap objectGuard(obj);
916         auto *napiAudioManager = objectGuard.GetPtr();
917         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
918             "audio manager state is error.");
919         napiAudioManager->audioMngr_->SetAudioParameter(context->key, context->valueStr);
920     };
921 
922     auto complete = [env](napi_value &output) {
923         output = NapiParamUtils::GetUndefinedValue(env);
924     };
925     return NapiAsyncWork::Enqueue(env, context, "SetAudioParameter", executor, complete);
926 }
927 
GetAudioParameter(napi_env env,napi_callback_info info)928 napi_value NapiAudioManager::GetAudioParameter(napi_env env, napi_callback_info info)
929 {
930     auto context = std::make_shared<AudioManagerAsyncContext>();
931     if (context == nullptr) {
932         AUDIO_ERR_LOG("GetAudioParameter failed : no memory");
933         NapiAudioError::ThrowError(env, "GetAudioParameter failed : no memory", NAPI_ERR_NO_MEMORY);
934         return NapiParamUtils::GetUndefinedValue(env);
935     }
936 
937     auto inputParser = [env, context](size_t argc, napi_value *argv) {
938         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
939             NAPI_ERR_INVALID_PARAM);
940         context->key = NapiParamUtils::GetStringArgument(env, argv[PARAM0]);
941         NAPI_CHECK_ARGS_RETURN_VOID(context, !context->key.empty(), "get key failed",
942             NAPI_ERR_INVALID_PARAM);
943     };
944     context->GetCbInfo(env, info, inputParser);
945 
946     auto executor = [context]() {
947         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
948         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
949         ObjectRefMap objectGuard(obj);
950         auto *napiAudioManager = objectGuard.GetPtr();
951         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
952             "audio manager state is error.");
953         context->valueStr = napiAudioManager->audioMngr_->GetAudioParameter(context->key);
954     };
955 
956     auto complete = [env, context](napi_value &output) {
957         NapiParamUtils::SetValueString(env, context->valueStr, output);
958     };
959     return NapiAsyncWork::Enqueue(env, context, "GetAudioParameter", executor, complete);
960 }
961 
SetExtraParameters(napi_env env,napi_callback_info info)962 napi_value NapiAudioManager::SetExtraParameters(napi_env env, napi_callback_info info)
963 {
964     CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySelfPermission(),
965         NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED), "No system permission");
966 
967     auto context = std::make_shared<AudioManagerAsyncContext>();
968     if (context == nullptr) {
969         AUDIO_ERR_LOG("set extra parameters failed : no memory");
970         NapiAudioError::ThrowError(env, "SetExtraParameters failed : no memory", NAPI_ERR_NO_MEMORY);
971         return NapiParamUtils::GetUndefinedValue(env);
972     }
973 
974     auto inputParser = [env, context](size_t argc, napi_value *argv) {
975         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_TWO, "mandatory parameters are left unspecified",
976             NAPI_ERR_INPUT_INVALID);
977 
978         napi_valuetype valueType = napi_undefined;
979         napi_typeof(env, argv[PARAM0], &valueType);
980         NAPI_CHECK_ARGS_RETURN_VOID(context, valueType == napi_string,
981             "incorrect parameter types: The type of mainKey must be string", NAPI_ERR_INPUT_INVALID);
982         context->key = NapiParamUtils::GetStringArgument(env, argv[PARAM0]);
983 
984         napi_typeof(env, argv[PARAM1], &valueType);
985         NAPI_CHECK_ARGS_RETURN_VOID(context, valueType == napi_object,
986             "incorrect parameter types: The type of kvpairs must be Record<string, string>", NAPI_ERR_INPUT_INVALID);
987         context->status = NapiParamUtils::GetExtraParametersSubKV(env, context->subKvpairs, argv[PARAM1]);
988         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get sub key and value failed",
989             NAPI_ERR_INPUT_INVALID);
990     };
991     context->GetCbInfo(env, info, inputParser);
992     if (context->status != napi_ok) {
993         NapiAudioError::ThrowError(env, context->errCode, context->errMessage);
994         return NapiParamUtils::GetUndefinedValue(env);
995     }
996 
997     auto executor = [context]() {
998         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
999         auto obj = reinterpret_cast<NapiAudioManager *>(context->native);
1000         ObjectRefMap objectGuard(obj);
1001         auto *napiAudioManager = objectGuard.GetPtr();
1002         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context), "audio manager state is error.");
1003 
1004         NAPI_CHECK_ARGS_RETURN_VOID(context, !context->key.empty(),
1005             "parameter verification failed: get main key failed", NAPI_ERR_INVALID_PARAM);
1006         NAPI_CHECK_ARGS_RETURN_VOID(context, !context->subKvpairs.empty(),
1007             "parameter verification failed: sub key and value is empty", NAPI_ERR_INVALID_PARAM);
1008         context->intValue = napiAudioManager->audioMngr_->SetExtraParameters(context->key, context->subKvpairs);
1009         NAPI_CHECK_ARGS_RETURN_VOID(context, context->intValue != ERR_PERMISSION_DENIED, "permission denied",
1010             NAPI_ERR_NO_PERMISSION);
1011         NAPI_CHECK_ARGS_RETURN_VOID(context, context->intValue == SUCCESS, "SetExtraParameters failed",
1012             NAPI_ERR_INVALID_PARAM);
1013     };
1014 
1015     auto complete = [env](napi_value &output) {
1016         output = NapiParamUtils::GetUndefinedValue(env);
1017     };
1018     return NapiAsyncWork::Enqueue(env, context, "SetExtraParameters", executor, complete);
1019 }
1020 
GetExtraParameters(napi_env env,napi_callback_info info)1021 napi_value NapiAudioManager::GetExtraParameters(napi_env env, napi_callback_info info)
1022 {
1023     CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySelfPermission(),
1024         NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED), "No system permission");
1025 
1026     auto context = std::make_shared<AudioManagerAsyncContext>();
1027     if (context == nullptr) {
1028         AUDIO_ERR_LOG("get extra parameters failed : no memory");
1029         NapiAudioError::ThrowError(env, "GetExtraParameters failed : no memory", NAPI_ERR_NO_MEMORY);
1030         return NapiParamUtils::GetUndefinedValue(env);
1031     }
1032 
1033     auto inputParser = [env, context](size_t argc, napi_value *argv) {
1034         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "mandatory parameters are left unspecified",
1035             NAPI_ERR_INPUT_INVALID);
1036 
1037         napi_valuetype valueType = napi_undefined;
1038         napi_typeof(env, argv[PARAM0], &valueType);
1039         NAPI_CHECK_ARGS_RETURN_VOID(context, valueType == napi_string,
1040             "incorrect parameter types: The type of mainKey must be string", NAPI_ERR_INPUT_INVALID);
1041         context->key = NapiParamUtils::GetStringArgument(env, argv[PARAM0]);
1042 
1043         if (argc > ARGS_ONE) {
1044             napi_typeof(env, argv[PARAM1], &valueType);
1045             NAPI_CHECK_ARGS_RETURN_VOID(context, valueType == napi_object,
1046                 "incorrect parameter types: The type of kvpairs must be Record<string, string>",
1047                 NAPI_ERR_INPUT_INVALID);
1048             context->status = NapiParamUtils::GetExtraParametersVector(env, context->subKeys, argv[PARAM1]);
1049             NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok,
1050                 "parameter verification failed: get sub key and value failed", NAPI_ERR_INVALID_PARAM);
1051         }
1052     };
1053     context->GetCbInfo(env, info, inputParser);
1054     if (context->status != napi_ok) {
1055         NapiAudioError::ThrowError(env, context->errCode, context->errMessage);
1056         return NapiParamUtils::GetUndefinedValue(env);
1057     }
1058 
1059     auto executor = [context]() {
1060         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
1061         auto obj = reinterpret_cast<NapiAudioManager *>(context->native);
1062         ObjectRefMap objectGuard(obj);
1063         auto *napiAudioManager = objectGuard.GetPtr();
1064         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context), "audio manager state is error.");
1065 
1066         NAPI_CHECK_ARGS_RETURN_VOID(context, !context->key.empty(),
1067             "parameter verification failed: get main key failed", NAPI_ERR_INVALID_PARAM);
1068         context->intValue = napiAudioManager->audioMngr_->GetExtraParameters(
1069             context->key, context->subKeys, context->subKvpairs);
1070         NAPI_CHECK_ARGS_RETURN_VOID(context, context->intValue == SUCCESS, "GetExtraParameters failed",
1071             NAPI_ERR_INVALID_PARAM);
1072     };
1073 
1074     auto complete = [env, context](napi_value &output) {
1075         NapiParamUtils::SetExtraAudioParametersInfo(env, context->subKvpairs, output);
1076     };
1077     return NapiAsyncWork::Enqueue(env, context, "GetExtraParameters", executor, complete);
1078 }
1079 
SetMicrophoneMute(napi_env env,napi_callback_info info)1080 napi_value NapiAudioManager::SetMicrophoneMute(napi_env env, napi_callback_info info)
1081 {
1082     auto context = std::make_shared<AudioManagerAsyncContext>();
1083     if (context == nullptr) {
1084         AUDIO_ERR_LOG("SetMicrophoneMute failed : no memory");
1085         NapiAudioError::ThrowError(env, "SetMicrophoneMute failed : no memory", NAPI_ERR_NO_MEMORY);
1086         return NapiParamUtils::GetUndefinedValue(env);
1087     }
1088 
1089     auto inputParser = [env, context](size_t argc, napi_value *argv) {
1090         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
1091             NAPI_ERR_INVALID_PARAM);
1092         context->status = NapiParamUtils::GetValueBoolean(env, context->isMute, argv[PARAM0]);
1093         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get isMute failed",
1094             NAPI_ERR_INVALID_PARAM);
1095     };
1096     context->GetCbInfo(env, info, inputParser);
1097 
1098     auto executor = [context]() {
1099         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
1100         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
1101         ObjectRefMap objectGuard(obj);
1102         auto *napiAudioManager = objectGuard.GetPtr();
1103         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
1104             "audio manager state is error.");
1105         context->intValue = napiAudioManager->audioMngr_->SetMicrophoneMute(context->isMute);
1106         NAPI_CHECK_ARGS_RETURN_VOID(context, context->intValue == SUCCESS, "SetMicrophoneMute failed",
1107             NAPI_ERR_SYSTEM);
1108     };
1109 
1110     auto complete = [env](napi_value &output) {
1111         output = NapiParamUtils::GetUndefinedValue(env);
1112     };
1113     return NapiAsyncWork::Enqueue(env, context, "SetMicrophoneMute", executor, complete);
1114 }
1115 
IsMicrophoneMute(napi_env env,napi_callback_info info)1116 napi_value NapiAudioManager::IsMicrophoneMute(napi_env env, napi_callback_info info)
1117 {
1118     auto context = std::make_shared<AudioManagerAsyncContext>();
1119     if (context == nullptr) {
1120         AUDIO_ERR_LOG("IsMicrophoneMute failed : no memory");
1121         NapiAudioError::ThrowError(env, "IsMicrophoneMute failed : no memory", NAPI_ERR_NO_MEMORY);
1122         return NapiParamUtils::GetUndefinedValue(env);
1123     }
1124 
1125     context->GetCbInfo(env, info);
1126 
1127     auto executor = [context]() {
1128         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
1129         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
1130         ObjectRefMap objectGuard(obj);
1131         auto *napiAudioManager = objectGuard.GetPtr();
1132         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
1133             "audio manager state is error.");
1134         context->isMute = napiAudioManager->audioMngr_->IsMicrophoneMute();
1135     };
1136 
1137     auto complete = [env, context](napi_value &output) {
1138         NapiParamUtils::SetValueBoolean(env, context->isMute, output);
1139     };
1140     return NapiAsyncWork::Enqueue(env, context, "IsMicrophoneMute", executor, complete);
1141 }
1142 
RequestIndependentInterrupt(napi_env env,napi_callback_info info)1143 napi_value NapiAudioManager::RequestIndependentInterrupt(napi_env env, napi_callback_info info)
1144 {
1145     auto context = std::make_shared<AudioManagerAsyncContext>();
1146     if (context == nullptr) {
1147         AUDIO_ERR_LOG("RequestIndependentInterrupt failed : no memory");
1148         NapiAudioError::ThrowError(env, "RequestIndependentInterrupt failed : no memory",
1149             NAPI_ERR_NO_MEMORY);
1150         return NapiParamUtils::GetUndefinedValue(env);
1151     }
1152 
1153     auto inputParser = [env, context](size_t argc, napi_value *argv) {
1154         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
1155             NAPI_ERR_INVALID_PARAM);
1156         context->status = NapiParamUtils::GetValueInt32(env, context->focusType, argv[PARAM0]);
1157         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get focusType failed",
1158             NAPI_ERR_INVALID_PARAM);
1159     };
1160     context->GetCbInfo(env, info, inputParser);
1161 
1162     auto executor = [context]() {
1163         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
1164         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
1165         ObjectRefMap objectGuard(obj);
1166         auto *napiAudioManager = objectGuard.GetPtr();
1167         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
1168             "audio manager state is error.");
1169         context->isTrue = napiAudioManager->audioMngr_->RequestIndependentInterrupt(
1170             NapiAudioEnum::GetNativeFocusType(context->focusType));
1171     };
1172 
1173     auto complete = [env, context](napi_value &output) {
1174         NapiParamUtils::SetValueBoolean(env, context->isTrue, output);
1175     };
1176     return NapiAsyncWork::Enqueue(env, context, "RequestIndependentInterrupt", executor, complete);
1177 }
1178 
AbandonIndependentInterrupt(napi_env env,napi_callback_info info)1179 napi_value NapiAudioManager::AbandonIndependentInterrupt(napi_env env, napi_callback_info info)
1180 {
1181     auto context = std::make_shared<AudioManagerAsyncContext>();
1182     if (context == nullptr) {
1183         AUDIO_ERR_LOG("AbandonIndependentInterrupt failed : no memory");
1184         NapiAudioError::ThrowError(env, "AbandonIndependentInterrupt failed : no memory",
1185             NAPI_ERR_NO_MEMORY);
1186         return NapiParamUtils::GetUndefinedValue(env);
1187     }
1188 
1189     auto inputParser = [env, context](size_t argc, napi_value *argv) {
1190         NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
1191             NAPI_ERR_INVALID_PARAM);
1192         context->status = NapiParamUtils::GetValueInt32(env, context->focusType, argv[PARAM0]);
1193         NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get focusType failed",
1194             NAPI_ERR_INVALID_PARAM);
1195     };
1196     context->GetCbInfo(env, info, inputParser);
1197 
1198     auto executor = [context]() {
1199         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
1200         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
1201         ObjectRefMap objectGuard(obj);
1202         auto *napiAudioManager = objectGuard.GetPtr();
1203         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
1204             "audio manager state is error.");
1205         context->isTrue = napiAudioManager->audioMngr_->AbandonIndependentInterrupt(
1206             NapiAudioEnum::GetNativeFocusType(context->focusType));
1207     };
1208 
1209     auto complete = [env, context](napi_value &output) {
1210         NapiParamUtils::SetValueBoolean(env, context->isTrue, output);
1211     };
1212     return NapiAsyncWork::Enqueue(env, context, "AbandonIndependentInterrupt", executor, complete);
1213 }
1214 
DisableSafeMediaVolume(napi_env env,napi_callback_info info)1215 napi_value NapiAudioManager::DisableSafeMediaVolume(napi_env env, napi_callback_info info)
1216 {
1217     auto context = std::make_shared<AudioManagerAsyncContext>();
1218     if (context == nullptr) {
1219         AUDIO_ERR_LOG("failed : no memory");
1220         NapiAudioError::ThrowError(env, "DisableSafeMediaVolume failed : no memory",
1221             NAPI_ERR_NO_MEMORY);
1222         return NapiParamUtils::GetUndefinedValue(env);
1223     }
1224 
1225     context->GetCbInfo(env, info);
1226 
1227     auto executor = [context]() {
1228         CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
1229         auto obj = reinterpret_cast<NapiAudioManager*>(context->native);
1230         ObjectRefMap objectGuard(obj);
1231         auto *napiAudioManager = objectGuard.GetPtr();
1232         CHECK_AND_RETURN_LOG(CheckAudioManagerStatus(napiAudioManager, context),
1233             "audio manager state is error.");
1234         context->intValue = napiAudioManager->audioMngr_->DisableSafeMediaVolume();
1235         if (context->intValue == ERR_PERMISSION_DENIED) {
1236             context->SignError(NAPI_ERR_NO_PERMISSION);
1237         } else if (context->intValue == ERR_SYSTEM_PERMISSION_DENIED) {
1238             context->SignError(NAPI_ERR_PERMISSION_DENIED);
1239         }
1240     };
1241 
1242     auto complete = [env](napi_value &output) {
1243         output = NapiParamUtils::GetUndefinedValue(env);
1244     };
1245     return NapiAsyncWork::Enqueue(env, context, "DisableSafeMediaVolume", executor, complete);
1246 }
1247 
RegisterCallback(napi_env env,napi_value jsThis,napi_value * argv,const std::string & cbName)1248 napi_value NapiAudioManager::RegisterCallback(napi_env env, napi_value jsThis,
1249     napi_value *argv, const std::string &cbName)
1250 {
1251     napi_value undefinedResult = nullptr;
1252     NapiAudioManager *napiAudioManager = nullptr;
1253     napi_status status = napi_unwrap(env, jsThis, reinterpret_cast<void **>(&napiAudioManager));
1254     CHECK_AND_RETURN_RET_LOG(status == napi_ok,
1255         NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_SYSTEM), "status error");
1256     CHECK_AND_RETURN_RET_LOG(napiAudioManager != nullptr, NapiAudioError::ThrowErrorAndReturn(env,
1257         NAPI_ERR_NO_MEMORY), "napiAudioManager is nullptr");
1258     CHECK_AND_RETURN_RET_LOG(napiAudioManager->audioMngr_ != nullptr, NapiAudioError::ThrowErrorAndReturn(
1259         env, NAPI_ERR_NO_MEMORY), "audioMngr_ is nullptr");
1260 
1261     if (!cbName.compare(INTERRUPT_CALLBACK_NAME)) {
1262         RegisterInterruptCallback(env, argv, napiAudioManager);
1263     } else if (!cbName.compare(RINGERMODE_CALLBACK_NAME)) {
1264         RegisterRingerModeCallback(env, argv, napiAudioManager);
1265     } else if (!cbName.compare(VOLUME_CHANGE_CALLBACK_NAME)) {
1266         AUDIO_INFO_LOG("enter RegisterVolumeChangeCallback");
1267         RegisterVolumeChangeCallback(env, argv, napiAudioManager);
1268     } else if (!cbName.compare(DEVICE_CHANGE_CALLBACK_NAME)) {
1269         RegisterDeviceChangeCallback(env, argv, napiAudioManager);
1270     }
1271     return undefinedResult;
1272 }
1273 
RegisterInterruptCallback(napi_env env,const T & argv,NapiAudioManager * napiAudioManager)1274 template<typename T> void NapiAudioManager::RegisterInterruptCallback(napi_env env, const T &argv,
1275     NapiAudioManager *napiAudioManager)
1276 {
1277     napi_valuetype paramArg1 = napi_undefined;
1278     napi_typeof(env, argv[PARAM1], &paramArg1);
1279     napi_valuetype handler = napi_undefined;
1280     if (paramArg1 != napi_object) {
1281         AUDIO_ERR_LOG("NapiAudioManager::On Type mismatch for parameter 2");
1282         NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID);
1283         return;
1284     }
1285     if (napi_typeof(env, argv[PARAM2], &handler) != napi_ok || handler != napi_function) {
1286         AUDIO_ERR_LOG("NapiAudioManager::On type mismatch for parameter 3");
1287         NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID);
1288         return;
1289     }
1290     if (napiAudioManager->interruptCallbackNapi_ == nullptr) {
1291         napiAudioManager->interruptCallbackNapi_ = std::make_shared<NapiAudioManagerInterruptCallback>(env);
1292         int32_t ret = napiAudioManager->audioMngr_->
1293             SetAudioManagerInterruptCallback(napiAudioManager->interruptCallbackNapi_);
1294         CHECK_AND_RETURN_LOG(ret == SUCCESS, "SetAudioManagerInterruptCallback Failed");
1295     }
1296     std::lock_guard<std::mutex> lock(napiAudioManager->interruptCallbackNapi_->cbMutex_);
1297     std::shared_ptr<NapiAudioManagerInterruptCallback> cb =
1298         std::static_pointer_cast<NapiAudioManagerInterruptCallback>(napiAudioManager->interruptCallbackNapi_);
1299     cb->SaveCallbackReference(INTERRUPT_CALLBACK_NAME, argv[PARAM2]);
1300     if (!cb->GetManagerInterruptTsfnFlag()) {
1301         cb->CreateManagerInterruptTsfn(env);
1302     }
1303     AudioInterrupt audioInterrupt;
1304     NapiParamUtils::GetAudioInterrupt(env, audioInterrupt, argv[PARAM1]);
1305     int32_t ret = napiAudioManager->audioMngr_->RequestAudioFocus(audioInterrupt);
1306     CHECK_AND_RETURN_LOG(ret == SUCCESS, "RequestAudioFocus Failed");
1307     AUDIO_INFO_LOG("SetAudioManagerInterruptCallback and RequestAudioFocus is successful");
1308 }
1309 
RegisterRingerModeCallback(napi_env env,const T & argv,NapiAudioManager * napiAudioManager)1310 template<typename T> void NapiAudioManager::RegisterRingerModeCallback(napi_env env, const T &argv,
1311     NapiAudioManager *napiAudioManager)
1312 {
1313     if (napiAudioManager->ringerModecallbackNapi_ == nullptr) {
1314         napiAudioManager->ringerModecallbackNapi_ = std::make_shared<NapiAudioRingerModeCallback>(env);
1315         int32_t ret = napiAudioManager->audioMngr_->SetRingerModeCallback(
1316             napiAudioManager->cachedClientId_, napiAudioManager->ringerModecallbackNapi_);
1317         CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, NapiAudioError::ThrowError(env, ret),
1318             "SetRingerModeCallback Failed %{public}d", ret);
1319     }
1320 
1321     std::shared_ptr<NapiAudioRingerModeCallback> cb =
1322         std::static_pointer_cast<NapiAudioRingerModeCallback>(napiAudioManager->ringerModecallbackNapi_);
1323     cb->SaveCallbackReference(RINGERMODE_CALLBACK_NAME, argv[PARAM1]);
1324     if (!cb->GetRingModeTsfnFlag()) {
1325         cb->CreateRingModeTsfn(env);
1326     }
1327 }
1328 
RegisterVolumeChangeCallback(napi_env env,const T & argv,NapiAudioManager * napiAudioManager)1329 template<typename T> void NapiAudioManager::RegisterVolumeChangeCallback(napi_env env, const T &argv,
1330     NapiAudioManager *napiAudioManager)
1331 {
1332     if (napiAudioManager->volumeKeyEventCallbackNapi_ == nullptr) {
1333         napiAudioManager->volumeKeyEventCallbackNapi_ = std::make_shared<NapiAudioVolumeKeyEvent>(env);
1334         int32_t ret = napiAudioManager->audioMngr_->RegisterVolumeKeyEventCallback(napiAudioManager->cachedClientId_,
1335             napiAudioManager->volumeKeyEventCallbackNapi_, API_8);
1336         CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, NapiAudioError::ThrowError(env, ret),
1337             "RegisterVolumeKeyEventCallback Failed %{public}d", ret);
1338     }
1339     std::shared_ptr<NapiAudioVolumeKeyEvent> cb =
1340         std::static_pointer_cast<NapiAudioVolumeKeyEvent>(napiAudioManager->volumeKeyEventCallbackNapi_);
1341     cb->SaveCallbackReference(VOLUME_CHANGE_CALLBACK_NAME, argv[PARAM1]);
1342     if (!cb->GetVolumeTsfnFlag()) {
1343         cb->CreateVolumeTsfn(env);
1344     }
1345 }
1346 
RegisterDeviceChangeCallback(napi_env env,const T & argv,NapiAudioManager * napiAudioManager)1347 template<typename T> void NapiAudioManager::RegisterDeviceChangeCallback(napi_env env, const T &argv,
1348     NapiAudioManager *napiAudioManager)
1349 {
1350     if (napiAudioManager->deviceChangeCallbackNapi_ == nullptr) {
1351         napiAudioManager->deviceChangeCallbackNapi_ = std::make_shared<NapiAudioManagerCallback>(env);
1352     }
1353     int32_t ret = napiAudioManager->audioMngr_->SetDeviceChangeCallback(DeviceFlag::ALL_DEVICES_FLAG,
1354         napiAudioManager->deviceChangeCallbackNapi_);
1355     CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, NapiAudioError::ThrowError(env, ret),
1356         "NapiAudioManager: SetDeviceChangeCallback Failed %{public}d", ret);
1357     std::shared_ptr<NapiAudioManagerCallback> cb =
1358         std::static_pointer_cast<NapiAudioManagerCallback>(napiAudioManager->deviceChangeCallbackNapi_);
1359     cb->SaveAudioManagerDeviceChangeCbRef(DeviceFlag::ALL_DEVICES_FLAG, argv[PARAM1]);
1360     if (!cb->GetDevChgTsfnFlag()) {
1361         cb->CreateDevChgTsfn(env);
1362     }
1363 }
1364 
On(napi_env env,napi_callback_info info)1365 napi_value NapiAudioManager::On(napi_env env, napi_callback_info info)
1366 {
1367     napi_value undefinedResult = nullptr;
1368     NapiParamUtils::GetUndefinedValue(env);
1369 
1370     constexpr size_t minArgCount = ARGS_TWO;
1371     size_t argCount = ARGS_THREE;
1372     napi_value argv[minArgCount + PARAM1] = {nullptr, nullptr, nullptr};
1373     napi_value jsThis = nullptr;
1374     napi_status status = napi_get_cb_info(env, info, &argCount, argv, &jsThis, nullptr);
1375     if (status != napi_ok || argCount < minArgCount) {
1376         AUDIO_ERR_LOG("On fail to napi_get_cb_info/Requires min 2 parameters");
1377         NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID);
1378         return undefinedResult;
1379     }
1380 
1381     napi_valuetype eventType = napi_undefined;
1382     if (napi_typeof(env, argv[PARAM0], &eventType) != napi_ok || eventType != napi_string) {
1383         NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID);
1384         return undefinedResult;
1385     }
1386     std::string callbackName = NapiParamUtils::GetStringArgument(env, argv[PARAM0]);
1387     AUDIO_INFO_LOG("On callbackName: %{public}s", callbackName.c_str());
1388 
1389     if (argCount == minArgCount) {
1390         napi_valuetype handler = napi_undefined;
1391         if (napi_typeof(env, argv[PARAM1], &handler) != napi_ok || handler != napi_function) {
1392             AUDIO_ERR_LOG("NapiAudioManager::On type mismatch for parameter 2");
1393             NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID);
1394             return undefinedResult;
1395         }
1396     }
1397 
1398     return RegisterCallback(env, jsThis, argv, callbackName);
1399 }
1400 
UnregisterInterruptCallback(napi_env env,const T & argv,const size_t argCount,NapiAudioManager * napiAudioManager)1401 template<typename T> void NapiAudioManager::UnregisterInterruptCallback(napi_env env, const T &argv,
1402     const size_t argCount, NapiAudioManager *napiAudioManager)
1403 {
1404     napi_valuetype paramArg1 = napi_undefined;
1405     napi_valuetype handler = napi_undefined;
1406     if (napi_typeof(env, argv[PARAM1], &paramArg1) != napi_ok || paramArg1 != napi_object) {
1407         AUDIO_ERR_LOG("Off type mismatch for parameter 2");
1408         NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID);
1409         return;
1410     }
1411     if ((argCount == ARGS_THREE) &&
1412         (napi_typeof(env, argv[PARAM2], &handler) != napi_ok || handler != napi_function)) {
1413         AUDIO_ERR_LOG("Off type mismatch for parameter 3");
1414         NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID);
1415         return;
1416     }
1417     int32_t callbackCount = PARAM0;
1418     if (napiAudioManager->interruptCallbackNapi_ != nullptr) {
1419         std::shared_ptr<NapiAudioManagerInterruptCallback> cb =
1420             std::static_pointer_cast<NapiAudioManagerInterruptCallback>(napiAudioManager->interruptCallbackNapi_);
1421         if (argCount == ARGS_TWO) {
1422             cb->RemoveAllCallbackReferences(INTERRUPT_CALLBACK_NAME);
1423         } else if (argCount == ARGS_THREE) {
1424             cb->RemoveCallbackReference(INTERRUPT_CALLBACK_NAME, argv[PARAM2]);
1425         }
1426         callbackCount = cb->GetInterruptCallbackListSize();
1427     }
1428     AUDIO_INFO_LOG("Remove Callback Reference success");
1429     if (callbackCount == PARAM0) {
1430         AudioInterrupt audioInterrupt;
1431         NapiParamUtils::GetAudioInterrupt(env, audioInterrupt, argv[PARAM1]);
1432         int32_t ret = napiAudioManager->audioMngr_->AbandonAudioFocus(audioInterrupt);
1433         if (ret) {
1434             AUDIO_ERR_LOG("Off AbandonAudioFocus Failed");
1435         }
1436         ret = napiAudioManager->audioMngr_->UnsetAudioManagerInterruptCallback();
1437         CHECK_AND_RETURN_LOG(ret == SUCCESS,
1438             "Off UnsetAudioManagerInterruptCallback Failed");
1439         if (napiAudioManager->interruptCallbackNapi_ != nullptr) {
1440             std::lock_guard<std::mutex> lock(napiAudioManager->interruptCallbackNapi_->cbMutex_);
1441             napiAudioManager->interruptCallbackNapi_.reset();
1442             napiAudioManager->interruptCallbackNapi_ = nullptr;
1443         }
1444         AUDIO_INFO_LOG("Off Abandon Focus and UnsetAudioInterruptCallback success");
1445     }
1446 }
1447 
UnregisterDeviceChangeCallback(napi_env env,napi_value callback,NapiAudioManager * audioMgrNapi)1448 void NapiAudioManager::UnregisterDeviceChangeCallback(napi_env env, napi_value callback,
1449     NapiAudioManager *audioMgrNapi)
1450 {
1451     if (audioMgrNapi == nullptr) {
1452         AUDIO_ERR_LOG("audioMgrNapi is nullptr");
1453         return;
1454     }
1455     CHECK_AND_RETURN_LOG(audioMgrNapi->deviceChangeCallbackNapi_ != nullptr,
1456         "UnregisterDeviceChangeCallback: audio manager deviceChangeCallbackNapi_ is null");
1457     std::shared_ptr<NapiAudioManagerCallback> cb =
1458         std::static_pointer_cast<NapiAudioManagerCallback>(audioMgrNapi->deviceChangeCallbackNapi_);
1459     if (callback != nullptr) {
1460         cb->RemoveAudioManagerDeviceChangeCbRef(env, callback);
1461     }
1462     if (callback == nullptr || cb->GetAudioManagerDeviceChangeCbListSize() == 0) {
1463         int32_t ret = audioMgrNapi->audioMngr_->UnsetDeviceChangeCallback(DeviceFlag::ALL_DEVICES_FLAG);
1464         CHECK_AND_RETURN_LOG(ret == SUCCESS, "UnsetDeviceChangeCallback Failed");
1465         audioMgrNapi->deviceChangeCallbackNapi_.reset();
1466         audioMgrNapi->deviceChangeCallbackNapi_ = nullptr;
1467         cb->RemoveAllAudioManagerDeviceChangeCb();
1468     }
1469 }
1470 
Off(napi_env env,napi_callback_info info)1471 napi_value NapiAudioManager::Off(napi_env env, napi_callback_info info)
1472 {
1473     napi_value undefinedResult = nullptr;
1474     NapiParamUtils::GetUndefinedValue(env);
1475 
1476     constexpr size_t minArgCount = ARGS_ONE;
1477     size_t argCount = ARGS_THREE;
1478     napi_value argv[minArgCount + PARAM2] = {nullptr, nullptr, nullptr};
1479     napi_value jsThis = nullptr;
1480     napi_status status = napi_get_cb_info(env, info, &argCount, argv, &jsThis, nullptr);
1481     if (status != napi_ok || argCount < minArgCount) {
1482         AUDIO_ERR_LOG("Off fail to napi_get_cb_info/Requires min 1 parameters");
1483         NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID);
1484         return undefinedResult;
1485     }
1486 
1487     napi_valuetype eventType = napi_undefined;
1488     if (napi_typeof(env, argv[PARAM0], &eventType) != napi_ok || eventType != napi_string) {
1489         NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID);
1490         return undefinedResult;
1491     }
1492     std::string callbackName = NapiParamUtils::GetStringArgument(env, argv[PARAM0]);
1493     AUDIO_INFO_LOG("Off callbackName: %{public}s", callbackName.c_str());
1494 
1495     NapiAudioManager *napiAudioManager = nullptr;
1496     status = napi_unwrap(env, jsThis, reinterpret_cast<void **>(&napiAudioManager));
1497 
1498     if (!callbackName.compare(INTERRUPT_CALLBACK_NAME) && argCount > ARGS_ONE) {
1499         UnregisterInterruptCallback(env, argv, argCount, napiAudioManager);
1500     } else if (!callbackName.compare(DEVICE_CHANGE_CALLBACK_NAME)) {
1501         UnregisterDeviceChangeCallback(env, argv[PARAM1], napiAudioManager);
1502     } else {
1503         NapiAudioError::ThrowError(env, NAPI_ERR_INVALID_PARAM);
1504     }
1505     return undefinedResult;
1506 }
1507 }  // namespace AudioStandard
1508 }  // namespace OHOS