1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_system_manager.h"
17
18 #include "iservice_registry.h"
19 #include "system_ability_definition.h"
20 #include "bundle_mgr_interface.h"
21
22 #include "audio_log.h"
23 #include "audio_errors.h"
24 #include "audio_manager_base.h"
25 #include "audio_manager_proxy.h"
26 #include "audio_server_death_recipient.h"
27 #include "audio_policy_manager.h"
28 #include "audio_volume_key_event_callback_stub.h"
29 #include "audio_utils.h"
30 #include "audio_manager_listener_stub.h"
31
32 namespace OHOS {
33 namespace AudioStandard {
34 using namespace std;
35
36 const map<pair<ContentType, StreamUsage>, AudioStreamType> AudioSystemManager::streamTypeMap_
37 = AudioSystemManager::CreateStreamMap();
38 mutex g_asProxyMutex;
39 sptr<IStandardAudioService> g_asProxy = nullptr;
40
AudioSystemManager()41 AudioSystemManager::AudioSystemManager()
42 {
43 AUDIO_DEBUG_LOG("AudioSystemManager start");
44 }
45
~AudioSystemManager()46 AudioSystemManager::~AudioSystemManager()
47 {
48 AUDIO_DEBUG_LOG("AudioSystemManager::~AudioSystemManager");
49 if (cbClientId_ != -1) {
50 UnsetRingerModeCallback(cbClientId_);
51 }
52
53 if (volumeChangeClientPid_ != -1) {
54 AUDIO_DEBUG_LOG("AudioSystemManager::~AudioSystemManager UnregisterVolumeKeyEventCallback");
55 (void)UnregisterVolumeKeyEventCallback(volumeChangeClientPid_);
56 }
57 }
58
GetInstance()59 AudioSystemManager *AudioSystemManager::GetInstance()
60 {
61 static AudioSystemManager audioManager;
62 return &audioManager;
63 }
64
GetCallingPid()65 uint32_t AudioSystemManager::GetCallingPid()
66 {
67 return getpid();
68 }
69
CreateStreamMap()70 map<pair<ContentType, StreamUsage>, AudioStreamType> AudioSystemManager::CreateStreamMap()
71 {
72 map<pair<ContentType, StreamUsage>, AudioStreamType> streamMap;
73 // Mapping relationships from content and usage to stream type in design
74 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_UNKNOWN)] = STREAM_MUSIC;
75 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_VOICE_CALL;
76 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_MODEM_COMMUNICATION)] = STREAM_VOICE_CALL;
77 streamMap[make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_SYSTEM)] = STREAM_SYSTEM;
78 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
79 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_MEDIA)] = STREAM_MUSIC;
80 streamMap[make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_MEDIA)] = STREAM_MOVIE;
81 streamMap[make_pair(CONTENT_TYPE_GAME, STREAM_USAGE_MEDIA)] = STREAM_GAME;
82 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_MEDIA)] = STREAM_SPEECH;
83 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_ALARM)] = STREAM_ALARM;
84 streamMap[make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_NOTIFICATION)] = STREAM_NOTIFICATION;
85 streamMap[make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_ENFORCED_TONE)] = STREAM_SYSTEM_ENFORCED;
86 streamMap[make_pair(CONTENT_TYPE_DTMF, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_DTMF;
87 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
88 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_ACCESSIBILITY)] = STREAM_ACCESSIBILITY;
89 streamMap[make_pair(CONTENT_TYPE_ULTRASONIC, STREAM_USAGE_SYSTEM)] = STREAM_ULTRASONIC;
90
91 // Old mapping relationships from content and usage to stream type
92 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
93 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_UNKNOWN)] = STREAM_NOTIFICATION;
94 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_MEDIA)] = STREAM_NOTIFICATION;
95 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
96 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_UNKNOWN)] = STREAM_RING;
97 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_MEDIA)] = STREAM_RING;
98 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
99
100 // Only use stream usage to choose stream type
101 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MEDIA)] = STREAM_MUSIC;
102 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MUSIC)] = STREAM_MUSIC;
103 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_VOICE_CALL;
104 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_MODEM_COMMUNICATION)] = STREAM_VOICE_CALL;
105 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
106 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ALARM)] = STREAM_ALARM;
107 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_MESSAGE)] = STREAM_VOICE_MESSAGE;
108 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
109 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_RINGTONE)] = STREAM_RING;
110 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NOTIFICATION)] = STREAM_NOTIFICATION;
111 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ACCESSIBILITY)] = STREAM_ACCESSIBILITY;
112 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_SYSTEM)] = STREAM_SYSTEM;
113 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MOVIE)] = STREAM_MOVIE;
114 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_GAME)] = STREAM_GAME;
115 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_AUDIOBOOK)] = STREAM_SPEECH;
116 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NAVIGATION)] = STREAM_NAVIGATION;
117 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_DTMF)] = STREAM_DTMF;
118 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ENFORCED_TONE)] = STREAM_SYSTEM_ENFORCED;
119 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ULTRASONIC)] = STREAM_ULTRASONIC;
120
121 return streamMap;
122 }
123
GetStreamType(ContentType contentType,StreamUsage streamUsage)124 AudioStreamType AudioSystemManager::GetStreamType(ContentType contentType, StreamUsage streamUsage)
125 {
126 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
127 auto pos = streamTypeMap_.find(make_pair(contentType, streamUsage));
128 if (pos != streamTypeMap_.end()) {
129 streamType = pos->second;
130 } else {
131 AUDIO_ERR_LOG("The pair of contentType and streamUsage is not in design. Use the default stream type");
132 }
133
134 if (streamType == AudioStreamType::STREAM_MEDIA) {
135 streamType = AudioStreamType::STREAM_MUSIC;
136 }
137
138 return streamType;
139 }
140
GetAudioSystemManagerProxy()141 inline const sptr<IStandardAudioService> GetAudioSystemManagerProxy()
142 {
143 lock_guard<mutex> lock(g_asProxyMutex);
144 if (g_asProxy == nullptr) {
145 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
146 if (samgr == nullptr) {
147 AUDIO_ERR_LOG("GetAudioSystemManagerProxy: get sa manager failed");
148 return nullptr;
149 }
150 sptr<IRemoteObject> object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID);
151 if (object == nullptr) {
152 AUDIO_ERR_LOG("GetAudioSystemManagerProxy: get audio service remote object failed");
153 return nullptr;
154 }
155 g_asProxy = iface_cast<IStandardAudioService>(object);
156 if (g_asProxy == nullptr) {
157 AUDIO_ERR_LOG("GetAudioSystemManagerProxy: get audio service proxy failed");
158 return nullptr;
159 }
160
161 // register death recipent to restore proxy
162 sptr<AudioServerDeathRecipient> asDeathRecipient = new(std::nothrow) AudioServerDeathRecipient(getpid());
163 if (asDeathRecipient != nullptr) {
164 asDeathRecipient->SetNotifyCb(std::bind(&AudioSystemManager::AudioServerDied,
165 std::placeholders::_1));
166 bool result = object->AddDeathRecipient(asDeathRecipient);
167 if (!result) {
168 AUDIO_ERR_LOG("GetAudioSystemManagerProxy: failed to add deathRecipient");
169 }
170 }
171 }
172 sptr<IStandardAudioService> gasp = g_asProxy;
173 return gasp;
174 }
175
AudioServerDied(pid_t pid)176 void AudioSystemManager::AudioServerDied(pid_t pid)
177 {
178 AUDIO_INFO_LOG("audio server died, will restore proxy in next call");
179 lock_guard<mutex> lock(g_asProxyMutex);
180 g_asProxy = nullptr;
181 }
182
SetRingerMode(AudioRingerMode ringMode)183 int32_t AudioSystemManager::SetRingerMode(AudioRingerMode ringMode)
184 {
185 std::lock_guard<std::mutex> lockSet(ringerModeCallbackMutex_);
186 ringModeBackup_ = ringMode;
187 if (ringerModeCallback_ != nullptr) {
188 ringerModeCallback_->OnRingerModeUpdated(ringModeBackup_);
189 }
190
191 return SUCCESS;
192 }
193
GetRingerMode()194 AudioRingerMode AudioSystemManager::GetRingerMode()
195 {
196 return ringModeBackup_;
197 }
198
SetAudioScene(const AudioScene & scene)199 int32_t AudioSystemManager::SetAudioScene(const AudioScene &scene)
200 {
201 AUDIO_DEBUG_LOG("SetAudioScene audioScene_=%{public}d done", scene);
202 return AudioPolicyManager::GetInstance().SetAudioScene(scene);
203 }
204
GetAudioScene() const205 AudioScene AudioSystemManager::GetAudioScene() const
206 {
207 return AudioPolicyManager::GetInstance().GetAudioScene();
208 }
209
SetDeviceActive(ActiveDeviceType deviceType,bool flag) const210 int32_t AudioSystemManager::SetDeviceActive(ActiveDeviceType deviceType, bool flag) const
211 {
212 AUDIO_INFO_LOG("SetDeviceActive device: %{public}d", deviceType);
213 switch (deviceType) {
214 case EARPIECE:
215 case SPEAKER:
216 case BLUETOOTH_SCO:
217 case FILE_SINK_DEVICE:
218 break;
219 default:
220 AUDIO_ERR_LOG("SetDeviceActive device=%{public}d not supported", deviceType);
221 return ERR_NOT_SUPPORTED;
222 }
223
224 /* Call Audio Policy SetDeviceActive */
225 return (AudioPolicyManager::GetInstance().SetDeviceActive(static_cast<InternalDeviceType>(deviceType), flag));
226 }
227
IsDeviceActive(ActiveDeviceType deviceType) const228 bool AudioSystemManager::IsDeviceActive(ActiveDeviceType deviceType) const
229 {
230 switch (deviceType) {
231 case EARPIECE:
232 case SPEAKER:
233 case BLUETOOTH_SCO:
234 case FILE_SINK_DEVICE:
235 break;
236 default:
237 AUDIO_ERR_LOG("IsDeviceActive device=%{public}d not supported", deviceType);
238 return false;
239 }
240
241 /* Call Audio Policy IsDeviceActive */
242 return (AudioPolicyManager::GetInstance().IsDeviceActive(static_cast<InternalDeviceType>(deviceType)));
243 }
244
GetActiveOutputDevice()245 DeviceType AudioSystemManager::GetActiveOutputDevice()
246 {
247 return AudioPolicyManager::GetInstance().GetActiveOutputDevice();
248 }
249
GetActiveInputDevice()250 DeviceType AudioSystemManager::GetActiveInputDevice()
251 {
252 return AudioPolicyManager::GetInstance().GetActiveInputDevice();
253 }
254
IsStreamActive(AudioVolumeType volumeType) const255 bool AudioSystemManager::IsStreamActive(AudioVolumeType volumeType) const
256 {
257 switch (volumeType) {
258 case STREAM_MUSIC:
259 case STREAM_RING:
260 case STREAM_NOTIFICATION:
261 case STREAM_VOICE_CALL:
262 case STREAM_VOICE_ASSISTANT:
263 case STREAM_ALARM:
264 case STREAM_ACCESSIBILITY:
265 break;
266 case STREAM_ULTRASONIC:
267 if (!PermissionUtil::VerifySelfPermission()) {
268 AUDIO_ERR_LOG("IsStreamActive: volumeType=%{public}d. No system permission", volumeType);
269 return false;
270 }
271 break;
272 case STREAM_ALL:
273 default:
274 AUDIO_ERR_LOG("IsStreamActive: volumeType=%{public}d not supported", volumeType);
275 return false;
276 }
277
278 AudioStreamType StreamVolType = (AudioStreamType)volumeType;
279 return AudioPolicyManager::GetInstance().IsStreamActive(StreamVolType);
280 }
281
GetAudioParameter(const std::string key)282 const std::string AudioSystemManager::GetAudioParameter(const std::string key)
283 {
284 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
285 if (gasp == nullptr) {
286 AUDIO_ERR_LOG("GetAudioParameter::Audio service unavailable.");
287 return nullptr;
288 }
289 return gasp->GetAudioParameter(key);
290 }
291
SetAudioParameter(const std::string & key,const std::string & value)292 void AudioSystemManager::SetAudioParameter(const std::string &key, const std::string &value)
293 {
294 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
295 if (gasp == nullptr) {
296 AUDIO_ERR_LOG("SetAudioParameter::Audio service unavailable.");
297 return;
298 }
299 gasp->SetAudioParameter(key, value);
300 }
301
RetrieveCookie(int32_t & size)302 const char *AudioSystemManager::RetrieveCookie(int32_t &size)
303 {
304 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
305 if (gasp == nullptr) {
306 AUDIO_ERR_LOG("RetrieveCookie::Audio service unavailable.");
307 return nullptr;
308 }
309 return gasp->RetrieveCookie(size);
310 }
311
GetTransactionId(DeviceType deviceType,DeviceRole deviceRole)312 uint64_t AudioSystemManager::GetTransactionId(DeviceType deviceType, DeviceRole deviceRole)
313 {
314 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
315 if (gasp == nullptr) {
316 AUDIO_ERR_LOG("GetTransactionId::Audio service unavailable.");
317 return 0;
318 }
319 return gasp->GetTransactionId(deviceType, deviceRole);
320 }
321
SetVolume(AudioVolumeType volumeType,int32_t volumeLevel) const322 int32_t AudioSystemManager::SetVolume(AudioVolumeType volumeType, int32_t volumeLevel) const
323 {
324 AUDIO_DEBUG_LOG("SetVolume volumeType[%{public}d], volumeLevel[%{public}d]", volumeType, volumeLevel);
325
326 /* Validate volumeType and return INVALID_PARAMS error */
327 switch (volumeType) {
328 case STREAM_VOICE_CALL:
329 case STREAM_RING:
330 case STREAM_MUSIC:
331 case STREAM_ALARM:
332 case STREAM_ACCESSIBILITY:
333 case STREAM_VOICE_ASSISTANT:
334 break;
335 case STREAM_ULTRASONIC:
336 case STREAM_ALL:
337 if (!PermissionUtil::VerifySelfPermission()) {
338 AUDIO_ERR_LOG("SetVolume: No system permission");
339 return ERR_PERMISSION_DENIED;
340 }
341 break;
342 default:
343 AUDIO_ERR_LOG("SetVolume: volumeType[%{public}d] is not supported", volumeType);
344 return ERR_NOT_SUPPORTED;
345 }
346
347 /* Call Audio Policy SetSystemVolumeLevel */
348 AudioStreamType StreamVolType = (AudioStreamType)volumeType;
349 return AudioPolicyManager::GetInstance().SetSystemVolumeLevel(StreamVolType, volumeLevel, API_7);
350 }
351
GetVolume(AudioVolumeType volumeType) const352 int32_t AudioSystemManager::GetVolume(AudioVolumeType volumeType) const
353 {
354 switch (volumeType) {
355 case STREAM_MUSIC:
356 case STREAM_RING:
357 case STREAM_NOTIFICATION:
358 case STREAM_VOICE_CALL:
359 case STREAM_VOICE_ASSISTANT:
360 case STREAM_ALARM:
361 case STREAM_ACCESSIBILITY:
362 break;
363 case STREAM_ULTRASONIC:
364 case STREAM_ALL:
365 if (!PermissionUtil::VerifySelfPermission()) {
366 AUDIO_ERR_LOG("SetMute: No system permission");
367 return ERR_PERMISSION_DENIED;
368 }
369 break;
370 default:
371 AUDIO_ERR_LOG("GetVolume volumeType = %{public}d not supported", volumeType);
372 return ERR_NOT_SUPPORTED;
373 }
374
375 AudioStreamType streamVolType = (AudioStreamType)volumeType;
376 return AudioPolicyManager::GetInstance().GetSystemVolumeLevel(streamVolType);
377 }
378
SetLowPowerVolume(int32_t streamId,float volume) const379 int32_t AudioSystemManager::SetLowPowerVolume(int32_t streamId, float volume) const
380 {
381 AUDIO_INFO_LOG("AudioSystemManager SetLowPowerVolume, streamId:%{public}d, vol:%{public}f.", streamId, volume);
382 if ((volume < 0) || (volume > 1.0)) {
383 AUDIO_ERR_LOG("Invalid Volume Input!");
384 return ERR_INVALID_PARAM;
385 }
386
387 return AudioPolicyManager::GetInstance().SetLowPowerVolume(streamId, volume);
388 }
389
GetLowPowerVolume(int32_t streamId) const390 float AudioSystemManager::GetLowPowerVolume(int32_t streamId) const
391 {
392 return AudioPolicyManager::GetInstance().GetLowPowerVolume(streamId);
393 }
394
GetSingleStreamVolume(int32_t streamId) const395 float AudioSystemManager::GetSingleStreamVolume(int32_t streamId) const
396 {
397 return AudioPolicyManager::GetInstance().GetSingleStreamVolume(streamId);
398 }
399
GetMaxVolume(AudioVolumeType volumeType)400 int32_t AudioSystemManager::GetMaxVolume(AudioVolumeType volumeType)
401 {
402 if (volumeType == STREAM_ALL) {
403 if (!PermissionUtil::VerifySelfPermission()) {
404 AUDIO_ERR_LOG("GetMaxVolume: No system permission");
405 return ERR_PERMISSION_DENIED;
406 }
407 }
408
409 if (volumeType == STREAM_ULTRASONIC) {
410 if (!PermissionUtil::VerifySelfPermission()) {
411 AUDIO_ERR_LOG("GetMaxVolume: STREAM_ULTRASONIC No system permission");
412 return ERR_PERMISSION_DENIED;
413 }
414 }
415
416 return AudioPolicyManager::GetInstance().GetMaxVolumeLevel(volumeType);
417 }
418
GetMinVolume(AudioVolumeType volumeType)419 int32_t AudioSystemManager::GetMinVolume(AudioVolumeType volumeType)
420 {
421 if (volumeType == STREAM_ALL) {
422 if (!PermissionUtil::VerifySelfPermission()) {
423 AUDIO_ERR_LOG("GetMinVolume: No system permission");
424 return ERR_PERMISSION_DENIED;
425 }
426 }
427
428 if (volumeType == STREAM_ULTRASONIC) {
429 if (!PermissionUtil::VerifySelfPermission()) {
430 AUDIO_ERR_LOG("GetMinVolume: STREAM_ULTRASONIC No system permission");
431 return ERR_PERMISSION_DENIED;
432 }
433 }
434
435 return AudioPolicyManager::GetInstance().GetMinVolumeLevel(volumeType);
436 }
437
SetMute(AudioVolumeType volumeType,bool mute) const438 int32_t AudioSystemManager::SetMute(AudioVolumeType volumeType, bool mute) const
439 {
440 AUDIO_DEBUG_LOG("AudioSystemManager SetMute for volumeType=%{public}d", volumeType);
441 switch (volumeType) {
442 case STREAM_MUSIC:
443 case STREAM_RING:
444 case STREAM_NOTIFICATION:
445 case STREAM_VOICE_CALL:
446 case STREAM_VOICE_ASSISTANT:
447 case STREAM_ALARM:
448 case STREAM_ACCESSIBILITY:
449 break;
450 case STREAM_ULTRASONIC:
451 case STREAM_ALL:
452 if (!PermissionUtil::VerifySelfPermission()) {
453 AUDIO_ERR_LOG("SetMute: No system permission");
454 return ERR_PERMISSION_DENIED;
455 }
456 break;
457 default:
458 AUDIO_ERR_LOG("SetMute volumeType=%{public}d not supported", volumeType);
459 return ERR_NOT_SUPPORTED;
460 }
461
462 /* Call Audio Policy SetStreamMute */
463 AudioStreamType StreamVolType = (AudioStreamType)volumeType;
464 return AudioPolicyManager::GetInstance().SetStreamMute(StreamVolType, mute, API_7);
465 }
466
IsStreamMute(AudioVolumeType volumeType) const467 bool AudioSystemManager::IsStreamMute(AudioVolumeType volumeType) const
468 {
469 AUDIO_DEBUG_LOG("AudioSystemManager::GetMute Client");
470
471 switch (volumeType) {
472 case STREAM_MUSIC:
473 case STREAM_RING:
474 case STREAM_NOTIFICATION:
475 case STREAM_VOICE_CALL:
476 case STREAM_VOICE_ASSISTANT:
477 case STREAM_ALARM:
478 case STREAM_ACCESSIBILITY:
479 break;
480 case STREAM_ULTRASONIC:
481 case STREAM_ALL:
482 if (!PermissionUtil::VerifySelfPermission()) {
483 AUDIO_ERR_LOG("IsStreamMute: No system permission");
484 return ERR_PERMISSION_DENIED;
485 }
486 break;
487 default:
488 AUDIO_ERR_LOG("IsStreamMute volumeType=%{public}d not supported", volumeType);
489 return false;
490 }
491
492 AudioStreamType StreamVolType = (AudioStreamType)volumeType;
493 return AudioPolicyManager::GetInstance().GetStreamMute(StreamVolType);
494 }
495
SetDeviceChangeCallback(const DeviceFlag flag,const std::shared_ptr<AudioManagerDeviceChangeCallback> & callback)496 int32_t AudioSystemManager::SetDeviceChangeCallback(const DeviceFlag flag,
497 const std::shared_ptr<AudioManagerDeviceChangeCallback>& callback)
498 {
499 AUDIO_INFO_LOG("Entered %{public}s", __func__);
500 if (callback == nullptr) {
501 AUDIO_ERR_LOG("SetDeviceChangeCallback: callback is nullptr");
502 return ERR_INVALID_PARAM;
503 }
504
505 int32_t clientId = static_cast<int32_t>(GetCallingPid());
506 return AudioPolicyManager::GetInstance().SetDeviceChangeCallback(clientId, flag, callback);
507 }
508
UnsetDeviceChangeCallback(DeviceFlag flag)509 int32_t AudioSystemManager::UnsetDeviceChangeCallback(DeviceFlag flag)
510 {
511 AUDIO_INFO_LOG("Entered %{public}s", __func__);
512 int32_t clientId = static_cast<int32_t>(GetCallingPid());
513 return AudioPolicyManager::GetInstance().UnsetDeviceChangeCallback(clientId, flag);
514 }
515
SetRingerModeCallback(const int32_t clientId,const std::shared_ptr<AudioRingerModeCallback> & callback)516 int32_t AudioSystemManager::SetRingerModeCallback(const int32_t clientId,
517 const std::shared_ptr<AudioRingerModeCallback> &callback)
518 {
519 std::lock_guard<std::mutex> lockSet(ringerModeCallbackMutex_);
520 if (!PermissionUtil::VerifySelfPermission()) {
521 AUDIO_ERR_LOG("SetRingerModeCallback: No system permission");
522 return ERR_PERMISSION_DENIED;
523 }
524 if (callback == nullptr) {
525 AUDIO_ERR_LOG("AudioSystemManager: callback is nullptr");
526 return ERR_INVALID_PARAM;
527 }
528
529 cbClientId_ = clientId;
530 ringerModeCallback_ = callback;
531
532 return SUCCESS;
533 }
534
UnsetRingerModeCallback(const int32_t clientId) const535 int32_t AudioSystemManager::UnsetRingerModeCallback(const int32_t clientId) const
536 {
537 if (clientId != cbClientId_) {
538 return ERR_INVALID_OPERATION;
539 }
540
541 return SUCCESS;
542 }
543
SetMicrophoneMute(bool isMute)544 int32_t AudioSystemManager::SetMicrophoneMute(bool isMute)
545 {
546 return AudioPolicyManager::GetInstance().SetMicrophoneMute(isMute);
547 }
548
IsMicrophoneMute(API_VERSION api_v)549 bool AudioSystemManager::IsMicrophoneMute(API_VERSION api_v)
550 {
551 std::shared_ptr<AudioGroupManager> groupManager = GetGroupManager(DEFAULT_VOLUME_GROUP_ID);
552 if (groupManager == nullptr) {
553 AUDIO_ERR_LOG("IsMicrophoneMute failed, groupManager is null");
554 return false;
555 }
556 return groupManager->IsMicrophoneMute(api_v);
557 }
558
SelectOutputDevice(std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const559 int32_t AudioSystemManager::SelectOutputDevice(std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
560 {
561 if (audioDeviceDescriptors.size() != 1 || audioDeviceDescriptors[0] == nullptr) {
562 AUDIO_ERR_LOG("SelectOutputDevice: invalid parameter");
563 return ERR_INVALID_PARAM;
564 }
565 if (audioDeviceDescriptors[0]->deviceRole_ != DeviceRole::OUTPUT_DEVICE) {
566 AUDIO_ERR_LOG("SelectOutputDevice: not an output device.");
567 return ERR_INVALID_OPERATION;
568 }
569 size_t validSize = 64;
570 if (audioDeviceDescriptors[0]->networkId_ != LOCAL_NETWORK_ID &&
571 audioDeviceDescriptors[0]->networkId_.size() != validSize) {
572 AUDIO_ERR_LOG("SelectOutputDevice: invalid networkId.");
573 return ERR_INVALID_PARAM;
574 }
575 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
576 audioRendererFilter->uid = -1;
577 int32_t ret = AudioPolicyManager::GetInstance().SelectOutputDevice(audioRendererFilter, audioDeviceDescriptors);
578 return ret;
579 }
580
SelectInputDevice(std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const581 int32_t AudioSystemManager::SelectInputDevice(std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
582 {
583 if (audioDeviceDescriptors.size() != 1 || audioDeviceDescriptors[0] == nullptr) {
584 AUDIO_ERR_LOG("SelectInputDevice: invalid parameter");
585 return ERR_INVALID_PARAM;
586 }
587 if (audioDeviceDescriptors[0]->deviceRole_ != DeviceRole::INPUT_DEVICE) {
588 AUDIO_ERR_LOG("SelectInputDevice: not an output device.");
589 return ERR_INVALID_OPERATION;
590 }
591 sptr<AudioCapturerFilter> audioCapturerFilter = new(std::nothrow) AudioCapturerFilter();
592 audioCapturerFilter->uid = -1;
593 int32_t ret = AudioPolicyManager::GetInstance().SelectInputDevice(audioCapturerFilter, audioDeviceDescriptors);
594 return ret;
595 }
596
GetSelectedDeviceInfo(int32_t uid,int32_t pid,AudioStreamType streamType) const597 std::string AudioSystemManager::GetSelectedDeviceInfo(int32_t uid, int32_t pid, AudioStreamType streamType) const
598 {
599 return AudioPolicyManager::GetInstance().GetSelectedDeviceInfo(uid, pid, streamType);
600 }
601
SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter,std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const602 int32_t AudioSystemManager::SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter,
603 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
604 {
605 // basic check
606 if (audioRendererFilter == nullptr || audioDeviceDescriptors.size() == 0) {
607 AUDIO_ERR_LOG("SelectOutputDevice: invalid parameter");
608 return ERR_INVALID_PARAM;
609 }
610
611 size_t validDeviceSize = 1;
612 if (audioDeviceDescriptors.size() > validDeviceSize || audioDeviceDescriptors[0] == nullptr) {
613 AUDIO_ERR_LOG("SelectOutputDevice: device error");
614 return ERR_INVALID_OPERATION;
615 }
616 audioRendererFilter->streamType = AudioSystemManager::GetStreamType(audioRendererFilter->rendererInfo.contentType,
617 audioRendererFilter->rendererInfo.streamUsage);
618 // operation chack
619 if (audioDeviceDescriptors[0]->deviceRole_ != DeviceRole::OUTPUT_DEVICE) {
620 AUDIO_ERR_LOG("SelectOutputDevice: not an output device.");
621 return ERR_INVALID_OPERATION;
622 }
623 size_t validSize = 64;
624 if (audioDeviceDescriptors[0]->networkId_ != LOCAL_NETWORK_ID &&
625 audioDeviceDescriptors[0]->networkId_.size() != validSize) {
626 AUDIO_ERR_LOG("SelectOutputDevice: invalid networkId.");
627 return ERR_INVALID_PARAM;
628 }
629 if (audioRendererFilter->uid < 0) {
630 AUDIO_ERR_LOG("SelectOutputDevice: invalid uid.");
631 return ERR_INVALID_PARAM;
632 }
633 AUDIO_DEBUG_LOG("[%{public}d] SelectOutputDevice: uid<%{public}d> streamType<%{public}d> device<name:%{public}s>",
634 getpid(), audioRendererFilter->uid, static_cast<int32_t>(audioRendererFilter->streamType),
635 (audioDeviceDescriptors[0]->networkId_.c_str()));
636
637 return AudioPolicyManager::GetInstance().SelectOutputDevice(audioRendererFilter, audioDeviceDescriptors);
638 }
639
SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter,std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const640 int32_t AudioSystemManager::SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter,
641 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
642 {
643 // basic check
644 if (audioCapturerFilter == nullptr || audioDeviceDescriptors.size() == 0) {
645 AUDIO_ERR_LOG("SelectInputDevice: invalid parameter");
646 return ERR_INVALID_PARAM;
647 }
648
649 size_t validDeviceSize = 1;
650 if (audioDeviceDescriptors.size() > validDeviceSize || audioDeviceDescriptors[0] == nullptr) {
651 AUDIO_ERR_LOG("SelectInputDevice: device error.");
652 return ERR_INVALID_OPERATION;
653 }
654 // operation chack
655 if (audioDeviceDescriptors[0]->deviceRole_ != DeviceRole::INPUT_DEVICE) {
656 AUDIO_ERR_LOG("SelectInputDevice: not an input device");
657 return ERR_INVALID_OPERATION;
658 }
659 if (audioCapturerFilter->uid < 0) {
660 AUDIO_ERR_LOG("SelectInputDevice: invalid uid.");
661 return ERR_INVALID_PARAM;
662 }
663 AUDIO_DEBUG_LOG("[%{public}d] SelectInputDevice: uid<%{public}d> device<type:%{public}d>",
664 getpid(), audioCapturerFilter->uid, static_cast<int32_t>(audioDeviceDescriptors[0]->deviceType_));
665
666 return AudioPolicyManager::GetInstance().SelectInputDevice(audioCapturerFilter, audioDeviceDescriptors);
667 }
668
GetDevices(DeviceFlag deviceFlag)669 std::vector<sptr<AudioDeviceDescriptor>> AudioSystemManager::GetDevices(DeviceFlag deviceFlag)
670 {
671 return AudioPolicyManager::GetInstance().GetDevices(deviceFlag);
672 }
673
GetActiveOutputDeviceDescriptors()674 std::vector<sptr<AudioDeviceDescriptor>> AudioSystemManager::GetActiveOutputDeviceDescriptors()
675 {
676 AudioRendererInfo rendererInfo;
677 return AudioPolicyManager::GetInstance().GetPreferredOutputDeviceDescriptors(rendererInfo);
678 }
679
680
GetAudioFocusInfoList(std::list<std::pair<AudioInterrupt,AudioFocuState>> & focusInfoList)681 int32_t AudioSystemManager::GetAudioFocusInfoList(std::list<std::pair<AudioInterrupt, AudioFocuState>> &focusInfoList)
682 {
683 AUDIO_DEBUG_LOG("Entered %{public}s", __func__);
684 return AudioPolicyManager::GetInstance().GetAudioFocusInfoList(focusInfoList);
685 }
686
RegisterFocusInfoChangeCallback(const std::shared_ptr<AudioFocusInfoChangeCallback> & callback)687 int32_t AudioSystemManager::RegisterFocusInfoChangeCallback(
688 const std::shared_ptr<AudioFocusInfoChangeCallback> &callback)
689 {
690 if (callback == nullptr) {
691 AUDIO_ERR_LOG("AudioSystemManager::callback is null");
692 return ERR_INVALID_PARAM;
693 }
694
695 int32_t clientId = GetCallingPid();
696 AUDIO_DEBUG_LOG("RegisterFocusInfoChangeCallback clientId:%{public}d", clientId);
697 if (audioFocusInfoCallback_ == nullptr) {
698 audioFocusInfoCallback_ = std::make_shared<AudioFocusInfoChangeCallbackImpl>();
699 if (audioFocusInfoCallback_ == nullptr) {
700 AUDIO_ERR_LOG("AudioSystemManager::Failed to allocate memory for audioInterruptCallback");
701 return ERROR;
702 }
703 int32_t ret = AudioPolicyManager::GetInstance().RegisterFocusInfoChangeCallback(clientId,
704 audioFocusInfoCallback_);
705 if (ret != SUCCESS) {
706 AUDIO_ERR_LOG("AudioSystemManager::Failed set callback");
707 return ERROR;
708 }
709 }
710
711 std::shared_ptr<AudioFocusInfoChangeCallbackImpl> cbFocusInfo =
712 std::static_pointer_cast<AudioFocusInfoChangeCallbackImpl>(audioFocusInfoCallback_);
713 if (cbFocusInfo == nullptr) {
714 AUDIO_ERR_LOG("AudioSystemManager::cbFocusInfo is nullptr");
715 return ERROR;
716 }
717 cbFocusInfo->SaveCallback(callback);
718
719 return SUCCESS;
720 }
721
UnregisterFocusInfoChangeCallback(const std::shared_ptr<AudioFocusInfoChangeCallback> & callback)722 int32_t AudioSystemManager::UnregisterFocusInfoChangeCallback(
723 const std::shared_ptr<AudioFocusInfoChangeCallback> &callback)
724 {
725 int32_t clientId = GetCallingPid();
726 int32_t ret = 0;
727
728 if (callback == nullptr) {
729 ret = AudioPolicyManager::GetInstance().UnregisterFocusInfoChangeCallback(clientId);
730 audioFocusInfoCallback_.reset();
731 audioFocusInfoCallback_ = nullptr;
732 if (!ret) {
733 AUDIO_DEBUG_LOG("AudioSystemManager::UnregisterVolumeKeyEventCallback success");
734 }
735 return ret;
736 }
737 if (audioFocusInfoCallback_ == nullptr) {
738 AUDIO_ERR_LOG("Failed to allocate memory for audioInterruptCallback");
739 return ERROR;
740 }
741 std::shared_ptr<AudioFocusInfoChangeCallbackImpl> cbFocusInfo =
742 std::static_pointer_cast<AudioFocusInfoChangeCallbackImpl>(audioFocusInfoCallback_);
743 cbFocusInfo->RemoveCallback(callback);
744
745 return ret;
746 }
747
AudioFocusInfoChangeCallbackImpl()748 AudioFocusInfoChangeCallbackImpl::AudioFocusInfoChangeCallbackImpl()
749 {
750 AUDIO_INFO_LOG("AudioFocusInfoChangeCallbackImpl constructor");
751 }
752
~AudioFocusInfoChangeCallbackImpl()753 AudioFocusInfoChangeCallbackImpl::~AudioFocusInfoChangeCallbackImpl()
754 {
755 AUDIO_INFO_LOG("AudioFocusInfoChangeCallbackImpl: destroy");
756 }
757
SaveCallback(const std::weak_ptr<AudioFocusInfoChangeCallback> & callback)758 void AudioFocusInfoChangeCallbackImpl::SaveCallback(const std::weak_ptr<AudioFocusInfoChangeCallback> &callback)
759 {
760 AUDIO_INFO_LOG("Entered %{public}s", __func__);
761 bool hasCallback = false;
762 for (auto it = callbackList_.begin(); it != callbackList_.end(); ++it) {
763 if ((*it).lock() == callback.lock()) {
764 hasCallback = true;
765 }
766 }
767 if (!hasCallback) {
768 callbackList_.push_back(callback);
769 }
770 }
771
RemoveCallback(const std::weak_ptr<AudioFocusInfoChangeCallback> & callback)772 void AudioFocusInfoChangeCallbackImpl::RemoveCallback(const std::weak_ptr<AudioFocusInfoChangeCallback> &callback)
773 {
774 AUDIO_INFO_LOG("Entered %{public}s", __func__);
775 callbackList_.remove_if([&callback](std::weak_ptr<AudioFocusInfoChangeCallback> &callback_) {
776 return callback_.lock() == callback.lock();
777 });
778 }
779
OnAudioFocusInfoChange(const std::list<std::pair<AudioInterrupt,AudioFocuState>> & focusInfoList)780 void AudioFocusInfoChangeCallbackImpl::OnAudioFocusInfoChange(
781 const std::list<std::pair<AudioInterrupt, AudioFocuState>> &focusInfoList)
782 {
783 AUDIO_DEBUG_LOG("on callback Entered AudioFocusInfoChangeCallbackImpl %{public}s", __func__);
784
785 for (auto callback = callbackList_.begin(); callback != callbackList_.end(); ++callback) {
786 cb_ = (*callback).lock();
787 if (cb_ != nullptr) {
788 AUDIO_DEBUG_LOG("OnAudioFocusInfoChange : Notify event to app complete");
789 cb_->OnAudioFocusInfoChange(focusInfoList);
790 } else {
791 AUDIO_ERR_LOG("OnAudioFocusInfoChange: callback is null");
792 }
793 }
794 return;
795 }
796
RegisterVolumeKeyEventCallback(const int32_t clientPid,const std::shared_ptr<VolumeKeyEventCallback> & callback,API_VERSION api_v)797 int32_t AudioSystemManager::RegisterVolumeKeyEventCallback(const int32_t clientPid,
798 const std::shared_ptr<VolumeKeyEventCallback> &callback, API_VERSION api_v)
799 {
800 AUDIO_DEBUG_LOG("AudioSystemManager RegisterVolumeKeyEventCallback");
801
802 if (callback == nullptr) {
803 AUDIO_ERR_LOG("AudioSystemManager::RegisterVolumeKeyEventCallbackcallback is nullptr");
804 return ERR_INVALID_PARAM;
805 }
806 volumeChangeClientPid_ = clientPid;
807
808 return AudioPolicyManager::GetInstance().SetVolumeKeyEventCallback(clientPid, callback, api_v);
809 }
810
UnregisterVolumeKeyEventCallback(const int32_t clientPid)811 int32_t AudioSystemManager::UnregisterVolumeKeyEventCallback(const int32_t clientPid)
812 {
813 AUDIO_DEBUG_LOG("AudioSystemManager::UnregisterVolumeKeyEventCallback");
814 int32_t ret = AudioPolicyManager::GetInstance().UnsetVolumeKeyEventCallback(clientPid);
815 if (!ret) {
816 AUDIO_DEBUG_LOG("AudioSystemManager::UnregisterVolumeKeyEventCallback success");
817 volumeChangeClientPid_ = -1;
818 }
819
820 return ret;
821 }
822
SetAudioMonoState(bool monoState)823 void AudioSystemManager::SetAudioMonoState(bool monoState)
824 {
825 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
826 if (gasp == nullptr) {
827 AUDIO_ERR_LOG("SetAudioMonoState::Audio service unavailable.");
828 return;
829 }
830 gasp->SetAudioMonoState(monoState);
831 }
832
SetAudioBalanceValue(float balanceValue)833 void AudioSystemManager::SetAudioBalanceValue(float balanceValue)
834 {
835 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
836 if (gasp == nullptr) {
837 AUDIO_ERR_LOG("SetAudioBalanceValue::Audio service unavailable.");
838 return;
839 }
840 gasp->SetAudioBalanceValue(balanceValue);
841 }
842
SetSystemSoundUri(const std::string & key,const std::string & uri)843 int32_t AudioSystemManager::SetSystemSoundUri(const std::string &key, const std::string &uri)
844 {
845 return AudioPolicyManager::GetInstance().SetSystemSoundUri(key, uri);
846 }
847
GetSystemSoundUri(const std::string & key)848 std::string AudioSystemManager::GetSystemSoundUri(const std::string &key)
849 {
850 return AudioPolicyManager::GetInstance().GetSystemSoundUri(key);
851 }
852
853 // Below stub implementation is added to handle compilation error in call manager
854 // Once call manager adapt to new interrupt implementation, this will be removed
SetAudioManagerCallback(const AudioVolumeType streamType,const std::shared_ptr<AudioManagerCallback> & callback)855 int32_t AudioSystemManager::SetAudioManagerCallback(const AudioVolumeType streamType,
856 const std::shared_ptr<AudioManagerCallback> &callback)
857 {
858 AUDIO_DEBUG_LOG("AudioSystemManager SetAudioManagerCallback stub implementation");
859 return SUCCESS;
860 }
861
UnsetAudioManagerCallback(const AudioVolumeType streamType) const862 int32_t AudioSystemManager::UnsetAudioManagerCallback(const AudioVolumeType streamType) const
863 {
864 AUDIO_DEBUG_LOG("AudioSystemManager UnsetAudioManagerCallback stub implementation");
865 return SUCCESS;
866 }
867
ActivateAudioInterrupt(const AudioInterrupt & audioInterrupt)868 int32_t AudioSystemManager::ActivateAudioInterrupt(const AudioInterrupt &audioInterrupt)
869 {
870 AUDIO_DEBUG_LOG("AudioSystemManager ActivateAudioInterrupt stub implementation");
871 return SUCCESS;
872 }
873
DeactivateAudioInterrupt(const AudioInterrupt & audioInterrupt) const874 int32_t AudioSystemManager::DeactivateAudioInterrupt(const AudioInterrupt &audioInterrupt) const
875 {
876 AUDIO_DEBUG_LOG("AudioSystemManager DeactivateAudioInterrupt stub implementation");
877 return SUCCESS;
878 }
879
SetAudioManagerInterruptCallback(const std::shared_ptr<AudioManagerCallback> & callback)880 int32_t AudioSystemManager::SetAudioManagerInterruptCallback(const std::shared_ptr<AudioManagerCallback> &callback)
881 {
882 int32_t clientId = GetCallingPid();
883 AUDIO_INFO_LOG("SetAudioManagerInterruptCallback client id: %{public}d", clientId);
884 if (callback == nullptr) {
885 AUDIO_ERR_LOG("AudioSystemManager::callback is null");
886 return ERR_INVALID_PARAM;
887 }
888
889 if (audioInterruptCallback_ != nullptr) {
890 AUDIO_DEBUG_LOG("AudioSystemManager reset existing callback object");
891 AudioPolicyManager::GetInstance().UnsetAudioManagerInterruptCallback(clientId);
892 audioInterruptCallback_.reset();
893 audioInterruptCallback_ = nullptr;
894 }
895
896 audioInterruptCallback_ = std::make_shared<AudioManagerInterruptCallbackImpl>();
897 if (audioInterruptCallback_ == nullptr) {
898 AUDIO_ERR_LOG("AudioSystemManager::Failed to allocate memory for audioInterruptCallback");
899 return ERROR;
900 }
901
902 int32_t ret = AudioPolicyManager::GetInstance().SetAudioManagerInterruptCallback(clientId, audioInterruptCallback_);
903 if (ret != SUCCESS) {
904 AUDIO_ERR_LOG("AudioSystemManager::Failed set callback");
905 return ERROR;
906 }
907
908 std::shared_ptr<AudioManagerInterruptCallbackImpl> cbInterrupt =
909 std::static_pointer_cast<AudioManagerInterruptCallbackImpl>(audioInterruptCallback_);
910 if (cbInterrupt == nullptr) {
911 AUDIO_ERR_LOG("AudioSystemManager::cbInterrupt is nullptr");
912 return ERROR;
913 }
914 cbInterrupt->SaveCallback(callback);
915
916 return SUCCESS;
917 }
918
UnsetAudioManagerInterruptCallback()919 int32_t AudioSystemManager::UnsetAudioManagerInterruptCallback()
920 {
921 int32_t clientId = GetCallingPid();
922 AUDIO_INFO_LOG("UnsetAudioManagerInterruptCallback client id: %{public}d", clientId);
923
924 int32_t ret = AudioPolicyManager::GetInstance().UnsetAudioManagerInterruptCallback(clientId);
925 if (audioInterruptCallback_ != nullptr) {
926 audioInterruptCallback_.reset();
927 audioInterruptCallback_ = nullptr;
928 }
929
930 return ret;
931 }
932
RequestAudioFocus(const AudioInterrupt & audioInterrupt)933 int32_t AudioSystemManager::RequestAudioFocus(const AudioInterrupt &audioInterrupt)
934 {
935 int32_t clientId = GetCallingPid();
936 AUDIO_INFO_LOG("RequestAudioFocus client id: %{public}d", clientId);
937 CHECK_AND_RETURN_RET_LOG(audioInterrupt.contentType >= CONTENT_TYPE_UNKNOWN &&
938 audioInterrupt.contentType <= CONTENT_TYPE_ULTRASONIC, ERR_INVALID_PARAM, "Invalid content type");
939 CHECK_AND_RETURN_RET_LOG(audioInterrupt.streamUsage >= STREAM_USAGE_UNKNOWN &&
940 audioInterrupt.streamUsage <= STREAM_USAGE_ULTRASONIC, ERR_INVALID_PARAM, "Invalid stream usage");
941 CHECK_AND_RETURN_RET_LOG(audioInterrupt.audioFocusType.streamType >= STREAM_VOICE_CALL &&
942 audioInterrupt.audioFocusType.streamType <= STREAM_TYPE_MAX, ERR_INVALID_PARAM, "Invalid stream type");
943 return AudioPolicyManager::GetInstance().RequestAudioFocus(clientId, audioInterrupt);
944 }
945
AbandonAudioFocus(const AudioInterrupt & audioInterrupt)946 int32_t AudioSystemManager::AbandonAudioFocus(const AudioInterrupt &audioInterrupt)
947 {
948 int32_t clientId = GetCallingPid();
949 AUDIO_INFO_LOG("AbandonAudioFocus client id: %{public}d", clientId);
950 CHECK_AND_RETURN_RET_LOG(audioInterrupt.contentType >= CONTENT_TYPE_UNKNOWN &&
951 audioInterrupt.contentType <= CONTENT_TYPE_ULTRASONIC, ERR_INVALID_PARAM, "Invalid content type");
952 CHECK_AND_RETURN_RET_LOG(audioInterrupt.streamUsage >= STREAM_USAGE_UNKNOWN &&
953 audioInterrupt.streamUsage <= STREAM_USAGE_ULTRASONIC, ERR_INVALID_PARAM, "Invalid stream usage");
954 CHECK_AND_RETURN_RET_LOG(audioInterrupt.audioFocusType.streamType >= STREAM_VOICE_CALL &&
955 audioInterrupt.audioFocusType.streamType <= STREAM_TYPE_MAX, ERR_INVALID_PARAM, "Invalid stream type");
956 return AudioPolicyManager::GetInstance().AbandonAudioFocus(clientId, audioInterrupt);
957 }
958
ReconfigureAudioChannel(const uint32_t & count,DeviceType deviceType)959 int32_t AudioSystemManager::ReconfigureAudioChannel(const uint32_t &count, DeviceType deviceType)
960 {
961 return AudioPolicyManager::GetInstance().ReconfigureAudioChannel(count, deviceType);
962 }
963
GetVolumeGroups(std::string networkId,std::vector<sptr<VolumeGroupInfo>> & infos)964 int32_t AudioSystemManager::GetVolumeGroups(std::string networkId, std::vector<sptr<VolumeGroupInfo>> &infos)
965 {
966 return AudioPolicyManager::GetInstance().GetVolumeGroupInfos(networkId, infos);
967 }
968
GetGroupManager(int32_t groupId)969 std::shared_ptr<AudioGroupManager> AudioSystemManager::GetGroupManager(int32_t groupId)
970 {
971 std::vector<std::shared_ptr<AudioGroupManager>>::iterator iter = groupManagerMap_.begin();
972 while (iter != groupManagerMap_.end()) {
973 if ((*iter)->GetGroupId() == groupId) {
974 return *iter;
975 } else {
976 iter++;
977 }
978 }
979
980 std::shared_ptr<AudioGroupManager> groupManager = std::make_shared<AudioGroupManager>(groupId);
981 if (groupManager->Init() == SUCCESS) {
982 groupManagerMap_.push_back(groupManager);
983 } else {
984 groupManager = nullptr;
985 }
986 return groupManager;
987 }
988
AudioManagerInterruptCallbackImpl()989 AudioManagerInterruptCallbackImpl::AudioManagerInterruptCallbackImpl()
990 {
991 AUDIO_INFO_LOG("AudioManagerInterruptCallbackImpl constructor");
992 }
993
~AudioManagerInterruptCallbackImpl()994 AudioManagerInterruptCallbackImpl::~AudioManagerInterruptCallbackImpl()
995 {
996 AUDIO_DEBUG_LOG("AudioManagerInterruptCallbackImpl: instance destroy");
997 }
998
SaveCallback(const std::weak_ptr<AudioManagerCallback> & callback)999 void AudioManagerInterruptCallbackImpl::SaveCallback(const std::weak_ptr<AudioManagerCallback> &callback)
1000 {
1001 auto wp = callback.lock();
1002 if (wp != nullptr) {
1003 callback_ = callback;
1004 } else {
1005 AUDIO_ERR_LOG("AudioManagerInterruptCallbackImpl::SaveCallback: callback is nullptr");
1006 }
1007 }
1008
OnInterrupt(const InterruptEventInternal & interruptEvent)1009 void AudioManagerInterruptCallbackImpl::OnInterrupt(const InterruptEventInternal &interruptEvent)
1010 {
1011 cb_ = callback_.lock();
1012 if (cb_ != nullptr) {
1013 InterruptAction interruptAction = {};
1014 interruptAction.actionType = (interruptEvent.eventType == INTERRUPT_TYPE_BEGIN)
1015 ? TYPE_INTERRUPT : TYPE_ACTIVATED;
1016 interruptAction.interruptType = interruptEvent.eventType;
1017 interruptAction.interruptHint = interruptEvent.hintType;
1018 interruptAction.activated = (interruptEvent.eventType == INTERRUPT_TYPE_BEGIN) ? false : true;
1019 cb_->OnInterrupt(interruptAction);
1020 AUDIO_DEBUG_LOG("AudioManagerInterruptCallbackImpl: OnInterrupt : Notify event to app complete");
1021 } else {
1022 AUDIO_ERR_LOG("AudioManagerInterruptCallbackImpl: callback is null");
1023 }
1024
1025 return;
1026 }
1027
RequestIndependentInterrupt(FocusType focusType)1028 bool AudioSystemManager::RequestIndependentInterrupt(FocusType focusType)
1029 {
1030 AUDIO_INFO_LOG("RequestIndependentInterrupt : foncusType");
1031 AudioInterrupt audioInterrupt;
1032 int32_t clientId = GetCallingPid();
1033 audioInterrupt.contentType = ContentType::CONTENT_TYPE_SPEECH;
1034 audioInterrupt.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
1035 audioInterrupt.audioFocusType.streamType = AudioStreamType::STREAM_RECORDING;
1036 audioInterrupt.sessionID = clientId;
1037 int32_t result = AudioPolicyManager::GetInstance().ActivateAudioInterrupt(audioInterrupt);
1038
1039 AUDIO_DEBUG_LOG("RequestIndependentInterrupt : result -> %{public}d", result);
1040 return (result == SUCCESS) ? true:false;
1041 }
AbandonIndependentInterrupt(FocusType focusType)1042 bool AudioSystemManager::AbandonIndependentInterrupt(FocusType focusType)
1043 {
1044 AUDIO_INFO_LOG("AbandonIndependentInterrupt : foncusType");
1045 AudioInterrupt audioInterrupt;
1046 int32_t clientId = GetCallingPid();
1047 audioInterrupt.contentType = ContentType::CONTENT_TYPE_SPEECH;
1048 audioInterrupt.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
1049 audioInterrupt.audioFocusType.streamType = AudioStreamType::STREAM_RECORDING;
1050 audioInterrupt.sessionID = clientId;
1051 int32_t result = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt);
1052 AUDIO_DEBUG_LOG("AbandonIndependentInterrupt : result -> %{public}d", result);
1053 return (result == SUCCESS) ? true:false;
1054 }
1055
GetAudioLatencyFromXml() const1056 int32_t AudioSystemManager::GetAudioLatencyFromXml() const
1057 {
1058 return AudioPolicyManager::GetInstance().GetAudioLatencyFromXml();
1059 }
1060
GetSinkLatencyFromXml() const1061 uint32_t AudioSystemManager::GetSinkLatencyFromXml() const
1062 {
1063 return AudioPolicyManager::GetInstance().GetSinkLatencyFromXml();
1064 }
1065
UpdateStreamState(const int32_t clientUid,StreamSetState streamSetState,AudioStreamType audioStreamType)1066 int32_t AudioSystemManager::UpdateStreamState(const int32_t clientUid,
1067 StreamSetState streamSetState, AudioStreamType audioStreamType)
1068 {
1069 AUDIO_INFO_LOG("UpdateStreamState::clientUid:%{public}d streamSetState:%{public}d",
1070 clientUid, streamSetState);
1071 int32_t result = 0;
1072
1073 result = AudioPolicyManager::GetInstance().UpdateStreamState(clientUid, streamSetState, audioStreamType);
1074 return result;
1075 }
1076
GetSelfBundleName()1077 std::string AudioSystemManager::GetSelfBundleName()
1078 {
1079 std::string bundleName = "";
1080
1081 sptr<ISystemAbilityManager> systemAbilityManager =
1082 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1083 sptr<OHOS::IRemoteObject> remoteObject =
1084 systemAbilityManager->CheckSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
1085 sptr<AppExecFwk::IBundleMgr> iBundleMgr = iface_cast<AppExecFwk::IBundleMgr>(remoteObject);
1086 if (iBundleMgr == nullptr) {
1087 AUDIO_ERR_LOG("bundlemgr interface is null");
1088 return bundleName;
1089 }
1090
1091 AppExecFwk::BundleInfo bundleInfo;
1092 if (iBundleMgr->GetBundleInfoForSelf(0, bundleInfo) == ERR_OK) {
1093 bundleName = bundleInfo.name;
1094 } else {
1095 AUDIO_ERR_LOG("Get bundle info failed");
1096 }
1097 return bundleName;
1098 }
1099
RequestThreadPriority(uint32_t tid)1100 void AudioSystemManager::RequestThreadPriority(uint32_t tid)
1101 {
1102 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
1103 if (gasp == nullptr) {
1104 AUDIO_ERR_LOG("RequestThreadPriority Audio service unavailable.");
1105 return;
1106 }
1107 std::string bundleName = GetSelfBundleName();
1108 gasp->RequestThreadPriority(tid, bundleName);
1109 }
1110
GetPinValueFromType(DeviceType deviceType,DeviceRole deviceRole) const1111 AudioPin AudioSystemManager::GetPinValueFromType(DeviceType deviceType, DeviceRole deviceRole) const
1112 {
1113 AudioPin pin = AUDIO_PIN_NONE;
1114 switch (deviceType) {
1115 case OHOS::AudioStandard::DEVICE_TYPE_NONE:
1116 case OHOS::AudioStandard::DEVICE_TYPE_INVALID:
1117 pin = AUDIO_PIN_NONE;
1118 break;
1119 case OHOS::AudioStandard::DEVICE_TYPE_DEFAULT:
1120 if (deviceRole == DeviceRole::INPUT_DEVICE) {
1121 pin = AUDIO_PIN_IN_DAUDIO_DEFAULT;
1122 } else {
1123 pin = AUDIO_PIN_OUT_DAUDIO_DEFAULT;
1124 }
1125 break;
1126 case OHOS::AudioStandard::DEVICE_TYPE_SPEAKER:
1127 pin = AUDIO_PIN_OUT_SPEAKER;
1128 break;
1129 case OHOS::AudioStandard::DEVICE_TYPE_MIC:
1130 case OHOS::AudioStandard::DEVICE_TYPE_WAKEUP:
1131 pin = AUDIO_PIN_IN_MIC;
1132 break;
1133 case OHOS::AudioStandard::DEVICE_TYPE_WIRED_HEADSET:
1134 if (deviceRole == DeviceRole::INPUT_DEVICE) {
1135 pin = AUDIO_PIN_IN_HS_MIC;
1136 } else {
1137 pin = AUDIO_PIN_OUT_HEADSET;
1138 }
1139 break;
1140 case OHOS::AudioStandard::DEVICE_TYPE_USB_HEADSET:
1141 case OHOS::AudioStandard::DEVICE_TYPE_FILE_SINK:
1142 case OHOS::AudioStandard::DEVICE_TYPE_FILE_SOURCE:
1143 case OHOS::AudioStandard::DEVICE_TYPE_BLUETOOTH_SCO:
1144 case OHOS::AudioStandard::DEVICE_TYPE_BLUETOOTH_A2DP:
1145 case OHOS::AudioStandard::DEVICE_TYPE_MAX:
1146 AUDIO_INFO_LOG("GetPinValueFromType :don't supported the device type");
1147 break;
1148 default:
1149 AUDIO_INFO_LOG("GetPinValueFromType : invalid input parameter");
1150 break;
1151 }
1152 return pin;
1153 }
1154
GetTypeValueFromPin(AudioPin pin) const1155 DeviceType AudioSystemManager::GetTypeValueFromPin(AudioPin pin) const
1156 {
1157 DeviceType type = DEVICE_TYPE_NONE;
1158 switch (pin) {
1159 case OHOS::AudioStandard::AUDIO_PIN_NONE:
1160 type = DEVICE_TYPE_NONE;
1161 break;
1162 case OHOS::AudioStandard::AUDIO_PIN_OUT_SPEAKER:
1163 type = DEVICE_TYPE_SPEAKER;
1164 break;
1165 case OHOS::AudioStandard::AUDIO_PIN_OUT_HEADSET:
1166 break;
1167 case OHOS::AudioStandard::AUDIO_PIN_OUT_LINEOUT:
1168 break;
1169 case OHOS::AudioStandard::AUDIO_PIN_OUT_HDMI:
1170 break;
1171 case OHOS::AudioStandard::AUDIO_PIN_OUT_USB:
1172 break;
1173 case OHOS::AudioStandard::AUDIO_PIN_OUT_USB_EXT:
1174 break;
1175 case OHOS::AudioStandard::AUDIO_PIN_OUT_DAUDIO_DEFAULT:
1176 type = DEVICE_TYPE_DEFAULT;
1177 break;
1178 case OHOS::AudioStandard::AUDIO_PIN_IN_MIC:
1179 type = DEVICE_TYPE_MIC;
1180 break;
1181 case OHOS::AudioStandard::AUDIO_PIN_IN_HS_MIC:
1182 type = DEVICE_TYPE_WIRED_HEADSET;
1183 break;
1184 case OHOS::AudioStandard::AUDIO_PIN_IN_LINEIN:
1185 break;
1186 case OHOS::AudioStandard::AUDIO_PIN_IN_USB_EXT:
1187 break;
1188 case OHOS::AudioStandard::AUDIO_PIN_IN_DAUDIO_DEFAULT:
1189 type = DEVICE_TYPE_DEFAULT;
1190 break;
1191 default:
1192 AUDIO_INFO_LOG("GetTypeValueFromPin : invalid input parameter");
1193 break;
1194 }
1195 return type;
1196 }
1197
RegisterWakeupSourceCallback()1198 int32_t AudioSystemManager::RegisterWakeupSourceCallback()
1199 {
1200 AUDIO_INFO_LOG("RegisterWakeupSourceCallback");
1201 remoteWakeUpCallback_ = std::make_shared<WakeUpCallbackImpl>(this);
1202
1203 auto wakeupCloseCbStub = new(std::nothrow) AudioManagerListenerStub();
1204 if (wakeupCloseCbStub == nullptr) {
1205 AUDIO_ERR_LOG("wakeupCloseCbStub is null");
1206 return ERROR;
1207 }
1208 wakeupCloseCbStub->SetWakeupSourceCallback(remoteWakeUpCallback_);
1209
1210 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
1211 if (gasp == nullptr) {
1212 AUDIO_ERR_LOG("GetAudioParameter::Audio service unavailable.");
1213 return ERROR;
1214 }
1215
1216 sptr<IRemoteObject> object = wakeupCloseCbStub->AsObject();
1217 if (object == nullptr) {
1218 AUDIO_ERR_LOG("SetWakeupCloseCallback listenerStub object is nullptr");
1219 delete wakeupCloseCbStub;
1220 return ERROR;
1221 }
1222 return gasp->SetWakeupSourceCallback(object);
1223 }
1224
SetAudioCapturerSourceCallback(const std::shared_ptr<AudioCapturerSourceCallback> & callback)1225 int32_t AudioSystemManager::SetAudioCapturerSourceCallback(const std::shared_ptr<AudioCapturerSourceCallback> &callback)
1226 {
1227 audioCapturerSourceCallback_ = callback;
1228 return isRemoteWakeUpCallbackRegistered.exchange(true) ? SUCCESS :
1229 RegisterWakeupSourceCallback();
1230 }
1231
SetWakeUpSourceCloseCallback(const std::shared_ptr<WakeUpSourceCloseCallback> & callback)1232 int32_t AudioSystemManager::SetWakeUpSourceCloseCallback(const std::shared_ptr<WakeUpSourceCloseCallback> &callback)
1233 {
1234 audioWakeUpSourceCloseCallback_ = callback;
1235 return isRemoteWakeUpCallbackRegistered.exchange(true) ? SUCCESS :
1236 RegisterWakeupSourceCallback();
1237 }
1238 } // namespace AudioStandard
1239 } // namespace OHOS
1240