1/*
2 * Copyright (c) 2022-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 "dfx_hisysevent.h"
17
18#include <fstream>
19
20#include "i_input_windows_manager.h"
21#include "parameters.h"
22
23#undef MMI_LOG_DOMAIN
24#define MMI_LOG_DOMAIN MMI_LOG_SERVER
25#undef MMI_LOG_TAG
26#define MMI_LOG_TAG "DfxHisysevent"
27
28namespace OHOS {
29namespace MMI {
30namespace {
31constexpr int32_t INVALID_DEVICE_ID { -1 };
32constexpr uint32_t REPORT_DISPATCH_TIMES { 100 };
33constexpr uint32_t REPORT_COMBO_START_TIMES { 100 };
34constexpr uint32_t POINTER_CLEAR_TIMES { 10 };
35constexpr int32_t CONVERSION_US_TO_MS { 1000 };
36constexpr int32_t TIMES_LEVEL1 { 10 };
37constexpr int32_t TIMES_LEVEL2 { 25 };
38constexpr int32_t TIMES_LEVEL3 { 30 };
39constexpr int32_t TIMES_LEVEL4 { 50 };
40constexpr int32_t FINGERSENSE_EVENT_TIMES { 1 };
41constexpr size_t SINGLE_KNUCKLE_SIZE { 1 };
42constexpr size_t DOUBLE_KNUCKLE_SIZE { 2 };
43constexpr int32_t FAIL_SUCC_TIME_DIFF { 3 * 60 * 1000 };
44constexpr int32_t MIN_GESTURE_TIMESTAMPS_SIZE { 2 };
45constexpr int32_t DOWN_TO_PREV_UP_MAX_TIME_THRESHOLD { 1000 * 1000 };
46constexpr int32_t FOLDABLE_DEVICE { 2 };
47const int32_t ROTATE_POLICY = system::GetIntParameter("const.window.device.rotate_policy", 0);
48const std::string EMPTY_STRING { "" };
49const std::string LCD_PATH { "/sys/class/graphics/fb0/lcd_model" };
50const std::string ACC_PATH { "/sys/devices/platform/_sensor/acc_info" };
51const std::string ACC0_PATH { "/sys/class/sensors/acc_sensor/info" };
52const std::string TP_PATH { "/sys/touchscreen/touch_chip_info" };
53const std::string TP0_PATH { "/sys/touchscreen0/touch_chip_info" };
54const std::string TP1_PATH { "/sys/touchscreen1/touch_chip_info" };
55} // namespace
56
57static std::string GetVendorInfo(const std::string &nodePath)
58{
59    char realPath[PATH_MAX] = {};
60    if (realpath(nodePath.c_str(), realPath) == nullptr) {
61        MMI_HILOGE("The realpath return nullptr");
62        return "";
63    }
64    std::ifstream file(realPath);
65    if (!file.is_open()) {
66        MMI_HILOGE("Unable to open file:%{public}s, error:%{public}d", nodePath.c_str(), errno);
67        return "";
68    }
69    std::string vendorInfo;
70    file >> vendorInfo;
71    file.close();
72    return vendorInfo;
73}
74
75void DfxHisysevent::OnDeviceConnect(int32_t id, OHOS::HiviewDFX::HiSysEvent::EventType type)
76{
77    std::shared_ptr<InputDevice> dev = INPUT_DEV_MGR->GetInputDevice(id);
78    CHKPV(dev);
79    std::string message;
80    std::string name;
81    if (type == OHOS::HiviewDFX::HiSysEvent::EventType::FAULT) {
82        message = "The input_device connection failed for already existing";
83        name = "INPUT_DEV_CONNECTION_FAILURE";
84    } else {
85        message = "The input_device connection succeed";
86        name = "INPUT_DEV_CONNECTION_SUCCESS";
87    }
88    if (id == INT32_MAX) {
89        int32_t ret = HiSysEventWrite(
90            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
91            name,
92            type,
93            "MSG", "The input_device connection failed because the nextId_ exceeded the upper limit");
94        if (ret != 0) {
95            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
96        }
97    } else {
98        int32_t ret = HiSysEventWrite(
99            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
100            name,
101            type,
102            "DEVICE_ID", id,
103            "DEVICE_PHYS", dev->GetPhys(),
104            "DEVICE_NAME", dev->GetName(),
105            "DEVICE_TYPE", dev->GetType(),
106            "MSG", message);
107        if (ret != 0) {
108            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
109        }
110    }
111}
112
113void DfxHisysevent::OnDeviceDisconnect(int32_t id, OHOS::HiviewDFX::HiSysEvent::EventType type)
114{
115    if (id == INVALID_DEVICE_ID) {
116        int32_t ret = HiSysEventWrite(
117            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
118            "INPUT_DEV_DISCONNECTION_FAILURE",
119            type,
120            "MSG", "The input device failed to disconnect to server");
121        if (ret != 0) {
122            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
123        }
124    } else {
125        std::shared_ptr dev = INPUT_DEV_MGR->GetInputDevice(id);
126        CHKPV(dev);
127        int32_t ret = HiSysEventWrite(
128            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
129            "INPUT_DEV_DISCONNECTION_SUCCESS",
130            type,
131            "DEVICE_Id", id,
132            "DEVICE_PHYS", dev->GetPhys(),
133            "DEVICE_NAME", dev->GetName(),
134            "DEVICE_TYPE", dev->GetType(),
135            "MSG", "The input device successfully disconnect to server");
136        if (ret != 0) {
137            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
138        }
139    }
140}
141
142void DfxHisysevent::OnClientConnect(const ClientConnectData &data, OHOS::HiviewDFX::HiSysEvent::EventType type)
143{
144    if (type == OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR) {
145        int32_t ret = HiSysEventWrite(
146            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
147            "CLIENT_CONNECTION_SUCCESS",
148            type,
149            "PID", data.pid,
150            "UID", data.uid,
151            "MODULE_TYPE", data.moduleType,
152            "SERVER_FD", data.serverFd,
153            "PROGRAMNAME", data.programName,
154            "MSG", "The client successfully connected to the server");
155        if (ret != 0) {
156            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
157        }
158    } else {
159        int32_t ret = HiSysEventWrite(
160            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
161            "CLIENT_CONNECTION_FAILURE",
162            type,
163            "PID", data.pid,
164            "UID", data.uid,
165            "MODULE_TYPE", data.moduleType,
166            "PROGRAMNAME", data.programName,
167            "MSG", "The client failed to connect to the server");
168        if (ret != 0) {
169            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
170        }
171    }
172}
173
174void DfxHisysevent::OnClientDisconnect(const SessionPtr& secPtr, int32_t fd,
175    OHOS::HiviewDFX::HiSysEvent::EventType type)
176{
177    CHKPV(secPtr);
178    if (type == OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR) {
179        int32_t ret = HiSysEventWrite(
180            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
181            "CLIENT_DISCONNECTION_SUCCESS",
182            type,
183            "PID", secPtr->GetPid(),
184            "UID", secPtr->GetUid(),
185            "MODULE_TYPE", secPtr->GetModuleType(),
186            "FD", fd,
187            "PROGRAMNAME", secPtr->GetProgramName(),
188            "MSG", "The client successfully disconnected to the server");
189        if (ret != 0) {
190            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
191        }
192    } else {
193        if (secPtr == nullptr) {
194            int32_t ret = HiSysEventWrite(
195                OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
196                "CLIENT_DISCONNECTION_FAILURE",
197                type,
198                "MSG", "The client failed to disconnect to the server because secPtr is nullptr");
199            if (ret != 0) {
200                MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
201            }
202        } else {
203            int32_t ret = HiSysEventWrite(
204                OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
205                "CLIENT_DISCONNECTION_FAILURE",
206                type,
207                "MSG", "The client failed to disconnect to the server because close(fd) return error");
208            if (ret != 0) {
209                MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
210            }
211        }
212    }
213}
214
215void DfxHisysevent::OnUpdateTargetPointer(std::shared_ptr<PointerEvent> pointer, int32_t fd,
216    OHOS::HiviewDFX::HiSysEvent::EventType type)
217{
218    CHKPV(pointer);
219    if (type == OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR) {
220        int32_t ret = HiSysEventWrite(
221            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
222            "TARGET_POINTER_EVENT_SUCCESS",
223            type,
224            "EVENTTYPE", pointer->GetEventType(),
225            "AGENT_WINDOWID", pointer->GetAgentWindowId(),
226            "TARGET_WINDOWID", pointer->GetTargetWindowId(),
227            "PID", WIN_MGR->GetWindowPid(pointer->GetTargetWindowId()),
228            "FD", fd,
229            "MSG", "The window manager successfully update target pointer");
230        if (ret != 0) {
231            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
232        }
233    } else {
234        int32_t ret = HiSysEventWrite(
235            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
236            "TARGET_POINTER_EVENT_FAILURE",
237            OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
238            "EVENTTYPE", pointer->GetEventType(),
239            "MSG", "The window manager failed to update target pointer");
240        if (ret != 0) {
241            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
242        }
243    }
244}
245
246void DfxHisysevent::OnUpdateTargetKey(std::shared_ptr<KeyEvent> key, int32_t fd,
247    OHOS::HiviewDFX::HiSysEvent::EventType type)
248{
249    CHKPV(key);
250    if (type == OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR) {
251        int32_t ret = HiSysEventWrite(
252            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
253            "TARGET_KEY_EVENT_SUCCESS",
254            type,
255            "EVENTTYPE", key->GetEventType(),
256            "KEYCODE", key->GetKeyCode(),
257            "ACTION", key->GetAction(),
258            "ACTION_TIME", key->GetActionTime(),
259            "ACTION_STARTTIME", key->GetActionStartTime(),
260            "FLAG", key->GetFlag(),
261            "KEYACTION", key->GetKeyAction(),
262            "FD", fd,
263            "AGENT_WINDOWID", key->GetAgentWindowId(),
264            "TARGET_WINDOWID", key->GetTargetWindowId(),
265            "PID", WIN_MGR->GetWindowPid(key->GetTargetWindowId()),
266            "MSG", "The window manager successfully update target key");
267        if (ret != 0) {
268            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
269        }
270    } else {
271        int32_t ret = HiSysEventWrite(
272            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
273            "TARGET_KEY_EVENT_FAILURE",
274            type,
275            "EVENTTYPE", key->GetEventType(),
276            "KEYCODE", key->GetKeyCode(),
277            "ACTION", key->GetAction(),
278            "ACTION_TIME", key->GetActionTime(),
279            "ACTION_STARTTIME", key->GetActionStartTime(),
280            "FLAG", key->GetFlag(),
281            "KEYACTION", key->GetKeyAction(),
282            "MSG", "The window manager failed to update target key");
283        if (ret != 0) {
284            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
285        }
286    }
287}
288
289void DfxHisysevent::OnFocusWindowChanged(int32_t oldFocusWindowId, int32_t newFocusWindowId,
290    int32_t oldFocusWindowPid, int32_t newFocusWindowPid)
291{
292    int32_t ret = HiSysEventWrite(
293        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
294        "FOCUS_WINDOW_CHANGE",
295        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
296        "OLD_FOCUS_WINDOWID", oldFocusWindowId,
297        "NEW_FOCUS_WINDOWID", newFocusWindowId,
298        "OLD_FOCUS_WINDOWPID", oldFocusWindowPid,
299        "NEW_FOCUS_WINDOWPID", newFocusWindowPid,
300        "MSG", "The focusWindowId changing succeeded");
301    if (ret != 0) {
302        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
303    }
304}
305
306void DfxHisysevent::OnZorderWindowChanged(int32_t oldZorderFirstWindowId, int32_t newZorderFirstWindowId,
307    int32_t oldZorderFirstWindowPid, int32_t newZorderFirstWindowPid)
308{
309    int32_t ret = HiSysEventWrite(
310        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
311        "Z_ORDER_WINDOW_CHANGE",
312        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
313        "OLD_ZORDER_FIRST_WINDOWID", oldZorderFirstWindowId,
314        "NEW_ZORDER_FIRST_WINDOWID", newZorderFirstWindowId,
315        "OLD_ZORDER_FIRST_WINDOWPID", oldZorderFirstWindowPid,
316        "NEW_ZORDER_FIRST_WINDOWPID", newZorderFirstWindowPid,
317        "MSG", "The ZorderFirstWindow changing succeeded");
318    if (ret != 0) {
319        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
320    }
321}
322
323void DfxHisysevent::OnLidSwitchChanged(int32_t lidSwitch)
324{
325    int32_t ret = HiSysEventWrite(
326        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
327        "LID_SWITCH",
328        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
329        "SWITCH", lidSwitch);
330    if (ret != 0) {
331        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
332    }
333}
334
335void DfxHisysevent::ApplicationBlockInput(const SessionPtr& sess)
336{
337    int32_t ret = HiSysEventWrite(
338        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
339        "APPLICATION_BLOCK_INPUT",
340        OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
341        "PID", sess->GetPid(),
342        "UID", sess->GetUid(),
343        "PACKAGE_NAME", sess->GetProgramName(),
344        "PROCESS_NAME", sess->GetProgramName(),
345        "MSG", "User input does not respond");
346    if (ret != 0) {
347        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
348    }
349}
350
351void DfxHisysevent::CalcKeyDispTimes()
352{
353    int64_t endTime = GetSysClockTime();
354    dispCastTime_.totalTimes++;
355    int64_t castTime = (endTime - dispatchStartTime_) / CONVERSION_US_TO_MS;
356    if (castTime <= TIMES_LEVEL1) {
357        dispCastTime_.below10msTimes++;
358    } else if (castTime <= TIMES_LEVEL2) {
359        dispCastTime_.below25msTimes++;
360    } else if (castTime <= TIMES_LEVEL4) {
361        dispCastTime_.below50msTimes++;
362    } else {
363        dispCastTime_.above50msTimes++;
364    }
365}
366
367void DfxHisysevent::CalcPointerDispTimes()
368{
369    int64_t endTime = GetSysClockTime();
370    dispCastTime_.sampleCount++;
371    int64_t castTime = (endTime - dispatchStartTime_) / CONVERSION_US_TO_MS;
372    if (dispCastTime_.sampleCount == POINTER_CLEAR_TIMES) {
373        dispCastTime_.sampleCount = 0;
374        dispCastTime_.totalTimes++;
375        if (castTime <= TIMES_LEVEL1) {
376            dispCastTime_.below10msTimes++;
377        } else if (castTime <= TIMES_LEVEL2) {
378            dispCastTime_.below25msTimes++;
379        } else if (castTime <= TIMES_LEVEL4) {
380            dispCastTime_.below50msTimes++;
381        } else {
382            dispCastTime_.above50msTimes++;
383        }
384    }
385}
386
387void DfxHisysevent::ReportDispTimes()
388{
389    if (dispCastTime_.totalTimes >= REPORT_DISPATCH_TIMES) {
390        int32_t ret = HiSysEventWrite(
391            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
392            "INPUT_DISPATCH_TIME",
393            OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
394            "BELOW10MS", dispCastTime_.below10msTimes,
395            "BELOW25MS", dispCastTime_.below25msTimes,
396            "BELOW50MS", dispCastTime_.below50msTimes,
397            "ABOVE50MS", dispCastTime_.above50msTimes,
398            "MSG", "The costing time to dispatch event");
399        if (ret != 0) {
400            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
401        } else {
402            dispCastTime_.sampleCount = 0;
403            dispCastTime_.totalTimes = 0;
404            dispCastTime_.below10msTimes = 0;
405            dispCastTime_.below25msTimes = 0;
406            dispCastTime_.below50msTimes = 0;
407            dispCastTime_.above50msTimes = 0;
408        }
409    }
410}
411
412void DfxHisysevent::CalcComboStartTimes(const int32_t keyDownDuration)
413{
414    int64_t endTime = GetSysClockTime();
415    comboStartCastTime_.totalTimes++;
416    int64_t castTime = (endTime - comboStartTime_) / CONVERSION_US_TO_MS - keyDownDuration;
417    if (castTime <= TIMES_LEVEL1) {
418        comboStartCastTime_.below10msTimes++;
419    } else if (castTime <= TIMES_LEVEL3) {
420        comboStartCastTime_.below30msTimes++;
421    } else if (castTime <= TIMES_LEVEL4) {
422        comboStartCastTime_.below50msTimes++;
423    } else {
424        comboStartCastTime_.above50msTimes++;
425    }
426}
427
428void DfxHisysevent::ReportComboStartTimes()
429{
430    if (comboStartCastTime_.totalTimes >= REPORT_COMBO_START_TIMES) {
431        int32_t ret = HiSysEventWrite(
432            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
433            "COMBO_START_TIME",
434            OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
435            "BELOW10MS", comboStartCastTime_.below10msTimes,
436            "BELOW30MS", comboStartCastTime_.below30msTimes,
437            "BELOW50MS", comboStartCastTime_.below50msTimes,
438            "ABOVE50MS", comboStartCastTime_.above50msTimes,
439            "MSG", "The costing time to launch application of combination");
440        if (ret != 0) {
441            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
442        } else {
443            comboStartCastTime_.totalTimes = 0;
444            comboStartCastTime_.below10msTimes = 0;
445            comboStartCastTime_.below30msTimes = 0;
446            comboStartCastTime_.below50msTimes = 0;
447            comboStartCastTime_.above50msTimes = 0;
448        }
449    }
450}
451
452void DfxHisysevent::ReportPowerInfo(std::shared_ptr<KeyEvent> key, OHOS::HiviewDFX::HiSysEvent::EventType type)
453{
454    CHKPV(key);
455    if (key->GetKeyAction() == KeyEvent::KEY_ACTION_UP) {
456        int32_t ret = HiSysEventWrite(
457            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
458            "INPUT_POWER_UP",
459            type);
460        if (ret != RET_OK) {
461            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
462        }
463    } else if (key->GetKeyAction() == KeyEvent::KEY_ACTION_DOWN) {
464        int32_t ret = HiSysEventWrite(
465            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
466            "INPUT_POWER_DOWN",
467            type);
468        if (ret != RET_OK) {
469            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
470        }
471    } else {
472        MMI_HILOGW("Press power key is error");
473    }
474}
475
476void DfxHisysevent::StatisticTouchpadGesture(std::shared_ptr<PointerEvent> pointerEvent)
477{
478    CHKPV(pointerEvent);
479    int32_t pointerAction = pointerEvent->GetPointerAction();
480    int32_t fingerCount = pointerEvent->GetFingerCount();
481
482    if (pointerAction == PointerEvent::POINTER_ACTION_AXIS_BEGIN) {
483        int32_t ret = HiSysEventWrite(
484            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
485            "TOUCHPAD_PINCH",
486            OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
487            "FINGER_COUNT", fingerCount);
488        if (ret != RET_OK) {
489            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
490        }
491    } else if (pointerAction == PointerEvent::POINTER_ACTION_SWIPE_BEGIN) {
492        int32_t ret = HiSysEventWrite(
493            OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
494            "TOUCHPAD_SWIPE",
495            OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
496            "FINGER_COUNT", fingerCount);
497        if (ret != RET_OK) {
498            MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
499        }
500    } else {
501        MMI_HILOGW("HiviewDFX Statistic touchpad gesture is error, pointer action is invalid");
502    }
503}
504
505void DfxHisysevent::ReportTouchpadSettingState(TOUCHPAD_SETTING_CODE settingCode, bool flag)
506{
507    const std::map<uint32_t, std::string> mapSettingCodeToSettingType = {
508        { TOUCHPAD_SCROLL_SETTING, "TOUCHPAD_SCROLL_SETTING" },
509        { TOUCHPAD_SCROLL_DIR_SETTING, "TOUCHPAD_SCROLL_DIR_SETTING" },
510        { TOUCHPAD_TAP_SETTING, "TOUCHPAD_TAP_SETTING" },
511        { TOUCHPAD_SWIPE_SETTING, "TOUCHPAD_SWIPE_SETTING" },
512        { TOUCHPAD_PINCH_SETTING, "TOUCHPAD_PINCH_SETTING" },
513    };
514
515    auto it = mapSettingCodeToSettingType.find(settingCode);
516    if (it == mapSettingCodeToSettingType.end()) {
517        MMI_HILOGE("HiviewDFX Report touchpad setting state is error, setting code is invalid");
518        return;
519    }
520    std::string name = it->second;
521
522    int32_t ret = HiSysEventWrite(
523        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
524        name,
525        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
526        "SWITCH_STATE", flag);
527    if (ret != RET_OK) {
528        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
529    }
530}
531
532void DfxHisysevent::ReportTouchpadSettingState(TOUCHPAD_SETTING_CODE settingCode, int32_t value)
533{
534    const std::map<uint32_t, std::string> mapSettingCodeToSettingType = {
535        { TOUCHPAD_POINTER_SPEED_SETTING, "TOUCHPAD_POINTER_SPEED_SETTING" },
536        { TOUCHPAD_RIGHT_CLICK_SETTING, "TOUCHPAD_RIGHT_CLICK_SETTING" },
537    };
538
539    auto it = mapSettingCodeToSettingType.find(settingCode);
540    if (it == mapSettingCodeToSettingType.end()) {
541        MMI_HILOGW("HiviewDFX Report touchpad setting state is error, setting code is invalid");
542        return;
543    }
544    std::string name = it->second;
545
546    int32_t ret = HiSysEventWrite(
547        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
548        name,
549        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
550        "SWITCH_VALUE", value);
551    if (ret != RET_OK) {
552        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
553    }
554}
555
556void DfxHisysevent::ReportSingleKnuckleDoubleClickEvent(int32_t intervalTime, int32_t distanceInterval)
557{
558    int32_t ret = HiSysEventWrite(
559        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
560        "FINGERSENSE_KNOCK_EVENT_INFO",
561        OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
562        "SK_S_T", FINGERSENSE_EVENT_TIMES,
563        "SKS_T_I", intervalTime / CONVERSION_US_TO_MS,
564        "DKS_D_I", distanceInterval,
565        "TP_INFO", GetTpVendorName(),
566        "S_INFO", GetAccVendorName(),
567        "LCD_INFO", GetLcdInfo());
568    if (ret != RET_OK) {
569        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
570    }
571}
572
573void DfxHisysevent::ReportFailIfInvalidTime(const std::shared_ptr<PointerEvent> touchEvent, int32_t intervalTime)
574{
575    if (intervalTime >= DOWN_TO_PREV_UP_MAX_TIME_THRESHOLD) {
576        return;
577    }
578    CHKPV(touchEvent);
579    size_t size = touchEvent->GetPointerIds().size();
580    std::string knuckleFailCount;
581    std::string invalidTimeFailCount;
582    if (size == SINGLE_KNUCKLE_SIZE) {
583        knuckleFailCount = "SKF_T_I";
584        invalidTimeFailCount = "SK_F_T";
585    } else if (size == DOUBLE_KNUCKLE_SIZE) {
586        knuckleFailCount = "DKF_T_I";
587        invalidTimeFailCount = "DK_F_T";
588    } else {
589        MMI_HILOGE("HiviewDFX Report knuckle state error, knuckle size:%{public}zu", size);
590        return;
591    }
592    int32_t ret = HiSysEventWrite(
593        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
594        "FINGERSENSE_KNOCK_EVENT_INFO",
595        OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
596        "FSF_T_C", FINGERSENSE_EVENT_TIMES,
597        knuckleFailCount, intervalTime / CONVERSION_US_TO_MS,
598        invalidTimeFailCount, FINGERSENSE_EVENT_TIMES,
599        "TP_INFO", GetTpVendorName(),
600        "S_INFO", GetAccVendorName(),
601        "LCD_INFO", GetLcdInfo());
602    if (ret != RET_OK) {
603        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
604    }
605}
606
607void DfxHisysevent::ReportFailIfInvalidDistance(const std::shared_ptr<PointerEvent> touchEvent, float distance)
608{
609    CHKPV(touchEvent);
610    int32_t ret = HiSysEventWrite(
611        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
612        "FINGERSENSE_KNOCK_EVENT_INFO",
613        OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
614        "SK_F_T", FINGERSENSE_EVENT_TIMES,
615        "DKF_D_I", distance,
616        "FSF_D_C", FINGERSENSE_EVENT_TIMES,
617        "TP_INFO", GetTpVendorName(),
618        "S_INFO", GetAccVendorName(),
619        "LCD_INFO", GetLcdInfo());
620    if (ret != RET_OK) {
621        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
622    }
623}
624
625void DfxHisysevent::ReportKnuckleClickEvent()
626{
627    int32_t ret = HiSysEventWrite(
628        OHOS::HiviewDFX::HiSysEvent::Domain::INPUT_UE,
629        "KNUCKLE_CLICK",
630        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
631        "PNAMEID", EMPTY_STRING,
632        "PVERSIONID", EMPTY_STRING);
633    if (ret != RET_OK) {
634        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
635    }
636}
637
638void DfxHisysevent::ReportScreenCaptureGesture()
639{
640    int32_t ret = HiSysEventWrite(
641        OHOS::HiviewDFX::HiSysEvent::Domain::INPUT_UE,
642        "SINGLE_KNUCKLE_DOUBLE_CLICK",
643        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
644        "PNAMEID", EMPTY_STRING,
645        "PVERSIONID", EMPTY_STRING);
646    if (ret != RET_OK) {
647        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
648    }
649}
650
651#ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
652void DfxHisysevent::ReportMagicCursorColorChange(std::string fill_Color, std::string stroke_Color)
653{
654    int32_t ret = HiSysEventWrite(
655        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
656        "MAGIC_CURSOR_COLOR",
657        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
658        "FILL_COLOR", fill_Color,
659        "STROKE_COLOR", stroke_Color);
660    if (ret != RET_OK) {
661        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
662    }
663}
664
665void DfxHisysevent::ReportMagicCursorShapeChange(std::string fill_Code, OHOS::MMI::MOUSE_ICON mouse_Style)
666{
667    int32_t ret = HiSysEventWrite(
668        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
669        "MAGIC_CURSOR_SHAPE",
670        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
671        "MOUSE_STYLE", mouse_Style,
672        "FILL_CODE", fill_Code);
673    if (ret != RET_OK) {
674        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
675    }
676}
677
678void DfxHisysevent::ReportMagicCursorSizeChange(std::string fill_Code, std::string mouse_Size)
679{
680    int32_t ret = HiSysEventWrite(
681        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
682        "MAGIC_CURSOR_SIZE",
683        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
684        "MOUSE_SIZE", mouse_Size,
685        "FILL_CODE", fill_Code);
686    if (ret != RET_OK) {
687        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
688    }
689}
690
691void DfxHisysevent::ReportMagicCursorFault(std::string error_Code, std::string error_Name)
692{
693    int32_t ret = HiSysEventWrite(
694        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
695        "FANTASY_CURSOR_FAILED",
696        OHOS::HiviewDFX::HiSysEvent::EventType::FAULT,
697        "ERROR_CODE", error_Code,
698        "ERROR_NAME", error_Name);
699    if (ret != RET_OK) {
700        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
701    }
702}
703#endif // OHOS_BUILD_ENABLE_MAGICCURSOR
704
705void DfxHisysevent::ReportSmartShotSuccTimes()
706{
707    int32_t ret = HiSysEventWrite(
708        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
709        "FINGERSENSE_KNOCK_EVENT_INFO",
710        OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
711        "RG_S_T", FINGERSENSE_EVENT_TIMES,
712        "TP_INFO", GetTpVendorName(),
713        "S_INFO", GetAccVendorName(),
714        "LCD_INFO", GetLcdInfo());
715    if (ret != RET_OK) {
716        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
717    }
718}
719
720void DfxHisysevent::ReportKnuckleGestureTrackLength(int32_t knuckleGestureTrackLength)
721{
722    int32_t ret = HiSysEventWrite(
723        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
724        "FINGERSENSE_KNOCK_EVENT_INFO",
725        OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
726        "RG_TRACK_LENGTH", knuckleGestureTrackLength,
727        "TP_INFO", GetTpVendorName(),
728        "S_INFO", GetAccVendorName(),
729        "LCD_INFO", GetLcdInfo());
730    if (ret != RET_OK) {
731        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
732    }
733}
734
735void DfxHisysevent::ReportKnuckleGestureTrackTime(const std::vector<int64_t> &gestureTimeStamps)
736{
737    size_t size = gestureTimeStamps.size();
738    if (size < MIN_GESTURE_TIMESTAMPS_SIZE) {
739        MMI_HILOGE("HiviewDFX Report knuckle gesture track time error, knuckle timestamps size:%{public}zu", size);
740        return;
741    }
742    int32_t knuckleGestureTrackTime = (gestureTimeStamps[size - 1] - gestureTimeStamps[0]) / CONVERSION_US_TO_MS;
743    int32_t ret = HiSysEventWrite(
744        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
745        "FINGERSENSE_KNOCK_EVENT_INFO",
746        OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
747        "RG_TRACK_TIME", knuckleGestureTrackTime,
748        "TP_INFO", GetTpVendorName(),
749        "S_INFO", GetAccVendorName(),
750        "LCD_INFO", GetLcdInfo());
751    if (ret != RET_OK) {
752        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
753    }
754}
755
756void DfxHisysevent::ReportScreenRecorderGesture(int32_t intervalTime)
757{
758    int32_t ret = HiSysEventWrite(
759        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
760        "FINGERSENSE_KNOCK_EVENT_INFO",
761        OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
762        "DK_S_T", FINGERSENSE_EVENT_TIMES,
763        "DKS_T_I", intervalTime / CONVERSION_US_TO_MS,
764        "TP_INFO", GetTpVendorName(),
765        "S_INFO", GetAccVendorName(),
766        "LCD_INFO", GetLcdInfo());
767    if (ret != RET_OK) {
768        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
769    }
770}
771
772void DfxHisysevent::ReportKnuckleGestureFaildTimes()
773{
774    int32_t ret = HiSysEventWrite(
775        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
776        "FINGERSENSE_KNOCK_EVENT_INFO",
777        OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
778        "LG_F_T", FINGERSENSE_EVENT_TIMES,
779        "TP_INFO", GetTpVendorName(),
780        "S_INFO", GetAccVendorName(),
781        "LCD_INFO", GetLcdInfo());
782    if (ret != RET_OK) {
783        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
784    }
785}
786
787void DfxHisysevent::ReportKnuckleDrawSSuccessTimes()
788{
789    int32_t ret = HiSysEventWrite(
790        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
791        "FINGERSENSE_KNOCK_EVENT_INFO",
792        OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
793        "L_S_S_T", FINGERSENSE_EVENT_TIMES,
794        "TP_INFO", GetTpVendorName(),
795        "S_INFO", GetAccVendorName(),
796        "LCD_INFO", GetLcdInfo());
797    if (ret != RET_OK) {
798        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
799    }
800}
801
802void DfxHisysevent::ReportKnuckleGestureFromFailToSuccessTime(int32_t intervalTime)
803{
804    intervalTime /= CONVERSION_US_TO_MS;
805    if (intervalTime < 0 || intervalTime >= FAIL_SUCC_TIME_DIFF) {
806        return;
807    }
808    int32_t ret = HiSysEventWrite(
809        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
810        "FINGERSENSE_KNOCK_EVENT_INFO",
811        OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
812        "RG_F_S_TIME_DIFF", intervalTime,
813        "TP_INFO", GetTpVendorName(),
814        "S_INFO", GetAccVendorName(),
815        "LCD_INFO", GetLcdInfo());
816    if (ret != RET_OK) {
817        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
818    }
819}
820
821void DfxHisysevent::ReportKnuckleGestureFromSuccessToFailTime(int32_t intervalTime)
822{
823    intervalTime /= CONVERSION_US_TO_MS;
824    if (intervalTime < 0 || intervalTime >= FAIL_SUCC_TIME_DIFF) {
825        return;
826    }
827    int32_t ret = HiSysEventWrite(
828        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
829        "FINGERSENSE_KNOCK_EVENT_INFO",
830        OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
831        "RG_S_F_TIME_DIFF", intervalTime,
832        "TP_INFO", GetTpVendorName(),
833        "S_INFO", GetAccVendorName(),
834        "LCD_INFO", GetLcdInfo());
835    if (ret != RET_OK) {
836        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
837    }
838}
839
840void DfxHisysevent::ReportFailIfKnockTooFast()
841{
842    int32_t ret = HiSysEventWrite(
843        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
844        "FINGERSENSE_KNOCK_EVENT_INFO",
845        OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
846        "SK_F_T", FINGERSENSE_EVENT_TIMES,
847        "FSF_C_C", FINGERSENSE_EVENT_TIMES,
848        "TP_INFO", GetTpVendorName(),
849        "S_INFO", GetAccVendorName(),
850        "LCD_INFO", GetLcdInfo());
851    if (ret != RET_OK) {
852        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
853    }
854}
855
856void DfxHisysevent::ReportFailIfOneSuccTwoFail(const std::shared_ptr<PointerEvent> touchEvent)
857{
858    CHKPV(touchEvent);
859    int32_t id = touchEvent->GetPointerId();
860    PointerEvent::PointerItem item;
861    touchEvent->GetPointerItem(id, item);
862    if (item.GetToolType() == PointerEvent::TOOL_TYPE_KNUCKLE) {
863        return;
864    }
865    int32_t ret = HiSysEventWrite(
866        OHOS::HiviewDFX::HiSysEvent::Domain::MULTI_MODAL_INPUT,
867        "FINGERSENSE_KNOCK_EVENT_INFO",
868        OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC,
869        "SK_F_T", FINGERSENSE_EVENT_TIMES,
870        "FSF_1S_2F_C", FINGERSENSE_EVENT_TIMES,
871        "TP_INFO", GetTpVendorName(),
872        "S_INFO", GetAccVendorName(),
873        "LCD_INFO", GetLcdInfo());
874    if (ret != RET_OK) {
875        MMI_HILOGE("HiviewDFX Write failed, ret:%{public}d", ret);
876    }
877}
878
879std::string DfxHisysevent::GetTpVendorName()
880{
881    if (ROTATE_POLICY != FOLDABLE_DEVICE) {
882        return GetVendorInfo(TP_PATH);
883    }
884    auto displayMode = WIN_MGR->GetDisplayMode();
885    if (displayMode == DisplayMode::FULL) {
886        return GetVendorInfo(TP0_PATH);
887    } else if (displayMode == DisplayMode::MAIN) {
888        return GetVendorInfo(TP1_PATH);
889    }
890    return "NA";
891}
892
893std::string DfxHisysevent::GetAccVendorName()
894{
895    if (ROTATE_POLICY != FOLDABLE_DEVICE) {
896        return GetVendorInfo(ACC_PATH);
897    }
898    return GetVendorInfo(ACC0_PATH);
899}
900
901std::string DfxHisysevent::GetLcdInfo()
902{
903    return GetVendorInfo(LCD_PATH);
904}
905} // namespace MMI
906} // namespace OHOS