1 /*
2 * Copyright (C) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_proxy.h"
17
18 #ifdef SUPPORT_VIBRATOR
19 #include "vibrator_agent.h"
20 #endif
21
22 #include "telephony_log_wrapper.h"
23 #include "call_control_manager.h"
24 #include "bluetooth_call_manager.h"
25 #include "audio_control_manager.h"
26 #include "audio_group_manager.h"
27 #include "distributed_call_manager.h"
28 #include "distributed_communication_manager.h"
29
30 namespace OHOS {
31 namespace Telephony {
32 #ifdef SUPPORT_VIBRATOR
33 const std::unordered_map<VibrationType, VibratorUsage> VIBRATOR_USAGE_MAP = {
34 {VibrationType::VIBRATION_RINGTONE, USAGE_RING},
35 };
36
37 const std::unordered_map<VibrationType, int32_t> LOOP_COUNT_MAP = {
38 // Default loop count. Ringtone need be repeated.
39 {VibrationType::VIBRATION_RINGTONE, 10},
40 };
41
42 const std::unordered_map<VibrationType, std::string> EFFECT_ID_MAP = {
43 // Default effectId
44 {VibrationType::VIBRATION_RINGTONE, "haptic.ringtone.Dream_It_Possible"},
45 };
46 #endif
47
48 const int32_t NO_DEVICE_VALID = 0;
49 const int32_t RENDERER_FLAG = 0;
50 const std::string LOCAL_DEVICE = "LocalDevice";
51
AudioProxy()52 AudioProxy::AudioProxy()
53 : deviceCallback_(std::make_shared<AudioDeviceChangeCallback>()),
54 preferredDeviceCallback_(std::make_shared<AudioPreferDeviceChangeCallback>()),
55 audioMicStateChangeCallback_(std::make_shared<AudioMicStateChangeCallback>())
56 {}
57
~AudioProxy()58 AudioProxy::~AudioProxy() {}
59
SetVoiceRingtoneMute(bool isMute)60 bool AudioProxy::SetVoiceRingtoneMute(bool isMute)
61 {
62 return (AudioStandard::AudioSystemManager::GetInstance()->SetVoiceRingtoneMute(isMute) == TELEPHONY_SUCCESS);
63 }
64
SetAudioDeviceChangeCallback()65 int32_t AudioProxy::SetAudioDeviceChangeCallback()
66 {
67 if (deviceCallback_ == nullptr) {
68 TELEPHONY_LOGE("device callback nullptr");
69 return TELEPHONY_ERR_LOCAL_PTR_NULL;
70 }
71 return AudioStandard::AudioSystemManager::GetInstance()->SetDeviceChangeCallback(
72 AudioStandard::DeviceFlag::ALL_DEVICES_FLAG, deviceCallback_);
73 }
74
UnsetDeviceChangeCallback()75 int32_t AudioProxy::UnsetDeviceChangeCallback()
76 {
77 if (deviceCallback_ == nullptr) {
78 TELEPHONY_LOGI("device callback nullptr");
79 return TELEPHONY_SUCCESS;
80 }
81 return AudioStandard::AudioSystemManager::GetInstance()->UnsetDeviceChangeCallback();
82 }
83
SetBluetoothDevActive()84 bool AudioProxy::SetBluetoothDevActive()
85 {
86 if (AudioStandard::AudioSystemManager::GetInstance()->IsDeviceActive(
87 AudioStandard::DeviceType::DEVICE_TYPE_BLUETOOTH_SCO)) {
88 TELEPHONY_LOGI("bluetooth device is already active");
89 return true;
90 }
91 bool ret = AudioStandard::AudioSystemManager::GetInstance()->SetDeviceActive(
92 AudioStandard::DeviceType::DEVICE_TYPE_BLUETOOTH_SCO, true);
93 if (ret == ERR_NONE) {
94 return true;
95 }
96 return false;
97 }
98
SetSpeakerDevActive(bool isActive)99 bool AudioProxy::SetSpeakerDevActive(bool isActive)
100 {
101 bool ret = AudioStandard::AudioSystemManager::GetInstance()->SetDeviceActive(
102 AudioStandard::DeviceType::DEVICE_TYPE_SPEAKER, isActive);
103 if (ret == ERR_NONE) {
104 return true;
105 }
106 return false;
107 }
108
SetWiredHeadsetDevActive()109 bool AudioProxy::SetWiredHeadsetDevActive()
110 {
111 if (!isWiredHeadsetConnected_) {
112 TELEPHONY_LOGE("SetWiredHeadsetDevActive wiredheadset is not connected");
113 return false;
114 }
115 if (AudioStandard::AudioSystemManager::GetInstance()->
116 IsDeviceActive(AudioStandard::DeviceType::DEVICE_TYPE_USB_HEADSET)) {
117 TELEPHONY_LOGI("wired headset device is already active");
118 return true;
119 }
120 bool ret = AudioStandard::AudioSystemManager::GetInstance()->SetDeviceActive(
121 AudioStandard::DeviceType::DEVICE_TYPE_USB_HEADSET, true);
122 if (ret == ERR_NONE) {
123 return true;
124 }
125 return false;
126 }
127
SetEarpieceDevActive()128 bool AudioProxy::SetEarpieceDevActive()
129 {
130 if (isWiredHeadsetConnected_) {
131 TELEPHONY_LOGE("SetEarpieceDevActive wiredheadset is connected, no need set earpiece dev active");
132 return false;
133 }
134 if (AudioStandard::AudioSystemManager::GetInstance()->IsDeviceActive(
135 AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE)) {
136 TELEPHONY_LOGI("earpiece device is already active");
137 return true;
138 }
139 if (AudioStandard::AudioSystemManager::GetInstance()->SetDeviceActive(
140 AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE, true) != ERR_NONE) {
141 TELEPHONY_LOGE("SetEarpieceDevActive earpiece active fail");
142 return false;
143 }
144 return true;
145 }
146
StartVibrator()147 int32_t AudioProxy::StartVibrator()
148 {
149 VibrationType type = VibrationType::VIBRATION_RINGTONE;
150 TELEPHONY_LOGE("StartVibrator: for vibration type %{public}d", type);
151 int32_t result = TELEPHONY_SUCCESS;
152 #ifdef SUPPORT_VIBRATOR
153 bool setUsageRet = Sensors::SetUsage(VIBRATOR_USAGE_MAP.at(type));
154 bool setLoopRet = Sensors::SetLoopCount(LOOP_COUNT_MAP.at(type));
155 result = Sensors::StartVibrator(EFFECT_ID_MAP.at(type).c_str());
156 TELEPHONY_LOGE("StartVibrator: setUsageRet %{public}d, setLoopRet %{public}d, startRet %{public}d",
157 setUsageRet, setLoopRet, result);
158 #endif
159 return result;
160 }
161
StopVibrator()162 int32_t AudioProxy::StopVibrator()
163 {
164 int32_t result = TELEPHONY_SUCCESS;
165 #ifdef SUPPORT_VIBRATOR
166 result = Sensors::Cancel();
167 TELEPHONY_LOGE("StopVibrator: %{public}d", result);
168 #endif
169 return result;
170 }
171
GetVolume(AudioStandard::AudioVolumeType audioVolumeType)172 int32_t AudioProxy::GetVolume(AudioStandard::AudioVolumeType audioVolumeType)
173 {
174 return AudioStandard::AudioSystemManager::GetInstance()->GetVolume(audioVolumeType);
175 }
176
SetVolume(AudioStandard::AudioVolumeType audioVolumeType,int32_t volume)177 int32_t AudioProxy::SetVolume(AudioStandard::AudioVolumeType audioVolumeType, int32_t volume)
178 {
179 return AudioStandard::AudioSystemManager::GetInstance()->SetVolume(audioVolumeType, volume);
180 }
181
SetMaxVolume(AudioStandard::AudioVolumeType audioVolumeType)182 int32_t AudioProxy::SetMaxVolume(AudioStandard::AudioVolumeType audioVolumeType)
183 {
184 int32_t maxVolume = GetMaxVolume(audioVolumeType);
185 return AudioStandard::AudioSystemManager::GetInstance()->SetVolume(audioVolumeType, maxVolume);
186 }
187
SetVolumeAudible()188 void AudioProxy::SetVolumeAudible()
189 {
190 int32_t volume = GetMaxVolume(AudioStandard::AudioVolumeType::STREAM_VOICE_CALL);
191 SetVolume(AudioStandard::AudioVolumeType::STREAM_VOICE_CALL,
192 (int32_t)(volume / VOLUME_AUDIBLE_DIVISOR));
193 }
194
IsStreamActive(AudioStandard::AudioVolumeType audioVolumeType)195 bool AudioProxy::IsStreamActive(AudioStandard::AudioVolumeType audioVolumeType)
196 {
197 return AudioStandard::AudioSystemManager::GetInstance()->IsStreamActive(audioVolumeType);
198 }
199
IsStreamMute(AudioStandard::AudioVolumeType audioVolumeType)200 bool AudioProxy::IsStreamMute(AudioStandard::AudioVolumeType audioVolumeType)
201 {
202 return AudioStandard::AudioSystemManager::GetInstance()->IsStreamMute(audioVolumeType);
203 }
204
GetMaxVolume(AudioStandard::AudioVolumeType audioVolumeType)205 int32_t AudioProxy::GetMaxVolume(AudioStandard::AudioVolumeType audioVolumeType)
206 {
207 return AudioStandard::AudioSystemManager::GetInstance()->GetMaxVolume(audioVolumeType);
208 }
209
GetMinVolume(AudioStandard::AudioVolumeType audioVolumeType)210 int32_t AudioProxy::GetMinVolume(AudioStandard::AudioVolumeType audioVolumeType)
211 {
212 return AudioStandard::AudioSystemManager::GetInstance()->GetMinVolume(audioVolumeType);
213 }
214
IsMicrophoneMute()215 bool AudioProxy::IsMicrophoneMute()
216 {
217 std::shared_ptr<AudioStandard::AudioGroupManager> audioGroupManager =
218 AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(AudioStandard::DEFAULT_VOLUME_GROUP_ID);
219 if (audioGroupManager == nullptr) {
220 TELEPHONY_LOGE("IsMicrophoneMute fail, audioGroupManager is nullptr");
221 return false;
222 }
223 return audioGroupManager->IsMicrophoneMute();
224 }
225
SetMicrophoneMute(bool mute)226 bool AudioProxy::SetMicrophoneMute(bool mute)
227 {
228 if (mute == IsMicrophoneMute()) {
229 return true;
230 }
231 std::shared_ptr<AudioStandard::AudioGroupManager> audioGroupManager =
232 AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(AudioStandard::DEFAULT_VOLUME_GROUP_ID);
233 if (audioGroupManager == nullptr) {
234 TELEPHONY_LOGE("SetMicrophoneMute fail, audioGroupManager is nullptr");
235 return false;
236 }
237 int32_t muteResult = audioGroupManager->SetMicrophoneMute(mute);
238 TELEPHONY_LOGI("set microphone mute result : %{public}d, %{public}d ", muteResult, mute);
239 return (muteResult == TELEPHONY_SUCCESS);
240 }
241
GetRingerMode() const242 AudioStandard::AudioRingerMode AudioProxy::GetRingerMode() const
243 {
244 std::shared_ptr<AudioStandard::AudioGroupManager> audioGroupManager =
245 AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(AudioStandard::DEFAULT_VOLUME_GROUP_ID);
246 if (audioGroupManager == nullptr) {
247 TELEPHONY_LOGE("GetRingerMode fail, audioGroupManager is nullptr");
248 return AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL;
249 }
250 return audioGroupManager->GetRingerMode();
251 }
252
OnDeviceChange(const AudioStandard::DeviceChangeAction & deviceChangeAction)253 void AudioDeviceChangeCallback::OnDeviceChange(const AudioStandard::DeviceChangeAction &deviceChangeAction)
254 {
255 TELEPHONY_LOGI("AudioDeviceChangeCallback::OnDeviceChange enter");
256 for (auto &audioDeviceDescriptor : deviceChangeAction.deviceDescriptors) {
257 if (audioDeviceDescriptor->deviceType_ == AudioStandard::DEVICE_TYPE_WIRED_HEADSET ||
258 audioDeviceDescriptor->deviceType_ == AudioStandard::DEVICE_TYPE_WIRED_HEADPHONES ||
259 audioDeviceDescriptor->deviceType_ == AudioStandard::DEVICE_TYPE_USB_HEADSET) {
260 if (deviceChangeAction.type == AudioStandard::CONNECT) {
261 TELEPHONY_LOGI("WiredHeadset connected");
262 DelayedSingleton<AudioProxy>::GetInstance()->SetWiredHeadsetState(true);
263 DelayedSingleton<AudioDeviceManager>::GetInstance()->AddAudioDeviceList(
264 "", AudioDeviceType::DEVICE_WIRED_HEADSET, "");
265 } else {
266 TELEPHONY_LOGI("WiredHeadset disConnected");
267 DelayedSingleton<AudioProxy>::GetInstance()->SetWiredHeadsetState(false);
268 DelayedSingleton<AudioDeviceManager>::GetInstance()->RemoveAudioDeviceList(
269 "", AudioDeviceType::DEVICE_WIRED_HEADSET);
270 DelayedSingleton<AudioDeviceManager>::GetInstance()->ProcessEvent(
271 AudioEvent::WIRED_HEADSET_DISCONNECTED);
272 }
273 }
274 }
275 }
276
GetDefaultTonePath() const277 std::string AudioProxy::GetDefaultTonePath() const
278 {
279 return defaultTonePath_;
280 }
281
GetDefaultDtmfPath() const282 std::string AudioProxy::GetDefaultDtmfPath() const
283 {
284 return defaultDtmfPath_;
285 }
286
SetWiredHeadsetState(bool isConnected)287 void AudioProxy::SetWiredHeadsetState(bool isConnected)
288 {
289 isWiredHeadsetConnected_ = isConnected;
290 }
291
GetPreferredOutputAudioDevice(AudioDevice & device)292 int32_t AudioProxy::GetPreferredOutputAudioDevice(AudioDevice &device)
293 {
294 AudioStandard::AudioRendererInfo rendererInfo;
295 rendererInfo.contentType = AudioStandard::ContentType::CONTENT_TYPE_UNKNOWN;
296 rendererInfo.streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_VOICE_MODEM_COMMUNICATION;
297 rendererInfo.rendererFlags = RENDERER_FLAG;
298 std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> desc;
299 int32_t ret =
300 AudioStandard::AudioRoutingManager::GetInstance()->GetPreferredOutputDeviceForRendererInfo(rendererInfo, desc);
301 if (ret != TELEPHONY_SUCCESS) {
302 TELEPHONY_LOGE("GetPreferredOutputDeviceForRendererInfo fail");
303 return CALL_ERR_AUDIO_OPERATE_FAILED;
304 }
305 if (desc.size() == NO_DEVICE_VALID) {
306 TELEPHONY_LOGE("desc size is zero");
307 return CALL_ERR_AUDIO_OPERATE_FAILED;
308 }
309 switch (desc[0]->deviceType_) {
310 case AudioStandard::DEVICE_TYPE_BLUETOOTH_SCO:
311 device.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO;
312 if (memset_s(&device.address, kMaxAddressLen + 1, 0, kMaxAddressLen + 1) != EOK ||
313 memset_s(&device.deviceName, kMaxDeviceNameLen + 1, 0, kMaxDeviceNameLen + 1) != EOK) {
314 TELEPHONY_LOGE("memset_s address fail");
315 return TELEPHONY_ERR_MEMSET_FAIL;
316 }
317 if (memcpy_s(device.address, kMaxAddressLen, desc[0]->macAddress_.c_str(),
318 desc[0]->macAddress_.length()) != EOK ||
319 memcpy_s(&device.deviceName, kMaxDeviceNameLen, desc[0]->deviceName_.c_str(),
320 desc[0]->deviceName_.length()) != EOK) {
321 TELEPHONY_LOGE("memcpy_s address fail");
322 return TELEPHONY_ERR_MEMCPY_FAIL;
323 }
324 break;
325 case AudioStandard::DEVICE_TYPE_EARPIECE:
326 device.deviceType = AudioDeviceType::DEVICE_EARPIECE;
327 break;
328 case AudioStandard::DEVICE_TYPE_SPEAKER:
329 device.deviceType = AudioDeviceType::DEVICE_SPEAKER;
330 break;
331 case AudioStandard::DEVICE_TYPE_WIRED_HEADSET:
332 case AudioStandard::DEVICE_TYPE_WIRED_HEADPHONES:
333 case AudioStandard::DEVICE_TYPE_USB_HEADSET:
334 device.deviceType = AudioDeviceType::DEVICE_WIRED_HEADSET;
335 break;
336 default:
337 break;
338 }
339 return TELEPHONY_SUCCESS;
340 }
341
SetAudioPreferDeviceChangeCallback()342 int32_t AudioProxy::SetAudioPreferDeviceChangeCallback()
343 {
344 if (preferredDeviceCallback_ == nullptr) {
345 TELEPHONY_LOGE("preferredDeviceCallback_ is nullptr");
346 return TELEPHONY_ERR_LOCAL_PTR_NULL;
347 }
348 AudioStandard::AudioRendererInfo rendererInfo;
349 rendererInfo.contentType = AudioStandard::ContentType::CONTENT_TYPE_SPEECH;
350 rendererInfo.streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_VOICE_MODEM_COMMUNICATION;
351 rendererInfo.rendererFlags = RENDERER_FLAG;
352 int32_t ret = AudioStandard::AudioRoutingManager::GetInstance()->SetPreferredOutputDeviceChangeCallback(
353 rendererInfo, preferredDeviceCallback_);
354 if (ret != TELEPHONY_SUCCESS) {
355 TELEPHONY_LOGE("SetPreferredOutputDeviceChangeCallback fail");
356 return CALL_ERR_AUDIO_OPERATE_FAILED;
357 }
358 return TELEPHONY_SUCCESS;
359 }
360
UnsetAudioPreferDeviceChangeCallback()361 int32_t AudioProxy::UnsetAudioPreferDeviceChangeCallback()
362 {
363 if (preferredDeviceCallback_ == nullptr) {
364 TELEPHONY_LOGE("preferredDeviceCallback_ is nullptr");
365 return TELEPHONY_ERR_LOCAL_PTR_NULL;
366 }
367 int32_t ret = AudioStandard::AudioRoutingManager::GetInstance()->UnsetPreferredOutputDeviceChangeCallback();
368 if (ret != TELEPHONY_SUCCESS) {
369 TELEPHONY_LOGE("UnsetPreferredOutputDeviceChangeCallback fail");
370 return CALL_ERR_AUDIO_OPERATE_FAILED;
371 }
372 return TELEPHONY_SUCCESS;
373 }
374
OnPreferredOutputDeviceUpdated(const std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> & desc)375 void AudioPreferDeviceChangeCallback::OnPreferredOutputDeviceUpdated(
376 const std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> &desc)
377 {
378 bool hasCall = DelayedSingleton<CallControlManager>::GetInstance()->HasCall() ||
379 DelayedSingleton<CallControlManager>::GetInstance()->HasVoipCall();
380 if (!hasCall) {
381 TELEPHONY_LOGE("no call exists, on preferred audio device update failed");
382 return;
383 }
384 AudioDevice device;
385 if (desc.size() == NO_DEVICE_VALID) {
386 TELEPHONY_LOGE("desc size is zero");
387 return;
388 }
389 if (DelayedSingleton<DistributedCommunicationManager>::GetInstance()->IsAudioOnSink() &&
390 !DelayedSingleton<DistributedCommunicationManager>::GetInstance()->IsSinkRole()) {
391 TELEPHONY_LOGI("has already switch to distributed communication device");
392 return;
393 }
394 TELEPHONY_LOGI("OnPreferredOutputDeviceUpdated type: %{public}d", desc[0]->deviceType_);
395
396 if (IsDistributedDeviceSelected(desc)) {
397 return;
398 }
399
400 switch (desc[0]->deviceType_) {
401 case AudioStandard::DEVICE_TYPE_BLUETOOTH_SCO:
402 if (!SetBluetoothDevice(device, desc)) {
403 return;
404 }
405 DelayedSingleton<AudioDeviceManager>::GetInstance()->SetCurrentAudioDevice(device);
406 break;
407 case AudioStandard::DEVICE_TYPE_EARPIECE:
408 device.deviceType = AudioDeviceType::DEVICE_EARPIECE;
409 DelayedSingleton<AudioDeviceManager>::GetInstance()->SetCurrentAudioDevice(device.deviceType);
410 break;
411 case AudioStandard::DEVICE_TYPE_SPEAKER:
412 device.deviceType = AudioDeviceType::DEVICE_SPEAKER;
413 DelayedSingleton<AudioDeviceManager>::GetInstance()->SetCurrentAudioDevice(device.deviceType);
414 break;
415 case AudioStandard::DEVICE_TYPE_WIRED_HEADSET:
416 case AudioStandard::DEVICE_TYPE_WIRED_HEADPHONES:
417 case AudioStandard::DEVICE_TYPE_USB_HEADSET:
418 device.deviceType = AudioDeviceType::DEVICE_WIRED_HEADSET;
419 DelayedSingleton<AudioDeviceManager>::GetInstance()->AddAudioDeviceList(
420 "", AudioDeviceType::DEVICE_WIRED_HEADSET, "");
421 DelayedSingleton<AudioDeviceManager>::GetInstance()->SetCurrentAudioDevice(device.deviceType);
422 break;
423 default:
424 break;
425 }
426 TELEPHONY_LOGI("OnPreferredOutputDeviceUpdated, type: %{public}d", static_cast<int32_t>(desc[0]->deviceType_));
427 if (desc[0]->deviceType_ != AudioStandard::DEVICE_TYPE_SPEAKER) {
428 DelayedSingleton<AudioControlManager>::GetInstance()->UpdateDeviceTypeForCrs();
429 }
430 }
431
SetBluetoothDevice(AudioDevice & device,const std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> & desc)432 bool AudioPreferDeviceChangeCallback::SetBluetoothDevice(AudioDevice &device,
433 const std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> &desc)
434 {
435 device.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO;
436 if (memset_s(&device.address, kMaxAddressLen + 1, 0, kMaxAddressLen + 1) != EOK ||
437 memset_s(&device.deviceName, kMaxDeviceNameLen + 1, 0, kMaxDeviceNameLen + 1) != EOK) {
438 TELEPHONY_LOGE("memset_s address fail");
439 return false;
440 }
441 if (memcpy_s(device.address, kMaxAddressLen, desc[0]->macAddress_.c_str(),
442 desc[0]->macAddress_.length()) != EOK ||
443 memcpy_s(device.deviceName, kMaxDeviceNameLen, desc[0]->deviceName_.c_str(),
444 desc[0]->deviceName_.length()) != EOK) {
445 TELEPHONY_LOGE("memcpy_s address fail");
446 return false;
447 }
448 return true;
449 }
450
IsDistributedDeviceSelected(const std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> & desc)451 bool AudioPreferDeviceChangeCallback::IsDistributedDeviceSelected(
452 const std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> &desc)
453 {
454 size_t size = desc.size();
455 TELEPHONY_LOGI("desc size is: %{public}zu", size);
456 for (auto iter = desc.begin(); iter != desc.end(); iter++) {
457 std::string networkId = (*iter)->networkId_;
458 if (LOCAL_DEVICE != networkId && (*iter)->deviceType_ == AudioStandard::DEVICE_TYPE_SPEAKER) {
459 TELEPHONY_LOGI("distributed device networkId.");
460 return true;
461 }
462 }
463 return false;
464 }
465
SetAudioMicStateChangeCallback()466 int32_t AudioProxy::SetAudioMicStateChangeCallback()
467 {
468 if (audioMicStateChangeCallback_ == nullptr) {
469 TELEPHONY_LOGE("audioMicStateChangeCallback_ is nullptr");
470 return TELEPHONY_ERR_LOCAL_PTR_NULL;
471 }
472 std::shared_ptr<AudioStandard::AudioGroupManager> audioGroupManager =
473 AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(AudioStandard::DEFAULT_VOLUME_GROUP_ID);
474 if (audioGroupManager == nullptr) {
475 TELEPHONY_LOGE("SetAudioMicStateChangeCallback fail, audioGroupManager is nullptr");
476 return false;
477 }
478 int32_t ret = audioGroupManager->SetMicStateChangeCallback(audioMicStateChangeCallback_);
479 if (ret != TELEPHONY_SUCCESS) {
480 TELEPHONY_LOGE("SetPreferredOutputDeviceChangeCallback fail");
481 return CALL_ERR_AUDIO_OPERATE_FAILED;
482 }
483 return TELEPHONY_SUCCESS;
484 }
485
UnsetAudioMicStateChangeCallback()486 int32_t AudioProxy::UnsetAudioMicStateChangeCallback()
487 {
488 if (audioMicStateChangeCallback_ == nullptr) {
489 TELEPHONY_LOGE("audioMicStateChangeCallback_ is nullptr");
490 return TELEPHONY_ERR_LOCAL_PTR_NULL;
491 }
492 std::shared_ptr<AudioStandard::AudioGroupManager> audioGroupManager =
493 AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(AudioStandard::DEFAULT_VOLUME_GROUP_ID);
494 if (audioGroupManager == nullptr) {
495 TELEPHONY_LOGE("UnsetAudioMicStateChangeCallback fail, audioGroupManager is nullptr");
496 return false;
497 }
498 int32_t ret = audioGroupManager->UnsetMicStateChangeCallback(audioMicStateChangeCallback_);
499 if (ret != TELEPHONY_SUCCESS) {
500 TELEPHONY_LOGE("UnsetAudioMicStateChangeCallback fail");
501 return CALL_ERR_AUDIO_OPERATE_FAILED;
502 }
503 return TELEPHONY_SUCCESS;
504 }
505
OnMicStateUpdated(const AudioStandard::MicStateChangeEvent & micStateChangeEvent)506 void AudioMicStateChangeCallback::OnMicStateUpdated(
507 const AudioStandard::MicStateChangeEvent &micStateChangeEvent)
508 {
509 std::shared_ptr<AudioStandard::AudioGroupManager> audioGroupManager =
510 AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(AudioStandard::DEFAULT_VOLUME_GROUP_ID);
511 if (audioGroupManager == nullptr) {
512 TELEPHONY_LOGE("OnMicStateUpdated fail, audioGroupManager is nullptr");
513 return;
514 }
515 DelayedSingleton<CallControlManager>::GetInstance()->SetMuted(audioGroupManager->IsMicrophoneMute());
516 }
517
GetSystemRingVolumeInDb(int32_t volumeLevel)518 float AudioProxy::GetSystemRingVolumeInDb(int32_t volumeLevel)
519 {
520 std::shared_ptr<AudioStandard::AudioGroupManager> audioGroupManager =
521 AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(AudioStandard::DEFAULT_VOLUME_GROUP_ID);
522 if (audioGroupManager == nullptr) {
523 TELEPHONY_LOGE("GetSystemRingVolumeInDb fail, audioGroupManager is nullptr");
524 return 0;
525 }
526 return audioGroupManager->GetSystemVolumeInDb(AudioStandard::AudioVolumeType::STREAM_RING,
527 volumeLevel, AudioStandard::DEVICE_TYPE_SPEAKER);
528 }
529 } // namespace Telephony
530 } // namespace OHOS
531