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 <gtest/gtest.h>
17 #include "audio_errors.h"
18 #include "audio_session.h"
19 #include "audio_session_service.h"
20 #include "audio_session_unit_test.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace AudioStandard {
26
SetUpTestCase(void)27 void AudioSessionUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)28 void AudioSessionUnitTest::TearDownTestCase(void) {}
SetUp(void)29 void AudioSessionUnitTest::SetUp(void) {}
TearDown(void)30 void AudioSessionUnitTest::TearDown(void) {}
31
32 /**
33 * @tc.name : Test AudioSession.
34 * @tc.number: AudioSessionUnitTest_001.
35 * @tc.desc : Test AddStreamInfo.
36 */
37 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_001, TestSize.Level1)
38 {
39 int32_t callerPid = 1;
40 AudioSessionStrategy strategy;
41 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
42 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
43
44 AudioInterrupt audioInterrupt = {};
45 audioInterrupt.streamId = 1;
46 audioSession->AddStreamInfo(audioInterrupt);
47 EXPECT_FALSE(audioSession->IsAudioSessionEmpty());
48 audioSession->RemoveStreamInfo(audioInterrupt.streamId);
49 EXPECT_TRUE(audioSession->IsAudioSessionEmpty());
50 }
51
52 /**
53 * @tc.name : Test AudioSession.
54 * @tc.number: AudioSessionUnitTest_002.
55 * @tc.desc : Test RemoveStreamInfo.
56 */
57 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_002, TestSize.Level1)
58 {
59 int32_t callerPid = 1;
60 AudioSessionStrategy strategy;
61 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
62 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
63
64 AudioInterrupt audioInterrupt = {};
65 audioInterrupt.streamId = 1;
66 audioSession->AddStreamInfo(audioInterrupt);
67 audioSession->RemoveStreamInfo(0);
68 EXPECT_FALSE(audioSession->IsAudioSessionEmpty());
69 audioSession->RemoveStreamInfo(audioInterrupt.streamId);
70 }
71
72 /**
73 * @tc.name : Test AudioSession.
74 * @tc.number: AudioSessionUnitTest_003.
75 * @tc.desc : Test RemoveStreamInfo.
76 */
77 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_003, TestSize.Level1)
78 {
79 int32_t callerPid = 1;
80 AudioSessionStrategy strategy;
81 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
82 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
83
84 AudioInterrupt audioInterrupt = {};
85 audioInterrupt.streamId = 10;
86 audioSession->AddStreamInfo(audioInterrupt);
87 audioSession->RemoveStreamInfo(audioInterrupt.streamId);
88 EXPECT_TRUE(audioSession->IsAudioSessionEmpty());
89 }
90
91 /**
92 * @tc.name : Test AudioSession.
93 * @tc.number: AudioSessionUnitTest_004.
94 * @tc.desc : Test RemoveStreamInfo.
95 */
96 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_004, TestSize.Level1)
97 {
98 int32_t callerPid = 1;
99 AudioSessionStrategy strategy;
100 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
101 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
102
103 AudioInterrupt audioInterrupt = {};
104 audioInterrupt.streamId = 0;
105 audioSession->AddStreamInfo(audioInterrupt);
106 audioSession->RemoveStreamInfo(audioInterrupt.streamId);
107 EXPECT_TRUE(audioSession->IsAudioSessionEmpty());
108 }
109
110 /**
111 * @tc.name : Test AudioSession.
112 * @tc.number: AudioSessionUnitTest_005.
113 * @tc.desc : Test RemoveStreamInfo.
114 */
115 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_005, TestSize.Level1)
116 {
117 int32_t callerPid = 1;
118 AudioSessionStrategy strategy;
119 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
120 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
121
122 uint32_t i = 1;
123 AudioInterrupt audioInterrupt = {};
124 audioInterrupt.streamId = i;
125 audioSession->AddStreamInfo(audioInterrupt);
126
127 AudioInterrupt audioInterrupt2;
128 audioInterrupt2.streamId = i + 1;
129 audioSession->AddStreamInfo(audioInterrupt2);
130
131 audioSession->RemoveStreamInfo(audioInterrupt2.streamId);
132 EXPECT_FALSE(audioSession->IsAudioSessionEmpty());
133 audioSession->RemoveStreamInfo(audioInterrupt.streamId);
134 }
135
136 /**
137 * @tc.name : Test AudioSession.
138 * @tc.number: AudioSessionUnitTest_006.
139 * @tc.desc : Test RemoveStreamInfo.
140 */
141 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_006, TestSize.Level1)
142 {
143 int32_t callerPid = 1;
144 AudioSessionStrategy strategy;
145 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
146 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
147
148 uint32_t i = 1;
149 AudioInterrupt audioInterrupt = {};
150 audioInterrupt.streamId = i;
151
152 audioSession->AddStreamInfo(audioInterrupt);
153 EXPECT_FALSE(audioSession->IsAudioSessionEmpty());
154 audioSession->RemoveStreamInfo(audioInterrupt.streamId);
155 }
156
157 /**
158 * @tc.name : Test AudioSession.
159 * @tc.number: AudioSessionUnitTest_007.
160 * @tc.desc : Test IsAudioRendererEmpty.
161 */
162 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_007, TestSize.Level1)
163 {
164 int32_t callerPid = 1;
165 AudioSessionStrategy strategy;
166 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
167 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
168
169 uint32_t streamId = 1;
170 AudioInterrupt audioInterrupt = {};
171 audioInterrupt.streamId = streamId;
172 audioInterrupt.audioFocusType.streamType = STREAM_DEFAULT;
173
174 audioSession->AddStreamInfo(audioInterrupt);
175 EXPECT_TRUE(audioSession->IsAudioRendererEmpty());
176 audioSession->RemoveStreamInfo(streamId);
177 }
178
179 /**
180 * @tc.name : Test AudioSession.
181 * @tc.number: AudioSessionUnitTest_008.
182 * @tc.desc : Test IsAudioRendererEmpty.
183 */
184 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_008, TestSize.Level1)
185 {
186 int32_t callerPid = 1;
187 AudioSessionStrategy strategy;
188 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
189 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
190
191 uint32_t streamId = 1;
192 AudioInterrupt audioInterrupt = {};
193 audioInterrupt.streamId = streamId;
194 audioInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
195
196 audioSession->AddStreamInfo(audioInterrupt);
197 EXPECT_FALSE(audioSession->IsAudioRendererEmpty());
198 }
199
200 /**
201 * @tc.name : Test EnableDefaultDevice.
202 * @tc.number: AudioSessionUnitTest_009.
203 * @tc.desc : Test EnableDefaultDevice function.
204 */
205 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_009, TestSize.Level1)
206 {
207 int32_t callerPid = 1;
208 AudioSessionStrategy strategy;
209 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
210 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
211
212 audioSession->fakeStreamId_ = 0;
213 audioSession->state_ = AudioSessionState::SESSION_RELEASED;
214 EXPECT_EQ(audioSession->EnableDefaultDevice(), 0);
215
216 audioSession->state_ = AudioSessionState::SESSION_ACTIVE;
217 audioSession->defaultDeviceType_ = DEVICE_TYPE_INVALID;
218 EXPECT_EQ(audioSession->EnableDefaultDevice(), 0);
219 }
220
221 /**
222 * @tc.name : Test ShouldExcludeStreamType.
223 * @tc.number: AudioSessionUnitTest_010.
224 * @tc.desc : Test ShouldExcludeStreamType function.
225 */
226 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_010, TestSize.Level1)
227 {
228 int32_t callerPid = 1;
229 AudioSessionStrategy strategy;
230 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
231 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
232
233 AudioInterrupt audioInterrupt = {};
234 audioInterrupt.audioFocusType.streamType = STREAM_NOTIFICATION;
235 EXPECT_TRUE(audioSession->ShouldExcludeStreamType(audioInterrupt));
236
237
238 audioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
239 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
240 EXPECT_FALSE(audioSession->ShouldExcludeStreamType(audioInterrupt));
241
242 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
243 EXPECT_TRUE(audioSession->ShouldExcludeStreamType(audioInterrupt));
244 }
245
246 /**
247 * @tc.name : Test SetSessionDefaultOutputDevice
248 * @tc.number: AudioSessionUnitTest_011
249 * @tc.desc : Test SetSessionDefaultOutputDevice function
250 */
251 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_011, TestSize.Level1)
252 {
253 int32_t callerPid = 1;
254 AudioSessionStrategy strategy;
255 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
256 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
257
258 EXPECT_EQ(audioSession->SetSessionDefaultOutputDevice(DEVICE_TYPE_INVALID), ERROR_INVALID_PARAM);
259
260 audioSession->state_ = AudioSessionState::SESSION_ACTIVE;
261 audioSession->fakeStreamId_ = 0;
262 EXPECT_EQ(audioSession->SetSessionDefaultOutputDevice(DEVICE_TYPE_EARPIECE), 0);
263
264 audioSession->state_ = AudioSessionState::SESSION_DEACTIVE;
265 EXPECT_EQ(audioSession->SetSessionDefaultOutputDevice(DEVICE_TYPE_EARPIECE), 0);
266
267 DeviceType type;
268 audioSession->GetSessionDefaultOutputDevice(type);
269 }
270
271 /**
272 * @tc.name : Test IsStreamContainedInCurrentSession
273 * @tc.number: AudioSessionUnitTest_012
274 * @tc.desc : Test IsStreamContainedInCurrentSession function
275 */
276 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_012, TestSize.Level1)
277 {
278 int32_t callerPid = 1;
279 AudioSessionStrategy strategy;
280 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
281 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
282
283 audioSession->streamsInSession_.clear();
284 EXPECT_FALSE(audioSession->IsStreamContainedInCurrentSession(0));
285
286 AudioInterrupt incomingInterrupt;
287 incomingInterrupt.streamId = 0;
288 audioSession->streamsInSession_.push_back(incomingInterrupt);
289 EXPECT_TRUE(audioSession->IsStreamContainedInCurrentSession(0));
290 }
291
292 /**
293 * @tc.name : Test IsRecommendToStopAudio
294 * @tc.number: AudioSessionUnitTest_013
295 * @tc.desc : Test IsRecommendToStopAudio function
296 */
297 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_013, TestSize.Level1)
298 {
299 int32_t callerPid = 1;
300 AudioSessionStrategy strategy;
301 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
302 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
303
304 EXPECT_FALSE(audioSession->IsRecommendToStopAudio(nullptr));
305
306 std::shared_ptr<AudioPolicyServerHandler::EventContextObj> eventContextObj =
307 std::make_shared<AudioPolicyServerHandler::EventContextObj>();
308 eventContextObj->reason_ = AudioStreamDeviceChangeReason::OVERRODE;
309 eventContextObj->reason_ = AudioStreamDeviceChangeReason::UNKNOWN;
310 eventContextObj->descriptor = nullptr;
311 EXPECT_FALSE(audioSession->IsRecommendToStopAudio(eventContextObj));
312 }
313
314 /**
315 * @tc.name : Test UpdateVoipStreamsDefaultOutputDevice
316 * @tc.number: AudioSessionUnitTest_014
317 * @tc.desc : Test UpdateVoipStreamsDefaultOutputDevice function
318 */
319 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_014, TestSize.Level1)
320 {
321 int32_t callerPid = 1;
322 AudioSessionStrategy strategy;
323 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
324 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
325
326 AudioInterrupt audioInterrupt = {};
327 audioInterrupt.streamId = 1;
328 audioInterrupt.streamUsage = STREAM_USAGE_VOICE_MESSAGE;
329 audioSession->streamsInSession_.push_back(audioInterrupt);
330 audioSession->SetAudioSessionScene(AudioSessionScene::MEDIA);
331 int32_t ret = audioSession->Activate(strategy);
332 EXPECT_EQ(ret, SUCCESS);
333 audioSession->SetSessionDefaultOutputDevice(DEVICE_TYPE_DEFAULT);
334 ret = audioSession->Deactivate();
335 EXPECT_EQ(ret, SUCCESS);
336 }
337
338
339 /**
340 * @tc.name : Test SetAudioSessionScene
341 * @tc.number: AudioSessionUnitTest_015
342 * @tc.desc : Test SetAudioSessionScene function
343 */
344 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_015, TestSize.Level1)
345 {
346 int32_t callerPid = 1;
347 AudioSessionStrategy strategy;
348 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
349 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
350
351 AudioSessionScene scene = AudioSessionScene::INVALID;
352 int32_t ret = audioSession->SetAudioSessionScene(scene);
353 EXPECT_EQ(ret, ERR_INVALID_PARAM);
354 }
355
356 /**
357 * @tc.name : Test ShouldExcludeStreamType
358 * @tc.number: AudioSessionUnitTest_016
359 * @tc.desc : Test ShouldExcludeStreamType function
360 */
361 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_016, TestSize.Level1)
362 {
363 int32_t callerPid = 1;
364 AudioSessionStrategy strategy;
365 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
366 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
367 audioSession->IsActivated();
368 audioSession->IsSceneParameterSet();
369 AudioInterrupt incomingInterrupt;
370
371 incomingInterrupt.audioFocusType.streamType = STREAM_NOTIFICATION;
372 EXPECT_TRUE(audioSession->ShouldExcludeStreamType(incomingInterrupt));
373
374 EXPECT_NO_THROW(
375 audioSession->AddStreamInfo(incomingInterrupt);
376 );
377
378 incomingInterrupt.isAudioSessionInterrupt = true;
379 EXPECT_NO_THROW(
380 audioSession->AddStreamInfo(incomingInterrupt);
381 );
382 }
383
384 /**
385 * @tc.name : Test EnableSingleVoipStreamDefaultOutputDevice
386 * @tc.number: AudioSessionUnitTest_017
387 * @tc.desc : Test EnableSingleVoipStreamDefaultOutputDevice function
388 */
389 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_017, TestSize.Level1)
390 {
391 int32_t callerPid = 1;
392 AudioSessionStrategy strategy;
393 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
394 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
395
396 EXPECT_EQ(SUCCESS, audioSession->SetAudioSessionScene(AudioSessionScene::MEDIA));
397
398 AudioInterrupt interrupt = {};
399 interrupt.streamUsage = STREAM_USAGE_VOICE_MESSAGE;
400 interrupt.streamId = 2;
401 int32_t ret = audioSession->EnableSingleVoipStreamDefaultOutputDevice(interrupt);
402 EXPECT_EQ(ret, SUCCESS);
403 }
404
405 /**
406 * @tc.name : Test EnableVoipStreamsDefaultOutputDevice
407 * @tc.number: AudioSessionUnitTest_018
408 * @tc.desc : Test EnableVoipStreamsDefaultOutputDevice function
409 */
410 HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_018, TestSize.Level1)
411 {
412 int32_t callerPid = 1;
413 AudioSessionStrategy strategy;
414 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
415 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
416
417 EXPECT_EQ(SUCCESS, audioSession->SetAudioSessionScene(AudioSessionScene::MEDIA));
418
419 AudioInterrupt interrupt = {};
420 interrupt.streamUsage = STREAM_USAGE_VOICE_MESSAGE;
421 interrupt.streamId = 2;
422 audioSession->AddStreamInfo(interrupt);
423 int32_t ret = audioSession->EnableVoipStreamsDefaultOutputDevice();
424 EXPECT_EQ(ret, SUCCESS);
425 }
426 } // namespace AudioStandard
427 } // namespace OHOS
428