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 ringModeBackup_ = ringMode;
170 if (ringerModeCallback_ != nullptr) {
171 ringerModeCallback_->OnRingerModeUpdated(ringModeBackup_);
172 }
173 return SUCCESS;
174 }
175
GetRingerMode()176 AudioRingerMode AudioSystemManager::GetRingerMode()
177 {
178 return ringModeBackup_;
179 }
180
SetAudioScene(const AudioScene & scene)181 int32_t AudioSystemManager::SetAudioScene(const AudioScene &scene)
182 {
183 AUDIO_DEBUG_LOG("SetAudioScene audioScene_=%{public}d done", scene);
184 return AudioPolicyManager::GetInstance().SetAudioScene(scene);
185 }
186
GetAudioScene() const187 AudioScene AudioSystemManager::GetAudioScene() const
188 {
189 return AudioPolicyManager::GetInstance().GetAudioScene();
190 }
191
SetDeviceActive(ActiveDeviceType deviceType,bool flag) const192 int32_t AudioSystemManager::SetDeviceActive(ActiveDeviceType deviceType, bool flag) const
193 {
194 switch (deviceType) {
195 case SPEAKER:
196 case BLUETOOTH_SCO:
197 case FILE_SINK_DEVICE:
198 break;
199 default:
200 AUDIO_ERR_LOG("SetDeviceActive device=%{public}d not supported", deviceType);
201 return ERR_NOT_SUPPORTED;
202 }
203
204 /* Call Audio Policy SetDeviceActive */
205 return (AudioPolicyManager::GetInstance().SetDeviceActive(static_cast<InternalDeviceType>(deviceType), flag));
206 }
207
IsDeviceActive(ActiveDeviceType deviceType) const208 bool AudioSystemManager::IsDeviceActive(ActiveDeviceType deviceType) const
209 {
210 switch (deviceType) {
211 case SPEAKER:
212 case BLUETOOTH_SCO:
213 case FILE_SINK_DEVICE:
214 break;
215 default:
216 AUDIO_ERR_LOG("IsDeviceActive device=%{public}d not supported", deviceType);
217 return false;
218 }
219
220 /* Call Audio Policy IsDeviceActive */
221 return (AudioPolicyManager::GetInstance().IsDeviceActive(static_cast<InternalDeviceType>(deviceType)));
222 }
223
GetActiveOutputDevice()224 DeviceType AudioSystemManager::GetActiveOutputDevice()
225 {
226 return AudioPolicyManager::GetInstance().GetActiveOutputDevice();
227 }
228
GetActiveInputDevice()229 DeviceType AudioSystemManager::GetActiveInputDevice()
230 {
231 return AudioPolicyManager::GetInstance().GetActiveInputDevice();
232 }
233
IsStreamActive(AudioVolumeType volumeType) const234 bool AudioSystemManager::IsStreamActive(AudioVolumeType volumeType) const
235 {
236 switch (volumeType) {
237 case STREAM_MUSIC:
238 case STREAM_RING:
239 case STREAM_VOICE_CALL:
240 case STREAM_VOICE_ASSISTANT:
241 break;
242 default:
243 AUDIO_ERR_LOG("IsStreamActive volumeType=%{public}d not supported", volumeType);
244 return false;
245 }
246
247 AudioStreamType StreamVolType = (AudioStreamType)volumeType;
248 return AudioPolicyManager::GetInstance().IsStreamActive(StreamVolType);
249 }
250
GetAudioParameter(const std::string key)251 const std::string AudioSystemManager::GetAudioParameter(const std::string key)
252 {
253 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
254 if (gasp == nullptr) {
255 AUDIO_ERR_LOG("GetAudioParameter::Audio service unavailable.");
256 return nullptr;
257 }
258 return gasp->GetAudioParameter(key);
259 }
260
SetAudioParameter(const std::string & key,const std::string & value)261 void AudioSystemManager::SetAudioParameter(const std::string &key, const std::string &value)
262 {
263 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
264 if (gasp == nullptr) {
265 AUDIO_ERR_LOG("SetAudioParameter::Audio service unavailable.");
266 return;
267 }
268 gasp->SetAudioParameter(key, value);
269 }
270
RetrieveCookie(int32_t & size)271 const char *AudioSystemManager::RetrieveCookie(int32_t &size)
272 {
273 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
274 if (gasp == nullptr) {
275 AUDIO_ERR_LOG("RetrieveCookie::Audio service unavailable.");
276 return nullptr;
277 }
278 return gasp->RetrieveCookie(size);
279 }
280
GetTransactionId(DeviceType deviceType,DeviceRole deviceRole)281 uint64_t AudioSystemManager::GetTransactionId(DeviceType deviceType, DeviceRole deviceRole)
282 {
283 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
284 if (gasp == nullptr) {
285 AUDIO_ERR_LOG("GetTransactionId::Audio service unavailable.");
286 return 0;
287 }
288 return gasp->GetTransactionId(deviceType, deviceRole);
289 }
290
SetVolume(AudioVolumeType volumeType,int32_t volume) const291 int32_t AudioSystemManager::SetVolume(AudioVolumeType volumeType, int32_t volume) const
292 {
293 AUDIO_DEBUG_LOG("AudioSystemManager SetVolume volumeType=%{public}d ", volumeType);
294
295 /* Validate and return INVALID_PARAMS error */
296 if ((volume < MIN_VOLUME_LEVEL) || (volume > MAX_VOLUME_LEVEL)) {
297 AUDIO_ERR_LOG("Invalid Volume Input!");
298 return ERR_INVALID_PARAM;
299 }
300
301 switch (volumeType) {
302 case STREAM_MUSIC:
303 case STREAM_RING:
304 case STREAM_NOTIFICATION:
305 case STREAM_VOICE_CALL:
306 case STREAM_VOICE_ASSISTANT:
307 case STREAM_ALL:
308 break;
309 default:
310 AUDIO_ERR_LOG("SetVolume volumeType=%{public}d not supported", volumeType);
311 return ERR_NOT_SUPPORTED;
312 }
313
314 /* Call Audio Policy SetStreamVolume */
315 AudioStreamType StreamVolType = (AudioStreamType)volumeType;
316 float volumeToHdi = MapVolumeToHDI(volume);
317
318 if (volumeType == STREAM_ALL) {
319 for (auto audioVolumeType : GET_STREAM_ALL_VOLUME_TYPES) {
320 StreamVolType = (AudioStreamType)audioVolumeType;
321 int32_t setResult = AudioPolicyManager::GetInstance().SetStreamVolume(StreamVolType, volumeToHdi);
322 AUDIO_DEBUG_LOG("SetVolume of STREAM_ALL, volumeType=%{public}d ", StreamVolType);
323 if (setResult != SUCCESS) {
324 return setResult;
325 }
326 }
327 return SUCCESS;
328 }
329
330 return AudioPolicyManager::GetInstance().SetStreamVolume(StreamVolType, volumeToHdi);
331 }
332
GetVolume(AudioVolumeType volumeType) const333 int32_t AudioSystemManager::GetVolume(AudioVolumeType volumeType) const
334 {
335 switch (volumeType) {
336 case STREAM_MUSIC:
337 case STREAM_RING:
338 case STREAM_NOTIFICATION:
339 case STREAM_VOICE_CALL:
340 case STREAM_VOICE_ASSISTANT:
341 case STREAM_ALL:
342 break;
343 default:
344 AUDIO_ERR_LOG("GetVolume volumeType=%{public}d not supported", volumeType);
345 return ERR_NOT_SUPPORTED;
346 }
347
348 if (volumeType == STREAM_ALL) {
349 volumeType = STREAM_MUSIC;
350 AUDIO_DEBUG_LOG("GetVolume of STREAM_ALL for volumeType=%{public}d ", volumeType);
351 }
352
353 /* Call Audio Policy SetStreamMute */
354 AudioStreamType StreamVolType = (AudioStreamType)volumeType;
355 float volumeFromHdi = AudioPolicyManager::GetInstance().GetStreamVolume(StreamVolType);
356
357 return MapVolumeFromHDI(volumeFromHdi);
358 }
359
SetLowPowerVolume(int32_t streamId,float volume) const360 int32_t AudioSystemManager::SetLowPowerVolume(int32_t streamId, float volume) const
361 {
362 AUDIO_INFO_LOG("AudioSystemManager SetLowPowerVolume, streamId:%{public}d, vol:%{public}f.", streamId, volume);
363 if ((volume < 0) || (volume > 1.0)) {
364 AUDIO_ERR_LOG("Invalid Volume Input!");
365 return ERR_INVALID_PARAM;
366 }
367
368 return AudioPolicyManager::GetInstance().SetLowPowerVolume(streamId, volume);
369 }
370
GetLowPowerVolume(int32_t streamId) const371 float AudioSystemManager::GetLowPowerVolume(int32_t streamId) const
372 {
373 return AudioPolicyManager::GetInstance().GetLowPowerVolume(streamId);
374 }
375
GetSingleStreamVolume(int32_t streamId) const376 float AudioSystemManager::GetSingleStreamVolume(int32_t streamId) const
377 {
378 return AudioPolicyManager::GetInstance().GetSingleStreamVolume(streamId);
379 }
380
MapVolumeToHDI(int32_t volume)381 float AudioSystemManager::MapVolumeToHDI(int32_t volume)
382 {
383 float value = (float)volume / MAX_VOLUME_LEVEL;
384 float roundValue = (int)(value * CONST_FACTOR);
385
386 return (float)roundValue / CONST_FACTOR;
387 }
388
MapVolumeFromHDI(float volume)389 int32_t AudioSystemManager::MapVolumeFromHDI(float volume)
390 {
391 float value = (float)volume * MAX_VOLUME_LEVEL;
392 return nearbyint(value);
393 }
394
GetMaxVolume(AudioVolumeType volumeType)395 int32_t AudioSystemManager::GetMaxVolume(AudioVolumeType volumeType)
396 {
397 if (volumeType == STREAM_ALL) {
398 volumeType = STREAM_MUSIC;
399 }
400 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
401 if (gasp == nullptr) {
402 AUDIO_ERR_LOG("GetMaxVolume::Audio service unavailable.");
403 return ERR_OPERATION_FAILED;
404 }
405 return gasp->GetMaxVolume(volumeType);
406 }
407
GetMinVolume(AudioVolumeType volumeType)408 int32_t AudioSystemManager::GetMinVolume(AudioVolumeType volumeType)
409 {
410 if (volumeType == STREAM_ALL) {
411 volumeType = STREAM_MUSIC;
412 }
413 const sptr<IStandardAudioService> gasp = GetAudioSystemManagerProxy();
414 if (gasp == nullptr) {
415 AUDIO_ERR_LOG("GetMinVolume::Audio service unavailable.");
416 return ERR_OPERATION_FAILED;
417 }
418 return gasp->GetMinVolume(volumeType);
419 }
420
SetMute(AudioVolumeType volumeType,bool mute) const421 int32_t AudioSystemManager::SetMute(AudioVolumeType volumeType, bool mute) const
422 {
423 AUDIO_DEBUG_LOG("AudioSystemManager SetMute for volumeType=%{public}d", volumeType);
424 switch (volumeType) {
425 case STREAM_MUSIC:
426 case STREAM_RING:
427 case STREAM_NOTIFICATION:
428 case STREAM_VOICE_CALL:
429 case STREAM_VOICE_ASSISTANT:
430 case STREAM_ALL:
431 break;
432 default:
433 AUDIO_ERR_LOG("SetMute volumeType=%{public}d not supported", volumeType);
434 return ERR_NOT_SUPPORTED;
435 }
436
437 /* Call Audio Policy SetStreamMute */
438 AudioStreamType StreamVolType = (AudioStreamType)volumeType;
439
440 if (volumeType == STREAM_ALL) {
441 for (auto audioVolumeType : GET_STREAM_ALL_VOLUME_TYPES) {
442 StreamVolType = (AudioStreamType)audioVolumeType;
443 int32_t setResult = AudioPolicyManager::GetInstance().SetStreamMute(StreamVolType, mute);
444 AUDIO_DEBUG_LOG("SetMute of STREAM_ALL for volumeType=%{public}d ", StreamVolType);
445 if (setResult != SUCCESS) {
446 return setResult;
447 }
448 }
449 return SUCCESS;
450 }
451
452 return AudioPolicyManager::GetInstance().SetStreamMute(StreamVolType, mute);
453 }
454
IsStreamMute(AudioVolumeType volumeType) const455 bool AudioSystemManager::IsStreamMute(AudioVolumeType volumeType) const
456 {
457 AUDIO_DEBUG_LOG("AudioSystemManager::GetMute Client");
458
459 switch (volumeType) {
460 case STREAM_MUSIC:
461 case STREAM_RING:
462 case STREAM_NOTIFICATION:
463 case STREAM_VOICE_CALL:
464 case STREAM_VOICE_ASSISTANT:
465 case STREAM_ALL:
466 break;
467 default:
468 AUDIO_ERR_LOG("IsStreamMute volumeType=%{public}d not supported", volumeType);
469 return false;
470 }
471
472 if (volumeType == STREAM_ALL) {
473 volumeType = STREAM_MUSIC;
474 }
475
476 /* Call Audio Policy SetStreamVolume */
477 AudioStreamType StreamVolType = (AudioStreamType)volumeType;
478 return AudioPolicyManager::GetInstance().GetStreamMute(StreamVolType);
479 }
480
SetDeviceChangeCallback(const DeviceFlag flag,const std::shared_ptr<AudioManagerDeviceChangeCallback> & callback)481 int32_t AudioSystemManager::SetDeviceChangeCallback(const DeviceFlag flag,
482 const std::shared_ptr<AudioManagerDeviceChangeCallback>& callback)
483 {
484 AUDIO_INFO_LOG("Entered AudioSystemManager::%{public}s", __func__);
485 if (callback == nullptr) {
486 AUDIO_ERR_LOG("SetDeviceChangeCallback: callback is nullptr");
487 return ERR_INVALID_PARAM;
488 }
489
490 int32_t clientId = static_cast<int32_t>(GetCallingPid());
491 return AudioPolicyManager::GetInstance().SetDeviceChangeCallback(clientId, flag, callback);
492 }
493
UnsetDeviceChangeCallback()494 int32_t AudioSystemManager::UnsetDeviceChangeCallback()
495 {
496 AUDIO_INFO_LOG("Entered AudioSystemManager::%{public}s", __func__);
497 int32_t clientId = static_cast<int32_t>(GetCallingPid());
498 return AudioPolicyManager::GetInstance().UnsetDeviceChangeCallback(clientId);
499 }
500
SetRingerModeCallback(const int32_t clientId,const std::shared_ptr<AudioRingerModeCallback> & callback)501 int32_t AudioSystemManager::SetRingerModeCallback(const int32_t clientId,
502 const std::shared_ptr<AudioRingerModeCallback> &callback)
503 {
504 if (callback == nullptr) {
505 AUDIO_ERR_LOG("AudioSystemManager: callback is nullptr");
506 return ERR_INVALID_PARAM;
507 }
508
509 cbClientId_ = clientId;
510 ringerModeCallback_ = callback;
511
512 return SUCCESS;
513 }
514
UnsetRingerModeCallback(const int32_t clientId) const515 int32_t AudioSystemManager::UnsetRingerModeCallback(const int32_t clientId) const
516 {
517 if (clientId != cbClientId_) {
518 return ERR_INVALID_OPERATION;
519 }
520
521 return SUCCESS;
522 }
523
SetMicrophoneMute(bool isMute)524 int32_t AudioSystemManager::SetMicrophoneMute(bool isMute)
525 {
526 return AudioPolicyManager::GetInstance().SetMicrophoneMute(isMute);
527 }
528
IsMicrophoneMute(API_VERSION api_v)529 bool AudioSystemManager::IsMicrophoneMute(API_VERSION api_v)
530 {
531 std::shared_ptr<AudioGroupManager> groupManager = GetGroupManager(DEFAULT_VOLUME_GROUP_ID);
532 if (groupManager == nullptr) {
533 AUDIO_ERR_LOG("IsMicrophoneMute failed, groupManager is null");
534 return false;
535 }
536 return groupManager->IsMicrophoneMute(api_v);
537 }
538
SelectOutputDevice(std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const539 int32_t AudioSystemManager::SelectOutputDevice(std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
540 {
541 if (audioDeviceDescriptors.size() != 1 || audioDeviceDescriptors[0] == nullptr) {
542 AUDIO_ERR_LOG("SelectOutputDevice: invalid parameter");
543 return ERR_INVALID_PARAM;
544 }
545 if (audioDeviceDescriptors[0]->deviceRole_ != DeviceRole::OUTPUT_DEVICE) {
546 AUDIO_ERR_LOG("SelectOutputDevice: not an output device.");
547 return ERR_INVALID_OPERATION;
548 }
549 size_t validSize = 64;
550 if (audioDeviceDescriptors[0]->networkId_ != LOCAL_NETWORK_ID &&
551 audioDeviceDescriptors[0]->networkId_.size() != validSize) {
552 AUDIO_ERR_LOG("SelectOutputDevice: invalid networkId.");
553 return ERR_INVALID_PARAM;
554 }
555 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
556 audioRendererFilter->uid = -1;
557 int32_t ret = AudioPolicyManager::GetInstance().SelectOutputDevice(audioRendererFilter, audioDeviceDescriptors);
558 return ret;
559 }
560
SelectInputDevice(std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const561 int32_t AudioSystemManager::SelectInputDevice(std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
562 {
563 if (audioDeviceDescriptors.size() != 1 || audioDeviceDescriptors[0] == nullptr) {
564 AUDIO_ERR_LOG("SelectInputDevice: invalid parameter");
565 return ERR_INVALID_PARAM;
566 }
567 if (audioDeviceDescriptors[0]->deviceRole_ != DeviceRole::INPUT_DEVICE) {
568 AUDIO_ERR_LOG("SelectInputDevice: not an output device.");
569 return ERR_INVALID_OPERATION;
570 }
571 sptr<AudioCapturerFilter> audioCapturerFilter = new(std::nothrow) AudioCapturerFilter();
572 audioCapturerFilter->uid = -1;
573 int32_t ret = AudioPolicyManager::GetInstance().SelectInputDevice(audioCapturerFilter, audioDeviceDescriptors);
574 return ret;
575 }
576
GetSelectedDeviceInfo(int32_t uid,int32_t pid,AudioStreamType streamType) const577 std::string AudioSystemManager::GetSelectedDeviceInfo(int32_t uid, int32_t pid, AudioStreamType streamType) const
578 {
579 return AudioPolicyManager::GetInstance().GetSelectedDeviceInfo(uid, pid, streamType);
580 }
581
SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter,std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const582 int32_t AudioSystemManager::SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter,
583 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
584 {
585 // basic check
586 if (audioRendererFilter == nullptr || audioDeviceDescriptors.size() == 0) {
587 AUDIO_ERR_LOG("SelectOutputDevice: invalid parameter");
588 return ERR_INVALID_PARAM;
589 }
590
591 size_t validDeviceSize = 1;
592 if (audioDeviceDescriptors.size() > validDeviceSize || audioDeviceDescriptors[0] == nullptr) {
593 AUDIO_ERR_LOG("SelectOutputDevice: device error");
594 return ERR_INVALID_OPERATION;
595 }
596 audioRendererFilter->streamType = AudioSystemManager::GetStreamType(audioRendererFilter->rendererInfo.contentType,
597 audioRendererFilter->rendererInfo.streamUsage);
598 // operation chack
599 if (audioDeviceDescriptors[0]->deviceRole_ != DeviceRole::OUTPUT_DEVICE) {
600 AUDIO_ERR_LOG("SelectOutputDevice: not an output device.");
601 return ERR_INVALID_OPERATION;
602 }
603 size_t validSize = 64;
604 if (audioDeviceDescriptors[0]->networkId_ != LOCAL_NETWORK_ID &&
605 audioDeviceDescriptors[0]->networkId_.size() != validSize) {
606 AUDIO_ERR_LOG("SelectOutputDevice: invalid networkId.");
607 return ERR_INVALID_PARAM;
608 }
609 if (audioRendererFilter->uid < 0) {
610 AUDIO_ERR_LOG("SelectOutputDevice: invalid uid.");
611 return ERR_INVALID_PARAM;
612 }
613 AUDIO_DEBUG_LOG("[%{public}d] SelectOutputDevice: uid<%{public}d> streamType<%{public}d> device<name:%{public}s>",
614 getpid(), audioRendererFilter->uid, static_cast<int32_t>(audioRendererFilter->streamType),
615 (audioDeviceDescriptors[0]->networkId_.c_str()));
616
617 return AudioPolicyManager::GetInstance().SelectOutputDevice(audioRendererFilter, audioDeviceDescriptors);
618 }
619
SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter,std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const620 int32_t AudioSystemManager::SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter,
621 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) const
622 {
623 // basic check
624 if (audioCapturerFilter == nullptr || audioDeviceDescriptors.size() == 0) {
625 AUDIO_ERR_LOG("SelectInputDevice: invalid parameter");
626 return ERR_INVALID_PARAM;
627 }
628
629 size_t validDeviceSize = 1;
630 if (audioDeviceDescriptors.size() > validDeviceSize || audioDeviceDescriptors[0] == nullptr) {
631 AUDIO_ERR_LOG("SelectInputDevice: device error.");
632 return ERR_INVALID_OPERATION;
633 }
634 // operation chack
635 if (audioDeviceDescriptors[0]->deviceRole_ != DeviceRole::INPUT_DEVICE) {
636 AUDIO_ERR_LOG("SelectInputDevice: not an input device");
637 return ERR_INVALID_OPERATION;
638 }
639 if (audioCapturerFilter->uid < 0) {
640 AUDIO_ERR_LOG("SelectInputDevice: invalid uid.");
641 return ERR_INVALID_PARAM;
642 }
643 AUDIO_DEBUG_LOG("[%{public}d] SelectInputDevice: uid<%{public}d> device<type:%{public}d>",
644 getpid(), audioCapturerFilter->uid, static_cast<int32_t>(audioDeviceDescriptors[0]->deviceType_));
645
646 return AudioPolicyManager::GetInstance().SelectInputDevice(audioCapturerFilter, audioDeviceDescriptors);
647 }
648
GetDevices(DeviceFlag deviceFlag)649 std::vector<sptr<AudioDeviceDescriptor>> AudioSystemManager::GetDevices(DeviceFlag deviceFlag)
650 {
651 return AudioPolicyManager::GetInstance().GetDevices(deviceFlag);
652 }
653
GetActiveOutputDeviceDescriptors()654 std::vector<sptr<AudioDeviceDescriptor>> AudioSystemManager::GetActiveOutputDeviceDescriptors()
655 {
656 return AudioPolicyManager::GetInstance().GetActiveOutputDeviceDescriptors();
657 }
658
RegisterVolumeKeyEventCallback(const int32_t clientPid,const std::shared_ptr<VolumeKeyEventCallback> & callback)659 int32_t AudioSystemManager::RegisterVolumeKeyEventCallback(const int32_t clientPid,
660 const std::shared_ptr<VolumeKeyEventCallback> &callback)
661 {
662 AUDIO_DEBUG_LOG("AudioSystemManager RegisterVolumeKeyEventCallback");
663
664 if (callback == nullptr) {
665 AUDIO_ERR_LOG("AudioSystemManager::RegisterVolumeKeyEventCallbackcallback is nullptr");
666 return ERR_INVALID_PARAM;
667 }
668 volumeChangeClientPid_ = clientPid;
669
670 return AudioPolicyManager::GetInstance().SetVolumeKeyEventCallback(clientPid, callback);
671 }
672
UnregisterVolumeKeyEventCallback(const int32_t clientPid)673 int32_t AudioSystemManager::UnregisterVolumeKeyEventCallback(const int32_t clientPid)
674 {
675 AUDIO_DEBUG_LOG("AudioSystemManager::UnregisterVolumeKeyEventCallback");
676 int32_t ret = AudioPolicyManager::GetInstance().UnsetVolumeKeyEventCallback(clientPid);
677 if (!ret) {
678 AUDIO_DEBUG_LOG("AudioSystemManager::UnregisterVolumeKeyEventCallback success");
679 volumeChangeClientPid_ = -1;
680 }
681
682 return ret;
683 }
684
685 // Below stub implementation is added to handle compilation error in call manager
686 // Once call manager adapt to new interrupt implementation, this will be removed
SetAudioManagerCallback(const AudioVolumeType streamType,const std::shared_ptr<AudioManagerCallback> & callback)687 int32_t AudioSystemManager::SetAudioManagerCallback(const AudioVolumeType streamType,
688 const std::shared_ptr<AudioManagerCallback> &callback)
689 {
690 AUDIO_DEBUG_LOG("AudioSystemManager SetAudioManagerCallback stub implementation");
691 return SUCCESS;
692 }
693
UnsetAudioManagerCallback(const AudioVolumeType streamType) const694 int32_t AudioSystemManager::UnsetAudioManagerCallback(const AudioVolumeType streamType) const
695 {
696 AUDIO_DEBUG_LOG("AudioSystemManager UnsetAudioManagerCallback stub implementation");
697 return SUCCESS;
698 }
699
ActivateAudioInterrupt(const AudioInterrupt & audioInterrupt)700 int32_t AudioSystemManager::ActivateAudioInterrupt(const AudioInterrupt &audioInterrupt)
701 {
702 AUDIO_DEBUG_LOG("AudioSystemManager ActivateAudioInterrupt stub implementation");
703 return SUCCESS;
704 }
705
DeactivateAudioInterrupt(const AudioInterrupt & audioInterrupt) const706 int32_t AudioSystemManager::DeactivateAudioInterrupt(const AudioInterrupt &audioInterrupt) const
707 {
708 AUDIO_DEBUG_LOG("AudioSystemManager DeactivateAudioInterrupt stub implementation");
709 return SUCCESS;
710 }
711
SetAudioManagerInterruptCallback(const std::shared_ptr<AudioManagerCallback> & callback)712 int32_t AudioSystemManager::SetAudioManagerInterruptCallback(const std::shared_ptr<AudioManagerCallback> &callback)
713 {
714 uint32_t clientID = GetCallingPid();
715 AUDIO_INFO_LOG("AudioSystemManager:: SetAudioManagerInterruptCallback client id: %{public}d", clientID);
716 if (callback == nullptr) {
717 AUDIO_ERR_LOG("AudioSystemManager::callback is null");
718 return ERR_INVALID_PARAM;
719 }
720
721 if (audioInterruptCallback_ != nullptr) {
722 AUDIO_DEBUG_LOG("AudioSystemManager reset existing callback object");
723 AudioPolicyManager::GetInstance().UnsetAudioManagerInterruptCallback(clientID);
724 audioInterruptCallback_.reset();
725 audioInterruptCallback_ = nullptr;
726 }
727
728 audioInterruptCallback_ = std::make_shared<AudioManagerInterruptCallbackImpl>();
729 if (audioInterruptCallback_ == nullptr) {
730 AUDIO_ERR_LOG("AudioSystemManager::Failed to allocate memory for audioInterruptCallback");
731 return ERROR;
732 }
733
734 int32_t ret = AudioPolicyManager::GetInstance().SetAudioManagerInterruptCallback(clientID, audioInterruptCallback_);
735 if (ret != SUCCESS) {
736 AUDIO_ERR_LOG("AudioSystemManager::Failed set callback");
737 return ERROR;
738 }
739
740 std::shared_ptr<AudioManagerInterruptCallbackImpl> cbInterrupt =
741 std::static_pointer_cast<AudioManagerInterruptCallbackImpl>(audioInterruptCallback_);
742 if (cbInterrupt == nullptr) {
743 AUDIO_ERR_LOG("AudioSystemManager::cbInterrupt is nullptr");
744 return ERROR;
745 }
746 cbInterrupt->SaveCallback(callback);
747
748 return SUCCESS;
749 }
750
UnsetAudioManagerInterruptCallback()751 int32_t AudioSystemManager::UnsetAudioManagerInterruptCallback()
752 {
753 uint32_t clientID = GetCallingPid();
754 AUDIO_INFO_LOG("AudioSystemManager:: UnsetAudioManagerInterruptCallback client id: %{public}d", clientID);
755
756 int32_t ret = AudioPolicyManager::GetInstance().UnsetAudioManagerInterruptCallback(clientID);
757 if (audioInterruptCallback_ != nullptr) {
758 audioInterruptCallback_.reset();
759 audioInterruptCallback_ = nullptr;
760 }
761
762 return ret;
763 }
764
RequestAudioFocus(const AudioInterrupt & audioInterrupt)765 int32_t AudioSystemManager::RequestAudioFocus(const AudioInterrupt &audioInterrupt)
766 {
767 uint32_t clientID = GetCallingPid();
768 AUDIO_INFO_LOG("AudioSystemManager:: RequestAudioFocus client id: %{public}d", clientID);
769 CHECK_AND_RETURN_RET_LOG(audioInterrupt.contentType >= CONTENT_TYPE_UNKNOWN
770 && audioInterrupt.contentType <= CONTENT_TYPE_RINGTONE, ERR_INVALID_PARAM,
771 "Invalid content type");
772 CHECK_AND_RETURN_RET_LOG(audioInterrupt.streamUsage >= STREAM_USAGE_UNKNOWN
773 && audioInterrupt.streamUsage <= STREAM_USAGE_NOTIFICATION_RINGTONE,
774 ERR_INVALID_PARAM, "Invalid stream usage");
775 CHECK_AND_RETURN_RET_LOG(audioInterrupt.streamType >= AudioStreamType::STREAM_VOICE_CALL
776 && audioInterrupt.streamType <= AudioStreamType::STREAM_RECORDING,
777 ERR_INVALID_PARAM, "Invalid stream type");
778 return AudioPolicyManager::GetInstance().RequestAudioFocus(clientID, audioInterrupt);
779 }
780
AbandonAudioFocus(const AudioInterrupt & audioInterrupt)781 int32_t AudioSystemManager::AbandonAudioFocus(const AudioInterrupt &audioInterrupt)
782 {
783 uint32_t clientID = GetCallingPid();
784 AUDIO_INFO_LOG("AudioSystemManager:: AbandonAudioFocus client id: %{public}d", clientID);
785 CHECK_AND_RETURN_RET_LOG(audioInterrupt.contentType >= CONTENT_TYPE_UNKNOWN
786 && audioInterrupt.contentType <= CONTENT_TYPE_RINGTONE, ERR_INVALID_PARAM,
787 "Invalid content type");
788 CHECK_AND_RETURN_RET_LOG(audioInterrupt.streamUsage >= STREAM_USAGE_UNKNOWN
789 && audioInterrupt.streamUsage <= STREAM_USAGE_NOTIFICATION_RINGTONE,
790 ERR_INVALID_PARAM, "Invalid stream usage");
791 CHECK_AND_RETURN_RET_LOG(audioInterrupt.streamType >= AudioStreamType::STREAM_VOICE_CALL
792 && audioInterrupt.streamType <= AudioStreamType::STREAM_RECORDING,
793 ERR_INVALID_PARAM, "Invalid stream type");
794 return AudioPolicyManager::GetInstance().AbandonAudioFocus(clientID, audioInterrupt);
795 }
796
ReconfigureAudioChannel(const uint32_t & count,DeviceType deviceType)797 int32_t AudioSystemManager::ReconfigureAudioChannel(const uint32_t &count, DeviceType deviceType)
798 {
799 return AudioPolicyManager::GetInstance().ReconfigureAudioChannel(count, deviceType);
800 }
801
GetVolumeGroups(std::string networkId)802 std::vector<sptr<VolumeGroupInfo>> AudioSystemManager::GetVolumeGroups(std::string networkId)
803 {
804 std::vector<sptr<VolumeGroupInfo>> infos = {};
805 infos = AudioPolicyManager::GetInstance().GetVolumeGroupInfos();
806
807 auto filter = [&networkId](const sptr<VolumeGroupInfo>& info) {
808 return networkId != info->networkId_;
809 };
810 infos.erase(std::remove_if(infos.begin(), infos.end(), filter), infos.end());
811 return infos;
812 }
813
GetGroupManager(int32_t groupId)814 std::shared_ptr<AudioGroupManager> AudioSystemManager::GetGroupManager(int32_t groupId)
815 {
816 std::vector<std::shared_ptr<AudioGroupManager>>::iterator iter = groupManagerMap_.begin();
817 while (iter != groupManagerMap_.end()) {
818 if ((*iter)->GetGroupId() == groupId) {
819 return *iter;
820 } else {
821 iter++;
822 }
823 }
824
825 std::shared_ptr<AudioGroupManager> groupManager = std::make_shared<AudioGroupManager>(groupId);
826 if (groupManager->Init() == SUCCESS) {
827 groupManagerMap_.push_back(groupManager);
828 } else {
829 groupManager = nullptr;
830 }
831 return groupManager;
832 }
833
AudioManagerInterruptCallbackImpl()834 AudioManagerInterruptCallbackImpl::AudioManagerInterruptCallbackImpl()
835 {
836 AUDIO_INFO_LOG("AudioManagerInterruptCallbackImpl constructor");
837 }
838
~AudioManagerInterruptCallbackImpl()839 AudioManagerInterruptCallbackImpl::~AudioManagerInterruptCallbackImpl()
840 {
841 AUDIO_DEBUG_LOG("AudioManagerInterruptCallbackImpl: instance destroy");
842 }
843
SaveCallback(const std::weak_ptr<AudioManagerCallback> & callback)844 void AudioManagerInterruptCallbackImpl::SaveCallback(const std::weak_ptr<AudioManagerCallback> &callback)
845 {
846 auto wp = callback.lock();
847 if (wp != nullptr) {
848 callback_ = callback;
849 } else {
850 AUDIO_ERR_LOG("AudioManagerInterruptCallbackImpl::SaveCallback: callback is nullptr");
851 }
852 }
853
OnInterrupt(const InterruptEventInternal & interruptEvent)854 void AudioManagerInterruptCallbackImpl::OnInterrupt(const InterruptEventInternal &interruptEvent)
855 {
856 cb_ = callback_.lock();
857 if (cb_ != nullptr) {
858 InterruptAction interruptAction = {};
859 interruptAction.actionType = (interruptEvent.eventType == INTERRUPT_TYPE_BEGIN)
860 ? TYPE_INTERRUPT : TYPE_ACTIVATED;
861 interruptAction.interruptType = interruptEvent.eventType;
862 interruptAction.interruptHint = interruptEvent.hintType;
863 interruptAction.activated = (interruptEvent.eventType == INTERRUPT_TYPE_BEGIN) ? false : true;
864 cb_->OnInterrupt(interruptAction);
865 AUDIO_DEBUG_LOG("AudioManagerInterruptCallbackImpl: OnInterrupt : Notify event to app complete");
866 } else {
867 AUDIO_ERR_LOG("AudioManagerInterruptCallbackImpl: callback is null");
868 }
869
870 return;
871 }
872
RequestIndependentInterrupt(FocusType focusType)873 bool AudioSystemManager::RequestIndependentInterrupt(FocusType focusType)
874 {
875 AUDIO_INFO_LOG("AudioSystemManager: requestIndependentInterrupt : foncusType");
876 AudioInterrupt audioInterrupt;
877 uint32_t clientID = GetCallingPid();
878 audioInterrupt.contentType = ContentType::CONTENT_TYPE_SPEECH;
879 audioInterrupt.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
880 audioInterrupt.streamType = AudioStreamType::STREAM_RECORDING;
881 audioInterrupt.sessionID = clientID;
882 int32_t result = AudioPolicyManager::GetInstance().ActivateAudioInterrupt(audioInterrupt);
883
884 AUDIO_INFO_LOG("AudioSystemManager: requestIndependentInterrupt : result -> %{public}d", result);
885 return (result == SUCCESS) ? true:false;
886 }
AbandonIndependentInterrupt(FocusType focusType)887 bool AudioSystemManager::AbandonIndependentInterrupt(FocusType focusType)
888 {
889 AUDIO_INFO_LOG("AudioSystemManager: abandonIndependentInterrupt : foncusType");
890 AudioInterrupt audioInterrupt;
891 uint32_t clientID = GetCallingPid();
892 audioInterrupt.contentType = ContentType::CONTENT_TYPE_SPEECH;
893 audioInterrupt.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
894 audioInterrupt.streamType = AudioStreamType::STREAM_RECORDING;
895 audioInterrupt.sessionID = clientID;
896 int32_t result = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt);
897 AUDIO_INFO_LOG("AudioSystemManager: abandonIndependentInterrupt : result -> %{public}d", result);
898 return (result == SUCCESS) ? true:false;
899 }
900
GetAudioLatencyFromXml() const901 int32_t AudioSystemManager::GetAudioLatencyFromXml() const
902 {
903 return AudioPolicyManager::GetInstance().GetAudioLatencyFromXml();
904 }
905
GetSinkLatencyFromXml() const906 uint32_t AudioSystemManager::GetSinkLatencyFromXml() const
907 {
908 return AudioPolicyManager::GetInstance().GetSinkLatencyFromXml();
909 }
910
UpdateStreamState(const int32_t clientUid,StreamSetState streamSetState,AudioStreamType audioStreamType)911 int32_t AudioSystemManager::UpdateStreamState(const int32_t clientUid,
912 StreamSetState streamSetState, AudioStreamType audioStreamType)
913 {
914 AUDIO_INFO_LOG("AudioSystemManager::UpdateStreamState::clientUid:%{public}d streamSetState:%{public}d",
915 clientUid, streamSetState);
916 int32_t result = 0;
917
918 result = AudioPolicyManager::GetInstance().UpdateStreamState(clientUid, streamSetState, audioStreamType);
919 return result;
920 }
921
GetPinValueFromType(DeviceType deviceType,DeviceRole deviceRole) const922 AudioPin AudioSystemManager::GetPinValueFromType(DeviceType deviceType, DeviceRole deviceRole) const
923 {
924 AudioPin pin = AUDIO_PIN_NONE;
925 switch (deviceType) {
926 case OHOS::AudioStandard::DEVICE_TYPE_NONE:
927 case OHOS::AudioStandard::DEVICE_TYPE_INVALID:
928 pin = AUDIO_PIN_NONE;
929 break;
930 case OHOS::AudioStandard::DEVICE_TYPE_DEFAULT:
931 if (deviceRole == DeviceRole::INPUT_DEVICE) {
932 pin = AUDIO_PIN_IN_DAUDIO_DEFAULT;
933 } else {
934 pin = AUDIO_PIN_OUT_DAUDIO_DEFAULT;
935 }
936 break;
937 case OHOS::AudioStandard::DEVICE_TYPE_SPEAKER:
938 pin = AUDIO_PIN_OUT_SPEAKER;
939 break;
940 case OHOS::AudioStandard::DEVICE_TYPE_MIC:
941 pin = AUDIO_PIN_IN_MIC;
942 break;
943 case OHOS::AudioStandard::DEVICE_TYPE_WIRED_HEADSET:
944 if (deviceRole == DeviceRole::INPUT_DEVICE) {
945 pin = AUDIO_PIN_IN_HS_MIC;
946 } else {
947 pin = AUDIO_PIN_OUT_HEADSET;
948 }
949 break;
950 case OHOS::AudioStandard::DEVICE_TYPE_USB_HEADSET:
951 case OHOS::AudioStandard::DEVICE_TYPE_FILE_SINK:
952 case OHOS::AudioStandard::DEVICE_TYPE_FILE_SOURCE:
953 case OHOS::AudioStandard::DEVICE_TYPE_BLUETOOTH_SCO:
954 case OHOS::AudioStandard::DEVICE_TYPE_BLUETOOTH_A2DP:
955 case OHOS::AudioStandard::DEVICE_TYPE_MAX:
956 AUDIO_INFO_LOG("AudioSystemManager: GetPinValueFromType :don't supported the device type");
957 break;
958 default:
959 AUDIO_INFO_LOG("AudioSystemManager: GetPinValueFromType : invalid input parameter");
960 break;
961 }
962 return pin;
963 }
964
GetTypeValueFromPin(AudioPin pin) const965 DeviceType AudioSystemManager::GetTypeValueFromPin(AudioPin pin) const
966 {
967 DeviceType type = DEVICE_TYPE_NONE;
968 switch (pin) {
969 case OHOS::AudioStandard::AUDIO_PIN_NONE:
970 type = DEVICE_TYPE_NONE;
971 break;
972 case OHOS::AudioStandard::AUDIO_PIN_OUT_SPEAKER:
973 type = DEVICE_TYPE_SPEAKER;
974 break;
975 case OHOS::AudioStandard::AUDIO_PIN_OUT_HEADSET:
976 break;
977 case OHOS::AudioStandard::AUDIO_PIN_OUT_LINEOUT:
978 break;
979 case OHOS::AudioStandard::AUDIO_PIN_OUT_HDMI:
980 break;
981 case OHOS::AudioStandard::AUDIO_PIN_OUT_USB:
982 break;
983 case OHOS::AudioStandard::AUDIO_PIN_OUT_USB_EXT:
984 break;
985 case OHOS::AudioStandard::AUDIO_PIN_OUT_DAUDIO_DEFAULT:
986 type = DEVICE_TYPE_DEFAULT;
987 break;
988 case OHOS::AudioStandard::AUDIO_PIN_IN_MIC:
989 type = DEVICE_TYPE_MIC;
990 break;
991 case OHOS::AudioStandard::AUDIO_PIN_IN_HS_MIC:
992 type = DEVICE_TYPE_WIRED_HEADSET;
993 break;
994 case OHOS::AudioStandard::AUDIO_PIN_IN_LINEIN:
995 break;
996 case OHOS::AudioStandard::AUDIO_PIN_IN_USB_EXT:
997 break;
998 case OHOS::AudioStandard::AUDIO_PIN_IN_DAUDIO_DEFAULT:
999 type = DEVICE_TYPE_DEFAULT;
1000 break;
1001 default:
1002 AUDIO_INFO_LOG("AudioSystemManager: GetTypeValueFromPin : invalid input parameter");
1003 break;
1004 }
1005 return type;
1006 }
1007 } // namespace AudioStandard
1008 } // namespace OHOS
1009