1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_policy_utils.h"
17 #include "audio_active_device_unit_test.h"
18
19 using namespace testing::ext;
20
21 namespace OHOS {
22 namespace AudioStandard {
23
SetUpTestCase(void)24 void AudioActiveDeviceUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)25 void AudioActiveDeviceUnitTest::TearDownTestCase(void) {}
SetUp(void)26 void AudioActiveDeviceUnitTest::SetUp(void) {}
TearDown(void)27 void AudioActiveDeviceUnitTest::TearDown(void) {}
28
29 /**
30 * @tc.name : Test AudioActiveDevice.
31 * @tc.number: AudioActiveDeviceUnitTest_001.
32 * @tc.desc : Test GetActiveA2dpDeviceStreamInfo.
33 */
34 HWTEST_F(AudioActiveDeviceUnitTest, AudioActiveDeviceUnitTest_001, TestSize.Level1)
35 {
36 AudioStreamInfo streamInfo;
37 auto audioActiveDevice = std::make_shared<AudioActiveDevice>();
38 bool result = audioActiveDevice->GetActiveA2dpDeviceStreamInfo(DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP_IN,
39 streamInfo);
40 EXPECT_EQ(result, false);
41 }
42
43 /**
44 * @tc.name : Test AudioActiveDevice.
45 * @tc.number: AudioActiveDeviceUnitTest_002.
46 * @tc.desc : Test GetMaxAmplitude.
47 */
48 HWTEST_F(AudioActiveDeviceUnitTest, AudioActiveDeviceUnitTest_002, TestSize.Level1)
49 {
50 auto audioActiveDevice = std::make_shared<AudioActiveDevice>();
51 int32_t deviceId = AudioActiveDevice::GetInstance().GetCurrentInputDevice().deviceId_;
52 AudioInterrupt audioInterrupt;
53 float result = audioActiveDevice->GetMaxAmplitude(deviceId, audioInterrupt);
54 EXPECT_NE(audioActiveDevice, nullptr);
55 }
56
57 /**
58 * @tc.name : Test AudioActiveDevice.
59 * @tc.number: AudioActiveDeviceUnitTest_003.
60 * @tc.desc : Test UpdateDevice.
61 */
62 HWTEST_F(AudioActiveDeviceUnitTest, AudioActiveDeviceUnitTest_003, TestSize.Level1)
63 {
64 auto audioActiveDevice = std::make_shared<AudioActiveDevice>();
65 auto desc = std::make_shared<AudioDeviceDescriptor>(DeviceType::DEVICE_TYPE_NONE);
66 AudioStreamDeviceChangeReasonExt reason(AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE);
67 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
68 rendererChangeInfo->clientUID = 1001;
69 rendererChangeInfo->createrUID = 1001;
70 rendererChangeInfo->sessionId = 2001;
71
72 audioActiveDevice->UpdateDevice(desc, reason, rendererChangeInfo);
73 EXPECT_NE(rendererChangeInfo, nullptr);
74 }
75
76 /**
77 * @tc.name : Test AudioActiveDevice.
78 * @tc.number: AudioActiveDeviceUnitTest_004.
79 * @tc.desc : Test UpdateDevice.
80 */
81 HWTEST_F(AudioActiveDeviceUnitTest, AudioActiveDeviceUnitTest_004, TestSize.Level1)
82 {
83 auto audioActiveDevice = std::make_shared<AudioActiveDevice>();
84 auto desc = std::make_shared<AudioDeviceDescriptor>(DeviceType::DEVICE_TYPE_NONE);
85 AudioStreamDeviceChangeReasonExt reason(AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE);
86 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
87 rendererChangeInfo->clientUID = 1001;
88 rendererChangeInfo->createrUID = 1001;
89 rendererChangeInfo->sessionId = 2001;
90
91 audioActiveDevice->UpdateDevice(desc, reason, rendererChangeInfo);
92 EXPECT_NE(rendererChangeInfo, nullptr);
93 }
94
95 /**
96 * @tc.name : Test AudioActiveDevice.
97 * @tc.number: AudioActiveDeviceUnitTest_005.
98 * @tc.desc : Test HandleActiveBt.
99 */
100 HWTEST_F(AudioActiveDeviceUnitTest, AudioActiveDeviceUnitTest_005, TestSize.Level1)
101 {
102 std::string macAddress = "test";
103 auto audioActiveDevice = std::make_shared<AudioActiveDevice>();
104 AudioDeviceDescriptor deviceDescriptor;
105 deviceDescriptor.deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
106 audioActiveDevice->SetCurrentOutputDevice(deviceDescriptor);
107 audioActiveDevice->HandleActiveBt(DeviceType::DEVICE_TYPE_BLUETOOTH_SCO, macAddress);
108 EXPECT_NE(audioActiveDevice, nullptr);
109
110 audioActiveDevice->HandleActiveBt(DeviceType::DEVICE_TYPE_EARPIECE, macAddress);
111 EXPECT_NE(audioActiveDevice, nullptr);
112
113 deviceDescriptor.deviceType_ = DEVICE_TYPE_EARPIECE;
114 audioActiveDevice->SetCurrentOutputDevice(deviceDescriptor);
115 audioActiveDevice->HandleActiveBt(DeviceType::DEVICE_TYPE_BLUETOOTH_SCO, macAddress);
116 EXPECT_NE(audioActiveDevice, nullptr);
117
118 audioActiveDevice->HandleActiveBt(DeviceType::DEVICE_TYPE_EARPIECE, macAddress);
119 EXPECT_NE(audioActiveDevice, nullptr);
120
121 deviceDescriptor.deviceType_ = DEVICE_TYPE_NEARLINK;
122 audioActiveDevice->SetCurrentOutputDevice(deviceDescriptor);
123 audioActiveDevice->HandleActiveBt(DeviceType::DEVICE_TYPE_EARPIECE, macAddress);
124 EXPECT_NE(audioActiveDevice, nullptr);
125
126 audioActiveDevice->HandleActiveBt(DeviceType::DEVICE_TYPE_NEARLINK, macAddress);
127 EXPECT_NE(audioActiveDevice, nullptr);
128 }
129
130 /**
131 * @tc.name : Test AudioActiveDevice.
132 * @tc.number: AudioActiveDeviceUnitTest_006.
133 * @tc.desc : Test HandleNegtiveBt.
134 */
135 HWTEST_F(AudioActiveDeviceUnitTest, AudioActiveDeviceUnitTest_006, TestSize.Level1)
136 {
137 auto audioActiveDevice = std::make_shared<AudioActiveDevice>();
138 AudioDeviceDescriptor deviceDescriptor;
139 deviceDescriptor.deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
140 audioActiveDevice->SetCurrentOutputDevice(deviceDescriptor);
141 audioActiveDevice->HandleNegtiveBt(DeviceType::DEVICE_TYPE_BLUETOOTH_SCO);
142 EXPECT_NE(audioActiveDevice, nullptr);
143
144 audioActiveDevice->HandleNegtiveBt(DeviceType::DEVICE_TYPE_EARPIECE);
145 EXPECT_NE(audioActiveDevice, nullptr);
146
147 deviceDescriptor.deviceType_ = DEVICE_TYPE_EARPIECE;
148 audioActiveDevice->SetCurrentOutputDevice(deviceDescriptor);
149 audioActiveDevice->HandleNegtiveBt(DeviceType::DEVICE_TYPE_BLUETOOTH_SCO);
150 EXPECT_NE(audioActiveDevice, nullptr);
151
152 audioActiveDevice->HandleNegtiveBt(DeviceType::DEVICE_TYPE_EARPIECE);
153 EXPECT_NE(audioActiveDevice, nullptr);
154
155 deviceDescriptor.deviceType_ = DEVICE_TYPE_NEARLINK;
156 audioActiveDevice->SetCurrentOutputDevice(deviceDescriptor);
157 audioActiveDevice->HandleNegtiveBt(DeviceType::DEVICE_TYPE_NEARLINK);
158 EXPECT_NE(audioActiveDevice, nullptr);
159 }
160
161 /**
162 * @tc.name : Test AudioActiveDevice.
163 * @tc.number: AudioActiveDeviceUnitTest_007.
164 * @tc.desc : Test HandleNegtiveBt.
165 */
166 HWTEST_F(AudioActiveDeviceUnitTest, AudioActiveDeviceUnitTest_007, TestSize.Level1)
167 {
168 auto audioActiveDevice = std::make_shared<AudioActiveDevice>();
169 std::vector<std::shared_ptr<AudioDeviceDescriptor>> callDevices =
170 AudioPolicyUtils::GetInstance().GetAvailableDevicesInner(CALL_OUTPUT_DEVICES);
171 for (const auto &desc : callDevices) {
172 int32_t result = audioActiveDevice->SetDeviceActive(DeviceType::DEVICE_TYPE_FILE_SINK, true);
173 EXPECT_EQ(result, SUCCESS);
174 }
175
176 for (const auto &desc : callDevices) {
177 int32_t result = audioActiveDevice->SetDeviceActive(DeviceType::DEVICE_TYPE_FILE_SINK, false);
178 EXPECT_EQ(result, SUCCESS);
179 }
180 }
181
182 /**
183 * @tc.name : Test AudioActiveDevice.
184 * @tc.number: AudioActiveDeviceUnitTest_008.
185 * @tc.desc : Test SetCallDeviceActive.
186 */
187 HWTEST_F(AudioActiveDeviceUnitTest, AudioActiveDeviceUnitTest_008, TestSize.Level1)
188 {
189 auto audioActiveDevice = std::make_shared<AudioActiveDevice>();
190 std::vector<std::shared_ptr<AudioDeviceDescriptor>> callDevices =
191 AudioPolicyUtils::GetInstance().GetAvailableDevicesInner(CALL_OUTPUT_DEVICES);
192 for (const auto &desc : callDevices) {
193 int32_t result = audioActiveDevice->SetCallDeviceActive(desc->deviceType_, true, desc->macAddress_);
194 }
195 EXPECT_NE(audioActiveDevice, nullptr);
196 }
197
198 /**
199 * @tc.name : Test AudioActiveDevice.
200 * @tc.number: AudioActiveDeviceUnitTest_009.
201 * @tc.desc : Test SetCallDeviceActive.
202 */
203 HWTEST_F(AudioActiveDeviceUnitTest, AudioActiveDeviceUnitTest_009, TestSize.Level1)
204 {
205 auto audioActiveDevice = std::make_shared<AudioActiveDevice>();
206 std::vector<std::shared_ptr<AudioDeviceDescriptor>> callDevices =
207 AudioPolicyUtils::GetInstance().GetAvailableDevicesInner(CALL_OUTPUT_DEVICES);
208 for (const auto &desc : callDevices) {
209 audioActiveDevice->SetCallDeviceActive(desc->deviceType_, false, desc->macAddress_);
210 }
211 EXPECT_NE(audioActiveDevice, nullptr);
212 }
213
214 /**
215 * @tc.name : Test AudioActiveDevice.
216 * @tc.number: AudioActiveDeviceUnitTest_010.
217 * @tc.desc : Test CheckActiveOutputDeviceSupportOffload.
218 */
219 HWTEST_F(AudioActiveDeviceUnitTest, AudioActiveDeviceUnitTest_010, TestSize.Level1)
220 {
221 auto audioActiveDevice = std::make_shared<AudioActiveDevice>();
222
223 AudioDeviceDescriptor audioDeviceDescriptor1(DeviceType::DEVICE_TYPE_SPEAKER, OUTPUT_DEVICE);
224 audioActiveDevice->SetCurrentOutputDevice(audioDeviceDescriptor1);
225 bool result = audioActiveDevice->CheckActiveOutputDeviceSupportOffload();
226 EXPECT_EQ(result, true);
227
228 AudioDeviceDescriptor audioDeviceDescriptor(DeviceType::DEVICE_TYPE_REMOTE_CAST, OUTPUT_DEVICE);
229 audioActiveDevice->SetCurrentOutputDevice(audioDeviceDescriptor);
230 auto ret = audioActiveDevice->CheckActiveOutputDeviceSupportOffload();
231 EXPECT_EQ(ret, false);
232 }
233
234 /**
235 * @tc.name : Test AudioActiveDevice.
236 * @tc.number: AudioActiveDeviceUnitTest_011.
237 * @tc.desc : Test IsDirectSupportedDevice.
238 */
239 HWTEST_F(AudioActiveDeviceUnitTest, AudioActiveDeviceUnitTest_011, TestSize.Level1)
240 {
241 auto audioActiveDevice = std::make_shared<AudioActiveDevice>();
242 AudioDeviceDescriptor audioDeviceDescriptor(DeviceType::DEVICE_TYPE_USB_HEADSET, OUTPUT_DEVICE);
243 audioActiveDevice->SetCurrentOutputDevice(audioDeviceDescriptor);
244 bool result = audioActiveDevice->IsDirectSupportedDevice();
245 EXPECT_EQ(result, true);
246
247 AudioDeviceDescriptor audioDeviceDescriptor1(DeviceType::DEVICE_TYPE_BLUETOOTH_SCO, OUTPUT_DEVICE);
248 audioActiveDevice->SetCurrentOutputDevice(audioDeviceDescriptor1);
249 result = audioActiveDevice->IsDirectSupportedDevice();
250 EXPECT_EQ(result, false);
251 }
252
253 /**
254 * @tc.name : Test AudioActiveDevice.
255 * @tc.number: AudioActiveDeviceUnitTest_012.
256 * @tc.desc : Test IsDeviceActive.
257 */
258 HWTEST_F(AudioActiveDeviceUnitTest, AudioActiveDeviceUnitTest_012, TestSize.Level1)
259 {
260 auto audioActiveDevice = std::make_shared<AudioActiveDevice>();
261 AudioDeviceDescriptor audioDeviceDescriptor(DeviceType::DEVICE_TYPE_USB_HEADSET, OUTPUT_DEVICE);
262 audioActiveDevice->SetCurrentOutputDevice(audioDeviceDescriptor);
263 bool result = audioActiveDevice->IsDeviceActive(DeviceType::DEVICE_TYPE_USB_HEADSET);
264 EXPECT_EQ(result, true);
265
266 result = audioActiveDevice->IsDeviceActive(DeviceType::DEVICE_TYPE_BLUETOOTH_SCO);
267 EXPECT_EQ(result, false);
268 }
269 } // namespace AudioStandard
270 } // namespace OHOS
271