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