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_service_second_unit_test.h"
17 using namespace testing::ext;
18
19 namespace OHOS {
20 namespace AudioStandard {
21
SetUpTestCase(void)22 void AudioInterruptServiceSecondUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)23 void AudioInterruptServiceSecondUnitTest::TearDownTestCase(void) {}
SetUp(void)24 void AudioInterruptServiceSecondUnitTest::SetUp(void) {}
TearDown(void)25 void AudioInterruptServiceSecondUnitTest::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 IStandardAudioPolicyManagerListenerStub : public IStandardAudioPolicyManagerListener {
40 public:
AsObject()41 sptr<IRemoteObject> AsObject() override { return nullptr; }
42
~IStandardAudioPolicyManagerListenerStub()43 ~IStandardAudioPolicyManagerListenerStub() {}
44
OnInterrupt(const InterruptEventInternal & interruptEvent)45 ErrCode OnInterrupt(const InterruptEventInternal& interruptEvent) override { return SUCCESS; }
46
OnRouteUpdate(uint32_t routeFlag,const std::string & networkId)47 ErrCode OnRouteUpdate(uint32_t routeFlag, const std::string& networkId) override { return SUCCESS; }
48
OnAvailableDeviceChange(uint32_t usage,const DeviceChangeAction & deviceChangeAction)49 ErrCode OnAvailableDeviceChange(uint32_t usage, const DeviceChangeAction& deviceChangeAction) override
50 {
51 return SUCCESS;
52 }
53
OnQueryClientType(const std::string & bundleName,uint32_t uid,bool & ret)54 ErrCode OnQueryClientType(const std::string& bundleName, uint32_t uid, bool& ret) override
55 {
56 return SUCCESS;
57 }
58
OnCheckClientInfo(const std::string & bundleName,int32_t & uid,int32_t pid,bool & ret)59 ErrCode OnCheckClientInfo(const std::string& bundleName, int32_t& uid, int32_t pid, bool& ret) override
60 {
61 return SUCCESS;
62 }
63
OnCheckVKBInfo(const std::string & bundleName,bool & isValid)64 ErrCode OnCheckVKBInfo(const std::string& bundleName, bool& isValid) override
65 {
66 return SUCCESS;
67 }
68
OnQueryAllowedPlayback(int32_t uid,int32_t pid,bool & ret)69 ErrCode OnQueryAllowedPlayback(int32_t uid, int32_t pid, bool& ret) override
70 {
71 return SUCCESS;
72 }
73
OnBackgroundMute(int32_t uid)74 ErrCode OnBackgroundMute(int32_t uid) override
75 {
76 return SUCCESS;
77 }
78
OnQueryBundleNameIsInList(const std::string & bundleName,const std::string & listType,bool & ret)79 ErrCode OnQueryBundleNameIsInList(const std::string& bundleName, const std::string& listType, bool& ret) override
80 {
81 ret = true;
82 return SUCCESS;
83 }
84
OnQueryDeviceVolumeBehavior(VolumeBehavior & volumeBehavior)85 ErrCode OnQueryDeviceVolumeBehavior(VolumeBehavior &volumeBehavior) override
86 {
87 volumeBehavior.isReady = false;
88 volumeBehavior.isVolumeControlDisabled = false;
89 volumeBehavior.databaseVolumeName = "";
90 return SUCCESS;
91 }
92 };
93
94 class AudioInterruptCallbackTest : public AudioInterruptCallback {
95 public:
OnInterrupt(const InterruptEventInternal & interruptEvent)96 void OnInterrupt(const InterruptEventInternal &interruptEvent) override {};
97 };
98
99 /**
100 * @tc.name : Test AudioInterruptService
101 * @tc.number: AudioInterruptService_001
102 * @tc.desc : Test OnSessionTimeout and HandleSessionTimeOutEvent
103 */
104 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_001, TestSize.Level1)
105 {
106 auto audioInterruptService = std::make_shared<AudioInterruptService>();
107 ASSERT_NE(audioInterruptService, nullptr);
108
109 auto pid = getpid();
110 auto audioInterruptZone = make_shared<AudioInterruptZone>();
111 AudioInterrupt audioInterrupt;
112 audioInterrupt.pid = pid;
113 audioInterrupt.isAudioSessionInterrupt = true;
114 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
115 audioInterruptService->zonesMap_[0] = audioInterruptZone;
116 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
117 audioInterruptService->sessionService_ = sessionService;
118 audioInterruptService->OnSessionTimeout(pid);
119 EXPECT_EQ(nullptr, audioInterruptService->handler_);
120
121 audioInterruptService->handler_ = make_shared<AudioPolicyServerHandler>();
122 audioInterruptService->OnSessionTimeout(pid);
123 EXPECT_NE(nullptr, audioInterruptService->handler_);
124 }
125
126 /**
127 * @tc.name : Test AudioInterruptService
128 * @tc.number: AudioInterruptService_002
129 * @tc.desc : Test ActivateAudioSession_001
130 */
131 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_002, TestSize.Level1)
132 {
133 auto audioInterruptService = std::make_shared<AudioInterruptService>();
134 ASSERT_NE(audioInterruptService, nullptr);
135
136 int32_t fakePid = 123;
137 AudioInterrupt incomingInterrupt;
138 incomingInterrupt.pid = fakePid;
139 incomingInterrupt.audioFocusType.streamType = STREAM_MUSIC;
140 incomingInterrupt.streamId = 888; // 888 is a fake stream id.
141
142 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
143 sessionService->sessionMap_[fakePid] = nullptr;
144 audioInterruptService->sessionService_ = sessionService;
145
146 AudioSessionStrategy audioSessionStrategy;
147 audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
148 auto ret = audioInterruptService->ActivateAudioSession(AudioInterruptService::ZONEID_DEFAULT,
149 fakePid, audioSessionStrategy);
150 EXPECT_EQ(ERROR, ret);
151 }
152
153 /**
154 * @tc.name : Test AudioInterruptService
155 * @tc.number: AudioInterruptService_003
156 * @tc.desc : Test ActivateAudioSession_002
157 */
158 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_003, TestSize.Level1)
159 {
160 auto audioInterruptService = std::make_shared<AudioInterruptService>();
161 ASSERT_NE(audioInterruptService, nullptr);
162
163 int32_t fakePid = 123;
164 AudioInterrupt incomingInterrupt;
165 incomingInterrupt.pid = fakePid;
166 incomingInterrupt.audioFocusType.streamType = STREAM_MUSIC;
167 incomingInterrupt.streamId = 888;
168 AudioSessionStrategy audioSessionStrategy;
169 audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
170 audioInterruptService->sessionService_ = AudioSessionService::GetAudioSessionService();
171 audioInterruptService->sessionService_->sessionMap_[fakePid] = nullptr;
172 auto ret = audioInterruptService->ActivateAudioSession(1, fakePid, audioSessionStrategy);
173 EXPECT_EQ(ERROR, ret);
174 }
175
176 /**
177 * @tc.name : Test AudioInterruptService
178 * @tc.number: AudioInterruptService_004
179 * @tc.desc : Test IsSessionNeedToFetchOutputDevice、SetAudioSessionScene
180 */
181 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_004, TestSize.Level1)
182 {
183 auto audioInterruptService = std::make_shared<AudioInterruptService>();
184 ASSERT_NE(audioInterruptService, nullptr);
185
186 int32_t fakePid = 123;
187 auto ret = audioInterruptService->IsSessionNeedToFetchOutputDevice(fakePid);
188 EXPECT_EQ(false, ret);
189 ret = audioInterruptService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
190 EXPECT_EQ(true, ret);
191
192 sptr<AudioPolicyServer> server(new AudioPolicyServer(0));
193 audioInterruptService->Init(server);
194 ret = audioInterruptService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
195 EXPECT_EQ(false, ret);
196 }
197
198 /**
199 * @tc.name : Test AudioInterruptService
200 * @tc.number: AudioInterruptService_005
201 * @tc.desc : Test DeactivateAudioSession
202 */
203 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_005, TestSize.Level1)
204 {
205 auto audioInterruptService = std::make_shared<AudioInterruptService>();
206 ASSERT_NE(audioInterruptService, nullptr);
207
208 auto pid = getpid();
209 auto audioInterruptZone = make_shared<AudioInterruptZone>();
210 AudioInterrupt audioInterrupt;
211 audioInterrupt.pid = pid;
212 audioInterrupt.isAudioSessionInterrupt = true;
213 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
214 audioInterruptService->zonesMap_[0] = audioInterruptZone;
215 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
216 audioInterruptService->sessionService_ = sessionService;
217 EXPECT_EQ(nullptr, audioInterruptService->handler_);
218 auto ret = audioInterruptService->DeactivateAudioSession(0, pid);
219 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
220 audioInterruptService->handler_ = make_shared<AudioPolicyServerHandler>();
221 ret = audioInterruptService->DeactivateAudioSession(0, pid);
222 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
223 }
224
225 /**
226 * @tc.name : Test AudioInterruptService
227 * @tc.number: AudioInterruptService_006
228 * @tc.desc : Test DeactivateAudioSessionInFakeFocusMode
229 */
230 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_006, TestSize.Level1)
231 {
232 auto audioInterruptService = std::make_shared<AudioInterruptService>();
233 ASSERT_NE(audioInterruptService, nullptr);
234
235 auto pid = getpid();
236 InterruptHint hintType = INTERRUPT_HINT_PAUSE;
237 EXPECT_EQ(nullptr, audioInterruptService->sessionService_);
238 audioInterruptService->DeactivateAudioSessionInFakeFocusMode(pid, hintType);
239 auto audioInterruptZone = make_shared<AudioInterruptZone>();
240 AudioInterrupt audioInterrupt;
241 audioInterrupt.pid = pid;
242 audioInterrupt.isAudioSessionInterrupt = true;
243 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
244 audioInterruptService->zonesMap_[0] = audioInterruptZone;
245 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
246 audioInterruptService->sessionService_ = sessionService;
247
248 audioInterruptService->handler_ = nullptr;
249 audioInterruptService->DeactivateAudioSessionInFakeFocusMode(pid, hintType);
250
251 audioInterruptService->handler_ = make_shared<AudioPolicyServerHandler>();
252 audioInterruptService->DeactivateAudioSessionInFakeFocusMode(pid, hintType);
253
254 hintType = INTERRUPT_HINT_STOP;
255 audioInterruptService->DeactivateAudioSessionInFakeFocusMode(pid, hintType);
256 EXPECT_NE(nullptr, audioInterruptService->handler_);
257 }
258
259 /**
260 * @tc.name : Test AudioInterruptService
261 * @tc.number: AudioInterruptService_008
262 * @tc.desc : Test UnsetAudioInterruptCallback
263 */
264 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_008, TestSize.Level1)
265 {
266 auto audioInterruptService = std::make_shared<AudioInterruptService>();
267 ASSERT_NE(audioInterruptService, nullptr);
268
269 pid_t pid = 123;
270 uint32_t streamId = 123;
271 audioInterruptService->interruptClients_[streamId] = nullptr;
272 auto audioInterruptZone = make_shared<AudioInterruptZone>();
273 AudioInterrupt audioInterrupt;
274 audioInterrupt.pid = pid;
275 audioInterrupt.isAudioSessionInterrupt = true;
276 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
277 audioInterruptZone->interruptCbsMap[streamId] = nullptr;
278 audioInterruptService->zonesMap_[0] = audioInterruptZone;
279
280 auto ret = audioInterruptService->UnsetAudioInterruptCallback(0, streamId);
281 EXPECT_EQ(SUCCESS, ret);
282 }
283
284 /**
285 * @tc.name : Test AudioInterruptService
286 * @tc.number: AudioInterruptService_009
287 * @tc.desc : Test HandleAppStreamType
288 */
289 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_009, TestSize.Level1)
290 {
291 auto audioInterruptService = std::make_shared<AudioInterruptService>();
292 ASSERT_NE(audioInterruptService, nullptr);
293
294 int32_t fakePid = 123;
295 int32_t zoneId = -1;
296 AudioInterrupt incomingInterrupt;
297 incomingInterrupt.pid = fakePid;
298 incomingInterrupt.audioFocusType.streamType = STREAM_MUSIC;
299 incomingInterrupt.streamId = 888; // 888 is a fake stream id.
300 AudioSessionStrategy audioSessionStrategy;
301 audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
302
303 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
304 int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
305 EXPECT_EQ(SUCCESS, ret);
306 sessionService->sessionMap_[fakePid]->audioSessionScene_ = AudioSessionScene::MEDIA;
307 sessionService->sessionMap_[fakePid]->state_ = AudioSessionState::SESSION_ACTIVE;
308 audioInterruptService->sessionService_ = sessionService;
309 audioInterruptService->HandleAppStreamType(zoneId, incomingInterrupt);
310
311 audioInterruptService->sessionService_ = nullptr;
312 auto audioInterruptZone = make_shared<AudioInterruptZone>();
313 AudioInterrupt audioInterrupt;
314 audioInterrupt.pid = fakePid;
315 audioInterrupt.isAudioSessionInterrupt = true;
316 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
317 audioInterruptService->zonesMap_[0] = audioInterruptZone;
318 audioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
319 audioInterruptService->HandleAppStreamType(zoneId, incomingInterrupt);
320 EXPECT_EQ(nullptr, audioInterruptService->sessionService_);
321 }
322
323 /**
324 * @tc.name : Test AudioInterruptService
325 * @tc.number: AudioInterruptService_010
326 * @tc.desc : Test PrintLogsOfFocusStrategyBaseMusic_001
327 */
328 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_010, TestSize.Level1)
329 {
330 auto audioInterruptService = std::make_shared<AudioInterruptService>();
331 ASSERT_NE(audioInterruptService, nullptr);
332
333 AudioInterrupt audioInterrupt;
334 AudioFocusType audioFocusType;
335 audioFocusType.streamType = AudioStreamType::STREAM_MUSIC;
336 std::pair<AudioFocusType, AudioFocusType> focusPair =
337 std::make_pair(audioFocusType, audioInterrupt.audioFocusType);
338 AudioFocusEntry focusEntry;
339 focusEntry.actionOn = INCOMING;
340 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
341 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
342 EXPECT_EQ(nullptr, audioInterruptService->sessionService_);
343 }
344
345 /**
346 * @tc.name : Test AudioInterruptService
347 * @tc.number: AudioInterruptService_011
348 * @tc.desc : Test PrintLogsOfFocusStrategyBaseMusic_002
349 */
350 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_011, TestSize.Level1)
351 {
352 auto audioInterruptService = std::make_shared<AudioInterruptService>();
353 ASSERT_NE(audioInterruptService, nullptr);
354
355 AudioInterrupt audioInterrupt;
356 audioInterrupt.pid = 123;
357 AudioFocusType audioFocusType;
358 audioFocusType.streamType = AudioStreamType::STREAM_MUSIC;
359 std::pair<AudioFocusType, AudioFocusType> focusPair =
360 std::make_pair(audioFocusType, audioInterrupt.audioFocusType);
361 AudioFocusEntry focusEntry;
362 focusEntry.actionOn = CURRENT;
363 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
364
365 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
366 int ret = sessionService->SetAudioSessionScene(audioInterrupt.pid, AudioSessionScene::MEDIA);
367 EXPECT_EQ(SUCCESS, ret);
368 sessionService->sessionMap_[audioInterrupt.pid]->audioSessionScene_ = AudioSessionScene::MEDIA;
369 sessionService->sessionMap_[audioInterrupt.pid]->state_ = AudioSessionState::SESSION_NEW;
370 audioInterruptService->sessionService_ = sessionService;
371 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
372 EXPECT_NE(nullptr, audioInterruptService->sessionService_);
373
374 sessionService->sessionMap_[audioInterrupt.pid]->state_ = AudioSessionState::SESSION_ACTIVE;
375 audioInterruptService->sessionService_ = sessionService;
376 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
377 EXPECT_NE(nullptr, audioInterruptService->sessionService_);
378 }
379
380 /**
381 * @tc.name : Test AudioInterruptService
382 * @tc.number: AudioInterruptService_012
383 * @tc.desc : Test PrintLogsOfFocusStrategyBaseMusic_003
384 */
385 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_012, TestSize.Level1)
386 {
387 auto audioInterruptService = std::make_shared<AudioInterruptService>();
388 ASSERT_NE(audioInterruptService, nullptr);
389
390 AudioInterrupt audioInterrupt;
391 AudioFocusType audioFocusType;
392 audioFocusType.streamType = AudioStreamType::STREAM_MUSIC;
393 std::pair<AudioFocusType, AudioFocusType> focusPair =
394 std::make_pair(audioFocusType, audioInterrupt.audioFocusType);
395 AudioFocusEntry focusEntry;
396 focusEntry.actionOn = CURRENT;
397 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
398 audioInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
399 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
400 EXPECT_EQ(nullptr, audioInterruptService->sessionService_);
401
402 focusEntry.hintType = INTERRUPT_HINT_DUCK;
403 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
404 audioInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::SILENT;
405 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
406 EXPECT_EQ(INTERRUPT_HINT_DUCK, audioInterruptService->focusCfgMap_[focusPair].hintType);
407
408 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
409 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
410 audioInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::SILENT;
411 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
412 EXPECT_EQ(INTERRUPT_HINT_PAUSE, audioInterruptService->focusCfgMap_[focusPair].hintType);
413
414 focusEntry.hintType = INTERRUPT_HINT_STOP;
415 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
416 audioInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::SILENT;
417 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
418 EXPECT_EQ(INTERRUPT_HINT_STOP, audioInterruptService->focusCfgMap_[focusPair].hintType);
419
420 focusEntry.hintType = INTERRUPT_HINT_MUTE;
421 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
422 audioInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::SILENT;
423 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
424 EXPECT_EQ(INTERRUPT_HINT_MUTE, audioInterruptService->focusCfgMap_[focusPair].hintType);
425 }
426
427 /**
428 * @tc.name : Test AudioInterruptService
429 * @tc.number: AudioInterruptService_013
430 * @tc.desc : Test PrintLogsOfFocusStrategyBaseMusic_004
431 */
432 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_013, TestSize.Level1)
433 {
434 auto audioInterruptService = std::make_shared<AudioInterruptService>();
435 ASSERT_NE(audioInterruptService, nullptr);
436
437 AudioInterrupt audioInterrupt;
438 AudioFocusType audioFocusType;
439 audioFocusType.streamType = AudioStreamType::STREAM_MUSIC;
440 std::pair<AudioFocusType, AudioFocusType> focusPair =
441 std::make_pair(audioFocusType, audioInterrupt.audioFocusType);
442 AudioFocusEntry focusEntry;
443 focusEntry.actionOn = CURRENT;
444 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
445 audioInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::DUCK_OTHERS;
446 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
447 EXPECT_EQ(nullptr, audioInterruptService->sessionService_);
448
449 focusEntry.hintType = INTERRUPT_HINT_DUCK;
450 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
451 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
452 EXPECT_EQ(INTERRUPT_HINT_DUCK, audioInterruptService->focusCfgMap_[focusPair].hintType);
453
454 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
455 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
456 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
457 EXPECT_EQ(INTERRUPT_HINT_PAUSE, audioInterruptService->focusCfgMap_[focusPair].hintType);
458
459 focusEntry.hintType = INTERRUPT_HINT_STOP;
460 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
461 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
462 EXPECT_EQ(INTERRUPT_HINT_STOP, audioInterruptService->focusCfgMap_[focusPair].hintType);
463
464 focusEntry.hintType = INTERRUPT_HINT_MUTE;
465 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
466 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
467 EXPECT_EQ(INTERRUPT_HINT_MUTE, audioInterruptService->focusCfgMap_[focusPair].hintType);
468 }
469
470 /**
471 * @tc.name : Test AudioInterruptService
472 * @tc.number: AudioInterruptService_014
473 * @tc.desc : Test PrintLogsOfFocusStrategyBaseMusic_005
474 */
475 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_014, TestSize.Level1)
476 {
477 auto audioInterruptService = std::make_shared<AudioInterruptService>();
478 ASSERT_NE(audioInterruptService, nullptr);
479
480 AudioInterrupt audioInterrupt;
481 AudioFocusType audioFocusType;
482 audioFocusType.streamType = AudioStreamType::STREAM_MUSIC;
483 std::pair<AudioFocusType, AudioFocusType> focusPair =
484 std::make_pair(audioFocusType, audioInterrupt.audioFocusType);
485 AudioFocusEntry focusEntry;
486 focusEntry.actionOn = CURRENT;
487 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
488 audioInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::PAUSE_OTHERS;
489 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
490 EXPECT_EQ(nullptr, audioInterruptService->sessionService_);
491
492 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
493 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
494 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
495 EXPECT_EQ(INTERRUPT_HINT_PAUSE, audioInterruptService->focusCfgMap_[focusPair].hintType);
496
497 focusEntry.hintType = INTERRUPT_HINT_STOP;
498 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
499 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
500 EXPECT_EQ(INTERRUPT_HINT_STOP, audioInterruptService->focusCfgMap_[focusPair].hintType);
501
502 focusEntry.hintType = INTERRUPT_HINT_MUTE;
503 audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
504 audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
505 EXPECT_EQ(INTERRUPT_HINT_MUTE, audioInterruptService->focusCfgMap_[focusPair].hintType);
506 }
507
508 /**
509 * @tc.name : Test AudioInterruptService
510 * @tc.number: AudioInterruptService_015
511 * @tc.desc : Test ActivatePreemptMode
512 */
513 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_015, TestSize.Level1)
514 {
515 auto audioInterruptService = std::make_shared<AudioInterruptService>();
516 ASSERT_NE(audioInterruptService, nullptr);
517
518 auto audioInterruptZone = make_shared<AudioInterruptZone>();
519 AudioInterrupt audioInterrupt;
520 audioInterrupt.pid = 123;
521 audioInterrupt.isAudioSessionInterrupt = true;
522 audioInterrupt.streamUsage = STREAM_USAGE_GAME;
523 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
524 audioInterruptService->zonesMap_[0] = audioInterruptZone;
525 audioInterruptService->handler_ = nullptr;
526 auto ret = audioInterruptService->ActivatePreemptMode();
527 EXPECT_EQ(ERROR, ret);
528 }
529
530 /**
531 * @tc.name : Test AudioInterruptService
532 * @tc.number: AudioInterruptService_016
533 * @tc.desc : Test GetStreamInFocusInternal_001
534 */
535 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_016, TestSize.Level1)
536 {
537 auto audioInterruptService = std::make_shared<AudioInterruptService>();
538 ASSERT_NE(audioInterruptService, nullptr);
539
540 int32_t uid = 123;
541 auto audioInterruptZone = make_shared<AudioInterruptZone>();
542 AudioInterrupt audioInterrupt;
543 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
544 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
545 audioInterruptService->zonesMap_[0] = audioInterruptZone;
546 auto ret = audioInterruptService->GetStreamInFocusInternal(uid, 0);
547 EXPECT_EQ(audioInterruptService->defaultVolumeType_, ret);
548
549 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
550 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, ACTIVE});
551 audioInterruptService->zonesMap_[0] = audioInterruptZone;
552 ret = audioInterruptService->GetStreamInFocusInternal(uid, 0);
553 EXPECT_EQ(audioInterruptService->defaultVolumeType_, ret);
554
555 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
556 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
557 audioInterruptService->zonesMap_[0] = audioInterruptZone;
558 ret = audioInterruptService->GetStreamInFocusInternal(uid, 0);
559 EXPECT_EQ(audioInterruptService->defaultVolumeType_, ret);
560 }
561
562 /**
563 * @tc.name : Test AudioInterruptService
564 * @tc.number: AudioInterruptService_017
565 * @tc.desc : Test GetStreamInFocusInternal_002
566 */
567 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_017, TestSize.Level1)
568 {
569 auto audioInterruptService = std::make_shared<AudioInterruptService>();
570 ASSERT_NE(audioInterruptService, nullptr);
571
572 int32_t uid = 111;
573 auto audioInterruptZone = make_shared<AudioInterruptZone>();
574 AudioInterrupt audioInterrupt;
575 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
576 audioInterrupt.uid = 111;
577 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, ACTIVE});
578 audioInterruptService->zonesMap_[0] = audioInterruptZone;
579 auto ret = audioInterruptService->GetStreamInFocusInternal(uid, 0);
580 EXPECT_EQ(audioInterruptService->defaultVolumeType_, ret);
581 uid = 123;
582 ret = audioInterruptService->GetStreamInFocusInternal(uid, 0);
583 EXPECT_EQ(audioInterruptService->defaultVolumeType_, ret);
584 }
585
586 /**
587 * @tc.name : Test AudioInterruptService
588 * @tc.number: AudioInterruptService_018
589 * @tc.desc : Test GetStreamInFocusInternal_003
590 */
591 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_018, TestSize.Level1)
592 {
593 auto audioInterruptService = std::make_shared<AudioInterruptService>();
594 ASSERT_NE(audioInterruptService, nullptr);
595
596 int32_t uid = 1003;
597 auto audioInterruptZone = make_shared<AudioInterruptZone>();
598 AudioInterrupt audioInterrupt;
599 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
600 audioInterrupt.uid = 1003;
601 audioInterrupt.audioFocusType.streamType = STREAM_VOICE_ASSISTANT;
602 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, ACTIVE});
603 audioInterruptService->zonesMap_[0] = audioInterruptZone;
604 auto ret = audioInterruptService->GetStreamInFocusInternal(uid, 0);
605 EXPECT_EQ(STREAM_VOICE_ASSISTANT, ret);
606
607 uid = 123;
608 audioInterrupt.uid = uid;
609 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, ACTIVE});
610 audioInterruptService->zonesMap_[0] = audioInterruptZone;
611 ret = audioInterruptService->GetStreamInFocusInternal(uid, 0);
612 EXPECT_EQ(audioInterruptService->defaultVolumeType_, ret);
613 }
614
615 /**
616 * @tc.name : Test AudioInterruptService
617 * @tc.number: AudioInterruptService_019
618 * @tc.desc : Test GetStreamInFocusInternal_004
619 */
620 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_019, TestSize.Level1)
621 {
622 auto audioInterruptService = std::make_shared<AudioInterruptService>();
623 ASSERT_NE(audioInterruptService, nullptr);
624
625 int32_t uid = 1003;
626 int32_t pid = 123;
627 auto audioInterruptZone = make_shared<AudioInterruptZone>();
628 AudioInterrupt audioInterrupt;
629 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
630 audioInterrupt.uid = uid;
631 audioInterrupt.pid = pid;
632 audioInterrupt.audioFocusType.streamType = STREAM_VOICE_ASSISTANT;
633 audioInterrupt.isAudioSessionInterrupt = true;
634 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, ACTIVE});
635 audioInterruptService->zonesMap_[0] = audioInterruptZone;
636 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
637 int ret = sessionService->SetAudioSessionScene(pid, AudioSessionScene::MEDIA);
638 EXPECT_EQ(SUCCESS, ret);
639 sessionService->sessionMap_[pid]->audioSessionScene_ = AudioSessionScene::MEDIA;
640 sessionService->sessionMap_[pid]->state_ = AudioSessionState::SESSION_ACTIVE;
641 audioInterruptService->sessionService_ = sessionService;
642 ret = audioInterruptService->GetStreamInFocusInternal(uid, 0);
643 EXPECT_EQ(STREAM_MUSIC, ret);
644 }
645
646 /**
647 * @tc.name : Test AudioInterruptService
648 * @tc.number: AudioInterruptService_020
649 * @tc.desc : Test NotifyFocusGranted
650 */
651 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_020, TestSize.Level1)
652 {
653 auto audioInterruptService = std::make_shared<AudioInterruptService>();
654 ASSERT_NE(audioInterruptService, nullptr);
655
656 int32_t clientId = 123;
657 AudioInterrupt audioInterrupt;
658 audioInterruptService->handler_ = make_shared<AudioPolicyServerHandler>();
659 audioInterruptService->NotifyFocusGranted(clientId, audioInterrupt);
660 EXPECT_NE(nullptr, audioInterruptService->handler_);
661 }
662
663 /**
664 * @tc.name : Test AudioInterruptService
665 * @tc.number: AudioInterruptService_021
666 * @tc.desc : Test NotifyFocusAbandoned
667 */
668 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_021, TestSize.Level1)
669 {
670 auto audioInterruptService = std::make_shared<AudioInterruptService>();
671 ASSERT_NE(audioInterruptService, nullptr);
672
673 int32_t clientId = 123;
674 AudioInterrupt audioInterrupt;
675 audioInterruptService->handler_ = make_shared<AudioPolicyServerHandler>();
676 auto ret = audioInterruptService->NotifyFocusAbandoned(clientId, audioInterrupt);
677 EXPECT_EQ(SUCCESS, ret);
678 }
679
680 /**
681 * @tc.name : Test AudioInterruptService
682 * @tc.number: AudioInterruptService_022
683 * @tc.desc : Test AbandonAudioFocusInternal
684 */
685 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_022, TestSize.Level1)
686 {
687 auto audioInterruptService = std::make_shared<AudioInterruptService>();
688 ASSERT_NE(audioInterruptService, nullptr);
689
690 int32_t clientId = 123;
691 AudioInterrupt audioInterrupt;
692 audioInterruptService->handler_ = make_shared<AudioPolicyServerHandler>();
693 auto ret = audioInterruptService->AbandonAudioFocusInternal(clientId, audioInterrupt);
694 EXPECT_EQ(SUCCESS, ret);
695 }
696
697 /**
698 * @tc.name : Test AudioInterruptService
699 * @tc.number: AudioInterruptService_023
700 * @tc.desc : Test CheckAudioSessionExistence
701 */
702 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_023, TestSize.Level1)
703 {
704 auto audioInterruptService = std::make_shared<AudioInterruptService>();
705 ASSERT_NE(audioInterruptService, nullptr);
706
707 int32_t pid = 123;
708 AudioInterrupt audioInterrupt;
709 AudioFocusEntry audioFocusEntry;
710 audioInterrupt.pid = pid;
711 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
712 audioInterruptService->sessionService_ = sessionService;
713 auto ret = audioInterruptService->CheckAudioSessionExistence(audioInterrupt, audioFocusEntry);
714 EXPECT_EQ(false, ret);
715
716 ret = sessionService->SetAudioSessionScene(pid, AudioSessionScene::MEDIA);
717 EXPECT_EQ(SUCCESS, ret);
718 sessionService->sessionMap_[pid]->audioSessionScene_ = AudioSessionScene::MEDIA;
719 sessionService->sessionMap_[pid]->state_ = AudioSessionState::SESSION_ACTIVE;
720 audioInterruptService->sessionService_ = sessionService;
721 audioFocusEntry.actionOn = INCOMING;
722 ret = audioInterruptService->CheckAudioSessionExistence(audioInterrupt, audioFocusEntry);
723 EXPECT_EQ(false, ret);
724
725 audioFocusEntry.actionOn = CURRENT;
726 ret = audioInterruptService->CheckAudioSessionExistence(audioInterrupt, audioFocusEntry);
727 EXPECT_EQ(true, ret);
728 }
729
730 /**
731 * @tc.name : Test AudioInterruptService
732 * @tc.number: AudioInterruptService_024
733 * @tc.desc : Test UpdateHintTypeForExistingSession_001
734 */
735 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_024, TestSize.Level1)
736 {
737 auto audioInterruptService = std::make_shared<AudioInterruptService>();
738 ASSERT_NE(audioInterruptService, nullptr);
739
740 int32_t pid = 123;
741 AudioInterrupt audioInterrupt;
742 AudioFocusEntry audioFocusEntry;
743 audioInterrupt.pid = pid;
744 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
745 auto ret = sessionService->SetAudioSessionScene(pid, AudioSessionScene::MEDIA);
746 EXPECT_EQ(SUCCESS, ret);
747 sessionService->sessionMap_[pid]->audioSessionScene_ = AudioSessionScene::MEDIA;
748 sessionService->sessionMap_[pid]->state_ = AudioSessionState::SESSION_ACTIVE;
749 audioInterruptService->sessionService_ = sessionService;
750 audioFocusEntry.actionOn = CURRENT;
751 audioInterruptService->UpdateHintTypeForExistingSession(audioInterrupt, audioFocusEntry);
752 }
753
754 /**
755 * @tc.name : Test AudioInterruptService
756 * @tc.number: AudioInterruptService_025
757 * @tc.desc : Test UpdateHintTypeForExistingSession_002
758 */
759 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_025, TestSize.Level1)
760 {
761 auto audioInterruptService = std::make_shared<AudioInterruptService>();
762 ASSERT_NE(audioInterruptService, nullptr);
763
764 AudioInterrupt audioInterrupt;
765 AudioFocusEntry audioFocusEntry;
766 audioInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::DUCK_OTHERS;
767 audioFocusEntry.hintType = INTERRUPT_HINT_DUCK;
768 audioInterruptService->UpdateHintTypeForExistingSession(audioInterrupt, audioFocusEntry);
769 EXPECT_EQ(INTERRUPT_HINT_DUCK, audioFocusEntry.hintType);
770
771 audioFocusEntry.hintType = INTERRUPT_HINT_PAUSE;
772 audioInterruptService->UpdateHintTypeForExistingSession(audioInterrupt, audioFocusEntry);
773 EXPECT_EQ(INTERRUPT_HINT_DUCK, audioFocusEntry.hintType);
774
775 audioFocusEntry.hintType = INTERRUPT_HINT_STOP;
776 audioInterruptService->UpdateHintTypeForExistingSession(audioInterrupt, audioFocusEntry);
777 EXPECT_EQ(INTERRUPT_HINT_DUCK, audioFocusEntry.hintType);
778
779 audioFocusEntry.hintType = INTERRUPT_HINT_RESUME;
780 audioInterruptService->UpdateHintTypeForExistingSession(audioInterrupt, audioFocusEntry);
781 EXPECT_EQ(INTERRUPT_HINT_RESUME, audioFocusEntry.hintType);
782
783 audioInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::PAUSE_OTHERS;
784 audioFocusEntry.hintType = INTERRUPT_HINT_PAUSE;
785 audioInterruptService->UpdateHintTypeForExistingSession(audioInterrupt, audioFocusEntry);
786 EXPECT_EQ(INTERRUPT_HINT_PAUSE, audioFocusEntry.hintType);
787
788 audioFocusEntry.hintType = INTERRUPT_HINT_STOP;
789 audioInterruptService->UpdateHintTypeForExistingSession(audioInterrupt, audioFocusEntry);
790 EXPECT_EQ(INTERRUPT_HINT_PAUSE, audioFocusEntry.hintType);
791
792 audioFocusEntry.hintType = INTERRUPT_HINT_RESUME;
793 audioInterruptService->UpdateHintTypeForExistingSession(audioInterrupt, audioFocusEntry);
794 EXPECT_EQ(INTERRUPT_HINT_RESUME, audioFocusEntry.hintType);
795 }
796
797 /**
798 * @tc.name : Test AudioInterruptService
799 * @tc.number: AudioInterruptService_026
800 * @tc.desc : Test ProcessExistInterrupt_001
801 */
802 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_026, TestSize.Level1)
803 {
804 auto audioInterruptService = std::make_shared<AudioInterruptService>();
805 ASSERT_NE(audioInterruptService, nullptr);
806 AudioInterrupt audioInterrupt;
807 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
808 std::list<std::pair<AudioInterrupt, AudioFocuState>> focusInfoList;
809 focusInfoList.push_back({audioInterrupt, ACTIVE});
810 AudioFocusEntry audioFocusEntry;
811 InterruptEventInternal interruptEvent {INTERRUPT_TYPE_BEGIN, INTERRUPT_FORCE,
812 INTERRUPT_HINT_NONE, 1.0f};
813 bool removeFocusInfo = false;
814 auto iterActive = focusInfoList.begin();
815 AudioInterrupt incomingInterrupt;
816 audioInterruptService->ProcessExistInterrupt(iterActive, audioFocusEntry,
817 incomingInterrupt, removeFocusInfo, interruptEvent);
818 EXPECT_FALSE(removeFocusInfo);
819
820 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
821 incomingInterrupt.currencySources.sourcesTypes.push_back(SOURCE_TYPE_MIC);
822 audioFocusEntry.hintType = INTERRUPT_HINT_STOP;
823 audioInterruptService->ProcessExistInterrupt(iterActive, audioFocusEntry,
824 incomingInterrupt, removeFocusInfo, interruptEvent);
825 EXPECT_FALSE(removeFocusInfo);
826
827 incomingInterrupt.currencySources.sourcesTypes.clear();
828 audioInterruptService->ProcessExistInterrupt(iterActive, audioFocusEntry,
829 incomingInterrupt, removeFocusInfo, interruptEvent);
830 EXPECT_TRUE(removeFocusInfo);
831 }
832
833 /**
834 * @tc.name : Test AudioInterruptService
835 * @tc.number: AudioInterruptService_027
836 * @tc.desc : Test ProcessExistInterrupt_002
837 */
838 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_027, TestSize.Level1)
839 {
840 auto audioInterruptService = std::make_shared<AudioInterruptService>();
841 ASSERT_NE(audioInterruptService, nullptr);
842 AudioInterrupt audioInterrupt;
843 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
844 std::list<std::pair<AudioInterrupt, AudioFocuState>> focusInfoList;
845 focusInfoList.push_back({audioInterrupt, ACTIVE});
846 AudioFocusEntry audioFocusEntry;
847 InterruptEventInternal interruptEvent {INTERRUPT_TYPE_BEGIN, INTERRUPT_FORCE,
848 INTERRUPT_HINT_NONE, 1.0f};
849 bool removeFocusInfo = false;
850 auto iterActive = focusInfoList.begin();
851 AudioInterrupt incomingInterrupt;
852 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
853 audioFocusEntry.hintType = INTERRUPT_HINT_PAUSE;
854 incomingInterrupt.currencySources.sourcesTypes.push_back(SOURCE_TYPE_MIC);
855 audioInterruptService->ProcessExistInterrupt(iterActive, audioFocusEntry,
856 incomingInterrupt, removeFocusInfo, interruptEvent);
857 EXPECT_FALSE(removeFocusInfo);
858
859 incomingInterrupt.currencySources.sourcesTypes.clear();
860 focusInfoList.clear();
861 focusInfoList.push_back({audioInterrupt, STOP});
862 iterActive = focusInfoList.begin();
863 audioInterruptService->ProcessExistInterrupt(iterActive, audioFocusEntry,
864 incomingInterrupt, removeFocusInfo, interruptEvent);
865 EXPECT_FALSE(removeFocusInfo);
866
867 focusInfoList.clear();
868 focusInfoList.push_back({audioInterrupt, ACTIVE});
869 iterActive = focusInfoList.begin();
870 audioInterruptService->ProcessExistInterrupt(iterActive, audioFocusEntry,
871 incomingInterrupt, removeFocusInfo, interruptEvent);
872 EXPECT_EQ(interruptEvent.hintType, audioFocusEntry.hintType);
873
874 focusInfoList.clear();
875 focusInfoList.push_back({audioInterrupt, DUCK});
876 iterActive = focusInfoList.begin();
877 audioInterruptService->ProcessExistInterrupt(iterActive, audioFocusEntry,
878 incomingInterrupt, removeFocusInfo, interruptEvent);
879 EXPECT_EQ(interruptEvent.hintType, audioFocusEntry.hintType);
880 }
881
882 /**
883 * @tc.name : Test AudioInterruptService
884 * @tc.number: AudioInterruptService_028
885 * @tc.desc : Test ProcessExistInterrupt_003
886 */
887 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_028, TestSize.Level1)
888 {
889 auto audioInterruptService = std::make_shared<AudioInterruptService>();
890 ASSERT_NE(audioInterruptService, nullptr);
891 AudioInterrupt audioInterrupt;
892 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
893 std::list<std::pair<AudioInterrupt, AudioFocuState>> focusInfoList;
894 focusInfoList.push_back({audioInterrupt, ACTIVE});
895 AudioFocusEntry audioFocusEntry;
896 InterruptEventInternal interruptEvent {INTERRUPT_TYPE_BEGIN, INTERRUPT_FORCE,
897 INTERRUPT_HINT_NONE, 1.0f};
898 bool removeFocusInfo = false;
899 auto iterActive = focusInfoList.begin();
900 AudioInterrupt incomingInterrupt;
901 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
902 audioFocusEntry.hintType = INTERRUPT_HINT_DUCK;
903 audioInterruptService->ProcessExistInterrupt(iterActive, audioFocusEntry,
904 incomingInterrupt, removeFocusInfo, interruptEvent);
905 EXPECT_EQ(DUCK, iterActive->second);
906
907 focusInfoList.clear();
908 focusInfoList.push_back({audioInterrupt, DUCK});
909 iterActive = focusInfoList.begin();
910 audioInterruptService->ProcessExistInterrupt(iterActive, audioFocusEntry,
911 incomingInterrupt, removeFocusInfo, interruptEvent);
912 EXPECT_EQ(DUCK, iterActive->second);
913 }
914
915 /**
916 * @tc.name : Test AudioInterruptService
917 * @tc.number: AudioInterruptService_029
918 * @tc.desc : Test ProcessExistInterrupt_004
919 */
920 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_029, TestSize.Level1)
921 {
922 auto audioInterruptService = std::make_shared<AudioInterruptService>();
923 ASSERT_NE(audioInterruptService, nullptr);
924 AudioInterrupt audioInterrupt;
925 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
926 std::list<std::pair<AudioInterrupt, AudioFocuState>> focusInfoList;
927 focusInfoList.push_back({audioInterrupt, ACTIVE});
928 AudioFocusEntry audioFocusEntry;
929 InterruptEventInternal interruptEvent {INTERRUPT_TYPE_BEGIN, INTERRUPT_FORCE,
930 INTERRUPT_HINT_NONE, 1.0f};
931 bool removeFocusInfo = false;
932 auto iterActive = focusInfoList.begin();
933 AudioInterrupt incomingInterrupt;
934 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
935 audioFocusEntry.hintType = INTERRUPT_HINT_MUTE;
936 audioInterruptService->ProcessExistInterrupt(iterActive, audioFocusEntry,
937 incomingInterrupt, removeFocusInfo, interruptEvent);
938 EXPECT_EQ(MUTED, iterActive->second);
939
940 focusInfoList.clear();
941 focusInfoList.push_back({audioInterrupt, MUTED});
942 iterActive = focusInfoList.begin();
943 audioInterruptService->ProcessExistInterrupt(iterActive, audioFocusEntry,
944 incomingInterrupt, removeFocusInfo, interruptEvent);
945 EXPECT_EQ(MUTED, iterActive->second);
946 }
947
948 /**
949 * @tc.name : Test AudioInterruptService
950 * @tc.number: AudioInterruptService_030
951 * @tc.desc : Test SwitchHintType_001
952 */
953 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_030, TestSize.Level1)
954 {
955 auto audioInterruptService = std::make_shared<AudioInterruptService>();
956 ASSERT_NE(audioInterruptService, nullptr);
957 AudioInterrupt audioInterrupt;
958 std::list<std::pair<AudioInterrupt, AudioFocuState>> focusInfoList;
959 focusInfoList.push_back({audioInterrupt, ACTIVE});
960 auto iterActive = focusInfoList.begin();
961 InterruptEventInternal interruptEvent;
962 std::list<std::pair<AudioInterrupt, AudioFocuState>> tempfocusInfoList;
963 interruptEvent.hintType = INTERRUPT_HINT_STOP;
964 auto ret = audioInterruptService->SwitchHintType(iterActive, interruptEvent, tempfocusInfoList);
965 EXPECT_EQ(true, ret);
966
967 interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
968 audioInterruptService->SwitchHintType(iterActive, interruptEvent, tempfocusInfoList);
969 EXPECT_EQ(PAUSEDBYREMOTE, iterActive->second);
970
971 focusInfoList.clear();
972 focusInfoList.push_back({audioInterrupt, DUCK});
973 iterActive = focusInfoList.begin();
974 audioInterruptService->SwitchHintType(iterActive, interruptEvent, tempfocusInfoList);
975 EXPECT_EQ(PAUSEDBYREMOTE, iterActive->second);
976
977 focusInfoList.clear();
978 focusInfoList.push_back({audioInterrupt, STOP});
979 iterActive = focusInfoList.begin();
980 audioInterruptService->SwitchHintType(iterActive, interruptEvent, tempfocusInfoList);
981 EXPECT_EQ(STOP, iterActive->second);
982 }
983
984 /**
985 * @tc.name : Test AudioInterruptService
986 * @tc.number: AudioInterruptService_031
987 * @tc.desc : Test SwitchHintType_002
988 */
989 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_031, TestSize.Level1)
990 {
991 auto audioInterruptService = std::make_shared<AudioInterruptService>();
992 ASSERT_NE(audioInterruptService, nullptr);
993 AudioInterrupt audioInterrupt;
994 std::list<std::pair<AudioInterrupt, AudioFocuState>> focusInfoList;
995 focusInfoList.push_back({audioInterrupt, ACTIVE});
996 auto iterActive = focusInfoList.begin();
997 InterruptEventInternal interruptEvent;
998 std::list<std::pair<AudioInterrupt, AudioFocuState>> tempfocusInfoList;
999 interruptEvent.hintType = INTERRUPT_HINT_RESUME;
1000 auto ret = audioInterruptService->SwitchHintType(iterActive, interruptEvent, tempfocusInfoList);
1001 EXPECT_EQ(false, ret);
1002
1003 focusInfoList.clear();
1004 focusInfoList.push_back({audioInterrupt, PAUSEDBYREMOTE});
1005 iterActive = focusInfoList.begin();
1006 ret = audioInterruptService->SwitchHintType(iterActive, interruptEvent, tempfocusInfoList);
1007 EXPECT_EQ(true, ret);
1008
1009 interruptEvent.hintType = INTERRUPT_HINT_DUCK;
1010 ret = audioInterruptService->SwitchHintType(iterActive, interruptEvent, tempfocusInfoList);
1011 EXPECT_EQ(false, ret);
1012 }
1013
1014 /**
1015 * @tc.name : Test AudioInterruptService
1016 * @tc.number: AudioInterruptService_032
1017 * @tc.desc : Test ProcessRemoteInterrupt_001
1018 */
1019 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_032, TestSize.Level1)
1020 {
1021 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1022 ASSERT_NE(audioInterruptService, nullptr);
1023 auto pid = getpid();
1024 auto audioInterruptZone = make_shared<AudioInterruptZone>();
1025 AudioInterrupt audioInterrupt;
1026 audioInterrupt.pid = pid;
1027 audioInterrupt.isAudioSessionInterrupt = true;
1028 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
1029 audioInterruptService->zonesMap_[0] = audioInterruptZone;
1030 std::set<int32_t> streamIds {123};
1031 InterruptEventInternal interruptEvent;
1032 audioInterruptService->ProcessRemoteInterrupt(streamIds, interruptEvent);
1033 EXPECT_EQ(0, audioInterruptZone->zoneId);
1034 }
1035
1036
1037 /**
1038 * @tc.name : Test AudioInterruptService
1039 * @tc.number: AudioInterruptService_033
1040 * @tc.desc : Test ProcessRemoteInterrupt_002
1041 */
1042 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_033, TestSize.Level1)
1043 {
1044 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1045 ASSERT_NE(audioInterruptService, nullptr);
1046 auto pid = getpid();
1047 auto audioInterruptZone = make_shared<AudioInterruptZone>();
1048 AudioInterrupt audioInterrupt;
1049 audioInterrupt.pid = pid;
1050 audioInterrupt.isAudioSessionInterrupt = true;
1051 audioInterrupt.streamId = 123;
1052 audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
1053 audioInterruptService->zonesMap_[0] = audioInterruptZone;
1054 std::set<int32_t> streamIds {123};
1055 InterruptEventInternal interruptEvent;
1056 interruptEvent.hintType = INTERRUPT_HINT_DUCK;
1057 audioInterruptService->ProcessRemoteInterrupt(streamIds, interruptEvent);
1058 EXPECT_EQ(0, audioInterruptZone->zoneId);
1059
1060 interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
1061 audioInterruptService->ProcessRemoteInterrupt(streamIds, interruptEvent);
1062 EXPECT_EQ(0, audioInterruptZone->zoneId);
1063
1064 interruptEvent.hintType = INTERRUPT_HINT_STOP;
1065 audioInterruptService->ProcessRemoteInterrupt(streamIds, interruptEvent);
1066 EXPECT_EQ(0, audioInterruptZone->zoneId);
1067 }
1068
1069 /**
1070 * @tc.name : Test AudioInterruptService
1071 * @tc.number: AudioInterruptService_034
1072 * @tc.desc : Test RemoveFocusInfo_001
1073 */
1074 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_034, TestSize.Level1)
1075 {
1076 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1077 ASSERT_NE(audioInterruptService, nullptr);
1078 AudioInterrupt audioInterrupt;
1079 audioInterrupt.pid = 123;
1080 audioInterrupt.streamId = 1234;
1081 std::list<std::pair<AudioInterrupt, AudioFocuState>> focusInfoList;
1082 focusInfoList.push_back({audioInterrupt, ACTIVE});
1083 auto iterActive = focusInfoList.begin();
1084 std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
1085 tmpFocusInfoList.push_back(*iterActive);
1086 auto zoneInfo = make_shared<AudioInterruptZone>();
1087 std::list<int32_t> removeFocusInfoPidList;
1088 audioInterruptService->RemoveFocusInfo(iterActive, tmpFocusInfoList, zoneInfo, removeFocusInfoPidList);
1089 EXPECT_TRUE(tmpFocusInfoList.empty());
1090 }
1091
1092 /**
1093 * @tc.name : Test AudioInterruptService
1094 * @tc.number: AudioInterruptService_035
1095 * @tc.desc : Test RemoveFocusInfo_002
1096 */
1097 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_035, TestSize.Level1)
1098 {
1099 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1100 ASSERT_NE(audioInterruptService, nullptr);
1101 AudioInterrupt audioInterrupt;
1102 audioInterrupt.pid = 12;
1103 audioInterrupt.streamId = 1234;
1104 std::list<std::pair<AudioInterrupt, AudioFocuState>> focusInfoList;
1105 focusInfoList.push_back({audioInterrupt, ACTIVE});
1106 auto iterActive = focusInfoList.begin();
1107 std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
1108 tmpFocusInfoList.push_back(*iterActive);
1109 auto zoneInfo = make_shared<AudioInterruptZone>();
1110 std::list<int32_t> removeFocusInfoPidList;
1111 int32_t pid = 12;
1112 audioInterruptService->sessionService_ = AudioSessionService::GetAudioSessionService();
1113 int ret = audioInterruptService->SetAudioSessionScene(pid, AudioSessionScene::MEDIA);
1114 EXPECT_EQ(SUCCESS, ret);
1115 audioInterruptService->RemoveFocusInfo(iterActive, tmpFocusInfoList, zoneInfo, removeFocusInfoPidList);
1116 EXPECT_TRUE(tmpFocusInfoList.empty());
1117 }
1118
1119 /**
1120 * @tc.name : Test AudioInterruptService
1121 * @tc.number: AudioInterruptService_036
1122 * @tc.desc : Test HandleLowPriorityEvent
1123 */
1124 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_036, TestSize.Level1)
1125 {
1126 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1127 ASSERT_NE(audioInterruptService, nullptr);
1128 int32_t pid = 123;
1129 int32_t streamId = 123;
1130 auto ret = audioInterruptService->HandleLowPriorityEvent(pid, streamId);
1131 EXPECT_EQ(false, ret);
1132
1133 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
1134 audioInterruptService->sessionService_ = sessionService;
1135 ret = audioInterruptService->HandleLowPriorityEvent(pid, streamId);
1136 EXPECT_EQ(false, ret);
1137 }
1138
1139 /**
1140 * @tc.name : Test AudioInterruptService
1141 * @tc.number: AudioInterruptService_037
1142 * @tc.desc : Test SendActiveInterruptEvent
1143 */
1144 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_037, TestSize.Level1)
1145 {
1146 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1147 ASSERT_NE(audioInterruptService, nullptr);
1148 uint32_t streamId = 123;
1149 InterruptEventInternal interruptEvent;
1150 interruptEvent.hintType = INTERRUPT_HINT_STOP;
1151 AudioInterrupt incomingInterrupt;
1152 AudioInterrupt activeInterrupt;
1153 audioInterruptService->SendActiveInterruptEvent(streamId, interruptEvent, incomingInterrupt, activeInterrupt);
1154
1155 interruptEvent.hintType = INTERRUPT_HINT_NONE;
1156 audioInterruptService->SendActiveInterruptEvent(streamId, interruptEvent, incomingInterrupt, activeInterrupt);
1157 }
1158
1159 /**
1160 * @tc.name : Test AudioInterruptService
1161 * @tc.number: AudioInterruptService_038
1162 * @tc.desc : Test IsAudioSourceConcurrency、IsMediaStream
1163 */
1164 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_038, TestSize.Level1)
1165 {
1166 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1167 ASSERT_NE(audioInterruptService, nullptr);
1168 SourceType existSourceType = SOURCE_TYPE_WAKEUP;
1169 SourceType incomingSourceType = SOURCE_TYPE_VOICE_RECOGNITION;
1170 std::vector<SourceType> existConcurrentSources, incomingConcurrentSources;
1171 incomingConcurrentSources.push_back(existSourceType);
1172 existConcurrentSources.push_back(incomingSourceType);
1173 auto ret = audioInterruptService->IsAudioSourceConcurrency(existSourceType,
1174 incomingSourceType, existConcurrentSources, incomingConcurrentSources);
1175 EXPECT_TRUE(ret);
1176
1177 AudioStreamType audioStreamType = STREAM_ALARM;
1178 ret = audioInterruptService->IsMediaStream(audioStreamType);
1179 EXPECT_FALSE(ret);
1180 }
1181
1182 /**
1183 * @tc.name : Test AudioInterruptService
1184 * @tc.number: AudioInterruptService_039
1185 * @tc.desc : Test UpdateFocusStrategy
1186 */
1187 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_039, TestSize.Level1)
1188 {
1189 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1190 ASSERT_NE(audioInterruptService, nullptr);
1191 string bundleName = "test";
1192 AudioFocusEntry focusEntry;
1193 bool isExistMediaStream = true;
1194 bool isIncomingMediaStream = true;
1195 sptr<IStandardAudioPolicyManagerListener> listener(new IStandardAudioPolicyManagerListenerStub());
1196 audioInterruptService->queryBundleNameListCallback_ = listener;
1197 audioInterruptService->UpdateFocusStrategy(bundleName, focusEntry, isExistMediaStream, isIncomingMediaStream);
1198 }
1199
1200 /**
1201 * @tc.name : Test AudioInterruptService
1202 * @tc.number: AudioInterruptService_040
1203 * @tc.desc : Test UpdateMicFocusStrategy
1204 */
1205 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_040, TestSize.Level1)
1206 {
1207 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1208 ASSERT_NE(audioInterruptService, nullptr);
1209 SourceType existSourceType, incomingSourceType;
1210 incomingSourceType = SOURCE_TYPE_INVALID;
1211 existSourceType = SOURCE_TYPE_INVALID;
1212 string bundleName = "test";
1213 AudioFocusEntry focusEntry;
1214 audioInterruptService->UpdateMicFocusStrategy(existSourceType, incomingSourceType,
1215 bundleName, focusEntry);
1216 incomingSourceType = SOURCE_TYPE_VOICE_CALL;
1217 audioInterruptService->UpdateMicFocusStrategy(existSourceType, incomingSourceType,
1218 bundleName, focusEntry);
1219 existSourceType = SOURCE_TYPE_MIC;
1220 audioInterruptService->UpdateMicFocusStrategy(existSourceType, incomingSourceType,
1221 bundleName, focusEntry);
1222 sptr<IStandardAudioPolicyManagerListener> listener(new IStandardAudioPolicyManagerListenerStub());
1223 audioInterruptService->queryBundleNameListCallback_ = listener;
1224 audioInterruptService->UpdateMicFocusStrategy(existSourceType, incomingSourceType,
1225 bundleName, focusEntry);
1226 }
1227
1228 /**
1229 * @tc.name : Test AudioInterruptService
1230 * @tc.number: AudioInterruptService_041
1231 * @tc.desc : Test FocusEntryContinue
1232 */
1233 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_041, TestSize.Level1)
1234 {
1235 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1236 ASSERT_NE(audioInterruptService, nullptr);
1237 AudioInterrupt audioInterrupt;
1238 audioInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION;
1239 audioInterrupt.uid = AUDIO_ID;
1240 audioInterrupt.currencySources.sourcesTypes.push_back(SOURCE_TYPE_INVALID);
1241 std::list<std::pair<AudioInterrupt, AudioFocuState>> list;
1242 list.push_back({audioInterrupt, ACTIVE});
1243 auto iterActive = list.begin();
1244 AudioFocusEntry focusEntry;
1245 focusEntry.actionOn = INCOMING;
1246 focusEntry.isReject = false;
1247 AudioInterrupt incomingInterrupt;
1248 incomingInterrupt.streamUsage = STREAM_USAGE_NOTIFICATION;
1249 auto ret = audioInterruptService->FocusEntryContinue(iterActive, focusEntry, incomingInterrupt);
1250 EXPECT_EQ(false, ret);
1251 incomingInterrupt.streamUsage = STREAM_USAGE_RINGTONE;
1252 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
1253 ret = audioInterruptService->FocusEntryContinue(iterActive, focusEntry, incomingInterrupt);
1254 EXPECT_EQ(true, ret);
1255 focusEntry.hintType = INTERRUPT_HINT_DUCK;
1256 ret = audioInterruptService->FocusEntryContinue(iterActive, focusEntry, incomingInterrupt);
1257 EXPECT_EQ(false, ret);
1258 }
1259
1260 /**
1261 * @tc.name : Test AudioInterruptService
1262 * @tc.number: AudioInterruptService_042
1263 * @tc.desc : Test IsLowestPriorityRecording
1264 */
1265 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_042, TestSize.Level1)
1266 {
1267 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1268 ASSERT_NE(audioInterruptService, nullptr);
1269 AudioInterrupt audioInterrupt;
1270 audioInterrupt.currencySources.sourcesTypes.push_back(SOURCE_TYPE_MIC);
1271 auto ret = audioInterruptService->IsLowestPriorityRecording(audioInterrupt);
1272 EXPECT_FALSE(ret);
1273 audioInterrupt.currencySources.sourcesTypes[0] = SOURCE_TYPE_INVALID;
1274 EXPECT_FALSE(ret);
1275 }
1276
1277 /**
1278 * @tc.name : Test AudioInterruptService
1279 * @tc.number: AudioInterruptService_043
1280 * @tc.desc : Test HadVoipStatus
1281 */
1282 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_043, TestSize.Level1)
1283 {
1284 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1285 ASSERT_NE(audioInterruptService, nullptr);
1286 AudioInterrupt audioInterrupt;
1287 audioInterrupt.pid = 123;
1288 audioInterrupt.streamId = 123;
1289 audioInterrupt.audioFocusType.streamType = STREAM_VOICE_COMMUNICATION;
1290 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
1291 audioFocusInfoList.push_back({audioInterrupt, PLACEHOLDER});
1292 auto ret = audioInterruptService->HadVoipStatus(audioInterrupt, audioFocusInfoList);
1293 EXPECT_FALSE(ret);
1294 audioInterrupt.streamId = 111;
1295 ret = audioInterruptService->HadVoipStatus(audioInterrupt, audioFocusInfoList);
1296 EXPECT_TRUE(ret);
1297 }
1298
1299 /**
1300 * @tc.name : Test AudioInterruptService
1301 * @tc.number: AudioInterruptService_044
1302 * @tc.desc : Test EvaluateWhetherContinue
1303 */
1304 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_044, TestSize.Level1)
1305 {
1306 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1307 ASSERT_NE(audioInterruptService, nullptr);
1308 AudioInterrupt incoming, inprocessing;
1309 AudioFocusEntry focusEntry;
1310 focusEntry.hintType = INTERRUPT_HINT_MUTE;
1311 auto ret = audioInterruptService->EvaluateWhetherContinue(incoming, inprocessing,
1312 focusEntry, false);
1313 EXPECT_FALSE(ret);
1314 }
1315
1316 /**
1317 * @tc.name : Test AudioInterruptService
1318 * @tc.number: AudioInterruptService_045
1319 * @tc.desc : Test GetAudioSessionUidList
1320 */
1321 HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_GetAudioSessionUidList, TestSize.Level1)
1322 {
1323 auto audioInterruptService = std::make_shared<AudioInterruptService>();
1324 ASSERT_NE(audioInterruptService, nullptr);
1325
1326 int32_t zoneId = 0;
1327 AudioInterrupt audioInterrupt;
1328 audioInterrupt.isAudioSessionInterrupt = true;
1329 audioInterrupt.uid = 1000;
1330 AudioFocuState audioFocuState = AudioFocuState::DUCK;
1331 std::pair<AudioInterrupt, AudioFocuState> tmpFocusInfoList = std::make_pair(audioInterrupt, audioFocuState);
1332
1333 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
1334 audioInterruptZone->audioFocusInfoList.push_back(tmpFocusInfoList);
1335
1336 audioInterruptService->zonesMap_.insert({zoneId, audioInterruptZone});
1337 auto ret = audioInterruptService->GetAudioSessionUidList(zoneId);
1338
1339 EXPECT_EQ(ret.size(), 1);
1340 EXPECT_EQ(ret.at(0), 1000);
1341 }
1342
1343 } // namespace AudioStandard
1344 } // namespace OHOS
1345