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