1 /*
2 * Copyright (C) 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_hisysevent.h"
17
18 #include <securec.h>
19
20 #include "call_manager_errors.h"
21 #include "telephony_errors.h"
22 #include "telephony_log_wrapper.h"
23 #ifdef SECURITY_GUARDE_ENABLE
24 #include <iostream>
25 #include <ctime>
26 #include "cellular_call_hisysevent.h"
27 #include "nlohmann/json.hpp"
28 #include "event_info.h"
29 #include "sg_collect_client.h"
30 #endif
31
32 namespace OHOS {
33 namespace Telephony {
34 // EVENT
35 static constexpr const char *CALL_INCOMING_FAILED_EVENT = "CALL_INCOMING_FAILED";
36 static constexpr const char *CALL_DIAL_FAILED_EVENT = "CALL_DIAL_FAILED";
37 static constexpr const char *CALL_ANSWER_FAILED_EVENT = "CALL_ANSWER_FAILED";
38 static constexpr const char *CALL_HANGUP_FAILED_EVENT = "CALL_HANGUP_FAILED";
39 static constexpr const char *DIAL_EVENT = "DIAL";
40 static constexpr const char *ANSWER_EVENT = "ANSWER";
41 static constexpr const char *HANG_UP_EVENT = "HANG_UP";
42 static constexpr const char *CALL_END_EXCEPTION_EVENT = "CALL_END_EXCEPTION";
43 static constexpr const char *FOUNDATION_RESTART_EVENT = "FOUNDATION_RESTART";
44 static constexpr const char *VONR_SWITCH_STATE_EVENT = "VONR_SWITCH_STATE";
45 static constexpr const char *CALL_MODE_SEND_REQUEST_EVENT = "CALL_MODE_SEND_REQUEST";
46 static constexpr const char *CALL_MODE_SEND_RESPONSE_EVENT = "CALL_MODE_SEND_RESPONSE";
47 static constexpr const char *CALL_MODE_RECEIVE_RESPONSE_EVENT = "CALL_MODE_RECEIVE_RESPONSE";
48 static constexpr const char *CALL_MODE_RECEIVE_REQUEST_EVENT = "CALL_MODE_RECEIVE_REQUEST";
49
50 // KEY
51 static constexpr const char *MODULE_NAME_KEY = "MODULE";
52 static constexpr const char *SLOT_ID_KEY = "SLOT_ID";
53 static constexpr const char *CALL_ID_KEY = "CALL_ID";
54 static constexpr const char *CALL_TYPE_KEY = "CALL_TYPE";
55 static constexpr const char *VIDEO_STATE_KEY = "VIDEO_STATE";
56 static constexpr const char *RESULT_KEY = "RESULT";
57 static constexpr const char *FAIL_CAUSE_KEY = "FAIL_CAUSE";
58 static constexpr const char *ERROR_TYPE_KEY = "ERROR_TYPE";
59 static constexpr const char *ERROR_MSG_KEY = "ERROR_MSG";
60 static constexpr const char *RESTART_COUNT_KEY = "RESTART_COUNT";
61 static constexpr const char *SWITCH_KEY = "SWITCH_KEY";
62
63 // VALUE
64 static constexpr const char *CELLULAR_CALL_MODULE = "CELLULAR_CALL";
65 static const int32_t INVALID_VALUE = -1;
66 static const int32_t CS_CALL_TYPE = 0;
67 static const int32_t IMS_CALL_TYPE = 1;
68 static const int32_t VOICE_TYPE = 0;
69 static const int32_t VIDEO_TYPE = 1;
70
WriteFoundationRestartFaultEvent(const int32_t count)71 void CellularCallHiSysEvent::WriteFoundationRestartFaultEvent(const int32_t count)
72 {
73 HiWriteFaultEvent(FOUNDATION_RESTART_EVENT, RESTART_COUNT_KEY, count);
74 }
75
WriteCallEndBehaviorEvent(const int32_t slotId,const int32_t cause)76 void CellularCallHiSysEvent::WriteCallEndBehaviorEvent(const int32_t slotId, const int32_t cause)
77 {
78 HiWriteBehaviorEvent(CALL_END_EXCEPTION_EVENT, SLOT_ID_KEY, slotId, FAIL_CAUSE_KEY, cause);
79 }
80
WriteDialCallBehaviorEvent(const CallBehaviorParameterInfo & info,const CallResponseResult & result)81 void CellularCallHiSysEvent::WriteDialCallBehaviorEvent(
82 const CallBehaviorParameterInfo &info, const CallResponseResult &result)
83 {
84 int32_t type = 0;
85 if (info.callType == CS_CALL_TYPE && info.videoState == VOICE_TYPE) {
86 type = static_cast<int32_t>(DialCallType::CS_VOICE_DIAL);
87 } else if (info.callType == IMS_CALL_TYPE && info.videoState == VOICE_TYPE) {
88 type = static_cast<int32_t>(DialCallType::IMS_VOICE_DIAL);
89 } else if (info.callType == IMS_CALL_TYPE && info.videoState == VIDEO_TYPE) {
90 type = static_cast<int32_t>(DialCallType::IMS_VIDEO_DIAL);
91 } else {
92 TELEPHONY_LOGE("WriteDialCallBehaviorEvent callType is out of range!");
93 return;
94 }
95 HiWriteBehaviorEvent(
96 DIAL_EVENT, SLOT_ID_KEY, info.slotId, CALL_TYPE_KEY, type, RESULT_KEY, static_cast<int32_t>(result));
97 }
98
WriteHangUpCallBehaviorEvent(const CallBehaviorParameterInfo & info,const CallResponseResult & result)99 void CellularCallHiSysEvent::WriteHangUpCallBehaviorEvent(
100 const CallBehaviorParameterInfo &info, const CallResponseResult &result)
101 {
102 int32_t type = 0;
103 if (info.callType == CS_CALL_TYPE && info.videoState == VOICE_TYPE) {
104 type = static_cast<int32_t>(HangUpCallType::CS_VOICE_CALL);
105 } else if (info.callType == IMS_CALL_TYPE && info.videoState == VOICE_TYPE) {
106 type = static_cast<int32_t>(HangUpCallType::IMS_VOICE_CALL);
107 } else if (info.callType == IMS_CALL_TYPE && info.videoState == VIDEO_TYPE) {
108 type = static_cast<int32_t>(HangUpCallType::IMS_VIDEO_CALL);
109 } else {
110 TELEPHONY_LOGE("WriteHangUpCallBehaviorEvent callType is out of range!");
111 return;
112 }
113 HiWriteBehaviorEvent(
114 HANG_UP_EVENT, SLOT_ID_KEY, info.slotId, CALL_TYPE_KEY, type, RESULT_KEY, static_cast<int32_t>(result));
115 }
116
WriteAnswerCallBehaviorEvent(const CallBehaviorParameterInfo & info,const CallResponseResult & result)117 void CellularCallHiSysEvent::WriteAnswerCallBehaviorEvent(
118 const CallBehaviorParameterInfo &info, const CallResponseResult &result)
119 {
120 int32_t type = 0;
121 if (info.incomingCallType == IMS_CALL_TYPE && info.incomingVideoState == VOICE_TYPE &&
122 info.callType == IMS_CALL_TYPE && info.videoState == VOICE_TYPE) {
123 type = static_cast<int32_t>(AnswerCallType::IMS_VOICE_ANSWER);
124 } else if (info.incomingCallType == IMS_CALL_TYPE && info.incomingVideoState == VIDEO_TYPE &&
125 info.callType == IMS_CALL_TYPE && info.videoState == VOICE_TYPE) {
126 type = static_cast<int32_t>(AnswerCallType::IMS_VIDEO_TO_VOICE_ANSWER);
127 } else if (info.incomingCallType == IMS_CALL_TYPE && info.incomingVideoState == VIDEO_TYPE &&
128 info.callType == IMS_CALL_TYPE && info.videoState == VIDEO_TYPE) {
129 type = static_cast<int32_t>(AnswerCallType::IMS_VIDEO_TO_VIDEO_ANSWER);
130 } else if (info.incomingCallType == CS_CALL_TYPE && info.incomingVideoState == VOICE_TYPE &&
131 info.callType == CS_CALL_TYPE && info.videoState == VOICE_TYPE) {
132 type = static_cast<int32_t>(AnswerCallType::CS_VOICE_ANSWER);
133 } else {
134 TELEPHONY_LOGE("WriteAnswerCallBehaviorEvent callType is out of range!");
135 return;
136 }
137 HiWriteBehaviorEvent(
138 ANSWER_EVENT, SLOT_ID_KEY, info.slotId, CALL_TYPE_KEY, type, RESULT_KEY, static_cast<int32_t>(result));
139 }
140
WriteIncomingCallFaultEvent(const int32_t slotId,const int32_t callType,const int32_t videoState,const int32_t errCode,const std::string & desc)141 void CellularCallHiSysEvent::WriteIncomingCallFaultEvent(const int32_t slotId, const int32_t callType,
142 const int32_t videoState, const int32_t errCode, const std::string &desc)
143 {
144 CallErrorCode value = CallErrorCode::CALL_ERROR_NONE;
145 if (ErrorCodeConversion(errCode, value)) {
146 HiWriteFaultEvent(CALL_INCOMING_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
147 CALL_TYPE_KEY, callType, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, static_cast<int32_t>(value),
148 ERROR_MSG_KEY, desc);
149 } else {
150 HiWriteFaultEvent(CALL_INCOMING_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
151 CALL_TYPE_KEY, callType, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, errCode, ERROR_MSG_KEY, desc);
152 }
153 }
154
WriteDialCallFaultEvent(const int32_t slotId,const int32_t callType,const int32_t videoState,const int32_t errorCode,const std::string & desc)155 void CellularCallHiSysEvent::WriteDialCallFaultEvent(const int32_t slotId, const int32_t callType,
156 const int32_t videoState, const int32_t errorCode, const std::string &desc)
157 {
158 CallErrorCode value = CallErrorCode::CALL_ERROR_NONE;
159 if (ErrorCodeConversion(errorCode, value)) {
160 HiWriteFaultEvent(CALL_DIAL_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
161 CALL_TYPE_KEY, callType, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, static_cast<int32_t>(value),
162 ERROR_MSG_KEY, desc);
163 } else {
164 HiWriteFaultEvent(CALL_DIAL_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
165 CALL_TYPE_KEY, callType, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, errorCode, ERROR_MSG_KEY, desc);
166 }
167 }
168
WriteAnswerCallFaultEvent(const int32_t slotId,const int32_t callId,const int32_t videoState,const int32_t errorCode,const std::string & desc)169 void CellularCallHiSysEvent::WriteAnswerCallFaultEvent(const int32_t slotId, const int32_t callId,
170 const int32_t videoState, const int32_t errorCode, const std::string &desc)
171 {
172 CallErrorCode value = CallErrorCode::CALL_ERROR_NONE;
173 if (ErrorCodeConversion(errorCode, value)) {
174 HiWriteFaultEvent(CALL_ANSWER_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
175 CALL_ID_KEY, callId, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, static_cast<int32_t>(value),
176 ERROR_MSG_KEY, desc);
177 } else {
178 HiWriteFaultEvent(CALL_ANSWER_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
179 CALL_ID_KEY, callId, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, errorCode, ERROR_MSG_KEY, desc);
180 }
181 }
182
WriteHangUpFaultEvent(const int32_t slotId,const int32_t callId,const int32_t errorCode,const std::string & desc)183 void CellularCallHiSysEvent::WriteHangUpFaultEvent(
184 const int32_t slotId, const int32_t callId, const int32_t errorCode, const std::string &desc)
185 {
186 CallErrorCode value = CallErrorCode::CALL_ERROR_NONE;
187 if (ErrorCodeConversion(errorCode, value)) {
188 HiWriteFaultEvent(CALL_HANGUP_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
189 CALL_ID_KEY, callId, ERROR_TYPE_KEY, static_cast<int32_t>(value), ERROR_MSG_KEY, desc);
190 } else {
191 HiWriteFaultEvent(CALL_HANGUP_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
192 CALL_ID_KEY, callId, ERROR_TYPE_KEY, errorCode, ERROR_MSG_KEY, desc);
193 }
194 }
195
WriteVoNRSwitchChangeEvent(const int32_t enable)196 void CellularCallHiSysEvent::WriteVoNRSwitchChangeEvent(const int32_t enable)
197 {
198 HiWriteBehaviorEvent(VONR_SWITCH_STATE_EVENT, SWITCH_KEY, enable);
199 }
200
WriteImsCallModeBehaviorEvent(const CallModeBehaviorType type,const CallBehaviorParameterInfo & info,const int32_t requestResult)201 void CellularCallHiSysEvent::WriteImsCallModeBehaviorEvent(
202 const CallModeBehaviorType type, const CallBehaviorParameterInfo &info, const int32_t requestResult)
203 {
204 std::string imsCallModeEvent = "";
205 switch (type) {
206 case CallModeBehaviorType::SEND_REQUEST_EVENT:
207 imsCallModeEvent = CALL_MODE_SEND_REQUEST_EVENT;
208 break;
209 case CallModeBehaviorType::SEND_RESPONSE_EVENT:
210 imsCallModeEvent = CALL_MODE_SEND_RESPONSE_EVENT;
211 break;
212 case CallModeBehaviorType::RECEIVE_REQUEST_EVENT:
213 imsCallModeEvent = CALL_MODE_RECEIVE_REQUEST_EVENT;
214 break;
215 case CallModeBehaviorType::RECEIVE_RESPONSE_EVENT:
216 imsCallModeEvent = CALL_MODE_RECEIVE_RESPONSE_EVENT;
217 break;
218 default:
219 break;
220 }
221 if (requestResult == INVALID_VALUE) {
222 HiWriteBehaviorEvent(imsCallModeEvent, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, info.slotId,
223 CALL_TYPE_KEY, info.callType, VIDEO_STATE_KEY, info.videoState);
224 } else {
225 HiWriteBehaviorEvent(imsCallModeEvent, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, info.slotId,
226 CALL_TYPE_KEY, info.callType, VIDEO_STATE_KEY, info.videoState, RESULT_KEY, requestResult);
227 }
228 }
229
230 #ifdef SECURITY_GUARDE_ENABLE
WriteCallTansferEvent(uint8_t state)231 void CellularCallHiSysEvent::WriteCallTansferEvent(uint8_t state)
232 {
233 using namespace OHOS::Security::SecurityGuard;
234 const int32_t TIME_STR_LENGTH = 14 + 1;
235 const int64_t EVENT_ID = 0x009000002;
236 char timeStr[TIME_STR_LENGTH] = {0};
237 time_t nowTime = time(0);
238 struct tm *lt = localtime(&nowTime);
239 if (lt == nullptr || strftime(timeStr, TIME_STR_LENGTH, "%Y%m%d%H%M%S", lt) == 0) {
240 TELEPHONY_LOGE("strftime error");
241 return;
242 }
243 nlohmann::json jsonResult;
244 jsonResult["occurTime"] = timeStr;
245 jsonResult["transferState"] = state;
246 jsonResult["setting"] = "dial";
247 std::string strInfo = jsonResult.dump();
248 std::shared_ptr<EventInfo> eventInfo = std::make_shared<EventInfo>(EVENT_ID, "1.0", strInfo);
249 int32_t ret = NativeDataCollectKit::ReportSecurityInfo(eventInfo);
250 if (ret != ERR_OK) {
251 TELEPHONY_LOGE("ReportSecurityInfo ret: %{public}d", ret);
252 }
253 }
254 #endif
255
ErrorCodeConversion(const int32_t errCode,CallErrorCode & eventValue)256 int32_t CellularCallHiSysEvent::ErrorCodeConversion(const int32_t errCode, CallErrorCode &eventValue)
257 {
258 if (CallDataErrorCodeConversion(errCode, eventValue) || CallInterfaceErrorCodeConversion(errCode, eventValue) ||
259 TelephonyErrorCodeConversion(errCode, eventValue)) {
260 return true;
261 }
262 return false;
263 }
264
TelephonyErrorCodeConversion(const int32_t errCode,CallErrorCode & eventValue)265 int32_t CellularCallHiSysEvent::TelephonyErrorCodeConversion(const int32_t errCode, CallErrorCode &eventValue)
266 {
267 switch (errCode) {
268 case static_cast<int32_t>(TELEPHONY_ERR_LOCAL_PTR_NULL):
269 eventValue = CallErrorCode::CALL_ERROR_CALL_LOCAL_PTR_NULL;
270 break;
271 case static_cast<int32_t>(TELEPHONY_ERR_ARGUMENT_INVALID):
272 eventValue = CallErrorCode::CALL_ERROR_ARGUMENT_INVALID;
273 break;
274 case static_cast<int32_t>(TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL):
275 eventValue = CallErrorCode::CALL_ERROR_IPC_CONNECT_STUB_FAIL;
276 break;
277 case static_cast<int32_t>(TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL):
278 eventValue = CallErrorCode::CALL_ERROR_IPC_WRITE_DESCRIPTOR_TOKEN_FAIL;
279 break;
280 case static_cast<int32_t>(TELEPHONY_ERR_WRITE_DATA_FAIL):
281 eventValue = CallErrorCode::CALL_ERROR_IPC_WRITE_DATA_FAIL;
282 break;
283 case static_cast<int32_t>(TELEPHONY_ERR_PERMISSION_ERR):
284 eventValue = CallErrorCode::CALL_ERROR_PERMISSION_ERR;
285 break;
286 case static_cast<int32_t>(TELEPHONY_ERR_MEMSET_FAIL):
287 eventValue = CallErrorCode::CALL_ERROR_MEMSET_FAIL;
288 break;
289 case static_cast<int32_t>(TELEPHONY_ERR_MEMCPY_FAIL):
290 eventValue = CallErrorCode::CALL_ERROR_MEMCPY_FAIL;
291 break;
292 default:
293 return false;
294 }
295
296 return true;
297 }
298
CallDataErrorCodeConversion(const int32_t errCode,CallErrorCode & eventValue)299 int32_t CellularCallHiSysEvent::CallDataErrorCodeConversion(const int32_t errCode, CallErrorCode &eventValue)
300 {
301 switch (errCode) {
302 case static_cast<int32_t>(CALL_ERR_INVALID_SLOT_ID):
303 eventValue = CallErrorCode::CALL_ERROR_INVALID_SLOT_ID;
304 break;
305 case static_cast<int32_t>(CALL_ERR_INVALID_CALLID):
306 eventValue = CallErrorCode::CALL_ERROR_INVALID_CALLID;
307 break;
308 case static_cast<int32_t>(CALL_ERR_PHONE_NUMBER_EMPTY):
309 eventValue = CallErrorCode::CALL_ERROR_PHONE_NUMBER_EMPTY;
310 break;
311 case static_cast<int32_t>(CALL_ERR_NUMBER_OUT_OF_RANGE):
312 eventValue = CallErrorCode::CALL_ERROR_NUMBER_OUT_OF_RANGE;
313 break;
314 case static_cast<int32_t>(CALL_ERR_UNSUPPORTED_NETWORK_TYPE):
315 eventValue = CallErrorCode::CALL_ERROR_UNSUPPORTED_NETWORK_TYPE;
316 break;
317 case static_cast<int32_t>(CALL_ERR_INVALID_DIAL_SCENE):
318 eventValue = CallErrorCode::CALL_ERROR_INVALID_DIAL_SCENE;
319 break;
320 case static_cast<int32_t>(CALL_ERR_INVALID_VIDEO_STATE):
321 eventValue = CallErrorCode::CALL_ERROR_INVALID_VIDEO_STATE;
322 break;
323 case static_cast<int32_t>(CALL_ERR_UNKNOW_DIAL_TYPE):
324 eventValue = CallErrorCode::CALL_ERROR_UNKNOW_DIAL_TYPE;
325 break;
326 case static_cast<int32_t>(CALL_ERR_UNKNOW_CALL_TYPE):
327 eventValue = CallErrorCode::CALL_ERROR_UNKNOW_CALL_TYPE;
328 break;
329 case static_cast<int32_t>(CALL_ERR_CALL_OBJECT_IS_NULL):
330 eventValue = CallErrorCode::CALL_ERROR_CALL_OBJECT_IS_NULL;
331 break;
332 default:
333 return false;
334 }
335 return true;
336 }
337
CallInterfaceErrorCodeConversion(const int32_t errCode,CallErrorCode & eventValue)338 int32_t CellularCallHiSysEvent::CallInterfaceErrorCodeConversion(const int32_t errCode, CallErrorCode &eventValue)
339 {
340 switch (errCode) {
341 case static_cast<int32_t>(CALL_ERR_DIAL_IS_BUSY):
342 eventValue = CallErrorCode::CALL_ERROR_DIAL_IS_BUSY;
343 break;
344 case static_cast<int32_t>(CALL_ERR_ILLEGAL_CALL_OPERATION):
345 eventValue = CallErrorCode::CALL_ERROR_ILLEGAL_CALL_OPERATION;
346 break;
347 case static_cast<int32_t>(CALL_ERR_PHONE_CALLSTATE_NOTIFY_FAILED):
348 eventValue = CallErrorCode::CALL_ERROR_PHONE_CALLSTATE_NOTIFY_FAILED;
349 break;
350 case static_cast<int32_t>(CALL_ERR_SYSTEM_EVENT_HANDLE_FAILURE):
351 eventValue = CallErrorCode::CALL_ERROR_SYSTEM_EVENT_HANDLE_FAILURE;
352 break;
353 case static_cast<int32_t>(CALL_ERR_CALL_COUNTS_EXCEED_LIMIT):
354 eventValue = CallErrorCode::CALL_ERROR_CALL_COUNTS_EXCEED_LIMIT;
355 break;
356 case static_cast<int32_t>(CALL_ERR_GET_RADIO_STATE_FAILED):
357 eventValue = CallErrorCode::CALL_ERROR_GET_RADIO_STATE_FAILED;
358 break;
359 default:
360 return false;
361 }
362
363 return true;
364 }
365
SetCallParameterInfo(const int32_t slotId,const int32_t callType,const int32_t videoState)366 void CellularCallHiSysEvent::SetCallParameterInfo(
367 const int32_t slotId, const int32_t callType, const int32_t videoState)
368 {
369 dfxSlotId_ = slotId;
370 dfxCallType_ = callType;
371 dfxVideoState_ = videoState;
372 }
373
SetIncomingCallParameterInfo(const int32_t incomingCallType,const int32_t incomingVideoState)374 void CellularCallHiSysEvent::SetIncomingCallParameterInfo(
375 const int32_t incomingCallType, const int32_t incomingVideoState)
376 {
377 dfxIncomingCallType_ = incomingCallType;
378 dfxIncomingVideoState_ = incomingVideoState;
379 }
380
GetCallParameterInfo(CallBehaviorParameterInfo & info)381 void CellularCallHiSysEvent::GetCallParameterInfo(CallBehaviorParameterInfo &info)
382 {
383 info.slotId = dfxSlotId_;
384 info.callType = dfxCallType_;
385 info.videoState = dfxVideoState_;
386 info.incomingCallType = dfxIncomingCallType_;
387 info.incomingVideoState = dfxIncomingVideoState_;
388 }
389
SetIncomingStartTime()390 void CellularCallHiSysEvent::SetIncomingStartTime()
391 {
392 incomingStartTime_ =
393 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
394 .count();
395 }
396
JudgingIncomingTimeOut(const int32_t slotId,const int32_t callType,const int32_t videoState)397 void CellularCallHiSysEvent::JudgingIncomingTimeOut(
398 const int32_t slotId, const int32_t callType, const int32_t videoState)
399 {
400 int64_t incomingEndTime =
401 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
402 .count();
403 if ((incomingEndTime - incomingStartTime_) > NORMAL_INCOMING_TIME) {
404 WriteIncomingCallFaultEvent(slotId, callType, videoState,
405 static_cast<int32_t>(CallErrorCode::CALL_ERROR_INCOMING_TIME_OUT),
406 "incoming time out " + std::to_string(incomingStartTime_ - incomingEndTime));
407 }
408 }
409
SetCallForwardingInfo(const int32_t slotId,const bool enable,const std::string & number)410 void CellularCallHiSysEvent::SetCallForwardingInfo(const int32_t slotId, const bool enable, const std::string &number)
411 {
412 callForwardingSlotId_ = slotId;
413 callForwardingEnable_ = enable;
414 callForwardingNumber_ = number;
415 }
416
GetCallForwardingInfo(CallForwardingInfo & info)417 void CellularCallHiSysEvent::GetCallForwardingInfo(CallForwardingInfo &info)
418 {
419 info.slotId = callForwardingSlotId_;
420 info.enable = callForwardingEnable_;
421
422 if (callForwardingNumber_.length() > static_cast<size_t>(maxNumberLen)) {
423 return;
424 }
425 size_t cpyLen = callForwardingNumber_.length() + 1;
426 if (cpyLen > static_cast<size_t>(maxNumberLen + 1)) {
427 return;
428 }
429 if (strcpy_s(info.number, cpyLen, callForwardingNumber_.c_str()) != EOK) {
430 TELEPHONY_LOGE("strcpy_s fail.");
431 return;
432 }
433 }
434 } // namespace Telephony
435 } // namespace OHOS
436