1 /*
2 * Copyright (c) 2021-2025 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 "AudioSystemManager"
17 #endif
18
19 #include "audio_system_manager.h"
20
21 #include "ipc_skeleton.h"
22 #include "iservice_registry.h"
23 #include "system_ability_definition.h"
24 #include "bundle_mgr_interface.h"
25
26 #include "audio_common_log.h"
27 #include "audio_errors.h"
28 #include "audio_manager_base.h"
29 #include "audio_manager_proxy.h"
30 #include "audio_server_death_recipient.h"
31 #include "audio_policy_manager.h"
32 #include "audio_utils.h"
33 #include "audio_manager_listener_stub.h"
34 #include "audio_policy_interface.h"
35 #include "audio_focus_info_change_callback_impl.h"
36
37 namespace OHOS {
38 namespace AudioStandard {
39 using namespace std;
40 constexpr unsigned int GET_BUNDLE_INFO_TIME_OUT_SECONDS = 10;
41 constexpr unsigned int XCOLLIE_TIME_OUT_SECONDS = 10;
42 constexpr size_t VALID_REMOTE_NETWORK_ID_LENGTH = 64;
43 const map<pair<ContentType, StreamUsage>, AudioStreamType> AudioSystemManager::streamTypeMap_
44 = AudioSystemManager::CreateStreamMap();
45 mutex g_asProxyMutex;
46 sptr<IStandardAudioService> g_asProxy = nullptr;
47
AudioSystemManager()48 AudioSystemManager::AudioSystemManager()
49 {
50 AUDIO_DEBUG_LOG("AudioSystemManager start");
51 }
52
~AudioSystemManager()53 AudioSystemManager::~AudioSystemManager()
54 {
55 AUDIO_DEBUG_LOG("~AudioSystemManager");
56 if (cbClientId_ != -1) {
57 UnsetRingerModeCallback(cbClientId_);
58 }
59
60 if (volumeChangeClientPid_ != -1) {
61 AUDIO_DEBUG_LOG("UnregisterVolumeKeyEventCallback");
62 (void)UnregisterVolumeKeyEventCallback(volumeChangeClientPid_);
63 }
64 }
65
GetInstance()66 AudioSystemManager *AudioSystemManager::GetInstance()
67 {
68 static AudioSystemManager audioManager;
69 return &audioManager;
70 }
71
GetCallingPid() const72 int32_t AudioSystemManager::GetCallingPid() const
73 {
74 return getpid();
75 }
76
CreateStreamMap()77 map<pair<ContentType, StreamUsage>, AudioStreamType> AudioSystemManager::CreateStreamMap()
78 {
79 map<pair<ContentType, StreamUsage>, AudioStreamType> streamMap;
80 // Mapping relationships from content and usage to stream type in design
81 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_UNKNOWN)] = STREAM_MUSIC;
82 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
83 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VIDEO_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
84 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_MODEM_COMMUNICATION)] = STREAM_VOICE_CALL;
85 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_CALL_ASSISTANT)] = STREAM_VOICE_CALL_ASSISTANT;
86 streamMap[make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_SYSTEM)] = STREAM_SYSTEM;
87 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
88 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_MEDIA)] = STREAM_MUSIC;
89 streamMap[make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_MEDIA)] = STREAM_MOVIE;
90 streamMap[make_pair(CONTENT_TYPE_GAME, STREAM_USAGE_MEDIA)] = STREAM_GAME;
91 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_MEDIA)] = STREAM_SPEECH;
92 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_ALARM)] = STREAM_ALARM;
93 streamMap[make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_NOTIFICATION)] = STREAM_NOTIFICATION;
94 streamMap[make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_ENFORCED_TONE)] = STREAM_SYSTEM_ENFORCED;
95 streamMap[make_pair(CONTENT_TYPE_DTMF, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_DTMF;
96 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
97 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_ACCESSIBILITY)] = STREAM_ACCESSIBILITY;
98 streamMap[make_pair(CONTENT_TYPE_ULTRASONIC, STREAM_USAGE_SYSTEM)] = STREAM_ULTRASONIC;
99
100 // Old mapping relationships from content and usage to stream type
101 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
102 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_UNKNOWN)] = STREAM_NOTIFICATION;
103 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_MEDIA)] = STREAM_NOTIFICATION;
104 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
105 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_UNKNOWN)] = STREAM_RING;
106 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_MEDIA)] = STREAM_RING;
107 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
108
109 AudioSystemManager::CreateStreamMap(streamMap);
110 return streamMap;
111 }
112
CreateStreamMap(map<pair<ContentType,StreamUsage>,AudioStreamType> & streamMap)113 void AudioSystemManager::CreateStreamMap(map<pair<ContentType, StreamUsage>, AudioStreamType> &streamMap)
114 {
115 // Only use stream usage to choose stream type
116 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MEDIA)] = STREAM_MUSIC;
117 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MUSIC)] = STREAM_MUSIC;
118 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
119 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VIDEO_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
120 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_MODEM_COMMUNICATION)] = STREAM_VOICE_CALL;
121 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_CALL_ASSISTANT)] = STREAM_VOICE_CALL_ASSISTANT;
122 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
123 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ALARM)] = STREAM_ALARM;
124 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_MESSAGE)] = STREAM_VOICE_MESSAGE;
125 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
126 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_RINGTONE)] = STREAM_RING;
127 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NOTIFICATION)] = STREAM_NOTIFICATION;
128 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ACCESSIBILITY)] = STREAM_ACCESSIBILITY;
129 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_SYSTEM)] = STREAM_SYSTEM;
130 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MOVIE)] = STREAM_MOVIE;
131 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_GAME)] = STREAM_GAME;
132 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_AUDIOBOOK)] = STREAM_SPEECH;
133 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NAVIGATION)] = STREAM_NAVIGATION;
134 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_DTMF)] = STREAM_DTMF;
135 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ENFORCED_TONE)] = STREAM_SYSTEM_ENFORCED;
136 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ULTRASONIC)] = STREAM_ULTRASONIC;
137 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_RINGTONE)] = STREAM_VOICE_RING;
138 }
139
GetStreamType(ContentType contentType,StreamUsage streamUsage)140 AudioStreamType AudioSystemManager::GetStreamType(ContentType contentType, StreamUsage streamUsage)
141 {
142 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
143 auto pos = streamTypeMap_.find(make_pair(contentType, streamUsage));
144 if (pos != streamTypeMap_.end()) {
145 streamType = pos->second;
146 } else {
147 AUDIO_ERR_LOG("The pair of contentType and streamUsage is not in design. Use the default stream type");
148 }
149
150 if (streamType == AudioStreamType::STREAM_MEDIA) {
151 streamType = AudioStreamType::STREAM_MUSIC;
152 }
153
154 return streamType;
155 }
156
GetAudioSystemManagerProxy()157 inline const sptr<IStandardAudioService> GetAudioSystemManagerProxy()
158 {
159 AudioXCollie xcollieGetAudioSystemManagerProxy("GetAudioSystemManagerProxy", XCOLLIE_TIME_OUT_SECONDS);
160 lock_guard<mutex> lock(g_asProxyMutex);
161 if (g_asProxy == nullptr) {
162 AudioXCollie xcollieGetSystemAbilityManager("GetSystemAbilityManager", XCOLLIE_TIME_OUT_SECONDS);
163 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
164 CHECK_AND_RETURN_RET_LOG(samgr != nullptr, nullptr, "get sa manager failed");
165 xcollieGetSystemAbilityManager.CancelXCollieTimer();
166
167 AudioXCollie xcollieGetSystemAbility("GetSystemAbility", XCOLLIE_TIME_OUT_SECONDS);
168 sptr<IRemoteObject> object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID);
169 CHECK_AND_RETURN_RET_LOG(object != nullptr, nullptr, "get audio service remote object failed");
170 g_asProxy = iface_cast<IStandardAudioService>(object);
171 CHECK_AND_RETURN_RET_LOG(g_asProxy != nullptr, nullptr, "get audio service proxy failed");
172 xcollieGetSystemAbility.CancelXCollieTimer();
173
174 // register death recipent to restore proxy
175 sptr<AudioServerDeathRecipient> asDeathRecipient =
176 new(std::nothrow) AudioServerDeathRecipient(getpid(), getuid());
177 if (asDeathRecipient != nullptr) {
178 asDeathRecipient->SetNotifyCb([] (pid_t pid, pid_t uid) {
179 AudioSystemManager::AudioServerDied(pid, uid);
180 });
181 bool result = object->AddDeathRecipient(asDeathRecipient);
182 if (!result) {
183 AUDIO_ERR_LOG("failed to add deathRecipient");
184 }
185 }
186 }
187 sptr<IStandardAudioService> gasp = g_asProxy;
188 return gasp;
189 }
190
AudioServerDied(pid_t pid,pid_t uid)191 void AudioSystemManager::AudioServerDied(pid_t pid, pid_t uid)
192 {
193 AUDIO_INFO_LOG("audio server died, will restore proxy in next call");
194 lock_guard<mutex> lock(g_asProxyMutex);
195 g_asProxy = nullptr;
196 }
197
SetRingerMode(AudioRingerMode ringMode)198 int32_t AudioSystemManager::SetRingerMode(AudioRingerMode ringMode)
199 {
200 // Deprecated. Please use the SetRingerMode interface of AudioGroupManager.
201 AUDIO_WARNING_LOG("Use the deprecated SetRingerMode func. ringer mode [%{public}d]", ringMode);
202 std::lock_guard<std::mutex> lockSet(ringerModeCallbackMutex_);
203 ringModeBackup_ = ringMode;
204 if (ringerModeCallback_ != nullptr) {
205 ringerModeCallback_->OnRingerModeUpdated(ringModeBackup_);
206 }
207
208 return SUCCESS;
209 }
210
GetSelfBundleName(int32_t uid)211 std::string AudioSystemManager::GetSelfBundleName(int32_t uid)
212 {
213 AudioXCollie audioXCollie("AudioSystemManager::GetSelfBundleName_FromUid", GET_BUNDLE_INFO_TIME_OUT_SECONDS);
214 std::string bundleName = "";
215
216 WatchTimeout guard("SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager():GetSelfBundleName");
217 sptr<ISystemAbilityManager> systemAbilityManager =
218 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
219 guard.CheckCurrTimeout();
220 sptr<OHOS::IRemoteObject> remoteObject =
221 systemAbilityManager->CheckSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
222 CHECK_AND_RETURN_RET_LOG(remoteObject != nullptr, bundleName, "remoteObject is null");
223
224 sptr<AppExecFwk::IBundleMgr> iBundleMgr = iface_cast<AppExecFwk::IBundleMgr>(remoteObject);
225 CHECK_AND_RETURN_RET_LOG(iBundleMgr != nullptr, bundleName, "bundlemgr interface is null");
226
227 WatchTimeout reguard("bundleMgrProxy->GetNameForUid:GetSelfBundleName");
228 iBundleMgr->GetNameForUid(uid, bundleName);
229 reguard.CheckCurrTimeout();
230 return bundleName;
231 }
232
GetRingerMode()233 AudioRingerMode AudioSystemManager::GetRingerMode()
234 {
235 return ringModeBackup_;
236 }
237
SetAudioScene(const AudioScene & scene)238 int32_t AudioSystemManager::SetAudioScene(const AudioScene &scene)
239 {
240 AUDIO_DEBUG_LOG("audioScene_=%{public}d done", scene);
241 return AudioPolicyManager::GetInstance().SetAudioScene(scene);
242 }
243
GetAudioScene() const244 AudioScene AudioSystemManager::GetAudioScene() const
245 {
246 auto audioScene = AudioPolicyManager::GetInstance().GetAudioScene();
247 AUDIO_DEBUG_LOG("origin audioScene: %{public}d", audioScene);
248 switch (audioScene) {
249 case AUDIO_SCENE_CALL_START:
250 case AUDIO_SCENE_CALL_END:
251 return AUDIO_SCENE_DEFAULT;
252
253 case AUDIO_SCENE_VOICE_RINGING:
254 return AUDIO_SCENE_RINGING;
255
256 default:
257 return audioScene;
258 }
259 }
260
SetDeviceActive(DeviceType deviceType,bool flag,const int32_t clientUid) const261 int32_t AudioSystemManager::SetDeviceActive(DeviceType deviceType, bool flag, const int32_t clientUid) const
262 {
263 int32_t uid = clientUid == -1 ? getuid() : clientUid;
264 if (!IsActiveDeviceType(deviceType)) {
265 AUDIO_ERR_LOG("device=%{public}d not supported", deviceType);
266 return ERR_NOT_SUPPORTED;
267 }
268
269 /* Call Audio Policy SetDeviceActive */
270 return (AudioPolicyManager::GetInstance().SetDeviceActive(static_cast<InternalDeviceType>(deviceType), flag, uid));
271 }
272
IsDeviceActive(DeviceType deviceType) const273 bool AudioSystemManager::IsDeviceActive(DeviceType deviceType) const
274 {
275 if (!IsActiveDeviceType(deviceType)) {
276 AUDIO_ERR_LOG("device=%{public}d not supported", deviceType);
277 return ERR_NOT_SUPPORTED;
278 }
279
280 /* Call Audio Policy IsDeviceActive */
281 return (AudioPolicyManager::GetInstance().IsDeviceActive(static_cast<InternalDeviceType>(deviceType)));
282 }
283
GetActiveOutputDevice()284 DeviceType AudioSystemManager::GetActiveOutputDevice()
285 {
286 return AudioPolicyManager::GetInstance().GetActiveOutputDevice();
287 }
288
GetActiveInputDevice()289 DeviceType AudioSystemManager::GetActiveInputDevice()
290 {
291 return AudioPolicyManager::GetInstance().GetActiveInputDevice();
292 }
293
IsStreamActive(AudioVolumeType volumeType) const294 bool AudioSystemManager::IsStreamActive(AudioVolumeType volumeType) const
295 {
296 switch (volumeType) {
297 case STREAM_MUSIC:
298 case STREAM_RING:
299 case STREAM_NOTIFICATION:
300 case STREAM_VOICE_CALL:
301 case STREAM_VOICE_COMMUNICATION:
302 case STREAM_VOICE_ASSISTANT:
303 case STREAM_ALARM:
304 case STREAM_SYSTEM:
305 case STREAM_ACCESSIBILITY:
306 case STREAM_VOICE_RING:
307 case STREAM_CAMCORDER:
308 break;
309 case STREAM_ULTRASONIC:{
310 bool ret = PermissionUtil::VerifySelfPermission();
311 CHECK_AND_RETURN_RET_LOG(ret, false, "volumeType=%{public}d. No system permission", volumeType);
312 break;
313 }
314 case STREAM_ALL:
315 default:
316 AUDIO_ERR_LOG("volumeType=%{public}d not supported", volumeType);
317 return false;
318 }
319
320 return AudioPolicyManager::GetInstance().IsStreamActive(volumeType);
321 }
322
SetAsrAecMode(const AsrAecMode asrAecMode)323 int32_t AudioSystemManager::SetAsrAecMode(const AsrAecMode asrAecMode)
324 {
325 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
326 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, 0, "Audio service unavailable.");
327 return gasp->SetAsrAecMode(asrAecMode);
328 }
329
GetAsrAecMode(AsrAecMode & asrAecMode)330 int32_t AudioSystemManager::GetAsrAecMode(AsrAecMode &asrAecMode)
331 {
332 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
333 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, 0, "Audio service unavailable.");
334 int32_t ret = gasp->GetAsrAecMode(asrAecMode);
335 CHECK_AND_RETURN_RET_LOG(ret == 0, AUDIO_ERR, "Get AsrAec Mode audio parameters failed");
336 return 0;
337 }
338
SetAsrNoiseSuppressionMode(const AsrNoiseSuppressionMode asrNoiseSuppressionMode)339 int32_t AudioSystemManager::SetAsrNoiseSuppressionMode(const AsrNoiseSuppressionMode asrNoiseSuppressionMode)
340 {
341 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
342 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, 0, "Audio service unavailable.");
343 return gasp->SetAsrNoiseSuppressionMode(asrNoiseSuppressionMode);
344 }
345
GetAsrNoiseSuppressionMode(AsrNoiseSuppressionMode & asrNoiseSuppressionMode)346 int32_t AudioSystemManager::GetAsrNoiseSuppressionMode(AsrNoiseSuppressionMode &asrNoiseSuppressionMode)
347 {
348 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
349 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, 0, "Audio service unavailable.");
350 int32_t ret = gasp->GetAsrNoiseSuppressionMode(asrNoiseSuppressionMode);
351 CHECK_AND_RETURN_RET_LOG(ret == 0, AUDIO_ERR, "Get AsrAec Mode audio parameters failed");
352 return 0;
353 }
354
SetAsrWhisperDetectionMode(const AsrWhisperDetectionMode asrWhisperDetectionMode)355 int32_t AudioSystemManager::SetAsrWhisperDetectionMode(const AsrWhisperDetectionMode asrWhisperDetectionMode)
356 {
357 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
358 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, 0, "Audio service unavailable.");
359 return gasp->SetAsrWhisperDetectionMode(asrWhisperDetectionMode);
360 }
361
GetAsrWhisperDetectionMode(AsrWhisperDetectionMode & asrWhisperDetectionMode)362 int32_t AudioSystemManager::GetAsrWhisperDetectionMode(AsrWhisperDetectionMode &asrWhisperDetectionMode)
363 {
364 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
365 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, 0, "Audio service unavailable.");
366 int32_t ret = gasp->GetAsrWhisperDetectionMode(asrWhisperDetectionMode);
367 CHECK_AND_RETURN_RET_LOG(ret == 0, AUDIO_ERR, "Get AsrWhisperDetection Mode audio parameters failed");
368 return 0;
369 }
370
SetAsrVoiceControlMode(const AsrVoiceControlMode asrVoiceControlMode,bool on)371 int32_t AudioSystemManager::SetAsrVoiceControlMode(const AsrVoiceControlMode asrVoiceControlMode, bool on)
372 {
373 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
374 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, 0, "Audio service unavailable.");
375 return gasp->SetAsrVoiceControlMode(asrVoiceControlMode, on);
376 }
377
SetAsrVoiceMuteMode(const AsrVoiceMuteMode asrVoiceMuteMode,bool on)378 int32_t AudioSystemManager::SetAsrVoiceMuteMode(const AsrVoiceMuteMode asrVoiceMuteMode, bool on)
379 {
380 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
381 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, 0, "Audio service unavailable.");
382 return gasp->SetAsrVoiceMuteMode(asrVoiceMuteMode, on);
383 }
384
IsWhispering()385 int32_t AudioSystemManager::IsWhispering()
386 {
387 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
388 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, 0, "Audio service unavailable.");
389 return gasp->IsWhispering();
390 }
391
GetAudioParameter(const std::string key)392 const std::string AudioSystemManager::GetAudioParameter(const std::string key)
393 {
394 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
395 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, "", "Audio service unavailable.");
396 return gasp->GetAudioParameter(key);
397 }
398
SetAudioParameter(const std::string & key,const std::string & value)399 void AudioSystemManager::SetAudioParameter(const std::string &key, const std::string &value)
400 {
401 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
402 CHECK_AND_RETURN_LOG(gasp != nullptr, "Audio service unavailable.");
403 gasp->SetAudioParameter(key, value);
404 }
405
GetExtraParameters(const std::string & mainKey,const std::vector<std::string> & subKeys,std::vector<std::pair<std::string,std::string>> & result)406 int32_t AudioSystemManager::GetExtraParameters(const std::string &mainKey,
407 const std::vector<std::string> &subKeys, std::vector<std::pair<std::string, std::string>> &result)
408 {
409 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
410 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, 0, "Audio service unavailable.");
411 return gasp->GetExtraParameters(mainKey, subKeys, result);
412 }
413
SetExtraParameters(const std::string & key,const std::vector<std::pair<std::string,std::string>> & kvpairs)414 int32_t AudioSystemManager::SetExtraParameters(const std::string &key,
415 const std::vector<std::pair<std::string, std::string>> &kvpairs)
416 {
417 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
418 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, 0, "Audio service unavailable.");
419 return gasp->SetExtraParameters(key, kvpairs);
420 }
421
GetTransactionId(DeviceType deviceType,DeviceRole deviceRole)422 uint64_t AudioSystemManager::GetTransactionId(DeviceType deviceType, DeviceRole deviceRole)
423 {
424 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
425 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, 0, "Audio service unavailable.");
426 return gasp->GetTransactionId(deviceType, deviceRole);
427 }
428
SetSelfAppVolume(int32_t volume,int32_t flag)429 int32_t AudioSystemManager::SetSelfAppVolume(int32_t volume, int32_t flag)
430 {
431 AUDIO_INFO_LOG("enter AudioSystemManager::SetSelfAppVolume");
432 return AudioPolicyManager::GetInstance().SetSelfAppVolumeLevel(volume);
433 }
434
SetAppVolume(int32_t appUid,int32_t volume,int32_t flag)435 int32_t AudioSystemManager::SetAppVolume(int32_t appUid, int32_t volume, int32_t flag)
436 {
437 AUDIO_INFO_LOG("enter AudioSystemManager::SetAppVolume");
438 bool ret = PermissionUtil::VerifyIsSystemApp();
439 CHECK_AND_RETURN_RET_LOG(ret, ERR_SYSTEM_PERMISSION_DENIED, "SetAppVolume: No system permission");
440 ret = PermissionUtil::VerifySelfPermission();
441 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "SetAppVolume: No system permission");
442 return AudioPolicyManager::GetInstance().SetAppVolumeLevel(appUid, volume);
443 }
444
GetAppVolume(int32_t appUid) const445 int32_t AudioSystemManager::GetAppVolume(int32_t appUid) const
446 {
447 AUDIO_INFO_LOG("enter AudioSystemManager::GetAppVolume");
448 bool ret = PermissionUtil::VerifyIsSystemApp();
449 CHECK_AND_RETURN_RET_LOG(ret, ERR_SYSTEM_PERMISSION_DENIED, "GetAppVolume: No system permission");
450 ret = PermissionUtil::VerifySelfPermission();
451 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "GetAppVolume: No system permission");
452 return AudioPolicyManager::GetInstance().GetAppVolumeLevel(appUid);
453 }
454
GetSelfAppVolume() const455 int32_t AudioSystemManager::GetSelfAppVolume() const
456 {
457 AUDIO_INFO_LOG("enter AudioSystemManager::GetSelfAppVolume");
458 return AudioPolicyManager::GetInstance().GetSelfAppVolumeLevel();
459 }
460
SetAppVolumeMuted(int32_t appUid,bool muted,int32_t volumeFlag)461 int32_t AudioSystemManager::SetAppVolumeMuted(int32_t appUid, bool muted, int32_t volumeFlag)
462 {
463 AUDIO_INFO_LOG("SetAppVolumeMuted: appUid[%{public}d], muted[%{public}d], flag[%{public}d]",
464 appUid, muted, volumeFlag);
465 bool ret = PermissionUtil::VerifyIsSystemApp();
466 CHECK_AND_RETURN_RET_LOG(ret, ERR_SYSTEM_PERMISSION_DENIED, "SetAppVolumeMuted: No system permission");
467 ret = PermissionUtil::VerifySelfPermission();
468 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "SetAppVolumeMuted: No system permission");
469 return AudioPolicyManager::GetInstance().SetAppVolumeMuted(appUid, muted, volumeFlag);
470 }
471
UnsetSelfAppVolumeCallback(const std::shared_ptr<AudioManagerAppVolumeChangeCallback> & callback)472 int32_t AudioSystemManager::UnsetSelfAppVolumeCallback(
473 const std::shared_ptr<AudioManagerAppVolumeChangeCallback> &callback)
474 {
475 return AudioPolicyManager::GetInstance().UnsetSelfAppVolumeCallback(callback);
476 }
477
SetSelfAppVolumeCallback(const std::shared_ptr<AudioManagerAppVolumeChangeCallback> & callback)478 int32_t AudioSystemManager::SetSelfAppVolumeCallback(
479 const std::shared_ptr<AudioManagerAppVolumeChangeCallback> &callback)
480 {
481 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM,
482 "SetSelfAppVolumeCallback: callback is nullptr");
483 return AudioPolicyManager::GetInstance().SetSelfAppVolumeChangeCallback(callback);
484 }
485
SetAppVolumeCallbackForUid(const int32_t appUid,const std::shared_ptr<AudioManagerAppVolumeChangeCallback> & callback)486 int32_t AudioSystemManager::SetAppVolumeCallbackForUid(const int32_t appUid,
487 const std::shared_ptr<AudioManagerAppVolumeChangeCallback> &callback)
488 {
489 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM,
490 "SetAppVolumeCallbackForUid: callback is nullptr");
491 return AudioPolicyManager::GetInstance().SetAppVolumeChangeCallbackForUid(appUid, callback);
492 }
493
UnsetAppVolumeCallbackForUid(const std::shared_ptr<AudioManagerAppVolumeChangeCallback> & callback)494 int32_t AudioSystemManager::UnsetAppVolumeCallbackForUid(
495 const std::shared_ptr<AudioManagerAppVolumeChangeCallback> &callback)
496 {
497 return AudioPolicyManager::GetInstance().UnsetAppVolumeCallbackForUid(callback);
498 }
499
IsAppVolumeMute(int32_t appUid,bool owned)500 bool AudioSystemManager::IsAppVolumeMute(int32_t appUid, bool owned)
501 {
502 AUDIO_INFO_LOG("IsAppVolumeMute: appUid[%{public}d], muted[%{public}d]", appUid, owned);
503 bool ret = PermissionUtil::VerifyIsSystemApp();
504 CHECK_AND_RETURN_RET_LOG(ret, ERR_SYSTEM_PERMISSION_DENIED, "IsAppVolumeMute: No system permission");
505 ret = PermissionUtil::VerifySelfPermission();
506 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "IsAppVolumeMute: No system permission");
507 return AudioPolicyManager::GetInstance().IsAppVolumeMute(appUid, owned);
508 }
509
SetVolume(AudioVolumeType volumeType,int32_t volumeLevel) const510 int32_t AudioSystemManager::SetVolume(AudioVolumeType volumeType, int32_t volumeLevel) const
511 {
512 AUDIO_INFO_LOG("SetSystemVolume: volumeType[%{public}d], volumeLevel[%{public}d]", volumeType, volumeLevel);
513
514 /* Validate volumeType and return INVALID_PARAMS error */
515 switch (volumeType) {
516 case STREAM_VOICE_CALL:
517 case STREAM_VOICE_COMMUNICATION:
518 case STREAM_RING:
519 case STREAM_MUSIC:
520 case STREAM_ALARM:
521 case STREAM_SYSTEM:
522 case STREAM_ACCESSIBILITY:
523 case STREAM_VOICE_ASSISTANT:
524 case STREAM_VOICE_RING:
525 break;
526 case STREAM_ULTRASONIC:
527 case STREAM_ALL:{
528 bool ret = PermissionUtil::VerifySelfPermission();
529 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "No system permission");
530 break;
531 }
532 default:
533 AUDIO_ERR_LOG("volumeType[%{public}d] is not supported", volumeType);
534 return ERR_NOT_SUPPORTED;
535 }
536
537 /* Call Audio Policy SetSystemVolumeLevel */
538 return AudioPolicyManager::GetInstance().SetSystemVolumeLevel(volumeType, volumeLevel, true);
539 }
540
SetVolumeWithDevice(AudioVolumeType volumeType,int32_t volumeLevel,DeviceType deviceType) const541 int32_t AudioSystemManager::SetVolumeWithDevice(AudioVolumeType volumeType, int32_t volumeLevel,
542 DeviceType deviceType) const
543 {
544 AUDIO_INFO_LOG("SetSystemVolumeWithDevice: volumeType[%{public}d], volumeLevel[%{public}d], deviceType[%{public}d]",
545 volumeType, volumeLevel, deviceType);
546
547 /* Validate volumeType and return INVALID_PARAMS error */
548 switch (volumeType) {
549 case STREAM_VOICE_CALL:
550 case STREAM_VOICE_COMMUNICATION:
551 case STREAM_RING:
552 case STREAM_MUSIC:
553 case STREAM_ALARM:
554 case STREAM_SYSTEM:
555 case STREAM_ACCESSIBILITY:
556 case STREAM_VOICE_ASSISTANT:
557 case STREAM_VOICE_RING:
558 break;
559 case STREAM_ULTRASONIC:
560 case STREAM_ALL:{
561 bool ret = PermissionUtil::VerifySelfPermission();
562 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "No system permission");
563 break;
564 }
565 default:
566 AUDIO_ERR_LOG("volumeType[%{public}d] is not supported", volumeType);
567 return ERR_NOT_SUPPORTED;
568 }
569
570 /* Call Audio Policy SetSystemVolumeLevel */
571 return AudioPolicyManager::GetInstance().SetSystemVolumeLevelWithDevice(volumeType, volumeLevel, deviceType);
572 }
573
GetVolume(AudioVolumeType volumeType) const574 int32_t AudioSystemManager::GetVolume(AudioVolumeType volumeType) const
575 {
576 switch (volumeType) {
577 case STREAM_MUSIC:
578 case STREAM_RING:
579 case STREAM_NOTIFICATION:
580 case STREAM_VOICE_CALL:
581 case STREAM_VOICE_COMMUNICATION:
582 case STREAM_VOICE_ASSISTANT:
583 case STREAM_ALARM:
584 case STREAM_SYSTEM:
585 case STREAM_ACCESSIBILITY:
586 case STREAM_VOICE_RING:
587 break;
588 case STREAM_ULTRASONIC:
589 case STREAM_ALL:{
590 bool ret = PermissionUtil::VerifySelfPermission();
591 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "No system permission");
592 break;
593 }
594 default:
595 AUDIO_ERR_LOG("volumeType[%{public}d] is not supported", volumeType);
596 return ERR_NOT_SUPPORTED;
597 }
598
599 return AudioPolicyManager::GetInstance().GetSystemVolumeLevel(volumeType);
600 }
601
SetLowPowerVolume(int32_t streamId,float volume) const602 int32_t AudioSystemManager::SetLowPowerVolume(int32_t streamId, float volume) const
603 {
604 AUDIO_INFO_LOG("streamId:%{public}d, vol:%{public}f.", streamId, volume);
605 CHECK_AND_RETURN_RET_LOG((volume >= 0) && (volume <= 1.0), ERR_INVALID_PARAM,
606 "Invalid Volume Input!");
607
608 return AudioPolicyManager::GetInstance().SetLowPowerVolume(streamId, volume);
609 }
610
GetLowPowerVolume(int32_t streamId) const611 float AudioSystemManager::GetLowPowerVolume(int32_t streamId) const
612 {
613 return AudioPolicyManager::GetInstance().GetLowPowerVolume(streamId);
614 }
615
GetSingleStreamVolume(int32_t streamId) const616 float AudioSystemManager::GetSingleStreamVolume(int32_t streamId) const
617 {
618 return AudioPolicyManager::GetInstance().GetSingleStreamVolume(streamId);
619 }
620
GetMaxVolume(AudioVolumeType volumeType)621 int32_t AudioSystemManager::GetMaxVolume(AudioVolumeType volumeType)
622 {
623 if (volumeType == STREAM_ALL) {
624 bool ret = PermissionUtil::VerifySelfPermission();
625 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "No system permission");
626 }
627
628 if (volumeType == STREAM_ULTRASONIC) {
629 bool ret = PermissionUtil::VerifySelfPermission();
630 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "No system permission");
631 }
632
633 return AudioPolicyManager::GetInstance().GetMaxVolumeLevel(volumeType);
634 }
635
GetMinVolume(AudioVolumeType volumeType)636 int32_t AudioSystemManager::GetMinVolume(AudioVolumeType volumeType)
637 {
638 if (volumeType == STREAM_ALL) {
639 bool ret = PermissionUtil::VerifySelfPermission();
640 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "No system permission");
641 }
642
643 if (volumeType == STREAM_ULTRASONIC) {
644 bool ret = PermissionUtil::VerifySelfPermission();
645 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "STREAM_ULTRASONIC No system permission");
646 }
647
648 return AudioPolicyManager::GetInstance().GetMinVolumeLevel(volumeType);
649 }
650
SetMute(AudioVolumeType volumeType,bool mute,const DeviceType & deviceType) const651 int32_t AudioSystemManager::SetMute(AudioVolumeType volumeType, bool mute, const DeviceType &deviceType) const
652 {
653 AUDIO_INFO_LOG("SetStreamMute for volumeType [%{public}d], mute [%{public}d]", volumeType, mute);
654 switch (volumeType) {
655 case STREAM_MUSIC:
656 case STREAM_RING:
657 case STREAM_NOTIFICATION:
658 case STREAM_VOICE_CALL:
659 case STREAM_VOICE_COMMUNICATION:
660 case STREAM_VOICE_ASSISTANT:
661 case STREAM_ALARM:
662 case STREAM_SYSTEM:
663 case STREAM_ACCESSIBILITY:
664 case STREAM_VOICE_RING:
665 break;
666 case STREAM_ULTRASONIC:
667 case STREAM_ALL:{
668 bool ret = PermissionUtil::VerifySelfPermission();
669 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "No system permission");
670 break;
671 }
672 default:
673 AUDIO_ERR_LOG("volumeType=%{public}d not supported", volumeType);
674 return ERR_NOT_SUPPORTED;
675 }
676
677 /* Call Audio Policy SetStreamMute */
678 return AudioPolicyManager::GetInstance().SetStreamMute(volumeType, mute, true, deviceType);
679 }
680
IsStreamMute(AudioVolumeType volumeType) const681 bool AudioSystemManager::IsStreamMute(AudioVolumeType volumeType) const
682 {
683 AUDIO_DEBUG_LOG("AudioSystemManager::GetMute Client");
684
685 switch (volumeType) {
686 case STREAM_MUSIC:
687 case STREAM_RING:
688 case STREAM_NOTIFICATION:
689 case STREAM_VOICE_CALL:
690 case STREAM_VOICE_COMMUNICATION:
691 case STREAM_VOICE_ASSISTANT:
692 case STREAM_ALARM:
693 case STREAM_SYSTEM:
694 case STREAM_ACCESSIBILITY:
695 case STREAM_VOICE_RING:
696 break;
697 case STREAM_ULTRASONIC:
698 case STREAM_ALL:{
699 bool ret = PermissionUtil::VerifySelfPermission();
700 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "No system permission");
701 break;
702 }
703 default:
704 AUDIO_ERR_LOG("volumeType=%{public}d not supported", volumeType);
705 return false;
706 }
707
708 return AudioPolicyManager::GetInstance().GetStreamMute(volumeType);
709 }
710
SetDeviceChangeCallback(const DeviceFlag flag,const std::shared_ptr<AudioManagerDeviceChangeCallback> & callback)711 int32_t AudioSystemManager::SetDeviceChangeCallback(const DeviceFlag flag,
712 const std::shared_ptr<AudioManagerDeviceChangeCallback>& callback)
713 {
714 AUDIO_INFO_LOG("Entered %{public}s", __func__);
715 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is nullptr");
716
717 int32_t clientId = GetCallingPid();
718 return AudioPolicyManager::GetInstance().SetDeviceChangeCallback(clientId, flag, callback);
719 }
720
UnsetDeviceChangeCallback(DeviceFlag flag,std::shared_ptr<AudioManagerDeviceChangeCallback> cb)721 int32_t AudioSystemManager::UnsetDeviceChangeCallback(DeviceFlag flag,
722 std::shared_ptr<AudioManagerDeviceChangeCallback> cb)
723 {
724 AUDIO_INFO_LOG("Entered %{public}s", __func__);
725 int32_t clientId = GetCallingPid();
726 return AudioPolicyManager::GetInstance().UnsetDeviceChangeCallback(clientId, flag, cb);
727 }
728
SetMicrophoneBlockedCallback(const std::shared_ptr<AudioManagerMicrophoneBlockedCallback> & callback)729 int32_t AudioSystemManager::SetMicrophoneBlockedCallback(
730 const std::shared_ptr<AudioManagerMicrophoneBlockedCallback>& callback)
731 {
732 AUDIO_INFO_LOG("Entered %{public}s", __func__);
733 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is nullptr");
734
735 int32_t clientId = GetCallingPid();
736 return AudioPolicyManager::GetInstance().SetMicrophoneBlockedCallback(clientId, callback);
737 }
738
UnsetMicrophoneBlockedCallback(const std::shared_ptr<AudioManagerMicrophoneBlockedCallback> callback)739 int32_t AudioSystemManager::UnsetMicrophoneBlockedCallback(
740 const std::shared_ptr<AudioManagerMicrophoneBlockedCallback> callback)
741 {
742 AUDIO_INFO_LOG("Entered %{public}s", __func__);
743 int32_t clientId = GetCallingPid();
744 return AudioPolicyManager::GetInstance().UnsetMicrophoneBlockedCallback(clientId, callback);
745 }
746
SetAudioSceneChangeCallback(const std::shared_ptr<AudioManagerAudioSceneChangedCallback> & callback)747 int32_t AudioSystemManager::SetAudioSceneChangeCallback(
748 const std::shared_ptr<AudioManagerAudioSceneChangedCallback>& callback)
749 {
750 AUDIO_INFO_LOG("Entered %{public}s", __func__);
751 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is nullptr");
752
753 int32_t clientId = GetCallingPid();
754 return AudioPolicyManager::GetInstance().SetAudioSceneChangeCallback(clientId, callback);
755 }
756
UnsetAudioSceneChangeCallback(const std::shared_ptr<AudioManagerAudioSceneChangedCallback> callback)757 int32_t AudioSystemManager::UnsetAudioSceneChangeCallback(
758 const std::shared_ptr<AudioManagerAudioSceneChangedCallback> callback)
759 {
760 AUDIO_INFO_LOG("Entered %{public}s", __func__);
761 return AudioPolicyManager::GetInstance().UnsetAudioSceneChangeCallback(callback);
762 }
763
SetQueryClientTypeCallback(const std::shared_ptr<AudioQueryClientTypeCallback> & callback)764 int32_t AudioSystemManager::SetQueryClientTypeCallback(const std::shared_ptr<AudioQueryClientTypeCallback> &callback)
765 {
766 AUDIO_INFO_LOG("In");
767 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is nullptr");
768 return AudioPolicyManager::GetInstance().SetQueryClientTypeCallback(callback);
769 }
770
SetAudioClientInfoMgrCallback(const std::shared_ptr<AudioClientInfoMgrCallback> & callback)771 int32_t AudioSystemManager::SetAudioClientInfoMgrCallback(const std::shared_ptr<AudioClientInfoMgrCallback> &callback)
772 {
773 AUDIO_INFO_LOG("In");
774 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is nullptr");
775 return AudioPolicyManager::GetInstance().SetAudioClientInfoMgrCallback(callback);
776 }
777
SetRingerModeCallback(const int32_t clientId,const std::shared_ptr<AudioRingerModeCallback> & callback)778 int32_t AudioSystemManager::SetRingerModeCallback(const int32_t clientId,
779 const std::shared_ptr<AudioRingerModeCallback> &callback)
780 {
781 std::lock_guard<std::mutex> lockSet(ringerModeCallbackMutex_);
782 bool ret = PermissionUtil::VerifySelfPermission();
783 CHECK_AND_RETURN_RET_LOG(ret, ERR_PERMISSION_DENIED, "No system permission");
784 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is nullptr");
785
786 cbClientId_ = clientId;
787 ringerModeCallback_ = callback;
788
789 return SUCCESS;
790 }
791
UnsetRingerModeCallback(const int32_t clientId) const792 int32_t AudioSystemManager::UnsetRingerModeCallback(const int32_t clientId) const
793 {
794 CHECK_AND_RETURN_RET(clientId == cbClientId_, ERR_INVALID_OPERATION);
795
796 return SUCCESS;
797 }
798
SetMicrophoneMute(bool isMute)799 int32_t AudioSystemManager::SetMicrophoneMute(bool isMute)
800 {
801 return AudioPolicyManager::GetInstance().SetMicrophoneMute(isMute);
802 }
803
SetVoiceRingtoneMute(bool isMute)804 int32_t AudioSystemManager::SetVoiceRingtoneMute(bool isMute)
805 {
806 AUDIO_INFO_LOG("Set Voice Ringtone is %{public}d", isMute);
807 return AudioPolicyManager::GetInstance().SetVoiceRingtoneMute(isMute);
808 }
809
IsMicrophoneMute()810 bool AudioSystemManager::IsMicrophoneMute()
811 {
812 std::shared_ptr<AudioGroupManager> groupManager = GetGroupManager(DEFAULT_VOLUME_GROUP_ID);
813 CHECK_AND_RETURN_RET_LOG(groupManager != nullptr, false, "failed, groupManager is null");
814 return groupManager->IsMicrophoneMuteLegacy();
815 }
816
SelectOutputDevice(std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const817 int32_t AudioSystemManager::SelectOutputDevice(
818 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
819 {
820 CHECK_AND_RETURN_RET_LOG(audioDeviceDescriptors.size() == 1 && audioDeviceDescriptors[0] != nullptr,
821 ERR_INVALID_PARAM, "invalid parameter");
822 CHECK_AND_RETURN_RET_LOG(audioDeviceDescriptors[0]->deviceRole_ == DeviceRole::OUTPUT_DEVICE,
823 ERR_INVALID_OPERATION, "not an output device.");
824 if (audioDeviceDescriptors[0]->networkId_ != LOCAL_NETWORK_ID &&
825 audioDeviceDescriptors[0]->networkId_.size() != VALID_REMOTE_NETWORK_ID_LENGTH) {
826 AUDIO_ERR_LOG("SelectOutputDevice: invalid networkId.");
827 return ERR_INVALID_PARAM;
828 }
829 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
830 audioRendererFilter->uid = -1;
831 int32_t ret = AudioPolicyManager::GetInstance().SelectOutputDevice(audioRendererFilter, audioDeviceDescriptors);
832 return ret;
833 }
834
SelectInputDevice(std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const835 int32_t AudioSystemManager::SelectInputDevice(
836 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
837 {
838 CHECK_AND_RETURN_RET_LOG(audioDeviceDescriptors.size() == 1 && audioDeviceDescriptors[0] != nullptr,
839 ERR_INVALID_PARAM, "invalid parameter");
840 CHECK_AND_RETURN_RET_LOG(audioDeviceDescriptors[0]->deviceRole_ == DeviceRole::INPUT_DEVICE,
841 ERR_INVALID_OPERATION, "not an output device.");
842 sptr<AudioCapturerFilter> audioCapturerFilter = new(std::nothrow) AudioCapturerFilter();
843 audioCapturerFilter->uid = -1;
844 int32_t ret = AudioPolicyManager::GetInstance().SelectInputDevice(audioCapturerFilter, audioDeviceDescriptors);
845 return ret;
846 }
847
GetSelectedDeviceInfo(int32_t uid,int32_t pid,AudioStreamType streamType) const848 std::string AudioSystemManager::GetSelectedDeviceInfo(int32_t uid, int32_t pid, AudioStreamType streamType) const
849 {
850 return AudioPolicyManager::GetInstance().GetSelectedDeviceInfo(uid, pid, streamType);
851 }
852
SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter,std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const853 int32_t AudioSystemManager::SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter,
854 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
855 {
856 // basic check
857 CHECK_AND_RETURN_RET_LOG(audioRendererFilter != nullptr && audioDeviceDescriptors.size() != 0,
858 ERR_INVALID_PARAM, "invalid parameter");
859
860 size_t validDeviceSize = 1;
861 CHECK_AND_RETURN_RET_LOG(audioDeviceDescriptors.size() <= validDeviceSize &&
862 audioDeviceDescriptors[0] != nullptr, ERR_INVALID_OPERATION, "device error");
863 audioRendererFilter->streamType = AudioSystemManager::GetStreamType(audioRendererFilter->rendererInfo.contentType,
864 audioRendererFilter->rendererInfo.streamUsage);
865 // operation chack
866 CHECK_AND_RETURN_RET_LOG(audioDeviceDescriptors[0]->deviceRole_ == DeviceRole::OUTPUT_DEVICE,
867 ERR_INVALID_OPERATION, "not an output device.");
868
869 CHECK_AND_RETURN_RET_LOG(audioDeviceDescriptors[0]->networkId_ == LOCAL_NETWORK_ID ||
870 audioDeviceDescriptors[0]->networkId_.size() == VALID_REMOTE_NETWORK_ID_LENGTH,
871 ERR_INVALID_PARAM, "invalid networkId.");
872 CHECK_AND_RETURN_RET_LOG(audioRendererFilter->uid >= 0 || (audioRendererFilter->uid == -1),
873 ERR_INVALID_PARAM, "invalid uid.");
874
875 AUDIO_DEBUG_LOG("[%{public}d] SelectOutputDevice: uid<%{public}d> streamType<%{public}d> device<name:%{public}s>",
876 getpid(), audioRendererFilter->uid, static_cast<int32_t>(audioRendererFilter->streamType),
877 (audioDeviceDescriptors[0]->networkId_.c_str()));
878
879 return AudioPolicyManager::GetInstance().SelectOutputDevice(audioRendererFilter, audioDeviceDescriptors);
880 }
881
SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter,std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const882 int32_t AudioSystemManager::SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter,
883 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
884 {
885 // basic check
886 CHECK_AND_RETURN_RET_LOG(audioCapturerFilter != nullptr && audioDeviceDescriptors.size() != 0,
887 ERR_INVALID_PARAM, "invalid parameter");
888
889 size_t validDeviceSize = 1;
890 CHECK_AND_RETURN_RET_LOG(audioDeviceDescriptors.size() <= validDeviceSize && audioDeviceDescriptors[0] != nullptr,
891 ERR_INVALID_OPERATION, "device error.");
892 // operation chack
893 CHECK_AND_RETURN_RET_LOG(audioDeviceDescriptors[0]->deviceRole_ == DeviceRole::INPUT_DEVICE,
894 ERR_INVALID_OPERATION, "not an input device");
895 CHECK_AND_RETURN_RET_LOG(audioCapturerFilter->uid >= 0 || (audioCapturerFilter->uid == -1),
896 ERR_INVALID_PARAM, "invalid uid.");
897 AUDIO_DEBUG_LOG("[%{public}d] SelectInputDevice: uid<%{public}d> device<type:%{public}d>",
898 getpid(), audioCapturerFilter->uid, static_cast<int32_t>(audioDeviceDescriptors[0]->deviceType_));
899
900 return AudioPolicyManager::GetInstance().SelectInputDevice(audioCapturerFilter, audioDeviceDescriptors);
901 }
902
ExcludeOutputDevices(AudioDeviceUsage audioDevUsage,std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const903 int32_t AudioSystemManager::ExcludeOutputDevices(AudioDeviceUsage audioDevUsage,
904 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
905 {
906 CHECK_AND_RETURN_RET_LOG(audioDevUsage == MEDIA_OUTPUT_DEVICES || audioDevUsage == CALL_OUTPUT_DEVICES,
907 ERR_INVALID_PARAM, "invalid parameter: only support output device");
908 CHECK_AND_RETURN_RET_LOG(!audioDeviceDescriptors.empty(), ERR_INVALID_PARAM, "invalid parameter: empty list");
909 for (const auto &devDesc : audioDeviceDescriptors) {
910 CHECK_AND_RETURN_RET_LOG(devDesc != nullptr, ERR_INVALID_PARAM, "invalid parameter: mull pointer in list");
911 CHECK_AND_RETURN_RET_LOG(!(devDesc->deviceType_ == DEVICE_TYPE_SPEAKER &&
912 devDesc->networkId_ == LOCAL_NETWORK_ID),
913 ERR_INVALID_PARAM, "invalid parameter: speaker can not be excluded.");
914 CHECK_AND_RETURN_RET_LOG(devDesc->deviceType_ != DEVICE_TYPE_EARPIECE, ERR_INVALID_PARAM,
915 "invalid parameter: earpiece can not be excluded.");
916 CHECK_AND_RETURN_RET_LOG(devDesc->networkId_ == LOCAL_NETWORK_ID ||
917 devDesc->networkId_.size() == VALID_REMOTE_NETWORK_ID_LENGTH,
918 ERR_INVALID_PARAM, "invalid parameter: invalid networkId.");
919 }
920 return AudioPolicyManager::GetInstance().ExcludeOutputDevices(audioDevUsage, audioDeviceDescriptors);
921 }
922
UnexcludeOutputDevices(AudioDeviceUsage audioDevUsage,std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const923 int32_t AudioSystemManager::UnexcludeOutputDevices(AudioDeviceUsage audioDevUsage,
924 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
925 {
926 CHECK_AND_RETURN_RET_LOG(audioDevUsage == MEDIA_OUTPUT_DEVICES || audioDevUsage == CALL_OUTPUT_DEVICES,
927 ERR_INVALID_PARAM, "invalid parameter: only support output device");
928 CHECK_AND_RETURN_RET_LOG(!audioDeviceDescriptors.empty(), ERR_INVALID_PARAM, "invalid parameter: empty list");
929 for (const auto &devDesc : audioDeviceDescriptors) {
930 CHECK_AND_RETURN_RET_LOG(devDesc != nullptr, ERR_INVALID_PARAM, "invalid parameter: mull pointer in list");
931 CHECK_AND_RETURN_RET_LOG(!(devDesc->deviceType_ == DEVICE_TYPE_SPEAKER &&
932 devDesc->networkId_ == LOCAL_NETWORK_ID),
933 ERR_INVALID_PARAM, "invalid parameter: speaker can not be excluded.");
934 CHECK_AND_RETURN_RET_LOG(devDesc->deviceType_ != DEVICE_TYPE_EARPIECE, ERR_INVALID_PARAM,
935 "invalid parameter: earpiece can not be excluded.");
936 CHECK_AND_RETURN_RET_LOG(devDesc->networkId_ == LOCAL_NETWORK_ID ||
937 devDesc->networkId_.size() == VALID_REMOTE_NETWORK_ID_LENGTH,
938 ERR_INVALID_PARAM, "invalid parameter: invalid networkId.");
939 }
940 return AudioPolicyManager::GetInstance().UnexcludeOutputDevices(audioDevUsage, audioDeviceDescriptors);
941 }
942
UnexcludeOutputDevices(AudioDeviceUsage audioDevUsage) const943 int32_t AudioSystemManager::UnexcludeOutputDevices(AudioDeviceUsage audioDevUsage) const
944 {
945 CHECK_AND_RETURN_RET_LOG(audioDevUsage == MEDIA_OUTPUT_DEVICES || audioDevUsage == CALL_OUTPUT_DEVICES,
946 ERR_INVALID_PARAM, "invalid parameter: only support output device");
947 auto unexcludeOutputDevices = GetExcludedDevices(audioDevUsage);
948 if (unexcludeOutputDevices.empty()) {
949 return SUCCESS;
950 }
951 for (const auto &devDesc : unexcludeOutputDevices) {
952 CHECK_AND_RETURN_RET_LOG(devDesc != nullptr, ERR_INVALID_PARAM, "invalid parameter: mull pointer in list");
953 CHECK_AND_RETURN_RET_LOG(!(devDesc->deviceType_ == DEVICE_TYPE_SPEAKER &&
954 devDesc->networkId_ == LOCAL_NETWORK_ID),
955 ERR_INVALID_PARAM, "invalid parameter: speaker can not be excluded.");
956 CHECK_AND_RETURN_RET_LOG(devDesc->deviceType_ != DEVICE_TYPE_EARPIECE, ERR_INVALID_PARAM,
957 "invalid parameter: earpiece can not be excluded.");
958 CHECK_AND_RETURN_RET_LOG(devDesc->networkId_ == LOCAL_NETWORK_ID ||
959 devDesc->networkId_.size() == VALID_REMOTE_NETWORK_ID_LENGTH,
960 ERR_INVALID_PARAM, "invalid parameter: invalid networkId.");
961 }
962 return AudioPolicyManager::GetInstance().UnexcludeOutputDevices(audioDevUsage, unexcludeOutputDevices);
963 }
964
GetExcludedDevices(AudioDeviceUsage audioDevUsage) const965 std::vector<std::shared_ptr<AudioDeviceDescriptor>> AudioSystemManager::GetExcludedDevices(
966 AudioDeviceUsage audioDevUsage) const
967 {
968 return AudioPolicyManager::GetInstance().GetExcludedDevices(audioDevUsage);
969 }
970
GetDevices(DeviceFlag deviceFlag)971 std::vector<std::shared_ptr<AudioDeviceDescriptor>> AudioSystemManager::GetDevices(DeviceFlag deviceFlag)
972 {
973 return AudioPolicyManager::GetInstance().GetDevices(deviceFlag);
974 }
975
GetDevicesInner(DeviceFlag deviceFlag)976 std::vector<std::shared_ptr<AudioDeviceDescriptor>> AudioSystemManager::GetDevicesInner(DeviceFlag deviceFlag)
977 {
978 return AudioPolicyManager::GetInstance().GetDevicesInner(deviceFlag);
979 }
980
GetActiveOutputDeviceDescriptors()981 std::vector<std::shared_ptr<AudioDeviceDescriptor>> AudioSystemManager::GetActiveOutputDeviceDescriptors()
982 {
983 AudioRendererInfo rendererInfo;
984 return AudioPolicyManager::GetInstance().GetPreferredOutputDeviceDescriptors(rendererInfo);
985 }
986
GetPreferredInputDeviceDescriptors()987 int32_t AudioSystemManager::GetPreferredInputDeviceDescriptors()
988 {
989 AudioCapturerInfo capturerInfo;
990 auto dec = AudioPolicyManager::GetInstance().GetPreferredInputDeviceDescriptors(capturerInfo);
991 CHECK_AND_RETURN_RET(dec.size() > 0, ERROR_INVALID_PARAM);
992 return SUCCESS;
993 }
994
GetOutputDevice(sptr<AudioRendererFilter> audioRendererFilter)995 std::vector<std::shared_ptr<AudioDeviceDescriptor>> AudioSystemManager::GetOutputDevice(
996 sptr<AudioRendererFilter> audioRendererFilter)
997 {
998 return AudioPolicyManager::GetInstance().GetOutputDevice(audioRendererFilter);
999 }
1000
GetInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter)1001 std::vector<std::shared_ptr<AudioDeviceDescriptor>> AudioSystemManager::GetInputDevice(
1002 sptr<AudioCapturerFilter> audioCapturerFilter)
1003 {
1004 return AudioPolicyManager::GetInstance().GetInputDevice(audioCapturerFilter);
1005 }
1006
GetAudioFocusInfoList(std::list<std::pair<AudioInterrupt,AudioFocuState>> & focusInfoList)1007 int32_t AudioSystemManager::GetAudioFocusInfoList(std::list<std::pair<AudioInterrupt, AudioFocuState>> &focusInfoList)
1008 {
1009 AUDIO_DEBUG_LOG("Entered %{public}s", __func__);
1010 return AudioPolicyManager::GetInstance().GetAudioFocusInfoList(focusInfoList);
1011 }
1012
RegisterFocusInfoChangeCallback(const std::shared_ptr<AudioFocusInfoChangeCallback> & callback)1013 int32_t AudioSystemManager::RegisterFocusInfoChangeCallback(
1014 const std::shared_ptr<AudioFocusInfoChangeCallback> &callback)
1015 {
1016 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is null");
1017
1018 int32_t clientId = GetCallingPid();
1019 AUDIO_DEBUG_LOG("RegisterFocusInfoChangeCallback clientId:%{public}d", clientId);
1020 if (audioFocusInfoCallback_ == nullptr) {
1021 audioFocusInfoCallback_ = std::make_shared<AudioFocusInfoChangeCallbackImpl>();
1022 CHECK_AND_RETURN_RET_LOG(audioFocusInfoCallback_ != nullptr, ERROR,
1023 "Failed to allocate memory for audioInterruptCallback");
1024 int32_t ret = AudioPolicyManager::GetInstance().RegisterFocusInfoChangeCallback(clientId,
1025 audioFocusInfoCallback_);
1026 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "Failed set callback");
1027 }
1028
1029 std::shared_ptr<AudioFocusInfoChangeCallbackImpl> cbFocusInfo =
1030 std::static_pointer_cast<AudioFocusInfoChangeCallbackImpl>(audioFocusInfoCallback_);
1031 CHECK_AND_RETURN_RET_LOG(cbFocusInfo != nullptr, ERROR, "cbFocusInfo is nullptr");
1032 cbFocusInfo->SaveCallback(callback);
1033
1034 return SUCCESS;
1035 }
1036
UnregisterFocusInfoChangeCallback(const std::shared_ptr<AudioFocusInfoChangeCallback> & callback)1037 int32_t AudioSystemManager::UnregisterFocusInfoChangeCallback(
1038 const std::shared_ptr<AudioFocusInfoChangeCallback> &callback)
1039 {
1040 int32_t clientId = GetCallingPid();
1041 int32_t ret = 0;
1042
1043 if (callback == nullptr) {
1044 ret = AudioPolicyManager::GetInstance().UnregisterFocusInfoChangeCallback(clientId);
1045 audioFocusInfoCallback_.reset();
1046 audioFocusInfoCallback_ = nullptr;
1047 if (!ret) {
1048 AUDIO_DEBUG_LOG("AudioSystemManager::UnregisterVolumeKeyEventCallback success");
1049 }
1050 return ret;
1051 }
1052 CHECK_AND_RETURN_RET_LOG(audioFocusInfoCallback_ != nullptr, ERROR,
1053 "Failed to allocate memory for audioInterruptCallback");
1054 std::shared_ptr<AudioFocusInfoChangeCallbackImpl> cbFocusInfo =
1055 std::static_pointer_cast<AudioFocusInfoChangeCallbackImpl>(audioFocusInfoCallback_);
1056 cbFocusInfo->RemoveCallback(callback);
1057
1058 return ret;
1059 }
1060
RegisterVolumeKeyEventCallback(const int32_t clientPid,const std::shared_ptr<VolumeKeyEventCallback> & callback,API_VERSION api_v)1061 int32_t AudioSystemManager::RegisterVolumeKeyEventCallback(const int32_t clientPid,
1062 const std::shared_ptr<VolumeKeyEventCallback> &callback, API_VERSION api_v)
1063 {
1064 AUDIO_DEBUG_LOG("AudioSystemManager RegisterVolumeKeyEventCallback");
1065
1066 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM,
1067 "RegisterVolumeKeyEventCallbackcallback is nullptr");
1068 volumeChangeClientPid_ = clientPid;
1069
1070 return AudioPolicyManager::GetInstance().SetVolumeKeyEventCallback(clientPid, callback, api_v);
1071 }
1072
UnregisterVolumeKeyEventCallback(const int32_t clientPid,const std::shared_ptr<VolumeKeyEventCallback> & callback)1073 int32_t AudioSystemManager::UnregisterVolumeKeyEventCallback(const int32_t clientPid,
1074 const std::shared_ptr<VolumeKeyEventCallback> &callback)
1075 {
1076 AUDIO_DEBUG_LOG("UnregisterVolumeKeyEventCallback");
1077 int32_t ret = AudioPolicyManager::GetInstance().UnsetVolumeKeyEventCallback(callback);
1078 if (!ret) {
1079 AUDIO_DEBUG_LOG("UnsetVolumeKeyEventCallback success");
1080 volumeChangeClientPid_ = -1;
1081 }
1082 return ret;
1083 }
1084
SetAudioMonoState(bool monoState)1085 void AudioSystemManager::SetAudioMonoState(bool monoState)
1086 {
1087 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
1088 CHECK_AND_RETURN_LOG(gasp != nullptr, "Audio service unavailable.");
1089 gasp->SetAudioMonoState(monoState);
1090 }
1091
SetAudioBalanceValue(float balanceValue)1092 void AudioSystemManager::SetAudioBalanceValue(float balanceValue)
1093 {
1094 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
1095 CHECK_AND_RETURN_LOG(gasp != nullptr, "Audio service unavailable.");
1096 gasp->SetAudioBalanceValue(balanceValue);
1097 }
1098
SetSystemSoundUri(const std::string & key,const std::string & uri)1099 int32_t AudioSystemManager::SetSystemSoundUri(const std::string &key, const std::string &uri)
1100 {
1101 return AudioPolicyManager::GetInstance().SetSystemSoundUri(key, uri);
1102 }
1103
GetSystemSoundUri(const std::string & key)1104 std::string AudioSystemManager::GetSystemSoundUri(const std::string &key)
1105 {
1106 return AudioPolicyManager::GetInstance().GetSystemSoundUri(key);
1107 }
1108
1109 // Below stub implementation is added to handle compilation error in call manager
1110 // Once call manager adapt to new interrupt implementation, this will be removed
SetAudioManagerCallback(const AudioVolumeType streamType,const std::shared_ptr<AudioManagerCallback> & callback)1111 int32_t AudioSystemManager::SetAudioManagerCallback(const AudioVolumeType streamType,
1112 const std::shared_ptr<AudioManagerCallback> &callback)
1113 {
1114 AUDIO_DEBUG_LOG("stub implementation");
1115 return SUCCESS;
1116 }
1117
UnsetAudioManagerCallback(const AudioVolumeType streamType) const1118 int32_t AudioSystemManager::UnsetAudioManagerCallback(const AudioVolumeType streamType) const
1119 {
1120 AUDIO_DEBUG_LOG("stub implementation");
1121 return SUCCESS;
1122 }
1123
ActivateAudioInterrupt(AudioInterrupt & audioInterrupt)1124 int32_t AudioSystemManager::ActivateAudioInterrupt(AudioInterrupt &audioInterrupt)
1125 {
1126 AUDIO_DEBUG_LOG("stub implementation");
1127 return AudioPolicyManager::GetInstance().ActivateAudioInterrupt(audioInterrupt);
1128 }
1129
DeactivateAudioInterrupt(const AudioInterrupt & audioInterrupt) const1130 int32_t AudioSystemManager::DeactivateAudioInterrupt(const AudioInterrupt &audioInterrupt) const
1131 {
1132 AUDIO_DEBUG_LOG("stub implementation");
1133 return AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt);
1134 }
1135
GetStandbyStatus(uint32_t sessionId,bool & isStandby,int64_t & enterStandbyTime)1136 int32_t AudioSystemManager::GetStandbyStatus(uint32_t sessionId, bool &isStandby, int64_t &enterStandbyTime)
1137 {
1138 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
1139 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, ERR_ILLEGAL_STATE, "Audio service unavailable.");
1140 int32_t ret = gasp->GetStandbyStatus(sessionId, isStandby, enterStandbyTime);
1141 CHECK_AND_RETURN_RET_LOG(ret == 0, ret, "failed: %{public}d", ret);
1142 return ret;
1143 }
1144
1145 #ifdef HAS_FEATURE_INNERCAPTURER
CheckCaptureLimit(const AudioPlaybackCaptureConfig & config,int32_t & innerCapId)1146 int32_t AudioSystemManager::CheckCaptureLimit(const AudioPlaybackCaptureConfig &config, int32_t &innerCapId)
1147 {
1148 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
1149 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, ERR_ILLEGAL_STATE, "Audio service unavailable.");
1150 int32_t ret = gasp->CheckCaptureLimit(config, innerCapId);
1151 CHECK_AND_RETURN_RET_LOG(ret == 0, ret, "failed: %{public}d", ret);
1152 return ret;
1153 }
1154
ReleaseCaptureLimit(int32_t innerCapId)1155 int32_t AudioSystemManager::ReleaseCaptureLimit(int32_t innerCapId)
1156 {
1157 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
1158 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, ERR_ILLEGAL_STATE, "Audio service unavailable.");
1159 int32_t ret = gasp->ReleaseCaptureLimit(innerCapId);
1160 CHECK_AND_RETURN_RET_LOG(ret == 0, ret, "failed: %{public}d", ret);
1161 return ret;
1162 }
1163 #endif
1164
GenerateSessionId(uint32_t & sessionId)1165 int32_t AudioSystemManager::GenerateSessionId(uint32_t &sessionId)
1166 {
1167 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
1168 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, 0, "Audio service unavailable.");
1169 int32_t ret = gasp->GenerateSessionId(sessionId);
1170 CHECK_AND_RETURN_RET_LOG(ret == 0, AUDIO_ERR, "Get sessionId failed");
1171 return 0;
1172 }
1173
SetAudioInterruptCallback(const uint32_t sessionID,const std::shared_ptr<AudioInterruptCallback> & callback,uint32_t clientUid,const int32_t zoneID)1174 int32_t AudioSystemManager::SetAudioInterruptCallback(const uint32_t sessionID,
1175 const std::shared_ptr<AudioInterruptCallback> &callback, uint32_t clientUid, const int32_t zoneID)
1176 {
1177 return AudioPolicyManager::GetInstance().SetAudioInterruptCallback(sessionID, callback, clientUid, zoneID);
1178 }
1179
UnsetAudioInterruptCallback(const int32_t zoneId,const uint32_t sessionId)1180 int32_t AudioSystemManager::UnsetAudioInterruptCallback(const int32_t zoneId, const uint32_t sessionId)
1181 {
1182 return AudioPolicyManager::GetInstance().UnsetAudioInterruptCallback(zoneId, sessionId);
1183 }
1184
SetAudioManagerInterruptCallback(const std::shared_ptr<AudioManagerCallback> & callback)1185 int32_t AudioSystemManager::SetAudioManagerInterruptCallback(const std::shared_ptr<AudioManagerCallback> &callback)
1186 {
1187 int32_t clientId = GetCallingPid();
1188 AUDIO_INFO_LOG("client id: %{public}d", clientId);
1189 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is null");
1190
1191 if (audioInterruptCallback_ != nullptr) {
1192 callback->cbMutex_.lock();
1193 AUDIO_DEBUG_LOG("reset existing callback object");
1194 AudioPolicyManager::GetInstance().UnsetAudioManagerInterruptCallback(clientId);
1195 audioInterruptCallback_.reset();
1196 audioInterruptCallback_ = nullptr;
1197 callback->cbMutex_.unlock();
1198 }
1199
1200 audioInterruptCallback_ = std::make_shared<AudioManagerInterruptCallbackImpl>();
1201 CHECK_AND_RETURN_RET_LOG(audioInterruptCallback_ != nullptr, ERROR,
1202 "Failed to allocate memory for audioInterruptCallback");
1203
1204 int32_t ret =
1205 AudioPolicyManager::GetInstance().SetAudioManagerInterruptCallback(clientId, audioInterruptCallback_);
1206 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "Failed set callback");
1207
1208 std::shared_ptr<AudioManagerInterruptCallbackImpl> cbInterrupt =
1209 std::static_pointer_cast<AudioManagerInterruptCallbackImpl>(audioInterruptCallback_);
1210 CHECK_AND_RETURN_RET_LOG(cbInterrupt != nullptr, ERROR, "cbInterrupt is nullptr");
1211 cbInterrupt->SaveCallback(callback);
1212
1213 return SUCCESS;
1214 }
1215
UnsetAudioManagerInterruptCallback()1216 int32_t AudioSystemManager::UnsetAudioManagerInterruptCallback()
1217 {
1218 int32_t clientId = GetCallingPid();
1219 AUDIO_INFO_LOG("client id: %{public}d", clientId);
1220
1221 int32_t ret = AudioPolicyManager::GetInstance().UnsetAudioManagerInterruptCallback(clientId);
1222 if (audioInterruptCallback_ != nullptr) {
1223 audioInterruptCallback_.reset();
1224 audioInterruptCallback_ = nullptr;
1225 }
1226
1227 return ret;
1228 }
1229
RequestAudioFocus(const AudioInterrupt & audioInterrupt)1230 int32_t AudioSystemManager::RequestAudioFocus(const AudioInterrupt &audioInterrupt)
1231 {
1232 int32_t clientId = GetCallingPid();
1233 AUDIO_INFO_LOG("RequestAudioFocus client id: %{public}d", clientId);
1234 CHECK_AND_RETURN_RET_LOG(audioInterrupt.contentType >= CONTENT_TYPE_UNKNOWN &&
1235 audioInterrupt.contentType <= CONTENT_TYPE_ULTRASONIC, ERR_INVALID_PARAM, "Invalid content type");
1236 CHECK_AND_RETURN_RET_LOG(audioInterrupt.streamUsage >= STREAM_USAGE_UNKNOWN &&
1237 audioInterrupt.streamUsage <= STREAM_USAGE_ULTRASONIC, ERR_INVALID_PARAM, "Invalid stream usage");
1238 CHECK_AND_RETURN_RET_LOG(audioInterrupt.audioFocusType.streamType >= STREAM_VOICE_CALL &&
1239 audioInterrupt.audioFocusType.streamType <= STREAM_TYPE_MAX, ERR_INVALID_PARAM, "Invalid stream type");
1240 return AudioPolicyManager::GetInstance().RequestAudioFocus(clientId, audioInterrupt);
1241 }
1242
AbandonAudioFocus(const AudioInterrupt & audioInterrupt)1243 int32_t AudioSystemManager::AbandonAudioFocus(const AudioInterrupt &audioInterrupt)
1244 {
1245 int32_t clientId = GetCallingPid();
1246 AUDIO_INFO_LOG("AbandonAudioFocus client id: %{public}d", clientId);
1247 CHECK_AND_RETURN_RET_LOG(audioInterrupt.contentType >= CONTENT_TYPE_UNKNOWN &&
1248 audioInterrupt.contentType <= CONTENT_TYPE_ULTRASONIC, ERR_INVALID_PARAM, "Invalid content type");
1249 CHECK_AND_RETURN_RET_LOG(audioInterrupt.streamUsage >= STREAM_USAGE_UNKNOWN &&
1250 audioInterrupt.streamUsage <= STREAM_USAGE_ULTRASONIC, ERR_INVALID_PARAM, "Invalid stream usage");
1251 CHECK_AND_RETURN_RET_LOG(audioInterrupt.audioFocusType.streamType >= STREAM_VOICE_CALL &&
1252 audioInterrupt.audioFocusType.streamType <= STREAM_TYPE_MAX, ERR_INVALID_PARAM, "Invalid stream type");
1253 return AudioPolicyManager::GetInstance().AbandonAudioFocus(clientId, audioInterrupt);
1254 }
1255
ReconfigureAudioChannel(const uint32_t & count,DeviceType deviceType)1256 int32_t AudioSystemManager::ReconfigureAudioChannel(const uint32_t &count, DeviceType deviceType)
1257 {
1258 return AudioPolicyManager::GetInstance().ReconfigureAudioChannel(count, deviceType);
1259 }
1260
GetVolumeGroups(std::string networkId,std::vector<sptr<VolumeGroupInfo>> & infos)1261 int32_t AudioSystemManager::GetVolumeGroups(std::string networkId, std::vector<sptr<VolumeGroupInfo>> &infos)
1262 {
1263 return AudioPolicyManager::GetInstance().GetVolumeGroupInfos(networkId, infos);
1264 }
1265
GetGroupManager(int32_t groupId)1266 std::shared_ptr<AudioGroupManager> AudioSystemManager::GetGroupManager(int32_t groupId)
1267 {
1268 std::lock_guard<std::mutex> lock(groupManagerMapMutex_);
1269 std::vector<std::shared_ptr<AudioGroupManager>>::iterator iter = groupManagerMap_.begin();
1270 while (iter != groupManagerMap_.end()) {
1271 if ((*iter)->GetGroupId() == groupId) {
1272 return *iter;
1273 } else {
1274 iter++;
1275 }
1276 }
1277
1278 std::shared_ptr<AudioGroupManager> groupManager = std::make_shared<AudioGroupManager>(groupId);
1279 if (groupManager->Init() == SUCCESS) {
1280 groupManagerMap_.push_back(groupManager);
1281 } else {
1282 groupManager = nullptr;
1283 }
1284 return groupManager;
1285 }
1286
AudioManagerInterruptCallbackImpl()1287 AudioManagerInterruptCallbackImpl::AudioManagerInterruptCallbackImpl()
1288 {
1289 AUDIO_INFO_LOG("AudioManagerInterruptCallbackImpl constructor");
1290 }
1291
~AudioManagerInterruptCallbackImpl()1292 AudioManagerInterruptCallbackImpl::~AudioManagerInterruptCallbackImpl()
1293 {
1294 AUDIO_DEBUG_LOG("AudioManagerInterruptCallbackImpl: instance destroy");
1295 }
1296
SaveCallback(const std::weak_ptr<AudioManagerCallback> & callback)1297 void AudioManagerInterruptCallbackImpl::SaveCallback(const std::weak_ptr<AudioManagerCallback> &callback)
1298 {
1299 auto wp = callback.lock();
1300 if (wp != nullptr) {
1301 callback_ = callback;
1302 } else {
1303 AUDIO_ERR_LOG("callback is nullptr");
1304 }
1305 }
1306
OnInterrupt(const InterruptEventInternal & interruptEvent)1307 void AudioManagerInterruptCallbackImpl::OnInterrupt(const InterruptEventInternal &interruptEvent)
1308 {
1309 cb_ = callback_.lock();
1310 if (cb_ != nullptr) {
1311 cb_->cbMutex_.lock();
1312 InterruptAction interruptAction = {};
1313 interruptAction.actionType = (interruptEvent.eventType == INTERRUPT_TYPE_BEGIN)
1314 ? TYPE_INTERRUPT : TYPE_ACTIVATED;
1315 interruptAction.interruptType = interruptEvent.eventType;
1316 interruptAction.interruptHint = interruptEvent.hintType;
1317 interruptAction.activated = (interruptEvent.eventType == INTERRUPT_TYPE_BEGIN) ? false : true;
1318 cb_->OnInterrupt(interruptAction);
1319 AUDIO_DEBUG_LOG("Notify event to app complete");
1320 cb_->cbMutex_.unlock();
1321 } else {
1322 AUDIO_ERR_LOG("callback is null");
1323 }
1324
1325 return;
1326 }
1327
RequestIndependentInterrupt(FocusType focusType)1328 bool AudioSystemManager::RequestIndependentInterrupt(FocusType focusType)
1329 {
1330 AUDIO_INFO_LOG("RequestIndependentInterrupt : foncusType");
1331 AudioInterrupt audioInterrupt;
1332 int32_t clientId = GetCallingPid();
1333 audioInterrupt.contentType = ContentType::CONTENT_TYPE_SPEECH;
1334 audioInterrupt.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
1335 audioInterrupt.audioFocusType.streamType = AudioStreamType::STREAM_RECORDING;
1336 audioInterrupt.streamId = static_cast<uint32_t>(clientId);
1337 int32_t result = AudioPolicyManager::GetInstance().ActivateAudioInterrupt(audioInterrupt);
1338
1339 AUDIO_DEBUG_LOG("Rresult -> %{public}d", result);
1340 return (result == SUCCESS) ? true:false;
1341 }
AbandonIndependentInterrupt(FocusType focusType)1342 bool AudioSystemManager::AbandonIndependentInterrupt(FocusType focusType)
1343 {
1344 AUDIO_INFO_LOG("AbandonIndependentInterrupt : foncusType");
1345 AudioInterrupt audioInterrupt;
1346 int32_t clientId = GetCallingPid();
1347 audioInterrupt.contentType = ContentType::CONTENT_TYPE_SPEECH;
1348 audioInterrupt.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
1349 audioInterrupt.audioFocusType.streamType = AudioStreamType::STREAM_RECORDING;
1350 audioInterrupt.streamId = static_cast<uint32_t>(clientId);
1351 int32_t result = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt);
1352 AUDIO_DEBUG_LOG("result -> %{public}d", result);
1353 return (result == SUCCESS) ? true:false;
1354 }
1355
UpdateStreamState(const int32_t clientUid,StreamSetState streamSetState,StreamUsage streamUsage)1356 int32_t AudioSystemManager::UpdateStreamState(const int32_t clientUid,
1357 StreamSetState streamSetState, StreamUsage streamUsage)
1358 {
1359 AUDIO_INFO_LOG("clientUid:%{public}d streamSetState:%{public}d streamUsage:%{public}d",
1360 clientUid, streamSetState, streamUsage);
1361 return AudioPolicyManager::GetInstance().UpdateStreamState(clientUid, streamSetState, streamUsage);
1362 }
1363
GetSelfBundleName()1364 std::string AudioSystemManager::GetSelfBundleName()
1365 {
1366 AudioXCollie audioXCollie("AudioSystemManager::GetSelfBundleName", GET_BUNDLE_INFO_TIME_OUT_SECONDS);
1367
1368 std::string bundleName = "";
1369
1370 WatchTimeout guard("SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();GetSelfBundleName");
1371 sptr<ISystemAbilityManager> systemAbilityManager =
1372 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1373 guard.CheckCurrTimeout();
1374 sptr<OHOS::IRemoteObject> remoteObject =
1375 systemAbilityManager->CheckSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
1376 CHECK_AND_RETURN_RET_LOG(remoteObject != nullptr, bundleName, "remoteObject is null");
1377
1378 sptr<AppExecFwk::IBundleMgr> iBundleMgr = iface_cast<AppExecFwk::IBundleMgr>(remoteObject);
1379 CHECK_AND_RETURN_RET_LOG(iBundleMgr != nullptr, bundleName, "bundlemgr interface is null");
1380
1381 AppExecFwk::BundleInfo bundleInfo;
1382 WatchTimeout reguard("iBundleMgr->GetBundleInfoForSelf:GetSelfBundleName");
1383 if (iBundleMgr->GetBundleInfoForSelf(0, bundleInfo) == ERR_OK) {
1384 bundleName = bundleInfo.name;
1385 } else {
1386 AUDIO_DEBUG_LOG("Get bundle info failed");
1387 }
1388 reguard.CheckCurrTimeout();
1389 return bundleName;
1390 }
1391
SetDeviceAbsVolumeSupported(const std::string & macAddress,const bool support)1392 int32_t AudioSystemManager::SetDeviceAbsVolumeSupported(const std::string &macAddress, const bool support)
1393 {
1394 AUDIO_INFO_LOG("AudioSystemManager::SetDeviceAbsVolumeSupported");
1395 return AudioPolicyManager::GetInstance().SetDeviceAbsVolumeSupported(macAddress, support);
1396 }
1397
SetA2dpDeviceVolume(const std::string & macAddress,const int32_t volume,const bool updateUi)1398 int32_t AudioSystemManager::SetA2dpDeviceVolume(const std::string &macAddress, const int32_t volume,
1399 const bool updateUi)
1400 {
1401 AUDIO_INFO_LOG("volume: %{public}d, update ui: %{public}d", volume, updateUi);
1402 return AudioPolicyManager::GetInstance().SetA2dpDeviceVolume(macAddress, volume, updateUi);
1403 }
1404
GetPinValueFromType(DeviceType deviceType,DeviceRole deviceRole) const1405 AudioPin AudioSystemManager::GetPinValueFromType(DeviceType deviceType, DeviceRole deviceRole) const
1406 {
1407 AudioPin pin = AUDIO_PIN_NONE;
1408 switch (deviceType) {
1409 case OHOS::AudioStandard::DEVICE_TYPE_NONE:
1410 case OHOS::AudioStandard::DEVICE_TYPE_INVALID:
1411 pin = AUDIO_PIN_NONE;
1412 break;
1413 case OHOS::AudioStandard::DEVICE_TYPE_DEFAULT:
1414 if (deviceRole == DeviceRole::INPUT_DEVICE) {
1415 pin = AUDIO_PIN_IN_DAUDIO_DEFAULT;
1416 } else {
1417 pin = AUDIO_PIN_OUT_DAUDIO_DEFAULT;
1418 }
1419 break;
1420 case OHOS::AudioStandard::DEVICE_TYPE_SPEAKER:
1421 pin = AUDIO_PIN_OUT_SPEAKER;
1422 break;
1423 case OHOS::AudioStandard::DEVICE_TYPE_MIC:
1424 case OHOS::AudioStandard::DEVICE_TYPE_WAKEUP:
1425 pin = AUDIO_PIN_IN_MIC;
1426 break;
1427 case OHOS::AudioStandard::DEVICE_TYPE_WIRED_HEADSET:
1428 if (deviceRole == DeviceRole::INPUT_DEVICE) {
1429 pin = AUDIO_PIN_IN_HS_MIC;
1430 } else {
1431 pin = AUDIO_PIN_OUT_HEADSET;
1432 }
1433 break;
1434 case OHOS::AudioStandard::DEVICE_TYPE_DP:
1435 pin = AUDIO_PIN_OUT_DP;
1436 break;
1437 case OHOS::AudioStandard::DEVICE_TYPE_USB_HEADSET:
1438 if (deviceRole == DeviceRole::INPUT_DEVICE) {
1439 pin = AUDIO_PIN_IN_USB_HEADSET;
1440 } else {
1441 pin = AUDIO_PIN_OUT_USB_HEADSET;
1442 }
1443 break;
1444 case OHOS::AudioStandard::DEVICE_TYPE_HDMI:
1445 pin = AUDIO_PIN_OUT_HDMI;
1446 break;
1447 default:
1448 OtherDeviceTypeCases(deviceType);
1449 break;
1450 }
1451 return pin;
1452 }
1453
OtherDeviceTypeCases(DeviceType deviceType) const1454 void AudioSystemManager::OtherDeviceTypeCases(DeviceType deviceType) const
1455 {
1456 switch (deviceType) {
1457 case OHOS::AudioStandard::DEVICE_TYPE_FILE_SINK:
1458 case OHOS::AudioStandard::DEVICE_TYPE_FILE_SOURCE:
1459 case OHOS::AudioStandard::DEVICE_TYPE_BLUETOOTH_SCO:
1460 case OHOS::AudioStandard::DEVICE_TYPE_BLUETOOTH_A2DP:
1461 case OHOS::AudioStandard::DEVICE_TYPE_MAX:
1462 AUDIO_INFO_LOG("don't supported the device type");
1463 break;
1464 default:
1465 AUDIO_INFO_LOG("invalid input parameter");
1466 break;
1467 }
1468 }
1469
GetTypeValueFromPin(AudioPin pin) const1470 DeviceType AudioSystemManager::GetTypeValueFromPin(AudioPin pin) const
1471 {
1472 DeviceType type = DEVICE_TYPE_NONE;
1473 switch (pin) {
1474 case OHOS::AudioStandard::AUDIO_PIN_NONE:
1475 type = DEVICE_TYPE_NONE;
1476 break;
1477 case OHOS::AudioStandard::AUDIO_PIN_OUT_SPEAKER:
1478 type = DEVICE_TYPE_SPEAKER;
1479 break;
1480 case OHOS::AudioStandard::AUDIO_PIN_OUT_HEADSET:
1481 break;
1482 case OHOS::AudioStandard::AUDIO_PIN_OUT_LINEOUT:
1483 break;
1484 case OHOS::AudioStandard::AUDIO_PIN_OUT_HDMI:
1485 break;
1486 case OHOS::AudioStandard::AUDIO_PIN_OUT_USB:
1487 break;
1488 case OHOS::AudioStandard::AUDIO_PIN_OUT_USB_EXT:
1489 break;
1490 case OHOS::AudioStandard::AUDIO_PIN_OUT_DAUDIO_DEFAULT:
1491 type = DEVICE_TYPE_DEFAULT;
1492 break;
1493 case OHOS::AudioStandard::AUDIO_PIN_IN_MIC:
1494 type = DEVICE_TYPE_MIC;
1495 break;
1496 case OHOS::AudioStandard::AUDIO_PIN_IN_HS_MIC:
1497 type = DEVICE_TYPE_WIRED_HEADSET;
1498 break;
1499 case OHOS::AudioStandard::AUDIO_PIN_IN_LINEIN:
1500 break;
1501 case OHOS::AudioStandard::AUDIO_PIN_IN_USB_EXT:
1502 break;
1503 case OHOS::AudioStandard::AUDIO_PIN_IN_DAUDIO_DEFAULT:
1504 type = DEVICE_TYPE_DEFAULT;
1505 break;
1506 default:
1507 AUDIO_INFO_LOG("invalid input parameter");
1508 break;
1509 }
1510 return type;
1511 }
1512
RegisterWakeupSourceCallback()1513 int32_t AudioSystemManager::RegisterWakeupSourceCallback()
1514 {
1515 AUDIO_INFO_LOG("RegisterWakeupSourceCallback");
1516 remoteWakeUpCallback_ = std::make_shared<WakeUpCallbackImpl>(this);
1517
1518 auto wakeupCloseCbStub = new(std::nothrow) AudioManagerListenerStub();
1519 CHECK_AND_RETURN_RET_LOG(wakeupCloseCbStub != nullptr, ERROR,
1520 "wakeupCloseCbStub is null");
1521 wakeupCloseCbStub->SetWakeupSourceCallback(remoteWakeUpCallback_);
1522
1523 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
1524 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, ERROR, "GetAudioParameter::Audio service unavailable.");
1525
1526 sptr<IRemoteObject> object = wakeupCloseCbStub->AsObject();
1527 if (object == nullptr) {
1528 AUDIO_ERR_LOG("SetWakeupCloseCallback listenerStub object is nullptr");
1529 delete wakeupCloseCbStub;
1530 return ERROR;
1531 }
1532 return gasp->SetWakeupSourceCallback(object);
1533 }
1534
SetAudioCapturerSourceCallback(const std::shared_ptr<AudioCapturerSourceCallback> & callback)1535 int32_t AudioSystemManager::SetAudioCapturerSourceCallback(
1536 const std::shared_ptr<AudioCapturerSourceCallback> &callback)
1537 {
1538 audioCapturerSourceCallback_ = callback;
1539 return RegisterWakeupSourceCallback();
1540 }
1541
SetWakeUpSourceCloseCallback(const std::shared_ptr<WakeUpSourceCloseCallback> & callback)1542 int32_t AudioSystemManager::SetWakeUpSourceCloseCallback(const std::shared_ptr<WakeUpSourceCloseCallback> &callback)
1543 {
1544 audioWakeUpSourceCloseCallback_ = callback;
1545 return RegisterWakeupSourceCallback();
1546 }
1547
SetAvailableDeviceChangeCallback(const AudioDeviceUsage usage,const std::shared_ptr<AudioManagerAvailableDeviceChangeCallback> & callback)1548 int32_t AudioSystemManager::SetAvailableDeviceChangeCallback(const AudioDeviceUsage usage,
1549 const std::shared_ptr<AudioManagerAvailableDeviceChangeCallback>& callback)
1550 {
1551 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is nullptr");
1552
1553 int32_t clientId = GetCallingPid();
1554 return AudioPolicyManager::GetInstance().SetAvailableDeviceChangeCallback(clientId, usage, callback);
1555 }
1556
UnsetAvailableDeviceChangeCallback(AudioDeviceUsage usage)1557 int32_t AudioSystemManager::UnsetAvailableDeviceChangeCallback(AudioDeviceUsage usage)
1558 {
1559 int32_t clientId = GetCallingPid();
1560 return AudioPolicyManager::GetInstance().UnsetAvailableDeviceChangeCallback(clientId, usage);
1561 }
1562
ConfigDistributedRoutingRole(std::shared_ptr<AudioDeviceDescriptor> descriptor,CastType type)1563 int32_t AudioSystemManager::ConfigDistributedRoutingRole(
1564 std::shared_ptr<AudioDeviceDescriptor> descriptor, CastType type)
1565 {
1566 if (descriptor == nullptr) {
1567 AUDIO_ERR_LOG("ConfigDistributedRoutingRole: invalid parameter");
1568 return ERR_INVALID_PARAM;
1569 }
1570 AUDIO_INFO_LOG(" Entered ConfigDistributedRoutingRole casttype %{public}d", type);
1571 if (descriptor->deviceRole_ != DeviceRole::OUTPUT_DEVICE) {
1572 AUDIO_ERR_LOG("ConfigDistributedRoutingRole: not an output device");
1573 return ERR_INVALID_PARAM;
1574 }
1575
1576 if (descriptor->networkId_ != LOCAL_NETWORK_ID &&
1577 descriptor->networkId_.size() != VALID_REMOTE_NETWORK_ID_LENGTH) {
1578 AUDIO_ERR_LOG("ConfigDistributedRoutingRole: invalid networkId");
1579 return ERR_INVALID_PARAM;
1580 }
1581
1582 int32_t ret = AudioPolicyManager::GetInstance().ConfigDistributedRoutingRole(descriptor, type);
1583 return ret;
1584 }
1585
SetDistributedRoutingRoleCallback(const std::shared_ptr<AudioDistributedRoutingRoleCallback> & callback)1586 int32_t AudioSystemManager::SetDistributedRoutingRoleCallback(
1587 const std::shared_ptr<AudioDistributedRoutingRoleCallback> &callback)
1588 {
1589 if (callback == nullptr) {
1590 AUDIO_ERR_LOG("SetDistributedRoutingRoleCallback: callback is nullptr");
1591 return ERR_INVALID_PARAM;
1592 }
1593
1594 if (audioDistributedRoutingRoleCallback_ == nullptr) {
1595 audioDistributedRoutingRoleCallback_ = std::make_shared<AudioDistributedRoutingRoleCallbackImpl>();
1596 if (audioDistributedRoutingRoleCallback_ == nullptr) {
1597 AUDIO_ERR_LOG("AudioSystemManger failed to allocate memory for distributedRoutingRole callback");
1598 return ERROR;
1599 }
1600 int32_t ret = AudioPolicyManager::GetInstance().
1601 SetDistributedRoutingRoleCallback(audioDistributedRoutingRoleCallback_);
1602 if (ret != SUCCESS) {
1603 AUDIO_ERR_LOG("AudioSystemManger failed to set distributedRoutingRole callback");
1604 return ERROR;
1605 }
1606 }
1607
1608 std::shared_ptr<AudioDistributedRoutingRoleCallbackImpl> cbImpl =
1609 std::static_pointer_cast<AudioDistributedRoutingRoleCallbackImpl>(audioDistributedRoutingRoleCallback_);
1610 if (cbImpl == nullptr) {
1611 AUDIO_ERR_LOG("AudioSystemManger cbImpl is nullptr");
1612 return ERROR;
1613 }
1614 cbImpl->SaveCallback(callback);
1615 return SUCCESS;
1616 }
1617
UnsetDistributedRoutingRoleCallback(const std::shared_ptr<AudioDistributedRoutingRoleCallback> & callback)1618 int32_t AudioSystemManager::UnsetDistributedRoutingRoleCallback(
1619 const std::shared_ptr<AudioDistributedRoutingRoleCallback> &callback)
1620 {
1621 int32_t ret = AudioPolicyManager::GetInstance().UnsetDistributedRoutingRoleCallback();
1622 if (audioDistributedRoutingRoleCallback_ != nullptr) {
1623 audioDistributedRoutingRoleCallback_.reset();
1624 audioDistributedRoutingRoleCallback_ = nullptr;
1625 }
1626
1627 std::shared_ptr<AudioDistributedRoutingRoleCallbackImpl> cbImpl =
1628 std::static_pointer_cast<AudioDistributedRoutingRoleCallbackImpl>(audioDistributedRoutingRoleCallback_);
1629 if (cbImpl == nullptr) {
1630 AUDIO_ERR_LOG("AudioSystemManger cbImpl is nullptr");
1631 return ERROR;
1632 }
1633 cbImpl->RemoveCallback(callback);
1634 return ret;
1635 }
1636
SaveCallback(const std::shared_ptr<AudioDistributedRoutingRoleCallback> & callback)1637 void AudioDistributedRoutingRoleCallbackImpl::SaveCallback(
1638 const std::shared_ptr<AudioDistributedRoutingRoleCallback> &callback)
1639 {
1640 bool hasCallback = false;
1641 std::lock_guard<std::mutex> cbListLock(cbListMutex_);
1642 for (auto it = callbackList_.begin(); it != callbackList_.end(); ++it) {
1643 if ((*it) == callback) {
1644 hasCallback = true;
1645 }
1646 }
1647 if (!hasCallback) {
1648 callbackList_.push_back(callback);
1649 }
1650 }
1651
RemoveCallback(const std::shared_ptr<AudioDistributedRoutingRoleCallback> & callback)1652 void AudioDistributedRoutingRoleCallbackImpl::RemoveCallback(
1653 const std::shared_ptr<AudioDistributedRoutingRoleCallback> &callback)
1654 {
1655 AUDIO_INFO_LOG("Entered %{public}s", __func__);
1656 std::lock_guard<std::mutex> cbListLock(cbListMutex_);
1657 callbackList_.remove_if([&callback](std::shared_ptr<AudioDistributedRoutingRoleCallback> &callback_) {
1658 return callback_ == callback;
1659 });
1660 }
1661
OnDistributedRoutingRoleChange(std::shared_ptr<AudioDeviceDescriptor> descriptor,const CastType type)1662 void AudioDistributedRoutingRoleCallbackImpl::OnDistributedRoutingRoleChange(
1663 std::shared_ptr<AudioDeviceDescriptor>descriptor, const CastType type)
1664 {
1665 std::vector<std::shared_ptr<AudioDistributedRoutingRoleCallback>> temp_;
1666 std::unique_lock<mutex> cbListLock(cbListMutex_);
1667 for (auto callback = callbackList_.begin(); callback != callbackList_.end(); ++callback) {
1668 cb_ = (*callback);
1669 if (cb_ != nullptr) {
1670 AUDIO_DEBUG_LOG("OnDistributedRoutingRoleChange : Notify event to app complete");
1671 temp_.push_back(cb_);
1672 } else {
1673 AUDIO_ERR_LOG("OnDistributedRoutingRoleChange: callback is null");
1674 }
1675 }
1676 cbListLock.unlock();
1677 for (uint32_t i = 0; i < temp_.size(); i++) {
1678 temp_[i]->OnDistributedRoutingRoleChange(descriptor, type);
1679 }
1680 return;
1681 }
1682
AudioDistributedRoutingRoleCallbackImpl()1683 AudioDistributedRoutingRoleCallbackImpl::AudioDistributedRoutingRoleCallbackImpl()
1684 {
1685 AUDIO_INFO_LOG("AudioDistributedRoutingRoleCallbackImpl constructor");
1686 }
1687
~AudioDistributedRoutingRoleCallbackImpl()1688 AudioDistributedRoutingRoleCallbackImpl::~AudioDistributedRoutingRoleCallbackImpl()
1689 {
1690 AUDIO_INFO_LOG("AudioDistributedRoutingRoleCallbackImpl destroy");
1691 }
1692
SetCallDeviceActive(DeviceType deviceType,bool flag,std::string address,const int32_t clientUid) const1693 int32_t AudioSystemManager::SetCallDeviceActive(DeviceType deviceType, bool flag, std::string address,
1694 const int32_t clientUid) const
1695 {
1696 int32_t uid = clientUid == -1 ? getuid() : clientUid;
1697 return (AudioPolicyManager::GetInstance().SetCallDeviceActive(static_cast<InternalDeviceType>(deviceType),
1698 flag, address, uid));
1699 }
1700
GetEffectLatency(const std::string & sessionId)1701 uint32_t AudioSystemManager::GetEffectLatency(const std::string &sessionId)
1702 {
1703 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
1704 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, ERR_INVALID_PARAM, "Audio service unavailable.");
1705 return gasp->GetEffectLatency(sessionId);
1706 }
1707
DisableSafeMediaVolume()1708 int32_t AudioSystemManager::DisableSafeMediaVolume()
1709 {
1710 return AudioPolicyManager::GetInstance().DisableSafeMediaVolume();
1711 }
1712
InjectInterruption(const std::string networkId,InterruptEvent & event)1713 int32_t AudioSystemManager::InjectInterruption(const std::string networkId, InterruptEvent &event)
1714 {
1715 return AudioPolicyManager::GetInstance().InjectInterruption(networkId, event);
1716 }
1717
LoadSplitModule(const std::string & splitArgs,const std::string & networkId)1718 int32_t AudioSystemManager::LoadSplitModule(const std::string &splitArgs, const std::string &networkId)
1719 {
1720 return AudioPolicyManager::GetInstance().LoadSplitModule(splitArgs, networkId);
1721 }
1722
SetVirtualCall(const bool isVirtual)1723 int32_t AudioSystemManager::SetVirtualCall(const bool isVirtual)
1724 {
1725 return AudioPolicyManager::GetInstance().SetVirtualCall(isVirtual);
1726 }
1727
SetQueryAllowedPlaybackCallback(const std::shared_ptr<AudioQueryAllowedPlaybackCallback> & callback)1728 int32_t AudioSystemManager::SetQueryAllowedPlaybackCallback(
1729 const std::shared_ptr<AudioQueryAllowedPlaybackCallback> &callback)
1730 {
1731 AUDIO_INFO_LOG("In");
1732 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback is nullptr");
1733 return AudioPolicyManager::GetInstance().SetQueryAllowedPlaybackCallback(callback);
1734 }
1735
OnVoiceWakeupState(bool state)1736 int32_t AudioSystemManager::OnVoiceWakeupState(bool state)
1737 {
1738 AUDIO_INFO_LOG("%{public}d", state);
1739 return SUCCESS;
1740 }
1741 } // namespace AudioStandard
1742 } // namespace OHOS
1743