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
30namespace OHOS {
31namespace Telephony {
32#ifdef SUPPORT_VIBRATOR
33const std::unordered_map<VibrationType, VibratorUsage> VIBRATOR_USAGE_MAP = {
34    {VibrationType::VIBRATION_RINGTONE, USAGE_RING},
35};
36
37const std::unordered_map<VibrationType, int32_t> LOOP_COUNT_MAP = {
38    // Default loop count. Ringtone need be repeated.
39    {VibrationType::VIBRATION_RINGTONE, 10},
40};
41
42const 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
48const int32_t NO_DEVICE_VALID = 0;
49const int32_t RENDERER_FLAG = 0;
50
51AudioProxy::AudioProxy()
52    : deviceCallback_(std::make_shared<AudioDeviceChangeCallback>()),
53      preferredDeviceCallback_(std::make_shared<AudioPreferDeviceChangeCallback>()),
54      audioMicStateChangeCallback_(std::make_shared<AudioMicStateChangeCallback>())
55{}
56
57AudioProxy::~AudioProxy() {}
58
59bool AudioProxy::SetAudioScene(AudioStandard::AudioScene audioScene)
60{
61    return (AudioStandard::AudioSystemManager::GetInstance()->SetAudioScene(audioScene) == TELEPHONY_SUCCESS);
62}
63
64int32_t AudioProxy::SetAudioDeviceChangeCallback()
65{
66    if (deviceCallback_ == nullptr) {
67        TELEPHONY_LOGE("device callback nullptr");
68        return TELEPHONY_ERR_LOCAL_PTR_NULL;
69    }
70    return AudioStandard::AudioSystemManager::GetInstance()->SetDeviceChangeCallback(
71        AudioStandard::DeviceFlag::ALL_DEVICES_FLAG, deviceCallback_);
72}
73
74int32_t AudioProxy::UnsetDeviceChangeCallback()
75{
76    if (deviceCallback_ == nullptr) {
77        TELEPHONY_LOGI("device callback nullptr");
78        return TELEPHONY_SUCCESS;
79    }
80    return AudioStandard::AudioSystemManager::GetInstance()->UnsetDeviceChangeCallback();
81}
82
83bool AudioProxy::SetBluetoothDevActive()
84{
85    if (AudioStandard::AudioSystemManager::GetInstance()->IsDeviceActive(
86        AudioStandard::ActiveDeviceType::BLUETOOTH_SCO)) {
87        TELEPHONY_LOGI("bluetooth device is already active");
88        return true;
89    }
90    bool ret = AudioStandard::AudioSystemManager::GetInstance()->SetDeviceActive(
91        AudioStandard::ActiveDeviceType::BLUETOOTH_SCO, true);
92    if (ret == ERR_NONE) {
93        return true;
94    }
95    return false;
96}
97
98bool AudioProxy::SetSpeakerDevActive(bool isActive)
99{
100    if (AudioStandard::AudioSystemManager::GetInstance()->
101        IsDeviceActive(AudioStandard::ActiveDeviceType::SPEAKER) == isActive) {
102        TELEPHONY_LOGI("current speaker state[%{public}d] is consistent with the expected", isActive);
103        return true;
104    }
105    bool ret = AudioStandard::AudioSystemManager::GetInstance()->SetDeviceActive(
106        AudioStandard::ActiveDeviceType::SPEAKER, isActive);
107    if (ret == ERR_NONE) {
108        return true;
109    }
110    return false;
111}
112
113bool AudioProxy::SetWiredHeadsetDevActive()
114{
115    if (!isWiredHeadsetConnected_) {
116        TELEPHONY_LOGE("SetWiredHeadsetDevActive wiredheadset is not connected");
117        return false;
118    }
119    if (AudioStandard::AudioSystemManager::GetInstance()->
120        IsDeviceActive(AudioStandard::ActiveDeviceType::USB_HEADSET)) {
121        TELEPHONY_LOGI("wired headset device is already active");
122        return true;
123    }
124    bool ret = AudioStandard::AudioSystemManager::GetInstance()->SetDeviceActive(
125        AudioStandard::ActiveDeviceType::USB_HEADSET, true);
126    if (ret == ERR_NONE) {
127        return true;
128    }
129    return false;
130}
131
132bool AudioProxy::SetEarpieceDevActive()
133{
134    if (isWiredHeadsetConnected_) {
135        TELEPHONY_LOGE("SetEarpieceDevActive wiredheadset is connected, no need set earpiece dev active");
136        return false;
137    }
138    if (AudioStandard::AudioSystemManager::GetInstance()->IsDeviceActive(AudioStandard::ActiveDeviceType::EARPIECE)) {
139        TELEPHONY_LOGI("earpiece device is already active");
140        return true;
141    }
142    if (AudioStandard::AudioSystemManager::GetInstance()->SetDeviceActive(
143        AudioStandard::ActiveDeviceType::EARPIECE, true) != ERR_NONE) {
144        TELEPHONY_LOGE("SetEarpieceDevActive earpiece active fail");
145        return false;
146    }
147    return true;
148}
149
150int32_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
165int32_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
175int32_t AudioProxy::GetVolume(AudioStandard::AudioVolumeType audioVolumeType)
176{
177    return AudioStandard::AudioSystemManager::GetInstance()->GetVolume(audioVolumeType);
178}
179
180int32_t AudioProxy::SetVolume(AudioStandard::AudioVolumeType audioVolumeType, int32_t volume)
181{
182    return AudioStandard::AudioSystemManager::GetInstance()->SetVolume(audioVolumeType, volume);
183}
184
185int32_t AudioProxy::SetMaxVolume(AudioStandard::AudioVolumeType audioVolumeType)
186{
187    int32_t maxVolume = GetMaxVolume(audioVolumeType);
188    return AudioStandard::AudioSystemManager::GetInstance()->SetVolume(audioVolumeType, maxVolume);
189}
190
191void 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
198bool AudioProxy::IsStreamActive(AudioStandard::AudioVolumeType audioVolumeType)
199{
200    return AudioStandard::AudioSystemManager::GetInstance()->IsStreamActive(audioVolumeType);
201}
202
203bool AudioProxy::IsStreamMute(AudioStandard::AudioVolumeType audioVolumeType)
204{
205    return AudioStandard::AudioSystemManager::GetInstance()->IsStreamMute(audioVolumeType);
206}
207
208int32_t AudioProxy::GetMaxVolume(AudioStandard::AudioVolumeType audioVolumeType)
209{
210    return AudioStandard::AudioSystemManager::GetInstance()->GetMaxVolume(audioVolumeType);
211}
212
213int32_t AudioProxy::GetMinVolume(AudioStandard::AudioVolumeType audioVolumeType)
214{
215    return AudioStandard::AudioSystemManager::GetInstance()->GetMinVolume(audioVolumeType);
216}
217
218bool 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
229bool 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
245AudioStandard::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
256void 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
280std::string AudioProxy::GetDefaultTonePath() const
281{
282    return defaultTonePath_;
283}
284
285std::string AudioProxy::GetDefaultDtmfPath() const
286{
287    return defaultDtmfPath_;
288}
289
290void AudioProxy::SetWiredHeadsetState(bool isConnected)
291{
292    isWiredHeadsetConnected_ = isConnected;
293}
294
295int32_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
345int32_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
364int32_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
378void 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<DistributedCommunicationManager>::GetInstance()->IsAudioOnSink()) {
387        TELEPHONY_LOGI("has already switch to distributed communication device");
388        return;
389    }
390    TELEPHONY_LOGI("OnPreferredOutputDeviceUpdated type: %{public}d", desc[0]->deviceType_);
391
392    if (IsDistributedDeviceSelected(desc)) {
393        return;
394    }
395
396    switch (desc[0]->deviceType_) {
397        case AudioStandard::DEVICE_TYPE_BLUETOOTH_SCO:
398            if (!SetBluetoothDevice(device, desc)) {
399                return;
400            }
401            DelayedSingleton<AudioDeviceManager>::GetInstance()->SetCurrentAudioDevice(device);
402            break;
403        case AudioStandard::DEVICE_TYPE_EARPIECE:
404            device.deviceType = AudioDeviceType::DEVICE_EARPIECE;
405            DelayedSingleton<AudioDeviceManager>::GetInstance()->SetCurrentAudioDevice(device.deviceType);
406            break;
407        case AudioStandard::DEVICE_TYPE_SPEAKER:
408            device.deviceType = AudioDeviceType::DEVICE_SPEAKER;
409            DelayedSingleton<AudioDeviceManager>::GetInstance()->SetCurrentAudioDevice(device.deviceType);
410            break;
411        case AudioStandard::DEVICE_TYPE_WIRED_HEADSET:
412        case AudioStandard::DEVICE_TYPE_WIRED_HEADPHONES:
413        case AudioStandard::DEVICE_TYPE_USB_HEADSET:
414            device.deviceType = AudioDeviceType::DEVICE_WIRED_HEADSET;
415            DelayedSingleton<AudioDeviceManager>::GetInstance()->AddAudioDeviceList(
416                "", AudioDeviceType::DEVICE_WIRED_HEADSET, "");
417            DelayedSingleton<AudioDeviceManager>::GetInstance()->SetCurrentAudioDevice(device.deviceType);
418            break;
419        default:
420            break;
421    }
422    TELEPHONY_LOGI("OnPreferredOutputDeviceUpdated, type: %{public}d", static_cast<int32_t>(desc[0]->deviceType_));
423    if (desc[0]->deviceType_ != AudioStandard::DEVICE_TYPE_SPEAKER) {
424        DelayedSingleton<AudioControlManager>::GetInstance()->UpdateDeviceTypeForCrs();
425    }
426}
427
428bool AudioPreferDeviceChangeCallback::SetBluetoothDevice(AudioDevice &device,
429    const std::vector<sptr<AudioStandard::AudioDeviceDescriptor>> &desc)
430{
431    device.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO;
432    if (memset_s(&device.address, kMaxAddressLen + 1, 0, kMaxAddressLen + 1) != EOK ||
433        memset_s(&device.deviceName, kMaxDeviceNameLen + 1, 0, kMaxDeviceNameLen + 1) != EOK) {
434        TELEPHONY_LOGE("memset_s address fail");
435        return false;
436    }
437    if (memcpy_s(device.address, kMaxAddressLen, desc[0]->macAddress_.c_str(),
438        desc[0]->macAddress_.length()) != EOK ||
439        memcpy_s(device.deviceName, kMaxDeviceNameLen, desc[0]->deviceName_.c_str(),
440        desc[0]->deviceName_.length()) != EOK) {
441        TELEPHONY_LOGE("memcpy_s address fail");
442        return false;
443    }
444    return true;
445}
446
447bool AudioPreferDeviceChangeCallback::IsDistributedDeviceSelected(
448    const std::vector<sptr<AudioStandard::AudioDeviceDescriptor>> &desc)
449{
450    size_t size = desc.size();
451    TELEPHONY_LOGI("desc size is: %{public}zu", size);
452    std::string deviceId = DelayedSingleton<DistributedCallManager>::GetInstance()->GetConnectedDCallDeviceId();
453    for (auto iter = desc.begin(); iter != desc.end(); iter++) {
454        std::string networkId = (*iter)->networkId_;
455        if (networkId.empty() || deviceId != networkId) {
456            continue;
457        }
458        DelayedSingleton<AudioDeviceManager>::GetInstance()->SetCurrentAudioDevice(
459            AudioDeviceType::DEVICE_DISTRIBUTED_AUTOMOTIVE);
460        TELEPHONY_LOGI("switch to distributed audio device");
461        return true;
462    }
463    return false;
464}
465
466int32_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
486int32_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
506void 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
518} // namespace Telephony
519} // namespace OHOS
520