1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_device_common_unit_test.h"
17
18 using namespace testing::ext;
19
20 namespace OHOS {
21 namespace AudioStandard {
22 static const int32_t GET_RESULT_NO_VALUE = 0;
23 static const int32_t GET_RESULT_HAS_VALUE = 1;
24
SetUpTestCase(void)25 void AudioDeviceCommonUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)26 void AudioDeviceCommonUnitTest::TearDownTestCase(void) {}
SetUp(void)27 void AudioDeviceCommonUnitTest::SetUp(void) {}
TearDown(void)28 void AudioDeviceCommonUnitTest::TearDown(void) {}
29
30 /**
31 * @tc.name : Test AudioDeviceCommon.
32 * @tc.number: AudioDeviceCommon_001
33 * @tc.desc : Test GetHasDpFlag interface.
34 */
35 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_001, TestSize.Level1)
36 {
37 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
38 audioDeviceCommon.audioPolicyServerHandler_ = nullptr;
39 AudioDeviceDescriptor deviceDescriptor;
40 audioDeviceCommon.OnPreferredOutputDeviceUpdated(deviceDescriptor);
41 EXPECT_NE(0, audioDeviceCommon.spatialDeviceMap_.size());
42
43 DeviceType deviceType = DEVICE_TYPE_NONE;
44 audioDeviceCommon.OnPreferredInputDeviceUpdated(deviceType, "");
45 EXPECT_EQ(nullptr, audioDeviceCommon.audioPolicyServerHandler_);
46
47 AudioRendererInfo rendererInfo;
48 rendererInfo.streamUsage = static_cast<StreamUsage>(1000);
49
50 std::vector<std::shared_ptr<AudioDeviceDescriptor>> deviceOutputList =
51 audioDeviceCommon.GetPreferredOutputDeviceDescInner(rendererInfo, "");
52 EXPECT_EQ(1, deviceOutputList.size());
53
54 AudioCapturerInfo captureInfo;
55 captureInfo.sourceType = SOURCE_TYPE_INVALID;
56 std::vector<std::shared_ptr<AudioDeviceDescriptor>> deviceInputList =
57 audioDeviceCommon.GetPreferredInputDeviceDescInner(captureInfo, "");
58 EXPECT_EQ(1, deviceOutputList.size());
59 }
60
61 /**
62 * @tc.name : Test AudioDeviceCommon.
63 * @tc.number: AudioDeviceCommon_002
64 * @tc.desc : Test IsRingerOrAlarmerDualDevicesRange interface.
65 */
66 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_002, TestSize.Level1)
67 {
68 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
69 InternalDeviceType deviceType = DEVICE_TYPE_SPEAKER;
70 bool ret = audioDeviceCommon.IsRingerOrAlarmerDualDevicesRange(deviceType);
71 EXPECT_EQ(true, ret);
72
73 deviceType = DEVICE_TYPE_WIRED_HEADSET;
74 ret = audioDeviceCommon.IsRingerOrAlarmerDualDevicesRange(deviceType);
75 EXPECT_EQ(true, ret);
76
77 deviceType = DEVICE_TYPE_WIRED_HEADPHONES;
78 ret = audioDeviceCommon.IsRingerOrAlarmerDualDevicesRange(deviceType);
79 EXPECT_EQ(true, ret);
80
81 deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
82 ret = audioDeviceCommon.IsRingerOrAlarmerDualDevicesRange(deviceType);
83 EXPECT_EQ(true, ret);
84
85 deviceType = DEVICE_TYPE_BLUETOOTH_A2DP;
86 ret = audioDeviceCommon.IsRingerOrAlarmerDualDevicesRange(deviceType);
87 EXPECT_EQ(true, ret);
88
89 deviceType = DEVICE_TYPE_USB_HEADSET;
90 ret = audioDeviceCommon.IsRingerOrAlarmerDualDevicesRange(deviceType);
91 EXPECT_EQ(true, ret);
92
93 deviceType = DEVICE_TYPE_USB_ARM_HEADSET;
94 ret = audioDeviceCommon.IsRingerOrAlarmerDualDevicesRange(deviceType);
95 EXPECT_EQ(true, ret);
96
97 deviceType = DEVICE_TYPE_REMOTE_CAST;
98 ret = audioDeviceCommon.IsRingerOrAlarmerDualDevicesRange(deviceType);
99 EXPECT_EQ(true, ret);
100
101 deviceType = DEVICE_TYPE_EARPIECE;
102 ret = audioDeviceCommon.IsRingerOrAlarmerDualDevicesRange(deviceType);
103 EXPECT_EQ(false, ret);
104
105 deviceType = DEVICE_TYPE_BLUETOOTH_A2DP_IN;
106 ret = audioDeviceCommon.IsRingerOrAlarmerDualDevicesRange(deviceType);
107 EXPECT_EQ(false, ret);
108
109 deviceType = DEVICE_TYPE_MIC;
110 ret = audioDeviceCommon.IsRingerOrAlarmerDualDevicesRange(deviceType);
111 EXPECT_EQ(false, ret);
112
113 deviceType = DEVICE_TYPE_DP;
114 ret = audioDeviceCommon.IsRingerOrAlarmerDualDevicesRange(deviceType);
115 EXPECT_EQ(false, ret);
116 }
117
118 /**
119 * @tc.name : Test AudioDeviceCommon.
120 * @tc.number: AudioDeviceCommon_003
121 * @tc.desc : Test GetPreferredOutputDeviceDescInner interface.
122 */
123 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_003, TestSize.Level1)
124 {
125 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
126 audioDeviceCommon.audioPolicyServerHandler_ = nullptr;
127 AudioDeviceDescriptor deviceDescriptor;
128 audioDeviceCommon.OnPreferredOutputDeviceUpdated(deviceDescriptor);
129
130 DeviceType deviceType = DEVICE_TYPE_NONE;
131 audioDeviceCommon.OnPreferredInputDeviceUpdated(deviceType, "");
132
133 AudioRendererInfo rendererInfo;
134 rendererInfo.streamUsage = STREAM_USAGE_MUSIC;
135 std::vector<std::shared_ptr<AudioDeviceDescriptor>> ret =
136 audioDeviceCommon.GetPreferredOutputDeviceDescInner(rendererInfo, "LocalDevice");
137 EXPECT_EQ(GET_RESULT_HAS_VALUE, ret.size());
138
139 AudioCapturerInfo captureInfo;
140 captureInfo.sourceType = SOURCE_TYPE_MAX;
141 ret = audioDeviceCommon.GetPreferredInputDeviceDescInner(captureInfo, "");
142 EXPECT_EQ(GET_RESULT_NO_VALUE, ret.size());
143 }
144
145 /**
146 * @tc.name : Test AudioDeviceCommon.
147 * @tc.number: AudioDeviceCommon_004
148 * @tc.desc : Test GetPreferredOutputDeviceDescInner interface.
149 */
150 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_004, TestSize.Level1)
151 {
152 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
153 audioDeviceCommon.audioPolicyServerHandler_ = nullptr;
154 AudioDeviceDescriptor deviceDescriptor;
155 audioDeviceCommon.OnPreferredOutputDeviceUpdated(deviceDescriptor);
156
157 DeviceType deviceType = DEVICE_TYPE_NONE;
158 audioDeviceCommon.OnPreferredInputDeviceUpdated(deviceType, "");
159
160 AudioRendererInfo rendererInfo;
161 rendererInfo.streamUsage = STREAM_USAGE_MUSIC;
162 std::vector<std::shared_ptr<AudioDeviceDescriptor>> ret =
163 audioDeviceCommon.GetPreferredOutputDeviceDescInner(rendererInfo, "");
164 EXPECT_EQ(GET_RESULT_NO_VALUE, ret.size());
165
166 AudioCapturerInfo captureInfo;
167 captureInfo.sourceType = SOURCE_TYPE_WAKEUP;
168 ret = audioDeviceCommon.GetPreferredInputDeviceDescInner(captureInfo, "");
169 EXPECT_EQ(GET_RESULT_HAS_VALUE, ret.size());
170 }
171
172 /**
173 * @tc.name : Test AudioDeviceCommon.
174 * @tc.number: AudioDeviceCommon_005
175 * @tc.desc : Test GetPreferredInputDeviceDescInner interface.
176 */
177 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_005, TestSize.Level1)
178 {
179 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
180 audioDeviceCommon.audioPolicyServerHandler_ = nullptr;
181 AudioDeviceDescriptor deviceDescriptor;
182 audioDeviceCommon.OnPreferredOutputDeviceUpdated(deviceDescriptor);
183
184 DeviceType deviceType = DEVICE_TYPE_NONE;
185 audioDeviceCommon.OnPreferredInputDeviceUpdated(deviceType, "");
186
187 AudioRendererInfo rendererInfo;
188 rendererInfo.streamUsage = STREAM_USAGE_MUSIC;
189 std::vector<std::shared_ptr<AudioDeviceDescriptor>> ret =
190 audioDeviceCommon.GetPreferredOutputDeviceDescInner(rendererInfo, "");
191 EXPECT_EQ(GET_RESULT_NO_VALUE, ret.size());
192
193 AudioCapturerInfo captureInfo;
194 captureInfo.sourceType = SOURCE_TYPE_MIC;
195 ret = audioDeviceCommon.GetPreferredInputDeviceDescInner(captureInfo, "LocalDevice");
196 EXPECT_EQ(GET_RESULT_HAS_VALUE, ret.size());
197 }
198
199 /**
200 * @tc.name : Test AudioDeviceCommon.
201 * @tc.number: AudioDeviceCommon_006
202 * @tc.desc : Test GetPreferredInputDeviceDescInner interface.
203 */
204 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_006, TestSize.Level1)
205 {
206 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
207 audioDeviceCommon.audioPolicyServerHandler_ = nullptr;
208 AudioDeviceDescriptor deviceDescriptor;
209 audioDeviceCommon.OnPreferredOutputDeviceUpdated(deviceDescriptor);
210
211 DeviceType deviceType = DEVICE_TYPE_NONE;
212 audioDeviceCommon.OnPreferredInputDeviceUpdated(deviceType, "");
213
214 AudioRendererInfo rendererInfo;
215 rendererInfo.streamUsage = STREAM_USAGE_MUSIC;
216 std::vector<std::shared_ptr<AudioDeviceDescriptor>> ret =
217 audioDeviceCommon.GetPreferredOutputDeviceDescInner(rendererInfo, "");
218 EXPECT_EQ(GET_RESULT_NO_VALUE, ret.size());
219
220 AudioCapturerInfo captureInfo;
221 captureInfo.sourceType = SOURCE_TYPE_MIC;
222 ret = audioDeviceCommon.GetPreferredInputDeviceDescInner(captureInfo, "");
223 EXPECT_EQ(GET_RESULT_NO_VALUE, ret.size());
224 }
225
226 /**
227 * @tc.name : Test AudioDeviceCommon.
228 * @tc.number: AudioDeviceCommon_010
229 * @tc.desc : Test IsRingerOrAlarmerDualDevicesRange interface.
230 */
231 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_010, TestSize.Level1)
232 {
233 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
234 DeviceType deviceType = DEVICE_TYPE_EARPIECE;
235 bool isRemote = true;
236 bool ret = audioDeviceCommon.HasLowLatencyCapability(deviceType, isRemote);
237 EXPECT_EQ(true, ret);
238
239 isRemote = false;
240 deviceType = DEVICE_TYPE_EARPIECE;
241 ret = audioDeviceCommon.HasLowLatencyCapability(deviceType, isRemote);
242 EXPECT_EQ(true, ret);
243
244 isRemote = false;
245 deviceType = DEVICE_TYPE_SPEAKER;
246 ret = audioDeviceCommon.HasLowLatencyCapability(deviceType, isRemote);
247 EXPECT_EQ(true, ret);
248
249 isRemote = false;
250 deviceType = DEVICE_TYPE_WIRED_HEADSET;
251 ret = audioDeviceCommon.HasLowLatencyCapability(deviceType, isRemote);
252 EXPECT_EQ(true, ret);
253
254 isRemote = false;
255 deviceType = DEVICE_TYPE_WIRED_HEADPHONES;
256 ret = audioDeviceCommon.HasLowLatencyCapability(deviceType, isRemote);
257 EXPECT_EQ(true, ret);
258
259 isRemote = false;
260 deviceType = DEVICE_TYPE_USB_HEADSET;
261 ret = audioDeviceCommon.HasLowLatencyCapability(deviceType, isRemote);
262 EXPECT_EQ(true, ret);
263
264 isRemote = false;
265 deviceType = DEVICE_TYPE_DP;
266 ret = audioDeviceCommon.HasLowLatencyCapability(deviceType, isRemote);
267 EXPECT_EQ(true, ret);
268
269 isRemote = false;
270 deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
271 ret = audioDeviceCommon.HasLowLatencyCapability(deviceType, isRemote);
272 EXPECT_EQ(false, ret);
273
274 isRemote = false;
275 deviceType = DEVICE_TYPE_BLUETOOTH_A2DP;
276 ret = audioDeviceCommon.HasLowLatencyCapability(deviceType, isRemote);
277 EXPECT_EQ(false, ret);
278
279 isRemote = false;
280 deviceType = DEVICE_TYPE_BLUETOOTH_A2DP_IN;
281 ret = audioDeviceCommon.HasLowLatencyCapability(deviceType, isRemote);
282 EXPECT_EQ(false, ret);
283
284 isRemote = false;
285 deviceType = DEVICE_TYPE_MIC;
286 ret = audioDeviceCommon.HasLowLatencyCapability(deviceType, isRemote);
287 EXPECT_EQ(false, ret);
288 }
289
290 /**
291 * @tc.name : Test AudioDeviceCommon.
292 * @tc.number: AudioDeviceCommon_020
293 * @tc.desc : Test UpdateDeviceInfo interface.
294 */
295 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_020, TestSize.Level1)
296 {
297 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
298 AudioDeviceDescriptor deviceInfo;
299 bool hasBTPermission = true;
300 bool hasSystemPermission = true;
301 BluetoothOffloadState state = NO_A2DP_DEVICE;
302 audioDeviceCommon.audioA2dpOffloadFlag_.SetA2dpOffloadFlag(state);
303 audioDeviceCommon.UpdateDeviceInfo(deviceInfo, std::make_shared<AudioDeviceDescriptor>(),
304 hasBTPermission, hasSystemPermission);
305 EXPECT_EQ(NO_A2DP_DEVICE, deviceInfo.a2dpOffloadFlag_);
306 }
307
308 /**
309 * @tc.name : Test AudioDeviceCommon.
310 * @tc.number: AudioDeviceCommon_021
311 * @tc.desc : Test UpdateDeviceInfo interface.
312 */
313 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_021, TestSize.Level1)
314 {
315 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
316 AudioDeviceDescriptor deviceInfo;
317 bool hasBTPermission = false;
318 bool hasSystemPermission = true;
319 BluetoothOffloadState state = NO_A2DP_DEVICE;
320 audioDeviceCommon.audioA2dpOffloadFlag_.SetA2dpOffloadFlag(state);
321 audioDeviceCommon.UpdateDeviceInfo(deviceInfo, std::make_shared<AudioDeviceDescriptor>(),
322 hasBTPermission, hasSystemPermission);
323 EXPECT_EQ(CATEGORY_DEFAULT, deviceInfo.deviceCategory_);
324 }
325
326 /**
327 * @tc.name : Test AudioDeviceCommon.
328 * @tc.number: AudioDeviceCommon_022
329 * @tc.desc : Test UpdateDeviceInfo interface.
330 */
331 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_022, TestSize.Level1)
332 {
333 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
334 AudioDeviceDescriptor deviceInfo;
335 bool hasBTPermission = false;
336 bool hasSystemPermission = false;
337 BluetoothOffloadState state = NO_A2DP_DEVICE;
338 audioDeviceCommon.audioA2dpOffloadFlag_.SetA2dpOffloadFlag(state);
339 audioDeviceCommon.UpdateDeviceInfo(deviceInfo, std::make_shared<AudioDeviceDescriptor>(),
340 hasBTPermission, hasSystemPermission);
341 EXPECT_EQ(GROUP_ID_NONE, deviceInfo.volumeGroupId_);
342 EXPECT_EQ(GROUP_ID_NONE, deviceInfo.interruptGroupId_);
343 }
344
345 /**
346 * @tc.name : Test AudioDeviceCommon.
347 * @tc.number: AudioDeviceCommon_023
348 * @tc.desc : Test DeviceParamsCheck interface.
349 */
350 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_023, TestSize.Level1)
351 {
352 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
353 DeviceRole targetRole = INPUT_DEVICE;
354 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
355 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorSptrVector;
356 audioDeviceDescriptorSptrVector.push_back(audioDeviceDescriptorSptr);
357 int32_t ret = audioDeviceCommon.DeviceParamsCheck(targetRole, audioDeviceDescriptorSptrVector);
358 EXPECT_EQ(ERR_INVALID_OPERATION, ret);
359 }
360
361 /**
362 * @tc.name : Test AudioDeviceCommon.
363 * @tc.number: AudioDeviceCommon_024
364 * @tc.desc : Test DeviceParamsCheck interface.
365 */
366 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_024, TestSize.Level1)
367 {
368 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
369 DeviceRole targetRole = OUTPUT_DEVICE;
370 std::vector<std::shared_ptr<AudioDeviceDescriptor>> sharedAudioDeviceDescriptors;
371 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
372 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorSptrVector;
373 audioDeviceDescriptorSptrVector.push_back(audioDeviceDescriptorSptr);
374 int32_t ret = audioDeviceCommon.DeviceParamsCheck(targetRole, audioDeviceDescriptorSptrVector);
375 EXPECT_EQ(ERR_INVALID_OPERATION, ret);
376 }
377
378 /**
379 * @tc.name : Test AudioDeviceCommon.
380 * @tc.number: AudioDeviceCommon_026
381 * @tc.desc : Test UpdateConnectedDevicesWhenConnecting interface.
382 */
383 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_026, TestSize.Level1)
384 {
385 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
386 AudioDeviceDescriptor updatedDesc;
387 updatedDesc.deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
388 updatedDesc.deviceRole_ = INPUT_DEVICE;
389 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
390 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorSptrVector;
391 audioDeviceDescriptorSptrVector.push_back(audioDeviceDescriptorSptr);
392 audioDeviceCommon.UpdateConnectedDevicesWhenConnecting(updatedDesc, audioDeviceDescriptorSptrVector);
393 audioDeviceCommon.RemoveOfflineDevice(updatedDesc);
394 EXPECT_EQ(2, audioDeviceDescriptorSptrVector.size());
395 }
396
397 /**
398 * @tc.name : Test AudioDeviceCommon.
399 * @tc.number: AudioDeviceCommon_027
400 * @tc.desc : Test UpdateConnectedDevicesWhenConnecting interface.
401 */
402 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_027, TestSize.Level1)
403 {
404 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
405 AudioDeviceDescriptor updatedDesc;
406 updatedDesc.deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
407 updatedDesc.deviceRole_ = OUTPUT_DEVICE;
408 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
409 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorSptrVector;
410 audioDeviceDescriptorSptrVector.push_back(audioDeviceDescriptorSptr);
411 audioDeviceCommon.UpdateConnectedDevicesWhenConnecting(updatedDesc, audioDeviceDescriptorSptrVector);
412 audioDeviceCommon.RemoveOfflineDevice(updatedDesc);
413 EXPECT_EQ(2, audioDeviceDescriptorSptrVector.size());
414 }
415
416 /**
417 * @tc.name : Test AudioDeviceCommon.
418 * @tc.number: AudioDeviceCommon_028
419 * @tc.desc : Test UpdateConnectedDevicesWhenDisconnecting interface.
420 */
421 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_028, TestSize.Level1)
422 {
423 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
424 AudioDeviceDescriptor updatedDesc;
425 updatedDesc.deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
426 updatedDesc.deviceRole_ = OUTPUT_DEVICE;
427 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
428 audioDeviceDescriptorSptr->deviceType_ = DEVICE_TYPE_DP;
429 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorSptrVector;
430 audioDeviceDescriptorSptrVector.push_back(audioDeviceDescriptorSptr);
431 audioDeviceCommon.UpdateConnectedDevicesWhenDisconnecting(updatedDesc, audioDeviceDescriptorSptrVector);
432 EXPECT_EQ(false, audioDeviceCommon.hasDpDevice_);
433 }
434
435 /**
436 * @tc.name : Test AudioDeviceCommon.
437 * @tc.number: AudioDeviceCommon_029
438 * @tc.desc : Test UpdateConnectedDevicesWhenDisconnecting interface.
439 */
440 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_029, TestSize.Level1)
441 {
442 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
443 AudioDeviceDescriptor updatedDesc;
444 updatedDesc.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
445 updatedDesc.deviceRole_ = INPUT_DEVICE;
446 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
447 audioDeviceDescriptorSptr->deviceType_ = DEVICE_TYPE_DP;
448 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorSptrVector;
449 audioDeviceDescriptorSptrVector.push_back(audioDeviceDescriptorSptr);
450 audioDeviceCommon.UpdateConnectedDevicesWhenDisconnecting(updatedDesc, audioDeviceDescriptorSptrVector);
451 EXPECT_EQ(false, audioDeviceCommon.hasDpDevice_);
452 }
453
454 /**
455 * @tc.name : Test AudioDeviceCommon.
456 * @tc.number: AudioDeviceCommon_030
457 * @tc.desc : Test UpdateConnectedDevicesWhenConnectingForInputDevice interface.
458 */
459 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_030, TestSize.Level1)
460 {
461 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
462 AudioDeviceDescriptor updatedDesc;
463 updatedDesc.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
464 updatedDesc.deviceRole_ = INPUT_DEVICE;
465 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
466 audioDeviceDescriptorSptr->deviceType_ = DEVICE_TYPE_DP;
467 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorSptrVector;
468 audioDeviceDescriptorSptrVector.push_back(audioDeviceDescriptorSptr);
469 audioDeviceCommon.UpdateConnectedDevicesWhenConnectingForInputDevice(updatedDesc,
470 audioDeviceDescriptorSptrVector);
471 EXPECT_EQ(2, audioDeviceDescriptorSptrVector.size());
472 }
473
474 /**
475 * @tc.name : Test AudioDeviceCommon.
476 * @tc.number: AudioDeviceCommon_031
477 * @tc.desc : Test UpdateConnectedDevicesWhenConnectingForInputDevice interface.
478 */
479 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_031, TestSize.Level1)
480 {
481 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
482 AudioDeviceDescriptor updatedDesc;
483 updatedDesc.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
484 updatedDesc.deviceRole_ = INPUT_DEVICE;
485 updatedDesc.connectState_ = VIRTUAL_CONNECTED;
486 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
487 audioDeviceDescriptorSptr->deviceType_ = DEVICE_TYPE_DP;
488 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorSptrVector;
489 audioDeviceDescriptorSptrVector.push_back(audioDeviceDescriptorSptr);
490 audioDeviceCommon.UpdateConnectedDevicesWhenConnectingForInputDevice(updatedDesc,
491 audioDeviceDescriptorSptrVector);
492 EXPECT_EQ(2, audioDeviceDescriptorSptrVector.size());
493 }
494
495 /**
496 * @tc.name : Test AudioDeviceCommon.
497 * @tc.number: AudioDeviceCommon_032
498 * @tc.desc : Test UpdateConnectedDevicesWhenConnectingForOutputDevice interface.
499 */
500 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_032, TestSize.Level1)
501 {
502 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
503 AudioDeviceDescriptor updatedDesc;
504 updatedDesc.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
505 updatedDesc.deviceRole_ = INPUT_DEVICE;
506 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
507 audioDeviceDescriptorSptr->deviceType_ = DEVICE_TYPE_DP;
508 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorSptrVector;
509 audioDeviceDescriptorSptrVector.push_back(audioDeviceDescriptorSptr);
510 audioDeviceCommon.UpdateConnectedDevicesWhenConnectingForOutputDevice(updatedDesc,
511 audioDeviceDescriptorSptrVector);
512 EXPECT_EQ(2, audioDeviceDescriptorSptrVector.size());
513 }
514
515 /** std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorSptrVector;
516 * @tc.name : Test AudioDeviceCommon.
517 * @tc.number: AudioDeviceCommon_033
518 * @tc.desc : Test UpdateConnectedDevicesWhenConnectingForOutputDevice interface.
519 */
520 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_033, TestSize.Level1)
521 {
522 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
523 AudioDeviceDescriptor updatedDesc;
524 updatedDesc.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
525 updatedDesc.deviceRole_ = INPUT_DEVICE;
526 updatedDesc.connectState_ = VIRTUAL_CONNECTED;
527 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
528 audioDeviceDescriptorSptr->deviceType_ = DEVICE_TYPE_DP;
529 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorSptrVector;
530 audioDeviceDescriptorSptrVector.push_back(audioDeviceDescriptorSptr);
531 audioDeviceCommon.UpdateConnectedDevicesWhenConnectingForOutputDevice(updatedDesc,
532 audioDeviceDescriptorSptrVector);
533 EXPECT_EQ(2, audioDeviceDescriptorSptrVector.size());
534 }
535
536 /**
537 * @tc.name : Test AudioDeviceCommon.
538 * @tc.number: AudioDeviceCommon_034
539 * @tc.desc : Test UpdateDualToneState interface.
540 */
541 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_034, TestSize.Level1)
542 {
543 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
544 bool enable = true;
545 int32_t sessionId = 0;
546 audioDeviceCommon.UpdateDualToneState(enable, sessionId);
547 EXPECT_EQ(sessionId, audioDeviceCommon.enableDualHalToneSessionId_);
548 }
549
550 /**
551 * @tc.name : Test AudioDeviceCommon.
552 * @tc.number: AudioDeviceCommon_035
553 * @tc.desc : Test UpdateDualToneState interface.
554 */
555 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_035, TestSize.Level1)
556 {
557 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
558 bool enable = false;
559 int32_t sessionId = 0;
560 audioDeviceCommon.UpdateDualToneState(enable, sessionId);
561 EXPECT_EQ(enable, audioDeviceCommon.enableDualHalToneState_);
562 }
563
564 /**
565 * @tc.name : Test AudioDeviceCommon.
566 * @tc.number: AudioDeviceCommon_036
567 * @tc.desc : Test IsFastFromA2dpToA2dp interface.
568 */
569 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_036, TestSize.Level1)
570 {
571 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
572 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
573 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
574 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
575 rendererChangeInfo->outputDeviceInfo.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
576 rendererChangeInfo->rendererInfo.originalFlag = AUDIO_FLAG_MMAP;
577 rendererChangeInfo->outputDeviceInfo.deviceId_ = 0;
578 desc->deviceId_ = 1;
579 bool ret = audioDeviceCommon.IsFastFromA2dpToA2dp(desc, rendererChangeInfo, reason);
580 EXPECT_EQ(true, ret);
581 }
582
583 /**
584 * @tc.name : Test AudioDeviceCommon.
585 * @tc.number: AudioDeviceCommon_037
586 * @tc.desc : Test IsFastFromA2dpToA2dp interface.
587 */
588 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_037, TestSize.Level1)
589 {
590 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
591 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
592 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
593 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
594 rendererChangeInfo->outputDeviceInfo.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
595 rendererChangeInfo->rendererInfo.originalFlag = AUDIO_FLAG_MMAP;
596 rendererChangeInfo->outputDeviceInfo.deviceId_ = 0;
597 desc->deviceId_ = 0;
598 bool ret = audioDeviceCommon.IsFastFromA2dpToA2dp(desc, rendererChangeInfo, reason);
599 EXPECT_EQ(false, ret);
600 }
601
602 /**
603 * @tc.name : Test AudioDeviceCommon.
604 * @tc.number: AudioDeviceCommon_038
605 * @tc.desc : Test NotifyRecreateDirectStream interface.
606 */
607 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_038, TestSize.Level1)
608 {
609 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
610 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
611 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
612 rendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_DIRECT_MUSIC;
613 rendererChangeInfo->outputDeviceInfo.deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
614 bool ret = audioDeviceCommon.NotifyRecreateDirectStream(rendererChangeInfo, reason);
615 EXPECT_EQ(false, ret);
616 }
617
618 /**
619 * @tc.name : Test AudioDeviceCommon.
620 * @tc.number: AudioDeviceCommon_039
621 * @tc.desc : Test NotifyRecreateDirectStream interface.
622 */
623 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_039, TestSize.Level1)
624 {
625 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
626 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
627 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
628 rendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_DIRECT_MUSIC;
629 rendererChangeInfo->outputDeviceInfo.deviceType_ = DEVICE_TYPE_MIC;
630 bool ret = audioDeviceCommon.NotifyRecreateDirectStream(rendererChangeInfo, reason);
631 EXPECT_EQ(true, ret);
632 }
633
634 /**
635 * @tc.name : Test AudioDeviceCommon.
636 * @tc.number: AudioDeviceCommon_040
637 * @tc.desc : Test NotifyRecreateDirectStream interface.
638 */
639 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_040, TestSize.Level1)
640 {
641 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
642 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
643 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
644 audioDeviceCommon.audioActiveDevice_.SetCurrentOutputDeviceType(DEVICE_TYPE_WIRED_HEADSET);
645 rendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_OFFLOAD;
646 rendererChangeInfo->rendererInfo.streamUsage = STREAM_USAGE_MUSIC;
647 rendererChangeInfo->rendererInfo.rendererFlags = AUDIO_FLAG_NORMAL;
648 rendererChangeInfo->rendererInfo.samplingRate = SAMPLE_RATE_48000;
649 rendererChangeInfo->rendererInfo.format = SAMPLE_S24LE;
650 bool ret = audioDeviceCommon.NotifyRecreateDirectStream(rendererChangeInfo, reason);
651 EXPECT_EQ(true, ret);
652 }
653
654 /**
655 * @tc.name : Test AudioDeviceCommon.
656 * @tc.number: AudioDeviceCommon_041
657 * @tc.desc : Test NotifyRecreateDirectStream interface.
658 */
659 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_041, TestSize.Level1)
660 {
661 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
662 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
663 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
664 audioDeviceCommon.audioActiveDevice_.SetCurrentOutputDeviceType(DEVICE_TYPE_WIRED_HEADSET);
665 rendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_OFFLOAD;
666 rendererChangeInfo->rendererInfo.streamUsage = STREAM_USAGE_MUSIC;
667 rendererChangeInfo->rendererInfo.rendererFlags = AUDIO_FLAG_NORMAL;
668 rendererChangeInfo->rendererInfo.samplingRate = SAMPLE_RATE_8000;
669 rendererChangeInfo->rendererInfo.format = SAMPLE_S24LE;
670 bool ret = audioDeviceCommon.NotifyRecreateDirectStream(rendererChangeInfo, reason);
671 EXPECT_EQ(false, ret);
672 }
673
674 /**
675 * @tc.name : Test AudioDeviceCommon.
676 * @tc.number: AudioDeviceCommon_042
677 * @tc.desc : Test NotifyRecreateDirectStream interface.
678 */
679 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_042, TestSize.Level1)
680 {
681 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
682 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
683 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
684 audioDeviceCommon.audioActiveDevice_.SetCurrentOutputDeviceType(DEVICE_TYPE_USB_HEADSET);
685 rendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_OFFLOAD;
686 rendererChangeInfo->rendererInfo.streamUsage = STREAM_USAGE_MUSIC;
687 rendererChangeInfo->rendererInfo.rendererFlags = AUDIO_FLAG_NORMAL;
688 rendererChangeInfo->rendererInfo.samplingRate = SAMPLE_RATE_8000;
689 rendererChangeInfo->rendererInfo.format = SAMPLE_S24LE;
690 bool ret = audioDeviceCommon.NotifyRecreateDirectStream(rendererChangeInfo, reason);
691 EXPECT_EQ(false, ret);
692 }
693
694 /**
695 * @tc.name : Test AudioDeviceCommon.
696 * @tc.number: AudioDeviceCommon_043
697 * @tc.desc : Test MuteSinkForSwitchGeneralDevice interface.
698 */
699 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_043, TestSize.Level1)
700 {
701 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
702 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
703 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
704 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorUniqueptr = std::make_shared<AudioDeviceDescriptor>();
705 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorUniqueptrVector;
706 audioDeviceDescriptorUniqueptr->deviceType_ = DEVICE_TYPE_SPEAKER;
707 audioDeviceDescriptorUniqueptrVector.push_back(std::move(audioDeviceDescriptorUniqueptr));
708 audioDeviceCommon.MuteSinkForSwitchGeneralDevice(rendererChangeInfo,
709 audioDeviceDescriptorUniqueptrVector, reason);
710 EXPECT_EQ(1, audioDeviceDescriptorUniqueptrVector.size());
711 }
712
713 /**
714 * @tc.name : Test AudioDeviceCommon.
715 * @tc.number: AudioDeviceCommon_044
716 * @tc.desc : Test MuteSinkForSwitchGeneralDevice interface.
717 */
718 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_044, TestSize.Level1)
719 {
720 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
721 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
722 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
723 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorUniqueptr = std::make_shared<AudioDeviceDescriptor>();
724 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorUniqueptrVector;
725 audioDeviceDescriptorUniqueptr->deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
726 audioDeviceDescriptorUniqueptrVector.push_back(std::move(audioDeviceDescriptorUniqueptr));
727 audioDeviceCommon.MuteSinkForSwitchGeneralDevice(rendererChangeInfo,
728 audioDeviceDescriptorUniqueptrVector, reason);
729 EXPECT_EQ(1, audioDeviceDescriptorUniqueptrVector.size());
730 }
731
732 /**
733 * @tc.name : Test AudioDeviceCommon.
734 * @tc.number: AudioDeviceCommon_045
735 * @tc.desc : Test MuteSinkForSwitchGeneralDevice interface.
736 */
737 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_045, TestSize.Level1)
738 {
739 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
740 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
741 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
742 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorUniqueptr = std::make_shared<AudioDeviceDescriptor>();
743 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorUniqueptrVector;
744 audioDeviceDescriptorUniqueptr->deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
745 audioDeviceDescriptorUniqueptrVector.push_back(std::move(audioDeviceDescriptorUniqueptr));
746 audioDeviceCommon.MuteSinkForSwitchGeneralDevice(rendererChangeInfo,
747 audioDeviceDescriptorUniqueptrVector, reason);
748 EXPECT_EQ(1, audioDeviceDescriptorUniqueptrVector.size());
749 }
750
751 /**
752 * @tc.name : Test AudioDeviceCommon.
753 * @tc.number: AudioDeviceCommon_046
754 * @tc.desc : Test MuteSinkForSwitchBluetoothDevice interface.
755 */
756 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_046, TestSize.Level1)
757 {
758 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
759 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
760 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
761 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorUniqueptr = std::make_shared<AudioDeviceDescriptor>();
762 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorUniqueptrVector;
763 audioDeviceDescriptorUniqueptr->deviceType_ = DEVICE_TYPE_SPEAKER;
764 audioDeviceDescriptorUniqueptrVector.push_back(std::move(audioDeviceDescriptorUniqueptr));
765 audioDeviceCommon.MuteSinkForSwitchBluetoothDevice(rendererChangeInfo,
766 audioDeviceDescriptorUniqueptrVector, reason);
767 EXPECT_EQ(1, audioDeviceDescriptorUniqueptrVector.size());
768 }
769
770 /**
771 * @tc.name : Test AudioDeviceCommon.
772 * @tc.number: AudioDeviceCommon_047
773 * @tc.desc : Test MuteSinkForSwitchBluetoothDevice interface.
774 */
775 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_047, TestSize.Level1)
776 {
777 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
778 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
779 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
780 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorUniqueptr = std::make_shared<AudioDeviceDescriptor>();
781 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorUniqueptrVector;
782 audioDeviceDescriptorUniqueptr->deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
783 audioDeviceDescriptorUniqueptrVector.push_back(std::move(audioDeviceDescriptorUniqueptr));
784 audioDeviceCommon.MuteSinkForSwitchBluetoothDevice(rendererChangeInfo,
785 audioDeviceDescriptorUniqueptrVector, reason);
786 EXPECT_EQ(1, audioDeviceDescriptorUniqueptrVector.size());
787 }
788
789 /**
790 * @tc.name : Test AudioDeviceCommon.
791 * @tc.number: AudioDeviceCommon_048
792 * @tc.desc : Test MuteSinkForSwitchBluetoothDevice interface.
793 */
794 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_048, TestSize.Level1)
795 {
796 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
797 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
798 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
799 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorUniqueptr = std::make_shared<AudioDeviceDescriptor>();
800 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorUniqueptrVector;
801 audioDeviceDescriptorUniqueptr->deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
802 audioDeviceDescriptorUniqueptrVector.push_back(std::move(audioDeviceDescriptorUniqueptr));
803 audioDeviceCommon.MuteSinkForSwitchBluetoothDevice(rendererChangeInfo,
804 audioDeviceDescriptorUniqueptrVector, reason);
805 EXPECT_EQ(1, audioDeviceDescriptorUniqueptrVector.size());
806 }
807
808 /**
809 * @tc.name : Test AudioDeviceCommon.
810 * @tc.number: AudioDeviceCommon_049
811 * @tc.desc : Test MuteSinkForSwitchDistributedDevice interface.
812 */
813 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_049, TestSize.Level1)
814 {
815 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
816 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
817 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReasonExt::ExtEnum::DISTRIBUTED_DEVICE;
818 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorUniqueptr = std::make_shared<AudioDeviceDescriptor>();
819 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorUniqueptrVector;
820 audioDeviceDescriptorUniqueptr->deviceType_ = DEVICE_TYPE_SPEAKER;
821 audioDeviceDescriptorUniqueptrVector.push_back(std::move(audioDeviceDescriptorUniqueptr));
822 audioDeviceCommon.MuteSinkForSwitchDistributedDevice(rendererChangeInfo,
823 audioDeviceDescriptorUniqueptrVector, reason);
824 EXPECT_EQ(1, audioDeviceDescriptorUniqueptrVector.size());
825 }
826
827 /**
828 * @tc.name : Test AudioDeviceCommon.
829 * @tc.number: AudioDeviceCommon_050
830 * @tc.desc : Test IsRendererStreamRunning interface.
831 */
832 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_050, TestSize.Level1)
833 {
834 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
835 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
836 rendererChangeInfo->rendererInfo.streamUsage = STREAM_USAGE_VOICE_MODEM_COMMUNICATION;
837 audioDeviceCommon.audioSceneManager_.SetAudioScenePre(AUDIO_SCENE_RINGING);
838 bool ret = audioDeviceCommon.IsRendererStreamRunning(rendererChangeInfo);
839 EXPECT_EQ(false, ret);
840 }
841
842 /**
843 * @tc.name : Test AudioDeviceCommon.
844 * @tc.number: AudioDeviceCommon_051
845 * @tc.desc : Test ActivateA2dpDeviceWhenDescEnabled interface.
846 */
847 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_051, TestSize.Level1)
848 {
849 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
850 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
851 desc->isEnable_ = false;
852 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
853 vector<std::shared_ptr<AudioRendererChangeInfo>> rendererChangeInfos;
854 rendererChangeInfos.push_back(std::move(rendererChangeInfo));
855 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
856 int32_t ret = audioDeviceCommon.ActivateA2dpDeviceWhenDescEnabled(desc, rendererChangeInfos, reason);
857 EXPECT_EQ(SUCCESS, ret);
858
859 desc->isEnable_ = true;
860 ret = audioDeviceCommon.ActivateA2dpDeviceWhenDescEnabled(desc, rendererChangeInfos, reason);
861 EXPECT_EQ(ERROR, ret);
862 }
863
864 /**
865 * @tc.name : Test AudioDeviceCommon.
866 * @tc.number: AudioDeviceCommon_052
867 * @tc.desc : Test HandleScoOutputDeviceFetched interface.
868 */
869 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_052, TestSize.Level1)
870 {
871 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
872 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
873 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
874 vector<std::shared_ptr<AudioRendererChangeInfo>> rendererChangeInfos;
875 rendererChangeInfos.push_back(std::move(rendererChangeInfo));
876 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
877 int32_t ret = audioDeviceCommon.HandleScoOutputDeviceFetched(desc, rendererChangeInfos, reason);
878 EXPECT_EQ(ERROR, ret);
879 }
880
881 /**
882 * @tc.name : Test AudioDeviceCommon.
883 * @tc.number: AudioDeviceCommon_053
884 * @tc.desc : Test NotifyRecreateRendererStream interface.
885 */
886 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_053, TestSize.Level1)
887 {
888 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
889 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
890 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
891 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
892 rendererChangeInfo->outputDeviceInfo.deviceType_ = DEVICE_TYPE_SPEAKER;
893 desc->deviceType_ = DEVICE_TYPE_EARPIECE;
894 rendererChangeInfo->rendererInfo.originalFlag = AUDIO_FLAG_MMAP;
895 rendererChangeInfo->rendererInfo.originalFlag = AUDIO_FLAG_VOIP_DIRECT;
896 rendererChangeInfo->outputDeviceInfo.deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
897 desc->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
898 bool ret = audioDeviceCommon.NotifyRecreateRendererStream(desc, rendererChangeInfo, reason);
899 EXPECT_EQ(false, ret);
900
901 desc->deviceType_ = DEVICE_TYPE_SPEAKER;
902 rendererChangeInfo->outputDeviceInfo.networkId_ = "test1";
903 desc->networkId_ = "test2";
904 ret = audioDeviceCommon.NotifyRecreateRendererStream(desc, rendererChangeInfo, reason);
905 EXPECT_EQ(true, ret);
906 }
907
908 /**
909 * @tc.name : Test AudioDeviceCommon.
910 * @tc.number: AudioDeviceCommon_054
911 * @tc.desc : Test NeedRehandleA2DPDevice interface.
912 */
913 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_054, TestSize.Level1)
914 {
915 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
916 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
917 desc->deviceType_ = DEVICE_TYPE_SPEAKER;
918 bool ret = audioDeviceCommon.NeedRehandleA2DPDevice(desc);
919 EXPECT_EQ(false, ret);
920
921 desc->deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
922 ret = audioDeviceCommon.NeedRehandleA2DPDevice(desc);
923 EXPECT_EQ(true, ret);
924 }
925
926 /**
927 * @tc.name : Test AudioDeviceCommon.
928 * @tc.number: AudioDeviceCommon_055
929 * @tc.desc : Test ActivateA2dpDevice interface.
930 */
931 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_055, TestSize.Level1)
932 {
933 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
934 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
935 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
936 vector<std::shared_ptr<AudioRendererChangeInfo>> rendererChangeInfos;
937 rendererChangeInfos.push_back(std::move(rendererChangeInfo));
938 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
939 int32_t ret = audioDeviceCommon.ActivateA2dpDevice(desc, rendererChangeInfos, reason);
940 EXPECT_EQ(ERROR, ret);
941 }
942
943 /**
944 * @tc.name : Test AudioDeviceCommon.
945 * @tc.number: AudioDeviceCommon_056
946 * @tc.desc : Test TriggerRecreateRendererStreamCallback interface.
947 */
948 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_056, TestSize.Level1)
949 {
950 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
951 int32_t callerPid = 0;
952 int32_t sessionId = 0;
953 int32_t streamFlag = 0;
954 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
955 audioDeviceCommon.audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
956 audioDeviceCommon.TriggerRecreateRendererStreamCallback(callerPid, sessionId, streamFlag, reason);
957 EXPECT_EQ(true, audioDeviceCommon.audioPolicyServerHandler_ != nullptr);
958 }
959
960 /**
961 * @tc.name : Test AudioDeviceCommon.
962 * @tc.number: AudioDeviceCommon_057
963 * @tc.desc : Test HandleBluetoothInputDeviceFetched interface.
964 */
965 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_057, TestSize.Level1)
966 {
967 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
968 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
969 desc->deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
970 std::shared_ptr<AudioCapturerChangeInfo> captureChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
971 vector<std::shared_ptr<AudioCapturerChangeInfo>> captureChangeInfos;
972 captureChangeInfos.push_back(std::move(captureChangeInfo));
973
974 SourceType sourceType = SOURCE_TYPE_MIC;
975 audioDeviceCommon.HandleBluetoothInputDeviceFetched(desc, captureChangeInfos, sourceType);
976 EXPECT_EQ(1, captureChangeInfos.size());
977 }
978
979 /**
980 * @tc.name : Test AudioDeviceCommon.
981 * @tc.number: AudioDeviceCommon_058
982 * @tc.desc : Test HandleBluetoothInputDeviceFetched interface.
983 */
984 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_058, TestSize.Level1)
985 {
986 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
987 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
988 desc->deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP_IN;
989 std::shared_ptr<AudioCapturerChangeInfo> captureChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
990 vector<std::shared_ptr<AudioCapturerChangeInfo>> captureChangeInfos;
991 captureChangeInfos.push_back(std::move(captureChangeInfo));
992 SourceType sourceType = SOURCE_TYPE_MIC;
993 audioDeviceCommon.HandleBluetoothInputDeviceFetched(desc, captureChangeInfos, sourceType);
994 EXPECT_EQ(1, captureChangeInfos.size());
995 }
996
997 /**
998 * @tc.name : Test AudioDeviceCommon.
999 * @tc.number: AudioDeviceCommon_059
1000 * @tc.desc : Test HandleBluetoothInputDeviceFetched interface.
1001 */
1002 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_059, TestSize.Level1)
1003 {
1004 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1005 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
1006 desc->deviceType_ = DEVICE_TYPE_MIC;
1007 std::shared_ptr<AudioCapturerChangeInfo> captureChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
1008 vector<std::shared_ptr<AudioCapturerChangeInfo>> captureChangeInfos;
1009 captureChangeInfos.push_back(std::move(captureChangeInfo));
1010 SourceType sourceType = SOURCE_TYPE_MIC;
1011 audioDeviceCommon.HandleBluetoothInputDeviceFetched(desc, captureChangeInfos, sourceType);
1012 EXPECT_EQ(1, captureChangeInfos.size());
1013 }
1014
1015 /**
1016 * @tc.name : Test AudioDeviceCommon.
1017 * @tc.number: AudioDeviceCommon_060
1018 * @tc.desc : Test HandleBluetoothInputDeviceFetched interface.
1019 */
1020 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_060, TestSize.Level1)
1021 {
1022 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1023 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
1024 desc->deviceType_ = DEVICE_TYPE_MIC;
1025 std::shared_ptr<AudioCapturerChangeInfo> captureChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
1026 vector<std::shared_ptr<AudioCapturerChangeInfo>> captureChangeInfos;
1027 captureChangeInfos.push_back(std::move(captureChangeInfo));
1028 SourceType sourceType = SOURCE_TYPE_MIC;
1029 audioDeviceCommon.HandleBluetoothInputDeviceFetched(desc, captureChangeInfos, sourceType);
1030 EXPECT_EQ(1, captureChangeInfos.size());
1031 }
1032
1033 /**
1034 * @tc.name : Test AudioDeviceCommon.
1035 * @tc.number: AudioDeviceCommon_061
1036 * @tc.desc : Test NotifyRecreateCapturerStream interface.
1037 */
1038 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_061, TestSize.Level1)
1039 {
1040 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1041 bool isUpdateActiveDevice = true;
1042 std::shared_ptr<AudioCapturerChangeInfo> capturerChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
1043 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
1044 capturerChangeInfo->capturerInfo.originalFlag = AUDIO_FLAG_MMAP;
1045 capturerChangeInfo->inputDeviceInfo.deviceType_ = DEVICE_TYPE_MIC;
1046 audioDeviceCommon.audioActiveDevice_.SetCurrentInputDeviceType(DEVICE_TYPE_MIC);
1047 capturerChangeInfo->inputDeviceInfo.networkId_ = "test";
1048 bool ret = audioDeviceCommon.NotifyRecreateCapturerStream(isUpdateActiveDevice,
1049 capturerChangeInfo, reason);
1050 EXPECT_EQ(true, ret);
1051 }
1052
1053 /**
1054 * @tc.name : Test AudioDeviceCommon.
1055 * @tc.number: AudioDeviceCommon_062
1056 * @tc.desc : Test NotifyRecreateCapturerStream interface.
1057 */
1058 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_062, TestSize.Level1)
1059 {
1060 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1061 bool isUpdateActiveDevice = true;
1062 std::shared_ptr<AudioCapturerChangeInfo> capturerChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
1063 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
1064 capturerChangeInfo->capturerInfo.originalFlag = AUDIO_FLAG_MMAP;
1065 capturerChangeInfo->inputDeviceInfo.deviceType_ = DEVICE_TYPE_MIC;
1066 audioDeviceCommon.audioActiveDevice_.SetCurrentInputDeviceType(DEVICE_TYPE_MIC);
1067 capturerChangeInfo->inputDeviceInfo.networkId_ = "LocalDevice";
1068 bool ret = audioDeviceCommon.NotifyRecreateCapturerStream(isUpdateActiveDevice,
1069 capturerChangeInfo, reason);
1070 EXPECT_EQ(false, ret);
1071 }
1072
1073 /**
1074 * @tc.name : Test AudioDeviceCommon.
1075 * @tc.number: AudioDeviceCommon_063
1076 * @tc.desc : Test ReloadA2dpAudioPort interface.
1077 */
1078 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_063, TestSize.Level1)
1079 {
1080 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1081 AudioModuleInfo moduleInfo;
1082 DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP;
1083 AudioStreamInfo audioStreamInfo;
1084 std::string networkID = "";
1085 std::string sinkName = "";
1086 SourceType sourceType = SOURCE_TYPE_MIC;
1087 int32_t ret = audioDeviceCommon.ReloadA2dpAudioPort(moduleInfo, deviceType, audioStreamInfo, networkID,
1088 sinkName, sourceType);
1089 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
1090
1091 deviceType = DEVICE_TYPE_BLUETOOTH_A2DP_IN;
1092 ret = audioDeviceCommon.ReloadA2dpAudioPort(moduleInfo, deviceType, audioStreamInfo, networkID,
1093 sinkName, sourceType);
1094 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
1095 }
1096
1097 /**
1098 * @tc.name : Test AudioDeviceCommon.
1099 * @tc.number: AudioDeviceCommon_064
1100 * @tc.desc : Test ScoInputDeviceFetchedForRecongnition interface.
1101 */
1102 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_064, TestSize.Level1)
1103 {
1104 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1105 bool handleFlag = true;
1106 std::string address = "";
1107 ConnectState connectState = CONNECTED;
1108 int32_t ret = audioDeviceCommon.ScoInputDeviceFetchedForRecongnition(handleFlag, address, connectState);
1109 EXPECT_EQ(SUCCESS, ret);
1110
1111 handleFlag = false;
1112 DeviceType deviceType = DEVICE_TYPE_BLUETOOTH_A2DP_IN;
1113 ret = audioDeviceCommon.ScoInputDeviceFetchedForRecongnition(handleFlag, address, connectState);
1114 EXPECT_EQ(ERROR, ret);
1115 }
1116
1117 /**
1118 * @tc.name : Test AudioDeviceCommon.
1119 * @tc.number: AudioDeviceCommon_065
1120 * @tc.desc : Test GetSpatialDeviceType interface.
1121 */
1122 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_065, TestSize.Level1)
1123 {
1124 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1125 std::string macAddress = "F0-FA-C7-8C-46-01";
1126 DeviceType deviceType = audioDeviceCommon.GetSpatialDeviceType(macAddress);
1127 EXPECT_EQ(DEVICE_TYPE_NONE, deviceType);
1128
1129 AudioDeviceDescriptor deviceDescriptor;
1130 deviceDescriptor.macAddress_ = "F0-FA-C7-8C-46-01";
1131 deviceDescriptor.deviceType_ = DEVICE_TYPE_SPEAKER;
1132 audioDeviceCommon.OnPreferredOutputDeviceUpdated(deviceDescriptor);
1133 deviceType = audioDeviceCommon.GetSpatialDeviceType(macAddress);
1134 EXPECT_EQ(DEVICE_TYPE_SPEAKER, deviceType);
1135 }
1136
1137 /**
1138 * @tc.name : Test AudioDeviceCommon.
1139 * @tc.number: AudioDeviceCommon_066
1140 * @tc.desc : Test GetDeviceDescriptorInner interface.
1141 */
1142 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_066, TestSize.Level1)
1143 {
1144 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1145 VolumeUtils::SetPCVolumeEnable(true);
1146 audioDeviceCommon.isFirstScreenOn_ = false;
1147 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
1148 vector<std::shared_ptr<AudioDeviceDescriptor>> descs =
1149 audioDeviceCommon.GetDeviceDescriptorInner(rendererChangeInfo);
1150 EXPECT_NE(0, descs.size());
1151
1152 audioDeviceCommon.isFirstScreenOn_ = true;
1153 rendererChangeInfo->rendererInfo.streamUsage = STREAM_USAGE_ULTRASONIC;
1154 rendererChangeInfo->clientUID = 0;
1155 descs = audioDeviceCommon.GetDeviceDescriptorInner(rendererChangeInfo);
1156 EXPECT_NE(0, descs.size());
1157 }
1158
1159 /**
1160 * @tc.name : Test AudioDeviceCommon.
1161 * @tc.number: AudioDeviceCommon_067
1162 * @tc.desc : Test FetchOutputEnd interface.
1163 */
1164 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_067, TestSize.Level1)
1165 {
1166 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1167 bool isUpdateActiveDevice = true;
1168 int32_t runningStreamCount = 0;
1169 audioDeviceCommon.FetchOutputEnd(isUpdateActiveDevice, runningStreamCount);
1170 EXPECT_NE(0, audioDeviceCommon.spatialDeviceMap_.size());
1171 }
1172
1173 /**
1174 * @tc.name : Test AudioDeviceCommon.
1175 * @tc.number: AudioDeviceCommon_068
1176 * @tc.desc : Test HandleDeviceChangeForFetchOutputDevice interface.
1177 */
1178 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_068, TestSize.Level1)
1179 {
1180 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1181 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
1182 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
1183 desc->deviceType_ = DEVICE_TYPE_NONE;
1184 int32_t ret = audioDeviceCommon.HandleDeviceChangeForFetchOutputDevice(desc, rendererChangeInfo);
1185 EXPECT_EQ(ERR_NEED_NOT_SWITCH_DEVICE, ret);
1186
1187 desc->deviceType_ = DEVICE_TYPE_EARPIECE;
1188 rendererChangeInfo->outputDeviceInfo.deviceType_ = DEVICE_TYPE_SPEAKER;
1189 ret = audioDeviceCommon.HandleDeviceChangeForFetchOutputDevice(desc, rendererChangeInfo);
1190 EXPECT_EQ(SUCCESS, ret);
1191 }
1192
1193 /**
1194 * @tc.name : Test AudioDeviceCommon.
1195 * @tc.number: AudioDeviceCommon_069
1196 * @tc.desc : Test IsSameDevice interface.
1197 */
1198 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_069, TestSize.Level1)
1199 {
1200 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1201 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
1202 AudioDeviceDescriptor deviceInfo;
1203 desc->deviceType_ = DEVICE_TYPE_NONE;
1204 deviceInfo.deviceType_ = DEVICE_TYPE_EARPIECE;
1205 bool ret = audioDeviceCommon.IsSameDevice(desc, deviceInfo);
1206 EXPECT_EQ(false, ret);
1207
1208 desc->networkId_ = "";
1209 deviceInfo.networkId_ = "";
1210 desc->macAddress_ = "";
1211 deviceInfo.macAddress_ = "";
1212 desc->connectState_ = CONNECTED;
1213 deviceInfo.connectState_ = CONNECTED;
1214 desc->deviceType_ = DEVICE_TYPE_USB_HEADSET;
1215 deviceInfo.deviceType_ = DEVICE_TYPE_USB_HEADSET;
1216 desc->deviceRole_ = DEVICE_ROLE_NONE;
1217 deviceInfo.deviceRole_ = DEVICE_ROLE_NONE;
1218 ret = audioDeviceCommon.IsSameDevice(desc, deviceInfo);
1219 EXPECT_EQ(true, ret);
1220
1221 desc->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
1222 deviceInfo.deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
1223 ret = audioDeviceCommon.IsSameDevice(desc, deviceInfo);
1224 EXPECT_EQ(true, ret);
1225
1226 BluetoothOffloadState state = A2DP_NOT_OFFLOAD;
1227 audioDeviceCommon.audioA2dpOffloadFlag_.SetA2dpOffloadFlag(state);
1228 desc->deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
1229 deviceInfo.a2dpOffloadFlag_ = A2DP_OFFLOAD;
1230 ret = audioDeviceCommon.IsSameDevice(desc, deviceInfo);
1231 EXPECT_EQ(false, ret);
1232
1233 deviceInfo.a2dpOffloadFlag_ = A2DP_NOT_OFFLOAD;
1234 state = A2DP_OFFLOAD;
1235 ret = audioDeviceCommon.IsSameDevice(desc, deviceInfo);
1236 EXPECT_EQ(false, ret);
1237
1238 desc->deviceType_ = DEVICE_TYPE_SPEAKER;
1239 deviceInfo.deviceType_ = DEVICE_TYPE_SPEAKER;
1240 ret = audioDeviceCommon.IsSameDevice(desc, deviceInfo);
1241 EXPECT_EQ(true, ret);
1242 }
1243
1244 /**
1245 * @tc.name : Test AudioDeviceCommon.
1246 * @tc.number: AudioDeviceCommon_070
1247 * @tc.desc : Test IsSameDevice interface.
1248 */
1249 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_070, TestSize.Level1)
1250 {
1251 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1252 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
1253 desc->deviceType_ = DEVICE_TYPE_NONE;
1254 AudioDeviceDescriptor deviceDesc;
1255 deviceDesc.deviceType_ = DEVICE_TYPE_EARPIECE;
1256 audioDeviceCommon.audioActiveDevice_.SetCurrentOutputDevice(deviceDesc);
1257 bool ret = audioDeviceCommon.IsSameDevice(desc, deviceDesc);
1258 EXPECT_EQ(false, ret);
1259
1260 desc->networkId_ = "";
1261 deviceDesc.networkId_ = "";
1262 desc->macAddress_ = "";
1263 deviceDesc.macAddress_ = "";
1264 desc->connectState_ = CONNECTED;
1265 deviceDesc.connectState_ = CONNECTED;
1266 desc->deviceType_ = DEVICE_TYPE_SPEAKER;
1267 deviceDesc.deviceType_ = DEVICE_TYPE_SPEAKER;
1268 ret = audioDeviceCommon.IsSameDevice(desc, deviceDesc);
1269 EXPECT_EQ(true, ret);
1270
1271 desc->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
1272 deviceDesc.deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
1273 desc->deviceRole_ = DEVICE_ROLE_NONE;
1274 deviceDesc.deviceRole_ = DEVICE_ROLE_NONE;
1275 ret = audioDeviceCommon.IsSameDevice(desc, deviceDesc);
1276 EXPECT_EQ(true, ret);
1277 }
1278
1279 /**
1280 * @tc.name : Test AudioDeviceCommon.
1281 * @tc.number: AudioDeviceCommon_071
1282 * @tc.desc : Test UpdateTracker interface.
1283 */
1284 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_071, TestSize.Level1)
1285 {
1286 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1287 AudioMode mode = AUDIO_MODE_PLAYBACK;
1288 AudioStreamChangeInfo streamChangeInfo;
1289 RendererState rendererState = RENDERER_RELEASED;
1290 audioDeviceCommon.UpdateTracker(mode, streamChangeInfo, rendererState);
1291 bool ret = audioDeviceCommon.audioOffloadStream_.GetOffloadAvailableFromXml();
1292 EXPECT_EQ(false, ret);
1293
1294 rendererState = RENDERER_STOPPED;
1295 audioDeviceCommon.UpdateTracker(mode, streamChangeInfo, rendererState);
1296 ret = audioDeviceCommon.audioOffloadStream_.GetOffloadAvailableFromXml();
1297 EXPECT_EQ(false, ret);
1298
1299 rendererState = RENDERER_PAUSED;
1300 audioDeviceCommon.UpdateTracker(mode, streamChangeInfo, rendererState);
1301 ret = audioDeviceCommon.audioOffloadStream_.GetOffloadAvailableFromXml();
1302 EXPECT_EQ(false, ret);
1303
1304 rendererState = RENDERER_RELEASED;
1305 audioDeviceCommon.UpdateTracker(mode, streamChangeInfo, rendererState);
1306 ret = audioDeviceCommon.audioOffloadStream_.GetOffloadAvailableFromXml();
1307 EXPECT_EQ(false, ret);
1308
1309 audioDeviceCommon.enableDualHalToneState_ = true;
1310 rendererState = RENDERER_STOPPED;
1311 audioDeviceCommon.UpdateTracker(mode, streamChangeInfo, rendererState);
1312 ret = audioDeviceCommon.audioOffloadStream_.GetOffloadAvailableFromXml();
1313 EXPECT_EQ(false, ret);
1314
1315 rendererState = RENDERER_RELEASED;
1316 audioDeviceCommon.enableDualHalToneSessionId_ = 0;
1317 streamChangeInfo.audioRendererChangeInfo.sessionId = 0;
1318 streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage = STREAM_USAGE_ALARM;
1319 audioDeviceCommon.UpdateTracker(mode, streamChangeInfo, rendererState);
1320 ret = audioDeviceCommon.audioOffloadStream_.GetOffloadAvailableFromXml();
1321 EXPECT_EQ(false, ret);
1322
1323 streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage = STREAM_USAGE_VOICE_RINGTONE;
1324 audioDeviceCommon.UpdateTracker(mode, streamChangeInfo, rendererState);
1325 ret = audioDeviceCommon.audioOffloadStream_.GetOffloadAvailableFromXml();
1326 EXPECT_EQ(false, ret);
1327
1328 streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage = STREAM_USAGE_RINGTONE;
1329 audioDeviceCommon.UpdateTracker(mode, streamChangeInfo, rendererState);
1330 ret = audioDeviceCommon.audioOffloadStream_.GetOffloadAvailableFromXml();
1331 EXPECT_EQ(false, ret);
1332 }
1333
1334 /**
1335 * @tc.name : Test AudioDeviceCommon.
1336 * @tc.number: AudioDeviceCommon_072
1337 * @tc.desc : Test CheckAndNotifyUserSelectedDevice interface.
1338 */
1339 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_072, TestSize.Level1)
1340 {
1341 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1342 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
1343 audioDeviceCommon.CheckAndNotifyUserSelectedDevice(desc);
1344 bool ret = audioDeviceCommon.audioActiveDevice_.CheckActiveOutputDeviceSupportOffload();
1345 EXPECT_EQ(false, ret);
1346 }
1347
1348 /**
1349 * @tc.name : Test AudioDeviceCommon.
1350 * @tc.number: AudioDeviceCommon_073
1351 * @tc.desc : Test ResetOffloadAndMchMode interface.
1352 */
1353 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_073, TestSize.Level1)
1354 {
1355 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1356 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
1357 vector<std::shared_ptr<AudioDeviceDescriptor>> outputDevices;
1358 std::shared_ptr<AudioDeviceDescriptor> outputDevice = std::make_shared<AudioDeviceDescriptor>();
1359 outputDevice->networkId_ = "";
1360 outputDevices.push_back(std::move(outputDevice));
1361 audioDeviceCommon.ResetOffloadAndMchMode(rendererChangeInfo, outputDevices);
1362 audioDeviceCommon.SetHasDpFlag(true);
1363 EXPECT_EQ(true, audioDeviceCommon.GetHasDpFlag());
1364 }
1365
1366 /**
1367 * @tc.name : Test AudioDeviceCommon.
1368 * @tc.number: AudioDeviceCommon_074
1369 * @tc.desc : Test ResetOffloadAndMchMode interface.
1370 */
1371 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_074, TestSize.Level1)
1372 {
1373 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1374 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
1375 vector<std::shared_ptr<AudioDeviceDescriptor>> outputDevices;
1376 std::shared_ptr<AudioDeviceDescriptor> outputDevice = std::make_shared<AudioDeviceDescriptor>();
1377 outputDevice->networkId_ = "LocalDevice";
1378 outputDevice->deviceType_ = DEVICE_TYPE_REMOTE_CAST;
1379 outputDevices.push_back(std::move(outputDevice));
1380 audioDeviceCommon.ResetOffloadAndMchMode(rendererChangeInfo, outputDevices);
1381 audioDeviceCommon.SetHasDpFlag(true);
1382 EXPECT_EQ(true, audioDeviceCommon.GetHasDpFlag());
1383 }
1384
1385 /**
1386 * @tc.name : Test AudioDeviceCommon.
1387 * @tc.number: AudioDeviceCommon_075
1388 * @tc.desc : Test ResetOffloadAndMchMode interface.
1389 */
1390 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_075, TestSize.Level1)
1391 {
1392 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1393 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
1394 vector<std::shared_ptr<AudioDeviceDescriptor>> outputDevices;
1395 std::shared_ptr<AudioDeviceDescriptor> outputDevice = std::make_shared<AudioDeviceDescriptor>();
1396 outputDevice->networkId_ = "LocalDevice";
1397 outputDevice->deviceType_ = DEVICE_TYPE_DP;
1398 outputDevices.push_back(std::move(outputDevice));
1399 audioDeviceCommon.ResetOffloadAndMchMode(rendererChangeInfo, outputDevices);
1400 audioDeviceCommon.SetHasDpFlag(false);
1401 EXPECT_EQ(false, audioDeviceCommon.GetHasDpFlag());;
1402 }
1403
1404 /**
1405 * @tc.name : Test AudioDeviceCommon.
1406 * @tc.number: AudioDeviceCommon_076
1407 * @tc.desc : Test JudgeIfLoadMchModule interface.
1408 */
1409 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_076, TestSize.Level1)
1410 {
1411 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1412 audioDeviceCommon.JudgeIfLoadMchModule();
1413 audioDeviceCommon.SetHasDpFlag(false);
1414 EXPECT_EQ(false, audioDeviceCommon.GetHasDpFlag());
1415
1416 AudioIOHandle moduleId = 0;
1417 std::string moduleName = "MCH_Speaker";
1418 audioDeviceCommon.audioIOHandleMap_.AddIOHandleInfo(moduleName, moduleId);
1419 audioDeviceCommon.JudgeIfLoadMchModule();
1420 audioDeviceCommon.SetHasDpFlag(true);
1421 EXPECT_EQ(true, audioDeviceCommon.GetHasDpFlag());
1422 }
1423
1424 /**
1425 * @tc.name : Test AudioDeviceCommon.
1426 * @tc.number: AudioDeviceCommon_077
1427 * @tc.desc : Test FetchStreamForA2dpMchStream interface.
1428 */
1429 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_077, TestSize.Level1)
1430 {
1431 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1432 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
1433 vector<std::shared_ptr<AudioDeviceDescriptor>> descs;
1434 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
1435 descs.push_back(std::move(desc));
1436 audioDeviceCommon.FetchStreamForA2dpMchStream(rendererChangeInfo, descs);
1437 audioDeviceCommon.SetHasDpFlag(true);
1438 EXPECT_EQ(true, audioDeviceCommon.GetHasDpFlag());
1439 }
1440
1441 /**
1442 * @tc.name : Test AudioDeviceCommon.
1443 * @tc.number: AudioDeviceCommon_078
1444 * @tc.desc : Test FetchStreamForSpkMchStream interface.
1445 */
1446 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_078, TestSize.Level1)
1447 {
1448 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1449 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
1450 vector<std::shared_ptr<AudioDeviceDescriptor>> descs;
1451 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
1452 descs.push_back(std::move(desc));
1453 audioDeviceCommon.FetchStreamForSpkMchStream(rendererChangeInfo, descs);
1454 audioDeviceCommon.SetHasDpFlag(true);
1455 EXPECT_EQ(true, audioDeviceCommon.GetHasDpFlag());
1456 }
1457
1458 /**
1459 * @tc.name : Test AudioDeviceCommon.
1460 * @tc.number: AudioDeviceCommon_079
1461 * @tc.desc : Test HandleDeviceChangeForFetchInputDevice interface.
1462 */
1463 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_079, TestSize.Level1)
1464 {
1465 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1466 std::shared_ptr<AudioCapturerChangeInfo> capturerChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
1467 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
1468 desc->deviceType_ = DEVICE_TYPE_NONE;
1469 int32_t ret = audioDeviceCommon.HandleDeviceChangeForFetchInputDevice(desc, capturerChangeInfo);
1470 EXPECT_EQ(ERR_NEED_NOT_SWITCH_DEVICE, ret);
1471
1472 desc->networkId_ = "";
1473 capturerChangeInfo->inputDeviceInfo.networkId_ = "";
1474 desc->macAddress_ = "";
1475 capturerChangeInfo->inputDeviceInfo.macAddress_ = "";
1476 desc->connectState_ = CONNECTED;
1477 capturerChangeInfo->inputDeviceInfo.connectState_ = CONNECTED;
1478 desc->deviceType_ = DEVICE_TYPE_USB_HEADSET;
1479 capturerChangeInfo->inputDeviceInfo.deviceType_ = DEVICE_TYPE_USB_HEADSET;
1480 desc->deviceRole_ = DEVICE_ROLE_NONE;
1481 capturerChangeInfo->inputDeviceInfo.deviceRole_ = DEVICE_ROLE_NONE;
1482 ret = audioDeviceCommon.HandleDeviceChangeForFetchInputDevice(desc, capturerChangeInfo);
1483 EXPECT_EQ(ERR_NEED_NOT_SWITCH_DEVICE, ret);
1484
1485 desc->deviceType_ = DEVICE_TYPE_SPEAKER;
1486 desc->connectState_ = DEACTIVE_CONNECTED;
1487 ret = audioDeviceCommon.HandleDeviceChangeForFetchInputDevice(desc, capturerChangeInfo);
1488 EXPECT_EQ(SUCCESS, ret);
1489 }
1490
1491 /**
1492 * @tc.name : Test AudioDeviceCommon.
1493 * @tc.number: AudioDeviceCommon_080
1494 * @tc.desc : Test MoveToRemoteInputDevice interface.
1495 */
1496 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_080, TestSize.Level1)
1497 {
1498 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1499 SourceOutput sourceOutput;
1500 std::vector<SourceOutput> sourceOutputs;
1501 sourceOutputs.push_back(sourceOutput);
1502 std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
1503 audioDeviceCommon.isOpenRemoteDevice = false;
1504 int32_t ret = audioDeviceCommon.MoveToRemoteInputDevice(sourceOutputs, remoteDeviceDescriptor);
1505 EXPECT_EQ(ERR_INVALID_OPERATION, ret);
1506
1507 audioDeviceCommon.isOpenRemoteDevice = true;
1508 ret = audioDeviceCommon.MoveToRemoteInputDevice(sourceOutputs, remoteDeviceDescriptor);
1509 EXPECT_EQ(ERR_INVALID_OPERATION, ret);
1510 }
1511
1512 /**
1513 * @tc.name : Test AudioDeviceCommon.
1514 * @tc.number: AudioDeviceCommon_081
1515 * @tc.desc : Test MuteSinkPort interface.
1516 */
1517 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_081, TestSize.Level1)
1518 {
1519 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1520 std::string oldSinkname = "";
1521 std::string newSinkName = "Offload_Speaker";
1522 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::OVERRODE;
1523 audioDeviceCommon.MuteSinkPort(oldSinkname, newSinkName, reason);
1524 audioDeviceCommon.SetHasDpFlag(false);
1525 bool ret = audioDeviceCommon.GetHasDpFlag();
1526 EXPECT_EQ(false, ret);
1527
1528 oldSinkname = "Offload_Speaker";
1529 newSinkName = "";
1530 audioDeviceCommon.MuteSinkPort(oldSinkname, newSinkName, reason);
1531 audioDeviceCommon.SetHasDpFlag(false);
1532 ret = audioDeviceCommon.GetHasDpFlag();
1533 EXPECT_EQ(false, ret);
1534
1535 reason = AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE;
1536 newSinkName = "Offload_Speaker";
1537 oldSinkname = "";
1538 audioDeviceCommon.MuteSinkPort(oldSinkname, newSinkName, reason);
1539 audioDeviceCommon.SetHasDpFlag(false);
1540 ret = audioDeviceCommon.GetHasDpFlag();
1541 EXPECT_EQ(false, ret);
1542
1543 newSinkName = "";
1544 oldSinkname = "Offload_Speaker";
1545 audioDeviceCommon.MuteSinkPort(oldSinkname, newSinkName, reason);
1546 audioDeviceCommon.SetHasDpFlag(false);
1547 ret = audioDeviceCommon.GetHasDpFlag();
1548 EXPECT_EQ(false, ret);
1549
1550 reason = AudioStreamDeviceChangeReason::OLD_DEVICE_UNAVALIABLE;
1551 audioDeviceCommon.audioSceneManager_.SetAudioScenePre(AUDIO_SCENE_DEFAULT);
1552 audioDeviceCommon.MuteSinkPort(oldSinkname, newSinkName, reason);
1553 audioDeviceCommon.SetHasDpFlag(false);
1554 ret = audioDeviceCommon.GetHasDpFlag();
1555 EXPECT_EQ(false, ret);
1556
1557 audioDeviceCommon.audioSceneManager_.SetAudioScenePre(AUDIO_SCENE_RINGING);
1558 audioDeviceCommon.audioPolicyManager_.SetRingerMode(RINGER_MODE_SILENT);
1559 audioDeviceCommon.MuteSinkPort(oldSinkname, newSinkName, reason);
1560 audioDeviceCommon.SetHasDpFlag(false);
1561 ret = audioDeviceCommon.GetHasDpFlag();
1562 EXPECT_EQ(false, ret);
1563
1564 reason = AudioStreamDeviceChangeReason::UNKNOWN;
1565 oldSinkname = "RemoteCastInnerCapturer";
1566 audioDeviceCommon.MuteSinkPort(oldSinkname, newSinkName, reason);
1567 audioDeviceCommon.SetHasDpFlag(true);
1568 ret = audioDeviceCommon.GetHasDpFlag();
1569 EXPECT_EQ(true, ret);
1570 }
1571
1572 /**
1573 * @tc.name : Test AudioDeviceCommon.
1574 * @tc.number: AudioDeviceCommon_082
1575 * @tc.desc : Test MoveToNewOutputDevice interface.
1576 */
1577 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_082, TestSize.Level1)
1578 {
1579 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1580 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1581 rendererChangeInfo->outputDeviceInfo.deviceType_ = DEVICE_TYPE_SPEAKER;
1582 rendererChangeInfo->outputDeviceInfo.macAddress_ = "";
1583 rendererChangeInfo->outputDeviceInfo.networkId_ = "";
1584 rendererChangeInfo->outputDeviceInfo.deviceRole_ = INPUT_DEVICE;
1585 std::shared_ptr<AudioDeviceDescriptor> outputdevice = std::make_shared<AudioDeviceDescriptor>();
1586 outputdevice->deviceType_ = DEVICE_TYPE_SPEAKER;
1587 outputdevice->macAddress_ = "";
1588 outputdevice->networkId_ = "";
1589 outputdevice->deviceRole_ = INPUT_DEVICE;
1590 vector<std::shared_ptr<AudioDeviceDescriptor>> outputDevices;
1591 outputDevices.push_back(std::move(outputdevice));
1592 std::vector<SinkInput> sinkInputs;
1593 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::OVERRODE;
1594 audioDeviceCommon.audioConfigManager_.OnUpdateRouteSupport(true);
1595 audioDeviceCommon.MoveToNewOutputDevice(rendererChangeInfo, outputDevices, sinkInputs, reason);
1596 EXPECT_EQ(true, audioDeviceCommon.audioConfigManager_.GetUpdateRouteSupport());
1597 }
1598
1599 /**
1600 * @tc.name : Test AudioDeviceCommon.
1601 * @tc.number: AudioDeviceCommon_083
1602 * @tc.desc : Test MoveToNewOutputDevice interface.
1603 */
1604 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_083, TestSize.Level1)
1605 {
1606 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1607 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1608 rendererChangeInfo->outputDeviceInfo.deviceType_ = DEVICE_TYPE_SPEAKER;
1609 rendererChangeInfo->outputDeviceInfo.macAddress_ = "";
1610 rendererChangeInfo->outputDeviceInfo.networkId_ = "";
1611 rendererChangeInfo->outputDeviceInfo.deviceRole_ = INPUT_DEVICE;
1612 std::shared_ptr<AudioDeviceDescriptor> outputdevice = std::make_shared<AudioDeviceDescriptor>();
1613 outputdevice->deviceType_ = DEVICE_TYPE_SPEAKER;
1614 outputdevice->macAddress_ = "";
1615 outputdevice->networkId_ = "LocalDevice";
1616 outputdevice->deviceRole_ = INPUT_DEVICE;
1617 vector<std::shared_ptr<AudioDeviceDescriptor>> outputDevices;
1618 outputDevices.push_back(std::move(outputdevice));
1619 std::vector<SinkInput> sinkInputs;
1620 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::OVERRODE;
1621 audioDeviceCommon.audioConfigManager_.OnUpdateRouteSupport(true);
1622 audioDeviceCommon.audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
1623 audioDeviceCommon.MoveToNewOutputDevice(rendererChangeInfo, outputDevices, sinkInputs, reason);
1624 EXPECT_EQ(true, audioDeviceCommon.audioConfigManager_.GetUpdateRouteSupport());
1625 }
1626
1627 /**
1628 * @tc.name : Test AudioDeviceCommon.
1629 * @tc.number: AudioDeviceCommon_084
1630 * @tc.desc : Test UpdateRoute interface.
1631 */
1632 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_084, TestSize.Level1)
1633 {
1634 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1635 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1636 rendererChangeInfo->rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
1637
1638 std::shared_ptr<AudioDeviceDescriptor> outputdevice = std::make_shared<AudioDeviceDescriptor>();
1639 vector<std::shared_ptr<AudioDeviceDescriptor>> outputDevices;
1640 outputDevices.push_back(std::move(outputdevice));
1641 audioDeviceCommon.enableDualHalToneState_ = true;
1642 audioDeviceCommon.UpdateRoute(rendererChangeInfo, outputDevices);
1643 EXPECT_EQ(0, audioDeviceCommon.enableDualHalToneSessionId_);
1644 }
1645
1646 /**
1647 * @tc.name : Test AudioDeviceCommon.
1648 * @tc.number: AudioDeviceCommon_085
1649 * @tc.desc : Test UpdateRoute interface.
1650 */
1651 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_085, TestSize.Level1)
1652 {
1653 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1654 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1655 rendererChangeInfo->rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
1656
1657 std::shared_ptr<AudioDeviceDescriptor> outputdevice = std::make_shared<AudioDeviceDescriptor>();
1658 vector<std::shared_ptr<AudioDeviceDescriptor>> outputDevices;
1659 outputDevices.push_back(std::move(outputdevice));
1660 audioDeviceCommon.enableDualHalToneState_ = false;
1661 audioDeviceCommon.UpdateRoute(rendererChangeInfo, outputDevices);
1662 EXPECT_EQ(true, audioDeviceCommon.audioVolumeManager_.IsRingerModeMute());
1663 }
1664
1665 /**
1666 * @tc.name : Test AudioDeviceCommon.
1667 * @tc.number: AudioDeviceCommon_086
1668 * @tc.desc : Test UpdateRoute interface.
1669 */
1670 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_086, TestSize.Level1)
1671 {
1672 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1673 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1674 rendererChangeInfo->rendererInfo.streamUsage = STREAM_USAGE_ALARM;
1675
1676 std::shared_ptr<AudioDeviceDescriptor> outputdevice = std::make_shared<AudioDeviceDescriptor>();
1677 outputdevice->deviceType_ = DEVICE_TYPE_WIRED_HEADSET;
1678 vector<std::shared_ptr<AudioDeviceDescriptor>> outputDevices;
1679 outputDevices.push_back(std::move(outputdevice));
1680 VolumeUtils::SetPCVolumeEnable(false);
1681 audioDeviceCommon.UpdateRoute(rendererChangeInfo, outputDevices);
1682 EXPECT_EQ(true, audioDeviceCommon.shouldUpdateDeviceDueToDualTone_);
1683 }
1684
1685 /**
1686 * @tc.name : Test AudioDeviceCommon.
1687 * @tc.number: AudioDeviceCommon_087
1688 * @tc.desc : Test UpdateRoute interface.
1689 */
1690 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_087, TestSize.Level1)
1691 {
1692 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1693 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1694 rendererChangeInfo->rendererInfo.streamUsage = STREAM_USAGE_ALARM;
1695
1696 std::shared_ptr<AudioDeviceDescriptor> outputdevice = std::make_shared<AudioDeviceDescriptor>();
1697 outputdevice->deviceType_ = DEVICE_TYPE_SPEAKER;
1698 vector<std::shared_ptr<AudioDeviceDescriptor>> outputDevices;
1699 outputDevices.push_back(std::move(outputdevice));
1700 VolumeUtils::SetPCVolumeEnable(false);
1701 audioDeviceCommon.UpdateRoute(rendererChangeInfo, outputDevices);
1702 EXPECT_EQ(true, audioDeviceCommon.audioVolumeManager_.IsRingerModeMute());
1703 }
1704
1705 /**
1706 * @tc.name : Test AudioDeviceCommon.
1707 * @tc.number: AudioDeviceCommon_088
1708 * @tc.desc : Test UpdateRoute interface.
1709 */
1710 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_088, TestSize.Level1)
1711 {
1712 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1713 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1714 rendererChangeInfo->rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
1715 rendererChangeInfo->sessionId = 1;
1716 vector<std::shared_ptr<AudioDeviceDescriptor>> outputDevices;
1717 outputDevices.push_back(std::make_shared<AudioDeviceDescriptor>());
1718
1719 audioDeviceCommon.UpdateRoute(rendererChangeInfo, outputDevices);
1720 EXPECT_EQ(0, audioDeviceCommon.streamsWhenRingDualOnPrimarySpeaker_.size());
1721
1722 outputDevices.front()->deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
1723 audioDeviceCommon.UpdateRoute(rendererChangeInfo, outputDevices);
1724 EXPECT_EQ(0, audioDeviceCommon.streamsWhenRingDualOnPrimarySpeaker_.size());
1725
1726 audioDeviceCommon.isRingDualToneOnPrimarySpeaker_ = true;
1727 audioDeviceCommon.UpdateRoute(rendererChangeInfo, outputDevices);
1728 EXPECT_EQ(1, audioDeviceCommon.streamsWhenRingDualOnPrimarySpeaker_.size());
1729
1730 outputDevices.front()->deviceType_ = DEVICE_TYPE_INVALID;
1731 audioDeviceCommon.UpdateRoute(rendererChangeInfo, outputDevices);
1732 EXPECT_EQ(2, audioDeviceCommon.streamsWhenRingDualOnPrimarySpeaker_.size());
1733 }
1734
1735 /**
1736 * @tc.name : Test AudioDeviceCommon.
1737 * @tc.number: AudioDeviceCommon_089
1738 * @tc.desc : Test IsDualStreamWhenRingDual interface.
1739 */
1740 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_089, TestSize.Level1)
1741 {
1742 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1743
1744 EXPECT_TRUE(audioDeviceCommon.IsDualStreamWhenRingDual(STREAM_RING));
1745 EXPECT_TRUE(audioDeviceCommon.IsDualStreamWhenRingDual(STREAM_ALARM));
1746 EXPECT_TRUE(audioDeviceCommon.IsDualStreamWhenRingDual(STREAM_ACCESSIBILITY));
1747 EXPECT_FALSE(audioDeviceCommon.IsDualStreamWhenRingDual(STREAM_MUSIC));
1748 }
1749
1750 /**
1751 * @tc.name : Test AudioDeviceCommon.
1752 * @tc.number: AudioDeviceCommon_090
1753 * @tc.desc : Test IsRingDualToneOnPrimarySpeaker interface.
1754 */
1755 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_090, TestSize.Level1)
1756 {
1757 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1758 vector<std::shared_ptr<AudioDeviceDescriptor>> descs;
1759 EXPECT_FALSE(audioDeviceCommon.IsRingDualToneOnPrimarySpeaker(descs, 1));
1760
1761 descs.push_back(std::make_shared<AudioDeviceDescriptor>());
1762 descs.push_back(std::make_shared<AudioDeviceDescriptor>());
1763 EXPECT_FALSE(audioDeviceCommon.IsRingDualToneOnPrimarySpeaker(descs, 1));
1764
1765 descs.front()->deviceType_ = DEVICE_TYPE_EARPIECE;
1766 EXPECT_FALSE(audioDeviceCommon.IsRingDualToneOnPrimarySpeaker(descs, 1));
1767
1768 descs.back()->deviceType_ = DEVICE_TYPE_EARPIECE;
1769 EXPECT_FALSE(audioDeviceCommon.IsRingDualToneOnPrimarySpeaker(descs, 1));
1770
1771 descs.front()->deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
1772 EXPECT_FALSE(audioDeviceCommon.IsRingDualToneOnPrimarySpeaker(descs, 1));
1773
1774 descs.back()->deviceType_ = DEVICE_TYPE_SPEAKER;
1775 EXPECT_TRUE(audioDeviceCommon.IsRingDualToneOnPrimarySpeaker(descs, 1));
1776 }
1777
1778 /**
1779 * @tc.name : Test AudioDeviceCommon.
1780 * @tc.number: AudioDeviceCommon_091
1781 * @tc.desc : Test IsStopOrReleasePlayback interface.
1782 */
1783 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_091, TestSize.Level1)
1784 {
1785 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1786 AudioMode mode = AUDIO_MODE_RECORD;
1787 RendererState state = RENDERER_RUNNING;
1788 EXPECT_FALSE(audioDeviceCommon.IsStopOrReleasePlayback(mode, state));
1789
1790 mode = AUDIO_MODE_PLAYBACK;
1791 EXPECT_FALSE(audioDeviceCommon.IsStopOrReleasePlayback(mode, state));
1792
1793 state = RENDERER_STOPPED;
1794 EXPECT_TRUE(audioDeviceCommon.IsStopOrReleasePlayback(mode, state));
1795
1796 state = RENDERER_RELEASED;
1797 EXPECT_TRUE(audioDeviceCommon.IsStopOrReleasePlayback(mode, state));
1798 }
1799
1800 /**
1801 * @tc.name : Test AudioDeviceCommon.
1802 * @tc.number: AudioDeviceCommon_092
1803 * @tc.desc : Test UpdateTracker interface.
1804 */
1805 HWTEST_F(AudioDeviceCommonUnitTest, AudioDeviceCommon_092, TestSize.Level1)
1806 {
1807 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1808 AudioMode mode = AUDIO_MODE_RECORD;
1809 AudioStreamChangeInfo streamChangeInfo;
1810 streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage = STREAM_USAGE_INVALID;
1811 RendererState state = RENDERER_STOPPED;
1812 audioDeviceCommon.isRingDualToneOnPrimarySpeaker_ = false;
1813 audioDeviceCommon.UpdateTracker(mode, streamChangeInfo, state);
1814 EXPECT_FALSE(audioDeviceCommon.isRingDualToneOnPrimarySpeaker_);
1815
1816 streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage = STREAM_USAGE_VOICE_RINGTONE;
1817 audioDeviceCommon.UpdateTracker(mode, streamChangeInfo, state);
1818 EXPECT_FALSE(audioDeviceCommon.isRingDualToneOnPrimarySpeaker_);
1819
1820 streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage = STREAM_USAGE_RINGTONE;
1821 audioDeviceCommon.UpdateTracker(mode, streamChangeInfo, state);
1822 EXPECT_FALSE(audioDeviceCommon.isRingDualToneOnPrimarySpeaker_);
1823
1824 mode = AUDIO_MODE_PLAYBACK;
1825 streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage = STREAM_USAGE_INVALID;
1826 audioDeviceCommon.UpdateTracker(mode, streamChangeInfo, state);
1827 EXPECT_FALSE(audioDeviceCommon.isRingDualToneOnPrimarySpeaker_);
1828
1829 streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage = STREAM_USAGE_VOICE_RINGTONE;
1830 audioDeviceCommon.UpdateTracker(mode, streamChangeInfo, state);
1831 EXPECT_FALSE(audioDeviceCommon.isRingDualToneOnPrimarySpeaker_);
1832
1833 streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage = STREAM_USAGE_RINGTONE;
1834 audioDeviceCommon.UpdateTracker(mode, streamChangeInfo, state);
1835 EXPECT_FALSE(audioDeviceCommon.isRingDualToneOnPrimarySpeaker_);
1836
1837 audioDeviceCommon.isRingDualToneOnPrimarySpeaker_ = true;
1838 audioDeviceCommon.UpdateTracker(mode, streamChangeInfo, state);
1839 EXPECT_FALSE(audioDeviceCommon.isRingDualToneOnPrimarySpeaker_);
1840 }
1841 } // namespace AudioStandard
1842 } // namespace OHOS