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