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_manager_proxy.h"
21 #include "audio_policy_manager.h"
22 #include "audio_service_log.h"
23 #include "iservice_registry.h"
24 #include "system_ability_definition.h"
25 #include "audio_utils.h"
26
27 #include "audio_group_manager.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)43 int32_t AudioGroupManager::SetVolume(AudioVolumeType volumeType, int32_t volume, int32_t volumeFlag)
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_MUSIC:
62 case STREAM_ALARM:
63 case STREAM_SYSTEM:
64 case STREAM_ACCESSIBILITY:
65 case STREAM_VOICE_ASSISTANT:
66 break;
67 case STREAM_ULTRASONIC:
68 case STREAM_ALL:{
69 bool ret = PermissionUtil::VerifySelfPermission();
70 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "SetVolume: No system permission");
71 break;
72 }
73 default:
74 AUDIO_ERR_LOG("SetVolume: volumeType[%{public}d] is not supported", volumeType);
75 return ERR_NOT_SUPPORTED;
76 }
77
78 /* Call Audio Policy SetSystemVolumeLevel */
79 return AudioPolicyManager::GetInstance().SetSystemVolumeLevel(volumeType, volume, false, volumeFlag);
80 }
81
GetActiveVolumeType(const int32_t clientUid)82 AudioStreamType AudioGroupManager::GetActiveVolumeType(const int32_t clientUid)
83 {
84 return AudioPolicyManager::GetInstance().GetSystemActiveVolumeType(clientUid);
85 }
86
GetVolume(AudioVolumeType volumeType)87 int32_t AudioGroupManager::GetVolume(AudioVolumeType volumeType)
88 {
89 if (connectType_ == CONNECT_TYPE_DISTRIBUTED) {
90 std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=" + std::to_string(groupId_) + ";AUDIO_VOLUME_TYPE="
91 + std::to_string(volumeType) + ";";
92 std::string value = g_sProxy->GetAudioParameter(netWorkId_, AudioParamKey::VOLUME, condition);
93 int32_t convertValue = 0;
94 CHECK_AND_RETURN_RET_LOG(StringConverter(value, convertValue), 0,
95 "[AudioGroupManger]: convert invalid value: %{public}s", value.c_str());
96 return convertValue;
97 }
98
99 switch (volumeType) {
100 case STREAM_MUSIC:
101 case STREAM_RING:
102 case STREAM_NOTIFICATION:
103 case STREAM_VOICE_CALL:
104 case STREAM_VOICE_COMMUNICATION:
105 case STREAM_VOICE_ASSISTANT:
106 case STREAM_ALARM:
107 case STREAM_SYSTEM:
108 case STREAM_ACCESSIBILITY:
109 break;
110 case STREAM_ULTRASONIC:
111 case STREAM_ALL:{
112 bool ret = PermissionUtil::VerifySelfPermission();
113 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED,
114 "GetVolume: No system permission");
115 break;
116 }
117 default:
118 AUDIO_ERR_LOG("GetVolume volumeType=%{public}d not supported", volumeType);
119 return ERR_NOT_SUPPORTED;
120 }
121
122 return AudioPolicyManager::GetInstance().GetSystemVolumeLevel(volumeType);
123 }
124
GetMaxVolume(AudioVolumeType volumeType)125 int32_t AudioGroupManager::GetMaxVolume(AudioVolumeType volumeType)
126 {
127 if (!IsAlived()) {
128 CHECK_AND_RETURN_RET_LOG(g_sProxy != nullptr, ERR_OPERATION_FAILED, "GetMaxVolume service unavailable");
129 }
130 if (connectType_ == CONNECT_TYPE_DISTRIBUTED) {
131 std::string condition = "EVENT_TYPE=3;VOLUME_GROUP_ID=" + std::to_string(groupId_) + ";AUDIO_VOLUME_TYPE=" +
132 std::to_string(volumeType) + ";";
133 std::string value = g_sProxy->GetAudioParameter(netWorkId_, AudioParamKey::VOLUME, condition);
134 int32_t convertValue = 0;
135 CHECK_AND_RETURN_RET_LOG(StringConverter(value, convertValue), 0,
136 "[AudioGroupManger]: convert invalid value: %{public}s", value.c_str());
137 return convertValue;
138 }
139
140 if (volumeType == STREAM_ALL) {
141 bool ret = PermissionUtil::VerifySelfPermission();
142 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "GetMaxVolume: No system permission");
143 }
144
145 if (volumeType == STREAM_ULTRASONIC) {
146 bool ret = PermissionUtil::VerifySelfPermission();
147 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED,
148 "GetMaxVolume: STREAM_ULTRASONIC No system permission");
149 }
150 return AudioPolicyManager::GetInstance().GetMaxVolumeLevel(volumeType);
151 }
152
GetMinVolume(AudioVolumeType volumeType)153 int32_t AudioGroupManager::GetMinVolume(AudioVolumeType volumeType)
154 {
155 if (!IsAlived()) {
156 CHECK_AND_RETURN_RET_LOG(g_sProxy != nullptr, ERR_OPERATION_FAILED, "GetMinVolume service unavailable");
157 }
158 if (connectType_ == CONNECT_TYPE_DISTRIBUTED) {
159 std::string condition = "EVENT_TYPE=2;VOLUME_GROUP_ID=" + std::to_string(groupId_) + ";AUDIO_VOLUME_TYPE" +
160 std::to_string(volumeType) + ";";
161 std::string value = g_sProxy->GetAudioParameter(netWorkId_, AudioParamKey::VOLUME, condition);
162 int32_t convertValue = 0;
163 CHECK_AND_RETURN_RET_LOG(StringConverter(value, convertValue), 0,
164 "[AudioGroupManger]: convert invalid value: %{public}s", value.c_str());
165 return convertValue;
166 }
167
168 if (volumeType == STREAM_ALL) {
169 bool ret = PermissionUtil::VerifySelfPermission();
170 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED,
171 "GetMinVolume: No system permission");
172 }
173
174 if (volumeType == STREAM_ULTRASONIC) {
175 bool ret = PermissionUtil::VerifySelfPermission();
176 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED,
177 "GetMinVolume: STREAM_ULTRASONIC No system permission");
178 }
179 return AudioPolicyManager::GetInstance().GetMinVolumeLevel(volumeType);
180 }
181
SetMute(AudioVolumeType volumeType,bool mute,const DeviceType & deviceType)182 int32_t AudioGroupManager::SetMute(AudioVolumeType volumeType, bool mute, const DeviceType &deviceType)
183 {
184 if (connectType_ == CONNECT_TYPE_DISTRIBUTED) {
185 std::string conditon = "EVENT_TYPE=4;VOLUME_GROUP_ID=" + std::to_string(groupId_) + ";AUDIO_VOLUME_TYPE="
186 + std::to_string(volumeType) + ";";
187 std::string value = mute ? "1" : "0";
188 g_sProxy->SetAudioParameter(netWorkId_, AudioParamKey::VOLUME, conditon, value);
189 return SUCCESS;
190 }
191
192 if (deviceType != DEVICE_TYPE_NONE) {
193 AUDIO_INFO_LOG("SetMute: deviceType [%{public}d], mute [%{public}d]", deviceType, mute);
194 }
195
196 AUDIO_INFO_LOG("SetStreamMute: volumeType [%{public}d], mute [%{public}d]", volumeType, mute);
197 switch (volumeType) {
198 case STREAM_MUSIC:
199 case STREAM_RING:
200 case STREAM_NOTIFICATION:
201 case STREAM_VOICE_CALL:
202 case STREAM_VOICE_COMMUNICATION:
203 case STREAM_VOICE_ASSISTANT:
204 case STREAM_ALARM:
205 case STREAM_SYSTEM:
206 case STREAM_ACCESSIBILITY:
207 case STREAM_ULTRASONIC:
208 case STREAM_ALL:
209 break;
210 default:
211 AUDIO_ERR_LOG("volumeType [%{public}d] is not supported", volumeType);
212 return ERR_NOT_SUPPORTED;
213 }
214
215 /* Call Audio Policy SetStreamMute */
216 return AudioPolicyManager::GetInstance().SetStreamMute(volumeType, mute, false, deviceType);
217 }
218
IsStreamMute(AudioVolumeType volumeType,bool & isMute)219 int32_t AudioGroupManager::IsStreamMute(AudioVolumeType volumeType, bool &isMute)
220 {
221 AUDIO_DEBUG_LOG("GetMute Client");
222 if (connectType_ == CONNECT_TYPE_DISTRIBUTED) {
223 std::string condition = "EVENT_TYPE=4;VOLUME_GROUP_ID=" + std::to_string(groupId_) + ";AUDIO_VOLUME_TYPE="
224 + std::to_string(volumeType) + ";";
225 std::string ret = g_sProxy->GetAudioParameter(netWorkId_, AudioParamKey::VOLUME, condition);
226 isMute = (ret == "1" ? true : false);
227 return SUCCESS;
228 }
229
230 switch (volumeType) {
231 case STREAM_MUSIC:
232 case STREAM_RING:
233 case STREAM_NOTIFICATION:
234 case STREAM_VOICE_CALL:
235 case STREAM_VOICE_COMMUNICATION:
236 case STREAM_VOICE_ASSISTANT:
237 case STREAM_ALARM:
238 case STREAM_SYSTEM:
239 case STREAM_ACCESSIBILITY:
240 break;
241 case STREAM_ULTRASONIC:
242 case STREAM_ALL:{
243 bool ret = PermissionUtil::VerifySelfPermission();
244 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED,
245 "IsStreamMute: No system permission");
246 break;
247 }
248 default:
249 AUDIO_ERR_LOG("volumeType [%{public}d] is not supported", volumeType);
250 return false;
251 }
252
253 isMute = AudioPolicyManager::GetInstance().GetStreamMute(volumeType);
254 return SUCCESS;
255 }
256
Init()257 int32_t AudioGroupManager::Init()
258 {
259 // init networkId_
260 std::string netWorkId;
261 int32_t ret = AudioPolicyManager::GetInstance().GetNetworkIdByGroupId(groupId_, netWorkId);
262 if (ret == SUCCESS) {
263 netWorkId_ = netWorkId;
264 connectType_ = netWorkId_ == LOCAL_NETWORK_ID ? CONNECT_TYPE_LOCAL : CONNECT_TYPE_DISTRIBUTED;
265 AUDIO_INFO_LOG("AudioGroupManager::init set networkId %{public}s.", netWorkId_.c_str());
266 } else {
267 AUDIO_ERR_LOG("AudioGroupManager::init failed, has no valid group");
268 return ERROR;
269 }
270
271 // init g_sProxy
272 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
273 CHECK_AND_RETURN_RET_LOG(samgr != nullptr, ERROR, "AudioSystemManager::init failed");
274
275 sptr<IRemoteObject> object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID);
276 CHECK_AND_RETURN_RET_LOG(object != nullptr, ERROR, "AudioSystemManager::object is NULL.");
277 g_sProxy = iface_cast<IStandardAudioService>(object);
278 if (g_sProxy == nullptr) {
279 AUDIO_DEBUG_LOG("AudioSystemManager::init g_sProxy is NULL.");
280 return ERROR;
281 } else {
282 AUDIO_DEBUG_LOG("AudioSystemManager::init g_sProxy is assigned.");
283 return SUCCESS;
284 }
285 }
286
IsAlived()287 bool AudioGroupManager::IsAlived()
288 {
289 if (g_sProxy == nullptr) {
290 Init();
291 }
292
293 return (g_sProxy != nullptr) ? true : false;
294 }
295
GetGroupId()296 int32_t AudioGroupManager::GetGroupId()
297 {
298 return groupId_;
299 }
300
SetRingerModeCallback(const int32_t clientId,const std::shared_ptr<AudioRingerModeCallback> & callback)301 int32_t AudioGroupManager::SetRingerModeCallback(const int32_t clientId,
302 const std::shared_ptr<AudioRingerModeCallback> &callback)
303 {
304 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM,
305 "AudioSystemManager: callback is nullptr");
306
307 cbClientId_ = clientId;
308
309 return AudioPolicyManager::GetInstance().SetRingerModeCallback(clientId, callback, API_9);
310 }
311
UnsetRingerModeCallback(const int32_t clientId) const312 int32_t AudioGroupManager::UnsetRingerModeCallback(const int32_t clientId) const
313 {
314 return AudioPolicyManager::GetInstance().UnsetRingerModeCallback(clientId);
315 }
316
UnsetRingerModeCallback(const int32_t clientId,const std::shared_ptr<AudioRingerModeCallback> & callback) const317 int32_t AudioGroupManager::UnsetRingerModeCallback(const int32_t clientId,
318 const std::shared_ptr<AudioRingerModeCallback> &callback) const
319 {
320 return AudioPolicyManager::GetInstance().UnsetRingerModeCallback(clientId, callback);
321 }
322
SetRingerMode(AudioRingerMode ringMode) const323 int32_t AudioGroupManager::SetRingerMode(AudioRingerMode ringMode) const
324 {
325 AUDIO_INFO_LOG("ringer mode: %{public}d", ringMode);
326 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, ERROR,
327 "AudioGroupManager::SetRingerMode is not supported for local device.");
328 /* Call Audio Policy SetRingerMode */
329 return AudioPolicyManager::GetInstance().SetRingerMode(ringMode);
330 }
331
GetRingerMode() const332 AudioRingerMode AudioGroupManager::GetRingerMode() const
333 {
334 /* Call Audio Policy GetRingerMode */
335 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, AudioRingerMode::RINGER_MODE_NORMAL,
336 "AudioGroupManager::SetRingerMode is not supported for local device.");
337 return (AudioPolicyManager::GetInstance().GetRingerMode());
338 }
339
SetMicrophoneMute(bool isMute)340 int32_t AudioGroupManager::SetMicrophoneMute(bool isMute)
341 {
342 /* Call Audio Policy GetRingerMode */
343 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, ERROR,
344 "AudioGroupManager::SetRingerMode is not supported for local device.");
345 return AudioPolicyManager::GetInstance().SetMicrophoneMuteAudioConfig(isMute);
346 }
347
SetMicrophoneMutePersistent(const bool isMute,const PolicyType type)348 int32_t AudioGroupManager::SetMicrophoneMutePersistent(const bool isMute, const PolicyType type)
349 {
350 AUDIO_INFO_LOG("Set persistent mic mute state, isMute is %{public}d", isMute);
351 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, ERROR,
352 "Failed due to not supported for local device.");
353 return AudioPolicyManager::GetInstance().SetMicrophoneMutePersistent(isMute, type);
354 }
355
GetPersistentMicMuteState()356 bool AudioGroupManager::GetPersistentMicMuteState()
357 {
358 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, ERROR,
359 "AudioGroupManager::GetPersistentMicMuteState is not supported for local device.");
360 return AudioPolicyManager::GetInstance().GetPersistentMicMuteState();
361 }
362
IsMicrophoneMuteLegacy()363 bool AudioGroupManager::IsMicrophoneMuteLegacy()
364 {
365 /* Call Audio Policy GetRingerMode */
366 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, false,
367 "AudioGroupManager::SetRingerMode is not supported for local device.");
368 return AudioPolicyManager::GetInstance().IsMicrophoneMuteLegacy();
369 }
370
IsMicrophoneMute()371 bool AudioGroupManager::IsMicrophoneMute()
372 {
373 /* Call Audio Policy GetRingerMode */
374 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, false,
375 "AudioGroupManager::SetRingerMode is not supported for local device.");
376 return AudioPolicyManager::GetInstance().IsMicrophoneMute();
377 }
378
SetMicStateChangeCallback(const std::shared_ptr<AudioManagerMicStateChangeCallback> & callback)379 int32_t AudioGroupManager::SetMicStateChangeCallback(
380 const std::shared_ptr<AudioManagerMicStateChangeCallback> &callback)
381 {
382 AUDIO_INFO_LOG("Entered AudioRoutingManager::%{public}s", __func__);
383 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM,
384 "setMicrophoneMuteCallback::callback is null");
385 int32_t clientId = static_cast<int32_t>(getpid());
386 return AudioPolicyManager::GetInstance().SetMicStateChangeCallback(clientId, callback);
387 }
388
UnsetMicStateChangeCallback(const std::shared_ptr<AudioManagerMicStateChangeCallback> & callback)389 int32_t AudioGroupManager::UnsetMicStateChangeCallback(
390 const std::shared_ptr<AudioManagerMicStateChangeCallback> &callback)
391 {
392 return AudioPolicyManager::GetInstance().UnsetMicStateChangeCallback(callback);
393 }
394
IsVolumeUnadjustable()395 bool AudioGroupManager::IsVolumeUnadjustable()
396 {
397 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, ERROR, "is only supported for LOCAL_NETWORK_ID.");
398 return AudioPolicyManager::GetInstance().IsVolumeUnadjustable();
399 }
400
AdjustVolumeByStep(VolumeAdjustType adjustType)401 int32_t AudioGroupManager::AdjustVolumeByStep(VolumeAdjustType adjustType)
402 {
403 return AudioPolicyManager::GetInstance().AdjustVolumeByStep(adjustType);
404 }
405
AdjustSystemVolumeByStep(AudioVolumeType volumeType,VolumeAdjustType adjustType)406 int32_t AudioGroupManager::AdjustSystemVolumeByStep(AudioVolumeType volumeType, VolumeAdjustType adjustType)
407 {
408 return AudioPolicyManager::GetInstance().AdjustSystemVolumeByStep(volumeType, adjustType);
409 }
410
GetSystemVolumeInDb(AudioVolumeType volumeType,int32_t volumeLevel,DeviceType deviceType)411 float AudioGroupManager::GetSystemVolumeInDb(AudioVolumeType volumeType, int32_t volumeLevel, DeviceType deviceType)
412 {
413 /* Call Audio Policy GetSystemVolumeInDb */
414 CHECK_AND_RETURN_RET_LOG(netWorkId_ == LOCAL_NETWORK_ID, static_cast<float>(ERROR),
415 "is only supported for LOCAL_NETWORK_ID.");
416 return AudioPolicyManager::GetInstance().GetSystemVolumeInDb(volumeType, volumeLevel, deviceType);
417 }
418
GetMaxAmplitude(const int32_t deviceId)419 float AudioGroupManager::GetMaxAmplitude(const int32_t deviceId)
420 {
421 return AudioPolicyManager::GetInstance().GetMaxAmplitude(deviceId);
422 }
423 } // namespace AudioStandard
424 } // namespace OHOS
425