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
21 #include "audio_log.h"
22 #include "audio_errors.h"
23 #include "audio_manager_proxy.h"
24 #include "audio_server_death_recipient.h"
25 #include "audio_stream.h"
26 #include "audio_policy_manager.h"
27 #include "audio_volume_key_event_callback_stub.h"
28
29 namespace OHOS {
30 namespace AudioStandard {
31 using namespace std;
32
33 const map<pair<ContentType, StreamUsage>, AudioStreamType> AudioSystemManager::streamTypeMap_
34 = AudioSystemManager::CreateStreamMap();
35 mutex g_asProxyMutex;
36 sptr<IStandardAudioService> g_asProxy = nullptr;
37
AudioSystemManager()38 AudioSystemManager::AudioSystemManager()
39 {
40 AUDIO_DEBUG_LOG("AudioSystemManager start");
41 }
42
~AudioSystemManager()43 AudioSystemManager::~AudioSystemManager()
44 {
45 AUDIO_DEBUG_LOG("AudioSystemManager::~AudioSystemManager");
46 if (cbClientId_ != -1) {
47 UnsetRingerModeCallback(cbClientId_);
48 }
49
50 if (volumeChangeClientPid_ != -1) {
51 AUDIO_DEBUG_LOG("AudioSystemManager::~AudioSystemManager UnregisterVolumeKeyEventCallback");
52 (void)UnregisterVolumeKeyEventCallback(volumeChangeClientPid_);
53 }
54 }
55
GetInstance()56 AudioSystemManager *AudioSystemManager::GetInstance()
57 {
58 static AudioSystemManager audioManager;
59 return &audioManager;
60 }
61
GetCallingPid()62 uint32_t AudioSystemManager::GetCallingPid()
63 {
64 return getpid();
65 }
66
CreateStreamMap()67 map<pair<ContentType, StreamUsage>, AudioStreamType> AudioSystemManager::CreateStreamMap()
68 {
69 map<pair<ContentType, StreamUsage>, AudioStreamType> streamMap;
70
71 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_UNKNOWN)] = AudioStreamType::STREAM_MUSIC;
72 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MEDIA)] = AudioStreamType::STREAM_MUSIC;
73 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_COMMUNICATION)] = AudioStreamType::STREAM_MUSIC;
74 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_ASSISTANT)] = AudioStreamType::STREAM_MUSIC;
75 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NOTIFICATION_RINGTONE)] = AudioStreamType::STREAM_MUSIC;
76
77 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_UNKNOWN)] = AudioStreamType::STREAM_MUSIC;
78 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_MEDIA)] = AudioStreamType::STREAM_VOICE_ASSISTANT;
79 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_COMMUNICATION)] = AudioStreamType::STREAM_VOICE_CALL;
80 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_ASSISTANT)] = AudioStreamType::STREAM_VOICE_ASSISTANT;
81 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_NOTIFICATION_RINGTONE)] = AudioStreamType::STREAM_MUSIC;
82
83 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_UNKNOWN)] = AudioStreamType::STREAM_MUSIC;
84 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_MEDIA)] = AudioStreamType::STREAM_MUSIC;
85 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_VOICE_COMMUNICATION)] = AudioStreamType::STREAM_MUSIC;
86 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_VOICE_ASSISTANT)] = AudioStreamType::STREAM_VOICE_ASSISTANT;
87 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_NOTIFICATION_RINGTONE)] = AudioStreamType::STREAM_RING;
88
89 streamMap[make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_UNKNOWN)] = AudioStreamType::STREAM_MEDIA;
90 streamMap[make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_MEDIA)] = AudioStreamType::STREAM_MEDIA;
91 streamMap[make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_VOICE_COMMUNICATION)] = AudioStreamType::STREAM_MUSIC;
92 streamMap[make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_VOICE_ASSISTANT)] = AudioStreamType::STREAM_MUSIC;
93 streamMap[make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_NOTIFICATION_RINGTONE)] = AudioStreamType::STREAM_MUSIC;
94
95 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_UNKNOWN)] = AudioStreamType::STREAM_NOTIFICATION;
96 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_MEDIA)] = AudioStreamType::STREAM_NOTIFICATION;
97 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_VOICE_COMMUNICATION)] = AudioStreamType::STREAM_MUSIC;
98 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_VOICE_ASSISTANT)] = AudioStreamType::STREAM_MUSIC;
99 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_NOTIFICATION_RINGTONE)] = AudioStreamType::STREAM_RING;
100
101 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_UNKNOWN)] = AudioStreamType::STREAM_RING;
102 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_MEDIA)] = AudioStreamType::STREAM_RING;
103 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_VOICE_COMMUNICATION)] = AudioStreamType::STREAM_MUSIC;
104 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_VOICE_ASSISTANT)] = AudioStreamType::STREAM_MUSIC;
105 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_NOTIFICATION_RINGTONE)] = AudioStreamType::STREAM_RING;
106
107 return streamMap;
108 }
109
GetStreamType(ContentType contentType,StreamUsage streamUsage)110 AudioStreamType AudioSystemManager::GetStreamType(ContentType contentType, StreamUsage streamUsage)
111 {
112 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
113 auto pos = streamTypeMap_.find(make_pair(contentType, streamUsage));
114 if (pos != streamTypeMap_.end()) {
115 streamType = pos->second;
116 }
117
118 if (streamType == AudioStreamType::STREAM_MEDIA) {
119 streamType = AudioStreamType::STREAM_MUSIC;
120 }
121
122 return streamType;
123 }
124
GetAudioSystemManagerProxy()125 const sptr<IStandardAudioService> AudioSystemManager::GetAudioSystemManagerProxy()
126 {
127 lock_guard<mutex> lock(g_asProxyMutex);
128 if (g_asProxy == nullptr) {
129 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
130 if (samgr == nullptr) {
131 AUDIO_ERR_LOG("GetAudioSystemManagerProxy: get sa manager failed");
132 return nullptr;
133 }
134 sptr<IRemoteObject> object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID);
135 if (object == nullptr) {
136 AUDIO_ERR_LOG("GetAudioSystemManagerProxy: get audio service remote object failed");
137 return nullptr;
138 }
139 g_asProxy = iface_cast<IStandardAudioService>(object);
140 if (g_asProxy == nullptr) {
141 AUDIO_ERR_LOG("GetAudioSystemManagerProxy: get audio service proxy failed");
142 return nullptr;
143 }
144
145 // register death recipent to restore proxy
146 sptr<AudioServerDeathRecipient> asDeathRecipient = new(std::nothrow) AudioServerDeathRecipient(getpid());
147 if (asDeathRecipient != nullptr) {
148 asDeathRecipient->SetNotifyCb(std::bind(&AudioSystemManager::AudioServerDied, this,
149 std::placeholders::_1));
150 bool result = object->AddDeathRecipient(asDeathRecipient);
151 if (!result) {
152 AUDIO_ERR_LOG("GetAudioSystemManagerProxy: failed to add deathRecipient");
153 }
154 }
155 }
156 sptr<IStandardAudioService> gasp = g_asProxy;
157 return gasp;
158 }
159
AudioServerDied(pid_t pid)160 void AudioSystemManager::AudioServerDied(pid_t pid)
161 {
162 AUDIO_INFO_LOG("audio server died, will restore proxy in next call");
163 lock_guard<mutex> lock(g_asProxyMutex);
164 g_asProxy = nullptr;
165 }
166
SetRingerMode(AudioRingerMode ringMode)167 int32_t AudioSystemManager::SetRingerMode(AudioRingerMode ringMode)
168 {
169 std::lock_guard<std::mutex> lockSet(ringerModeCallbackMutex_);
170 ringModeBackup_ = ringMode;
171 if (ringerModeCallback_ != nullptr) {
172 ringerModeCallback_->OnRingerModeUpdated(ringModeBackup_);
173 }
174 return SUCCESS;
175 }
176
GetRingerMode()177 AudioRingerMode AudioSystemManager::GetRingerMode()
178 {
179 return ringModeBackup_;
180 }
181
SetAudioScene(const AudioScene & scene)182 int32_t AudioSystemManager::SetAudioScene(const AudioScene &scene)
183 {
184 AUDIO_DEBUG_LOG("SetAudioScene audioScene_=%{public}d done", scene);
185 return AudioPolicyManager::GetInstance().SetAudioScene(scene);
186 }
187
GetAudioScene() const188 AudioScene AudioSystemManager::GetAudioScene() const
189 {
190 return AudioPolicyManager::GetInstance().GetAudioScene();
191 }
192
SetDeviceActive(ActiveDeviceType deviceType,bool flag) const193 int32_t AudioSystemManager::SetDeviceActive(ActiveDeviceType deviceType, bool flag) const
194 {
195 switch (deviceType) {
196 case SPEAKER:
197 case BLUETOOTH_SCO:
198 case FILE_SINK_DEVICE:
199 break;
200 default:
201 AUDIO_ERR_LOG("SetDeviceActive device=%{public}d not supported", deviceType);
202 return ERR_NOT_SUPPORTED;
203 }
204
205 /* Call Audio Policy SetDeviceActive */
206 return (AudioPolicyManager::GetInstance().SetDeviceActive(static_cast<InternalDeviceType>(deviceType), flag));
207 }
208
IsDeviceActive(ActiveDeviceType deviceType) const209 bool AudioSystemManager::IsDeviceActive(ActiveDeviceType deviceType) const
210 {
211 switch (deviceType) {
212 case SPEAKER:
213 case BLUETOOTH_SCO:
214 case FILE_SINK_DEVICE:
215 break;
216 default:
217 AUDIO_ERR_LOG("IsDeviceActive device=%{public}d not supported", deviceType);
218 return false;
219 }
220
221 /* Call Audio Policy IsDeviceActive */
222 return (AudioPolicyManager::GetInstance().IsDeviceActive(static_cast<InternalDeviceType>(deviceType)));
223 }
224
GetActiveOutputDevice()225 DeviceType AudioSystemManager::GetActiveOutputDevice()
226 {
227 return AudioPolicyManager::GetInstance().GetActiveOutputDevice();
228 }
229
GetActiveInputDevice()230 DeviceType AudioSystemManager::GetActiveInputDevice()
231 {
232 return AudioPolicyManager::GetInstance().GetActiveInputDevice();
233 }
234
IsStreamActive(AudioVolumeType volumeType) const235 bool AudioSystemManager::IsStreamActive(AudioVolumeType volumeType) const
236 {
237 switch (volumeType) {
238 case STREAM_MUSIC:
239 case STREAM_RING:
240 case STREAM_VOICE_CALL:
241 case STREAM_VOICE_ASSISTANT:
242 break;
243 default:
244 AUDIO_ERR_LOG("IsStreamActive volumeType=%{public}d not supported", volumeType);
245 return false;
246 }
247
248 AudioStreamType StreamVolType = (AudioStreamType)volumeType;
249 return AudioPolicyManager::GetInstance().IsStreamActive(StreamVolType);
250 }
251
GetAudioParameter(const std::string key)252 const std::string AudioSystemManager::GetAudioParameter(const std::string key)
253 {
254 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
255 if (gasp == nullptr) {
256 AUDIO_ERR_LOG("GetAudioParameter::Audio service unavailable.");
257 return nullptr;
258 }
259 return gasp->GetAudioParameter(key);
260 }
261
SetAudioParameter(const std::string & key,const std::string & value)262 void AudioSystemManager::SetAudioParameter(const std::string &key, const std::string &value)
263 {
264 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
265 if (gasp == nullptr) {
266 AUDIO_ERR_LOG("SetAudioParameter::Audio service unavailable.");
267 return;
268 }
269 gasp->SetAudioParameter(key, value);
270 }
271
RetrieveCookie(int32_t & size)272 const char *AudioSystemManager::RetrieveCookie(int32_t &size)
273 {
274 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
275 if (gasp == nullptr) {
276 AUDIO_ERR_LOG("RetrieveCookie::Audio service unavailable.");
277 return nullptr;
278 }
279 return gasp->RetrieveCookie(size);
280 }
281
GetTransactionId(DeviceType deviceType,DeviceRole deviceRole)282 uint64_t AudioSystemManager::GetTransactionId(DeviceType deviceType, DeviceRole deviceRole)
283 {
284 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
285 if (gasp == nullptr) {
286 AUDIO_ERR_LOG("GetTransactionId::Audio service unavailable.");
287 return 0;
288 }
289 return gasp->GetTransactionId(deviceType, deviceRole);
290 }
291
SetVolume(AudioVolumeType volumeType,int32_t volume) const292 int32_t AudioSystemManager::SetVolume(AudioVolumeType volumeType, int32_t volume) const
293 {
294 AUDIO_DEBUG_LOG("AudioSystemManager SetVolume volumeType=%{public}d ", volumeType);
295
296 /* Validate and return INVALID_PARAMS error */
297 if ((volume < MIN_VOLUME_LEVEL) || (volume > MAX_VOLUME_LEVEL)) {
298 AUDIO_ERR_LOG("Invalid Volume Input!");
299 return ERR_INVALID_PARAM;
300 }
301
302 switch (volumeType) {
303 case STREAM_MUSIC:
304 case STREAM_RING:
305 case STREAM_NOTIFICATION:
306 case STREAM_VOICE_CALL:
307 case STREAM_VOICE_ASSISTANT:
308 case STREAM_ALL:
309 break;
310 default:
311 AUDIO_ERR_LOG("SetVolume volumeType=%{public}d not supported", volumeType);
312 return ERR_NOT_SUPPORTED;
313 }
314
315 /* Call Audio Policy SetStreamVolume */
316 AudioStreamType StreamVolType = (AudioStreamType)volumeType;
317 float volumeToHdi = MapVolumeToHDI(volume);
318
319 if (volumeType == STREAM_ALL) {
320 for (auto audioVolumeType : GET_STREAM_ALL_VOLUME_TYPES) {
321 StreamVolType = (AudioStreamType)audioVolumeType;
322 int32_t setResult = AudioPolicyManager::GetInstance().SetStreamVolume(StreamVolType, volumeToHdi);
323 AUDIO_DEBUG_LOG("SetVolume of STREAM_ALL, volumeType=%{public}d ", StreamVolType);
324 if (setResult != SUCCESS) {
325 return setResult;
326 }
327 }
328 return SUCCESS;
329 }
330
331 return AudioPolicyManager::GetInstance().SetStreamVolume(StreamVolType, volumeToHdi);
332 }
333
GetVolume(AudioVolumeType volumeType) const334 int32_t AudioSystemManager::GetVolume(AudioVolumeType volumeType) const
335 {
336 switch (volumeType) {
337 case STREAM_MUSIC:
338 case STREAM_RING:
339 case STREAM_NOTIFICATION:
340 case STREAM_VOICE_CALL:
341 case STREAM_VOICE_ASSISTANT:
342 case STREAM_ALL:
343 break;
344 default:
345 AUDIO_ERR_LOG("GetVolume volumeType=%{public}d not supported", volumeType);
346 return ERR_NOT_SUPPORTED;
347 }
348
349 if (volumeType == STREAM_ALL) {
350 volumeType = STREAM_MUSIC;
351 AUDIO_DEBUG_LOG("GetVolume of STREAM_ALL for volumeType=%{public}d ", volumeType);
352 }
353
354 /* Call Audio Policy SetStreamMute */
355 AudioStreamType StreamVolType = (AudioStreamType)volumeType;
356 float volumeFromHdi = AudioPolicyManager::GetInstance().GetStreamVolume(StreamVolType);
357
358 return MapVolumeFromHDI(volumeFromHdi);
359 }
360
SetLowPowerVolume(int32_t streamId,float volume) const361 int32_t AudioSystemManager::SetLowPowerVolume(int32_t streamId, float volume) const
362 {
363 AUDIO_INFO_LOG("AudioSystemManager SetLowPowerVolume, streamId:%{public}d, vol:%{public}f.", streamId, volume);
364 if ((volume < 0) || (volume > 1.0)) {
365 AUDIO_ERR_LOG("Invalid Volume Input!");
366 return ERR_INVALID_PARAM;
367 }
368
369 return AudioPolicyManager::GetInstance().SetLowPowerVolume(streamId, volume);
370 }
371
GetLowPowerVolume(int32_t streamId) const372 float AudioSystemManager::GetLowPowerVolume(int32_t streamId) const
373 {
374 return AudioPolicyManager::GetInstance().GetLowPowerVolume(streamId);
375 }
376
GetSingleStreamVolume(int32_t streamId) const377 float AudioSystemManager::GetSingleStreamVolume(int32_t streamId) const
378 {
379 return AudioPolicyManager::GetInstance().GetSingleStreamVolume(streamId);
380 }
381
MapVolumeToHDI(int32_t volume)382 float AudioSystemManager::MapVolumeToHDI(int32_t volume)
383 {
384 float value = (float)volume / MAX_VOLUME_LEVEL;
385 float roundValue = (int)(value * CONST_FACTOR);
386
387 return (float)roundValue / CONST_FACTOR;
388 }
389
MapVolumeFromHDI(float volume)390 int32_t AudioSystemManager::MapVolumeFromHDI(float volume)
391 {
392 float value = (float)volume * MAX_VOLUME_LEVEL;
393 return nearbyint(value);
394 }
395
GetMaxVolume(AudioVolumeType volumeType)396 int32_t AudioSystemManager::GetMaxVolume(AudioVolumeType volumeType)
397 {
398 if (volumeType == STREAM_ALL) {
399 volumeType = STREAM_MUSIC;
400 }
401 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
402 if (gasp == nullptr) {
403 AUDIO_ERR_LOG("GetMaxVolume::Audio service unavailable.");
404 return ERR_OPERATION_FAILED;
405 }
406 return gasp->GetMaxVolume(volumeType);
407 }
408
GetMinVolume(AudioVolumeType volumeType)409 int32_t AudioSystemManager::GetMinVolume(AudioVolumeType volumeType)
410 {
411 if (volumeType == STREAM_ALL) {
412 volumeType = STREAM_MUSIC;
413 }
414 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
415 if (gasp == nullptr) {
416 AUDIO_ERR_LOG("GetMinVolume::Audio service unavailable.");
417 return ERR_OPERATION_FAILED;
418 }
419 return gasp->GetMinVolume(volumeType);
420 }
421
SetMute(AudioVolumeType volumeType,bool mute) const422 int32_t AudioSystemManager::SetMute(AudioVolumeType volumeType, bool mute) const
423 {
424 AUDIO_DEBUG_LOG("AudioSystemManager SetMute for volumeType=%{public}d", volumeType);
425 switch (volumeType) {
426 case STREAM_MUSIC:
427 case STREAM_RING:
428 case STREAM_NOTIFICATION:
429 case STREAM_VOICE_CALL:
430 case STREAM_VOICE_ASSISTANT:
431 case STREAM_ALL:
432 break;
433 default:
434 AUDIO_ERR_LOG("SetMute volumeType=%{public}d not supported", volumeType);
435 return ERR_NOT_SUPPORTED;
436 }
437
438 /* Call Audio Policy SetStreamMute */
439 AudioStreamType StreamVolType = (AudioStreamType)volumeType;
440
441 if (volumeType == STREAM_ALL) {
442 for (auto audioVolumeType : GET_STREAM_ALL_VOLUME_TYPES) {
443 StreamVolType = (AudioStreamType)audioVolumeType;
444 int32_t setResult = AudioPolicyManager::GetInstance().SetStreamMute(StreamVolType, mute);
445 AUDIO_DEBUG_LOG("SetMute of STREAM_ALL for volumeType=%{public}d ", StreamVolType);
446 if (setResult != SUCCESS) {
447 return setResult;
448 }
449 }
450 return SUCCESS;
451 }
452
453 return AudioPolicyManager::GetInstance().SetStreamMute(StreamVolType, mute);
454 }
455
IsStreamMute(AudioVolumeType volumeType) const456 bool AudioSystemManager::IsStreamMute(AudioVolumeType volumeType) const
457 {
458 AUDIO_DEBUG_LOG("AudioSystemManager::GetMute Client");
459
460 switch (volumeType) {
461 case STREAM_MUSIC:
462 case STREAM_RING:
463 case STREAM_NOTIFICATION:
464 case STREAM_VOICE_CALL:
465 case STREAM_VOICE_ASSISTANT:
466 case STREAM_ALL:
467 break;
468 default:
469 AUDIO_ERR_LOG("IsStreamMute volumeType=%{public}d not supported", volumeType);
470 return false;
471 }
472
473 if (volumeType == STREAM_ALL) {
474 volumeType = STREAM_MUSIC;
475 }
476
477 /* Call Audio Policy SetStreamVolume */
478 AudioStreamType StreamVolType = (AudioStreamType)volumeType;
479 return AudioPolicyManager::GetInstance().GetStreamMute(StreamVolType);
480 }
481
SetDeviceChangeCallback(const DeviceFlag flag,const std::shared_ptr<AudioManagerDeviceChangeCallback> & callback)482 int32_t AudioSystemManager::SetDeviceChangeCallback(const DeviceFlag flag,
483 const std::shared_ptr<AudioManagerDeviceChangeCallback>& callback)
484 {
485 AUDIO_INFO_LOG("Entered AudioSystemManager::%{public}s", __func__);
486 if (callback == nullptr) {
487 AUDIO_ERR_LOG("SetDeviceChangeCallback: callback is nullptr");
488 return ERR_INVALID_PARAM;
489 }
490
491 int32_t clientId = static_cast<int32_t>(GetCallingPid());
492 return AudioPolicyManager::GetInstance().SetDeviceChangeCallback(clientId, flag, callback);
493 }
494
UnsetDeviceChangeCallback()495 int32_t AudioSystemManager::UnsetDeviceChangeCallback()
496 {
497 AUDIO_INFO_LOG("Entered AudioSystemManager::%{public}s", __func__);
498 int32_t clientId = static_cast<int32_t>(GetCallingPid());
499 return AudioPolicyManager::GetInstance().UnsetDeviceChangeCallback(clientId);
500 }
501
SetRingerModeCallback(const int32_t clientId,const std::shared_ptr<AudioRingerModeCallback> & callback)502 int32_t AudioSystemManager::SetRingerModeCallback(const int32_t clientId,
503 const std::shared_ptr<AudioRingerModeCallback> &callback)
504 {
505 std::lock_guard<std::mutex> lockSet(ringerModeCallbackMutex_);
506 if (callback == nullptr) {
507 AUDIO_ERR_LOG("AudioSystemManager: callback is nullptr");
508 return ERR_INVALID_PARAM;
509 }
510
511 cbClientId_ = clientId;
512 ringerModeCallback_ = callback;
513
514 return SUCCESS;
515 }
516
UnsetRingerModeCallback(const int32_t clientId) const517 int32_t AudioSystemManager::UnsetRingerModeCallback(const int32_t clientId) const
518 {
519 if (clientId != cbClientId_) {
520 return ERR_INVALID_OPERATION;
521 }
522
523 return SUCCESS;
524 }
525
SetMicrophoneMute(bool isMute)526 int32_t AudioSystemManager::SetMicrophoneMute(bool isMute)
527 {
528 return AudioPolicyManager::GetInstance().SetMicrophoneMute(isMute);
529 }
530
IsMicrophoneMute(API_VERSION api_v)531 bool AudioSystemManager::IsMicrophoneMute(API_VERSION api_v)
532 {
533 std::shared_ptr<AudioGroupManager> groupManager = GetGroupManager(DEFAULT_VOLUME_GROUP_ID);
534 if (groupManager == nullptr) {
535 AUDIO_ERR_LOG("IsMicrophoneMute failed, groupManager is null");
536 return false;
537 }
538 return groupManager->IsMicrophoneMute(api_v);
539 }
540
SelectOutputDevice(std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const541 int32_t AudioSystemManager::SelectOutputDevice(std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
542 {
543 if (audioDeviceDescriptors.size() != 1 || audioDeviceDescriptors[0] == nullptr) {
544 AUDIO_ERR_LOG("SelectOutputDevice: invalid parameter");
545 return ERR_INVALID_PARAM;
546 }
547 if (audioDeviceDescriptors[0]->deviceRole_ != DeviceRole::OUTPUT_DEVICE) {
548 AUDIO_ERR_LOG("SelectOutputDevice: not an output device.");
549 return ERR_INVALID_OPERATION;
550 }
551 size_t validSize = 64;
552 if (audioDeviceDescriptors[0]->networkId_ != LOCAL_NETWORK_ID &&
553 audioDeviceDescriptors[0]->networkId_.size() != validSize) {
554 AUDIO_ERR_LOG("SelectOutputDevice: invalid networkId.");
555 return ERR_INVALID_PARAM;
556 }
557 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
558 audioRendererFilter->uid = -1;
559 int32_t ret = AudioPolicyManager::GetInstance().SelectOutputDevice(audioRendererFilter, audioDeviceDescriptors);
560 return ret;
561 }
562
SelectInputDevice(std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const563 int32_t AudioSystemManager::SelectInputDevice(std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
564 {
565 if (audioDeviceDescriptors.size() != 1 || audioDeviceDescriptors[0] == nullptr) {
566 AUDIO_ERR_LOG("SelectInputDevice: invalid parameter");
567 return ERR_INVALID_PARAM;
568 }
569 if (audioDeviceDescriptors[0]->deviceRole_ != DeviceRole::INPUT_DEVICE) {
570 AUDIO_ERR_LOG("SelectInputDevice: not an output device.");
571 return ERR_INVALID_OPERATION;
572 }
573 sptr<AudioCapturerFilter> audioCapturerFilter = new(std::nothrow) AudioCapturerFilter();
574 audioCapturerFilter->uid = -1;
575 int32_t ret = AudioPolicyManager::GetInstance().SelectInputDevice(audioCapturerFilter, audioDeviceDescriptors);
576 return ret;
577 }
578
GetSelectedDeviceInfo(int32_t uid,int32_t pid,AudioStreamType streamType) const579 std::string AudioSystemManager::GetSelectedDeviceInfo(int32_t uid, int32_t pid, AudioStreamType streamType) const
580 {
581 return AudioPolicyManager::GetInstance().GetSelectedDeviceInfo(uid, pid, streamType);
582 }
583
SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter,std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const584 int32_t AudioSystemManager::SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter,
585 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
586 {
587 // basic check
588 if (audioRendererFilter == nullptr || audioDeviceDescriptors.size() == 0) {
589 AUDIO_ERR_LOG("SelectOutputDevice: invalid parameter");
590 return ERR_INVALID_PARAM;
591 }
592
593 size_t validDeviceSize = 1;
594 if (audioDeviceDescriptors.size() > validDeviceSize || audioDeviceDescriptors[0] == nullptr) {
595 AUDIO_ERR_LOG("SelectOutputDevice: device error");
596 return ERR_INVALID_OPERATION;
597 }
598 audioRendererFilter->streamType = AudioSystemManager::GetStreamType(audioRendererFilter->rendererInfo.contentType,
599 audioRendererFilter->rendererInfo.streamUsage);
600 // operation chack
601 if (audioDeviceDescriptors[0]->deviceRole_ != DeviceRole::OUTPUT_DEVICE) {
602 AUDIO_ERR_LOG("SelectOutputDevice: not an output device.");
603 return ERR_INVALID_OPERATION;
604 }
605 size_t validSize = 64;
606 if (audioDeviceDescriptors[0]->networkId_ != LOCAL_NETWORK_ID &&
607 audioDeviceDescriptors[0]->networkId_.size() != validSize) {
608 AUDIO_ERR_LOG("SelectOutputDevice: invalid networkId.");
609 return ERR_INVALID_PARAM;
610 }
611 if (audioRendererFilter->uid < 0) {
612 AUDIO_ERR_LOG("SelectOutputDevice: invalid uid.");
613 return ERR_INVALID_PARAM;
614 }
615 AUDIO_DEBUG_LOG("[%{public}d] SelectOutputDevice: uid<%{public}d> streamType<%{public}d> device<name:%{public}s>",
616 getpid(), audioRendererFilter->uid, static_cast<int32_t>(audioRendererFilter->streamType),
617 (audioDeviceDescriptors[0]->networkId_.c_str()));
618
619 return AudioPolicyManager::GetInstance().SelectOutputDevice(audioRendererFilter, audioDeviceDescriptors);
620 }
621
SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter,std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const622 int32_t AudioSystemManager::SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter,
623 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
624 {
625 // basic check
626 if (audioCapturerFilter == nullptr || audioDeviceDescriptors.size() == 0) {
627 AUDIO_ERR_LOG("SelectInputDevice: invalid parameter");
628 return ERR_INVALID_PARAM;
629 }
630
631 size_t validDeviceSize = 1;
632 if (audioDeviceDescriptors.size() > validDeviceSize || audioDeviceDescriptors[0] == nullptr) {
633 AUDIO_ERR_LOG("SelectInputDevice: device error.");
634 return ERR_INVALID_OPERATION;
635 }
636 // operation chack
637 if (audioDeviceDescriptors[0]->deviceRole_ != DeviceRole::INPUT_DEVICE) {
638 AUDIO_ERR_LOG("SelectInputDevice: not an input device");
639 return ERR_INVALID_OPERATION;
640 }
641 if (audioCapturerFilter->uid < 0) {
642 AUDIO_ERR_LOG("SelectInputDevice: invalid uid.");
643 return ERR_INVALID_PARAM;
644 }
645 AUDIO_DEBUG_LOG("[%{public}d] SelectInputDevice: uid<%{public}d> device<type:%{public}d>",
646 getpid(), audioCapturerFilter->uid, static_cast<int32_t>(audioDeviceDescriptors[0]->deviceType_));
647
648 return AudioPolicyManager::GetInstance().SelectInputDevice(audioCapturerFilter, audioDeviceDescriptors);
649 }
650
GetDevices(DeviceFlag deviceFlag)651 std::vector<sptr<AudioDeviceDescriptor>> AudioSystemManager::GetDevices(DeviceFlag deviceFlag)
652 {
653 return AudioPolicyManager::GetInstance().GetDevices(deviceFlag);
654 }
655
GetActiveOutputDeviceDescriptors()656 std::vector<sptr<AudioDeviceDescriptor>> AudioSystemManager::GetActiveOutputDeviceDescriptors()
657 {
658 return AudioPolicyManager::GetInstance().GetActiveOutputDeviceDescriptors();
659 }
660
RegisterVolumeKeyEventCallback(const int32_t clientPid,const std::shared_ptr<VolumeKeyEventCallback> & callback)661 int32_t AudioSystemManager::RegisterVolumeKeyEventCallback(const int32_t clientPid,
662 const std::shared_ptr<VolumeKeyEventCallback> &callback)
663 {
664 AUDIO_DEBUG_LOG("AudioSystemManager RegisterVolumeKeyEventCallback");
665
666 if (callback == nullptr) {
667 AUDIO_ERR_LOG("AudioSystemManager::RegisterVolumeKeyEventCallbackcallback is nullptr");
668 return ERR_INVALID_PARAM;
669 }
670 volumeChangeClientPid_ = clientPid;
671
672 return AudioPolicyManager::GetInstance().SetVolumeKeyEventCallback(clientPid, callback);
673 }
674
UnregisterVolumeKeyEventCallback(const int32_t clientPid)675 int32_t AudioSystemManager::UnregisterVolumeKeyEventCallback(const int32_t clientPid)
676 {
677 AUDIO_DEBUG_LOG("AudioSystemManager::UnregisterVolumeKeyEventCallback");
678 int32_t ret = AudioPolicyManager::GetInstance().UnsetVolumeKeyEventCallback(clientPid);
679 if (!ret) {
680 AUDIO_DEBUG_LOG("AudioSystemManager::UnregisterVolumeKeyEventCallback success");
681 volumeChangeClientPid_ = -1;
682 }
683
684 return ret;
685 }
686
687 // Below stub implementation is added to handle compilation error in call manager
688 // Once call manager adapt to new interrupt implementation, this will be removed
SetAudioManagerCallback(const AudioVolumeType streamType,const std::shared_ptr<AudioManagerCallback> & callback)689 int32_t AudioSystemManager::SetAudioManagerCallback(const AudioVolumeType streamType,
690 const std::shared_ptr<AudioManagerCallback> &callback)
691 {
692 AUDIO_DEBUG_LOG("AudioSystemManager SetAudioManagerCallback stub implementation");
693 return SUCCESS;
694 }
695
UnsetAudioManagerCallback(const AudioVolumeType streamType) const696 int32_t AudioSystemManager::UnsetAudioManagerCallback(const AudioVolumeType streamType) const
697 {
698 AUDIO_DEBUG_LOG("AudioSystemManager UnsetAudioManagerCallback stub implementation");
699 return SUCCESS;
700 }
701
ActivateAudioInterrupt(const AudioInterrupt & audioInterrupt)702 int32_t AudioSystemManager::ActivateAudioInterrupt(const AudioInterrupt &audioInterrupt)
703 {
704 AUDIO_DEBUG_LOG("AudioSystemManager ActivateAudioInterrupt stub implementation");
705 return SUCCESS;
706 }
707
DeactivateAudioInterrupt(const AudioInterrupt & audioInterrupt) const708 int32_t AudioSystemManager::DeactivateAudioInterrupt(const AudioInterrupt &audioInterrupt) const
709 {
710 AUDIO_DEBUG_LOG("AudioSystemManager DeactivateAudioInterrupt stub implementation");
711 return SUCCESS;
712 }
713
SetAudioManagerInterruptCallback(const std::shared_ptr<AudioManagerCallback> & callback)714 int32_t AudioSystemManager::SetAudioManagerInterruptCallback(const std::shared_ptr<AudioManagerCallback> &callback)
715 {
716 uint32_t clientID = GetCallingPid();
717 AUDIO_INFO_LOG("AudioSystemManager:: SetAudioManagerInterruptCallback client id: %{public}d", clientID);
718 if (callback == nullptr) {
719 AUDIO_ERR_LOG("AudioSystemManager::callback is null");
720 return ERR_INVALID_PARAM;
721 }
722
723 if (audioInterruptCallback_ != nullptr) {
724 AUDIO_DEBUG_LOG("AudioSystemManager reset existing callback object");
725 AudioPolicyManager::GetInstance().UnsetAudioManagerInterruptCallback(clientID);
726 audioInterruptCallback_.reset();
727 audioInterruptCallback_ = nullptr;
728 }
729
730 audioInterruptCallback_ = std::make_shared<AudioManagerInterruptCallbackImpl>();
731 if (audioInterruptCallback_ == nullptr) {
732 AUDIO_ERR_LOG("AudioSystemManager::Failed to allocate memory for audioInterruptCallback");
733 return ERROR;
734 }
735
736 int32_t ret = AudioPolicyManager::GetInstance().SetAudioManagerInterruptCallback(clientID, audioInterruptCallback_);
737 if (ret != SUCCESS) {
738 AUDIO_ERR_LOG("AudioSystemManager::Failed set callback");
739 return ERROR;
740 }
741
742 std::shared_ptr<AudioManagerInterruptCallbackImpl> cbInterrupt =
743 std::static_pointer_cast<AudioManagerInterruptCallbackImpl>(audioInterruptCallback_);
744 if (cbInterrupt == nullptr) {
745 AUDIO_ERR_LOG("AudioSystemManager::cbInterrupt is nullptr");
746 return ERROR;
747 }
748 cbInterrupt->SaveCallback(callback);
749
750 return SUCCESS;
751 }
752
UnsetAudioManagerInterruptCallback()753 int32_t AudioSystemManager::UnsetAudioManagerInterruptCallback()
754 {
755 uint32_t clientID = GetCallingPid();
756 AUDIO_INFO_LOG("AudioSystemManager:: UnsetAudioManagerInterruptCallback client id: %{public}d", clientID);
757
758 int32_t ret = AudioPolicyManager::GetInstance().UnsetAudioManagerInterruptCallback(clientID);
759 if (audioInterruptCallback_ != nullptr) {
760 audioInterruptCallback_.reset();
761 audioInterruptCallback_ = nullptr;
762 }
763
764 return ret;
765 }
766
RequestAudioFocus(const AudioInterrupt & audioInterrupt)767 int32_t AudioSystemManager::RequestAudioFocus(const AudioInterrupt &audioInterrupt)
768 {
769 uint32_t clientID = GetCallingPid();
770 AUDIO_INFO_LOG("AudioSystemManager:: RequestAudioFocus client id: %{public}d", clientID);
771 CHECK_AND_RETURN_RET_LOG(audioInterrupt.contentType >= CONTENT_TYPE_UNKNOWN
772 && audioInterrupt.contentType <= CONTENT_TYPE_RINGTONE, ERR_INVALID_PARAM,
773 "Invalid content type");
774 CHECK_AND_RETURN_RET_LOG(audioInterrupt.streamUsage >= STREAM_USAGE_UNKNOWN
775 && audioInterrupt.streamUsage <= STREAM_USAGE_NOTIFICATION_RINGTONE,
776 ERR_INVALID_PARAM, "Invalid stream usage");
777 CHECK_AND_RETURN_RET_LOG(audioInterrupt.streamType >= AudioStreamType::STREAM_VOICE_CALL
778 && audioInterrupt.streamType <= AudioStreamType::STREAM_RECORDING,
779 ERR_INVALID_PARAM, "Invalid stream type");
780 return AudioPolicyManager::GetInstance().RequestAudioFocus(clientID, audioInterrupt);
781 }
782
AbandonAudioFocus(const AudioInterrupt & audioInterrupt)783 int32_t AudioSystemManager::AbandonAudioFocus(const AudioInterrupt &audioInterrupt)
784 {
785 uint32_t clientID = GetCallingPid();
786 AUDIO_INFO_LOG("AudioSystemManager:: AbandonAudioFocus client id: %{public}d", clientID);
787 CHECK_AND_RETURN_RET_LOG(audioInterrupt.contentType >= CONTENT_TYPE_UNKNOWN
788 && audioInterrupt.contentType <= CONTENT_TYPE_RINGTONE, ERR_INVALID_PARAM,
789 "Invalid content type");
790 CHECK_AND_RETURN_RET_LOG(audioInterrupt.streamUsage >= STREAM_USAGE_UNKNOWN
791 && audioInterrupt.streamUsage <= STREAM_USAGE_NOTIFICATION_RINGTONE,
792 ERR_INVALID_PARAM, "Invalid stream usage");
793 CHECK_AND_RETURN_RET_LOG(audioInterrupt.streamType >= AudioStreamType::STREAM_VOICE_CALL
794 && audioInterrupt.streamType <= AudioStreamType::STREAM_RECORDING,
795 ERR_INVALID_PARAM, "Invalid stream type");
796 return AudioPolicyManager::GetInstance().AbandonAudioFocus(clientID, audioInterrupt);
797 }
798
ReconfigureAudioChannel(const uint32_t & count,DeviceType deviceType)799 int32_t AudioSystemManager::ReconfigureAudioChannel(const uint32_t &count, DeviceType deviceType)
800 {
801 return AudioPolicyManager::GetInstance().ReconfigureAudioChannel(count, deviceType);
802 }
803
GetVolumeGroups(std::string networkId)804 std::vector<sptr<VolumeGroupInfo>> AudioSystemManager::GetVolumeGroups(std::string networkId)
805 {
806 std::vector<sptr<VolumeGroupInfo>> infos = {};
807 infos = AudioPolicyManager::GetInstance().GetVolumeGroupInfos();
808
809 auto filter = [&networkId](const sptr<VolumeGroupInfo>& info) {
810 return networkId != info->networkId_;
811 };
812 infos.erase(std::remove_if(infos.begin(), infos.end(), filter), infos.end());
813 return infos;
814 }
815
GetGroupManager(int32_t groupId)816 std::shared_ptr<AudioGroupManager> AudioSystemManager::GetGroupManager(int32_t groupId)
817 {
818 std::vector<std::shared_ptr<AudioGroupManager>>::iterator iter = groupManagerMap_.begin();
819 while (iter != groupManagerMap_.end()) {
820 if ((*iter)->GetGroupId() == groupId) {
821 return *iter;
822 } else {
823 iter++;
824 }
825 }
826
827 std::shared_ptr<AudioGroupManager> groupManager = std::make_shared<AudioGroupManager>(groupId);
828 if (groupManager->Init() == SUCCESS) {
829 groupManagerMap_.push_back(groupManager);
830 } else {
831 groupManager = nullptr;
832 }
833 return groupManager;
834 }
835
AudioManagerInterruptCallbackImpl()836 AudioManagerInterruptCallbackImpl::AudioManagerInterruptCallbackImpl()
837 {
838 AUDIO_INFO_LOG("AudioManagerInterruptCallbackImpl constructor");
839 }
840
~AudioManagerInterruptCallbackImpl()841 AudioManagerInterruptCallbackImpl::~AudioManagerInterruptCallbackImpl()
842 {
843 AUDIO_DEBUG_LOG("AudioManagerInterruptCallbackImpl: instance destroy");
844 }
845
SaveCallback(const std::weak_ptr<AudioManagerCallback> & callback)846 void AudioManagerInterruptCallbackImpl::SaveCallback(const std::weak_ptr<AudioManagerCallback> &callback)
847 {
848 auto wp = callback.lock();
849 if (wp != nullptr) {
850 callback_ = callback;
851 } else {
852 AUDIO_ERR_LOG("AudioManagerInterruptCallbackImpl::SaveCallback: callback is nullptr");
853 }
854 }
855
OnInterrupt(const InterruptEventInternal & interruptEvent)856 void AudioManagerInterruptCallbackImpl::OnInterrupt(const InterruptEventInternal &interruptEvent)
857 {
858 cb_ = callback_.lock();
859 if (cb_ != nullptr) {
860 InterruptAction interruptAction = {};
861 interruptAction.actionType = (interruptEvent.eventType == INTERRUPT_TYPE_BEGIN)
862 ? TYPE_INTERRUPT : TYPE_ACTIVATED;
863 interruptAction.interruptType = interruptEvent.eventType;
864 interruptAction.interruptHint = interruptEvent.hintType;
865 interruptAction.activated = (interruptEvent.eventType == INTERRUPT_TYPE_BEGIN) ? false : true;
866 cb_->OnInterrupt(interruptAction);
867 AUDIO_DEBUG_LOG("AudioManagerInterruptCallbackImpl: OnInterrupt : Notify event to app complete");
868 } else {
869 AUDIO_ERR_LOG("AudioManagerInterruptCallbackImpl: callback is null");
870 }
871
872 return;
873 }
874
RequestIndependentInterrupt(FocusType focusType)875 bool AudioSystemManager::RequestIndependentInterrupt(FocusType focusType)
876 {
877 AUDIO_INFO_LOG("AudioSystemManager: requestIndependentInterrupt : foncusType");
878 AudioInterrupt audioInterrupt;
879 uint32_t clientID = GetCallingPid();
880 audioInterrupt.contentType = ContentType::CONTENT_TYPE_SPEECH;
881 audioInterrupt.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
882 audioInterrupt.streamType = AudioStreamType::STREAM_RECORDING;
883 audioInterrupt.sessionID = clientID;
884 int32_t result = AudioPolicyManager::GetInstance().ActivateAudioInterrupt(audioInterrupt);
885
886 AUDIO_INFO_LOG("AudioSystemManager: requestIndependentInterrupt : result -> %{public}d", result);
887 return (result == SUCCESS) ? true:false;
888 }
AbandonIndependentInterrupt(FocusType focusType)889 bool AudioSystemManager::AbandonIndependentInterrupt(FocusType focusType)
890 {
891 AUDIO_INFO_LOG("AudioSystemManager: abandonIndependentInterrupt : foncusType");
892 AudioInterrupt audioInterrupt;
893 uint32_t clientID = GetCallingPid();
894 audioInterrupt.contentType = ContentType::CONTENT_TYPE_SPEECH;
895 audioInterrupt.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
896 audioInterrupt.streamType = AudioStreamType::STREAM_RECORDING;
897 audioInterrupt.sessionID = clientID;
898 int32_t result = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt);
899 AUDIO_INFO_LOG("AudioSystemManager: abandonIndependentInterrupt : result -> %{public}d", result);
900 return (result == SUCCESS) ? true:false;
901 }
902
GetAudioLatencyFromXml() const903 int32_t AudioSystemManager::GetAudioLatencyFromXml() const
904 {
905 return AudioPolicyManager::GetInstance().GetAudioLatencyFromXml();
906 }
907
GetSinkLatencyFromXml() const908 uint32_t AudioSystemManager::GetSinkLatencyFromXml() const
909 {
910 return AudioPolicyManager::GetInstance().GetSinkLatencyFromXml();
911 }
912
UpdateStreamState(const int32_t clientUid,StreamSetState streamSetState,AudioStreamType audioStreamType)913 int32_t AudioSystemManager::UpdateStreamState(const int32_t clientUid,
914 StreamSetState streamSetState, AudioStreamType audioStreamType)
915 {
916 AUDIO_INFO_LOG("AudioSystemManager::UpdateStreamState::clientUid:%{public}d streamSetState:%{public}d",
917 clientUid, streamSetState);
918 int32_t result = 0;
919
920 result = AudioPolicyManager::GetInstance().UpdateStreamState(clientUid, streamSetState, audioStreamType);
921 return result;
922 }
923
GetPinValueFromType(DeviceType deviceType,DeviceRole deviceRole) const924 AudioPin AudioSystemManager::GetPinValueFromType(DeviceType deviceType, DeviceRole deviceRole) const
925 {
926 AudioPin pin = AUDIO_PIN_NONE;
927 switch (deviceType) {
928 case OHOS::AudioStandard::DEVICE_TYPE_NONE:
929 case OHOS::AudioStandard::DEVICE_TYPE_INVALID:
930 pin = AUDIO_PIN_NONE;
931 break;
932 case OHOS::AudioStandard::DEVICE_TYPE_DEFAULT:
933 if (deviceRole == DeviceRole::INPUT_DEVICE) {
934 pin = AUDIO_PIN_IN_DAUDIO_DEFAULT;
935 } else {
936 pin = AUDIO_PIN_OUT_DAUDIO_DEFAULT;
937 }
938 break;
939 case OHOS::AudioStandard::DEVICE_TYPE_SPEAKER:
940 pin = AUDIO_PIN_OUT_SPEAKER;
941 break;
942 case OHOS::AudioStandard::DEVICE_TYPE_MIC:
943 pin = AUDIO_PIN_IN_MIC;
944 break;
945 case OHOS::AudioStandard::DEVICE_TYPE_WIRED_HEADSET:
946 if (deviceRole == DeviceRole::INPUT_DEVICE) {
947 pin = AUDIO_PIN_IN_HS_MIC;
948 } else {
949 pin = AUDIO_PIN_OUT_HEADSET;
950 }
951 break;
952 case OHOS::AudioStandard::DEVICE_TYPE_USB_HEADSET:
953 case OHOS::AudioStandard::DEVICE_TYPE_FILE_SINK:
954 case OHOS::AudioStandard::DEVICE_TYPE_FILE_SOURCE:
955 case OHOS::AudioStandard::DEVICE_TYPE_BLUETOOTH_SCO:
956 case OHOS::AudioStandard::DEVICE_TYPE_BLUETOOTH_A2DP:
957 case OHOS::AudioStandard::DEVICE_TYPE_MAX:
958 AUDIO_INFO_LOG("AudioSystemManager: GetPinValueFromType :don't supported the device type");
959 break;
960 default:
961 AUDIO_INFO_LOG("AudioSystemManager: GetPinValueFromType : invalid input parameter");
962 break;
963 }
964 return pin;
965 }
966
GetTypeValueFromPin(AudioPin pin) const967 DeviceType AudioSystemManager::GetTypeValueFromPin(AudioPin pin) const
968 {
969 DeviceType type = DEVICE_TYPE_NONE;
970 switch (pin) {
971 case OHOS::AudioStandard::AUDIO_PIN_NONE:
972 type = DEVICE_TYPE_NONE;
973 break;
974 case OHOS::AudioStandard::AUDIO_PIN_OUT_SPEAKER:
975 type = DEVICE_TYPE_SPEAKER;
976 break;
977 case OHOS::AudioStandard::AUDIO_PIN_OUT_HEADSET:
978 break;
979 case OHOS::AudioStandard::AUDIO_PIN_OUT_LINEOUT:
980 break;
981 case OHOS::AudioStandard::AUDIO_PIN_OUT_HDMI:
982 break;
983 case OHOS::AudioStandard::AUDIO_PIN_OUT_USB:
984 break;
985 case OHOS::AudioStandard::AUDIO_PIN_OUT_USB_EXT:
986 break;
987 case OHOS::AudioStandard::AUDIO_PIN_OUT_DAUDIO_DEFAULT:
988 type = DEVICE_TYPE_DEFAULT;
989 break;
990 case OHOS::AudioStandard::AUDIO_PIN_IN_MIC:
991 type = DEVICE_TYPE_MIC;
992 break;
993 case OHOS::AudioStandard::AUDIO_PIN_IN_HS_MIC:
994 type = DEVICE_TYPE_WIRED_HEADSET;
995 break;
996 case OHOS::AudioStandard::AUDIO_PIN_IN_LINEIN:
997 break;
998 case OHOS::AudioStandard::AUDIO_PIN_IN_USB_EXT:
999 break;
1000 case OHOS::AudioStandard::AUDIO_PIN_IN_DAUDIO_DEFAULT:
1001 type = DEVICE_TYPE_DEFAULT;
1002 break;
1003 default:
1004 AUDIO_INFO_LOG("AudioSystemManager: GetTypeValueFromPin : invalid input parameter");
1005 break;
1006 }
1007 return type;
1008 }
1009 } // namespace AudioStandard
1010 } // namespace OHOS
1011