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