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