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