1 /*
2 * Copyright (C) 2022-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 #define private public
16 #define protected public
17 #include <thread>
18 #include <chrono>
19 #include "bluetooth_call_client.h"
20 #include "bluetooth_call_manager.h"
21 #include "bluetooth_call_service.h"
22 #include "bluetooth_connection.h"
23 #include "iremote_broker.h"
24 #include "call_ability_callback.h"
25 #include "call_ability_connect_callback.h"
26 #include "call_ability_report_proxy.h"
27 #include "call_connect_ability.h"
28 #include "call_control_manager.h"
29 #include "call_manager_client.h"
30 #include "call_manager_hisysevent.h"
31 #include "call_number_utils.h"
32 #include "call_policy.h"
33 #include "call_records_manager.h"
34 #include "call_request_event_handler_helper.h"
35 #include "call_request_handler.h"
36 #include "call_request_process.h"
37 #include "call_setting_manager.h"
38 #include "call_state_report_proxy.h"
39 #include "call_status_manager.h"
40 #include "cellular_call_connection.h"
41 #include "common_event_manager.h"
42 #include "common_event_support.h"
43 #include "cs_call.h"
44 #include "cs_conference.h"
45 #include "distributed_call_manager.h"
46 #include "gtest/gtest.h"
47 #include "i_voip_call_manager_service.h"
48 #include "ims_call.h"
49 #include "ims_conference.h"
50 #include "incoming_call_notification.h"
51 #include "missed_call_notification.h"
52 #include "ott_call.h"
53 #include "ott_conference.h"
54 #include "reject_call_sms.h"
55 #include "report_call_info_handler.h"
56 #include "satellite_call.h"
57 #include "surface_utils.h"
58 #include "telephony_errors.h"
59 #include "telephony_hisysevent.h"
60 #include "telephony_log_wrapper.h"
61 #include "video_call_state.h"
62 #include "video_control_manager.h"
63 #include "voip_call_manager_proxy.h"
64 #include "voip_call.h"
65 #include "accesstoken_kit.h"
66 #include "token_setproc.h"
67 #include "nativetoken_kit.h"
68 #include "number_identity_data_base_helper.h"
69 #include "call_ability_callback_death_recipient.h"
70 #include "app_state_observer.h"
71 #include "call_ability_callback_proxy.h"
72 #include "super_privacy_manager_client.h"
73 #include "call_status_callback.h"
74 #include "satellite_call_control.h"
75 #include "proximity_sensor.h"
76 #include "status_bar.h"
77 #include "wired_headset.h"
78 #include "call_status_policy.h"
79 #include "call_superprivacy_control_manager.h"
80 #include "bluetooth_hfp_ag.h"
81 #include "call_manager_connect.h"
82 #include "call_manager_service.h"
83 #include "surface_utils.h"
84 #include "telephony_types.h"
85 #include "voip_call.h"
86 #include "telephony_permission.h"
87 #include "call_setting_manager.h"
88 #include "voip_call_connection.h"
89
90 namespace OHOS {
91 namespace Telephony {
92 using namespace testing::ext;
93
94 namespace {
95 const int32_t INVALID_SLOTID = 2;
96 const int32_t SIM1_SLOTID = 0;
97 const int32_t DEFAULT_INDEX = 1;
98 const int16_t CAMERA_ROTATION_0 = 0;
99 const int16_t CAMERA_ROTATION_90 = 90;
100 const int16_t CAMERA_ROTATION_180 = 180;
101 const int16_t CAMERA_ROTATION_270 = 270;
102 const int32_t INVALID_MODE = 0;
103 const int32_t VALID_CALLID = 1;
104 const int32_t ERROR_CALLID = -1;
105 const int32_t ONE_TIME = 1;
106 const int32_t STEP_1 = 1;
107 const int32_t SOURCE_CALL = 2;
108 const int32_t FIVE_SECOND = 5;
109 constexpr int16_t DEFAULT_TIME = 0;
110 constexpr const char *TEST_STR = "123";
111 constexpr const char *LONG_STR =
112 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
113 "111111111";
114 static constexpr const char *OHOS_PERMISSION_SET_TELEPHONY_STATE = "ohos.permission.SET_TELEPHONY_STATE";
115 static constexpr const char *OHOS_PERMISSION_PLACE_CALL = "ohos.permission.PLACE_CALL";
116 } // namespace
117
118 class DemoHandler : public AppExecFwk::EventHandler {
119 public:
DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> & eventRunner)120 explicit DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> &eventRunner) : AppExecFwk::EventHandler(eventRunner)
121 {}
~DemoHandler()122 virtual ~DemoHandler() {}
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)123 void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) {}
124 };
125
126 class ZeroBranch8Test : public testing::Test {
127 public:
128 void SetUp();
129 void TearDown();
130 void InitDialInfo(int32_t accountId, int32_t videoState, int32_t dialScene, int32_t dialType);
131 static void SetUpTestCase();
132 static void TearDownTestCase();
133 public:
134 AppExecFwk::PacMap dialInfo_;
135 };
136
SetUp()137 void ZeroBranch8Test::SetUp() {}
138
TearDown()139 void ZeroBranch8Test::TearDown() {}
140
SetUpTestCase()141 void ZeroBranch8Test::SetUpTestCase()
142 {
143 constexpr int permissionNum = 1;
144 const char *perms[permissionNum] = {
145 "ohos.permission.GET_TELEPHONY_STATE"
146 };
147 NativeTokenInfoParams infoInstance = {
148 .dcapsNum = 0, // Indicates the capsbility list of the sa.
149 .permsNum = permissionNum,
150 .aclsNum = 0, // acls is the list of rights thar can be escalated.
151 .dcaps = nullptr,
152 .perms = perms,
153 .acls = nullptr,
154 .processName = "ZeroBranch8Test",
155 .aplStr = "system_basic",
156 };
157 uint64_t tokenId = GetAccessTokenId(&infoInstance);
158 SetSelfTokenID(tokenId);
159 auto result = Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
160 EXPECT_EQ(result, Security::AccessToken::RET_SUCCESS);
161 }
162
TearDownTestCase()163 void ZeroBranch8Test::TearDownTestCase()
164 {
165 std::this_thread::sleep_for(std::chrono::seconds(FIVE_SECOND));
166 }
167
InitDialInfo(int32_t accountId,int32_t videoState,int32_t dialScene,int32_t dialType)168 void ZeroBranch8Test::InitDialInfo(int32_t accountId, int32_t videoState, int32_t dialScene, int32_t dialType)
169 {
170 dialInfo_.PutIntValue("accountId", accountId);
171 dialInfo_.PutIntValue("videoState", videoState);
172 dialInfo_.PutIntValue("dialScene", dialScene);
173 dialInfo_.PutIntValue("dialType", dialType);
174 }
175
176 HWTEST_F(ZeroBranch8Test, Telephony_CallPolicy_001, Function | MediumTest | Level1)
177 {
178 AccessToken token;
179 CallPolicy mCallPolicy;
180 std::u16string testEmptyStr = u"";
181 AppExecFwk::PacMap mPacMap;
182 mPacMap.PutIntValue("dialType", static_cast<int32_t>(DialType::DIAL_OTT_TYPE));
183 mPacMap.PutIntValue("callType", static_cast<int32_t>(CallType::TYPE_BLUETOOTH));
184 mPacMap.PutIntValue("dialType", static_cast<int32_t>(DialType::DIAL_CARRIER_TYPE));
185 mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true);
186 mPacMap.PutIntValue("callType", static_cast<int32_t>(CallType::TYPE_CS));
187 mPacMap.PutIntValue("dialScene", 3);
188 mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true);
189 mPacMap.PutIntValue("dialScene", static_cast<int32_t>(DialScene::CALL_EMERGENCY));
190 mPacMap.PutIntValue("videoState", static_cast<int32_t>(VideoStateType::TYPE_VOICE));
191 mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true);
192 mPacMap.PutIntValue("videoState", static_cast<int32_t>(VideoStateType::TYPE_SEND_ONLY));
193 mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true);
194 mPacMap.PutIntValue("dialType", -1);
195 EXPECT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_ARGUMENT_INVALID);
196 }
197
198 HWTEST_F(ZeroBranch8Test, Telephony_CallManagerService_001, Function | MediumTest | Level1)
199 {
200 AccessToken token;
201 auto callManagerService = new CallManagerService();
202 callManagerService->state_ = CallManagerService::ServiceRunningState::STATE_RUNNING;
203 callManagerService->OnStart();
204 callManagerService->Init();
205 std::string deviceId("123");
206 int32_t systemAbilityId = 100;
207 std::u16string test = u"";
208 callManagerService->OnAddSystemAbility(systemAbilityId, deviceId);
209 EXPECT_NE(systemAbilityId, AUDIO_POLICY_SERVICE_ID);
210 std::string eventName = "EVENT_INVALID_VIDEO_FD";
211 int32_t callId = 0;
212 EXPECT_EQ(callManagerService->SendCallUiEvent(callId, eventName), TELEPHONY_SUCCESS);
213 DialParaInfo info;
214 sptr<CallBase> ringingCall = new IMSCall(info);
215 ringingCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
216 CallObjectManager::AddOneCallObject(ringingCall);
217 EXPECT_EQ(callManagerService->SendCallUiEvent(callId, eventName), TELEPHONY_SUCCESS);
218 int32_t slotId = 0;
219 EXPECT_NE(callManagerService->CloseUnFinishedUssd(slotId), TELEPHONY_ERR_LOCAL_PTR_NULL);
220 EXPECT_NE(callManagerService->SetVoIPCallState(0), TELEPHONY_ERR_LOCAL_PTR_NULL);
221 EXPECT_TRUE(TelephonyPermission::CheckCallerIsSystemApp());
222 EXPECT_TRUE(TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE));
223 eventName = "ABC";
224 EXPECT_EQ(callManagerService->SendCallUiEvent(callId, eventName), TELEPHONY_SUCCESS);
225 callManagerService->dealCeliaCallEvent(1);
226 std::string number = "123456";
227 EXPECT_NE(callManagerService->MakeCall(number), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
228 EXPECT_TRUE(TelephonyPermission::CheckCallerIsSystemApp());
229 EXPECT_TRUE(TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE));
230 if (TelephonyPermission::CheckCallerIsSystemApp() && TelephonyPermission::CheckPermission(
231 OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
232 std::string content = "1";
233 EXPECT_EQ(callManagerService->SendUssdResponse(slotId, content), TELEPHONY_SUCCESS);
234 }
235 }
236
237 HWTEST_F(ZeroBranch8Test, Telephony_CallManagerService_002, TestSize.Level0)
238 {
239 AccessToken token;
240 std::u16string test = u"";
241 std::string testStr = "";
242 bool enabled;
243 auto callManagerService = new CallManagerService();
244 callManagerService->OnStart();
245 EXPECT_NE(callManagerService->callControlManagerPtr_, nullptr);
246 EXPECT_NE(callManagerService->DialCall(test, dialInfo_), TELEPHONY_ERR_PERMISSION_ERR);
247 EXPECT_NE(callManagerService->AnswerCall(0, 0), TELEPHONY_ERR_PERMISSION_ERR);
248 EXPECT_NE(callManagerService->RejectCall(0, false, test), TELEPHONY_ERR_PERMISSION_ERR);
249 EXPECT_NE(callManagerService->HangUpCall(0), TELEPHONY_ERR_PERMISSION_ERR);
250 EXPECT_NE(callManagerService->GetCallState(), TELEPHONY_ERR_LOCAL_PTR_NULL);
251 EXPECT_NE(callManagerService->HoldCall(0), TELEPHONY_ERR_PERMISSION_ERR);
252 EXPECT_NE(callManagerService->SwitchCall(0), TELEPHONY_ERR_PERMISSION_ERR);
253 EXPECT_FALSE(callManagerService->HasCall());
254 EXPECT_FALSE(callManagerService->HasCall(false));
255 EXPECT_FALSE(callManagerService->HasCall(true));
256 EXPECT_NE(callManagerService->IsNewCallAllowed(enabled), TELEPHONY_ERR_LOCAL_PTR_NULL);
257 EXPECT_NE(callManagerService->IsRinging(enabled), TELEPHONY_ERR_PERMISSION_ERR);
258 EXPECT_NE(callManagerService->IsInEmergencyCall(enabled), TELEPHONY_ERR_LOCAL_PTR_NULL);
259 EXPECT_NE(callManagerService->StartDtmf(0, 'a'), TELEPHONY_ERR_LOCAL_PTR_NULL);
260 EXPECT_NE(callManagerService->StopDtmf(0), TELEPHONY_ERR_LOCAL_PTR_NULL);
261 EXPECT_NE(callManagerService->callControlManagerPtr_, nullptr);
262 EXPECT_NE(callManagerService->GetCallWaiting(0), TELEPHONY_ERR_PERMISSION_ERR);
263 EXPECT_NE(callManagerService->SetCallWaiting(0, false), TELEPHONY_ERR_PERMISSION_ERR);
264 EXPECT_NE(callManagerService->GetCallRestriction(0, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
265 TELEPHONY_ERR_LOCAL_PTR_NULL);
266 CallRestrictionInfo callRestrictionInfo;
267 EXPECT_NE(callManagerService->SetCallRestriction(0, callRestrictionInfo), TELEPHONY_ERR_LOCAL_PTR_NULL);
268 EXPECT_NE(
269 callManagerService->SetCallRestrictionPassword(0, CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS, "11", "22"),
270 TELEPHONY_ERR_LOCAL_PTR_NULL);
271 EXPECT_NE(
272 callManagerService->GetCallTransferInfo(0, CallTransferType::TRANSFER_TYPE_UNCONDITIONAL),
273 TELEPHONY_ERR_LOCAL_PTR_NULL);
274 }
275
276 /**
277 * @tc.number Telephony_CallManagerService_003
278 * @tc.name test error nullptr branch with permission
279 * @tc.desc Function test
280 */
281 HWTEST_F(ZeroBranch8Test, Telephony_CallManagerService_003, TestSize.Level0)
282 {
283 AccessToken token;
284 float zoomRatio = 1;
285 std::u16string test = u"";
286 std::string testStr = "";
287 int32_t callId = 1;
288 int32_t value = 1;
289 bool enabled;
290 auto callManagerService = new CallManagerService();
291 callManagerService->OnStart();
292 EXPECT_NE(callManagerService->callControlManagerPtr_, nullptr);
293 EXPECT_TRUE(TelephonyPermission::CheckCallerIsSystemApp());
294 EXPECT_TRUE(TelephonyPermission::CheckPermission(OHOS_PERMISSION_PLACE_CALL));
295 EXPECT_NE(callManagerService->SetCameraZoom(zoomRatio), TELEPHONY_ERR_LOCAL_PTR_NULL);
296 EXPECT_NE(callManagerService->SetPausePicture(callId, test), TELEPHONY_ERR_LOCAL_PTR_NULL);
297 EXPECT_NE(callManagerService->SetDeviceDirection(callId, value), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
298 EXPECT_NE(callManagerService->CancelCallUpgrade(callId), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
299 EXPECT_NE(callManagerService->RequestCameraCapabilities(callId), TELEPHONY_ERR_PERMISSION_ERR);
300 EXPECT_NE(callManagerService->IsEmergencyPhoneNumber(test, 0, enabled), TELEPHONY_ERR_LOCAL_PTR_NULL);
301 EXPECT_NE(callManagerService->FormatPhoneNumber(test, test, test), TELEPHONY_ERR_LOCAL_PTR_NULL);
302 EXPECT_NE(callManagerService->FormatPhoneNumberToE164(test, test, test), TELEPHONY_ERR_LOCAL_PTR_NULL);
303 EXPECT_NE(callManagerService->GetMainCallId(value, value), TELEPHONY_ERR_PERMISSION_ERR);
304 std::vector<std::u16string> callIdList;
305 EXPECT_NE(callManagerService->GetSubCallIdList(0, callIdList), TELEPHONY_ERR_LOCAL_PTR_NULL);
306 EXPECT_NE(callManagerService->GetCallIdListForConference(0, callIdList), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
307 EXPECT_NE(callManagerService->GetImsConfig(0, ImsConfigItem::ITEM_VIDEO_QUALITY), TELEPHONY_ERR_LOCAL_PTR_NULL);
308 EXPECT_NE(callManagerService->SetImsConfig(0, ImsConfigItem::ITEM_VIDEO_QUALITY, test),
309 TELEPHONY_ERR_LOCAL_PTR_NULL);
310 EXPECT_NE(callManagerService->GetImsFeatureValue(0, FeatureType::TYPE_VOICE_OVER_LTE),
311 TELEPHONY_ERR_LOCAL_PTR_NULL);
312 EXPECT_NE(callManagerService->SetImsFeatureValue(0, FeatureType::TYPE_VOICE_OVER_LTE, 0),
313 TELEPHONY_ERR_LOCAL_PTR_NULL);
314 EXPECT_NE(callManagerService->UpdateImsCallMode(0, ImsCallMode::CALL_MODE_AUDIO_ONLY),
315 TELEPHONY_ERR_LOCAL_PTR_NULL);
316 EXPECT_NE(callManagerService->EnableImsSwitch(false), TELEPHONY_ERR_LOCAL_PTR_NULL);
317 EXPECT_NE(callManagerService->DisableImsSwitch(false), TELEPHONY_ERR_LOCAL_PTR_NULL);
318 EXPECT_NE(callManagerService->IsImsSwitchEnabled(0, enabled), TELEPHONY_ERR_LOCAL_PTR_NULL);
319 EXPECT_NE(callManagerService->SetVoNRState(0, value), TELEPHONY_ERR_LOCAL_PTR_NULL);
320 EXPECT_NE(callManagerService->GetVoNRState(0, value), TELEPHONY_ERR_LOCAL_PTR_NULL);
321 std::vector<std::u16string> numberList;
322 EXPECT_NE(callManagerService->JoinConference(false, numberList), TELEPHONY_ERR_LOCAL_PTR_NULL);
323 AudioDevice audioDevice = {
324 .deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO,
325 .address = { 0 },
326 };
327 EXPECT_NE(callManagerService->SetAudioDevice(audioDevice), TELEPHONY_ERR_LOCAL_PTR_NULL);
328 EXPECT_NE(callManagerService->ControlCamera(1, test), TELEPHONY_ERR_LOCAL_PTR_NULL);
329 EXPECT_NE(callManagerService->SetPreviewWindow(1, testStr, nullptr), TELEPHONY_ERR_LOCAL_PTR_NULL);
330 EXPECT_NE(callManagerService->SetDisplayWindow(1, testStr, nullptr), TELEPHONY_ERR_LOCAL_PTR_NULL);
331 std::string testStr_ = "123";
332 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
333 callManagerService->SetPreviewWindow(0, testStr, surface);
334 }
335
336 /**
337 * @tc.number Telephony_CallManagerService_004
338 * @tc.name test error nullptr branch with permission
339 * @tc.desc Function test
340 */
341 HWTEST_F(ZeroBranch8Test, Telephony_CallManagerService_004, TestSize.Level0)
342 {
343 AccessFalseToken token;
344 std::u16string test = u"";
345 std::string testStr = "";
346 bool enabled;
347 auto callManagerService = new CallManagerService();
348 EXPECT_FALSE(TelephonyPermission::CheckCallerIsSystemApp());
349 EXPECT_EQ(callManagerService->DialCall(test, dialInfo_), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
350 EXPECT_EQ(callManagerService->AnswerCall(0, 0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
351 EXPECT_EQ(callManagerService->RejectCall(0, false, test), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
352 EXPECT_EQ(callManagerService->HangUpCall(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
353 EXPECT_EQ(callManagerService->HoldCall(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
354 EXPECT_EQ(callManagerService->UnHoldCall(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
355 EXPECT_EQ(callManagerService->SwitchCall(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
356 EXPECT_EQ(callManagerService->IsNewCallAllowed(enabled), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
357 EXPECT_EQ(callManagerService->IsRinging(enabled), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
358 EXPECT_EQ(callManagerService->IsInEmergencyCall(enabled), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
359 EXPECT_EQ(callManagerService->StartDtmf(0, 'a'), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
360 EXPECT_EQ(callManagerService->StopDtmf(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
361 EXPECT_EQ(callManagerService->GetCallWaiting(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
362 EXPECT_EQ(callManagerService->SetCallWaiting(0, false), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
363 EXPECT_EQ(callManagerService->GetCallRestriction(0, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
364 TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
365 CallRestrictionInfo callRestrictionInfo;
366 EXPECT_EQ(callManagerService->SetCallRestriction(0, callRestrictionInfo), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
367 EXPECT_EQ(
368 callManagerService->SetCallRestrictionPassword(0, CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS, "11", "22"),
369 TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
370 EXPECT_EQ(
371 callManagerService->GetCallTransferInfo(0, CallTransferType::TRANSFER_TYPE_UNCONDITIONAL),
372 TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
373 CallTransferInfo callTransferInfo;
374 EXPECT_EQ(callManagerService->SetCallTransferInfo(0, callTransferInfo), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
375 EXPECT_EQ(callManagerService->CanSetCallTransferTime(0, enabled), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
376 EXPECT_EQ(callManagerService->CombineConference(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
377 EXPECT_EQ(callManagerService->SeparateConference(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
378 EXPECT_EQ(callManagerService->KickOutFromConference(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
379 EXPECT_EQ(callManagerService->SetMuted(false), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
380 EXPECT_EQ(callManagerService->MuteRinger(), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
381 AudioDevice audioDevice = {
382 .deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO,
383 .address = { 0 },
384 };
385 EXPECT_EQ(callManagerService->SetAudioDevice(audioDevice), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
386 EXPECT_EQ(callManagerService->ControlCamera(1, test), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
387 EXPECT_EQ(callManagerService->SetPreviewWindow(1, testStr, nullptr), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
388 EXPECT_EQ(callManagerService->SetDisplayWindow(1, testStr, nullptr), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
389 }
390
391 /**
392 * @tc.number Telephony_CallManagerService_005
393 * @tc.name test error nullptr branch with permission
394 * @tc.desc Function test
395 */
396 HWTEST_F(ZeroBranch8Test, Telephony_CallManagerService_005, TestSize.Level0)
397 {
398 AccessFalseToken token;
399 float zoomRatio = 1;
400 std::u16string test = u"";
401 int32_t callId = 1;
402 int32_t value = 1;
403 bool enabled;
404 auto callManagerService = new CallManagerService();
405 EXPECT_FALSE(TelephonyPermission::CheckCallerIsSystemApp());
406 EXPECT_EQ(callManagerService->SetPausePicture(callId, test), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
407 EXPECT_EQ(callManagerService->SetDeviceDirection(callId, value), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
408 EXPECT_EQ(callManagerService->CancelCallUpgrade(callId), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
409 EXPECT_EQ(callManagerService->RequestCameraCapabilities(callId), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
410 EXPECT_EQ(callManagerService->GetMainCallId(value, value), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
411 std::vector<std::u16string> callIdList;
412 EXPECT_EQ(callManagerService->GetSubCallIdList(0, callIdList), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
413 EXPECT_EQ(callManagerService->GetCallIdListForConference(0, callIdList), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
414 EXPECT_EQ(callManagerService->UpdateImsCallMode(0, ImsCallMode::CALL_MODE_AUDIO_ONLY),
415 TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
416 EXPECT_EQ(callManagerService->EnableImsSwitch(false), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
417 EXPECT_EQ(callManagerService->DisableImsSwitch(false), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
418 EXPECT_EQ(callManagerService->IsImsSwitchEnabled(0, enabled), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
419 EXPECT_EQ(callManagerService->SetVoNRState(0, value), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
420 EXPECT_EQ(callManagerService->GetVoNRState(0, value), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
421 std::vector<std::u16string> numberList;
422 EXPECT_EQ(callManagerService->JoinConference(false, numberList), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
423 std::string number = "123456";
424 EXPECT_EQ(callManagerService->MakeCall(number), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
425 int32_t slotId = 0;
426 std::string content = "1";
427 EXPECT_EQ(callManagerService->SendUssdResponse(slotId, content), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
428 }
429
430 HWTEST_F(ZeroBranch8Test, Telephony_BluetoothCallService_001, TestSize.Level0)
431 {
432 AccessToken token;
433 BluetoothCallService bluetoothCallService;
434 EXPECT_NE(bluetoothCallService.HangUpCall(), TELEPHONY_SUCCESS);
435 EXPECT_NE(bluetoothCallService.HoldCall(), TELEPHONY_SUCCESS);
436 EXPECT_NE(bluetoothCallService.UnHoldCall(), TELEPHONY_SUCCESS);
437 EXPECT_NE(bluetoothCallService.SwitchCall(), TELEPHONY_SUCCESS);
438 EXPECT_NE(bluetoothCallService.CombineConference(), TELEPHONY_SUCCESS);
439 EXPECT_NE(bluetoothCallService.SeparateConference(), TELEPHONY_SUCCESS);
440 EXPECT_NE(bluetoothCallService.KickOutFromConference(), TELEPHONY_SUCCESS);
441 }
442
443 HWTEST_F(ZeroBranch8Test, Telephony_BluetoothCallService_002, TestSize.Level1)
444 {
445 AccessToken token;
446 BluetoothCallService bluetoothCallService;
447 bluetoothCallService.callControlManagerPtr_ = DelayedSingleton<CallControlManager>::GetInstance();
448 EXPECT_NE(bluetoothCallService.SeparateConference(), TELEPHONY_ERR_LOCAL_PTR_NULL);
449 EXPECT_NE(bluetoothCallService.KickOutFromConference(), TELEPHONY_ERR_LOCAL_PTR_NULL);
450 }
451
452 HWTEST_F(ZeroBranch8Test, Telephony_CallSettingManager_001, TestSize.Level0)
453 {
454 std::shared_ptr<CallSettingManager> callSettingManager = std::make_shared<CallSettingManager>();
455 callSettingManager->cellularCallConnectionPtr_ = nullptr;
456 EXPECT_EQ(callSettingManager->GetCallRestriction(SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
457 TELEPHONY_ERR_LOCAL_PTR_NULL);
458 CallRestrictionInfo callRestrictionInfo = {
459 .password = "",
460 .fac = CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING,
461 .mode = CallRestrictionMode::RESTRICTION_MODE_DEACTIVATION,
462 };
463 EXPECT_EQ(callSettingManager->SetCallRestriction(SIM1_SLOTID, callRestrictionInfo), TELEPHONY_ERR_LOCAL_PTR_NULL);
464 CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING;
465 const char oldPassword[kMaxNumberLen + 1] = "1111";
466 const char newPassword[kMaxNumberLen + 1] = "2222";
467 EXPECT_EQ(callSettingManager->SetCallRestrictionPassword(INVALID_SLOTID, fac, oldPassword, newPassword),
468 CALL_ERR_INVALID_SLOT_ID);
469 EXPECT_EQ(callSettingManager->SetCallRestrictionPassword(SIM1_SLOTID, fac, oldPassword, newPassword),
470 TELEPHONY_ERR_LOCAL_PTR_NULL);
471 CallTransferType type = CallTransferType::TRANSFER_TYPE_UNCONDITIONAL;
472 EXPECT_EQ(callSettingManager->GetCallTransferInfo(INVALID_SLOTID, type), CALL_ERR_INVALID_SLOT_ID);
473 EXPECT_EQ(callSettingManager->GetCallTransferInfo(SIM1_SLOTID, type), TELEPHONY_ERR_LOCAL_PTR_NULL);
474 CallTransferInfo callTransferInfo = {
475 .transferNum = "",
476 .settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE,
477 .type = CallTransferType::TRANSFER_TYPE_BUSY,
478 .startHour = 1,
479 .startMinute = 1,
480 .endHour = 1,
481 .endMinute = 1,
482 };
483 EXPECT_EQ(callSettingManager->SetCallTransferInfo(SIM1_SLOTID, callTransferInfo), TELEPHONY_ERR_LOCAL_PTR_NULL);
484 bool result = false;
485 EXPECT_EQ(callSettingManager->CanSetCallTransferTime(SIM1_SLOTID, result), TELEPHONY_ERR_LOCAL_PTR_NULL);
486 int32_t featureValue = 0;
487 EXPECT_EQ(callSettingManager->SetImsFeatureValue(SIM1_SLOTID, FeatureType::TYPE_VOICE_OVER_LTE, featureValue),
488 TELEPHONY_ERR_LOCAL_PTR_NULL);
489 EXPECT_EQ(callSettingManager->EnableImsSwitch(SIM1_SLOTID), TELEPHONY_ERR_LOCAL_PTR_NULL);
490 EXPECT_EQ(callSettingManager->DisableImsSwitch(SIM1_SLOTID), TELEPHONY_ERR_LOCAL_PTR_NULL);
491 bool enabled = false;
492 EXPECT_EQ(callSettingManager->IsImsSwitchEnabled(SIM1_SLOTID, enabled), TELEPHONY_ERR_LOCAL_PTR_NULL);
493 int32_t state = 0;
494 EXPECT_EQ(callSettingManager->SetVoNRState(SIM1_SLOTID, state), TELEPHONY_ERR_LOCAL_PTR_NULL);
495 EXPECT_EQ(callSettingManager->GetVoNRState(SIM1_SLOTID, state), TELEPHONY_ERR_LOCAL_PTR_NULL);
496 EXPECT_EQ(callSettingManager->CloseUnFinishedUssd(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
497 EXPECT_EQ(callSettingManager->CloseUnFinishedUssd(SIM1_SLOTID), TELEPHONY_ERR_LOCAL_PTR_NULL);
498 }
499
500 HWTEST_F(ZeroBranch8Test, Telephony_CallSettingManager_002, TestSize.Level0)
501 {
502 std::shared_ptr<CallSettingManager> callSettingManager = std::make_shared<CallSettingManager>();
503 CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING;
504 const char oldPassword[kMaxNumberLen + 1] = "1111";
505 const char newPassword[kMaxNumberLen + 1] = "2222";
506 EXPECT_NE(callSettingManager->SetCallRestrictionPassword(SIM1_SLOTID, fac, oldPassword, newPassword),
507 TELEPHONY_ERR_LOCAL_PTR_NULL);
508 int32_t state = 0;
509 EXPECT_NE(callSettingManager->SetVoNRState(SIM1_SLOTID, state), TELEPHONY_ERR_LOCAL_PTR_NULL);
510 EXPECT_NE(callSettingManager->GetVoNRState(SIM1_SLOTID, state), TELEPHONY_ERR_LOCAL_PTR_NULL);
511 }
512
513 HWTEST_F(ZeroBranch8Test, Telephony_CallRequestHandler_001, Function | MediumTest | Level1)
514 {
515 std::unique_ptr<CallRequestHandler> callRequestHandler = std::make_unique<CallRequestHandler>();
516 callRequestHandler->Init();
517 EXPECT_NE(callRequestHandler->DialCall(), TELEPHONY_ERR_LOCAL_PTR_NULL);
518 EXPECT_NE(callRequestHandler->AnswerCall(1, 1), TELEPHONY_ERR_LOCAL_PTR_NULL);
519 std::string content = "";
520 EXPECT_NE(callRequestHandler->RejectCall(1, true, content), TELEPHONY_ERR_LOCAL_PTR_NULL);
521 EXPECT_NE(callRequestHandler->HangUpCall(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
522 EXPECT_NE(callRequestHandler->HoldCall(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
523 EXPECT_NE(callRequestHandler->UnHoldCall(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
524 EXPECT_NE(callRequestHandler->SwitchCall(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
525 EXPECT_NE(callRequestHandler->CombineConference(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
526 EXPECT_NE(callRequestHandler->SeparateConference(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
527 EXPECT_NE(callRequestHandler->KickOutFromConference(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
528 std::u16string test = u"";
529 EXPECT_NE(callRequestHandler->StartRtt(1, test), TELEPHONY_ERR_LOCAL_PTR_NULL);
530 EXPECT_NE(callRequestHandler->StopRtt(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
531 std::vector<std::string> emptyRecords = {};
532 EXPECT_NE(callRequestHandler->JoinConference(1, emptyRecords), TELEPHONY_ERR_LOCAL_PTR_NULL);
533 }
534
535 HWTEST_F(ZeroBranch8Test, Telephony_CallManagerClient_001, Function | MediumTest | Level1)
536 {
537 std::u16string test = u"";
538 int32_t callId = 1;
539 int32_t systemAbilityId = 1;
540 std::shared_ptr<CallManagerClient> callManagerClient = std::make_shared<CallManagerClient>();
541 callManagerClient->Init(systemAbilityId);
542 EXPECT_NE(callManagerClient->ObserverOnCallDetailsChange(), TELEPHONY_ERR_UNINIT);
543 std::string number = "12345678";
544 EXPECT_NE(callManagerClient->MakeCall(number), TELEPHONY_ERR_UNINIT);
545 EXPECT_NE(callManagerClient->UnRegisterVoipCallManagerCallback(), TELEPHONY_ERR_UNINIT);
546 bool result = false;
547 EXPECT_NE(callManagerClient->CanSetCallTransferTime(SIM1_SLOTID, result), TELEPHONY_ERR_UNINIT);
548 EXPECT_NE(callManagerClient->IsRinging(result), TELEPHONY_ERR_UNINIT);
549 EXPECT_NE(callManagerClient->IsNewCallAllowed(result), TELEPHONY_ERR_UNINIT);
550 float zoomRatio = 1.0;
551 EXPECT_NE(callManagerClient->SetCameraZoom(zoomRatio), TELEPHONY_ERR_UNINIT);
552 EXPECT_NE(callManagerClient->SetPausePicture(callId, test), TELEPHONY_ERR_UNINIT);
553 EXPECT_NE(callManagerClient->GetImsConfig(SIM1_SLOTID, ImsConfigItem::ITEM_IMS_SWITCH_STATUS),
554 TELEPHONY_ERR_UNINIT);
555 EXPECT_NE(callManagerClient->SetImsConfig(SIM1_SLOTID, ImsConfigItem::ITEM_IMS_SWITCH_STATUS, test),
556 TELEPHONY_ERR_UNINIT);
557 EXPECT_NE(callManagerClient->GetImsFeatureValue(SIM1_SLOTID, FeatureType::TYPE_SS_OVER_UT), TELEPHONY_ERR_UNINIT);
558 int32_t value = 0;
559 EXPECT_NE(callManagerClient->SetImsFeatureValue(SIM1_SLOTID, FeatureType::TYPE_SS_OVER_UT, value),
560 TELEPHONY_ERR_UNINIT);
561 EXPECT_NE(callManagerClient->UpdateImsCallMode(callId, ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_ERR_UNINIT);
562 EXPECT_NE(callManagerClient->StartRtt(callId, test), TELEPHONY_ERR_UNINIT);
563 EXPECT_NE(callManagerClient->StopRtt(callId), TELEPHONY_ERR_UNINIT);
564 EXPECT_NE(callManagerClient->CancelCallUpgrade(callId), TELEPHONY_ERR_UNINIT);
565 EXPECT_NE(callManagerClient->RequestCameraCapabilities(callId), TELEPHONY_ERR_UNINIT);
566 std::string eventName = "abc";
567 EXPECT_NE(callManagerClient->SendCallUiEvent(callId, eventName), TELEPHONY_ERR_UNINIT);
568 EXPECT_EQ(callManagerClient->RegisterBluetoothCallManagerCallbackPtr(eventName), nullptr);
569 int32_t slotId = 0;
570 std::string content = "1";
571 EXPECT_NE(callManagerClient->SendUssdResponse(slotId, content), TELEPHONY_ERR_UNINIT);
572 std::vector<std::string> dialingList;
573 std::vector<std::string> incomingList;
574 EXPECT_NE(callManagerClient->SetCallPolicyInfo(false, dialingList, false, incomingList), TELEPHONY_ERR_UNINIT);
575 }
576
577 HWTEST_F(ZeroBranch8Test, Telephony_CallStatusCallback_001, Function | MediumTest | Level1)
578 {
579 auto callStatusCallback = std::make_shared<CallStatusCallback>();
580 CallReportInfo callReportInfo;
581 callReportInfo.callType = CallType::TYPE_VOIP;
582 EXPECT_EQ(callStatusCallback->UpdateCallReportInfo(callReportInfo), TELEPHONY_SUCCESS);
583 CallsReportInfo info;
584 callReportInfo.state = TelCallState::CALL_STATUS_INCOMING;
585 info.callVec.push_back(callReportInfo);
586 EXPECT_EQ(callStatusCallback->UpdateCallsReportInfo(info), TELEPHONY_SUCCESS);
587 }
588
589 HWTEST_F(ZeroBranch8Test, Telephony_VoipCallConnection_001, Function | MediumTest | Level1)
590 {
591 std::shared_ptr<VoipCallConnection> voipCallConnection = std::make_shared<VoipCallConnection>();
592 voipCallConnection->Init(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
593 EXPECT_NE(voipCallConnection->voipCallManagerInterfacePtr_, nullptr);
594 EXPECT_EQ(voipCallConnection->GetCallManagerProxy(), TELEPHONY_SUCCESS);
595 EXPECT_TRUE(voipCallConnection->connectCallManagerState_);
596 voipCallConnection->Init(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
597 VoipCallEventInfo voipCallEventInfo;
598 voipCallEventInfo.voipCallId = "123";
599 EXPECT_NE(voipCallConnection->AnswerCall(voipCallEventInfo, static_cast<int32_t>(VideoStateType::TYPE_VOICE)),
600 TELEPHONY_ERROR);
601 EXPECT_NE(voipCallConnection->RejectCall(voipCallEventInfo), TELEPHONY_ERROR);
602 EXPECT_NE(voipCallConnection->HangUpCall(voipCallEventInfo), TELEPHONY_ERROR);
603 sptr<ICallStatusCallback> callStatusCallback = nullptr;
604 EXPECT_NE(voipCallConnection->RegisterCallManagerCallBack(callStatusCallback), TELEPHONY_ERROR);
605 EXPECT_NE(voipCallConnection->UnRegisterCallManagerCallBack(), TELEPHONY_ERROR);
606 CallAudioEvent callAudioEvent = CallAudioEvent::AUDIO_EVENT_MUTED;
607 std::string voipCallId = "123";
608 EXPECT_NE(voipCallConnection->SendCallUiEvent(voipCallId, callAudioEvent), TELEPHONY_ERROR);
609 AppExecFwk::PacMap extras;
610 voipCallConnection->SendCallUiEventForWindow(extras);
611 voipCallConnection->voipCallManagerInterfacePtr_ = nullptr;
612 int32_t systemAbilityId = 1;
613 voipCallConnection->Init(systemAbilityId);
614 voipCallConnection->SendCallUiEventForWindow(extras);
615 voipCallConnection->ClearVoipCall();
616 }
617
618 HWTEST_F(ZeroBranch8Test, Telephony_CallSuperPrivacyControlManager_001, Function | MediumTest | Level1)
619 {
620 int32_t callId = 0;
621 int32_t videoState = 0;
622 std::u16string phoneNumber = u"";
623 int32_t accountId = 1;
624 int32_t dialType = 0;
625 int32_t dialScene = 0;
626 int32_t callType = 0;
627 auto controlManager = DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance();
628 controlManager->RestoreSuperPrivacyMode();
629 EXPECT_FALSE(controlManager->GetIsChangeSuperPrivacyMode());
630 controlManager->SetIsChangeSuperPrivacyMode(true);
631 controlManager->RestoreSuperPrivacyMode();
632 EXPECT_TRUE(controlManager->GetIsChangeSuperPrivacyMode());
633 controlManager->CloseAnswerSuperPrivacyMode(callId, videoState);
634 controlManager->CloseCallSuperPrivacyMode(phoneNumber, accountId, videoState, dialType, dialScene, callType);
635 }
636 } // namespace Telephony
637 } // namespace OHOS
638