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