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_interrupt_unit_test.h"
17 using namespace testing::ext;
18
19 namespace OHOS {
20 namespace AudioStandard {
21
SetUpTestCase(void)22 void AudioInterruptServiceUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)23 void AudioInterruptServiceUnitTest::TearDownTestCase(void) {}
24
SetUp(void)25 void AudioInterruptServiceUnitTest::SetUp(void)
26 {
27 audioInterruptService_ = std::make_shared<AudioInterruptService>();
28 ASSERT_NE(audioInterruptService_, nullptr);
29 }
30
TearDown(void)31 void AudioInterruptServiceUnitTest::TearDown(void)
32 {
33 audioInterruptService_ = nullptr;
34 }
35
36 /**
37 * @tc.name : Test AudioInterruptService
38 * @tc.number: AudioInterruptService_001
39 * @tc.desc : Test SetAudioInterruptCallback
40 */
41 HWTEST(AudioInterruptServiceProUnitTest, AudioInterruptService_001, TestSize.Level1)
42 {
43 auto audioInterruptService = std::make_shared<AudioInterruptService>();
44 ASSERT_NE(audioInterruptService, nullptr);
45
46 int32_t zoneId = 0;
47 uint32_t streamId = 0;
48 uint32_t uid = 0;
49 sptr<AudioPolicyManagerListenerStubImpl> interruptListenerStub =
50 new(std::nothrow) AudioPolicyManagerListenerStubImpl();
51 sptr<IRemoteObject> object = interruptListenerStub->AsObject();
52 auto ret = audioInterruptService->SetAudioInterruptCallback(zoneId, streamId, object, uid);
53 EXPECT_EQ(ret, SUCCESS);
54 }
55
56 /**
57 * @tc.name : Test AudioInterruptService
58 * @tc.number: AudioInterruptService_002
59 * @tc.desc : Test SetAudioInterruptCallback
60 */
61 HWTEST(AudioInterruptServiceProUnitTest, AudioInterruptService_002, TestSize.Level1)
62 {
63 auto audioInterruptService = std::make_shared<AudioInterruptService>();
64 ASSERT_NE(audioInterruptService, nullptr);
65
66 int32_t zoneId = 0;
67 uint32_t streamId = 0;
68 uint32_t uid = 0;
69 sptr<AudioPolicyManagerListenerStubImpl> interruptListenerStub =
70 new(std::nothrow) AudioPolicyManagerListenerStubImpl();
71 sptr<IRemoteObject> object = interruptListenerStub->AsObject();
72
73 audioInterruptService->zonesMap_.insert({zoneId, nullptr});
74 auto ret = audioInterruptService->SetAudioInterruptCallback(zoneId, streamId, object, uid);
75 EXPECT_EQ(ret, SUCCESS);
76 }
77
78 /**
79 * @tc.name : Test AudioInterruptService
80 * @tc.number: AudioInterruptService_003
81 * @tc.desc : Test SetAudioInterruptCallback
82 */
83 HWTEST(AudioInterruptServiceProUnitTest, AudioInterruptService_003, TestSize.Level1)
84 {
85 auto audioInterruptService = std::make_shared<AudioInterruptService>();
86 ASSERT_NE(audioInterruptService, nullptr);
87
88 int32_t zoneId = 0;
89 uint32_t streamId = 0;
90 uint32_t uid = 0;
91 sptr<AudioPolicyManagerListenerStubImpl> interruptListenerStub =
92 new(std::nothrow) AudioPolicyManagerListenerStubImpl();
93 sptr<IRemoteObject> object = interruptListenerStub->AsObject();
94
95 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
96 audioInterruptService->zonesMap_.insert({zoneId, audioInterruptZone});
97 auto ret = audioInterruptService->SetAudioInterruptCallback(zoneId, streamId, object, uid);
98 EXPECT_EQ(ret, SUCCESS);
99
100 audioInterruptService->interruptClients_.insert({streamId, nullptr});
101 ret = audioInterruptService->SetAudioInterruptCallback(zoneId, streamId, object, uid);
102 EXPECT_EQ(ret, ERR_INVALID_PARAM);
103 }
104
105 /**
106 * @tc.name : Test AudioInterruptService
107 * @tc.number: AudioInterruptService_005
108 * @tc.desc : Test GetStreamTypePriority
109 */
110 HWTEST(AudioInterruptServiceProUnitTest, AudioInterruptService_005, TestSize.Level1)
111 {
112 auto audioInterruptService = std::make_shared<AudioInterruptService>();
113 ASSERT_NE(audioInterruptService, nullptr);
114
115 auto ret = audioInterruptService->GetStreamTypePriority(AudioStreamType::STREAM_VOICE_CALL);
116 EXPECT_EQ(ret, 0);
117
118 ret = audioInterruptService->GetStreamTypePriority(AudioStreamType::STREAM_APP);
119 EXPECT_EQ(ret, 100);
120 }
121
122 /**
123 * @tc.name : Test AudioInterruptService
124 * @tc.number: AudioInterruptService_006
125 * @tc.desc : Test GetStreamInFocusInternal
126 */
127 HWTEST(AudioInterruptServiceProUnitTest, AudioInterruptService_006, TestSize.Level1)
128 {
129 auto audioInterruptService = std::make_shared<AudioInterruptService>();
130 ASSERT_NE(audioInterruptService, nullptr);
131
132 int32_t uid = 0;
133 int32_t zoneId = 0;
134
135 AudioInterrupt audioInterrupt;
136 AudioFocuState audioFocuState = AudioFocuState::PAUSE;
137 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
138 std::pair<AudioInterrupt, AudioFocuState> tmpFocusInfoList = std::make_pair(audioInterrupt, audioFocuState);
139
140 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
141 audioInterruptZone->audioFocusInfoList.push_back(tmpFocusInfoList);
142
143 audioInterruptService->zonesMap_.insert({zoneId, audioInterruptZone});
144 auto ret = audioInterruptService->GetStreamInFocusInternal(uid, zoneId);
145 EXPECT_EQ(ret, STREAM_MUSIC);
146 }
147
148 /**
149 * @tc.name : Test AudioInterruptService
150 * @tc.number: AudioInterruptService_007
151 * @tc.desc : Test GetStreamInFocusInternal
152 */
153 HWTEST(AudioInterruptServiceProUnitTest, AudioInterruptService_007, TestSize.Level1)
154 {
155 auto audioInterruptService = std::make_shared<AudioInterruptService>();
156 ASSERT_NE(audioInterruptService, nullptr);
157
158 int32_t uid = 0;
159 int32_t zoneId = 0;
160
161 AudioInterrupt audioInterrupt;
162 AudioFocuState audioFocuState = AudioFocuState::ACTIVE;
163 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
164 std::pair<AudioInterrupt, AudioFocuState> tmpFocusInfoList = std::make_pair(audioInterrupt, audioFocuState);
165
166 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
167 audioInterruptZone->audioFocusInfoList.push_back(tmpFocusInfoList);
168
169 audioInterruptService->zonesMap_.insert({zoneId, audioInterruptZone});
170 auto ret = audioInterruptService->GetStreamInFocusInternal(uid, zoneId);
171 EXPECT_EQ(ret, STREAM_MUSIC);
172 }
173
174 /**
175 * @tc.name : Test AudioInterruptService
176 * @tc.number: AudioInterruptService_008
177 * @tc.desc : Test GetStreamInFocusInternal
178 */
179 HWTEST(AudioInterruptServiceProUnitTest, AudioInterruptService_008, TestSize.Level1)
180 {
181 auto audioInterruptService = std::make_shared<AudioInterruptService>();
182 ASSERT_NE(audioInterruptService, nullptr);
183
184 int32_t uid = 0;
185 int32_t zoneId = 0;
186
187 AudioInterrupt audioInterrupt;
188 AudioFocuState audioFocuState = AudioFocuState::PAUSE;
189 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
190 std::pair<AudioInterrupt, AudioFocuState> tmpFocusInfoList = std::make_pair(audioInterrupt, audioFocuState);
191
192 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
193 audioInterruptZone->audioFocusInfoList.push_back(tmpFocusInfoList);
194
195 audioInterruptService->zonesMap_.insert({zoneId, audioInterruptZone});
196 auto ret = audioInterruptService->GetStreamInFocusInternal(uid, zoneId);
197 EXPECT_EQ(ret, STREAM_MUSIC);
198 }
199
200 /**
201 * @tc.name : Test AudioInterruptService
202 * @tc.number: AudioInterruptService_009
203 * @tc.desc : Test GetStreamInFocusInternal
204 */
205 HWTEST(AudioInterruptServiceProUnitTest, AudioInterruptService_009, TestSize.Level1)
206 {
207 auto audioInterruptService = std::make_shared<AudioInterruptService>();
208 ASSERT_NE(audioInterruptService, nullptr);
209
210 int32_t uid = 1;
211 int32_t zoneId = 0;
212
213 AudioInterrupt audioInterrupt;
214 AudioFocuState audioFocuState = AudioFocuState::DUCK;
215 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
216 audioInterrupt.uid = 0;
217 std::pair<AudioInterrupt, AudioFocuState> tmpFocusInfoList = std::make_pair(audioInterrupt, audioFocuState);
218
219 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
220 audioInterruptZone->audioFocusInfoList.push_back(tmpFocusInfoList);
221
222 audioInterruptService->zonesMap_.insert({zoneId, audioInterruptZone});
223 auto ret = audioInterruptService->GetStreamInFocusInternal(uid, zoneId);
224 EXPECT_EQ(ret, STREAM_MUSIC);
225
226 uid = 0;
227 ret = audioInterruptService->GetStreamInFocusInternal(uid, zoneId);
228 EXPECT_EQ(ret, STREAM_MUSIC);
229 }
230
231 /**
232 * @tc.name : Test AudioInterruptService
233 * @tc.number: AudioInterruptService_010
234 * @tc.desc : Test GetStreamInFocusInternal
235 */
236 HWTEST(AudioInterruptServiceProUnitTest, AudioInterruptService_010, TestSize.Level1)
237 {
238 auto audioInterruptService = std::make_shared<AudioInterruptService>();
239 ASSERT_NE(audioInterruptService, nullptr);
240
241 int32_t uid = 0;
242 int32_t zoneId = 0;
243
244 AudioInterrupt audioInterrupt;
245 AudioFocuState audioFocuState = AudioFocuState::DUCK;
246 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
247 audioInterrupt.uid = 1;
248 audioInterrupt.audioFocusType.streamType = STREAM_VOICE_ASSISTANT;
249 std::pair<AudioInterrupt, AudioFocuState> tmpFocusInfoList = std::make_pair(audioInterrupt, audioFocuState);
250
251 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
252 audioInterruptZone->audioFocusInfoList.push_back(tmpFocusInfoList);
253
254 audioInterruptService->zonesMap_.insert({zoneId, audioInterruptZone});
255 auto ret = audioInterruptService->GetStreamInFocusInternal(uid, zoneId);
256 EXPECT_EQ(ret, STREAM_MUSIC);
257 }
258
259 /**
260 * @tc.name : Test AudioInterruptService
261 * @tc.number: AudioInterruptService_011
262 * @tc.desc : Test GetStreamInFocusInternal
263 */
264 HWTEST(AudioInterruptServiceProUnitTest, AudioInterruptService_011, TestSize.Level1)
265 {
266 auto audioInterruptService = std::make_shared<AudioInterruptService>();
267 ASSERT_NE(audioInterruptService, nullptr);
268
269 int32_t uid = 1;
270 int32_t zoneId = 0;
271
272 AudioInterrupt audioInterrupt;
273 AudioFocuState audioFocuState = AudioFocuState::DUCK;
274 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
275 audioInterrupt.uid = 1;
276 audioInterrupt.audioFocusType.streamType = STREAM_MEDIA;
277 std::pair<AudioInterrupt, AudioFocuState> tmpFocusInfoList = std::make_pair(audioInterrupt, audioFocuState);
278
279 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
280 audioInterruptZone->audioFocusInfoList.push_back(tmpFocusInfoList);
281
282 audioInterruptService->zonesMap_.insert({zoneId, audioInterruptZone});
283 auto ret = audioInterruptService->GetStreamInFocusInternal(uid, zoneId);
284 EXPECT_EQ(ret, STREAM_MUSIC);
285 }
286
287 /**
288 * @tc.name : Test AudioInterruptService
289 * @tc.number: AudioInterruptService_012
290 * @tc.desc : Test GetSessionInfoInFocus
291 */
292 HWTEST(AudioInterruptServiceProUnitTest, AudioInterruptService_012, TestSize.Level1)
293 {
294 auto audioInterruptService = std::make_shared<AudioInterruptService>();
295 ASSERT_NE(audioInterruptService, nullptr);
296
297 int32_t zoneId = 0;
298 AudioInterrupt audioInterrupt;
299 AudioFocuState audioFocuState = AudioFocuState::DUCK;
300 std::pair<AudioInterrupt, AudioFocuState> tmpFocusInfoList = std::make_pair(audioInterrupt, audioFocuState);
301
302 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
303 audioInterruptZone->audioFocusInfoList.push_back(tmpFocusInfoList);
304
305 audioInterruptService->zonesMap_.insert({zoneId, audioInterruptZone});
306 auto ret = audioInterruptService->GetSessionInfoInFocus(audioInterrupt, zoneId);
307 EXPECT_EQ(ret, SUCCESS);
308 }
309
310 /**
311 * @tc.name : Test AudioInterruptService
312 * @tc.number: AudioInterruptService_013
313 * @tc.desc : Test GetSessionInfoInFocus
314 */
315 HWTEST(AudioInterruptServiceProUnitTest, AudioInterruptService_013, TestSize.Level1)
316 {
317 auto audioInterruptService = std::make_shared<AudioInterruptService>();
318 ASSERT_NE(audioInterruptService, nullptr);
319
320 int32_t zoneId = 0;
321 AudioInterrupt audioInterrupt;
322 AudioFocuState audioFocuState = AudioFocuState::ACTIVE;
323 std::pair<AudioInterrupt, AudioFocuState> tmpFocusInfoList = std::make_pair(audioInterrupt, audioFocuState);
324
325 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
326 audioInterruptZone->audioFocusInfoList.push_back(tmpFocusInfoList);
327
328 audioInterruptService->zonesMap_.insert({zoneId, audioInterruptZone});
329 auto ret = audioInterruptService->GetSessionInfoInFocus(audioInterrupt, zoneId);
330 EXPECT_EQ(ret, SUCCESS);
331 }
332
333 /**
334 * @tc.name : Test AudioInterruptService
335 * @tc.number: IsSessionNeedToFetchOutputDevice_001
336 * @tc.desc : Test IsSessionNeedToFetchOutputDevice sessionService_ != nullptr
337 */
338 HWTEST_F(AudioInterruptServiceUnitTest, IsSessionNeedToFetchOutputDevice_001, TestSize.Level4)
339 {
340 audioInterruptService_->sessionService_ = std::make_shared<AudioSessionService>();
341 int32_t callerPid = 1001;
342 bool ret = audioInterruptService_->IsSessionNeedToFetchOutputDevice(callerPid);
343 EXPECT_FALSE(ret);
344 }
345
346 /**
347 * @tc.name : Test AudioInterruptService
348 * @tc.number: DeactivateAudioSessionFakeInterrupt_001
349 * @tc.desc : Test DeactivateAudioSessionFakeInterrupt iter != audioFocusInfoList.end()
350 */
351 HWTEST_F(AudioInterruptServiceUnitTest, DeactivateAudioSessionFakeInterrupt_001, TestSize.Level4)
352 {
353 int32_t zoneId = 1;
354 const int32_t callerPid = 1001;
355 bool isSessionTimeout = false;
356 std::shared_ptr<AudioInterruptZone> zone = std::make_shared<AudioInterruptZone>();
357 AudioInterrupt audioInterrupt;
358 audioInterrupt.pid = callerPid;
359 audioInterrupt.isAudioSessionInterrupt = true;
360 zone->audioFocusInfoList.push_back(
361 std::make_pair(audioInterrupt, AudioFocuState::ACTIVE));
362 audioInterruptService_->zonesMap_[zoneId] = zone;
363 EXPECT_NO_THROW(
364 audioInterruptService_->DeactivateAudioSessionFakeInterrupt(zoneId, callerPid, isSessionTimeout));
365 }
366
367 /**
368 * @tc.name : Test AudioInterruptService
369 * @tc.number: CanMixForSession_001
370 * @tc.desc : Test CanMixForSession IsCanMixInterrupt(incomingInterrupt, activeInterrupt) == false
371 */
372 HWTEST_F(AudioInterruptServiceUnitTest, CanMixForSession_001, TestSize.Level4)
373 {
374 AudioInterrupt incomingInterrupt;
375 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
376 AudioInterrupt activeInterrupt;
377 activeInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
378 AudioFocusEntry focusEntry;
379 focusEntry.isReject = false;
380 EXPECT_FALSE(audioInterruptService_->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry));
381 }
382
383 /**
384 * @tc.name : Test AudioInterruptService
385 * @tc.number: CanMixForSession_002
386 * @tc.desc : Test CanMixForSession incomingInterrupt.audioFocusType.streamType == STREAM_INTERNAL_FORCE_STOP ||
387 * activeInterrupt.audioFocusType.streamType == STREAM_INTERNAL_FORCE_STOP
388 */
389 HWTEST_F(AudioInterruptServiceUnitTest, CanMixForSession_002, TestSize.Level4)
390 {
391 AudioInterrupt incomingInterrupt;
392 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
393 incomingInterrupt.audioFocusType.streamType = STREAM_INTERNAL_FORCE_STOP;
394 AudioInterrupt activeInterrupt;
395 activeInterrupt.audioFocusType.streamType = STREAM_DEFAULT;
396 AudioFocusEntry focusEntry;
397 focusEntry.isReject = false;
398 EXPECT_FALSE(audioInterruptService_->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry));
399
400 activeInterrupt.audioFocusType.streamType = STREAM_INTERNAL_FORCE_STOP;
401 EXPECT_FALSE(audioInterruptService_->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry));
402 }
403
404 /**
405 * @tc.name : Test AudioInterruptService
406 * @tc.number: CanMixForIncomingSession_001
407 * @tc.desc : Test CanMixForIncomingSession concurrencyMode == AudioConcurrencyMode::SILENT ||
408 * concurrencyMode == AudioConcurrencyMode::MIX_WITH_OTHERS
409 */
410 HWTEST_F(AudioInterruptServiceUnitTest, CanMixForIncomingSession_001, TestSize.Level4)
411 {
412 AudioInterrupt incomingInterrupt;
413 incomingInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::SILENT;
414 AudioInterrupt activeInterrupt;
415 AudioFocusEntry focusEntry;
416 EXPECT_TRUE(audioInterruptService_->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry));
417
418 incomingInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
419 EXPECT_TRUE(audioInterruptService_->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry));
420 }
421
422 /**
423 * @tc.name : Test AudioInterruptService
424 * @tc.number: CanMixForActiveSession_001
425 * @tc.desc : Test CanMixForActiveSession IsIncomingStreamLowPriority(focusEntry) == true
426 */
427 HWTEST_F(AudioInterruptServiceUnitTest, CanMixForActiveSession_001, TestSize.Level4)
428 {
429 int32_t callerPid = 1001;
430 AudioInterrupt incomingInterrupt;
431 AudioInterrupt activeInterrupt;
432 AudioFocusEntry focusEntry;
433 focusEntry.actionOn = CURRENT;
434 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
435 audioInterruptService_->sessionService_ = std::make_shared<AudioSessionService>();
436 AudioSessionStrategy strategy;
437 strategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
438 std::shared_ptr<AudioSession> session = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
439 session->state_ = AudioSessionState::SESSION_ACTIVE;
440 audioInterruptService_->sessionService_->sessionMap_[callerPid] = session;
441 EXPECT_FALSE(audioInterruptService_->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry));
442 }
443
444 /**
445 * @tc.name : Test AudioInterruptService
446 * @tc.number: CanMixForActiveSession_002
447 * @tc.desc : Test CanMixForActiveSession concurrencyMode == AudioConcurrencyMode::SILENT ||
448 * concurrencyMode == AudioConcurrencyMode::MIX_WITH_OTHERS
449 */
450 HWTEST_F(AudioInterruptServiceUnitTest, CanMixForActiveSession_002, TestSize.Level4)
451 {
452 AudioInterrupt incomingInterrupt;
453 AudioInterrupt activeInterrupt;
454 activeInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::SILENT;
455 AudioFocusEntry focusEntry;
456 audioInterruptService_->sessionService_.reset();
457 EXPECT_TRUE(audioInterruptService_->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry));
458
459 activeInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
460 EXPECT_TRUE(audioInterruptService_->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry));
461 }
462
463 /**
464 * @tc.name : Test AudioInterruptService
465 * @tc.number: UnsetAudioInterruptCallback_001
466 * @tc.desc : Test UnsetAudioInterruptCallback interruptClients_.erase(streamId) == 0
467 */
468 HWTEST_F(AudioInterruptServiceUnitTest, UnsetAudioInterruptCallback_001, TestSize.Level4)
469 {
470 int32_t zoneId = 1;
471 uint32_t streamId = 1;
472 audioInterruptService_->interruptClients_.clear();
473 EXPECT_EQ(audioInterruptService_->UnsetAudioInterruptCallback(zoneId, streamId), ERR_INVALID_PARAM);
474 }
475
476 /**
477 * @tc.name : Test AudioInterruptService
478 * @tc.number: DeactivateAudioInterrupt_001
479 * @tc.desc : Test DeactivateAudioInterrupt HasAudioSessionFakeInterrupt(zoneId, currAudioInterrupt.pid) == true
480 */
481 HWTEST_F(AudioInterruptServiceUnitTest, DeactivateAudioInterrupt_001, TestSize.Level4)
482 {
483 int32_t zoneId = 1;
484 AudioInterrupt audioInterrupt;
485 audioInterrupt.pid = 1;
486 audioInterrupt.isAudioSessionInterrupt = true;
487 std::shared_ptr<AudioInterruptZone> zone = std::make_shared<AudioInterruptZone>();
488 zone->audioFocusInfoList.push_back(
489 std::make_pair(audioInterrupt, AudioFocuState::ACTIVE));
490 audioInterruptService_->zonesMap_[zoneId] = zone;
491 EXPECT_EQ(audioInterruptService_->DeactivateAudioInterrupt(zoneId, audioInterrupt), SUCCESS);
492 }
493
494 /**
495 * @tc.name : Test AudioInterruptService
496 * @tc.number: GetSessionInfoInFocus_001
497 * @tc.desc : Test GetSessionInfoInFocus iter->second == ACTIVE
498 */
499 HWTEST_F(AudioInterruptServiceUnitTest, GetSessionInfoInFocus_001, TestSize.Level4)
500 {
501 AudioInterrupt audioInterrupt;
502 int32_t zoneId = 1;
503 std::shared_ptr<AudioInterruptZone> zone = std::make_shared<AudioInterruptZone>();
504 zone->audioFocusInfoList.push_back(std::make_pair(audioInterrupt, AudioFocuState::ACTIVE));
505 zone->audioFocusInfoList.push_back(std::make_pair(audioInterrupt, AudioFocuState::MUTED));
506 audioInterruptService_->zonesMap_[zoneId] = zone;
507 EXPECT_EQ(audioInterruptService_->GetSessionInfoInFocus(audioInterrupt, zoneId), SUCCESS);
508 }
509
510 /**
511 * @tc.name : Test AudioInterruptService
512 * @tc.number: ProcessRemoteInterrupt_001
513 * @tc.desc : Test ProcessRemoteInterrupt targetZoneIt == zonesMap_.end()
514 */
515 HWTEST_F(AudioInterruptServiceUnitTest, ProcessRemoteInterrupt_001, TestSize.Level4)
516 {
517 std::set<int32_t> streamIds;
518 InterruptEventInternal interruptEvent;
519 int32_t zoneMapId = 0;
520 std::shared_ptr<AudioInterruptZone> zone = std::make_shared<AudioInterruptZone>();
521 AudioInterrupt audioInterrupt;
522 audioInterrupt.streamId = 1;
523 zone->zoneId = 1;
524 zone->audioFocusInfoList.push_back(std::make_pair(audioInterrupt, AudioFocuState::ACTIVE));
525 audioInterruptService_->zonesMap_[zoneMapId] = zone;
526 streamIds.insert(audioInterrupt.streamId);
527
528 interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
529 audioInterruptService_->ProcessRemoteInterrupt(streamIds, interruptEvent);
530
531 interruptEvent.hintType = INTERRUPT_HINT_STOP;
532 audioInterruptService_->ProcessRemoteInterrupt(streamIds, interruptEvent);
533
534 interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
535 audioInterruptService_->ProcessRemoteInterrupt(streamIds, interruptEvent);
536 EXPECT_EQ(zone->zoneId, 0);
537 }
538
539 /**
540 * @tc.name : Test AudioInterruptService
541 * @tc.number: WriteSessionTimeoutDfxEvent_001
542 * @tc.desc : Test itZone->second == nullptr
543 */
544 HWTEST_F(AudioInterruptServiceUnitTest, WriteSessionTimeoutDfxEvent_001, TestSize.Level4)
545 {
546 int32_t pid = 0;
547 audioInterruptService_->dfxCollector_ = std::make_unique<AudioInterruptDfxCollector>();
548
549 audioInterruptService_->zonesMap_.clear();
550 audioInterruptService_->zonesMap_.insert({0, nullptr});
551
552 audioInterruptService_->WriteSessionTimeoutDfxEvent(pid);
553 EXPECT_EQ(audioInterruptService_->zonesMap_.size(), 1);
554 }
555
556 /**
557 * @tc.name : Test AudioInterruptService
558 * @tc.number: WriteSessionTimeoutDfxEvent_002
559 * @tc.desc : Test iter == audioFocusInfoList.end()
560 */
561 HWTEST_F(AudioInterruptServiceUnitTest, WriteSessionTimeoutDfxEvent_002, TestSize.Level4)
562 {
563 int32_t pid = 1;
564 audioInterruptService_->dfxCollector_ = std::make_unique<AudioInterruptDfxCollector>();
565 ASSERT_NE(audioInterruptService_->dfxCollector_, nullptr);
566
567 audioInterruptService_->zonesMap_.clear();
568
569 auto zone1 = std::make_shared<AudioInterruptZone>();
570 ASSERT_NE(zone1, nullptr);
571
572 AudioInterrupt audioInterrupt;
573 audioInterrupt.pid = pid;
574 AudioFocuState audioFocuState = ACTIVE;
575 zone1->audioFocusInfoList.push_back({audioInterrupt, audioFocuState});
576
577 audioInterruptService_->zonesMap_.insert({0, zone1});
578
579 audioInterruptService_->WriteSessionTimeoutDfxEvent(pid);
580 EXPECT_EQ(audioInterruptService_->zonesMap_.size(), 1);
581 }
582
583 /**
584 * @tc.name : Test AudioInterruptService
585 * @tc.number: WriteStartDfxMsg_001
586 * @tc.desc : Test audioInterrupt.state == State::PREPARED
587 */
588 HWTEST_F(AudioInterruptServiceUnitTest, WriteStartDfxMsg_001, TestSize.Level4)
589 {
590 audioInterruptService_->dfxCollector_ = std::make_unique<AudioInterruptDfxCollector>();
591 ASSERT_NE(audioInterruptService_->dfxCollector_, nullptr);
592
593 audioInterruptService_->sessionService_ = std::make_shared<AudioSessionService>();
594 ASSERT_NE(audioInterruptService_->sessionService_, nullptr);
595
596 InterruptDfxBuilder dfxBuilder;
597 AudioInterrupt audioInterrupt;
598 audioInterrupt.state = State::PREPARED;
599 audioInterruptService_->WriteStartDfxMsg(dfxBuilder, audioInterrupt);
600 EXPECT_EQ(audioInterruptService_->zonesMap_.size(), 0);
601 }
602
603 /**
604 * @tc.name : Test AudioInterruptService
605 * @tc.number: GetAppState_001
606 * @tc.desc : Test state != 0
607 */
608 HWTEST_F(AudioInterruptServiceUnitTest, GetAppState_001, TestSize.Level4)
609 {
610 OHOS::AppExecFwk::AppMgrClient appManager;
611 int32_t appPid = 0;
612 std::vector<AppExecFwk::RunningProcessInfo> info;
613 appManager.GetAllRunningProcesses(info);
614 if (!info.empty()) {
615 appPid = info[0].pid_;
616 }
617 std::vector<int32_t> pids;
618 pids.push_back (appPid);
619 appManager.KillProcessesByPids(pids);
620
621 audioInterruptService_->GetAppState(appPid);
622 EXPECT_TRUE(audioInterruptService_->GetAppState(appPid) != 0);
623 }
624
625 /**
626 * @tc.name : Test AudioInterruptService
627 * @tc.number: RemoveClient_004
628 * @tc.desc : Test it->second->interruptCbsMap.find(streamId) != it->second->interruptCbsMap.end()
629 */
630 HWTEST_F(AudioInterruptServiceUnitTest, RemoveClient_004, TestSize.Level4)
631 {
632 int32_t zoneId = 0;
633 uint32_t streamId = 0;
634 audioInterruptService_->zonesMap_.clear();
635 auto zone1 = std::make_shared<AudioInterruptZone>();
636 ASSERT_NE(zone1, nullptr);
637
638 AudioInterrupt audioInterrupt;
639 audioInterrupt.streamId = streamId;
640 AudioFocuState audioFocuState = ACTIVE;
641 zone1->audioFocusInfoList.push_back({audioInterrupt, audioFocuState});
642
643 zone1->interruptCbsMap.insert({streamId, nullptr});
644 audioInterruptService_->zonesMap_.insert({zoneId, zone1});
645
646 audioInterruptService_->RemoveClient(zoneId, streamId);
647 EXPECT_EQ(audioInterruptService_->zonesMap_.size(), 1);
648 }
649
650 /**
651 * @tc.name : Test AudioInterruptService
652 * @tc.number: ShouldCallbackToClient_001
653 * @tc.desc : Test clientType != CLIENT_TYPE_GAME
654 */
655 HWTEST_F(AudioInterruptServiceUnitTest, ShouldCallbackToClient_001, TestSize.Level4)
656 {
657 uint32_t uid = 0;
658 int32_t streamId = 0;
659 InterruptEventInternal interruptEvent;
660
661 ClientTypeManager::GetInstance()->clientTypeMap_.clear();
662
663 EXPECT_EQ(audioInterruptService_->ShouldCallbackToClient(uid, streamId, interruptEvent), true);
664 }
665
666 /**
667 * @tc.name : Test AudioInterruptService
668 * @tc.number: ShouldCallbackToClient_002
669 * @tc.desc : Test interruptEvent.hintType == INTERRUPT_HINT_DUCK
670 */
671 HWTEST_F(AudioInterruptServiceUnitTest, ShouldCallbackToClient_002, TestSize.Level4)
672 {
673 uint32_t uid = 0;
674 int32_t streamId = 0;
675 InterruptEventInternal interruptEvent;
676 interruptEvent.hintType = INTERRUPT_HINT_DUCK;
677
678 ClientTypeManager::GetInstance()->clientTypeMap_.clear();
679 ClientTypeManager::GetInstance()->OnClientTypeQueryCompleted(uid, ClientType::CLIENT_TYPE_GAME);
680 EXPECT_EQ(audioInterruptService_->ShouldCallbackToClient(uid, streamId, interruptEvent), true);
681 EXPECT_EQ(interruptEvent.callbackToApp, false);
682 }
683
684 /**
685 * @tc.name : Test AudioInterruptService
686 * @tc.number: ShouldCallbackToClient_003
687 * @tc.desc : Test interruptEvent.hintType == INTERRUPT_HINT_UNDUCK
688 */
689 HWTEST_F(AudioInterruptServiceUnitTest, ShouldCallbackToClient_003, TestSize.Level4)
690 {
691 uint32_t uid = 0;
692 int32_t streamId = 0;
693 InterruptEventInternal interruptEvent;
694 interruptEvent.hintType = INTERRUPT_HINT_UNDUCK;
695
696 ClientTypeManager::GetInstance()->clientTypeMap_.clear();
697 ClientTypeManager::GetInstance()->OnClientTypeQueryCompleted(uid, ClientType::CLIENT_TYPE_GAME);
698 EXPECT_EQ(audioInterruptService_->ShouldCallbackToClient(uid, streamId, interruptEvent), true);
699 EXPECT_EQ(interruptEvent.callbackToApp, false);
700 }
701
702 /**
703 * @tc.name : Test AudioInterruptService
704 * @tc.number: ShouldCallbackToClient_004
705 * @tc.desc : Test interruptEvent.hintType = INTERRUPT_HINT_RESUME
706 */
707 HWTEST_F(AudioInterruptServiceUnitTest, ShouldCallbackToClient_004, TestSize.Level4)
708 {
709 uint32_t uid = 0;
710 int32_t streamId = 0;
711 InterruptEventInternal interruptEvent;
712 interruptEvent.hintType = INTERRUPT_HINT_RESUME;
713
714 ClientTypeManager::GetInstance()->clientTypeMap_.clear();
715 ClientTypeManager::GetInstance()->OnClientTypeQueryCompleted(uid, ClientType::CLIENT_TYPE_GAME);
716
717 audioInterruptService_->policyServer_ = new AudioPolicyServer(0);
718 ASSERT_NE(audioInterruptService_->policyServer_, nullptr);
719
720 EXPECT_EQ(audioInterruptService_->ShouldCallbackToClient(uid, streamId, interruptEvent), false);
721 }
722
723 /**
724 * @tc.name : Test AudioInterruptService
725 * @tc.number: ShouldCallbackToClient_005
726 * @tc.desc : Test interruptEvent.hintType = INTERRUPT_HINT_PAUSE
727 */
728 HWTEST_F(AudioInterruptServiceUnitTest, ShouldCallbackToClient_005, TestSize.Level4)
729 {
730 uint32_t uid = 0;
731 int32_t streamId = 0;
732 InterruptEventInternal interruptEvent;
733 interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
734
735 ClientTypeManager::GetInstance()->clientTypeMap_.clear();
736 ClientTypeManager::GetInstance()->OnClientTypeQueryCompleted(uid, ClientType::CLIENT_TYPE_GAME);
737 audioInterruptService_->policyServer_ = new AudioPolicyServer(0);
738 ASSERT_NE(audioInterruptService_->policyServer_, nullptr);
739
740 EXPECT_EQ(audioInterruptService_->ShouldCallbackToClient(uid, streamId, interruptEvent), false);
741 }
742
743 /**
744 * @tc.name : Test AudioInterruptService
745 * @tc.number: ShouldCallbackToClient_006
746 * @tc.desc : Test interruptEvent.hintType = INTERRUPT_HINT_STOP
747 */
748 HWTEST_F(AudioInterruptServiceUnitTest, ShouldCallbackToClient_006, TestSize.Level4)
749 {
750 uint32_t uid = 0;
751 int32_t streamId = 0;
752 InterruptEventInternal interruptEvent;
753 interruptEvent.hintType = INTERRUPT_HINT_STOP;
754
755 ClientTypeManager::GetInstance()->clientTypeMap_.clear();
756 ClientTypeManager::GetInstance()->OnClientTypeQueryCompleted(uid, ClientType::CLIENT_TYPE_GAME);
757 audioInterruptService_->policyServer_ = new AudioPolicyServer(0);
758 ASSERT_NE(audioInterruptService_->policyServer_, nullptr);
759
760 EXPECT_EQ(audioInterruptService_->ShouldCallbackToClient(uid, streamId, interruptEvent), false);
761 }
762
763 /**
764 * @tc.name : Test AudioInterruptService
765 * @tc.number: ShouldCallbackToClient_007
766 * @tc.desc : Test interruptEvent.hintType = INTERRUPT_HINT_NONE
767 */
768 HWTEST_F(AudioInterruptServiceUnitTest, ShouldCallbackToClient_007, TestSize.Level4)
769 {
770 uint32_t uid = 0;
771 int32_t streamId = 0;
772 InterruptEventInternal interruptEvent;
773 interruptEvent.hintType = INTERRUPT_HINT_NONE;
774
775 ClientTypeManager::GetInstance()->clientTypeMap_.clear();
776 ClientTypeManager::GetInstance()->OnClientTypeQueryCompleted(uid, ClientType::CLIENT_TYPE_GAME);
777
778 EXPECT_EQ(audioInterruptService_->ShouldCallbackToClient(uid, streamId, interruptEvent), false);
779 }
780 } // namespace AudioStandard
781 } // namespace OHOS