1 /*
2 * Copyright (C) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #define private public
16 #define protected public
17
18 #include <gtest/gtest.h>
19
20 #include "accesstoken_kit.h"
21 #include "audio_control_manager.h"
22 #include "audio_device_manager.h"
23 #include "audio_proxy.h"
24 #include "bluetooth_call_client.h"
25 #include "bluetooth_call_service.h"
26 #include "call_ability_callback.h"
27 #include "call_ability_report_proxy.h"
28 #include "call_control_manager.h"
29 #include "ims_call.h"
30 #include "incoming_flash_reminder.h"
31 #include "nativetoken_kit.h"
32 #include "nearlink_call_client.h"
33 #include "telephony_errors.h"
34 #include "token_setproc.h"
35 #ifdef ABILITY_CAMERA_FRAMEWORK_SUPPORT
36 #include "input/camera_manager.h"
37 #endif
38 #ifdef ABILITY_SCREENLOCKMGR_SUPPORT
39 #include "screenlock_manager.h"
40 #endif
41
42 namespace OHOS::Telephony {
43 using namespace testing::ext;
44 constexpr int WAIT_TIME = 3;
45 class ZeroBranch10Test : public testing::Test {
46 public:
47 void SetUp();
48 void TearDown();
49 static void SetUpTestCase();
50 static void TearDownTestCase();
51 };
SetUp()52 void ZeroBranch10Test::SetUp() {}
53
TearDown()54 void ZeroBranch10Test::TearDown() {}
55
SetUpTestCase()56 void ZeroBranch10Test::SetUpTestCase()
57 {
58 const char *perms[1] = {
59 "ohos.permission.SET_TELEPHONY_STATE",
60 };
61 NativeTokenInfoParams infoInstance = {
62 .dcapsNum = 0,
63 .permsNum = 1,
64 .aclsNum = 0,
65 .dcaps = nullptr,
66 .perms = perms,
67 .acls = nullptr,
68 .processName = "ZeroBranch10Test",
69 .aplStr = "system_basic",
70 };
71 uint64_t tokenId = GetAccessTokenId(&infoInstance);
72 SetSelfTokenID(tokenId);
73 auto result = Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
74 EXPECT_EQ(result, Security::AccessToken::RET_SUCCESS);
75 }
76
TearDownTestCase()77 void ZeroBranch10Test::TearDownTestCase()
78 {
79 sleep(WAIT_TIME);
80 }
81
82 using namespace Security::AccessToken;
83 using Security::AccessToken::AccessTokenID;
84
85 inline HapInfoParams testInfoParams = {
86 .bundleName = "ZeroBranch10Test",
87 .userID = 1,
88 .instIndex = 0,
89 .appIDDesc = "test",
90 .isSystemApp = true,
91 };
92
93 inline PermissionDef testPermSetTelephonyStateDef = {
94 .permissionName = "ohos.permission.SET_TELEPHONY_STATE",
95 .bundleName = "ZeroBranch10Test",
96 .grantMode = 1, // SYSTEM_GRANT
97 .label = "label",
98 .labelId = 1,
99 .description = "Test call manager",
100 .descriptionId = 1,
101 .availableLevel = APL_SYSTEM_BASIC,
102 };
103
104 inline PermissionStateFull testSetTelephonyState = {
105 .grantFlags = { 2 }, // PERMISSION_USER_SET
106 .grantStatus = { PermissionState::PERMISSION_GRANTED },
107 .isGeneral = true,
108 .permissionName = "ohos.permission.SET_TELEPHONY_STATE",
109 .resDeviceID = { "local" },
110 };
111
112 inline HapPolicyParams testPolicyParams = {
113 .apl = APL_SYSTEM_BASIC,
114 .domain = "test.domain",
115 .permList = { testPermSetTelephonyStateDef },
116 .permStateList = { testSetTelephonyState },
117 };
118
119 class AccessToken {
120 public:
AccessToken()121 AccessToken()
122 {
123 currentID_ = GetSelfTokenID();
124 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(testInfoParams, testPolicyParams);
125 accessID_ = tokenIdEx.tokenIdExStruct.tokenID;
126 SetSelfTokenID(tokenIdEx.tokenIDEx);
127 }
~AccessToken()128 ~AccessToken()
129 {
130 AccessTokenKit::DeleteToken(accessID_);
131 SetSelfTokenID(currentID_);
132 }
133 private:
134 AccessTokenID currentID_ = 0;
135 AccessTokenID accessID_ = 0;
136 };
137
138 /**
139 * @tc.number Telephony_NearlinkCallClient_001
140 * @tc.name test NearlinkCallClient
141 * @tc.desc Function test
142 */
143 HWTEST_F(ZeroBranch10Test, Telephony_NearlinkCallClient_001, TestSize.Level1)
144 {
145 NearlinkCallClient &client = DelayedRefSingleton<NearlinkCallClient>::GetInstance();
146 client.UnInit();
147 EXPECT_EQ(client.RegisterCallBack(nullptr), TELEPHONY_ERR_UNINIT);
148 EXPECT_EQ(client.UnRegisterCallBack(), TELEPHONY_ERR_UNINIT);
149 EXPECT_EQ(client.AnswerCall(), TELEPHONY_ERR_UNINIT);
150 EXPECT_EQ(client.RejectCall(), TELEPHONY_ERR_UNINIT);
151 EXPECT_EQ(client.HangUpCall(), TELEPHONY_ERR_UNINIT);
152 EXPECT_EQ(client.GetCallState(), TELEPHONY_ERR_UNINIT);
153 EXPECT_TRUE(client.GetCurrentCallList(0).empty());
154 EXPECT_EQ(client.AddAudioDevice("", ""), TELEPHONY_ERR_UNINIT);
155 EXPECT_EQ(client.RemoveAudioDevice(""), TELEPHONY_ERR_UNINIT);
156 EXPECT_EQ(client.ResetNearlinkDeviceList(), TELEPHONY_ERR_UNINIT);
157 client.Init();
158 EXPECT_NE(client.RegisterCallBack(nullptr), TELEPHONY_ERR_UNINIT);
159 EXPECT_NE(client.UnRegisterCallBack(), TELEPHONY_ERR_UNINIT);
160 EXPECT_NE(client.AnswerCall(), TELEPHONY_ERR_UNINIT);
161 EXPECT_NE(client.RejectCall(), TELEPHONY_ERR_UNINIT);
162 EXPECT_NE(client.HangUpCall(), TELEPHONY_ERR_UNINIT);
163 EXPECT_NE(client.GetCallState(), TELEPHONY_ERR_UNINIT);
164 EXPECT_TRUE(client.GetCurrentCallList(0).empty());
165 EXPECT_NE(client.AddAudioDevice("", ""), TELEPHONY_ERR_UNINIT);
166 EXPECT_NE(client.RemoveAudioDevice(""), TELEPHONY_ERR_UNINIT);
167 EXPECT_NE(client.ResetNearlinkDeviceList(), TELEPHONY_ERR_UNINIT);
168 client.UnInit();
169 }
170
171 /**
172 * @tc.number Telephony_BluetoothCallClient_001
173 * @tc.name test BluetoothCallClient
174 * @tc.desc Function test
175 */
176 HWTEST_F(ZeroBranch10Test, Telephony_BluetoothCallClient_001, TestSize.Level1)
177 {
178 BluetoothCallClient &client = DelayedRefSingleton<BluetoothCallClient>::GetInstance();
179 EXPECT_EQ(client.AddAudioDevice("", "", AudioDeviceType::DEVICE_BLUETOOTH_HEARING_AID), TELEPHONY_ERR_UNINIT);
180 EXPECT_EQ(client.RemoveAudioDevice("", AudioDeviceType::DEVICE_BLUETOOTH_HEARING_AID), TELEPHONY_ERR_UNINIT);
181 EXPECT_EQ(client.ResetHearingAidDeviceList(), TELEPHONY_ERR_UNINIT);
182 }
183
184 /**
185 * @tc.number Telephony_BluetoothCallService_001
186 * @tc.name test BluetoothCallService
187 * @tc.desc Function test
188 */
189 HWTEST_F(ZeroBranch10Test, Telephony_BluetoothCallService_001, TestSize.Level1)
190 {
191 AccessToken accessToken;
192 auto bluetoothCallService = std::make_shared<BluetoothCallService>();
193 MessageParcel data;
194 MessageParcel reply;
195 int32_t result = bluetoothCallService->OnAddAudioDeviceList(data, reply);
196 EXPECT_EQ(result, TELEPHONY_ERR_ARGUMENT_INVALID);
197 result = bluetoothCallService->OnRemoveAudioDeviceList(data, reply);
198 EXPECT_EQ(result, TELEPHONY_ERR_ARGUMENT_INVALID);
199 result = bluetoothCallService->OnResetNearlinkDeviceList(data, reply);
200 EXPECT_NE(result, TELEPHONY_ERR_PERMISSION_ERR);
201 result = bluetoothCallService->OnResetBtHearingAidDeviceList(data, reply);
202 EXPECT_NE(result, TELEPHONY_ERR_PERMISSION_ERR);
203 data.WriteString("addr");
204 data.WriteInt32(static_cast<int32_t>(AudioDeviceType::DEVICE_NEARLINK));
205 data.WriteString("name");
206 result = bluetoothCallService->OnAddAudioDeviceList(data, reply);
207 EXPECT_NE(result, TELEPHONY_ERR_ARGUMENT_INVALID);
208 MessageParcel data1;
209 data1.WriteString("addr");
210 data1.WriteInt32(static_cast<int32_t>(AudioDeviceType::DEVICE_NEARLINK));
211 result = bluetoothCallService->OnRemoveAudioDeviceList(data1, reply);
212 EXPECT_NE(result, TELEPHONY_ERR_ARGUMENT_INVALID);
213 result = bluetoothCallService->AddAudioDeviceList("addr",
214 static_cast<int32_t>(AudioDeviceType::DEVICE_BLUETOOTH_HEARING_AID), "name");
215 EXPECT_NE(result, TELEPHONY_ERR_ARGUMENT_INVALID);
216 result = bluetoothCallService->AddAudioDeviceList("addr",
217 static_cast<int32_t>(AudioDeviceType::DEVICE_EARPIECE), "name");
218 EXPECT_EQ(result, TELEPHONY_ERR_ARGUMENT_INVALID);
219 result = bluetoothCallService->RemoveAudioDeviceList("addr",
220 static_cast<int32_t>(AudioDeviceType::DEVICE_BLUETOOTH_HEARING_AID));
221 EXPECT_NE(result, TELEPHONY_ERR_ARGUMENT_INVALID);
222 result = bluetoothCallService->RemoveAudioDeviceList("addr",
223 static_cast<int32_t>(AudioDeviceType::DEVICE_EARPIECE));
224 EXPECT_EQ(result, TELEPHONY_ERR_ARGUMENT_INVALID);
225 }
226
227 class MockCallManagerCallback : public CallManagerCallback {
228 public:
MockCallManagerCallback(int32_t value)229 explicit MockCallManagerCallback(int32_t value) : value_(value) {}
OnCallDetailsChange(const CallAttributeInfo & info)230 int32_t OnCallDetailsChange(const CallAttributeInfo &info)
231 {
232 return value_;
233 }
234
OnMeeTimeDetailsChange(const CallAttributeInfo & info)235 int32_t OnMeeTimeDetailsChange(const CallAttributeInfo &info)
236 {
237 return value_;
238 }
239
OnCallEventChange(const CallEventInfo & info)240 int32_t OnCallEventChange(const CallEventInfo &info)
241 {
242 return value_;
243 }
244
OnCallDisconnectedCause(const DisconnectedDetails & details)245 int32_t OnCallDisconnectedCause(const DisconnectedDetails &details)
246 {
247 return value_;
248 }
249
OnReportAsyncResults(CallResultReportId reportId,AppExecFwk::PacMap & resultInfo)250 int32_t OnReportAsyncResults(CallResultReportId reportId, AppExecFwk::PacMap &resultInfo)
251 {
252 return value_;
253 }
254
OnOttCallRequest(OttCallRequestId requestId,AppExecFwk::PacMap & info)255 int32_t OnOttCallRequest(OttCallRequestId requestId, AppExecFwk::PacMap &info)
256 {
257 return value_;
258 }
259
OnReportMmiCodeResult(const MmiCodeInfo & info)260 int32_t OnReportMmiCodeResult(const MmiCodeInfo &info)
261 {
262 return value_;
263 }
264
OnReportAudioDeviceChange(const AudioDeviceInfo & info)265 int32_t OnReportAudioDeviceChange(const AudioDeviceInfo &info)
266 {
267 return value_;
268 }
269
OnReportPostDialDelay(const std::string & str)270 int32_t OnReportPostDialDelay(const std::string &str)
271 {
272 return value_;
273 }
274
OnUpdateImsCallModeChange(const CallMediaModeInfo & imsCallModeInfo)275 int32_t OnUpdateImsCallModeChange(const CallMediaModeInfo &imsCallModeInfo)
276 {
277 return value_;
278 }
279
OnCallSessionEventChange(const CallSessionEvent & callSessionEventOptions)280 int32_t OnCallSessionEventChange(const CallSessionEvent &callSessionEventOptions)
281 {
282 return value_;
283 }
284
OnPeerDimensionsChange(const PeerDimensionsDetail & peerDimensionsDetail)285 int32_t OnPeerDimensionsChange(const PeerDimensionsDetail &peerDimensionsDetail)
286 {
287 return value_;
288 }
289
OnCallDataUsageChange(const int64_t dataUsage)290 int32_t OnCallDataUsageChange(const int64_t dataUsage)
291 {
292 return value_;
293 }
294
OnUpdateCameraCapabilities(const CameraCapabilities & cameraCapabilities)295 int32_t OnUpdateCameraCapabilities(const CameraCapabilities &cameraCapabilities)
296 {
297 return value_;
298 }
299
OnPhoneStateChange(int32_t numActive,int32_t numHeld,int32_t callState,const std::string & number)300 int32_t OnPhoneStateChange(int32_t numActive, int32_t numHeld, int32_t callState,
301 const std::string &number)
302 {
303 return value_;
304 }
305 private:
306 int32_t value_;
307 };
308
309 /**
310 * @tc.number Telephony_NearlinkCallReport_001
311 * @tc.name test NearlinkCall Report
312 * @tc.desc Function test
313 */
314 HWTEST_F(ZeroBranch10Test, Telephony_NearlinkCallReport_001, TestSize.Level1)
315 {
316 NearlinkCallClient &client = DelayedRefSingleton<NearlinkCallClient>::GetInstance();
317 client.Init();
318 EXPECT_NE(client.RegisterCallBack(std::make_unique<MockCallManagerCallback>(0)), TELEPHONY_ERR_UNINIT);
319 EXPECT_NE(client.RegisterCallBack(std::make_unique<MockCallManagerCallback>(-1)), TELEPHONY_ERR_UNINIT);
320 sptr<CallAbilityCallback> callback1 = new (std::nothrow) CallAbilityCallback();
321 ASSERT_NE(callback1, nullptr);
322 callback1->SetProcessCallback(std::make_unique<MockCallManagerCallback>(0));
323 sptr<CallAbilityCallback> callback2 = new (std::nothrow) CallAbilityCallback();
324 ASSERT_NE(callback2, nullptr);
325 callback2->SetProcessCallback(std::make_unique<MockCallManagerCallback>(-1));
326 DelayedSingleton<CallAbilityReportProxy>::GetInstance()->callbackPtrList_.emplace_back(callback1);
327 DelayedSingleton<CallAbilityReportProxy>::GetInstance()->callbackPtrList_.emplace_back(callback2);
328 DelayedSingleton<CallAbilityReportProxy>::GetInstance()->callbackPtrList_.emplace_back(nullptr);
329 EXPECT_NE(DelayedSingleton<CallAbilityReportProxy>::GetInstance()->ReportPhoneStateChange(0, 0, 0, ""), 0);
330 client.UnInit();
331 }
332
333 /**
334 * @tc.number Telephony_AudioControlManager_001
335 * @tc.name test AudioControlManager
336 * @tc.desc Function test
337 */
338 HWTEST_F(ZeroBranch10Test, Telephony_AudioControlManager_001, TestSize.Level0)
339 {
340 DialParaInfo info;
341 sptr<CallBase> call = new IMSCall(info);
342 call->SetCallType(CallType::TYPE_IMS);
343 call->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
344 call->SetOriginalCallType(0);
345 CallObjectManager::AddOneCallObject(call);
346 AudioDeviceType initDeviceType = AudioDeviceType::DEVICE_NEARLINK;
347 AudioDevice device;
348 device.deviceType = AudioDeviceType::DEVICE_DISABLE;
349 auto audioControlManager = DelayedSingleton<AudioControlManager>::GetInstance();
350 audioControlManager->CheckTypeAndSetAudioDevice(call, VideoStateType::TYPE_VIDEO,
351 VideoStateType::TYPE_VOICE, initDeviceType, device);
352 audioControlManager->CheckTypeAndSetAudioDevice(call, VideoStateType::TYPE_VOICE,
353 VideoStateType::TYPE_VIDEO, initDeviceType, device);
354 call->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
355 audioControlManager->CheckTypeAndSetAudioDevice(call, VideoStateType::TYPE_VIDEO,
356 VideoStateType::TYPE_VOICE, initDeviceType, device);
357 audioControlManager->CheckTypeAndSetAudioDevice(call, VideoStateType::TYPE_VOICE,
358 VideoStateType::TYPE_VIDEO, initDeviceType, device);
359 call->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
360 audioControlManager->CheckTypeAndSetAudioDevice(call, VideoStateType::TYPE_VIDEO,
361 VideoStateType::TYPE_VOICE, initDeviceType, device);
362 audioControlManager->CheckTypeAndSetAudioDevice(call, VideoStateType::TYPE_VOICE,
363 VideoStateType::TYPE_VIDEO, initDeviceType, device);
364 EXPECT_EQ(device.deviceType, AudioDeviceType::DEVICE_NEARLINK);
365 initDeviceType = AudioDeviceType::DEVICE_BLUETOOTH_HEARING_AID;
366 audioControlManager->CheckTypeAndSetAudioDevice(call, VideoStateType::TYPE_VOICE,
367 VideoStateType::TYPE_VIDEO, initDeviceType, device);
368 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_DIALING);
369 call->SetVideoStateType(VideoStateType::TYPE_VOICE);
370 audioControlManager->UpdateDeviceTypeForVideoDialing();
371 call->SetVideoStateType(VideoStateType::TYPE_VIDEO);
372 audioControlManager->UpdateDeviceTypeForVideoDialing();
373 device.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_HEARING_AID;
374 audioControlManager->SetAudioDevice(device, false);
375 device.deviceType = AudioDeviceType::DEVICE_EARPIECE;
376 audioControlManager->SetAudioDevice(device, false);
377 CallObjectManager::DeleteOneCallObject(call);
378 EXPECT_TRUE(audioControlManager->IsExternalAudioDevice(AudioDeviceType::DEVICE_BLUETOOTH_HEARING_AID));
379 }
380
381 /**
382 * @tc.number Telephony_AudioControlManager_002
383 * @tc.name test AudioControlManager
384 * @tc.desc Function test
385 */
386 HWTEST_F(ZeroBranch10Test, Telephony_AudioControlManager_002, TestSize.Level0)
387 {
388 AudioDevice device;
389 device.deviceType = AudioDeviceType::DEVICE_NEARLINK;
390 auto audioControlManager = DelayedSingleton<AudioControlManager>::GetInstance();
391 EXPECT_EQ(audioControlManager->HandleWirelessAudioDevice(device),
392 CALL_ERR_AUDIO_SET_AUDIO_DEVICE_FAILED);
393 device.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO;
394 EXPECT_EQ(audioControlManager->HandleWirelessAudioDevice(device),
395 CALL_ERR_AUDIO_SET_AUDIO_DEVICE_FAILED);
396 device.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_HEARING_AID;
397 EXPECT_EQ(audioControlManager->HandleWirelessAudioDevice(device),
398 CALL_ERR_AUDIO_SET_AUDIO_DEVICE_FAILED);
399 strcpy_s(device.address, kMaxAddressLen, "1");
400 device.deviceType = AudioDeviceType::DEVICE_NEARLINK;
401 EXPECT_NE(audioControlManager->HandleWirelessAudioDevice(device),
402 CALL_ERR_AUDIO_SET_AUDIO_DEVICE_FAILED);
403 device.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO;
404 EXPECT_NE(audioControlManager->HandleWirelessAudioDevice(device),
405 CALL_ERR_AUDIO_SET_AUDIO_DEVICE_FAILED);
406 device.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_HEARING_AID;
407 EXPECT_NE(audioControlManager->HandleWirelessAudioDevice(device),
408 CALL_ERR_AUDIO_SET_AUDIO_DEVICE_FAILED);
409 audioControlManager->audioInterruptState_ = AudioInterruptState::INTERRUPT_STATE_ACTIVATED;
410 EXPECT_NE(audioControlManager->GetInitAudioDeviceType(), AudioDeviceType::DEVICE_NEARLINK);
411 }
412
413 /**
414 * @tc.number Telephony_AudioDeviceManager_001
415 * @tc.name test AudioDeviceManager
416 * @tc.desc Function test
417 */
418 HWTEST_F(ZeroBranch10Test, Telephony_AudioDeviceManager_001, TestSize.Level0)
419 {
420 auto audioDeviceManager = DelayedSingleton<AudioDeviceManager>::GetInstance();
421 AudioDevice device;
422 device.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO;
423 audioDeviceManager->info_.audioDeviceList.clear();
424 audioDeviceManager->info_.audioDeviceList.push_back(device);
425 audioDeviceManager->audioDeviceType_ = AudioDeviceType::DEVICE_BLUETOOTH_SCO;
426 audioDeviceManager->ResetNearlinkAudioDevicesList();
427 audioDeviceManager->ResetBtHearingAidDeviceList();
428 device.deviceType = AudioDeviceType::DEVICE_NEARLINK;
429 audioDeviceManager->info_.audioDeviceList.push_back(device);
430 audioDeviceManager->audioDeviceType_ = AudioDeviceType::DEVICE_NEARLINK;
431 audioDeviceManager->ResetNearlinkAudioDevicesList();
432 EXPECT_EQ(audioDeviceManager->info_.audioDeviceList.size(), 1);
433 audioDeviceManager->ReportAudioDeviceChange(device);
434 device.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_HEARING_AID;
435 audioDeviceManager->info_.audioDeviceList.push_back(device);
436 audioDeviceManager->audioDeviceType_ = AudioDeviceType::DEVICE_BLUETOOTH_HEARING_AID;
437 audioDeviceManager->ResetBtHearingAidDeviceList();
438 EXPECT_EQ(audioDeviceManager->info_.audioDeviceList.size(), 1);
439 EXPECT_FALSE(audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_NEARLINK));
440 audioDeviceManager->info_.currentAudioDevice.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO;
441 device.deviceType = AudioDeviceType::DEVICE_NEARLINK;
442 audioDeviceManager->audioDeviceType_ = AudioDeviceType::DEVICE_NEARLINK;
443 audioDeviceManager->ReportAudioDeviceChange(device);
444 std::string address = "1";
445 std::string deviceName = "1";
446 audioDeviceManager->UpdateNearlinkDevice(address, deviceName);
447 audioDeviceManager->UpdateBtDevice(address, deviceName);
448 audioDeviceManager->UpdateBtHearingAidDevice(address, deviceName);
449 address = "";
450 audioDeviceManager->UpdateNearlinkDevice(address, deviceName);
451 audioDeviceManager->UpdateBtDevice(address, deviceName);
452 audioDeviceManager->UpdateBtHearingAidDevice(address, deviceName);
453 address = "1";
454 deviceName = "";
455 audioDeviceManager->UpdateNearlinkDevice(address, deviceName);
456 audioDeviceManager->UpdateBtDevice(address, deviceName);
457 audioDeviceManager->UpdateBtHearingAidDevice(address, deviceName);
458 EXPECT_EQ(audioDeviceManager->info_.currentAudioDevice.deviceType, AudioDeviceType::DEVICE_NEARLINK);
459 EXPECT_TRUE(audioDeviceManager->ConvertAddress().empty());
460 audioDeviceManager->info_.currentAudioDevice.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_HEARING_AID;
461 EXPECT_TRUE(audioDeviceManager->ConvertAddress().empty());
462 EXPECT_FALSE(audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_BLUETOOTH_HEARING_AID));
463 }
464
465 /**
466 * @tc.number Telephony_AudioProxy_001
467 * @tc.name test AudioProxy
468 * @tc.desc Function test
469 */
470 HWTEST_F(ZeroBranch10Test, Telephony_AudioProxy_001, TestSize.Level0)
471 {
472 DelayedSingleton<AudioDeviceManager>::GetInstance()->audioDeviceType_ = AudioDeviceType::DEVICE_SPEAKER;
473 std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> descs;
474 std::make_shared<AudioPreferDeviceChangeCallback>()->OnPreferredOutputDeviceUpdated(descs);
475 DialParaInfo info;
476 sptr<CallBase> call = new IMSCall(info);
477 call->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
478 call->SetCallType(CallType::TYPE_IMS);
479 CallObjectManager::AddOneCallObject(call);
480 std::make_shared<AudioPreferDeviceChangeCallback>()->OnPreferredOutputDeviceUpdated(descs);
481 auto desc = std::make_shared<AudioStandard::AudioDeviceDescriptor>();
482 desc->deviceType_ = AudioStandard::DEVICE_TYPE_BLUETOOTH_SCO;
483 descs.push_back(desc);
484 std::make_shared<AudioPreferDeviceChangeCallback>()->OnPreferredOutputDeviceUpdated(descs);
485 EXPECT_EQ(DelayedSingleton<AudioDeviceManager>::GetInstance()->audioDeviceType_,
486 AudioDeviceType::DEVICE_BLUETOOTH_SCO);
487 descs.clear();
488 desc->deviceType_ = AudioStandard::DEVICE_TYPE_NEARLINK;
489 descs.push_back(desc);
490 std::make_shared<AudioPreferDeviceChangeCallback>()->OnPreferredOutputDeviceUpdated(descs);
491 EXPECT_EQ(DelayedSingleton<AudioDeviceManager>::GetInstance()->audioDeviceType_, AudioDeviceType::DEVICE_NEARLINK);
492 descs.clear();
493 desc->deviceType_ = AudioStandard::DEVICE_TYPE_EARPIECE;
494 descs.push_back(desc);
495 std::make_shared<AudioPreferDeviceChangeCallback>()->OnPreferredOutputDeviceUpdated(descs);
496 EXPECT_EQ(DelayedSingleton<AudioDeviceManager>::GetInstance()->audioDeviceType_, AudioDeviceType::DEVICE_EARPIECE);
497 descs.clear();
498 desc->deviceType_ = AudioStandard::DEVICE_TYPE_SPEAKER;
499 descs.push_back(desc);
500 std::make_shared<AudioPreferDeviceChangeCallback>()->OnPreferredOutputDeviceUpdated(descs);
501 EXPECT_EQ(DelayedSingleton<AudioDeviceManager>::GetInstance()->audioDeviceType_, AudioDeviceType::DEVICE_SPEAKER);
502 descs.clear();
503 desc->deviceType_ = AudioStandard::DEVICE_TYPE_WIRED_HEADSET;
504 descs.push_back(desc);
505 std::make_shared<AudioPreferDeviceChangeCallback>()->OnPreferredOutputDeviceUpdated(descs);
506 EXPECT_EQ(DelayedSingleton<AudioDeviceManager>::GetInstance()->audioDeviceType_,
507 AudioDeviceType::DEVICE_WIRED_HEADSET);
508 descs.clear();
509 desc->deviceType_ = AudioStandard::DEVICE_TYPE_WIRED_HEADPHONES;
510 descs.push_back(desc);
511 std::make_shared<AudioPreferDeviceChangeCallback>()->OnPreferredOutputDeviceUpdated(descs);
512 EXPECT_EQ(DelayedSingleton<AudioDeviceManager>::GetInstance()->audioDeviceType_,
513 AudioDeviceType::DEVICE_WIRED_HEADSET);
514 descs.clear();
515 desc->deviceType_ = AudioStandard::DEVICE_TYPE_USB_HEADSET;
516 descs.push_back(desc);
517 std::make_shared<AudioPreferDeviceChangeCallback>()->OnPreferredOutputDeviceUpdated(descs);
518 EXPECT_EQ(DelayedSingleton<AudioDeviceManager>::GetInstance()->audioDeviceType_,
519 AudioDeviceType::DEVICE_WIRED_HEADSET);
520 }
521
522 /**
523 * @tc.number Telephony_AudioProxy_002
524 * @tc.name test AudioProxy
525 * @tc.desc Function test
526 */
527 HWTEST_F(ZeroBranch10Test, Telephony_AudioProxy_002, TestSize.Level0)
528 {
529 DelayedSingleton<AudioDeviceManager>::GetInstance()->audioDeviceType_ = AudioDeviceType::DEVICE_SPEAKER;
530 std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> descs;
531 std::make_shared<AudioPreferDeviceChangeCallback>()->OnPreferredOutputDeviceUpdated(descs);
532 DialParaInfo info;
533 sptr<CallBase> call = new IMSCall(info);
534 call->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
535 call->SetCallType(CallType::TYPE_IMS);
536 CallObjectManager::AddOneCallObject(call);
537 std::make_shared<AudioPreferDeviceChangeCallback>()->OnPreferredOutputDeviceUpdated(descs);
538 auto desc = std::make_shared<AudioStandard::AudioDeviceDescriptor>();
539 desc->deviceType_ = AudioStandard::DEVICE_TYPE_HEARING_AID;
540 descs.push_back(desc);
541 std::make_shared<AudioPreferDeviceChangeCallback>()->OnPreferredOutputDeviceUpdated(descs);
542 EXPECT_EQ(DelayedSingleton<AudioDeviceManager>::GetInstance()->audioDeviceType_,
543 AudioDeviceType::DEVICE_BLUETOOTH_HEARING_AID);
544 }
545
546 /**
547 * @tc.number Telephony_IncomingFlashReminder_001
548 * @tc.name test IncomingFlashReminder
549 * @tc.desc Function test
550 */
551 HWTEST_F(ZeroBranch10Test, Telephony_IncomingFlashReminder_001, TestSize.Level1)
552 {
553 DelayedSingleton<CallControlManager>::GetInstance()->incomingFlashReminder_ = nullptr;
554 DelayedSingleton<CallControlManager>::GetInstance()->StartFlashRemind();
555 DelayedSingleton<CallControlManager>::GetInstance()->StopFlashRemind();
556 auto runner = AppExecFwk::EventRunner::Create("handler_incoming_flash_reminder");
557 DelayedSingleton<CallControlManager>::GetInstance()->incomingFlashReminder_ =
558 std::make_shared<IncomingFlashReminder>(runner, nullptr);
559 DelayedSingleton<CallControlManager>::GetInstance()->StopFlashRemind();
560 DelayedSingleton<CallControlManager>::GetInstance()->StartFlashRemind();
561 DelayedSingleton<CallControlManager>::GetInstance()->StopFlashRemind();
562 DelayedSingleton<CallControlManager>::GetInstance()->ClearFlashReminder();
563 EXPECT_EQ(DelayedSingleton<CallControlManager>::GetInstance()->incomingFlashReminder_, nullptr);
564 }
565
566 /**
567 * @tc.number Telephony_IncomingFlashReminder_002
568 * @tc.name test IncomingFlashReminder
569 * @tc.desc Function test
570 */
571 HWTEST_F(ZeroBranch10Test, Telephony_IncomingFlashReminder_002, TestSize.Level1)
572 {
573 auto runner = AppExecFwk::EventRunner::Create("handler_incoming_flash_reminder");
574 std::shared_ptr<IncomingFlashReminder> reminder = std::make_shared<IncomingFlashReminder>(runner, nullptr);
575 reminder->isFlashRemindUsed_ = false;
576 reminder->HandleStopFlashRemind();
577 reminder->isFlashRemindUsed_ = true;
578 reminder->HandleStopFlashRemind();
579 EXPECT_FALSE(reminder->isFlashRemindUsed_);
580 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(0);
581 reminder->ProcessEvent(event);
582 event = AppExecFwk::InnerEvent::Get(1000001);
583 reminder->ProcessEvent(event);
584 event = AppExecFwk::InnerEvent::Get(1000002);
585 reminder->ProcessEvent(event);
586 EXPECT_TRUE(reminder->isFlashRemindUsed_);
587 reminder->HandleStartFlashRemind();
588 event = AppExecFwk::InnerEvent::Get(1000000);
589 reminder->ProcessEvent(event);
590 reminder->RemoveEvent(1000000);
591 reminder->IsScreenStatusSatisfied();
592 bool isTorchOk = false;
593 #ifdef ABILITY_CAMERA_FRAMEWORK_SUPPORT
594 isTorchOk = (CameraStandard::CameraManager::GetInstance()->IsTorchSupported() &&
595 CameraStandard::CameraManager::GetInstance()->GetTorchMode() != CameraStandard::TORCH_MODE_ON);
596 #endif
597 EXPECT_EQ(reminder->IsTorchReady(), isTorchOk);
598 }
599
600 /**
601 * @tc.number Telephony_IncomingFlashReminder_003
602 * @tc.name test IncomingFlashReminder
603 * @tc.desc Function test
604 */
605 HWTEST_F(ZeroBranch10Test, Telephony_IncomingFlashReminder_003, TestSize.Level1)
606 {
607 auto runner = AppExecFwk::EventRunner::Create("handler_incoming_flash_reminder");
608 DelayedSingleton<CallControlManager>::GetInstance()->incomingFlashReminder_ =
609 std::make_shared<IncomingFlashReminder>(runner,
__anon576f627e0102() 610 []() {
611 TELEPHONY_LOGI("clear flash reminder");
612 DelayedSingleton<CallControlManager>::GetInstance()->ClearFlashReminder();
613 }
614 );
615 DelayedSingleton<CallControlManager>::GetInstance()->incomingFlashReminder_->HandleStartFlashRemind();
616 DelayedSingleton<CallControlManager>::GetInstance()->incomingFlashReminder_->isFlashRemindUsed_ = false;
617 DelayedSingleton<CallControlManager>::GetInstance()->incomingFlashReminder_->HandleStopFlashRemind();
618 EXPECT_EQ(DelayedSingleton<CallControlManager>::GetInstance()->incomingFlashReminder_, nullptr);
619 DelayedSingleton<CallControlManager>::GetInstance()->incomingFlashReminder_ =
620 std::make_shared<IncomingFlashReminder>(runner,
__anon576f627e0202() 621 []() {
622 TELEPHONY_LOGI("clear flash reminder");
623 DelayedSingleton<CallControlManager>::GetInstance()->ClearFlashReminder();
624 }
625 );
626 DelayedSingleton<CallControlManager>::GetInstance()->incomingFlashReminder_->isFlashRemindUsed_ = true;
627 DelayedSingleton<CallControlManager>::GetInstance()->incomingFlashReminder_->HandleStopFlashRemind();
628 EXPECT_EQ(DelayedSingleton<CallControlManager>::GetInstance()->incomingFlashReminder_, nullptr);
629 }
630 }