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 "NapiAudioVolumeManager"
17 #endif
18
19 #include "napi_audio_volume_manager.h"
20 #include "napi_audio_volume_group_manager.h"
21 #include "napi_appvolume_change_callback.h"
22 #include "napi_audio_enum.h"
23 #include "napi_audio_error.h"
24 #include "napi_param_utils.h"
25 #include "audio_errors.h"
26 #include "audio_manager_log.h"
27
28 namespace OHOS {
29 namespace AudioStandard {
30 static __thread napi_ref g_volumeManagerConstructor = nullptr;
31
NapiAudioVolumeManager()32 NapiAudioVolumeManager::NapiAudioVolumeManager()
33 : audioSystemMngr_(nullptr), env_(nullptr) {}
34
35 NapiAudioVolumeManager::~NapiAudioVolumeManager() = default;
36
CheckContextStatus(std::shared_ptr<AudioVolumeManagerAsyncContext> context)37 bool NapiAudioVolumeManager::CheckContextStatus(std::shared_ptr<AudioVolumeManagerAsyncContext> context)
38 {
39 CHECK_AND_RETURN_RET_LOG(context != nullptr, false, "context object is nullptr.");
40 if (context->native == nullptr) {
41 context->SignError(NAPI_ERR_SYSTEM);
42 AUDIO_ERR_LOG("context object state is error.");
43 return false;
44 }
45 return true;
46 }
47
CheckAudioVolumeManagerStatus(NapiAudioVolumeManager * napi,std::shared_ptr<AudioVolumeManagerAsyncContext> context)48 bool NapiAudioVolumeManager::CheckAudioVolumeManagerStatus(NapiAudioVolumeManager *napi,
49 std::shared_ptr<AudioVolumeManagerAsyncContext> context)
50 {
51 CHECK_AND_RETURN_RET_LOG(napi != nullptr, false, "napi object is nullptr.");
52 if (napi->audioSystemMngr_ == nullptr) {
53 context->SignError(NAPI_ERR_SYSTEM);
54 AUDIO_ERR_LOG("context object state is error.");
55 return false;
56 }
57 return true;
58 }
59
GetParamWithSync(const napi_env & env,napi_callback_info info,size_t & argc,napi_value * args)60 NapiAudioVolumeManager* NapiAudioVolumeManager::GetParamWithSync(const napi_env &env, napi_callback_info info,
61 size_t &argc, napi_value *args)
62 {
63 NapiAudioVolumeManager *napiAudioVolumeManager = nullptr;
64 napi_value jsThis = nullptr;
65
66 napi_status status = napi_get_cb_info(env, info, &argc, args, &jsThis, nullptr);
67 CHECK_AND_RETURN_RET_LOG(status == napi_ok && jsThis != nullptr, nullptr,
68 "GetParamWithSync fail to napi_get_cb_info");
69
70 status = napi_unwrap(env, jsThis, (void **)&napiAudioVolumeManager);
71 CHECK_AND_RETURN_RET_LOG(status == napi_ok, nullptr, "napi_unwrap failed");
72 CHECK_AND_RETURN_RET_LOG(napiAudioVolumeManager != nullptr && napiAudioVolumeManager->audioSystemMngr_ !=
73 nullptr, napiAudioVolumeManager, "GetParamWithSync fail to napi_unwrap");
74 return napiAudioVolumeManager;
75 }
76
Destructor(napi_env env,void * nativeObject,void * finalizeHint)77 void NapiAudioVolumeManager::Destructor(napi_env env, void *nativeObject, void *finalizeHint)
78 {
79 if (nativeObject == nullptr) {
80 AUDIO_WARNING_LOG("Native object is null");
81 return;
82 }
83 auto obj = static_cast<NapiAudioVolumeManager *>(nativeObject);
84 ObjectRefMap<NapiAudioVolumeManager>::DecreaseRef(obj);
85 AUDIO_INFO_LOG("Decrease obj count");
86 }
87
Construct(napi_env env,napi_callback_info info)88 napi_value NapiAudioVolumeManager::Construct(napi_env env, napi_callback_info info)
89 {
90 AUDIO_PRERELEASE_LOGI("Construct");
91 napi_status status;
92 napi_value result = nullptr;
93 napi_get_undefined(env, &result);
94
95 size_t argc = ARGS_TWO;
96 napi_value argv[ARGS_TWO] = {0};
97 napi_value thisVar = nullptr;
98 void *data = nullptr;
99
100 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
101 std::unique_ptr<NapiAudioVolumeManager> napiAudioVolumeManager = std::make_unique<NapiAudioVolumeManager>();
102 CHECK_AND_RETURN_RET_LOG(napiAudioVolumeManager != nullptr, result, "No memory");
103
104 napiAudioVolumeManager->audioSystemMngr_ = AudioSystemManager::GetInstance();
105 napiAudioVolumeManager->env_ = env;
106 napiAudioVolumeManager->cachedClientId_ = getpid();
107 ObjectRefMap<NapiAudioVolumeManager>::Insert(napiAudioVolumeManager.get());
108
109 status = napi_wrap(env, thisVar, static_cast<void*>(napiAudioVolumeManager.get()),
110 NapiAudioVolumeManager::Destructor, nullptr, nullptr);
111 if (status != napi_ok) {
112 ObjectRefMap<NapiAudioVolumeManager>::Erase(napiAudioVolumeManager.get());
113 return result;
114 }
115 napiAudioVolumeManager.release();
116 return thisVar;
117 }
118
CreateVolumeManagerWrapper(napi_env env)119 napi_value NapiAudioVolumeManager::CreateVolumeManagerWrapper(napi_env env)
120 {
121 napi_status status;
122 napi_value result = nullptr;
123 napi_value constructor;
124
125 status = napi_get_reference_value(env, g_volumeManagerConstructor, &constructor);
126 if (status != napi_ok) {
127 AUDIO_ERR_LOG("Failed in CreateVolumeManagerWrapper, %{public}d", status);
128 goto fail;
129 }
130 status = napi_new_instance(env, constructor, PARAM0, nullptr, &result);
131 if (status != napi_ok) {
132 AUDIO_ERR_LOG("napi_new_instance failed, status:%{public}d", status);
133 goto fail;
134 }
135 return result;
136
137 fail:
138 napi_get_undefined(env, &result);
139 return result;
140 }
141
Init(napi_env env,napi_value exports)142 napi_value NapiAudioVolumeManager::Init(napi_env env, napi_value exports)
143 {
144 napi_status status;
145 napi_value constructor;
146 napi_value result = nullptr;
147 const int32_t refCount = ARGS_ONE;
148 napi_get_undefined(env, &result);
149
150 napi_property_descriptor audio_volume_manager_properties[] = {
151 DECLARE_NAPI_FUNCTION("getVolumeGroupInfos", GetVolumeGroupInfos),
152 DECLARE_NAPI_FUNCTION("getVolumeGroupInfosSync", GetVolumeGroupInfosSync),
153 DECLARE_NAPI_FUNCTION("getVolumeGroupManager", GetVolumeGroupManager),
154 DECLARE_NAPI_FUNCTION("getVolumeGroupManagerSync", GetVolumeGroupManagerSync),
155 DECLARE_NAPI_FUNCTION("setAppVolumePercentage", SetAppVolumePercentage),
156 DECLARE_NAPI_FUNCTION("setAppVolumePercentageForUid", SetAppVolumePercentageForUid),
157 DECLARE_NAPI_FUNCTION("getAppVolumePercentage", GetAppVolumePercentage),
158 DECLARE_NAPI_FUNCTION("getAppVolumePercentageForUid", GetAppVolumePercentageForUid),
159 DECLARE_NAPI_FUNCTION("setAppVolumeMutedForUid", SetAppVolumeMutedForUid),
160 DECLARE_NAPI_FUNCTION("isAppVolumeMutedForUid", IsAppVolumeMutedForUid),
161 DECLARE_NAPI_FUNCTION("on", On),
162 DECLARE_NAPI_FUNCTION("off", Off),
163 };
164
165 status = napi_define_class(env, AUDIO_VOLUME_MANAGER_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr,
166 sizeof(audio_volume_manager_properties) / sizeof(audio_volume_manager_properties[PARAM0]),
167 audio_volume_manager_properties, &constructor);
168 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "napi_define_class fail");
169 status = napi_create_reference(env, constructor, refCount, &g_volumeManagerConstructor);
170 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "napi_create_reference fail");
171 status = napi_set_named_property(env, exports, AUDIO_VOLUME_MANAGER_NAPI_CLASS_NAME.c_str(), constructor);
172 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "napi_set_named_property fail");
173 return exports;
174 }
175
GetAppVolumePercentage(napi_env env,napi_callback_info info)176 napi_value NapiAudioVolumeManager::GetAppVolumePercentage(napi_env env, napi_callback_info info)
177 {
178 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
179 if (context == nullptr) {
180 AUDIO_ERR_LOG("GetAppVolumePercentage failed : no memory");
181 NapiAudioError::ThrowError(env, "GetAppVolumePercentage failed : no memory", NAPI_ERR_SYSTEM);
182 return NapiParamUtils::GetUndefinedValue(env);
183 }
184 int32_t argNum = 0;
185 auto inputParser = [context, &argNum](size_t argc, napi_value *argv) {
186 argNum = argc;
187 };
188 context->GetCbInfo(env, info, inputParser);
189
190 auto executor = [context]() {
191 CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
192 auto obj = reinterpret_cast<NapiAudioVolumeManager*>(context->native);
193 ObjectRefMap objectGuard(obj);
194 auto *napiAudioVolumeManager = objectGuard.GetPtr();
195 CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context),
196 "audio volume group manager state is error.");
197 context->volLevel = napiAudioVolumeManager->audioSystemMngr_->GetSelfAppVolume();
198 };
199
200 auto complete = [env, context](napi_value &output) {
201 NapiParamUtils::SetValueInt32(env, context->volLevel, output);
202 };
203 return NapiAsyncWork::Enqueue(env, context, "GetAppVolumePercentage", executor, complete);
204 }
205
GetAppVolumePercentageForUid(napi_env env,napi_callback_info info)206 napi_value NapiAudioVolumeManager::GetAppVolumePercentageForUid(napi_env env, napi_callback_info info)
207 {
208 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
209 if (context == nullptr) {
210 AUDIO_ERR_LOG("GetAppVolumePercentageForUid failed : no memory");
211 NapiAudioError::ThrowError(env, "GetAppVolumePercentageForUid failed : no memory", NAPI_ERR_SYSTEM);
212 return NapiParamUtils::GetUndefinedValue(env);
213 }
214 int32_t argNum = 0;
215 auto inputParser = [env, context, &argNum](size_t argc, napi_value *argv) {
216 argNum = argc;
217 NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments", NAPI_ERR_INVALID_PARAM);
218 context->status = NapiParamUtils::GetValueInt32(env, context->appUid, argv[PARAM0]);
219 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get appUid failed",
220 NAPI_ERR_INPUT_INVALID);
221 };
222 context->GetCbInfo(env, info, inputParser);
223
224 auto executor = [context]() {
225 CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
226 auto obj = reinterpret_cast<NapiAudioVolumeManager*>(context->native);
227 ObjectRefMap objectGuard(obj);
228 auto *napiAudioVolumeManager = objectGuard.GetPtr();
229 CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context),
230 "audio volume group manager state is error.");
231 context->volLevel = napiAudioVolumeManager->audioSystemMngr_->GetAppVolume(context->appUid);
232 if (context->volLevel == ERR_PERMISSION_DENIED) {
233 context->SignError(NAPI_ERR_NO_PERMISSION);
234 } else if (context->volLevel == ERR_SYSTEM_PERMISSION_DENIED) {
235 context->SignError(NAPI_ERR_PERMISSION_DENIED);
236 }
237 };
238
239 auto complete = [env, context](napi_value &output) {
240 NapiParamUtils::SetValueInt32(env, context->volLevel, output);
241 };
242 return NapiAsyncWork::Enqueue(env, context, "GetAppVolumePercentageForUid", executor, complete);
243 }
244
SetAppVolumePercentageForUid(napi_env env,napi_callback_info info)245 napi_value NapiAudioVolumeManager::SetAppVolumePercentageForUid(napi_env env, napi_callback_info info)
246 {
247 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
248 if (context == nullptr) {
249 AUDIO_ERR_LOG("SetAppVolumePercentageForUid failed : no memory");
250 NapiAudioError::ThrowError(env, "SetAppVolumePercentageForUid failed : no memory", NAPI_ERR_SYSTEM);
251 return NapiParamUtils::GetUndefinedValue(env);
252 }
253 int32_t argNum = 0;
254 auto inputParser = [env, context, &argNum](size_t argc, napi_value *argv) {
255 argNum = argc;
256 NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_TWO, "invalid arguments", NAPI_ERR_INVALID_PARAM);
257 context->status = NapiParamUtils::GetValueInt32(env, context->appUid, argv[PARAM0]);
258 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get appUid failed",
259 NAPI_ERR_INPUT_INVALID);
260 context->status = NapiParamUtils::GetValueInt32(env, context->volLevel, argv[PARAM1]);
261 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get volLevel failed",
262 NAPI_ERR_INPUT_INVALID);
263 };
264 context->GetCbInfo(env, info, inputParser);
265
266 auto executor = [context]() {
267 CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
268 auto obj = reinterpret_cast<NapiAudioVolumeManager*>(context->native);
269 ObjectRefMap objectGuard(obj);
270 auto *napiAudioVolumeManager = objectGuard.GetPtr();
271 CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context),
272 "audio volume group manager state is error.");
273 context->intValue = napiAudioVolumeManager->audioSystemMngr_->SetAppVolume(
274 context->appUid, context->volLevel);
275 NAPI_CHECK_ARGS_RETURN_VOID(context, context->intValue == SUCCESS, "set appvolume failed",
276 NAPI_ERR_SYSTEM);
277 };
278
279 auto complete = [env](napi_value &output) {
280 output = NapiParamUtils::GetUndefinedValue(env);
281 };
282 return NapiAsyncWork::Enqueue(env, context, "SetAppVolumePercentageForUid", executor, complete);
283 }
284
SetAppVolumePercentage(napi_env env,napi_callback_info info)285 napi_value NapiAudioVolumeManager::SetAppVolumePercentage(napi_env env, napi_callback_info info)
286 {
287 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
288 if (context == nullptr) {
289 AUDIO_ERR_LOG("SetAppVolumeDegree failed : no memory");
290 NapiAudioError::ThrowError(env, "SetAppVolumeDegree failed : no memory", NAPI_ERR_SYSTEM);
291 return NapiParamUtils::GetUndefinedValue(env);
292 }
293 int32_t argNum = 0;
294 auto inputParser = [env, context, &argNum](size_t argc, napi_value *argv) {
295 argNum = argc;
296 NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments", NAPI_ERR_INVALID_PARAM);
297 context->status = NapiParamUtils::GetValueInt32(env, context->volLevel, argv[PARAM0]);
298 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get appUid failed",
299 NAPI_ERR_INPUT_INVALID);
300 };
301 context->GetCbInfo(env, info, inputParser);
302
303 auto executor = [context]() {
304 CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
305 auto obj = reinterpret_cast<NapiAudioVolumeManager*>(context->native);
306 ObjectRefMap objectGuard(obj);
307 auto *napiAudioVolumeManager = objectGuard.GetPtr();
308 CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context),
309 "audio volume group manager state is error.");
310 context->intValue = napiAudioVolumeManager->audioSystemMngr_->SetSelfAppVolume(
311 context->volLevel);
312 NAPI_CHECK_ARGS_RETURN_VOID(context, context->intValue == SUCCESS, "set appvolume failed",
313 NAPI_ERR_SYSTEM);
314 };
315
316 auto complete = [env](napi_value &output) {
317 output = NapiParamUtils::GetUndefinedValue(env);
318 };
319 return NapiAsyncWork::Enqueue(env, context, "SetAppVolumePercentage", executor, complete);
320 }
321
SetAppVolumeMutedForUid(napi_env env,napi_callback_info info)322 napi_value NapiAudioVolumeManager::SetAppVolumeMutedForUid(napi_env env, napi_callback_info info)
323 {
324 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
325 if (context == nullptr) {
326 AUDIO_ERR_LOG("SetAppVolumeMutedForUid failed : no memory");
327 NapiAudioError::ThrowError(env, "SetAppVolumeMutedForUid failed : no memory", NAPI_ERR_SYSTEM);
328 return NapiParamUtils::GetUndefinedValue(env);
329 }
330
331 auto inputParser = [env, context](size_t argc, napi_value *argv) {
332 NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_TWO, "invalid arguments", NAPI_ERR_INVALID_PARAM);
333 context->status = NapiParamUtils::GetValueInt32(env, context->appUid, argv[PARAM0]);
334 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get appUid failed", NAPI_ERR_INPUT_INVALID);
335 context->status = NapiParamUtils::GetValueBoolean(env, context->isMute, argv[PARAM1]);
336 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get isMute failed", NAPI_ERR_INPUT_INVALID);
337 };
338 context->GetCbInfo(env, info, inputParser);
339 auto executor = [context]() {
340 CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
341 auto obj = reinterpret_cast<NapiAudioVolumeManager*>(context->native);
342 ObjectRefMap objectGuard(obj);
343 auto *napiAudioVolumeManager = objectGuard.GetPtr();
344 CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context),
345 "audio volume group manager state is error.");
346 context->intValue = napiAudioVolumeManager->audioSystemMngr_->SetAppVolumeMuted(
347 context->appUid, context->isMute);
348 NAPI_CHECK_ARGS_RETURN_VOID(context, context->intValue == SUCCESS, "SetAppVolumeMuted failed", NAPI_ERR_SYSTEM);
349 };
350
351 auto complete = [env](napi_value &output) {
352 output = NapiParamUtils::GetUndefinedValue(env);
353 };
354 return NapiAsyncWork::Enqueue(env, context, "SetAppVolumeMutedForUid", executor, complete);
355 }
356
IsAppVolumeMutedForUid(napi_env env,napi_callback_info info)357 napi_value NapiAudioVolumeManager::IsAppVolumeMutedForUid(napi_env env, napi_callback_info info)
358 {
359 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
360 if (context == nullptr) {
361 AUDIO_ERR_LOG("IsAppVolumeMutedForUid failed : no memory");
362 NapiAudioError::ThrowError(env, "IsAppVolumeMutedForUid failed : no memory", NAPI_ERR_SYSTEM);
363 return NapiParamUtils::GetUndefinedValue(env);
364 }
365 auto inputParser = [env, context](size_t argc, napi_value *argv) {
366 NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_TWO, "invalid arguments", NAPI_ERR_INVALID_PARAM);
367 context->status = NapiParamUtils::GetValueInt32(env, context->appUid, argv[PARAM0]);
368 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get appUid failed", NAPI_ERR_INPUT_INVALID);
369 context->status = NapiParamUtils::GetValueBoolean(env, context->isOwned, argv[PARAM1]);
370 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get isOwned failed", NAPI_ERR_INPUT_INVALID);
371 };
372 context->GetCbInfo(env, info, inputParser);
373 auto executor = [context]() {
374 CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
375 auto obj = reinterpret_cast<NapiAudioVolumeManager*>(context->native);
376 ObjectRefMap objectGuard(obj);
377 auto *napiAudioVolumeManager = objectGuard.GetPtr();
378 CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context),
379 "audio volume group manager state is error.");
380 context->isMute = napiAudioVolumeManager->audioSystemMngr_->IsAppVolumeMute(
381 context->appUid, context->isOwned);
382 };
383 auto complete = [env, context](napi_value &output) {
384 NapiParamUtils::SetValueBoolean(env, context->isMute, output);
385 };
386 return NapiAsyncWork::Enqueue(env, context, "IsAppVolumeMutedForUid", executor, complete);
387 }
388
GetVolumeGroupInfos(napi_env env,napi_callback_info info)389 napi_value NapiAudioVolumeManager::GetVolumeGroupInfos(napi_env env, napi_callback_info info)
390 {
391 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
392 if (context == nullptr) {
393 AUDIO_ERR_LOG("GetVolumeGroupInfos failed : no memory");
394 NapiAudioError::ThrowError(env, "GetVolumeGroupInfos failed : no memory", NAPI_ERR_NO_MEMORY);
395 return NapiParamUtils::GetUndefinedValue(env);
396 }
397
398 auto inputParser = [env, context](size_t argc, napi_value *argv) {
399 NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
400 NAPI_ERR_INVALID_PARAM);
401 napi_valuetype valueType = napi_undefined;
402 napi_typeof(env, argv[PARAM0], &valueType);
403 NAPI_CHECK_ARGS_RETURN_VOID(context, valueType == napi_string, "invaild valueType",
404 NAPI_ERR_INVALID_PARAM);
405 context->networkId = NapiParamUtils::GetStringArgument(env, argv[PARAM0]);
406 };
407 context->GetCbInfo(env, info, inputParser);
408
409 auto executor = [context]() {
410 CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
411 auto obj = reinterpret_cast<NapiAudioVolumeManager*>(context->native);
412 ObjectRefMap objectGuard(obj);
413 auto *napiAudioVolumeManager = objectGuard.GetPtr();
414 CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context),
415 "audio volume group manager state is error.");
416 context->intValue = napiAudioVolumeManager->audioSystemMngr_->GetVolumeGroups(
417 context->networkId, context->volumeGroupInfos);
418 NAPI_CHECK_ARGS_RETURN_VOID(context, context->intValue == SUCCESS, "getvolumegroups failed",
419 NAPI_ERR_SYSTEM);
420 };
421
422 auto complete = [env, context](napi_value &output) {
423 NapiParamUtils::SetVolumeGroupInfos(env, context->volumeGroupInfos, output);
424 };
425 return NapiAsyncWork::Enqueue(env, context, "GetVolumeGroupInfos", executor, complete);
426 }
427
GetVolumeGroupInfosSync(napi_env env,napi_callback_info info)428 napi_value NapiAudioVolumeManager::GetVolumeGroupInfosSync(napi_env env, napi_callback_info info)
429 {
430 AUDIO_INFO_LOG("GetVolumeGroupInfosSync");
431 napi_value result = nullptr;
432 size_t argc = ARGS_ONE;
433 napi_value args[ARGS_ONE] = {};
434 auto *napiAudioVolumeManager = GetParamWithSync(env, info, argc, args);
435 CHECK_AND_RETURN_RET_LOG(argc >= ARGS_ONE, NapiAudioError::ThrowErrorAndReturn(env,
436 NAPI_ERR_INPUT_INVALID, "mandatory parameters are left unspecified"), "invalid arguments");
437
438 napi_valuetype valueType = napi_undefined;
439 napi_typeof(env, args[PARAM0], &valueType);
440 CHECK_AND_RETURN_RET_LOG(valueType == napi_string, NapiAudioError::ThrowErrorAndReturn(env,
441 NAPI_ERR_INPUT_INVALID, "incorrect parameter types: The type of networkId must be string"),
442 "invalid valueType");
443
444 std::string networkId = NapiParamUtils::GetStringArgument(env, args[PARAM0]);
445 CHECK_AND_RETURN_RET_LOG(!networkId.empty(), NapiAudioError::ThrowErrorAndReturn(env,
446 NAPI_ERR_INVALID_PARAM, "parameter verification failed: The param of networkId is empty"),
447 "get networkid failed");
448
449 std::vector<sptr<VolumeGroupInfo>> volumeGroupInfos;
450 if (napiAudioVolumeManager == nullptr || napiAudioVolumeManager->audioSystemMngr_ == nullptr) {
451 AUDIO_ERR_LOG("napiAudioVolumeManager or audioSystemMngr is nullptr!");
452 return nullptr;
453 }
454 int32_t ret = napiAudioVolumeManager->audioSystemMngr_->GetVolumeGroups(networkId, volumeGroupInfos);
455 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, result, "GetVolumeGroups failure!");
456
457 NapiParamUtils::SetVolumeGroupInfos(env, volumeGroupInfos, result);
458 return result;
459 }
460
GetVolumeGroupManager(napi_env env,napi_callback_info info)461 napi_value NapiAudioVolumeManager::GetVolumeGroupManager(napi_env env, napi_callback_info info)
462 {
463 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
464 if (context == nullptr) {
465 AUDIO_ERR_LOG("GetVolumeGroupManager failed : no memory");
466 NapiAudioError::ThrowError(env, "GetVolumeGroupManager failed : no memory", NAPI_ERR_NO_MEMORY);
467 return NapiParamUtils::GetUndefinedValue(env);
468 }
469
470 auto inputParser = [env, context](size_t argc, napi_value *argv) {
471 NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
472 NAPI_ERR_INVALID_PARAM);
473 context->status = NapiParamUtils::GetValueInt32(env, context->groupId, argv[PARAM0]);
474 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get groupId failed",
475 NAPI_ERR_INVALID_PARAM);
476 };
477 context->GetCbInfo(env, info, inputParser);
478
479 auto complete = [env, context](napi_value &output) {
480 output = NapiAudioVolumeGroupManager::CreateAudioVolumeGroupManagerWrapper(env, context->groupId);
481 NapiAudioVolumeGroupManager::isConstructSuccess_ = SUCCESS;
482 };
483 return NapiAsyncWork::Enqueue(env, context, "GetVolumeGroupManager", nullptr, complete);
484 }
485
GetVolumeGroupManagerSync(napi_env env,napi_callback_info info)486 napi_value NapiAudioVolumeManager::GetVolumeGroupManagerSync(napi_env env, napi_callback_info info)
487 {
488 napi_value result = nullptr;
489 size_t argc = ARGS_ONE;
490 napi_value args[ARGS_ONE] = {};
491 napi_status status = NapiParamUtils::GetParam(env, info, argc, args);
492 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "getparam failed");
493 CHECK_AND_RETURN_RET_LOG(argc == ARGS_ONE, NapiAudioError::ThrowErrorAndReturn(env,
494 NAPI_ERR_INPUT_INVALID, "mandatory parameters are left unspecified"), "invalid arguments");
495
496 napi_valuetype valueType = napi_undefined;
497 napi_typeof(env, args[PARAM0], &valueType);
498 CHECK_AND_RETURN_RET_LOG(valueType == napi_number, NapiAudioError::ThrowErrorAndReturn(env,
499 NAPI_ERR_INPUT_INVALID, "incorrect parameter types: The type of groupId must be number"),
500 "invalid valueType");
501
502 int32_t groupId;
503 NapiParamUtils::GetValueInt32(env, groupId, args[PARAM0]);
504
505 result = NapiAudioVolumeGroupManager::CreateAudioVolumeGroupManagerWrapper(env, groupId);
506
507 napi_value undefinedValue = nullptr;
508 napi_get_undefined(env, &undefinedValue);
509 bool isEqual = false;
510 napi_strict_equals(env, result, undefinedValue, &isEqual);
511 if (isEqual) {
512 AUDIO_ERR_LOG("The audio volume group manager is undefined!");
513 NapiAudioError::ThrowError(env, "GetVolumeGroupManagerSync failed: invalid param",
514 NAPI_ERR_INVALID_PARAM);
515 return result;
516 }
517
518 return result;
519 }
520
RegisterCallback(napi_env env,napi_value jsThis,size_t argc,napi_value * args,const std::string & cbName)521 napi_value NapiAudioVolumeManager::RegisterCallback(napi_env env, napi_value jsThis, size_t argc, napi_value *args,
522 const std::string &cbName)
523 {
524 napi_value undefinedResult = nullptr;
525 NapiAudioVolumeManager *napiVolumeManager = nullptr;
526 napi_status status = napi_unwrap(env, jsThis, reinterpret_cast<void **>(&napiVolumeManager));
527 CHECK_AND_RETURN_RET_LOG(status == napi_ok, NapiAudioError::ThrowErrorAndReturn(env,
528 NAPI_ERR_SYSTEM), "status error");
529 CHECK_AND_RETURN_RET_LOG(napiVolumeManager != nullptr, NapiAudioError::ThrowErrorAndReturn(env,
530 NAPI_ERR_NO_MEMORY), "napiVolumeManager is nullptr");
531 CHECK_AND_RETURN_RET_LOG(napiVolumeManager->audioSystemMngr_ != nullptr, NapiAudioError::ThrowErrorAndReturn(
532 env, NAPI_ERR_NO_MEMORY), "audioSystemMngr_ is nullptr");
533
534 if (!cbName.compare(VOLUME_KEY_EVENT_CALLBACK_NAME)) {
535 if (napiVolumeManager->volumeKeyEventCallbackNapi_ == nullptr) {
536 napiVolumeManager->volumeKeyEventCallbackNapi_ = std::make_shared<NapiAudioVolumeKeyEvent>(env);
537 int32_t ret = napiVolumeManager->audioSystemMngr_->RegisterVolumeKeyEventCallback(
538 napiVolumeManager->cachedClientId_, napiVolumeManager->volumeKeyEventCallbackNapi_);
539 napiVolumeManager->volumeKeyEventCallbackNapiList_.push_back(
540 std::static_pointer_cast<NapiAudioVolumeKeyEvent>(napiVolumeManager->volumeKeyEventCallbackNapi_));
541 if (ret) {
542 AUDIO_ERR_LOG("RegisterVolumeKeyEventCallback Failed");
543 }
544 }
545 std::shared_ptr<NapiAudioVolumeKeyEvent> cb =
546 std::static_pointer_cast<NapiAudioVolumeKeyEvent>(napiVolumeManager->volumeKeyEventCallbackNapi_);
547 cb->SaveCallbackReference(cbName, args[PARAM1]);
548 if (!cb->GetVolumeTsfnFlag()) {
549 cb->CreateVolumeTsfn(env);
550 }
551 } else if (!cbName.compare(APP_VOLUME_CHANGE_CALLBACK_NAME)) {
552 undefinedResult = RegisterSelfAppVolumeChangeCallback(env, args, cbName,
553 napiVolumeManager);
554 } else if (!cbName.compare(APP_VOLUME_CHANGE_CALLBACK_NAME_FOR_UID)) {
555 undefinedResult = RegisterAppVolumeChangeForUidCallback(env, args, cbName,
556 napiVolumeManager);
557 } else {
558 AUDIO_ERR_LOG("No such callback supported");
559 NapiAudioError::ThrowError(env, NAPI_ERR_INVALID_PARAM,
560 "parameter verification failed: The param of type is not supported");
561 }
562 return undefinedResult;
563 }
564
RegisterAppVolumeChangeForUidCallback(napi_env env,napi_value * args,const std::string & cbName,NapiAudioVolumeManager * napiAudioVolumeManager)565 napi_value NapiAudioVolumeManager::RegisterAppVolumeChangeForUidCallback(napi_env env, napi_value *args,
566 const std::string &cbName, NapiAudioVolumeManager *napiAudioVolumeManager)
567 {
568 napi_value result = nullptr;
569 napi_get_undefined(env, &result);
570 int32_t appUid = 0;
571 NapiParamUtils::GetValueInt32(env, appUid, args[PARAM1]);
572 if (napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_ == nullptr) {
573 napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_ =
574 std::make_shared<NapiAudioManagerAppVolumeChangeCallback>(env);
575 }
576 CHECK_AND_RETURN_RET_LOG(napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_, result,
577 "RegisterAppVolumeChangeForUidCallback: Memory Allocation Failed !");
578 int32_t ret = napiAudioVolumeManager->audioSystemMngr_->SetAppVolumeCallbackForUid(appUid,
579 napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_);
580 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, result, "SetAppVolumeCallbackForUid Failed");
581 std::shared_ptr<NapiAudioManagerAppVolumeChangeCallback> cb =
582 std::static_pointer_cast<NapiAudioManagerAppVolumeChangeCallback>(
583 napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_);
584 cb->SaveVolumeChangeCallbackForUidReference(cbName, args[PARAM2], appUid);
585 if (!cb->GetManagerAppVolumeChangeTsfnFlag()) {
586 cb->CreateManagerAppVolumeChangeTsfn(env);
587 }
588 return result;
589 }
590
RegisterSelfAppVolumeChangeCallback(napi_env env,napi_value * args,const std::string & cbName,NapiAudioVolumeManager * napiAudioVolumeManager)591 napi_value NapiAudioVolumeManager::RegisterSelfAppVolumeChangeCallback(napi_env env,
592 napi_value *args, const std::string &cbName, NapiAudioVolumeManager *napiAudioVolumeManager)
593 {
594 napi_value result = nullptr;
595 napi_get_undefined(env, &result);
596 if (napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_ == nullptr) {
597 napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_ =
598 std::make_shared<NapiAudioManagerAppVolumeChangeCallback>(env);
599 }
600 CHECK_AND_RETURN_RET_LOG(napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_, result,
601 "napiAudioVolumeManager: Memory Allocation Failed !");
602 int32_t ret = napiAudioVolumeManager->audioSystemMngr_->SetSelfAppVolumeCallback(
603 napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_);
604 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, result, "SetSelfAppVolumeCallback Failed");
605 std::shared_ptr<NapiAudioManagerAppVolumeChangeCallback> cb =
606 std::static_pointer_cast<NapiAudioManagerAppVolumeChangeCallback>(
607 napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_);
608 cb->SaveSelfVolumdChangeCallbackReference(cbName, args[PARAM1]);
609 if (!cb->GetManagerAppVolumeChangeTsfnFlag()) {
610 cb->CreateManagerAppVolumeChangeTsfn(env);
611 }
612 return result;
613 }
614
On(napi_env env,napi_callback_info info)615 napi_value NapiAudioVolumeManager::On(napi_env env, napi_callback_info info)
616 {
617 napi_value undefinedResult = nullptr;
618 napi_get_undefined(env, &undefinedResult);
619
620 const size_t minArgCount = ARGS_TWO;
621 size_t argCount = ARGS_THREE;
622 napi_value args[minArgCount + PARAM1] = {nullptr, nullptr, nullptr};
623 napi_value jsThis = nullptr;
624 napi_status status = napi_get_cb_info(env, info, &argCount, args, &jsThis, nullptr);
625 if (status != napi_ok || argCount < minArgCount) {
626 AUDIO_ERR_LOG("On fail to napi_get_cb_info/Requires min 2 parameters");
627 NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID,
628 "mandatory parameters are left unspecified");
629 }
630
631 napi_valuetype eventType = napi_undefined;
632 if (napi_typeof(env, args[PARAM0], &eventType) != napi_ok || eventType != napi_string) {
633 NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID,
634 "incorrect parameter types: The type of eventType must be string");
635 return undefinedResult;
636 }
637 std::string callbackName = NapiParamUtils::GetStringArgument(env, args[PARAM0]);
638 AUDIO_INFO_LOG("On callbackName: %{public}s", callbackName.c_str());
639
640 napi_valuetype handler = napi_undefined;
641 if (napi_typeof(env, args[argCount -1], &handler) != napi_ok || handler != napi_function) {
642 AUDIO_ERR_LOG("On type mismatch for parameter 2");
643 NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID,
644 "incorrect parameter types: The type of callback must be function");
645 return undefinedResult;
646 }
647
648 return RegisterCallback(env, jsThis, argCount, args, callbackName);
649 }
650
Off(napi_env env,napi_callback_info info)651 napi_value NapiAudioVolumeManager::Off(napi_env env, napi_callback_info info)
652 {
653 napi_value undefinedResult = nullptr;
654 napi_get_undefined(env, &undefinedResult);
655
656 const size_t minArgCount = ARGS_ONE;
657 size_t argc = ARGS_TWO;
658 napi_value args[minArgCount + PARAM2] = {nullptr, nullptr, nullptr};
659 napi_value jsThis = nullptr;
660 napi_status status = napi_get_cb_info(env, info, &argc, args, &jsThis, nullptr);
661 if (status != napi_ok || argc < minArgCount) {
662 AUDIO_ERR_LOG("Off fail to napi_get_cb_info/Requires min 1 parameters");
663 NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID,
664 "mandatory parameters are left unspecified");
665 }
666 napi_valuetype eventType = napi_undefined;
667 if (napi_typeof(env, args[PARAM0], &eventType) != napi_ok || eventType != napi_string) {
668 NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID,
669 "incorrect parameter types: The type of eventType must be string");
670 return undefinedResult;
671 }
672 std::string callbackName = NapiParamUtils::GetStringArgument(env, args[PARAM0]);
673 AUDIO_INFO_LOG("Off callbackName: %{public}s", callbackName.c_str());
674
675 return UnregisterCallback(env, jsThis, argc, args, callbackName);
676 }
677
UnregisterCallback(napi_env env,napi_value jsThis,size_t argc,napi_value * args,const std::string & cbName)678 napi_value NapiAudioVolumeManager::UnregisterCallback(napi_env env, napi_value jsThis,
679 size_t argc, napi_value *args, const std::string &cbName)
680 {
681 napi_value undefinedResult = nullptr;
682 NapiAudioVolumeManager *napiVolumeManager = nullptr;
683 napi_status status = napi_unwrap(env, jsThis, reinterpret_cast<void **>(&napiVolumeManager));
684 CHECK_AND_RETURN_RET_LOG(status == napi_ok, NapiAudioError::ThrowErrorAndReturn(env,
685 NAPI_ERR_SYSTEM), "status error");
686 CHECK_AND_RETURN_RET_LOG(napiVolumeManager != nullptr, NapiAudioError::ThrowErrorAndReturn(env,
687 NAPI_ERR_NO_MEMORY), "napiVolumeManager is nullptr");
688 CHECK_AND_RETURN_RET_LOG(napiVolumeManager->audioSystemMngr_ != nullptr, NapiAudioError::ThrowErrorAndReturn(
689 env, NAPI_ERR_NO_MEMORY), "audioSystemMngr_ is nullptr");
690
691 if (!cbName.compare(VOLUME_KEY_EVENT_CALLBACK_NAME)) {
692 napi_value callback = nullptr;
693 if (argc == ARGS_TWO) {
694 callback = args[PARAM1];
695 }
696 if (callback != nullptr) {
697 std::shared_ptr<NapiAudioVolumeKeyEvent> cb = GetVolumeEventNapiCallback(callback, napiVolumeManager);
698 CHECK_AND_RETURN_RET_LOG(cb != nullptr, undefinedResult, "NapiAudioVolumeKeyEvent is nullptr");
699 int32_t ret = napiVolumeManager->audioSystemMngr_->UnregisterVolumeKeyEventCallback(
700 napiVolumeManager->cachedClientId_, cb);
701 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, undefinedResult, "Unset of VolumeKeyEventCallback failed");
702 napiVolumeManager->volumeKeyEventCallbackNapiList_.remove(cb);
703 napiVolumeManager->volumeKeyEventCallbackNapi_.reset();
704 napiVolumeManager->volumeKeyEventCallbackNapi_ = nullptr;
705 return undefinedResult;
706 } else {
707 int32_t ret = napiVolumeManager->audioSystemMngr_->UnregisterVolumeKeyEventCallback(
708 napiVolumeManager->cachedClientId_);
709 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, undefinedResult, "Unset of VolumeKeyEventCallback failed");
710 napiVolumeManager->volumeKeyEventCallbackNapiList_.clear();
711 napiVolumeManager->volumeKeyEventCallbackNapi_.reset();
712 napiVolumeManager->volumeKeyEventCallbackNapi_ = nullptr;
713 return undefinedResult;
714 }
715 } else if (!cbName.compare(APP_VOLUME_CHANGE_CALLBACK_NAME)) {
716 UnregisterSelfAppVolumeChangeCallback(env, args[PARAM1], argc, napiVolumeManager);
717 } else if (!cbName.compare(APP_VOLUME_CHANGE_CALLBACK_NAME_FOR_UID)) {
718 CHECK_AND_RETURN_RET_LOG(argc == ARGS_TWO, NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INPUT_INVALID,
719 "INPUT ERROR PARAMETER"), "parameter error");
720 UnregisterAppVolumeChangeForUidCallback(env, args[PARAM1], args, argc, napiVolumeManager);
721 } else {
722 AUDIO_ERR_LOG("No such callback supported");
723 NapiAudioError::ThrowError(env, NAPI_ERR_INVALID_PARAM,
724 "parameter verification failed: The param of type is not supported");
725 }
726 return undefinedResult;
727 }
728
UnregisterAppVolumeChangeForUidCallback(napi_env env,napi_value callback,napi_value * args,size_t argc,NapiAudioVolumeManager * napiAudioVolumeManager)729 void NapiAudioVolumeManager::UnregisterAppVolumeChangeForUidCallback(napi_env env, napi_value callback,
730 napi_value *args, size_t argc, NapiAudioVolumeManager *napiAudioVolumeManager)
731 {
732 if (napiAudioVolumeManager == nullptr) {
733 AUDIO_ERR_LOG("napiAudioVolumeManager is nullptr");
734 return;
735 }
736 CHECK_AND_RETURN_LOG(napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_ != nullptr,
737 "UnregisterDeviceChangeCallback: audio manager deviceChangeCallbackNapi_ is null");
738 std::shared_ptr<NapiAudioManagerAppVolumeChangeCallback> cb =
739 std::static_pointer_cast<NapiAudioManagerAppVolumeChangeCallback>(
740 napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_);
741 if (callback != nullptr) {
742 cb->RemoveAudioVolumeChangeForUidCbRef(env, callback);
743 }
744
745 if (cb->GetAppVolumeChangeForUidListSize() == 0) {
746 napiAudioVolumeManager->audioSystemMngr_->UnsetAppVolumeCallbackForUid();
747 napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_.reset();
748 napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_ = nullptr;
749 cb->RemoveAllAudioVolumeChangeForUidCbRef();
750 }
751 }
752
UnregisterSelfAppVolumeChangeCallback(napi_env env,napi_value callback,size_t argc,NapiAudioVolumeManager * napiAudioVolumeManager)753 void NapiAudioVolumeManager::UnregisterSelfAppVolumeChangeCallback(napi_env env, napi_value callback,
754 size_t argc, NapiAudioVolumeManager *napiAudioVolumeManager)
755 {
756 if (napiAudioVolumeManager == nullptr) {
757 AUDIO_ERR_LOG("napiAudioVolumeManager is nullptr");
758 return;
759 }
760 CHECK_AND_RETURN_LOG(napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_ != nullptr,
761 "UnregisterDeviceChangeCallback: audio manager selfAppVolumeChangeCallbackNapi_ is null");
762 std::shared_ptr<NapiAudioManagerAppVolumeChangeCallback> cb =
763 std::static_pointer_cast<NapiAudioManagerAppVolumeChangeCallback>(
764 napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_);
765 if (callback != nullptr && argc == ARGS_TWO) {
766 cb->RemoveSelfAudioVolumeChangeCbRef(env, callback);
767 }
768 if (argc == ARGS_ONE || cb->GetSelfAppVolumeChangeListSize() == 0) {
769 napiAudioVolumeManager->audioSystemMngr_->UnsetSelfAppVolumeCallback();
770 napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_.reset();
771 napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_ = nullptr;
772 cb->RemoveAllSelfAudioVolumeChangeCbRef();
773 }
774 }
775
GetVolumeEventNapiCallback(napi_value argv,NapiAudioVolumeManager * napiVolumeManager)776 std::shared_ptr<NapiAudioVolumeKeyEvent> NapiAudioVolumeManager::GetVolumeEventNapiCallback(napi_value argv,
777 NapiAudioVolumeManager *napiVolumeManager)
778 {
779 std::shared_ptr<NapiAudioVolumeKeyEvent> cb = nullptr;
780 for (auto &iter : napiVolumeManager->volumeKeyEventCallbackNapiList_) {
781 if (iter->ContainSameJsCallback(argv)) {
782 cb = iter;
783 }
784 }
785 return cb;
786 }
787 } // namespace AudioStandard
788 } // namespace OHOS