1 /*
2 * Copyright (C) 2021-2022 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 "cellular_call_connection_ims.h"
17
18 #include "cellular_call_hisysevent.h"
19 #include "cellular_call_service.h"
20 #include "ims_call_client.h"
21 #include "radio_event.h"
22 #include "securec.h"
23 #include "standardize_utils.h"
24
25 namespace OHOS {
26 namespace Telephony {
DialRequest(int32_t slotId,const ImsDialInfoStruct & dialRequest)27 int32_t CellularCallConnectionIMS::DialRequest(int32_t slotId, const ImsDialInfoStruct &dialRequest)
28 {
29 TELEPHONY_LOGI("call ims service");
30 ImsCallInfo callInfo;
31 if (memset_s(&callInfo, sizeof(callInfo), 0, sizeof(callInfo)) != EOK) {
32 TELEPHONY_LOGE("return, memset_s error.");
33 CellularCallHiSysEvent::WriteDialCallFaultEvent(
34 slotId, INVALID_PARAMETER, dialRequest.videoState, TELEPHONY_ERR_MEMSET_FAIL, "memset_s error");
35 return TELEPHONY_ERR_MEMSET_FAIL;
36 }
37 UpdateCallNumber(dialRequest.phoneNum);
38 size_t cpyLen = strlen(phoneNumber_.c_str()) + 1;
39 if (cpyLen > static_cast<size_t>(kMaxNumberLength)) {
40 phoneNumber_.clear();
41 return TELEPHONY_ERR_STRCPY_FAIL;
42 }
43 if (strcpy_s(callInfo.phoneNum, cpyLen, phoneNumber_.c_str()) != EOK) {
44 TELEPHONY_LOGE("return, strcpy_s fail.");
45 phoneNumber_.clear();
46 CellularCallHiSysEvent::WriteDialCallFaultEvent(
47 slotId, INVALID_PARAMETER, dialRequest.videoState, TELEPHONY_ERR_STRCPY_FAIL, "strcpy_s fail");
48 return TELEPHONY_ERR_STRCPY_FAIL;
49 }
50 phoneNumber_.clear();
51 callInfo.videoState = dialRequest.videoState;
52 callInfo.slotId = slotId;
53 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
54 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
55 CellularCallHiSysEvent::WriteDialCallFaultEvent(slotId, INVALID_PARAMETER, dialRequest.videoState,
56 CALL_ERR_RESOURCE_UNAVAILABLE, "ims vendor service does not exist");
57 return CALL_ERR_RESOURCE_UNAVAILABLE;
58 }
59 return DelayedSingleton<ImsCallClient>::GetInstance()->Dial(callInfo, dialRequest.clirMode);
60 }
61
HangUpRequest(int32_t slotId,const std::string & phoneNum,int32_t index)62 int32_t CellularCallConnectionIMS::HangUpRequest(int32_t slotId, const std::string &phoneNum, int32_t index)
63 {
64 if (moduleUtils_.NeedCallImsService()) {
65 TELEPHONY_LOGI("call ims service");
66 ImsCallInfo hangUpCallInfo;
67 if (memset_s(&hangUpCallInfo, sizeof(hangUpCallInfo), 0, sizeof(hangUpCallInfo)) != EOK) {
68 TELEPHONY_LOGE("return, memset_s error.");
69 return TELEPHONY_ERR_MEMSET_FAIL;
70 }
71 if (static_cast<int32_t>(phoneNum.length() + 1) > kMaxNumberLength) {
72 return TELEPHONY_ERR_STRCPY_FAIL;
73 }
74 if (strcpy_s(hangUpCallInfo.phoneNum, strlen(phoneNum.c_str()) + 1, phoneNum.c_str()) != EOK) {
75 TELEPHONY_LOGE("return, strcpy_s fail.");
76 return TELEPHONY_ERR_STRCPY_FAIL;
77 }
78 hangUpCallInfo.slotId = slotId;
79 hangUpCallInfo.index = index;
80 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
81 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
82 return CALL_ERR_RESOURCE_UNAVAILABLE;
83 }
84 return DelayedSingleton<ImsCallClient>::GetInstance()->HangUp(hangUpCallInfo);
85 }
86 TELEPHONY_LOGE("ims vendor service does not exist.");
87 CellularCallHiSysEvent::WriteHangUpFaultEvent(slotId, INVALID_PARAMETER,
88 static_cast<int32_t>(CallErrorCode::CALL_ERROR_IMS_SERVICE_NOT_EXIST),
89 "HangUpRequest ims vendor service does not exist");
90 return TELEPHONY_ERROR;
91 }
92
AnswerRequest(int32_t slotId,const std::string & phoneNum,int32_t videoState,int32_t index)93 int32_t CellularCallConnectionIMS::AnswerRequest(
94 int32_t slotId, const std::string &phoneNum, int32_t videoState, int32_t index)
95 {
96 if (moduleUtils_.NeedCallImsService()) {
97 TELEPHONY_LOGI("call ims service");
98 ImsCallInfo answerCallInfo;
99 if (memset_s(&answerCallInfo, sizeof(answerCallInfo), 0, sizeof(answerCallInfo)) != EOK) {
100 TELEPHONY_LOGE("return, memset_s error.");
101 return TELEPHONY_ERR_MEMSET_FAIL;
102 }
103 if (static_cast<int32_t>(phoneNum.length() + 1) > kMaxNumberLength) {
104 return TELEPHONY_ERR_STRCPY_FAIL;
105 }
106 if (strcpy_s(answerCallInfo.phoneNum, strlen(phoneNum.c_str()) + 1, phoneNum.c_str()) != EOK) {
107 TELEPHONY_LOGE("return, strcpy_s fail.");
108 return TELEPHONY_ERR_STRCPY_FAIL;
109 }
110 answerCallInfo.videoState = videoState;
111 answerCallInfo.slotId = slotId;
112 answerCallInfo.index = index;
113 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
114 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
115 return CALL_ERR_RESOURCE_UNAVAILABLE;
116 }
117 return DelayedSingleton<ImsCallClient>::GetInstance()->Answer(answerCallInfo);
118 }
119 TELEPHONY_LOGE("ims vendor service does not exist.");
120 CellularCallHiSysEvent::WriteAnswerCallFaultEvent(slotId, INVALID_PARAMETER, INVALID_PARAMETER,
121 static_cast<int32_t>(CallErrorCode::CALL_ERROR_IMS_SERVICE_NOT_EXIST), "ims vendor service does not exist");
122 return TELEPHONY_ERROR;
123 }
124
RejectRequest(int32_t slotId,const std::string & phoneNum,int32_t index)125 int32_t CellularCallConnectionIMS::RejectRequest(int32_t slotId, const std::string &phoneNum, int32_t index)
126 {
127 if (moduleUtils_.NeedCallImsService()) {
128 TELEPHONY_LOGI("call ims service");
129 ImsCallInfo rejectCallInfo;
130 if (memset_s(&rejectCallInfo, sizeof(rejectCallInfo), 0, sizeof(rejectCallInfo)) != EOK) {
131 TELEPHONY_LOGE("return, memset_s error.");
132 return TELEPHONY_ERR_MEMSET_FAIL;
133 }
134 if (static_cast<int32_t>(phoneNum.length() + 1) > kMaxNumberLength) {
135 return TELEPHONY_ERR_STRCPY_FAIL;
136 }
137 if (strcpy_s(rejectCallInfo.phoneNum, strlen(phoneNum.c_str()) + 1, phoneNum.c_str()) != EOK) {
138 TELEPHONY_LOGE("return, strcpy_s fail.");
139 return TELEPHONY_ERR_STRCPY_FAIL;
140 }
141 rejectCallInfo.slotId = slotId;
142 rejectCallInfo.index = index;
143 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
144 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
145 return CALL_ERR_RESOURCE_UNAVAILABLE;
146 }
147 return DelayedSingleton<ImsCallClient>::GetInstance()->Reject(rejectCallInfo);
148 }
149 TELEPHONY_LOGE("ims vendor service does not exist.");
150 CellularCallHiSysEvent::WriteHangUpFaultEvent(slotId, INVALID_PARAMETER,
151 static_cast<int32_t>(CallErrorCode::CALL_ERROR_IMS_SERVICE_NOT_EXIST),
152 "RejectRequest ims vendor service does not exist");
153 return TELEPHONY_ERROR;
154 }
155
HoldCallRequest(int32_t slotId)156 int32_t CellularCallConnectionIMS::HoldCallRequest(int32_t slotId)
157 {
158 if (moduleUtils_.NeedCallImsService()) {
159 TELEPHONY_LOGI("call ims service");
160 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
161 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
162 return CALL_ERR_RESOURCE_UNAVAILABLE;
163 }
164 int32_t callType = static_cast<int32_t>(GetCallReportInfo().callMode);
165 return DelayedSingleton<ImsCallClient>::GetInstance()->HoldCall(slotId, callType);
166 }
167 TELEPHONY_LOGE("ims vendor service does not exist.");
168 return TELEPHONY_ERROR;
169 }
170
UnHoldCallRequest(int32_t slotId)171 int32_t CellularCallConnectionIMS::UnHoldCallRequest(int32_t slotId)
172 {
173 if (moduleUtils_.NeedCallImsService()) {
174 TELEPHONY_LOGI("call ims service");
175 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
176 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
177 return CALL_ERR_RESOURCE_UNAVAILABLE;
178 }
179 int32_t callType = static_cast<int32_t>(GetCallReportInfo().callMode);
180 return DelayedSingleton<ImsCallClient>::GetInstance()->UnHoldCall(slotId, callType);
181 }
182 TELEPHONY_LOGE("ims vendor service does not exist.");
183 return TELEPHONY_ERROR;
184 }
185
SwitchCallRequest(int32_t slotId,int32_t videoState)186 int32_t CellularCallConnectionIMS::SwitchCallRequest(int32_t slotId, int32_t videoState)
187 {
188 if (moduleUtils_.NeedCallImsService()) {
189 TELEPHONY_LOGI("call ims service");
190 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
191 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
192 return CALL_ERR_RESOURCE_UNAVAILABLE;
193 }
194 int32_t ret = DelayedSingleton<ImsCallClient>::GetInstance()->SwitchCall(slotId, videoState);
195 if (ret == TELEPHONY_SUCCESS) {
196 UpdatePendingHoldFlag(true);
197 }
198 return ret;
199 }
200 TELEPHONY_LOGE("ims vendor service does not exist.");
201 return TELEPHONY_ERROR;
202 }
203
CombineConferenceRequest(int32_t slotId,int32_t voiceCall)204 int32_t CellularCallConnectionIMS::CombineConferenceRequest(int32_t slotId, int32_t voiceCall)
205 {
206 if (moduleUtils_.NeedCallImsService()) {
207 TELEPHONY_LOGI("call ims service");
208 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
209 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
210 return CALL_ERR_RESOURCE_UNAVAILABLE;
211 }
212 return DelayedSingleton<ImsCallClient>::GetInstance()->CombineConference(slotId);
213 }
214 TELEPHONY_LOGE("ims vendor service does not exist.");
215 return TELEPHONY_ERROR;
216 }
217
InviteToConferenceRequest(int32_t slotId,const std::vector<std::string> & numberList)218 int32_t CellularCallConnectionIMS::InviteToConferenceRequest(
219 int32_t slotId, const std::vector<std::string> &numberList)
220 {
221 if (moduleUtils_.NeedCallImsService()) {
222 TELEPHONY_LOGI("call ims service");
223 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
224 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
225 return CALL_ERR_RESOURCE_UNAVAILABLE;
226 }
227 return DelayedSingleton<ImsCallClient>::GetInstance()->InviteToConference(slotId, numberList);
228 }
229 TELEPHONY_LOGE("ims vendor service does not exist.");
230 return TELEPHONY_ERROR;
231 }
232
KickOutFromConferenceRequest(int32_t slotId,int32_t index)233 int32_t CellularCallConnectionIMS::KickOutFromConferenceRequest(int32_t slotId, int32_t index)
234 {
235 if (moduleUtils_.NeedCallImsService()) {
236 TELEPHONY_LOGI("call ims service");
237 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
238 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
239 return CALL_ERR_RESOURCE_UNAVAILABLE;
240 }
241 return DelayedSingleton<ImsCallClient>::GetInstance()->KickOutFromConference(slotId, index);
242 }
243 TELEPHONY_LOGE("ims vendor service does not exist.");
244 return TELEPHONY_ERROR;
245 }
246
CallSupplementRequest(int32_t slotId,CallSupplementType type)247 int32_t CellularCallConnectionIMS::CallSupplementRequest(int32_t slotId, CallSupplementType type)
248 {
249 TELEPHONY_LOGD("start");
250 if (DelayedSingleton<CellularCallService>::GetInstance() == nullptr) {
251 TELEPHONY_LOGE("return, error type: GetInstance() is nullptr.");
252 return CALL_ERR_RESOURCE_UNAVAILABLE;
253 }
254 auto handle = DelayedSingleton<CellularCallService>::GetInstance()->GetHandler(slotId);
255 if (handle == nullptr) {
256 TELEPHONY_LOGE("return, error type: handle is nullptr.");
257 return CALL_ERR_RESOURCE_UNAVAILABLE;
258 }
259 CoreManagerInner::GetInstance().CallSupplement(slotId, RadioEvent::RADIO_CALL_SUPPLEMENT, type, handle);
260 return TELEPHONY_SUCCESS;
261 }
262
GetImsCallsDataRequest(int32_t slotId,int64_t lastCallsDataFlag)263 int32_t CellularCallConnectionIMS::GetImsCallsDataRequest(int32_t slotId, int64_t lastCallsDataFlag)
264 {
265 if (moduleUtils_.NeedCallImsService()) {
266 TELEPHONY_LOGI("call ims service");
267 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
268 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
269 return CALL_ERR_RESOURCE_UNAVAILABLE;
270 }
271 return DelayedSingleton<ImsCallClient>::GetInstance()->GetImsCallsDataRequest(slotId, lastCallsDataFlag);
272 }
273 TELEPHONY_LOGE("ims vendor service does not exist.");
274 return TELEPHONY_ERROR;
275 }
276
SendDtmfRequest(int32_t slotId,char cDtmfCode,int32_t index) const277 int32_t CellularCallConnectionIMS::SendDtmfRequest(int32_t slotId, char cDtmfCode, int32_t index) const
278 {
279 if (moduleUtils_.NeedCallImsService()) {
280 TELEPHONY_LOGD("call ims service");
281 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
282 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
283 return CALL_ERR_RESOURCE_UNAVAILABLE;
284 }
285 return DelayedSingleton<ImsCallClient>::GetInstance()->SendDtmf(slotId, cDtmfCode, index);
286 }
287 TELEPHONY_LOGE("ims vendor service does not exist.");
288 return TELEPHONY_ERROR;
289 }
290
StartDtmfRequest(int32_t slotId,char cDtmfCode,int32_t index) const291 int32_t CellularCallConnectionIMS::StartDtmfRequest(int32_t slotId, char cDtmfCode, int32_t index) const
292 {
293 if (moduleUtils_.NeedCallImsService()) {
294 TELEPHONY_LOGI("call ims service");
295 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
296 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
297 return CALL_ERR_RESOURCE_UNAVAILABLE;
298 }
299 return DelayedSingleton<ImsCallClient>::GetInstance()->StartDtmf(slotId, cDtmfCode, index);
300 }
301 TELEPHONY_LOGE("ims vendor service does not exist.");
302 return TELEPHONY_ERROR;
303 }
304
StopDtmfRequest(int32_t slotId,int32_t index) const305 int32_t CellularCallConnectionIMS::StopDtmfRequest(int32_t slotId, int32_t index) const
306 {
307 if (moduleUtils_.NeedCallImsService()) {
308 TELEPHONY_LOGI("call ims service");
309 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
310 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
311 return CALL_ERR_RESOURCE_UNAVAILABLE;
312 }
313 return DelayedSingleton<ImsCallClient>::GetInstance()->StopDtmf(slotId, index);
314 }
315 TELEPHONY_LOGE("ims vendor service does not exist.");
316 return TELEPHONY_ERROR;
317 }
318
StartRttRequest(int32_t slotId,const std::string & msg)319 int32_t CellularCallConnectionIMS::StartRttRequest(int32_t slotId, const std::string &msg)
320 {
321 if (moduleUtils_.NeedCallImsService()) {
322 TELEPHONY_LOGI("call ims service");
323 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
324 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
325 return CALL_ERR_RESOURCE_UNAVAILABLE;
326 }
327 return DelayedSingleton<ImsCallClient>::GetInstance()->StartRtt(slotId, msg);
328 }
329 TELEPHONY_LOGE("ims vendor service does not exist.");
330 return TELEPHONY_ERROR;
331 }
332
StopRttRequest(int32_t slotId)333 int32_t CellularCallConnectionIMS::StopRttRequest(int32_t slotId)
334 {
335 if (moduleUtils_.NeedCallImsService()) {
336 TELEPHONY_LOGI("call ims service");
337 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
338 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
339 return CALL_ERR_RESOURCE_UNAVAILABLE;
340 }
341 return DelayedSingleton<ImsCallClient>::GetInstance()->StopRtt(slotId);
342 }
343 TELEPHONY_LOGE("ims vendor service does not exist.");
344 return TELEPHONY_ERROR;
345 }
346
GetCallFailReasonRequest(int32_t slotId) const347 int32_t CellularCallConnectionIMS::GetCallFailReasonRequest(int32_t slotId) const
348 {
349 if (moduleUtils_.NeedCallImsService()) {
350 TELEPHONY_LOGD("call ims service");
351 if (DelayedSingleton<ImsCallClient>::GetInstance() == nullptr) {
352 TELEPHONY_LOGE("return, ImsCallClient is nullptr.");
353 return CALL_ERR_RESOURCE_UNAVAILABLE;
354 }
355 return DelayedSingleton<ImsCallClient>::GetInstance()->GetLastCallFailReason(slotId);
356 }
357 TELEPHONY_LOGE("ims vendor service does not exist.");
358 return TELEPHONY_ERROR;
359 }
360
ProcessPostDialCallChar(int32_t slotId,char c)361 int32_t CellularCallConnectionIMS::ProcessPostDialCallChar(int32_t slotId, char c)
362 {
363 if (StandardizeUtils::IsDtmfKey(c)) {
364 SendDtmfRequest(slotId, c, GetIndex());
365 } else if (StandardizeUtils::IsPauseKey(c)) {
366 SetPostDialCallState(PostDialCallState::POST_DIAL_CALL_PAUSE);
367 auto handle = DelayedSingleton<CellularCallService>::GetInstance()->GetHandler(slotId);
368 if (handle == nullptr) {
369 TELEPHONY_LOGE("SendDtmfRequest return, error type: handle is nullptr.");
370 return CALL_ERR_RESOURCE_UNAVAILABLE;
371 }
372 std::shared_ptr<PostDialData> postDial = std::make_shared<PostDialData>();
373 postDial->callId = GetIndex();
374 postDial->isIms = true;
375 handle->SendEvent(EVENT_EXECUTE_POST_DIAL, postDial, PAUSE_DELAY_TIME);
376 } else if (StandardizeUtils::IsWaitKey(c)) {
377 SetPostDialCallState(PostDialCallState::POST_DIAL_CALL_DELAY);
378 }
379 return TELEPHONY_SUCCESS;
380 }
381
SetHoldToDialInfo(std::string holdToDialNum,CLIRMode holdToDialClirMode,int32_t holdToDialVideoState,bool isEmergency)382 void CellularCallConnectionIMS::SetHoldToDialInfo(std::string holdToDialNum, CLIRMode holdToDialClirMode,
383 int32_t holdToDialVideoState, bool isEmergency)
384 {
385 holdToDialInfo_.phoneNum = holdToDialNum;
386 holdToDialInfo_.clirMode = holdToDialClirMode;
387 holdToDialInfo_.videoState = holdToDialVideoState;
388 holdToDialInfo_.bEmergencyCall = isEmergency;
389 }
390
IsNeedToDial()391 bool CellularCallConnectionIMS::IsNeedToDial()
392 {
393 return isNeedToDial_;
394 }
395
SetDialFlag(bool isNeedToDial)396 void CellularCallConnectionIMS::SetDialFlag(bool isNeedToDial)
397 {
398 isNeedToDial_ = isNeedToDial;
399 }
400
GetHoldToDialInfo()401 ImsDialInfoStruct CellularCallConnectionIMS::GetHoldToDialInfo()
402 {
403 return holdToDialInfo_;
404 }
405
IsPendingHold()406 bool CellularCallConnectionIMS::IsPendingHold()
407 {
408 return GetCallReportInfo().isPendingHold;
409 }
410
IsPendingHangup()411 bool CellularCallConnectionIMS::IsPendingHangup()
412 {
413 return isPendingHangup_;
414 }
415
SetHangupFlag(bool isPendingHangup)416 void CellularCallConnectionIMS::SetHangupFlag(bool isPendingHangup)
417 {
418 isPendingHangup_ = isPendingHangup;
419 }
420
GetDisconnectReason()421 RilDisconnectedReason CellularCallConnectionIMS::GetDisconnectReason()
422 {
423 return disconnectReason_;
424 }
425
SetDisconnectReason(RilDisconnectedReason reason)426 void CellularCallConnectionIMS::SetDisconnectReason(RilDisconnectedReason reason)
427 {
428 disconnectReason_ = reason;
429 }
430
GetDisconnectMessage()431 std::string CellularCallConnectionIMS::GetDisconnectMessage()
432 {
433 return disconnectMessage_;
434 }
435
SetDisconnectMessage(const std::string & message)436 void CellularCallConnectionIMS::SetDisconnectMessage(const std::string &message)
437 {
438 disconnectMessage_ = message;
439 }
440 } // namespace Telephony
441 } // namespace OHOS
442