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 #ifndef LOG_TAG
16 #define LOG_TAG "AudioGroupManager"
17 #endif
18
19 #include "audio_errors.h"
20 #include "audio_policy_manager.h"
21 #include "audio_service_log.h"
22 #include "iservice_registry.h"
23 #include "system_ability_definition.h"
24 #include "audio_utils.h"
25
26 #include "audio_group_manager.h"
27 #include "istandard_audio_service.h"
28
29 namespace OHOS {
30 namespace AudioStandard {
31 static sptr<IStandardAudioService> g_sProxy = nullptr;
AudioGroupManager(int32_t groupId)32 AudioGroupManager::AudioGroupManager(int32_t groupId) : groupId_(groupId)
33 {
34 }
~AudioGroupManager()35 AudioGroupManager::~AudioGroupManager()
36 {
37 AUDIO_DEBUG_LOG("AudioGroupManager start");
38 if (cbClientId_ != -1) {
39 UnsetRingerModeCallback(cbClientId_);
40 }
41 }
42
SetVolume(AudioVolumeType volumeType,int32_t volume,int32_t volumeFlag,int32_t uid)43 int32_t AudioGroupManager::SetVolume(AudioVolumeType volumeType, int32_t volume, int32_t volumeFlag, int32_t uid)
44 {
45 if (connectType_ == CONNECT_TYPE_DISTRIBUTED) {
46 std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=" + std::to_string(groupId_) + ";AUDIO_VOLUME_TYPE="
47 + std::to_string(volumeType) + ";";
48 std::string value = std::to_string(volume);
49 g_sProxy->SetAudioParameter(netWorkId_, AudioParamKey::VOLUME, condition, value);
50 return SUCCESS;
51 }
52
53 AUDIO_INFO_LOG("SetSystemVolume: volumeType[%{public}d], volume[%{public}d], flag[%{public}d]",
54 volumeType, volume, volumeFlag);
55
56 /* Validate volume type and return INVALID_PARAMS error */
57 switch (volumeType) {
58 case STREAM_VOICE_CALL:
59 case STREAM_VOICE_COMMUNICATION:
60 case STREAM_RING:
61 case STREAM_NOTIFICATION:
62 case STREAM_MUSIC:
63 case STREAM_ALARM:
64 case STREAM_SYSTEM:
65 case STREAM_ACCESSIBILITY:
66 case STREAM_VOICE_ASSISTANT:
67 break;
68 case STREAM_ULTRASONIC:
69 case STREAM_ALL:{
70 bool ret = PermissionUtil::VerifySelfPermission();
71 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "SetVolume: No system permission");
72 break;
73 }
74 default:
75 AUDIO_ERR_LOG("SetVolume: volumeType[%{public}d] is not supported", volumeType);
76 return ERR_NOT_SUPPORTED;
77 }
78
79 if (volumeType == STREAM_NOTIFICATION) {
80 return AudioPolicyManager::GetInstance().SetSystemNotificationVolumeLevel(
81 volumeType, volume, false, volumeFlag, uid);
82 }
83
84 /* Call Audio Policy SetSystemVolumeLevel */
85 return AudioPolicyManager::GetInstance().SetSystemVolumeLevel(volumeType, volume, false, volumeFlag, uid);
86 }
87
GetActiveVolumeType(const int32_t clientUid)88 AudioStreamType AudioGroupManager::GetActiveVolumeType(const int32_t clientUid)
89 {
90 return AudioPolicyManager::GetInstance().GetSystemActiveVolumeType(clientUid);
91 }
92
GetVolume(AudioVolumeType volumeType,int32_t uid)93 int32_t AudioGroupManager::GetVolume(AudioVolumeType volumeType, int32_t uid)
94 {
95 if (connectType_ == CONNECT_TYPE_DISTRIBUTED) {
96 std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=" + std::to_string(groupId_) + ";AUDIO_VOLUME_TYPE="
97 + std::to_string(volumeType) + ";";
98 std::string value;
99 CHECK_AND_RETURN_RET_LOG(g_sProxy != nullptr, ERROR, "g_sProxy is nullptr");
100 g_sProxy->GetAudioParameter(netWorkId_, AudioParamKey::VOLUME, condition, value);
101 int32_t convertValue = 0;
102 CHECK_AND_RETURN_RET_LOG(StringConverter(value, convertValue), 0,
103 "[AudioGroupManger]: convert invalid value: %{public}s", value.c_str());
104 return convertValue;
105 }
106
107 switch (volumeType) {
108 case STREAM_MUSIC:
109 case STREAM_RING:
110 case STREAM_NOTIFICATION:
111 case STREAM_VOICE_CALL:
112 case STREAM_VOICE_COMMUNICATION:
113 case STREAM_VOICE_ASSISTANT:
114 case STREAM_ALARM:
115 case STREAM_SYSTEM:
116 case STREAM_ACCESSIBILITY:
117 break;
118 case STREAM_ULTRASONIC:
119 case STREAM_ALL:{
120 bool ret = PermissionUtil::VerifySelfPermission();
121 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED,
122 "GetVolume: No system permission");
123 break;
124 }
125 default:
126 AUDIO_ERR_LOG("GetVolume volumeType=%{public}d not supported", volumeType);
127 return ERR_NOT_SUPPORTED;
128 }
129
130 if (volumeType == STREAM_NOTIFICATION) {
131 return AudioPolicyManager::GetInstance().GetSystemNotificationVolumeLevel(volumeType, uid);
132 }
133
134 return AudioPolicyManager::GetInstance().GetSystemVolumeLevel(volumeType, uid);
135 }
136
GetMaxVolume(AudioVolumeType volumeType)137 int32_t AudioGroupManager::GetMaxVolume(AudioVolumeType volumeType)
138 {
139 if (!IsAlived()) {
140 CHECK_AND_RETURN_RET_LOG(g_sProxy != nullptr, ERR_OPERATION_FAILED, "GetMaxVolume service unavailable");
141 }
142 if (connectType_ == CONNECT_TYPE_DISTRIBUTED) {
143 std::string condition = "EVENT_TYPE=3;VOLUME_GROUP_ID=" + std::to_string(groupId_) + ";AUDIO_VOLUME_TYPE=" +
144 std::to_string(volumeType) + ";";
145 std::string value;
146 g_sProxy->GetAudioParameter(netWorkId_, AudioParamKey::VOLUME, condition, value);
147 int32_t convertValue = 0;
148 CHECK_AND_RETURN_RET_LOG(StringConverter(value, convertValue), 0,
149 "[AudioGroupManger]: convert invalid value: %{public}s", value.c_str());
150 return convertValue;
151 }
152
153 if (volumeType == STREAM_ALL) {
154 bool ret = PermissionUtil::VerifySelfPermission();
155 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "GetMaxVolume: No system permission");
156 }
157
158 if (volumeType == STREAM_ULTRASONIC) {
159 bool ret = PermissionUtil::VerifySelfPermission();
160 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED,
161 "GetMaxVolume: STREAM_ULTRASONIC No system permission");
162 }
163 return AudioPolicyManager::GetInstance().GetMaxVolumeLevel(volumeType);
164 }
165
GetMinVolume(AudioVolumeType volumeType)166 int32_t AudioGroupManager::GetMinVolume(AudioVolumeType volumeType)
167 {
168 if (!IsAlived()) {
169 CHECK_AND_RETURN_RET_LOG(g_sProxy != nullptr, ERR_OPERATION_FAILED, "GetMinVolume service unavailable");
170 }
171 if (connectType_ == CONNECT_TYPE_DISTRIBUTED) {
172 std::string condition = "EVENT_TYPE=2;VOLUME_GROUP_ID=" + std::to_string(groupId_) + ";AUDIO_VOLUME_TYPE" +
173 std::to_string(volumeType) + ";";
174 std::string value;
175 g_sProxy->GetAudioParameter(netWorkId_, AudioParamKey::VOLUME, condition, value);
176 int32_t convertValue = 0;
177 CHECK_AND_RETURN_RET_LOG(StringConverter(value, convertValue), 0,
178 "[AudioGroupManger]: convert invalid value: %{public}s", value.c_str());
179 return convertValue;
180 }
181
182 if (volumeType == STREAM_ALL) {
183 bool ret = PermissionUtil::VerifySelfPermission();
184 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED,
185 "GetMinVolume: No system permission");
186 }
187
188 if (volumeType == STREAM_ULTRASONIC) {
189 bool ret = PermissionUtil::VerifySelfPermission();
190 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED,
191 "GetMinVolume: STREAM_ULTRASONIC No system permission");
192 }
193 return AudioPolicyManager::GetInstance().GetMinVolumeLevel(volumeType);
194 }
195
SetMute(AudioVolumeType volumeType,bool mute,const DeviceType & deviceType)196 int32_t AudioGroupManager::SetMute(AudioVolumeType volumeType, bool mute, const DeviceType &deviceType)
197 {
198 if (connectType_ == CONNECT_TYPE_DISTRIBUTED) {
199 std::string conditon = "EVENT_TYPE=4;VOLUME_GROUP_ID=" + std::to_string(groupId_) + ";AUDIO_VOLUME_TYPE="
200 + std::to_string(volumeType) + ";";
201 std::string value = mute ? "1" : "0";
202 g_sProxy->SetAudioParameter(netWorkId_, AudioParamKey::VOLUME, conditon, value);
203 return SUCCESS;
204 }
205
206 if (deviceType != DEVICE_TYPE_NONE) {
207 AUDIO_INFO_LOG("SetMute: deviceType [%{public}d], mute [%{public}d]", deviceType, mute);
208 }
209
210 AUDIO_INFO_LOG("SetStreamMute: volumeType [%{public}d], mute [%{public}d]", volumeType, mute);
211 switch (volumeType) {
212 case STREAM_MUSIC:
213 case STREAM_RING:
214 case STREAM_NOTIFICATION:
215 case STREAM_VOICE_CALL:
216 case STREAM_VOICE_COMMUNICATION:
217 case STREAM_VOICE_ASSISTANT:
218 case STREAM_ALARM:
219 case STREAM_SYSTEM:
220 case STREAM_ACCESSIBILITY:
221 case STREAM_ULTRASONIC:
222 case STREAM_ALL:
223 break;
224 default:
225 AUDIO_ERR_LOG("volumeType [%{public}d] is not supported", volumeType);
226 return ERR_NOT_SUPPORTED;
227 }
228
229 /* Call Audio Policy SetStreamMute */
230 return AudioPolicyManager::GetInstance().SetStreamMute(volumeType, mute, false, deviceType);
231 }
232
IsStreamMute(AudioVolumeType volumeType,bool & isMute)233 int32_t AudioGroupManager::IsStreamMute(AudioVolumeType volumeType, bool &isMute)
234 {
235 AUDIO_DEBUG_LOG("GetMute Client");
236 if (connectType_ == CONNECT_TYPE_DISTRIBUTED) {
237 std::string condition = "EVENT_TYPE=4;VOLUME_GROUP_ID=" + std::to_string(groupId_) + ";AUDIO_VOLUME_TYPE="
238 + std::to_string(volumeType) + ";";
239 CHECK_AND_RETURN_RET_LOG(g_sProxy != nullptr, ERROR, "g_sProxy is nullptr");
240 std::string ret;
241 g_sProxy->GetAudioParameter(netWorkId_, AudioParamKey::VOLUME, condition, ret);
242 isMute = (ret == "1" ? true : false);
243 return SUCCESS;
244 }
245
246 switch (volumeType) {
247 case STREAM_MUSIC:
248 case STREAM_RING:
249 case STREAM_NOTIFICATION:
250 case STREAM_VOICE_CALL:
251 case STREAM_VOICE_COMMUNICATION:
252 case STREAM_VOICE_ASSISTANT:
253 case STREAM_ALARM:
254 case STREAM_SYSTEM:
255 case STREAM_ACCESSIBILITY:
256 break;
257 case STREAM_ULTRASONIC:
258 case STREAM_ALL:{
259 bool ret = PermissionUtil::VerifySelfPermission();
260 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED,
261 "IsStreamMute: No system permission");
262 break;
263 }
264 default:
265 AUDIO_ERR_LOG("volumeType [%{public}d] is not supported", volumeType);
266 return false;
267 }
268
269 isMute = AudioPolicyManager::GetInstance().GetStreamMute(volumeType);
270 return SUCCESS;
271 }
272
Init()273 int32_t AudioGroupManager::Init()
274 {
275 // init networkId_
276 std::string netWorkId;
277 int32_t ret = AudioPolicyManager::GetInstance().GetNetworkIdByGroupId(groupId_, netWorkId);
278 if (ret == SUCCESS) {
279 netWorkId_ = netWorkId;
280 connectType_ = netWorkId_ == LOCAL_NETWORK_ID ? CONNECT_TYPE_LOCAL : CONNECT_TYPE_DISTRIBUTED;
281 AUDIO_INFO_LOG("AudioGroupManager::init set networkId %{public}s.", netWorkId_.c_str());
282 } else {
283 AUDIO_ERR_LOG("AudioGroupManager::init failed, has no valid group");
284 return ERROR;
285 }
286
287 // init g_sProxy
288 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
289 CHECK_AND_RETURN_RET_LOG(samgr != nullptr, ERROR, "AudioSystemManager::init failed");
290
291 sptr<IRemoteObject> object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID);
292 CHECK_AND_RETURN_RET_LOG(object != nullptr, ERROR, "AudioSystemManager::object is NULL.");
293 g_sProxy = iface_cast<IStandardAudioService>(object);
294 if (g_sProxy == nullptr) {
295 AUDIO_DEBUG_LOG("AudioSystemManager::init g_sProxy is NULL.");
296 return ERROR;
297 } else {
298 AUDIO_DEBUG_LOG("AudioSystemManager::init g_sProxy is assigned.");
299 return SUCCESS;
300 }
301 }
302 // LCOV_EXCL_STOP
303
IsAlived()304 bool AudioGroupManager::IsAlived()
305 {
306 if (g_sProxy == nullptr) {
307 Init();
308 }
309
310 return (g_sProxy != nullptr) ? true : false;
311 }
312
GetGroupId()313 int32_t AudioGroupManager::GetGroupId()
314 {
315 return groupId_;
316 }
317
SetRingerModeCallback(const int32_t clientId,const std::shared_ptr<AudioRingerModeCallback> & callback)318 int32_t AudioGroupManager::SetRingerModeCallback(const int32_t clientId,
319 const std::shared_ptr<AudioRingerModeCallback> &callback)
320 {
321 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM,
322 "AudioSystemManager: callback is nullptr");
323
324 cbClientId_ = clientId;
325
326 return AudioPolicyManager::GetInstance().SetRingerModeCallback(clientId, callback, API_9);
327 }
328
UnsetRingerModeCallback(const int32_t clientId) const329 int32_t AudioGroupManager::UnsetRingerModeCallback(const int32_t clientId) const
330 {
331 return AudioPolicyManager::GetInstance().UnsetRingerModeCallback(clientId);
332 }
333
UnsetRingerModeCallback(const int32_t clientId,const std::shared_ptr<AudioRingerModeCallback> & callback) const334 int32_t AudioGroupManager::UnsetRingerModeCallback(const int32_t clientId,
335 const std::shared_ptr<AudioRingerModeCallback> &callback) const
336 {
337 return AudioPolicyManager::GetInstance().UnsetRingerModeCallback(clientId, callback);
338 }
339
SetRingerMode(AudioRingerMode ringMode) const340 int32_t AudioGroupManager::SetRingerMode(AudioRingerMode ringMode) const
341 {
342 AUDIO_INFO_LOG("ringer mode: %{public}d", ringMode);
343 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, ERROR,
344 "AudioGroupManager::SetRingerMode is not supported for local device.");
345 /* Call Audio Policy SetRingerMode */
346 return AudioPolicyManager::GetInstance().SetRingerMode(ringMode);
347 }
348
GetRingerMode() const349 AudioRingerMode AudioGroupManager::GetRingerMode() const
350 {
351 /* Call Audio Policy GetRingerMode */
352 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, AudioRingerMode::RINGER_MODE_NORMAL,
353 "AudioGroupManager::SetRingerMode is not supported for local device.");
354 return (AudioPolicyManager::GetInstance().GetRingerMode());
355 }
356
SetMicrophoneMute(bool isMute)357 int32_t AudioGroupManager::SetMicrophoneMute(bool isMute)
358 {
359 /* Call Audio Policy GetRingerMode */
360 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, ERROR,
361 "AudioGroupManager::SetRingerMode is not supported for local device.");
362 return AudioPolicyManager::GetInstance().SetMicrophoneMuteAudioConfig(isMute);
363 }
364
SetMicrophoneMutePersistent(const bool isMute,const PolicyType type)365 int32_t AudioGroupManager::SetMicrophoneMutePersistent(const bool isMute, const PolicyType type)
366 {
367 AUDIO_INFO_LOG("Set persistent mic mute state, isMute is %{public}d", isMute);
368 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, ERROR,
369 "Failed due to not supported for local device.");
370 return AudioPolicyManager::GetInstance().SetMicrophoneMutePersistent(isMute, type);
371 }
372
GetPersistentMicMuteState()373 bool AudioGroupManager::GetPersistentMicMuteState()
374 {
375 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, ERROR,
376 "AudioGroupManager::GetPersistentMicMuteState is not supported for local device.");
377 return AudioPolicyManager::GetInstance().GetPersistentMicMuteState();
378 }
379
IsMicrophoneMuteLegacy()380 bool AudioGroupManager::IsMicrophoneMuteLegacy()
381 {
382 /* Call Audio Policy GetRingerMode */
383 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, false,
384 "AudioGroupManager::SetRingerMode is not supported for local device.");
385 return AudioPolicyManager::GetInstance().IsMicrophoneMuteLegacy();
386 }
387
IsMicrophoneMute()388 bool AudioGroupManager::IsMicrophoneMute()
389 {
390 /* Call Audio Policy GetRingerMode */
391 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, false,
392 "AudioGroupManager::SetRingerMode is not supported for local device.");
393 return AudioPolicyManager::GetInstance().IsMicrophoneMute();
394 }
395
SetMicStateChangeCallback(const std::shared_ptr<AudioManagerMicStateChangeCallback> & callback)396 int32_t AudioGroupManager::SetMicStateChangeCallback(
397 const std::shared_ptr<AudioManagerMicStateChangeCallback> &callback)
398 {
399 AUDIO_INFO_LOG("Entered AudioRoutingManager::%{public}s", __func__);
400 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM,
401 "setMicrophoneMuteCallback::callback is null");
402 int32_t clientId = static_cast<int32_t>(getpid());
403 return AudioPolicyManager::GetInstance().SetMicStateChangeCallback(clientId, callback);
404 }
405
UnsetMicStateChangeCallback(const std::shared_ptr<AudioManagerMicStateChangeCallback> & callback)406 int32_t AudioGroupManager::UnsetMicStateChangeCallback(
407 const std::shared_ptr<AudioManagerMicStateChangeCallback> &callback)
408 {
409 return AudioPolicyManager::GetInstance().UnsetMicStateChangeCallback(callback);
410 }
411
IsVolumeUnadjustable()412 bool AudioGroupManager::IsVolumeUnadjustable()
413 {
414 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, ERROR, "is only supported for LOCAL_NETWORK_ID.");
415 return AudioPolicyManager::GetInstance().IsVolumeUnadjustable();
416 }
417
AdjustVolumeByStep(VolumeAdjustType adjustType)418 int32_t AudioGroupManager::AdjustVolumeByStep(VolumeAdjustType adjustType)
419 {
420 return AudioPolicyManager::GetInstance().AdjustVolumeByStep(adjustType);
421 }
422
AdjustSystemVolumeByStep(AudioVolumeType volumeType,VolumeAdjustType adjustType)423 int32_t AudioGroupManager::AdjustSystemVolumeByStep(AudioVolumeType volumeType, VolumeAdjustType adjustType)
424 {
425 return AudioPolicyManager::GetInstance().AdjustSystemVolumeByStep(volumeType, adjustType);
426 }
427
GetSystemVolumeInDb(AudioVolumeType volumeType,int32_t volumeLevel,DeviceType deviceType)428 float AudioGroupManager::GetSystemVolumeInDb(AudioVolumeType volumeType, int32_t volumeLevel, DeviceType deviceType)
429 {
430 /* Call Audio Policy GetSystemVolumeInDb */
431 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, static_cast<float>(ERROR),
432 "is only supported for LOCAL_NETWORK_ID.");
433 return AudioPolicyManager::GetInstance().GetSystemVolumeInDb(volumeType, volumeLevel, deviceType);
434 }
435
GetMaxAmplitude(const int32_t deviceId)436 float AudioGroupManager::GetMaxAmplitude(const int32_t deviceId)
437 {
438 return AudioPolicyManager::GetInstance().GetMaxAmplitude(deviceId);
439 }
440
SetVolumeDegree(AudioVolumeType volumeType,int32_t degree,int32_t volumeFlag,int32_t uid)441 int32_t AudioGroupManager::SetVolumeDegree(AudioVolumeType volumeType, int32_t degree, int32_t volumeFlag, int32_t uid)
442 {
443 AUDIO_INFO_LOG("volumeType[%{public}d], degree[%{public}d], flag[%{public}d]",
444 volumeType, degree, volumeFlag);
445
446 /* Validate volume type and return INVALID_PARAMS error */
447 switch (volumeType) {
448 case STREAM_VOICE_CALL:
449 case STREAM_VOICE_COMMUNICATION:
450 case STREAM_RING:
451 case STREAM_MUSIC:
452 case STREAM_ALARM:
453 case STREAM_SYSTEM:
454 case STREAM_ACCESSIBILITY:
455 case STREAM_VOICE_ASSISTANT:
456 break;
457 case STREAM_ULTRASONIC:
458 case STREAM_ALL:{
459 bool ret = PermissionUtil::VerifySelfPermission();
460 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "No system permission");
461 break;
462 }
463 default:
464 AUDIO_ERR_LOG("volumeType[%{public}d] is not supported", volumeType);
465 return ERR_NOT_SUPPORTED;
466 }
467
468 return AudioPolicyManager::GetInstance().SetSystemVolumeDegree(volumeType, degree, volumeFlag, uid);
469 }
470
GetVolumeDegree(AudioVolumeType volumeType,int32_t uid)471 int32_t AudioGroupManager::GetVolumeDegree(AudioVolumeType volumeType, int32_t uid)
472 {
473 switch (volumeType) {
474 case STREAM_MUSIC:
475 case STREAM_RING:
476 case STREAM_NOTIFICATION:
477 case STREAM_VOICE_CALL:
478 case STREAM_VOICE_COMMUNICATION:
479 case STREAM_VOICE_ASSISTANT:
480 case STREAM_ALARM:
481 case STREAM_SYSTEM:
482 case STREAM_ACCESSIBILITY:
483 break;
484 case STREAM_ULTRASONIC:
485 case STREAM_ALL:{
486 bool ret = PermissionUtil::VerifySelfPermission();
487 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED,
488 "No system permission");
489 break;
490 }
491 default:
492 AUDIO_ERR_LOG("volumeType=%{public}d not supported", volumeType);
493 return ERR_NOT_SUPPORTED;
494 }
495
496 return AudioPolicyManager::GetInstance().GetSystemVolumeDegree(volumeType, uid);
497 }
498
GetMinVolumeDegree(AudioVolumeType volumeType)499 int32_t AudioGroupManager::GetMinVolumeDegree(AudioVolumeType volumeType)
500 {
501 if (volumeType == STREAM_ALL) {
502 bool ret = PermissionUtil::VerifySelfPermission();
503 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED,
504 "No system permission");
505 }
506
507 if (volumeType == STREAM_ULTRASONIC) {
508 bool ret = PermissionUtil::VerifySelfPermission();
509 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED,
510 "STREAM_ULTRASONIC No system permission");
511 }
512 return AudioPolicyManager::GetInstance().GetMinVolumeDegree(volumeType);
513 }
514 } // namespace AudioStandard
515 } // namespace OHOS
516