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