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 "call_manager_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_DIAL_FAILED_EVENT = "CALL_DIAL_FAILED";
26 static constexpr const char *CALL_INCOMING_FAILED_EVENT = "CALL_INCOMING_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 *INCOMING_CALL_EVENT = "INCOMING_CALL";
30 static constexpr const char *CALL_STATE_CHANGED_EVENT = "CALL_STATE";
31
32 // KEY
33 static constexpr const char *MODULE_NAME_KEY = "MODULE";
34 static constexpr const char *SLOT_ID_KEY = "SLOT_ID";
35 static constexpr const char *INDEX_ID_KEY = "INDEX_ID";
36 static constexpr const char *STATE_KEY = "STATE";
37 static constexpr const char *CALL_ID_KEY = "CALL_ID";
38 static constexpr const char *CALL_TYPE_KEY = "CALL_TYPE";
39 static constexpr const char *VIDEO_STATE_KEY = "VIDEO_STATE";
40 static constexpr const char *ERROR_TYPE_KEY = "ERROR_TYPE";
41 static constexpr const char *ERROR_MSG_KEY = "ERROR_MSG";
42
43 // VALUE
44 static constexpr const char *CALL_MANAGER_MODULE = "CALL_MANAGER";
45 static const int32_t CS_CALL_TYPE = 0;
46 static const int32_t IMS_CALL_TYPE = 1;
47 static const int32_t SATELLITE_CALL_TYPE = 5;
48 static const int32_t VOICE_TYPE = 0;
49 static const int32_t VIDEO_TYPE = 1;
50
WriteCallStateBehaviorEvent(const int32_t slotId,const int32_t state,const int32_t index)51 void CallManagerHisysevent::WriteCallStateBehaviorEvent(const int32_t slotId, const int32_t state, const int32_t index)
52 {
53 HiWriteBehaviorEvent(CALL_STATE_CHANGED_EVENT, SLOT_ID_KEY, slotId, STATE_KEY, state, INDEX_ID_KEY, index);
54 }
55
WriteIncomingCallBehaviorEvent(const int32_t slotId,int32_t callType,int32_t callMode)56 void CallManagerHisysevent::WriteIncomingCallBehaviorEvent(const int32_t slotId, int32_t callType, int32_t callMode)
57 {
58 int32_t type = 0;
59 if (callType == IMS_CALL_TYPE && callMode == VOICE_TYPE) {
60 type = static_cast<int32_t>(IncomingCallType::IMS_VOICE_INCOMING);
61 } else if (callType == IMS_CALL_TYPE && callMode == VIDEO_TYPE) {
62 type = static_cast<int32_t>(IncomingCallType::IMS_VIDEO_INCOMING);
63 } else if ((callType == CS_CALL_TYPE || callType == SATELLITE_CALL_TYPE) && callMode == VOICE_TYPE) {
64 type = static_cast<int32_t>(IncomingCallType::CS_VOICE_INCOMING);
65 } else {
66 TELEPHONY_LOGE("WriteIncomingCallBehaviorEvent call incomming arges is out of range!");
67 return;
68 }
69 HiWriteBehaviorEvent(INCOMING_CALL_EVENT, SLOT_ID_KEY, slotId, CALL_TYPE_KEY, type);
70 }
71
WriteIncomingCallFaultEvent(const int32_t slotId,const int32_t callType,const int32_t videoState,const int32_t errCode,const std::string & desc)72 void CallManagerHisysevent::WriteIncomingCallFaultEvent(const int32_t slotId, const int32_t callType,
73 const int32_t videoState, const int32_t errCode, const std::string &desc)
74 {
75 CallErrorCode value = CallErrorCode::CALL_ERROR_NONE;
76 if (ErrorCodeConversion(errCode, value)) {
77 HiWriteFaultEvent(CALL_INCOMING_FAILED_EVENT, MODULE_NAME_KEY, CALL_MANAGER_MODULE, SLOT_ID_KEY, slotId,
78 CALL_TYPE_KEY, callType, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, static_cast<int32_t>(value),
79 ERROR_MSG_KEY, desc);
80 } else {
81 HiWriteFaultEvent(CALL_INCOMING_FAILED_EVENT, MODULE_NAME_KEY, CALL_MANAGER_MODULE, SLOT_ID_KEY, slotId,
82 CALL_TYPE_KEY, callType, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, errCode, ERROR_MSG_KEY, desc);
83 }
84 }
85
WriteDialCallFaultEvent(const int32_t slotId,const int32_t callType,const int32_t videoState,const int32_t errCode,const std::string & desc)86 void CallManagerHisysevent::WriteDialCallFaultEvent(const int32_t slotId, const int32_t callType,
87 const int32_t videoState, const int32_t errCode, const std::string &desc)
88 {
89 CallErrorCode value = CallErrorCode::CALL_ERROR_NONE;
90 if (ErrorCodeConversion(errCode, value)) {
91 HiWriteFaultEvent(CALL_DIAL_FAILED_EVENT, MODULE_NAME_KEY, CALL_MANAGER_MODULE, SLOT_ID_KEY, slotId,
92 CALL_TYPE_KEY, callType, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, static_cast<int32_t>(value),
93 ERROR_MSG_KEY, desc);
94 } else {
95 HiWriteFaultEvent(CALL_DIAL_FAILED_EVENT, MODULE_NAME_KEY, CALL_MANAGER_MODULE, SLOT_ID_KEY, slotId,
96 CALL_TYPE_KEY, callType, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, errCode, ERROR_MSG_KEY, desc);
97 }
98 }
99
WriteAnswerCallFaultEvent(const int32_t slotId,const int32_t callId,const int32_t videoState,const int32_t errCode,const std::string & desc)100 void CallManagerHisysevent::WriteAnswerCallFaultEvent(const int32_t slotId, const int32_t callId,
101 const int32_t videoState, const int32_t errCode, const std::string &desc)
102 {
103 CallErrorCode value = CallErrorCode::CALL_ERROR_NONE;
104 if (ErrorCodeConversion(errCode, value)) {
105 HiWriteFaultEvent(CALL_ANSWER_FAILED_EVENT, MODULE_NAME_KEY, CALL_MANAGER_MODULE, SLOT_ID_KEY, slotId,
106 CALL_ID_KEY, callId, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, static_cast<int32_t>(value),
107 ERROR_MSG_KEY, desc);
108 } else {
109 HiWriteFaultEvent(CALL_ANSWER_FAILED_EVENT, MODULE_NAME_KEY, CALL_MANAGER_MODULE, SLOT_ID_KEY, slotId,
110 CALL_ID_KEY, callId, VIDEO_STATE_KEY, videoState, ERROR_TYPE_KEY, errCode, ERROR_MSG_KEY, desc);
111 }
112 }
113
WriteHangUpFaultEvent(const int32_t slotId,const int32_t callId,const int32_t errCode,const std::string & desc)114 void CallManagerHisysevent::WriteHangUpFaultEvent(
115 const int32_t slotId, const int32_t callId, const int32_t errCode, const std::string &desc)
116 {
117 CallErrorCode value = CallErrorCode::CALL_ERROR_NONE;
118 if (ErrorCodeConversion(errCode, value)) {
119 HiWriteFaultEvent(CALL_HANGUP_FAILED_EVENT, MODULE_NAME_KEY, CALL_MANAGER_MODULE, SLOT_ID_KEY, slotId,
120 CALL_ID_KEY, callId, ERROR_TYPE_KEY, static_cast<int32_t>(value), ERROR_MSG_KEY, desc);
121 } else {
122 HiWriteFaultEvent(CALL_HANGUP_FAILED_EVENT, MODULE_NAME_KEY, CALL_MANAGER_MODULE, SLOT_ID_KEY, slotId,
123 CALL_ID_KEY, callId, ERROR_TYPE_KEY, errCode, ERROR_MSG_KEY, desc);
124 }
125 }
126
GetErrorDescription(const int32_t errCode,std::string & errordesc)127 void CallManagerHisysevent::GetErrorDescription(const int32_t errCode, std::string &errordesc)
128 {
129 switch (errCode) {
130 case CALL_ERR_PHONE_NUMBER_EMPTY:
131 case CALL_ERR_NUMBER_OUT_OF_RANGE:
132 errordesc = "NumberLegalityCheck failed";
133 break;
134 case CALL_ERR_UNKNOW_DIAL_TYPE:
135 case CALL_ERR_INVALID_SLOT_ID:
136 case CALL_ERR_UNKNOW_CALL_TYPE:
137 case CALL_ERR_INVALID_DIAL_SCENE:
138 case CALL_ERR_INVALID_VIDEO_STATE:
139 errordesc = "DialPolicy failed";
140 break;
141 case TELEPHONY_ERR_LOCAL_PTR_NULL:
142 errordesc = errordesc = "CallRequestHandlerPtr_ or handler_ is nullptr";
143 break;
144 case CALL_ERR_SYSTEM_EVENT_HANDLE_FAILURE:
145 errordesc = "Send HANDLER_DIAL_CALL_REQUEST event failed";
146 break;
147 default:
148 break;
149 }
150 }
151
ErrorCodeConversion(const int32_t errCode,CallErrorCode & eventValue)152 int32_t CallManagerHisysevent::ErrorCodeConversion(const int32_t errCode, CallErrorCode &eventValue)
153 {
154 if (CallDataErrorCodeConversion(errCode, eventValue) || CallInterfaceErrorCodeConversion(errCode, eventValue) ||
155 TelephonyErrorCodeConversion(errCode, eventValue)) {
156 TELEPHONY_LOGI("CallManagerHisysevent::ErrorCodeConversion in %{public}d out %{public}d", errCode, eventValue);
157 return true;
158 }
159 return false;
160 }
161
TelephonyErrorCodeConversion(const int32_t errCode,CallErrorCode & eventValue)162 int32_t CallManagerHisysevent::TelephonyErrorCodeConversion(const int32_t errCode, CallErrorCode &eventValue)
163 {
164 switch (errCode) {
165 case static_cast<int32_t>(TELEPHONY_ERR_LOCAL_PTR_NULL):
166 eventValue = CallErrorCode::CALL_ERROR_CALL_LOCAL_PTR_NULL;
167 break;
168 case static_cast<int32_t>(TELEPHONY_ERR_ARGUMENT_INVALID):
169 eventValue = CallErrorCode::CALL_ERROR_ARGUMENT_INVALID;
170 break;
171 case static_cast<int32_t>(TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL):
172 eventValue = CallErrorCode::CALL_ERROR_IPC_CONNECT_STUB_FAIL;
173 break;
174 case static_cast<int32_t>(TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL):
175 eventValue = CallErrorCode::CALL_ERROR_IPC_WRITE_DESCRIPTOR_TOKEN_FAIL;
176 break;
177 case static_cast<int32_t>(TELEPHONY_ERR_WRITE_DATA_FAIL):
178 eventValue = CallErrorCode::CALL_ERROR_IPC_WRITE_DATA_FAIL;
179 break;
180 case static_cast<int32_t>(TELEPHONY_ERR_PERMISSION_ERR):
181 eventValue = CallErrorCode::CALL_ERROR_PERMISSION_ERR;
182 break;
183 case static_cast<int32_t>(TELEPHONY_ERR_MEMSET_FAIL):
184 eventValue = CallErrorCode::CALL_ERROR_MEMSET_FAIL;
185 break;
186 case static_cast<int32_t>(TELEPHONY_ERR_MEMCPY_FAIL):
187 eventValue = CallErrorCode::CALL_ERROR_MEMCPY_FAIL;
188 break;
189 default:
190 return false;
191 }
192
193 return true;
194 }
195
CallDataErrorCodeConversion(const int32_t errCode,CallErrorCode & eventValue)196 int32_t CallManagerHisysevent::CallDataErrorCodeConversion(const int32_t errCode, CallErrorCode &eventValue)
197 {
198 switch (errCode) {
199 case static_cast<int32_t>(CALL_ERR_INVALID_SLOT_ID):
200 eventValue = CallErrorCode::CALL_ERROR_INVALID_SLOT_ID;
201 break;
202 case static_cast<int32_t>(CALL_ERR_INVALID_CALLID):
203 eventValue = CallErrorCode::CALL_ERROR_INVALID_CALLID;
204 break;
205 case static_cast<int32_t>(CALL_ERR_PHONE_NUMBER_EMPTY):
206 eventValue = CallErrorCode::CALL_ERROR_PHONE_NUMBER_EMPTY;
207 break;
208 case static_cast<int32_t>(CALL_ERR_NUMBER_OUT_OF_RANGE):
209 eventValue = CallErrorCode::CALL_ERROR_NUMBER_OUT_OF_RANGE;
210 break;
211 case static_cast<int32_t>(CALL_ERR_UNSUPPORTED_NETWORK_TYPE):
212 eventValue = CallErrorCode::CALL_ERROR_UNSUPPORTED_NETWORK_TYPE;
213 break;
214 case static_cast<int32_t>(CALL_ERR_INVALID_DIAL_SCENE):
215 eventValue = CallErrorCode::CALL_ERROR_INVALID_DIAL_SCENE;
216 break;
217 case static_cast<int32_t>(CALL_ERR_INVALID_VIDEO_STATE):
218 eventValue = CallErrorCode::CALL_ERROR_INVALID_VIDEO_STATE;
219 break;
220 case static_cast<int32_t>(CALL_ERR_UNKNOW_DIAL_TYPE):
221 eventValue = CallErrorCode::CALL_ERROR_UNKNOW_DIAL_TYPE;
222 break;
223 case static_cast<int32_t>(CALL_ERR_UNKNOW_CALL_TYPE):
224 eventValue = CallErrorCode::CALL_ERROR_UNKNOW_CALL_TYPE;
225 break;
226 case static_cast<int32_t>(CALL_ERR_CALL_OBJECT_IS_NULL):
227 eventValue = CallErrorCode::CALL_ERROR_CALL_OBJECT_IS_NULL;
228 break;
229 default:
230 return false;
231 }
232 return true;
233 }
234
CallInterfaceErrorCodeConversion(const int32_t errCode,CallErrorCode & eventValue)235 int32_t CallManagerHisysevent::CallInterfaceErrorCodeConversion(const int32_t errCode, CallErrorCode &eventValue)
236 {
237 switch (errCode) {
238 case static_cast<int32_t>(CALL_ERR_DIAL_IS_BUSY):
239 eventValue = CallErrorCode::CALL_ERROR_DIAL_IS_BUSY;
240 break;
241 case static_cast<int32_t>(CALL_ERR_ILLEGAL_CALL_OPERATION):
242 eventValue = CallErrorCode::CALL_ERROR_ILLEGAL_CALL_OPERATION;
243 break;
244 case static_cast<int32_t>(CALL_ERR_PHONE_CALLSTATE_NOTIFY_FAILED):
245 eventValue = CallErrorCode::CALL_ERROR_PHONE_CALLSTATE_NOTIFY_FAILED;
246 break;
247 case static_cast<int32_t>(CALL_ERR_SYSTEM_EVENT_HANDLE_FAILURE):
248 eventValue = CallErrorCode::CALL_ERROR_SYSTEM_EVENT_HANDLE_FAILURE;
249 break;
250 case static_cast<int32_t>(CALL_ERR_CALL_COUNTS_EXCEED_LIMIT):
251 eventValue = CallErrorCode::CALL_ERROR_CALL_COUNTS_EXCEED_LIMIT;
252 break;
253 case static_cast<int32_t>(CALL_ERR_GET_RADIO_STATE_FAILED):
254 eventValue = CallErrorCode::CALL_ERROR_GET_RADIO_STATE_FAILED;
255 break;
256 default:
257 return false;
258 }
259
260 return true;
261 }
262
SetDialStartTime()263 void CallManagerHisysevent::SetDialStartTime()
264 {
265 dialStartTime_ =
266 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
267 .count();
268 }
269
SetIncomingStartTime()270 void CallManagerHisysevent::SetIncomingStartTime()
271 {
272 incomingStartTime_ =
273 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
274 .count();
275 }
276
SetAnswerStartTime()277 void CallManagerHisysevent::SetAnswerStartTime()
278 {
279 answerStartTime_ =
280 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
281 .count();
282 }
283
JudgingDialTimeOut(const int32_t slotId,const int32_t callType,const int32_t videoState)284 void CallManagerHisysevent::JudgingDialTimeOut(const int32_t slotId, const int32_t callType, const int32_t videoState)
285 {
286 int64_t dialEndTime =
287 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
288 .count();
289 if (dialEndTime - dialStartTime_ > NORMAL_DIAL_TIME) {
290 WriteDialCallFaultEvent(slotId, callType, videoState,
291 static_cast<int32_t>(CallErrorCode::CALL_ERROR_DIAL_TIME_OUT),
292 "dial time out " + std::to_string(dialEndTime - dialStartTime_));
293 }
294 }
295
JudgingIncomingTimeOut(const int32_t slotId,const int32_t callType,const int32_t videoState)296 void CallManagerHisysevent::JudgingIncomingTimeOut(
297 const int32_t slotId, const int32_t callType, const int32_t videoState)
298 {
299 int64_t incomingEndTime =
300 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
301 .count();
302 if (incomingEndTime - incomingStartTime_ > NORMAL_INCOMING_TIME) {
303 WriteIncomingCallFaultEvent(slotId, callType, videoState,
304 static_cast<int32_t>(CallErrorCode::CALL_ERROR_INCOMING_TIME_OUT),
305 "incoming time out " + std::to_string(incomingEndTime - incomingStartTime_));
306 }
307 }
308
JudgingAnswerTimeOut(const int32_t slotId,const int32_t callId,const int32_t videoState)309 void CallManagerHisysevent::JudgingAnswerTimeOut(const int32_t slotId, const int32_t callId, const int32_t videoState)
310 {
311 int64_t answerEndTime =
312 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
313 .count();
314 if (answerEndTime - answerStartTime_ > NORMAL_ANSWER_TIME) {
315 WriteAnswerCallFaultEvent(slotId, callId, videoState,
316 static_cast<int32_t>(CallErrorCode::CALL_ERROR_ANSWER_TIME_OUT),
317 "answer time out " + std::to_string(answerEndTime - answerStartTime_));
318 }
319 }
320 } // namespace Telephony
321 } // namespace OHOS
322