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 "event_normalize_handler.h"
17 
18 #include "bytrace_adapter.h"
19 #include "crown_transform_processor.h"
20 #include "define_multimodal.h"
21 #include "dfx_hisysevent.h"
22 #include "error_multimodal.h"
23 #include "event_log_helper.h"
24 #ifdef OHOS_BUILD_ENABLE_TOUCH
25 #include "event_resample.h"
26 #endif // OHOS_BUILD_ENABLE_TOUCH
27 #include "event_statistic.h"
28 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
29 #include "fingerprint_event_processor.h"
30 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
31 #include "input_device_manager.h"
32 #include "input_event_handler.h"
33 #include "input_scene_board_judgement.h"
34 #include "key_auto_repeat.h"
35 #include "key_event_normalize.h"
36 #include "key_event_value_transformation.h"
37 #ifdef SHORTCUT_KEY_MANAGER_ENABLED
38 #include "key_shortcut_manager.h"
39 #endif // SHORTCUT_KEY_MANAGER_ENABLED
40 #include "libinput_adapter.h"
41 #include "mmi_log.h"
42 #include "multimodal_input_preferences_manager.h"
43 #include "time_cost_chk.h"
44 #include "timer_manager.h"
45 #include "touch_event_normalize.h"
46 #ifdef OHOS_BUILD_ENABLE_POINTER
47 #include "touchpad_transform_processor.h"
48 #endif // OHOS_BUILD_ENABLE_POINTER
49 
50 #undef MMI_LOG_DOMAIN
51 #define MMI_LOG_DOMAIN MMI_LOG_HANDLER
52 #undef MMI_LOG_TAG
53 #define MMI_LOG_TAG "EventNormalizeHandler"
54 
55 namespace OHOS {
56 namespace MMI {
57 namespace {
58 constexpr int32_t FINGER_NUM { 2 };
59 constexpr int32_t SWIPE_INWARD_FINGER_ONE { 1 };
60 constexpr int32_t USELIB_ABS_MT_POSITION_X { 0x35 };
61 constexpr int32_t USELIB_ABS_MT_POSITION_Y { 0x36 };
62 constexpr int32_t SWIPE_INWARD_EDGE_X_THRE { 8 };
63 constexpr int32_t SWIPE_INWARD_ANGLE_TOLERANCE { 8 };
64 constexpr int32_t WEBER_PRODUCT_DEVICE_ID { 4274 };
65 double g_touchPadDeviceWidth { 1 }; // physic size
66 double g_touchPadDeviceHeight { 1 };
67 int32_t g_touchPadDeviceAxisX { 1 }; // max axis size
68 int32_t g_touchPadDeviceAxisY { 1 };
69 bool g_isSwipeInward = false;
70 constexpr int32_t SWIPE_INWARD_ANGLE_JUDGE { 2 };
71 constexpr int32_t MT_TOOL_PALM { 2 };
72 [[ maybe_unused ]] constexpr double TOUCH_SLOP { 1.0 };
73 [[ maybe_unused ]] constexpr int32_t SQUARE { 2 };
74 [[ maybe_unused ]] constexpr double DENSITY_BASELINE { 160.0 };
75 const std::vector<int32_t> ALL_EVENT_TYPES = {
76     static_cast<int32_t>(LIBINPUT_EVENT_DEVICE_ADDED),
77     static_cast<int32_t>(LIBINPUT_EVENT_DEVICE_REMOVED),
78     static_cast<int32_t>(LIBINPUT_EVENT_KEYBOARD_KEY),
79     static_cast<int32_t>(LIBINPUT_EVENT_POINTER_MOTION),
80     static_cast<int32_t>(LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE),
81     static_cast<int32_t>(LIBINPUT_EVENT_POINTER_BUTTON),
82     static_cast<int32_t>(LIBINPUT_EVENT_POINTER_BUTTON_TOUCHPAD),
83     static_cast<int32_t>(LIBINPUT_EVENT_POINTER_AXIS),
84     static_cast<int32_t>(LIBINPUT_EVENT_POINTER_TAP),
85     static_cast<int32_t>(LIBINPUT_EVENT_POINTER_MOTION_TOUCHPAD),
86     static_cast<int32_t>(LIBINPUT_EVENT_TOUCHPAD_DOWN),
87     static_cast<int32_t>(LIBINPUT_EVENT_TOUCHPAD_UP),
88     static_cast<int32_t>(LIBINPUT_EVENT_TOUCHPAD_MOTION),
89     static_cast<int32_t>(LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN),
90     static_cast<int32_t>(LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE),
91     static_cast<int32_t>(LIBINPUT_EVENT_GESTURE_SWIPE_END),
92     static_cast<int32_t>(LIBINPUT_EVENT_GESTURE_PINCH_BEGIN),
93     static_cast<int32_t>(LIBINPUT_EVENT_GESTURE_PINCH_UPDATE),
94     static_cast<int32_t>(LIBINPUT_EVENT_GESTURE_PINCH_END),
95     static_cast<int32_t>(LIBINPUT_EVENT_TOUCH_DOWN),
96     static_cast<int32_t>(LIBINPUT_EVENT_TOUCH_UP),
97     static_cast<int32_t>(LIBINPUT_EVENT_TOUCH_MOTION),
98     static_cast<int32_t>(LIBINPUT_EVENT_TABLET_TOOL_AXIS),
99     static_cast<int32_t>(LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY),
100     static_cast<int32_t>(LIBINPUT_EVENT_TABLET_TOOL_TIP),
101     static_cast<int32_t>(LIBINPUT_EVENT_JOYSTICK_BUTTON),
102     static_cast<int32_t>(LIBINPUT_EVENT_JOYSTICK_AXIS),
103     static_cast<int32_t>(LIBINPUT_EVENT_SWITCH_TOGGLE)
104 };
105 constexpr int32_t MAX_N_PRESSED_KEYS { 10 };
106 }
107 
HandleEvent(libinput_event* event, int64_t frameTime)108 void EventNormalizeHandler::HandleEvent(libinput_event* event, int64_t frameTime)
109 {
110     CALL_DEBUG_ENTER;
111 
112     if (ProcessNullEvent(event, frameTime)) {
113         return;
114     }
115 
116     if (event == nullptr) {
117         return;
118     }
119     DfxHisysevent::GetDispStartTime();
120     auto type = libinput_event_get_type(event);
121     TimeCostChk chk("HandleLibinputEvent", "overtime 1000(us)", MAX_INPUT_EVENT_TIME, type);
122     if (type == LIBINPUT_EVENT_TOUCH_CANCEL || type == LIBINPUT_EVENT_TOUCH_FRAME) {
123         MMI_HILOGD("This touch event is canceled type:%{public}d", type);
124         return;
125     }
126 #ifdef OHOS_BUILD_ENABLE_POINTER
127     if ((type == LIBINPUT_EVENT_POINTER_TAP) &&
128         (MULTI_FINGERTAP_HDR->GetMultiFingersState() == MulFingersTap::TRIPLETAP)) {
129         MULTI_FINGERTAP_HDR->SetMULTI_FINGERTAP_HDRDefault();
130         return;
131     }
132     if ((type < LIBINPUT_EVENT_TOUCHPAD_DOWN) || (type > LIBINPUT_EVENT_TOUCHPAD_MOTION)) {
133         auto iter = std::find(ALL_EVENT_TYPES.begin(), ALL_EVENT_TYPES.end(), static_cast<int32_t>(type));
134         if (iter != ALL_EVENT_TYPES.end()) {
135             MULTI_FINGERTAP_HDR->SetMULTI_FINGERTAP_HDRDefault();
136         }
137     }
138 #endif // OHOS_BUILD_ENABLE_POINTER
139     BytraceAdapter::StartHandleInput(static_cast<int32_t>(type));
140     switch (type) {
141         case LIBINPUT_EVENT_DEVICE_ADDED: {
142             OnEventDeviceAdded(event);
143             break;
144         }
145         case LIBINPUT_EVENT_DEVICE_REMOVED: {
146             OnEventDeviceRemoved(event);
147             break;
148         }
149         case LIBINPUT_EVENT_KEYBOARD_KEY: {
150             HandleKeyboardEvent(event);
151             DfxHisysevent::CalcKeyDispTimes();
152             break;
153         }
154         case LIBINPUT_EVENT_POINTER_MOTION:
155         case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE:
156         case LIBINPUT_EVENT_POINTER_BUTTON:
157         case LIBINPUT_EVENT_POINTER_BUTTON_TOUCHPAD:
158         case LIBINPUT_EVENT_POINTER_AXIS:
159         case LIBINPUT_EVENT_POINTER_TAP:
160         case LIBINPUT_EVENT_POINTER_MOTION_TOUCHPAD: {
161             if (g_isSwipeInward) {
162                 break;
163             }
164             HandleMouseEvent(event);
165             DfxHisysevent::CalcPointerDispTimes();
166             break;
167         }
168         case LIBINPUT_EVENT_TOUCHPAD_DOWN:
169         case LIBINPUT_EVENT_TOUCHPAD_UP:
170         case LIBINPUT_EVENT_TOUCHPAD_MOTION: {
171             HandleTouchPadEvent(event);
172             DfxHisysevent::CalcPointerDispTimes();
173             break;
174         }
175         case LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN:
176         case LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE:
177         case LIBINPUT_EVENT_GESTURE_SWIPE_END:
178         case LIBINPUT_EVENT_GESTURE_PINCH_BEGIN:
179         case LIBINPUT_EVENT_GESTURE_PINCH_UPDATE:
180         case LIBINPUT_EVENT_GESTURE_PINCH_END: {
181             HandleGestureEvent(event);
182             DfxHisysevent::CalcPointerDispTimes();
183             break;
184         }
185         case LIBINPUT_EVENT_TOUCH_DOWN:
186         case LIBINPUT_EVENT_TOUCH_UP:
187         case LIBINPUT_EVENT_TOUCH_MOTION: {
188             HandleTouchEvent(event, frameTime);
189             DfxHisysevent::CalcPointerDispTimes();
190             break;
191         }
192         case LIBINPUT_EVENT_TABLET_TOOL_AXIS:
193         case LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY:
194         case LIBINPUT_EVENT_TABLET_TOOL_TIP: {
195             HandleTableToolEvent(event);
196             break;
197         }
198         case LIBINPUT_EVENT_JOYSTICK_BUTTON:
199         case LIBINPUT_EVENT_JOYSTICK_AXIS: {
200             HandleJoystickEvent(event);
201             DfxHisysevent::CalcPointerDispTimes();
202             break;
203         }
204         case LIBINPUT_EVENT_SWITCH_TOGGLE: {
205             HandleSwitchInputEvent(event);
206             break;
207         }
208         default: {
209             MMI_HILOGD("This device does not support :%d", type);
210             break;
211         }
212     }
213     BytraceAdapter::StopHandleInput();
214     DfxHisysevent::ReportDispTimes();
215 }
216 
ProcessNullEvent(libinput_event *event, int64_t frameTime)217 bool EventNormalizeHandler::ProcessNullEvent(libinput_event *event, int64_t frameTime)
218 {
219 #ifdef OHOS_BUILD_ENABLE_TOUCH
220     std::shared_ptr<PointerEvent> pointerEvent = EventResampleHdr->GetPointerEvent();
221     if ((event == nullptr) && (pointerEvent != nullptr) && MMISceneBoardJudgement::IsSceneBoardEnabled()
222         && MMISceneBoardJudgement::IsResampleEnabled()) {
223         int32_t sourceType = pointerEvent->GetSourceType();
224         if (sourceType == PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
225             HandleTouchEvent(event, frameTime);
226         }
227         return true;
228     }
229 #endif // OHOS_BUILD_ENABLE_TOUCH
230     return false;
231 }
232 
OnEventDeviceAdded(libinput_event *event)233 int32_t EventNormalizeHandler::OnEventDeviceAdded(libinput_event *event)
234 {
235     CHKPR(event, ERROR_NULL_POINTER);
236     auto device = libinput_event_get_device(event);
237     CHKPR(device, ERROR_NULL_POINTER);
238     INPUT_DEV_MGR->OnInputDeviceAdded(device);
239     KeyMapMgr->ParseDeviceConfigFile(device);
240     KeyRepeat->AddDeviceConfig(device);
241 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
242     KeyEventHdr->ResetKeyEvent(device);
243 #endif // OHOS_BUILD_ENABLE_KEYBOARD
244     return RET_OK;
245 }
246 
OnEventDeviceRemoved(libinput_event *event)247 int32_t EventNormalizeHandler::OnEventDeviceRemoved(libinput_event *event)
248 {
249     CHKPR(event, ERROR_NULL_POINTER);
250     auto device = libinput_event_get_device(event);
251     CHKPR(device, ERROR_NULL_POINTER);
252     KeyMapMgr->RemoveKeyValue(device);
253     KeyRepeat->RemoveDeviceConfig(device);
254     INPUT_DEV_MGR->OnInputDeviceRemoved(device);
255     return RET_OK;
256 }
257 
258 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
HandleKeyEvent(const std::shared_ptr<KeyEvent> keyEvent)259 void EventNormalizeHandler::HandleKeyEvent(const std::shared_ptr<KeyEvent> keyEvent)
260 {
261     CHKPV(nextHandler_);
262     DfxHisysevent::GetDispStartTime();
263     CHKPV(keyEvent);
264     EventLogHelper::PrintEventData(keyEvent, MMI_LOG_HEADER);
265     UpdateKeyEventHandlerChain(keyEvent);
266     if (keyEvent->IsRepeat()) {
267         KeyRepeat->SelectAutoRepeat(keyEvent);
268         keyEvent->SetRepeat(false);
269     }
270     DfxHisysevent::CalcKeyDispTimes();
271     DfxHisysevent::ReportDispTimes();
272 }
273 #endif // OHOS_BUILD_ENABLE_KEYBOARD
274 
275 #ifdef OHOS_BUILD_ENABLE_POINTER
HandlePointerEvent(const std::shared_ptr<PointerEvent> pointerEvent)276 void EventNormalizeHandler::HandlePointerEvent(const std::shared_ptr<PointerEvent> pointerEvent)
277 {
278     CHKPV(nextHandler_);
279     DfxHisysevent::GetDispStartTime();
280     CHKPV(pointerEvent);
281     if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_AXIS_END) {
282         MMI_HILOGI("MouseEvent Normalization Results, PointerAction:%{public}d, PointerId:%{public}d,"
283             "SourceType:%{public}d, ButtonId:%{public}d,"
284             "VerticalAxisValue:%{public}lf, HorizontalAxisValue:%{public}lf",
285             pointerEvent->GetPointerAction(), pointerEvent->GetPointerId(), pointerEvent->GetSourceType(),
286             pointerEvent->GetButtonId(), pointerEvent->GetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL),
287             pointerEvent->GetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL));
288         PointerEvent::PointerItem item;
289         if (!pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), item)) {
290             MMI_HILOGE("Get pointer item failed. pointer:%{public}d", pointerEvent->GetPointerId());
291             return;
292         }
293         if (!EventLogHelper::IsBetaVersion()) {
294             MMI_HILOGI("MouseEvent Item Normalization Results, IsPressed:%{public}d, Pressure:%{public}f"
295                        ", Device:%{public}d",
296                 static_cast<int32_t>(item.IsPressed()), item.GetPressure(), item.GetDeviceId());
297         } else {
298             MMI_HILOGI("MouseEvent Item Normalization Results, DownTime:%{public}" PRId64 ", IsPressed:%{public}d,"
299                 "DisplayX:%{public}d, DisplayY:%{public}d, WindowX:%{public}d, WindowY:%{public}d,"
300                 "Width:%{public}d, Height:%{public}d, Pressure:%{public}f, MoveFlag:%{public}d, Device:%{public}d",
301                 item.GetDownTime(), static_cast<int32_t>(item.IsPressed()), item.GetDisplayX(), item.GetDisplayY(),
302                 item.GetWindowX(), item.GetWindowY(), item.GetWidth(), item.GetHeight(), item.GetPressure(),
303                 item.GetMoveFlag(), item.GetDeviceId());
304         }
305     }
306     WIN_MGR->UpdateTargetPointer(pointerEvent);
307     nextHandler_->HandlePointerEvent(pointerEvent);
308     DfxHisysevent::CalcPointerDispTimes();
309     DfxHisysevent::ReportDispTimes();
310 }
311 #endif // OHOS_BUILD_ENABLE_POINTER
312 
313 #ifdef OHOS_BUILD_ENABLE_TOUCH
HandleTouchEvent(const std::shared_ptr<PointerEvent> pointerEvent)314 void EventNormalizeHandler::HandleTouchEvent(const std::shared_ptr<PointerEvent> pointerEvent)
315 {
316     CHKPV(nextHandler_);
317     DfxHisysevent::GetDispStartTime();
318     CHKPV(pointerEvent);
319     WIN_MGR->UpdateTargetPointer(pointerEvent);
320     BytraceAdapter::StartTouchEvent(pointerEvent->GetId());
321     nextHandler_->HandleTouchEvent(pointerEvent);
322     BytraceAdapter::StopTouchEvent();
323     DfxHisysevent::CalcPointerDispTimes();
324     DfxHisysevent::ReportDispTimes();
325 }
326 #endif // OHOS_BUILD_ENABLE_TOUCH
327 
HandleKeyboardEvent(libinput_event* event)328 int32_t EventNormalizeHandler::HandleKeyboardEvent(libinput_event* event)
329 {
330 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
331     FingerprintEventHdr->SetPowerAndVolumeKeyState(event);
332     if (FingerprintEventHdr->IsFingerprintEvent(event)) {
333         return FingerprintEventHdr->HandleFingerprintEvent(event);
334     }
335 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
336     CHKPR(nextHandler_, ERROR_UNSUPPORT);
337 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
338     BytraceAdapter::StartPackageEvent("package keyEvent");
339     auto keyEvent = KeyEventHdr->GetKeyEvent();
340     CHKPR(keyEvent, ERROR_NULL_POINTER);
341     CHKPR(event, ERROR_NULL_POINTER);
342     std::vector<int32_t> pressedKeys = keyEvent->GetPressedKeys();
343     int32_t lastPressedKey = -1;
344     if (!pressedKeys.empty()) {
345         lastPressedKey = pressedKeys.back();
346         MMI_HILOGD("The last repeat button, keyCode:%d", lastPressedKey);
347     }
348     auto packageResult = KeyEventHdr->Normalize(event, keyEvent);
349     EventStatistic::PushEvent(keyEvent);
350     WIN_MGR->HandleKeyEventWindowId(keyEvent);
351     LogTracer lt(keyEvent->GetId(), keyEvent->GetEventType(), keyEvent->GetKeyAction());
352     if (packageResult == MULTIDEVICE_SAME_EVENT_MARK) {
353         MMI_HILOGD("The same event reported by multi_device should be discarded");
354         BytraceAdapter::StopPackageEvent();
355         return RET_OK;
356     }
357     if (packageResult != RET_OK) {
358         MMI_HILOGE("KeyEvent package failed, ret:%{public}d, errCode:%{public}d", packageResult, KEY_EVENT_PKG_FAIL);
359         BytraceAdapter::StopPackageEvent();
360         return KEY_EVENT_PKG_FAIL;
361     }
362     BytraceAdapter::StopPackageEvent();
363     BytraceAdapter::StartBytrace(keyEvent);
364     EventLogHelper::PrintEventData(keyEvent, MMI_LOG_HEADER);
365     auto device = INPUT_DEV_MGR->GetInputDevice(keyEvent->GetDeviceId());
366     CHKPR(device, RET_ERR);
367     MMI_HILOGI("InputTracking id:%{public}d event created by:%{public}s", keyEvent->GetId(), device->GetName().c_str());
368     UpdateKeyEventHandlerChain(keyEvent);
369     KeyRepeat->SelectAutoRepeat(keyEvent);
370 #ifdef SHORTCUT_KEY_RULES_ENABLED
371     KEY_SHORTCUT_MGR->UpdateShortcutConsumed(keyEvent);
372 #endif // SHORTCUT_KEY_RULES_ENABLED
373     if (EventLogHelper::IsBetaVersion() && !keyEvent->HasFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE)) {
374         MMI_HILOGD("keyCode:%{private}d, action:%{public}d", keyEvent->GetKeyCode(), keyEvent->GetKeyAction());
375     } else {
376         MMI_HILOGD("keyCode:%d, action:%{public}d", keyEvent->GetKeyCode(), keyEvent->GetKeyAction());
377     }
378 #else
379     MMI_HILOGW("Keyboard device does not support");
380 #endif // OHOS_BUILD_ENABLE_KEYBOARD
381     return RET_OK;
382 }
383 
384 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
UpdateKeyEventHandlerChain(const std::shared_ptr<KeyEvent> keyEvent)385 void EventNormalizeHandler::UpdateKeyEventHandlerChain(const std::shared_ptr<KeyEvent> keyEvent)
386 {
387     CALL_DEBUG_ENTER;
388     CHKPV(keyEvent);
389     int32_t currentShieldMode = KeyEventHdr->GetCurrentShieldMode();
390     if (currentShieldMode == SHIELD_MODE::FACTORY_MODE) {
391         auto eventDispatchHandler = InputHandler->GetEventDispatchHandler();
392         CHKPV(eventDispatchHandler);
393         eventDispatchHandler->HandleKeyEvent(keyEvent);
394     } else {
395         CHKPV(nextHandler_);
396         nextHandler_->HandleKeyEvent(keyEvent);
397     }
398 }
399 #endif // OHOS_BUILD_ENABLE_KEYBOARD
400 
HandleMouseEvent(libinput_event* event)401 int32_t EventNormalizeHandler::HandleMouseEvent(libinput_event* event)
402 {
403 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
404     if (FingerprintEventHdr->IsFingerprintEvent(event)) {
405         return FingerprintEventHdr->HandleFingerprintEvent(event);
406     }
407 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
408 #ifdef OHOS_BUILD_ENABLE_POINTER
409     if (CROWN_EVENT_HDR->IsCrownEvent(event)) {
410 #ifdef OHOS_BUILD_ENABLE_CROWN
411         return CROWN_EVENT_HDR->NormalizeRotateEvent(event);
412 #else
413         return RET_ERR;
414 #endif // OHOS_BUILD_ENABLE_CROWN
415     }
416 #endif // OHOS_BUILD_ENABLE_POINTER
417     CHKPR(nextHandler_, ERROR_UNSUPPORT);
418 #ifdef OHOS_BUILD_ENABLE_POINTER
419     BytraceAdapter::StartPackageEvent("package mouseEvent");
420 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
421     const auto &keyEvent = KeyEventHdr->GetKeyEvent();
422     CHKPR(keyEvent, ERROR_NULL_POINTER);
423 #endif // OHOS_BUILD_ENABLE_KEYBOARD
424     TerminateAxis(event);
425     if (MouseEventHdr->OnEvent(event) == RET_ERR) {
426         MMI_HILOGE("OnEvent is failed");
427         BytraceAdapter::StopPackageEvent();
428         return RET_ERR;
429     }
430     auto pointerEvent = MouseEventHdr->GetPointerEvent();
431     CHKPR(pointerEvent, ERROR_NULL_POINTER);
432     LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
433 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
434     std::vector<int32_t> pressedKeys = keyEvent->GetPressedKeys();
435     for (const int32_t& keyCode : pressedKeys) {
436         MMI_HILOGI("Pressed keyCode:%d", keyCode);
437     }
438     pointerEvent->SetPressedKeys(pressedKeys);
439 #endif // OHOS_BUILD_ENABLE_KEYBOARD
440     BytraceAdapter::StopPackageEvent();
441     BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START);
442     HandlePalmEvent(event, pointerEvent);
443     if (SetOriginPointerId(pointerEvent) != RET_OK) {
444         MMI_HILOGE("Failed to set origin pointerId");
445         return RET_ERR;
446     }
447     EventStatistic::PushPointerEvent(pointerEvent);
448     nextHandler_->HandlePointerEvent(pointerEvent);
449 #else
450     MMI_HILOGW("Pointer device does not support");
451 #endif // OHOS_BUILD_ENABLE_POINTER
452     return RET_OK;
453 }
454 
HandlePalmEvent(libinput_event* event, std::shared_ptr<PointerEvent> pointerEvent)455 void EventNormalizeHandler::HandlePalmEvent(libinput_event* event, std::shared_ptr<PointerEvent> pointerEvent)
456 {
457     auto touchpad = libinput_event_get_touchpad_event(event);
458     if (touchpad == nullptr) {
459         return;
460     }
461     int32_t toolType = libinput_event_touchpad_get_tool_type(touchpad);
462     if (toolType == MT_TOOL_PALM) {
463         MMI_HILOGI("ToolType is MT_TOOL_PALM");
464         pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
465     }
466 }
467 
HandleTouchPadTripleTapEvent(std::shared_ptr<PointerEvent> pointerEvent)468 bool EventNormalizeHandler::HandleTouchPadTripleTapEvent(std::shared_ptr<PointerEvent> pointerEvent)
469 {
470     CHKPF(nextHandler_);
471     if (MULTI_FINGERTAP_HDR->GetMultiFingersState() == MulFingersTap::TRIPLETAP) {
472         bool threeFingerSwitch = false;
473         TOUCH_EVENT_HDR->GetTouchpadThreeFingersTapSwitch(threeFingerSwitch);
474         if (!threeFingerSwitch) {
475             return true;
476         }
477         nextHandler_->HandlePointerEvent(pointerEvent);
478         MULTI_FINGERTAP_HDR->ClearPointerItems(pointerEvent);
479     }
480     return false;
481 }
482 
HandleTouchPadEvent(libinput_event* event)483 int32_t EventNormalizeHandler::HandleTouchPadEvent(libinput_event* event)
484 {
485     CHKPR(nextHandler_, ERROR_UNSUPPORT);
486 #ifdef OHOS_BUILD_ENABLE_POINTER
487     CHKPR(event, ERROR_NULL_POINTER);
488     auto touchpad = libinput_event_get_touchpad_event(event);
489     CHKPR(touchpad, ERROR_NULL_POINTER);
490     auto type = libinput_event_get_type(event);
491     if (type == LIBINPUT_EVENT_TOUCHPAD_MOTION && TouchPadKnuckleDoubleClickHandle(event)) {
492         return RET_OK;
493     }
494     int32_t seatSlot = libinput_event_touchpad_get_seat_slot(touchpad);
495     MULTI_FINGERTAP_HDR->HandleMulFingersTap(touchpad, type);
496     auto pointerEvent = TOUCH_EVENT_HDR->OnLibInput(event, TouchEventNormalize::DeviceType::TOUCH_PAD);
497     CHKPR(pointerEvent, ERROR_NULL_POINTER);
498     LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
499     EventStatistic::PushPointerEvent(pointerEvent);
500     if (HandleTouchPadTripleTapEvent(pointerEvent)) {
501         return RET_OK;
502     }
503     buttonIds_.insert(seatSlot);
504     if (buttonIds_.size() == FINGER_NUM &&
505         (type == LIBINPUT_EVENT_TOUCHPAD_DOWN || type == LIBINPUT_EVENT_TOUCHPAD_UP)) {
506         MMI_HILOGD("Handle mouse axis event");
507         g_isSwipeInward = false;
508         HandleMouseEvent(event);
509     }
510     if (buttonIds_.size() == SWIPE_INWARD_FINGER_ONE && JudgeIfSwipeInward(pointerEvent, type, event)) {
511         nextHandler_->HandlePointerEvent(pointerEvent);
512     }
513     if (type == LIBINPUT_EVENT_TOUCHPAD_UP) {
514         pointerEvent->RemovePointerItem(pointerEvent->GetPointerId());
515         MMI_HILOGD("This event is up remove this finger");
516         if (pointerEvent->GetPointerIds().empty()) {
517             MMI_HILOGD("This event is final up");
518             pointerEvent->Reset();
519         }
520         buttonIds_.erase(seatSlot);
521         g_isSwipeInward = false;
522     }
523     if (buttonIds_.empty()) {
524         MULTI_FINGERTAP_HDR->SetMULTI_FINGERTAP_HDRDefault(false);
525     }
526     MMI_HILOGD("Button ids count:%{public}d, action:%{public}d",
527         static_cast<int32_t>(buttonIds_.size()), pointerEvent->GetPointerAction());
528     return RET_OK;
529 #else
530     MMI_HILOGW("Pointer device does not support");
531 #endif // OHOS_BUILD_ENABLE_POINTER
532     return RET_OK;
533 }
534 
HandleGestureEvent(libinput_event* event)535 int32_t EventNormalizeHandler::HandleGestureEvent(libinput_event* event)
536 {
537     CHKPR(nextHandler_, ERROR_UNSUPPORT);
538 #ifdef OHOS_BUILD_ENABLE_POINTER
539     CHKPR(event, ERROR_NULL_POINTER);
540     auto pointerEvent = TOUCH_EVENT_HDR->OnLibInput(event, TouchEventNormalize::DeviceType::TOUCH_PAD);
541     CHKPR(pointerEvent, ERROR_NULL_POINTER);
542     auto type = libinput_event_get_type(event);
543     if (type == LIBINPUT_EVENT_GESTURE_PINCH_BEGIN) {
544         MMI_HILOGI("Prepare to send a axis-end event");
545         CancelTwoFingerAxis(event);
546     }
547     LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
548     PointerEventSetPressedKeys(pointerEvent);
549     EventStatistic::PushPointerEvent(pointerEvent);
550     nextHandler_->HandlePointerEvent(pointerEvent);
551     type = libinput_event_get_type(event);
552     if (type == LIBINPUT_EVENT_GESTURE_SWIPE_END || type == LIBINPUT_EVENT_GESTURE_PINCH_END) {
553         pointerEvent->RemovePointerItem(pointerEvent->GetPointerId());
554         MMI_HILOGD("This touch pad event is up remove this finger");
555         if (pointerEvent->GetPointerIds().empty()) {
556             MMI_HILOGD("This touch pad event is final finger up remove this finger");
557             pointerEvent->Reset();
558         }
559     }
560 #else
561     MMI_HILOGW("Pointer device does not support");
562 #endif // OHOS_BUILD_ENABLE_POINTER
563     return RET_OK;
564 }
565 
HandleTouchEvent(libinput_event* event, int64_t frameTime)566 int32_t EventNormalizeHandler::HandleTouchEvent(libinput_event* event, int64_t frameTime)
567 {
568     CHKPR(nextHandler_, ERROR_UNSUPPORT);
569 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
570     FingerprintEventHdr->SetScreenState(event);
571 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
572 #ifdef OHOS_BUILD_ENABLE_TOUCH
573     BytraceAdapter::StartPackageEvent("package touchEvent");
574     std::shared_ptr<PointerEvent> pointerEvent = nullptr;
575     LogTracer lt;
576     if (event != nullptr) {
577         pointerEvent = TOUCH_EVENT_HDR->OnLibInput(event, TouchEventNormalize::DeviceType::TOUCH);
578         CHKPR(pointerEvent, ERROR_NULL_POINTER);
579         lt = LogTracer(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
580     }
581 #ifdef OHOS_BUILD_ENABLE_MOVE_EVENT_FILTERS
582     if (HandleTouchEventWithFlag(pointerEvent)) {
583         MMI_HILOGD("Touch event is filtered with flag");
584         return RET_OK;
585     }
586 #endif // OHOS_BUILD_ENABLE_MOVE_EVENT_FILTERS
587     if (MMISceneBoardJudgement::IsSceneBoardEnabled() && MMISceneBoardJudgement::IsResampleEnabled()) {
588         ErrCode status = RET_OK;
589         std::shared_ptr<PointerEvent> outputEvent = EventResampleHdr->OnEventConsume(pointerEvent, frameTime, status);
590         CHKPR(outputEvent, RET_OK);
591         MMI_HILOGD("Output event received, SourceType:%{public}d, PointerAction:%{public}d, status:%{public}d",
592             outputEvent->GetSourceType(), outputEvent->GetPointerAction(), status);
593         EndLogTraceId(pointerEvent->GetId());
594         pointerEvent = outputEvent;
595         lt = LogTracer(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
596     }
597     BytraceAdapter::StopPackageEvent();
598     EventStatistic::PushPointerEvent(pointerEvent);
599     PointerEventSetPressedKeys(pointerEvent);
600 
601     BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START);
602     if (SetOriginPointerId(pointerEvent) != RET_OK) {
603         MMI_HILOGE("Failed to set origin pointerId");
604         return RET_ERR;
605     }
606     nextHandler_->HandleTouchEvent(pointerEvent);
607     if ((pointerEvent != nullptr) && (event != nullptr)) {
608         ResetTouchUpEvent(pointerEvent, event);
609     }
610 #else
611     MMI_HILOGW("Touchscreen device does not support");
612 #endif // OHOS_BUILD_ENABLE_TOUCH
613     return RET_OK;
614 }
615 
PointerEventSetPressedKeys(std::shared_ptr<PointerEvent> pointerEvent)616 void EventNormalizeHandler::PointerEventSetPressedKeys(std::shared_ptr<PointerEvent> pointerEvent)
617 {
618 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
619     if (KeyEventHdr != nullptr) {
620         const auto &keyEvent = KeyEventHdr->GetKeyEvent();
621         if (keyEvent != nullptr && pointerEvent != nullptr) {
622             std::vector<int32_t> setPressedKeys;
623             std::vector<int32_t> pressedKeys = keyEvent->GetPressedKeys();
624             if (pressedKeys.size() > MAX_N_PRESSED_KEYS) {
625                 setPressedKeys.insert(setPressedKeys.begin(), pressedKeys.begin(),
626                     pressedKeys.begin() + MAX_N_PRESSED_KEYS);
627             } else {
628                 setPressedKeys = pressedKeys;
629             }
630             pointerEvent->SetPressedKeys(setPressedKeys);
631         }
632     }
633 #endif // OHOS_BUILD_ENABLE_KEYBOARD
634 }
635 
ResetTouchUpEvent(std::shared_ptr<PointerEvent> pointerEvent, struct libinput_event *event)636 void EventNormalizeHandler::ResetTouchUpEvent(std::shared_ptr<PointerEvent> pointerEvent,
637     struct libinput_event *event)
638 {
639     CHKPV(pointerEvent);
640     CHKPV(event);
641     auto type = libinput_event_get_type(event);
642     if (type == LIBINPUT_EVENT_TOUCH_UP) {
643         pointerEvent->RemovePointerItem(pointerEvent->GetPointerId());
644         MMI_HILOGD("This touch event is up remove this finger");
645         if (pointerEvent->GetPointerIds().empty()) {
646             MMI_HILOGD("This touch event is final finger up remove this finger");
647             pointerEvent->Reset();
648         }
649     }
650 }
651 
HandleTableToolEvent(libinput_event* event)652 int32_t EventNormalizeHandler::HandleTableToolEvent(libinput_event* event)
653 {
654     CHKPR(nextHandler_, ERROR_UNSUPPORT);
655 #ifdef OHOS_BUILD_ENABLE_TOUCH
656     CHKPR(event, ERROR_NULL_POINTER);
657     BytraceAdapter::StartPackageEvent("package penEvent");
658     auto pointerEvent = TOUCH_EVENT_HDR->OnLibInput(event, TouchEventNormalize::DeviceType::TABLET_TOOL);
659     BytraceAdapter::StopPackageEvent();
660     CHKPR(pointerEvent, ERROR_NULL_POINTER);
661     LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
662     BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START);
663     EventStatistic::PushPointerEvent(pointerEvent);
664     nextHandler_->HandleTouchEvent(pointerEvent);
665     if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_UP) {
666         pointerEvent->Reset();
667     }
668 #else
669     MMI_HILOGW("TableTool device does not support");
670 #endif // OHOS_BUILD_ENABLE_TOUCH
671     return RET_OK;
672 }
673 
HandleJoystickEvent(libinput_event* event)674 int32_t EventNormalizeHandler::HandleJoystickEvent(libinput_event* event)
675 {
676     CHKPR(nextHandler_, ERROR_UNSUPPORT);
677 #ifdef OHOS_BUILD_ENABLE_JOYSTICK
678     CHKPR(event, ERROR_NULL_POINTER);
679     BytraceAdapter::StartPackageEvent("package joystickEvent");
680     auto pointerEvent = TOUCH_EVENT_HDR->OnLibInput(event, TouchEventNormalize::DeviceType::JOYSTICK);
681     BytraceAdapter::StopPackageEvent();
682     CHKPR(pointerEvent, ERROR_NULL_POINTER);
683     BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START);
684     EventStatistic::PushPointerEvent(pointerEvent);
685     nextHandler_->HandlePointerEvent(pointerEvent);
686 #else
687     MMI_HILOGW("Joystick device does not support");
688 #endif // OHOS_BUILD_ENABLE_JOYSTICK
689     return RET_OK;
690 }
691 
HandleSwitchInputEvent(libinput_event* event)692 int32_t EventNormalizeHandler::HandleSwitchInputEvent(libinput_event* event)
693 {
694     CHKPR(nextHandler_, ERROR_UNSUPPORT);
695 #ifdef OHOS_BUILD_ENABLE_SWITCH
696     CHKPR(event, ERROR_NULL_POINTER);
697     struct libinput_event_switch *swev = libinput_event_get_switch_event(event);
698     CHKPR(swev, ERROR_NULL_POINTER);
699 
700     enum libinput_switch_state state = libinput_event_switch_get_switch_state(swev);
701     enum libinput_switch sw = libinput_event_switch_get_switch(swev);
702     MMI_HILOGI("libinput_event_switch type:%{public}d, state:%{public}d", sw, state);
703     if (sw == LIBINPUT_SWITCH_PRIVACY && state == LIBINPUT_SWITCH_STATE_OFF) {
704         MMI_HILOGD("Privacy switch event ignored");
705         return RET_OK;
706     }
707     auto swEvent = std::make_unique<SwitchEvent>(static_cast<int32_t>(state));
708     int32_t switchStatus = static_cast<int32_t>(sw);
709     if (switchStatus) {
710         RestoreTouchPadStatus();
711     }
712     swEvent->SetSwitchType(switchStatus);
713     EventStatistic::PushEvent(std::move(swEvent));
714     nextHandler_->HandleSwitchEvent(std::move(swEvent));
715 #else
716     MMI_HILOGW("Switch device does not support");
717 #endif // OHOS_BUILD_ENABLE_SWITCH
718     return RET_OK;
719 }
720 
AddHandleTimer(int32_t timeout)721 int32_t EventNormalizeHandler::AddHandleTimer(int32_t timeout)
722 {
723     CALL_DEBUG_ENTER;
724     timerId_ = TimerMgr->AddTimer(timeout, 1, [this]() {
725 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
726         auto keyEvent = KeyEventHdr->GetKeyEvent();
727         CHKPV(keyEvent);
728         UpdateKeyEventHandlerChain(keyEvent);
729         int32_t triggerTime = KeyRepeat->GetIntervalTime(keyEvent->GetDeviceId());
730         this->AddHandleTimer(triggerTime);
731 #endif // OHOS_BUILD_ENABLE_KEYBOARD
732     });
733     return timerId_;
734 }
735 
736 #ifdef OHOS_BUILD_ENABLE_MOVE_EVENT_FILTERS
SetMoveEventFilters(bool flag)737 int32_t EventNormalizeHandler::SetMoveEventFilters(bool flag)
738 {
739     moveEventFilterFlag_ = flag;
740 
741     int32_t ret = PREFERENCES_MGR->SetBoolValue("moveEventFilterFlag", "mouse_settings.xml", moveEventFilterFlag_);
742     if (ret != RET_OK) {
743         MMI_HILOGE("Failed to save moveEventFilterFlag, ret:%{public}d", ret);
744     }
745     return ret;
746 }
747 
HandleTouchEventWithFlag(const std::shared_ptr<PointerEvent> pointerEvent)748 bool EventNormalizeHandler::HandleTouchEventWithFlag(const std::shared_ptr<PointerEvent> pointerEvent)
749 {
750     if (!moveEventFilterFlag_) {
751         return false;
752     }
753     CHKPF(pointerEvent);
754     if (pointerEvent->GetSourceType() != PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
755         return false;
756     }
757     static bool isFirstMoveEvent = false;
758     int32_t action = pointerEvent->GetPointerAction();
759     if (action == PointerEvent::POINTER_ACTION_DOWN) {
760         isFirstMoveEvent = false;
761         lastTouchDownItems_ = pointerEvent->GetAllPointerItems();
762     } else if (action == PointerEvent::POINTER_ACTION_MOVE) {
763         if (isFirstMoveEvent) {
764             return false;
765         }
766         double offset = CalcTouchOffset(pointerEvent);
767         bool isMoveEventFiltered = MMI_LNE(offset, TOUCH_SLOP);
768         MMI_HILOGD("Touch move event, offset:%{public}f, isMoveEventFiltered:%{public}s",
769             offset, isMoveEventFiltered ? "true" : "false");
770         isFirstMoveEvent = !isMoveEventFiltered;
771         return isMoveEventFiltered;
772     } else if (action == PointerEvent::POINTER_ACTION_UP) {
773         lastTouchDownItems_.clear();
774     }
775     return false;
776 }
777 
CalcTouchOffset(const std::shared_ptr<PointerEvent> touchMoveEvent)778 double EventNormalizeHandler::CalcTouchOffset(const std::shared_ptr<PointerEvent> touchMoveEvent)
779 {
780     CHKPR(touchMoveEvent, ERROR_NULL_POINTER);
781     auto moveItems = touchMoveEvent->GetAllPointerItems();
782     if (moveItems.empty() || lastTouchDownItems_.empty()) {
783         MMI_HILOGE("moveItems or lastTouchDownItems_ is empty");
784         return 0.f;
785     }
786     PointerEvent::PointerItem itemMove = moveItems.front();
787     PointerEvent::PointerItem itemDown = lastTouchDownItems_.front();
788     double offset = sqrt(pow(itemMove.GetDisplayX() - itemDown.GetDisplayX(), SQUARE) +
789         pow(itemMove.GetDisplayY() - itemDown.GetDisplayY(), SQUARE));
790     auto displayInfo = WIN_MGR->GetPhysicalDisplay(touchMoveEvent->GetTargetDisplayId());
791     if (displayInfo != nullptr) {
792         double scale = static_cast<double>(displayInfo->dpi) / DENSITY_BASELINE;
793         if (!MMI_EQ(static_cast<float>(scale), 0.f)) {
794             offset /= scale;
795         }
796     }
797     return offset;
798 }
799 #endif // OHOS_BUILD_ENABLE_MOVE_EVENT_FILTERS
800 
SetOriginPointerId(std::shared_ptr<PointerEvent> pointerEvent)801 int32_t EventNormalizeHandler::SetOriginPointerId(std::shared_ptr<PointerEvent> pointerEvent)
802 {
803     CALL_DEBUG_ENTER;
804     CHKPR(pointerEvent, ERROR_NULL_POINTER);
805     int32_t pointerId = pointerEvent->GetPointerId();
806     PointerEvent::PointerItem pointerItem;
807     if (!pointerEvent->GetPointerItem(pointerId, pointerItem)) {
808         MMI_HILOGE("Can't find pointer item, pointer:%{public}d", pointerId);
809         return RET_ERR;
810     }
811     pointerItem.SetOriginPointerId(pointerItem.GetPointerId());
812     pointerEvent->UpdatePointerItem(pointerId, pointerItem);
813     MMI_HILOGD("pointerId:%{public}d, originPointerId:%{public}d",
814         pointerId, pointerItem.GetPointerId());
815     return RET_OK;
816 }
817 
818 #ifdef OHOS_BUILD_ENABLE_SWITCH
RestoreTouchPadStatus()819 void EventNormalizeHandler::RestoreTouchPadStatus()
820 {
821     CALL_INFO_TRACE;
822 #ifdef OHOS_BUILD_ENABLE_POINTER
823     auto ids = INPUT_DEV_MGR->GetTouchPadIds();
824     for (auto id : ids) {
825         MMI_HILOGI("Restore touchpad, deviceId:%{public}d", id);
826         auto mouseEvent = TOUCH_EVENT_HDR->GetPointerEvent(id);
827         if (mouseEvent != nullptr) {
828             mouseEvent->Reset();
829         }
830         mouseEvent = MouseEventHdr->GetPointerEvent(id);
831         if (mouseEvent != nullptr) {
832             mouseEvent->Reset();
833         }
834     }
835 #endif // OHOS_BUILD_ENABLE_POINTER
836     buttonIds_.clear();
837 }
838 #endif // OHOS_BUILD_ENABLE_SWITCH
839 
CancelTwoFingerAxis(libinput_event* event)840 void EventNormalizeHandler::CancelTwoFingerAxis(libinput_event* event)
841 {
842     CALL_DEBUG_ENTER;
843     auto type = libinput_event_get_type(event);
844     if (type != LIBINPUT_EVENT_GESTURE_PINCH_BEGIN) {
845         MMI_HILOGI("Current event is not expected");
846         return;
847     }
848     bool result = MouseEventHdr->CheckAndPackageAxisEvent(event);
849     if (!result) {
850         MMI_HILOGI("Check or packet axis event failed");
851         return;
852     }
853     auto pointerEvent = MouseEventHdr->GetPointerEvent();
854     CHKPV(pointerEvent);
855     nextHandler_->HandlePointerEvent(pointerEvent);
856 }
857 
TerminateAxis(libinput_event* event)858 void EventNormalizeHandler::TerminateAxis(libinput_event* event)
859 {
860     CALL_DEBUG_ENTER;
861 #ifdef OHOS_BUILD_ENABLE_POINTER
862     auto type = libinput_event_get_type(event);
863     if (type == LIBINPUT_EVENT_POINTER_BUTTON_TOUCHPAD) {
864         bool result = MouseEventHdr->CheckAndPackageAxisEvent(event);
865         if (!result) {
866             return;
867         }
868         MMI_HILOGI("Terminate axis event");
869         auto pointerEvent = MouseEventHdr->GetPointerEvent();
870         CHKPV(pointerEvent);
871         LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
872         nextHandler_->HandlePointerEvent(pointerEvent);
873     }
874 #else
875     MMI_HILOGW("Pointer device does not support");
876 #endif // OHOS_BUILD_ENABLE_POINTER
877 }
878 
JudgeIfSwipeInward(std::shared_ptr<PointerEvent> pointerEvent, enum libinput_event_type type, libinput_event* event)879 bool EventNormalizeHandler::JudgeIfSwipeInward(std::shared_ptr<PointerEvent> pointerEvent,
880     enum libinput_event_type type, libinput_event* event)
881 {
882     static int32_t angleTolerance = 0;
883     static int32_t lastDirection = 0;
884     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD);
885     if (g_isSwipeInward == false &&
886         type == LIBINPUT_EVENT_TOUCHPAD_DOWN &&
887         pointerEvent->GetAllPointerItems().size() == SWIPE_INWARD_FINGER_ONE) {
888         auto touchPadDevice = libinput_event_get_device(event);
889         // product isolation
890         uint32_t touchPadDeviceId = libinput_device_get_id_product(touchPadDevice);
891         if (touchPadDeviceId != WEBER_PRODUCT_DEVICE_ID) {
892             return g_isSwipeInward;
893         }
894         // get touchpad physic size
895         if (libinput_device_get_size(touchPadDevice, &g_touchPadDeviceWidth, &g_touchPadDeviceHeight)) {
896             MMI_HILOGD("judgeIfSwipeInward, get touchPad physic size error");
897         }
898         // get touchpad max axis size
899         g_touchPadDeviceAxisX = libinput_device_get_axis_max(touchPadDevice, USELIB_ABS_MT_POSITION_X);
900         g_touchPadDeviceAxisY = libinput_device_get_axis_max(touchPadDevice, USELIB_ABS_MT_POSITION_Y);
901         // if down position on edge, start deliver data
902         if (pointerEvent->GetAllPointerItems().begin()->GetDisplayX() >=
903             g_touchPadDeviceWidth - SWIPE_INWARD_EDGE_X_THRE) {
904             lastDirection = -1; // -1 means direction from right to left
905             g_isSwipeInward = true;
906         } else if (pointerEvent->GetAllPointerItems().begin()->GetDisplayX() <= SWIPE_INWARD_EDGE_X_THRE) {
907             lastDirection = 1; // 1 means direction from left to right
908             g_isSwipeInward = true;
909         }
910     }
911     // judge
912     if (g_isSwipeInward == true) {
913         SwipeInwardProcess(pointerEvent, type, event, &angleTolerance, lastDirection);
914         if (angleTolerance == 0) {
915             g_isSwipeInward = false;
916         }
917     }
918     return g_isSwipeInward;
919 }
920 
SwipeInwardProcess(std::shared_ptr<PointerEvent> pointerEvent, enum libinput_event_type type, libinput_event* event, int32_t* angleTolerance, int32_t lastDirection)921 void EventNormalizeHandler::SwipeInwardProcess(std::shared_ptr<PointerEvent> pointerEvent,
922     enum libinput_event_type type, libinput_event* event, int32_t* angleTolerance, int32_t lastDirection)
923 {
924     static int32_t lastPointerX;
925     static int32_t lastPointerY;
926     int32_t pointerMotionX;
927     int32_t pointerMotionY;
928     int32_t pointerId = pointerEvent->GetPointerId();
929     PointerEvent::PointerItem pointerItem;
930     if (!pointerEvent->GetPointerItem(pointerId, pointerItem)) {
931         MMI_HILOGD("judgeIfSwipeInward, Can't find pointerItem");
932         g_isSwipeInward = false;
933         return;
934     }
935     switch (static_cast<int32_t>(type)) {
936         case static_cast<int32_t>(LIBINPUT_EVENT_TOUCHPAD_DOWN):
937             pointerItem.SetDisplayX(g_touchPadDeviceAxisX);
938             pointerItem.SetDisplayY(g_touchPadDeviceAxisY);
939             *angleTolerance = SWIPE_INWARD_ANGLE_TOLERANCE;
940             return;
941         case static_cast<int32_t>(LIBINPUT_EVENT_TOUCHPAD_MOTION): {
942             auto touchpad = libinput_event_get_touchpad_event(event);
943             pointerItem.SetDisplayX(static_cast<int32_t>(
944                 (libinput_event_touchpad_get_x(touchpad) / g_touchPadDeviceWidth) * g_touchPadDeviceAxisX));
945             pointerItem.SetDisplayY(static_cast<int32_t>(
946                 (libinput_event_touchpad_get_y(touchpad) / g_touchPadDeviceHeight) * g_touchPadDeviceAxisY));
947             break;
948         }
949         case static_cast<int32_t>(LIBINPUT_EVENT_TOUCHPAD_UP):
950             lastPointerX = 0;
951             return;
952         default:
953             return;
954     }
955     // angle and direction judge
956     if ((std::abs(pointerItem.GetDisplayX() - lastPointerX) * SWIPE_INWARD_ANGLE_JUDGE <
957         std::abs(pointerItem.GetDisplayY() - lastPointerY) ||
958         (pointerItem.GetDisplayX() - lastPointerX) * lastDirection < 0) && lastPointerX) {
959         --(*angleTolerance); // angle judge have more weights than direction judge
960         --(*angleTolerance);
961     }
962     lastPointerX = pointerItem.GetDisplayX();
963     lastPointerY = pointerItem.GetDisplayY();
964 }
965 
TouchPadKnuckleDoubleClickHandle(libinput_event* event)966 bool EventNormalizeHandler::TouchPadKnuckleDoubleClickHandle(libinput_event* event)
967 {
968     CHKPF(event);
969     CHKPF(nextHandler_);
970     auto touchpadEvent = libinput_event_get_touchpad_event(event);
971     CHKPF(touchpadEvent);
972     double value = libinput_event_touchpad_get_pressure(touchpadEvent);
973     std::shared_ptr<MMI::KeyEvent> keyEvent = KeyEvent::Create();
974     CHKPF(keyEvent);
975     if (std::fabs(SINGLE_KNUCKLE_ABS_PRESSURE_VALUE - value) <= std::numeric_limits<double>::epsilon()) {
976         keyEvent->SetKeyAction(KNUCKLE_1F_DOUBLE_CLICK);
977         MMI_HILOGI("Current is touchPad single knuckle double click action");
978         nextHandler_->HandleKeyEvent(keyEvent);
979         return true;
980     }
981     if (value == DOUBLE_KNUCKLE_ABS_PRESSURE_VALUE) {
982         keyEvent->SetKeyAction(KNUCKLE_2F_DOUBLE_CLICK);
983         MMI_HILOGI("Current is touchPad double knuckle double click action");
984         nextHandler_->HandleKeyEvent(keyEvent);
985         return true;
986     }
987     return false;
988 }
989 } // namespace MMI
990 } // namespace OHOS
991