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 #ifndef LOG_TAG
16 #define LOG_TAG "AudioDeviceCommon"
17 #endif
18
19 #include "audio_device_common.h"
20 #include "parameter.h"
21 #include "parameters.h"
22 #include "audio_inner_call.h"
23 #include "media_monitor_manager.h"
24 #include "audio_spatialization_manager.h"
25 #include "audio_spatialization_service.h"
26 #include "common/hdi_adapter_info.h"
27
28 #include "audio_server_proxy.h"
29 #include "audio_policy_utils.h"
30 #include "audio_event_utils.h"
31 #include "audio_recovery_device.h"
32 #include "audio_bundle_manager.h"
33
34 namespace OHOS {
35 namespace AudioStandard {
36
37 static const int64_t WAIT_MODEM_CALL_SET_VOLUME_TIME_US = 120000; // 120ms
38 static const int64_t OLD_DEVICE_UNAVALIABLE_MUTE_MS = 1000000; // 1s
39 static const int64_t NEW_DEVICE_AVALIABLE_MUTE_MS = 400000; // 400ms
40 static const int64_t NEW_DEVICE_AVALIABLE_OFFLOAD_MUTE_MS = 1000000; // 1s
41 static const int64_t NEW_DEVICE_REMOTE_CAST_AVALIABLE_MUTE_MS = 300000; // 300ms
42 static const int64_t SELECT_DEVICE_MUTE_MS = 200000; // 200ms
43 static const int64_t SELECT_OFFLOAD_DEVICE_MUTE_MS = 400000; // 400ms
44 static const int64_t OLD_DEVICE_UNAVALIABLE_MUTE_SLEEP_MS = 150000; // 150ms
45 static const int64_t OLD_DEVICE_UNAVALIABLE_EXT_SLEEP_US = 50000; // 50ms
46 static const int64_t OLD_DEVICE_UNAVALIABLE_EXT_MUTE_MS = 300000; // 300ms
47 static const int64_t DISTRIBUTED_DEVICE_UNAVALIABLE_MUTE_MS = 1500000; // 1.5s
48 static const int64_t DISTRIBUTED_DEVICE_UNAVALIABLE_SLEEP_US = 350000; // 350ms
49 static const uint32_t BT_BUFFER_ADJUSTMENT_FACTOR = 50;
50 static const int VOLUME_LEVEL_DEFAULT = 5;
51 static const int VOLUME_LEVEL_MIN_SIZE = 5;
52 static const int VOLUME_LEVEL_MID_SIZE = 12;
53 static const int VOLUME_LEVEL_MAX_SIZE = 15;
54 static const int32_t DISTRIBUTED_DEVICE = 1003;
55 static const int DEFAULT_ADJUST_TIMES = 10;
56
GetEncryptAddr(const std::string & addr)57 static std::string GetEncryptAddr(const std::string &addr)
58 {
59 const int32_t START_POS = 6;
60 const int32_t END_POS = 13;
61 const int32_t ADDRESS_STR_LEN = 17;
62 if (addr.empty() || addr.length() != ADDRESS_STR_LEN) {
63 return std::string("");
64 }
65 std::string tmp = "**:**:**:**:**:**";
66 std::string out = addr;
67 for (int i = START_POS; i <= END_POS; i++) {
68 out[i] = tmp[i];
69 }
70 return out;
71 }
72
PrintSourceOutput(SourceOutput sourceOutput)73 inline std::string PrintSourceOutput(SourceOutput sourceOutput)
74 {
75 std::stringstream value;
76 value << "streamId:[" << sourceOutput.streamId << "] ";
77 value << "streamType:[" << sourceOutput.streamType << "] ";
78 value << "uid:[" << sourceOutput.uid << "] ";
79 value << "pid:[" << sourceOutput.pid << "] ";
80 value << "statusMark:[" << sourceOutput.statusMark << "] ";
81 value << "deviceSourceId:[" << sourceOutput.deviceSourceId << "] ";
82 value << "startTime:[" << sourceOutput.startTime << "]";
83 return value.str();
84 }
85
86 static const std::vector<std::string> SourceNames = {
87 std::string(PRIMARY_MIC),
88 std::string(BLUETOOTH_MIC),
89 std::string(USB_MIC),
90 std::string(PRIMARY_WAKEUP),
91 std::string(FILE_SOURCE)
92 };
93
IsDistributedOutput(const AudioDeviceDescriptor & desc)94 static bool IsDistributedOutput(const AudioDeviceDescriptor &desc)
95 {
96 return desc.deviceType_ == DEVICE_TYPE_SPEAKER && desc.networkId_ != LOCAL_NETWORK_ID;
97 }
98
Init(std::shared_ptr<AudioPolicyServerHandler> handler)99 void AudioDeviceCommon::Init(std::shared_ptr<AudioPolicyServerHandler> handler)
100 {
101 audioPolicyServerHandler_ = handler;
102 }
103
DeInit()104 void AudioDeviceCommon::DeInit()
105 {
106 audioPolicyServerHandler_ = nullptr;
107 }
108
IsRingerOrAlarmerDualDevicesRange(const InternalDeviceType & deviceType)109 bool AudioDeviceCommon::IsRingerOrAlarmerDualDevicesRange(const InternalDeviceType &deviceType)
110 {
111 switch (deviceType) {
112 case DEVICE_TYPE_SPEAKER:
113 case DEVICE_TYPE_WIRED_HEADSET:
114 case DEVICE_TYPE_WIRED_HEADPHONES:
115 case DEVICE_TYPE_BLUETOOTH_SCO:
116 case DEVICE_TYPE_BLUETOOTH_A2DP:
117 case DEVICE_TYPE_USB_HEADSET:
118 case DEVICE_TYPE_USB_ARM_HEADSET:
119 case DEVICE_TYPE_REMOTE_CAST:
120 return true;
121 default:
122 return false;
123 }
124 }
125
OnPreferredOutputDeviceUpdated(const AudioDeviceDescriptor & deviceDescriptor,const AudioStreamDeviceChangeReason reason)126 void AudioDeviceCommon::OnPreferredOutputDeviceUpdated(const AudioDeviceDescriptor& deviceDescriptor,
127 const AudioStreamDeviceChangeReason reason)
128 {
129 Trace trace("AudioDeviceCommon::OnPreferredOutputDeviceUpdated:" + std::to_string(deviceDescriptor.deviceType_));
130 AUDIO_INFO_LOG("Start");
131
132 if (audioPolicyServerHandler_ != nullptr) {
133 audioPolicyServerHandler_->SendPreferredOutputDeviceUpdated();
134 audioPolicyServerHandler_->SendAudioSessionDeviceChange(reason);
135 }
136 if (deviceDescriptor.deviceType_ != DEVICE_TYPE_BLUETOOTH_SCO) {
137 spatialDeviceMap_.insert(make_pair(deviceDescriptor.macAddress_, deviceDescriptor.deviceType_));
138 }
139
140 if (deviceDescriptor.macAddress_ !=
141 AudioSpatializationService::GetAudioSpatializationService().GetCurrentDeviceAddress()) {
142 AudioServerProxy::GetInstance().UpdateEffectBtOffloadSupportedProxy(false);
143 }
144 AudioPolicyUtils::GetInstance().UpdateEffectDefaultSink(deviceDescriptor.deviceType_);
145 AudioSpatializationService::GetAudioSpatializationService().UpdateCurrentDevice(deviceDescriptor.macAddress_);
146 }
147
OnPreferredInputDeviceUpdated(DeviceType deviceType,std::string networkId)148 void AudioDeviceCommon::OnPreferredInputDeviceUpdated(DeviceType deviceType, std::string networkId)
149 {
150 AUDIO_INFO_LOG("Start");
151
152 if (audioPolicyServerHandler_ != nullptr) {
153 audioPolicyServerHandler_->SendPreferredInputDeviceUpdated();
154 }
155 }
156
GetPreferredOutputDeviceDescInner(AudioRendererInfo & rendererInfo,std::string networkId)157 std::vector<std::shared_ptr<AudioDeviceDescriptor>> AudioDeviceCommon::GetPreferredOutputDeviceDescInner(
158 AudioRendererInfo &rendererInfo, std::string networkId)
159 {
160 std::vector<std::shared_ptr<AudioDeviceDescriptor>> deviceList = {};
161 if (rendererInfo.streamUsage <= STREAM_USAGE_UNKNOWN ||
162 rendererInfo.streamUsage > STREAM_USAGE_MAX) {
163 AUDIO_WARNING_LOG("Invalid usage[%{public}d], return current device.", rendererInfo.streamUsage);
164 std::shared_ptr<AudioDeviceDescriptor> devDesc =
165 std::make_shared<AudioDeviceDescriptor>(audioActiveDevice_.GetCurrentOutputDevice());
166 deviceList.push_back(devDesc);
167 return deviceList;
168 }
169 if (networkId == LOCAL_NETWORK_ID) {
170 vector<std::shared_ptr<AudioDeviceDescriptor>> descs =
171 audioRouterCenter_.FetchOutputDevices(rendererInfo.streamUsage,
172 -1, "GetPreferredOutputDeviceDescInner");
173 for (size_t i = 0; i < descs.size(); i++) {
174 std::shared_ptr<AudioDeviceDescriptor> devDesc = std::make_shared<AudioDeviceDescriptor>(*descs[i]);
175 deviceList.push_back(devDesc);
176 }
177 } else {
178 vector<shared_ptr<AudioDeviceDescriptor>> descs = audioDeviceManager_.GetRemoteRenderDevices();
179 for (const auto &desc : descs) {
180 std::shared_ptr<AudioDeviceDescriptor> devDesc = std::make_shared<AudioDeviceDescriptor>(*desc);
181 deviceList.push_back(devDesc);
182 }
183 }
184
185 return deviceList;
186 }
187
GetPreferredInputDeviceDescInner(AudioCapturerInfo & captureInfo,std::string networkId)188 std::vector<std::shared_ptr<AudioDeviceDescriptor>> AudioDeviceCommon::GetPreferredInputDeviceDescInner(
189 AudioCapturerInfo &captureInfo, std::string networkId)
190 {
191 std::vector<std::shared_ptr<AudioDeviceDescriptor>> deviceList = {};
192 if (captureInfo.sourceType <= SOURCE_TYPE_INVALID ||
193 captureInfo.sourceType > SOURCE_TYPE_MAX) {
194 std::shared_ptr<AudioDeviceDescriptor> devDesc =
195 std::make_shared<AudioDeviceDescriptor>(audioActiveDevice_.GetCurrentInputDevice());
196 deviceList.push_back(devDesc);
197 return deviceList;
198 }
199
200 if (captureInfo.sourceType == SOURCE_TYPE_WAKEUP) {
201 std::shared_ptr<AudioDeviceDescriptor> devDesc =
202 std::make_shared<AudioDeviceDescriptor>(DEVICE_TYPE_MIC, INPUT_DEVICE);
203 devDesc->networkId_ = LOCAL_NETWORK_ID;
204 deviceList.push_back(devDesc);
205 return deviceList;
206 }
207
208 if (networkId == LOCAL_NETWORK_ID) {
209 std::shared_ptr<AudioDeviceDescriptor> desc = audioRouterCenter_.FetchInputDevice(captureInfo.sourceType, -1);
210 CHECK_AND_RETURN_RET_LOG(desc != nullptr, deviceList, "desc is nullptr.");
211 if (desc->deviceType_ == DEVICE_TYPE_NONE && (captureInfo.sourceType == SOURCE_TYPE_PLAYBACK_CAPTURE ||
212 captureInfo.sourceType == SOURCE_TYPE_REMOTE_CAST)) {
213 desc->deviceType_ = DEVICE_TYPE_INVALID;
214 desc->deviceRole_ = INPUT_DEVICE;
215 }
216 std::shared_ptr<AudioDeviceDescriptor> devDesc = std::make_shared<AudioDeviceDescriptor>(*desc);
217 deviceList.push_back(devDesc);
218 } else {
219 vector<shared_ptr<AudioDeviceDescriptor>> descs = audioDeviceManager_.GetRemoteCaptureDevices();
220 for (const auto &desc : descs) {
221 std::shared_ptr<AudioDeviceDescriptor> devDesc = std::make_shared<AudioDeviceDescriptor>(*desc);
222 deviceList.push_back(devDesc);
223 }
224 }
225
226 return deviceList;
227 }
228
GetPreferredOutputStreamTypeInner(StreamUsage streamUsage,DeviceType deviceType,int32_t flags,std::string & networkId,AudioSamplingRate & samplingRate,bool isFirstCreate)229 int32_t AudioDeviceCommon::GetPreferredOutputStreamTypeInner(StreamUsage streamUsage, DeviceType deviceType,
230 int32_t flags, std::string &networkId, AudioSamplingRate &samplingRate, bool isFirstCreate)
231 {
232 AUDIO_INFO_LOG("Not support, should use AudioPipeSelector");
233 return flags;
234 }
235
GetPreferredInputStreamTypeInner(SourceType sourceType,DeviceType deviceType,int32_t flags,const std::string & networkId,const AudioSamplingRate & samplingRate)236 int32_t AudioDeviceCommon::GetPreferredInputStreamTypeInner(SourceType sourceType, DeviceType deviceType,
237 int32_t flags, const std::string &networkId, const AudioSamplingRate &samplingRate)
238 {
239 AUDIO_INFO_LOG("Not support, should use AudioPipeSelector");
240 return flags;
241 }
242
UpdateDeviceInfo(AudioDeviceDescriptor & deviceInfo,const std::shared_ptr<AudioDeviceDescriptor> & desc,bool hasBTPermission,bool hasSystemPermission)243 void AudioDeviceCommon::UpdateDeviceInfo(AudioDeviceDescriptor &deviceInfo,
244 const std::shared_ptr<AudioDeviceDescriptor> &desc,
245 bool hasBTPermission, bool hasSystemPermission)
246 {
247 deviceInfo.deviceType_ = desc->deviceType_;
248 deviceInfo.deviceRole_ = desc->deviceRole_;
249 deviceInfo.deviceId_ = desc->deviceId_;
250 deviceInfo.channelMasks_ = desc->channelMasks_;
251 deviceInfo.channelIndexMasks_ = desc->channelIndexMasks_;
252 deviceInfo.displayName_ = desc->displayName_;
253 deviceInfo.connectState_ = desc->connectState_;
254
255 if (deviceInfo.deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP) {
256 deviceInfo.a2dpOffloadFlag_ = audioA2dpOffloadFlag_.GetA2dpOffloadFlag();
257 }
258
259 if (hasBTPermission) {
260 deviceInfo.deviceName_ = desc->deviceName_;
261 deviceInfo.macAddress_ = desc->macAddress_;
262 deviceInfo.deviceCategory_ = desc->deviceCategory_;
263 } else {
264 deviceInfo.deviceName_ = "";
265 deviceInfo.macAddress_ = "";
266 deviceInfo.deviceCategory_ = CATEGORY_DEFAULT;
267 }
268
269 deviceInfo.isLowLatencyDevice_ = HasLowLatencyCapability(deviceInfo.deviceType_,
270 desc->networkId_ != LOCAL_NETWORK_ID);
271
272 if (hasSystemPermission) {
273 deviceInfo.networkId_ = desc->networkId_;
274 deviceInfo.volumeGroupId_ = desc->volumeGroupId_;
275 deviceInfo.interruptGroupId_ = desc->interruptGroupId_;
276 } else {
277 deviceInfo.networkId_ = "";
278 deviceInfo.volumeGroupId_ = GROUP_ID_NONE;
279 deviceInfo.interruptGroupId_ = GROUP_ID_NONE;
280 }
281 deviceInfo.audioStreamInfo_ = desc->audioStreamInfo_;
282 }
283
DeviceParamsCheck(DeviceRole targetRole,std::vector<std::shared_ptr<AudioDeviceDescriptor>> & audioDeviceDescriptors) const284 int32_t AudioDeviceCommon::DeviceParamsCheck(DeviceRole targetRole,
285 std::vector<std::shared_ptr<AudioDeviceDescriptor>> &audioDeviceDescriptors) const
286 {
287 size_t targetSize = audioDeviceDescriptors.size();
288 CheckAndWriteDeviceChangeExceptionEvent(targetSize == 1,
289 AudioStreamDeviceChangeReason::OVERRODE, audioDeviceDescriptors[0]->deviceType_,
290 audioDeviceDescriptors[0]->deviceRole_, ERR_INVALID_OPERATION, "device params check: size error");
291 CHECK_AND_RETURN_RET_LOG(targetSize == 1, ERR_INVALID_OPERATION,
292 "Device error: size[%{public}zu]", targetSize);
293
294 bool isDeviceTypeCorrect = false;
295 if (targetRole == DeviceRole::OUTPUT_DEVICE) {
296 isDeviceTypeCorrect = IsOutputDevice(audioDeviceDescriptors[0]->deviceType_,
297 audioDeviceDescriptors[0]->deviceRole_) && IsDeviceConnected(audioDeviceDescriptors[0]);
298 } else if (targetRole == DeviceRole::INPUT_DEVICE) {
299 isDeviceTypeCorrect = IsInputDevice(audioDeviceDescriptors[0]->deviceType_,
300 audioDeviceDescriptors[0]->deviceRole_) && IsDeviceConnected(audioDeviceDescriptors[0]);
301 }
302
303 CheckAndWriteDeviceChangeExceptionEvent(audioDeviceDescriptors[0]->deviceRole_ == targetRole &&
304 isDeviceTypeCorrect, AudioStreamDeviceChangeReason::OVERRODE, audioDeviceDescriptors[0]->deviceType_,
305 audioDeviceDescriptors[0]->deviceRole_, ERR_INVALID_OPERATION, "device params check: role error");
306 CHECK_AND_RETURN_RET_LOG(audioDeviceDescriptors[0]->deviceRole_ == targetRole && isDeviceTypeCorrect,
307 ERR_INVALID_OPERATION, "Device error: size[%{public}zu] deviceRole[%{public}d] isDeviceCorrect[%{public}d]",
308 targetSize, static_cast<int32_t>(audioDeviceDescriptors[0]->deviceRole_), isDeviceTypeCorrect);
309 return SUCCESS;
310 }
311
UpdateConnectedDevicesWhenConnecting(const AudioDeviceDescriptor & updatedDesc,std::vector<std::shared_ptr<AudioDeviceDescriptor>> & descForCb)312 void AudioDeviceCommon::UpdateConnectedDevicesWhenConnecting(const AudioDeviceDescriptor &updatedDesc,
313 std::vector<std::shared_ptr<AudioDeviceDescriptor>> &descForCb)
314 {
315 AUDIO_INFO_LOG("UpdateConnectedDevicesWhenConnecting In, deviceType: %{public}d", updatedDesc.deviceType_);
316 if (IsOutputDevice(updatedDesc.deviceType_, updatedDesc.deviceRole_)) {
317 UpdateConnectedDevicesWhenConnectingForOutputDevice(updatedDesc, descForCb);
318 }
319 if (IsInputDevice(updatedDesc.deviceType_, updatedDesc.deviceRole_)) {
320 UpdateConnectedDevicesWhenConnectingForInputDevice(updatedDesc, descForCb);
321 }
322 }
323
RemoveOfflineDevice(const AudioDeviceDescriptor & updatedDesc)324 void AudioDeviceCommon::RemoveOfflineDevice(const AudioDeviceDescriptor& updatedDesc)
325 {
326 if (IsOutputDevice(updatedDesc.deviceType_, updatedDesc.deviceRole_)) {
327 audioAffinityManager_.RemoveOfflineRendererDevice(updatedDesc);
328 }
329 if (IsInputDevice(updatedDesc.deviceType_, updatedDesc.deviceRole_)) {
330 audioAffinityManager_.RemoveOfflineCapturerDevice(updatedDesc);
331 }
332 }
333
UpdateConnectedDevicesWhenDisconnecting(const AudioDeviceDescriptor & updatedDesc,std::vector<std::shared_ptr<AudioDeviceDescriptor>> & descForCb)334 void AudioDeviceCommon::UpdateConnectedDevicesWhenDisconnecting(const AudioDeviceDescriptor& updatedDesc,
335 std::vector<std::shared_ptr<AudioDeviceDescriptor>> &descForCb)
336 {
337 RemoveOfflineDevice(updatedDesc);
338 AUDIO_INFO_LOG("[%{public}s], devType:[%{public}d]", __func__, updatedDesc.deviceType_);
339
340 // Remember the disconnected device descriptor and remove it
341 audioDeviceManager_.GetAllConnectedDeviceByType(updatedDesc.networkId_, updatedDesc.deviceType_,
342 updatedDesc.macAddress_, updatedDesc.deviceRole_, descForCb);
343 for (const auto& desc : descForCb) {
344 if (audioStateManager_.GetPreferredMediaRenderDevice() != nullptr &&
345 desc->IsSameDeviceDesc(*audioStateManager_.GetPreferredMediaRenderDevice())) {
346 AudioPolicyUtils::GetInstance().SetPreferredDevice(AUDIO_MEDIA_RENDER,
347 std::make_shared<AudioDeviceDescriptor>());
348 }
349 if (audioStateManager_.GetPreferredCallRenderDevice() != nullptr &&
350 desc->IsSameDeviceDesc(*audioStateManager_.GetPreferredCallRenderDevice())) {
351 AudioPolicyUtils::GetInstance().SetPreferredDevice(AUDIO_CALL_RENDER,
352 std::make_shared<AudioDeviceDescriptor>(), CLEAR_UID, "UpdateConnectedDevicesWhenDisconnecting");
353 }
354 if (audioStateManager_.GetPreferredCallCaptureDevice() != nullptr &&
355 desc->IsSameDeviceDesc(*audioStateManager_.GetPreferredCallCaptureDevice())) {
356 AudioPolicyUtils::GetInstance().SetPreferredDevice(AUDIO_CALL_CAPTURE,
357 std::make_shared<AudioDeviceDescriptor>());
358 }
359 if (audioStateManager_.GetPreferredRecordCaptureDevice() != nullptr &&
360 desc->IsSameDeviceDesc(*audioStateManager_.GetPreferredRecordCaptureDevice())) {
361 AudioPolicyUtils::GetInstance().SetPreferredDevice(AUDIO_RECORD_CAPTURE,
362 std::make_shared<AudioDeviceDescriptor>());
363 }
364 }
365
366 AudioPolicyUtils::GetInstance().UnexcludeOutputDevices(descForCb);
367
368 audioConnectedDevice_.DelConnectedDevice(updatedDesc.networkId_, updatedDesc.deviceType_,
369 updatedDesc.macAddress_, updatedDesc.deviceRole_);
370
371 // reset disconnected device info in stream
372 if (IsOutputDevice(updatedDesc.deviceType_, updatedDesc.deviceRole_)) {
373 streamCollector_.ResetRendererStreamDeviceInfo(updatedDesc);
374 }
375 if (IsInputDevice(updatedDesc.deviceType_, updatedDesc.deviceRole_)) {
376 streamCollector_.ResetCapturerStreamDeviceInfo(updatedDesc);
377 }
378
379 std::shared_ptr<AudioDeviceDescriptor> devDesc = std::make_shared<AudioDeviceDescriptor>(updatedDesc);
380 CHECK_AND_RETURN_LOG(devDesc != nullptr, "Create device descriptor failed");
381 audioDeviceManager_.RemoveNewDevice(devDesc);
382 audioMicrophoneDescriptor_.RemoveMicrophoneDescriptor(devDesc);
383 if (updatedDesc.deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP &&
384 audioActiveDevice_.GetCurrentOutputDeviceMacAddr() == updatedDesc.macAddress_) {
385 audioA2dpOffloadFlag_.SetA2dpOffloadFlag(NO_A2DP_DEVICE);
386 }
387 }
388
UpdateConnectedDevicesWhenConnectingForOutputDevice(const AudioDeviceDescriptor & updatedDesc,std::vector<std::shared_ptr<AudioDeviceDescriptor>> & descForCb)389 void AudioDeviceCommon::UpdateConnectedDevicesWhenConnectingForOutputDevice(
390 const AudioDeviceDescriptor &updatedDesc, std::vector<std::shared_ptr<AudioDeviceDescriptor>> &descForCb)
391 {
392 std::shared_ptr<AudioDeviceDescriptor> audioDescriptor = std::make_shared<AudioDeviceDescriptor>(updatedDesc);
393 audioDescriptor->deviceRole_ = OUTPUT_DEVICE;
394 // Use speaker streaminfo for all output devices cap
395 if (updatedDesc.deviceType_ != DEVICE_TYPE_HEARING_AID) {
396 auto itr = audioConnectedDevice_.GetConnectedDeviceByType(DEVICE_TYPE_SPEAKER);
397 if (itr != nullptr) {
398 audioDescriptor->SetDeviceCapability(itr->audioStreamInfo_, 0);
399 }
400 }
401 bool wasVirtualConnected = audioDeviceManager_.IsVirtualConnectedDevice(audioDescriptor);
402 if (!wasVirtualConnected) {
403 audioDescriptor->deviceId_ = AudioPolicyUtils::startDeviceId++;
404 } else {
405 audioDeviceManager_.UpdateDeviceDescDeviceId(audioDescriptor);
406 CheckAndNotifyUserSelectedDevice(audioDescriptor);
407 audioDeviceManager_.UpdateVirtualDevices(audioDescriptor, true);
408 }
409 descForCb.push_back(audioDescriptor);
410 AudioPolicyUtils::GetInstance().UpdateDisplayName(audioDescriptor);
411 audioConnectedDevice_.AddConnectedDevice(audioDescriptor);
412 audioDeviceManager_.AddNewDevice(audioDescriptor);
413
414 if (updatedDesc.connectState_ == VIRTUAL_CONNECTED) {
415 AUDIO_INFO_LOG("The device is virtual device, no need to update preferred device");
416 return; // No need to update preferred device for virtual device
417 }
418 DeviceUsage usage = audioDeviceManager_.GetDeviceUsage(updatedDesc);
419 if (audioDescriptor->networkId_ == LOCAL_NETWORK_ID && audioDescriptor->IsSameDeviceDesc(
420 audioRouterCenter_.FetchOutputDevices(STREAM_USAGE_MEDIA, -1,
421 "UpdateConnectedDevicesWhenConnectingForOutputDevice_1",
422 ROUTER_TYPE_USER_SELECT).front()) && (usage & MEDIA) == MEDIA) {
423 AudioPolicyUtils::GetInstance().SetPreferredDevice(AUDIO_MEDIA_RENDER,
424 std::make_shared<AudioDeviceDescriptor>());
425 }
426 if (audioDescriptor->networkId_ == LOCAL_NETWORK_ID && audioDescriptor->IsSameDeviceDesc(
427 audioRouterCenter_.FetchOutputDevices(STREAM_USAGE_VOICE_COMMUNICATION, -1,
428 "UpdateConnectedDevicesWhenConnectingForOutputDevice_2",
429 ROUTER_TYPE_USER_SELECT).front()) && (usage & VOICE) == VOICE) {
430 AudioPolicyUtils::GetInstance().SetPreferredDevice(AUDIO_CALL_RENDER,
431 std::make_shared<AudioDeviceDescriptor>(), CLEAR_UID,
432 "UpdateConnectedDevicesWhenConnectingForOutputDevice");
433 }
434 }
435
UpdateConnectedDevicesWhenConnectingForInputDevice(const AudioDeviceDescriptor & updatedDesc,std::vector<std::shared_ptr<AudioDeviceDescriptor>> & descForCb)436 void AudioDeviceCommon::UpdateConnectedDevicesWhenConnectingForInputDevice(
437 const AudioDeviceDescriptor &updatedDesc, std::vector<std::shared_ptr<AudioDeviceDescriptor>> &descForCb)
438 {
439 std::shared_ptr<AudioDeviceDescriptor> audioDescriptor = std::make_shared<AudioDeviceDescriptor>(updatedDesc);
440 audioDescriptor->deviceRole_ = INPUT_DEVICE;
441 // Use mic streaminfo for all input devices cap
442 auto itr = audioConnectedDevice_.GetConnectedDeviceByType(DEVICE_TYPE_MIC);
443 if (itr != nullptr) {
444 audioDescriptor->SetDeviceCapability(itr->audioStreamInfo_, 0);
445 }
446 bool wasVirtualConnected = audioDeviceManager_.IsVirtualConnectedDevice(audioDescriptor);
447 if (!wasVirtualConnected) {
448 audioDescriptor->deviceId_ = AudioPolicyUtils::startDeviceId++;
449 } else {
450 audioDeviceManager_.UpdateDeviceDescDeviceId(audioDescriptor);
451 audioDeviceManager_.UpdateVirtualDevices(audioDescriptor, true);
452 }
453 descForCb.push_back(audioDescriptor);
454 AudioPolicyUtils::GetInstance().UpdateDisplayName(audioDescriptor);
455 audioConnectedDevice_.AddConnectedDevice(audioDescriptor);
456 audioMicrophoneDescriptor_.AddMicrophoneDescriptor(audioDescriptor);
457 audioDeviceManager_.AddNewDevice(audioDescriptor);
458 if (updatedDesc.connectState_ == VIRTUAL_CONNECTED) {
459 return;
460 }
461 if (audioDescriptor->deviceCategory_ != BT_UNWEAR_HEADPHONE && audioDescriptor->deviceCategory_ != BT_WATCH) {
462 AudioPolicyUtils::GetInstance().SetPreferredDevice(AUDIO_CALL_CAPTURE,
463 std::make_shared<AudioDeviceDescriptor>());
464 AudioPolicyUtils::GetInstance().SetPreferredDevice(AUDIO_RECORD_CAPTURE,
465 std::make_shared<AudioDeviceDescriptor>());
466 }
467 }
468
UpdateDualToneState(const bool & enable,const int32_t & sessionId)469 void AudioDeviceCommon::UpdateDualToneState(const bool &enable, const int32_t &sessionId)
470 {
471 AUDIO_INFO_LOG("update dual tone state, enable:%{public}d, sessionId:%{public}d", enable, sessionId);
472 enableDualHalToneState_ = enable;
473 if (enableDualHalToneState_) {
474 enableDualHalToneSessionId_ = sessionId;
475 }
476 Trace trace("AudioDeviceCommon::UpdateDualToneState sessionId:" + std::to_string(sessionId));
477 auto ret = AudioServerProxy::GetInstance().UpdateDualToneStateProxy(enable, sessionId);
478 CHECK_AND_RETURN_LOG(ret == SUCCESS, "Failed to update the dual tone state for sessionId:%{public}d", sessionId);
479 }
480
IsFastFromA2dpToA2dp(const std::shared_ptr<AudioDeviceDescriptor> & desc,const std::shared_ptr<AudioRendererChangeInfo> & rendererChangeInfo,const AudioStreamDeviceChangeReasonExt reason)481 bool AudioDeviceCommon::IsFastFromA2dpToA2dp(const std::shared_ptr<AudioDeviceDescriptor> &desc,
482 const std::shared_ptr<AudioRendererChangeInfo> &rendererChangeInfo, const AudioStreamDeviceChangeReasonExt reason)
483 {
484 if (rendererChangeInfo->outputDeviceInfo.deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP &&
485 rendererChangeInfo->rendererInfo.originalFlag == AUDIO_FLAG_MMAP &&
486 rendererChangeInfo->outputDeviceInfo.deviceId_ != desc->deviceId_) {
487 TriggerRecreateRendererStreamCallback(rendererChangeInfo->callerPid, rendererChangeInfo->sessionId,
488 AUDIO_OUTPUT_FLAG_FAST, reason);
489 AUDIO_INFO_LOG("Switch fast stream from a2dp to a2dp");
490 return true;
491 }
492 return false;
493 }
494
SetDeviceConnectedFlagWhenFetchOutputDevice()495 void AudioDeviceCommon::SetDeviceConnectedFlagWhenFetchOutputDevice()
496 {
497 AudioDeviceDescriptor currentActiveDevice = audioActiveDevice_.GetCurrentOutputDevice();
498 if (currentActiveDevice.deviceType_ == DEVICE_TYPE_USB_HEADSET ||
499 currentActiveDevice.deviceType_ == DEVICE_TYPE_USB_ARM_HEADSET) {
500 AudioServerProxy::GetInstance().SetDeviceConnectedFlag(false);
501 }
502 }
503
FetchOutputDevice(std::vector<std::shared_ptr<AudioRendererChangeInfo>> & rendererChangeInfos,const AudioStreamDeviceChangeReasonExt reason)504 void AudioDeviceCommon::FetchOutputDevice(std::vector<std::shared_ptr<AudioRendererChangeInfo>> &rendererChangeInfos,
505 const AudioStreamDeviceChangeReasonExt reason)
506 {
507 Trace trace("AudioDeviceCommon::FetchOutputDevice");
508 AUDIO_PRERELEASE_LOGI("Start for %{public}zu stream, connected %{public}s",
509 rendererChangeInfos.size(), audioDeviceManager_.GetConnDevicesStr().c_str());
510 bool needUpdateActiveDevice = true;
511 bool isUpdateActiveDevice = false;
512 int32_t runningStreamCount = 0;
513 bool hasDirectChangeDevice = false;
514 std::vector<SinkInput> sinkInputs;
515 audioPolicyManager_.GetAllSinkInputs(sinkInputs);
516 for (auto &rendererChangeInfo : rendererChangeInfos) {
517 if (!IsRendererStreamRunning(rendererChangeInfo) ||
518 (audioSceneManager_.GetAudioScene(true) == AUDIO_SCENE_DEFAULT &&
519 audioRouterCenter_.isCallRenderRouter(rendererChangeInfo->rendererInfo.streamUsage))) {
520 AUDIO_WARNING_LOG("stream %{public}d not running, no need fetch device", rendererChangeInfo->sessionId);
521 continue;
522 }
523 runningStreamCount++;
524 SetDeviceConnectedFlagWhenFetchOutputDevice();
525 vector<std::shared_ptr<AudioDeviceDescriptor>> descs = GetDeviceDescriptorInner(rendererChangeInfo);
526 if (HandleDeviceChangeForFetchOutputDevice(descs.front(), rendererChangeInfo, reason) ==
527 ERR_NEED_NOT_SWITCH_DEVICE &&
528 !Util::IsRingerOrAlarmerStreamUsage(rendererChangeInfo->rendererInfo.streamUsage)) {
529 continue;
530 }
531 MuteSinkForSwitchBluetoothDevice(rendererChangeInfo, descs, reason);
532 std::string encryptMacAddr = GetEncryptAddr(descs.front()->macAddress_);
533 if (descs.front()->deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP) {
534 if (IsFastFromA2dpToA2dp(descs.front(), rendererChangeInfo, reason)) { continue; }
535 int32_t ret = ActivateA2dpDeviceWhenDescEnabled(descs.front(), rendererChangeInfos, reason);
536 CHECK_AND_RETURN_LOG(ret == SUCCESS, "activate a2dp [%{public}s] failed", encryptMacAddr.c_str());
537 } else if (descs.front()->deviceType_ == DEVICE_TYPE_BLUETOOTH_SCO) {
538 int32_t ret = HandleScoOutputDeviceFetched(descs.front(), rendererChangeInfos, reason);
539 CHECK_AND_RETURN_LOG(ret == SUCCESS, "sco [%{public}s] is not connected yet", encryptMacAddr.c_str());
540 } else if (descs.front()->deviceType_ == DEVICE_TYPE_USB_ARM_HEADSET) {
541 audioEcManager_.ActivateArmDevice(descs.front()->macAddress_, descs.front()->deviceRole_);
542 }
543 if (needUpdateActiveDevice) {
544 isUpdateActiveDevice = audioActiveDevice_.UpdateDevice(descs.front(), reason, rendererChangeInfo);
545 needUpdateActiveDevice = !isUpdateActiveDevice;
546 }
547 if (!hasDirectChangeDevice && !IsSameDevice(descs.front(), rendererChangeInfo->outputDeviceInfo)) {
548 hasDirectChangeDevice = true;
549 }
550 NotifyRecreateRendererStream(descs.front(), rendererChangeInfo, reason);
551 MoveToNewOutputDevice(rendererChangeInfo, descs, sinkInputs, reason);
552 }
553 FetchOutputEnd(isUpdateActiveDevice, runningStreamCount, reason);
554 }
555
GetDeviceDescriptorInner(std::shared_ptr<AudioRendererChangeInfo> & rendererChangeInfo)556 vector<std::shared_ptr<AudioDeviceDescriptor>> AudioDeviceCommon::GetDeviceDescriptorInner(
557 std::shared_ptr<AudioRendererChangeInfo> &rendererChangeInfo)
558 {
559 vector<std::shared_ptr<AudioDeviceDescriptor>> descs;
560 if (VolumeUtils::IsPCVolumeEnable() && !isFirstScreenOn_) {
561 descs.push_back(AudioDeviceManager::GetAudioDeviceManager().GetRenderDefaultDevice());
562 } else {
563 descs = audioRouterCenter_.FetchOutputDevices(rendererChangeInfo->rendererInfo.streamUsage,
564 rendererChangeInfo->clientUID, "GetDeviceDescriptorInner");
565 }
566 return descs;
567 }
568
FetchOutputEnd(const bool isUpdateActiveDevice,const int32_t runningStreamCount,const AudioStreamDeviceChangeReason reason)569 void AudioDeviceCommon::FetchOutputEnd(const bool isUpdateActiveDevice, const int32_t runningStreamCount,
570 const AudioStreamDeviceChangeReason reason)
571 {
572 if (isUpdateActiveDevice) {
573 OnPreferredOutputDeviceUpdated(audioActiveDevice_.GetCurrentOutputDevice(), reason);
574 }
575 if (runningStreamCount == 0) {
576 FetchOutputDeviceWhenNoRunningStream(reason);
577 }
578 }
579
FetchOutputDeviceWhenNoRunningStream(const AudioStreamDeviceChangeReason reason)580 void AudioDeviceCommon::FetchOutputDeviceWhenNoRunningStream(const AudioStreamDeviceChangeReason reason)
581 {
582 vector<std::shared_ptr<AudioDeviceDescriptor>> descs =
583 audioRouterCenter_.FetchOutputDevices(STREAM_USAGE_MEDIA, -1, "FetchOutputDeviceWhenNoRunningStream");
584 CHECK_AND_RETURN_LOG(!descs.empty(), "descs is empty");
585 AudioDeviceDescriptor tmpOutputDeviceDesc = audioActiveDevice_.GetCurrentOutputDevice();
586 if (descs.front()->deviceType_ == DEVICE_TYPE_NONE || IsSameDevice(descs.front(), tmpOutputDeviceDesc)) {
587 AUDIO_DEBUG_LOG("output device is not change");
588 return;
589 }
590 audioActiveDevice_.SetCurrentOutputDevice(*descs.front());
591 AUDIO_DEBUG_LOG("currentActiveDevice update %{public}d", audioActiveDevice_.GetCurrentOutputDeviceType());
592 audioVolumeManager_.SetVolumeForSwitchDevice(*descs.front());
593
594 AudioServerProxy::GetInstance().SetActiveOutputDeviceProxy(audioActiveDevice_.GetCurrentOutputDeviceType());
595
596 if (descs.front()->deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP) {
597 SwitchActiveA2dpDevice(std::make_shared<AudioDeviceDescriptor>(*descs.front()));
598 }
599 OnPreferredOutputDeviceUpdated(audioActiveDevice_.GetCurrentOutputDevice(), reason);
600 }
601
HandleDeviceChangeForFetchOutputDevice(std::shared_ptr<AudioDeviceDescriptor> & desc,std::shared_ptr<AudioRendererChangeInfo> & rendererChangeInfo,const AudioStreamDeviceChangeReason reason)602 int32_t AudioDeviceCommon::HandleDeviceChangeForFetchOutputDevice(std::shared_ptr<AudioDeviceDescriptor> &desc,
603 std::shared_ptr<AudioRendererChangeInfo> &rendererChangeInfo, const AudioStreamDeviceChangeReason reason)
604 {
605 if (desc->deviceType_ == DEVICE_TYPE_NONE || (IsSameDevice(desc, rendererChangeInfo->outputDeviceInfo) &&
606 !NeedRehandleA2DPDevice(desc) && desc->connectState_ != DEACTIVE_CONNECTED &&
607 audioSceneManager_.IsSameAudioScene() && !shouldUpdateDeviceDueToDualTone_)) {
608 AUDIO_WARNING_LOG("stream %{public}d device not change, no need move device", rendererChangeInfo->sessionId);
609 AudioDeviceDescriptor tmpOutputDeviceDesc = audioActiveDevice_.GetCurrentOutputDevice();
610 std::shared_ptr<AudioDeviceDescriptor> preferredDesc =
611 audioAffinityManager_.GetRendererDevice(rendererChangeInfo->clientUID);
612 if (((preferredDesc->deviceType_ != DEVICE_TYPE_NONE) && !IsSameDevice(desc, tmpOutputDeviceDesc)
613 && desc->deviceType_ != preferredDesc->deviceType_)
614 || ((preferredDesc->deviceType_ == DEVICE_TYPE_NONE) && !IsSameDevice(desc, tmpOutputDeviceDesc))) {
615 audioActiveDevice_.SetCurrentOutputDevice(*desc);
616 AudioDeviceDescriptor curOutputDevice = audioActiveDevice_.GetCurrentOutputDevice();
617 audioVolumeManager_.SetVolumeForSwitchDevice(curOutputDevice);
618 audioActiveDevice_.UpdateActiveDeviceRoute(curOutputDevice.deviceType_, DeviceFlag::OUTPUT_DEVICES_FLAG);
619 OnPreferredOutputDeviceUpdated(audioActiveDevice_.GetCurrentOutputDevice(), reason);
620 }
621 return ERR_NEED_NOT_SWITCH_DEVICE;
622 }
623 return SUCCESS;
624 }
625
MuteSinkPortForSwitchDevice(std::shared_ptr<AudioRendererChangeInfo> & rendererChangeInfo,std::vector<std::shared_ptr<AudioDeviceDescriptor>> & outputDevices,const AudioStreamDeviceChangeReasonExt reason)626 void AudioDeviceCommon::MuteSinkPortForSwitchDevice(std::shared_ptr<AudioRendererChangeInfo>& rendererChangeInfo,
627 std::vector<std::shared_ptr<AudioDeviceDescriptor>>& outputDevices, const AudioStreamDeviceChangeReasonExt reason)
628 {
629 Trace trace("AudioDeviceCommon::MuteSinkPortForSwitchDevice");
630 if (outputDevices.front()->IsSameDeviceDesc(rendererChangeInfo->outputDeviceInfo)) return;
631
632 SetHeadsetUnpluggedToSpkOrEpFlag(rendererChangeInfo->outputDeviceInfo.deviceType_,
633 outputDevices.front()->deviceType_);
634
635 audioIOHandleMap_.SetMoveFinish(false);
636
637 if (audioSceneManager_.GetAudioScene(true) == AUDIO_SCENE_PHONE_CALL &&
638 rendererChangeInfo->rendererInfo.streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION &&
639 audioSceneManager_.CheckVoiceCallActive(rendererChangeInfo->sessionId)) {
640 return SetVoiceCallMuteForSwitchDevice();
641 }
642
643 std::string oldSinkName = AudioPolicyUtils::GetInstance().GetSinkName(rendererChangeInfo->outputDeviceInfo,
644 rendererChangeInfo->sessionId);
645 std::string newSinkName = AudioPolicyUtils::GetInstance().GetSinkName(*outputDevices.front(),
646 rendererChangeInfo->sessionId);
647 int32_t oldStreamClass = GetPreferredOutputStreamTypeInner(rendererChangeInfo->rendererInfo.streamUsage,
648 rendererChangeInfo->outputDeviceInfo.deviceType_, rendererChangeInfo->rendererInfo.originalFlag,
649 rendererChangeInfo->outputDeviceInfo.networkId_, rendererChangeInfo->rendererInfo.samplingRate, false);
650 int32_t newStreamClass = GetPreferredOutputStreamTypeInner(rendererChangeInfo->rendererInfo.streamUsage,
651 outputDevices.front()->deviceType_, rendererChangeInfo->rendererInfo.originalFlag,
652 outputDevices.front()->networkId_, rendererChangeInfo->rendererInfo.samplingRate, false);
653 oldSinkName = oldStreamClass == AUDIO_FLAG_VOIP_DIRECT ? PRIMARY_DIRECT_VOIP : oldSinkName;
654 oldSinkName = oldStreamClass == AUDIO_FLAG_VOIP_FAST ? PRIMARY_MMAP_VOIP : oldSinkName;
655 newSinkName = newStreamClass == AUDIO_FLAG_VOIP_DIRECT ? PRIMARY_DIRECT_VOIP : newSinkName;
656 newSinkName = newStreamClass == AUDIO_FLAG_VOIP_FAST ? PRIMARY_MMAP_VOIP : newSinkName;
657 AUDIO_INFO_LOG("mute sink old:[%{public}s] new:[%{public}s]", oldSinkName.c_str(), newSinkName.c_str());
658 MuteSinkPort(oldSinkName, newSinkName, reason);
659 }
660
MuteSinkForSwitchGeneralDevice(std::shared_ptr<AudioRendererChangeInfo> & rendererChangeInfo,std::vector<std::shared_ptr<AudioDeviceDescriptor>> & outputDevices,const AudioStreamDeviceChangeReasonExt reason)661 void AudioDeviceCommon::MuteSinkForSwitchGeneralDevice(std::shared_ptr<AudioRendererChangeInfo>& rendererChangeInfo,
662 std::vector<std::shared_ptr<AudioDeviceDescriptor>>& outputDevices, const AudioStreamDeviceChangeReasonExt reason)
663 {
664 if (outputDevices.front() != nullptr && (outputDevices.front()->deviceType_ != DEVICE_TYPE_BLUETOOTH_A2DP &&
665 outputDevices.front()->deviceType_ != DEVICE_TYPE_BLUETOOTH_SCO)) {
666 MuteSinkPortForSwitchDevice(rendererChangeInfo, outputDevices, reason);
667 }
668 }
669
MuteSinkForSwitchBluetoothDevice(std::shared_ptr<AudioRendererChangeInfo> & rendererChangeInfo,std::vector<std::shared_ptr<AudioDeviceDescriptor>> & outputDevices,const AudioStreamDeviceChangeReasonExt reason)670 void AudioDeviceCommon::MuteSinkForSwitchBluetoothDevice(std::shared_ptr<AudioRendererChangeInfo>& rendererChangeInfo,
671 std::vector<std::shared_ptr<AudioDeviceDescriptor>>& outputDevices, const AudioStreamDeviceChangeReasonExt reason)
672 {
673 if (outputDevices.front() != nullptr && (outputDevices.front()->deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP ||
674 outputDevices.front()->deviceType_ == DEVICE_TYPE_BLUETOOTH_SCO)) {
675 MuteSinkPortForSwitchDevice(rendererChangeInfo, outputDevices, reason);
676 }
677 }
678
SetVoiceCallMuteForSwitchDevice()679 void AudioDeviceCommon::SetVoiceCallMuteForSwitchDevice()
680 {
681 Trace trace("SetVoiceMuteForSwitchDevice");
682 AudioServerProxy::GetInstance().SetVoiceVolumeProxy(0);
683
684 AUDIO_INFO_LOG("%{public}" PRId64" us for modem call update route", WAIT_MODEM_CALL_SET_VOLUME_TIME_US);
685 usleep(WAIT_MODEM_CALL_SET_VOLUME_TIME_US);
686 // Unmute in SetVolumeForSwitchDevice after update route.
687 }
688
IsRendererStreamRunning(std::shared_ptr<AudioRendererChangeInfo> & rendererChangeInfo)689 bool AudioDeviceCommon::IsRendererStreamRunning(std::shared_ptr<AudioRendererChangeInfo> &rendererChangeInfo)
690 {
691 StreamUsage usage = rendererChangeInfo->rendererInfo.streamUsage;
692 RendererState rendererState = rendererChangeInfo->rendererState;
693 if ((usage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION &&
694 audioSceneManager_.GetAudioScene(true) != AUDIO_SCENE_PHONE_CALL) ||
695 (usage != STREAM_USAGE_VOICE_MODEM_COMMUNICATION &&
696 (rendererState != RENDERER_RUNNING && !rendererChangeInfo->prerunningState))) {
697 return false;
698 }
699 return true;
700 }
701
ActivateA2dpDeviceWhenDescEnabled(std::shared_ptr<AudioDeviceDescriptor> & desc,std::vector<std::shared_ptr<AudioRendererChangeInfo>> & rendererChangeInfos,const AudioStreamDeviceChangeReasonExt reason)702 int32_t AudioDeviceCommon::ActivateA2dpDeviceWhenDescEnabled(std::shared_ptr<AudioDeviceDescriptor> &desc,
703 std::vector<std::shared_ptr<AudioRendererChangeInfo>> &rendererChangeInfos,
704 const AudioStreamDeviceChangeReasonExt reason)
705 {
706 if (desc->isEnable_) {
707 AUDIO_INFO_LOG("descs front is enabled");
708 return ActivateA2dpDevice(desc, rendererChangeInfos, reason);
709 }
710 return SUCCESS;
711 }
712
ActivateA2dpDevice(std::shared_ptr<AudioDeviceDescriptor> & desc,std::vector<std::shared_ptr<AudioRendererChangeInfo>> & rendererChangeInfos,const AudioStreamDeviceChangeReasonExt reason)713 int32_t AudioDeviceCommon::ActivateA2dpDevice(std::shared_ptr<AudioDeviceDescriptor> &desc,
714 std::vector<std::shared_ptr<AudioRendererChangeInfo>> &rendererChangeInfos,
715 const AudioStreamDeviceChangeReasonExt reason)
716 {
717 Trace trace("AudioDeviceCommon::ActivateA2dpDevice");
718 std::shared_ptr<AudioDeviceDescriptor> deviceDesc = std::make_shared<AudioDeviceDescriptor>(*desc);
719 int32_t ret = SwitchActiveA2dpDevice(deviceDesc);
720 if (ret != SUCCESS) {
721 AUDIO_ERR_LOG("Active A2DP device failed, retrigger fetch output device");
722 deviceDesc->exceptionFlag_ = true;
723 audioDeviceManager_.UpdateDevicesListInfo(deviceDesc, EXCEPTION_FLAG_UPDATE);
724 audioIOHandleMap_.NotifyUnmutePort();
725 FetchOutputDevice(rendererChangeInfos, reason);
726 return ERROR;
727 }
728 return SUCCESS;
729 }
730
HandleScoOutputDeviceFetched(std::shared_ptr<AudioDeviceDescriptor> & desc,std::vector<std::shared_ptr<AudioRendererChangeInfo>> & rendererChangeInfos,const AudioStreamDeviceChangeReasonExt reason)731 int32_t AudioDeviceCommon::HandleScoOutputDeviceFetched(std::shared_ptr<AudioDeviceDescriptor> &desc,
732 std::vector<std::shared_ptr<AudioRendererChangeInfo>> &rendererChangeInfos,
733 const AudioStreamDeviceChangeReasonExt reason)
734 {
735 Trace trace("AudioDeviceCommon::HandleScoOutputDeviceFetched");
736 #ifdef BLUETOOTH_ENABLE
737 int32_t ret = Bluetooth::AudioHfpManager::SetActiveHfpDevice(desc->macAddress_);
738 if (ret != SUCCESS) {
739 AUDIO_ERR_LOG("Active hfp device failed, retrigger fetch output device.");
740 desc->exceptionFlag_ = true;
741 audioDeviceManager_.UpdateDevicesListInfo(
742 std::make_shared<AudioDeviceDescriptor>(*desc), EXCEPTION_FLAG_UPDATE);
743 FetchOutputDevice(rendererChangeInfos, reason);
744 return ERROR;
745 }
746 Bluetooth::AudioHfpManager::UpdateAudioScene(audioSceneManager_.GetAudioScene(true));
747 #endif
748 return SUCCESS;
749 }
750
NotifyRecreateRendererStream(std::shared_ptr<AudioDeviceDescriptor> & desc,const std::shared_ptr<AudioRendererChangeInfo> & rendererChangeInfo,const AudioStreamDeviceChangeReasonExt reason)751 bool AudioDeviceCommon::NotifyRecreateRendererStream(std::shared_ptr<AudioDeviceDescriptor> &desc,
752 const std::shared_ptr<AudioRendererChangeInfo> &rendererChangeInfo, const AudioStreamDeviceChangeReasonExt reason)
753 {
754 AUDIO_INFO_LOG("Not support, should use AudioPipeSelector");
755 return false;
756 }
757
NeedRehandleA2DPDevice(std::shared_ptr<AudioDeviceDescriptor> & desc)758 bool AudioDeviceCommon::NeedRehandleA2DPDevice(std::shared_ptr<AudioDeviceDescriptor> &desc)
759 {
760 if (desc->deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP
761 && audioIOHandleMap_.CheckIOHandleExist(BLUETOOTH_SPEAKER) == false) {
762 AUDIO_WARNING_LOG("A2DP module is not loaded, need rehandle");
763 return true;
764 }
765 return false;
766 }
767
MoveToNewOutputDevice(std::shared_ptr<AudioRendererChangeInfo> & rendererChangeInfo,std::vector<std::shared_ptr<AudioDeviceDescriptor>> & outputDevices,std::vector<SinkInput> sinkInputs,const AudioStreamDeviceChangeReasonExt reason)768 void AudioDeviceCommon::MoveToNewOutputDevice(std::shared_ptr<AudioRendererChangeInfo> &rendererChangeInfo,
769 std::vector<std::shared_ptr<AudioDeviceDescriptor>> &outputDevices, std::vector<SinkInput> sinkInputs,
770 const AudioStreamDeviceChangeReasonExt reason)
771 {
772 Trace trace("AudioDeviceCommon::MoveToNewOutputDevice");
773 std::vector<SinkInput> targetSinkInputs = audioOffloadStream_.FilterSinkInputs(rendererChangeInfo->sessionId,
774 sinkInputs);
775
776 bool needTriggerCallback = true;
777 if (outputDevices.front()->IsSameDeviceDesc(rendererChangeInfo->outputDeviceInfo)) {
778 needTriggerCallback = false;
779 }
780
781 AUDIO_WARNING_LOG("move session %{public}d [%{public}d][%{public}s]-->[%{public}d][%{public}s], reason %{public}d",
782 rendererChangeInfo->sessionId, rendererChangeInfo->outputDeviceInfo.deviceType_,
783 GetEncryptAddr(rendererChangeInfo->outputDeviceInfo.macAddress_).c_str(),
784 outputDevices.front()->deviceType_, GetEncryptAddr(outputDevices.front()->macAddress_).c_str(),
785 static_cast<int>(reason));
786
787 DeviceType oldDevice = rendererChangeInfo->outputDeviceInfo.deviceType_;
788 auto oldRendererChangeInfo = std::make_shared<AudioRendererChangeInfo>(*rendererChangeInfo.get());
789
790 UpdateDeviceInfo(rendererChangeInfo->outputDeviceInfo,
791 std::make_shared<AudioDeviceDescriptor>(*outputDevices.front()), true, true);
792
793 if (needTriggerCallback && audioPolicyServerHandler_) {
794 audioPolicyServerHandler_->SendRendererDeviceChangeEvent(rendererChangeInfo->callerPid,
795 rendererChangeInfo->sessionId, rendererChangeInfo->outputDeviceInfo, reason);
796 }
797 MuteSinkForSwitchGeneralDevice(oldRendererChangeInfo, outputDevices, reason);
798
799 // MoveSinkInputByIndexOrName
800 auto ret = (outputDevices.front()->networkId_ == LOCAL_NETWORK_ID)
801 ? MoveToLocalOutputDevice(targetSinkInputs, std::make_shared<AudioDeviceDescriptor>(*outputDevices.front()))
802 : MoveToRemoteOutputDevice(targetSinkInputs, std::make_shared<AudioDeviceDescriptor>(*outputDevices.front()));
803 if (ret != SUCCESS) {
804 AUDIO_ERR_LOG("Move sink input %{public}d to device %{public}d failed!",
805 rendererChangeInfo->sessionId, outputDevices.front()->deviceType_);
806 audioIOHandleMap_.NotifyUnmutePort();
807 return;
808 }
809
810 if (audioConfigManager_.GetUpdateRouteSupport()) {
811 UpdateRoute(oldRendererChangeInfo, outputDevices);
812 }
813
814 std::string newSinkName = AudioPolicyUtils::GetInstance().GetSinkName(*outputDevices.front(),
815 rendererChangeInfo->sessionId);
816 audioVolumeManager_.SetVolumeForSwitchDevice(*outputDevices.front(), newSinkName);
817
818 streamCollector_.UpdateRendererDeviceInfo(rendererChangeInfo->clientUID, rendererChangeInfo->sessionId,
819 rendererChangeInfo->outputDeviceInfo);
820 ResetOffloadAndMchMode(rendererChangeInfo, outputDevices);
821 audioIOHandleMap_.NotifyUnmutePort();
822 }
823
MuteOtherSink(const std::string & sinkName,int64_t muteTime)824 void AudioDeviceCommon::MuteOtherSink(const std::string &sinkName, int64_t muteTime)
825 {
826 // fix pop when switching devices during multiple concurrent streams
827 if (sinkName == OFFLOAD_PRIMARY_SPEAKER ||
828 ((sinkName == PRIMARY_DIRECT_VOIP || sinkName == PRIMARY_MMAP_VOIP) &&
829 streamCollector_.HasRunningRendererStream())) {
830 audioIOHandleMap_.MuteSinkPort(PRIMARY_SPEAKER, muteTime, true, false);
831 } else if (sinkName == PRIMARY_SPEAKER && streamCollector_.IsVoipStreamActive()) {
832 audioIOHandleMap_.MuteSinkPort(PRIMARY_DIRECT_VOIP, muteTime, true, false);
833 audioIOHandleMap_.MuteSinkPort(PRIMARY_MMAP_VOIP, muteTime, true, false);
834 } else if (sinkName == PRIMARY_SPEAKER) {
835 audioIOHandleMap_.MuteSinkPort(OFFLOAD_PRIMARY_SPEAKER, muteTime, true, false);
836 }
837 }
838
MuteSinkPort(const std::string & oldSinkName,const std::string & newSinkName,AudioStreamDeviceChangeReasonExt reason)839 void AudioDeviceCommon::MuteSinkPort(const std::string &oldSinkName, const std::string &newSinkName,
840 AudioStreamDeviceChangeReasonExt reason)
841 {
842 if (reason.IsOverride() || reason.IsSetDefaultOutputDevice()) {
843 int64_t muteTime = SELECT_DEVICE_MUTE_MS;
844 if (newSinkName == OFFLOAD_PRIMARY_SPEAKER || oldSinkName == OFFLOAD_PRIMARY_SPEAKER) {
845 muteTime = SELECT_OFFLOAD_DEVICE_MUTE_MS;
846 }
847 MuteOtherSink(newSinkName, muteTime);
848 audioIOHandleMap_.MuteSinkPort(newSinkName, SELECT_DEVICE_MUTE_MS, true);
849 audioIOHandleMap_.MuteSinkPort(oldSinkName, muteTime, true);
850 } else if (reason == AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE) {
851 int64_t muteTime = NEW_DEVICE_AVALIABLE_MUTE_MS;
852 if (newSinkName == OFFLOAD_PRIMARY_SPEAKER || oldSinkName == OFFLOAD_PRIMARY_SPEAKER) {
853 muteTime = NEW_DEVICE_AVALIABLE_OFFLOAD_MUTE_MS;
854 }
855 MuteOtherSink(oldSinkName, muteTime);
856 audioIOHandleMap_.MuteSinkPort(newSinkName, NEW_DEVICE_AVALIABLE_MUTE_MS, true);
857 audioIOHandleMap_.MuteSinkPort(oldSinkName, muteTime, true);
858 }
859 MuteSinkPortLogic(oldSinkName, newSinkName, reason);
860 }
861
MuteSinkPortLogic(const std::string & oldSinkName,const std::string & newSinkName,AudioStreamDeviceChangeReasonExt reason)862 void AudioDeviceCommon::MuteSinkPortLogic(const std::string &oldSinkName, const std::string &newSinkName,
863 AudioStreamDeviceChangeReasonExt reason)
864 {
865 auto ringermode = audioPolicyManager_.GetRingerMode();
866 AudioScene scene = audioSceneManager_.GetAudioScene(true);
867 if (reason == DISTRIBUTED_DEVICE) {
868 audioIOHandleMap_.MuteSinkPort(newSinkName, DISTRIBUTED_DEVICE_UNAVALIABLE_MUTE_MS, true);
869 usleep(DISTRIBUTED_DEVICE_UNAVALIABLE_SLEEP_US);
870 } else if (reason.IsOldDeviceUnavaliable() && ((scene == AUDIO_SCENE_DEFAULT) ||
871 ((scene == AUDIO_SCENE_RINGING || scene == AUDIO_SCENE_VOICE_RINGING) &&
872 ringermode != RINGER_MODE_NORMAL) || (scene == AUDIO_SCENE_PHONE_CHAT))) {
873 MuteOtherSink(newSinkName, OLD_DEVICE_UNAVALIABLE_MUTE_MS);
874 audioIOHandleMap_.MuteSinkPort(newSinkName, OLD_DEVICE_UNAVALIABLE_MUTE_MS, true);
875 usleep(OLD_DEVICE_UNAVALIABLE_MUTE_SLEEP_MS); // sleep fix data cache pop.
876 if (isHeadsetUnpluggedToSpkOrEpFlag_) {
877 usleep(OLD_DEVICE_UNAVALIABLE_EXT_SLEEP_US); // sleep fix data cache pop.
878 isHeadsetUnpluggedToSpkOrEpFlag_ = false;
879 }
880 } else if (reason.IsOldDeviceUnavaliableExt() && ((scene == AUDIO_SCENE_DEFAULT) ||
881 ((scene == AUDIO_SCENE_RINGING || scene == AUDIO_SCENE_VOICE_RINGING) &&
882 ringermode != RINGER_MODE_NORMAL) || (scene == AUDIO_SCENE_PHONE_CHAT))) {
883 audioIOHandleMap_.MuteSinkPort(newSinkName, OLD_DEVICE_UNAVALIABLE_EXT_MUTE_MS, true);
884 usleep(OLD_DEVICE_UNAVALIABLE_MUTE_SLEEP_MS); // sleep fix data cache pop.
885 } else if (reason == AudioStreamDeviceChangeReason::UNKNOWN &&
886 oldSinkName == REMOTE_CAST_INNER_CAPTURER_SINK_NAME) {
887 // remote cast -> earpiece 300ms fix sound leak
888 audioIOHandleMap_.MuteSinkPort(newSinkName, NEW_DEVICE_REMOTE_CAST_AVALIABLE_MUTE_MS, true);
889 }
890 }
891
TriggerRecreateRendererStreamCallback(int32_t callerPid,int32_t sessionId,int32_t streamFlag,const AudioStreamDeviceChangeReasonExt reason)892 void AudioDeviceCommon::TriggerRecreateRendererStreamCallback(int32_t callerPid, int32_t sessionId,
893 int32_t streamFlag, const AudioStreamDeviceChangeReasonExt reason)
894 {
895 Trace trace("AudioDeviceCommon::TriggerRecreateRendererStreamCallback");
896 AUDIO_INFO_LOG("Trigger recreate renderer stream, pid: %{public}d, sessionId: %{public}d, flag: %{public}d",
897 callerPid, sessionId, streamFlag);
898 if (audioPolicyServerHandler_ != nullptr) {
899 audioPolicyServerHandler_->SendRecreateRendererStreamEvent(callerPid, sessionId, streamFlag, reason);
900 } else {
901 AUDIO_WARNING_LOG("No audio policy server handler");
902 }
903 }
904
IsDualStreamWhenRingDual(AudioStreamType streamType)905 bool AudioDeviceCommon::IsDualStreamWhenRingDual(AudioStreamType streamType)
906 {
907 AudioStreamType volumeType = VolumeUtils::GetVolumeTypeFromStreamType(streamType);
908 if (volumeType == STREAM_RING || volumeType == STREAM_ALARM || volumeType == STREAM_ACCESSIBILITY) {
909 return true;
910 }
911 return false;
912 }
913
UpdateRoute(std::shared_ptr<AudioRendererChangeInfo> & rendererChangeInfo,std::vector<std::shared_ptr<AudioDeviceDescriptor>> & outputDevices)914 void AudioDeviceCommon::UpdateRoute(std::shared_ptr<AudioRendererChangeInfo> &rendererChangeInfo,
915 std::vector<std::shared_ptr<AudioDeviceDescriptor>> &outputDevices)
916 {
917 StreamUsage streamUsage = rendererChangeInfo->rendererInfo.streamUsage;
918 InternalDeviceType deviceType = outputDevices.front()->deviceType_;
919 AUDIO_INFO_LOG("update route, streamUsage:%{public}d, 1st devicetype:%{public}d", streamUsage, deviceType);
920 if (Util::IsRingerOrAlarmerStreamUsage(streamUsage) && IsRingerOrAlarmerDualDevicesRange(deviceType) &&
921 !VolumeUtils::IsPCVolumeEnable()) {
922 if (!IsSameDevice(outputDevices.front(), rendererChangeInfo->outputDeviceInfo) &&
923 !SelectRingerOrAlarmDevices(outputDevices, rendererChangeInfo)) {
924 audioActiveDevice_.UpdateActiveDeviceRoute(deviceType, DeviceFlag::OUTPUT_DEVICES_FLAG);
925 }
926
927 AudioRingerMode ringerMode = audioPolicyManager_.GetRingerMode();
928 if (ringerMode != RINGER_MODE_NORMAL && IsRingerOrAlarmerDualDevicesRange(outputDevices.front()->getType()) &&
929 outputDevices.front()->getType() != DEVICE_TYPE_SPEAKER) {
930 audioPolicyManager_.SetStreamMute(STREAM_RING, false, streamUsage);
931 audioVolumeManager_.SetRingerModeMute(false);
932 int32_t curRingToneLevel = RingToneVoiceControl(outputDevices.front()->getType());
933 audioPolicyManager_.SetDoubleRingVolumeDb(STREAM_RING, curRingToneLevel);
934 } else {
935 audioVolumeManager_.SetRingerModeMute(true);
936 }
937 shouldUpdateDeviceDueToDualTone_ = true;
938 } else {
939 audioVolumeManager_.SetRingerModeMute(true);
940 if (isRingDualToneOnPrimarySpeaker_ && streamUsage != STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
941 std::vector<std::pair<InternalDeviceType, DeviceFlag>> activeDevices;
942 activeDevices.push_back(make_pair(deviceType, DeviceFlag::OUTPUT_DEVICES_FLAG));
943 activeDevices.push_back(make_pair(DEVICE_TYPE_SPEAKER, DeviceFlag::OUTPUT_DEVICES_FLAG));
944 audioActiveDevice_.UpdateActiveDevicesRoute(activeDevices);
945 AUDIO_INFO_LOG("update desc [%{public}d] with speaker on session [%{public}d]",
946 deviceType, rendererChangeInfo->sessionId);
947 AudioStreamType streamType = streamCollector_.GetStreamType(rendererChangeInfo->sessionId);
948 if (!IsDualStreamWhenRingDual(streamType)) {
949 streamsWhenRingDualOnPrimarySpeaker_.push_back(make_pair(streamType, streamUsage));
950 audioPolicyManager_.SetStreamMute(streamType, true, streamUsage);
951 }
952 } else {
953 audioActiveDevice_.UpdateActiveDeviceRoute(deviceType, DeviceFlag::OUTPUT_DEVICES_FLAG);
954 }
955 shouldUpdateDeviceDueToDualTone_ = false;
956 }
957 }
958
ResetOffloadAndMchMode(std::shared_ptr<AudioRendererChangeInfo> & rendererChangeInfo,vector<std::shared_ptr<AudioDeviceDescriptor>> & outputDevices)959 void AudioDeviceCommon::ResetOffloadAndMchMode(std::shared_ptr<AudioRendererChangeInfo> &rendererChangeInfo,
960 vector<std::shared_ptr<AudioDeviceDescriptor>> &outputDevices)
961 {
962 if (outputDevices.front()->networkId_ != LOCAL_NETWORK_ID
963 || outputDevices.front()->deviceType_ == DEVICE_TYPE_REMOTE_CAST) {
964 audioOffloadStream_.RemoteOffloadStreamRelease(rendererChangeInfo->sessionId);
965 } else {
966 FetchStreamForSpkMchStream(rendererChangeInfo, outputDevices);
967 }
968 }
969
JudgeIfLoadMchModule()970 void AudioDeviceCommon::JudgeIfLoadMchModule()
971 {
972 bool isNeedLoadMchModule = false;
973 {
974 if (audioIOHandleMap_.CheckIOHandleExist(MCH_PRIMARY_SPEAKER) == false) {
975 isNeedLoadMchModule = true;
976 }
977 }
978 if (isNeedLoadMchModule) {
979 audioOffloadStream_.LoadMchModule();
980 }
981 }
982
FetchStreamForA2dpMchStream(std::shared_ptr<AudioRendererChangeInfo> & rendererChangeInfo,vector<std::shared_ptr<AudioDeviceDescriptor>> & descs)983 void AudioDeviceCommon::FetchStreamForA2dpMchStream(std::shared_ptr<AudioRendererChangeInfo> &rendererChangeInfo,
984 vector<std::shared_ptr<AudioDeviceDescriptor>> &descs)
985 {
986 if (audioOffloadStream_.CheckStreamMultichannelMode(rendererChangeInfo->sessionId)) {
987 JudgeIfLoadMchModule();
988 audioActiveDevice_.UpdateActiveDeviceRoute(DEVICE_TYPE_BLUETOOTH_A2DP, DeviceFlag::OUTPUT_DEVICES_FLAG);
989 std::string portName = AudioPolicyUtils::GetInstance().GetSinkPortName(descs.front()->deviceType_,
990 PIPE_TYPE_MULTICHANNEL);
991 int32_t ret = audioOffloadStream_.MoveToOutputDevice(rendererChangeInfo->sessionId, portName);
992 if (ret == SUCCESS) {
993 streamCollector_.UpdateRendererPipeInfo(rendererChangeInfo->sessionId, PIPE_TYPE_MULTICHANNEL);
994 }
995 } else {
996 AudioPipeType pipeType = PIPE_TYPE_UNKNOWN;
997 streamCollector_.GetPipeType(rendererChangeInfo->sessionId, pipeType);
998 if (pipeType == PIPE_TYPE_MULTICHANNEL) {
999 std::string currentActivePort = MCH_PRIMARY_SPEAKER;
1000 AudioIOHandle activateDeviceIOHandle;
1001 CHECK_AND_RETURN_LOG(audioIOHandleMap_.GetModuleIdByKey(currentActivePort, activateDeviceIOHandle),
1002 "Can not find port MCH_PRIMARY_SPEAKER in io map");
1003 audioPolicyManager_.SuspendAudioDevice(currentActivePort, true);
1004 audioPolicyManager_.CloseAudioPort(activateDeviceIOHandle);
1005 audioIOHandleMap_.DelIOHandleInfo(currentActivePort);
1006 streamCollector_.UpdateRendererPipeInfo(rendererChangeInfo->sessionId, PIPE_TYPE_NORMAL_OUT);
1007 }
1008 audioOffloadStream_.ResetOffloadMode(rendererChangeInfo->sessionId);
1009 std::vector<SinkInput> sinkInputs;
1010 audioPolicyManager_.GetAllSinkInputs(sinkInputs);
1011 MoveToNewOutputDevice(rendererChangeInfo, descs, sinkInputs);
1012 }
1013 }
1014
FetchStreamForSpkMchStream(std::shared_ptr<AudioRendererChangeInfo> & rendererChangeInfo,vector<std::shared_ptr<AudioDeviceDescriptor>> & descs)1015 void AudioDeviceCommon::FetchStreamForSpkMchStream(std::shared_ptr<AudioRendererChangeInfo> &rendererChangeInfo,
1016 vector<std::shared_ptr<AudioDeviceDescriptor>> &descs)
1017 {
1018 if (audioOffloadStream_.CheckStreamMultichannelMode(rendererChangeInfo->sessionId)) {
1019 JudgeIfLoadMchModule();
1020 std::string oldSinkName = AudioPolicyUtils::GetInstance().GetSinkName(rendererChangeInfo->outputDeviceInfo,
1021 rendererChangeInfo->sessionId);
1022 std::string newSinkName = AudioPolicyUtils::GetInstance().GetSinkPortName(descs.front()->deviceType_,
1023 PIPE_TYPE_MULTICHANNEL);
1024 if (oldSinkName != newSinkName) {
1025 AUDIO_INFO_LOG("mute sink old:[%{public}s] new:[%{public}s]", oldSinkName.c_str(), newSinkName.c_str());
1026 MuteSinkPort(oldSinkName, newSinkName, AudioStreamDeviceChangeReason::OVERRODE);
1027 }
1028 int32_t ret = audioOffloadStream_.MoveToOutputDevice(rendererChangeInfo->sessionId, newSinkName);
1029 if (ret == SUCCESS) {
1030 streamCollector_.UpdateRendererPipeInfo(rendererChangeInfo->sessionId, PIPE_TYPE_MULTICHANNEL);
1031 }
1032 } else {
1033 AudioPipeType pipeType = PIPE_TYPE_UNKNOWN;
1034 streamCollector_.GetPipeType(rendererChangeInfo->sessionId, pipeType);
1035 if (pipeType == PIPE_TYPE_MULTICHANNEL) {
1036 {
1037 AUDIO_INFO_LOG("unload multichannel module");
1038 std::string currentActivePort = MCH_PRIMARY_SPEAKER;
1039 AudioIOHandle activateDeviceIOHandle;
1040 CHECK_AND_RETURN_LOG(audioIOHandleMap_.GetModuleIdByKey(currentActivePort, activateDeviceIOHandle),
1041 "Can not find port MCH_PRIMARY_SPEAKER in io map");
1042 audioPolicyManager_.SuspendAudioDevice(currentActivePort, true);
1043 audioPolicyManager_.CloseAudioPort(activateDeviceIOHandle);
1044 audioIOHandleMap_.DelIOHandleInfo(currentActivePort);
1045 }
1046 }
1047 audioOffloadStream_.ResetOffloadMode(rendererChangeInfo->sessionId);
1048 }
1049 }
1050
IsRingDualToneOnPrimarySpeaker(const vector<std::shared_ptr<AudioDeviceDescriptor>> & descs,const int32_t sessionId)1051 bool AudioDeviceCommon::IsRingDualToneOnPrimarySpeaker(const vector<std::shared_ptr<AudioDeviceDescriptor>> &descs,
1052 const int32_t sessionId)
1053 {
1054 if (descs.size() != AUDIO_CONCURRENT_ACTIVE_DEVICES_LIMIT) {
1055 return false;
1056 }
1057 if (AudioPolicyUtils::GetInstance().GetSinkName(*descs.front(), sessionId) != PRIMARY_SPEAKER) {
1058 return false;
1059 }
1060 if (AudioPolicyUtils::GetInstance().GetSinkName(*descs.back(), sessionId) != PRIMARY_SPEAKER) {
1061 return false;
1062 }
1063 if (descs.back()->deviceType_ != DEVICE_TYPE_SPEAKER) {
1064 return false;
1065 }
1066 AUDIO_INFO_LOG("ring dual tone on primary speaker and mute music.");
1067 audioPolicyManager_.SetInnerStreamMute(STREAM_MUSIC, true, STREAM_USAGE_MUSIC);
1068 return true;
1069 }
1070
ClearRingMuteWhenCallStart(bool pre,bool after)1071 void AudioDeviceCommon::ClearRingMuteWhenCallStart(bool pre, bool after)
1072 {
1073 CHECK_AND_RETURN_LOG(pre == true && after == false, "ringdual not cancel by call");
1074 AUDIO_INFO_LOG("disable primary speaker dual tone when call start and ring not over");
1075 for (std::pair<AudioStreamType, StreamUsage> stream : streamsWhenRingDualOnPrimarySpeaker_) {
1076 audioPolicyManager_.SetStreamMute(stream.first, false, stream.second);
1077 }
1078 streamsWhenRingDualOnPrimarySpeaker_.clear();
1079 audioPolicyManager_.SetStreamMute(STREAM_MUSIC, false, STREAM_USAGE_MUSIC);
1080 }
1081
SelectRingerOrAlarmDevices(const vector<std::shared_ptr<AudioDeviceDescriptor>> & descs,const std::shared_ptr<AudioRendererChangeInfo> & rendererChangeInfo)1082 bool AudioDeviceCommon::SelectRingerOrAlarmDevices(const vector<std::shared_ptr<AudioDeviceDescriptor>> &descs,
1083 const std::shared_ptr<AudioRendererChangeInfo> &rendererChangeInfo)
1084 {
1085 CHECK_AND_RETURN_RET_LOG(descs.size() > 0 && descs.size() <= AUDIO_CONCURRENT_ACTIVE_DEVICES_LIMIT, false,
1086 "audio devices not in range for ringer or alarmer.");
1087 const int32_t sessionId = rendererChangeInfo->sessionId;
1088 const StreamUsage streamUsage = rendererChangeInfo->rendererInfo.streamUsage;
1089 bool allDevicesInDualDevicesRange = true;
1090 std::vector<std::pair<InternalDeviceType, DeviceFlag>> activeDevices;
1091 for (size_t i = 0; i < descs.size(); i++) {
1092 if (IsRingerOrAlarmerDualDevicesRange(descs[i]->deviceType_)) {
1093 activeDevices.push_back(make_pair(descs[i]->deviceType_, DeviceFlag::OUTPUT_DEVICES_FLAG));
1094 AUDIO_INFO_LOG("select ringer/alarm devices devicetype[%{public}zu]:%{public}d", i, descs[i]->deviceType_);
1095 } else {
1096 allDevicesInDualDevicesRange = false;
1097 break;
1098 }
1099 }
1100
1101 AUDIO_INFO_LOG("select ringer/alarm sessionId:%{public}d, streamUsage:%{public}d", sessionId, streamUsage);
1102 if (!descs.empty() && allDevicesInDualDevicesRange) {
1103 if (descs.size() == AUDIO_CONCURRENT_ACTIVE_DEVICES_LIMIT &&
1104 AudioPolicyUtils::GetInstance().GetSinkName(*descs.front(), sessionId) !=
1105 AudioPolicyUtils::GetInstance().GetSinkName(*descs.back(), sessionId)) {
1106 AUDIO_INFO_LOG("set dual hal tone, reset primary sink to default before.");
1107 audioActiveDevice_.UpdateActiveDeviceRoute(DEVICE_TYPE_SPEAKER, DeviceFlag::OUTPUT_DEVICES_FLAG);
1108 if (enableDualHalToneState_ && enableDualHalToneSessionId_ != sessionId) {
1109 AUDIO_INFO_LOG("session changed, disable old dual hal tone.");
1110 UpdateDualToneState(false, enableDualHalToneSessionId_);
1111 }
1112
1113 if ((audioPolicyManager_.GetRingerMode() != RINGER_MODE_NORMAL && streamUsage != STREAM_USAGE_ALARM) ||
1114 (VolumeUtils::IsPCVolumeEnable() && audioVolumeManager_.GetStreamMute(STREAM_MUSIC))) {
1115 AUDIO_INFO_LOG("no normal ringer mode and no alarm, dont dual hal tone.");
1116 return false;
1117 }
1118 UpdateDualToneState(true, sessionId);
1119 } else {
1120 if (enableDualHalToneState_ && enableDualHalToneSessionId_ == sessionId) {
1121 AUDIO_INFO_LOG("device unavailable, disable dual hal tone.");
1122 UpdateDualToneState(false, enableDualHalToneSessionId_);
1123 }
1124 bool pre = isRingDualToneOnPrimarySpeaker_;
1125 isRingDualToneOnPrimarySpeaker_ = IsRingDualToneOnPrimarySpeaker(descs, sessionId);
1126 ClearRingMuteWhenCallStart(pre, isRingDualToneOnPrimarySpeaker_);
1127 audioActiveDevice_.UpdateActiveDevicesRoute(activeDevices);
1128 }
1129 return true;
1130 }
1131 return false;
1132 }
1133
HandleDeviceChangeForFetchInputDevice(std::shared_ptr<AudioDeviceDescriptor> & desc,std::shared_ptr<AudioCapturerChangeInfo> & capturerChangeInfo)1134 int32_t AudioDeviceCommon::HandleDeviceChangeForFetchInputDevice(std::shared_ptr<AudioDeviceDescriptor> &desc,
1135 std::shared_ptr<AudioCapturerChangeInfo> &capturerChangeInfo)
1136 {
1137 if (desc->deviceType_ == DEVICE_TYPE_NONE ||
1138 (IsSameDevice(desc, capturerChangeInfo->inputDeviceInfo) && desc->connectState_ != DEACTIVE_CONNECTED)) {
1139 AUDIO_WARNING_LOG("stream %{public}d device not change, no need move device", capturerChangeInfo->sessionId);
1140 std::shared_ptr<AudioDeviceDescriptor> preferredDesc =
1141 audioAffinityManager_.GetCapturerDevice(capturerChangeInfo->clientUID);
1142 if (!IsSameDevice(desc, audioActiveDevice_.GetCurrentInputDevice()) &&
1143 (((preferredDesc->deviceType_ != DEVICE_TYPE_NONE) && desc->deviceType_ != preferredDesc->deviceType_) ||
1144 IsSameDevice(desc, capturerChangeInfo->inputDeviceInfo))) {
1145 audioActiveDevice_.SetCurrentInputDevice(*desc);
1146 // networkId is not used.
1147 OnPreferredInputDeviceUpdated(audioActiveDevice_.GetCurrentInputDeviceType(), "");
1148 audioActiveDevice_.UpdateActiveDeviceRoute(audioActiveDevice_.GetCurrentInputDeviceType(),
1149 DeviceFlag::INPUT_DEVICES_FLAG, audioActiveDevice_.GetCurrentInputDevice().deviceName_);
1150 }
1151 return ERR_NEED_NOT_SWITCH_DEVICE;
1152 }
1153 return SUCCESS;
1154 }
1155
FetchInputDeviceInner(std::vector<std::shared_ptr<AudioCapturerChangeInfo>> & capturerChangeInfos,const AudioStreamDeviceChangeReasonExt reason,bool & needUpdateActiveDevice,bool & isUpdateActiveDevice,int32_t & runningStreamCount)1156 void AudioDeviceCommon::FetchInputDeviceInner(
1157 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> &capturerChangeInfos,
1158 const AudioStreamDeviceChangeReasonExt reason, bool& needUpdateActiveDevice, bool& isUpdateActiveDevice,
1159 int32_t& runningStreamCount)
1160 {
1161 for (auto &capturerChangeInfo : capturerChangeInfos) {
1162 SourceType sourceType = capturerChangeInfo->capturerInfo.sourceType;
1163 int32_t clientUID = capturerChangeInfo->clientUID;
1164 if ((sourceType == SOURCE_TYPE_VIRTUAL_CAPTURE &&
1165 audioSceneManager_.GetAudioScene(true) != AUDIO_SCENE_PHONE_CALL) ||
1166 (sourceType != SOURCE_TYPE_VIRTUAL_CAPTURE && capturerChangeInfo->capturerState != CAPTURER_RUNNING &&
1167 !capturerChangeInfo->prerunningState)) {
1168 AUDIO_WARNING_LOG("stream %{public}d not running, no need fetch device", capturerChangeInfo->sessionId);
1169 continue;
1170 }
1171 runningStreamCount++;
1172 std::shared_ptr<AudioDeviceDescriptor> desc = audioRouterCenter_.FetchInputDevice(sourceType, clientUID,
1173 capturerChangeInfo->sessionId);
1174 AudioDeviceDescriptor inputDeviceInfo = capturerChangeInfo->inputDeviceInfo;
1175 if (HandleDeviceChangeForFetchInputDevice(desc, capturerChangeInfo) == ERR_NEED_NOT_SWITCH_DEVICE) {
1176 continue;
1177 }
1178 HandleBluetoothInputDeviceFetched(desc, capturerChangeInfos, sourceType);
1179 CHECK_AND_RETURN_LOG(desc != nullptr, "desc is nullptr");
1180 if (desc->deviceType_ == DEVICE_TYPE_USB_ARM_HEADSET) {
1181 audioEcManager_.ActivateArmDevice(desc->macAddress_, desc->deviceRole_);
1182 }
1183 if (needUpdateActiveDevice) {
1184 std::shared_ptr<AudioDeviceDescriptor> preferredDesc = audioAffinityManager_.GetCapturerDevice(clientUID);
1185 if (((preferredDesc->deviceType_ != DEVICE_TYPE_NONE) &&
1186 !IsSameDevice(desc, audioActiveDevice_.GetCurrentInputDevice())
1187 && desc->deviceType_ != preferredDesc->deviceType_)
1188 || ((preferredDesc->deviceType_ == DEVICE_TYPE_NONE)
1189 && !IsSameDevice(desc, audioActiveDevice_.GetCurrentInputDevice()))) {
1190 WriteInputRouteChangeEvent(desc, reason);
1191 audioActiveDevice_.SetCurrentInputDevice(*desc);
1192 AUDIO_DEBUG_LOG("currentActiveInputDevice update %{public}d",
1193 audioActiveDevice_.GetCurrentInputDeviceType());
1194 isUpdateActiveDevice = true;
1195 }
1196 needUpdateActiveDevice = false;
1197 }
1198 if (NotifyRecreateCapturerStream(isUpdateActiveDevice, capturerChangeInfo, reason)) {continue;}
1199 // move sourceoutput to target device
1200 MoveToNewInputDevice(capturerChangeInfo, desc);
1201 audioMicrophoneDescriptor_.AddAudioCapturerMicrophoneDescriptor(capturerChangeInfo->sessionId,
1202 desc->deviceType_);
1203 }
1204 }
1205
FetchInputDevice(std::vector<std::shared_ptr<AudioCapturerChangeInfo>> & capturerChangeInfos,const AudioStreamDeviceChangeReasonExt reason)1206 void AudioDeviceCommon::FetchInputDevice(std::vector<std::shared_ptr<AudioCapturerChangeInfo>> &capturerChangeInfos,
1207 const AudioStreamDeviceChangeReasonExt reason)
1208 {
1209 Trace trace("AudioDeviceCommon::FetchInputDevice");
1210 AUDIO_PRERELEASE_LOGI("Start for %{public}zu stream, connected %{public}s",
1211 capturerChangeInfos.size(), audioDeviceManager_.GetConnDevicesStr().c_str());
1212 bool needUpdateActiveDevice = true;
1213 bool isUpdateActiveDevice = false;
1214 int32_t runningStreamCount = 0;
1215
1216 FetchInputDeviceInner(capturerChangeInfos, reason, needUpdateActiveDevice, isUpdateActiveDevice,
1217 runningStreamCount);
1218
1219 FetchInputEnd(isUpdateActiveDevice, runningStreamCount);
1220 }
1221
FetchInputEnd(const bool isUpdateActiveDevice,const int32_t runningStreamCount)1222 void AudioDeviceCommon::FetchInputEnd(const bool isUpdateActiveDevice, const int32_t runningStreamCount)
1223 {
1224 if (isUpdateActiveDevice) {
1225 OnPreferredInputDeviceUpdated(audioActiveDevice_.GetCurrentInputDeviceType(), ""); // networkId is not used.
1226 }
1227 if (runningStreamCount == 0) {
1228 FetchInputDeviceWhenNoRunningStream();
1229 }
1230 }
1231
HandleBluetoothInputDeviceFetched(std::shared_ptr<AudioDeviceDescriptor> & desc,std::vector<std::shared_ptr<AudioCapturerChangeInfo>> & capturerChangeInfos,SourceType sourceType)1232 void AudioDeviceCommon::HandleBluetoothInputDeviceFetched(std::shared_ptr<AudioDeviceDescriptor> &desc,
1233 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> &capturerChangeInfos, SourceType sourceType)
1234 {
1235 if (desc->deviceType_ == DEVICE_TYPE_BLUETOOTH_SCO) {
1236 BluetoothScoFetch(desc, capturerChangeInfos, sourceType);
1237 } else if (desc->deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP_IN) {
1238 HandleA2dpInputDeviceFetched(desc, sourceType);
1239 }
1240 }
1241
WriteInputRouteChangeEvent(std::shared_ptr<AudioDeviceDescriptor> & desc,const AudioStreamDeviceChangeReason reason)1242 void AudioDeviceCommon::WriteInputRouteChangeEvent(std::shared_ptr<AudioDeviceDescriptor> &desc,
1243 const AudioStreamDeviceChangeReason reason)
1244 {
1245 int64_t timeStamp = AudioPolicyUtils::GetInstance().GetCurrentTimeMS();
1246 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1247 Media::MediaMonitor::AUDIO, Media::MediaMonitor::AUDIO_ROUTE_CHANGE,
1248 Media::MediaMonitor::BEHAVIOR_EVENT);
1249 bean->Add("REASON", static_cast<int32_t>(reason));
1250 bean->Add("TIMESTAMP", static_cast<uint64_t>(timeStamp));
1251 bean->Add("DEVICE_TYPE_BEFORE_CHANGE", audioActiveDevice_.GetCurrentInputDeviceType());
1252 bean->Add("DEVICE_TYPE_AFTER_CHANGE", desc->deviceType_);
1253 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1254 }
1255
NotifyRecreateCapturerStream(bool isUpdateActiveDevice,const std::shared_ptr<AudioCapturerChangeInfo> & capturerChangeInfo,const AudioStreamDeviceChangeReasonExt reason)1256 bool AudioDeviceCommon::NotifyRecreateCapturerStream(bool isUpdateActiveDevice,
1257 const std::shared_ptr<AudioCapturerChangeInfo> &capturerChangeInfo,
1258 const AudioStreamDeviceChangeReasonExt reason)
1259 {
1260 AUDIO_INFO_LOG("Is update active device: %{public}d, current capturerFlag: %{public}d, origianl flag: %{public}d",
1261 isUpdateActiveDevice, capturerChangeInfo->capturerInfo.capturerFlags,
1262 capturerChangeInfo->capturerInfo.originalFlag);
1263 CHECK_AND_RETURN_RET_LOG(isUpdateActiveDevice, false, "isUpdateActiveDevice is false");
1264 CHECK_AND_RETURN_RET_LOG(capturerChangeInfo->capturerInfo.originalFlag == AUDIO_FLAG_MMAP, false,
1265 "original flag is false");
1266 // Switch between old and new stream as they have different hals
1267 std::string oldDevicePortName = AudioPolicyUtils::GetInstance().GetSourcePortName(
1268 capturerChangeInfo->inputDeviceInfo.deviceType_);
1269 if ((strcmp(oldDevicePortName.c_str(),
1270 AudioPolicyUtils::GetInstance().GetSourcePortName(audioActiveDevice_.GetCurrentInputDeviceType()).c_str())) ||
1271 ((capturerChangeInfo->inputDeviceInfo.networkId_ == LOCAL_NETWORK_ID) ^
1272 (audioActiveDevice_.GetCurrentInputDevice().networkId_ == LOCAL_NETWORK_ID))) {
1273 int32_t streamClass = GetPreferredInputStreamTypeInner(capturerChangeInfo->capturerInfo.sourceType,
1274 audioActiveDevice_.GetCurrentInputDeviceType(), capturerChangeInfo->capturerInfo.originalFlag,
1275 audioActiveDevice_.GetCurrentInputDevice().networkId_, capturerChangeInfo->capturerInfo.samplingRate);
1276 TriggerRecreateCapturerStreamCallback(capturerChangeInfo, streamClass, reason);
1277 return true;
1278 }
1279 return false;
1280 }
1281
MoveToNewInputDevice(std::shared_ptr<AudioCapturerChangeInfo> & capturerChangeInfo,std::shared_ptr<AudioDeviceDescriptor> & inputDevice)1282 void AudioDeviceCommon::MoveToNewInputDevice(std::shared_ptr<AudioCapturerChangeInfo> &capturerChangeInfo,
1283 std::shared_ptr<AudioDeviceDescriptor> &inputDevice)
1284 {
1285 std::vector<SourceOutput> targetSourceOutputs = FilterSourceOutputs(capturerChangeInfo->sessionId);
1286
1287 // MoveSourceOuputByIndexName
1288 auto ret = (inputDevice->networkId_ == LOCAL_NETWORK_ID)
1289 ? MoveToLocalInputDevice(targetSourceOutputs, std::make_shared<AudioDeviceDescriptor>(*inputDevice))
1290 : MoveToRemoteInputDevice(targetSourceOutputs, std::make_shared<AudioDeviceDescriptor>(*inputDevice));
1291 CHECK_AND_RETURN_LOG((ret == SUCCESS), "Move source output %{public}d to device %{public}d failed!",
1292 capturerChangeInfo->sessionId, inputDevice->deviceType_);
1293 AUDIO_WARNING_LOG("move session %{public}d [%{public}d][%{public}s]-->[%{public}d][%{public}s]",
1294 capturerChangeInfo->sessionId, capturerChangeInfo->inputDeviceInfo.deviceType_,
1295 GetEncryptAddr(capturerChangeInfo->inputDeviceInfo.macAddress_).c_str(),
1296 inputDevice->deviceType_, GetEncryptAddr(inputDevice->macAddress_).c_str());
1297
1298 if (audioConfigManager_.GetUpdateRouteSupport() && inputDevice->networkId_ == LOCAL_NETWORK_ID) {
1299 audioActiveDevice_.UpdateActiveDeviceRoute(inputDevice->deviceType_, DeviceFlag::INPUT_DEVICES_FLAG,
1300 inputDevice->deviceName_);
1301 }
1302 UpdateDeviceInfo(capturerChangeInfo->inputDeviceInfo, std::make_shared<AudioDeviceDescriptor>(*inputDevice),
1303 true, true);
1304 streamCollector_.UpdateCapturerDeviceInfo(capturerChangeInfo->clientUID, capturerChangeInfo->sessionId,
1305 capturerChangeInfo->inputDeviceInfo);
1306 }
1307
FetchInputDeviceWhenNoRunningStream()1308 void AudioDeviceCommon::FetchInputDeviceWhenNoRunningStream()
1309 {
1310 std::shared_ptr<AudioDeviceDescriptor> desc;
1311 AudioDeviceDescriptor tempDesc = audioActiveDevice_.GetCurrentInputDevice();
1312 if (tempDesc.deviceType_ == DEVICE_TYPE_BLUETOOTH_SCO && Bluetooth::AudioHfpManager::IsRecognitionStatus()) {
1313 desc = audioRouterCenter_.FetchInputDevice(SOURCE_TYPE_VOICE_RECOGNITION, -1);
1314 } else {
1315 desc = audioRouterCenter_.FetchInputDevice(SOURCE_TYPE_MIC, -1);
1316 }
1317 CHECK_AND_RETURN_LOG(desc != nullptr, "desc is nullptr");
1318 if (desc->deviceType_ == DEVICE_TYPE_NONE || IsSameDevice(desc, tempDesc)) {
1319 AUDIO_DEBUG_LOG("input device is not change");
1320 return;
1321 }
1322 audioActiveDevice_.SetCurrentInputDevice(*desc);
1323 if (desc->deviceType_ == DEVICE_TYPE_USB_ARM_HEADSET) {
1324 audioEcManager_.PresetArmIdleInput(desc->macAddress_);
1325 }
1326 DeviceType deviceType = audioActiveDevice_.GetCurrentInputDeviceType();
1327 AUDIO_DEBUG_LOG("currentActiveInputDevice update %{public}d", deviceType);
1328 OnPreferredInputDeviceUpdated(deviceType, ""); // networkId is not used
1329 }
1330
BluetoothScoFetch(std::shared_ptr<AudioDeviceDescriptor> & desc,std::vector<std::shared_ptr<AudioCapturerChangeInfo>> & capturerChangeInfos,SourceType sourceType)1331 void AudioDeviceCommon::BluetoothScoFetch(std::shared_ptr<AudioDeviceDescriptor> &desc,
1332 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> &capturerChangeInfos, SourceType sourceType)
1333 {
1334 Trace trace("AudioDeviceCommon::BluetoothScoFetch");
1335 int32_t ret;
1336 if (Util::IsScoSupportSource(sourceType)) {
1337 int32_t activeRet = Bluetooth::AudioHfpManager::SetActiveHfpDevice(desc->macAddress_);
1338 if (activeRet != SUCCESS) {
1339 AUDIO_ERR_LOG("Active hfp device failed, retrigger fetch input device");
1340 desc->exceptionFlag_ = true;
1341 audioDeviceManager_.UpdateDevicesListInfo(
1342 std::make_shared<AudioDeviceDescriptor>(*desc), EXCEPTION_FLAG_UPDATE);
1343 FetchInputDevice(capturerChangeInfos);
1344 }
1345 ret = ScoInputDeviceFetchedForRecongnition(true, desc->macAddress_, desc->connectState_);
1346 } else {
1347 ret = HandleScoInputDeviceFetched(desc, capturerChangeInfos);
1348 }
1349 if (ret != SUCCESS) {
1350 AUDIO_ERR_LOG("sco [%{public}s] is not connected yet", GetEncryptAddr(desc->macAddress_).c_str());
1351 }
1352 }
1353
FilterSourceOutputs(int32_t sessionId)1354 std::vector<SourceOutput> AudioDeviceCommon::FilterSourceOutputs(int32_t sessionId)
1355 {
1356 std::vector<SourceOutput> targetSourceOutputs = {};
1357 std::vector<SourceOutput> sourceOutputs = GetSourceOutputs();
1358
1359 for (size_t i = 0; i < sourceOutputs.size(); i++) {
1360 AUDIO_DEBUG_LOG("sourceOutput[%{public}zu]:%{public}s", i, PrintSourceOutput(sourceOutputs[i]).c_str());
1361 if (sessionId == sourceOutputs[i].streamId) {
1362 targetSourceOutputs.push_back(sourceOutputs[i]);
1363 }
1364 }
1365 return targetSourceOutputs;
1366 }
1367
HandleA2dpInputDeviceFetched(std::shared_ptr<AudioDeviceDescriptor> & desc,SourceType sourceType)1368 void AudioDeviceCommon::HandleA2dpInputDeviceFetched(std::shared_ptr<AudioDeviceDescriptor> &desc,
1369 SourceType sourceType)
1370 {
1371 audioActiveDevice_.SetActiveBtInDeviceMac(desc->macAddress_);
1372 AudioStreamInfo audioStreamInfo = {};
1373 audioActiveDevice_.GetActiveA2dpDeviceStreamInfo(DEVICE_TYPE_BLUETOOTH_A2DP_IN, audioStreamInfo);
1374
1375 std::string networkId = audioActiveDevice_.GetCurrentOutputDeviceNetworkId();
1376 std::string sinkName = AudioPolicyUtils::GetInstance().GetSinkPortName(
1377 audioActiveDevice_.GetCurrentOutputDeviceType());
1378
1379 int32_t ret = LoadA2dpModule(DEVICE_TYPE_BLUETOOTH_A2DP_IN, audioStreamInfo, networkId, sinkName,
1380 sourceType);
1381 CHECK_AND_RETURN_LOG(ret == SUCCESS, "load a2dp input module failed");
1382 }
1383
TriggerRecreateCapturerStreamCallback(const std::shared_ptr<AudioCapturerChangeInfo> & capturerChangeInfo,int32_t streamFlag,const AudioStreamDeviceChangeReasonExt reason)1384 void AudioDeviceCommon::TriggerRecreateCapturerStreamCallback(
1385 const std::shared_ptr<AudioCapturerChangeInfo> &capturerChangeInfo,
1386 int32_t streamFlag, const AudioStreamDeviceChangeReasonExt reason)
1387 {
1388 Trace trace("AudioDeviceCommon::TriggerRecreateCapturerStreamCallback");
1389
1390 AUDIO_WARNING_LOG("Trigger recreate capturer stream, pid: %{public}d, sessionId: %{public}d, flag: %{public}d",
1391 capturerChangeInfo->callerPid, capturerChangeInfo->sessionId, streamFlag);
1392 if (audioPolicyServerHandler_ != nullptr) {
1393 audioPolicyServerHandler_->SendRecreateCapturerStreamEvent(capturerChangeInfo->callerPid,
1394 capturerChangeInfo->sessionId, streamFlag, reason);
1395 } else {
1396 AUDIO_WARNING_LOG("No audio policy server handler");
1397 }
1398 }
1399
MoveToLocalInputDevice(std::vector<SourceOutput> sourceOutputs,std::shared_ptr<AudioDeviceDescriptor> localDeviceDescriptor)1400 int32_t AudioDeviceCommon::MoveToLocalInputDevice(std::vector<SourceOutput> sourceOutputs,
1401 std::shared_ptr<AudioDeviceDescriptor> localDeviceDescriptor)
1402 {
1403 AUDIO_DEBUG_LOG("Start");
1404 // check
1405 CHECK_AND_RETURN_RET_LOG(LOCAL_NETWORK_ID == localDeviceDescriptor->networkId_, ERR_INVALID_OPERATION,
1406 "failed: not a local device.");
1407 // start move.
1408 uint32_t sourceId = -1; // invalid source id, use source name instead.
1409 std::string sourceName = AudioPolicyUtils::GetInstance().GetSourcePortName(localDeviceDescriptor->deviceType_);
1410 for (size_t i = 0; i < sourceOutputs.size(); i++) {
1411 int32_t ret = audioPolicyManager_.MoveSourceOutputByIndexOrName(sourceOutputs[i].paStreamId,
1412 sourceId, sourceName);
1413 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR,
1414 "move [%{public}d] to local failed", sourceOutputs[i].paStreamId);
1415 }
1416
1417 return SUCCESS;
1418 }
1419
MoveToRemoteInputDevice(std::vector<SourceOutput> sourceOutputs,std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor)1420 int32_t AudioDeviceCommon::MoveToRemoteInputDevice(std::vector<SourceOutput> sourceOutputs,
1421 std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor)
1422 {
1423 AUDIO_INFO_LOG("Start");
1424
1425 std::string networkId = remoteDeviceDescriptor->networkId_;
1426 DeviceRole deviceRole = remoteDeviceDescriptor->deviceRole_;
1427 DeviceType deviceType = remoteDeviceDescriptor->deviceType_;
1428
1429 // check: networkid
1430 CHECK_AND_RETURN_RET_LOG(networkId != LOCAL_NETWORK_ID, ERR_INVALID_OPERATION,
1431 "failed: not a remote device.");
1432
1433 uint32_t sourceId = -1; // invalid sink id, use sink name instead.
1434 std::string moduleName = AudioPolicyUtils::GetInstance().GetRemoteModuleName(networkId, deviceRole);
1435
1436 AudioIOHandle moduleId;
1437 if (audioIOHandleMap_.GetModuleIdByKey(moduleName, moduleId)) {
1438 (void)moduleId; // mIOHandle is module id, not equal to sink id.
1439 } else {
1440 AUDIO_ERR_LOG("no such device.");
1441 if (!isOpenRemoteDevice) {
1442 return ERR_INVALID_PARAM;
1443 } else {
1444 return OpenRemoteAudioDevice(networkId, deviceRole, deviceType, remoteDeviceDescriptor);
1445 }
1446 }
1447 int32_t res = AudioServerProxy::GetInstance().CheckRemoteDeviceStateProxy(networkId, deviceRole, true);
1448 CHECK_AND_RETURN_RET_LOG(res == SUCCESS, ERR_OPERATION_FAILED, "remote device state is invalid!");
1449
1450 // start move.
1451 for (size_t i = 0; i < sourceOutputs.size(); i++) {
1452 int32_t ret = audioPolicyManager_.MoveSourceOutputByIndexOrName(sourceOutputs[i].paStreamId,
1453 sourceId, moduleName);
1454 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR,
1455 "move [%{public}d] failed", sourceOutputs[i].paStreamId);
1456 }
1457
1458 if (deviceType != DeviceType::DEVICE_TYPE_DEFAULT) {
1459 AUDIO_DEBUG_LOG("Not defult type[%{public}d] on device:[%{public}s]",
1460 deviceType, GetEncryptStr(networkId).c_str());
1461 }
1462 return SUCCESS;
1463 }
1464
ScoInputDeviceFetchedForRecongnition(bool handleFlag,const std::string & address,ConnectState connectState)1465 int32_t AudioDeviceCommon::ScoInputDeviceFetchedForRecongnition(bool handleFlag, const std::string &address,
1466 ConnectState connectState)
1467 {
1468 if (handleFlag && connectState != DEACTIVE_CONNECTED) {
1469 return SUCCESS;
1470 }
1471 return Bluetooth::AudioHfpManager::HandleScoWithRecongnition(handleFlag);
1472 }
1473
HandleScoInputDeviceFetched(std::shared_ptr<AudioDeviceDescriptor> & desc,std::vector<std::shared_ptr<AudioCapturerChangeInfo>> & capturerChangeInfos)1474 int32_t AudioDeviceCommon::HandleScoInputDeviceFetched(std::shared_ptr<AudioDeviceDescriptor> &desc,
1475 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> &capturerChangeInfos)
1476 {
1477 #ifdef BLUETOOTH_ENABLE
1478 int32_t ret = Bluetooth::AudioHfpManager::SetActiveHfpDevice(desc->macAddress_);
1479 if (ret != SUCCESS) {
1480 AUDIO_ERR_LOG("Active hfp device failed, retrigger fetch input device");
1481 desc->exceptionFlag_ = true;
1482 audioDeviceManager_.UpdateDevicesListInfo(
1483 std::make_shared<AudioDeviceDescriptor>(*desc), EXCEPTION_FLAG_UPDATE);
1484 FetchInputDevice(capturerChangeInfos);
1485 return ERROR;
1486 }
1487 Bluetooth::AudioHfpManager::UpdateAudioScene(audioSceneManager_.GetAudioScene(true));
1488 #endif
1489 return SUCCESS;
1490 }
1491
NotifyDistributedOutputChange(const AudioDeviceDescriptor & deviceDesc)1492 void AudioDeviceCommon::NotifyDistributedOutputChange(const AudioDeviceDescriptor &deviceDesc)
1493 {
1494 bool isDistOld = IsDistributedOutput(audioActiveDevice_.GetCurrentOutputDevice());
1495 bool isDistNew = IsDistributedOutput(deviceDesc);
1496 AUDIO_INFO_LOG("Check Distributed Output Change[%{public}d-->%{public}d]", isDistOld, isDistNew);
1497 if (isDistOld != isDistNew) {
1498 auto ret = audioRouterCenter_.NotifyDistributedOutputChange(isDistNew);
1499 CHECK_AND_RETURN_LOG(ret == SUCCESS, "NotifyDistributedOutputChange Failed. ret=%{public}d", ret);
1500 }
1501 }
1502
MoveToRemoteOutputDevice(std::vector<SinkInput> sinkInputIds,std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor)1503 int32_t AudioDeviceCommon::MoveToRemoteOutputDevice(std::vector<SinkInput> sinkInputIds,
1504 std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor)
1505 {
1506 AUDIO_INFO_LOG("Start for [%{public}zu] sink-inputs", sinkInputIds.size());
1507
1508 std::string networkId = remoteDeviceDescriptor->networkId_;
1509 DeviceRole deviceRole = remoteDeviceDescriptor->deviceRole_;
1510 DeviceType deviceType = remoteDeviceDescriptor->deviceType_;
1511
1512 // check: networkid
1513 CHECK_AND_RETURN_RET_LOG(networkId != LOCAL_NETWORK_ID, ERR_INVALID_OPERATION,
1514 "failed: not a remote device.");
1515
1516 uint32_t sinkId = -1; // invalid sink id, use sink name instead.
1517 std::string moduleName = AudioPolicyUtils::GetInstance().GetRemoteModuleName(networkId, deviceRole);
1518 AudioIOHandle moduleId;
1519 if (audioIOHandleMap_.GetModuleIdByKey(moduleName, moduleId)) {
1520 (void)moduleId; // mIOHandle is module id, not equal to sink id.
1521 } else {
1522 AUDIO_ERR_LOG("no such device.");
1523 if (!isOpenRemoteDevice) {
1524 return ERR_INVALID_PARAM;
1525 } else {
1526 return OpenRemoteAudioDevice(networkId, deviceRole, deviceType, remoteDeviceDescriptor);
1527 }
1528 }
1529 int32_t res = AudioServerProxy::GetInstance().CheckRemoteDeviceStateProxy(networkId, deviceRole, true);
1530 CHECK_AND_RETURN_RET_LOG(res == SUCCESS, ERR_OPERATION_FAILED, "remote device state is invalid!");
1531
1532 // start move.
1533 for (size_t i = 0; i < sinkInputIds.size(); i++) {
1534 int32_t ret = audioPolicyManager_.MoveSinkInputByIndexOrName(sinkInputIds[i].paStreamId, sinkId, moduleName);
1535 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "move [%{public}d] failed", sinkInputIds[i].streamId);
1536 audioRouteMap_.AddRouteMapInfo(sinkInputIds[i].uid, moduleName, sinkInputIds[i].pid);
1537 }
1538
1539 if (deviceType != DeviceType::DEVICE_TYPE_DEFAULT) {
1540 AUDIO_WARNING_LOG("Not defult type[%{public}d] on device:[%{public}s]",
1541 deviceType, GetEncryptStr(networkId).c_str());
1542 }
1543 isCurrentRemoteRenderer = true;
1544 return SUCCESS;
1545 }
1546
MoveToLocalOutputDevice(std::vector<SinkInput> sinkInputIds,std::shared_ptr<AudioDeviceDescriptor> localDeviceDescriptor)1547 int32_t AudioDeviceCommon::MoveToLocalOutputDevice(std::vector<SinkInput> sinkInputIds,
1548 std::shared_ptr<AudioDeviceDescriptor> localDeviceDescriptor)
1549 {
1550 AUDIO_INFO_LOG("Start for [%{public}zu] sink-inputs", sinkInputIds.size());
1551 // check
1552 CHECK_AND_RETURN_RET_LOG(LOCAL_NETWORK_ID == localDeviceDescriptor->networkId_,
1553 ERR_INVALID_OPERATION, "failed: not a local device.");
1554
1555 // start move.
1556 uint32_t sinkId = -1; // invalid sink id, use sink name instead.
1557 for (size_t i = 0; i < sinkInputIds.size(); i++) {
1558 AudioPipeType pipeType = PIPE_TYPE_UNKNOWN;
1559 streamCollector_.GetPipeType(sinkInputIds[i].streamId, pipeType);
1560 std::string sinkName = AudioPolicyUtils::GetInstance().GetSinkPortName(localDeviceDescriptor->deviceType_,
1561 pipeType);
1562 if (sinkName == BLUETOOTH_SPEAKER) {
1563 std::string activePort = BLUETOOTH_SPEAKER;
1564 audioPolicyManager_.SuspendAudioDevice(activePort, false);
1565 }
1566 AUDIO_INFO_LOG("move for session [%{public}d], portName %{public}s pipeType %{public}d",
1567 sinkInputIds[i].streamId, sinkName.c_str(), pipeType);
1568 int32_t ret = audioPolicyManager_.MoveSinkInputByIndexOrName(sinkInputIds[i].paStreamId, sinkId, sinkName);
1569 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR,
1570 "move [%{public}d] to local failed", sinkInputIds[i].streamId);
1571 audioRouteMap_.AddRouteMapInfo(sinkInputIds[i].uid, LOCAL_NETWORK_ID, sinkInputIds[i].pid);
1572 }
1573
1574 isCurrentRemoteRenderer = false;
1575 return SUCCESS;
1576 }
1577
OpenRemoteAudioDevice(std::string networkId,DeviceRole deviceRole,DeviceType deviceType,std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor)1578 int32_t AudioDeviceCommon::OpenRemoteAudioDevice(std::string networkId, DeviceRole deviceRole, DeviceType deviceType,
1579 std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor)
1580 {
1581 // open the test device. We should open it when device is online.
1582 std::string moduleName = AudioPolicyUtils::GetInstance().GetRemoteModuleName(networkId, deviceRole);
1583 AudioModuleInfo remoteDeviceInfo = AudioPolicyUtils::GetInstance().ConstructRemoteAudioModuleInfo(networkId,
1584 deviceRole, deviceType);
1585
1586 auto ret = AudioServerProxy::GetInstance().LoadHdiAdapterProxy(HDI_DEVICE_MANAGER_TYPE_REMOTE, networkId);
1587 if (ret) {
1588 AUDIO_ERR_LOG("load adapter fail");
1589 }
1590 audioIOHandleMap_.OpenPortAndInsertIOHandle(moduleName, remoteDeviceInfo);
1591
1592 // If device already in list, remove it else do not modify the list.
1593 audioConnectedDevice_.DelConnectedDevice(networkId, deviceType);
1594 AudioPolicyUtils::GetInstance().UpdateDisplayName(remoteDeviceDescriptor);
1595 audioConnectedDevice_.AddConnectedDevice(remoteDeviceDescriptor);
1596 audioMicrophoneDescriptor_.AddMicrophoneDescriptor(remoteDeviceDescriptor);
1597 return SUCCESS;
1598 }
1599
CheckAndNotifyUserSelectedDevice(const std::shared_ptr<AudioDeviceDescriptor> & deviceDescriptor)1600 void AudioDeviceCommon::CheckAndNotifyUserSelectedDevice(
1601 const std::shared_ptr<AudioDeviceDescriptor> &deviceDescriptor)
1602 {
1603 shared_ptr<AudioDeviceDescriptor> userSelectedMediaDevice = audioStateManager_.GetPreferredMediaRenderDevice();
1604 shared_ptr<AudioDeviceDescriptor> userSelectedCallDevice = audioStateManager_.GetPreferredCallRenderDevice();
1605 if (userSelectedMediaDevice != nullptr
1606 && userSelectedMediaDevice->connectState_ == VIRTUAL_CONNECTED
1607 && deviceDescriptor->IsSameDeviceDesc(*userSelectedMediaDevice)) {
1608 audioActiveDevice_.NotifyUserSelectionEventToBt(deviceDescriptor);
1609 }
1610 if (userSelectedCallDevice != nullptr
1611 && userSelectedCallDevice->connectState_ == VIRTUAL_CONNECTED
1612 && deviceDescriptor->IsSameDeviceDesc(*userSelectedCallDevice)) {
1613 audioActiveDevice_.NotifyUserSelectionEventToBt(deviceDescriptor);
1614 }
1615 }
1616
HasLowLatencyCapability(DeviceType deviceType,bool isRemote)1617 bool AudioDeviceCommon::HasLowLatencyCapability(DeviceType deviceType, bool isRemote)
1618 {
1619 // Distributed devices are low latency devices
1620 if (isRemote) {
1621 return true;
1622 }
1623
1624 switch (deviceType) {
1625 case DeviceType::DEVICE_TYPE_EARPIECE:
1626 case DeviceType::DEVICE_TYPE_SPEAKER:
1627 case DeviceType::DEVICE_TYPE_WIRED_HEADSET:
1628 case DeviceType::DEVICE_TYPE_WIRED_HEADPHONES:
1629 case DeviceType::DEVICE_TYPE_USB_HEADSET:
1630 case DeviceType::DEVICE_TYPE_DP:
1631 case DeviceType::DEVICE_TYPE_ACCESSORY:
1632 return true;
1633
1634 case DeviceType::DEVICE_TYPE_BLUETOOTH_SCO:
1635 case DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP:
1636 return false;
1637 default:
1638 return false;
1639 }
1640 }
1641
GetSpatialDeviceType(const std::string & macAddress)1642 DeviceType AudioDeviceCommon::GetSpatialDeviceType(const std::string& macAddress)
1643 {
1644 auto it = spatialDeviceMap_.find(macAddress);
1645 DeviceType spatialDevice;
1646 if (it != spatialDeviceMap_.end()) {
1647 spatialDevice = it->second;
1648 } else {
1649 AUDIO_DEBUG_LOG("we can't find the spatialDevice of hvs");
1650 spatialDevice = DEVICE_TYPE_NONE;
1651 }
1652 AUDIO_INFO_LOG("Update a2dpOffloadFlag spatialDevice: %{public}d", spatialDevice);
1653 return spatialDevice;
1654 }
1655
IsRingOverPlayback(AudioMode & mode,RendererState rendererState)1656 bool AudioDeviceCommon::IsRingOverPlayback(AudioMode &mode, RendererState rendererState)
1657 {
1658 if (mode != AUDIO_MODE_PLAYBACK) {
1659 return false;
1660 }
1661 if (rendererState != RENDERER_STOPPED && rendererState != RENDERER_RELEASED &&
1662 rendererState != RENDERER_PAUSED) {
1663 return false;
1664 }
1665 return true;
1666 }
1667
IsDeviceConnected(std::shared_ptr<AudioDeviceDescriptor> & audioDeviceDescriptors) const1668 bool AudioDeviceCommon::IsDeviceConnected(std::shared_ptr<AudioDeviceDescriptor> &audioDeviceDescriptors) const
1669 {
1670 return audioDeviceManager_.IsDeviceConnected(audioDeviceDescriptors);
1671 }
1672
IsSameDevice(std::shared_ptr<AudioDeviceDescriptor> & desc,AudioDeviceDescriptor & deviceInfo)1673 bool AudioDeviceCommon::IsSameDevice(std::shared_ptr<AudioDeviceDescriptor> &desc, AudioDeviceDescriptor &deviceInfo)
1674 {
1675 if (desc->networkId_ == deviceInfo.networkId_ && desc->deviceType_ == deviceInfo.deviceType_ &&
1676 desc->macAddress_ == deviceInfo.macAddress_ && desc->connectState_ == deviceInfo.connectState_) {
1677 if (deviceInfo.IsAudioDeviceDescriptor()) {
1678 return true;
1679 }
1680 BluetoothOffloadState state = audioA2dpOffloadFlag_.GetA2dpOffloadFlag();
1681 if (desc->deviceType_ == DEVICE_TYPE_BLUETOOTH_A2DP &&
1682 // switch to A2dp
1683 ((deviceInfo.a2dpOffloadFlag_ == A2DP_OFFLOAD && state != A2DP_OFFLOAD) ||
1684 // switch to A2dp offload
1685 (deviceInfo.a2dpOffloadFlag_ != A2DP_OFFLOAD && state == A2DP_OFFLOAD))) {
1686 return false;
1687 }
1688 if (IsUsb(desc->deviceType_)) {
1689 return desc->deviceRole_ == deviceInfo.deviceRole_;
1690 }
1691 return true;
1692 } else {
1693 return false;
1694 }
1695 }
1696
IsSameDevice(std::shared_ptr<AudioDeviceDescriptor> & desc,const AudioDeviceDescriptor & deviceDesc)1697 bool AudioDeviceCommon::IsSameDevice(std::shared_ptr<AudioDeviceDescriptor> &desc,
1698 const AudioDeviceDescriptor &deviceDesc)
1699 {
1700 if (desc->networkId_ == deviceDesc.networkId_ && desc->deviceType_ == deviceDesc.deviceType_ &&
1701 desc->macAddress_ == deviceDesc.macAddress_ && desc->connectState_ == deviceDesc.connectState_ &&
1702 (!IsUsb(desc->deviceType_) || desc->deviceRole_ == deviceDesc.deviceRole_)) {
1703 return true;
1704 } else {
1705 return false;
1706 }
1707 }
1708
GetSourceOutputs()1709 std::vector<SourceOutput> AudioDeviceCommon::GetSourceOutputs()
1710 {
1711 std::vector<SourceOutput> sourceOutputs;
1712 {
1713 std::unordered_map<std::string, AudioIOHandle> mapCopy = AudioIOHandleMap::GetInstance().GetCopy();
1714 if (std::any_of(mapCopy.cbegin(), mapCopy.cend(), [](const auto &pair) {
1715 return std::find(SourceNames.cbegin(), SourceNames.cend(), pair.first) != SourceNames.cend();
1716 })) {
1717 sourceOutputs = audioPolicyManager_.GetAllSourceOutputs();
1718 }
1719 }
1720 return sourceOutputs;
1721 }
1722
ClientDiedDisconnectScoNormal()1723 void AudioDeviceCommon::ClientDiedDisconnectScoNormal()
1724 {
1725 bool isRecord = streamCollector_.HasRunningNormalCapturerStream(DEVICE_TYPE_BLUETOOTH_SCO);
1726 AudioScene scene = audioSceneManager_.GetAudioScene(true);
1727 Bluetooth::AudioHfpManager::UpdateAudioScene(scene, isRecord);
1728 }
1729
ClientDiedDisconnectScoRecognition()1730 void AudioDeviceCommon::ClientDiedDisconnectScoRecognition()
1731 {
1732 bool hasRunningRecognitionCapturerStream = streamCollector_.HasRunningRecognitionCapturerStream();
1733 if (hasRunningRecognitionCapturerStream) {
1734 return;
1735 }
1736 Bluetooth::AudioHfpManager::HandleScoWithRecongnition(false);
1737 }
1738
GetA2dpModuleInfo(AudioModuleInfo & moduleInfo,const AudioStreamInfo & audioStreamInfo,SourceType sourceType)1739 void AudioDeviceCommon::GetA2dpModuleInfo(AudioModuleInfo &moduleInfo, const AudioStreamInfo& audioStreamInfo,
1740 SourceType sourceType)
1741 {
1742 uint32_t bufferSize = audioStreamInfo.samplingRate *
1743 AudioPolicyUtils::GetInstance().PcmFormatToBytes(audioStreamInfo.format) *
1744 audioStreamInfo.channels / BT_BUFFER_ADJUSTMENT_FACTOR;
1745 AUDIO_INFO_LOG("a2dp rate: %{public}d, format: %{public}d, channel: %{public}d",
1746 audioStreamInfo.samplingRate, audioStreamInfo.format, audioStreamInfo.channels);
1747 moduleInfo.channels = to_string(audioStreamInfo.channels);
1748 moduleInfo.rate = to_string(audioStreamInfo.samplingRate);
1749 moduleInfo.format = AudioPolicyUtils::GetInstance().ConvertToHDIAudioFormat(audioStreamInfo.format);
1750 moduleInfo.bufferSize = to_string(bufferSize);
1751 if (moduleInfo.role != "source") {
1752 moduleInfo.renderInIdleState = "1";
1753 moduleInfo.sinkLatency = "0";
1754 }
1755 audioEcManager_.UpdateStreamEcAndMicRefInfo(moduleInfo, sourceType);
1756 }
1757
LoadA2dpModule(DeviceType deviceType,const AudioStreamInfo & audioStreamInfo,std::string networkID,std::string sinkName,SourceType sourceType)1758 int32_t AudioDeviceCommon::LoadA2dpModule(DeviceType deviceType, const AudioStreamInfo &audioStreamInfo,
1759 std::string networkID, std::string sinkName, SourceType sourceType)
1760 {
1761 std::list<AudioModuleInfo> moduleInfoList;
1762 bool ret = audioConfigManager_.GetModuleListByType(ClassType::TYPE_A2DP, moduleInfoList);
1763 CHECK_AND_RETURN_RET_LOG(ret, ERR_OPERATION_FAILED,
1764 "A2dp module is not exist in the configuration file");
1765
1766 // not load bt_a2dp_fast and bt_hdap, maybe need fix
1767 int32_t loadRet = AudioServerProxy::GetInstance().LoadHdiAdapterProxy(HDI_DEVICE_MANAGER_TYPE_BLUETOOTH, "bt_a2dp");
1768 if (loadRet) {
1769 AUDIO_ERR_LOG("load adapter fail");
1770 }
1771 for (auto &moduleInfo : moduleInfoList) {
1772 DeviceRole configRole = moduleInfo.role == "source" ? INPUT_DEVICE : OUTPUT_DEVICE;
1773 DeviceRole deviceRole = deviceType == DEVICE_TYPE_BLUETOOTH_A2DP ? OUTPUT_DEVICE : INPUT_DEVICE;
1774 AUDIO_INFO_LOG("Load a2dp module [%{public}s], load role[%{public}d], config role[%{public}d]",
1775 moduleInfo.name.c_str(), deviceRole, configRole);
1776 if (configRole != deviceRole) {continue;}
1777 if (audioIOHandleMap_.CheckIOHandleExist(moduleInfo.name) == false) {
1778 // a2dp device connects for the first time
1779 GetA2dpModuleInfo(moduleInfo, audioStreamInfo, sourceType);
1780 uint32_t temp = 0;
1781 AudioIOHandle ioHandle = audioPolicyManager_.OpenAudioPort(moduleInfo, temp);
1782 CHECK_AND_RETURN_RET_LOG(ioHandle != HDI_INVALID_ID, ERR_OPERATION_FAILED,
1783 "OpenAudioPort failed %{public}d", ioHandle);
1784 audioIOHandleMap_.AddIOHandleInfo(moduleInfo.name, ioHandle);
1785 } else {
1786 // At least one a2dp device is already connected. A new a2dp device is connecting.
1787 // Need to reload a2dp module when switching to a2dp device.
1788 int32_t result = ReloadA2dpAudioPort(moduleInfo, deviceType, audioStreamInfo, networkID, sinkName,
1789 sourceType);
1790 CHECK_AND_RETURN_RET_LOG(result == SUCCESS, result, "ReloadA2dpAudioPort failed %{public}d", result);
1791 }
1792 }
1793
1794 return SUCCESS;
1795 }
1796
ReloadA2dpAudioPort(AudioModuleInfo & moduleInfo,DeviceType deviceType,const AudioStreamInfo & audioStreamInfo,std::string networkID,std::string sinkName,SourceType sourceType)1797 int32_t AudioDeviceCommon::ReloadA2dpAudioPort(AudioModuleInfo &moduleInfo, DeviceType deviceType,
1798 const AudioStreamInfo& audioStreamInfo, std::string networkID, std::string sinkName,
1799 SourceType sourceType)
1800 {
1801 AUDIO_INFO_LOG("switch device from a2dp to another a2dp, reload a2dp module");
1802 if (deviceType == DEVICE_TYPE_BLUETOOTH_A2DP) {
1803 audioIOHandleMap_.MuteDefaultSinkPort(networkID, sinkName);
1804 }
1805
1806 // Firstly, unload the existing a2dp sink or source.
1807 std::string portName = BLUETOOTH_SPEAKER;
1808 if (deviceType == DEVICE_TYPE_BLUETOOTH_A2DP_IN) {
1809 portName = BLUETOOTH_MIC;
1810 }
1811 AudioIOHandle activateDeviceIOHandle;
1812 audioIOHandleMap_.GetModuleIdByKey(portName, activateDeviceIOHandle);
1813 int32_t result = audioPolicyManager_.CloseAudioPort(activateDeviceIOHandle);
1814 CHECK_AND_RETURN_RET_LOG(result == SUCCESS, result,
1815 "CloseAudioPort failed %{public}d", result);
1816
1817 // Load a2dp sink or source module again with the configuration of active a2dp device.
1818 GetA2dpModuleInfo(moduleInfo, audioStreamInfo, sourceType);
1819 uint32_t temp = 0;
1820 AudioIOHandle ioHandle = audioPolicyManager_.OpenAudioPort(moduleInfo, temp);
1821 CHECK_AND_RETURN_RET_LOG(ioHandle != HDI_INVALID_ID, ERR_OPERATION_FAILED,
1822 "OpenAudioPort failed %{public}d", ioHandle);
1823 audioIOHandleMap_.AddIOHandleInfo(moduleInfo.name, ioHandle);
1824 return SUCCESS;
1825 }
1826
SwitchActiveA2dpDevice(const std::shared_ptr<AudioDeviceDescriptor> & deviceDescriptor)1827 int32_t AudioDeviceCommon::SwitchActiveA2dpDevice(const std::shared_ptr<AudioDeviceDescriptor> &deviceDescriptor)
1828 {
1829 CHECK_AND_RETURN_RET_LOG(audioA2dpDevice_.CheckA2dpDeviceExist(deviceDescriptor->macAddress_),
1830 ERR_INVALID_PARAM, "the target A2DP device doesn't exist.");
1831 int32_t result = ERROR;
1832 #ifdef BLUETOOTH_ENABLE
1833 AUDIO_INFO_LOG("a2dp device name [%{public}s]", (deviceDescriptor->deviceName_).c_str());
1834 std::string lastActiveA2dpDevice = audioActiveDevice_.GetActiveBtDeviceMac();
1835 audioActiveDevice_.SetActiveBtDeviceMac(deviceDescriptor->macAddress_);
1836 AudioDeviceDescriptor lastDevice = audioPolicyManager_.GetActiveDeviceDescriptor();
1837 deviceDescriptor->deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
1838
1839 if (Bluetooth::AudioA2dpManager::GetActiveA2dpDevice() == deviceDescriptor->macAddress_ &&
1840 audioIOHandleMap_.CheckIOHandleExist(BLUETOOTH_SPEAKER)) {
1841 AUDIO_WARNING_LOG("a2dp device [%{public}s] is already active",
1842 GetEncryptAddr(deviceDescriptor->macAddress_).c_str());
1843 return SUCCESS;
1844 }
1845
1846 result = Bluetooth::AudioA2dpManager::SetActiveA2dpDevice(deviceDescriptor->macAddress_);
1847 if (result != SUCCESS) {
1848 audioActiveDevice_.SetActiveBtDeviceMac(lastActiveA2dpDevice);
1849 AUDIO_ERR_LOG("Active [%{public}s] failed, using original [%{public}s] device",
1850 GetEncryptAddr(audioActiveDevice_.GetActiveBtDeviceMac()).c_str(),
1851 GetEncryptAddr(lastActiveA2dpDevice).c_str());
1852 return result;
1853 }
1854
1855 AudioStreamInfo audioStreamInfo = {};
1856 audioActiveDevice_.GetActiveA2dpDeviceStreamInfo(DEVICE_TYPE_BLUETOOTH_A2DP, audioStreamInfo);
1857 std::string networkId = audioActiveDevice_.GetCurrentOutputDeviceNetworkId();
1858 std::string sinkName = AudioPolicyUtils::GetInstance().GetSinkPortName(
1859 audioActiveDevice_.GetCurrentOutputDeviceType());
1860 result = LoadA2dpModule(DEVICE_TYPE_BLUETOOTH_A2DP, audioStreamInfo, networkId, sinkName, SOURCE_TYPE_INVALID);
1861 CHECK_AND_RETURN_RET_LOG(result == SUCCESS, ERR_OPERATION_FAILED, "LoadA2dpModule failed %{public}d", result);
1862 #endif
1863 return result;
1864 }
1865
RingToneVoiceControl(const InternalDeviceType & deviceType)1866 int32_t AudioDeviceCommon::RingToneVoiceControl(const InternalDeviceType &deviceType)
1867 {
1868 int32_t curVoiceCallLevel = audioPolicyManager_.GetSystemVolumeLevel(STREAM_VOICE_CALL);
1869 float curVoiceCallDb = audioPolicyManager_.GetSystemVolumeInDb(STREAM_VOICE_CALL, curVoiceCallLevel, deviceType);
1870 int32_t curRingToneLevel = audioPolicyManager_.GetSystemVolumeLevel(STREAM_RING);
1871 float curRingToneDb = audioPolicyManager_.GetSystemVolumeInDb(STREAM_RING, curRingToneLevel, deviceType);
1872 int32_t maxVoiceCall = audioPolicyManager_.GetMaxVolumeLevel(STREAM_VOICE_CALL);
1873 int32_t maxRingTone = audioPolicyManager_.GetMaxVolumeLevel(STREAM_RING);
1874 float curVoiceRingMixDb = curVoiceCallDb * curRingToneDb;
1875 float minMixDbDefault = audioPolicyManager_.GetSystemVolumeInDb(STREAM_VOICE_CALL,
1876 maxVoiceCall * VOLUME_LEVEL_MIN_SIZE / VOLUME_LEVEL_MAX_SIZE, deviceType) *
1877 audioPolicyManager_.GetSystemVolumeInDb(STREAM_RING, maxRingTone, deviceType);
1878 float maxMixDbDefault = audioPolicyManager_.GetSystemVolumeInDb(STREAM_VOICE_CALL,
1879 maxVoiceCall * VOLUME_LEVEL_MID_SIZE / VOLUME_LEVEL_MAX_SIZE, deviceType) *
1880 audioPolicyManager_.GetSystemVolumeInDb(STREAM_RING, maxRingTone, deviceType);
1881
1882 if (curVoiceCallLevel > VOLUME_LEVEL_DEFAULT) {
1883 for (int i = 0; i < DEFAULT_ADJUST_TIMES; i++) {
1884 if (curVoiceRingMixDb < minMixDbDefault && curRingToneLevel <= VOLUME_LEVEL_MAX_SIZE) {
1885 curRingToneLevel++;
1886 curRingToneDb = audioPolicyManager_.GetSystemVolumeInDb(STREAM_RING, curRingToneLevel, deviceType);
1887 curVoiceRingMixDb = curVoiceCallDb * curRingToneDb;
1888 } else if (curVoiceRingMixDb > maxMixDbDefault && curRingToneLevel > 0) {
1889 curRingToneLevel--;
1890 curRingToneDb = audioPolicyManager_.GetSystemVolumeInDb(STREAM_RING, curRingToneLevel, deviceType);
1891 curVoiceRingMixDb = curVoiceCallDb * curRingToneDb;
1892 } else {
1893 break;
1894 }
1895 }
1896 }
1897 return curRingToneLevel;
1898 }
1899
SetFirstScreenOn()1900 void AudioDeviceCommon::SetFirstScreenOn()
1901 {
1902 isFirstScreenOn_ = true;
1903 }
1904
SetVirtualCall(pid_t uid,const bool isVirtual)1905 int32_t AudioDeviceCommon::SetVirtualCall(pid_t uid, const bool isVirtual)
1906 {
1907 if (uid == 5523) { /* 5523 call manager */
1908 return Bluetooth::AudioHfpManager::SetVirtualCall("meetimeservice", isVirtual);
1909 }
1910 std::string bundleName = AudioBundleManager::GetBundleNameFromUid(uid);
1911 return Bluetooth::AudioHfpManager::SetVirtualCall(bundleName, isVirtual);
1912 }
1913
SetHeadsetUnpluggedToSpkOrEpFlag(DeviceType oldDeviceType,DeviceType newDeviceType)1914 void AudioDeviceCommon::SetHeadsetUnpluggedToSpkOrEpFlag(DeviceType oldDeviceType, DeviceType newDeviceType)
1915 {
1916 if ((oldDeviceType == DEVICE_TYPE_USB_HEADSET || oldDeviceType == DEVICE_TYPE_USB_ARM_HEADSET) &&
1917 (newDeviceType == DEVICE_TYPE_SPEAKER || newDeviceType == DEVICE_TYPE_EARPIECE)) {
1918 isHeadsetUnpluggedToSpkOrEpFlag_ = true;
1919 }
1920 }
1921 }
1922 }
1923