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