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