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_active_volume_type_change_callback.h"
23 #include "napi_audio_enum.h"
24 #include "napi_audio_error.h"
25 #include "napi_param_utils.h"
26 #include "audio_errors.h"
27 #include "audio_manager_log.h"
28
29 namespace OHOS {
30 namespace AudioStandard {
31 static __thread napi_ref g_volumeManagerConstructor = nullptr;
32
NapiAudioVolumeManager()33 NapiAudioVolumeManager::NapiAudioVolumeManager()
34 : audioSystemMngr_(nullptr), env_(nullptr) {}
35
36 NapiAudioVolumeManager::~NapiAudioVolumeManager() = default;
37
CheckContextStatus(std::shared_ptr<AudioVolumeManagerAsyncContext> context)38 bool NapiAudioVolumeManager::CheckContextStatus(std::shared_ptr<AudioVolumeManagerAsyncContext> context)
39 {
40 CHECK_AND_RETURN_RET_LOG(context != nullptr, false, "context object is nullptr.");
41 if (context->native == nullptr) {
42 context->SignError(NAPI_ERR_SYSTEM);
43 AUDIO_ERR_LOG("context object state is error.");
44 return false;
45 }
46 return true;
47 }
48
CheckAudioVolumeManagerStatus(NapiAudioVolumeManager * napi,std::shared_ptr<AudioVolumeManagerAsyncContext> context)49 bool NapiAudioVolumeManager::CheckAudioVolumeManagerStatus(NapiAudioVolumeManager *napi,
50 std::shared_ptr<AudioVolumeManagerAsyncContext> context)
51 {
52 CHECK_AND_RETURN_RET_LOG(napi != nullptr, false, "napi object is nullptr.");
53 if (napi->audioSystemMngr_ == nullptr) {
54 context->SignError(NAPI_ERR_SYSTEM);
55 AUDIO_ERR_LOG("context object state is error.");
56 return false;
57 }
58 return true;
59 }
60
GetParamWithSync(const napi_env & env,napi_callback_info info,size_t & argc,napi_value * args)61 NapiAudioVolumeManager* NapiAudioVolumeManager::GetParamWithSync(const napi_env &env, napi_callback_info info,
62 size_t &argc, napi_value *args)
63 {
64 NapiAudioVolumeManager *napiAudioVolumeManager = nullptr;
65 napi_value jsThis = nullptr;
66
67 napi_status 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 **)&napiAudioVolumeManager);
72 CHECK_AND_RETURN_RET_LOG(status == napi_ok, nullptr, "napi_unwrap failed");
73 CHECK_AND_RETURN_RET_LOG(napiAudioVolumeManager != nullptr && napiAudioVolumeManager->audioSystemMngr_ != nullptr,
74 napiAudioVolumeManager, "GetParamWithSync fail to napi_unwrap");
75 return napiAudioVolumeManager;
76 }
77
Destructor(napi_env env,void * nativeObject,void * finalizeHint)78 void NapiAudioVolumeManager::Destructor(napi_env env, void *nativeObject, void *finalizeHint)
79 {
80 if (nativeObject == nullptr) {
81 AUDIO_WARNING_LOG("Native object is null");
82 return;
83 }
84 auto obj = static_cast<NapiAudioVolumeManager *>(nativeObject);
85 ObjectRefMap<NapiAudioVolumeManager>::DecreaseRef(obj);
86 AUDIO_INFO_LOG("Decrease obj count");
87 }
88
Construct(napi_env env,napi_callback_info info)89 napi_value NapiAudioVolumeManager::Construct(napi_env env, napi_callback_info info)
90 {
91 AUDIO_PRERELEASE_LOGI("Construct");
92 napi_status status;
93 napi_value result = nullptr;
94 napi_get_undefined(env, &result);
95
96 size_t argc = ARGS_TWO;
97 napi_value argv[ARGS_TWO] = {0};
98 napi_value thisVar = nullptr;
99 void *data = nullptr;
100
101 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
102 std::unique_ptr<NapiAudioVolumeManager> napiAudioVolumeManager = std::make_unique<NapiAudioVolumeManager>();
103 CHECK_AND_RETURN_RET_LOG(napiAudioVolumeManager != nullptr, result, "No memory");
104
105 napiAudioVolumeManager->audioSystemMngr_ = AudioSystemManager::GetInstance();
106 napiAudioVolumeManager->env_ = env;
107 napiAudioVolumeManager->cachedClientId_ = getpid();
108 ObjectRefMap<NapiAudioVolumeManager>::Insert(napiAudioVolumeManager.get());
109
110 status = napi_wrap(env, thisVar, static_cast<void*>(napiAudioVolumeManager.get()),
111 NapiAudioVolumeManager::Destructor, nullptr, nullptr);
112 if (status != napi_ok) {
113 ObjectRefMap<NapiAudioVolumeManager>::Erase(napiAudioVolumeManager.get());
114 return result;
115 }
116 napiAudioVolumeManager.release();
117 return thisVar;
118 }
119
CreateVolumeManagerWrapper(napi_env env)120 napi_value NapiAudioVolumeManager::CreateVolumeManagerWrapper(napi_env env)
121 {
122 napi_status status;
123 napi_value result = nullptr;
124 napi_value constructor;
125
126 status = napi_get_reference_value(env, g_volumeManagerConstructor, &constructor);
127 if (status != napi_ok) {
128 AUDIO_ERR_LOG("Failed in CreateVolumeManagerWrapper, %{public}d", status);
129 goto fail;
130 }
131 status = napi_new_instance(env, constructor, PARAM0, nullptr, &result);
132 if (status != napi_ok) {
133 AUDIO_ERR_LOG("napi_new_instance failed, status:%{public}d", status);
134 goto fail;
135 }
136 return result;
137
138 fail:
139 napi_get_undefined(env, &result);
140 return result;
141 }
142
Init(napi_env env,napi_value exports)143 napi_value NapiAudioVolumeManager::Init(napi_env env, napi_value exports)
144 {
145 napi_status status;
146 napi_value constructor;
147 napi_value result = nullptr;
148 const int32_t refCount = ARGS_ONE;
149 napi_get_undefined(env, &result);
150
151 napi_property_descriptor audio_volume_manager_properties[] = {
152 DECLARE_NAPI_FUNCTION("getVolumeGroupInfos", GetVolumeGroupInfos),
153 DECLARE_NAPI_FUNCTION("getVolumeGroupInfosSync", GetVolumeGroupInfosSync),
154 DECLARE_NAPI_FUNCTION("getVolumeGroupManager", GetVolumeGroupManager),
155 DECLARE_NAPI_FUNCTION("getVolumeGroupManagerSync", GetVolumeGroupManagerSync),
156 DECLARE_NAPI_FUNCTION("setAppVolumePercentage", SetAppVolumePercentage),
157 DECLARE_NAPI_FUNCTION("setAppVolumePercentageForUid", SetAppVolumePercentageForUid),
158 DECLARE_NAPI_FUNCTION("getAppVolumePercentage", GetAppVolumePercentage),
159 DECLARE_NAPI_FUNCTION("getAppVolumePercentageForUid", GetAppVolumePercentageForUid),
160 DECLARE_NAPI_FUNCTION("setAppVolumeMutedForUid", SetAppVolumeMutedForUid),
161 DECLARE_NAPI_FUNCTION("isAppVolumeMutedForUid", IsAppVolumeMutedForUid),
162 DECLARE_NAPI_FUNCTION("getSystemVolume", GetSystemVolume),
163 DECLARE_NAPI_FUNCTION("getMinSystemVolume", GetMinSystemVolume),
164 DECLARE_NAPI_FUNCTION("getMaxSystemVolume", GetMaxSystemVolume),
165 DECLARE_NAPI_FUNCTION("isSystemMuted", IsSystemMuted),
166 DECLARE_NAPI_FUNCTION("getVolumeInUnitOfDb", GetVolumeInUnitOfDb),
167 DECLARE_NAPI_FUNCTION("getVolumeByStream", GetVolumeByStream),
168 DECLARE_NAPI_FUNCTION("getMinVolumeByStream", GetMinVolumeByStream),
169 DECLARE_NAPI_FUNCTION("getMaxVolumeByStream", GetMaxVolumeByStream),
170 DECLARE_NAPI_FUNCTION("isSystemMutedForStream", IsSystemMutedForStream),
171 DECLARE_NAPI_FUNCTION("getVolumeInUnitOfDbByStream", GetVolumeInUnitOfDbByStream),
172 DECLARE_NAPI_FUNCTION("getSupportedAudioVolumeTypes", GetSupportedAudioVolumeTypes),
173 DECLARE_NAPI_FUNCTION("getAudioVolumeTypeByStreamUsage", GetAudioVolumeTypeByStreamUsage),
174 DECLARE_NAPI_FUNCTION("getStreamUsagesByVolumeType", GetStreamUsagesByVolumeType),
175 DECLARE_NAPI_FUNCTION("on", On),
176 DECLARE_NAPI_FUNCTION("off", Off),
177 DECLARE_NAPI_FUNCTION("forceVolumeKeyControlType", ForceVolumeKeyControlType),
178 };
179
180 status = napi_define_class(env, AUDIO_VOLUME_MANAGER_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Construct, nullptr,
181 sizeof(audio_volume_manager_properties) / sizeof(audio_volume_manager_properties[PARAM0]),
182 audio_volume_manager_properties, &constructor);
183 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "napi_define_class fail");
184 status = napi_create_reference(env, constructor, refCount, &g_volumeManagerConstructor);
185 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "napi_create_reference fail");
186 status = napi_set_named_property(env, exports, AUDIO_VOLUME_MANAGER_NAPI_CLASS_NAME.c_str(), constructor);
187 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "napi_set_named_property fail");
188 return exports;
189 }
190
GetAppVolumePercentage(napi_env env,napi_callback_info info)191 napi_value NapiAudioVolumeManager::GetAppVolumePercentage(napi_env env, napi_callback_info info)
192 {
193 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
194 if (context == nullptr) {
195 AUDIO_ERR_LOG("GetAppVolumePercentage failed : no memory");
196 NapiAudioError::ThrowError(env, "GetAppVolumePercentage failed : no memory", NAPI_ERR_SYSTEM);
197 return NapiParamUtils::GetUndefinedValue(env);
198 }
199 size_t argNum = 0;
200 auto inputParser = [context, &argNum](size_t argc, napi_value *argv) {
201 argNum = argc;
202 };
203 context->GetCbInfo(env, info, inputParser);
204
205 auto executor = [context]() {
206 CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
207 auto obj = reinterpret_cast<NapiAudioVolumeManager*>(context->native);
208 ObjectRefMap objectGuard(obj);
209 auto *napiAudioVolumeManager = objectGuard.GetPtr();
210 CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context),
211 "audio volume group manager state is error.");
212 context->intValue = napiAudioVolumeManager->audioSystemMngr_->GetSelfAppVolume(context->volLevel);
213 if (context->intValue != SUCCESS) {
214 context->SignError(NAPI_ERR_SYSTEM);
215 }
216 };
217
218 auto complete = [env, context](napi_value &output) {
219 NapiParamUtils::SetValueInt32(env, context->volLevel, output);
220 };
221 return NapiAsyncWork::Enqueue(env, context, "GetAppVolumePercentage", executor, complete);
222 }
223
GetAppVolumePercentageForUid(napi_env env,napi_callback_info info)224 napi_value NapiAudioVolumeManager::GetAppVolumePercentageForUid(napi_env env, napi_callback_info info)
225 {
226 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
227 if (context == nullptr) {
228 AUDIO_ERR_LOG("GetAppVolumePercentageForUid failed : no memory");
229 NapiAudioError::ThrowError(env, "GetAppVolumePercentageForUid failed : no memory", NAPI_ERR_SYSTEM);
230 return NapiParamUtils::GetUndefinedValue(env);
231 }
232 size_t argNum = 0;
233 auto inputParser = [env, context, &argNum](size_t argc, napi_value *argv) {
234 argNum = argc;
235 NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "Invalid arguments count or types.",
236 NAPI_ERR_INVALID_PARAM);
237 context->status = NapiParamUtils::GetValueInt32(env, context->appUid, argv[PARAM0]);
238 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get appUid failed",
239 NAPI_ERR_INPUT_INVALID);
240 };
241 context->GetCbInfo(env, info, inputParser);
242
243 auto executor = [context]() {
244 CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
245 auto obj = reinterpret_cast<NapiAudioVolumeManager*>(context->native);
246 ObjectRefMap objectGuard(obj);
247 auto *napiAudioVolumeManager = objectGuard.GetPtr();
248 CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context),
249 "audio volume group manager state is error.");
250 context->intValue = napiAudioVolumeManager->audioSystemMngr_->GetAppVolume(context->appUid, context->volLevel);
251 CHECK_AND_RETURN(context->intValue != SUCCESS);
252 if (context->intValue == ERR_PERMISSION_DENIED) {
253 context->SignError(NAPI_ERR_NO_PERMISSION);
254 } else if (context->intValue == ERR_SYSTEM_PERMISSION_DENIED) {
255 context->SignError(NAPI_ERR_PERMISSION_DENIED);
256 } else {
257 context->SignError(NAPI_ERR_SYSTEM);
258 }
259 };
260
261 auto complete = [env, context](napi_value &output) {
262 NapiParamUtils::SetValueInt32(env, context->volLevel, output);
263 };
264 return NapiAsyncWork::Enqueue(env, context, "GetAppVolumePercentageForUid", executor, complete);
265 }
266
SetAppVolumePercentageForUid(napi_env env,napi_callback_info info)267 napi_value NapiAudioVolumeManager::SetAppVolumePercentageForUid(napi_env env, napi_callback_info info)
268 {
269 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
270 if (context == nullptr) {
271 AUDIO_ERR_LOG("SetAppVolumePercentageForUid failed : no memory");
272 NapiAudioError::ThrowError(env, "SetAppVolumePercentageForUid failed : no memory", NAPI_ERR_SYSTEM);
273 return NapiParamUtils::GetUndefinedValue(env);
274 }
275 size_t argNum = 0;
276 auto inputParser = [env, context, &argNum](size_t argc, napi_value *argv) {
277 argNum = argc;
278 NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_TWO, " Invalid arguments count or types.",
279 NAPI_ERR_INVALID_PARAM);
280 context->status = NapiParamUtils::GetValueInt32(env, context->appUid, argv[PARAM0]);
281 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get appUid failed",
282 NAPI_ERR_INPUT_INVALID);
283 context->status = NapiParamUtils::GetValueInt32(env, context->volLevel, argv[PARAM1]);
284 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get volLevel failed",
285 NAPI_ERR_INPUT_INVALID);
286 };
287 context->GetCbInfo(env, info, inputParser);
288
289 auto executor = [context]() {
290 CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
291 auto obj = reinterpret_cast<NapiAudioVolumeManager*>(context->native);
292 ObjectRefMap objectGuard(obj);
293 auto *napiAudioVolumeManager = objectGuard.GetPtr();
294 CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context),
295 "audio volume group manager state is error.");
296 context->intValue = napiAudioVolumeManager->audioSystemMngr_->SetAppVolume(
297 context->appUid, context->volLevel);
298 CHECK_AND_RETURN(context->intValue != SUCCESS);
299 if (context->intValue == ERR_PERMISSION_DENIED) {
300 context->SignError(NAPI_ERR_NO_PERMISSION);
301 } else if (context->intValue == ERR_SYSTEM_PERMISSION_DENIED) {
302 context->SignError(NAPI_ERR_PERMISSION_DENIED);
303 } else if (context->intValue == ERR_INVALID_PARAM) {
304 context->SignError(NAPI_ERROR_INVALID_PARAM);
305 } else {
306 context->SignError(NAPI_ERR_SYSTEM, "System error. Set app volume fail.");
307 }
308 };
309
310 auto complete = [env](napi_value &output) {
311 output = NapiParamUtils::GetUndefinedValue(env);
312 };
313 return NapiAsyncWork::Enqueue(env, context, "SetAppVolumePercentageForUid", executor, complete);
314 }
315
SetAppVolumePercentage(napi_env env,napi_callback_info info)316 napi_value NapiAudioVolumeManager::SetAppVolumePercentage(napi_env env, napi_callback_info info)
317 {
318 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
319 if (context == nullptr) {
320 AUDIO_ERR_LOG("SetAppVolumeDegree failed : no memory");
321 NapiAudioError::ThrowError(env, "SetAppVolumeDegree failed : no memory", NAPI_ERR_SYSTEM);
322 return NapiParamUtils::GetUndefinedValue(env);
323 }
324 size_t argNum = 0;
325 auto inputParser = [env, context, &argNum](size_t argc, napi_value *argv) {
326 argNum = argc;
327 NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "Invalid arguments count or types.",
328 NAPI_ERR_INVALID_PARAM);
329 context->status = NapiParamUtils::GetValueInt32(env, context->volLevel, argv[PARAM0]);
330 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get appUid failed",
331 NAPI_ERR_INPUT_INVALID);
332 };
333 context->GetCbInfo(env, info, inputParser);
334
335 auto executor = [context]() {
336 CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
337 auto obj = reinterpret_cast<NapiAudioVolumeManager*>(context->native);
338 ObjectRefMap objectGuard(obj);
339 auto *napiAudioVolumeManager = objectGuard.GetPtr();
340 CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context),
341 "audio volume group manager state is error.");
342 context->intValue = napiAudioVolumeManager->audioSystemMngr_->SetSelfAppVolume(
343 context->volLevel);
344 CHECK_AND_RETURN(context->intValue != SUCCESS);
345 if (context->intValue == ERR_INVALID_PARAM) {
346 context->SignError(NAPI_ERROR_INVALID_PARAM, "Invalid arguments count or types.");
347 } else {
348 context->SignError(NAPI_ERR_SYSTEM, "System error. Set app volume fail.");
349 }
350 };
351
352 auto complete = [env](napi_value &output) {
353 output = NapiParamUtils::GetUndefinedValue(env);
354 };
355 return NapiAsyncWork::Enqueue(env, context, "SetAppVolumePercentage", executor, complete);
356 }
357
SetAppVolumeMutedForUid(napi_env env,napi_callback_info info)358 napi_value NapiAudioVolumeManager::SetAppVolumeMutedForUid(napi_env env, napi_callback_info info)
359 {
360 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
361 if (context == nullptr) {
362 AUDIO_ERR_LOG("SetAppVolumeMutedForUid failed : no memory");
363 NapiAudioError::ThrowError(env, "SetAppVolumeMutedForUid failed : no memory", NAPI_ERR_SYSTEM);
364 return NapiParamUtils::GetUndefinedValue(env);
365 }
366
367 auto inputParser = [env, context](size_t argc, napi_value *argv) {
368 NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_TWO, "Invalid arguments count or types.",
369 NAPI_ERR_INVALID_PARAM);
370 context->status = NapiParamUtils::GetValueInt32(env, context->appUid, argv[PARAM0]);
371 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get appUid failed", NAPI_ERR_INPUT_INVALID);
372 context->status = NapiParamUtils::GetValueBoolean(env, context->isMute, argv[PARAM1]);
373 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get isMute failed", NAPI_ERR_INPUT_INVALID);
374 };
375 context->GetCbInfo(env, info, inputParser);
376 auto executor = [context]() {
377 CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
378 auto obj = reinterpret_cast<NapiAudioVolumeManager*>(context->native);
379 ObjectRefMap objectGuard(obj);
380 auto *napiAudioVolumeManager = objectGuard.GetPtr();
381 CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context),
382 "audio volume group manager state is error.");
383 context->intValue = napiAudioVolumeManager->audioSystemMngr_->SetAppVolumeMuted(
384 context->appUid, context->isMute);
385 CHECK_AND_RETURN(context->intValue != SUCCESS);
386 if (context->intValue == ERR_PERMISSION_DENIED) {
387 context->SignError(NAPI_ERR_NO_PERMISSION);
388 } else if (context->intValue == ERR_SYSTEM_PERMISSION_DENIED) {
389 context->SignError(NAPI_ERR_PERMISSION_DENIED);
390 } else {
391 context->SignError(NAPI_ERR_SYSTEM, "System error. Set app volume fail.");
392 }
393 };
394
395 auto complete = [env](napi_value &output) {
396 output = NapiParamUtils::GetUndefinedValue(env);
397 };
398 return NapiAsyncWork::Enqueue(env, context, "SetAppVolumeMutedForUid", executor, complete);
399 }
400
IsAppVolumeMutedForUid(napi_env env,napi_callback_info info)401 napi_value NapiAudioVolumeManager::IsAppVolumeMutedForUid(napi_env env, napi_callback_info info)
402 {
403 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
404 if (context == nullptr) {
405 AUDIO_ERR_LOG("IsAppVolumeMutedForUid failed : no memory");
406 NapiAudioError::ThrowError(env, "IsAppVolumeMutedForUid failed : no memory", NAPI_ERR_SYSTEM);
407 return NapiParamUtils::GetUndefinedValue(env);
408 }
409 auto inputParser = [env, context](size_t argc, napi_value *argv) {
410 NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_TWO, "invalid arguments", NAPI_ERR_INVALID_PARAM);
411 context->status = NapiParamUtils::GetValueInt32(env, context->appUid, argv[PARAM0]);
412 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get appUid failed", NAPI_ERR_INPUT_INVALID);
413 context->status = NapiParamUtils::GetValueBoolean(env, context->isOwned, argv[PARAM1]);
414 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get isOwned failed", NAPI_ERR_INPUT_INVALID);
415 };
416 context->GetCbInfo(env, info, inputParser);
417 auto executor = [context]() {
418 CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
419 auto obj = reinterpret_cast<NapiAudioVolumeManager*>(context->native);
420 ObjectRefMap objectGuard(obj);
421 auto *napiAudioVolumeManager = objectGuard.GetPtr();
422 CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context),
423 "audio volume group manager state is error.");
424 context->intValue = napiAudioVolumeManager->audioSystemMngr_->IsAppVolumeMute(
425 context->appUid, context->isOwned, context->isMute);
426 CHECK_AND_RETURN(context->intValue != SUCCESS);
427 if (context->intValue == ERR_PERMISSION_DENIED) {
428 context->SignError(NAPI_ERR_NO_PERMISSION);
429 } else if (context->intValue == ERR_SYSTEM_PERMISSION_DENIED) {
430 context->SignError(NAPI_ERR_PERMISSION_DENIED);
431 } else {
432 context->SignError(NAPI_ERR_SYSTEM);
433 }
434 };
435 auto complete = [env, context](napi_value &output) {
436 NapiParamUtils::SetValueBoolean(env, context->isMute, output);
437 };
438 return NapiAsyncWork::Enqueue(env, context, "IsAppVolumeMutedForUid", executor, complete);
439 }
440
GetVolumeGroupInfos(napi_env env,napi_callback_info info)441 napi_value NapiAudioVolumeManager::GetVolumeGroupInfos(napi_env env, napi_callback_info info)
442 {
443 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
444 if (context == nullptr) {
445 AUDIO_ERR_LOG("GetVolumeGroupInfos failed : no memory");
446 NapiAudioError::ThrowError(env, "GetVolumeGroupInfos failed : no memory", NAPI_ERR_NO_MEMORY);
447 return NapiParamUtils::GetUndefinedValue(env);
448 }
449
450 auto inputParser = [env, context](size_t argc, napi_value *argv) {
451 NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
452 NAPI_ERR_INVALID_PARAM);
453 napi_valuetype valueType = napi_undefined;
454 napi_typeof(env, argv[PARAM0], &valueType);
455 NAPI_CHECK_ARGS_RETURN_VOID(context, valueType == napi_string, "invaild valueType",
456 NAPI_ERR_INVALID_PARAM);
457 context->networkId = NapiParamUtils::GetStringArgument(env, argv[PARAM0]);
458 };
459 context->GetCbInfo(env, info, inputParser);
460
461 auto executor = [context]() {
462 CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
463 auto obj = reinterpret_cast<NapiAudioVolumeManager*>(context->native);
464 ObjectRefMap objectGuard(obj);
465 auto *napiAudioVolumeManager = objectGuard.GetPtr();
466 CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context),
467 "audio volume group manager state is error.");
468 context->intValue = napiAudioVolumeManager->audioSystemMngr_->GetVolumeGroups(
469 context->networkId, context->volumeGroupInfos);
470 NAPI_CHECK_ARGS_RETURN_VOID(context, context->intValue == SUCCESS, "getvolumegroups failed",
471 NAPI_ERR_SYSTEM);
472 };
473
474 auto complete = [env, context](napi_value &output) {
475 NapiParamUtils::SetVolumeGroupInfos(env, context->volumeGroupInfos, output);
476 };
477 return NapiAsyncWork::Enqueue(env, context, "GetVolumeGroupInfos", executor, complete);
478 }
479
GetVolumeGroupInfosSync(napi_env env,napi_callback_info info)480 napi_value NapiAudioVolumeManager::GetVolumeGroupInfosSync(napi_env env, napi_callback_info info)
481 {
482 AUDIO_INFO_LOG("GetVolumeGroupInfosSync");
483 napi_value result = nullptr;
484 size_t argc = ARGS_ONE;
485 napi_value args[ARGS_ONE] = {};
486 auto *napiAudioVolumeManager = GetParamWithSync(env, info, argc, args);
487 CHECK_AND_RETURN_RET_LOG(argc >= ARGS_ONE, NapiAudioError::ThrowErrorAndReturn(env,
488 NAPI_ERR_INPUT_INVALID, "mandatory parameters are left unspecified"), "invalid arguments");
489
490 napi_valuetype valueType = napi_undefined;
491 napi_typeof(env, args[PARAM0], &valueType);
492 CHECK_AND_RETURN_RET_LOG(valueType == napi_string, NapiAudioError::ThrowErrorAndReturn(env,
493 NAPI_ERR_INPUT_INVALID, "incorrect parameter types: The type of networkId must be string"),
494 "invalid valueType");
495
496 std::string networkId = NapiParamUtils::GetStringArgument(env, args[PARAM0]);
497 CHECK_AND_RETURN_RET_LOG(!networkId.empty(), NapiAudioError::ThrowErrorAndReturn(env,
498 NAPI_ERR_INVALID_PARAM, "parameter verification failed: The param of networkId is empty"),
499 "get networkid failed");
500
501 std::vector<sptr<VolumeGroupInfo>> volumeGroupInfos;
502 if (napiAudioVolumeManager == nullptr || napiAudioVolumeManager->audioSystemMngr_ == nullptr) {
503 AUDIO_ERR_LOG("napiAudioVolumeManager or audioSystemMngr is nullptr!");
504 return nullptr;
505 }
506 int32_t ret = napiAudioVolumeManager->audioSystemMngr_->GetVolumeGroups(networkId, volumeGroupInfos);
507 CHECK_AND_RETURN_RET_LOG(ret == AUDIO_OK, result, "GetVolumeGroups failure!");
508
509 NapiParamUtils::SetVolumeGroupInfos(env, volumeGroupInfos, result);
510 return result;
511 }
512
GetSystemVolume(napi_env env,napi_callback_info info)513 napi_value NapiAudioVolumeManager::GetSystemVolume(napi_env env, napi_callback_info info)
514 {
515 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySelfPermission(),
516 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "No system permission"),
517 "No system permission");
518 napi_value result = nullptr;
519 size_t argc = ARGS_ONE;
520 napi_value args[ARGS_ONE] = {};
521 auto *napiAudioVolumeManager = GetParamWithSync(env, info, argc, args);
522 CHECK_AND_RETURN_RET_LOG(argc >= ARGS_ONE, NapiAudioError::ThrowErrorAndReturn(env,
523 NAPI_ERR_INVALID_PARAM, "mandatory parameters are left unspecified"), "invalid arguments");
524
525 napi_valuetype valueType = napi_undefined;
526 napi_typeof(env, args[PARAM0], &valueType);
527 CHECK_AND_RETURN_RET_LOG(valueType == napi_number, NapiAudioError::ThrowErrorAndReturn(env,
528 NAPI_ERR_INVALID_PARAM, "incorrect parameter types: The type of audioVolumeType must be number"),
529 "invalid valueType");
530
531 int32_t volType;
532 NapiParamUtils::GetValueInt32(env, volType, args[PARAM0]);
533 CHECK_AND_RETURN_RET_LOG(NapiAudioEnum::IsLegalInputArgumentVolType(volType),
534 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
535 "parameter verification failed: The param of volType must be enum AudioVolumeType"),
536 "get volType failed");
537
538 if (napiAudioVolumeManager == nullptr || napiAudioVolumeManager->audioSystemMngr_ == nullptr) {
539 AUDIO_ERR_LOG("napiAudioVolumeManager or audioSystemMngr is nullptr!");
540 return nullptr;
541 }
542 int32_t systemVolume = napiAudioVolumeManager->audioSystemMngr_->GetVolume(
543 NapiAudioEnum::GetNativeAudioVolumeType(volType));
544 NapiParamUtils::SetValueInt32(env, systemVolume, result);
545 return result;
546 }
547
GetMinSystemVolume(napi_env env,napi_callback_info info)548 napi_value NapiAudioVolumeManager::GetMinSystemVolume(napi_env env, napi_callback_info info)
549 {
550 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySelfPermission(),
551 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "No system permission"),
552 "No system permission");
553 napi_value result = nullptr;
554 size_t argc = ARGS_ONE;
555 napi_value args[ARGS_ONE] = {};
556 auto *napiAudioVolumeManager = GetParamWithSync(env, info, argc, args);
557 CHECK_AND_RETURN_RET_LOG(argc >= ARGS_ONE, NapiAudioError::ThrowErrorAndReturn(env,
558 NAPI_ERR_INVALID_PARAM, "mandatory parameters are left unspecified"), "invalid arguments");
559
560 napi_valuetype valueType = napi_undefined;
561 napi_typeof(env, args[PARAM0], &valueType);
562 CHECK_AND_RETURN_RET_LOG(valueType == napi_number, NapiAudioError::ThrowErrorAndReturn(env,
563 NAPI_ERR_INVALID_PARAM, "incorrect parameter types: The type of audioVolumeType must be number"),
564 "invalid valueType");
565
566 int32_t volType;
567 NapiParamUtils::GetValueInt32(env, volType, args[PARAM0]);
568 CHECK_AND_RETURN_RET_LOG(NapiAudioEnum::IsLegalInputArgumentVolType(volType),
569 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
570 "parameter verification failed: The param of volType must be enum AudioVolumeType"),
571 "get volType failed");
572
573 if (napiAudioVolumeManager == nullptr || napiAudioVolumeManager->audioSystemMngr_ == nullptr) {
574 AUDIO_ERR_LOG("napiAudioVolumeManager or audioSystemMngr is nullptr!");
575 return nullptr;
576 }
577 int32_t minSystemVolume = napiAudioVolumeManager->audioSystemMngr_->GetMinVolume(
578 NapiAudioEnum::GetNativeAudioVolumeType(volType));
579 NapiParamUtils::SetValueInt32(env, minSystemVolume, result);
580 return result;
581 }
582
GetMaxSystemVolume(napi_env env,napi_callback_info info)583 napi_value NapiAudioVolumeManager::GetMaxSystemVolume(napi_env env, napi_callback_info info)
584 {
585 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySelfPermission(),
586 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "No system permission"),
587 "No system permission");
588 napi_value result = nullptr;
589 size_t argc = ARGS_ONE;
590 napi_value args[ARGS_ONE] = {};
591 auto *napiAudioVolumeManager = GetParamWithSync(env, info, argc, args);
592 CHECK_AND_RETURN_RET_LOG(argc >= ARGS_ONE, NapiAudioError::ThrowErrorAndReturn(env,
593 NAPI_ERR_INVALID_PARAM, "mandatory parameters are left unspecified"), "invalid arguments");
594
595 napi_valuetype valueType = napi_undefined;
596 napi_typeof(env, args[PARAM0], &valueType);
597 CHECK_AND_RETURN_RET_LOG(valueType == napi_number, NapiAudioError::ThrowErrorAndReturn(env,
598 NAPI_ERR_INVALID_PARAM, "incorrect parameter types: The type of audioVolumeType must be number"),
599 "invalid valueType");
600
601 int32_t volType;
602 NapiParamUtils::GetValueInt32(env, volType, args[PARAM0]);
603 CHECK_AND_RETURN_RET_LOG(NapiAudioEnum::IsLegalInputArgumentVolType(volType),
604 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
605 "parameter verification failed: The param of volType must be enum AudioVolumeType"),
606 "get volType failed");
607
608 if (napiAudioVolumeManager == nullptr || napiAudioVolumeManager->audioSystemMngr_ == nullptr) {
609 AUDIO_ERR_LOG("napiAudioVolumeManager or audioSystemMngr is nullptr!");
610 return nullptr;
611 }
612 int32_t maxSystemVolume = napiAudioVolumeManager->audioSystemMngr_->GetMaxVolume(
613 NapiAudioEnum::GetNativeAudioVolumeType(volType));
614 NapiParamUtils::SetValueInt32(env, maxSystemVolume, result);
615 return result;
616 }
617
IsSystemMuted(napi_env env,napi_callback_info info)618 napi_value NapiAudioVolumeManager::IsSystemMuted(napi_env env, napi_callback_info info)
619 {
620 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySelfPermission(),
621 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "No system permission"),
622 "No system permission");
623 napi_value result = nullptr;
624 size_t argc = ARGS_ONE;
625 napi_value args[ARGS_ONE] = {};
626 auto *napiAudioVolumeManager = GetParamWithSync(env, info, argc, args);
627 CHECK_AND_RETURN_RET_LOG(argc >= ARGS_ONE, NapiAudioError::ThrowErrorAndReturn(env,
628 NAPI_ERR_INVALID_PARAM, "mandatory parameters are left unspecified"), "invalid arguments");
629
630 napi_valuetype valueType = napi_undefined;
631 napi_typeof(env, args[PARAM0], &valueType);
632 CHECK_AND_RETURN_RET_LOG(valueType == napi_number, NapiAudioError::ThrowErrorAndReturn(env,
633 NAPI_ERR_INVALID_PARAM, "incorrect parameter types: The type of audioVolumeType must be number"),
634 "invalid valueType");
635
636 int32_t volType;
637 NapiParamUtils::GetValueInt32(env, volType, args[PARAM0]);
638 CHECK_AND_RETURN_RET_LOG(NapiAudioEnum::IsLegalInputArgumentVolType(volType),
639 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
640 "parameter verification failed: The param of volType must be enum AudioVolumeType"),
641 "get volType failed");
642
643 if (napiAudioVolumeManager == nullptr || napiAudioVolumeManager->audioSystemMngr_ == nullptr) {
644 AUDIO_ERR_LOG("napiAudioVolumeManager or audioSystemMngr is nullptr!");
645 return nullptr;
646 }
647 bool isMuted = napiAudioVolumeManager->audioSystemMngr_->IsStreamMute(
648 NapiAudioEnum::GetNativeAudioVolumeType(volType));
649 NapiParamUtils::SetValueBoolean(env, isMuted, result);
650 return result;
651 }
652
GetVolumeInUnitOfDb(napi_env env,napi_callback_info info)653 napi_value NapiAudioVolumeManager::GetVolumeInUnitOfDb(napi_env env, napi_callback_info info)
654 {
655 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySelfPermission(),
656 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "No system permission"),
657 "No system permission");
658 napi_value result = nullptr;
659 size_t argc = ARGS_THREE;
660 napi_value args[ARGS_THREE] = {};
661 auto *napiAudioVolumeManager = GetParamWithSync(env, info, argc, args);
662 CHECK_AND_RETURN_RET_LOG(argc >= ARGS_THREE, NapiAudioError::ThrowErrorAndReturn(env,
663 NAPI_ERR_INVALID_PARAM, "mandatory parameters are left unspecified"), "invalid arguments");
664 for (size_t i = 0; i < argc; i++) {
665 napi_valuetype valueType = napi_undefined;
666 napi_typeof(env, args[i], &valueType);
667 CHECK_AND_RETURN_RET_LOG(valueType == napi_number, NapiAudioError::ThrowErrorAndReturn(env,
668 NAPI_ERR_INVALID_PARAM, "incorrect parameter types: The type of parameter must be number"),
669 "invalid valueType");
670 }
671 int32_t volType;
672 int32_t volLevel;
673 int32_t deviceType;
674 NapiParamUtils::GetValueInt32(env, volType, args[PARAM0]);
675 NapiParamUtils::GetValueInt32(env, volLevel, args[PARAM1]);
676 NapiParamUtils::GetValueInt32(env, deviceType, args[PARAM2]);
677 CHECK_AND_RETURN_RET_LOG(NapiAudioEnum::IsLegalInputArgumentVolType(volType),
678 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
679 "parameter verification failed: The param of volType must be enum AudioVolumeType"),
680 "get volType failed");
681 CHECK_AND_RETURN_RET_LOG(NapiAudioEnum::IsLegalInputArgumentDeviceType(deviceType),
682 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
683 "parameter verification failed: The param of deviceType must be enum DeviceType"),
684 "get deviceType failed");
685 if (napiAudioVolumeManager == nullptr) {
686 AUDIO_ERR_LOG("napiAudioVolumeManager is nullptr!");
687 return nullptr;
688 }
689 float volumeInDb = napiAudioVolumeManager->audioSystemMngr_->GetVolumeInUnitOfDb(
690 NapiAudioEnum::GetNativeAudioVolumeType(volType),
691 volLevel, static_cast<DeviceType>(deviceType));
692 CHECK_AND_RETURN_RET_LOG(!FLOAT_COMPARE_EQ(volumeInDb, static_cast<float>(ERR_INVALID_PARAM)),
693 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM, "volumeInDb invalid"),
694 "getsystemvolumeindb failed");
695 NapiParamUtils::SetValueDouble(env, volumeInDb, result);
696 return result;
697 }
698
GetVolumeByStream(napi_env env,napi_callback_info info)699 napi_value NapiAudioVolumeManager::GetVolumeByStream(napi_env env, napi_callback_info info)
700 {
701 napi_value result = nullptr;
702 size_t argc = ARGS_ONE;
703 napi_value args[ARGS_ONE] = {};
704 auto *napiAudioVolumeManager = GetParamWithSync(env, info, argc, args);
705 CHECK_AND_RETURN_RET_LOG(argc >= ARGS_ONE, NapiAudioError::ThrowErrorAndReturn(env,
706 NAPI_ERR_INVALID_PARAM, "mandatory parameters are left unspecified"), "invalid arguments");
707
708 napi_valuetype valueType = napi_undefined;
709 napi_typeof(env, args[PARAM0], &valueType);
710 CHECK_AND_RETURN_RET_LOG(valueType == napi_number, NapiAudioError::ThrowErrorAndReturn(env,
711 NAPI_ERR_INVALID_PARAM, "incorrect parameter types: The type of streamUsage must be number"),
712 "invalid valueType");
713
714 int32_t streamUsage;
715 NapiParamUtils::GetValueInt32(env, streamUsage, args[PARAM0]);
716 CHECK_AND_RETURN_RET_LOG(NapiAudioEnum::IsLegalInputArgumentStreamUsage(streamUsage),
717 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
718 "parameter verification failed: The param of streamUsage must be enum StreamUsage"),
719 "get volType failed");
720
721 if (napiAudioVolumeManager == nullptr || napiAudioVolumeManager->audioSystemMngr_ == nullptr) {
722 AUDIO_ERR_LOG("napiAudioVolumeManager or audioSystemMngr is nullptr!");
723 return nullptr;
724 }
725 int32_t volume = napiAudioVolumeManager->audioSystemMngr_->GetVolumeByUsage(
726 NapiAudioEnum::GetNativeStreamUsage(streamUsage));
727 if (volume == ERR_PERMISSION_DENIED) {
728 return NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "No system permission");
729 }
730 if (volume == ERR_NOT_SUPPORTED) {
731 return NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM, "streamUsage not supported");
732 }
733 NapiParamUtils::SetValueInt32(env, volume, result);
734 return result;
735 }
736
GetMinVolumeByStream(napi_env env,napi_callback_info info)737 napi_value NapiAudioVolumeManager::GetMinVolumeByStream(napi_env env, napi_callback_info info)
738 {
739 napi_value result = nullptr;
740 size_t argc = ARGS_ONE;
741 napi_value args[ARGS_ONE] = {};
742 auto *napiAudioVolumeManager = GetParamWithSync(env, info, argc, args);
743 CHECK_AND_RETURN_RET_LOG(argc >= ARGS_ONE, NapiAudioError::ThrowErrorAndReturn(env,
744 NAPI_ERR_INVALID_PARAM, "mandatory parameters are left unspecified"), "invalid arguments");
745
746 napi_valuetype valueType = napi_undefined;
747 napi_typeof(env, args[PARAM0], &valueType);
748 CHECK_AND_RETURN_RET_LOG(valueType == napi_number, NapiAudioError::ThrowErrorAndReturn(env,
749 NAPI_ERR_INVALID_PARAM, "incorrect parameter types: The type of streamUsage must be number"),
750 "invalid valueType");
751
752 int32_t streamUsage;
753 NapiParamUtils::GetValueInt32(env, streamUsage, args[PARAM0]);
754 CHECK_AND_RETURN_RET_LOG(NapiAudioEnum::IsLegalInputArgumentStreamUsage(streamUsage),
755 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
756 "parameter verification failed: The param of streamUsage must be enum StreamUsage"),
757 "get volType failed");
758
759 if (napiAudioVolumeManager == nullptr || napiAudioVolumeManager->audioSystemMngr_ == nullptr) {
760 AUDIO_ERR_LOG("napiAudioVolumeManager or audioSystemMngr is nullptr!");
761 return nullptr;
762 }
763 int32_t minVolume = napiAudioVolumeManager->audioSystemMngr_->GetMinVolumeByUsage(
764 NapiAudioEnum::GetNativeStreamUsage(streamUsage));
765 if (minVolume == ERR_PERMISSION_DENIED) {
766 return NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "No system permission");
767 }
768 if (minVolume == ERR_NOT_SUPPORTED) {
769 return NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM, "streamUsage not supported");
770 }
771 NapiParamUtils::SetValueInt32(env, minVolume, result);
772 return result;
773 }
774
GetMaxVolumeByStream(napi_env env,napi_callback_info info)775 napi_value NapiAudioVolumeManager::GetMaxVolumeByStream(napi_env env, napi_callback_info info)
776 {
777 napi_value result = nullptr;
778 size_t argc = ARGS_ONE;
779 napi_value args[ARGS_ONE] = {};
780 auto *napiAudioVolumeManager = GetParamWithSync(env, info, argc, args);
781 CHECK_AND_RETURN_RET_LOG(argc >= ARGS_ONE, NapiAudioError::ThrowErrorAndReturn(env,
782 NAPI_ERR_INVALID_PARAM, "mandatory parameters are left unspecified"), "invalid arguments");
783
784 napi_valuetype valueType = napi_undefined;
785 napi_typeof(env, args[PARAM0], &valueType);
786 CHECK_AND_RETURN_RET_LOG(valueType == napi_number, NapiAudioError::ThrowErrorAndReturn(env,
787 NAPI_ERR_INVALID_PARAM, "incorrect parameter types: The type of streamUsage must be number"),
788 "invalid valueType");
789
790 int32_t streamUsage;
791 NapiParamUtils::GetValueInt32(env, streamUsage, args[PARAM0]);
792 CHECK_AND_RETURN_RET_LOG(NapiAudioEnum::IsLegalInputArgumentStreamUsage(streamUsage),
793 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
794 "parameter verification failed: The param of streamUsage must be enum StreamUsage"),
795 "get volType failed");
796
797 if (napiAudioVolumeManager == nullptr || napiAudioVolumeManager->audioSystemMngr_ == nullptr) {
798 AUDIO_ERR_LOG("napiAudioVolumeManager or audioSystemMngr is nullptr!");
799 return nullptr;
800 }
801 int32_t maxVolume = napiAudioVolumeManager->audioSystemMngr_->GetMaxVolumeByUsage(
802 NapiAudioEnum::GetNativeStreamUsage(streamUsage));
803 if (maxVolume == ERR_PERMISSION_DENIED) {
804 return NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "No system permission");
805 }
806 if (maxVolume == ERR_NOT_SUPPORTED) {
807 return NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM, "streamUsage not supported");
808 }
809 NapiParamUtils::SetValueInt32(env, maxVolume, result);
810 return result;
811 }
812
IsSystemMutedForStream(napi_env env,napi_callback_info info)813 napi_value NapiAudioVolumeManager::IsSystemMutedForStream(napi_env env, napi_callback_info info)
814 {
815 napi_value result = nullptr;
816 size_t argc = ARGS_ONE;
817 napi_value args[ARGS_ONE] = {};
818 auto *napiAudioVolumeManager = GetParamWithSync(env, info, argc, args);
819 CHECK_AND_RETURN_RET_LOG(argc >= ARGS_ONE, NapiAudioError::ThrowErrorAndReturn(env,
820 NAPI_ERR_INVALID_PARAM, "mandatory parameters are left unspecified"), "invalid arguments");
821
822 napi_valuetype valueType = napi_undefined;
823 napi_typeof(env, args[PARAM0], &valueType);
824 CHECK_AND_RETURN_RET_LOG(valueType == napi_number, NapiAudioError::ThrowErrorAndReturn(env,
825 NAPI_ERR_INVALID_PARAM, "incorrect parameter types: The type of streamUsage must be number"),
826 "invalid valueType");
827
828 int32_t streamUsage;
829 NapiParamUtils::GetValueInt32(env, streamUsage, args[PARAM0]);
830 CHECK_AND_RETURN_RET_LOG(NapiAudioEnum::IsLegalInputArgumentStreamUsage(streamUsage),
831 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
832 "parameter verification failed: The param of streamUsage must be enum StreamUsage"),
833 "get volType failed");
834
835 if (napiAudioVolumeManager == nullptr || napiAudioVolumeManager->audioSystemMngr_ == nullptr) {
836 AUDIO_ERR_LOG("napiAudioVolumeManager or audioSystemMngr is nullptr!");
837 return nullptr;
838 }
839 bool isMuted;
840 int32_t status = napiAudioVolumeManager->audioSystemMngr_->IsStreamMuteByUsage(
841 NapiAudioEnum::GetNativeStreamUsage(streamUsage), isMuted);
842 if (status == ERR_PERMISSION_DENIED) {
843 return NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "No system permission");
844 }
845 if (status == ERR_NOT_SUPPORTED) {
846 return NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM, "streamUsage not supported");
847 }
848 NapiParamUtils::SetValueBoolean(env, isMuted, result);
849 return result;
850 }
851
GetVolumeInUnitOfDbByStream(napi_env env,napi_callback_info info)852 napi_value NapiAudioVolumeManager::GetVolumeInUnitOfDbByStream(napi_env env, napi_callback_info info)
853 {
854 napi_value result = nullptr;
855 size_t argc = ARGS_THREE;
856 napi_value args[ARGS_THREE] = {};
857 auto *napiAudioVolumeManager = GetParamWithSync(env, info, argc, args);
858 CHECK_AND_RETURN_RET_LOG(argc >= ARGS_THREE, NapiAudioError::ThrowErrorAndReturn(env,
859 NAPI_ERR_INVALID_PARAM, "mandatory parameters are left unspecified"), "invalid arguments");
860 for (size_t i = 0; i < argc; i++) {
861 napi_valuetype valueType = napi_undefined;
862 napi_typeof(env, args[i], &valueType);
863 CHECK_AND_RETURN_RET_LOG(valueType == napi_number, NapiAudioError::ThrowErrorAndReturn(env,
864 NAPI_ERR_INVALID_PARAM, "incorrect parameter types: The type of parameter must be number"),
865 "invalid valueType");
866 }
867 int32_t streamUsage;
868 int32_t volLevel;
869 int32_t deviceType;
870 NapiParamUtils::GetValueInt32(env, streamUsage, args[PARAM0]);
871 NapiParamUtils::GetValueInt32(env, volLevel, args[PARAM1]);
872 NapiParamUtils::GetValueInt32(env, deviceType, args[PARAM2]);
873 CHECK_AND_RETURN_RET_LOG(NapiAudioEnum::IsLegalInputArgumentStreamUsage(streamUsage),
874 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
875 "parameter verification failed: The param of streamUsage must be enum StreamUsage"),
876 "get streamUsage failed");
877 CHECK_AND_RETURN_RET_LOG(NapiAudioEnum::IsLegalInputArgumentDeviceType(deviceType),
878 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
879 "parameter verification failed: The param of deviceType must be enum DeviceType"),
880 "get deviceType failed");
881 if (napiAudioVolumeManager == nullptr || napiAudioVolumeManager->audioSystemMngr_ == nullptr) {
882 AUDIO_ERR_LOG("napiAudioVolumeManager or audioSystemMngr_ is nullptr!");
883 return nullptr;
884 }
885 float volumeInDb = napiAudioVolumeManager->audioSystemMngr_->GetVolumeInDbByStream(
886 NapiAudioEnum::GetNativeStreamUsage(streamUsage),
887 volLevel, static_cast<DeviceType>(deviceType));
888 CHECK_AND_RETURN_RET_LOG(!FLOAT_COMPARE_EQ(volumeInDb, static_cast<float>(ERR_PERMISSION_DENIED)),
889 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "No system permission"),
890 "getsystemvolumeindb failed");
891 CHECK_AND_RETURN_RET_LOG(!FLOAT_COMPARE_EQ(volumeInDb, static_cast<float>(ERR_NOT_SUPPORTED)),
892 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM, "streamUsage not supported"),
893 "getsystemvolumeindb failed");
894 NapiParamUtils::SetValueDouble(env, volumeInDb, result);
895 return result;
896 }
897
GetSupportedAudioVolumeTypes(napi_env env,napi_callback_info info)898 napi_value NapiAudioVolumeManager::GetSupportedAudioVolumeTypes(napi_env env, napi_callback_info info)
899 {
900 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySelfPermission(),
901 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "No system permission"),
902 "No system permission");
903 napi_value result = nullptr;
904 size_t argc = ARGS_ZERO;
905 napi_value args[ARGS_ONE] = {};
906 auto *napiAudioVolumeManager = GetParamWithSync(env, info, argc, args);
907 CHECK_AND_RETURN_RET_LOG(argc >= ARGS_ZERO, NapiAudioError::ThrowErrorAndReturn(env,
908 NAPI_ERR_INVALID_PARAM, "mandatory parameters are left unspecified"), "invalid arguments");
909
910 if (napiAudioVolumeManager == nullptr || napiAudioVolumeManager->audioSystemMngr_ == nullptr) {
911 AUDIO_ERR_LOG("napiAudioVolumeManager or audioSystemMngr is nullptr!");
912 return nullptr;
913 }
914 std::vector<AudioVolumeType> volTypes = napiAudioVolumeManager->audioSystemMngr_->GetSupportedAudioVolumeTypes();
915 NapiParamUtils::SetValueAudioVolumeTypeArray(env, volTypes, result);
916 return result;
917 }
918
GetAudioVolumeTypeByStreamUsage(napi_env env,napi_callback_info info)919 napi_value NapiAudioVolumeManager::GetAudioVolumeTypeByStreamUsage(napi_env env, napi_callback_info info)
920 {
921 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySelfPermission(),
922 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "No system permission"),
923 "No system permission");
924 napi_value result = nullptr;
925 size_t argc = ARGS_ONE;
926 napi_value args[ARGS_ONE] = {};
927 auto *napiAudioVolumeManager = GetParamWithSync(env, info, argc, args);
928 CHECK_AND_RETURN_RET_LOG(argc >= ARGS_ONE, NapiAudioError::ThrowErrorAndReturn(env,
929 NAPI_ERR_INVALID_PARAM, "mandatory parameters are left unspecified"), "invalid arguments");
930
931 napi_valuetype valueType = napi_undefined;
932 napi_typeof(env, args[PARAM0], &valueType);
933 CHECK_AND_RETURN_RET_LOG(valueType == napi_number, NapiAudioError::ThrowErrorAndReturn(env,
934 NAPI_ERR_INVALID_PARAM, "incorrect parameter types: The type of streamUsage must be number"),
935 "invalid valueType");
936
937 int32_t streamUsage;
938 NapiParamUtils::GetValueInt32(env, streamUsage, args[PARAM0]);
939 CHECK_AND_RETURN_RET_LOG(NapiAudioEnum::IsLegalInputArgumentStreamUsage(streamUsage),
940 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
941 "parameter verification failed: The param of streamUsage must be enum StreamUsage"),
942 "get volType failed");
943
944 if (napiAudioVolumeManager == nullptr || napiAudioVolumeManager->audioSystemMngr_ == nullptr) {
945 AUDIO_ERR_LOG("napiAudioVolumeManager or audioSystemMngr is nullptr!");
946 return nullptr;
947 }
948 AudioVolumeType volType = napiAudioVolumeManager->audioSystemMngr_->GetAudioVolumeTypeByStreamUsage(
949 NapiAudioEnum::GetNativeStreamUsage(streamUsage));
950 if (volType == STREAM_DEFAULT) {
951 return NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "No system permission");
952 }
953
954 NapiParamUtils::SetValueInt32(env, NapiAudioEnum::GetJsAudioVolumeType(volType), result);
955 return result;
956 }
957
GetStreamUsagesByVolumeType(napi_env env,napi_callback_info info)958 napi_value NapiAudioVolumeManager::GetStreamUsagesByVolumeType(napi_env env, napi_callback_info info)
959 {
960 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySelfPermission(),
961 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "No system permission"),
962 "No system permission");
963 napi_value result = nullptr;
964 size_t argc = ARGS_ONE;
965 napi_value args[ARGS_ONE] = {};
966 auto *napiAudioVolumeManager = GetParamWithSync(env, info, argc, args);
967 CHECK_AND_RETURN_RET_LOG(argc >= ARGS_ONE, NapiAudioError::ThrowErrorAndReturn(env,
968 NAPI_ERR_INVALID_PARAM, "mandatory parameters are left unspecified"), "invalid arguments");
969
970 napi_valuetype valueType = napi_undefined;
971 napi_typeof(env, args[PARAM0], &valueType);
972 CHECK_AND_RETURN_RET_LOG(valueType == napi_number, NapiAudioError::ThrowErrorAndReturn(env,
973 NAPI_ERR_INVALID_PARAM, "incorrect parameter types: The type of audioVolumeType must be number"),
974 "invalid valueType");
975
976 int32_t volType;
977 NapiParamUtils::GetValueInt32(env, volType, args[PARAM0]);
978 CHECK_AND_RETURN_RET_LOG(NapiAudioEnum::IsLegalInputArgumentVolType(volType),
979 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
980 "parameter verification failed: The param of volType must be enum AudioVolumeType"),
981 "get volType failed");
982
983 if (napiAudioVolumeManager == nullptr || napiAudioVolumeManager->audioSystemMngr_ == nullptr) {
984 AUDIO_ERR_LOG("napiAudioVolumeManager or audioSystemMngr is nullptr!");
985 return nullptr;
986 }
987 std::vector<StreamUsage> streamUsages = napiAudioVolumeManager->audioSystemMngr_->GetStreamUsagesByVolumeType(
988 NapiAudioEnum::GetNativeAudioVolumeType(volType));
989 NapiParamUtils::SetValueStreamUsageArray(env, streamUsages, result);
990 return result;
991 }
992
993
GetVolumeGroupManager(napi_env env,napi_callback_info info)994 napi_value NapiAudioVolumeManager::GetVolumeGroupManager(napi_env env, napi_callback_info info)
995 {
996 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
997 if (context == nullptr) {
998 AUDIO_ERR_LOG("GetVolumeGroupManager failed : no memory");
999 NapiAudioError::ThrowError(env, "GetVolumeGroupManager failed : no memory", NAPI_ERR_NO_MEMORY);
1000 return NapiParamUtils::GetUndefinedValue(env);
1001 }
1002
1003 auto inputParser = [env, context](size_t argc, napi_value *argv) {
1004 NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
1005 NAPI_ERR_INVALID_PARAM);
1006 context->status = NapiParamUtils::GetValueInt32(env, context->groupId, argv[PARAM0]);
1007 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get groupId failed",
1008 NAPI_ERR_INVALID_PARAM);
1009 };
1010 context->GetCbInfo(env, info, inputParser);
1011 auto executor = [context]() {
1012 context->audioGroupManager = AudioSystemManager::GetInstance()->GetGroupManager(context->groupId);
1013 };
1014
1015 auto complete = [env, context](napi_value &output) {
1016 if (context->audioGroupManager == nullptr) {
1017 AUDIO_ERR_LOG("Failed to get group manager!");
1018 NapiAudioVolumeGroupManager::isConstructSuccess_ = NAPI_ERR_INVALID_PARAM;
1019 output = NapiParamUtils::GetUndefinedValue(env);
1020 } else {
1021 output = NapiAudioVolumeGroupManager::CreateAudioVolumeGroupManagerWrapper(env, context->groupId);
1022 }
1023 NapiAudioVolumeGroupManager::isConstructSuccess_ = SUCCESS;
1024 };
1025 return NapiAsyncWork::Enqueue(env, context, "GetVolumeGroupManager", executor, complete);
1026 }
1027
GetVolumeGroupManagerSync(napi_env env,napi_callback_info info)1028 napi_value NapiAudioVolumeManager::GetVolumeGroupManagerSync(napi_env env, napi_callback_info info)
1029 {
1030 napi_value result = nullptr;
1031 size_t argc = ARGS_ONE;
1032 napi_value args[ARGS_ONE] = {};
1033 napi_status status = NapiParamUtils::GetParam(env, info, argc, args);
1034 CHECK_AND_RETURN_RET_LOG(status == napi_ok, result, "getparam failed");
1035 CHECK_AND_RETURN_RET_LOG(argc == ARGS_ONE, NapiAudioError::ThrowErrorAndReturn(env,
1036 NAPI_ERR_INPUT_INVALID, "mandatory parameters are left unspecified"), "invalid arguments");
1037
1038 napi_valuetype valueType = napi_undefined;
1039 napi_typeof(env, args[PARAM0], &valueType);
1040 CHECK_AND_RETURN_RET_LOG(valueType == napi_number, NapiAudioError::ThrowErrorAndReturn(env,
1041 NAPI_ERR_INPUT_INVALID, "incorrect parameter types: The type of groupId must be number"),
1042 "invalid valueType");
1043
1044 int32_t groupId;
1045 NapiParamUtils::GetValueInt32(env, groupId, args[PARAM0]);
1046
1047 if (AudioSystemManager::GetInstance()->GetGroupManager(groupId) == nullptr) {
1048 AUDIO_ERR_LOG("Failed to get group manager!");
1049 NapiAudioVolumeGroupManager::isConstructSuccess_ = NAPI_ERR_INVALID_PARAM;
1050 result = NapiParamUtils::GetUndefinedValue(env);
1051 } else {
1052 result = NapiAudioVolumeGroupManager::CreateAudioVolumeGroupManagerWrapper(env, groupId);
1053 }
1054
1055 napi_value undefinedValue = nullptr;
1056 napi_get_undefined(env, &undefinedValue);
1057 bool isEqual = false;
1058 napi_strict_equals(env, result, undefinedValue, &isEqual);
1059 if (isEqual) {
1060 AUDIO_ERR_LOG("The audio volume group manager is undefined!");
1061 NapiAudioError::ThrowError(env, "GetVolumeGroupManagerSync failed: invalid param",
1062 NAPI_ERR_INVALID_PARAM);
1063 return result;
1064 }
1065
1066 return result;
1067 }
1068
RegisterCallback(napi_env env,napi_value jsThis,size_t argc,napi_value * args,const std::string & cbName)1069 napi_value NapiAudioVolumeManager::RegisterCallback(napi_env env, napi_value jsThis, size_t argc, napi_value *args,
1070 const std::string &cbName)
1071 {
1072 napi_value undefinedResult = nullptr;
1073 NapiAudioVolumeManager *napiVolumeManager = nullptr;
1074 napi_status status = napi_unwrap(env, jsThis, reinterpret_cast<void **>(&napiVolumeManager));
1075 CHECK_AND_RETURN_RET_LOG(status == napi_ok, NapiAudioError::ThrowErrorAndReturn(env,
1076 NAPI_ERR_SYSTEM), "status error");
1077 CHECK_AND_RETURN_RET_LOG(napiVolumeManager != nullptr, NapiAudioError::ThrowErrorAndReturn(env,
1078 NAPI_ERR_NO_MEMORY), "napiVolumeManager is nullptr");
1079 CHECK_AND_RETURN_RET_LOG(napiVolumeManager->audioSystemMngr_ != nullptr, NapiAudioError::ThrowErrorAndReturn(
1080 env, NAPI_ERR_NO_MEMORY), "audioSystemMngr_ is nullptr");
1081
1082 if (!cbName.compare(VOLUME_KEY_EVENT_CALLBACK_NAME)) {
1083 if (napiVolumeManager->volumeKeyEventCallbackNapi_ == nullptr) {
1084 napiVolumeManager->volumeKeyEventCallbackNapi_ = std::make_shared<NapiAudioVolumeKeyEvent>(env);
1085 int32_t ret = napiVolumeManager->audioSystemMngr_->RegisterVolumeKeyEventCallback(
1086 napiVolumeManager->cachedClientId_, napiVolumeManager->volumeKeyEventCallbackNapi_);
1087 napiVolumeManager->volumeKeyEventCallbackNapiList_.push_back(
1088 std::static_pointer_cast<NapiAudioVolumeKeyEvent>(napiVolumeManager->volumeKeyEventCallbackNapi_));
1089 if (ret) {
1090 AUDIO_ERR_LOG("RegisterVolumeKeyEventCallback Failed");
1091 }
1092 }
1093 std::shared_ptr<NapiAudioVolumeKeyEvent> cb =
1094 std::static_pointer_cast<NapiAudioVolumeKeyEvent>(napiVolumeManager->volumeKeyEventCallbackNapi_);
1095 cb->SaveCallbackReference(cbName, args[PARAM1]);
1096 if (!cb->GetVolumeTsfnFlag()) {
1097 cb->CreateVolumeTsfn(env);
1098 }
1099 } else if (!cbName.compare(APP_VOLUME_CHANGE_CALLBACK_NAME)) {
1100 undefinedResult = RegisterSelfAppVolumeChangeCallback(env, args, cbName,
1101 napiVolumeManager);
1102 } else if (!cbName.compare(APP_VOLUME_CHANGE_CALLBACK_NAME_FOR_UID)) {
1103 undefinedResult = RegisterAppVolumeChangeForUidCallback(env, args, cbName,
1104 napiVolumeManager);
1105 } else if (!cbName.compare(ACTIVE_VOLUME_TYPE_CHANGE_CALLBACK_NAME)) {
1106 undefinedResult = RegisterActiveVolumeTypeChangeCallback(env, args, cbName,
1107 napiVolumeManager);
1108 } else if (!cbName.compare(AUDIO_STREAM_VOLUME_CHANGE_CALLBACK_NAME)) {
1109 undefinedResult = RegisterStreamVolumeChangeCallback(env, args, cbName,
1110 napiVolumeManager);
1111 } else if (!cbName.compare(AUDIO_SYSTEM_VOLUME_CHANGE_CALLBACK_NAME)) {
1112 undefinedResult = RegisterSystemVolumeChangeCallback(env, args, cbName,
1113 napiVolumeManager);
1114 } else {
1115 AUDIO_ERR_LOG("No such callback supported");
1116 NapiAudioError::ThrowError(env, NAPI_ERR_INVALID_PARAM,
1117 "parameter verification failed: The param of type is not supported");
1118 }
1119 return undefinedResult;
1120 }
1121
RegisterActiveVolumeTypeChangeCallback(napi_env env,napi_value * args,const std::string & cbName,NapiAudioVolumeManager * napiAudioVolumeManager)1122 napi_value NapiAudioVolumeManager::RegisterActiveVolumeTypeChangeCallback(napi_env env, napi_value *args,
1123 const std::string &cbName, NapiAudioVolumeManager *napiAudioVolumeManager)
1124 {
1125 napi_value result = nullptr;
1126 napi_get_undefined(env, &result);
1127 if (napiAudioVolumeManager->activeVolumeTypeChangeCallbackNapi_ == nullptr) {
1128 napiAudioVolumeManager->activeVolumeTypeChangeCallbackNapi_ =
1129 std::make_shared<NapiAudioManagerActiveVolumeTypeChangeCallback>(env);
1130 CHECK_AND_RETURN_RET_LOG(napiAudioVolumeManager->activeVolumeTypeChangeCallbackNapi_ != nullptr,
1131 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_SYSTEM, "System error"),
1132 "RegisterActiveVolumeTypeChangeForUidCallback: Memory Allocation Failed !");
1133 int32_t ret = napiAudioVolumeManager->audioSystemMngr_->SetActiveVolumeTypeCallback(
1134 napiAudioVolumeManager->activeVolumeTypeChangeCallbackNapi_);
1135 if (ret != SUCCESS) {
1136 if (ret == ERROR_INVALID_PARAM) {
1137 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM, "Invalid parameter");
1138 } else if (ret == ERR_PERMISSION_DENIED) {
1139 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "Permission denied");
1140 } else {
1141 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_SYSTEM, "System error");
1142 }
1143 }
1144 }
1145 std::shared_ptr<NapiAudioManagerActiveVolumeTypeChangeCallback> cb =
1146 std::static_pointer_cast<NapiAudioManagerActiveVolumeTypeChangeCallback>(
1147 napiAudioVolumeManager->activeVolumeTypeChangeCallbackNapi_);
1148 cb->SaveActiveVolumeTypeChangeCallbackReference(cbName, args[PARAM1]);
1149 if (!cb->GetManagerActiveVolumeTypeChangeTsfnFlag()) {
1150 cb->CreateManagerActiveVolumeTypeChangeTsfn(env);
1151 }
1152 return result;
1153 }
1154
RegisterAppVolumeChangeForUidCallback(napi_env env,napi_value * args,const std::string & cbName,NapiAudioVolumeManager * napiAudioVolumeManager)1155 napi_value NapiAudioVolumeManager::RegisterAppVolumeChangeForUidCallback(napi_env env, napi_value *args,
1156 const std::string &cbName, NapiAudioVolumeManager *napiAudioVolumeManager)
1157 {
1158 napi_value result = nullptr;
1159 napi_get_undefined(env, &result);
1160 int32_t appUid = 0;
1161 NapiParamUtils::GetValueInt32(env, appUid, args[PARAM1]);
1162 if (napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_ == nullptr) {
1163 napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_ =
1164 std::make_shared<NapiAudioManagerAppVolumeChangeCallback>(env);
1165 }
1166 CHECK_AND_RETURN_RET_LOG(napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_ != nullptr,
1167 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_SYSTEM, "System error"),
1168 "RegisterAppVolumeChangeForUidCallback: Memory Allocation Failed !");
1169 int32_t ret = napiAudioVolumeManager->audioSystemMngr_->SetAppVolumeCallbackForUid(appUid,
1170 napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_);
1171 if (ret != SUCCESS) {
1172 if (ret == ERROR_INVALID_PARAM) {
1173 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
1174 "Parameter verification failed. Invalid callback.");
1175 } else if (ret == ERR_PERMISSION_DENIED) {
1176 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "Permission denied");
1177 } else {
1178 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_SYSTEM, "System error");
1179 }
1180 }
1181 std::shared_ptr<NapiAudioManagerAppVolumeChangeCallback> cb =
1182 std::static_pointer_cast<NapiAudioManagerAppVolumeChangeCallback>(
1183 napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_);
1184 cb->SaveVolumeChangeCallbackForUidReference(cbName, args[PARAM2], appUid);
1185 if (!cb->GetManagerAppVolumeChangeTsfnFlag()) {
1186 cb->CreateManagerAppVolumeChangeTsfn(env);
1187 }
1188 return result;
1189 }
1190
RegisterSelfAppVolumeChangeCallback(napi_env env,napi_value * args,const std::string & cbName,NapiAudioVolumeManager * napiAudioVolumeManager)1191 napi_value NapiAudioVolumeManager::RegisterSelfAppVolumeChangeCallback(napi_env env,
1192 napi_value *args, const std::string &cbName, NapiAudioVolumeManager *napiAudioVolumeManager)
1193 {
1194 napi_value result = nullptr;
1195 napi_get_undefined(env, &result);
1196 if (napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_ == nullptr) {
1197 napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_ =
1198 std::make_shared<NapiAudioManagerAppVolumeChangeCallback>(env);
1199 }
1200 CHECK_AND_RETURN_RET_LOG(napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_ != nullptr,
1201 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_SYSTEM, "System error"),
1202 "napiAudioVolumeManager: Memory Allocation Failed !");
1203 int32_t ret = napiAudioVolumeManager->audioSystemMngr_->SetSelfAppVolumeCallback(
1204 napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_);
1205 if (ret != SUCCESS) {
1206 if (ret == ERROR_INVALID_PARAM) {
1207 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
1208 "Parameter verification failed. Invalid callback.");
1209 } else {
1210 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_SYSTEM, "System error");
1211 }
1212 }
1213 std::shared_ptr<NapiAudioManagerAppVolumeChangeCallback> cb =
1214 std::static_pointer_cast<NapiAudioManagerAppVolumeChangeCallback>(
1215 napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_);
1216 cb->SaveSelfVolumdChangeCallbackReference(cbName, args[PARAM1]);
1217 if (!cb->GetManagerAppVolumeChangeTsfnFlag()) {
1218 cb->CreateManagerAppVolumeChangeTsfn(env);
1219 }
1220 return result;
1221 }
1222
RegisterStreamVolumeChangeCallback(napi_env env,napi_value * args,const std::string & cbName,NapiAudioVolumeManager * napiAudioVolumeManager)1223 napi_value NapiAudioVolumeManager::RegisterStreamVolumeChangeCallback(napi_env env, napi_value *args,
1224 const std::string &cbName, NapiAudioVolumeManager *napiAudioVolumeManager)
1225 {
1226 napi_value result = nullptr;
1227 napi_get_undefined(env, &result);
1228 int32_t streamUsage = 0;
1229 NapiParamUtils::GetValueInt32(env, streamUsage, args[PARAM1]);
1230 if (napiAudioVolumeManager->streamVolumeChangeCallbackNapi_ == nullptr) {
1231 napiAudioVolumeManager->streamVolumeChangeCallbackNapi_ =
1232 std::make_shared<NapiAudioStreamVolumeChangeCallback>(env);
1233 int32_t ret = napiAudioVolumeManager->audioSystemMngr_->RegisterStreamVolumeChangeCallback(
1234 napiAudioVolumeManager->cachedClientId_,
1235 { NapiAudioEnum::GetNativeStreamUsage(streamUsage) },
1236 napiAudioVolumeManager->streamVolumeChangeCallbackNapi_);
1237 napiAudioVolumeManager->streamVolumeChangeCallbackNapiList_.push_back(
1238 std::static_pointer_cast<NapiAudioStreamVolumeChangeCallback>(
1239 napiAudioVolumeManager->streamVolumeChangeCallbackNapi_));
1240 if (ret != SUCCESS) {
1241 if (ret == ERROR_INVALID_PARAM) {
1242 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
1243 "Parameter verification failed. Invalid callback.");
1244 } else {
1245 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_SYSTEM,
1246 "System error.");
1247 }
1248 }
1249 }
1250 std::shared_ptr<NapiAudioStreamVolumeChangeCallback> cb =
1251 std::static_pointer_cast<NapiAudioStreamVolumeChangeCallback>(
1252 napiAudioVolumeManager->streamVolumeChangeCallbackNapi_);
1253 cb->SaveCallbackReference(cbName, args[PARAM2]);
1254 if (!cb->GetVolumeTsfnFlag()) {
1255 cb->CreateStreamVolumeChangeTsfn(env);
1256 }
1257 return result;
1258 }
1259
RegisterSystemVolumeChangeCallback(napi_env env,napi_value * args,const std::string & cbName,NapiAudioVolumeManager * napiAudioVolumeManager)1260 napi_value NapiAudioVolumeManager::RegisterSystemVolumeChangeCallback(napi_env env, napi_value *args,
1261 const std::string &cbName, NapiAudioVolumeManager *napiAudioVolumeManager)
1262 {
1263 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySelfPermission(),
1264 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED, "No system permission"),
1265 "No system permission");
1266 napi_value result = nullptr;
1267 napi_get_undefined(env, &result);
1268 if (napiAudioVolumeManager->systemVolumeChangeCallbackNapi_ == nullptr) {
1269 napiAudioVolumeManager->systemVolumeChangeCallbackNapi_ = std::make_shared<
1270 NapiAudioSystemVolumeChangeCallback>(env);
1271 int32_t ret = napiAudioVolumeManager->audioSystemMngr_->RegisterSystemVolumeChangeCallback(
1272 napiAudioVolumeManager->cachedClientId_, napiAudioVolumeManager->systemVolumeChangeCallbackNapi_);
1273 napiAudioVolumeManager->systemVolumeChangeCallbackNapiList_.push_back(
1274 std::static_pointer_cast<NapiAudioSystemVolumeChangeCallback>(
1275 napiAudioVolumeManager->systemVolumeChangeCallbackNapi_));
1276 if (ret != SUCCESS) {
1277 if (ret == ERROR_INVALID_PARAM) {
1278 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_INVALID_PARAM,
1279 "Parameter verification failed. Invalid callback.");
1280 } else {
1281 NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_SYSTEM,
1282 "System error.");
1283 }
1284 }
1285 }
1286 std::shared_ptr<NapiAudioSystemVolumeChangeCallback> cb =
1287 std::static_pointer_cast<NapiAudioSystemVolumeChangeCallback>(
1288 napiAudioVolumeManager->systemVolumeChangeCallbackNapi_);
1289 cb->SaveCallbackReference(cbName, args[PARAM1]);
1290 if (!cb->GetVolumeTsfnFlag()) {
1291 cb->CreateSystemVolumeChangeTsfn(env);
1292 }
1293 return result;
1294 }
1295
On(napi_env env,napi_callback_info info)1296 napi_value NapiAudioVolumeManager::On(napi_env env, napi_callback_info info)
1297 {
1298 napi_value undefinedResult = nullptr;
1299 napi_get_undefined(env, &undefinedResult);
1300
1301 const size_t minArgCount = ARGS_TWO;
1302 size_t argCount = ARGS_THREE;
1303 napi_value args[minArgCount + PARAM1] = {nullptr, nullptr, nullptr};
1304 napi_value jsThis = nullptr;
1305 napi_status status = napi_get_cb_info(env, info, &argCount, args, &jsThis, nullptr);
1306 if (status != napi_ok || argCount < minArgCount) {
1307 AUDIO_ERR_LOG("On fail to napi_get_cb_info/Requires min 2 parameters");
1308 NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID,
1309 "mandatory parameters are left unspecified");
1310 }
1311
1312 napi_valuetype eventType = napi_undefined;
1313 if (napi_typeof(env, args[PARAM0], &eventType) != napi_ok || eventType != napi_string) {
1314 NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID,
1315 "incorrect parameter types: The type of eventType must be string");
1316 return undefinedResult;
1317 }
1318 std::string callbackName = NapiParamUtils::GetStringArgument(env, args[PARAM0]);
1319 AUDIO_INFO_LOG("On callbackName: %{public}s", callbackName.c_str());
1320
1321 napi_valuetype handler = napi_undefined;
1322 if (napi_typeof(env, args[argCount -1], &handler) != napi_ok || handler != napi_function) {
1323 AUDIO_ERR_LOG("On type mismatch for parameter 2");
1324 NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID,
1325 "incorrect parameter types: The type of callback must be function");
1326 return undefinedResult;
1327 }
1328
1329 return RegisterCallback(env, jsThis, argCount, args, callbackName);
1330 }
1331
Off(napi_env env,napi_callback_info info)1332 napi_value NapiAudioVolumeManager::Off(napi_env env, napi_callback_info info)
1333 {
1334 napi_value undefinedResult = nullptr;
1335 napi_get_undefined(env, &undefinedResult);
1336
1337 const size_t minArgCount = ARGS_ONE;
1338 size_t argc = ARGS_TWO;
1339 napi_value args[minArgCount + PARAM2] = {nullptr, nullptr, nullptr};
1340 napi_value jsThis = nullptr;
1341 napi_status status = napi_get_cb_info(env, info, &argc, args, &jsThis, nullptr);
1342 if (status != napi_ok || argc < minArgCount) {
1343 AUDIO_ERR_LOG("Off fail to napi_get_cb_info/Requires min 1 parameters");
1344 NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID,
1345 "mandatory parameters are left unspecified");
1346 }
1347 napi_valuetype eventType = napi_undefined;
1348 if (napi_typeof(env, args[PARAM0], &eventType) != napi_ok || eventType != napi_string) {
1349 NapiAudioError::ThrowError(env, NAPI_ERR_INPUT_INVALID,
1350 "incorrect parameter types: The type of eventType must be string");
1351 return undefinedResult;
1352 }
1353 std::string callbackName = NapiParamUtils::GetStringArgument(env, args[PARAM0]);
1354 AUDIO_INFO_LOG("Off callbackName: %{public}s", callbackName.c_str());
1355
1356 return UnregisterCallback(env, jsThis, argc, args, callbackName);
1357 }
1358
UnregisterCallback(napi_env env,napi_value jsThis,size_t argc,napi_value * args,const std::string & cbName)1359 napi_value NapiAudioVolumeManager::UnregisterCallback(napi_env env, napi_value jsThis,
1360 size_t argc, napi_value *args, const std::string &cbName)
1361 {
1362 napi_value undefinedResult = nullptr;
1363 NapiAudioVolumeManager *napiVolumeManager = nullptr;
1364 napi_status status = napi_unwrap(env, jsThis, reinterpret_cast<void **>(&napiVolumeManager));
1365 CHECK_AND_RETURN_RET_LOG(status == napi_ok, NapiAudioError::ThrowErrorAndReturn(env,
1366 NAPI_ERR_SYSTEM), "status error");
1367 CHECK_AND_RETURN_RET_LOG(napiVolumeManager != nullptr, NapiAudioError::ThrowErrorAndReturn(env,
1368 NAPI_ERR_NO_MEMORY), "napiVolumeManager is nullptr");
1369 CHECK_AND_RETURN_RET_LOG(napiVolumeManager->audioSystemMngr_ != nullptr, NapiAudioError::ThrowErrorAndReturn(
1370 env, NAPI_ERR_NO_MEMORY), "audioSystemMngr_ is nullptr");
1371
1372 if (!cbName.compare(VOLUME_KEY_EVENT_CALLBACK_NAME)) {
1373 napi_value callback = nullptr;
1374 if (argc == ARGS_TWO) {
1375 callback = args[PARAM1];
1376 }
1377 if (callback != nullptr) {
1378 std::shared_ptr<NapiAudioVolumeKeyEvent> cb = GetVolumeEventNapiCallback(callback, napiVolumeManager);
1379 CHECK_AND_RETURN_RET_LOG(cb != nullptr, undefinedResult, "NapiAudioVolumeKeyEvent is nullptr");
1380 int32_t ret = napiVolumeManager->audioSystemMngr_->UnregisterVolumeKeyEventCallback(
1381 napiVolumeManager->cachedClientId_, cb);
1382 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, undefinedResult, "Unset of VolumeKeyEventCallback failed");
1383 napiVolumeManager->volumeKeyEventCallbackNapiList_.remove(cb);
1384 napiVolumeManager->volumeKeyEventCallbackNapi_.reset();
1385 napiVolumeManager->volumeKeyEventCallbackNapi_ = nullptr;
1386 return undefinedResult;
1387 } else {
1388 int32_t ret = napiVolumeManager->audioSystemMngr_->UnregisterVolumeKeyEventCallback(
1389 napiVolumeManager->cachedClientId_);
1390 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, undefinedResult, "Unset of VolumeKeyEventCallback failed");
1391 napiVolumeManager->volumeKeyEventCallbackNapiList_.clear();
1392 napiVolumeManager->volumeKeyEventCallbackNapi_.reset();
1393 napiVolumeManager->volumeKeyEventCallbackNapi_ = nullptr;
1394 return undefinedResult;
1395 }
1396 } else if (!cbName.compare(APP_VOLUME_CHANGE_CALLBACK_NAME)) {
1397 UnregisterSelfAppVolumeChangeCallback(env, args[PARAM1], argc, napiVolumeManager);
1398 } else if (!cbName.compare(APP_VOLUME_CHANGE_CALLBACK_NAME_FOR_UID)) {
1399 UnregisterAppVolumeChangeForUidCallback(env, args[PARAM1], args, argc, napiVolumeManager);
1400 } else if (!cbName.compare(ACTIVE_VOLUME_TYPE_CHANGE_CALLBACK_NAME)) {
1401 UnregisterActiveVolumeTypeChangeCallback(env, args[PARAM1], args, argc, napiVolumeManager);
1402 } else {
1403 UnregisterCallbackFir(env, args, argc, cbName, napiVolumeManager);
1404 }
1405 return undefinedResult;
1406 }
1407
UnregisterCallbackFir(napi_env env,napi_value * args,size_t argc,const std::string & cbName,NapiAudioVolumeManager * napiVolumeManager)1408 void NapiAudioVolumeManager::UnregisterCallbackFir(napi_env env, napi_value *args,
1409 size_t argc, const std::string &cbName, NapiAudioVolumeManager *napiVolumeManager)
1410 {
1411 if (!cbName.compare(AUDIO_STREAM_VOLUME_CHANGE_CALLBACK_NAME)) {
1412 UnregisterStreamVolumeChangeCallback(env, args, argc, napiVolumeManager);
1413 } else if (!cbName.compare(AUDIO_SYSTEM_VOLUME_CHANGE_CALLBACK_NAME)) {
1414 UnregisterSystemVolumeChangeCallback(env, args, argc, napiVolumeManager);
1415 } else {
1416 AUDIO_ERR_LOG("No such callback supported");
1417 NapiAudioError::ThrowError(env, NAPI_ERR_INVALID_PARAM,
1418 "parameter verification failed: The param of type is not supported");
1419 }
1420 }
1421
UnregisterActiveVolumeTypeChangeCallback(napi_env env,napi_value callback,napi_value * args,size_t argc,NapiAudioVolumeManager * napiAudioVolumeManager)1422 void NapiAudioVolumeManager::UnregisterActiveVolumeTypeChangeCallback(napi_env env, napi_value callback,
1423 napi_value *args, size_t argc, NapiAudioVolumeManager *napiAudioVolumeManager)
1424 {
1425 if (napiAudioVolumeManager == nullptr ||
1426 napiAudioVolumeManager->activeVolumeTypeChangeCallbackNapi_ == nullptr) {
1427 AUDIO_ERR_LOG("napiAudioVolumeManager is nullptr");
1428 NapiAudioError::ThrowError(env, "unregister activeVolumeType callback failed", NAPI_ERR_SYSTEM);
1429 return;
1430 }
1431 std::shared_ptr<NapiAudioManagerActiveVolumeTypeChangeCallback> cb =
1432 std::static_pointer_cast<NapiAudioManagerActiveVolumeTypeChangeCallback>(
1433 napiAudioVolumeManager->activeVolumeTypeChangeCallbackNapi_);
1434 if (callback != nullptr && argc == ARGS_TWO) {
1435 cb->RemoveSelfActiveVolumeTypeChangeCbRef(env, callback);
1436 }
1437 if (argc == ARGS_ONE || cb->GetActiveVolumeTypeChangeListSize() == 0) {
1438 napiAudioVolumeManager->audioSystemMngr_->UnsetActiveVolumeTypeCallback(
1439 napiAudioVolumeManager->activeVolumeTypeChangeCallbackNapi_);
1440 napiAudioVolumeManager->activeVolumeTypeChangeCallbackNapi_.reset();
1441 napiAudioVolumeManager->activeVolumeTypeChangeCallbackNapi_ = nullptr;
1442 cb->RemoveAllActiveVolumeTypeChangeCbRef();
1443 }
1444 }
1445
UnregisterAppVolumeChangeForUidCallback(napi_env env,napi_value callback,napi_value * args,size_t argc,NapiAudioVolumeManager * napiAudioVolumeManager)1446 void NapiAudioVolumeManager::UnregisterAppVolumeChangeForUidCallback(napi_env env, napi_value callback,
1447 napi_value *args, size_t argc, NapiAudioVolumeManager *napiAudioVolumeManager)
1448 {
1449 if (napiAudioVolumeManager == nullptr ||
1450 napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_ == nullptr) {
1451 NapiAudioError::ThrowError(env, "UnregisterAppVolumeChangeForUidCallback failed", NAPI_ERR_SYSTEM);
1452 AUDIO_ERR_LOG("napiAudioVolumeManager is nullptr");
1453 return;
1454 }
1455 std::shared_ptr<NapiAudioManagerAppVolumeChangeCallback> cb =
1456 std::static_pointer_cast<NapiAudioManagerAppVolumeChangeCallback>(
1457 napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_);
1458 if (callback != nullptr) {
1459 cb->RemoveAudioVolumeChangeForUidCbRef(env, callback);
1460 }
1461
1462 if (argc == ARGS_ONE || cb->GetAppVolumeChangeForUidListSize() == 0) {
1463 napiAudioVolumeManager->audioSystemMngr_->UnsetAppVolumeCallbackForUid();
1464 napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_.reset();
1465 napiAudioVolumeManager->appVolumeChangeCallbackForUidNapi_ = nullptr;
1466 cb->RemoveAllAudioVolumeChangeForUidCbRef();
1467 }
1468 }
1469
UnregisterSelfAppVolumeChangeCallback(napi_env env,napi_value callback,size_t argc,NapiAudioVolumeManager * napiAudioVolumeManager)1470 void NapiAudioVolumeManager::UnregisterSelfAppVolumeChangeCallback(napi_env env, napi_value callback,
1471 size_t argc, NapiAudioVolumeManager *napiAudioVolumeManager)
1472 {
1473 if (napiAudioVolumeManager == nullptr ||
1474 napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_ == nullptr) {
1475 AUDIO_ERR_LOG("napiAudioVolumeManager is nullptr");
1476 NapiAudioError::ThrowError(env, "UnregisterSelfAppVolumeChangeCallback failed", NAPI_ERR_SYSTEM);
1477 return;
1478 }
1479 std::shared_ptr<NapiAudioManagerAppVolumeChangeCallback> cb =
1480 std::static_pointer_cast<NapiAudioManagerAppVolumeChangeCallback>(
1481 napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_);
1482 if (callback != nullptr && argc == ARGS_TWO) {
1483 cb->RemoveSelfAudioVolumeChangeCbRef(env, callback);
1484 }
1485 if (argc == ARGS_ONE || cb->GetSelfAppVolumeChangeListSize() == 0) {
1486 napiAudioVolumeManager->audioSystemMngr_->UnsetSelfAppVolumeCallback();
1487 napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_.reset();
1488 napiAudioVolumeManager->selfAppVolumeChangeCallbackNapi_ = nullptr;
1489 cb->RemoveAllSelfAudioVolumeChangeCbRef();
1490 }
1491 }
1492
UnregisterStreamVolumeChangeCallback(napi_env env,napi_value * args,size_t argc,NapiAudioVolumeManager * napiAudioVolumeManager)1493 void NapiAudioVolumeManager::UnregisterStreamVolumeChangeCallback(napi_env env, napi_value *args,
1494 size_t argc, NapiAudioVolumeManager *napiAudioVolumeManager)
1495 {
1496 napi_value callback = nullptr;
1497 if (argc == ARGS_TWO) {
1498 callback = args[PARAM1];
1499 }
1500 if (callback != nullptr) {
1501 std::shared_ptr<NapiAudioStreamVolumeChangeCallback> cb = GetStreamVolumeChangeNapiCallback(
1502 callback, napiAudioVolumeManager);
1503 if (cb == nullptr) {
1504 AUDIO_ERR_LOG("NapiAudioSystemVolumeChangeCallback is nullptr");
1505 return;
1506 }
1507 int32_t ret = napiAudioVolumeManager->audioSystemMngr_->UnregisterStreamVolumeChangeCallback(
1508 napiAudioVolumeManager->cachedClientId_, cb);
1509 if (ret != SUCCESS) {
1510 AUDIO_ERR_LOG("UnregisterStreamVolumeChangeCallback failed");
1511 return;
1512 }
1513 napiAudioVolumeManager->streamVolumeChangeCallbackNapiList_.remove(cb);
1514 napiAudioVolumeManager->streamVolumeChangeCallbackNapi_.reset();
1515 napiAudioVolumeManager->streamVolumeChangeCallbackNapi_ = nullptr;
1516 } else {
1517 int32_t ret = napiAudioVolumeManager->audioSystemMngr_->UnregisterStreamVolumeChangeCallback(
1518 napiAudioVolumeManager->cachedClientId_, nullptr);
1519 if (ret != SUCCESS) {
1520 AUDIO_ERR_LOG("UnregisterStreamVolumeChangeCallback failed");
1521 return;
1522 }
1523 napiAudioVolumeManager->streamVolumeChangeCallbackNapiList_.clear();
1524 napiAudioVolumeManager->streamVolumeChangeCallbackNapi_.reset();
1525 napiAudioVolumeManager->streamVolumeChangeCallbackNapi_ = nullptr;
1526 }
1527 }
1528
UnregisterSystemVolumeChangeCallback(napi_env env,napi_value * args,size_t argc,NapiAudioVolumeManager * napiAudioVolumeManager)1529 void NapiAudioVolumeManager::UnregisterSystemVolumeChangeCallback(napi_env env, napi_value *args,
1530 size_t argc, NapiAudioVolumeManager *napiAudioVolumeManager)
1531 {
1532 CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySelfPermission(),
1533 NapiAudioError::ThrowError(env, NAPI_ERR_PERMISSION_DENIED, "No system permission"),
1534 "No system permission");
1535 napi_value callback = nullptr;
1536 if (argc == ARGS_TWO) {
1537 callback = args[PARAM1];
1538 }
1539 if (callback != nullptr) {
1540 std::shared_ptr<NapiAudioSystemVolumeChangeCallback> cb = GetSystemVolumeChangeNapiCallback(
1541 callback, napiAudioVolumeManager);
1542 if (cb == nullptr) {
1543 AUDIO_ERR_LOG("NapiAudioSystemVolumeChangeCallback is nullptr");
1544 return;
1545 }
1546 int32_t ret = napiAudioVolumeManager->audioSystemMngr_->UnregisterSystemVolumeChangeCallback(
1547 napiAudioVolumeManager->cachedClientId_, cb);
1548 if (ret != SUCCESS) {
1549 AUDIO_ERR_LOG("UnregisterSystemVolumeChangeCallback failed");
1550 return;
1551 }
1552 napiAudioVolumeManager->systemVolumeChangeCallbackNapiList_.remove(cb);
1553 napiAudioVolumeManager->systemVolumeChangeCallbackNapi_.reset();
1554 napiAudioVolumeManager->systemVolumeChangeCallbackNapi_ = nullptr;
1555 } else {
1556 int32_t ret = napiAudioVolumeManager->audioSystemMngr_->UnregisterSystemVolumeChangeCallback(
1557 napiAudioVolumeManager->cachedClientId_, nullptr);
1558 if (ret != SUCCESS) {
1559 AUDIO_ERR_LOG("UnregisterSystemVolumeChangeCallback failed");
1560 return;
1561 }
1562 napiAudioVolumeManager->systemVolumeChangeCallbackNapiList_.clear();
1563 napiAudioVolumeManager->systemVolumeChangeCallbackNapi_.reset();
1564 napiAudioVolumeManager->systemVolumeChangeCallbackNapi_ = nullptr;
1565 }
1566 }
1567
GetVolumeEventNapiCallback(napi_value argv,NapiAudioVolumeManager * napiVolumeManager)1568 std::shared_ptr<NapiAudioVolumeKeyEvent> NapiAudioVolumeManager::GetVolumeEventNapiCallback(napi_value argv,
1569 NapiAudioVolumeManager *napiVolumeManager)
1570 {
1571 std::shared_ptr<NapiAudioVolumeKeyEvent> cb = nullptr;
1572 for (auto &iter : napiVolumeManager->volumeKeyEventCallbackNapiList_) {
1573 if (iter->ContainSameJsCallback(argv)) {
1574 cb = iter;
1575 }
1576 }
1577 return cb;
1578 }
1579
GetStreamVolumeChangeNapiCallback(napi_value argv,NapiAudioVolumeManager * napiVolumeManager)1580 std::shared_ptr<NapiAudioStreamVolumeChangeCallback> NapiAudioVolumeManager::GetStreamVolumeChangeNapiCallback(
1581 napi_value argv, NapiAudioVolumeManager *napiVolumeManager)
1582 {
1583 std::shared_ptr<NapiAudioStreamVolumeChangeCallback> cb = nullptr;
1584 for (auto &iter : napiVolumeManager->streamVolumeChangeCallbackNapiList_) {
1585 if (iter->ContainSameJsCallback(argv)) {
1586 cb = iter;
1587 }
1588 }
1589 return cb;
1590 }
1591
GetSystemVolumeChangeNapiCallback(napi_value argv,NapiAudioVolumeManager * napiVolumeManager)1592 std::shared_ptr<NapiAudioSystemVolumeChangeCallback> NapiAudioVolumeManager::GetSystemVolumeChangeNapiCallback(
1593 napi_value argv, NapiAudioVolumeManager *napiVolumeManager)
1594 {
1595 std::shared_ptr<NapiAudioSystemVolumeChangeCallback> cb = nullptr;
1596 for (auto &iter : napiVolumeManager->systemVolumeChangeCallbackNapiList_) {
1597 if (iter->ContainSameJsCallback(argv)) {
1598 cb = iter;
1599 }
1600 }
1601 return cb;
1602 }
1603
ForceVolumeKeyControlType(napi_env env,napi_callback_info info)1604 napi_value NapiAudioVolumeManager::ForceVolumeKeyControlType(napi_env env, napi_callback_info info)
1605 {
1606 auto context = std::make_shared<AudioVolumeManagerAsyncContext>();
1607 if (context == nullptr) {
1608 AUDIO_ERR_LOG("ForceVolumeKeyControlType failed : no memory");
1609 NapiAudioError::ThrowError(env, "ForceVolumeKeyControlType failed : no memory", NAPI_ERR_SYSTEM);
1610 return NapiParamUtils::GetUndefinedValue(env);
1611 }
1612 size_t argNum = 0;
1613 auto inputParser = [env, context, &argNum](size_t argc, napi_value *argv) {
1614 argNum = argc;
1615 NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_TWO, " Invalid arguments count or types.",
1616 NAPI_ERR_INVALID_PARAM);
1617 context->status = NapiParamUtils::GetValueInt32(env, context->volumeType, argv[PARAM0]);
1618 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get volumeType failed",
1619 NAPI_ERR_INPUT_INVALID);
1620 context->status = NapiParamUtils::GetValueInt32(env, context->duration, argv[PARAM1]);
1621 NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get duration failed",
1622 NAPI_ERR_INPUT_INVALID);
1623 };
1624 context->GetCbInfo(env, info, inputParser);
1625
1626 auto executor = [context]() {
1627 CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
1628 auto obj = reinterpret_cast<NapiAudioVolumeManager*>(context->native);
1629 ObjectRefMap objectGuard(obj);
1630 auto *napiAudioVolumeManager = objectGuard.GetPtr();
1631 CHECK_AND_RETURN_LOG(CheckAudioVolumeManagerStatus(napiAudioVolumeManager, context),
1632 "audio volume manager state is error.");
1633 context->intValue = napiAudioVolumeManager->audioSystemMngr_->ForceVolumeKeyControlType(
1634 NapiAudioEnum::GetNativeAudioVolumeType(context->volumeType), context->duration);
1635 CHECK_AND_RETURN(context->intValue != SUCCESS);
1636 if (context->intValue == ERR_PERMISSION_DENIED) {
1637 context->SignError(NAPI_ERR_NO_PERMISSION);
1638 } else if (context->intValue == ERR_SYSTEM_PERMISSION_DENIED) {
1639 context->SignError(NAPI_ERR_PERMISSION_DENIED);
1640 } else if (context->intValue == ERR_INVALID_PARAM) {
1641 context->SignError(NAPI_ERR_INVALID_PARAM);
1642 } else {
1643 context->SignError(NAPI_ERR_SYSTEM, "ForceVolumeKeyControlType fail.");
1644 }
1645 };
1646
1647 auto complete = [env](napi_value &output) {
1648 output = NapiParamUtils::GetUndefinedValue(env);
1649 };
1650 return NapiAsyncWork::Enqueue(env, context, "ForceVolumeKeyControlType", executor, complete);
1651 }
1652 } // namespace AudioStandard
1653 } // namespace OHOS