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_errors.h"
17 #include "audio_session_service.h"
18 #include "audio_session_service_unit_test.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace AudioStandard {
25
26 static const uint32_t START_FAKE_STREAM_ID = 888;
27
28 class MockSessionTimeOutCallback : public SessionTimeOutCallback {
29 public:
30 ~MockSessionTimeOutCallback() = default;
31
OnSessionTimeout(const int32_t pid)32 void OnSessionTimeout(const int32_t pid) override {}
33 };
34
SetUpTestCase(void)35 void AudioSessionServiceUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)36 void AudioSessionServiceUnitTest::TearDownTestCase(void) {}
SetUp(void)37 void AudioSessionServiceUnitTest::SetUp(void) {}
TearDown(void)38 void AudioSessionServiceUnitTest::TearDown(void) {}
39
40 /**
41 * @tc.name : Test AudioSessionService.
42 * @tc.number: AudioSessionServiceUnitTest_001.
43 * @tc.desc : Test IsSameTypeForAudioSession.
44 */
45 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_001, TestSize.Level1)
46 {
47 auto audioSessionService = std::make_shared<AudioSessionService>();
48 auto ret = audioSessionService->IsSameTypeForAudioSession(AudioStreamType::STREAM_MUSIC,
49 AudioStreamType::STREAM_MUSIC);
50 EXPECT_TRUE(ret);
51 }
52
53 /**
54 * @tc.name : Test AudioSessionService.
55 * @tc.number: AudioSessionServiceUnitTest_002.
56 * @tc.desc : Test DeactivateAudioSessionInternal.
57 */
58 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_002, TestSize.Level1)
59 {
60 int32_t callerPid = 0;
61 auto audioSessionService = std::make_shared<AudioSessionService>();
62
63 AudioSessionStrategy strategy;
64 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
65 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
66
67 audioSessionService->sessionMap_[callerPid] = audioSession;
68 auto ret = audioSessionService->DeactivateAudioSessionInternal(callerPid, true);
69 EXPECT_EQ(ret, SUCCESS);
70
71 audioSessionService->sessionMap_[callerPid] = audioSession;
72 ret = audioSessionService->DeactivateAudioSessionInternal(callerPid, false);
73 EXPECT_EQ(ret, SUCCESS);
74 }
75
76 /**
77 * @tc.name : Test AudioSessionService.
78 * @tc.number: AudioSessionServiceUnitTest_003.
79 * @tc.desc : Test SetSessionTimeOutCallback.
80 */
81 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_003, TestSize.Level1)
82 {
83 int32_t callerPid = 0;
84 auto audioSessionService = std::make_shared<AudioSessionService>();
85 ASSERT_TRUE(audioSessionService != nullptr);
86
87 std::shared_ptr<SessionTimeOutCallback> timeOutCallback = nullptr;
88 auto ret = audioSessionService->SetSessionTimeOutCallback(timeOutCallback);
89 EXPECT_EQ(ret, -1);
90 }
91
92 /**
93 * @tc.name : Test AudioSessionService.
94 * @tc.number: AudioSessionServiceUnitTest_004.
95 * @tc.desc : Test GetAudioSessionByPid.
96 */
97 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_004, TestSize.Level1)
98 {
99 int32_t callerPid = 10;
100 auto audioSessionService = std::make_shared<AudioSessionService>();
101 ASSERT_TRUE(audioSessionService != nullptr);
102
103 auto ret = audioSessionService->GetAudioSessionByPid(callerPid);
104 EXPECT_TRUE(ret == nullptr);
105 }
106
107 /**
108 * @tc.name : Test AudioSessionService.
109 * @tc.number: AudioSessionServiceUnitTest_005.
110 * @tc.desc : Test OnAudioSessionTimeOut.
111 */
112 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_005, TestSize.Level1)
113 {
114 int32_t callerPid = 0;
115 auto audioSessionService = std::make_shared<AudioSessionService>();
116 ASSERT_TRUE(audioSessionService != nullptr);
117
118 audioSessionService->OnAudioSessionTimeOut(callerPid);
119 }
120
121 /**
122 * @tc.name : Test AudioSessionService.
123 * @tc.number: AudioSessionServiceUnitTest_006.
124 * @tc.desc : Test AudioSessionInfoDump.
125 */
126 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_006, TestSize.Level1)
127 {
128 std::string dumpString = "test";
129 auto audioSessionService = std::make_shared<AudioSessionService>();
130 ASSERT_TRUE(audioSessionService != nullptr);
131
132 audioSessionService->AudioSessionInfoDump(dumpString);
133 }
134
135 /**
136 * @tc.name : Test AudioSessionService.
137 * @tc.number: AudioSessionServiceUnitTest_007.
138 * @tc.desc : Test AudioSessionInfoDump.
139 */
140 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_007, TestSize.Level1)
141 {
142 int32_t callerPid = 0;
143 std::string dumpString = "test";
144 auto audioSessionService = std::make_shared<AudioSessionService>();
145 ASSERT_TRUE(audioSessionService != nullptr);
146
147 AudioSessionStrategy strategy;
148 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
149 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
150 AudioInterrupt audioInterrupt = {};
151 auto interruptPair = std::pair<AudioInterrupt, AudioFocuState>(audioInterrupt, AudioFocuState::DUCK);
152
153 audioSessionService->sessionMap_[callerPid] = audioSession;
154 audioSessionService->AudioSessionInfoDump(dumpString);
155 }
156
157 /**
158 * @tc.name : Test AudioSessionService.
159 * @tc.number: AudioSessionServiceUnitTest_008.
160 * @tc.desc : Test AudioSessionInfoDump.
161 */
162 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_008, TestSize.Level1)
163 {
164 int32_t callerPid = 0;
165 std::string dumpString = "test";
166 auto audioSessionService = std::make_shared<AudioSessionService>();
167 ASSERT_TRUE(audioSessionService != nullptr);
168
169 AudioSessionStrategy strategy;
170 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
171 auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
172 AudioInterrupt audioInterrupt = {};
173 audioInterrupt.streamId = 0;
174 audioSession->streamsInSession_.push_back(audioInterrupt);
175
176 audioSessionService->sessionMap_[callerPid] = audioSession;
177 audioSessionService->AudioSessionInfoDump(dumpString);
178 }
179
180 /**
181 * @tc.name : Test AudioSessionService.
182 * @tc.number: AudioSessionServiceUnitTest_009.
183 * @tc.desc : Test AudioSessionInfoDump.
184 */
185 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_009, TestSize.Level1)
186 {
187 int32_t callerPid = 0;
188 std::string dumpString = "test";
189 auto audioSessionService = std::make_shared<AudioSessionService>();
190 ASSERT_TRUE(audioSessionService != nullptr);
191
192 audioSessionService->sessionMap_[callerPid] = nullptr;
193 audioSessionService->AudioSessionInfoDump(dumpString);
194 }
195
196 /**
197 * @tc.name : Test SetAudioSessionScene
198 * @tc.number: SetAudioSessionSceneTest
199 * @tc.desc : Test SetAudioSessionScene
200 */
201 HWTEST_F(AudioSessionServiceUnitTest, SetAudioSessionSceneTest, TestSize.Level1)
202 {
203 int32_t fakePid = 123;
204 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
205 ASSERT_TRUE(sessionService != nullptr);
206 int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
207 EXPECT_EQ(SUCCESS, ret);
208 AudioSessionStrategy audioSessionStrategy;
209 audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
210 ret = sessionService->ActivateAudioSession(fakePid, audioSessionStrategy);
211 EXPECT_EQ(SUCCESS, ret);
212 EXPECT_TRUE(sessionService->IsAudioSessionActivated(fakePid));
213 EXPECT_TRUE(sessionService->IsAudioSessionFocusMode(fakePid));
214 }
215
216 /**
217 * @tc.name : Test GetAudioSessionStreamUsage
218 * @tc.number: GetAudioSessionStreamUsage
219 * @tc.desc : Test GetAudioSessionStreamUsage
220 */
221 HWTEST_F(AudioSessionServiceUnitTest, GetAudioSessionStreamUsage, TestSize.Level1)
222 {
223 int32_t fakePid = 123;
224 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
225 ASSERT_TRUE(sessionService != nullptr);
226 StreamUsage usage = sessionService->GetAudioSessionStreamUsage(fakePid);
227 EXPECT_EQ(STREAM_USAGE_INVALID, usage);
228 }
229
230 /**
231 * @tc.name : Test GetAudioSessionStreamUsage
232 * @tc.number: GetAudioSessionStreamUsage_001
233 * @tc.desc : Test GetAudioSessionStreamUsage
234 */
235 HWTEST_F(AudioSessionServiceUnitTest, GetAudioSessionStreamUsage_001, TestSize.Level1)
236 {
237 int32_t fakePid = 123;
238 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
239 ASSERT_TRUE(sessionService != nullptr);
240 int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
241 EXPECT_EQ(SUCCESS, ret);
242 StreamUsage usage = sessionService->GetAudioSessionStreamUsage(fakePid);
243 EXPECT_EQ(STREAM_USAGE_MEDIA, usage);
244 }
245
246 /**
247 * @tc.name : Test AudioSessionService.
248 * @tc.number: AudioSessionServiceUnitTest_010.
249 * @tc.desc : Test ActivateAudioSession.
250 */
251 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_010, TestSize.Level1)
252 {
253 auto sessionService = std::make_shared<AudioSessionService>();
254 int32_t callerPid = 1;
255 AudioSessionStrategy strategy;
256 sessionService->sessionMap_.emplace(callerPid, nullptr);
257 EXPECT_EQ(sessionService->ActivateAudioSession(callerPid, strategy), ERROR);
258 }
259
260 /**
261 * @tc.name : Test AudioSessionService.
262 * @tc.number: AudioSessionServiceUnitTest_011.
263 * @tc.desc : Test DeactivateAudioSessionInternal.
264 */
265 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_011, TestSize.Level1)
266 {
267 auto sessionService = std::make_shared<AudioSessionService>();
268 int32_t callerPid = 1;
269 bool isSessionTimeout = false;
270 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, nullptr));
271 EXPECT_EQ(sessionService->DeactivateAudioSessionInternal(callerPid, isSessionTimeout), ERR_ILLEGAL_STATE);
272
273 AudioSessionStrategy strategy;
274 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
275 uint32_t fakeStreamId = 1000;
276 audioSession->SaveFakeStreamId(fakeStreamId);
277 sessionService->sessionMap_[callerPid] = audioSession;
278 EXPECT_EQ(sessionService->DeactivateAudioSessionInternal(callerPid, isSessionTimeout), SUCCESS);
279 }
280
281 /**
282 * @tc.name : Test AudioSessionService.
283 * @tc.number: AudioSessionServiceUnitTest_012.
284 * @tc.desc : Test OnAudioSessionTimeOut.
285 */
286 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_012, TestSize.Level1)
287 {
288 auto sessionService = std::make_shared<AudioSessionService>();
289 int32_t callerPid = 1;
290 AudioSessionStrategy strategy;
291 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
292 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
293 auto mockTimeOutCallback = std::make_shared<MockSessionTimeOutCallback>();
294 sessionService->SetSessionTimeOutCallback(mockTimeOutCallback);
295 EXPECT_NO_THROW(sessionService->OnAudioSessionTimeOut(callerPid));
296 }
297
298 /**
299 * @tc.name : Test AudioSessionService.
300 * @tc.number: AudioSessionServiceUnitTest_013.
301 * @tc.desc : Test SetAudioSessionScene.
302 */
303 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_013, TestSize.Level1)
304 {
305 auto sessionService = std::make_shared<AudioSessionService>();
306 int32_t callerPid = 1;
307 AudioSessionScene scene = AudioSessionScene::MEDIA;
308 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, nullptr));
309 EXPECT_EQ(sessionService->SetAudioSessionScene(callerPid, scene), SUCCESS);
310
311 sessionService->sessionMap_.clear();
312 AudioSessionStrategy strategy;
313 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
314 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
315 EXPECT_EQ(sessionService->SetAudioSessionScene(callerPid, scene), SUCCESS);
316
317 callerPid = 2;
318 EXPECT_EQ(sessionService->SetAudioSessionScene(callerPid, scene), SUCCESS);
319 };
320
321 /**
322 * @tc.name : Test AudioSessionService.
323 * @tc.number: AudioSessionServiceUnitTest_014.
324 * @tc.desc : Test ShouldExcludeStreamType.
325 */
326 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_014, TestSize.Level1)
327 {
328 auto sessionService = std::make_shared<AudioSessionService>();
329 AudioInterrupt audioInterrupt = {};
330 audioInterrupt.audioFocusType.streamType = STREAM_NOTIFICATION;
331 EXPECT_TRUE(sessionService->ShouldExcludeStreamType(audioInterrupt));
332
333 audioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
334 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
335 EXPECT_TRUE(sessionService->ShouldExcludeStreamType(audioInterrupt));
336 }
337
338 /**
339 * @tc.name : Test AudioSessionService.
340 * @tc.number: AudioSessionServiceUnitTest_015.
341 * @tc.desc : Test ShouldBypassFocusForStream.
342 */
343 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_015, TestSize.Level1)
344 {
345 auto sessionService = std::make_shared<AudioSessionService>();
346 int32_t callerPid = 1;
347 AudioSessionStrategy strategy;
348 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
349 audioSession->audioSessionScene_ = AudioSessionScene::MEDIA;
350 audioSession->state_ = AudioSessionState::SESSION_ACTIVE;
351 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
352
353 AudioInterrupt audioInterrupt = {};
354 audioInterrupt.pid = callerPid;
355 audioInterrupt.audioFocusType.streamType = STREAM_NOTIFICATION;
356 EXPECT_FALSE(sessionService->ShouldBypassFocusForStream(audioInterrupt));
357 }
358
359 /**
360 * @tc.name : Test AudioSessionService.
361 * @tc.number: AudioSessionServiceUnitTest_016.
362 * @tc.desc : Test GenerateFakeAudioInterrupt.
363 */
364 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_016, TestSize.Level1)
365 {
366 auto sessionService = std::make_shared<AudioSessionService>();
367 int32_t callerPid = 1;
368 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, nullptr));
369
370 sessionService->GenerateFakeStreamId(callerPid);
371 AudioInterrupt fakeAudioInterrupt = sessionService->GenerateFakeAudioInterrupt(callerPid);
372 EXPECT_EQ(fakeAudioInterrupt.streamId, 0);
373
374 AudioSessionStrategy strategy;
375 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
376 audioSession->fakeStreamId_ = 1;
377 sessionService->sessionMap_[callerPid] = audioSession;
378 fakeAudioInterrupt = sessionService->GenerateFakeAudioInterrupt(callerPid);
379 EXPECT_EQ(fakeAudioInterrupt.streamId, 1);
380
381 callerPid = 2;
382 sessionService->GenerateFakeStreamId(callerPid);
383 fakeAudioInterrupt = sessionService->GenerateFakeAudioInterrupt(callerPid);
384 EXPECT_EQ(fakeAudioInterrupt.streamId, 0);
385 }
386
387 /**
388 * @tc.name : Test AudioSessionService.
389 * @tc.number: AudioSessionServiceUnitTest_017.
390 * @tc.desc : Test RemoveStreamInfo.
391 */
392 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_017, TestSize.Level1)
393 {
394 auto sessionService = std::make_shared<AudioSessionService>();
395 int32_t callerPid = 1;
396 AudioInterrupt audioInterrupt = {};
397 audioInterrupt.pid = callerPid;
398 audioInterrupt.isAudioSessionInterrupt = true;
399 EXPECT_NO_THROW(sessionService->RemoveStreamInfo(audioInterrupt));
400
401 audioInterrupt.isAudioSessionInterrupt = false;
402 AudioSessionStrategy strategy;
403 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
404 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
405 EXPECT_NO_THROW(sessionService->RemoveStreamInfo(audioInterrupt));
406
407 callerPid = 2;
408 EXPECT_NO_THROW(sessionService->RemoveStreamInfo(audioInterrupt));
409 }
410
411 /**
412 * @tc.name : Test AudioSessionService.
413 * @tc.number: AudioSessionServiceUnitTest_018.
414 * @tc.desc : Test ClearStreamInfo.
415 */
416 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_018, TestSize.Level1)
417 {
418 auto sessionService = std::make_shared<AudioSessionService>();
419 int32_t callerPid = 1;
420 EXPECT_NO_THROW(sessionService->ClearStreamInfo(callerPid));
421
422 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, nullptr));
423 EXPECT_NO_THROW(sessionService->ClearStreamInfo(callerPid));
424 }
425
426 /**
427 * @tc.name : Test AudioSessionService.
428 * @tc.number: AudioSessionServiceUnitTest_019.
429 * @tc.desc : Test SetSessionDefaultOutputDevice.
430 */
431 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_019, TestSize.Level1)
432 {
433 auto sessionService = std::make_shared<AudioSessionService>();
434 int32_t callerPid = 1;
435 DeviceType deviceType = DeviceType::DEVICE_TYPE_DEFAULT;
436 EXPECT_EQ(sessionService->SetSessionDefaultOutputDevice(callerPid, deviceType), SUCCESS);
437
438 callerPid = 2;
439 AudioSessionStrategy strategy;
440 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
441 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
442 EXPECT_EQ(sessionService->SetSessionDefaultOutputDevice(callerPid, deviceType), SUCCESS);
443
444 sessionService->sessionMap_[callerPid].reset();
445 EXPECT_EQ(sessionService->SetSessionDefaultOutputDevice(callerPid, deviceType), SUCCESS);
446 }
447
448 /**
449 * @tc.name : Test AudioSessionService.
450 * @tc.number: AudioSessionServiceUnitTest_020.
451 * @tc.desc : Test GetSessionDefaultOutputDevice.
452 */
453 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_020, TestSize.Level1)
454 {
455 auto sessionService = std::make_shared<AudioSessionService>();
456 int32_t callerPid = 1;
457 EXPECT_EQ(sessionService->GetSessionDefaultOutputDevice(callerPid), DEVICE_TYPE_INVALID);
458
459 AudioSessionStrategy strategy;
460 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
461 audioSession->defaultDeviceType_ = DEVICE_TYPE_DEFAULT;
462 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
463 EXPECT_EQ(sessionService->GetSessionDefaultOutputDevice(callerPid), DEVICE_TYPE_DEFAULT);
464
465 sessionService->sessionMap_[callerPid].reset();
466 EXPECT_EQ(sessionService->GetSessionDefaultOutputDevice(callerPid), DEVICE_TYPE_INVALID);
467 }
468
469 /**
470 * @tc.name : Test AudioSessionService.
471 * @tc.number: AudioSessionServiceUnitTest_021.
472 * @tc.desc : Test IsStreamAllowedToSetDevice.
473 */
474 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_021, TestSize.Level1)
475 {
476 auto sessionService = std::make_shared<AudioSessionService>();
477 uint32_t streamId = 1001;
478 int32_t callerPid = 1;
479 AudioSessionStrategy strategy;
480 AudioInterrupt audioInterrupt = {};
481 audioInterrupt.streamId = streamId;
482
483 std::shared_ptr<AudioSession> audioSession1 = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
484 audioSession1->streamsInSession_.push_back(audioInterrupt);
485 audioSession1->state_ == AudioSessionState::SESSION_ACTIVE;
486 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession1));
487 callerPid = 2;
488 std::shared_ptr<AudioSession> audioSession2 = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
489 audioSession2->streamsInSession_.push_back(audioInterrupt);
490 audioSession2->state_ == AudioSessionState::SESSION_NEW;
491 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession2));
492 callerPid = 3;
493 std::shared_ptr<AudioSession> audioSession3 = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
494 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession3));
495 callerPid = 4;
496 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, nullptr));
497
498 EXPECT_TRUE(sessionService->IsStreamAllowedToSetDevice(streamId));
499 }
500
501 /**
502 * @tc.name : Test AudioSessionService.
503 * @tc.number: AudioSessionServiceUnitTest_022.
504 * @tc.desc : Test IsSessionNeedToFetchOutputDevice.
505 */
506 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_022, TestSize.Level1)
507 {
508 auto sessionService = std::make_shared<AudioSessionService>();
509 int32_t callerPid = 1;
510 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, nullptr));
511 EXPECT_FALSE(sessionService->IsSessionNeedToFetchOutputDevice(callerPid));
512
513 AudioSessionStrategy strategy;
514 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
515 audioSession->needToFetch_ = true;
516 sessionService->sessionMap_[callerPid] = audioSession;
517 EXPECT_TRUE(sessionService->IsSessionNeedToFetchOutputDevice(callerPid));
518
519 callerPid = 2;
520 EXPECT_FALSE(sessionService->IsSessionNeedToFetchOutputDevice(callerPid));
521 }
522
523 /**
524 * @tc.name : Test AudioSessionService.
525 * @tc.number: AudioSessionServiceUnitTest_023.
526 * @tc.desc : Test NotifyAppStateChange.
527 */
528 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_023, TestSize.Level1)
529 {
530 auto sessionService = std::make_shared<AudioSessionService>();
531 int32_t pid = 1;
532 bool isBackState = false;
533 EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, isBackState));
534
535 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(pid, nullptr));
536 EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, isBackState));
537
538 AudioSessionStrategy strategy;
539 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(pid, strategy, nullptr);
540 audioSession->audioSessionScene_ = AudioSessionScene::INVALID;
541 sessionService->sessionMap_[pid] = audioSession;
542 EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, false));
543 EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
544
545 audioSession->audioSessionScene_ = AudioSessionScene::MEDIA;
546 EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, false));
547 EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
548 }
549
550 /**
551 * @tc.name : Test AudioSessionService.
552 * @tc.number: AudioSessionServiceUnitTest_024.
553 * @tc.desc : Test NotifyAppStateChange.
554 */
555 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_024, TestSize.Level1)
556 {
557 auto sessionService = std::make_shared<AudioSessionService>();
558 int32_t pid = 1;
559 AudioSessionStrategy strategy;
560 AudioInterrupt audioInterrupt = {};
561 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(pid, strategy, nullptr);
562 audioSession->state_ = AudioSessionState::SESSION_ACTIVE;
563 audioSession->audioSessionScene_ = AudioSessionScene::MEDIA;
564 audioSession->streamsInSession_.clear();
565 sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(pid, audioSession));
566 EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
567
568 audioSession->streamsInSession_.push_back(audioInterrupt);
569 EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
570
571 audioSession->audioSessionScene_ = AudioSessionScene::INVALID;
572 EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
573
574 audioSession->state_ = AudioSessionState::SESSION_NEW;
575 EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
576
577 audioSession->streamsInSession_.clear();
578 EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
579
580 audioSession->audioSessionScene_ = AudioSessionScene::MEDIA;
581 EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
582 }
583
584 /*
585 * @tc.name : Test RemoveStreamInfo
586 * @tc.number: RemoveStreamInfoTest
587 * @tc.desc : Test RemoveStreamInfo
588 */
589 HWTEST_F(AudioSessionServiceUnitTest, RemoveStreamInfoTest, TestSize.Level1)
590 {
591 int32_t fakePid = 123;
592 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
593 ASSERT_TRUE(sessionService != nullptr);
594 sessionService->sessionMap_.clear();
595 int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
596 EXPECT_EQ(SUCCESS, ret);
597
598 AudioInterrupt audioInterrupt = {};
599 audioInterrupt.pid = 0;
600 audioInterrupt.isAudioSessionInterrupt = true;
601 audioInterrupt.streamId = 0;
602 sessionService->RemoveStreamInfo(audioInterrupt);
603
604 audioInterrupt.isAudioSessionInterrupt = false;
605 sessionService->RemoveStreamInfo(audioInterrupt);
606
607 audioInterrupt.pid = fakePid;
608 sessionService->RemoveStreamInfo(audioInterrupt);
609 }
610
611 /**
612 * @tc.name : Test ClearStreamInfo
613 * @tc.number: ClearStreamInfoTest
614 * @tc.desc : Test ClearStreamInfo
615 */
616 HWTEST_F(AudioSessionServiceUnitTest, ClearStreamInfoTest, TestSize.Level1)
617 {
618 int32_t fakePid = 123;
619 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
620 ASSERT_TRUE(sessionService != nullptr);
621 sessionService->sessionMap_.clear();
622 int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
623 EXPECT_EQ(SUCCESS, ret);
624
625 sessionService->ClearStreamInfo(0);
626
627 sessionService->sessionMap_[0] = nullptr;
628 sessionService->ClearStreamInfo(0);
629
630 sessionService->ClearStreamInfo(fakePid);
631 }
632
633 /**
634 * @tc.name : Test SetSessionDefaultOutputDevice
635 * @tc.number: SetSessionDefaultOutputDeviceTest
636 * @tc.desc : Test SetSessionDefaultOutputDevice
637 */
638 HWTEST_F(AudioSessionServiceUnitTest, SetSessionDefaultOutputDeviceTest, TestSize.Level1)
639 {
640 int32_t fakePid = 123;
641 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
642 ASSERT_TRUE(sessionService != nullptr);
643 sessionService->sessionMap_.clear();
644 int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
645 EXPECT_EQ(SUCCESS, ret);
646
647 EXPECT_EQ(sessionService->SetSessionDefaultOutputDevice(0, DEVICE_TYPE_INVALID), ERROR_INVALID_PARAM);
648
649 sessionService->sessionMap_[1] = nullptr;
650 EXPECT_EQ(sessionService->SetSessionDefaultOutputDevice(1, DEVICE_TYPE_INVALID), ERROR_INVALID_PARAM);
651
652 EXPECT_EQ(sessionService->SetSessionDefaultOutputDevice(fakePid, DEVICE_TYPE_INVALID), ERROR_INVALID_PARAM);
653 }
654
655 /**
656 * @tc.name : Test GetSessionDefaultOutputDevice
657 * @tc.number: GetSessionDefaultOutputDeviceTest
658 * @tc.desc : Test GetSessionDefaultOutputDevice
659 */
660 HWTEST_F(AudioSessionServiceUnitTest, GetSessionDefaultOutputDeviceTest, TestSize.Level1)
661 {
662 int32_t fakePid = 100;
663 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
664 ASSERT_TRUE(sessionService != nullptr);
665 sessionService->sessionMap_.clear();
666 int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
667 EXPECT_EQ(SUCCESS, ret);
668
669 EXPECT_EQ(sessionService->GetSessionDefaultOutputDevice(0), DEVICE_TYPE_INVALID);
670
671 sessionService->sessionMap_[1] = nullptr;
672 EXPECT_EQ(sessionService->GetSessionDefaultOutputDevice(1), DEVICE_TYPE_INVALID);
673
674 EXPECT_EQ(sessionService->GetSessionDefaultOutputDevice(fakePid), DEVICE_TYPE_INVALID);
675 }
676
677 /**
678 * @tc.name : Test IsStreamAllowedToSetDevice
679 * @tc.number: IsStreamAllowedToSetDeviceTest
680 * @tc.desc : Test IsStreamAllowedToSetDevice
681 */
682 HWTEST_F(AudioSessionServiceUnitTest, IsStreamAllowedToSetDeviceTest, TestSize.Level1)
683 {
684 int32_t fakePid = 100;
685 int32_t fakeSessionId = 100;
686 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
687 ASSERT_TRUE(sessionService != nullptr);
688 sessionService->sessionMap_.clear();
689 int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
690 EXPECT_EQ(SUCCESS, ret);
691
692 EXPECT_TRUE(sessionService->IsStreamAllowedToSetDevice(0));
693
694 sessionService->sessionMap_[1] = nullptr;
695 EXPECT_TRUE(sessionService->IsStreamAllowedToSetDevice(1));
696
697 AudioInterrupt incomingInterrupt = {};
698 incomingInterrupt.streamId = fakeSessionId;
699 sessionService->sessionMap_[fakePid]->streamsInSession_.push_back(incomingInterrupt);
700 EXPECT_TRUE(sessionService->IsStreamAllowedToSetDevice(fakeSessionId));
701
702 sessionService->sessionMap_[fakePid]->state_ = AudioSessionState::SESSION_ACTIVE;
703 EXPECT_TRUE(sessionService->IsStreamAllowedToSetDevice(fakeSessionId));
704 }
705
706 /**
707 * @tc.name : Test IsSessionNeedToFetchOutputDevice
708 * @tc.number: IsSessionNeedToFetchOutputDeviceTest
709 * @tc.desc : Test IsSessionNeedToFetchOutputDevice
710 */
711 HWTEST_F(AudioSessionServiceUnitTest, IsSessionNeedToFetchOutputDeviceTest, TestSize.Level1)
712 {
713 int32_t fakePid = 100;
714 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
715 ASSERT_TRUE(sessionService != nullptr);
716 sessionService->sessionMap_.clear();
717 int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
718 EXPECT_EQ(SUCCESS, ret);
719
720 EXPECT_FALSE(sessionService->IsSessionNeedToFetchOutputDevice(0));
721
722 sessionService->sessionMap_[1] = nullptr;
723 EXPECT_FALSE(sessionService->IsSessionNeedToFetchOutputDevice(1));
724
725 EXPECT_FALSE(sessionService->IsSessionNeedToFetchOutputDevice(fakePid));
726 }
727
728 /**
729 * @tc.name : Test NotifyAppStateChange
730 * @tc.number: NotifyAppStateChangeTest
731 * @tc.desc : Test NotifyAppStateChange
732 */
733 HWTEST_F(AudioSessionServiceUnitTest, NotifyAppStateChangeTest, TestSize.Level1)
734 {
735 int32_t fakePid = 100;
736 int32_t fakeSessionId = 100;
737 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
738 ASSERT_TRUE(sessionService != nullptr);
739 sessionService->sessionMap_.clear();
740 int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
741 EXPECT_EQ(SUCCESS, ret);
742
743 sessionService->NotifyAppStateChange(0, true);
744
745 sessionService->sessionMap_[1] = nullptr;
746 sessionService->NotifyAppStateChange(1, true);
747
748 sessionService->NotifyAppStateChange(fakePid, false);
749
750 sessionService->sessionMap_[fakePid]->audioSessionScene_ = AudioSessionScene::MEDIA;
751 sessionService->NotifyAppStateChange(fakePid, false);
752
753 sessionService->sessionMap_[fakePid]->audioSessionScene_ = AudioSessionScene::INVALID;
754 sessionService->NotifyAppStateChange(fakePid, true);
755
756 sessionService->sessionMap_[fakePid]->state_ = AudioSessionState::SESSION_ACTIVE;
757 sessionService->NotifyAppStateChange(fakePid, true);
758
759 sessionService->sessionMap_[fakePid]->audioSessionScene_ = AudioSessionScene::MEDIA;
760 AudioInterrupt incomingInterrupt = {};
761 incomingInterrupt.streamId = fakeSessionId;
762 sessionService->sessionMap_[fakePid]->streamsInSession_.push_back(incomingInterrupt);
763 sessionService->NotifyAppStateChange(fakeSessionId, false);
764
765 sessionService->sessionMap_[fakePid]->streamsInSession_.clear();
766 sessionService->NotifyAppStateChange(fakeSessionId, false);
767 }
768
769 } // namespace AudioStandard
770 } // namespace OHOS
771