1 /*
2 * Copyright (c) 2022 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
16 #include "audio_volume_group_manager_napi.h"
17 #include "audio_common_napi.h"
18 #include "audio_errors.h"
19 #include "hilog/log.h"
20 #include "audio_log.h"
21 #include "xpower_event_js.h"
22
23 using namespace std;
24 using OHOS::HiviewDFX::HiLog;
25 using OHOS::HiviewDFX::HiLogLabel;
26
27 namespace OHOS {
28 namespace AudioStandard {
29 static __thread napi_ref g_groupmanagerConstructor = nullptr;
30 int32_t AudioVolumeGroupManagerNapi::isConstructSuccess_ = SUCCESS;
31 std::mutex AudioVolumeGroupManagerNapi::volumeGroupManagerMutex_;
32
33 #define GET_PARAMS(env, info, num) \
34 size_t argc = num; \
35 napi_value argv[num] = {0}; \
36 napi_value thisVar = nullptr; \
37 void *data; \
38 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data)
39
40 struct AudioVolumeGroupManagerAsyncContext {
41 napi_env env;
42 napi_async_work work;
43 napi_deferred deferred;
44 napi_ref callbackRef = nullptr;
45 int32_t volType;
46 int32_t volLevel;
47 int32_t deviceType;
48 int32_t ringMode;
49 int32_t scene;
50 int32_t deviceFlag;
51 int32_t intValue;
52 int32_t status = SUCCESS;
53 int32_t groupId;
54 int32_t adjustType;
55 int32_t volumeAdjustStatus;
56 bool isMute;
57 bool isActive;
58 bool isTrue;
59 double volumeInDb;
60 std::string key;
61 std::string valueStr;
62 int32_t networkId;
63 AudioVolumeGroupManagerNapi *objectInfo;
64 };
65 namespace {
66 const int ARGS_ONE = 1;
67 const int ARGS_TWO = 2;
68 const int ARGS_THREE = 3;
69 const int ARGS_FOUR = 4;
70 const int PARAM0 = 0;
71 const int PARAM1 = 1;
72 const int PARAM2 = 2;
73 const int PARAM3 = 3;
74 constexpr HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "AudioVolumeGroupManagerNapi"};
75 const std::string RINGERMODE_CALLBACK_NAME = "ringerModeChange";
76 }
77
GetNativeAudioVolumeType(int32_t volumeType)78 static AudioVolumeType GetNativeAudioVolumeType(int32_t volumeType)
79 {
80 AudioVolumeType result = STREAM_MUSIC;
81
82 switch (volumeType) {
83 case AudioCommonNapi::RINGTONE:
84 result = STREAM_RING;
85 break;
86 case AudioCommonNapi::MEDIA:
87 result = STREAM_MUSIC;
88 break;
89 case AudioCommonNapi::VOICE_CALL:
90 result = STREAM_VOICE_CALL;
91 break;
92 case AudioCommonNapi::VOICE_ASSISTANT:
93 result = STREAM_VOICE_ASSISTANT;
94 break;
95 case AudioCommonNapi::ALARM:
96 result = STREAM_ALARM;
97 break;
98 case AudioCommonNapi::ACCESSIBILITY:
99 result = STREAM_ACCESSIBILITY;
100 break;
101 case AudioCommonNapi::ULTRASONIC:
102 result = STREAM_ULTRASONIC;
103 break;
104 case AudioManagerNapi::ALL:
105 result = STREAM_ALL;
106 break;
107 default:
108 result = STREAM_MUSIC;
109 HiLog::Error(LABEL, "Unknown volume type, Set it to default MEDIA!");
110 break;
111 }
112 return result;
113 }
114
GetNativeAudioRingerMode(int32_t ringMode)115 static AudioRingerMode GetNativeAudioRingerMode(int32_t ringMode)
116 {
117 AudioRingerMode result = RINGER_MODE_NORMAL;
118
119 switch (ringMode) {
120 case AudioVolumeGroupManagerNapi::RINGER_MODE_SILENT:
121 result = RINGER_MODE_SILENT;
122 break;
123 case AudioVolumeGroupManagerNapi::RINGER_MODE_VIBRATE:
124 result = RINGER_MODE_VIBRATE;
125 break;
126 case AudioVolumeGroupManagerNapi::RINGER_MODE_NORMAL:
127 result = RINGER_MODE_NORMAL;
128 break;
129 default:
130 result = RINGER_MODE_NORMAL;
131 HiLog::Error(LABEL, "Unknown ringer mode requested by JS, Set it to default RINGER_MODE_NORMAL!");
132 break;
133 }
134
135 return result;
136 }
137
GetJsAudioRingMode(int32_t ringerMode)138 static AudioVolumeGroupManagerNapi::AudioRingMode GetJsAudioRingMode(int32_t ringerMode)
139 {
140 AudioVolumeGroupManagerNapi::AudioRingMode result = AudioVolumeGroupManagerNapi::RINGER_MODE_NORMAL;
141
142 switch (ringerMode) {
143 case RINGER_MODE_SILENT:
144 result = AudioVolumeGroupManagerNapi::RINGER_MODE_SILENT;
145 break;
146 case RINGER_MODE_VIBRATE:
147 result = AudioVolumeGroupManagerNapi::RINGER_MODE_VIBRATE;
148 break;
149 case RINGER_MODE_NORMAL:
150 result = AudioVolumeGroupManagerNapi::RINGER_MODE_NORMAL;
151 break;
152 default:
153 result = AudioVolumeGroupManagerNapi::RINGER_MODE_NORMAL;
154 HiLog::Error(LABEL, "Unknown ringer mode returned from native, Set it to default RINGER_MODE_NORMAL!");
155 break;
156 }
157
158 return result;
159 }
CommonCallbackRoutine(napi_env env,AudioVolumeGroupManagerAsyncContext * & asyncContext,const napi_value & valueParam)160 static void CommonCallbackRoutine(napi_env env, AudioVolumeGroupManagerAsyncContext* &asyncContext,
161 const napi_value &valueParam)
162 {
163 napi_value result[ARGS_TWO] = {0};
164 napi_value retVal;
165
166 if (!asyncContext->status) {
167 napi_get_undefined(env, &result[PARAM0]);
168 result[PARAM1] = valueParam;
169 } else {
170 napi_value message = nullptr;
171 std::string messageValue = AudioCommonNapi::getMessageByCode(asyncContext->status);
172 napi_create_string_utf8(env, messageValue.c_str(), NAPI_AUTO_LENGTH, &message);
173
174 napi_value code = nullptr;
175 napi_create_string_utf8(env, (std::to_string(asyncContext->status)).c_str(), NAPI_AUTO_LENGTH, &code);
176
177 napi_create_error(env, code, message, &result[PARAM0]);
178 napi_get_undefined(env, &result[PARAM1]);
179 }
180
181 if (asyncContext->deferred) {
182 if (!asyncContext->status) {
183 napi_resolve_deferred(env, asyncContext->deferred, result[PARAM1]);
184 } else {
185 napi_reject_deferred(env, asyncContext->deferred, result[PARAM0]);
186 }
187 } else {
188 napi_value callback = nullptr;
189 napi_get_reference_value(env, asyncContext->callbackRef, &callback);
190 napi_call_function(env, nullptr, callback, ARGS_TWO, result, &retVal);
191 napi_delete_reference(env, asyncContext->callbackRef);
192 }
193 napi_delete_async_work(env, asyncContext->work);
194
195 delete asyncContext;
196 asyncContext = nullptr;
197 }
198
GetIntValueAsyncCallbackComplete(napi_env env,napi_status status,void * data)199 static void GetIntValueAsyncCallbackComplete(napi_env env, napi_status status, void *data)
200 {
201 auto asyncContext = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
202 napi_value valueParam = nullptr;
203
204 if (asyncContext != nullptr) {
205 if (!asyncContext->status) {
206 napi_create_int32(env, asyncContext->intValue, &valueParam);
207 }
208 CommonCallbackRoutine(env, asyncContext, valueParam);
209 } else {
210 HiLog::Error(LABEL, "ERROR: AudioVolumeGroupManagerAsyncContext* is Null!");
211 }
212 }
213
GetVolumeAdjustByStepAsyncCallbackComplete(napi_env env,napi_status status,void * data)214 static void GetVolumeAdjustByStepAsyncCallbackComplete(napi_env env, napi_status status, void *data)
215 {
216 auto asyncContext = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
217 napi_value valueParam = nullptr;
218
219 if (asyncContext != nullptr) {
220 if (!asyncContext->status) {
221 napi_create_int32(env, asyncContext->volumeAdjustStatus, &valueParam);
222 }
223 CommonCallbackRoutine(env, asyncContext, valueParam);
224 } else {
225 HiLog::Error(LABEL, "ERROR: AudioVolumeGroupManagerAsyncContext* is Null!");
226 }
227 }
228
GetVolumeDbAsyncCallbackComplete(napi_env env,napi_status,void * data)229 static void GetVolumeDbAsyncCallbackComplete(napi_env env, napi_status, void *data)
230 {
231 auto asyncContext = static_cast<AudioVolumeGroupManagerAsyncContext *>(data);
232 napi_value valueParam = nullptr;
233
234 if (asyncContext != nullptr) {
235 if (!asyncContext->status) {
236 napi_create_double(env, asyncContext->volumeInDb, &valueParam);
237 }
238 CommonCallbackRoutine(env, asyncContext, valueParam);
239 } else {
240 HiLog::Error(LABEL, "ERROR: AudioVolumeGroupManagerAsyncContext* is Null!");
241 }
242 }
243
SetFunctionAsyncCallbackComplete(napi_env env,napi_status status,void * data)244 static void SetFunctionAsyncCallbackComplete(napi_env env, napi_status status, void *data)
245 {
246 auto asyncContext = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
247 napi_value valueParam = nullptr;
248
249 if (asyncContext != nullptr) {
250 if (!asyncContext->status) {
251 napi_get_undefined(env, &valueParam);
252 }
253 CommonCallbackRoutine(env, asyncContext, valueParam);
254 } else {
255 HiLog::Error(LABEL, "ERROR: AudioManagerAsyncContext* is Null!");
256 }
257 }
258
IsTrueAsyncCallbackComplete(napi_env env,napi_status status,void * data)259 static void IsTrueAsyncCallbackComplete(napi_env env, napi_status status, void *data)
260 {
261 auto asyncContext = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
262 napi_value valueParam = nullptr;
263
264 if (asyncContext != nullptr) {
265 if (!asyncContext->status) {
266 napi_get_boolean(env, asyncContext->isTrue, &valueParam);
267 }
268 CommonCallbackRoutine(env, asyncContext, valueParam);
269 } else {
270 HiLog::Error(LABEL, "ERROR: AudioManagerAsyncContext* is Null!");
271 }
272 }
273
274 // Constructor callback
Construct(napi_env env,napi_callback_info info)275 napi_value AudioVolumeGroupManagerNapi::Construct(napi_env env, napi_callback_info info)
276 {
277 std::lock_guard<mutex> lock(volumeGroupManagerMutex_);
278
279 napi_status status;
280 napi_value jsThis;
281 napi_value undefinedResult = nullptr;
282 napi_get_undefined(env, &undefinedResult);
283 size_t argCount = 1;
284 int32_t groupId = 0;
285
286 napi_value args[1] = { nullptr};
287 status = napi_get_cb_info(env, info, &argCount, args, &jsThis, nullptr);
288 napi_get_value_int32(env, args[0], &groupId);
289 HiLog::Info(LABEL, "Construct() %{public}d", groupId);
290
291 if (status == napi_ok) {
292 unique_ptr<AudioVolumeGroupManagerNapi> groupmanagerNapi = make_unique<AudioVolumeGroupManagerNapi>();
293 if (groupmanagerNapi != nullptr) {
294 groupmanagerNapi->audioGroupMngr_ = AudioSystemManager::GetInstance()->GetGroupManager(groupId);
295 if (groupmanagerNapi->audioGroupMngr_ == nullptr) {
296 HiLog::Error(LABEL, "Failed in AudioVolumeGroupManagerNapi::Construct()!");
297 AudioVolumeGroupManagerNapi::isConstructSuccess_ = NAPI_ERR_SYSTEM;
298 }
299 groupmanagerNapi->cachedClientId_ = getpid();
300 status = napi_wrap(env, jsThis, static_cast<void*>(groupmanagerNapi.get()),
301 AudioVolumeGroupManagerNapi::Destructor, nullptr, nullptr);
302 if (status == napi_ok) {
303 groupmanagerNapi.release();
304 return jsThis;
305 }
306 }
307 }
308
309 HiLog::Error(LABEL, "Failed in AudioVolumeGroupManagerNapi::Construct()!");
310
311 return undefinedResult;
312 }
313
Destructor(napi_env env,void * nativeObject,void * finalize_hint)314 void AudioVolumeGroupManagerNapi::Destructor(napi_env env, void *nativeObject, void *finalize_hint)
315 {
316 std::lock_guard<mutex> lock(volumeGroupManagerMutex_);
317
318 if (nativeObject != nullptr) {
319 auto obj = static_cast<AudioVolumeGroupManagerNapi*>(nativeObject);
320 delete obj;
321 obj = nullptr;
322 AUDIO_DEBUG_LOG("AudioVolumeGroupManagerNapi::Destructor delete AudioVolumeGroupManagerNapi obj done");
323 }
324 }
325
CreateAudioVolumeGroupManagerWrapper(napi_env env,int32_t groupId)326 napi_value AudioVolumeGroupManagerNapi::CreateAudioVolumeGroupManagerWrapper(napi_env env, int32_t groupId)
327 {
328 napi_status status;
329 napi_value result = nullptr;
330 napi_value constructor;
331 napi_value groupId_;
332 napi_create_int64(env, groupId, &groupId_);
333 napi_value args[PARAM1] = {groupId_};
334 status = napi_get_reference_value(env, g_groupmanagerConstructor, &constructor);
335 if (status == napi_ok) {
336 status = napi_new_instance(env, constructor, PARAM1, args, &result);
337 if (status == napi_ok) {
338 return result;
339 }
340 }
341
342 HiLog::Error(LABEL, "Failed in AudioVolumeGroupManagerNapi::CreateaudioMngrWrapper!");
343 napi_get_undefined(env, &result);
344
345 return result;
346 }
347
GetVolume(napi_env env,napi_callback_info info)348 napi_value AudioVolumeGroupManagerNapi::GetVolume(napi_env env, napi_callback_info info)
349 {
350 napi_status status;
351 const int32_t refCount = 1;
352 napi_value result = nullptr;
353
354 GET_PARAMS(env, info, ARGS_TWO);
355
356 unique_ptr<AudioVolumeGroupManagerAsyncContext> asyncContext = make_unique<AudioVolumeGroupManagerAsyncContext>();
357
358 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&asyncContext->objectInfo));
359 if (status == napi_ok && asyncContext->objectInfo != nullptr) {
360 if (argc < ARGS_ONE) {
361 asyncContext->status = NAPI_ERR_INVALID_PARAM;
362 }
363 for (size_t i = PARAM0; i < argc; i++) {
364 napi_valuetype valueType = napi_undefined;
365 napi_typeof(env, argv[i], &valueType);
366
367 if (i == PARAM0 && valueType == napi_number) {
368 napi_get_value_int32(env, argv[i], &asyncContext->volType);
369 if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) {
370 asyncContext->status = (asyncContext->status ==
371 NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED;
372 }
373 } else if (i == PARAM1) {
374 if (valueType == napi_function) {
375 napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef);
376 }
377 break;
378 } else {
379 asyncContext->status = NAPI_ERR_INVALID_PARAM;
380 }
381 }
382
383 if (asyncContext->callbackRef == nullptr) {
384 napi_create_promise(env, &asyncContext->deferred, &result);
385 } else {
386 napi_get_undefined(env, &result);
387 }
388
389 napi_value resource = nullptr;
390 napi_create_string_utf8(env, "GetVolume", NAPI_AUTO_LENGTH, &resource);
391
392 status = napi_create_async_work(
393 env, nullptr, resource,
394 [](napi_env env, void *data) {
395 auto context = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
396 if (context->status == SUCCESS) {
397 context->volLevel = context->objectInfo->audioGroupMngr_->GetVolume(
398 GetNativeAudioVolumeType(context->volType));
399 context->intValue = context->volLevel;
400 if (context->volLevel < 0) {
401 context->status = context->volLevel;
402 }
403 }
404 }, GetIntValueAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
405 if (status != napi_ok) {
406 result = nullptr;
407 } else {
408 status = napi_queue_async_work(env, asyncContext->work);
409 if (status == napi_ok) {
410 asyncContext.release();
411 } else {
412 result = nullptr;
413 }
414 }
415 }
416
417 return result;
418 }
419
GetVolumeSync(napi_env env,napi_callback_info info)420 napi_value AudioVolumeGroupManagerNapi::GetVolumeSync(napi_env env, napi_callback_info info)
421 {
422 napi_status status;
423 napi_value result = nullptr;
424 void *native = nullptr;
425
426 GET_PARAMS(env, info, ARGS_ONE);
427
428 if (argc < ARGS_ONE) {
429 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
430 return result;
431 }
432
433 status = napi_unwrap(env, thisVar, &native);
434 auto *audioVolumeGroupManagerNapi = reinterpret_cast<AudioVolumeGroupManagerNapi *>(native);
435 if (status != napi_ok || audioVolumeGroupManagerNapi == nullptr) {
436 AUDIO_ERR_LOG("GetVolumeSync unwrap failure!");
437 return result;
438 }
439
440 napi_valuetype valueType = napi_undefined;
441 napi_typeof(env, argv[PARAM0], &valueType);
442 if (valueType != napi_number) {
443 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
444 return result;
445 }
446
447 int32_t volType;
448 napi_get_value_int32(env, argv[PARAM0], &volType);
449 if (!AudioCommonNapi::IsLegalInputArgumentVolType(volType)) {
450 AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM);
451 return result;
452 }
453
454 int32_t volLevel = audioVolumeGroupManagerNapi->audioGroupMngr_->GetVolume(GetNativeAudioVolumeType(volType));
455 napi_create_int32(env, volLevel, &result);
456
457 return result;
458 }
459
SetVolume(napi_env env,napi_callback_info info)460 napi_value AudioVolumeGroupManagerNapi::SetVolume(napi_env env, napi_callback_info info)
461 {
462 napi_status status;
463 const int32_t refCount = 1;
464 napi_value result = nullptr;
465
466 GET_PARAMS(env, info, ARGS_THREE);
467
468 unique_ptr<AudioVolumeGroupManagerAsyncContext> asyncContext = make_unique<AudioVolumeGroupManagerAsyncContext>();
469
470 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&asyncContext->objectInfo));
471 if (status == napi_ok && asyncContext->objectInfo != nullptr) {
472 if (argc < ARGS_TWO) {
473 asyncContext->status = NAPI_ERR_INVALID_PARAM;
474 }
475 for (size_t i = PARAM0; i < argc; i++) {
476 napi_valuetype valueType = napi_undefined;
477 napi_typeof(env, argv[i], &valueType);
478
479 if (i == PARAM0 && valueType == napi_number) {
480 napi_get_value_int32(env, argv[i], &asyncContext->volType);
481 if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) {
482 asyncContext->status = (asyncContext->status ==
483 NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED;
484 }
485 } else if (i == PARAM1 && valueType == napi_number) {
486 napi_get_value_int32(env, argv[i], &asyncContext->volLevel);
487 } else if (i == PARAM2) {
488 if (valueType == napi_function) {
489 napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef);
490 }
491 break;
492 } else {
493 asyncContext->status = NAPI_ERR_INVALID_PARAM;
494 }
495 }
496
497 if (asyncContext->callbackRef == nullptr) {
498 napi_create_promise(env, &asyncContext->deferred, &result);
499 } else {
500 napi_get_undefined(env, &result);
501 }
502
503 HiviewDFX::ReportXPowerJsStackSysEvent(env, "VOLUME_CHANGE", "SRC=Audio");
504 napi_value resource = nullptr;
505 napi_create_string_utf8(env, "SetVolume", NAPI_AUTO_LENGTH, &resource);
506
507 status = napi_create_async_work(
508 env, nullptr, resource,
509 [](napi_env env, void *data) {
510 std::lock_guard<mutex> lock(volumeGroupManagerMutex_);
511 auto context = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
512 if (context->status == SUCCESS) {
513 auto &audioGroupManager = context->objectInfo->audioGroupMngr_;
514 context->status = (audioGroupManager == nullptr) ? NAPI_ERR_SYSTEM :
515 audioGroupManager->SetVolume(GetNativeAudioVolumeType(context->volType), context->volLevel);
516 }
517 }, SetFunctionAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
518 if (status != napi_ok) {
519 result = nullptr;
520 } else {
521 status = napi_queue_async_work(env, asyncContext->work);
522 if (status == napi_ok) {
523 asyncContext.release();
524 } else {
525 result = nullptr;
526 }
527 }
528 }
529
530 return result;
531 }
532
GetMaxVolume(napi_env env,napi_callback_info info)533 napi_value AudioVolumeGroupManagerNapi::GetMaxVolume(napi_env env, napi_callback_info info)
534 {
535 napi_status status;
536 const int32_t refCount = 1;
537 napi_value result = nullptr;
538
539 GET_PARAMS(env, info, ARGS_TWO);
540
541 unique_ptr<AudioVolumeGroupManagerAsyncContext> asyncContext = make_unique<AudioVolumeGroupManagerAsyncContext>();
542 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&asyncContext->objectInfo));
543 if (status == napi_ok && asyncContext->objectInfo != nullptr) {
544 if (argc < ARGS_ONE) {
545 asyncContext->status = NAPI_ERR_INVALID_PARAM;
546 }
547 for (size_t i = PARAM0; i < argc; i++) {
548 napi_valuetype valueType = napi_undefined;
549 napi_typeof(env, argv[i], &valueType);
550
551 if (i == PARAM0 && valueType == napi_number) {
552 napi_get_value_int32(env, argv[i], &asyncContext->volType);
553 if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) {
554 asyncContext->status = (asyncContext->status ==
555 NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED;
556 }
557 } else if (i == PARAM1) {
558 if (valueType == napi_function) {
559 napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef);
560 }
561 break;
562 } else {
563 asyncContext->status = NAPI_ERR_INVALID_PARAM;
564 }
565 }
566
567 if (asyncContext->callbackRef == nullptr) {
568 napi_create_promise(env, &asyncContext->deferred, &result);
569 } else {
570 napi_get_undefined(env, &result);
571 }
572
573 napi_value resource = nullptr;
574 napi_create_string_utf8(env, "GetMaxVolume", NAPI_AUTO_LENGTH, &resource);
575
576 status = napi_create_async_work(
577 env, nullptr, resource,
578 [](napi_env env, void *data) {
579 auto context = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
580 if (context->status == SUCCESS) {
581 context->volLevel = context->objectInfo->audioGroupMngr_->GetMaxVolume(
582 GetNativeAudioVolumeType(context->volType));
583 context->intValue = context->volLevel;
584 if (context->volLevel < 0) {
585 context->status = context->volLevel;
586 }
587 }
588 },
589 GetIntValueAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
590 if (status != napi_ok) {
591 result = nullptr;
592 } else {
593 status = napi_queue_async_work(env, asyncContext->work);
594 if (status == napi_ok) {
595 asyncContext.release();
596 } else {
597 result = nullptr;
598 }
599 }
600 }
601
602 return result;
603 }
604
GetMaxVolumeSync(napi_env env,napi_callback_info info)605 napi_value AudioVolumeGroupManagerNapi::GetMaxVolumeSync(napi_env env, napi_callback_info info)
606 {
607 napi_status status;
608 napi_value result = nullptr;
609 void *native = nullptr;
610
611 GET_PARAMS(env, info, ARGS_ONE);
612
613 if (argc < ARGS_ONE) {
614 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
615 return result;
616 }
617
618 status = napi_unwrap(env, thisVar, &native);
619 auto *audioVolumeGroupManagerNapi = reinterpret_cast<AudioVolumeGroupManagerNapi *>(native);
620 if (status != napi_ok || audioVolumeGroupManagerNapi == nullptr) {
621 AUDIO_ERR_LOG("GetMaxVolumeSync unwrap failure!");
622 return result;
623 }
624
625 napi_valuetype valueType = napi_undefined;
626 napi_typeof(env, argv[PARAM0], &valueType);
627 if (valueType != napi_number) {
628 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
629 return result;
630 }
631
632 int32_t volType;
633 napi_get_value_int32(env, argv[PARAM0], &volType);
634 if (!AudioCommonNapi::IsLegalInputArgumentVolType(volType)) {
635 AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM);
636 return result;
637 }
638
639 int32_t volLevel = audioVolumeGroupManagerNapi->audioGroupMngr_->GetMaxVolume(GetNativeAudioVolumeType(volType));
640 napi_create_int32(env, volLevel, &result);
641
642 return result;
643 }
644
GetMinVolume(napi_env env,napi_callback_info info)645 napi_value AudioVolumeGroupManagerNapi::GetMinVolume(napi_env env, napi_callback_info info)
646 {
647 napi_status status;
648 const int32_t refCount = 1;
649 napi_value result = nullptr;
650
651 GET_PARAMS(env, info, ARGS_TWO);
652
653 unique_ptr<AudioVolumeGroupManagerAsyncContext> asyncContext = make_unique<AudioVolumeGroupManagerAsyncContext>();
654 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&asyncContext->objectInfo));
655 if (status == napi_ok && asyncContext->objectInfo != nullptr) {
656 if (argc < ARGS_ONE) {
657 asyncContext->status = NAPI_ERR_INVALID_PARAM;
658 }
659 for (size_t i = PARAM0; i < argc; i++) {
660 napi_valuetype valueType = napi_undefined;
661 napi_typeof(env, argv[i], &valueType);
662
663 if (i == PARAM0 && valueType == napi_number) {
664 napi_get_value_int32(env, argv[i], &asyncContext->volType);
665 if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) {
666 asyncContext->status = (asyncContext->status ==
667 NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED;
668 }
669 } else if (i == PARAM1) {
670 if (valueType == napi_function) {
671 napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef);
672 }
673 break;
674 } else {
675 asyncContext->status = NAPI_ERR_INVALID_PARAM;
676 }
677 }
678
679 if (asyncContext->callbackRef == nullptr) {
680 napi_create_promise(env, &asyncContext->deferred, &result);
681 } else {
682 napi_get_undefined(env, &result);
683 }
684
685 napi_value resource = nullptr;
686 napi_create_string_utf8(env, "GetMinVolume", NAPI_AUTO_LENGTH, &resource);
687
688 status = napi_create_async_work(
689 env, nullptr, resource,
690 [](napi_env env, void *data) {
691 auto context = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
692 if (context->status == SUCCESS) {
693 context->volLevel = context->objectInfo->audioGroupMngr_->GetMinVolume(
694 GetNativeAudioVolumeType(context->volType));
695 context->intValue = context->volLevel;
696 if (context->volLevel < 0) {
697 context->status = context->volLevel;
698 }
699 }
700 },
701 GetIntValueAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
702 if (status != napi_ok) {
703 result = nullptr;
704 } else {
705 status = napi_queue_async_work(env, asyncContext->work);
706 if (status == napi_ok) {
707 asyncContext.release();
708 } else {
709 result = nullptr;
710 }
711 }
712 }
713
714 return result;
715 }
716
GetMinVolumeSync(napi_env env,napi_callback_info info)717 napi_value AudioVolumeGroupManagerNapi::GetMinVolumeSync(napi_env env, napi_callback_info info)
718 {
719 napi_status status;
720 napi_value result = nullptr;
721 void *native = nullptr;
722
723 GET_PARAMS(env, info, ARGS_ONE);
724
725 if (argc < ARGS_ONE) {
726 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
727 return result;
728 }
729
730 status = napi_unwrap(env, thisVar, &native);
731 auto *audioVolumeGroupManagerNapi = reinterpret_cast<AudioVolumeGroupManagerNapi *>(native);
732 if (status != napi_ok || audioVolumeGroupManagerNapi == nullptr) {
733 AUDIO_ERR_LOG("GetMinVolumeSync unwrap failure!");
734 return result;
735 }
736
737 napi_valuetype valueType = napi_undefined;
738 napi_typeof(env, argv[PARAM0], &valueType);
739 if (valueType != napi_number) {
740 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
741 return result;
742 }
743
744 int32_t volType;
745 napi_get_value_int32(env, argv[PARAM0], &volType);
746 if (!AudioCommonNapi::IsLegalInputArgumentVolType(volType)) {
747 AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM);
748 return result;
749 }
750
751 int32_t volLevel = audioVolumeGroupManagerNapi->audioGroupMngr_->GetMinVolume(GetNativeAudioVolumeType(volType));
752 napi_create_int32(env, volLevel, &result);
753
754 return result;
755 }
756
SetMute(napi_env env,napi_callback_info info)757 napi_value AudioVolumeGroupManagerNapi::SetMute(napi_env env, napi_callback_info info)
758 {
759 napi_status status;
760 const int32_t refCount = 1;
761 napi_value result = nullptr;
762
763 GET_PARAMS(env, info, ARGS_THREE);
764
765 unique_ptr<AudioVolumeGroupManagerAsyncContext> asyncContext = make_unique<AudioVolumeGroupManagerAsyncContext>();
766 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&asyncContext->objectInfo));
767 if (status == napi_ok && asyncContext->objectInfo != nullptr) {
768 if (argc < ARGS_ONE) {
769 asyncContext->status = NAPI_ERR_INVALID_PARAM;
770 }
771 for (size_t i = PARAM0; i < argc; i++) {
772 napi_valuetype valueType = napi_undefined;
773 napi_typeof(env, argv[i], &valueType);
774
775 if (i == PARAM0 && valueType == napi_number) {
776 napi_get_value_int32(env, argv[i], &asyncContext->volType);
777 if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) {
778 asyncContext->status = (asyncContext->status ==
779 NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED;
780 }
781 } else if (i == PARAM1 && valueType == napi_boolean) {
782 napi_get_value_bool(env, argv[i], &asyncContext->isMute);
783 } else if (i == PARAM2) {
784 if (valueType == napi_function) {
785 napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef);
786 }
787 break;
788 } else {
789 asyncContext->status = NAPI_ERR_INVALID_PARAM;
790 }
791 }
792
793 if (asyncContext->callbackRef == nullptr) {
794 napi_create_promise(env, &asyncContext->deferred, &result);
795 } else {
796 napi_get_undefined(env, &result);
797 }
798
799 napi_value resource = nullptr;
800 napi_create_string_utf8(env, "SetStreamMute", NAPI_AUTO_LENGTH, &resource);
801
802 status = napi_create_async_work(
803 env, nullptr, resource,
804 [](napi_env env, void *data) {
805 auto context = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
806 if (context->status == SUCCESS) {
807 context->status = context->objectInfo->audioGroupMngr_->SetMute(GetNativeAudioVolumeType(
808 context->volType), context->isMute);
809 }
810 },
811 SetFunctionAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
812 if (status != napi_ok) {
813 result = nullptr;
814 } else {
815 status = napi_queue_async_work(env, asyncContext->work);
816 if (status == napi_ok) {
817 asyncContext.release();
818 } else {
819 result = nullptr;
820 }
821 }
822 }
823
824 return result;
825 }
826
IsStreamMute(napi_env env,napi_callback_info info)827 napi_value AudioVolumeGroupManagerNapi::IsStreamMute(napi_env env, napi_callback_info info)
828 {
829 napi_status status;
830 const int32_t refCount = 1;
831 napi_value result = nullptr;
832
833 GET_PARAMS(env, info, ARGS_TWO);
834
835 unique_ptr<AudioVolumeGroupManagerAsyncContext> asyncContext = make_unique<AudioVolumeGroupManagerAsyncContext>();
836
837 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&asyncContext->objectInfo));
838 if (status == napi_ok && asyncContext->objectInfo != nullptr) {
839 if (argc < ARGS_ONE) {
840 asyncContext->status = NAPI_ERR_INVALID_PARAM;
841 }
842 for (size_t i = PARAM0; i < argc; i++) {
843 napi_valuetype valueType = napi_undefined;
844 napi_typeof(env, argv[i], &valueType);
845
846 if (i == PARAM0 && valueType == napi_number) {
847 napi_get_value_int32(env, argv[i], &asyncContext->volType);
848 if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) {
849 asyncContext->status = (asyncContext->status ==
850 NAPI_ERR_INVALID_PARAM) ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED;
851 }
852 } else if (i == PARAM1) {
853 if (valueType == napi_function) {
854 napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef);
855 }
856 break;
857 } else {
858 asyncContext->status = NAPI_ERR_INVALID_PARAM;
859 }
860 }
861
862 if (asyncContext->callbackRef == nullptr) {
863 napi_create_promise(env, &asyncContext->deferred, &result);
864 } else {
865 napi_get_undefined(env, &result);
866 }
867
868 napi_value resource = nullptr;
869 napi_create_string_utf8(env, "IsStreamMute", NAPI_AUTO_LENGTH, &resource);
870
871 status = napi_create_async_work(
872 env, nullptr, resource,
873 [](napi_env env, void *data) {
874 auto context = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
875 if (context->status == SUCCESS) {
876 context->status = context->objectInfo->audioGroupMngr_->IsStreamMute(
877 GetNativeAudioVolumeType(context->volType), context->isMute);
878 context->isTrue = context->isMute;
879 }
880 },
881 IsTrueAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
882 if (status != napi_ok) {
883 result = nullptr;
884 } else {
885 status = napi_queue_async_work(env, asyncContext->work);
886 if (status == napi_ok) {
887 asyncContext.release();
888 } else {
889 result = nullptr;
890 }
891 }
892 }
893
894 return result;
895 }
896
IsStreamMuteSync(napi_env env,napi_callback_info info)897 napi_value AudioVolumeGroupManagerNapi::IsStreamMuteSync(napi_env env, napi_callback_info info)
898 {
899 napi_status status;
900 napi_value result = nullptr;
901 void *native = nullptr;
902
903 GET_PARAMS(env, info, ARGS_ONE);
904
905 if (argc < ARGS_ONE) {
906 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
907 return result;
908 }
909
910 status = napi_unwrap(env, thisVar, &native);
911 auto *audioVolumeGroupManagerNapi = reinterpret_cast<AudioVolumeGroupManagerNapi *>(native);
912 if (status != napi_ok || audioVolumeGroupManagerNapi == nullptr) {
913 AUDIO_ERR_LOG("IsStreamMuteSync unwrap failure!");
914 return result;
915 }
916
917 napi_valuetype valueType = napi_undefined;
918 napi_typeof(env, argv[PARAM0], &valueType);
919 if (valueType != napi_number) {
920 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
921 return result;
922 }
923
924 int32_t volType;
925 napi_get_value_int32(env, argv[PARAM0], &volType);
926 if (!AudioCommonNapi::IsLegalInputArgumentVolType(volType)) {
927 AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM);
928 return result;
929 }
930
931 bool isMute;
932 int32_t ret = audioVolumeGroupManagerNapi->audioGroupMngr_->IsStreamMute(
933 GetNativeAudioVolumeType(volType), isMute);
934 if (ret != SUCCESS) {
935 AUDIO_ERR_LOG("IsStreamMute failure!");
936 return result;
937 }
938 napi_get_boolean(env, isMute, &result);
939
940 return result;
941 }
942
SetRingerMode(napi_env env,napi_callback_info info)943 napi_value AudioVolumeGroupManagerNapi::SetRingerMode(napi_env env, napi_callback_info info)
944 {
945 HiLog::Info(LABEL, " %{public}s IN", __func__);
946 napi_status status;
947 const int32_t refCount = 1;
948 napi_value result = nullptr;
949
950 GET_PARAMS(env, info, ARGS_TWO);
951
952 unique_ptr<AudioVolumeGroupManagerAsyncContext> asyncContext = make_unique<AudioVolumeGroupManagerAsyncContext>();
953
954 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&asyncContext->objectInfo));
955 if (status == napi_ok && asyncContext->objectInfo != nullptr) {
956 if (argc < ARGS_ONE) {
957 asyncContext->status = NAPI_ERR_INVALID_PARAM;
958 }
959 for (size_t i = PARAM0; i < argc; i++) {
960 napi_valuetype valueType = napi_undefined;
961 napi_typeof(env, argv[i], &valueType);
962
963 if (i == PARAM0 && valueType == napi_number) {
964 napi_get_value_int32(env, argv[i], &asyncContext->ringMode);
965 if (!AudioCommonNapi::IsLegalInputArgumentRingMode(asyncContext->ringMode)) {
966 asyncContext->status = asyncContext->status ==
967 NAPI_ERR_INVALID_PARAM ? NAPI_ERR_INVALID_PARAM : NAPI_ERR_UNSUPPORTED;
968 }
969 } else if (i == PARAM1) {
970 if (valueType == napi_function) {
971 napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef);
972 }
973 break;
974 } else {
975 asyncContext->status = NAPI_ERR_INVALID_PARAM;
976 }
977 }
978
979 if (asyncContext->callbackRef == nullptr) {
980 napi_create_promise(env, &asyncContext->deferred, &result);
981 } else {
982 napi_get_undefined(env, &result);
983 }
984
985 napi_value resource = nullptr;
986 napi_create_string_utf8(env, "SetRingerMode", NAPI_AUTO_LENGTH, &resource);
987
988 status = napi_create_async_work(
989 env, nullptr, resource,
990 [](napi_env env, void *data) {
991 auto context = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
992 if (context->status == SUCCESS) {
993 context->status =
994 context->objectInfo->audioGroupMngr_->SetRingerMode(GetNativeAudioRingerMode(context->ringMode));
995 }
996 },
997 SetFunctionAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
998 if (status != napi_ok) {
999 result = nullptr;
1000 } else {
1001 status = napi_queue_async_work(env, asyncContext->work);
1002 if (status == napi_ok) {
1003 asyncContext.release();
1004 } else {
1005 result = nullptr;
1006 }
1007 }
1008 }
1009
1010 return result;
1011 }
1012
GetRingerMode(napi_env env,napi_callback_info info)1013 napi_value AudioVolumeGroupManagerNapi::GetRingerMode(napi_env env, napi_callback_info info)
1014 {
1015 HiLog::Info(LABEL, " %{public}s IN", __func__);
1016 napi_status status;
1017 const int32_t refCount = 1;
1018 napi_value result = nullptr;
1019
1020 GET_PARAMS(env, info, ARGS_ONE);
1021
1022 unique_ptr<AudioVolumeGroupManagerAsyncContext> asyncContext = make_unique<AudioVolumeGroupManagerAsyncContext>();
1023
1024 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&asyncContext->objectInfo));
1025 if (status == napi_ok && asyncContext->objectInfo != nullptr) {
1026 if (argc > PARAM0) {
1027 napi_valuetype valueType = napi_undefined;
1028 napi_typeof(env, argv[PARAM0], &valueType);
1029 if (valueType == napi_function) {
1030 napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef);
1031 }
1032 }
1033
1034 if (asyncContext->callbackRef == nullptr) {
1035 napi_create_promise(env, &asyncContext->deferred, &result);
1036 } else {
1037 napi_get_undefined(env, &result);
1038 }
1039
1040 napi_value resource = nullptr;
1041 napi_create_string_utf8(env, "GetRingerMode", NAPI_AUTO_LENGTH, &resource);
1042
1043 status = napi_create_async_work(
1044 env, nullptr, resource,
1045 [](napi_env env, void *data) {
1046 auto context = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
1047 if (context->status == SUCCESS) {
1048 context->ringMode = GetJsAudioRingMode(context->objectInfo->audioGroupMngr_->GetRingerMode());
1049 context->intValue = context->ringMode;
1050 context->status = 0;
1051 }
1052 },
1053 GetIntValueAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
1054 if (status != napi_ok) {
1055 result = nullptr;
1056 } else {
1057 status = napi_queue_async_work(env, asyncContext->work);
1058 if (status == napi_ok) {
1059 asyncContext.release();
1060 } else {
1061 result = nullptr;
1062 }
1063 }
1064 }
1065
1066 return result;
1067 }
1068
GetRingerModeSync(napi_env env,napi_callback_info info)1069 napi_value AudioVolumeGroupManagerNapi::GetRingerModeSync(napi_env env, napi_callback_info info)
1070 {
1071 HiLog::Info(LABEL, " %{public}s IN", __func__);
1072 napi_status status;
1073 napi_value thisVar = nullptr;
1074 napi_value result = nullptr;
1075 size_t argCount = 0;
1076 void *native = nullptr;
1077
1078 status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr);
1079 if (status != napi_ok) {
1080 AUDIO_ERR_LOG("Invalid parameters!");
1081 return result;
1082 }
1083
1084 status = napi_unwrap(env, thisVar, &native);
1085 auto *audioVolumeGroupManagerNapi = reinterpret_cast<AudioVolumeGroupManagerNapi *>(native);
1086 if (status != napi_ok || audioVolumeGroupManagerNapi == nullptr) {
1087 AUDIO_ERR_LOG("GetRingerModeSync unwrap failure!");
1088 return result;
1089 }
1090
1091 AudioRingerMode ringerMode = audioVolumeGroupManagerNapi->audioGroupMngr_->GetRingerMode();
1092 napi_create_int32(env, ringerMode, &result);
1093
1094 return result;
1095 }
1096
1097
SetMicrophoneMute(napi_env env,napi_callback_info info)1098 napi_value AudioVolumeGroupManagerNapi::SetMicrophoneMute(napi_env env, napi_callback_info info)
1099 {
1100 napi_status status;
1101 const int32_t refCount = 1;
1102 napi_value result = nullptr;
1103
1104 GET_PARAMS(env, info, ARGS_TWO);
1105
1106 unique_ptr<AudioVolumeGroupManagerAsyncContext> asyncContext = make_unique<AudioVolumeGroupManagerAsyncContext>();
1107
1108 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&asyncContext->objectInfo));
1109 if (status == napi_ok && asyncContext->objectInfo != nullptr) {
1110 if (argc < ARGS_ONE) {
1111 asyncContext->status = NAPI_ERR_INVALID_PARAM;
1112 }
1113 for (size_t i = PARAM0; i < argc; i++) {
1114 napi_valuetype valueType = napi_undefined;
1115 napi_typeof(env, argv[i], &valueType);
1116
1117 if (i == PARAM0 && valueType == napi_boolean) {
1118 napi_get_value_bool(env, argv[i], &asyncContext->isMute);
1119 } else if (i == PARAM1) {
1120 if (valueType == napi_function) {
1121 napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef);
1122 }
1123 break;
1124 } else {
1125 asyncContext->status = NAPI_ERR_INVALID_PARAM;
1126 }
1127 }
1128
1129 if (asyncContext->callbackRef == nullptr) {
1130 napi_create_promise(env, &asyncContext->deferred, &result);
1131 } else {
1132 napi_get_undefined(env, &result);
1133 }
1134
1135 napi_value resource = nullptr;
1136 napi_create_string_utf8(env, "SetMicrophoneMute", NAPI_AUTO_LENGTH, &resource);
1137
1138 status = napi_create_async_work(
1139 env, nullptr, resource,
1140 [](napi_env env, void *data) {
1141 auto context = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
1142 if (context->status == SUCCESS) {
1143 context->status = context->objectInfo->audioGroupMngr_->SetMicrophoneMute(context->isMute);
1144 }
1145 },
1146 SetFunctionAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
1147 if (status != napi_ok) {
1148 result = nullptr;
1149 } else {
1150 status = napi_queue_async_work(env, asyncContext->work);
1151 if (status == napi_ok) {
1152 asyncContext.release();
1153 } else {
1154 result = nullptr;
1155 }
1156 }
1157 }
1158
1159 return result;
1160 }
1161
IsMicrophoneMute(napi_env env,napi_callback_info info)1162 napi_value AudioVolumeGroupManagerNapi::IsMicrophoneMute(napi_env env, napi_callback_info info)
1163 {
1164 napi_status status;
1165 const int32_t refCount = 1;
1166 napi_value result = nullptr;
1167
1168 GET_PARAMS(env, info, ARGS_ONE);
1169
1170 unique_ptr<AudioVolumeGroupManagerAsyncContext> asyncContext = make_unique<AudioVolumeGroupManagerAsyncContext>();
1171
1172 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&asyncContext->objectInfo));
1173 if (status == napi_ok && asyncContext->objectInfo != nullptr) {
1174 if (argc > PARAM0) {
1175 napi_valuetype valueType = napi_undefined;
1176 napi_typeof(env, argv[PARAM0], &valueType);
1177 if (valueType == napi_function) {
1178 napi_create_reference(env, argv[PARAM0], refCount, &asyncContext->callbackRef);
1179 }
1180 }
1181
1182 if (asyncContext->callbackRef == nullptr) {
1183 napi_create_promise(env, &asyncContext->deferred, &result);
1184 } else {
1185 napi_get_undefined(env, &result);
1186 }
1187
1188 napi_value resource = nullptr;
1189 napi_create_string_utf8(env, "IsMicrophoneMute", NAPI_AUTO_LENGTH, &resource);
1190
1191 status = napi_create_async_work(
1192 env, nullptr, resource,
1193 [](napi_env env, void *data) {
1194 auto context = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
1195 if (context->status == SUCCESS) {
1196 context->isMute = context->objectInfo->audioGroupMngr_->IsMicrophoneMute();
1197 context->isTrue = context->isMute;
1198 }
1199 },
1200 IsTrueAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
1201 if (status != napi_ok) {
1202 result = nullptr;
1203 } else {
1204 status = napi_queue_async_work(env, asyncContext->work);
1205 if (status == napi_ok) {
1206 asyncContext.release();
1207 } else {
1208 result = nullptr;
1209 }
1210 }
1211 }
1212
1213 return result;
1214 }
1215
IsMicrophoneMuteSync(napi_env env,napi_callback_info info)1216 napi_value AudioVolumeGroupManagerNapi::IsMicrophoneMuteSync(napi_env env, napi_callback_info info)
1217 {
1218 napi_status status;
1219 napi_value thisVar = nullptr;
1220 napi_value result = nullptr;
1221 size_t argCount = 0;
1222 void *native = nullptr;
1223
1224 status = napi_get_cb_info(env, info, &argCount, nullptr, &thisVar, nullptr);
1225 if (status != napi_ok) {
1226 AUDIO_ERR_LOG("Invalid parameters!");
1227 return result;
1228 }
1229
1230 status = napi_unwrap(env, thisVar, &native);
1231 auto *audioVolumeGroupManagerNapi = reinterpret_cast<AudioVolumeGroupManagerNapi *>(native);
1232 if (status != napi_ok || audioVolumeGroupManagerNapi == nullptr) {
1233 AUDIO_ERR_LOG("IsMicrophoneMuteSync unwrap failure!");
1234 return result;
1235 }
1236
1237 bool isMute = audioVolumeGroupManagerNapi->audioGroupMngr_->IsMicrophoneMute();
1238 napi_get_boolean(env, isMute, &result);
1239
1240 return result;
1241 }
1242
On(napi_env env,napi_callback_info info)1243 napi_value AudioVolumeGroupManagerNapi::On(napi_env env, napi_callback_info info)
1244 {
1245 napi_value undefinedResult = nullptr;
1246 napi_get_undefined(env, &undefinedResult);
1247
1248 const size_t minArgCount = 2;
1249 size_t argCount = 3;
1250 napi_value args[minArgCount + 1] = {nullptr, nullptr, nullptr};
1251 napi_value jsThis = nullptr;
1252 napi_status status = napi_get_cb_info(env, info, &argCount, args, &jsThis, nullptr);
1253 if (status != napi_ok || argCount < minArgCount) {
1254 AUDIO_ERR_LOG("On fail to napi_get_cb_info/Requires min 2 parameters");
1255 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
1256 }
1257
1258 napi_valuetype eventType = napi_undefined;
1259 if (napi_typeof(env, args[PARAM0], &eventType) != napi_ok || eventType != napi_string) {
1260 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
1261 return undefinedResult;
1262 }
1263 std::string callbackName = AudioCommonNapi::GetStringArgument(env, args[0]);
1264 AUDIO_INFO_LOG("On callbackName: %{public}s", callbackName.c_str());
1265
1266 AudioVolumeGroupManagerNapi *volumeGroupManagerNapi = nullptr;
1267 status = napi_unwrap(env, jsThis, reinterpret_cast<void **>(&volumeGroupManagerNapi));
1268
1269 napi_valuetype handler = napi_undefined;
1270 if (napi_typeof(env, args[PARAM1], &handler) != napi_ok || handler != napi_function) {
1271 AUDIO_ERR_LOG("On type mismatch for parameter 2");
1272 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
1273 return undefinedResult;
1274 }
1275
1276 if (!callbackName.compare(RINGERMODE_CALLBACK_NAME)) {
1277 if (volumeGroupManagerNapi->ringerModecallbackNapi_ == nullptr) {
1278 volumeGroupManagerNapi->ringerModecallbackNapi_ = std::make_shared<AudioRingerModeCallbackNapi>(env);
1279 int32_t ret = volumeGroupManagerNapi->audioGroupMngr_->SetRingerModeCallback(
1280 volumeGroupManagerNapi->cachedClientId_, volumeGroupManagerNapi->ringerModecallbackNapi_);
1281 if (ret) {
1282 AUDIO_ERR_LOG("SetRingerModeCallback Failed");
1283 return undefinedResult;
1284 } else {
1285 AUDIO_INFO_LOG("SetRingerModeCallback Success");
1286 }
1287 }
1288
1289 std::shared_ptr<AudioRingerModeCallbackNapi> cb =
1290 std::static_pointer_cast<AudioRingerModeCallbackNapi>(volumeGroupManagerNapi->ringerModecallbackNapi_);
1291 cb->SaveCallbackReference(callbackName, args[PARAM1]);
1292 } else if (!callbackName.compare(MIC_STATE_CHANGE_CALLBACK_NAME)) {
1293 if (!volumeGroupManagerNapi->micStateChangeCallbackNapi_) {
1294 volumeGroupManagerNapi->micStateChangeCallbackNapi_=
1295 std::make_shared<AudioManagerMicStateChangeCallbackNapi>(env);
1296 if (!volumeGroupManagerNapi->micStateChangeCallbackNapi_) {
1297 AUDIO_ERR_LOG("Memory Allocation Failed !!");
1298 }
1299
1300 int32_t ret = volumeGroupManagerNapi->audioGroupMngr_->SetMicStateChangeCallback(
1301 volumeGroupManagerNapi->micStateChangeCallbackNapi_);
1302 if (ret) {
1303 AUDIO_ERR_LOG("Registering Microphone Change Callback Failed");
1304 }
1305 }
1306
1307 std::shared_ptr<AudioManagerMicStateChangeCallbackNapi> cb =
1308 std::static_pointer_cast<AudioManagerMicStateChangeCallbackNapi>(volumeGroupManagerNapi->
1309 micStateChangeCallbackNapi_);
1310 cb->SaveCallbackReference(callbackName, args[PARAM1]);
1311
1312 AUDIO_DEBUG_LOG("On SetMicStateChangeCallback is successful");
1313 } else {
1314 AUDIO_ERR_LOG("No such callback supported");
1315 AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM);
1316 }
1317 return undefinedResult;
1318 }
1319
IsVolumeUnadjustable(napi_env env,napi_callback_info info)1320 napi_value AudioVolumeGroupManagerNapi::IsVolumeUnadjustable(napi_env env, napi_callback_info info)
1321 {
1322 napi_status status;
1323 napi_value result = nullptr;
1324 void* native = nullptr;
1325
1326 GET_PARAMS(env, info, ARGS_ONE);
1327 NAPI_ASSERT(env, argc <= ARGS_ONE, "requires 1 parameters maximum");
1328 status = napi_unwrap(env, thisVar, &native);
1329 auto* audioVolumeGroupManagerNapi = reinterpret_cast<AudioVolumeGroupManagerNapi*>(native);
1330 if (status != napi_ok || audioVolumeGroupManagerNapi == nullptr) {
1331 AUDIO_ERR_LOG("IsVolumeUnadjustable unwrap failure!");
1332 return nullptr;
1333 }
1334
1335 bool isVolumeUnadjustable = audioVolumeGroupManagerNapi->audioGroupMngr_->IsVolumeUnadjustable();
1336 napi_get_boolean(env, isVolumeUnadjustable, &result);
1337
1338 AUDIO_INFO_LOG("IsVolumeUnadjustable is successful");
1339 return result;
1340 }
1341
GetArgvForAdjustVolumeByStep(napi_env env,size_t argc,napi_value * argv,unique_ptr<AudioVolumeGroupManagerAsyncContext> & asyncContext)1342 bool GetArgvForAdjustVolumeByStep(napi_env env, size_t argc, napi_value* argv,
1343 unique_ptr<AudioVolumeGroupManagerAsyncContext> &asyncContext)
1344 {
1345 const int32_t refCount = 1;
1346
1347 if (argv == nullptr) {
1348 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
1349 return false;
1350 }
1351 if (argc < ARGS_ONE) {
1352 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
1353 return false;
1354 }
1355 for (size_t i = PARAM0; i < argc; i++) {
1356 napi_valuetype valueType = napi_undefined;
1357 napi_typeof(env, argv[i], &valueType);
1358
1359 if (i == PARAM0 && valueType == napi_number) {
1360 napi_get_value_int32(env, argv[i], &asyncContext->adjustType);
1361 if (!AudioCommonNapi::IsLegalInputArgumentVolumeAdjustType(asyncContext->adjustType)) {
1362 asyncContext->status = NAPI_ERR_INVALID_PARAM;
1363 }
1364 } else if (i == PARAM1) {
1365 if (valueType == napi_function) {
1366 napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef);
1367 }
1368 break;
1369 } else {
1370 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
1371 return false;
1372 }
1373 }
1374
1375 return true;
1376 }
1377
AdjustVolumeByStep(napi_env env,napi_callback_info info)1378 napi_value AudioVolumeGroupManagerNapi::AdjustVolumeByStep(napi_env env, napi_callback_info info)
1379 {
1380 napi_status status;
1381 napi_value result = nullptr;
1382
1383 GET_PARAMS(env, info, ARGS_TWO);
1384
1385 unique_ptr<AudioVolumeGroupManagerAsyncContext> asyncContext = make_unique<AudioVolumeGroupManagerAsyncContext>();
1386 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&asyncContext->objectInfo));
1387 if (status != napi_ok || asyncContext->objectInfo == nullptr) {
1388 AUDIO_ERR_LOG("AdjustVolumeByStep unwrap failure!");
1389 return nullptr;
1390 }
1391
1392 if (!GetArgvForAdjustVolumeByStep(env, argc, argv, asyncContext)) {
1393 return nullptr;
1394 }
1395
1396 if (asyncContext->callbackRef == nullptr) {
1397 napi_create_promise(env, &asyncContext->deferred, &result);
1398 } else {
1399 napi_get_undefined(env, &result);
1400 }
1401
1402 napi_value resource = nullptr;
1403 napi_create_string_utf8(env, "AdjustVolumeByStep", NAPI_AUTO_LENGTH, &resource);
1404
1405 status = napi_create_async_work(
1406 env, nullptr, resource,
1407 [](napi_env env, void *data) {
1408 auto context = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
1409 if (context->status == SUCCESS) {
1410 context->volumeAdjustStatus = context->objectInfo->audioGroupMngr_->AdjustVolumeByStep(
1411 static_cast<VolumeAdjustType>(context->adjustType));
1412 if (context->volumeAdjustStatus == SUCCESS) {
1413 context->status = SUCCESS;
1414 } else if (context->volumeAdjustStatus == ERR_PERMISSION_DENIED) {
1415 context->status = NAPI_ERR_NO_PERMISSION;
1416 } else {
1417 context->status = NAPI_ERR_SYSTEM;
1418 }
1419 }
1420 },
1421 GetVolumeAdjustByStepAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
1422 if (status != napi_ok) {
1423 result = nullptr;
1424 } else {
1425 NAPI_CALL(env, napi_queue_async_work(env, asyncContext->work));
1426 asyncContext.release();
1427 }
1428
1429 AUDIO_INFO_LOG("AdjustVolumeByStep is successful");
1430 return result;
1431 }
1432
GetArgvForAdjustSystemVolumeByStep(napi_env env,size_t argc,napi_value * argv,unique_ptr<AudioVolumeGroupManagerAsyncContext> & asyncContext)1433 bool GetArgvForAdjustSystemVolumeByStep(napi_env env, size_t argc, napi_value* argv,
1434 unique_ptr<AudioVolumeGroupManagerAsyncContext> &asyncContext)
1435 {
1436 const int32_t refCount = 1;
1437 if (argv == nullptr) {
1438 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
1439 return false;
1440 }
1441 if (argc < ARGS_ONE) {
1442 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
1443 return false;
1444 }
1445 for (size_t i = PARAM0; i < argc; i++) {
1446 napi_valuetype valueType = napi_undefined;
1447 napi_typeof(env, argv[i], &valueType);
1448
1449 if (i == PARAM0 && valueType == napi_number) {
1450 napi_get_value_int32(env, argv[i], &asyncContext->volType);
1451 if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)
1452 || asyncContext->volType == AudioManagerNapi::ALL) {
1453 asyncContext->status = NAPI_ERR_INVALID_PARAM;
1454 }
1455 } else if (i == PARAM1 && valueType == napi_number) {
1456 napi_get_value_int32(env, argv[i], &asyncContext->adjustType);
1457 if (!AudioCommonNapi::IsLegalInputArgumentVolumeAdjustType(asyncContext->adjustType)) {
1458 asyncContext->status = NAPI_ERR_INVALID_PARAM;
1459 }
1460 } else if (i == PARAM2) {
1461 if (valueType == napi_function) {
1462 napi_create_reference(env, argv[i], refCount, &asyncContext->callbackRef);
1463 }
1464 break;
1465 } else {
1466 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
1467 return false;
1468 }
1469 }
1470
1471 return true;
1472 }
1473
AdjustSystemVolumeByStep(napi_env env,napi_callback_info info)1474 napi_value AudioVolumeGroupManagerNapi::AdjustSystemVolumeByStep(napi_env env, napi_callback_info info)
1475 {
1476 napi_status status;
1477 napi_value result = nullptr;
1478
1479 GET_PARAMS(env, info, ARGS_THREE);
1480
1481 unique_ptr<AudioVolumeGroupManagerAsyncContext> asyncContext = make_unique<AudioVolumeGroupManagerAsyncContext>();
1482 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&asyncContext->objectInfo));
1483 if (status != napi_ok || asyncContext->objectInfo == nullptr) {
1484 AUDIO_ERR_LOG("AdjustSystemVolumeByStep unwrap failure!");
1485 return nullptr;
1486 }
1487
1488 if (!GetArgvForAdjustSystemVolumeByStep(env, argc, argv, asyncContext)) {
1489 return nullptr;
1490 }
1491
1492 if (asyncContext->callbackRef == nullptr) {
1493 napi_create_promise(env, &asyncContext->deferred, &result);
1494 } else {
1495 napi_get_undefined(env, &result);
1496 }
1497
1498 napi_value resource = nullptr;
1499 napi_create_string_utf8(env, "AdjustSystemVolumeByStep", NAPI_AUTO_LENGTH, &resource);
1500
1501 status = napi_create_async_work(
1502 env, nullptr, resource,
1503 [](napi_env env, void *data) {
1504 auto context = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
1505 if (context->status == SUCCESS) {
1506 context->volumeAdjustStatus = context->objectInfo->audioGroupMngr_->AdjustSystemVolumeByStep(
1507 GetNativeAudioVolumeType(context->volType),
1508 static_cast<VolumeAdjustType>(context->adjustType));
1509 if (context->volumeAdjustStatus == SUCCESS) {
1510 context->status = SUCCESS;
1511 } else if (context->volumeAdjustStatus == ERR_PERMISSION_DENIED) {
1512 context->status = NAPI_ERR_NO_PERMISSION;
1513 } else {
1514 context->status = NAPI_ERR_SYSTEM;
1515 }
1516 }
1517 },
1518 GetVolumeAdjustByStepAsyncCallbackComplete, static_cast<void*>(asyncContext.get()), &asyncContext->work);
1519 if (status != napi_ok) {
1520 result = nullptr;
1521 } else {
1522 NAPI_CALL(env, napi_queue_async_work(env, asyncContext->work));
1523 asyncContext.release();
1524 }
1525
1526 AUDIO_INFO_LOG("AdjustSystemVolumeByStep is successful");
1527 return result;
1528 }
1529
GetArgvForSystemVolumeInDb(napi_env env,size_t argc,napi_value * argv,unique_ptr<AudioVolumeGroupManagerAsyncContext> & asyncContext)1530 bool GetArgvForSystemVolumeInDb(napi_env env, size_t argc, napi_value* argv,
1531 unique_ptr<AudioVolumeGroupManagerAsyncContext> &asyncContext)
1532 {
1533 const int32_t refCount = 1;
1534 if (argv == nullptr) {
1535 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
1536 return false;
1537 }
1538
1539 if (argc < ARGS_THREE) {
1540 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
1541 return false;
1542 }
1543
1544 for (size_t i = PARAM0; i < argc; i++) {
1545 napi_valuetype valueType = napi_undefined;
1546 napi_typeof(env, argv[i], &valueType);
1547
1548 if (i == PARAM0 && valueType == napi_number) {
1549 napi_get_value_int32(env, argv[i], &asyncContext->volType);
1550 if (!AudioCommonNapi::IsLegalInputArgumentVolType(asyncContext->volType)) {
1551 asyncContext->status = NAPI_ERR_INVALID_PARAM;
1552 }
1553 } else if (i == PARAM1 && valueType == napi_number) {
1554 napi_get_value_int32(env, argv[i], &asyncContext->volLevel);
1555 } else if (i == PARAM2 && valueType == napi_number) {
1556 napi_get_value_int32(env, argv[i], &asyncContext->deviceType);
1557 if (!AudioCommonNapi::IsLegalInputArgumentDeviceType(asyncContext->deviceType)) {
1558 asyncContext->status = NAPI_ERR_INVALID_PARAM;
1559 }
1560 } else if (i == PARAM3) {
1561 if (valueType == napi_function) {
1562 napi_create_reference(env, argv[PARAM3], refCount, &asyncContext->callbackRef);
1563 }
1564 break;
1565 } else {
1566 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
1567 return false;
1568 }
1569 }
1570 return true;
1571 }
1572
GetSystemVolumeInDb(napi_env env,napi_callback_info info)1573 napi_value AudioVolumeGroupManagerNapi::GetSystemVolumeInDb(napi_env env, napi_callback_info info)
1574 {
1575 napi_status status;
1576 napi_value result = nullptr;
1577 GET_PARAMS(env, info, ARGS_FOUR);
1578
1579 unique_ptr<AudioVolumeGroupManagerAsyncContext> asyncContext = make_unique<AudioVolumeGroupManagerAsyncContext>();
1580 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&asyncContext->objectInfo));
1581 if (status != napi_ok || asyncContext->objectInfo == nullptr) {
1582 AUDIO_ERR_LOG("GetSystemVolumeInDb unwrap failure!");
1583 return nullptr;
1584 }
1585
1586 if (!GetArgvForSystemVolumeInDb(env, argc, argv, asyncContext)) {
1587 return nullptr;
1588 }
1589 if (asyncContext->callbackRef == nullptr) {
1590 napi_create_promise(env, &asyncContext->deferred, &result);
1591 } else {
1592 napi_get_undefined(env, &result);
1593 }
1594
1595 napi_value resource = nullptr;
1596 napi_create_string_utf8(env, "GetSystemVolumeInDb", NAPI_AUTO_LENGTH, &resource);
1597
1598 status = napi_create_async_work(
1599 env, nullptr, resource,
1600 [](napi_env env, void *data) {
1601 auto context = static_cast<AudioVolumeGroupManagerAsyncContext*>(data);
1602 if (context->status == SUCCESS) {
1603 context->volumeInDb = context->objectInfo->audioGroupMngr_->GetSystemVolumeInDb(
1604 GetNativeAudioVolumeType(context->volType), context->volLevel,
1605 static_cast<DeviceType>(context->deviceType));
1606 if (FLOAT_COMPARE_EQ(context->volumeInDb, static_cast<float>(ERR_INVALID_PARAM))) {
1607 // The return value is ERR_INVALID_PARAM
1608 context->status = NAPI_ERR_INVALID_PARAM;
1609 } else if (context->volumeInDb < 0) {
1610 context->status = NAPI_ERR_SYSTEM;
1611 } else {
1612 context->status = SUCCESS;
1613 }
1614 }
1615 },
1616 GetVolumeDbAsyncCallbackComplete, static_cast<void *>(asyncContext.get()), &asyncContext->work);
1617 if (status != napi_ok) {
1618 result = nullptr;
1619 } else {
1620 NAPI_CALL(env, napi_queue_async_work(env, asyncContext->work));
1621 asyncContext.release();
1622 }
1623
1624 AUDIO_INFO_LOG("GetSystemVolumeInDb is successful");
1625 return result;
1626 }
1627
GetSystemVolumeInDbSync(napi_env env,napi_callback_info info)1628 napi_value AudioVolumeGroupManagerNapi::GetSystemVolumeInDbSync(napi_env env, napi_callback_info info)
1629 {
1630 napi_status status;
1631 napi_value result = nullptr;
1632 void *native = nullptr;
1633
1634 GET_PARAMS(env, info, ARGS_THREE);
1635
1636 if (argc < ARGS_THREE) {
1637 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
1638 return result;
1639 }
1640
1641 status = napi_unwrap(env, thisVar, &native);
1642 auto *audioVolumeGroupManagerNapi = reinterpret_cast<AudioVolumeGroupManagerNapi *>(native);
1643 if (status != napi_ok || audioVolumeGroupManagerNapi == nullptr) {
1644 AUDIO_ERR_LOG("GetSystemVolumeInDbSync unwrap failure!");
1645 return result;
1646 }
1647
1648 int32_t volType;
1649 int32_t volLevel;
1650 int32_t deviceType;
1651 for (size_t i = PARAM0; i < argc; i++) {
1652 napi_valuetype valueType = napi_undefined;
1653 napi_typeof(env, argv[i], &valueType);
1654 if (valueType != napi_number) {
1655 AudioCommonNapi::throwError(env, NAPI_ERR_INPUT_INVALID);
1656 return result;
1657 }
1658
1659 bool isLegalInput = false;
1660 if (i == PARAM0) {
1661 napi_get_value_int32(env, argv[i], &volType);
1662 isLegalInput = AudioCommonNapi::IsLegalInputArgumentVolType(volType);
1663 } else if (i == PARAM1) {
1664 napi_get_value_int32(env, argv[i], &volLevel);
1665 isLegalInput = true;
1666 } else if (i == PARAM2) {
1667 napi_get_value_int32(env, argv[i], &deviceType);
1668 isLegalInput = AudioCommonNapi::IsLegalInputArgumentDeviceType(deviceType);
1669 }
1670 if (!isLegalInput) {
1671 AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM);
1672 return result;
1673 }
1674 }
1675
1676 double volumeInDb = audioVolumeGroupManagerNapi->audioGroupMngr_->GetSystemVolumeInDb(
1677 GetNativeAudioVolumeType(volType), volLevel, static_cast<DeviceType>(deviceType));
1678 if (FLOAT_COMPARE_EQ(static_cast<float>(volumeInDb), static_cast<float>(ERR_INVALID_PARAM))) {
1679 AudioCommonNapi::throwError(env, NAPI_ERR_INVALID_PARAM);
1680 return result;
1681 }
1682 napi_create_double(env, volumeInDb, &result);
1683
1684 return result;
1685 }
1686
Init(napi_env env,napi_value exports)1687 napi_value AudioVolumeGroupManagerNapi::Init(napi_env env, napi_value exports)
1688 {
1689 AUDIO_INFO_LOG("Init");
1690 napi_status status;
1691 napi_value constructor;
1692 napi_value result = nullptr;
1693 const int32_t refCount = 1;
1694 napi_get_undefined(env, &result);
1695
1696 napi_property_descriptor audio_svc_group_mngr_properties[] = {
1697 DECLARE_NAPI_FUNCTION("setVolume", AudioVolumeGroupManagerNapi::SetVolume),
1698 DECLARE_NAPI_FUNCTION("getVolume", AudioVolumeGroupManagerNapi::GetVolume),
1699 DECLARE_NAPI_FUNCTION("getVolumeSync", AudioVolumeGroupManagerNapi::GetVolumeSync),
1700 DECLARE_NAPI_FUNCTION("getMaxVolume", AudioVolumeGroupManagerNapi::GetMaxVolume),
1701 DECLARE_NAPI_FUNCTION("getMaxVolumeSync", AudioVolumeGroupManagerNapi::GetMaxVolumeSync),
1702 DECLARE_NAPI_FUNCTION("getMinVolume", AudioVolumeGroupManagerNapi::GetMinVolume),
1703 DECLARE_NAPI_FUNCTION("getMinVolumeSync", AudioVolumeGroupManagerNapi::GetMinVolumeSync),
1704 DECLARE_NAPI_FUNCTION("mute", AudioVolumeGroupManagerNapi::SetMute),
1705 DECLARE_NAPI_FUNCTION("isMute", AudioVolumeGroupManagerNapi::IsStreamMute),
1706 DECLARE_NAPI_FUNCTION("isMuteSync", AudioVolumeGroupManagerNapi::IsStreamMuteSync),
1707 DECLARE_NAPI_FUNCTION("setRingerMode", SetRingerMode),
1708 DECLARE_NAPI_FUNCTION("getRingerMode", GetRingerMode),
1709 DECLARE_NAPI_FUNCTION("getRingerModeSync", GetRingerModeSync),
1710 DECLARE_NAPI_FUNCTION("setMicrophoneMute", SetMicrophoneMute),
1711 DECLARE_NAPI_FUNCTION("isMicrophoneMute", IsMicrophoneMute),
1712 DECLARE_NAPI_FUNCTION("isMicrophoneMuteSync", IsMicrophoneMuteSync),
1713 DECLARE_NAPI_FUNCTION("on", On),
1714 DECLARE_NAPI_FUNCTION("isVolumeUnadjustable", IsVolumeUnadjustable),
1715 DECLARE_NAPI_FUNCTION("adjustVolumeByStep", AdjustVolumeByStep),
1716 DECLARE_NAPI_FUNCTION("adjustSystemVolumeByStep", AdjustSystemVolumeByStep),
1717 DECLARE_NAPI_FUNCTION("getSystemVolumeInDb", GetSystemVolumeInDb),
1718 DECLARE_NAPI_FUNCTION("getSystemVolumeInDbSync", GetSystemVolumeInDbSync),
1719 };
1720
1721 status = napi_define_class(env, AUDIO_VOLUME_GROUP_MNGR_NAPI_CLASS_NAME.c_str(),
1722 NAPI_AUTO_LENGTH, Construct, nullptr,
1723 sizeof(audio_svc_group_mngr_properties) / sizeof(audio_svc_group_mngr_properties[PARAM0]),
1724 audio_svc_group_mngr_properties, &constructor);
1725 if (status != napi_ok) {
1726 return result;
1727 }
1728 status = napi_create_reference(env, constructor, refCount, &g_groupmanagerConstructor);
1729 if (status == napi_ok) {
1730 status = napi_set_named_property(env, exports, AUDIO_VOLUME_GROUP_MNGR_NAPI_CLASS_NAME.c_str(), constructor);
1731 if (status == napi_ok) {
1732 return exports;
1733 }
1734 }
1735
1736 HiLog::Error(LABEL, "Failure in AudioVolumeGroupManagerNapi::Init()");
1737 return result;
1738 }
1739 } // namespace AudioStandard
1740 } // namespace OHOS
1741