1 /*
2 * Copyright (c) 2024 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 #include "audio_service_log.h"
18
19 #include "audio_interrupt_service.h"
20 #include "audio_policy_server.h"
21 #include <thread>
22 #include <memory>
23 #include <vector>
24 #include "binder_invoker.h"
25 #include "invoker_factory.h"
26 #include "ipc_thread_skeleton.h"
27
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace AudioStandard {
32
33 static AudioSessionStrategy strategyTest;
34
35 static std::shared_ptr<AudioInterruptService> audioInterruptService;
36 static sptr<AudioPolicyServer> serverTest = nullptr;
37 const int32_t CALLER_PID_TEST = 0;
38 const int32_t PIT_TEST = 0;
39 const int32_t SESSION_ID_TEST = 0;
40
41 const int32_t CALLER_PID = 0;
42 const int32_t DEFAULT_ZONE_ID = 0;
43 const int32_t VALUE_ERROR = -62980098;
44 const int32_t VALUE_SUCCESS = 1065353216;
45 const int32_t SYSTEM_ABILITY_ID = 3009;
46 const int32_t CALLER_UID = 1041;
47 const int32_t INTERRUPT_HINT_ERROR = -1;
48 const bool RUN_ON_CREATE = false;
49 const bool IS_SESSION_TIMEOUT = false;
50
SetUid1041()51 void SetUid1041()
52 {
53 IRemoteInvoker *remoteInvoker =
54 IPCThreadSkeleton::GetRemoteInvoker(IRemoteObject::IF_PROT_BINDER);
55 EXPECT_NE(nullptr, remoteInvoker);
56 BinderInvoker *ipcInvoker = (BinderInvoker *)remoteInvoker;
57 ipcInvoker->status_ = IRemoteInvoker::ACTIVE_INVOKER;
58 auto state = remoteInvoker->GetStatus();
59 EXPECT_EQ(state, IRemoteInvoker::ACTIVE_INVOKER);
60 ipcInvoker->callerUid_ = CALLER_UID;
61 }
62
SetUpTestCase(void)63 void AudioInterruptUnitTest::SetUpTestCase(void) {}
64
TearDownTestCase(void)65 void AudioInterruptUnitTest::TearDownTestCase(void)
66 {
67 audioInterruptService.reset();
68 serverTest = nullptr;
69 }
SetUp(void)70 void AudioInterruptUnitTest::SetUp(void) {}
TearDown(void)71 void AudioInterruptUnitTest::TearDown(void) {}
72
GetTnterruptServiceTest()73 std::shared_ptr<AudioInterruptService> GetTnterruptServiceTest()
74 {
75 return std::make_shared<AudioInterruptService>();
76 }
77
GetServerHandlerTest()78 std::shared_ptr<AudioPolicyServerHandler> GetServerHandlerTest()
79 {
80 return DelayedSingleton<AudioPolicyServerHandler>::GetInstance();
81 }
82
83 bool g_hasServerInit = false;
GetPolicyServerTest()84 sptr<AudioPolicyServer> GetPolicyServerTest()
85 {
86 static int32_t systemAbilityId = 3009;
87 static bool runOnCreate = false;
88 static sptr<AudioPolicyServer> server =
89 sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
90 if (!g_hasServerInit) {
91 server->OnStart();
92 server->OnAddSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID, "");
93 #ifdef FEATURE_MULTIMODALINPUT_INPUT
94 server->OnAddSystemAbility(MULTIMODAL_INPUT_SERVICE_ID, "");
95 #endif
96 server->OnAddSystemAbility(BLUETOOTH_HOST_SYS_ABILITY_ID, "");
97 server->OnAddSystemAbility(POWER_MANAGER_SERVICE_ID, "");
98 server->OnAddSystemAbility(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, "");
99 server->audioPolicyService_.SetDefaultDeviceLoadFlag(true);
100 g_hasServerInit = true;
101 }
102 return server;
103 }
104
105 #define PRINT_LINE printf("debug __LINE__:%d\n", __LINE__)
106
107 /**
108 * @tc.name : Test AudioInterruptService.
109 * @tc.number: AudioInterruptService_004
110 * @tc.desc : Test AddDumpInfo.
111 */
112 HWTEST(AudioInterruptUnitTest, AudioInterruptService_004, TestSize.Level1)
113 {
114 std::string dumpString;
115 auto interruptServiceTest = GetTnterruptServiceTest();
116 interruptServiceTest->zonesMap_.clear();
117 EXPECT_EQ(interruptServiceTest->zonesMap_.empty(), true);
118 interruptServiceTest->AudioInterruptZoneDump(dumpString);
119 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
120 interruptServiceTest->zonesMap_[0]->interruptCbsMap[0] = nullptr;
121 interruptServiceTest->AudioInterruptZoneDump(dumpString);
122 EXPECT_NE(dumpString.find("1 AudioInterruptZoneDump (s) available"), std::string::npos);
123 EXPECT_NE(dumpString.find("Interrupt callback size: 1"), std::string::npos);
124 }
125
126 /**
127 * @tc.name : Test AudioInterruptService.
128 * @tc.number: AudioInterruptService_005
129 * @tc.desc : Test AbandonAudioFocus.
130 */
131 HWTEST(AudioInterruptUnitTest, AudioInterruptService_005, TestSize.Level1)
132 {
133 auto interruptServiceTest = GetTnterruptServiceTest();
134 AudioInterrupt incomingInterrupt;
135 int32_t clientID = interruptServiceTest->clientOnFocus_;
136 auto retStatus = interruptServiceTest->AbandonAudioFocus(clientID, incomingInterrupt);
137 EXPECT_EQ(retStatus, SUCCESS);
138 }
139
140 class RemoteObjectTestStub : public IRemoteObject {
141 public:
RemoteObjectTestStub()142 RemoteObjectTestStub() : IRemoteObject(u"IRemoteObject") {}
GetObjectRefCount()143 int32_t GetObjectRefCount() { return 0; };
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)144 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; };
AddDeathRecipient(const sptr<DeathRecipient> & recipient)145 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)146 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
Dump(int fd,const std::vector<std::u16string> & args)147 int Dump(int fd, const std::vector<std::u16string> &args) { return 0; };
148
149 DECLARE_INTERFACE_DESCRIPTOR(u"RemoteObjectTestStub");
150 };
151
152 /**
153 * @tc.name : Test AudioInterruptService.
154 * @tc.number: AudioInterruptService_006
155 * @tc.desc : Test SetAudioInterruptCallback and UnsetAudioInterruptCallback.
156 */
157 HWTEST(AudioInterruptUnitTest, AudioInterruptService_006, TestSize.Level1)
158 {
159 auto interruptServiceTest = GetTnterruptServiceTest();
160 auto retStatus = interruptServiceTest->SetAudioInterruptCallback(0, 0, nullptr, 0);
161 EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
162
163 retStatus = interruptServiceTest->UnsetAudioInterruptCallback(0, 0);
164 EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
165
166 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
167 retStatus = interruptServiceTest->SetAudioInterruptCallback(0, 0, sptr<RemoteObjectTestStub>::MakeSptr(), 0);
168 EXPECT_EQ(retStatus, SUCCESS);
169
170 retStatus = interruptServiceTest->SetAudioInterruptCallback(0, 0, sptr<RemoteObjectTestStub>::MakeSptr(), 0);
171 EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
172
173 retStatus = interruptServiceTest->UnsetAudioInterruptCallback(0, 0);
174 EXPECT_EQ(retStatus, SUCCESS);
175
176 retStatus = interruptServiceTest->SetAudioInterruptCallback(0, 0, sptr<RemoteObjectTestStub>::MakeSptr(), 0);
177 EXPECT_EQ(retStatus, SUCCESS);
178 interruptServiceTest->zonesMap_[0]->interruptCbsMap.clear();
179 retStatus = interruptServiceTest->UnsetAudioInterruptCallback(0, 0);
180 EXPECT_EQ(retStatus, SUCCESS);
181
182 retStatus = interruptServiceTest->SetAudioInterruptCallback(0, 0, sptr<RemoteObjectTestStub>::MakeSptr(), 0);
183 EXPECT_EQ(retStatus, SUCCESS);
184 interruptServiceTest->zonesMap_[0] = nullptr;
185 retStatus = interruptServiceTest->UnsetAudioInterruptCallback(0, 0);
186 EXPECT_EQ(retStatus, SUCCESS);
187
188 retStatus = interruptServiceTest->SetAudioInterruptCallback(0, 0, sptr<RemoteObjectTestStub>::MakeSptr(), 0);
189 EXPECT_EQ(retStatus, SUCCESS);
190 interruptServiceTest->zonesMap_.clear();
191 retStatus = interruptServiceTest->UnsetAudioInterruptCallback(0, 0);
192 EXPECT_EQ(retStatus, SUCCESS);
193 }
194
195 /**
196 * @tc.name : Test AudioInterruptService.
197 * @tc.number: AudioInterruptService_008
198 * @tc.desc : Test ResumeAudioFocusList and SimulateFocusEntry.
199 */
200 HWTEST(AudioInterruptUnitTest, AudioInterruptService_008, TestSize.Level1)
201 {
202 auto interruptServiceTest = GetTnterruptServiceTest();
203 interruptServiceTest->Init(GetPolicyServerTest());
204 interruptServiceTest->zonesMap_.clear();
205 EXPECT_EQ(interruptServiceTest->zonesMap_.size(), 0);
206 auto newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
207 EXPECT_EQ(newAudioFocuInfoList.size(), 0);
208
209 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
210 AudioInterrupt audioInterrupt1;
211 audioInterrupt1.audioFocusType.streamType = STREAM_DEFAULT;
212 audioInterrupt1.audioFocusType.sourceType = SOURCE_TYPE_MIC;
213 audioInterrupt1.audioFocusType.isPlay = false;
214 AudioInterrupt audioInterrupt2;
215 audioInterrupt2.audioFocusType.streamType = STREAM_DEFAULT;
216 audioInterrupt2.audioFocusType.sourceType = SOURCE_TYPE_MIC;
217 audioInterrupt2.audioFocusType.isPlay = false;
218
219 audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt1, AudioFocuState{PAUSE});
220 audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt2, AudioFocuState{});
221 interruptServiceTest->zonesMap_[0] = audioInterruptZone;
222 newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
223 interruptServiceTest->ResumeAudioFocusList(0, true);
224 interruptServiceTest->ResumeAudioFocusList(0, false);
225 EXPECT_EQ(newAudioFocuInfoList.size(), 2);
226 }
227
228 /**
229 * @tc.name : Test AudioInterruptService.
230 * @tc.number: AudioInterruptService_010
231 * @tc.desc : Test ResumeAudioFocusList and SimulateFocusEntry.
232 */
233 HWTEST(AudioInterruptUnitTest, AudioInterruptService_010, TestSize.Level1)
234 {
235 auto interruptServiceTest = GetTnterruptServiceTest();
236 interruptServiceTest->Init(GetPolicyServerTest());
237 interruptServiceTest->zonesMap_.clear();
238 EXPECT_EQ(interruptServiceTest->zonesMap_.size(), 0);
239 auto newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
240 EXPECT_EQ(newAudioFocuInfoList.size(), 0);
241
242 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
243 AudioInterrupt audioInterrupt1;
244 audioInterrupt1.audioFocusType.streamType = STREAM_DEFAULT;
245 audioInterrupt1.audioFocusType.sourceType = SOURCE_TYPE_MIC;
246 audioInterrupt1.audioFocusType.isPlay = false;
247 AudioInterrupt audioInterrupt2;
248 audioInterrupt2.audioFocusType.streamType = STREAM_DEFAULT;
249 audioInterrupt2.audioFocusType.sourceType = SOURCE_TYPE_MIC;
250 audioInterrupt2.audioFocusType.isPlay = false;
251
252 audioInterruptZone->audioFocusInfoList.clear();
253 audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt1, AudioFocuState{PAUSE});
254 audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt2, AudioFocuState{DUCK});
255 interruptServiceTest->zonesMap_[0] = audioInterruptZone;
256 newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
257 interruptServiceTest->ResumeAudioFocusList(0, true);
258 interruptServiceTest->ResumeAudioFocusList(0, false);
259 EXPECT_EQ(newAudioFocuInfoList.size(), 2);
260
261 audioInterruptZone->audioFocusInfoList.clear();
262 audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt1, AudioFocuState{PAUSE});
263 audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt2, AudioFocuState{STOP});
264 interruptServiceTest->zonesMap_[0] = audioInterruptZone;
265 newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
266 interruptServiceTest->ResumeAudioFocusList(0, true);
267 interruptServiceTest->ResumeAudioFocusList(0, false);
268 EXPECT_EQ(newAudioFocuInfoList.size(), 2);
269 }
270
271 /**
272 * @tc.name : Test AudioInterruptService.
273 * @tc.number: AudioInterruptService_012
274 * @tc.desc : Test ResumeAudioFocusList and SimulateFocusEntry.
275 */
276 HWTEST(AudioInterruptUnitTest, AudioInterruptService_012, TestSize.Level1)
277 {
278 auto interruptServiceTest = GetTnterruptServiceTest();
279 interruptServiceTest->Init(GetPolicyServerTest());
280 interruptServiceTest->zonesMap_.clear();
281 EXPECT_EQ(interruptServiceTest->zonesMap_.size(), 0);
282 auto newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
283 EXPECT_EQ(newAudioFocuInfoList.size(), 0);
284 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
285 audioInterruptZone->audioFocusInfoList.emplace_back(AudioInterrupt(), AudioFocuState{PAUSE});
286 audioInterruptZone->audioFocusInfoList.emplace_back(AudioInterrupt(), AudioFocuState{});
287 interruptServiceTest->zonesMap_[0] = audioInterruptZone;
288 newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
289 interruptServiceTest->ResumeAudioFocusList(0, true);
290 interruptServiceTest->ResumeAudioFocusList(0, false);
291 EXPECT_EQ(newAudioFocuInfoList.size(), 2);
292 }
293
294 /**
295 * @tc.name : Test AudioInterruptService.
296 * @tc.number: AudioInterruptService_013
297 * @tc.desc : Test ResumeAudioFocusList and SimulateFocusEntry.
298 */
299 HWTEST(AudioInterruptUnitTest, AudioInterruptService_013, TestSize.Level1)
300 {
301 auto interruptServiceTest = GetTnterruptServiceTest();
302 interruptServiceTest->Init(GetPolicyServerTest());
303 interruptServiceTest->zonesMap_.clear();
304 EXPECT_EQ(interruptServiceTest->zonesMap_.size(), 0);
305 auto newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
306 EXPECT_EQ(newAudioFocuInfoList.size(), 0);
307 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
308 audioInterruptZone->audioFocusInfoList.emplace_back(AudioInterrupt(), AudioFocuState{PAUSE});
309 audioInterruptZone->audioFocusInfoList.emplace_back(AudioInterrupt(), AudioFocuState{});
310 interruptServiceTest->zonesMap_[0] = audioInterruptZone;
311 newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
312 interruptServiceTest->ResumeAudioFocusList(0, true);
313 interruptServiceTest->ResumeAudioFocusList(0, false);
314 EXPECT_EQ(newAudioFocuInfoList.size(), 2);
315 }
316
317 /**
318 * @tc.name : Test AudioInterruptService.
319 * @tc.number: AudioInterruptService_015
320 * @tc.desc : Test SendInterruptEvent.
321 */
322 HWTEST(AudioInterruptUnitTest, AudioInterruptService_015, TestSize.Level1)
323 {
324 auto interruptServiceTest = GetTnterruptServiceTest();
325 std::list<std::pair<AudioInterrupt, AudioFocuState>> pairList;
326 pairList.emplace_back(AudioInterrupt(), AudioFocuState::ACTIVE);
327 AudioFocuState oldState{};
328 AudioFocuState newState{};
329 auto it = pairList.begin();
330 bool removeFocusInfo = true;
331 interruptServiceTest->dfxCollector_ = std::make_unique<AudioInterruptDfxCollector>();
332 interruptServiceTest->SendInterruptEvent(oldState, newState, it, removeFocusInfo);
333 interruptServiceTest->SetCallbackHandler(GetServerHandlerTest());
334 interruptServiceTest->SendInterruptEvent(oldState, newState, it, removeFocusInfo);
335
336 interruptServiceTest->SendInterruptEvent(PAUSE, ACTIVE, it, removeFocusInfo);
337 interruptServiceTest->SendInterruptEvent(DUCK, ACTIVE, it, removeFocusInfo);
338 interruptServiceTest->SendInterruptEvent(PAUSE, DUCK, it, removeFocusInfo);
339 interruptServiceTest->SendInterruptEvent(DUCK, DUCK, it, removeFocusInfo);
340 interruptServiceTest->SendInterruptEvent(DUCK, PAUSE, it, removeFocusInfo);
341 interruptServiceTest->SendInterruptEvent(PAUSE, PAUSE, it, removeFocusInfo);
342 interruptServiceTest->SendInterruptEvent(DUCK, PLACEHOLDER, it, removeFocusInfo);
343 interruptServiceTest->SendInterruptEvent(DUCK, STOP, it, removeFocusInfo);
344 EXPECT_NE(interruptServiceTest->handler_, nullptr);
345 }
346
347 /**
348 * @tc.name : Test AudioInterruptService.
349 * @tc.number: AudioInterruptService_017
350 * @tc.desc : Test IsActiveStreamLowPriority and IsIncomingStreamLowPriority.
351 */
352 HWTEST(AudioInterruptUnitTest, AudioInterruptService_017, TestSize.Level1)
353 {
354 auto interruptServiceTest = GetTnterruptServiceTest();
355 AudioFocusEntry entry;
356 entry.actionOn = INCOMING;
357 bool ret = interruptServiceTest->IsActiveStreamLowPriority(entry);
358 EXPECT_EQ(ret, false);
359
360 entry.actionOn = CURRENT;
361 entry.hintType = INTERRUPT_HINT_PAUSE;
362 ret = interruptServiceTest->IsActiveStreamLowPriority(entry);
363 EXPECT_EQ(ret, true);
364 entry.hintType = INTERRUPT_HINT_STOP;
365 ret = interruptServiceTest->IsActiveStreamLowPriority(entry);
366 EXPECT_EQ(ret, true);
367 entry.hintType = INTERRUPT_HINT_DUCK;
368 ret = interruptServiceTest->IsActiveStreamLowPriority(entry);
369 EXPECT_EQ(ret, true);
370
371 entry.hintType = INTERRUPT_HINT_UNDUCK;
372 ret = interruptServiceTest->IsActiveStreamLowPriority(entry);
373 EXPECT_EQ(ret, false);
374 entry.isReject = true;
375 ret = interruptServiceTest->IsIncomingStreamLowPriority(entry);
376 EXPECT_EQ(ret, true);
377 entry.isReject = false;
378 entry.actionOn = CURRENT;
379 ret = interruptServiceTest->IsIncomingStreamLowPriority(entry);
380 EXPECT_EQ(ret, false);
381
382 entry.actionOn = INCOMING;
383 entry.hintType = INTERRUPT_HINT_PAUSE;
384 ret = interruptServiceTest->IsIncomingStreamLowPriority(entry);
385 EXPECT_EQ(ret, true);
386 entry.hintType = INTERRUPT_HINT_STOP;
387 ret = interruptServiceTest->IsIncomingStreamLowPriority(entry);
388 EXPECT_EQ(ret, true);
389 entry.hintType = INTERRUPT_HINT_DUCK;
390 ret = interruptServiceTest->IsIncomingStreamLowPriority(entry);
391 EXPECT_EQ(ret, true);
392 entry.hintType = INTERRUPT_HINT_NONE;
393 ret = interruptServiceTest->IsIncomingStreamLowPriority(entry);
394 EXPECT_EQ(ret, false);
395 }
396
397 /**
398 * @tc.name : Test AudioInterruptService.
399 * @tc.number: AudioInterruptService_018
400 * @tc.desc : Test WriteServiceStartupError.
401 */
402 HWTEST(AudioInterruptUnitTest, AudioInterruptService_018, TestSize.Level1)
403 {
404 auto interruptServiceTest = GetTnterruptServiceTest();
405 EXPECT_NO_THROW(
406 interruptServiceTest->WriteServiceStartupError();
407 );
408 }
409
410 /**
411 * @tc.name : Test AudioInterruptService.
412 * @tc.number: AudioInterruptService_019
413 * @tc.desc : Test SendFocusChangeEvent.
414 */
415 HWTEST(AudioInterruptUnitTest, AudioInterruptService_019, TestSize.Level1)
416 {
417 auto interruptServiceTest = GetTnterruptServiceTest();
418 AudioInterrupt audioInterrupt = {};
419 EXPECT_NO_THROW(
420 interruptServiceTest->SendFocusChangeEvent(0, 0, audioInterrupt);
421
422 interruptServiceTest->SetCallbackHandler(GetServerHandlerTest());
423 interruptServiceTest->zonesMap_.clear();
424 interruptServiceTest->SendFocusChangeEvent(0, 0, audioInterrupt);
425
426 interruptServiceTest->zonesMap_[0] = nullptr;
427 interruptServiceTest->SendFocusChangeEvent(0, 0, audioInterrupt);
428
429 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();;
430 interruptServiceTest->SendFocusChangeEvent(0, 0, audioInterrupt);
431 );
432 }
433
434 /**
435 * @tc.name : Test AudioInterruptService.
436 * @tc.number: AudioInterruptService_021
437 * @tc.desc : Test ClearAudioFocusInfoListOnAccountsChanged.
438 */
439 HWTEST(AudioInterruptUnitTest, AudioInterruptService_021, TestSize.Level1)
440 {
441 auto interruptServiceTest = GetTnterruptServiceTest();
442 sptr<AudioPolicyServer> server = nullptr;
443 interruptServiceTest->zonesMap_.clear();
444 interruptServiceTest->ClearAudioFocusInfoListOnAccountsChanged(0);
445 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
446 interruptServiceTest->handler_ = nullptr;
447
448 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.empty(), true);
449 interruptServiceTest->ClearAudioFocusInfoListOnAccountsChanged(0);
450 interruptServiceTest->SetCallbackHandler(GetServerHandlerTest());
451 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.empty(), true);
452 interruptServiceTest->ClearAudioFocusInfoListOnAccountsChanged(0);
453 AudioInterrupt a1, a2, a3;
454 a1.streamUsage = StreamUsage::STREAM_USAGE_VOICE_MODEM_COMMUNICATION;
455 a2.streamUsage = StreamUsage::STREAM_USAGE_VOICE_RINGTONE;
456 a3.streamUsage = StreamUsage::STREAM_USAGE_UNKNOWN;
457 interruptServiceTest->zonesMap_[0]->audioFocusInfoList.push_back({a1, AudioFocuState::ACTIVE});
458 interruptServiceTest->zonesMap_[0]->audioFocusInfoList.push_back({a2, AudioFocuState::ACTIVE});
459 interruptServiceTest->zonesMap_[0]->audioFocusInfoList.push_back({a3, AudioFocuState::ACTIVE});
460 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 3);
461 interruptServiceTest->ClearAudioFocusInfoListOnAccountsChanged(0);
462 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 2);
463 }
464
465 /**
466 * @tc.name : Test AudioInterruptService.
467 * @tc.number: AudioInterruptService_022
468 * @tc.desc : Test ResetNonInterruptControl.
469 */
470 HWTEST(AudioInterruptUnitTest, AudioInterruptService_022, TestSize.Level1)
471 {
472 uint32_t sessionId = CLIENT_TYPE_OTHERS;
473 auto interruptServiceTest = GetTnterruptServiceTest();
474
475 interruptServiceTest->Init(GetPolicyServerTest());
476 AudioInterrupt interrupt;
477 EXPECT_NO_THROW(
478 interruptServiceTest->ResetNonInterruptControl(interrupt);
479 );
480
481 interrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
482 EXPECT_NO_THROW(
483 interruptServiceTest->ResetNonInterruptControl(interrupt);
484 );
485
486 interrupt.streamId = 2;
487 EXPECT_NO_THROW(
488 interruptServiceTest->ResetNonInterruptControl(interrupt);
489 );
490 }
491
492 /**
493 * @tc.name : Test AudioInterruptService.
494 * @tc.number: AudioInterruptService_023
495 * @tc.desc : Test CreateAudioInterruptZone.
496 */
497 HWTEST(AudioInterruptUnitTest, AudioInterruptService_023, TestSize.Level1)
498 {
499 MessageParcel data;
500 auto interruptServiceTest = GetTnterruptServiceTest();
501
502 interruptServiceTest->Init(GetPolicyServerTest());
503 interruptServiceTest->zonesMap_.clear();
504 EXPECT_EQ(interruptServiceTest->zonesMap_.empty(), true);
505 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
506 interruptServiceTest->zonesMap_[0]->interruptCbsMap[0] = nullptr;
507 std::set<int32_t> pids;
508 pids.insert(data.ReadInt32());
509 int32_t zoneId = 1;
510
511 int32_t ret = interruptServiceTest->CreateAudioInterruptZone(zoneId);
512 EXPECT_EQ(ret, SUCCESS);
513
514 zoneId = 0;
515 ret = interruptServiceTest->CreateAudioInterruptZone(zoneId);
516 EXPECT_EQ(ret, VALUE_ERROR);
517 }
518
519 /**
520 * @tc.name : Test AudioInterruptService.
521 * @tc.number: AudioInterruptService_024
522 * @tc.desc : Test ReleaseAudioInterruptZone.
523 */
524 HWTEST(AudioInterruptUnitTest, AudioInterruptService_024, TestSize.Level1)
525 {
526 auto interruptServiceTest = GetTnterruptServiceTest();
527 int32_t zoneId = 1;
528
529 auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
__anon4eb1ff3a0102(int32_t uid, const std::string &deviceTag, const std::string &streamTag, const StreamUsage &usage)530 const std::string &streamTag, const StreamUsage &usage)->int32_t {
531 return 0;
532 };
533
534 interruptServiceTest->Init(GetPolicyServerTest());
535 interruptServiceTest->zonesMap_.clear();
536 EXPECT_EQ(interruptServiceTest->zonesMap_.empty(), true);
537 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
538 interruptServiceTest->zonesMap_[0]->interruptCbsMap[0] = nullptr;
539
540 int32_t ret = interruptServiceTest->ReleaseAudioInterruptZone(zoneId, getZoneFunc);
541 EXPECT_EQ(ret, VALUE_ERROR);
542
543 zoneId = 0;
544 ret = interruptServiceTest->ReleaseAudioInterruptZone(zoneId, getZoneFunc);
545 EXPECT_EQ(ret, VALUE_ERROR);
546 }
547
548 /**
549 * @tc.name : Test AudioInterruptService.
550 * @tc.number: AudioInterruptService_025
551 * @tc.desc : Test ReleaseAudioInterruptZone.
552 */
553 HWTEST(AudioInterruptUnitTest, AudioInterruptService_025, TestSize.Level1)
554 {
555 auto interruptServiceTest = GetTnterruptServiceTest();
556 int32_t zoneId = 0;
557
558 auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
__anon4eb1ff3a0202(int32_t uid, const std::string &deviceTag, const std::string &streamTag, const StreamUsage &usage)559 const std::string &streamTag, const StreamUsage &usage)->int32_t {
560 return 0;
561 };
562
563 interruptServiceTest->Init(GetPolicyServerTest());
564 MessageParcel data;
565 std::set<int32_t> pids;
566 pids.insert(data.ReadInt32());
567
568 int32_t ret = interruptServiceTest->ReleaseAudioInterruptZone(zoneId, getZoneFunc);
569 EXPECT_EQ(ret, VALUE_ERROR);
570
571 zoneId = 1;
572 ret = interruptServiceTest->ReleaseAudioInterruptZone(zoneId, getZoneFunc);
573 EXPECT_EQ(ret, VALUE_ERROR);
574
575 zoneId = 0;
576 ret = interruptServiceTest->ReleaseAudioInterruptZone(zoneId, getZoneFunc);
577 EXPECT_EQ(ret, VALUE_ERROR);
578 }
579
580 /**
581 * @tc.name : Test AudioInterruptService.
582 * @tc.number: AudioInterruptService_027
583 * @tc.desc : Test GetAudioFocusInfoList.
584 */
585 HWTEST(AudioInterruptUnitTest, AudioInterruptService_027, TestSize.Level1)
586 {
587 auto interruptServiceTest = GetTnterruptServiceTest();
588 int32_t zoneId = 0;
589
590 interruptServiceTest->Init(GetPolicyServerTest());
591 std::list<std::pair<AudioInterrupt, AudioFocuState>> focusInfoList = {};
592 std::pair<AudioInterrupt, AudioFocuState> focusInfo = {};
593
594 int32_t ret = interruptServiceTest->GetAudioFocusInfoList(zoneId, focusInfoList);
595 EXPECT_EQ(ret, SUCCESS);
596
597 interruptServiceTest->zonesMap_.clear();
598 EXPECT_EQ(interruptServiceTest->zonesMap_.empty(), true);
599 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
600 interruptServiceTest->zonesMap_[0]->interruptCbsMap[0] = nullptr;
601
602 ret = interruptServiceTest->GetAudioFocusInfoList(zoneId, focusInfoList);
603 EXPECT_EQ(ret, SUCCESS);
604 }
605
606 /**
607 * @tc.name : Test AudioInterruptService.
608 * @tc.number: AudioInterruptService_028
609 * @tc.desc : Test GetStreamInFocus.
610 */
611 HWTEST(AudioInterruptUnitTest, AudioInterruptService_028, TestSize.Level1)
612 {
613 auto interruptServiceTest = GetTnterruptServiceTest();
614 int32_t zoneId = 0;
615
616 interruptServiceTest->Init(GetPolicyServerTest());
617 EXPECT_NO_THROW(
618 interruptServiceTest->GetStreamInFocus(zoneId);
619 );
620
621 interruptServiceTest->zonesMap_.clear();
622 EXPECT_EQ(interruptServiceTest->zonesMap_.empty(), true);
623 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
624 interruptServiceTest->zonesMap_[0]->interruptCbsMap[0] = nullptr;
625 EXPECT_NO_THROW(
626 interruptServiceTest->GetStreamInFocus(zoneId);
627 );
628 }
629
630 /**
631 * @tc.name : Test AudioInterruptService.
632 * @tc.number: AudioInterruptService_029
633 * @tc.desc : Test GetAudioServerProxy.
634 */
635 HWTEST(AudioInterruptUnitTest, AudioInterruptService_029, TestSize.Level1)
636 {
637 auto interruptServiceTest = GetTnterruptServiceTest();
638 const sptr<IStandardAudioService> result = interruptServiceTest->GetAudioServerProxy();
639 EXPECT_NE(result, nullptr);
640 }
641
642 /**
643 * @tc.name : Test AudioInterruptService.
644 * @tc.number: AudioInterruptService_030
645 * @tc.desc : Test OnSessionTimeout.
646 */
647 HWTEST(AudioInterruptUnitTest, AudioInterruptService_030, TestSize.Level1)
648 {
649 auto interruptServiceTest = GetTnterruptServiceTest();
650 AudioInterrupt audioInterrupt = {};
651 audioInterrupt.pid = 2;
652 interruptServiceTest->OnSessionTimeout(audioInterrupt.pid);
653 EXPECT_NE(interruptServiceTest, nullptr);
654 }
655
656 /**
657 * @tc.name : Test AudioInterruptService.
658 * @tc.number: AudioInterruptService_031
659 * @tc.desc : Test ActivateAudioSession.
660 */
661 HWTEST(AudioInterruptUnitTest, AudioInterruptService_031, TestSize.Level1)
662 {
663 auto interruptServiceTest = GetTnterruptServiceTest();
664 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
665 AudioSessionStrategy strategy;
666 interruptServiceTest->ActivateAudioSession(0, CALLER_PID, strategy);
667 EXPECT_NE(interruptServiceTest, nullptr);
668
669 interruptServiceTest->sessionService_ = nullptr;
670 int32_t result = interruptServiceTest->ActivateAudioSession(0, CALLER_PID, strategy);
671 EXPECT_EQ(result, ERR_UNKNOWN);
672 }
673
674 /**
675 * @tc.name : Test AudioInterruptService.
676 * @tc.number: AudioInterruptService_032
677 * @tc.desc : Test AddActiveInterruptToSession.
678 */
679 HWTEST(AudioInterruptUnitTest, AudioInterruptService_032, TestSize.Level1)
680 {
681 auto interruptServiceTest = std::make_shared<AudioInterruptService>();
682 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
683 interruptServiceTest->AddActiveInterruptToSession(CALLER_PID);
684 EXPECT_NE(interruptServiceTest, nullptr);
685
686 interruptServiceTest->sessionService_ = nullptr;
687 interruptServiceTest->AddActiveInterruptToSession(CALLER_PID);
688 EXPECT_NE(interruptServiceTest, nullptr);
689 }
690
691 /**
692 * @tc.name : Test AudioInterruptService.
693 * @tc.number: AudioInterruptService_033
694 * @tc.desc : Test DeactivateAudioSession.
695 */
696 HWTEST(AudioInterruptUnitTest, AudioInterruptService_033, TestSize.Level1)
697 {
698 auto interruptServiceTest = GetTnterruptServiceTest();
699 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
700 int32_t result = interruptServiceTest->DeactivateAudioSession(0, CALLER_PID);
701 EXPECT_NE(interruptServiceTest, nullptr);
702
703 interruptServiceTest->sessionService_ = nullptr;
704 result = interruptServiceTest->DeactivateAudioSession(0, CALLER_PID);
705 EXPECT_EQ(result, ERR_UNKNOWN);
706 }
707
708 /**
709 * @tc.name : Test AudioInterruptService.
710 * @tc.number: AudioInterruptService_034
711 * @tc.desc : Test CanMixForSession.
712 */
713 HWTEST(AudioInterruptUnitTest, AudioInterruptService_034, TestSize.Level1)
714 {
715 auto interruptServiceTest = std::make_shared<AudioInterruptService>();
716 AudioInterrupt incomingInterrupt;
717 AudioInterrupt activeInterrupt;
718 AudioFocusEntry focusEntry;
719 interruptServiceTest->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry);
720 EXPECT_NE(interruptServiceTest, nullptr);
721
722 focusEntry.isReject = true;
723 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_VOICE_RECOGNITION;
724 bool result = interruptServiceTest->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry);
725 EXPECT_EQ(result, false);
726 }
727
728 /**
729 * @tc.name : Test AudioInterruptService.
730 * @tc.number: AudioInterruptService_035
731 * @tc.desc : Test CanMixForIncomingSession.
732 */
733 HWTEST(AudioInterruptUnitTest, AudioInterruptService_035, TestSize.Level1)
734 {
735 auto interruptServiceTest = std::make_shared<AudioInterruptService>();
736 AudioInterrupt incomingInterrupt;
737 AudioInterrupt activeInterrupt;
738 AudioFocusEntry focusEntry;
739 interruptServiceTest->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry);
740 EXPECT_NE(interruptServiceTest, nullptr);
741
742 interruptServiceTest->sessionService_ = nullptr;
743 bool result = interruptServiceTest->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry);
744 EXPECT_EQ(result, false);
745 }
746
747 /**
748 * @tc.name : Test AudioInterruptService.
749 * @tc.number: AudioInterruptService_036
750 * @tc.desc : Test CanMixForActiveSession.
751 */
752 HWTEST(AudioInterruptUnitTest, AudioInterruptService_036, TestSize.Level1)
753 {
754 auto interruptServiceTest = std::make_shared<AudioInterruptService>();
755 AudioInterrupt incomingInterrupt;
756 AudioInterrupt activeInterrupt;
757 AudioFocusEntry focusEntry;
758 interruptServiceTest->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
759 EXPECT_NE(interruptServiceTest, nullptr);
760
761 interruptServiceTest->sessionService_ = nullptr;
762 bool result = interruptServiceTest->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
763 EXPECT_EQ(result, false);
764 }
765
766 /**
767 * @tc.name : Test AudioInterruptService.
768 * @tc.number: AudioInterruptService_037
769 * @tc.desc : Test RequestAudioFocus.
770 */
771 HWTEST(AudioInterruptUnitTest, AudioInterruptService_037, TestSize.Level1)
772 {
773 auto interruptServiceTest = GetTnterruptServiceTest();
774 int32_t clientId = interruptServiceTest->clientOnFocus_;
775 AudioInterrupt audioInterrupt = {};
776 audioInterrupt.contentType = ContentType::CONTENT_TYPE_RINGTONE;
777 audioInterrupt.streamUsage = StreamUsage::STREAM_USAGE_VOICE_RINGTONE;
778 audioInterrupt.audioFocusType.streamType = STREAM_RING;
779 int32_t result = interruptServiceTest->RequestAudioFocus(clientId, audioInterrupt);
780 EXPECT_EQ(result, SUCCESS);
781 }
782
783 /**
784 * @tc.name : Test AudioInterruptService.
785 * @tc.number: AudioInterruptService_038
786 * @tc.desc : Test AbandonAudioFocus.
787 */
788 HWTEST(AudioInterruptUnitTest, AudioInterruptService_038, TestSize.Level1)
789 {
790 auto interruptServiceTest = GetTnterruptServiceTest();
791 int32_t clientId = interruptServiceTest->clientOnFocus_;
792 AudioInterrupt audioInterrupt = {};
793 audioInterrupt.contentType = ContentType::CONTENT_TYPE_RINGTONE;
794 audioInterrupt.streamUsage = StreamUsage::STREAM_USAGE_VOICE_RINGTONE;
795 audioInterrupt.audioFocusType.streamType = STREAM_RING;
796 int32_t result = interruptServiceTest->AbandonAudioFocus(clientId, audioInterrupt);
797 EXPECT_EQ(result, SUCCESS);
798 }
799
800 /**
801 * @tc.name : Test AudioInterruptService.
802 * @tc.number: AudioInterruptService_039
803 * @tc.desc : Test AudioInterruptIsActiveInFocusList.
804 */
805 HWTEST(AudioInterruptUnitTest, AudioInterruptService_039, TestSize.Level1)
806 {
807 auto interruptServiceTest = GetTnterruptServiceTest();
808 int32_t zoneId = 0;
809 uint32_t incomingSessionId = 0;
810 bool result = interruptServiceTest->AudioInterruptIsActiveInFocusList(zoneId, incomingSessionId);
811 EXPECT_EQ(result, 0);
812 zoneId = 1;
813 incomingSessionId = 1;
814 result = interruptServiceTest->AudioInterruptIsActiveInFocusList(zoneId, incomingSessionId);
815 EXPECT_EQ(result, 0);
816 zoneId = 0;
817 incomingSessionId = 2;
818 result = interruptServiceTest->AudioInterruptIsActiveInFocusList(zoneId, incomingSessionId);
819 EXPECT_EQ(result, 0);
820 }
821
822 /**
823 * @tc.name : Test AudioInterruptService.
824 * @tc.number: AudioInterruptService_040
825 * @tc.desc : Test ClearAudioFocusBySessionID.
826 */
827 HWTEST(AudioInterruptUnitTest, AudioInterruptService_040, TestSize.Level1)
828 {
829 auto interruptServiceTest = GetTnterruptServiceTest();
830 sptr<AudioPolicyServer> server = nullptr;
831 interruptServiceTest->zonesMap_.clear();
832 interruptServiceTest->ClearAudioFocusBySessionID(0);
833 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
834
835 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.empty(), true);
836 interruptServiceTest->ClearAudioFocusBySessionID(0);
837 interruptServiceTest->SetCallbackHandler(GetServerHandlerTest());
838 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.empty(), true);
839 interruptServiceTest->ClearAudioFocusBySessionID(0);
840 AudioInterrupt a1;
841 a1.streamId = 1;
842 interruptServiceTest->zonesMap_[0]->audioFocusInfoList.push_back({a1, AudioFocuState::ACTIVE});
843 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 1);
844 interruptServiceTest->ClearAudioFocusBySessionID(0);
845 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 1);
846 interruptServiceTest->ClearAudioFocusBySessionID(-1);
847 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 1);
848 interruptServiceTest->ClearAudioFocusBySessionID(1);
849 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 0);
850 }
851
852 /**
853 * @tc.name : Test AudioInterruptService.
854 * @tc.number: AudioInterruptServiceCanMixForIncomingSession_001
855 * @tc.desc : Test CanMixForIncomingSession. sessionService_ is nullptr.
856 */
857 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_001, TestSize.Level1)
858 {
859 auto interruptService = GetTnterruptServiceTest();
860 interruptService->sessionService_ = nullptr;
861 AudioInterrupt incomingInterrupt;
862 AudioInterrupt activeInterrupt;
863 AudioFocusEntry focusEntry;
864 auto ret = interruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry);
865 EXPECT_FALSE(ret);
866 }
867
868 /**
869 * @tc.name : Test AudioInterruptService.
870 * @tc.number: AudioInterruptServiceCanMixForIncomingSession_002
871 * @tc.desc : Test CanMixForIncomingSession. incomingInterrupt.pid is -1
872 */
873 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_002, TestSize.Level1)
874 {
875 auto interruptService = GetTnterruptServiceTest();
876 auto server = GetPolicyServerTest();
877 interruptService->Init(server);
878 AudioInterrupt incomingInterrupt;
879 AudioInterrupt activeInterrupt;
880 AudioFocusEntry focusEntry;
881 auto ret = interruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry);
882 EXPECT_FALSE(ret);
883 }
884
885 /**
886 * @tc.name : Test AudioInterruptService.
887 * @tc.number: AudioInterruptServiceCanMixForIncomingSession_003
888 * @tc.desc : Test CanMixForIncomingSession. incomingSession is nullptr.
889 */
890 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_003, TestSize.Level1)
891 {
892 auto interruptService = GetTnterruptServiceTest();
893 auto server = GetPolicyServerTest();
894 interruptService->Init(server);
895 AudioInterrupt incomingInterrupt;
896 AudioInterrupt activeInterrupt;
897 AudioFocusEntry focusEntry;
898 int32_t ret = interruptService->ActivateAudioSession(0, incomingInterrupt.pid, strategyTest);
899 EXPECT_EQ(SUCCESS, ret);
900
901 EXPECT_FALSE(interruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry));
902 }
903
904 /**
905 * @tc.name : Test AudioInterruptService.
906 * @tc.number: AudioInterruptServiceCanMixForIncomingSession_004
907 * @tc.desc : Test CanMixForIncomingSession. IsIncomingStreamLowPriority(focusEntry) is true.
908 */
909 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_004, TestSize.Level1)
910 {
911 auto interruptService = GetTnterruptServiceTest();
912 auto server = GetPolicyServerTest();
913 interruptService->Init(server);
914 AudioInterrupt incomingInterrupt;
915 AudioInterrupt activeInterrupt;
916 AudioFocusEntry focusEntry;
917 strategyTest.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
918 int32_t ret = interruptService->ActivateAudioSession(0, incomingInterrupt.pid, strategyTest);
919 EXPECT_EQ(SUCCESS, ret);
920
921 focusEntry.isReject = true;
922 EXPECT_FALSE(interruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry));
923 }
924
925 /**
926 * @tc.name : Test AudioInterruptService.
927 * @tc.number: AudioInterruptServiceCanMixForIncomingSession_005
928 * @tc.desc : Test CanMixForIncomingSession. IsIncomingStreamLowPriority(focusEntry) is false.
929 */
930 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_005, TestSize.Level1)
931 {
932 auto interruptService = GetTnterruptServiceTest();
933 auto server = GetPolicyServerTest();
934 interruptService->Init(server);
935 AudioInterrupt incomingInterrupt;
936 AudioInterrupt activeInterrupt;
937 AudioFocusEntry focusEntry;
938 strategyTest.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
939 int32_t ret = interruptService->ActivateAudioSession(0, incomingInterrupt.pid, strategyTest);
940 EXPECT_EQ(SUCCESS, ret);
941
942 focusEntry.isReject = false;
943 focusEntry.actionOn = CURRENT;
944 EXPECT_TRUE(interruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry));
945 }
946
947 /**
948 * @tc.name : Test AudioInterruptService.
949 * @tc.number: AudioInterruptServiceCanMixForSession_001
950 * @tc.desc : Test CanMixForSession.
951 */
952 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_001, TestSize.Level1)
953 {
954 auto interruptService = GetTnterruptServiceTest();
955 auto server = GetPolicyServerTest();
956 interruptService->Init(server);
957 AudioInterrupt incomingInterrupt;
958 AudioInterrupt activeInterrupt;
959 AudioFocusEntry focusEntry;
960 focusEntry.isReject = true;
961 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
962
963 auto ret = interruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry);
964 EXPECT_FALSE(ret);
965 }
966
967 /**
968 * @tc.name : Test AudioInterruptService.
969 * @tc.number: AudioInterruptServiceCanMixForSession_002
970 * @tc.desc : Test CanMixForSession.
971 */
972 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_002, TestSize.Level1)
973 {
974 auto interruptService = GetTnterruptServiceTest();
975 auto server = GetPolicyServerTest();
976 interruptService->Init(server);
977 AudioInterrupt incomingInterrupt;
978 AudioInterrupt activeInterrupt;
979 AudioFocusEntry focusEntry;
980 focusEntry.isReject = false;
981 focusEntry.actionOn = CURRENT;
982 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
983 strategyTest.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
984 int32_t ret = interruptService->ActivateAudioSession(0, incomingInterrupt.pid, strategyTest);
985 EXPECT_EQ(SUCCESS, ret);
986
987 ret = interruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry);
988 EXPECT_TRUE(ret);
989 }
990
991 /**
992 * @tc.name : Test AudioInterruptService.
993 * @tc.number: AudioInterruptServiceCanMixForSession_003
994 * @tc.desc : Test CanMixForSession.
995 */
996 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_003, TestSize.Level1)
997 {
998 auto interruptService = GetTnterruptServiceTest();
999 auto server = GetPolicyServerTest();
1000 interruptService->Init(server);
1001 AudioInterrupt incomingInterrupt;
1002 AudioInterrupt activeInterrupt;
1003 AudioFocusEntry focusEntry;
1004 focusEntry.isReject = false;
1005 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
1006 int32_t ret = interruptService->ActivateAudioSession(0, incomingInterrupt.pid, strategyTest);
1007 EXPECT_EQ(SUCCESS, ret);
1008
1009 focusEntry.actionOn = CURRENT;
1010 strategyTest.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
1011 ret = interruptService->ActivateAudioSession(0, activeInterrupt.pid, strategyTest);
1012 EXPECT_EQ(SUCCESS, ret);
1013
1014 ret = interruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry);
1015 EXPECT_TRUE(ret);
1016 }
1017
1018 /**
1019 * @tc.name : Test AudioInterruptService.
1020 * @tc.number: AudioInterruptServiceCanMixForSession_004
1021 * @tc.desc : Test CanMixForSession.
1022 */
1023 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_004, TestSize.Level1)
1024 {
1025 auto interruptService = GetTnterruptServiceTest();
1026 interruptService->SetCallbackHandler(GetServerHandlerTest());
1027 auto server = GetPolicyServerTest();
1028 interruptService->Init(server);
1029 AudioFocusType audioFocusTypeTest;
1030 AudioInterrupt incomingInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1031 AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1032 activeInterrupt.pid = { -1 };
1033 AudioFocusEntry focusEntry;
1034 focusEntry.isReject = true;
1035 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
1036
1037 auto ret = interruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry);
1038 EXPECT_TRUE(ret);
1039 }
1040
1041 /**
1042 * @tc.name : Test AudioInterruptService.
1043 * @tc.number: AudioInterruptServiceRemovePlaceholderInterruptForSession_001
1044 * @tc.desc : Test RemovePlaceholderInterruptForSession. sessionService_ is nullptr.
1045 */
1046 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRemovePlaceholderInterruptForSession_001, TestSize.Level1)
1047 {
1048 auto interruptService = GetTnterruptServiceTest();
1049 interruptService->sessionService_ = nullptr;
1050 int32_t pid = CALLER_PID;
1051 bool timeOut = IS_SESSION_TIMEOUT;
1052 interruptService->RemovePlaceholderInterruptForSession(pid, timeOut);
1053
1054 auto server = GetPolicyServerTest();
1055 interruptService->Init(server);
1056 int32_t ret = interruptService->ActivateAudioSession(0, pid, strategyTest);
1057 EXPECT_EQ(SUCCESS, ret);
1058 interruptService->RemovePlaceholderInterruptForSession(pid, timeOut);
1059 EXPECT_TRUE(interruptService->sessionService_->IsAudioSessionActivated(pid));
1060 }
1061
1062 /**
1063 * @tc.name : Test AudioInterruptService.
1064 * @tc.number: AudioInterruptServiceRemovePlaceholderInterruptForSession_002
1065 * @tc.desc : Test RemovePlaceholderInterruptForSession. About itZone.
1066 */
1067 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRemovePlaceholderInterruptForSession_002, TestSize.Level1)
1068 {
1069 auto interruptService = GetTnterruptServiceTest();
1070 auto server = GetPolicyServerTest();
1071 interruptService->Init(server);
1072 int32_t pid = CALLER_PID;
1073 bool timeOut = IS_SESSION_TIMEOUT;
1074 interruptService->zonesMap_.find(DEFAULT_ZONE_ID)->second = nullptr;
1075 interruptService->RemovePlaceholderInterruptForSession(pid, timeOut);
1076
1077 AudioInterrupt audioInterrupt = {};
1078 audioInterrupt.streamId = 2;
1079 audioInterrupt.pid = 2;
1080 interruptService->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1081 interruptService->zonesMap_[0]->audioFocusInfoList.push_back(std::make_pair(audioInterrupt, ACTIVE));
1082 interruptService->RemovePlaceholderInterruptForSession(pid, timeOut);
1083 EXPECT_FALSE(interruptService->zonesMap_.empty());
1084 }
1085
1086 /**
1087 * @tc.name : Test AudioInterruptService.
1088 * @tc.number: AudioInterruptServiceRemovePlaceholderInterruptForSession_003
1089 * @tc.desc : Test RemovePlaceholderInterruptForSession. About itZone.
1090 */
1091 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRemovePlaceholderInterruptForSession_003, TestSize.Level1)
1092 {
1093 auto interruptService = GetTnterruptServiceTest();
1094 auto server = GetPolicyServerTest();
1095 interruptService->Init(server);
1096
1097 bool timeOut = IS_SESSION_TIMEOUT;
1098 AudioInterrupt audioInterrupt = {};
1099 audioInterrupt.streamId = 2;
1100 audioInterrupt.pid = 2;
1101 int32_t pid = audioInterrupt.pid;
1102 interruptService->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1103 interruptService->zonesMap_[0]->audioFocusInfoList.push_back(std::make_pair(audioInterrupt, PLACEHOLDER));
1104 interruptService->RemovePlaceholderInterruptForSession(pid, timeOut);
1105 EXPECT_FALSE(interruptService->zonesMap_.empty());
1106 }
1107
1108 /**
1109 * @tc.name : Test AudioInterruptService.
1110 * @tc.number: AudioInterruptServiceDeactivateAudioSession_001
1111 * @tc.desc : Test DeactivateAudioSession.
1112 */
1113 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceDeactivateAudioSession_001, TestSize.Level1)
1114 {
1115 auto interruptService = GetTnterruptServiceTest();
1116 interruptService->sessionService_ = nullptr;
1117 int32_t pid = CALLER_PID;
1118 int32_t ret = interruptService->DeactivateAudioSession(0, pid);
1119 EXPECT_EQ(ERR_UNKNOWN, ret);
1120
1121 auto server = GetPolicyServerTest();
1122 interruptService->Init(server);
1123 ret = interruptService->DeactivateAudioSession(0, pid);
1124 EXPECT_EQ(SUCCESS, ret);
1125
1126 strategyTest.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
1127 ret = interruptService->ActivateAudioSession(0, pid, strategyTest);
1128 EXPECT_EQ(SUCCESS, ret);
1129 ret = interruptService->DeactivateAudioSession(0, pid);
1130 EXPECT_EQ(SUCCESS, ret);
1131 }
1132
1133 /**
1134 * @tc.name : Test AudioInterruptService.
1135 * @tc.number: AudioInterruptServiceAddActiveInterruptToSession_001
1136 * @tc.desc : Test AddActiveInterruptToSession. sessionService_ is nullptr.
1137 */
1138 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_001, TestSize.Level1)
1139 {
1140 auto interruptService = GetTnterruptServiceTest();
1141 interruptService->sessionService_ = nullptr;
1142 int32_t pid = CALLER_PID;
1143 interruptService->AddActiveInterruptToSession(pid);
1144
1145 auto server = GetPolicyServerTest();
1146 interruptService->Init(server);
1147 interruptService->AddActiveInterruptToSession(pid);
1148 EXPECT_FALSE(interruptService->sessionService_->IsAudioSessionActivated(pid));
1149 }
1150
1151 /**
1152 * @tc.name : Test AudioInterruptService.
1153 * @tc.number: AudioInterruptServiceAddActiveInterruptToSession_002
1154 * @tc.desc : Test AddActiveInterruptToSession. About itZone.
1155 */
1156 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_002, TestSize.Level1)
1157 {
1158 auto interruptService = GetTnterruptServiceTest();
1159 auto server = GetPolicyServerTest();
1160 interruptService->Init(server);
1161 int32_t pid = CALLER_PID;
1162 int32_t ret = interruptService->ActivateAudioSession(0, pid, strategyTest);
1163 EXPECT_EQ(SUCCESS, ret);
1164 interruptService->zonesMap_.find(DEFAULT_ZONE_ID)->second = nullptr;
1165 interruptService->AddActiveInterruptToSession(pid);
1166
1167 AudioInterrupt audioInterrupt = {};
1168 audioInterrupt.streamId = 2;
1169 audioInterrupt.pid = 2;
1170 interruptService->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1171 interruptService->zonesMap_[0]->audioFocusInfoList.push_back(std::make_pair(audioInterrupt, ACTIVE));
1172 interruptService->AddActiveInterruptToSession(pid);
1173 EXPECT_FALSE(interruptService->zonesMap_.empty());
1174 }
1175
1176 /**
1177 * @tc.name : Test AudioInterruptService.
1178 * @tc.number: AudioInterruptServiceAddActiveInterruptToSession_003
1179 * @tc.desc : Test AddActiveInterruptToSession. About itZone.
1180 */
1181 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_003, TestSize.Level1)
1182 {
1183 auto interruptService = GetTnterruptServiceTest();
1184 auto server = GetPolicyServerTest();
1185 interruptService->Init(server);
1186 int32_t pid = CALLER_PID;
1187 int32_t ret = interruptService->ActivateAudioSession(0, pid, strategyTest);
1188 EXPECT_EQ(SUCCESS, ret);
1189
1190 AudioInterrupt audioInterrupt = {};
1191 audioInterrupt.streamId = CALLER_PID;
1192 audioInterrupt.pid = CALLER_PID;
1193 interruptService->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1194 interruptService->zonesMap_[0]->audioFocusInfoList.push_back(std::make_pair(audioInterrupt, ACTIVE));
1195 interruptService->AddActiveInterruptToSession(pid);
1196 EXPECT_FALSE(interruptService->zonesMap_.empty());
1197 }
1198
1199 /**
1200 * @tc.name : Test AudioInterruptService.
1201 * @tc.number: AudioInterruptServiceAddActiveInterruptToSession_004
1202 * @tc.desc : Test AddActiveInterruptToSession. About itZone.
1203 */
1204 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_004, TestSize.Level1)
1205 {
1206 auto interruptService = GetTnterruptServiceTest();
1207 auto server = GetPolicyServerTest();
1208 interruptService->Init(server);
1209 interruptService->zonesMap_.clear();
1210 int32_t pid = CALLER_PID;
1211 AudioInterrupt audioInterrupt = {};
1212 audioInterrupt.streamId = CALLER_PID;
1213 audioInterrupt.pid = CALLER_PID;
1214 interruptService->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1215 interruptService->zonesMap_[0]->audioFocusInfoList.push_back(std::make_pair(audioInterrupt, ACTIVE));
1216 int32_t ret = interruptService->ActivateAudioSession(0, pid, strategyTest);
1217 EXPECT_EQ(SUCCESS, ret);
1218 interruptService->AddActiveInterruptToSession(pid);
1219 EXPECT_FALSE(interruptService->zonesMap_.empty());
1220 interruptService->zonesMap_.clear();
1221 }
1222
1223 /**
1224 * @tc.name : Test AudioInterruptService.
1225 * @tc.number: AudioInterruptServiceAddActiveInterruptToSession_005
1226 * @tc.desc : Test AddActiveInterruptToSession. About itZone. itZone->second != nullptr.
1227 */
1228 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_005, TestSize.Level1)
1229 {
1230 auto interruptService = GetTnterruptServiceTest();
1231 auto server = GetPolicyServerTest();
1232 interruptService->Init(server);
1233 interruptService->zonesMap_.clear();
1234 int32_t pid = CALLER_PID;
1235 AudioInterrupt audioInterrupt = {};
1236 audioInterrupt.streamId = CALLER_PID;
1237 audioInterrupt.pid = CALLER_PID;
1238 std::shared_ptr<AudioInterruptZone> audioInterruptZone = nullptr;
1239 interruptService->zonesMap_[0] = audioInterruptZone;
1240 int32_t ret = interruptService->ActivateAudioSession(0, pid, strategyTest);
1241 EXPECT_EQ(SUCCESS, ret);
1242 interruptService->AddActiveInterruptToSession(pid);
1243 EXPECT_FALSE(interruptService->zonesMap_.empty());
1244 interruptService->zonesMap_.clear();
1245 audioInterruptZone.reset();
1246 }
1247
1248 /**
1249 * @tc.name : Test GetAudioServerProxy API.
1250 * @tc.number: AudioInterruptServiceGetAudioServerProxy_001
1251 * @tc.desc : Test OnSessionTimeout when g_adProxy is nullptr.
1252 */
1253 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceGetAudioServerProxy_001, TestSize.Level1)
1254 {
1255 audioInterruptService = GetTnterruptServiceTest();
1256 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1257 EXPECT_NE(nullptr, audioInterruptService);
1258
1259 sptr<IStandardAudioService> ret = audioInterruptService->GetAudioServerProxy();
1260 EXPECT_NE(nullptr, ret);
1261 }
1262
1263 /**
1264 * @tc.name : Test GetAudioServerProxy API.
1265 * @tc.number: AudioInterruptServiceGetAudioServerProxy_002
1266 * @tc.desc : Test OnSessionTimeout when g_adProxy is not nullptr.
1267 */
1268 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceGetAudioServerProxy_002, TestSize.Level1)
1269 {
1270 audioInterruptService = GetTnterruptServiceTest();
1271 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1272 EXPECT_NE(nullptr, audioInterruptService);
1273
1274 sptr<IStandardAudioService> ret = audioInterruptService->GetAudioServerProxy();
1275 ret = audioInterruptService->GetAudioServerProxy();
1276 EXPECT_NE(nullptr, ret);
1277 }
1278
1279 /**
1280 * @tc.name : Test OnSessionTimeout API.
1281 * @tc.number: AudioInterruptServiceOnSessionTimeout_001
1282 * @tc.desc : Test normal OnSessionTimeout.
1283 * Test normal HandleSessionTimeOutEvent.
1284 */
1285 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceOnSessionTimeout_001, TestSize.Level1)
1286 {
1287 audioInterruptService = GetTnterruptServiceTest();
1288 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1289 EXPECT_NE(nullptr, audioInterruptService);
1290
1291 audioInterruptService->Init(serverTest);
1292 audioInterruptService->OnSessionTimeout(PIT_TEST);
1293 EXPECT_NE(nullptr, audioInterruptService->handler_);
1294 }
1295
1296 /**
1297 * @tc.name : Test OnSessionTimeout API.
1298 * @tc.number: AudioInterruptServiceOnSessionTimeout_002
1299 * @tc.desc : Test normal OnSessionTimeout.
1300 * Test normal HandleSessionTimeOutEvent.
1301 */
1302 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceOnSessionTimeout_002, TestSize.Level1)
1303 {
1304 audioInterruptService = GetTnterruptServiceTest();
1305 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1306 EXPECT_NE(nullptr, audioInterruptService);
1307
1308 audioInterruptService->Init(serverTest);
1309 audioInterruptService->handler_ = nullptr;
1310 audioInterruptService->OnSessionTimeout(PIT_TEST);
1311 EXPECT_EQ(nullptr, audioInterruptService->handler_);
1312 }
1313
1314 /**
1315 * @tc.name : Test ActivateAudioSession API.
1316 * @tc.number: AudioInterruptServiceActivateAudioSession_001
1317 * @tc.desc : Test ActivateAudioSession when sessionService_ is nullptr.
1318 */
1319 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceActivateAudioSession_001, TestSize.Level1)
1320 {
1321 audioInterruptService = GetTnterruptServiceTest();
1322 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1323 EXPECT_NE(nullptr, audioInterruptService);
1324
1325 audioInterruptService->Init(serverTest);
1326 audioInterruptService->sessionService_ = nullptr;
1327 int32_t ret = audioInterruptService->ActivateAudioSession(0, CALLER_PID_TEST, strategyTest);
1328 EXPECT_EQ(ERR_UNKNOWN, ret);
1329 }
1330
1331 /**
1332 * @tc.name : Test ActivateAudioSession API.
1333 * @tc.number: AudioInterruptServiceActivateAudioSession_002
1334 * @tc.desc : Test normal ActivateAudioSession.
1335 */
1336 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceActivateAudioSession_002, TestSize.Level1)
1337 {
1338 audioInterruptService = GetTnterruptServiceTest();
1339 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1340 EXPECT_NE(nullptr, audioInterruptService);
1341
1342 audioInterruptService->Init(serverTest);
1343 int32_t ret = audioInterruptService->ActivateAudioSession(0, CALLER_PID_TEST, strategyTest);
1344 EXPECT_EQ(SUCCESS, ret);
1345 }
1346
1347 /**
1348 * @tc.name : Test AudioInterruptService.
1349 * @tc.number: AudioInterruptServiceUnsetAudioManagerInterruptCallback_001
1350 * @tc.desc : Test UnsetAudioManagerInterruptCallback.
1351 */
1352 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceUnsetAudioManagerInterruptCallback_001, TestSize.Level1)
1353 {
1354 sptr<AudioPolicyServer> server = nullptr;
1355 auto interruptServiceTest = GetTnterruptServiceTest();
1356 interruptServiceTest->Init(server);
1357
1358 auto retStatus = interruptServiceTest->UnsetAudioManagerInterruptCallback();
1359 EXPECT_EQ(retStatus, SUCCESS);
1360
1361 interruptServiceTest->handler_ = GetServerHandlerTest();
1362 retStatus = interruptServiceTest->UnsetAudioManagerInterruptCallback();
1363 EXPECT_EQ(retStatus, -62980100);
1364 }
1365
1366 /**
1367 * @tc.name : Test IsAudioSessionActivated API.
1368 * @tc.number: AudioInterruptServiceIsAudioSessionActivated_001
1369 * @tc.desc : Test IsAudioSessionActivated when sessionService_ is not nullptr.
1370 */
1371 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceIsAudioSessionActivated_001, TestSize.Level1)
1372 {
1373 audioInterruptService = GetTnterruptServiceTest();
1374 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1375 EXPECT_NE(nullptr, audioInterruptService);
1376
1377 audioInterruptService->Init(serverTest);
1378 EXPECT_NE(nullptr, audioInterruptService->sessionService_);
1379 int32_t PIT_TEST { -1 };
1380 bool ret = audioInterruptService->IsAudioSessionActivated(PIT_TEST);
1381 EXPECT_TRUE(ret);
1382 }
1383
1384 /**
1385 * @tc.name : Test IsAudioSessionActivated API.
1386 * @tc.number: AudioInterruptServiceIsAudioSessionActivated_002
1387 * @tc.desc : Test IsAudioSessionActivated when sessionService_ is nullptr.
1388 */
1389 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceIsAudioSessionActivated_002, TestSize.Level1)
1390 {
1391 audioInterruptService = GetTnterruptServiceTest();
1392 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1393 EXPECT_NE(nullptr, audioInterruptService);
1394
1395 audioInterruptService->Init(serverTest);
1396 audioInterruptService->sessionService_ = nullptr;
1397 int32_t PIT_TEST { -1 };
1398 bool ret = audioInterruptService->IsAudioSessionActivated(PIT_TEST);
1399 EXPECT_FALSE(ret);
1400 }
1401
1402 /**
1403 * @tc.name : Test CanMixForActiveSession API.
1404 * @tc.number: AudioInterruptServiceCanMixForActiveSession_001
1405 * @tc.desc : Test CanMixForActiveSession when return true.
1406 */
1407 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_001, TestSize.Level1)
1408 {
1409 audioInterruptService = GetTnterruptServiceTest();
1410 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1411 EXPECT_NE(nullptr, audioInterruptService);
1412
1413 audioInterruptService->Init(serverTest);
1414 AudioFocusType audioFocusTypeTest;
1415 AudioInterrupt incomingInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1416 AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1417 AudioFocusEntry focusEntry;
1418 AudioSessionStrategy strategy;
1419 strategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
1420 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(0, strategy, nullptr);
1421 activeInterrupt.pid = { 0 };
1422 audioInterruptService->sessionService_->sessionMap_.insert({0, audioSession});
1423 focusEntry.actionOn = INCOMING;
1424 bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
1425 EXPECT_TRUE(ret);
1426 }
1427
1428 /**
1429 * @tc.name : Test CanMixForActiveSession API.
1430 * @tc.number: AudioInterruptServiceCanMixForActiveSession_002
1431 * @tc.desc : Test CanMixForActiveSession when sessionService_ is nullptr.
1432 */
1433 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_002, TestSize.Level1)
1434 {
1435 audioInterruptService = GetTnterruptServiceTest();
1436 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1437 EXPECT_NE(nullptr, audioInterruptService);
1438
1439 audioInterruptService->Init(serverTest);
1440 AudioFocusType audioFocusTypeTest;
1441 AudioInterrupt incomingInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1442 AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1443 AudioFocusEntry focusEntry;
1444 audioInterruptService->sessionService_ = nullptr;
1445 bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
1446 EXPECT_FALSE(ret);
1447 }
1448
1449 /**
1450 * @tc.name : Test CanMixForActiveSession API.
1451 * @tc.number: AudioInterruptServiceCanMixForActiveSession_003
1452 * @tc.desc : Test CanMixForActiveSession when IsAudioSessionActivated is true.
1453 */
1454 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_003, TestSize.Level1)
1455 {
1456 audioInterruptService = GetTnterruptServiceTest();
1457 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1458 EXPECT_NE(nullptr, audioInterruptService);
1459
1460 audioInterruptService->Init(serverTest);
1461 AudioFocusType audioFocusTypeTest;
1462 AudioInterrupt incomingInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1463 AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1464 activeInterrupt.pid = { -1 };
1465 AudioFocusEntry focusEntry;
1466 bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
1467 EXPECT_TRUE(ret);
1468 }
1469
1470 /**
1471 * @tc.name : Test CanMixForActiveSession API.
1472 * @tc.number: AudioInterruptServiceCanMixForActiveSession_004
1473 * @tc.desc : Test CanMixForActiveSession when concurrencyMode is not MIX_WITH_OTHERS.
1474 */
1475 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_004, TestSize.Level1)
1476 {
1477 audioInterruptService = GetTnterruptServiceTest();
1478 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1479 EXPECT_NE(nullptr, audioInterruptService);
1480
1481 audioInterruptService->Init(serverTest);
1482 AudioFocusType audioFocusTypeTest;
1483 AudioInterrupt incomingInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1484 AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1485 AudioFocusEntry focusEntry;
1486 AudioSessionStrategy strategy;
1487 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(0, strategy, nullptr);
1488 activeInterrupt.pid = { 0 };
1489 audioInterruptService->sessionService_->sessionMap_.insert({0, audioSession});
1490 std::shared_ptr<AudioSession> activeSession =
1491 audioInterruptService->sessionService_->sessionMap_[activeInterrupt.pid];
1492 activeSession->strategy_.concurrencyMode = AudioConcurrencyMode::DEFAULT;
1493 bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
1494 EXPECT_FALSE(ret);
1495 }
1496
1497 /**
1498 * @tc.name : Test CanMixForActiveSession API.
1499 * @tc.number: AudioInterruptServiceCanMixForActiveSession_005
1500 * @tc.desc : Test CanMixForActiveSession when IsActiveStreamLowPriority is true and return false.
1501 */
1502 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_005, TestSize.Level1)
1503 {
1504 audioInterruptService = GetTnterruptServiceTest();
1505 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1506 EXPECT_NE(nullptr, audioInterruptService);
1507
1508 audioInterruptService->Init(serverTest);
1509 AudioFocusType audioFocusTypeTest;
1510 AudioInterrupt incomingInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1511 AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1512 AudioFocusEntry focusEntry;
1513 focusEntry.actionOn = CURRENT;
1514 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
1515 AudioSessionStrategy strategy;
1516 strategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
1517 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(0, strategy, nullptr);
1518 activeInterrupt.pid = { 0 };
1519 audioInterruptService->sessionService_->sessionMap_.insert({0, audioSession});
1520 incomingInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
1521 activeInterrupt.audioFocusType.streamType = STREAM_MUSIC;
1522 bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
1523 EXPECT_FALSE(ret);
1524 }
1525
1526 /**
1527 * @tc.name : Test CanMixForActiveSession API.
1528 * @tc.number: AudioInterruptServiceCanMixForActiveSession_006
1529 * @tc.desc : Test CanMixForActiveSession when IsActiveStreamLowPriority is true and return true.
1530 */
1531 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_006, TestSize.Level1)
1532 {
1533 audioInterruptService = GetTnterruptServiceTest();
1534 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1535 EXPECT_NE(nullptr, audioInterruptService);
1536
1537 audioInterruptService->Init(serverTest);
1538 AudioFocusType audioFocusTypeTest;
1539 AudioInterrupt incomingInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1540 AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1541 AudioFocusEntry focusEntry;
1542 focusEntry.actionOn = CURRENT;
1543 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
1544 AudioSessionStrategy strategy;
1545 strategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
1546 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(0, strategy, nullptr);
1547 activeInterrupt.pid = { 0 };
1548 audioInterruptService->sessionService_->sessionMap_.insert({0, audioSession});
1549 incomingInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
1550 activeInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
1551 bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
1552 EXPECT_FALSE(ret);
1553 }
1554
1555 /**
1556 * @tc.name : Test SendSessionTimeOutStopEvent
1557 * @tc.number: SendSessionTimeOutStopEvent_001
1558 * @tc.desc : Test SendSessionTimeOutStopEvent
1559 */
1560 HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_001, TestSize.Level1)
1561 {
1562 auto interruptServiceTest = GetTnterruptServiceTest();
1563
1564 interruptServiceTest->zonesMap_.clear();
1565 std::shared_ptr<AudioPolicyServerHandler> handler = std::make_shared<AudioPolicyServerHandler>();
1566 interruptServiceTest->SetCallbackHandler(handler);
1567 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1568 AudioFocusType audioFocusTypeTest;
1569 AudioInterrupt audioInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, 0);
1570 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
1571 interruptServiceTest->SendSessionTimeOutStopEvent(0, audioInterrupt, audioFocusInfoList);
1572 EXPECT_NE(nullptr, interruptServiceTest->handler_);
1573 }
1574
1575 /**
1576 * @tc.name : Test SendSessionTimeOutStopEvent
1577 * @tc.number: SendSessionTimeOutStopEvent_002
1578 * @tc.desc : Test SendSessionTimeOutStopEvent
1579 */
1580 HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_002, TestSize.Level1)
1581 {
1582 auto interruptServiceTest = GetTnterruptServiceTest();
1583
1584 interruptServiceTest->zonesMap_.clear();
1585 AudioFocusType audioFocusTypeTest;
1586 AudioInterrupt audioInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, 0);
1587 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
1588 interruptServiceTest->SendSessionTimeOutStopEvent(0, audioInterrupt, audioFocusInfoList);
1589 EXPECT_EQ(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end());
1590 }
1591
1592 /**
1593 * @tc.name : Test SendSessionTimeOutStopEvent
1594 * @tc.number: SendSessionTimeOutStopEvent_003
1595 * @tc.desc : Test SendSessionTimeOutStopEvent
1596 */
1597 HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_003, TestSize.Level1)
1598 {
1599 auto interruptServiceTest = GetTnterruptServiceTest();
1600
1601 interruptServiceTest->zonesMap_.clear();
1602 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1603 interruptServiceTest->zonesMap_[1] = nullptr;
1604 interruptServiceTest->zonesMap_[2] = std::make_shared<AudioInterruptZone>();
1605 AudioFocusType audioFocusTypeTest;
1606 AudioInterrupt audioInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, 0);
1607 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
1608 interruptServiceTest->SendSessionTimeOutStopEvent(1, audioInterrupt, audioFocusInfoList);
1609 auto it = interruptServiceTest->zonesMap_.find(1);
1610 EXPECT_EQ(nullptr, it->second);
1611 }
1612
1613 /**
1614 * @tc.name : Test SendSessionTimeOutStopEvent
1615 * @tc.number: SendSessionTimeOutStopEvent_004
1616 * @tc.desc : Test SendSessionTimeOutStopEvent
1617 */
1618 HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_004, TestSize.Level1)
1619 {
1620 auto interruptServiceTest = GetTnterruptServiceTest();
1621 std::set<int32_t> pids = {100, 200, 300};
1622
1623 interruptServiceTest->zonesMap_.clear();
1624 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1625 interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
1626 interruptServiceTest->zonesMap_[2] = std::make_shared<AudioInterruptZone>();
1627 interruptServiceTest->zonesMap_.find(0)->second->pids = pids;
1628 AudioFocusType audioFocusTypeTest;
1629 AudioInterrupt audioInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, 0);
1630 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
1631 interruptServiceTest->SendSessionTimeOutStopEvent(1, audioInterrupt, audioFocusInfoList);
1632 auto it = interruptServiceTest->zonesMap_.find(1);
1633 EXPECT_EQ(it->second->pids.find(100), it->second->pids.end());
1634 }
1635
1636 /**
1637 * @tc.name : Test SendSessionTimeOutStopEvent
1638 * @tc.number: SendSessionTimeOutStopEvent_005
1639 * @tc.desc : Test SendSessionTimeOutStopEvent
1640 */
1641 HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_005, TestSize.Level1)
1642 {
1643 auto interruptServiceTest = GetTnterruptServiceTest();
1644
1645 interruptServiceTest->zonesMap_.clear();
1646 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
1647 audioInterruptZone->pids = {1, 2, 3};
1648 interruptServiceTest->zonesMap_[0] = audioInterruptZone;
1649 interruptServiceTest->zonesMap_[1] = audioInterruptZone;
1650 AudioFocusType audioFocusTypeTest;
1651 AudioInterrupt audioInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, 0);
1652 audioInterrupt.pid = 1;
1653 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
1654 interruptServiceTest->SendSessionTimeOutStopEvent(1, audioInterrupt, audioFocusInfoList);
1655 auto it = interruptServiceTest->zonesMap_.find(1);
1656 EXPECT_NE(it->second->pids.find(1), it->second->pids.end());
1657 }
1658
1659 /**
1660 * @tc.name : Test AudioInterruptService.
1661 * @tc.number: AudioInterruptService_DeactivateAudioInterruptInternal_001
1662 * @tc.desc : Test DeactivateAudioInterruptInternal.
1663 */
1664 HWTEST(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInternal_001, TestSize.Level1)
1665 {
1666 auto interruptServiceTest = GetTnterruptServiceTest();
1667 interruptServiceTest->zonesMap_.clear();
1668 AudioInterrupt audioInterrupt = {};
1669 AudioSessionService audioSessionService;
1670 AudioInterruptService audioInterruptService;
1671 AudioSessionStrategy strategy;
1672
1673 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, true);
1674 EXPECT_EQ(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end());
1675 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1676 interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
1677 interruptServiceTest->zonesMap_[2] = std::make_shared<AudioInterruptZone>();
1678 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, true);
1679 EXPECT_NE(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end());
1680
1681 bool IS_SESSION_TIMEOUT = true;
1682 interruptServiceTest->sessionService_ = nullptr;
1683 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, IS_SESSION_TIMEOUT);
1684
1685 interruptServiceTest->Init(GetPolicyServerTest());
1686 int32_t ret = interruptServiceTest->ActivateAudioSession(0, 0, strategy);
1687 EXPECT_EQ(SUCCESS, ret);
1688 audioInterrupt.pid = 3;
1689 audioInterrupt.streamId = 3;
1690 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, IS_SESSION_TIMEOUT);
1691 audioInterrupt.pid = 0;
1692 audioInterrupt.streamId = 0;
1693 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, IS_SESSION_TIMEOUT);
1694
1695 audioInterrupt.streamId = 0;
1696 std::pair<AudioInterrupt, AudioFocuState> pairTest = std::make_pair(audioInterrupt, ACTIVE);
1697 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.push_back(pairTest);
1698 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, true);
1699 EXPECT_NE(VALUE_SUCCESS, interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.back().second);
1700
1701 interruptServiceTest->zonesMap_.clear();
1702 }
1703
1704 /**
1705 * @tc.name : Test AudioInterruptService.
1706 * @tc.number: AudioInterruptService_DeactivateAudioInterruptInternal_002
1707 * @tc.desc : Test DeactivateAudioInterruptInternal.
1708 */
1709 HWTEST(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInternal_002, TestSize.Level1)
1710 {
1711 auto interruptServiceTest = GetTnterruptServiceTest();
1712 interruptServiceTest->zonesMap_.clear();
1713 AudioInterrupt audioInterrupt = {};
1714 AudioSessionStrategy strategy;
1715
1716 audioInterrupt.pid = 0;
1717 audioInterrupt.streamId = 0;
1718 interruptServiceTest->Init(GetPolicyServerTest());
1719 interruptServiceTest->ActivateAudioSession(0, 0, strategy);
1720 interruptServiceTest->sessionService_ = nullptr;
1721 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1722 std::pair<AudioInterrupt, AudioFocuState> pairTest = std::make_pair(audioInterrupt, ACTIVE);
1723 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.push_back(pairTest);
1724 interruptServiceTest->zonesMap_.find(0)->second->pids.insert(1);
1725
1726 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, true);
1727 EXPECT_FALSE(interruptServiceTest->zonesMap_.find(0)->second->pids.find(0) !=
1728 interruptServiceTest->zonesMap_.find(0)->second->pids.end());
1729 interruptServiceTest->zonesMap_.find(0)->second->pids.insert(0);
1730 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, true);
1731 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->pids.find(0) !=
1732 interruptServiceTest->zonesMap_.find(0)->second->pids.end());
1733
1734 interruptServiceTest->zonesMap_.clear();
1735 }
1736
1737 /**
1738 * @tc.name : Test AudioInterruptService.
1739 * @tc.number: AudioInterruptService_UpdateAudioSceneFromInterrupt_002
1740 * @tc.desc : Test UpdateAudioSceneFromInterrupt.
1741 */
1742 HWTEST(AudioInterruptUnitTest, AudioInterruptService_UpdateAudioSceneFromInterrupt_002, TestSize.Level1)
1743 {
1744 auto interruptServiceTest = GetTnterruptServiceTest();
1745 ASSERT_TRUE(interruptServiceTest != nullptr);
1746 interruptServiceTest->zonesMap_.clear();
1747
1748 interruptServiceTest->Init(GetPolicyServerTest());
1749 AudioInterruptChangeType changeType = DEACTIVATE_AUDIO_INTERRUPT;
1750 interruptServiceTest->UpdateAudioSceneFromInterrupt(AUDIO_SCENE_INVALID, changeType);
1751 interruptServiceTest->zonesMap_.clear();
1752 }
1753
1754 /**
1755 * @tc.name : Test AudioInterruptService.
1756 * @tc.number: AudioInterruptService_SendInterruptEvent_001
1757 * @tc.desc : Test SendInterruptEvent.
1758 */
1759 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SendInterruptEvent_001, TestSize.Level1)
1760 {
1761 auto interruptServiceTest = GetTnterruptServiceTest();
1762 interruptServiceTest->zonesMap_.clear();
1763 std::list<std::pair<AudioInterrupt, AudioFocuState>> pairList;
1764 pairList.emplace_back(AudioInterrupt(), AudioFocuState::ACTIVE);
1765 auto it = pairList.begin();
1766 interruptServiceTest->SetCallbackHandler(GetServerHandlerTest());
1767
1768 bool removeFocusInfo;
1769 interruptServiceTest->SendInterruptEvent(ACTIVE, DUCK, it, removeFocusInfo);
1770 EXPECT_NE(interruptServiceTest->handler_, nullptr);
1771
1772 interruptServiceTest->zonesMap_.clear();
1773 }
1774
1775 /**
1776 * @tc.name : Test SendFocusChangeEvent
1777 * @tc.number: SendFocusChangeEvent_001
1778 * @tc.desc : Test SendFocusChangeEvent
1779 */
1780 HWTEST(AudioInterruptUnitTest, SendFocusChangeEvent_001, TestSize.Level1)
1781 {
1782 auto interruptServiceTest = GetTnterruptServiceTest();
1783 AudioFocusType audioFocusTypeTest;
1784 AudioInterrupt audioInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, 0);
1785 int32_t callbackCategory = 0;
1786
1787 interruptServiceTest->zonesMap_.clear();
1788 interruptServiceTest->SendFocusChangeEvent(0, callbackCategory, audioInterrupt);
1789 EXPECT_EQ(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end());
1790 }
1791
1792 /**
1793 * @tc.name : Test SendFocusChangeEvent
1794 * @tc.number: SendFocusChangeEvent_002
1795 * @tc.desc : Test SendFocusChangeEvent
1796 */
1797 HWTEST(AudioInterruptUnitTest, SendFocusChangeEvent_002, TestSize.Level1)
1798 {
1799 auto interruptServiceTest = GetTnterruptServiceTest();
1800 AudioFocusType audioFocusTypeTest;
1801 AudioInterrupt audioInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, 0);
1802 int32_t callbackCategory = 0;
1803
1804 interruptServiceTest->zonesMap_.clear();
1805 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1806 interruptServiceTest->zonesMap_[1] = nullptr;
1807 interruptServiceTest->zonesMap_[2] = std::make_shared<AudioInterruptZone>();
1808 interruptServiceTest->SendFocusChangeEvent(1, callbackCategory, audioInterrupt);
1809 auto it = interruptServiceTest->zonesMap_.find(1);
1810 EXPECT_EQ(nullptr, it->second);
1811 EXPECT_NE(interruptServiceTest->zonesMap_.find(1), interruptServiceTest->zonesMap_.end());
1812 }
1813
1814 /**
1815 * @tc.name : Test SendActiveVolumeTypeChangeEvent
1816 * @tc.number: SendActiveVolumeTypeChangeEvent_001
1817 * @tc.desc : Test SendActiveVolumeTypeChangeEvent
1818 */
1819 HWTEST(AudioInterruptUnitTest, SendActiveVolumeTypeChangeEvent_001, TestSize.Level1)
1820 {
1821 auto interruptServiceTest = GetTnterruptServiceTest();
1822 interruptServiceTest->SetCallbackHandler(GetServerHandlerTest());
1823 EXPECT_NE(interruptServiceTest->handler_, nullptr);
1824
1825 interruptServiceTest->zonesMap_.clear();
1826 int32_t zoneId = 0;
1827 interruptServiceTest->SendActiveVolumeTypeChangeEvent(zoneId);
1828 EXPECT_EQ(STREAM_MUSIC, interruptServiceTest->activeStreamType_);
1829 }
1830
1831 /**
1832 * @tc.name : Test AudioInterruptService
1833 * @tc.number: AudioInterruptServiceReleaseAudioInterruptZone_001
1834 * @tc.desc : Test ReleaseAudioInterruptZone
1835 */
1836 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceReleaseAudioInterruptZone_001, TestSize.Level1)
1837 {
1838 sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
1839 server->interruptService_ = std::make_shared<AudioInterruptService>();
1840 server->interruptService_->Init(server);
1841 auto interruptServiceTest = server->interruptService_;
1842 auto coreService = std::make_shared<AudioCoreService>();
1843 server->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(coreService);
1844 server->eventEntry_->coreService_ = std::make_shared<AudioCoreService>();
1845
1846 auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
__anon4eb1ff3a0302(int32_t uid, const std::string &deviceTag, const std::string &streamTag, const StreamUsage &usage)1847 const std::string &streamTag, const StreamUsage &usage)->int32_t {
1848 return 0;
1849 };
1850
1851 auto retStatus = interruptServiceTest->ReleaseAudioInterruptZone(-1, getZoneFunc);
1852 EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
1853
1854 SetUid1041();
1855 retStatus = interruptServiceTest->ReleaseAudioInterruptZone(-1, getZoneFunc);
1856 EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
1857
1858 SetUid1041();
1859 retStatus = interruptServiceTest->ReleaseAudioInterruptZone(0, getZoneFunc);
1860 EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
1861
1862 SetUid1041();
1863 interruptServiceTest->zonesMap_.clear();
1864 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1865
1866 interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
1867 retStatus = interruptServiceTest->ReleaseAudioInterruptZone(1, getZoneFunc);
1868 EXPECT_EQ(retStatus, SUCCESS);
1869 }
1870
1871 /**
1872 * @tc.name : Test AudioInterruptService.
1873 * @tc.number: AudioInterruptServiceCreateAudioInterruptZone_001
1874 * @tc.desc : Test RCreateAudioInterruptZone.
1875 */
1876 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCreateAudioInterruptZone_001, TestSize.Level1)
1877 {
1878 sptr<AudioPolicyServer> server = nullptr;
1879 auto interruptServiceTest = GetTnterruptServiceTest();
1880 interruptServiceTest->Init(server);
1881
1882 SetUid1041();
1883 auto retStatus = interruptServiceTest->CreateAudioInterruptZone(-1);
1884 EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
1885
1886 SetUid1041();
1887 retStatus = interruptServiceTest->CreateAudioInterruptZone(0);
1888 EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
1889
1890 SetUid1041();
1891 retStatus = interruptServiceTest->CreateAudioInterruptZone(2);
1892 EXPECT_EQ(retStatus, SUCCESS);
1893 }
1894
1895 /**
1896 * @tc.name : Test MigrateAudioInterruptZone
1897 * @tc.number: MigrateAudioInterruptZone_001
1898 * @tc.desc : Test MigrateAudioInterruptZone
1899 */
1900 HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_001, TestSize.Level1)
1901 {
1902 sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
1903 server->interruptService_ = std::make_shared<AudioInterruptService>();
1904 server->interruptService_->Init(server);
1905 auto interruptServiceTest = server->interruptService_;
1906
1907 auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
__anon4eb1ff3a0402(int32_t uid, const std::string &deviceTag, const std::string &streamTag, const StreamUsage &usage)1908 const std::string &streamTag, const StreamUsage &usage)->int32_t {
1909 return 1;
1910 };
1911
1912 SetUid1041();
1913 interruptServiceTest->zonesMap_.clear();
1914 int32_t signal = interruptServiceTest->MigrateAudioInterruptZone(0, getZoneFunc);
1915 EXPECT_EQ(ERR_INVALID_PARAM, signal);
1916 signal = interruptServiceTest->MigrateAudioInterruptZone(0, nullptr);
1917 EXPECT_EQ(ERR_INVALID_PARAM, signal);
1918 }
1919
1920 /**
1921 * @tc.name : Test MigrateAudioInterruptZone
1922 * @tc.number: MigrateAudioInterruptZone_002
1923 * @tc.desc : Test MigrateAudioInterruptZone
1924 */
1925 HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_002, TestSize.Level1)
1926 {
1927 sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
1928 server->interruptService_ = std::make_shared<AudioInterruptService>();
1929 server->interruptService_->Init(server);
1930 auto interruptServiceTest = server->interruptService_;
1931 auto coreService = std::make_shared<AudioCoreService>();
1932 server->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(coreService);
1933 server->eventEntry_->coreService_ = std::make_shared<AudioCoreService>();
1934
1935 auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
__anon4eb1ff3a0502(int32_t uid, const std::string &deviceTag, const std::string &streamTag, const StreamUsage &usage)1936 const std::string &streamTag, const StreamUsage &usage)->int32_t {
1937 return 1;
1938 };
1939
1940 SetUid1041();
1941 interruptServiceTest->zonesMap_.clear();
1942 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1943 interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
1944 interruptServiceTest->zonesMap_[2] = std::make_shared<AudioInterruptZone>();
1945 auto signal = interruptServiceTest->MigrateAudioInterruptZone(0, getZoneFunc);
1946 auto it = interruptServiceTest->zonesMap_.find(1);
1947 EXPECT_NE(nullptr, it->second);
1948 EXPECT_NE(interruptServiceTest->zonesMap_.find(1), interruptServiceTest->zonesMap_.end());
1949 EXPECT_EQ(SUCCESS, signal);
1950 }
1951
1952 /**
1953 * @tc.name : Test MigrateAudioInterruptZone
1954 * @tc.number: MigrateAudioInterruptZone_003
1955 * @tc.desc : Test MigrateAudioInterruptZone
1956 */
1957 HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_003, TestSize.Level1)
1958 {
1959 auto interruptServiceTest = GetTnterruptServiceTest();
1960
1961 auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
__anon4eb1ff3a0602(int32_t uid, const std::string &deviceTag, const std::string &streamTag, const StreamUsage &usage)1962 const std::string &streamTag, const StreamUsage &usage)->int32_t {
1963 return 1;
1964 };
1965
1966 SetUid1041();
1967 interruptServiceTest->zonesMap_.clear();
1968 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1969 interruptServiceTest->zonesMap_[1] = nullptr;
1970 interruptServiceTest->zonesMap_[2] = std::make_shared<AudioInterruptZone>();
1971 auto signal = interruptServiceTest->MigrateAudioInterruptZone(1, getZoneFunc);
1972 EXPECT_NE(interruptServiceTest->zonesMap_.find(1), interruptServiceTest->zonesMap_.end());
1973 EXPECT_EQ(ERR_INVALID_PARAM, signal);
1974 }
1975
1976 /**
1977 * @tc.name : Test MigrateAudioInterruptZone
1978 * @tc.number: MigrateAudioInterruptZone_004
1979 * @tc.desc : Test MigrateAudioInterruptZone
1980 */
1981 HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_004, TestSize.Level1)
1982 {
1983 sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
1984 server->interruptService_ = std::make_shared<AudioInterruptService>();
1985 server->interruptService_->Init(server);
1986 auto interruptServiceTest = server->interruptService_;
1987 auto coreService = std::make_shared<AudioCoreService>();
1988 server->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(coreService);
1989 server->eventEntry_->coreService_ = std::make_shared<AudioCoreService>();
1990
1991 auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
__anon4eb1ff3a0702(int32_t uid, const std::string &deviceTag, const std::string &streamTag, const StreamUsage &usage)1992 const std::string &streamTag, const StreamUsage &usage)->int32_t {
1993 return 1;
1994 };
1995
1996 SetUid1041();
1997 interruptServiceTest->zonesMap_.clear();
1998 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1999 interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
2000 interruptServiceTest->zonesMap_[2] = std::make_shared<AudioInterruptZone>();
2001 int32_t signal = interruptServiceTest->MigrateAudioInterruptZone(1, getZoneFunc);
2002 EXPECT_EQ(SUCCESS, signal);
2003 }
2004
2005 /**
2006 * @tc.name : Test MigrateAudioInterruptZone
2007 * @tc.number: MigrateAudioInterruptZone_005
2008 * @tc.desc : Test MigrateAudioInterruptZone
2009 */
2010 HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_005, TestSize.Level1)
2011 {
2012 sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
2013 server->interruptService_ = std::make_shared<AudioInterruptService>();
2014 server->interruptService_->Init(server);
2015 auto interruptServiceTest = server->interruptService_;
2016 auto coreService = std::make_shared<AudioCoreService>();
2017 server->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(coreService);
2018 server->eventEntry_->coreService_ = std::make_shared<AudioCoreService>();
2019
2020 auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
__anon4eb1ff3a0802(int32_t uid, const std::string &deviceTag, const std::string &streamTag, const StreamUsage &usage)2021 const std::string &streamTag, const StreamUsage &usage)->int32_t {
2022 return 1;
2023 };
2024
2025 SetUid1041();
2026 interruptServiceTest->zonesMap_.clear();
2027 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2028 interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
2029 interruptServiceTest->zonesMap_[2] = std::make_shared<AudioInterruptZone>();
2030 auto ret = interruptServiceTest->MigrateAudioInterruptZone(1, getZoneFunc);
2031 EXPECT_NE(interruptServiceTest->zonesMap_.find(1), interruptServiceTest->zonesMap_.end());
2032 EXPECT_EQ(SUCCESS, ret);
2033 }
2034
AddMovieInterruptToList(AudioFocusList & list,int32_t streamId,int32_t uid,AudioFocuState state,const std::string & deviceTag="")2035 static void AddMovieInterruptToList(AudioFocusList &list, int32_t streamId, int32_t uid,
2036 AudioFocuState state, const std::string &deviceTag = "")
2037 {
2038 AudioInterrupt interrupt;
2039 interrupt.streamUsage = STREAM_USAGE_MOVIE;
2040 interrupt.audioFocusType.streamType = STREAM_MOVIE;
2041 interrupt.streamId = streamId;
2042 interrupt.uid = uid;
2043 interrupt.deviceTag = deviceTag;
2044 list.emplace_back(std::make_pair(interrupt, state));
2045 }
2046
AddMusicInterruptToList(AudioFocusList & list,int32_t streamId,int32_t uid,AudioFocuState state,const std::string & deviceTag="")2047 static void AddMusicInterruptToList(AudioFocusList &list, int32_t streamId, int32_t uid,
2048 AudioFocuState state, const std::string &deviceTag = "")
2049 {
2050 AudioInterrupt interrupt;
2051 interrupt.streamUsage = STREAM_USAGE_MUSIC;
2052 interrupt.audioFocusType.streamType = STREAM_MUSIC;
2053 interrupt.streamId = streamId;
2054 interrupt.uid = uid;
2055 interrupt.deviceTag = deviceTag;
2056 list.emplace_back(std::make_pair(interrupt, state));
2057 }
2058
AddVoipInterruptToList(AudioFocusList & list,int32_t streamId,int32_t uid,AudioFocuState state,const std::string & deviceTag="")2059 static void AddVoipInterruptToList(AudioFocusList &list, int32_t streamId, int32_t uid,
2060 AudioFocuState state, const std::string &deviceTag = "")
2061 {
2062 AudioInterrupt interrupt;
2063 interrupt.streamUsage = STREAM_USAGE_VOICE_COMMUNICATION;
2064 interrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
2065 interrupt.streamId = streamId;
2066 interrupt.uid = uid;
2067 interrupt.deviceTag = deviceTag;
2068 list.emplace_back(std::make_pair(interrupt, state));
2069 }
2070
2071 /**
2072 * @tc.name : Test MigrateAudioInterruptZone
2073 * @tc.number: MigrateAudioInterruptZone_006
2074 * @tc.desc : Test MigrateAudioInterruptZone
2075 */
2076 HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_006, TestSize.Level1)
2077 {
2078 sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
2079 server->coreService_ = AudioCoreService::GetCoreService();
2080 server->coreService_->Init();
2081 server->eventEntry_ = server->coreService_->GetEventEntry();
2082 server->interruptService_ = std::make_shared<AudioInterruptService>();
2083 server->interruptService_->Init(server);
2084 auto interruptServiceTest = server->interruptService_;
2085 auto coreService = std::make_shared<AudioCoreService>();
2086 server->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(coreService);
2087 server->eventEntry_->coreService_ = std::make_shared<AudioCoreService>();
2088
2089 auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
__anon4eb1ff3a0902(int32_t uid, const std::string &deviceTag, const std::string &streamTag, const StreamUsage &usage)2090 const std::string &streamTag, const StreamUsage &usage)->int32_t {
2091 if (uid == 2) {
2092 return 1;
2093 }
2094 return 0;
2095 };
2096
2097 SetUid1041();
2098 interruptServiceTest->zonesMap_.clear();
2099 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2100 auto &focusList = interruptServiceTest->zonesMap_[0]->audioFocusInfoList;
2101 AddMovieInterruptToList(focusList, 0, 1, AudioFocuState::PAUSE);
2102 AddVoipInterruptToList(focusList, 1, 2, AudioFocuState::ACTIVE);
2103 AddMusicInterruptToList(focusList, 2, 3, AudioFocuState::DUCK);
2104
2105 interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
2106 EXPECT_NO_THROW(
2107 interruptServiceTest->MigrateAudioInterruptZone(0, getZoneFunc);
2108 );
2109 EXPECT_NE(interruptServiceTest->zonesMap_.find(1), interruptServiceTest->zonesMap_.end());
2110 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 1);
2111 EXPECT_EQ(interruptServiceTest->zonesMap_[1]->audioFocusInfoList.size(), 1);
2112 }
2113
2114 /**
2115 * @tc.name : Test InjectInterruptToAudioZone
2116 * @tc.number: InjectInterruptToAudioZone_001
2117 * @tc.desc : Test InjectInterruptToAudioZone
2118 */
2119 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_001, TestSize.Level1)
2120 {
2121 auto interruptServiceTest = GetTnterruptServiceTest();
2122 AudioFocusList interrupts;
2123 interruptServiceTest->zonesMap_.clear();
2124 auto ret = interruptServiceTest->InjectInterruptToAudioZone(0, interrupts);
2125 EXPECT_EQ(ERR_INVALID_PARAM, ret);
2126 }
2127
2128 /**
2129 * @tc.name : Test InjectInterruptToAudioZone
2130 * @tc.number: InjectInterruptToAudioZone_002
2131 * @tc.desc : Test InjectInterruptToAudioZone
2132 */
2133 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_002, TestSize.Level1)
2134 {
2135 auto interruptServiceTest = GetTnterruptServiceTest();
2136 AudioFocusList interrupts;
2137
2138 interruptServiceTest->zonesMap_.clear();
2139 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2140 interruptServiceTest->zonesMap_[1] = nullptr;
2141
2142 SetUid1041();
2143 auto ret = interruptServiceTest->InjectInterruptToAudioZone(2, interrupts);
2144 EXPECT_EQ(ERR_INVALID_PARAM, ret);
2145 SetUid1041();
2146 ret = interruptServiceTest->InjectInterruptToAudioZone(1, interrupts);
2147 EXPECT_EQ(ERR_INVALID_PARAM, ret);
2148 }
2149
2150 /**
2151 * @tc.name : Test InjectInterruptToAudioZone
2152 * @tc.number: InjectInterruptToAudioZone_003
2153 * @tc.desc : Test InjectInterruptToAudioZone
2154 */
2155 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_003, TestSize.Level1)
2156 {
2157 auto interruptServiceTest = GetTnterruptServiceTest();
2158 AudioFocusList interrupts;
2159
2160 interruptServiceTest->zonesMap_.clear();
2161 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2162 interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
2163
2164 SetUid1041();
2165 EXPECT_NO_THROW(
2166 interruptServiceTest->InjectInterruptToAudioZone(1, interrupts);
2167 );
2168 }
2169
2170 /**
2171 * @tc.name : Test InjectInterruptToAudioZone
2172 * @tc.number: InjectInterruptToAudioZone_004
2173 * @tc.desc : Test InjectInterruptToAudioZone
2174 */
2175 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_004, TestSize.Level1)
2176 {
2177 auto interruptServiceTest = GetTnterruptServiceTest();
2178 AudioFocusList interrupts;
2179 interruptServiceTest->zonesMap_.clear();
2180 auto ret = interruptServiceTest->InjectInterruptToAudioZone(0, "", interrupts);
2181 EXPECT_EQ(ERR_INVALID_PARAM, ret);
2182 }
2183
2184 /**
2185 * @tc.name : Test InjectInterruptToAudioZone
2186 * @tc.number: InjectInterruptToAudioZone_005
2187 * @tc.desc : Test InjectInterruptToAudioZone
2188 */
2189 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_005, TestSize.Level1)
2190 {
2191 auto interruptServiceTest = GetTnterruptServiceTest();
2192 AudioFocusList interrupts;
2193
2194 interruptServiceTest->zonesMap_.clear();
2195 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2196 interruptServiceTest->zonesMap_[1] = nullptr;
2197
2198 SetUid1041();
2199 auto ret = interruptServiceTest->InjectInterruptToAudioZone(2, "", interrupts);
2200 EXPECT_EQ(ERR_INVALID_PARAM, ret);
2201 SetUid1041();
2202 ret = interruptServiceTest->InjectInterruptToAudioZone(1, "", interrupts);
2203 EXPECT_EQ(ERR_INVALID_PARAM, ret);
2204 }
2205
2206 /**
2207 * @tc.name : Test InjectInterruptToAudioZone
2208 * @tc.number: InjectInterruptToAudioZone_006
2209 * @tc.desc : Test InjectInterruptToAudioZone
2210 */
2211 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_006, TestSize.Level1)
2212 {
2213 auto interruptServiceTest = GetTnterruptServiceTest();
2214 AudioFocusList interrupts;
2215
2216 interruptServiceTest->zonesMap_.clear();
2217 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2218 interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
2219
2220 SetUid1041();
2221 auto ret = interruptServiceTest->InjectInterruptToAudioZone(1, "", interrupts);
2222 EXPECT_EQ(ERR_INVALID_PARAM, ret);
2223 }
2224
2225 /**
2226 * @tc.name : Test InjectInterruptToAudioZone
2227 * @tc.number: InjectInterruptToAudioZone_007
2228 * @tc.desc : Test InjectInterruptToAudioZone
2229 */
2230 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_007, TestSize.Level1)
2231 {
2232 sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
2233 server->coreService_ = AudioCoreService::GetCoreService();
2234 server->coreService_->Init();
2235 server->eventEntry_ = server->coreService_->GetEventEntry();
2236 server->interruptService_ = std::make_shared<AudioInterruptService>();
2237 server->interruptService_->Init(server);
2238 auto interruptServiceTest = server->interruptService_;
2239 AudioFocusList interrupts;
2240 auto coreService = std::make_shared<AudioCoreService>();
2241 server->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(coreService);
2242 server->eventEntry_->coreService_ = std::make_shared<AudioCoreService>();
2243
2244 interruptServiceTest->zonesMap_.clear();
2245 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2246 interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
2247
2248 SetUid1041();
2249 EXPECT_NO_THROW(
2250 interruptServiceTest->InjectInterruptToAudioZone(1, "1", interrupts);
2251 );
2252 }
2253
2254 /**
2255 * @tc.name : Test InjectInterruptToAudioZone
2256 * @tc.number: InjectInterruptToAudioZone_008
2257 * @tc.desc : Test InjectInterruptToAudioZone
2258 */
2259 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_008, TestSize.Level1)
2260 {
2261 sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
2262 server->interruptService_ = std::make_shared<AudioInterruptService>();
2263 server->interruptService_->Init(server);
2264 auto interruptServiceTest = server->interruptService_;
2265 AudioFocusList interrupts;
2266 auto coreService = std::make_shared<AudioCoreService>();
2267 server->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(coreService);
2268 server->eventEntry_->coreService_ = std::make_shared<AudioCoreService>();
2269
2270 SetUid1041();
2271 interruptServiceTest->zonesMap_.clear();
2272 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2273 auto &focusList = interruptServiceTest->zonesMap_[0]->audioFocusInfoList;
2274 AddMovieInterruptToList(focusList, 0, 1, AudioFocuState::PAUSE);
2275 AddVoipInterruptToList(focusList, 1, 2, AudioFocuState::ACTIVE);
2276 AddMusicInterruptToList(focusList, 2, 3, AudioFocuState::DUCK);
2277
2278 AddMovieInterruptToList(interrupts, 0, 1, AudioFocuState::PAUSE);
2279 AddMusicInterruptToList(interrupts, 2, 3, AudioFocuState::ACTIVE);
2280
2281 EXPECT_NO_THROW(
2282 interruptServiceTest->InjectInterruptToAudioZone(0, interrupts);
2283 );
2284 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 2);
2285 }
2286
2287 /**
2288 * @tc.name : Test InjectInterruptToAudioZone
2289 * @tc.number: InjectInterruptToAudioZone_009
2290 * @tc.desc : Test InjectInterruptToAudioZone
2291 */
2292 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_009, TestSize.Level1)
2293 {
2294 sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
2295 server->interruptService_ = std::make_shared<AudioInterruptService>();
2296 server->interruptService_->Init(server);
2297 auto interruptServiceTest = server->interruptService_;
2298 AudioFocusList interrupts;
2299 auto coreService = std::make_shared<AudioCoreService>();
2300 server->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(coreService);
2301 server->eventEntry_->coreService_ = std::make_shared<AudioCoreService>();
2302
2303 interruptServiceTest->zonesMap_.clear();
2304 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2305 auto &focusList = interruptServiceTest->zonesMap_[0]->audioFocusInfoList;
2306 AddMovieInterruptToList(focusList, 0, 1, AudioFocuState::PAUSE);
2307 AddVoipInterruptToList(focusList, 1, 2, AudioFocuState::ACTIVE, "test");
2308 AddMusicInterruptToList(focusList, 2, 3, AudioFocuState::DUCK, "test");
2309
2310 AddMusicInterruptToList(interrupts, 2, 3, AudioFocuState::ACTIVE, "test");
2311
2312 SetUid1041();
2313 EXPECT_NO_THROW(
2314 interruptServiceTest->InjectInterruptToAudioZone(0, "1", interrupts);
2315 );
2316 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 3);
2317 }
2318
2319 /**
2320 * @tc.name : Test InjectInterruptToAudioZone
2321 * @tc.number: InjectInterruptToAudioZone_010
2322 * @tc.desc : Test InjectInterruptToAudioZone
2323 */
2324 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_010, TestSize.Level1)
2325 {
2326 sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
2327 server->interruptService_ = std::make_shared<AudioInterruptService>();
2328 server->interruptService_->Init(server);
2329 auto interruptServiceTest = server->interruptService_;
2330 AudioFocusList interrupts;
2331 auto coreService = std::make_shared<AudioCoreService>();
2332 server->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(coreService);
2333 server->eventEntry_->coreService_ = std::make_shared<AudioCoreService>();
2334
2335 interruptServiceTest->zonesMap_.clear();
2336 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2337 auto &focusList = interruptServiceTest->zonesMap_[0]->audioFocusInfoList;
2338 AddMovieInterruptToList(focusList, 0, 1, AudioFocuState::PAUSE);
2339 AddVoipInterruptToList(focusList, 1, 2, AudioFocuState::ACTIVE, "test");
2340 AddMusicInterruptToList(focusList, 2, 3, AudioFocuState::DUCK, "test");
2341
2342 AddMusicInterruptToList(interrupts, 2, 3, AudioFocuState::PLACEHOLDER, "test");
2343 AddMovieInterruptToList(interrupts, 3, 4, AudioFocuState::ACTIVE, "test");
2344
2345 SetUid1041();
2346 EXPECT_NO_THROW(
2347 interruptServiceTest->InjectInterruptToAudioZone(0, "1", interrupts);
2348 );
2349 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 4);
2350 }
2351
2352 /**
2353 * @tc.name : Test AudioInterruptService.
2354 * @tc.number: AudioInterruptService_SimulateFocusEntry_001
2355 * @tc.desc : Test SimulateFocusEntry.
2356 */
2357 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_001, TestSize.Level1)
2358 {
2359 auto interruptServiceTest = GetTnterruptServiceTest();
2360 interruptServiceTest->zonesMap_.clear();
2361 AudioInterrupt audioInterrupt = {};
2362
2363 interruptServiceTest->SimulateFocusEntry(0);
2364 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0) == interruptServiceTest->zonesMap_.end());
2365
2366 interruptServiceTest->zonesMap_[0] = nullptr;
2367 interruptServiceTest->SimulateFocusEntry(0);
2368 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second == nullptr);
2369
2370 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2371 std::pair<AudioInterrupt, AudioFocuState> pairTest = std::make_pair(audioInterrupt, ACTIVE);
2372 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.push_back(pairTest);
2373 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->first.mode = SHARE_MODE;
2374 interruptServiceTest->SimulateFocusEntry(0);
2375 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.back().first.mode == SHARE_MODE);
2376
2377 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->first.mode = INDEPENDENT_MODE;
2378 interruptServiceTest->SimulateFocusEntry(0);
2379 EXPECT_FALSE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.back().first.mode == SHARE_MODE);
2380
2381 interruptServiceTest->zonesMap_.clear();
2382 }
2383
2384 /**
2385 * @tc.name : Test AudioInterruptService.
2386 * @tc.number: AudioInterruptService_SimulateFocusEntry_002
2387 * @tc.desc : Test SimulateFocusEntry.
2388 */
2389 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_002, TestSize.Level1)
2390 {
2391 auto interruptServiceTest = GetTnterruptServiceTest();
2392 interruptServiceTest->zonesMap_.clear();
2393 AudioInterrupt audioInterrupt = {};
2394 AudioInterruptService audioInterruptService;
2395
2396 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2397 std::pair<AudioInterrupt, AudioFocuState> pairTest = std::make_pair(audioInterrupt, PAUSE);
2398 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.push_back(pairTest);
2399 interruptServiceTest->SimulateFocusEntry(0);
2400 EXPECT_FALSE(interruptServiceTest->zonesMap_.find(0)->second == nullptr);
2401
2402 interruptServiceTest->zonesMap_.clear();
2403 }
2404
2405 /**
2406 * @tc.name : Test AudioInterruptService.
2407 * @tc.number: AudioInterruptService_SimulateFocusEntry_003
2408 * @tc.desc : Test SimulateFocusEntry.
2409 */
2410 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_003, TestSize.Level1)
2411 {
2412 auto interruptServiceTest = GetTnterruptServiceTest();
2413 interruptServiceTest->zonesMap_.clear();
2414 AudioInterrupt audioInterrupt = {};
2415 AudioInterruptService audioInterruptService;
2416
2417 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2418 std::pair<AudioInterrupt, AudioFocuState> pairTest = std::make_pair(audioInterrupt, PLACEHOLDER);
2419 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.push_back(pairTest);
2420 interruptServiceTest->SimulateFocusEntry(0);
2421 EXPECT_FALSE(interruptServiceTest->zonesMap_.find(0)->second == nullptr);
2422
2423 interruptServiceTest->zonesMap_.clear();
2424 }
2425
2426 /**
2427 * @tc.name : Test AudioInterruptService.
2428 * @tc.number: AudioInterruptService_SimulateFocusEntry_004
2429 * @tc.desc : Test SimulateFocusEntry.
2430 */
2431 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_004, TestSize.Level1)
2432 {
2433 auto interruptServiceTest = GetTnterruptServiceTest();
2434 interruptServiceTest->zonesMap_.clear();
2435 AudioInterrupt audioInterrupt = {};
2436
2437 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2438 std::pair<AudioInterrupt, AudioFocuState> pairTest = std::make_pair(audioInterrupt, PAUSE);
2439 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.push_back(pairTest);
2440
2441 std::pair<AudioFocusType, AudioFocusType> audioFocusTypePair = std::make_pair(
2442 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->first.audioFocusType,
2443 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->first.audioFocusType
2444 );
2445 interruptServiceTest->focusCfgMap_[audioFocusTypePair] = {};
2446
2447 interruptServiceTest->SimulateFocusEntry(0);
2448 EXPECT_FALSE(interruptServiceTest->zonesMap_.find(0)->second == nullptr);
2449
2450 interruptServiceTest->zonesMap_.clear();
2451 interruptServiceTest->focusCfgMap_.clear();
2452 }
2453
2454 /**
2455 * @tc.name : Test AudioInterruptService.
2456 * @tc.number: AudioInterruptService_SimulateFocusEntry_005
2457 * @tc.desc : Test SimulateFocusEntry.
2458 */
2459 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_005, TestSize.Level1)
2460 {
2461 auto interruptServiceTest = GetTnterruptServiceTest();
2462 interruptServiceTest->zonesMap_.clear();
2463
2464 interruptServiceTest->zonesMap_[0] = nullptr;
2465 interruptServiceTest->SimulateFocusEntry(1);
2466 EXPECT_EQ(interruptServiceTest->zonesMap_.find(1), interruptServiceTest->zonesMap_.end());
2467
2468 interruptServiceTest->SimulateFocusEntry(0);
2469 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second == nullptr);
2470
2471 interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
2472 interruptServiceTest->SimulateFocusEntry(1);
2473 AudioInterrupt interrupt;
2474 interruptServiceTest->zonesMap_.find(1)->second->audioFocusInfoList.emplace_back(
2475 std::make_pair(interrupt, STOP));
2476 EXPECT_FALSE(interruptServiceTest->zonesMap_.find(1)->second->audioFocusInfoList.empty());
2477
2478 interruptServiceTest->zonesMap_.clear();
2479 }
2480
2481 /**
2482 * @tc.name : Test AudioInterruptService.
2483 * @tc.number: AudioInterruptService_SimulateFocusEntry_006
2484 * @tc.desc : Test SimulateFocusEntry.
2485 */
2486 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_006, TestSize.Level1)
2487 {
2488 auto interruptServiceTest = GetTnterruptServiceTest();
2489 interruptServiceTest->zonesMap_.clear();
2490
2491 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2492 AudioInterrupt interrupt_1;
2493 AudioInterrupt interrupt_2;
2494
2495 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2496 std::make_pair(interrupt_1, PLACEHOLDER));
2497 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2498 std::make_pair(interrupt_2, PLACEHOLDER));
2499 interruptServiceTest->SimulateFocusEntry(0);
2500 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == PLACEHOLDER);
2501
2502 interruptServiceTest->zonesMap_.clear();
2503 }
2504
2505 /**
2506 * @tc.name : Test AudioInterruptService.
2507 * @tc.number: AudioInterruptService_SimulateFocusEntry_007
2508 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is true.
2509 */
2510 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_007, TestSize.Level1)
2511 {
2512 auto interruptServiceTest = GetTnterruptServiceTest();
2513 interruptServiceTest->zonesMap_.clear();
2514
2515 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2516 AudioInterrupt interrupt_1;
2517 AudioInterrupt interrupt_2;
2518
2519 interrupt_1.mode = SHARE_MODE;
2520 interrupt_1.pid = 0;
2521 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2522 std::make_pair(interrupt_1, ACTIVE));
2523
2524 interrupt_2.mode = SHARE_MODE;
2525 interrupt_2.pid = 0;
2526 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2527 std::make_pair(interrupt_2, PLACEHOLDER));
2528
2529 interruptServiceTest->SimulateFocusEntry(0);
2530 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == ACTIVE);
2531 interruptServiceTest->zonesMap_.clear();
2532 }
2533
2534 /**
2535 * @tc.name : Test AudioInterruptService.
2536 * @tc.number: AudioInterruptService_SimulateFocusEntry_008
2537 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is true.
2538 */
2539 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_008, TestSize.Level1)
2540 {
2541 auto interruptServiceTest = GetTnterruptServiceTest();
2542 interruptServiceTest->zonesMap_.clear();
2543 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2544 AudioInterrupt interrupt_1;
2545 AudioInterrupt interrupt_2;
2546
2547 interrupt_1.mode = SHARE_MODE;
2548 interrupt_1.pid = 0;
2549 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2550 std::make_pair(interrupt_1, PLACEHOLDER));
2551
2552 interrupt_2.mode = SHARE_MODE;
2553 interrupt_2.pid = 0;
2554 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2555 std::make_pair(interrupt_2, PLACEHOLDER));
2556
2557 interruptServiceTest->SimulateFocusEntry(0);
2558 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == PLACEHOLDER);
2559 interruptServiceTest->zonesMap_.clear();
2560 }
2561
2562 /**
2563 * @tc.name : Test AudioInterruptService.
2564 * @tc.number: AudioInterruptService_SimulateFocusEntry_009
2565 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2566 */
2567 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_009, TestSize.Level1)
2568 {
2569 auto interruptServiceTest = GetTnterruptServiceTest();
2570 interruptServiceTest->zonesMap_.clear();
2571 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2572 AudioInterrupt interrupt_1;
2573 AudioInterrupt interrupt_2;
2574
2575 interrupt_1.mode = SHARE_MODE;
2576 interrupt_1.pid = 0;
2577 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2578 std::make_pair(interrupt_1, PLACEHOLDER));
2579
2580 interrupt_2.mode = SHARE_MODE;
2581 interrupt_2.pid = 1;
2582 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2583 std::make_pair(interrupt_2, PLACEHOLDER));
2584
2585 interruptServiceTest->SimulateFocusEntry(0);
2586 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == PLACEHOLDER);
2587 interruptServiceTest->zonesMap_.clear();
2588 }
2589
2590 /**
2591 * @tc.name : Test AudioInterruptService.
2592 * @tc.number: AudioInterruptService_SimulateFocusEntry_010
2593 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2594 */
2595 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_010, TestSize.Level1)
2596 {
2597 auto interruptServiceTest = GetTnterruptServiceTest();
2598 interruptServiceTest->zonesMap_.clear();
2599 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2600 AudioInterrupt interrupt_1;
2601 AudioInterrupt interrupt_2;
2602
2603 interrupt_1.mode = SHARE_MODE;
2604 interrupt_1.pid = 0;
2605 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2606 std::make_pair(interrupt_1, ACTIVE));
2607
2608 interrupt_2.mode = SHARE_MODE;
2609 interrupt_2.pid = 1;
2610 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2611 std::make_pair(interrupt_2, PLACEHOLDER));
2612
2613 interruptServiceTest->SimulateFocusEntry(0);
2614 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == ACTIVE);
2615 interruptServiceTest->zonesMap_.clear();
2616 }
2617
2618 /**
2619 * @tc.name : Test AudioInterruptService.
2620 * @tc.number: AudioInterruptService_SimulateFocusEntry_011
2621 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2622 */
2623 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_011, TestSize.Level1)
2624 {
2625 auto interruptServiceTest = GetTnterruptServiceTest();
2626 interruptServiceTest->zonesMap_.clear();
2627 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2628 AudioInterrupt interrupt_1;
2629 AudioInterrupt interrupt_2;
2630
2631 interrupt_1.mode = SHARE_MODE;
2632 interrupt_1.pid = -1;
2633 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2634 std::make_pair(interrupt_1, PLACEHOLDER));
2635
2636 interrupt_2.mode = SHARE_MODE;
2637 interrupt_2.pid = 1;
2638 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2639 std::make_pair(interrupt_2, PLACEHOLDER));
2640
2641 interruptServiceTest->SimulateFocusEntry(0);
2642 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == PLACEHOLDER);
2643 interruptServiceTest->zonesMap_.clear();
2644 }
2645
2646 /**
2647 * @tc.name : Test AudioInterruptService.
2648 * @tc.number: AudioInterruptService_SimulateFocusEntry_012
2649 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2650 */
2651 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_012, TestSize.Level1)
2652 {
2653 auto interruptServiceTest = GetTnterruptServiceTest();
2654 interruptServiceTest->zonesMap_.clear();
2655 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2656 AudioInterrupt interrupt_1;
2657 AudioInterrupt interrupt_2;
2658
2659 interrupt_1.mode = SHARE_MODE;
2660 interrupt_1.pid = -1;
2661 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2662 std::make_pair(interrupt_1, ACTIVE));
2663
2664 interrupt_2.mode = SHARE_MODE;
2665 interrupt_2.pid = 1;
2666 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2667 std::make_pair(interrupt_2, PLACEHOLDER));
2668
2669 interruptServiceTest->SimulateFocusEntry(0);
2670 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == ACTIVE);
2671 interruptServiceTest->zonesMap_.clear();
2672 }
2673
2674 /**
2675 * @tc.name : Test AudioInterruptService.
2676 * @tc.number: AudioInterruptService_SimulateFocusEntry_013
2677 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2678 */
2679 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_013, TestSize.Level1)
2680 {
2681 auto interruptServiceTest = GetTnterruptServiceTest();
2682 interruptServiceTest->zonesMap_.clear();
2683 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2684 AudioInterrupt interrupt_1;
2685 AudioInterrupt interrupt_2;
2686
2687 interrupt_1.mode = SHARE_MODE;
2688 interrupt_1.pid = 1;
2689 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2690 std::make_pair(interrupt_1, PLACEHOLDER));
2691
2692 interrupt_2.mode = SHARE_MODE;
2693 interrupt_2.pid = -1;
2694 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2695 std::make_pair(interrupt_2, PLACEHOLDER));
2696
2697 interruptServiceTest->SimulateFocusEntry(0);
2698 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == PLACEHOLDER);
2699 interruptServiceTest->zonesMap_.clear();
2700 }
2701
2702 /**
2703 * @tc.name : Test AudioInterruptService.
2704 * @tc.number: AudioInterruptService_SimulateFocusEntry_014
2705 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2706 */
2707 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_014, TestSize.Level1)
2708 {
2709 auto interruptServiceTest = GetTnterruptServiceTest();
2710 interruptServiceTest->zonesMap_.clear();
2711 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2712 AudioInterrupt interrupt_1;
2713 AudioInterrupt interrupt_2;
2714
2715 interrupt_1.mode = SHARE_MODE;
2716 interrupt_1.pid = 1;
2717 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2718 std::make_pair(interrupt_1, ACTIVE));
2719
2720 interrupt_2.mode = SHARE_MODE;
2721 interrupt_2.pid = -1;
2722 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2723 std::make_pair(interrupt_2, PLACEHOLDER));
2724
2725 interruptServiceTest->SimulateFocusEntry(0);
2726 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == ACTIVE);
2727 interruptServiceTest->zonesMap_.clear();
2728 }
2729
2730 /**
2731 * @tc.name : Test AudioInterruptService.
2732 * @tc.number: AudioInterruptService_SimulateFocusEntry_015
2733 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2734 */
2735 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_015, TestSize.Level1)
2736 {
2737 auto interruptServiceTest = GetTnterruptServiceTest();
2738 interruptServiceTest->zonesMap_.clear();
2739 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2740 AudioInterrupt interrupt_1;
2741 AudioInterrupt interrupt_2;
2742
2743 interrupt_1.mode = INDEPENDENT_MODE;
2744 interrupt_1.pid = 1;
2745 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2746 std::make_pair(interrupt_1, ACTIVE));
2747
2748 interrupt_2.mode = SHARE_MODE;
2749 interrupt_2.pid = 1;
2750 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2751 std::make_pair(interrupt_2, PLACEHOLDER));
2752
2753 interruptServiceTest->SimulateFocusEntry(0);
2754 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == ACTIVE);
2755 interruptServiceTest->zonesMap_.clear();
2756 }
2757
2758 /**
2759 * @tc.name : Test AudioInterruptService.
2760 * @tc.number: AudioInterruptService_SimulateFocusEntry_016
2761 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2762 */
2763 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_016, TestSize.Level1)
2764 {
2765 auto interruptServiceTest = GetTnterruptServiceTest();
2766 interruptServiceTest->zonesMap_.clear();
2767 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2768 AudioInterrupt interrupt_1;
2769 AudioInterrupt interrupt_2;
2770
2771 interrupt_1.mode = INDEPENDENT_MODE;
2772 interrupt_1.pid = 1;
2773 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2774 std::make_pair(interrupt_1, PLACEHOLDER));
2775
2776 interrupt_2.mode = SHARE_MODE;
2777 interrupt_2.pid = 1;
2778 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2779 std::make_pair(interrupt_2, PLACEHOLDER));
2780
2781 interruptServiceTest->SimulateFocusEntry(0);
2782 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == PLACEHOLDER);
2783 interruptServiceTest->zonesMap_.clear();
2784 }
2785
2786 /**
2787 * @tc.name : Test AudioInterruptService.
2788 * @tc.number: AudioInterruptService_SimulateFocusEntry_017
2789 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2790 */
2791 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_017, TestSize.Level1)
2792 {
2793 auto interruptServiceTest = GetTnterruptServiceTest();
2794 interruptServiceTest->zonesMap_.clear();
2795 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2796 AudioInterrupt interrupt_1;
2797 AudioInterrupt interrupt_2;
2798
2799 interrupt_1.mode = SHARE_MODE;
2800 interrupt_1.pid = 1;
2801 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2802 std::make_pair(interrupt_1, ACTIVE));
2803
2804 interrupt_2.mode = INDEPENDENT_MODE;
2805 interrupt_2.pid = 1;
2806 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2807 std::make_pair(interrupt_2, PLACEHOLDER));
2808
2809 interruptServiceTest->SimulateFocusEntry(0);
2810 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == ACTIVE);
2811 interruptServiceTest->zonesMap_.clear();
2812 }
2813
2814 /**
2815 * @tc.name : Test AudioInterruptService.
2816 * @tc.number: AudioInterruptService_SimulateFocusEntry_018
2817 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2818 */
2819 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_018, TestSize.Level1)
2820 {
2821 auto interruptServiceTest = GetTnterruptServiceTest();
2822 interruptServiceTest->zonesMap_.clear();
2823 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2824 AudioInterrupt interrupt_1;
2825 AudioInterrupt interrupt_2;
2826
2827 interrupt_1.mode = SHARE_MODE;
2828 interrupt_1.pid = 1;
2829 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2830 std::make_pair(interrupt_1, PLACEHOLDER));
2831
2832 interrupt_2.mode = INDEPENDENT_MODE;
2833 interrupt_2.pid = 1;
2834 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2835 std::make_pair(interrupt_2, PLACEHOLDER));
2836
2837 interruptServiceTest->SimulateFocusEntry(0);
2838 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == PLACEHOLDER);
2839 interruptServiceTest->zonesMap_.clear();
2840 }
2841
2842 /**
2843 * @tc.name : Test AudioInterruptService.
2844 * @tc.number: AudioInterruptService_SimulateFocusEntry_019
2845 * @tc.desc : Test SimulateFocusEntry.
2846 */
2847 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_019, TestSize.Level1)
2848 {
2849 auto interruptServiceTest = GetTnterruptServiceTest();
2850 interruptServiceTest->zonesMap_.clear();
2851 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2852 AudioInterrupt interrupt_1;
2853 AudioInterrupt interrupt_2;
2854
2855 interrupt_1.mode = SHARE_MODE;
2856 interrupt_1.pid = 0;
2857 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2858 std::make_pair(interrupt_1, ACTIVE));
2859
2860 interrupt_2.mode = SHARE_MODE;
2861 interrupt_2.pid = 1;
2862 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2863 std::make_pair(interrupt_2, PLACEHOLDER));
2864
2865 interruptServiceTest->SimulateFocusEntry(0);
2866 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == ACTIVE);
2867 interruptServiceTest->zonesMap_.clear();
2868 }
2869
2870 /**
2871 * @tc.name : Test SimulateFocusEntry
2872 * @tc.number: AudioInterruptService_SimulateFocusEntry_020
2873 * @tc.desc : Test SimulateFocusEntry
2874 */
2875 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_020, TestSize.Level1)
2876 {
2877 auto interruptServiceTest = GetTnterruptServiceTest();
2878 interruptServiceTest->zonesMap_.clear();
2879
2880 AudioInterrupt interruptTest;
2881 interruptTest.mode = INDEPENDENT_MODE;
2882 interruptTest.pid = 0;
2883 std::pair<AudioInterrupt, AudioFocuState> audioFocusTypePair;
2884 audioFocusTypePair.first = interruptTest;
2885 audioFocusTypePair.second = PLACEHOLDER;
2886 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2887 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2888 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2889
2890 auto ret = interruptServiceTest->SimulateFocusEntry(0);
2891 EXPECT_EQ(PLACEHOLDER, ret.begin()->second);
2892 }
2893
2894 /**
2895 * @tc.name : Test SimulateFocusEntry
2896 * @tc.number: AudioInterruptService_SimulateFocusEntry_021
2897 * @tc.desc : Test SimulateFocusEntry
2898 */
2899 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_021, TestSize.Level1)
2900 {
2901 auto interruptServiceTest = GetTnterruptServiceTest();
2902 interruptServiceTest->zonesMap_.clear();
2903
2904 AudioInterrupt interruptTest;
2905 interruptTest.mode = SHARE_MODE;
2906 interruptTest.pid = 0;
2907 std::pair<AudioInterrupt, AudioFocuState> audioFocusTypePair;
2908 audioFocusTypePair.first = interruptTest;
2909 audioFocusTypePair.second = ACTIVE;
2910 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2911 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2912 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2913
2914 auto ret = interruptServiceTest->SimulateFocusEntry(0);
2915 auto it = ret.begin();
2916 EXPECT_EQ(SHARE_MODE, it->first.mode);
2917 EXPECT_NE(-1, it->first.pid);
2918 std::advance(it, 1);
2919 EXPECT_EQ(SHARE_MODE, it->first.mode);
2920 EXPECT_NE(-1, it->first.pid);
2921 EXPECT_EQ(ret.begin()->first.pid, it->first.pid);
2922 }
2923
2924 /**
2925 * @tc.name : Test SimulateFocusEntry
2926 * @tc.number: AudioInterruptService_SimulateFocusEntry_022
2927 * @tc.desc : Test SimulateFocusEntry
2928 */
2929 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_022, TestSize.Level1)
2930 {
2931 auto interruptServiceTest = GetTnterruptServiceTest();
2932 interruptServiceTest->zonesMap_.clear();
2933 interruptServiceTest->focusCfgMap_.clear();
2934
2935
2936 AudioInterrupt interruptTest;
2937 interruptTest.mode = SHARE_MODE;
2938 interruptTest.pid = 0;
2939 std::pair<AudioInterrupt, AudioFocuState> audioFocusTypePair;
2940 audioFocusTypePair.first = interruptTest;
2941 audioFocusTypePair.second = ACTIVE;
2942 audioFocusTypePair.first.audioFocusType.streamType = STREAM_VOICE_CALL;
2943 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2944 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2945
2946 std::pair<AudioFocusType, AudioFocusType> focusTypePair;
2947 AudioFocusEntry FocusEntryTest;
2948 FocusEntryTest.isReject = false;
2949 FocusEntryTest.hintType = static_cast<InterruptHint>(INTERRUPT_HINT_ERROR);
2950 focusTypePair.first.streamType = STREAM_VOICE_CALL;
2951 focusTypePair.second.streamType = STREAM_MUSIC;
2952 interruptServiceTest->focusCfgMap_[focusTypePair] = FocusEntryTest;
2953 audioFocusTypePair.first.pid = 1;
2954 audioFocusTypePair.second = PAUSE;
2955 audioFocusTypePair.first.audioFocusType.streamType = STREAM_VOICE_CALL;
2956 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2957
2958 audioFocusTypePair.first.audioFocusType.streamType = STREAM_MUSIC;
2959 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2960
2961 auto ret = interruptServiceTest->SimulateFocusEntry(0);
2962 auto it = ret.begin();
2963 std::advance(it, 1);
2964 EXPECT_EQ(PAUSE, it->second);
2965 }
2966
2967 /**
2968 * @tc.name : Test SimulateFocusEntry
2969 * @tc.number: AudioInterruptService_SimulateFocusEntry_023
2970 * @tc.desc : Test SimulateFocusEntry
2971 */
2972 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_023, TestSize.Level1)
2973 {
2974 auto interruptServiceTest = GetTnterruptServiceTest();
2975 interruptServiceTest->zonesMap_.clear();
2976 interruptServiceTest->focusCfgMap_.clear();
2977
2978 AudioInterrupt interruptTest;
2979 interruptTest.mode = SHARE_MODE;
2980 interruptTest.pid = 0;
2981 std::pair<AudioInterrupt, AudioFocuState> audioFocusTypePair;
2982 audioFocusTypePair.first = interruptTest;
2983 audioFocusTypePair.second = ACTIVE;
2984 audioFocusTypePair.first.audioFocusType.streamType = STREAM_VOICE_CALL;
2985 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2986 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2987
2988 std::pair<AudioFocusType, AudioFocusType> focusTypePair;
2989 AudioFocusEntry FocusEntryTest;
2990 FocusEntryTest.isReject = false;
2991 FocusEntryTest.hintType = static_cast<InterruptHint>(INTERRUPT_HINT_ERROR);
2992 focusTypePair.first.streamType = STREAM_VOICE_CALL;
2993 focusTypePair.second.streamType = STREAM_MUSIC;
2994 interruptServiceTest->focusCfgMap_[focusTypePair] = FocusEntryTest;
2995 audioFocusTypePair.first.pid = 1;
2996 audioFocusTypePair.second = ACTIVE;
2997 audioFocusTypePair.first.audioFocusType.streamType = STREAM_VOICE_CALL;
2998 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2999
3000 interruptTest.mode = INDEPENDENT_MODE;
3001 audioFocusTypePair.first.audioFocusType.streamType = STREAM_MUSIC;
3002 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
3003
3004 auto ret = interruptServiceTest->SimulateFocusEntry(0);
3005 auto it = ret.begin();
3006 std::advance(it, 1);
3007 EXPECT_NE(PAUSE, it->second);
3008 EXPECT_EQ(STREAM_VOICE_CALL, it->first.audioFocusType.streamType);
3009 }
3010
3011 /**
3012 * @tc.name : Test SimulateFocusEntry
3013 * @tc.number: AudioInterruptService_SimulateFocusEntry_024
3014 * @tc.desc : Test SimulateFocusEntry
3015 */
3016 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_024, TestSize.Level1)
3017 {
3018 auto interruptServiceTest = GetTnterruptServiceTest();
3019 interruptServiceTest->zonesMap_.clear();
3020 interruptServiceTest->focusCfgMap_.clear();
3021
3022
3023 AudioInterrupt interruptTest;
3024 interruptTest.mode = SHARE_MODE;
3025 interruptTest.pid = 0;
3026 std::pair<AudioInterrupt, AudioFocuState> audioFocusTypePair;
3027 audioFocusTypePair.first = interruptTest;
3028 audioFocusTypePair.second = ACTIVE;
3029 audioFocusTypePair.first.audioFocusType.streamType = STREAM_VOICE_CALL;
3030 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
3031 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
3032
3033 std::pair<AudioFocusType, AudioFocusType> focusTypePair;
3034 AudioFocusEntry FocusEntryTest;
3035 FocusEntryTest.isReject = false;
3036 FocusEntryTest.hintType = static_cast<InterruptHint>(INTERRUPT_HINT_ERROR);
3037 focusTypePair.first.streamType = STREAM_VOICE_CALL;
3038 focusTypePair.second.streamType = STREAM_MUSIC;
3039 interruptServiceTest->focusCfgMap_[focusTypePair] = FocusEntryTest;
3040 audioFocusTypePair.first.pid = 1;
3041 audioFocusTypePair.second = PLACEHOLDER;
3042 audioFocusTypePair.first.audioFocusType.streamType = STREAM_VOICE_CALL;
3043 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
3044
3045 interruptTest.mode = INDEPENDENT_MODE;
3046 audioFocusTypePair.first.audioFocusType.streamType = STREAM_MUSIC;
3047 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
3048
3049 auto ret = interruptServiceTest->SimulateFocusEntry(0);
3050 auto it = ret.begin();
3051 std::advance(it, 1);
3052 EXPECT_EQ(PLACEHOLDER, it->second);
3053 std::advance(it, 2);
3054 EXPECT_NE(SHARE_MODE, it->first.mode);
3055 }
3056
3057 /**
3058 * @tc.name : Test AudioInterruptService.
3059 * @tc.number: AudioInterruptServiceRequestAudioFocus_001
3060 * @tc.desc : Test RequestAudioFocus.
3061 */
3062 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRequestAudioFocus_001, TestSize.Level1)
3063 {
3064 sptr<AudioPolicyServer> server = nullptr;
3065 auto interruptServiceTest = GetTnterruptServiceTest();
3066 EXPECT_EQ(interruptServiceTest->sessionService_, nullptr);
3067 interruptServiceTest->Init(server);
3068 AudioInterrupt incomingInterrupt;
3069
3070 interruptServiceTest->clientOnFocus_ = 0;
3071 auto retStatus = interruptServiceTest->RequestAudioFocus(0, incomingInterrupt);
3072 EXPECT_EQ(retStatus, SUCCESS);
3073
3074 interruptServiceTest->clientOnFocus_ = 0;
3075 retStatus = interruptServiceTest->RequestAudioFocus(1, incomingInterrupt);
3076 EXPECT_EQ(retStatus, SUCCESS);
3077
3078 interruptServiceTest->focussedAudioInterruptInfo_ = std::make_unique<AudioInterrupt>();
3079 interruptServiceTest->clientOnFocus_ = 0;
3080 retStatus = interruptServiceTest->RequestAudioFocus(1, incomingInterrupt);
3081 EXPECT_EQ(retStatus, SUCCESS);
3082 }
3083
3084 /**
3085 * @tc.name : Test AudioInterruptService.
3086 * @tc.number: AudioInterruptService_DeactivateAudioInterruptInternal_004
3087 * @tc.desc : Test DeactivateAudioInterruptInternal.
3088 */
3089 HWTEST(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInternal_004, TestSize.Level1)
3090 {
3091 auto interruptServiceTest = GetTnterruptServiceTest();
3092 interruptServiceTest->zonesMap_.clear();
3093 AudioInterrupt audioInterrupt = {};
3094 AudioSessionService audioSessionService;
3095 AudioInterruptService audioInterruptService;
3096
3097 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, true);
3098 EXPECT_EQ(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end());
3099 audioInterrupt.pid = 0;
3100 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
3101 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, true);
3102 EXPECT_NE(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end());
3103
3104 interruptServiceTest->zonesMap_.clear();
3105 }
3106
3107 /**
3108 * @tc.name : Test AudioInterruptService
3109 * @tc.number: AudioInterruptService_GetAppState_001
3110 * @tc.desc : Test GetAppState
3111 */
3112 HWTEST(AudioInterruptUnitTest, AudioInterruptService_GetAppState_001, TestSize.Level1)
3113 {
3114 auto server = GetPolicyServerTest();
3115 auto interruptServiceTest = GetTnterruptServiceTest();
3116 interruptServiceTest->zonesMap_.clear();
3117 int32_t appPid = -1;
3118
3119 uint8_t ret = interruptServiceTest->GetAppState(appPid);
3120 EXPECT_EQ(ret, 0);
3121 }
3122
3123 /**
3124 * @tc.name : Test AudioInterruptService
3125 * @tc.number: AudioInterruptService_WriteStartDfxMsg_001
3126 * @tc.desc : Test WriteStartDfxMsg
3127 */
3128 HWTEST(AudioInterruptUnitTest, AudioInterruptService_WriteStartDfxMsg_001, TestSize.Level1)
3129 {
3130 auto server = GetPolicyServerTest();
3131 auto interruptServiceTest = GetTnterruptServiceTest();
3132 interruptServiceTest->zonesMap_.clear();
3133 interruptServiceTest->Init(server);
3134
3135 InterruptDfxBuilder dfxBuilder;
3136 AudioInterrupt audioInterrupt = {};
3137 audioInterrupt.state == State::PREPARED;
3138 audioInterrupt.audioFocusType.streamType = STREAM_DEFAULT;
3139 audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
3140 audioInterrupt.audioFocusType.isPlay = false;
3141
3142 interruptServiceTest->WriteStartDfxMsg(dfxBuilder, audioInterrupt);
3143 EXPECT_NE(interruptServiceTest->dfxCollector_, nullptr);
3144 }
3145
3146 /**
3147 * @tc.name : Test AudioInterruptService
3148 * @tc.number: AudioInterruptService_WriteSessionTimeoutDfxEvent_001
3149 * @tc.desc : Test WriteSessionTimeoutDfxEvent
3150 */
3151 HWTEST(AudioInterruptUnitTest, AudioInterruptService_WriteSessionTimeoutDfxEvent_001, TestSize.Level1)
3152 {
3153 auto server = GetPolicyServerTest();
3154 auto interruptServiceTest = GetTnterruptServiceTest();
3155 interruptServiceTest->zonesMap_.clear();
3156 interruptServiceTest->Init(server);
3157
3158 int32_t pid = 1001;
3159 AudioInterrupt interruptTest;
3160 interruptTest.mode = SHARE_MODE;
3161 interruptTest.pid = 0;
3162 std::pair<AudioInterrupt, AudioFocuState> audioFocusTypePair;
3163 audioFocusTypePair.first = interruptTest;
3164 audioFocusTypePair.second = ACTIVE;
3165 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
3166 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
3167
3168 interruptServiceTest->WriteSessionTimeoutDfxEvent(pid);
3169 EXPECT_NE(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end());
3170 }
3171
3172 /**
3173 * @tc.name : Test AudioInterruptService
3174 * @tc.number: AudioInterruptService_WriteStopDfxMsg_001
3175 * @tc.desc : Test WriteStopDfxMsg
3176 */
3177 HWTEST(AudioInterruptUnitTest, AudioInterruptService_WriteStopDfxMsg_001, TestSize.Level1)
3178 {
3179 auto server = GetPolicyServerTest();
3180 auto interruptServiceTest = GetTnterruptServiceTest();
3181 interruptServiceTest->zonesMap_.clear();
3182 interruptServiceTest->Init(server);
3183
3184 int32_t pid = 1001;
3185 AudioInterrupt interruptTest;
3186 interruptTest.mode = SHARE_MODE;
3187 interruptTest.pid = 0;
3188 interruptTest.state = State::RELEASED;
3189 std::pair<AudioInterrupt, AudioFocuState> audioFocusTypePair;
3190 audioFocusTypePair.first = interruptTest;
3191 audioFocusTypePair.second = ACTIVE;
3192 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
3193 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
3194
3195 interruptServiceTest->WriteStopDfxMsg(interruptTest);
3196 EXPECT_NE(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end());
3197 }
3198
3199 /**
3200 * @tc.name : Test AudioInterruptService
3201 * @tc.number: AudioInterruptService_AudioSessionInfoDump_001
3202 * @tc.desc : Test AudioSessionInfoDump
3203 */
3204 HWTEST(AudioInterruptUnitTest, AudioInterruptService_AudioSessionInfoDump_001, TestSize.Level1)
3205 {
3206 auto server = GetPolicyServerTest();
3207 auto interruptServiceTest = GetTnterruptServiceTest();
3208 interruptServiceTest->zonesMap_.clear();
3209 std::string dumpString = "test dump string";
3210
3211 interruptServiceTest->AudioSessionInfoDump(dumpString);
3212 EXPECT_EQ(interruptServiceTest->sessionService_, nullptr);
3213
3214 interruptServiceTest->Init(server);
3215 interruptServiceTest->AudioSessionInfoDump(dumpString);
3216 EXPECT_NE(interruptServiceTest->sessionService_, nullptr);
3217 }
3218
3219 /**
3220 * @tc.name : Test AudioInterruptService
3221 * @tc.number: AudioInterruptService_101
3222 * @tc.desc : Test AudioInterruptService
3223 */
3224 HWTEST(AudioInterruptUnitTest, AudioInterruptService_101, TestSize.Level1)
3225 {
3226 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3227 EXPECT_NE(audioInterruptService, nullptr);
3228
3229 AudioInterrupt incomingInterrupt;
3230 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
3231 AudioInterrupt activeInterrupt;
3232 activeInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
3233
3234 auto ret = audioInterruptService->IsCanMixInterrupt(incomingInterrupt, activeInterrupt);
3235 EXPECT_EQ(ret, false);
3236 }
3237
3238 /**
3239 * @tc.name : Test AudioInterruptService
3240 * @tc.number: AudioInterruptService_102
3241 * @tc.desc : Test AudioInterruptService
3242 */
3243 HWTEST(AudioInterruptUnitTest, AudioInterruptService_102, TestSize.Level1)
3244 {
3245 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3246 EXPECT_NE(audioInterruptService, nullptr);
3247
3248 AudioInterrupt incomingInterrupt;
3249 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
3250 AudioInterrupt activeInterrupt;
3251 activeInterrupt.audioFocusType.streamType = STREAM_MUSIC;
3252
3253 auto ret = audioInterruptService->IsCanMixInterrupt(incomingInterrupt, activeInterrupt);
3254 EXPECT_EQ(ret, true);
3255 }
3256
3257 /**
3258 * @tc.name : Test AudioInterruptService
3259 * @tc.number: AudioInterruptService_103
3260 * @tc.desc : Test AudioInterruptService
3261 */
3262 HWTEST(AudioInterruptUnitTest, AudioInterruptService_103, TestSize.Level1)
3263 {
3264 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3265 EXPECT_NE(audioInterruptService, nullptr);
3266
3267 AudioInterrupt incomingInterrupt;
3268 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
3269 AudioInterrupt activeInterrupt;
3270 activeInterrupt.audioFocusType.streamType = STREAM_MUSIC;
3271
3272 auto ret = audioInterruptService->IsCanMixInterrupt(incomingInterrupt, activeInterrupt);
3273 EXPECT_EQ(ret, true);
3274 }
3275
3276 /**
3277 * @tc.name : Test AudioInterruptService
3278 * @tc.number: AudioInterruptService_104
3279 * @tc.desc : Test AudioInterruptService
3280 */
3281 HWTEST(AudioInterruptUnitTest, AudioInterruptService_104, TestSize.Level1)
3282 {
3283 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3284 EXPECT_NE(audioInterruptService, nullptr);
3285
3286 AudioInterrupt incomingInterrupt;
3287 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
3288 incomingInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
3289 AudioInterrupt activeInterrupt;
3290 activeInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
3291 activeInterrupt.audioFocusType.streamType = STREAM_MUSIC;
3292
3293 auto ret = audioInterruptService->IsCanMixInterrupt(incomingInterrupt, activeInterrupt);
3294 EXPECT_EQ(ret, false);
3295 }
3296
3297 /**
3298 * @tc.name : Test AudioInterruptService
3299 * @tc.number: AudioInterruptService_105
3300 * @tc.desc : Test AudioInterruptService
3301 */
3302 HWTEST(AudioInterruptUnitTest, AudioInterruptService_105, TestSize.Level1)
3303 {
3304 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3305 EXPECT_NE(audioInterruptService, nullptr);
3306
3307 AudioInterrupt incomingInterrupt;
3308 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
3309 incomingInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
3310 AudioInterrupt activeInterrupt;
3311 activeInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
3312 activeInterrupt.audioFocusType.streamType = STREAM_MUSIC;
3313
3314 auto ret = audioInterruptService->IsCanMixInterrupt(incomingInterrupt, activeInterrupt);
3315 EXPECT_EQ(ret, true);
3316 }
3317
3318 /**
3319 * @tc.name : Test AudioInterruptService
3320 * @tc.number: AudioInterruptService_106
3321 * @tc.desc : Test AudioInterruptService
3322 */
3323 HWTEST(AudioInterruptUnitTest, AudioInterruptService_106, TestSize.Level1)
3324 {
3325 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3326 EXPECT_NE(audioInterruptService, nullptr);
3327
3328 AudioInterrupt incomingInterrupt;
3329 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
3330 incomingInterrupt.audioFocusType.streamType = STREAM_MUSIC;
3331 AudioInterrupt activeInterrupt;
3332 activeInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
3333 activeInterrupt.audioFocusType.streamType = STREAM_MUSIC;
3334
3335 auto ret = audioInterruptService->IsCanMixInterrupt(incomingInterrupt, activeInterrupt);
3336 EXPECT_EQ(ret, true);
3337 }
3338
3339 /**
3340 * @tc.name : Test AudioInterruptService
3341 * @tc.number: AudioInterruptService_107
3342 * @tc.desc : Test AudioInterruptService
3343 */
3344 HWTEST(AudioInterruptUnitTest, AudioInterruptService_107, TestSize.Level1)
3345 {
3346 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3347 EXPECT_NE(audioInterruptService, nullptr);
3348
3349 AudioInterrupt incomingInterrupt;
3350 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
3351 incomingInterrupt.audioFocusType.streamType = STREAM_MUSIC;
3352 AudioInterrupt activeInterrupt;
3353 activeInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
3354 activeInterrupt.audioFocusType.streamType = STREAM_MUSIC;
3355
3356 auto ret = audioInterruptService->IsCanMixInterrupt(incomingInterrupt, activeInterrupt);
3357 EXPECT_EQ(ret, false);
3358 }
3359
3360 /**
3361 * @tc.name : Test AudioInterruptService
3362 * @tc.number: AudioInterruptService_108
3363 * @tc.desc : Test AudioInterruptService
3364 */
3365 HWTEST(AudioInterruptUnitTest, AudioInterruptService_108, TestSize.Level1)
3366 {
3367 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3368 EXPECT_NE(audioInterruptService, nullptr);
3369
3370 int32_t systemAbilityId = 0;
3371 audioInterruptService->policyServer_ = new AudioPolicyServer(systemAbilityId);
3372 EXPECT_NE(audioInterruptService->policyServer_, nullptr);
3373 auto coreService = std::make_shared<AudioCoreService>();
3374 audioInterruptService->policyServer_->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(coreService);
3375 audioInterruptService->policyServer_->eventEntry_->coreService_ = std::make_shared<AudioCoreService>();
3376 AudioScene audioScene = AUDIO_SCENE_DEFAULT;
3377 AudioInterruptChangeType changeType = ACTIVATE_AUDIO_INTERRUPT;
3378
3379 audioInterruptService->UpdateAudioSceneFromInterrupt(audioScene, changeType);
3380 }
3381
3382 /**
3383 * @tc.name : Test AudioInterruptService
3384 * @tc.number: AudioInterruptService_109
3385 * @tc.desc : Test AudioInterruptService
3386 */
3387 HWTEST(AudioInterruptUnitTest, AudioInterruptService_109, TestSize.Level1)
3388 {
3389 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3390 EXPECT_NE(audioInterruptService, nullptr);
3391
3392 int32_t systemAbilityId = 0;
3393 audioInterruptService->policyServer_ = new AudioPolicyServer(systemAbilityId);
3394 auto coreService = std::make_shared<AudioCoreService>();
3395 audioInterruptService->policyServer_->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(coreService);
3396 audioInterruptService->policyServer_->eventEntry_->coreService_ = std::make_shared<AudioCoreService>();
3397
3398 audioInterruptService->policyServer_->SetAudioScene(AUDIO_SCENE_DEFAULT);
3399 EXPECT_NE(audioInterruptService->policyServer_, nullptr);
3400
3401 AudioScene audioScene = AUDIO_SCENE_PHONE_CALL;
3402 AudioInterruptChangeType changeType = DEACTIVATE_AUDIO_INTERRUPT;
3403
3404 audioInterruptService->UpdateAudioSceneFromInterrupt(audioScene, changeType);
3405 }
3406
3407 /**
3408 * @tc.name : Test AudioInterruptService
3409 * @tc.number: AudioInterruptService_110
3410 * @tc.desc : Test AudioInterruptService
3411 */
3412 HWTEST(AudioInterruptUnitTest, AudioInterruptService_110, TestSize.Level1)
3413 {
3414 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3415 EXPECT_NE(audioInterruptService, nullptr);
3416
3417 int32_t systemAbilityId = 0;
3418 audioInterruptService->policyServer_ = new AudioPolicyServer(systemAbilityId);
3419 auto coreService = std::make_shared<AudioCoreService>();
3420 audioInterruptService->policyServer_->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(coreService);
3421 audioInterruptService->policyServer_->eventEntry_->coreService_ = std::make_shared<AudioCoreService>();
3422
3423 audioInterruptService->policyServer_->SetAudioScene(AUDIO_SCENE_PHONE_CALL);
3424 EXPECT_NE(audioInterruptService->policyServer_, nullptr);
3425
3426 AudioScene audioScene = AUDIO_SCENE_DEFAULT;
3427 AudioInterruptChangeType changeType = DEACTIVATE_AUDIO_INTERRUPT;
3428
3429 audioInterruptService->UpdateAudioSceneFromInterrupt(audioScene, changeType);
3430 }
3431
3432 /**
3433 * @tc.name : Test AudioInterruptService
3434 * @tc.number: AudioInterruptService_111
3435 * @tc.desc : Test AudioInterruptService
3436 */
3437 HWTEST(AudioInterruptUnitTest, AudioInterruptService_111, TestSize.Level1)
3438 {
3439 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3440 EXPECT_NE(audioInterruptService, nullptr);
3441
3442 int32_t systemAbilityId = 0;
3443 audioInterruptService->policyServer_ = new AudioPolicyServer(systemAbilityId);
3444 auto coreService = std::make_shared<AudioCoreService>();
3445 audioInterruptService->policyServer_->eventEntry_ = std::make_shared<AudioCoreService::EventEntry>(coreService);
3446 audioInterruptService->policyServer_->eventEntry_->coreService_ = std::make_shared<AudioCoreService>();
3447
3448 EXPECT_NE(audioInterruptService->policyServer_, nullptr);
3449
3450 AudioScene audioScene = AUDIO_SCENE_DEFAULT;
3451 AudioInterruptChangeType changeType = static_cast<AudioInterruptChangeType>(3);
3452
3453 audioInterruptService->UpdateAudioSceneFromInterrupt(audioScene, changeType);
3454 }
3455
3456 /**
3457 * @tc.name : Test AudioInterruptService
3458 * @tc.number: AudioInterruptService_112
3459 * @tc.desc : Test AudioInterruptService
3460 */
3461 HWTEST(AudioInterruptUnitTest, AudioInterruptService_112, TestSize.Level1)
3462 {
3463 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3464 EXPECT_NE(audioInterruptService, nullptr);
3465
3466 AudioInterrupt incoming;
3467 AudioInterrupt inprocessing;
3468 AudioFocusEntry focusEntry;
3469 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
3470 bool bConcurrency = true;
3471
3472 auto ret = audioInterruptService->EvaluateWhetherContinue(incoming, inprocessing, focusEntry, bConcurrency);
3473 EXPECT_EQ(ret, true);
3474 }
3475
3476 /**
3477 * @tc.name : Test AudioInterruptService
3478 * @tc.number: AudioInterruptService_113
3479 * @tc.desc : Test AudioInterruptService
3480 */
3481 HWTEST(AudioInterruptUnitTest, AudioInterruptService_113, TestSize.Level1)
3482 {
3483 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3484 EXPECT_NE(audioInterruptService, nullptr);
3485
3486 AudioInterrupt incoming;
3487 AudioInterrupt inprocessing;
3488 AudioFocusEntry focusEntry;
3489 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
3490 bool bConcurrency = false;
3491
3492 auto ret = audioInterruptService->EvaluateWhetherContinue(incoming, inprocessing, focusEntry, bConcurrency);
3493 EXPECT_EQ(ret, false);
3494 }
3495
3496 /**
3497 * @tc.name : Test AudioInterruptService
3498 * @tc.number: AudioInterruptService_114
3499 * @tc.desc : Test AudioInterruptService
3500 */
3501 HWTEST(AudioInterruptUnitTest, AudioInterruptService_114, TestSize.Level1)
3502 {
3503 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3504 EXPECT_NE(audioInterruptService, nullptr);
3505
3506 AudioInterrupt incoming;
3507 AudioInterrupt inprocessing;
3508 AudioFocusEntry focusEntry;
3509 focusEntry.hintType = INTERRUPT_HINT_NONE;
3510 bool bConcurrency = false;
3511
3512 auto ret = audioInterruptService->EvaluateWhetherContinue(incoming, inprocessing, focusEntry, bConcurrency);
3513 EXPECT_EQ(ret, false);
3514 }
3515
3516 /**
3517 * @tc.name : Test AudioInterruptService
3518 * @tc.number: AudioInterruptService_115
3519 * @tc.desc : Test AudioInterruptService
3520 */
3521 HWTEST(AudioInterruptUnitTest, AudioInterruptService_115, TestSize.Level1)
3522 {
3523 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3524 EXPECT_NE(audioInterruptService, nullptr);
3525
3526 InterruptEventInternal interruptEvent;
3527 uint32_t streamId = 0;
3528 AudioInterrupt audioInterrupt = {};
3529 audioInterruptService->dfxCollector_ = std::make_unique<AudioInterruptDfxCollector>();
3530 EXPECT_NE(audioInterruptService->dfxCollector_, nullptr);
3531
3532 audioInterruptService->handler_ = std::make_shared<AudioPolicyServerHandler>();
3533 EXPECT_NE(audioInterruptService->handler_, nullptr);
3534
3535 audioInterruptService->SendInterruptEventCallback(interruptEvent, streamId, audioInterrupt);
3536 }
3537
3538 /**
3539 * @tc.name : Test AudioInterruptService
3540 * @tc.number: AudioInterruptService_116
3541 * @tc.desc : Test AudioInterruptService
3542 */
3543 HWTEST(AudioInterruptUnitTest, AudioInterruptService_116, TestSize.Level1)
3544 {
3545 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3546 EXPECT_NE(audioInterruptService, nullptr);
3547
3548 InterruptEventInternal interruptEvent;
3549 uint32_t streamId = 0;
3550 AudioInterrupt audioInterrupt = {};
3551 audioInterruptService->dfxCollector_ = std::make_unique<AudioInterruptDfxCollector>();
3552 EXPECT_NE(audioInterruptService->dfxCollector_, nullptr);
3553
3554 audioInterruptService->handler_ = nullptr;
3555
3556 audioInterruptService->SendInterruptEventCallback(interruptEvent, streamId, audioInterrupt);
3557 }
3558
3559 /**
3560 * @tc.name : Test AudioInterruptService
3561 * @tc.number: AudioInterruptService_117
3562 * @tc.desc : Test AudioInterruptService
3563 */
3564 HWTEST(AudioInterruptUnitTest, AudioInterruptService_117, TestSize.Level1)
3565 {
3566 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3567 EXPECT_NE(audioInterruptService, nullptr);
3568
3569 std::list<std::pair<AudioInterrupt, AudioFocuState>> myList;
3570 myList.emplace_back(AudioInterrupt(), AudioFocuState::PAUSEDBYREMOTE);
3571 auto iterActive = myList.begin();
3572
3573 AudioFocuState oldState = PAUSEDBYREMOTE;
3574
3575 std::list<std::pair<AudioInterrupt, AudioFocuState>> myList2;
3576 myList.emplace_back(AudioInterrupt(), AudioFocuState::PAUSEDBYREMOTE);
3577 auto iterNew = myList.begin();
3578
3579 auto ret = audioInterruptService->IsHandleIter(iterActive, oldState, iterNew);
3580 EXPECT_EQ(ret, true);
3581 }
3582
3583 /**
3584 * @tc.name : Test AudioInterruptService
3585 * @tc.number: AudioInterruptService_118
3586 * @tc.desc : Test AudioInterruptService
3587 */
3588 HWTEST(AudioInterruptUnitTest, AudioInterruptService_118, TestSize.Level1)
3589 {
3590 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3591 EXPECT_NE(audioInterruptService, nullptr);
3592
3593 std::list<std::pair<AudioInterrupt, AudioFocuState>> myList;
3594 myList.emplace_back(AudioInterrupt(), AudioFocuState::PAUSEDBYREMOTE);
3595 auto iterActive = myList.begin();
3596
3597 AudioFocuState oldState = ACTIVE;
3598
3599 std::list<std::pair<AudioInterrupt, AudioFocuState>> myList2;
3600 myList.emplace_back(AudioInterrupt(), AudioFocuState::PAUSEDBYREMOTE);
3601 auto iterNew = myList.begin();
3602
3603 auto ret = audioInterruptService->IsHandleIter(iterActive, oldState, iterNew);
3604 EXPECT_EQ(ret, false);
3605 }
3606
3607 /**
3608 * @tc.name : Test AudioInterruptService
3609 * @tc.number: AudioInterruptService_119
3610 * @tc.desc : Test AudioInterruptService
3611 */
3612 HWTEST(AudioInterruptUnitTest, AudioInterruptService_119, TestSize.Level1)
3613 {
3614 auto interruptServiceTest = GetTnterruptServiceTest();
3615 ASSERT_NE(interruptServiceTest, nullptr);
3616
3617 interruptServiceTest->zonesMap_.clear();
3618 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
3619 interruptServiceTest->SetCallbackHandler(GetServerHandlerTest());
3620
3621 AudioInterrupt audioInterrupt = {};
3622 int32_t ret1 = interruptServiceTest->ActivateAudioInterrupt(0, audioInterrupt);
3623 EXPECT_EQ(ret1, SUCCESS);
3624
3625 AudioInterrupt a1, a2, a3;
3626 a1.streamUsage = StreamUsage::STREAM_USAGE_VOICE_MODEM_COMMUNICATION;
3627 a2.streamUsage = StreamUsage::STREAM_USAGE_VOICE_RINGTONE;
3628 a3.streamUsage = StreamUsage::STREAM_USAGE_UNKNOWN;
3629 interruptServiceTest->zonesMap_[0]->audioFocusInfoList.push_back({a1, AudioFocuState::ACTIVE});
3630 interruptServiceTest->zonesMap_[0]->audioFocusInfoList.push_back({a2, AudioFocuState::ACTIVE});
3631 interruptServiceTest->zonesMap_[0]->audioFocusInfoList.push_back({a3, AudioFocuState::ACTIVE});
3632
3633 int32_t ret2 = interruptServiceTest->ActivatePreemptMode();
3634 EXPECT_EQ(ret2, SUCCESS);
3635
3636 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.empty(), true);
3637
3638 ret1 = interruptServiceTest->ActivateAudioInterrupt(0, audioInterrupt);
3639 EXPECT_EQ(ret1, ERR_FOCUS_DENIED);
3640
3641 ret2 = interruptServiceTest->DeactivatePreemptMode();
3642 EXPECT_EQ(ret2, SUCCESS);
3643 ret1 = interruptServiceTest->ActivateAudioInterrupt(0, audioInterrupt);
3644 EXPECT_EQ(ret1, SUCCESS);
3645 }
3646
3647 /**
3648 * @tc.name : Test RegisterDefaultVolumeTypeListener
3649 * @tc.number: RegisterDefaultVolumeTypeListenerTest
3650 * @tc.desc : Test RegisterDefaultVolumeTypeListener
3651 */
3652 HWTEST(AudioInterruptUnitTest, RegisterDefaultVolumeTypeListenerTest, TestSize.Level1)
3653 {
3654 AudioSettingProvider &settingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID);
3655 bool isDataShareReady = settingProvider.isDataShareReady_.load();
3656 settingProvider.SetDataShareReady(true);
3657 ASSERT_TRUE(settingProvider.isDataShareReady_.load());
3658 auto interruptServiceTest = GetTnterruptServiceTest();
3659 ASSERT_TRUE(interruptServiceTest != nullptr);
3660 // The result can be verified only after the datashare mock framework is completed.
3661 interruptServiceTest->RegisterDefaultVolumeTypeListener();
3662 settingProvider.SetDataShareReady(isDataShareReady);
3663 }
3664
3665 /**
3666 * @tc.name : Test AudioSessionFocusMode
3667 * @tc.number: AudioSessionFocusMode_001
3668 * @tc.desc : Test AudioSessionFocusMode
3669 */
3670 HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_001, TestSize.Level1)
3671 {
3672 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
3673 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3674 ASSERT_NE(audioInterruptService, nullptr);
3675 audioInterruptService->Init(GetPolicyServerTest());
3676 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
3677
3678 AudioInterrupt movieInterrupt;
3679 movieInterrupt.pid = CALLER_PID;
3680 movieInterrupt.streamId = 123; // fake stream id.
3681 movieInterrupt.audioFocusType.streamType = STREAM_MUSIC;
3682 movieInterrupt.audioFocusType.isPlay = true;
3683 movieInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
3684 int32_t ret = audioInterruptService->ActivateAudioInterrupt(DEFAULT_ZONE_ID, movieInterrupt, false);
3685 EXPECT_EQ(SUCCESS, ret);
3686
3687 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
3688 ASSERT_NE(nullptr, sessionService);
3689 audioInterruptService->sessionService_ = sessionService;
3690 ret = audioInterruptService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
3691 EXPECT_EQ(SUCCESS, ret);
3692 AudioSessionStrategy audioSessionStrategy;
3693 audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
3694 ret = audioInterruptService->ActivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID, audioSessionStrategy);
3695 EXPECT_EQ(SUCCESS, ret);
3696
3697 movieInterrupt.streamId = 456; // fake stream id.
3698 ret = audioInterruptService->ActivateAudioInterrupt(DEFAULT_ZONE_ID, movieInterrupt, false);
3699 EXPECT_EQ(SUCCESS, ret);
3700
3701 ret = audioInterruptService->DeactivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID);
3702 EXPECT_EQ(SUCCESS, ret);
3703 }
3704
3705 /**
3706 * @tc.name : Test AudioSessionFocusMode
3707 * @tc.number: AudioSessionFocusMode_002
3708 * @tc.desc : Test ActivateAudioSession interrupt other focus
3709 */
3710 HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_002, TestSize.Level1)
3711 {
3712 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
3713 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3714 ASSERT_NE(audioInterruptService, nullptr);
3715 audioInterruptService->Init(GetPolicyServerTest());
3716 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
3717
3718 AudioInterrupt movieInterrupt;
3719 movieInterrupt.audioFocusType.streamType = STREAM_MUSIC;
3720 movieInterrupt.audioFocusType.isPlay = true;
3721 movieInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
3722 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
3723 audioInterruptZone->audioFocusInfoList.emplace_back(movieInterrupt, AudioFocuState{ACTIVE});
3724 audioInterruptService->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
3725
3726 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
3727 ASSERT_NE(nullptr, sessionService);
3728 audioInterruptService->sessionService_ = sessionService;
3729 int32_t ret = sessionService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
3730 EXPECT_EQ(SUCCESS, ret);
3731 AudioSessionStrategy audioSessionStrategy;
3732 audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
3733 ret = audioInterruptService->ActivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID, audioSessionStrategy);
3734 EXPECT_EQ(SUCCESS, ret);
3735
3736 auto &newAudioInterruptZone = audioInterruptService->zonesMap_[DEFAULT_ZONE_ID];
3737 EXPECT_EQ(1, newAudioInterruptZone->audioFocusInfoList.size());
3738
3739 ret = audioInterruptService->DeactivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID);
3740 EXPECT_EQ(SUCCESS, ret);
3741 }
3742
3743 /**
3744 * @tc.name : Test AudioSessionFocusMode
3745 * @tc.number: AudioSessionFocusMode_003
3746 * @tc.desc : Test AudioSessionAbnormalCase
3747 */
3748 HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_003, TestSize.Level1)
3749 {
3750 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
3751 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3752 ASSERT_NE(audioInterruptService, nullptr);
3753 audioInterruptService->Init(GetPolicyServerTest());
3754
3755 audioInterruptService->sessionService_ = nullptr;
3756 int32_t ret = audioInterruptService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
3757 EXPECT_EQ(ERR_UNKNOWN, ret);
3758 bool updateScene = false;
3759 ret = audioInterruptService->ProcessFocusEntryForAudioSession(DEFAULT_ZONE_ID, CALLER_PID, updateScene);
3760 EXPECT_EQ(ERR_UNKNOWN, ret);
3761
3762 AudioInterrupt movieInterrupt;
3763 movieInterrupt.audioFocusType.streamType = STREAM_MUSIC;
3764 movieInterrupt.audioFocusType.isPlay = true;
3765 movieInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
3766
3767 audioInterruptService->TryHandleStreamCallbackInSession(DEFAULT_ZONE_ID, movieInterrupt);
3768
3769 InterruptEventInternal interruptEventInternal;
3770 audioInterruptService->DispatchInterruptEventForAudioSession(interruptEventInternal, movieInterrupt);
3771
3772 audioInterruptService->SendAudioSessionInterruptEventCallback(interruptEventInternal, movieInterrupt);
3773
3774 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
3775 audioInterruptService->SendAudioSessionInterruptEventCallback(interruptEventInternal, movieInterrupt);
3776
3777 int32_t zoneId = -1;
3778 bool result = audioInterruptService->ShouldBypassAudioSessionFocus(zoneId, movieInterrupt);
3779 EXPECT_FALSE(result);
3780 }
3781
3782 /**
3783 * @tc.name : Test AudioSessionFocusMode
3784 * @tc.number: AudioSessionFocusMode_004
3785 * @tc.desc : Test ShouldBypassAudioSessionFocus
3786 */
3787 HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_004, TestSize.Level1)
3788 {
3789 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
3790 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3791 ASSERT_NE(audioInterruptService, nullptr);
3792 audioInterruptService->Init(GetPolicyServerTest());
3793 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
3794
3795 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
3796 ASSERT_NE(nullptr, sessionService);
3797 audioInterruptService->sessionService_ = sessionService;
3798 int32_t ret = audioInterruptService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
3799 EXPECT_EQ(SUCCESS, ret);
3800
3801 AudioInterrupt movieInterrupt;
3802 movieInterrupt.pid = CALLER_PID;
3803 movieInterrupt.streamId = SESSION_ID_TEST;
3804 movieInterrupt.audioFocusType.streamType = STREAM_MUSIC;
3805 movieInterrupt.audioFocusType.isPlay = true;
3806 movieInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
3807
3808 int32_t zoneId = -1;
3809 bool result = audioInterruptService->ShouldBypassAudioSessionFocus(zoneId, movieInterrupt);
3810 EXPECT_FALSE(result);
3811
3812 movieInterrupt.isAudioSessionInterrupt = true;
3813 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
3814 audioInterruptZone->audioFocusInfoList.emplace_back(movieInterrupt, AudioFocuState{ACTIVE});
3815 audioInterruptService->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
3816
3817 result = audioInterruptService->ShouldBypassAudioSessionFocus(zoneId, movieInterrupt);
3818 EXPECT_FALSE(result);
3819
3820 movieInterrupt.isAudioSessionInterrupt = false;
3821 result = audioInterruptService->ShouldBypassAudioSessionFocus(zoneId, movieInterrupt);
3822 EXPECT_FALSE(result);
3823
3824 audioInterruptService->sessionService_ = nullptr;
3825 result = audioInterruptService->ShouldBypassAudioSessionFocus(zoneId, movieInterrupt);
3826 EXPECT_FALSE(result);
3827
3828 audioInterruptService->sessionService_ = sessionService;
3829 AudioSessionStrategy audioSessionStrategy;
3830 audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
3831 ret = audioInterruptService->ActivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID, audioSessionStrategy);
3832 EXPECT_EQ(SUCCESS, ret);
3833
3834 movieInterrupt.isAudioSessionInterrupt = false;
3835 result = audioInterruptService->ShouldBypassAudioSessionFocus(zoneId, movieInterrupt);
3836 EXPECT_FALSE(result);
3837 }
3838
3839 /**
3840 * @tc.name : Test AudioSessionFocusMode
3841 * @tc.number: AudioSessionFocusMode_005
3842 * @tc.desc : Test AudioSessionTimeOut
3843 */
3844 HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_005, TestSize.Level1)
3845 {
3846 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
3847 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3848 ASSERT_NE(audioInterruptService, nullptr);
3849 audioInterruptService->Init(GetPolicyServerTest());
3850 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
3851
3852 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
3853 ASSERT_NE(nullptr, sessionService);
3854 audioInterruptService->sessionService_ = sessionService;
3855 int32_t ret = audioInterruptService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
3856 EXPECT_EQ(SUCCESS, ret);
3857
3858 AudioSessionStrategy audioSessionStrategy;
3859 audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
3860 ret = audioInterruptService->ActivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID, audioSessionStrategy);
3861 EXPECT_EQ(SUCCESS, ret);
3862
3863 bool result = audioInterruptService->IsAudioSessionActivated(CALLER_PID);
3864 EXPECT_TRUE(result);
3865
3866 ret = sessionService->DeactivateAudioSession(CALLER_PID);
3867 EXPECT_EQ(SUCCESS, ret);
3868
3869 audioInterruptService->HandleSessionTimeOutEvent(CALLER_PID);
3870 result = audioInterruptService->IsAudioSessionActivated(CALLER_PID);
3871 EXPECT_FALSE(result);
3872 }
3873
3874 /**
3875 * @tc.name : Test AudioSessionFocusMode
3876 * @tc.number: AudioSessionFocusMode_006
3877 * @tc.desc : Test AudioSessionCallbackEvent
3878 */
3879 HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_006, TestSize.Level1)
3880 {
3881 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
3882 AudioInterrupt movieInterrupt;
3883 movieInterrupt.pid = CALLER_PID;
3884 movieInterrupt.streamId = SESSION_ID_TEST;
3885 movieInterrupt.audioFocusType.streamType = STREAM_MUSIC;
3886 movieInterrupt.audioFocusType.isPlay = true;
3887 movieInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
3888
3889 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3890 ASSERT_NE(audioInterruptService, nullptr);
3891
3892 InterruptEventInternal duckInterruptEvent {INTERRUPT_TYPE_BEGIN, INTERRUPT_FORCE, INTERRUPT_HINT_DUCK, 1.0f};
3893 InterruptEventInternal stopInterruptEvent {INTERRUPT_TYPE_BEGIN, INTERRUPT_FORCE, INTERRUPT_HINT_STOP, 1.0f};
3894 audioInterruptService->SendAudioSessionInterruptEventCallback(duckInterruptEvent, movieInterrupt);
3895 audioInterruptService->SendAudioSessionInterruptEventCallback(stopInterruptEvent, movieInterrupt);
3896
3897 audioInterruptService->Init(GetPolicyServerTest());
3898
3899 audioInterruptService->TryHandleStreamCallbackInSession(DEFAULT_ZONE_ID, movieInterrupt);
3900 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
3901 audioInterruptService->TryHandleStreamCallbackInSession(DEFAULT_ZONE_ID, movieInterrupt);
3902 audioInterruptService->SendAudioSessionInterruptEventCallback(duckInterruptEvent, movieInterrupt);
3903 audioInterruptService->SendAudioSessionInterruptEventCallback(stopInterruptEvent, movieInterrupt);
3904
3905 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
3906 ASSERT_NE(nullptr, sessionService);
3907 audioInterruptService->sessionService_ = sessionService;
3908 int32_t ret = audioInterruptService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
3909 EXPECT_EQ(SUCCESS, ret);
3910
3911 movieInterrupt.isAudioSessionInterrupt = true;
3912 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
3913 audioInterruptZone->audioFocusInfoList.emplace_back(movieInterrupt, AudioFocuState{PAUSE});
3914 audioInterruptService->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
3915 audioInterruptService->TryHandleStreamCallbackInSession(DEFAULT_ZONE_ID, movieInterrupt);
3916 audioInterruptService->SendAudioSessionInterruptEventCallback(duckInterruptEvent, movieInterrupt);
3917 audioInterruptService->SendAudioSessionInterruptEventCallback(stopInterruptEvent, movieInterrupt);
3918
3919 audioInterruptZone = std::make_shared<AudioInterruptZone>();
3920 audioInterruptZone->audioFocusInfoList.emplace_back(movieInterrupt, AudioFocuState{PAUSE});
3921 audioInterruptService->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
3922 audioInterruptService->TryHandleStreamCallbackInSession(DEFAULT_ZONE_ID, movieInterrupt);
3923
3924 AudioSessionStrategy audioSessionStrategy;
3925 audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
3926 ret = sessionService->ActivateAudioSession(CALLER_PID, audioSessionStrategy);
3927 EXPECT_EQ(SUCCESS, ret);
3928 ret = sessionService->DeactivateAudioSession(CALLER_PID);
3929 EXPECT_EQ(SUCCESS, ret);
3930 }
3931
3932 /**
3933 * @tc.name : Test AudioSessionFocusMode
3934 * @tc.number: AudioSessionFocusMode_007
3935 * @tc.desc : Test ProcessFocusEntryForAudioSession
3936 */
3937 HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_007, TestSize.Level1)
3938 {
3939 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
3940 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3941 ASSERT_NE(audioInterruptService, nullptr);
3942 audioInterruptService->Init(GetPolicyServerTest());
3943
3944 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
3945 ASSERT_NE(nullptr, sessionService);
3946 audioInterruptService->sessionService_ = sessionService;
3947 int32_t ret = audioInterruptService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
3948 EXPECT_EQ(SUCCESS, ret);
3949 bool updateScene = false;
3950 ret = audioInterruptService->ProcessFocusEntryForAudioSession(DEFAULT_ZONE_ID, CALLER_PID, updateScene);
3951 EXPECT_EQ(SUCCESS, ret);
3952
3953 AudioInterrupt movieInterrupt;
3954 movieInterrupt.pid = CALLER_PID;
3955 movieInterrupt.streamId = SESSION_ID_TEST;
3956 movieInterrupt.audioFocusType.streamType = STREAM_MUSIC;
3957 movieInterrupt.audioFocusType.isPlay = true;
3958 movieInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
3959 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
3960 audioInterruptZone->audioFocusInfoList.emplace_back(movieInterrupt, AudioFocuState{ACTIVE});
3961 audioInterruptService->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
3962
3963 ret = audioInterruptService->ProcessFocusEntryForAudioSession(DEFAULT_ZONE_ID, CALLER_PID, updateScene);
3964 EXPECT_EQ(SUCCESS, ret);
3965
3966 audioInterruptService->isPreemptMode_ = true;
3967 ret = audioInterruptService->ProcessFocusEntryForAudioSession(DEFAULT_ZONE_ID, CALLER_PID, updateScene);
3968 EXPECT_EQ(ERR_FOCUS_DENIED, ret);
3969 }
3970
3971 /**
3972 * @tc.name : Test AudioSessionFocusMode
3973 * @tc.number: AudioSessionFocusMode_008
3974 * @tc.desc : Test GetHighestPriorityAudioScene
3975 */
3976 HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_008, TestSize.Level1)
3977 {
3978 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
3979 auto audioInterruptService = std::make_shared<AudioInterruptService>();
3980 ASSERT_NE(audioInterruptService, nullptr);
3981
3982 AudioInterrupt fakeAudioInterrupt;
3983 fakeAudioInterrupt.pid = CALLER_PID;
3984 fakeAudioInterrupt.streamId = SESSION_ID_TEST;
3985 fakeAudioInterrupt.audioFocusType.streamType = STREAM_VOICE_COMMUNICATION;
3986 fakeAudioInterrupt.audioFocusType.isPlay = true;
3987 fakeAudioInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
3988 fakeAudioInterrupt.isAudioSessionInterrupt = true;
3989 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
3990 audioInterruptZone->audioFocusInfoList.emplace_back(fakeAudioInterrupt, AudioFocuState{ACTIVE});
3991 audioInterruptService->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
3992
3993 AudioScene audioScene = audioInterruptService->GetHighestPriorityAudioScene(DEFAULT_ZONE_ID);
3994 EXPECT_EQ(AUDIO_SCENE_DEFAULT, audioScene);
3995
3996 audioScene = audioInterruptService->RefreshAudioSceneFromAudioInterrupt(fakeAudioInterrupt, audioScene);
3997 EXPECT_EQ(AUDIO_SCENE_DEFAULT, audioScene);
3998
3999 audioScene = audioInterruptService->GetHighestPriorityAudioSceneFromAudioSession(fakeAudioInterrupt, audioScene);
4000 EXPECT_EQ(AUDIO_SCENE_DEFAULT, audioScene);
4001
4002 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
4003 ASSERT_NE(nullptr, sessionService);
4004 audioInterruptService->sessionService_ = sessionService;
4005 AudioSessionStrategy audioSessionStrategy;
4006 audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
4007 int32_t ret = sessionService->ActivateAudioSession(CALLER_PID, audioSessionStrategy);
4008 EXPECT_EQ(SUCCESS, ret);
4009 ASSERT_NE(nullptr, sessionService->sessionMap_[CALLER_PID]);
4010 AudioInterrupt audioInterrupt = {};
4011 audioInterrupt.pid = CALLER_PID;
4012 audioInterrupt.streamId = SESSION_ID_TEST + 1;
4013 audioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
4014 audioInterrupt.audioFocusType.isPlay = true;
4015 audioInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
4016 sessionService->sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
4017
4018 audioScene = audioInterruptService->GetHighestPriorityAudioSceneFromAudioSession(fakeAudioInterrupt, audioScene);
4019 EXPECT_EQ(AUDIO_SCENE_PHONE_CHAT, audioScene);
4020
4021 audioInterrupt.streamId++;
4022 audioInterrupt.audioFocusType.streamType = STREAM_RING;
4023 sessionService->sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
4024 audioScene = AUDIO_SCENE_DEFAULT;
4025 audioScene = audioInterruptService->GetHighestPriorityAudioSceneFromAudioSession(fakeAudioInterrupt, audioScene);
4026 EXPECT_EQ(AUDIO_SCENE_RINGING, audioScene);
4027
4028 ret = sessionService->DeactivateAudioSession(CALLER_PID);
4029 EXPECT_EQ(SUCCESS, ret);
4030 }
4031
4032 /**
4033 * @tc.name : Test AudioSessionFocusMode
4034 * @tc.number: AudioSessionFocusMode_009
4035 * @tc.desc : Test DeactivatAudioSession v2
4036 */
4037 HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_009, TestSize.Level2)
4038 {
4039 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
4040 auto audioInterruptService = std::make_shared<AudioInterruptService>();
4041 ASSERT_NE(audioInterruptService, nullptr);
4042 audioInterruptService->Init(GetPolicyServerTest());
4043 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
4044
4045 AudioInterrupt fakeAudioInterrupt;
4046 fakeAudioInterrupt.pid = CALLER_PID + 1;
4047 fakeAudioInterrupt.streamId = SESSION_ID_TEST;
4048 fakeAudioInterrupt.audioFocusType.streamType = STREAM_VOICE_COMMUNICATION;
4049 fakeAudioInterrupt.audioFocusType.isPlay = true;
4050 fakeAudioInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
4051 fakeAudioInterrupt.isAudioSessionInterrupt = true;
4052 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
4053 audioInterruptZone->audioFocusInfoList.emplace_back(fakeAudioInterrupt, AudioFocuState{ACTIVE});
4054 audioInterruptService->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
4055
4056 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
4057 ASSERT_NE(nullptr, sessionService);
4058 audioInterruptService->sessionService_ = sessionService;
4059 int32_t ret = sessionService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
4060 EXPECT_EQ(SUCCESS, ret);
4061 AudioSessionStrategy audioSessionStrategy;
4062 audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
4063 ret = audioInterruptService->ActivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID, audioSessionStrategy);
4064 EXPECT_EQ(SUCCESS, ret);
4065
4066 ret = audioInterruptService->DeactivateAudioInterrupt(DEFAULT_ZONE_ID, fakeAudioInterrupt);
4067 EXPECT_EQ(SUCCESS, ret);
4068
4069 auto &newAudioInterruptZone = audioInterruptService->zonesMap_[DEFAULT_ZONE_ID];
4070 EXPECT_EQ(1, newAudioInterruptZone->audioFocusInfoList.size());
4071
4072 audioInterruptService->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
4073
4074 ret = audioInterruptService->DeactivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID);
4075 EXPECT_EQ(SUCCESS, ret);
4076
4077 ret = sessionService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
4078 EXPECT_EQ(SUCCESS, ret);
4079 ret = audioInterruptService->ActivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID, audioSessionStrategy);
4080 EXPECT_EQ(SUCCESS, ret);
4081
4082 ASSERT_NE(nullptr, sessionService->sessionMap_[CALLER_PID]);
4083 AudioInterrupt audioInterrupt = {};
4084 audioInterrupt.pid = CALLER_PID;
4085 audioInterrupt.streamId = SESSION_ID_TEST + 1;
4086 audioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
4087 audioInterrupt.audioFocusType.isPlay = true;
4088 audioInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
4089 sessionService->sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
4090 audioInterruptService->sessionService_ = sessionService;
4091
4092 ret = audioInterruptService->DeactivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID);
4093 EXPECT_EQ(SUCCESS, ret);
4094 std::this_thread::sleep_for(std::chrono::seconds(2));
4095 }
4096
4097 /**
4098 * @tc.name : Test AudioSessionFocusMode
4099 * @tc.number: AudioSessionFocusMode_010
4100 * @tc.desc : Test DelayToDeactivateStreamsInAudioSession
4101 */
4102 HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_010, TestSize.Level2)
4103 {
4104 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
4105 auto audioInterruptService = std::make_shared<AudioInterruptService>();
4106 ASSERT_NE(audioInterruptService, nullptr);
4107 audioInterruptService->Init(GetPolicyServerTest());
4108 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
4109
4110 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
4111 ASSERT_NE(nullptr, sessionService);
4112 audioInterruptService->sessionService_ = sessionService;
4113 int32_t ret = sessionService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
4114 EXPECT_EQ(SUCCESS, ret);
4115 AudioSessionStrategy audioSessionStrategy;
4116 audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
4117 ret = audioInterruptService->ActivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID, audioSessionStrategy);
4118 EXPECT_EQ(SUCCESS, ret);
4119
4120 ASSERT_NE(nullptr, sessionService->sessionMap_[CALLER_PID]);
4121 AudioInterrupt audioInterrupt = {};
4122 audioInterrupt.pid = CALLER_PID;
4123 audioInterrupt.streamId = SESSION_ID_TEST + 1;
4124 audioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
4125 audioInterrupt.audioFocusType.isPlay = true;
4126 audioInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
4127 sessionService->sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
4128
4129 audioInterruptService->sessionService_ = nullptr;
4130 audioInterruptService->DelayToDeactivateStreamsInAudioSession(
4131 DEFAULT_ZONE_ID, CALLER_PID, sessionService->GetStreams(CALLER_PID));
4132 std::this_thread::sleep_for(std::chrono::seconds(2));
4133 audioInterruptService->sessionService_ = sessionService;
4134 sessionService->sessionMap_[CALLER_PID]->state_ = AudioSessionState::SESSION_ACTIVE;
4135 audioInterruptService->DelayToDeactivateStreamsInAudioSession(
4136 DEFAULT_ZONE_ID, CALLER_PID, sessionService->GetStreams(CALLER_PID));
4137 std::this_thread::sleep_for(std::chrono::seconds(2));
4138
4139 ret = sessionService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
4140 EXPECT_EQ(SUCCESS, ret);
4141 ret = audioInterruptService->ActivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID, audioSessionStrategy);
4142 EXPECT_EQ(SUCCESS, ret);
4143
4144 audioInterruptService->SetCallbackHandler(nullptr);
4145 ret = audioInterruptService->DeactivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID);
4146 EXPECT_EQ(SUCCESS, ret);
4147 std::this_thread::sleep_for(std::chrono::seconds(2));
4148 }
4149
4150 /**
4151 * @tc.name : Test AudioSessionFocusMode
4152 * @tc.number: AudioSessionFocusMode_011
4153 * @tc.desc : Test HasStreamForDeviceType
4154 */
4155 HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_011, TestSize.Level1)
4156 {
4157 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
4158
4159 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
4160 ASSERT_NE(nullptr, sessionService);
4161 EXPECT_FALSE(sessionService->HasStreamForDeviceType(CALLER_PID, DEVICE_TYPE_REMOTE_CAST));
4162
4163 AudioSessionStrategy audioSessionStrategy;
4164 audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
4165 int32_t ret = sessionService->ActivateAudioSession(CALLER_PID, audioSessionStrategy);
4166 EXPECT_EQ(SUCCESS, ret);
4167 ASSERT_NE(nullptr, sessionService->sessionMap_[CALLER_PID]);
4168 EXPECT_FALSE(sessionService->HasStreamForDeviceType(CALLER_PID, DEVICE_TYPE_REMOTE_CAST));
4169 AudioInterrupt audioInterrupt = {};
4170 audioInterrupt.pid = CALLER_PID;
4171 audioInterrupt.streamId = SESSION_ID_TEST + 1;
4172 audioInterrupt.streamUsage = STREAM_USAGE_MUSIC;
4173 audioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
4174 audioInterrupt.audioFocusType.isPlay = true;
4175 audioInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
4176 sessionService->sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
4177
4178 AudioStreamCollector &audioStreamCollector = AudioStreamCollector::GetAudioStreamCollector();
4179 AudioDeviceDescriptor outputDeviceInfo(DEVICE_TYPE_REMOTE_CAST, OUTPUT_DEVICE, 0, 0, "RemoteDevice");
4180 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
4181 rendererChangeInfo->clientUID = CALLER_UID;
4182 rendererChangeInfo->createrUID = CALLER_UID + 1;
4183 rendererChangeInfo->sessionId = audioInterrupt.streamId;
4184 rendererChangeInfo->outputDeviceInfo = outputDeviceInfo;
4185 rendererChangeInfo->rendererInfo.streamUsage = STREAM_USAGE_MUSIC;
4186 audioStreamCollector.audioRendererChangeInfos_.push_back(rendererChangeInfo);
4187 EXPECT_TRUE(sessionService->HasStreamForDeviceType(CALLER_PID, DEVICE_TYPE_REMOTE_CAST));
4188
4189 ret = sessionService->DeactivateAudioSession(CALLER_PID);
4190 EXPECT_EQ(SUCCESS, ret);
4191 }
4192
4193 /**
4194 * @tc.name : Test AudioSessionFocusMode
4195 * @tc.number: AudioSessionFocusMode_012
4196 * @tc.desc : Test GetStreamIdsForAudioSessionByStreamUsage
4197 */
4198 HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_012, TestSize.Level1)
4199 {
4200 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
4201 auto audioInterruptService = std::make_shared<AudioInterruptService>();
4202 ASSERT_NE(audioInterruptService, nullptr);
4203 AudioInterrupt fakeAudioInterrupt;
4204 fakeAudioInterrupt.pid = CALLER_PID;
4205 fakeAudioInterrupt.streamUsage = STREAM_USAGE_MUSIC;
4206 fakeAudioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
4207 fakeAudioInterrupt.streamId = SESSION_ID_TEST + 1;
4208 fakeAudioInterrupt.audioFocusType.isPlay = true;
4209 fakeAudioInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
4210 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
4211 audioInterruptZone->audioFocusInfoList.emplace_back(fakeAudioInterrupt, AudioFocuState{ACTIVE});
4212 audioInterruptService->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
4213
4214 std::set<StreamUsage> streamUsageSet;
4215 auto streamIds = audioInterruptService->GetStreamIdsForAudioSessionByStreamUsage(DEFAULT_ZONE_ID, streamUsageSet);
4216 EXPECT_TRUE(streamIds.empty());
4217
4218 fakeAudioInterrupt.isAudioSessionInterrupt = true;
4219 audioInterruptZone = std::make_shared<AudioInterruptZone>();
4220 audioInterruptZone->audioFocusInfoList.emplace_back(fakeAudioInterrupt, AudioFocuState{ACTIVE});
4221 audioInterruptService->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
4222
4223 streamUsageSet.insert(STREAM_USAGE_ALARM);
4224 streamIds = audioInterruptService->GetStreamIdsForAudioSessionByStreamUsage(DEFAULT_ZONE_ID, streamUsageSet);
4225 EXPECT_TRUE(streamIds.empty());
4226
4227 streamUsageSet.insert(STREAM_USAGE_MUSIC);
4228 streamIds = audioInterruptService->GetStreamIdsForAudioSessionByStreamUsage(DEFAULT_ZONE_ID, streamUsageSet);
4229 EXPECT_EQ(1, streamIds.size());
4230 EXPECT_EQ(fakeAudioInterrupt.streamId, *streamIds.begin());
4231
4232 int32_t systemAbilityId = 3009;
4233 bool runOnCreate = false;
4234 sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
4235 ASSERT_NE(nullptr, server);
4236 streamIds = server->GetStreamIdsForAudioSessionByStreamUsage(DEFAULT_ZONE_ID, streamUsageSet);
4237 EXPECT_TRUE(streamIds.empty());
4238
4239 const sptr<AudioPolicyServer> &policyServer = GetPolicyServerTest();
4240 ASSERT_NE(nullptr, policyServer);
4241 ASSERT_NE(nullptr, policyServer->interruptService_);
4242 policyServer->interruptService_->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
4243 streamIds = policyServer->GetStreamIdsForAudioSessionByStreamUsage(DEFAULT_ZONE_ID, streamUsageSet);
4244 EXPECT_EQ(1, streamIds.size());
4245 EXPECT_EQ(fakeAudioInterrupt.streamId, *streamIds.begin());
4246 }
4247
4248 /**
4249 * @tc.name : Test AudioSessionFocusMode
4250 * @tc.number: AudioSessionFocusMode_013
4251 * @tc.desc : Test GetStreamIdsForAudioSessionByDeviceType
4252 */
4253 HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_013, TestSize.Level1)
4254 {
4255 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
4256 auto interruptService = std::make_shared<AudioInterruptService>();
4257 ASSERT_NE(nullptr, interruptService);
4258
4259 AudioInterrupt fakeAudioInterrupt;
4260 fakeAudioInterrupt.pid = CALLER_PID;
4261 fakeAudioInterrupt.streamUsage = STREAM_USAGE_MUSIC;
4262 fakeAudioInterrupt.streamId = SESSION_ID_TEST + 1;
4263 fakeAudioInterrupt.audioFocusType.isPlay = true;
4264 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
4265 audioInterruptZone->audioFocusInfoList.emplace_back(fakeAudioInterrupt, AudioFocuState{ACTIVE});
4266 interruptService->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
4267
4268 auto streamIds =
4269 interruptService->GetStreamIdsForAudioSessionByDeviceType(DEFAULT_ZONE_ID, DEVICE_TYPE_REMOTE_CAST);
4270 EXPECT_TRUE(streamIds.empty());
4271
4272 fakeAudioInterrupt.isAudioSessionInterrupt = true;
4273 audioInterruptZone->audioFocusInfoList.clear();
4274 audioInterruptZone->audioFocusInfoList.emplace_back(fakeAudioInterrupt, AudioFocuState{ACTIVE});
4275 interruptService->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
4276
4277 streamIds = interruptService->GetStreamIdsForAudioSessionByDeviceType(DEFAULT_ZONE_ID, DEVICE_TYPE_REMOTE_CAST);
4278 EXPECT_TRUE(streamIds.empty());
4279
4280 std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
4281 ASSERT_NE(nullptr, sessionService);
4282 AudioSessionStrategy audioSessionStrategy;
4283 audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
4284 sessionService->ActivateAudioSession(CALLER_PID, audioSessionStrategy);
4285 ASSERT_NE(nullptr, sessionService->sessionMap_[CALLER_PID]);
4286 AudioInterrupt audioInterrupt = {};
4287 audioInterrupt.pid = CALLER_PID;
4288 audioInterrupt.streamId = SESSION_ID_TEST + 1;
4289 audioInterrupt.streamUsage = STREAM_USAGE_MUSIC;
4290 audioInterrupt.audioFocusType.isPlay = true;
4291 sessionService->sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
4292
4293 streamIds = interruptService->GetStreamIdsForAudioSessionByDeviceType(DEFAULT_ZONE_ID, DEVICE_TYPE_REMOTE_CAST);
4294 EXPECT_TRUE(streamIds.empty());
4295
4296 AudioDeviceDescriptor outputDeviceInfo(DEVICE_TYPE_REMOTE_CAST, OUTPUT_DEVICE, 0, 0, "RemoteDevice");
4297 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
4298 rendererChangeInfo->clientUID = CALLER_UID;
4299 rendererChangeInfo->createrUID = CALLER_UID + 1;
4300 rendererChangeInfo->sessionId = SESSION_ID_TEST + 1;
4301 rendererChangeInfo->outputDeviceInfo = outputDeviceInfo;
4302 rendererChangeInfo->rendererInfo.streamUsage = STREAM_USAGE_MUSIC;
4303 AudioStreamCollector::GetAudioStreamCollector().audioRendererChangeInfos_.push_back(rendererChangeInfo);
4304
4305 interruptService->sessionService_ = sessionService;
4306 streamIds = interruptService->GetStreamIdsForAudioSessionByDeviceType(DEFAULT_ZONE_ID, DEVICE_TYPE_REMOTE_CAST);
4307 EXPECT_EQ(1, streamIds.size());
4308 EXPECT_EQ(fakeAudioInterrupt.streamId, *streamIds.begin());
4309
4310 sessionService->DeactivateAudioSession(CALLER_PID);
4311 AudioStreamCollector::GetAudioStreamCollector().audioRendererChangeInfos_.clear();
4312 }
4313
4314 /**
4315 * @tc.name : Test InterruptStrategy Mute
4316 * @tc.number: AudioInterruptStrategy_001
4317 * @tc.desc : Test InterruptStrategy Mute
4318 */
4319 HWTEST(AudioInterruptServiceUnitTest, AudioInterruptStrategy_001, TestSize.Level1)
4320 {
4321 auto audioInterruptService = std::make_shared<AudioInterruptService>();
4322 EXPECT_NE(audioInterruptService, nullptr);
4323
4324 int32_t fakePid = 123;
4325 AudioInterrupt incomingInterrupt1;
4326 incomingInterrupt1.pid = fakePid;
4327 incomingInterrupt1.audioFocusType.sourceType = SOURCE_TYPE_MIC;
4328 incomingInterrupt1.streamId = 888; // 888 is a fake stream id.
4329
4330 int32_t fakePid2 = 124;
4331 AudioInterrupt incomingInterrupt2;
4332 incomingInterrupt2.pid = fakePid2;
4333 incomingInterrupt2.audioFocusType.sourceType = SOURCE_TYPE_UNPROCESSED;
4334 incomingInterrupt2.streamId = 889; // 889 is a fake stream id.
4335 incomingInterrupt1.strategy = InterruptStrategy::MUTE;
4336
4337 AudioFocusEntry focusEntry;
4338 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
4339 audioInterruptService->UpdateMuteAudioFocusStrategy(incomingInterrupt1, incomingInterrupt2, focusEntry);
4340 EXPECT_EQ(focusEntry.hintType, INTERRUPT_HINT_MUTE);
4341
4342 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
4343 audioInterruptService->UpdateMuteAudioFocusStrategy(incomingInterrupt2, incomingInterrupt1, focusEntry);
4344 EXPECT_EQ(focusEntry.hintType, INTERRUPT_HINT_MUTE);
4345 }
4346
4347 } // namespace AudioStandard
4348 } // namespace OHOS
4349