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
29 namespace OHOS {
30 namespace Telephony {
31 #ifdef SUPPORT_VIBRATOR
32 const std::unordered_map<VibrationType, VibratorUsage> VIBRATOR_USAGE_MAP = {
33 {VibrationType::VIBRATION_RINGTONE, USAGE_RING},
34 };
35
36 const std::unordered_map<VibrationType, int32_t> LOOP_COUNT_MAP = {
37 // Default loop count. Ringtone need be repeated.
38 {VibrationType::VIBRATION_RINGTONE, 10},
39 };
40
41 const std::unordered_map<VibrationType, std::string> EFFECT_ID_MAP = {
42 // Default effectId
43 {VibrationType::VIBRATION_RINGTONE, "haptic.ringtone.Dream_It_Possible"},
44 };
45 #endif
46
47 const int32_t NO_DEVICE_VALID = 0;
48 const int32_t RENDERER_FLAG = 0;
49
AudioProxy()50 AudioProxy::AudioProxy()
51 : deviceCallback_(std::make_shared<AudioDeviceChangeCallback>()),
52 preferredDeviceCallback_(std::make_shared<AudioPreferDeviceChangeCallback>()),
53 audioMicStateChangeCallback_(std::make_shared<AudioMicStateChangeCallback>())
54 {}
55
~AudioProxy()56 AudioProxy::~AudioProxy() {}
57
SetAudioScene(AudioStandard::AudioScene audioScene)58 bool AudioProxy::SetAudioScene(AudioStandard::AudioScene audioScene)
59 {
60 return (AudioStandard::AudioSystemManager::GetInstance()->SetAudioScene(audioScene) == TELEPHONY_SUCCESS);
61 }
62
SetAudioDeviceChangeCallback()63 int32_t AudioProxy::SetAudioDeviceChangeCallback()
64 {
65 if (deviceCallback_ == nullptr) {
66 TELEPHONY_LOGE("device callback nullptr");
67 return TELEPHONY_ERR_LOCAL_PTR_NULL;
68 }
69 return AudioStandard::AudioSystemManager::GetInstance()->SetDeviceChangeCallback(
70 AudioStandard::DeviceFlag::ALL_DEVICES_FLAG, deviceCallback_);
71 }
72
UnsetDeviceChangeCallback()73 int32_t AudioProxy::UnsetDeviceChangeCallback()
74 {
75 if (deviceCallback_ == nullptr) {
76 TELEPHONY_LOGI("device callback nullptr");
77 return TELEPHONY_SUCCESS;
78 }
79 return AudioStandard::AudioSystemManager::GetInstance()->UnsetDeviceChangeCallback();
80 }
81
SetBluetoothDevActive()82 bool AudioProxy::SetBluetoothDevActive()
83 {
84 if (AudioStandard::AudioSystemManager::GetInstance()->IsDeviceActive(
85 AudioStandard::DeviceType::DEVICE_TYPE_BLUETOOTH_SCO)) {
86 TELEPHONY_LOGI("bluetooth device is already active");
87 return true;
88 }
89 bool ret = AudioStandard::AudioSystemManager::GetInstance()->SetDeviceActive(
90 AudioStandard::DeviceType::DEVICE_TYPE_BLUETOOTH_SCO, true);
91 if (ret == ERR_NONE) {
92 return true;
93 }
94 return false;
95 }
96
SetSpeakerDevActive()97 bool AudioProxy::SetSpeakerDevActive()
98 {
99 if (AudioStandard::AudioSystemManager::GetInstance()->
100 IsDeviceActive(AudioStandard::DeviceType::DEVICE_TYPE_SPEAKER)) {
101 TELEPHONY_LOGI("speaker device is already active");
102 return true;
103 }
104 bool ret = AudioStandard::AudioSystemManager::GetInstance()->SetDeviceActive(
105 AudioStandard::DeviceType::DEVICE_TYPE_SPEAKER, true);
106 if (ret == ERR_NONE) {
107 return true;
108 }
109 return false;
110 }
111
SetWiredHeadsetDevActive()112 bool AudioProxy::SetWiredHeadsetDevActive()
113 {
114 if (!isWiredHeadsetConnected_) {
115 TELEPHONY_LOGE("SetWiredHeadsetDevActive wiredheadset is not connected");
116 return false;
117 }
118 if (AudioStandard::AudioSystemManager::GetInstance()->
119 IsDeviceActive(AudioStandard::DeviceType::DEVICE_TYPE_USB_HEADSET)) {
120 TELEPHONY_LOGI("wired headset device is already active");
121 return true;
122 }
123 bool ret = AudioStandard::AudioSystemManager::GetInstance()->SetDeviceActive(
124 AudioStandard::DeviceType::DEVICE_TYPE_USB_HEADSET, true);
125 if (ret == ERR_NONE) {
126 return true;
127 }
128 return false;
129 }
130
SetEarpieceDevActive()131 bool AudioProxy::SetEarpieceDevActive()
132 {
133 if (isWiredHeadsetConnected_) {
134 TELEPHONY_LOGE("SetEarpieceDevActive wiredheadset is connected, no need set earpiece dev active");
135 return false;
136 }
137 if (AudioStandard::AudioSystemManager::GetInstance()->IsDeviceActive(
138 AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE)) {
139 TELEPHONY_LOGI("earpiece device is already active");
140 return true;
141 }
142 if (AudioStandard::AudioSystemManager::GetInstance()->SetDeviceActive(
143 AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE, true) != ERR_NONE) {
144 TELEPHONY_LOGE("SetEarpieceDevActive earpiece active fail");
145 return false;
146 }
147 return true;
148 }
149
StartVibrator()150 int32_t AudioProxy::StartVibrator()
151 {
152 VibrationType type = VibrationType::VIBRATION_RINGTONE;
153 TELEPHONY_LOGE("StartVibrator: for vibration type %{public}d", type);
154 int32_t result = TELEPHONY_SUCCESS;
155 #ifdef SUPPORT_VIBRATOR
156 bool setUsageRet = Sensors::SetUsage(VIBRATOR_USAGE_MAP.at(type));
157 bool setLoopRet = Sensors::SetLoopCount(LOOP_COUNT_MAP.at(type));
158 result = Sensors::StartVibrator(EFFECT_ID_MAP.at(type).c_str());
159 TELEPHONY_LOGE("StartVibrator: setUsageRet %{public}d, setLoopRet %{public}d, startRet %{public}d",
160 setUsageRet, setLoopRet, result);
161 #endif
162 return result;
163 }
164
StopVibrator()165 int32_t AudioProxy::StopVibrator()
166 {
167 int32_t result = TELEPHONY_SUCCESS;
168 #ifdef SUPPORT_VIBRATOR
169 result = Sensors::Cancel();
170 TELEPHONY_LOGE("StopVibrator: %{public}d", result);
171 #endif
172 return result;
173 }
174
GetVolume(AudioStandard::AudioVolumeType audioVolumeType)175 int32_t AudioProxy::GetVolume(AudioStandard::AudioVolumeType audioVolumeType)
176 {
177 return AudioStandard::AudioSystemManager::GetInstance()->GetVolume(audioVolumeType);
178 }
179
SetVolume(AudioStandard::AudioVolumeType audioVolumeType,int32_t volume)180 int32_t AudioProxy::SetVolume(AudioStandard::AudioVolumeType audioVolumeType, int32_t volume)
181 {
182 return AudioStandard::AudioSystemManager::GetInstance()->SetVolume(audioVolumeType, volume);
183 }
184
SetMaxVolume(AudioStandard::AudioVolumeType audioVolumeType)185 int32_t AudioProxy::SetMaxVolume(AudioStandard::AudioVolumeType audioVolumeType)
186 {
187 int32_t maxVolume = GetMaxVolume(audioVolumeType);
188 return AudioStandard::AudioSystemManager::GetInstance()->SetVolume(audioVolumeType, maxVolume);
189 }
190
SetVolumeAudible()191 void AudioProxy::SetVolumeAudible()
192 {
193 int32_t volume = GetMaxVolume(AudioStandard::AudioVolumeType::STREAM_VOICE_CALL);
194 SetVolume(AudioStandard::AudioVolumeType::STREAM_VOICE_CALL,
195 (int32_t)(volume / VOLUME_AUDIBLE_DIVISOR));
196 }
197
IsStreamActive(AudioStandard::AudioVolumeType audioVolumeType)198 bool AudioProxy::IsStreamActive(AudioStandard::AudioVolumeType audioVolumeType)
199 {
200 return AudioStandard::AudioSystemManager::GetInstance()->IsStreamActive(audioVolumeType);
201 }
202
IsStreamMute(AudioStandard::AudioVolumeType audioVolumeType)203 bool AudioProxy::IsStreamMute(AudioStandard::AudioVolumeType audioVolumeType)
204 {
205 return AudioStandard::AudioSystemManager::GetInstance()->IsStreamMute(audioVolumeType);
206 }
207
GetMaxVolume(AudioStandard::AudioVolumeType audioVolumeType)208 int32_t AudioProxy::GetMaxVolume(AudioStandard::AudioVolumeType audioVolumeType)
209 {
210 return AudioStandard::AudioSystemManager::GetInstance()->GetMaxVolume(audioVolumeType);
211 }
212
GetMinVolume(AudioStandard::AudioVolumeType audioVolumeType)213 int32_t AudioProxy::GetMinVolume(AudioStandard::AudioVolumeType audioVolumeType)
214 {
215 return AudioStandard::AudioSystemManager::GetInstance()->GetMinVolume(audioVolumeType);
216 }
217
IsMicrophoneMute()218 bool AudioProxy::IsMicrophoneMute()
219 {
220 std::shared_ptr<AudioStandard::AudioGroupManager> audioGroupManager =
221 AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(AudioStandard::DEFAULT_VOLUME_GROUP_ID);
222 if (audioGroupManager == nullptr) {
223 TELEPHONY_LOGE("IsMicrophoneMute fail, audioGroupManager is nullptr");
224 return false;
225 }
226 return audioGroupManager->IsMicrophoneMute();
227 }
228
SetMicrophoneMute(bool mute)229 bool AudioProxy::SetMicrophoneMute(bool mute)
230 {
231 if (mute == IsMicrophoneMute()) {
232 return true;
233 }
234 std::shared_ptr<AudioStandard::AudioGroupManager> audioGroupManager =
235 AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(AudioStandard::DEFAULT_VOLUME_GROUP_ID);
236 if (audioGroupManager == nullptr) {
237 TELEPHONY_LOGE("SetMicrophoneMute fail, audioGroupManager is nullptr");
238 return false;
239 }
240 int32_t muteResult = audioGroupManager->SetMicrophoneMute(mute);
241 TELEPHONY_LOGI("set microphone mute result : %{public}d, %{public}d ", muteResult, mute);
242 return (muteResult == TELEPHONY_SUCCESS);
243 }
244
GetRingerMode() const245 AudioStandard::AudioRingerMode AudioProxy::GetRingerMode() const
246 {
247 std::shared_ptr<AudioStandard::AudioGroupManager> audioGroupManager =
248 AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(AudioStandard::DEFAULT_VOLUME_GROUP_ID);
249 if (audioGroupManager == nullptr) {
250 TELEPHONY_LOGE("GetRingerMode fail, audioGroupManager is nullptr");
251 return AudioStandard::AudioRingerMode::RINGER_MODE_NORMAL;
252 }
253 return audioGroupManager->GetRingerMode();
254 }
255
OnDeviceChange(const AudioStandard::DeviceChangeAction & deviceChangeAction)256 void AudioDeviceChangeCallback::OnDeviceChange(const AudioStandard::DeviceChangeAction &deviceChangeAction)
257 {
258 TELEPHONY_LOGI("AudioDeviceChangeCallback::OnDeviceChange enter");
259 for (auto &audioDeviceDescriptor : deviceChangeAction.deviceDescriptors) {
260 if (audioDeviceDescriptor->deviceType_ == AudioStandard::DEVICE_TYPE_WIRED_HEADSET ||
261 audioDeviceDescriptor->deviceType_ == AudioStandard::DEVICE_TYPE_WIRED_HEADPHONES ||
262 audioDeviceDescriptor->deviceType_ == AudioStandard::DEVICE_TYPE_USB_HEADSET) {
263 if (deviceChangeAction.type == AudioStandard::CONNECT) {
264 TELEPHONY_LOGI("WiredHeadset connected");
265 DelayedSingleton<AudioProxy>::GetInstance()->SetWiredHeadsetState(true);
266 DelayedSingleton<AudioDeviceManager>::GetInstance()->AddAudioDeviceList(
267 "", AudioDeviceType::DEVICE_WIRED_HEADSET, "");
268 } else {
269 TELEPHONY_LOGI("WiredHeadset disConnected");
270 DelayedSingleton<AudioProxy>::GetInstance()->SetWiredHeadsetState(false);
271 DelayedSingleton<AudioDeviceManager>::GetInstance()->RemoveAudioDeviceList(
272 "", AudioDeviceType::DEVICE_WIRED_HEADSET);
273 DelayedSingleton<AudioDeviceManager>::GetInstance()->ProcessEvent(
274 AudioEvent::WIRED_HEADSET_DISCONNECTED);
275 }
276 }
277 }
278 }
279
GetDefaultTonePath() const280 std::string AudioProxy::GetDefaultTonePath() const
281 {
282 return defaultTonePath_;
283 }
284
GetDefaultDtmfPath() const285 std::string AudioProxy::GetDefaultDtmfPath() const
286 {
287 return defaultDtmfPath_;
288 }
289
SetWiredHeadsetState(bool isConnected)290 void AudioProxy::SetWiredHeadsetState(bool isConnected)
291 {
292 isWiredHeadsetConnected_ = isConnected;
293 }
294
GetPreferredOutputAudioDevice(AudioDevice & device)295 int32_t AudioProxy::GetPreferredOutputAudioDevice(AudioDevice &device)
296 {
297 AudioStandard::AudioRendererInfo rendererInfo;
298 rendererInfo.contentType = AudioStandard::ContentType::CONTENT_TYPE_UNKNOWN;
299 rendererInfo.streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_VOICE_MODEM_COMMUNICATION;
300 rendererInfo.rendererFlags = RENDERER_FLAG;
301 std::vector<sptr<AudioStandard::AudioDeviceDescriptor>> desc;
302 int32_t ret =
303 AudioStandard::AudioRoutingManager::GetInstance()->GetPreferredOutputDeviceForRendererInfo(rendererInfo, desc);
304 if (ret != TELEPHONY_SUCCESS) {
305 TELEPHONY_LOGE("GetPreferredOutputDeviceForRendererInfo fail");
306 return CALL_ERR_AUDIO_OPERATE_FAILED;
307 }
308 if (desc.size() == NO_DEVICE_VALID) {
309 TELEPHONY_LOGE("desc size is zero");
310 return CALL_ERR_AUDIO_OPERATE_FAILED;
311 }
312 switch (desc[0]->deviceType_) {
313 case AudioStandard::DEVICE_TYPE_BLUETOOTH_SCO:
314 device.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO;
315 if (memset_s(&device.address, kMaxAddressLen + 1, 0, kMaxAddressLen + 1) != EOK ||
316 memset_s(&device.deviceName, kMaxDeviceNameLen + 1, 0, kMaxDeviceNameLen + 1) != EOK) {
317 TELEPHONY_LOGE("memset_s address fail");
318 return TELEPHONY_ERR_MEMSET_FAIL;
319 }
320 if (memcpy_s(device.address, kMaxAddressLen, desc[0]->macAddress_.c_str(),
321 desc[0]->macAddress_.length()) != EOK ||
322 memcpy_s(&device.deviceName, kMaxDeviceNameLen, desc[0]->deviceName_.c_str(),
323 desc[0]->deviceName_.length()) != EOK) {
324 TELEPHONY_LOGE("memcpy_s address fail");
325 return TELEPHONY_ERR_MEMCPY_FAIL;
326 }
327 break;
328 case AudioStandard::DEVICE_TYPE_EARPIECE:
329 device.deviceType = AudioDeviceType::DEVICE_EARPIECE;
330 break;
331 case AudioStandard::DEVICE_TYPE_SPEAKER:
332 device.deviceType = AudioDeviceType::DEVICE_SPEAKER;
333 break;
334 case AudioStandard::DEVICE_TYPE_WIRED_HEADSET:
335 case AudioStandard::DEVICE_TYPE_WIRED_HEADPHONES:
336 case AudioStandard::DEVICE_TYPE_USB_HEADSET:
337 device.deviceType = AudioDeviceType::DEVICE_WIRED_HEADSET;
338 break;
339 default:
340 break;
341 }
342 return TELEPHONY_SUCCESS;
343 }
344
SetAudioPreferDeviceChangeCallback()345 int32_t AudioProxy::SetAudioPreferDeviceChangeCallback()
346 {
347 if (preferredDeviceCallback_ == nullptr) {
348 TELEPHONY_LOGE("preferredDeviceCallback_ is nullptr");
349 return TELEPHONY_ERR_LOCAL_PTR_NULL;
350 }
351 AudioStandard::AudioRendererInfo rendererInfo;
352 rendererInfo.contentType = AudioStandard::ContentType::CONTENT_TYPE_SPEECH;
353 rendererInfo.streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_VOICE_MODEM_COMMUNICATION;
354 rendererInfo.rendererFlags = RENDERER_FLAG;
355 int32_t ret = AudioStandard::AudioRoutingManager::GetInstance()->SetPreferredOutputDeviceChangeCallback(
356 rendererInfo, preferredDeviceCallback_);
357 if (ret != TELEPHONY_SUCCESS) {
358 TELEPHONY_LOGE("SetPreferredOutputDeviceChangeCallback fail");
359 return CALL_ERR_AUDIO_OPERATE_FAILED;
360 }
361 return TELEPHONY_SUCCESS;
362 }
363
UnsetAudioPreferDeviceChangeCallback()364 int32_t AudioProxy::UnsetAudioPreferDeviceChangeCallback()
365 {
366 if (preferredDeviceCallback_ == nullptr) {
367 TELEPHONY_LOGE("preferredDeviceCallback_ is nullptr");
368 return TELEPHONY_ERR_LOCAL_PTR_NULL;
369 }
370 int32_t ret = AudioStandard::AudioRoutingManager::GetInstance()->UnsetPreferredOutputDeviceChangeCallback();
371 if (ret != TELEPHONY_SUCCESS) {
372 TELEPHONY_LOGE("UnsetPreferredOutputDeviceChangeCallback fail");
373 return CALL_ERR_AUDIO_OPERATE_FAILED;
374 }
375 return TELEPHONY_SUCCESS;
376 }
377
OnPreferredOutputDeviceUpdated(const std::vector<sptr<AudioStandard::AudioDeviceDescriptor>> & desc)378 void AudioPreferDeviceChangeCallback::OnPreferredOutputDeviceUpdated(
379 const std::vector<sptr<AudioStandard::AudioDeviceDescriptor>> &desc)
380 {
381 AudioDevice device;
382 if (desc.size() == NO_DEVICE_VALID) {
383 TELEPHONY_LOGE("desc size is zero");
384 return;
385 }
386 if (DelayedSingleton<DistributedCallManager>::GetInstance()->IsDCallDeviceSwitchedOn()) {
387 TELEPHONY_LOGW("has already switch to distributed audio device");
388 return;
389 }
390 TELEPHONY_LOGI("OnPreferredOutputDeviceUpdated type: %{public}d", desc[0]->deviceType_);
391 switch (desc[0]->deviceType_) {
392 case AudioStandard::DEVICE_TYPE_BLUETOOTH_SCO:
393 device.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO;
394 if (memset_s(&device.address, kMaxAddressLen + 1, 0, kMaxAddressLen + 1) != EOK ||
395 memset_s(&device.deviceName, kMaxDeviceNameLen + 1, 0, kMaxDeviceNameLen + 1) != EOK) {
396 TELEPHONY_LOGE("memset_s address fail");
397 return;
398 }
399 if (memcpy_s(device.address, kMaxAddressLen, desc[0]->macAddress_.c_str(),
400 desc[0]->macAddress_.length()) != EOK ||
401 memcpy_s(device.deviceName, kMaxDeviceNameLen, desc[0]->deviceName_.c_str(),
402 desc[0]->deviceName_.length()) != EOK) {
403 TELEPHONY_LOGE("memcpy_s address fail");
404 return;
405 }
406 DelayedSingleton<AudioDeviceManager>::GetInstance()->SetCurrentAudioDevice(device);
407 break;
408 case AudioStandard::DEVICE_TYPE_EARPIECE:
409 device.deviceType = AudioDeviceType::DEVICE_EARPIECE;
410 DelayedSingleton<AudioDeviceManager>::GetInstance()->SetCurrentAudioDevice(device.deviceType);
411 break;
412 case AudioStandard::DEVICE_TYPE_SPEAKER:
413 device.deviceType = AudioDeviceType::DEVICE_SPEAKER;
414 DelayedSingleton<AudioDeviceManager>::GetInstance()->SetCurrentAudioDevice(device.deviceType);
415 break;
416 case AudioStandard::DEVICE_TYPE_WIRED_HEADSET:
417 case AudioStandard::DEVICE_TYPE_WIRED_HEADPHONES:
418 case AudioStandard::DEVICE_TYPE_USB_HEADSET:
419 device.deviceType = AudioDeviceType::DEVICE_WIRED_HEADSET;
420 DelayedSingleton<AudioDeviceManager>::GetInstance()->AddAudioDeviceList(
421 "", AudioDeviceType::DEVICE_WIRED_HEADSET, "");
422 DelayedSingleton<AudioDeviceManager>::GetInstance()->SetCurrentAudioDevice(device.deviceType);
423 break;
424 default:
425 break;
426 }
427 TELEPHONY_LOGI("OnPreferredOutputDeviceUpdated, type: %{public}d", static_cast<int32_t>(desc[0]->deviceType_));
428 if (desc[0]->deviceType_ != AudioStandard::DEVICE_TYPE_SPEAKER) {
429 DelayedSingleton<AudioControlManager>::GetInstance()->UpdateDeviceTypeForCrs();
430 }
431 }
432
SetAudioMicStateChangeCallback()433 int32_t AudioProxy::SetAudioMicStateChangeCallback()
434 {
435 if (audioMicStateChangeCallback_ == nullptr) {
436 TELEPHONY_LOGE("audioMicStateChangeCallback_ is nullptr");
437 return TELEPHONY_ERR_LOCAL_PTR_NULL;
438 }
439 std::shared_ptr<AudioStandard::AudioGroupManager> audioGroupManager =
440 AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(AudioStandard::DEFAULT_VOLUME_GROUP_ID);
441 if (audioGroupManager == nullptr) {
442 TELEPHONY_LOGE("SetAudioMicStateChangeCallback fail, audioGroupManager is nullptr");
443 return false;
444 }
445 int32_t ret = audioGroupManager->SetMicStateChangeCallback(audioMicStateChangeCallback_);
446 if (ret != TELEPHONY_SUCCESS) {
447 TELEPHONY_LOGE("SetPreferredOutputDeviceChangeCallback fail");
448 return CALL_ERR_AUDIO_OPERATE_FAILED;
449 }
450 return TELEPHONY_SUCCESS;
451 }
452
UnsetAudioMicStateChangeCallback()453 int32_t AudioProxy::UnsetAudioMicStateChangeCallback()
454 {
455 if (audioMicStateChangeCallback_ == nullptr) {
456 TELEPHONY_LOGE("audioMicStateChangeCallback_ is nullptr");
457 return TELEPHONY_ERR_LOCAL_PTR_NULL;
458 }
459 std::shared_ptr<AudioStandard::AudioGroupManager> audioGroupManager =
460 AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(AudioStandard::DEFAULT_VOLUME_GROUP_ID);
461 if (audioGroupManager == nullptr) {
462 TELEPHONY_LOGE("UnsetAudioMicStateChangeCallback fail, audioGroupManager is nullptr");
463 return false;
464 }
465 int32_t ret = audioGroupManager->UnsetMicStateChangeCallback(audioMicStateChangeCallback_);
466 if (ret != TELEPHONY_SUCCESS) {
467 TELEPHONY_LOGE("UnsetAudioMicStateChangeCallback fail");
468 return CALL_ERR_AUDIO_OPERATE_FAILED;
469 }
470 return TELEPHONY_SUCCESS;
471 }
472
OnMicStateUpdated(const AudioStandard::MicStateChangeEvent & micStateChangeEvent)473 void AudioMicStateChangeCallback::OnMicStateUpdated(
474 const AudioStandard::MicStateChangeEvent &micStateChangeEvent)
475 {
476 std::shared_ptr<AudioStandard::AudioGroupManager> audioGroupManager =
477 AudioStandard::AudioSystemManager::GetInstance()->GetGroupManager(AudioStandard::DEFAULT_VOLUME_GROUP_ID);
478 if (audioGroupManager == nullptr) {
479 TELEPHONY_LOGE("OnMicStateUpdated fail, audioGroupManager is nullptr");
480 return;
481 }
482 DelayedSingleton<CallControlManager>::GetInstance()->SetMuted(audioGroupManager->IsMicrophoneMute());
483 }
484
485 } // namespace Telephony
486 } // namespace OHOS
487