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