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
24 namespace OHOS {
25 namespace Telephony {
26 // EVENT
27 static constexpr const char *CALL_INCOMING_FAILED_EVENT = "CALL_INCOMING_FAILED";
28 static constexpr const char *CALL_DIAL_FAILED_EVENT = "CALL_DIAL_FAILED";
29 static constexpr const char *CALL_ANSWER_FAILED_EVENT = "CALL_ANSWER_FAILED";
30 static constexpr const char *CALL_HANGUP_FAILED_EVENT = "CALL_HANGUP_FAILED";
31 static constexpr const char *DIAL_EVENT = "DIAL";
32 static constexpr const char *ANSWER_EVENT = "ANSWER";
33 static constexpr const char *HANG_UP_EVENT = "HANG_UP";
34 static constexpr const char *CALL_END_EXCEPTION_EVENT = "CALL_END_EXCEPTION";
35 static constexpr const char *FOUNDATION_RESTART_EVENT = "FOUNDATION_RESTART";
36 static constexpr const char *VONR_SWITCH_STATE_EVENT = "VONR_SWITCH_STATE";
37
38 // KEY
39 static constexpr const char *MODULE_NAME_KEY = "MODULE";
40 static constexpr const char *SLOT_ID_KEY = "SLOT_ID";
41 static constexpr const char *CALL_ID_KEY = "CALL_ID";
42 static constexpr const char *CALL_TYPE_KEY = "CALL_TYPE";
43 static constexpr const char *VIDEO_STATE_KEY = "VIDEO_STATE";
44 static constexpr const char *RESULT_KEY = "RESULT";
45 static constexpr const char *FAIL_CAUSE_KEY = "FAIL_CAUSE";
46 static constexpr const char *ERROR_TYPE_KEY = "ERROR_TYPE";
47 static constexpr const char *ERROR_MSG_KEY = "ERROR_MSG";
48 static constexpr const char *RESTART_COUNT_KEY = "RESTART_COUNT";
49 static constexpr const char *SWITCH_KEY = "SWITCH_KEY";
50
51 // VALUE
52 static constexpr const char *CELLULAR_CALL_MODULE = "CELLULAR_CALL";
53 static const int32_t CS_CALL_TYPE = 0;
54 static const int32_t IMS_CALL_TYPE = 1;
55 static const int32_t VOICE_TYPE = 0;
56 static const int32_t VIDEO_TYPE = 1;
57
WriteFoundationRestartFaultEvent(const int32_t count)58 void CellularCallHiSysEvent::WriteFoundationRestartFaultEvent(const int32_t count)
59 {
60 HiWriteFaultEvent(FOUNDATION_RESTART_EVENT, RESTART_COUNT_KEY, count);
61 }
62
WriteCallEndBehaviorEvent(const int32_t slotId,const int32_t cause)63 void CellularCallHiSysEvent::WriteCallEndBehaviorEvent(const int32_t slotId, const int32_t cause)
64 {
65 HiWriteBehaviorEvent(CALL_END_EXCEPTION_EVENT, SLOT_ID_KEY, slotId, FAIL_CAUSE_KEY, cause);
66 }
67
WriteDialCallBehaviorEvent(const CallBehaviorParameterInfo & info,const CallResponseResult & result)68 void CellularCallHiSysEvent::WriteDialCallBehaviorEvent(
69 const CallBehaviorParameterInfo &info, const CallResponseResult &result)
70 {
71 int32_t type = 0;
72 if (info.callType == CS_CALL_TYPE && info.videoState == VOICE_TYPE) {
73 type = static_cast<int32_t>(DialCallType::CS_VOICE_DIAL);
74 } else if (info.callType == IMS_CALL_TYPE && info.videoState == VOICE_TYPE) {
75 type = static_cast<int32_t>(DialCallType::IMS_VOICE_DIAL);
76 } else if (info.callType == IMS_CALL_TYPE && info.videoState == VIDEO_TYPE) {
77 type = static_cast<int32_t>(DialCallType::IMS_VIDEO_DIAL);
78 } else {
79 TELEPHONY_LOGE("WriteDialCallBehaviorEvent callType is out of range!");
80 return;
81 }
82 HiWriteBehaviorEvent(
83 DIAL_EVENT, SLOT_ID_KEY, info.slotId, CALL_TYPE_KEY, type, RESULT_KEY, static_cast<int32_t>(result));
84 }
85
WriteHangUpCallBehaviorEvent(const CallBehaviorParameterInfo & info,const CallResponseResult & result)86 void CellularCallHiSysEvent::WriteHangUpCallBehaviorEvent(
87 const CallBehaviorParameterInfo &info, const CallResponseResult &result)
88 {
89 int32_t type = 0;
90 if (info.callType == CS_CALL_TYPE && info.videoState == VOICE_TYPE) {
91 type = static_cast<int32_t>(HangUpCallType::CS_VOICE_CALL);
92 } else if (info.callType == IMS_CALL_TYPE && info.videoState == VOICE_TYPE) {
93 type = static_cast<int32_t>(HangUpCallType::IMS_VOICE_CALL);
94 } else if (info.callType == IMS_CALL_TYPE && info.videoState == VIDEO_TYPE) {
95 type = static_cast<int32_t>(HangUpCallType::IMS_VIDEO_CALL);
96 } else {
97 TELEPHONY_LOGE("WriteHangUpCallBehaviorEvent callType is out of range!");
98 return;
99 }
100 HiWriteBehaviorEvent(
101 HANG_UP_EVENT, SLOT_ID_KEY, info.slotId, CALL_TYPE_KEY, type, RESULT_KEY, static_cast<int32_t>(result));
102 }
103
WriteAnswerCallBehaviorEvent(const CallBehaviorParameterInfo & info,const CallResponseResult & result)104 void CellularCallHiSysEvent::WriteAnswerCallBehaviorEvent(
105 const CallBehaviorParameterInfo &info, const CallResponseResult &result)
106 {
107 int32_t type = 0;
108 if (info.incomingCallType == IMS_CALL_TYPE && info.incomingVideoState == VOICE_TYPE &&
109 info.callType == IMS_CALL_TYPE && info.videoState == VOICE_TYPE) {
110 type = static_cast<int32_t>(AnswerCallType::IMS_VOICE_ANSWER);
111 } else if (info.incomingCallType == IMS_CALL_TYPE && info.incomingVideoState == VIDEO_TYPE &&
112 info.callType == IMS_CALL_TYPE && info.videoState == VOICE_TYPE) {
113 type = static_cast<int32_t>(AnswerCallType::IMS_VIDEO_TO_VOICE_ANSWER);
114 } else if (info.incomingCallType == IMS_CALL_TYPE && info.incomingVideoState == VIDEO_TYPE &&
115 info.callType == IMS_CALL_TYPE && info.videoState == VIDEO_TYPE) {
116 type = static_cast<int32_t>(AnswerCallType::IMS_VIDEO_TO_VIDEO_ANSWER);
117 } else if (info.incomingCallType == CS_CALL_TYPE && info.incomingVideoState == VOICE_TYPE &&
118 info.callType == CS_CALL_TYPE && info.videoState == VOICE_TYPE) {
119 type = static_cast<int32_t>(AnswerCallType::CS_VOICE_ANSWER);
120 } else {
121 TELEPHONY_LOGE("WriteAnswerCallBehaviorEvent callType is out of range!");
122 return;
123 }
124 HiWriteBehaviorEvent(
125 ANSWER_EVENT, SLOT_ID_KEY, info.slotId, CALL_TYPE_KEY, type, RESULT_KEY, static_cast<int32_t>(result));
126 }
127
WriteIncomingCallFaultEvent(const int32_t slotId,const int32_t callType,const int32_t videoState,const int32_t errCode,const std::string & desc)128 void CellularCallHiSysEvent::WriteIncomingCallFaultEvent(const int32_t slotId, const int32_t callType,
129 const int32_t videoState, const int32_t errCode, const std::string &desc)
130 {
131 CallErrorCode value = CallErrorCode::CALL_ERROR_NONE;
132 if (ErrorCodeConversion(errCode, value)) {
133 HiWriteFaultEvent(CALL_INCOMING_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
134 CALL_TYPE_KEY, callType, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, static_cast<int32_t>(value),
135 ERROR_MSG_KEY, desc);
136 } else {
137 HiWriteFaultEvent(CALL_INCOMING_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
138 CALL_TYPE_KEY, callType, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, errCode, ERROR_MSG_KEY, desc);
139 }
140 }
141
WriteDialCallFaultEvent(const int32_t slotId,const int32_t callType,const int32_t videoState,const int32_t errorCode,const std::string & desc)142 void CellularCallHiSysEvent::WriteDialCallFaultEvent(const int32_t slotId, const int32_t callType,
143 const int32_t videoState, const int32_t errorCode, const std::string &desc)
144 {
145 CallErrorCode value = CallErrorCode::CALL_ERROR_NONE;
146 if (ErrorCodeConversion(errorCode, value)) {
147 HiWriteFaultEvent(CALL_DIAL_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
148 CALL_TYPE_KEY, callType, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, static_cast<int32_t>(value),
149 ERROR_MSG_KEY, desc);
150 } else {
151 HiWriteFaultEvent(CALL_DIAL_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
152 CALL_TYPE_KEY, callType, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, errorCode, ERROR_MSG_KEY, desc);
153 }
154 }
155
WriteAnswerCallFaultEvent(const int32_t slotId,const int32_t callId,const int32_t videoState,const int32_t errorCode,const std::string & desc)156 void CellularCallHiSysEvent::WriteAnswerCallFaultEvent(const int32_t slotId, const int32_t callId,
157 const int32_t videoState, const int32_t errorCode, const std::string &desc)
158 {
159 CallErrorCode value = CallErrorCode::CALL_ERROR_NONE;
160 if (ErrorCodeConversion(errorCode, value)) {
161 HiWriteFaultEvent(CALL_ANSWER_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
162 CALL_ID_KEY, callId, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, static_cast<int32_t>(value),
163 ERROR_MSG_KEY, desc);
164 } else {
165 HiWriteFaultEvent(CALL_ANSWER_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
166 CALL_ID_KEY, callId, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, errorCode, ERROR_MSG_KEY, desc);
167 }
168 }
169
WriteHangUpFaultEvent(const int32_t slotId,const int32_t callId,const int32_t errorCode,const std::string & desc)170 void CellularCallHiSysEvent::WriteHangUpFaultEvent(
171 const int32_t slotId, const int32_t callId, const int32_t errorCode, const std::string &desc)
172 {
173 CallErrorCode value = CallErrorCode::CALL_ERROR_NONE;
174 if (ErrorCodeConversion(errorCode, value)) {
175 HiWriteFaultEvent(CALL_HANGUP_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
176 CALL_ID_KEY, callId, ERROR_TYPE_KEY, static_cast<int32_t>(value), ERROR_MSG_KEY, desc);
177 } else {
178 HiWriteFaultEvent(CALL_HANGUP_FAILED_EVENT, MODULE_NAME_KEY, CELLULAR_CALL_MODULE, SLOT_ID_KEY, slotId,
179 CALL_ID_KEY, callId, ERROR_TYPE_KEY, errorCode, ERROR_MSG_KEY, desc);
180 }
181 }
182
WriteVoNRSwitchChangeEvent(const int32_t enable)183 void CellularCallHiSysEvent::WriteVoNRSwitchChangeEvent(const int32_t enable)
184 {
185 HiWriteBehaviorEvent(VONR_SWITCH_STATE_EVENT, SWITCH_KEY, enable);
186 }
187
ErrorCodeConversion(const int32_t errCode,CallErrorCode & eventValue)188 int32_t CellularCallHiSysEvent::ErrorCodeConversion(const int32_t errCode, CallErrorCode &eventValue)
189 {
190 if (CallDataErrorCodeConversion(errCode, eventValue) || CallInterfaceErrorCodeConversion(errCode, eventValue) ||
191 TelephonyErrorCodeConversion(errCode, eventValue)) {
192 return true;
193 }
194 return false;
195 }
196
TelephonyErrorCodeConversion(const int32_t errCode,CallErrorCode & eventValue)197 int32_t CellularCallHiSysEvent::TelephonyErrorCodeConversion(const int32_t errCode, CallErrorCode &eventValue)
198 {
199 switch (errCode) {
200 case static_cast<int32_t>(TELEPHONY_ERR_LOCAL_PTR_NULL):
201 eventValue = CallErrorCode::CALL_ERROR_CALL_LOCAL_PTR_NULL;
202 break;
203 case static_cast<int32_t>(TELEPHONY_ERR_ARGUMENT_INVALID):
204 eventValue = CallErrorCode::CALL_ERROR_ARGUMENT_INVALID;
205 break;
206 case static_cast<int32_t>(TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL):
207 eventValue = CallErrorCode::CALL_ERROR_IPC_CONNECT_STUB_FAIL;
208 break;
209 case static_cast<int32_t>(TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL):
210 eventValue = CallErrorCode::CALL_ERROR_IPC_WRITE_DESCRIPTOR_TOKEN_FAIL;
211 break;
212 case static_cast<int32_t>(TELEPHONY_ERR_WRITE_DATA_FAIL):
213 eventValue = CallErrorCode::CALL_ERROR_IPC_WRITE_DATA_FAIL;
214 break;
215 case static_cast<int32_t>(TELEPHONY_ERR_PERMISSION_ERR):
216 eventValue = CallErrorCode::CALL_ERROR_PERMISSION_ERR;
217 break;
218 case static_cast<int32_t>(TELEPHONY_ERR_MEMSET_FAIL):
219 eventValue = CallErrorCode::CALL_ERROR_MEMSET_FAIL;
220 break;
221 case static_cast<int32_t>(TELEPHONY_ERR_MEMCPY_FAIL):
222 eventValue = CallErrorCode::CALL_ERROR_MEMCPY_FAIL;
223 break;
224 default:
225 return false;
226 }
227
228 return true;
229 }
230
CallDataErrorCodeConversion(const int32_t errCode,CallErrorCode & eventValue)231 int32_t CellularCallHiSysEvent::CallDataErrorCodeConversion(const int32_t errCode, CallErrorCode &eventValue)
232 {
233 switch (errCode) {
234 case static_cast<int32_t>(CALL_ERR_INVALID_SLOT_ID):
235 eventValue = CallErrorCode::CALL_ERROR_INVALID_SLOT_ID;
236 break;
237 case static_cast<int32_t>(CALL_ERR_INVALID_CALLID):
238 eventValue = CallErrorCode::CALL_ERROR_INVALID_CALLID;
239 break;
240 case static_cast<int32_t>(CALL_ERR_PHONE_NUMBER_EMPTY):
241 eventValue = CallErrorCode::CALL_ERROR_PHONE_NUMBER_EMPTY;
242 break;
243 case static_cast<int32_t>(CALL_ERR_NUMBER_OUT_OF_RANGE):
244 eventValue = CallErrorCode::CALL_ERROR_NUMBER_OUT_OF_RANGE;
245 break;
246 case static_cast<int32_t>(CALL_ERR_UNSUPPORTED_NETWORK_TYPE):
247 eventValue = CallErrorCode::CALL_ERROR_UNSUPPORTED_NETWORK_TYPE;
248 break;
249 case static_cast<int32_t>(CALL_ERR_INVALID_DIAL_SCENE):
250 eventValue = CallErrorCode::CALL_ERROR_INVALID_DIAL_SCENE;
251 break;
252 case static_cast<int32_t>(CALL_ERR_INVALID_VIDEO_STATE):
253 eventValue = CallErrorCode::CALL_ERROR_INVALID_VIDEO_STATE;
254 break;
255 case static_cast<int32_t>(CALL_ERR_UNKNOW_DIAL_TYPE):
256 eventValue = CallErrorCode::CALL_ERROR_UNKNOW_DIAL_TYPE;
257 break;
258 case static_cast<int32_t>(CALL_ERR_UNKNOW_CALL_TYPE):
259 eventValue = CallErrorCode::CALL_ERROR_UNKNOW_CALL_TYPE;
260 break;
261 case static_cast<int32_t>(CALL_ERR_CALL_OBJECT_IS_NULL):
262 eventValue = CallErrorCode::CALL_ERROR_CALL_OBJECT_IS_NULL;
263 break;
264 default:
265 return false;
266 }
267 return true;
268 }
269
CallInterfaceErrorCodeConversion(const int32_t errCode,CallErrorCode & eventValue)270 int32_t CellularCallHiSysEvent::CallInterfaceErrorCodeConversion(const int32_t errCode, CallErrorCode &eventValue)
271 {
272 switch (errCode) {
273 case static_cast<int32_t>(CALL_ERR_DIAL_IS_BUSY):
274 eventValue = CallErrorCode::CALL_ERROR_DIAL_IS_BUSY;
275 break;
276 case static_cast<int32_t>(CALL_ERR_ILLEGAL_CALL_OPERATION):
277 eventValue = CallErrorCode::CALL_ERROR_ILLEGAL_CALL_OPERATION;
278 break;
279 case static_cast<int32_t>(CALL_ERR_PHONE_CALLSTATE_NOTIFY_FAILED):
280 eventValue = CallErrorCode::CALL_ERROR_PHONE_CALLSTATE_NOTIFY_FAILED;
281 break;
282 case static_cast<int32_t>(CALL_ERR_SYSTEM_EVENT_HANDLE_FAILURE):
283 eventValue = CallErrorCode::CALL_ERROR_SYSTEM_EVENT_HANDLE_FAILURE;
284 break;
285 case static_cast<int32_t>(CALL_ERR_CALL_COUNTS_EXCEED_LIMIT):
286 eventValue = CallErrorCode::CALL_ERROR_CALL_COUNTS_EXCEED_LIMIT;
287 break;
288 case static_cast<int32_t>(CALL_ERR_GET_RADIO_STATE_FAILED):
289 eventValue = CallErrorCode::CALL_ERROR_GET_RADIO_STATE_FAILED;
290 break;
291 default:
292 return false;
293 }
294
295 return true;
296 }
297
SetCallParameterInfo(const int32_t slotId,const int32_t callType,const int32_t videoState)298 void CellularCallHiSysEvent::SetCallParameterInfo(
299 const int32_t slotId, const int32_t callType, const int32_t videoState)
300 {
301 dfxSlotId_ = slotId;
302 dfxCallType_ = callType;
303 dfxVideoState_ = videoState;
304 }
305
SetIncomingCallParameterInfo(const int32_t incomingCallType,const int32_t incomingVideoState)306 void CellularCallHiSysEvent::SetIncomingCallParameterInfo(
307 const int32_t incomingCallType, const int32_t incomingVideoState)
308 {
309 dfxIncomingCallType_ = incomingCallType;
310 dfxIncomingVideoState_ = incomingVideoState;
311 }
312
GetCallParameterInfo(CallBehaviorParameterInfo & info)313 void CellularCallHiSysEvent::GetCallParameterInfo(CallBehaviorParameterInfo &info)
314 {
315 info.slotId = dfxSlotId_;
316 info.callType = dfxCallType_;
317 info.videoState = dfxVideoState_;
318 info.incomingCallType = dfxIncomingCallType_;
319 info.incomingVideoState = dfxIncomingVideoState_;
320 }
321
SetIncomingStartTime()322 void CellularCallHiSysEvent::SetIncomingStartTime()
323 {
324 incomingStartTime_ =
325 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
326 .count();
327 }
328
JudgingIncomingTimeOut(const int32_t slotId,const int32_t callType,const int32_t videoState)329 void CellularCallHiSysEvent::JudgingIncomingTimeOut(
330 const int32_t slotId, const int32_t callType, const int32_t videoState)
331 {
332 int64_t incomingEndTime =
333 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
334 .count();
335 if ((incomingEndTime - incomingStartTime_) > NORMAL_INCOMING_TIME) {
336 WriteIncomingCallFaultEvent(slotId, callType, videoState,
337 static_cast<int32_t>(CallErrorCode::CALL_ERROR_INCOMING_TIME_OUT),
338 "incoming time out " + std::to_string(incomingStartTime_ - incomingEndTime));
339 }
340 }
341
SetCallForwardingInfo(const int32_t slotId,const bool enable,const std::string & number)342 void CellularCallHiSysEvent::SetCallForwardingInfo(const int32_t slotId, const bool enable, const std::string &number)
343 {
344 callForwardingSlotId_ = slotId;
345 callForwardingEnable_ = enable;
346 callForwardingNumber_ = number;
347 }
348
GetCallForwardingInfo(CallForwardingInfo & info)349 void CellularCallHiSysEvent::GetCallForwardingInfo(CallForwardingInfo &info)
350 {
351 info.slotId = callForwardingSlotId_;
352 info.enable = callForwardingEnable_;
353
354 size_t cpyLen = callForwardingNumber_.length() + 1;
355 if (callForwardingNumber_.length() > static_cast<size_t>(maxNumberLen)) {
356 return;
357 }
358 if (strcpy_s(info.number, cpyLen, callForwardingNumber_.c_str()) != EOK) {
359 TELEPHONY_LOGE("strcpy_s fail.");
360 return;
361 }
362 }
363 } // namespace Telephony
364 } // namespace OHOS
365