1 /*
2 * Copyright (C) 2023 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 #define private public
16 #define protected public
17 #include "audio_control_manager.h"
18 #include "bluetooth_call.h"
19 #include "call_state_processor.h"
20 #include "call_control_manager.h"
21 #include "common_event_manager.h"
22 #include "gtest/gtest.h"
23 #include "ims_call.h"
24 #include "voip_call.h"
25 #include "int_wrapper.h"
26 #include "call_manager_connect.h"
27
28 namespace OHOS::Telephony {
29 using namespace testing::ext;
30 constexpr int WAIT_TIME = 5;
31 constexpr int VALID_CALL_ID = 1;
32 constexpr int32_t CRS_TYPE = 2;
33 constexpr const char* NUMBER = "10086";
34 static constexpr const char *SYSTEM_VIDEO_RING = "system_video_ring";
35 static constexpr const char *STR_MP4 = "123.mp4";
36 static constexpr const char *STR_NOT_MP4 = "1234567";
37 class ZeroBranch9Test : public testing::Test {
38 public:
39 void SetUp();
40 void TearDown();
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 };
SetUp()44 void ZeroBranch9Test::SetUp()
45 {
46 DelayedSingleton<AudioProxy>::GetInstance()->SetAudioMicStateChangeCallback();
47 DelayedSingleton<AudioProxy>::GetInstance()->SetAudioDeviceChangeCallback();
48 DelayedSingleton<AudioProxy>::GetInstance()->SetAudioPreferDeviceChangeCallback();
49 }
50
TearDown()51 void ZeroBranch9Test::TearDown()
52 {
53 DelayedSingleton<AudioProxy>::GetInstance()->UnsetAudioMicStateChangeCallback();
54 DelayedSingleton<AudioProxy>::GetInstance()->UnsetDeviceChangeCallback();
55 DelayedSingleton<AudioProxy>::GetInstance()->UnsetAudioPreferDeviceChangeCallback();
56 }
57
SetUpTestCase()58 void ZeroBranch9Test::SetUpTestCase() {}
59
TearDownTestCase()60 void ZeroBranch9Test::TearDownTestCase()
61 {
62 sleep(WAIT_TIME);
63 }
64
65 /**
66 * @tc.number Telephony_AudioControlManager_001
67 * @tc.name test error branch
68 * @tc.desc Function test
69 */
70 HWTEST_F(ZeroBranch9Test, Telephony_AudioControlManager_001, TestSize.Level0)
71 {
72 DialParaInfo mDialParaInfo;
73 mDialParaInfo.accountId = 0;
74 sptr<OHOS::Telephony::CallBase> callObjectPtr = nullptr;
75 DelayedSingleton<CallStateProcessor>::GetInstance()->holdingCalls_.insert(1);
76 auto audioControl = DelayedSingleton<AudioControlManager>::GetInstance();
77 audioControl->VideoStateUpdated(callObjectPtr, VideoStateType::TYPE_VOICE, VideoStateType::TYPE_VIDEO);
78 callObjectPtr = new IMSCall(mDialParaInfo);
79 callObjectPtr->SetCallType(CallType::TYPE_IMS);
80 audioControl->VideoStateUpdated(callObjectPtr, VideoStateType::TYPE_VOICE, VideoStateType::TYPE_VIDEO);
81 callObjectPtr->SetCrsType(2);
82 audioControl->VideoStateUpdated(callObjectPtr, VideoStateType::TYPE_VOICE, VideoStateType::TYPE_VIDEO);
83 audioControl->UpdateDeviceTypeForVideoOrSatelliteCall();
84 audioControl->MuteNetWorkRingTone(true);
85 audioControl->IsBtOrWireHeadPlugin();
86 ASSERT_FALSE(audioControl->IsVideoCall(VideoStateType::TYPE_RECEIVE_ONLY));
87 sptr<CallBase> call = nullptr;
88 audioControl->IncomingCallHungUp(call, false, "");
89 audioControl->CallStateUpdated(call, TelCallState::CALL_STATUS_DIALING, TelCallState::CALL_STATUS_ALERTING);
90 call = new VoIPCall(mDialParaInfo);
91 call->SetCallType(CallType::TYPE_VOIP);
92 audioControl->CallStateUpdated(call, TelCallState::CALL_STATUS_DIALING, TelCallState::CALL_STATUS_ALERTING);
93 audioControl->HandleCallStateUpdated(call, TelCallState::CALL_STATUS_DIALING, TelCallState::CALL_STATUS_ANSWERED);
94 audioControl->HandleNextState(call, TelCallState::CALL_STATUS_ALERTING);
95 audioControl->HandleNextState(call, TelCallState::CALL_STATUS_INCOMING);
96 audioControl->HandleNextState(call, TelCallState::CALL_STATUS_WAITING);
97 audioControl->HandlePriorState(call, TelCallState::CALL_STATUS_ALERTING);
98 audioControl->HandlePriorState(call, TelCallState::CALL_STATUS_INCOMING);
99 audioControl->HandlePriorState(call, TelCallState::CALL_STATUS_WAITING);
100 audioControl->HandlePriorState(call, TelCallState::CALL_STATUS_HOLDING);
101 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
102 audioControl->HandlePriorState(call, TelCallState::CALL_STATUS_INCOMING);
103 audioControl->HandlePriorState(call, TelCallState::CALL_STATUS_WAITING);
104 audioControl->UpdateForegroundLiveCall();
105 audioControl->ProcessAudioWhenCallActive(call);
106 std::string emptyNumber = "";
107 call->SetAccountNumber(emptyNumber);
108 audioControl->HandleNewActiveCall(call);
109 call->SetAccountNumber(NUMBER);
110 call->SetCallType(CallType::TYPE_CS);
111 audioControl->HandleNewActiveCall(call);
112 call->SetCallType(CallType::TYPE_SATELLITE);
113 audioControl->HandleNewActiveCall(call);
114 call->SetCallType(CallType::TYPE_ERR_CALL);
115 audioControl->HandleNewActiveCall(call);
116 audioControl->GetCallList().empty();
117 ASSERT_TRUE(audioControl->GetCurrentActiveCall() == nullptr);
118 DelayedSingleton<AudioControlManager>::GetInstance()->UnInit();
119 }
120
121 /**
122 * @tc.number Telephony_AudioControlManager_002
123 * @tc.name test error branch
124 * @tc.desc Function test
125 */
126 HWTEST_F(ZeroBranch9Test, Telephony_AudioControlManager_002, TestSize.Level1)
127 {
128 auto audioControl = DelayedSingleton<AudioControlManager>::GetInstance();
129 AudioDevice device;
130 device.deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_PAD;
131 if (memset_s(device.address, kMaxAddressLen + 1, 0, kMaxAddressLen + 1) != EOK) {
132 return;
133 }
134 audioControl->SetAudioDevice(device);
135 device.deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_PHONE;
136 audioControl->SetAudioDevice(device);
137 device.deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_AUTOMOTIVE;
138 audioControl->SetAudioDevice(device);
139 device.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO;
140 audioControl->SetAudioDevice(device);
141 audioControl->PlaySoundtone();
142 audioControl->GetInitAudioDeviceType();
143 audioControl->SetMute(false);
144 audioControl->MuteRinger();
145 audioControl->PlayCallEndedTone(CallEndedType::PHONE_IS_BUSY);
146 audioControl->PlayCallEndedTone(CallEndedType::CALL_ENDED_NORMALLY);
147 audioControl->PlayCallEndedTone(CallEndedType::UNKNOWN);
148 audioControl->PlayCallEndedTone(CallEndedType::INVALID_NUMBER);
149 audioControl->PlayCallEndedTone(static_cast<CallEndedType>(5));
150 audioControl->GetCallBase(VALID_CALL_ID);
151 audioControl->IsEmergencyCallExists();
152 audioControl->SetToneState(ToneState::TONEING);
153 audioControl->IsNumberAllowed(NUMBER);
154 audioControl->audioInterruptState_ = AudioInterruptState::INTERRUPT_STATE_ACTIVATED;
155 ASSERT_TRUE(audioControl->IsAudioActivated());
156 DelayedSingleton<AudioControlManager>::GetInstance()->UnInit();
157 }
158
159 /**
160 * @tc.number Telephony_AudioControlManager_003
161 * @tc.name test error branch
162 * @tc.desc Function test
163 */
164 HWTEST_F(ZeroBranch9Test, Telephony_AudioControlManager_003, TestSize.Level0)
165 {
166 auto audioControl = DelayedSingleton<AudioControlManager>::GetInstance();
167 audioControl->IsTonePlaying();
168 audioControl->IsCurrentRinging();
169 audioControl->PlayRingback();
170 audioControl->StopWaitingTone();
171 audioControl->PlayDtmfTone('a');
172 audioControl->StopDtmfTone();
173 audioControl->OnPostDialNextChar('a');
174 audioControl->IsSoundPlaying();
175 ASSERT_TRUE(audioControl->IsVideoCall(VideoStateType::TYPE_VIDEO));
176 DelayedSingleton<AudioControlManager>::GetInstance()->UnInit();
177 }
178
179 /**
180 * @tc.number Telephony_AudioControlManager_004
181 * @tc.name test error branch
182 * @tc.desc Function test
183 */
184 HWTEST_F(ZeroBranch9Test, Telephony_AudioControlManager_004, TestSize.Level0)
185 {
186 auto audioControl = DelayedSingleton<AudioControlManager>::GetInstance();
187 audioControl->isCrsVibrating_ = true;
188 audioControl->MuteNetWorkRingTone(true);
189 DisconnectedDetails details;
190 audioControl->CallDestroyed(details);
191 audioControl->toneState_ = ToneState::CALLENDED;
192 audioControl->StopCallTone();
193 audioControl->tone_ = nullptr;
194 audioControl->StopCallTone();
195 audioControl->GetAudioInterruptState();
196 audioControl->SetVolumeAudible();
197 audioControl->ringState_ = RingState::RINGING;
198 audioControl->MuteRinger();
199 ASSERT_TRUE(audioControl->GetCurrentActiveCall() == nullptr);
200 DelayedSingleton<AudioControlManager>::GetInstance()->UnInit();
201 }
202
203 /**
204 * @tc.number Telephony_AudioControlManager_005
205 * @tc.name test error branch
206 * @tc.desc Function test
207 */
208 HWTEST_F(ZeroBranch9Test, Telephony_AudioControlManager_005, TestSize.Level0)
209 {
210 auto audioControl = DelayedSingleton<AudioControlManager>::GetInstance();
211 audioControl->ExcludeBluetoothSco();
212 audioControl->UnexcludeBluetoothSco();
213 AudioDeviceType deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO;
214 audioControl->UpdateDeviceTypeForCrs(deviceType);
215 EXPECT_TRUE(audioControl->IsRingingVibrateModeOn());
216 auto callControl = DelayedSingleton<CallControlManager>::GetInstance();
217 callControl->SetVoIPCallState(1);
218 EXPECT_TRUE(audioControl->IsVoIPCallActived());
219 callControl->SetVoIPCallState(0);
220 EXPECT_FALSE(audioControl->IsVoIPCallActived());
221 callControl->SetVoIPCallState(-1);
222 EXPECT_FALSE(audioControl->IsVoIPCallActived());
223 CallObjectManager::callObjectPtrList_.clear();
224 EXPECT_FALSE(audioControl->IsBtCallDisconnected());
225 DialParaInfo info;
226 sptr<CallBase> call = new BluetoothCall(info, "");
227 CallObjectManager::AddOneCallObject(call);
228 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
229 EXPECT_FALSE(audioControl->IsBtCallDisconnected());
230 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_ENDED);
231 EXPECT_FALSE(audioControl->IsBtCallDisconnected());
232 call->SetCallType(CallType::TYPE_BLUETOOTH);
233 EXPECT_TRUE(audioControl->IsBtCallDisconnected());
234 audioControl->SetRingToneVolume(0.0f);
235 audioControl->PlaySoundtone();
236 audioControl->SetRingToneVolume(0.0f);
237 audioControl->SetRingToneVolume(0.5f);
238 audioControl->SetRingToneVolume(1.5f);
239 audioControl->StopSoundtone();
240 audioControl->ringState_ = RingState::RINGING;
241 audioControl->StopRingtone();
242 audioControl->ring_ = nullptr;
243 audioControl->StopRingtone();
244 audioControl->PlayCallTone(ToneDescriptor::TONE_ENGAGED);
245 EXPECT_EQ(audioControl->StopRingback(), 0);
246 DelayedSingleton<AudioControlManager>::GetInstance()->UnInit();
247 }
248
249 /**
250 * @tc.number Telephony_AudioControlManager_006
251 * @tc.name test error branch
252 * @tc.desc Function test
253 */
254 HWTEST_F(ZeroBranch9Test, Telephony_AudioControlManager_006, TestSize.Level0)
255 {
256 auto audioControl = DelayedSingleton<AudioControlManager>::GetInstance();
257 DialParaInfo info;
258 sptr<CallBase> ringingCall = new IMSCall(info);
259 ringingCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
260 audioControl->SaveVoiceVolume(1);
261 ASSERT_NO_THROW(audioControl->ProcessAudioWhenCallActive(ringingCall));
262 audioControl->SaveVoiceVolume(-1);
263 ASSERT_NO_THROW(audioControl->ProcessAudioWhenCallActive(ringingCall));
264 audioControl->soundState_ = SoundState::SOUNDING;
265 audioControl->SetRingState(RingState::RINGING);
266 ringingCall->SetCrsType(2);
267 auto audioDeviceManager = DelayedSingleton<AudioDeviceManager>::GetInstance();
268 audioDeviceManager->isWiredHeadsetConnected_ = true;
269 auto callStateProcessor = DelayedSingleton<CallStateProcessor>::GetInstance();
270 callStateProcessor->incomingCalls_.insert(1);
271 callStateProcessor->alertingCalls_.clear();
272 ringingCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
273 CallPolicy callPolicy;
274 callPolicy.AddOneCallObject(ringingCall);
275 audioControl->ringState_ = RingState::STOPPED;
276 audioControl->soundState_ = SoundState::STOPPED;
277 audioControl->isCrsVibrating_ =true;
278 ASSERT_FALSE(audioControl->PlayRingtone());
279 ASSERT_FALSE(audioControl->StopForNoRing());
280 ASSERT_TRUE(audioControl->PlayForNoRing());
281 ASSERT_TRUE(audioControl->StopForNoRing());
282 DelayedSingleton<AudioControlManager>::GetInstance()->UnInit();
283 }
284
285 /**
286 * @tc.number Telephony_AudioControlManager_007
287 * @tc.name test error branch
288 * @tc.desc Function test
289 */
290 HWTEST_F(ZeroBranch9Test, Telephony_AudioControlManager_007, Function | MediumTest | Level3)
291 {
292 auto audioControl = DelayedSingleton<AudioControlManager>::GetInstance();
293 ASSERT_NO_THROW(audioControl->PostProcessRingtone());
294 DialParaInfo info;
295 sptr<CallBase> ringingCall = new IMSCall(info);
296 AAFwk::WantParams params = ringingCall->GetExtraParams();
297 params.SetParam("isNeedMuteRing", AAFwk::Integer::Box(1));
298 ringingCall->SetExtraParams(params);
299 ringingCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
300 CallObjectManager::AddOneCallObject(ringingCall);
301 ASSERT_NO_THROW(audioControl->PostProcessRingtone());
302 DelayedSingleton<AudioControlManager>::GetInstance()->UnInit();
303 }
304
305 /**
306 * @tc.number Telephony_AudioControlManager_008
307 * @tc.name test error branch
308 * @tc.desc Function test
309 */
310 HWTEST_F(ZeroBranch9Test, Telephony_AudioControlManager_008, Function | MediumTest | Level3)
311 {
312 DialParaInfo info;
313 sptr<CallBase> call = new IMSCall(info);
314 auto audioControl = DelayedSingleton<AudioControlManager>::GetInstance();
315 audioControl->isCrsStartSoundTone_ = false;
316 audioControl->HandleCallStateUpdated(call, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_ACTIVE);
317 ASSERT_NO_THROW(audioControl->UnmuteSoundTone());
318 audioControl->HandleNextState(call, TelCallState::CALL_STATUS_ANSWERED);
319 audioControl->HandlePriorState(call, TelCallState::CALL_STATUS_INCOMING);
320 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
321 audioControl->UpdateForegroundLiveCall();
322 ASSERT_NO_THROW(audioControl->ProcessAudioWhenCallActive(call));
323 audioControl->isCrsStartSoundTone_ = true;
324 ASSERT_NO_THROW(audioControl->UnmuteSoundTone());
325 audioControl->HandlePriorState(call, TelCallState::CALL_STATUS_INCOMING);
326 ASSERT_NO_THROW(audioControl->ProcessAudioWhenCallActive(call));
327 ASSERT_NO_THROW(audioControl->MuteNetWorkRingTone(false));
328 audioControl->HandleCallStateUpdated(call, TelCallState::CALL_STATUS_INCOMING,
329 TelCallState::CALL_STATUS_DISCONNECTING);
330 ASSERT_NO_THROW(DelayedSingleton<CallStateProcessor>::GetInstance()->DeleteCall(call->GetCallID(),
331 TelCallState::CALL_STATUS_ACTIVE));
332 DelayedSingleton<AudioControlManager>::GetInstance()->UnInit();
333 }
334
335 /**
336 * @tc.number Telephony_AudioControlManager_009
337 * @tc.name test error branch
338 * @tc.desc Function test
339 */
340 HWTEST_F(ZeroBranch9Test, Telephony_AudioControlManager_009, Function | MediumTest | Level3)
341 {
342 auto audioControl = DelayedSingleton<AudioControlManager>::GetInstance();
343 sptr<OHOS::Telephony::CallBase> crsCallObjectPtr = nullptr;
344 DialParaInfo mDialParaInfo;
345 mDialParaInfo.accountId = 0;
346 mDialParaInfo.callId = 0;
347 mDialParaInfo.index = 0;
348 crsCallObjectPtr = new IMSCall(mDialParaInfo);
349 crsCallObjectPtr->SetCallType(CallType::TYPE_IMS);
350 CallObjectManager::AddOneCallObject(crsCallObjectPtr);
351 ASSERT_NO_THROW(audioControl->HandleNextState(crsCallObjectPtr, TelCallState::CALL_STATUS_DISCONNECTED));
352 ASSERT_NO_THROW(audioControl->ProcessAudioWhenCallActive(crsCallObjectPtr));
353 audioControl->isCrsVibrating_ = true;
354 ASSERT_NO_THROW(audioControl->HandleNextState(crsCallObjectPtr, TelCallState::CALL_STATUS_DISCONNECTED));
355 ASSERT_NO_THROW(audioControl->ProcessAudioWhenCallActive(crsCallObjectPtr));
356 audioControl->isVideoRingVibrating_ = true;
357 ASSERT_NO_THROW(audioControl->HandleNextState(crsCallObjectPtr, TelCallState::CALL_STATUS_DISCONNECTED));
358 ASSERT_NO_THROW(audioControl->ProcessAudioWhenCallActive(crsCallObjectPtr));
359 crsCallObjectPtr->SetCrsType(2);
360 ASSERT_NO_THROW(audioControl->HandleNextState(crsCallObjectPtr, TelCallState::CALL_STATUS_DISCONNECTED));
361 crsCallObjectPtr->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
362 ASSERT_NO_THROW(audioControl->HandleNextState(crsCallObjectPtr, TelCallState::CALL_STATUS_DISCONNECTED));
363 sptr<OHOS::Telephony::CallBase> videoRingCallObjectPtr = nullptr;
364 mDialParaInfo.callId = 1;
365 mDialParaInfo.index = 1;
366 videoRingCallObjectPtr = new IMSCall(mDialParaInfo);
367 CallObjectManager::AddOneCallObject(videoRingCallObjectPtr);
368 ASSERT_NO_THROW(audioControl->HandleNextState(crsCallObjectPtr, TelCallState::CALL_STATUS_DISCONNECTED));
369 crsCallObjectPtr->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
370 ASSERT_NO_THROW(audioControl->HandleNextState(crsCallObjectPtr, TelCallState::CALL_STATUS_DISCONNECTED));
371 ContactInfo contactInfo = videoRingCallObjectPtr->GetCallerInfo();
372 memcpy_s(contactInfo.ringtonePath, FILE_PATH_MAX_LEN, SYSTEM_VIDEO_RING, strlen(SYSTEM_VIDEO_RING));
373 videoRingCallObjectPtr->SetCallerInfo(contactInfo);
374 ASSERT_NO_THROW(audioControl->HandleNextState(crsCallObjectPtr, TelCallState::CALL_STATUS_DISCONNECTED));
375 ASSERT_NO_THROW(CallObjectManager::DeleteOneCallObject(crsCallObjectPtr->GetCallID()));
376 ASSERT_NO_THROW(CallObjectManager::DeleteOneCallObject(videoRingCallObjectPtr->GetCallID()));
377 DelayedSingleton<AudioControlManager>::GetInstance()->UnInit();
378 }
379
380 /**
381 * @tc.number Telephony_AudioControlManager_010
382 * @tc.name test error branch
383 * @tc.desc Function test
384 */
385 HWTEST_F(ZeroBranch9Test, Telephony_AudioControlManager_010, Function | MediumTest | Level3)
386 {
387 auto audioControl = DelayedSingleton<AudioControlManager>::GetInstance();
388 DialParaInfo mDialParaInfo;
389 mDialParaInfo.accountId = 0;
390 mDialParaInfo.callId = 0;
391 mDialParaInfo.index = 0;
392 sptr<OHOS::Telephony::CallBase> videoRingCallObjectPtr = nullptr;
393 videoRingCallObjectPtr = new IMSCall(mDialParaInfo);
394 videoRingCallObjectPtr->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
395 CallObjectManager::AddOneCallObject(videoRingCallObjectPtr);
396 ASSERT_NO_THROW(audioControl->ProcessAudioWhenCallActive(videoRingCallObjectPtr));
397 audioControl->isCrsVibrating_ = true;
398 ASSERT_NO_THROW(audioControl->ProcessAudioWhenCallActive(videoRingCallObjectPtr));
399 audioControl->isVideoRingVibrating_ = true;
400 ASSERT_NO_THROW(audioControl->ProcessAudioWhenCallActive(videoRingCallObjectPtr));
401 sptr<OHOS::Telephony::CallBase> videoRingCallObjectPtr1 = nullptr;
402 mDialParaInfo.callId = 1;
403 mDialParaInfo.index = 1;
404 videoRingCallObjectPtr1 = new IMSCall(mDialParaInfo);
405 videoRingCallObjectPtr1->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
406 CallObjectManager::AddOneCallObject(videoRingCallObjectPtr1);
407 ASSERT_NO_THROW(audioControl->ProcessAudioWhenCallActive(videoRingCallObjectPtr));
408 ContactInfo contactInfo = videoRingCallObjectPtr1->GetCallerInfo();
409 memcpy_s(contactInfo.ringtonePath, FILE_PATH_MAX_LEN, SYSTEM_VIDEO_RING, strlen(SYSTEM_VIDEO_RING));
410 videoRingCallObjectPtr1->SetCallerInfo(contactInfo);
411 ASSERT_NO_THROW(audioControl->ProcessAudioWhenCallActive(videoRingCallObjectPtr));
412 memcpy_s(contactInfo.personalNotificationRingtone, FILE_PATH_MAX_LEN, "abc.mp4", strlen("abc.mp4"));
413 videoRingCallObjectPtr1->SetCallerInfo(contactInfo);
414 ASSERT_NO_THROW(audioControl->ProcessAudioWhenCallActive(videoRingCallObjectPtr));
415 ASSERT_NO_THROW(CallObjectManager::DeleteOneCallObject(videoRingCallObjectPtr->GetCallID()));
416 ASSERT_NO_THROW(CallObjectManager::DeleteOneCallObject(videoRingCallObjectPtr1->GetCallID()));
417 DelayedSingleton<AudioControlManager>::GetInstance()->UnInit();
418 }
419
420 /**
421 * @tc.number Telephony_DealVideoRingPath_001
422 * @tc.name test error branch
423 * @tc.desc Function test
424 */
425 HWTEST_F(ZeroBranch9Test, Telephony_DealVideoRingPath_001, TestSize.Level0)
426 {
427 auto audioControl = DelayedSingleton<AudioControlManager>::GetInstance();
428 sptr<CallBase> callObjectPtr = nullptr;
429 DialParaInfo dialParaInfo;
430 dialParaInfo.index = 0;
431 dialParaInfo.accountId = 0;
432 dialParaInfo.callType = CallType::TYPE_CS;
433 dialParaInfo.callState = TelCallState::CALL_STATUS_INCOMING;
434 callObjectPtr = new IMSCall(dialParaInfo);
435 ContactInfo contactInfo;
436 ASSERT_FALSE(audioControl->NeedPlayVideoRing(contactInfo, callObjectPtr));
437 AccessToken token;
438 ASSERT_FALSE(audioControl->NeedPlayVideoRing(contactInfo, callObjectPtr));
439 memcpy_s(contactInfo.ringtonePath, 3, "123", 3);
440 ASSERT_FALSE(audioControl->NeedPlayVideoRing(contactInfo, callObjectPtr));
441 memcpy_s(contactInfo.personalNotificationRingtone, strlen(STR_MP4) + 1, STR_MP4, strlen(STR_MP4));
442 ASSERT_TRUE(audioControl->NeedPlayVideoRing(contactInfo, callObjectPtr));
443 memcpy_s(contactInfo.ringtonePath, strlen(SYSTEM_VIDEO_RING) + 1, SYSTEM_VIDEO_RING, strlen(SYSTEM_VIDEO_RING));
444 memcpy_s(contactInfo.personalNotificationRingtone, strlen(STR_NOT_MP4) + 1, STR_NOT_MP4, strlen(STR_NOT_MP4));
445 ASSERT_TRUE(audioControl->NeedPlayVideoRing(contactInfo, callObjectPtr));
446 auto callControl = DelayedSingleton<CallControlManager>::GetInstance();
447 callControl->SetWearState(WEAR_STATUS_OFF);
448 audioControl->NeedPlayVideoRing(contactInfo, callObjectPtr);
449 callObjectPtr->SetCrsType(CRS_TYPE);
450 audioControl->NeedPlayVideoRing(contactInfo, callObjectPtr);
451 ASSERT_NO_THROW(CallObjectManager::DeleteOneCallObject(callObjectPtr->GetCallID()));
452 DelayedSingleton<AudioControlManager>::GetInstance()->UnInit();
453 }
454
455 /**
456 * @tc.number Telephony_PlayRingtone_001
457 * @tc.name test error branch
458 * @tc.desc Function test
459 */
460 HWTEST_F(ZeroBranch9Test, Telephony_PlayRingtone_001, Function | MediumTest | Level3)
461 {
462 auto audioControl = DelayedSingleton<AudioControlManager>::GetInstance();
463 ASSERT_FALSE(audioControl->PlayRingtone());
464 DialParaInfo info;
465 sptr<CallBase> ringingCall = new IMSCall(info);
466 AAFwk::WantParams params = ringingCall->GetExtraParams();
467 params.SetParam("isNeedMuteRing", AAFwk::Integer::Box(1));
468 ringingCall->SetExtraParams(params);
469 ringingCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
470 CallObjectManager::AddOneCallObject(ringingCall);
471 ASSERT_TRUE(audioControl->PlayRingtone());
472 ContactInfo contactInfo;
473 memcpy_s(contactInfo.personalNotificationRingtone, strlen(STR_MP4) + 1, STR_MP4, strlen(STR_MP4));
474 ringingCall->SetCallerInfo(contactInfo);
475 audioControl->StopRingtone();
476 ASSERT_TRUE(audioControl->PlayRingtone());
477 ringingCall->SetCrsType(CRS_TYPE);
478 ASSERT_FALSE(audioControl->PlayRingtone());
479 ASSERT_NO_THROW(CallObjectManager::DeleteOneCallObject(ringingCall->GetCallID()));
480 DelayedSingleton<AudioControlManager>::GetInstance()->UnInit();
481 }
482
483 /**
484 * @tc.number Telephony_SwitchIncoming_001
485 * @tc.name test error branch
486 * @tc.desc Function test
487 */
488 HWTEST_F(ZeroBranch9Test, Telephony_SwitchIncoming_001, Function | MediumTest | Level3)
489 {
490 auto audioSceneProcessor = DelayedSingleton<AudioSceneProcessor>::GetInstance();
491 auto audioControl = DelayedSingleton<AudioControlManager>::GetInstance();
492 DialParaInfo mDialParaInfo;
493 mDialParaInfo.callType = CallType::TYPE_IMS;
494 mDialParaInfo.accountId = 0;
495 mDialParaInfo.callId = 0;
496 mDialParaInfo.index = 0;
497 sptr<OHOS::Telephony::CallBase> crsCallObjectPtr = nullptr;
498 crsCallObjectPtr = new IMSCall(mDialParaInfo);
499 crsCallObjectPtr->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
500 CallObjectManager::AddOneCallObject(crsCallObjectPtr);
501 ASSERT_TRUE(audioSceneProcessor->SwitchIncoming());
502 crsCallObjectPtr->SetCrsType(CRS_TYPE);
503 ASSERT_TRUE(audioSceneProcessor->SwitchIncoming());
504 mDialParaInfo.callId = 1;
505 mDialParaInfo.index = 1;
506 sptr<OHOS::Telephony::CallBase> vidioRingCallObjectPtr = nullptr;
507 vidioRingCallObjectPtr = new IMSCall(mDialParaInfo);
508 vidioRingCallObjectPtr->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
509 CallObjectManager::AddOneCallObject(vidioRingCallObjectPtr);
510 ASSERT_TRUE(audioSceneProcessor->SwitchIncoming());
511 audioControl->SetSoundState(SoundState::SOUNDING);
512 ASSERT_TRUE(audioSceneProcessor->SwitchIncoming());
513 ASSERT_NO_THROW(CallObjectManager::DeleteOneCallObject(crsCallObjectPtr->GetCallID()));
514 DelayedSingleton<AudioControlManager>::GetInstance()->UnInit();
515 }
516 }