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