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