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_volume_manager_unit_test.h"
17
18 using namespace testing::ext;
19
20 namespace OHOS {
21 namespace AudioStandard {
22 const int32_t RESTORE_VOLUME_NOTIFICATION_ID = 116000;
23 const int32_t INCREASE_VOLUME_NOTIFICATION_ID = 116001;
24 const uint32_t NOTIFICATION_BANNER_FLAG = 1 << 9;
25
SetUpTestCase(void)26 void AudioVolumeManagerUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)27 void AudioVolumeManagerUnitTest::TearDownTestCase(void) {}
28
SetUp(void)29 void AudioVolumeManagerUnitTest::SetUp(void)
30 {
31 std::shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler(
32 DelayedSingleton<AudioPolicyServerHandler>::GetInstance());
33 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
34
35 audioVolumeManager.Init(audioPolicyServerHandler);
36 }
37
TearDown(void)38 void AudioVolumeManagerUnitTest::TearDown(void)
39 {
40 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
41
42 audioVolumeManager.DeInit();
43 }
44
45 /**
46 * @tc.name : Test AudioVolumeManager.
47 * @tc.number: AudioVolumeManager_001
48 * @tc.desc : Test GetSharedVolume interface.
49 */
50 HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_001, TestSize.Level1)
51 {
52 AudioVolumeType streamType = AudioStreamType::STREAM_DEFAULT;
53 DeviceType deviceType = DeviceType::DEVICE_TYPE_SPEAKER;
54 Volume vol;
55 bool bRet;
56 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
57
58 bRet = audioVolumeManager.GetSharedVolume(streamType, deviceType, vol);
59 EXPECT_EQ(bRet, false);
60
61 streamType = AudioStreamType::STREAM_RING;
62 bRet = audioVolumeManager.GetSharedVolume(streamType, deviceType, vol);
63 EXPECT_EQ(bRet, true);
64 }
65
66 /**
67 * @tc.name : Test AudioVolumeManager.
68 * @tc.number: AudioVolumeManager_002
69 * @tc.desc : Test InitSharedVolume interface.
70 */
71 HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_002, TestSize.Level1)
72 {
73 std::shared_ptr<AudioSharedMemory> buffer;
74 int32_t ret;
75 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
76
77 ret = audioVolumeManager.InitSharedVolume(buffer);
78 EXPECT_EQ(ret, SUCCESS);
79 }
80
81 /**
82 * @tc.name : Test AudioVolumeManager.
83 * @tc.number: AudioVolumeManager_003
84 * @tc.desc : Test SetVoiceRingtoneMute interface.
85 */
86 HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_003, TestSize.Level1)
87 {
88 bool isMute = true;
89 int32_t ret;
90 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
91
92 ret = audioVolumeManager.SetVoiceRingtoneMute(isMute);
93 EXPECT_EQ(ret, SUCCESS);
94
95 isMute = false;
96 ret = audioVolumeManager.SetVoiceRingtoneMute(isMute);
97 EXPECT_EQ(ret, SUCCESS);
98 }
99
100 /**
101 * @tc.name : Test AudioVolumeManager.
102 * @tc.number: AudioVolumeManager_004
103 * @tc.desc : Test HandleAbsBluetoothVolume interface.
104 */
105 HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_004, TestSize.Level1)
106 {
107 std::string macAddress = "11:22:33:44:55:66";
108 int32_t volumeLevel = 0;
109 int32_t ret;
110 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
111
112 audioVolumeManager.isBtFirstBoot_ = true;
113 ret = audioVolumeManager.HandleAbsBluetoothVolume(macAddress, volumeLevel);
114 EXPECT_EQ(ret, 0);
115
116 audioVolumeManager.isBtFirstBoot_ = false;
117 audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_CAR;
118 ret = audioVolumeManager.HandleAbsBluetoothVolume(macAddress, volumeLevel);
119 EXPECT_EQ(ret, 0);
120 }
121
122 /**
123 * @tc.name : Test AudioVolumeManager.
124 * @tc.number: AudioVolumeManager_005
125 * @tc.desc : Test IsWiredHeadSet interface.
126 */
127 HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_005, TestSize.Level1)
128 {
129 DeviceType deviceType = DEVICE_TYPE_NONE;
130 bool bRet;
131 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
132
133 bRet = audioVolumeManager.IsWiredHeadSet(deviceType);
134 EXPECT_EQ(bRet, false);
135
136 deviceType = DEVICE_TYPE_WIRED_HEADSET;
137 bRet = audioVolumeManager.IsWiredHeadSet(deviceType);
138 EXPECT_EQ(bRet, true);
139
140 deviceType = DEVICE_TYPE_WIRED_HEADPHONES;
141 bRet = audioVolumeManager.IsWiredHeadSet(deviceType);
142 EXPECT_EQ(bRet, true);
143
144 deviceType = DEVICE_TYPE_USB_HEADSET;
145 bRet = audioVolumeManager.IsWiredHeadSet(deviceType);
146 EXPECT_EQ(bRet, true);
147
148 deviceType = DEVICE_TYPE_USB_ARM_HEADSET;
149 bRet = audioVolumeManager.IsWiredHeadSet(deviceType);
150 EXPECT_EQ(bRet, true);
151 }
152
153 /**
154 * @tc.name : Test AudioVolumeManager.
155 * @tc.number: AudioVolumeManager_006
156 * @tc.desc : Test IsBlueTooth interface.
157 */
158 HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_006, TestSize.Level1)
159 {
160 DeviceType deviceType = DEVICE_TYPE_NONE;
161 bool bRet;
162 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
163
164 bRet = audioVolumeManager.IsBlueTooth(deviceType);
165 EXPECT_EQ(bRet, false);
166
167 audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_CAR;
168 deviceType = DEVICE_TYPE_BLUETOOTH_A2DP;
169 bRet = audioVolumeManager.IsBlueTooth(deviceType);
170 EXPECT_EQ(bRet, false);
171
172 audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = BT_SOUNDBOX;
173 deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
174 bRet = audioVolumeManager.IsBlueTooth(deviceType);
175 EXPECT_EQ(bRet, false);
176
177 audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = CATEGORY_DEFAULT;
178 deviceType = DEVICE_TYPE_BLUETOOTH_A2DP;
179 bRet = audioVolumeManager.IsBlueTooth(deviceType);
180 EXPECT_EQ(bRet, true);
181
182 deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
183 bRet = audioVolumeManager.IsBlueTooth(deviceType);
184 EXPECT_EQ(bRet, true);
185 }
186
187 /**
188 * @tc.name : Test AudioVolumeManager.
189 * @tc.number: AudioVolumeManager_007
190 * @tc.desc : Test CheckMixActiveMusicTime interface.
191 */
192 HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_007, TestSize.Level1)
193 {
194 int32_t safeVolume = 0;
195 bool bRet;
196 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
197
198 audioVolumeManager.activeSafeTimeBt_ = 0;
199 audioVolumeManager.activeSafeTime_ = 0;
200 bRet = audioVolumeManager.CheckMixActiveMusicTime(safeVolume);
201 EXPECT_EQ(bRet, false);
202
203 audioVolumeManager.activeSafeTimeBt_ = 100000;
204 audioVolumeManager.activeSafeTime_ = 100000;
205 bRet = audioVolumeManager.CheckMixActiveMusicTime(safeVolume);
206 EXPECT_EQ(bRet, true);
207 }
208
209 /**
210 * @tc.name : Test AudioVolumeManager.
211 * @tc.number: AudioVolumeManager_008
212 * @tc.desc : Test CheckBlueToothActiveMusicTime interface.
213 */
214 HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_008, TestSize.Level1)
215 {
216 int32_t safeVolume = 0;
217 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
218
219 audioVolumeManager.startSafeTimeBt_ = 0;
220 audioVolumeManager.activeSafeTimeBt_ = 10;
221 audioVolumeManager.activeSafeTime_ = 100;
222 audioVolumeManager.CheckBlueToothActiveMusicTime(safeVolume);
223 EXPECT_EQ(audioVolumeManager.startSafeTime_, 0);
224 }
225
226 /**
227 * @tc.name : Test AudioVolumeManager.
228 * @tc.number: AudioVolumeManager_009
229 * @tc.desc : Test CheckWiredActiveMusicTime interface.
230 */
231 HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_009, TestSize.Level1)
232 {
233 int32_t safeVolume = 0;
234 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
235
236 audioVolumeManager.startSafeTime_ = 0;
237 audioVolumeManager.activeSafeTimeBt_ = 10;
238 audioVolumeManager.activeSafeTime_ = 100;
239 audioVolumeManager.CheckWiredActiveMusicTime(safeVolume);
240 EXPECT_EQ(audioVolumeManager.startSafeTimeBt_, 0);
241 }
242
243 /**
244 * @tc.name : Test AudioVolumeManager.
245 * @tc.number: AudioVolumeManager_010
246 * @tc.desc : Test RestoreSafeVolume interface.
247 */
248 HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_010, TestSize.Level1)
249 {
250 AudioStreamType streamType = STREAM_RING;
251 int32_t safeVolume = 0;
252 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
253
254 audioVolumeManager.RestoreSafeVolume(streamType, safeVolume);
255 EXPECT_EQ(audioVolumeManager.GetSystemVolumeLevel(streamType), 0);
256
257 safeVolume = -1;
258 audioVolumeManager.RestoreSafeVolume(streamType, safeVolume);
259 EXPECT_EQ(audioVolumeManager.GetSystemVolumeLevel(streamType), 0);
260 }
261
262 /**
263 * @tc.name : Test AudioVolumeManager.
264 * @tc.number: AudioVolumeManager_011
265 * @tc.desc : Test SetSafeVolumeCallback interface.
266 */
267 HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_011, TestSize.Level1)
268 {
269 AudioStreamType streamType = STREAM_MUSIC;
270 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
271
272 audioVolumeManager.SetSafeVolumeCallback(streamType);
273 }
274
275 /**
276 * @tc.name : Test AudioVolumeManager.
277 * @tc.number: AudioVolumeManager_012
278 * @tc.desc : Test ChangeDeviceSafeStatus interface.
279 */
280 HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_012, TestSize.Level1)
281 {
282 SafeStatus safeStatus = SAFE_UNKNOWN;
283 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
284
285 audioVolumeManager.ChangeDeviceSafeStatus(safeStatus);
286 EXPECT_EQ(audioVolumeManager.safeStatus_, SAFE_UNKNOWN);
287 }
288
289 /**
290 * @tc.name : Test AudioVolumeManager.
291 * @tc.number: AudioVolumeManager_013
292 * @tc.desc : Test SetAbsVolumeSceneAsync interface.
293 */
294 HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_013, TestSize.Level1)
295 {
296 std::string macAddress = "11:22:33:44:55:66";
297 bool support = true;
298 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
299
300 audioVolumeManager.audioActiveDevice_.SetActiveBtDeviceMac(macAddress);
301 audioVolumeManager.SetAbsVolumeSceneAsync(macAddress, support);
302 EXPECT_EQ(audioVolumeManager.audioActiveDevice_.GetActiveBtDeviceMac(), macAddress);
303 }
304
305 /**
306 * @tc.name : Test AudioVolumeManager.
307 * @tc.number: AudioVolumeManager_014
308 * @tc.desc : Test DealWithEventVolume interface.
309 */
310 HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_014, TestSize.Level1)
311 {
312 int32_t notificationId;
313 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
314 int32_t ret;
315
316 notificationId = RESTORE_VOLUME_NOTIFICATION_ID;
317 audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = CATEGORY_DEFAULT;
318 audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
319 ret = audioVolumeManager.DealWithEventVolume(notificationId);
320 EXPECT_NE(ret, 0);
321
322 notificationId = INCREASE_VOLUME_NOTIFICATION_ID;
323 ret = audioVolumeManager.DealWithEventVolume(notificationId);
324 EXPECT_NE(ret, 0);
325
326 notificationId = NOTIFICATION_BANNER_FLAG;
327 ret = audioVolumeManager.DealWithEventVolume(notificationId);
328 EXPECT_EQ(ret, 0);
329
330 audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_WIRED_HEADSET;
331 notificationId = RESTORE_VOLUME_NOTIFICATION_ID;
332 ret = audioVolumeManager.DealWithEventVolume(notificationId);
333 EXPECT_NE(ret, 0);
334
335 notificationId = INCREASE_VOLUME_NOTIFICATION_ID;
336 ret = audioVolumeManager.DealWithEventVolume(notificationId);
337 EXPECT_EQ(ret, 0);
338
339 notificationId = NOTIFICATION_BANNER_FLAG;
340 ret = audioVolumeManager.DealWithEventVolume(notificationId);
341 EXPECT_EQ(ret, 0);
342
343 audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_NONE;
344 ret = audioVolumeManager.DealWithEventVolume(notificationId);
345 EXPECT_NE(ret, 0);
346 }
347
348 /**
349 * @tc.name : Test AudioVolumeManager.
350 * @tc.number: AudioVolumeManager_015
351 * @tc.desc : Test UpdateSafeVolumeByS4 interface.
352 */
353 HWTEST_F(AudioVolumeManagerUnitTest, AudioVolumeManager_015, TestSize.Level1)
354 {
355 AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
356
357 audioVolumeManager.UpdateSafeVolumeByS4();
358 audioVolumeManager.audioPolicyManager_.SetVolumeForSwitchDevice(DEVICE_TYPE_NONE);
359 EXPECT_EQ(audioVolumeManager.isBtFirstBoot_, true);
360 }
361 } // namespace AudioStandard
362 } // namespace OHOS
363