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) {}
SetUp(void)24 void AudioInterruptServiceUnitTest::SetUp(void) {}
TearDown(void)25 void AudioInterruptServiceUnitTest::TearDown(void) {}
26
27 class RemoteObjectTestStub : public IRemoteObject {
28 public:
RemoteObjectTestStub()29 RemoteObjectTestStub() : IRemoteObject(u"IRemoteObject") {}
GetObjectRefCount()30 int32_t GetObjectRefCount() { return 0; };
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)31 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; };
AddDeathRecipient(const sptr<DeathRecipient> & recipient)32 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)33 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
Dump(int fd,const std::vector<std::u16string> & args)34 int Dump(int fd, const std::vector<std::u16string> &args) { return 0; };
35
36 DECLARE_INTERFACE_DESCRIPTOR(u"RemoteObjectTestStub");
37 };
38
39 class AudioInterruptCallbackTest : public AudioInterruptCallback {
40 public:
OnInterrupt(const InterruptEventInternal & interruptEvent)41 void OnInterrupt(const InterruptEventInternal &interruptEvent) override {};
42 };
43
44 /**
45 * @tc.name : Test AudioInterruptService
46 * @tc.number: AudioInterruptService_001
47 * @tc.desc : Test AudioInterruptService
48 */
49 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_001, TestSize.Level1)
50 {
51 auto audioInterruptService = std::make_shared<AudioInterruptService>();
52 ASSERT_NE(audioInterruptService, nullptr);
53
54 std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
55 AudioInterrupt audioInterrupt;
56 AudioFocuState audioFocuState = AudioFocuState::ACTIVE;
57 tmpFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
58
59 InterruptEventInternal interruptEvent;
60 interruptEvent.hintType = INTERRUPT_HINT_STOP;
61 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = tmpFocusInfoList.begin();
62
63 bool ret = audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
64 EXPECT_TRUE(ret);
65 }
66
67 /**
68 * @tc.name : Test AudioInterruptService
69 * @tc.number: AudioInterruptService_002
70 * @tc.desc : Test AudioInterruptService
71 */
72 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_002, TestSize.Level1)
73 {
74 auto audioInterruptService = std::make_shared<AudioInterruptService>();
75 ASSERT_NE(audioInterruptService, nullptr);
76
77 std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
78 AudioInterrupt audioInterrupt;
79 AudioFocuState audioFocuState = AudioFocuState::ACTIVE;
80 tmpFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
81
82 InterruptEventInternal interruptEvent;
83 interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
84 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = tmpFocusInfoList.begin();
85
86 audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
87 EXPECT_EQ(iterActive->second, PAUSEDBYREMOTE);
88 }
89
90 /**
91 * @tc.name : Test AudioInterruptService
92 * @tc.number: AudioInterruptService_003
93 * @tc.desc : Test AudioInterruptService
94 */
95 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_003, TestSize.Level1)
96 {
97 auto audioInterruptService = std::make_shared<AudioInterruptService>();
98 ASSERT_NE(audioInterruptService, nullptr);
99
100 std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
101 AudioInterrupt audioInterrupt;
102 AudioFocuState audioFocuState = AudioFocuState::DUCK;
103 tmpFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
104
105 InterruptEventInternal interruptEvent;
106 interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
107 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = tmpFocusInfoList.begin();
108
109 audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
110 EXPECT_EQ(iterActive->second, PAUSEDBYREMOTE);
111 }
112
113 /**
114 * @tc.name : Test AudioInterruptService
115 * @tc.number: AudioInterruptService_004
116 * @tc.desc : Test AudioInterruptService
117 */
118 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_004, TestSize.Level1)
119 {
120 auto audioInterruptService = std::make_shared<AudioInterruptService>();
121 ASSERT_NE(audioInterruptService, nullptr);
122
123 std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
124 AudioInterrupt audioInterrupt;
125 AudioFocuState audioFocuState = AudioFocuState::STOP;
126 tmpFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
127
128 InterruptEventInternal interruptEvent;
129 interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
130 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = tmpFocusInfoList.begin();
131
132 audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
133 EXPECT_EQ(iterActive->second, STOP);
134 }
135
136 /**
137 * @tc.name : Test AudioInterruptService
138 * @tc.number: AudioInterruptService_005
139 * @tc.desc : Test AudioInterruptService
140 */
141 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_005, TestSize.Level1)
142 {
143 auto audioInterruptService = std::make_shared<AudioInterruptService>();
144 ASSERT_NE(audioInterruptService, nullptr);
145
146 std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
147 AudioInterrupt audioInterrupt;
148 AudioFocuState audioFocuState = AudioFocuState::PAUSEDBYREMOTE;
149 tmpFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
150
151 InterruptEventInternal interruptEvent;
152 interruptEvent.hintType = INTERRUPT_HINT_RESUME;
153 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = tmpFocusInfoList.begin();
154
155 bool ret = audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
156 EXPECT_TRUE(ret);
157 }
158
159 /**
160 * @tc.name : Test AudioInterruptService
161 * @tc.number: AudioInterruptService_006
162 * @tc.desc : Test AudioInterruptService
163 */
164 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_006, TestSize.Level1)
165 {
166 auto audioInterruptService = std::make_shared<AudioInterruptService>();
167 ASSERT_NE(audioInterruptService, nullptr);
168
169 std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
170 AudioInterrupt audioInterrupt;
171 AudioFocuState audioFocuState = AudioFocuState::STOP;
172 tmpFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
173
174 InterruptEventInternal interruptEvent;
175 interruptEvent.hintType = INTERRUPT_HINT_RESUME;
176 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = tmpFocusInfoList.begin();
177
178 audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
179 EXPECT_EQ(iterActive, tmpFocusInfoList.begin());
180 }
181
182 /**
183 * @tc.name : Test AudioInterruptService
184 * @tc.number: AudioInterruptService_007
185 * @tc.desc : Test AudioInterruptService
186 */
187 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_007, TestSize.Level1)
188 {
189 auto audioInterruptService = std::make_shared<AudioInterruptService>();
190 ASSERT_NE(audioInterruptService, nullptr);
191
192 std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
193 AudioInterrupt audioInterrupt;
194 AudioFocuState audioFocuState = AudioFocuState::STOP;
195 tmpFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
196
197 InterruptEventInternal interruptEvent;
198 interruptEvent.hintType = INTERRUPT_HINT_NONE;
199 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = tmpFocusInfoList.begin();
200
201 audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
202 EXPECT_EQ(iterActive, tmpFocusInfoList.begin());
203 }
204
205 /**
206 * @tc.name : Test AudioInterruptService
207 * @tc.number: AudioInterruptService_008
208 * @tc.desc : Test AudioInterruptService
209 */
210 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_008, TestSize.Level1)
211 {
212 auto audioInterruptService = std::make_shared<AudioInterruptService>();
213 ASSERT_NE(audioInterruptService, nullptr);
214
215 audioInterruptService->dfxCollector_ = std::make_unique<AudioInterruptDfxCollector>();
216 ASSERT_NE(audioInterruptService->dfxCollector_, nullptr);
217 std::shared_ptr<AudioInterruptZone> audioInterruptZone = nullptr;
218 audioInterruptService->zonesMap_.insert({0, audioInterruptZone});
219 int32_t pid = 0;
220
221 audioInterruptService->WriteSessionTimeoutDfxEvent(pid);
222 EXPECT_EQ(audioInterruptService->zonesMap_.size(), 1);
223 }
224
225 /**
226 * @tc.name : Test AudioInterruptService
227 * @tc.number: AudioInterruptService_009
228 * @tc.desc : Test AudioInterruptService
229 */
230 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_009, TestSize.Level1)
231 {
232 auto audioInterruptService = std::make_shared<AudioInterruptService>();
233 ASSERT_NE(audioInterruptService, nullptr);
234
235 audioInterruptService->dfxCollector_ = std::make_unique<AudioInterruptDfxCollector>();
236 ASSERT_NE(audioInterruptService->dfxCollector_, nullptr);
237 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
238 AudioInterrupt audioInterrupt;
239 audioInterrupt.pid = 5;
240 AudioFocuState audioFocuState;
241 audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
242 audioInterruptService->zonesMap_.insert({0, audioInterruptZone});
243 int32_t pid = 5;
244
245 audioInterruptService->WriteSessionTimeoutDfxEvent(pid);
246 EXPECT_EQ(audioInterruptService->zonesMap_.size(), 1);
247 }
248
249 /**
250 * @tc.name : Test AudioInterruptService
251 * @tc.number: AudioInterruptService_010
252 * @tc.desc : Test AudioInterruptService
253 */
254 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_010, TestSize.Level1)
255 {
256 auto audioInterruptService = std::make_shared<AudioInterruptService>();
257 ASSERT_NE(audioInterruptService, nullptr);
258
259 AudioInterrupt audioInterrupt;
260 audioInterrupt.pid = 5;
261 audioInterrupt.streamId = 1;
262
263 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
264 AudioInterrupt interrupt;
265 interrupt.pid = 5;
266 interrupt.audioFocusType.streamType = STREAM_VOICE_COMMUNICATION;
267 interrupt.streamId = 0;
268
269 AudioFocuState focusState;
270 focusState = PLACEHOLDER;
271 audioFocusInfoList.emplace_back(interrupt, focusState);
272
273 auto ret = audioInterruptService->HadVoipStatus(audioInterrupt, audioFocusInfoList);
274 EXPECT_EQ(ret, true);
275 }
276
277 /**
278 * @tc.name : Test AudioInterruptService
279 * @tc.number: AudioInterruptService_011
280 * @tc.desc : Test AudioInterruptService
281 */
282 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_011, TestSize.Level1)
283 {
284 auto audioInterruptService = std::make_shared<AudioInterruptService>();
285 ASSERT_NE(audioInterruptService, nullptr);
286
287 AudioInterrupt audioInterrupt;
288 audioInterrupt.pid = 5;
289 audioInterrupt.streamId = 1;
290
291 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
292 AudioInterrupt interrupt;
293 interrupt.pid = 5;
294 interrupt.audioFocusType.streamType = STREAM_VOICE_COMMUNICATION;
295 interrupt.streamId = 1;
296
297 AudioFocuState focusState;
298 focusState = PLACEHOLDER;
299 audioFocusInfoList.emplace_back(interrupt, focusState);
300
301 auto ret = audioInterruptService->HadVoipStatus(audioInterrupt, audioFocusInfoList);
302 EXPECT_EQ(ret, false);
303 }
304
305 /**
306 * @tc.name : Test AudioInterruptService
307 * @tc.number: AudioInterruptService_012
308 * @tc.desc : Test AudioInterruptService
309 */
310 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_012, TestSize.Level1)
311 {
312 auto audioInterruptService = std::make_shared<AudioInterruptService>();
313 ASSERT_NE(audioInterruptService, nullptr);
314
315 AudioInterrupt audioInterrupt;
316 audioInterrupt.pid = 5;
317 audioInterrupt.streamId = 1;
318
319 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
320 AudioInterrupt interrupt;
321 interrupt.pid = 5;
322 interrupt.audioFocusType.streamType = STREAM_VOICE_RING;
323 interrupt.streamId = 1;
324
325 AudioFocuState focusState;
326 focusState = PLACEHOLDER;
327 audioFocusInfoList.emplace_back(interrupt, focusState);
328
329 auto ret = audioInterruptService->HadVoipStatus(audioInterrupt, audioFocusInfoList);
330 EXPECT_EQ(ret, false);
331 }
332
333 /**
334 * @tc.name : Test AudioInterruptService
335 * @tc.number: AudioInterruptService_013
336 * @tc.desc : Test AudioInterruptService
337 */
338 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_013, TestSize.Level1)
339 {
340 auto audioInterruptService = std::make_shared<AudioInterruptService>();
341 ASSERT_NE(audioInterruptService, nullptr);
342
343 AudioInterrupt audioInterrupt;
344 audioInterrupt.pid = 5;
345 audioInterrupt.streamId = 1;
346
347 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
348 AudioInterrupt interrupt;
349 interrupt.pid = 5;
350 interrupt.audioFocusType.streamType = STREAM_VOICE_RING;
351 interrupt.streamId = 1;
352
353 AudioFocuState focusState;
354 focusState = STOP;
355 audioFocusInfoList.emplace_back(interrupt, focusState);
356
357 auto ret = audioInterruptService->HadVoipStatus(audioInterrupt, audioFocusInfoList);
358 EXPECT_EQ(ret, false);
359 }
360
361 /**
362 * @tc.name : Test AudioInterruptService
363 * @tc.number: AudioInterruptService_014
364 * @tc.desc : Test AudioInterruptService
365 */
366 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_014, TestSize.Level1)
367 {
368 auto audioInterruptService = std::make_shared<AudioInterruptService>();
369 ASSERT_NE(audioInterruptService, nullptr);
370
371 AudioInterrupt audioInterrupt;
372 audioInterrupt.pid = 5;
373 audioInterrupt.streamId = 1;
374
375 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
376 AudioInterrupt interrupt;
377 interrupt.pid = 0;
378 interrupt.audioFocusType.streamType = STREAM_VOICE_RING;
379 interrupt.streamId = 1;
380
381 AudioFocuState focusState;
382 focusState = STOP;
383 audioFocusInfoList.emplace_back(interrupt, focusState);
384
385 auto ret = audioInterruptService->HadVoipStatus(audioInterrupt, audioFocusInfoList);
386 EXPECT_EQ(ret, false);
387 }
388
389 /**
390 * @tc.name : Test AudioInterruptService
391 * @tc.number: AudioInterruptService_015
392 * @tc.desc : Test AudioInterruptService
393 */
394 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_015, TestSize.Level1)
395 {
396 auto audioInterruptService = std::make_shared<AudioInterruptService>();
397 ASSERT_NE(audioInterruptService, nullptr);
398
399 uint32_t streamId = 100005;
400 InterruptEventInternal interruptEvent;
401
402 audioInterruptService->DispatchInterruptEventWithStreamId(streamId, interruptEvent);
403 ASSERT_NE(audioInterruptService, nullptr);
404 }
405
406 /**
407 * @tc.name : Test AudioInterruptService
408 * @tc.number: AudioInterruptService_016
409 * @tc.desc : Test AudioInterruptService
410 */
411 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_016, TestSize.Level1)
412 {
413 auto audioInterruptService = std::make_shared<AudioInterruptService>();
414 ASSERT_NE(audioInterruptService, nullptr);
415
416 uint32_t uid = 0;
417 int32_t streamId = 0;
418 InterruptEventInternal interruptEvent;
419
420 uint32_t uid2 = 0;
421 ClientType clientType = CLIENT_TYPE_OTHERS;
422 ClientTypeManager::GetInstance()->OnClientTypeQueryCompleted(uid2, clientType);
423 auto ret = audioInterruptService->ShouldCallbackToClient(uid, streamId, interruptEvent);
424 EXPECT_EQ(ret, true);
425 }
426
427 /**
428 * @tc.name : Test AudioInterruptService
429 * @tc.number: AudioInterruptService_017
430 * @tc.desc : Test AudioInterruptService
431 */
432 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_017, TestSize.Level1)
433 {
434 auto audioInterruptService = std::make_shared<AudioInterruptService>();
435 ASSERT_NE(audioInterruptService, nullptr);
436
437 uint32_t uid = 0;
438 int32_t streamId = 0;
439 InterruptEventInternal interruptEvent;
440 interruptEvent.hintType = INTERRUPT_HINT_DUCK;
441
442 uint32_t uid2 = 0;
443 ClientType clientType = CLIENT_TYPE_GAME;
444 ClientTypeManager::GetInstance()->OnClientTypeQueryCompleted(uid2, clientType);
445 auto ret = audioInterruptService->ShouldCallbackToClient(uid, streamId, interruptEvent);
446 EXPECT_EQ(ret, true);
447 EXPECT_EQ(interruptEvent.callbackToApp, false);
448 }
449
450 /**
451 * @tc.name : Test AudioInterruptService
452 * @tc.number: AudioInterruptService_018
453 * @tc.desc : Test AudioInterruptService
454 */
455 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_018, TestSize.Level1)
456 {
457 auto audioInterruptService = std::make_shared<AudioInterruptService>();
458 ASSERT_NE(audioInterruptService, nullptr);
459
460 uint32_t uid = 0;
461 int32_t streamId = 0;
462 InterruptEventInternal interruptEvent;
463 interruptEvent.hintType = INTERRUPT_HINT_UNDUCK;
464
465 uint32_t uid2 = 0;
466 ClientType clientType = CLIENT_TYPE_GAME;
467 ClientTypeManager::GetInstance()->OnClientTypeQueryCompleted(uid2, clientType);
468 auto ret = audioInterruptService->ShouldCallbackToClient(uid, streamId, interruptEvent);
469 EXPECT_EQ(ret, true);
470 EXPECT_EQ(interruptEvent.callbackToApp, false);
471 }
472
473 /**
474 * @tc.name : Test AudioInterruptService
475 * @tc.number: AudioInterruptService_019
476 * @tc.desc : Test AudioInterruptService
477 */
478 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_019, TestSize.Level1)
479 {
480 auto audioInterruptService = std::make_shared<AudioInterruptService>();
481 ASSERT_NE(audioInterruptService, nullptr);
482
483 uint32_t uid = 0;
484 int32_t streamId = 0;
485 InterruptEventInternal interruptEvent;
486 interruptEvent.hintType = INTERRUPT_HINT_NONE;
487
488 uint32_t uid2 = 0;
489 ClientType clientType = CLIENT_TYPE_GAME;
490 ClientTypeManager::GetInstance()->OnClientTypeQueryCompleted(uid2, clientType);
491 audioInterruptService->policyServer_ = new AudioPolicyServer(0);
492 ASSERT_NE(audioInterruptService->policyServer_, nullptr);
493 auto ret = audioInterruptService->ShouldCallbackToClient(uid, streamId, interruptEvent);
494 EXPECT_EQ(ret, false);
495 }
496
497 /**
498 * @tc.name : Test AudioInterruptService
499 * @tc.number: AudioInterruptService_020
500 * @tc.desc : Test SetAudioManagerInterruptCallback
501 */
502 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_020, TestSize.Level1)
503 {
504 auto audioInterruptService = std::make_shared<AudioInterruptService>();
505 ASSERT_NE(audioInterruptService, nullptr);
506
507 const sptr<IRemoteObject> object = new RemoteObjectTestStub();
508 auto ret = audioInterruptService->SetAudioManagerInterruptCallback(object);
509 EXPECT_EQ(ret, SUCCESS);
510
511 audioInterruptService->handler_ = std::make_shared<AudioPolicyServerHandler>();
512 ret = audioInterruptService->SetAudioManagerInterruptCallback(object);
513 EXPECT_EQ(ret, SUCCESS);
514 }
515
516 /**
517 * @tc.name : Test AudioInterruptService
518 * @tc.number: AudioInterruptService_021
519 * @tc.desc : Test AudioInterruptService
520 */
521 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_021, TestSize.Level1)
522 {
523 auto audioInterruptService = std::make_shared<AudioInterruptService>();
524 ASSERT_NE(audioInterruptService, nullptr);
525
526 int32_t zoneId = 0;
527 uint32_t streamId = 5;
528
529 int32_t map = audioInterruptService->ZONEID_DEFAULT;
530 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
531 AudioInterrupt audioInterrupt;
532 audioInterrupt.streamId = 5;
533 AudioFocuState audioFocuState = ACTIVE;
534 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, audioFocuState});
535 audioInterruptService->zonesMap_.insert({map, audioInterruptZone});
536
537 audioInterruptService->RemoveClient(zoneId, streamId);
538 EXPECT_EQ(audioInterruptService->zonesMap_.size(), 1);
539 }
540
541 /**
542 * @tc.name : Test AudioInterruptService
543 * @tc.number: AudioInterruptService_022
544 * @tc.desc : Test AudioInterruptService
545 */
546 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_022, TestSize.Level1)
547 {
548 auto audioInterruptService = std::make_shared<AudioInterruptService>();
549 ASSERT_NE(audioInterruptService, nullptr);
550
551 int32_t zoneId = 0;
552 uint32_t streamId = 5;
553
554 int32_t map = audioInterruptService->ZONEID_DEFAULT;
555 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
556 AudioInterrupt audioInterrupt;
557 audioInterrupt.streamId = 0;
558 AudioFocuState audioFocuState = ACTIVE;
559 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, audioFocuState});
560
561 uint32_t cb = 5;
562 auto audioInterruptCallbackTest = std::make_shared<AudioInterruptCallbackTest>();
563 audioInterruptZone->interruptCbsMap.insert({cb, audioInterruptCallbackTest});
564
565 audioInterruptService->zonesMap_.insert({map, audioInterruptZone});
566 EXPECT_EQ(audioInterruptService->zonesMap_.find(zoneId)->second->interruptCbsMap.size(), 1);
567
568 audioInterruptService->RemoveClient(zoneId, streamId);
569 EXPECT_EQ(audioInterruptService->zonesMap_.size(), 1);
570 EXPECT_EQ(audioInterruptService->zonesMap_.find(zoneId)->second->interruptCbsMap.size(), 0);
571 }
572
573 /**
574 * @tc.name : Test AudioInterruptService
575 * @tc.number: AudioInterruptService_023
576 * @tc.desc : Test AudioInterruptService
577 */
578 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_023, TestSize.Level1)
579 {
580 auto audioInterruptService = std::make_shared<AudioInterruptService>();
581 ASSERT_NE(audioInterruptService, nullptr);
582
583 int32_t zoneId = 0;
584 uint32_t streamId = 5;
585
586 int32_t map = audioInterruptService->ZONEID_DEFAULT;
587 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
588 AudioInterrupt audioInterrupt;
589 audioInterrupt.streamId = 0;
590 AudioFocuState audioFocuState = ACTIVE;
591 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, audioFocuState});
592
593 uint32_t cb = 0;
594 auto audioInterruptCallbackTest = std::make_shared<AudioInterruptCallbackTest>();
595 audioInterruptZone->interruptCbsMap.insert({cb, audioInterruptCallbackTest});
596
597 audioInterruptService->zonesMap_.insert({map, audioInterruptZone});
598 EXPECT_EQ(audioInterruptService->zonesMap_.find(zoneId)->second->interruptCbsMap.size(), 1);
599
600 audioInterruptService->RemoveClient(zoneId, streamId);
601 EXPECT_EQ(audioInterruptService->zonesMap_.size(), 1);
602 EXPECT_EQ(audioInterruptService->zonesMap_.find(zoneId)->second->interruptCbsMap.size(), 1);
603 }
604
605 /**
606 * @tc.name : Test AudioInterruptService
607 * @tc.number: AudioInterruptService_024
608 * @tc.desc : Test AudioInterruptService
609 */
610 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_024, TestSize.Level1)
611 {
612 auto audioInterruptService = std::make_shared<AudioInterruptService>();
613 ASSERT_NE(audioInterruptService, nullptr);
614
615 int32_t zoneId = 1;
616 uint32_t streamId = 5;
617
618 int32_t map = audioInterruptService->ZONEID_DEFAULT;
619 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
620 AudioInterrupt audioInterrupt;
621 audioInterrupt.streamId = 0;
622 AudioFocuState audioFocuState = ACTIVE;
623 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, audioFocuState});
624
625 uint32_t cb = 0;
626 auto audioInterruptCallbackTest = std::make_shared<AudioInterruptCallbackTest>();
627 audioInterruptZone->interruptCbsMap.insert({cb, audioInterruptCallbackTest});
628
629 audioInterruptService->zonesMap_.insert({map, audioInterruptZone});
630
631 audioInterruptService->RemoveClient(zoneId, streamId);
632 EXPECT_EQ(audioInterruptService->zonesMap_.size(), 1);
633 }
634
635 /**
636 * @tc.name : Test AudioInterruptService
637 * @tc.number: AudioInterruptService_034
638 * @tc.desc : Test NotifyFocusGranted
639 */
640 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_034, TestSize.Level1)
641 {
642 auto audioInterruptService = std::make_shared<AudioInterruptService>();
643 ASSERT_NE(audioInterruptService, nullptr);
644
645 int32_t clientId = 0;
646 AudioInterrupt audioInterrupt;
647 audioInterruptService->handler_ = std::make_shared<AudioPolicyServerHandler>();
648 ASSERT_TRUE(audioInterruptService->handler_ != nullptr);
649 audioInterruptService->NotifyFocusGranted(clientId, audioInterrupt);
650 }
651
652 /**
653 * @tc.name : Test AudioInterruptService
654 * @tc.number: AudioInterruptService_035
655 * @tc.desc : Test NotifyFocusAbandoned
656 */
657 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_035, TestSize.Level1)
658 {
659 auto audioInterruptService = std::make_shared<AudioInterruptService>();
660 ASSERT_NE(audioInterruptService, nullptr);
661
662 int32_t clientId = 0;
663 AudioInterrupt audioInterrupt;
664 audioInterruptService->handler_ = std::make_shared<AudioPolicyServerHandler>();
665 ASSERT_TRUE(audioInterruptService->handler_ != nullptr);
666 auto ret = audioInterruptService->NotifyFocusAbandoned(clientId, audioInterrupt);
667 EXPECT_EQ(ret, SUCCESS);
668 }
669
670 /**
671 * @tc.name : Test AudioInterruptService
672 * @tc.number: AudioInterruptService_036
673 * @tc.desc : Test AbandonAudioFocusInternal
674 */
675 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_036, TestSize.Level1)
676 {
677 auto audioInterruptService = std::make_shared<AudioInterruptService>();
678 ASSERT_NE(audioInterruptService, nullptr);
679
680 int32_t clientId = 0;
681 AudioInterrupt audioInterrupt;
682 auto ret = audioInterruptService->AbandonAudioFocusInternal(clientId, audioInterrupt);
683 EXPECT_EQ(ret, SUCCESS);
684
685 clientId = 10;
686 audioInterruptService->AbandonAudioFocusInternal(clientId, audioInterrupt);
687 EXPECT_EQ(ret, SUCCESS);
688 }
689
690 /**
691 * @tc.name : Test AudioInterruptService
692 * @tc.number: AudioInterruptService_037
693 * @tc.desc : Test CheckAudioSessionExistence
694 */
695 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_037, TestSize.Level1)
696 {
697 auto audioInterruptService = std::make_shared<AudioInterruptService>();
698 ASSERT_NE(audioInterruptService, nullptr);
699
700 AudioInterrupt incomingInterrupt;
701 incomingInterrupt.pid = 0;
702 AudioFocusEntry focusEntry;
703 focusEntry.actionOn = CURRENT;
704
705 AudioSessionStrategy strategy;
706 std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
707 auto audioSession = std::make_shared<AudioSession>(incomingInterrupt.pid, strategy, audioSessionStateMonitor);
708 audioInterruptService->sessionService_ = std::make_shared<AudioSessionService>();
709 audioInterruptService->sessionService_->sessionMap_[incomingInterrupt.pid] = audioSession;
710 auto ret = audioInterruptService->CheckAudioSessionExistence(incomingInterrupt, focusEntry);
711 EXPECT_FALSE(ret);
712 audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
713
714 focusEntry.actionOn = INCOMING;
715 ret = audioInterruptService->CheckAudioSessionExistence(incomingInterrupt, focusEntry);
716 EXPECT_FALSE(ret);
717 }
718
719 /**
720 * @tc.name : Test AudioInterruptService
721 * @tc.number: AudioInterruptService_038
722 * @tc.desc : Test CheckAudioSessionExistence
723 */
724 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_038, TestSize.Level1)
725 {
726 auto audioInterruptService = std::make_shared<AudioInterruptService>();
727 ASSERT_NE(audioInterruptService, nullptr);
728
729 AudioInterrupt incomingInterrupt;
730 incomingInterrupt.pid = 0;
731 AudioFocusEntry focusEntry;
732 focusEntry.actionOn = CURRENT;
733
734 audioInterruptService->sessionService_ = std::make_shared<AudioSessionService>();
735 audioInterruptService->sessionService_->sessionMap_[incomingInterrupt.pid] = nullptr;
736 auto ret = audioInterruptService->CheckAudioSessionExistence(incomingInterrupt, focusEntry);
737 EXPECT_FALSE(ret);
738 }
739
740 /**
741 * @tc.name : Test AudioInterruptService
742 * @tc.number: AudioInterruptService_039
743 * @tc.desc : Test UpdateHintTypeForExistingSession
744 */
745 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_039, TestSize.Level1)
746 {
747 auto audioInterruptService = std::make_shared<AudioInterruptService>();
748 ASSERT_NE(audioInterruptService, nullptr);
749
750 AudioInterrupt incomingInterrupt;
751 AudioFocusEntry focusEntry;
752 focusEntry.hintType = INTERRUPT_HINT_DUCK;
753 incomingInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::DUCK_OTHERS;
754 audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
755
756 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
757 audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
758 EXPECT_EQ(focusEntry.hintType, INTERRUPT_HINT_DUCK);
759
760 focusEntry.hintType = INTERRUPT_HINT_STOP;
761 audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
762 EXPECT_EQ(focusEntry.hintType, INTERRUPT_HINT_DUCK);
763
764 focusEntry.hintType = INTERRUPT_HINT_NONE;
765 audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
766 }
767
768 /**
769 * @tc.name : Test AudioInterruptService
770 * @tc.number: AudioInterruptService_040
771 * @tc.desc : Test UpdateHintTypeForExistingSession
772 */
773 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_040, TestSize.Level1)
774 {
775 auto audioInterruptService = std::make_shared<AudioInterruptService>();
776 ASSERT_NE(audioInterruptService, nullptr);
777
778 AudioInterrupt incomingInterrupt;
779 AudioFocusEntry focusEntry;
780 incomingInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::PAUSE_OTHERS;
781
782 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
783 audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
784 EXPECT_EQ(focusEntry.hintType, INTERRUPT_HINT_PAUSE);
785
786 focusEntry.hintType = INTERRUPT_HINT_STOP;
787 audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
788 EXPECT_EQ(focusEntry.hintType, INTERRUPT_HINT_PAUSE);
789
790 focusEntry.hintType = INTERRUPT_HINT_NONE;
791 audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
792 }
793
794 /**
795 * @tc.name : Test AudioInterruptService
796 * @tc.number: AudioInterruptService_041
797 * @tc.desc : Test ProcessExistInterrupt
798 */
799 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_041, TestSize.Level1)
800 {
801 auto audioInterruptService = std::make_shared<AudioInterruptService>();
802 ASSERT_NE(audioInterruptService, nullptr);
803
804 AudioFocusEntry focusEntry;
805 AudioInterrupt incomingInterrupt;
806 bool removeFocusInfo = true;
807 InterruptEventInternal interruptEvent;
808 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioList;
809 audioList.push_back(std::make_pair(incomingInterrupt, ACTIVE));
810 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = audioList.begin();
811
812 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
813 audioInterruptService->ProcessExistInterrupt(iterActive, focusEntry, incomingInterrupt,
814 removeFocusInfo, interruptEvent);
815 EXPECT_EQ(interruptEvent.hintType, focusEntry.hintType);
816 }
817
818 /**
819 * @tc.name : Test AudioInterruptService
820 * @tc.number: AudioInterruptService_042
821 * @tc.desc : Test ProcessExistInterrupt
822 */
823 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_042, TestSize.Level1)
824 {
825 auto audioInterruptService = std::make_shared<AudioInterruptService>();
826 ASSERT_NE(audioInterruptService, nullptr);
827
828 AudioFocusEntry focusEntry;
829 AudioInterrupt incomingInterrupt;
830 bool removeFocusInfo = true;
831 InterruptEventInternal interruptEvent;
832 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioList;
833 audioList.push_back(std::make_pair(incomingInterrupt, DUCK));
834 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = audioList.begin();
835
836 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
837 audioInterruptService->ProcessExistInterrupt(iterActive, focusEntry, incomingInterrupt,
838 removeFocusInfo, interruptEvent);
839 EXPECT_EQ(interruptEvent.hintType, focusEntry.hintType);
840 }
841
842 /**
843 * @tc.name : Test AudioInterruptService
844 * @tc.number: AudioInterruptService_043
845 * @tc.desc : Test ProcessExistInterrupt
846 */
847 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_043, TestSize.Level1)
848 {
849 auto audioInterruptService = std::make_shared<AudioInterruptService>();
850 ASSERT_NE(audioInterruptService, nullptr);
851
852 AudioFocusEntry focusEntry;
853 AudioInterrupt incomingInterrupt;
854 bool removeFocusInfo = true;
855 InterruptEventInternal interruptEvent;
856 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioList;
857 audioList.push_back(std::make_pair(incomingInterrupt, STOP));
858 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = audioList.begin();
859
860 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
861 audioInterruptService->ProcessExistInterrupt(iterActive, focusEntry, incomingInterrupt,
862 removeFocusInfo, interruptEvent);
863 }
864
865 /**
866 * @tc.name : Test AudioInterruptService
867 * @tc.number: AudioInterruptService_044
868 * @tc.desc : Test ProcessExistInterrupt
869 */
870 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_044, TestSize.Level1)
871 {
872 auto audioInterruptService = std::make_shared<AudioInterruptService>();
873 ASSERT_NE(audioInterruptService, nullptr);
874
875 AudioFocusEntry focusEntry;
876 AudioInterrupt incomingInterrupt;
877 bool removeFocusInfo = true;
878 InterruptEventInternal interruptEvent;
879 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioList;
880 audioList.push_back(std::make_pair(incomingInterrupt, ACTIVE));
881 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = audioList.begin();
882
883 focusEntry.hintType = INTERRUPT_HINT_DUCK;
884 audioInterruptService->ProcessExistInterrupt(iterActive, focusEntry, incomingInterrupt,
885 removeFocusInfo, interruptEvent);
886 EXPECT_EQ(interruptEvent.hintType, focusEntry.hintType);
887 }
888
889 /**
890 * @tc.name : Test AudioInterruptService
891 * @tc.number: AudioInterruptService_045
892 * @tc.desc : Test ProcessExistInterrupt
893 */
894 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_045, TestSize.Level1)
895 {
896 auto audioInterruptService = std::make_shared<AudioInterruptService>();
897 ASSERT_NE(audioInterruptService, nullptr);
898
899 AudioFocusEntry focusEntry;
900 AudioInterrupt incomingInterrupt;
901 bool removeFocusInfo = true;
902 InterruptEventInternal interruptEvent;
903 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioList;
904 audioList.push_back(std::make_pair(incomingInterrupt, DUCK));
905 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = audioList.begin();
906
907 focusEntry.hintType = INTERRUPT_HINT_DUCK;
908 audioInterruptService->ProcessExistInterrupt(iterActive, focusEntry, incomingInterrupt,
909 removeFocusInfo, interruptEvent);
910 }
911
912 /**
913 * @tc.name : Test AudioInterruptService
914 * @tc.number: AudioInterruptService_046
915 * @tc.desc : Test ProcessExistInterrupt
916 */
917 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_046, TestSize.Level1)
918 {
919 auto audioInterruptService = std::make_shared<AudioInterruptService>();
920 ASSERT_NE(audioInterruptService, nullptr);
921
922 AudioFocusEntry focusEntry;
923 AudioInterrupt incomingInterrupt;
924 bool removeFocusInfo = true;
925 InterruptEventInternal interruptEvent;
926 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioList;
927 audioList.push_back(std::make_pair(incomingInterrupt, DUCK));
928 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = audioList.begin();
929
930 focusEntry.hintType = INTERRUPT_HINT_UNDUCK;
931 audioInterruptService->ProcessExistInterrupt(iterActive, focusEntry, incomingInterrupt,
932 removeFocusInfo, interruptEvent);
933 }
934
935 /**
936 * @tc.name : Test AudioInterruptService
937 * @tc.number: AudioInterruptService_047
938 * @tc.desc : Test ProcessExistInterrupt
939 */
940 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_047, TestSize.Level1)
941 {
942 auto audioInterruptService = std::make_shared<AudioInterruptService>();
943 ASSERT_NE(audioInterruptService, nullptr);
944
945 AudioInterrupt audioInterrupt;
946 InterruptEventInternal interruptEvent;
947 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive;
948 std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
949
950 tmpFocusInfoList.push_back(std::make_pair<>(audioInterrupt, ACTIVE));
951 iterActive = tmpFocusInfoList.begin();
952
953 interruptEvent.hintType = INTERRUPT_HINT_STOP;
954 audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
955 }
956
957 /**
958 * @tc.name : Test AudioInterruptService
959 * @tc.number: AudioInterruptService_048
960 * @tc.desc : Test ProcessExistInterrupt
961 */
962 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_048, TestSize.Level1)
963 {
964 auto audioInterruptService = std::make_shared<AudioInterruptService>();
965 ASSERT_NE(audioInterruptService, nullptr);
966
967 AudioInterrupt audioInterrupt;
968 InterruptEventInternal interruptEvent;
969 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive;
970 std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
971
972 tmpFocusInfoList.push_back(std::make_pair<>(audioInterrupt, ACTIVE));
973 iterActive = tmpFocusInfoList.begin();
974
975 interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
976 audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
977 EXPECT_EQ(iterActive->second, PAUSEDBYREMOTE);
978 }
979
980 /**
981 * @tc.name : Test AudioInterruptService
982 * @tc.number: AudioInterruptService_049
983 * @tc.desc : Test ProcessExistInterrupt
984 */
985 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_049, TestSize.Level1)
986 {
987 auto audioInterruptService = std::make_shared<AudioInterruptService>();
988 ASSERT_NE(audioInterruptService, nullptr);
989
990 AudioInterrupt audioInterrupt;
991 InterruptEventInternal interruptEvent;
992 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive;
993 std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
994
995 tmpFocusInfoList.push_back(std::make_pair<>(audioInterrupt, DUCK));
996 iterActive = tmpFocusInfoList.begin();
997
998 interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
999 audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
1000 EXPECT_EQ(iterActive->second, PAUSEDBYREMOTE);
1001 }
1002
1003 /**
1004 * @tc.name : Test AudioInterruptService
1005 * @tc.number: AudioInterruptService_050
1006 * @tc.desc : Test ProcessExistInterrupt
1007 */
1008 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_050, TestSize.Level1)
1009 {
1010 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1011 ASSERT_NE(audioInterruptService, nullptr);
1012
1013 AudioInterrupt audioInterrupt;
1014 InterruptEventInternal interruptEvent;
1015 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive;
1016 std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
1017
1018 tmpFocusInfoList.push_back(std::make_pair<>(audioInterrupt, PLACEHOLDER));
1019 iterActive = tmpFocusInfoList.begin();
1020
1021 interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
1022 audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
1023 }
1024
1025 /**
1026 * @tc.name : Test AudioInterruptService
1027 * @tc.number: AudioInterruptService_051
1028 * @tc.desc : Test ReportRecordGetFocusFail
1029 */
1030 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_051, TestSize.Level1)
1031 {
1032 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1033 ASSERT_NE(audioInterruptService, nullptr);
1034
1035 AudioInterrupt incomingInterrupt = {};
1036 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
1037 AudioInterrupt activeInterrupt = {};
1038 activeInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
1039 audioInterruptService->ReportRecordGetFocusFail(incomingInterrupt, activeInterrupt, RECORD_ERROR_GET_FOCUS_FAIL);
1040 }
1041
1042 /**
1043 * @tc.name : Test AudioInterruptService
1044 * @tc.number: AudioInterruptService_052
1045 * @tc.desc : Test UpdateMicFocusStrategy
1046 */
1047 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_052, TestSize.Level1)
1048 {
1049 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1050 ASSERT_NE(audioInterruptService, nullptr);
1051
1052 SourceType existSourceType;
1053 SourceType incomingSourceType;
1054 std::string bundleName = "";
1055 AudioFocusEntry focusEntry;
1056
1057 existSourceType = SOURCE_TYPE_INVALID;
1058 incomingSourceType = SOURCE_TYPE_MIC;
1059 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
1060 audioInterruptService->UpdateMicFocusStrategy(existSourceType, incomingSourceType, bundleName, focusEntry);
1061 EXPECT_NE(focusEntry.hintType, INTERRUPT_HINT_NONE);
1062 }
1063
1064 /**
1065 * @tc.name : Test AudioSessionFocusMode
1066 * @tc.number: AudioInterruptService_053
1067 * @tc.desc : Test AudioSessionFocusMode
1068 */
1069 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_053, TestSize.Level1)
1070 {
1071 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1072 ASSERT_NE(audioInterruptService, nullptr);
1073
1074 int32_t fakePid = 123;
1075 AudioInterrupt incomingInterrupt;
1076 incomingInterrupt.pid = fakePid;
1077 incomingInterrupt.audioFocusType.streamType = STREAM_MUSIC;
1078 incomingInterrupt.streamId = 888; // 888 is a fake stream id.
1079
1080 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
1081 audioInterruptService->sessionService_ = sessionService;
1082 int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
1083 EXPECT_EQ(SUCCESS, ret);
1084 AudioSessionStrategy audioSessionStrategy;
1085 audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
1086 ret = sessionService->ActivateAudioSession(fakePid, audioSessionStrategy);
1087 EXPECT_EQ(SUCCESS, ret);
1088 ret = audioInterruptService->ActivateAudioInterrupt(0, incomingInterrupt, false);
1089 EXPECT_EQ(ERR_FOCUS_DENIED, ret);
1090 }
1091
1092 } // namespace AudioStandard
1093 } // namespace OHOS