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