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