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