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 "define_multimodal.h"
20 #include "dfx_hisysevent.h"
21 #include "error_multimodal.h"
22 #include "event_log_helper.h"
23 #ifdef OHOS_BUILD_ENABLE_TOUCH
24 #include "event_resample.h"
25 #endif // OHOS_BUILD_ENABLE_TOUCH
26 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
27 #include "fingerprint_event_processor.h"
28 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
29 #include "input_device_manager.h"
30 #include "input_event_handler.h"
31 #include "input_scene_board_judgement.h"
32 #include "key_auto_repeat.h"
33 #include "key_event_normalize.h"
34 #include "key_event_value_transformation.h"
35 #include "libinput_adapter.h"
36 #include "mmi_log.h"
37 #include "time_cost_chk.h"
38 #include "timer_manager.h"
39 #include "touch_event_normalize.h"
40 #ifdef OHOS_BUILD_ENABLE_POINTER
41 #include "touchpad_transform_processor.h"
42 #ifdef OHOS_BUILD_ENABLE_CROWN
43 #include "crown_transform_processor.h"
44 #endif // OHOS_BUILD_ENABLE_CROWN
45 #endif // OHOS_BUILD_ENABLE_POINTER
46 #ifdef OHOS_RSS_CLIENT
47 #include "res_sched_client.h"
48 #include "res_type.h"
49 #endif // OHOS_RSS_CLIENT
50 
51 #undef MMI_LOG_DOMAIN
52 #define MMI_LOG_DOMAIN MMI_LOG_HANDLER
53 #undef MMI_LOG_TAG
54 #define MMI_LOG_TAG "EventNormalizeHandler"
55 
56 namespace OHOS {
57 namespace MMI {
58 namespace {
59 constexpr int32_t FINGER_NUM { 2 };
60 constexpr int32_t MT_TOOL_PALM { 2 };
61 constexpr int32_t SWIPE_INWARD_FINGER_ONE { 1 };
62 constexpr int32_t USELIB_ABS_MT_POSITION_X { 0x35 };
63 constexpr int32_t USELIB_ABS_MT_POSITION_Y { 0x36 };
64 constexpr int32_t SWIPE_INWARD_EDGE_X_THRE { 8 };
65 constexpr int32_t SWIPE_INWARD_ANGLE_TOLERANCE { 8 };
66 constexpr int32_t TABLET_PRODUCT_DEVICE_ID { 4274 };
67 constexpr int32_t BLE_PRODUCT_DEVICE_ID { 4307 };
68 double g_touchPadDeviceWidth { 1 }; // physic size
69 double g_touchPadDeviceHeight { 1 };
70 int32_t g_touchPadDeviceAxisX { 1 }; // max axis size
71 int32_t g_touchPadDeviceAxisY { 1 };
72 bool g_isSwipeInward = false;
73 constexpr int32_t SWIPE_INWARD_ANGLE_JUDGE { 2 };
74 const std::vector<int32_t> ALL_EVENT_TYPES = {
75     static_cast<int32_t>(LIBINPUT_EVENT_DEVICE_ADDED),
76     static_cast<int32_t>(LIBINPUT_EVENT_DEVICE_REMOVED),
77     static_cast<int32_t>(LIBINPUT_EVENT_KEYBOARD_KEY),
78     static_cast<int32_t>(LIBINPUT_EVENT_POINTER_MOTION),
79     static_cast<int32_t>(LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE),
80     static_cast<int32_t>(LIBINPUT_EVENT_POINTER_BUTTON),
81     static_cast<int32_t>(LIBINPUT_EVENT_POINTER_BUTTON_TOUCHPAD),
82     static_cast<int32_t>(LIBINPUT_EVENT_POINTER_AXIS),
83     static_cast<int32_t>(LIBINPUT_EVENT_POINTER_TAP),
84     static_cast<int32_t>(LIBINPUT_EVENT_POINTER_MOTION_TOUCHPAD),
85     static_cast<int32_t>(LIBINPUT_EVENT_TOUCHPAD_DOWN),
86     static_cast<int32_t>(LIBINPUT_EVENT_TOUCHPAD_UP),
87     static_cast<int32_t>(LIBINPUT_EVENT_TOUCHPAD_MOTION),
88     static_cast<int32_t>(LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN),
89     static_cast<int32_t>(LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE),
90     static_cast<int32_t>(LIBINPUT_EVENT_GESTURE_SWIPE_END),
91     static_cast<int32_t>(LIBINPUT_EVENT_GESTURE_PINCH_BEGIN),
92     static_cast<int32_t>(LIBINPUT_EVENT_GESTURE_PINCH_UPDATE),
93     static_cast<int32_t>(LIBINPUT_EVENT_GESTURE_PINCH_END),
94     static_cast<int32_t>(LIBINPUT_EVENT_TOUCH_DOWN),
95     static_cast<int32_t>(LIBINPUT_EVENT_TOUCH_UP),
96     static_cast<int32_t>(LIBINPUT_EVENT_TOUCH_MOTION),
97     static_cast<int32_t>(LIBINPUT_EVENT_TABLET_TOOL_AXIS),
98     static_cast<int32_t>(LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY),
99     static_cast<int32_t>(LIBINPUT_EVENT_TABLET_TOOL_TIP),
100     static_cast<int32_t>(LIBINPUT_EVENT_JOYSTICK_BUTTON),
101     static_cast<int32_t>(LIBINPUT_EVENT_JOYSTICK_AXIS),
102     static_cast<int32_t>(LIBINPUT_EVENT_SWITCH_TOGGLE)
103 };
104 }
105 
HandleEvent(libinput_event * event,int64_t frameTime)106 void EventNormalizeHandler::HandleEvent(libinput_event* event, int64_t frameTime)
107 {
108     CALL_DEBUG_ENTER;
109 
110     if (ProcessNullEvent(event, frameTime)) {
111         return;
112     }
113 
114     if (event == nullptr) {
115         return;
116     }
117     DfxHisysevent::GetDispStartTime();
118     auto type = libinput_event_get_type(event);
119     TimeCostChk chk("HandleLibinputEvent", "overtime 1000(us)", MAX_INPUT_EVENT_TIME, type);
120     if (type == LIBINPUT_EVENT_TOUCH_CANCEL || type == LIBINPUT_EVENT_TOUCH_FRAME) {
121         MMI_HILOGD("This touch event is canceled type:%{public}d", type);
122         return;
123     }
124 #ifdef OHOS_BUILD_ENABLE_POINTER
125     if ((type == LIBINPUT_EVENT_POINTER_TAP) &&
126         (MULTI_FINGERTAP_HDR->GetMultiFingersState() == MulFingersTap::TRIPLE_TAP)) {
127         MULTI_FINGERTAP_HDR->SetMultiFingersTapHdrDefault();
128         return;
129     }
130     if ((type < LIBINPUT_EVENT_TOUCHPAD_DOWN) || (type > LIBINPUT_EVENT_TOUCHPAD_MOTION)) {
131         auto iter = std::find(ALL_EVENT_TYPES.begin(), ALL_EVENT_TYPES.end(), static_cast<int32_t>(type));
132         if (iter != ALL_EVENT_TYPES.end()) {
133             MULTI_FINGERTAP_HDR->SetMultiFingersTapHdrDefault();
134         }
135     }
136 #endif // OHOS_BUILD_ENABLE_POINTER
137     BytraceAdapter::StartHandleInput(static_cast<int32_t>(type));
138     switch (type) {
139         case LIBINPUT_EVENT_DEVICE_ADDED: {
140             OnEventDeviceAdded(event);
141             break;
142         }
143         case LIBINPUT_EVENT_DEVICE_REMOVED: {
144             OnEventDeviceRemoved(event);
145             break;
146         }
147         case LIBINPUT_EVENT_KEYBOARD_KEY: {
148             HandleKeyboardEvent(event);
149             DfxHisysevent::CalcKeyDispTimes();
150             break;
151         }
152         case LIBINPUT_EVENT_POINTER_MOTION:
153         case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE:
154         case LIBINPUT_EVENT_POINTER_BUTTON:
155         case LIBINPUT_EVENT_POINTER_BUTTON_TOUCHPAD:
156         case LIBINPUT_EVENT_POINTER_SCROLL_FINGER_BEGIN:
157         case LIBINPUT_EVENT_POINTER_AXIS:
158         case LIBINPUT_EVENT_POINTER_SCROLL_FINGER_END:
159         case LIBINPUT_EVENT_POINTER_TAP:
160         case LIBINPUT_EVENT_POINTER_MOTION_TOUCHPAD: {
161             if (g_isSwipeInward) {
162                 MMI_HILOGE("qing: no pointer motion touchpad");
163                 break;
164             }
165             HandleMouseEvent(event);
166             DfxHisysevent::CalcPointerDispTimes();
167             break;
168         }
169         case LIBINPUT_EVENT_TOUCHPAD_DOWN:
170         case LIBINPUT_EVENT_TOUCHPAD_UP:
171         case LIBINPUT_EVENT_TOUCHPAD_MOTION: {
172             HandleTouchPadEvent(event);
173             DfxHisysevent::CalcPointerDispTimes();
174             break;
175         }
176         case LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN:
177         case LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE:
178         case LIBINPUT_EVENT_GESTURE_SWIPE_END:
179         case LIBINPUT_EVENT_GESTURE_PINCH_BEGIN:
180         case LIBINPUT_EVENT_GESTURE_PINCH_UPDATE:
181         case LIBINPUT_EVENT_GESTURE_PINCH_END: {
182             HandleGestureEvent(event);
183             DfxHisysevent::CalcPointerDispTimes();
184             break;
185         }
186         case LIBINPUT_EVENT_TOUCH_DOWN:
187         case LIBINPUT_EVENT_TOUCH_UP:
188         case LIBINPUT_EVENT_TOUCH_MOTION: {
189             HandleTouchEvent(event, frameTime);
190             DfxHisysevent::CalcPointerDispTimes();
191             break;
192         }
193         case LIBINPUT_EVENT_TABLET_TOOL_AXIS:
194         case LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY:
195         case LIBINPUT_EVENT_TABLET_TOOL_TIP: {
196             HandleTableToolEvent(event);
197             break;
198         }
199         case LIBINPUT_EVENT_JOYSTICK_BUTTON:
200         case LIBINPUT_EVENT_JOYSTICK_AXIS: {
201             HandleJoystickEvent(event);
202             DfxHisysevent::CalcPointerDispTimes();
203             break;
204         }
205         case LIBINPUT_EVENT_SWITCH_TOGGLE: {
206             HandleSwitchInputEvent(event);
207             break;
208         }
209         default: {
210             MMI_HILOGD("This device does not support :%d", type);
211             break;
212         }
213     }
214     BytraceAdapter::StopHandleInput();
215     DfxHisysevent::ReportDispTimes();
216 }
217 
ProcessNullEvent(libinput_event * event,int64_t frameTime)218 bool EventNormalizeHandler::ProcessNullEvent(libinput_event *event, int64_t frameTime)
219 {
220 #ifdef OHOS_BUILD_ENABLE_TOUCH
221     std::shared_ptr<PointerEvent> pointerEvent = EventResampleHdr->GetPointerEvent();
222     if ((event == nullptr) && (pointerEvent != nullptr) && MMISceneBoardJudgement::IsSceneBoardEnabled()
223         && MMISceneBoardJudgement::IsResampleEnabled()) {
224         int32_t sourceType = pointerEvent->GetSourceType();
225         if (sourceType == PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
226             HandleTouchEvent(event, frameTime);
227         }
228         return true;
229     }
230 #endif // OHOS_BUILD_ENABLE_TOUCH
231     return false;
232 }
233 
OnEventDeviceAdded(libinput_event * event)234 int32_t EventNormalizeHandler::OnEventDeviceAdded(libinput_event *event)
235 {
236     CHKPR(event, ERROR_NULL_POINTER);
237     auto device = libinput_event_get_device(event);
238     CHKPR(device, ERROR_NULL_POINTER);
239     INPUT_DEV_MGR->OnInputDeviceAdded(device);
240     KeyMapMgr->ParseDeviceConfigFile(device);
241     KeyRepeat->AddDeviceConfig(device);
242 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
243     KeyEventHdr->ResetKeyEvent(device);
244 #endif // OHOS_BUILD_ENABLE_KEYBOARD
245     return RET_OK;
246 }
247 
OnEventDeviceRemoved(libinput_event * event)248 int32_t EventNormalizeHandler::OnEventDeviceRemoved(libinput_event *event)
249 {
250     CHKPR(event, ERROR_NULL_POINTER);
251     auto device = libinput_event_get_device(event);
252     CHKPR(device, ERROR_NULL_POINTER);
253     KeyMapMgr->RemoveKeyValue(device);
254     KeyRepeat->RemoveDeviceConfig(device);
255     INPUT_DEV_MGR->OnInputDeviceRemoved(device);
256     return RET_OK;
257 }
258 
259 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
HandleKeyEvent(const std::shared_ptr<KeyEvent> keyEvent)260 void EventNormalizeHandler::HandleKeyEvent(const std::shared_ptr<KeyEvent> keyEvent)
261 {
262     CHKPV(nextHandler_);
263     DfxHisysevent::GetDispStartTime();
264     CHKPV(keyEvent);
265     EventLogHelper::PrintEventData(keyEvent, MMI_LOG_HEADER);
266     UpdateKeyEventHandlerChain(keyEvent);
267     if (keyEvent->IsRepeat()) {
268         KeyRepeat->SelectAutoRepeat(keyEvent);
269         keyEvent->SetRepeat(false);
270     }
271     DfxHisysevent::CalcKeyDispTimes();
272     DfxHisysevent::ReportDispTimes();
273 }
274 #endif // OHOS_BUILD_ENABLE_KEYBOARD
275 
276 #ifdef OHOS_BUILD_ENABLE_POINTER
HandlePointerEvent(const std::shared_ptr<PointerEvent> pointerEvent)277 void EventNormalizeHandler::HandlePointerEvent(const std::shared_ptr<PointerEvent> pointerEvent)
278 {
279     CHKPV(nextHandler_);
280     DfxHisysevent::GetDispStartTime();
281     CHKPV(pointerEvent);
282     if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_AXIS_END) {
283         MMI_HILOGI("MouseEvent Normalization Results, PointerAction:%{public}d, PointerId:%{public}d,"
284             "SourceType:%{public}d, ButtonId:%{public}d,"
285             "VerticalAxisValue:%{public}lf, HorizontalAxisValue:%{public}lf",
286             pointerEvent->GetPointerAction(), pointerEvent->GetPointerId(), pointerEvent->GetSourceType(),
287             pointerEvent->GetButtonId(), pointerEvent->GetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL),
288             pointerEvent->GetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL));
289         PointerEvent::PointerItem item;
290         if (!pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), item)) {
291             MMI_HILOGE("Get pointer item failed. pointer:%{public}d", pointerEvent->GetPointerId());
292             return;
293         }
294         if (!EventLogHelper::IsBetaVersion()) {
295             MMI_HILOGI("MouseEvent Item Normalization Results, IsPressed:%{public}d, Pressure:%{public}f"
296                        ", Device:%{public}d",
297                 static_cast<int32_t>(item.IsPressed()), item.GetPressure(), item.GetDeviceId());
298         } else {
299             MMI_HILOGI("MouseEvent Item Normalization Results, IsPressed:%{public}d, Pressure:%{public}f"
300                        ", Device:%{public}d",
301                 static_cast<int32_t>(item.IsPressed()), item.GetPressure(), item.GetDeviceId());
302         }
303     }
304     if (pointerEvent->GetSourceType() != PointerEvent::SOURCE_TYPE_TOUCHPAD) {
305         WIN_MGR->UpdateTargetPointer(pointerEvent);
306     }
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     LogTracer lt(keyEvent->GetId(), keyEvent->GetEventType(), keyEvent->GetKeyAction());
350     if (packageResult == MULTIDEVICE_SAME_EVENT_MARK) {
351         MMI_HILOGD("The same event reported by multi_device should be discarded");
352         BytraceAdapter::StopPackageEvent();
353         return RET_OK;
354     }
355     if (packageResult != RET_OK) {
356         MMI_HILOGE("KeyEvent package failed, ret:%{public}d, errCode:%{public}d", packageResult, KEY_EVENT_PKG_FAIL);
357         BytraceAdapter::StopPackageEvent();
358         return KEY_EVENT_PKG_FAIL;
359     }
360     BytraceAdapter::StopPackageEvent();
361     BytraceAdapter::StartBytrace(keyEvent);
362     EventLogHelper::PrintEventData(keyEvent, MMI_LOG_HEADER);
363     auto device = INPUT_DEV_MGR->GetInputDevice(keyEvent->GetDeviceId());
364     CHKPR(device, RET_ERR);
365     MMI_HILOGI("InputTracking id:%{public}d event created by:%{public}s", keyEvent->GetId(), device->GetName().c_str());
366     UpdateKeyEventHandlerChain(keyEvent);
367     KeyRepeat->SelectAutoRepeat(keyEvent);
368     if (EventLogHelper::IsBetaVersion() && !keyEvent->HasFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE)) {
369         MMI_HILOGD("keyCode:%d, action:%{public}d", keyEvent->GetKeyCode(), keyEvent->GetKeyAction());
370     } else {
371         MMI_HILOGD("keyCode:%d, action:%{public}d", keyEvent->GetKeyCode(), keyEvent->GetKeyAction());
372     }
373 #else
374     MMI_HILOGW("Keyboard device does not support");
375 #endif // OHOS_BUILD_ENABLE_KEYBOARD
376     return RET_OK;
377 }
378 
379 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
UpdateKeyEventHandlerChain(const std::shared_ptr<KeyEvent> keyEvent)380 void EventNormalizeHandler::UpdateKeyEventHandlerChain(const std::shared_ptr<KeyEvent> keyEvent)
381 {
382     CALL_DEBUG_ENTER;
383     CHKPV(keyEvent);
384     WIN_MGR->HandleKeyEventWindowId(keyEvent);
385     currentHandleKeyCode_ = keyEvent->GetKeyCode();
386     int32_t currentShieldMode = KeyEventHdr->GetCurrentShieldMode();
387     if (currentShieldMode == SHIELD_MODE::FACTORY_MODE) {
388         MMI_HILOGD("The current mode is factory");
389         auto eventDispatchHandler = InputHandler->GetEventDispatchHandler();
390         CHKPV(eventDispatchHandler);
391         eventDispatchHandler->HandleKeyEvent(keyEvent);
392     } else {
393         CHKPV(nextHandler_);
394         nextHandler_->HandleKeyEvent(keyEvent);
395     }
396 }
397 #endif // OHOS_BUILD_ENABLE_KEYBOARD
398 
HandleMouseEvent(libinput_event * event)399 int32_t EventNormalizeHandler::HandleMouseEvent(libinput_event* event)
400 {
401 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
402     if (FingerprintEventHdr->IsFingerprintEvent(event)) {
403         return FingerprintEventHdr->HandleFingerprintEvent(event);
404     }
405 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
406 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_CROWN)
407     if (CROWN_EVENT_HDR->IsCrownEvent(event)) {
408         return CROWN_EVENT_HDR->NormalizeRotateEvent(event);
409     }
410 #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_CROWN
411     CHKPR(nextHandler_, ERROR_UNSUPPORT);
412 #ifdef OHOS_BUILD_ENABLE_POINTER
413     BytraceAdapter::StartPackageEvent("package mouseEvent");
414     if (MouseEventHdr->OnEvent(event) == RET_ERR) {
415         MMI_HILOGE("OnEvent is failed");
416         BytraceAdapter::StopPackageEvent();
417         return RET_ERR;
418     }
419     auto pointerEvent = MouseEventHdr->GetPointerEvent();
420     CHKPR(pointerEvent, ERROR_NULL_POINTER);
421     LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
422     PointerEventSetPressedKeys(pointerEvent);
423     BytraceAdapter::StopPackageEvent();
424     BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START);
425     HandlePalmEvent(event, pointerEvent);
426     if (SetOriginPointerId(pointerEvent) != RET_OK) {
427         MMI_HILOGE("Failed to set origin pointerId");
428         return RET_ERR;
429     }
430     nextHandler_->HandlePointerEvent(pointerEvent);
431 #else
432     MMI_HILOGW("Pointer device does not support");
433 #endif // OHOS_BUILD_ENABLE_POINTER
434     return RET_OK;
435 }
436 
HandlePalmEvent(libinput_event * event,std::shared_ptr<PointerEvent> pointerEvent)437 void EventNormalizeHandler::HandlePalmEvent(libinput_event* event, std::shared_ptr<PointerEvent> pointerEvent)
438 {
439     auto touchpad = libinput_event_get_touchpad_event(event);
440     if (touchpad == nullptr) {
441         return;
442     }
443     int32_t toolType = libinput_event_touchpad_get_tool_type(touchpad);
444     if (toolType == MT_TOOL_PALM) {
445         MMI_HILOGD("ToolType is MT_TOOL_PALM");
446         pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
447     }
448 }
449 
HandleTouchPadEvent(libinput_event * event)450 int32_t EventNormalizeHandler::HandleTouchPadEvent(libinput_event* event)
451 {
452     CHKPR(nextHandler_, ERROR_UNSUPPORT);
453 #ifdef OHOS_BUILD_ENABLE_POINTER
454     CHKPR(event, ERROR_NULL_POINTER);
455     auto touchpad = libinput_event_get_touchpad_event(event);
456     CHKPR(touchpad, ERROR_NULL_POINTER);
457     auto type = libinput_event_get_type(event);
458     int32_t seatSlot = libinput_event_touchpad_get_seat_slot(touchpad);
459     MULTI_FINGERTAP_HDR->HandleMulFingersTap(touchpad, type);
460     auto pointerEvent = TOUCH_EVENT_HDR->OnLibInput(event, TouchEventNormalize::DeviceType::TOUCH_PAD);
461     CHKPR(pointerEvent, ERROR_NULL_POINTER);
462     LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
463     if (MULTI_FINGERTAP_HDR->GetMultiFingersState() == MulFingersTap::TRIPLE_TAP) {
464         nextHandler_->HandlePointerEvent(pointerEvent);
465         MULTI_FINGERTAP_HDR->ClearPointerItems(pointerEvent);
466     }
467     buttonIds_.insert(seatSlot);
468     if (buttonIds_.size() == FINGER_NUM &&
469         (type == LIBINPUT_EVENT_TOUCHPAD_DOWN || type == LIBINPUT_EVENT_TOUCHPAD_UP)) {
470         g_isSwipeInward = false;
471     }
472     if (buttonIds_.size() == SWIPE_INWARD_FINGER_ONE && JudgeIfSwipeInward(pointerEvent, type, event)) {
473         nextHandler_->HandlePointerEvent(pointerEvent);
474     }
475     if (type == LIBINPUT_EVENT_TOUCHPAD_UP) {
476         pointerEvent->RemovePointerItem(pointerEvent->GetPointerId());
477         MMI_HILOGD("This event is up remove this finger");
478         if (pointerEvent->GetPointerIds().empty()) {
479             MMI_HILOGD("This event is final up");
480             pointerEvent->Reset();
481         }
482         buttonIds_.erase(seatSlot);
483         g_isSwipeInward = false;
484     }
485     if (buttonIds_.empty()) {
486         MULTI_FINGERTAP_HDR->SetMultiFingersTapHdrDefault(false);
487     }
488     return RET_OK;
489 #else
490     MMI_HILOGW("Pointer device does not support");
491 #endif // OHOS_BUILD_ENABLE_POINTER
492     return RET_OK;
493 }
494 
HandleGestureEvent(libinput_event * event)495 int32_t EventNormalizeHandler::HandleGestureEvent(libinput_event* event)
496 {
497     CHKPR(nextHandler_, ERROR_UNSUPPORT);
498 #ifdef OHOS_BUILD_ENABLE_POINTER
499     CHKPR(event, ERROR_NULL_POINTER);
500     auto pointerEvent = TOUCH_EVENT_HDR->OnLibInput(event, TouchEventNormalize::DeviceType::TOUCH_PAD);
501     CHKPR(pointerEvent, ERROR_NULL_POINTER);
502     LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
503     PointerEventSetPressedKeys(pointerEvent);
504     nextHandler_->HandlePointerEvent(pointerEvent);
505     auto type = libinput_event_get_type(event);
506     if (type == LIBINPUT_EVENT_GESTURE_SWIPE_END || type == LIBINPUT_EVENT_GESTURE_PINCH_END) {
507         pointerEvent->RemovePointerItem(pointerEvent->GetPointerId());
508         MMI_HILOGD("This touch pad event is up remove this finger");
509         if (pointerEvent->GetPointerIds().empty()) {
510             MMI_HILOGD("This touch pad event is final finger up remove this finger");
511             pointerEvent->Reset();
512         }
513     }
514 #else
515     MMI_HILOGW("Pointer device does not support");
516 #endif // OHOS_BUILD_ENABLE_POINTER
517     return RET_OK;
518 }
519 
520 #ifdef OHOS_RSS_CLIENT
ReportTouchDownToRSS(libinput_event * event)521     inline void ReportTouchDownToRSS(libinput_event* event)
522 {
523     if (libinput_event_get_type(event) == LIBINPUT_EVENT_TOUCH_DOWN) {
524         std::unordered_map<std::string, std::string> mapPayload;
525         OHOS::ResourceSchedule::ResSchedClient::GetInstance().ReportData(
526             OHOS::ResourceSchedule::ResType::RES_TYPE_CLICK_RECOGNIZE,
527             OHOS::ResourceSchedule::ResType::ClickEventType::TOUCH_EVENT_DOWN_MMI,
528             mapPayload);
529     }
530 }
531 #endif //OHOS_RSS_CLIENT
532 
HandleTouchEvent(libinput_event * event,int64_t frameTime)533 int32_t EventNormalizeHandler::HandleTouchEvent(libinput_event* event, int64_t frameTime)
534 {
535     CHKPR(nextHandler_, ERROR_UNSUPPORT);
536 #ifdef OHOS_RSS_CLIENT
537     ReportTouchDownToRSS(event);
538 #endif //OHOS_RSS_CLIENT
539 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
540     FingerprintEventHdr->SetScreenState(event);
541 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
542 #ifdef OHOS_BUILD_ENABLE_TOUCH
543     BytraceAdapter::StartPackageEvent("package touchEvent");
544     std::shared_ptr<PointerEvent> pointerEvent = nullptr;
545     LogTracer lt;
546     if (event != nullptr) {
547         pointerEvent = TOUCH_EVENT_HDR->OnLibInput(event, TouchEventNormalize::DeviceType::TOUCH);
548         CHKPR(pointerEvent, ERROR_NULL_POINTER);
549         lt = LogTracer(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
550     }
551     if (MMISceneBoardJudgement::IsSceneBoardEnabled() && MMISceneBoardJudgement::IsResampleEnabled()) {
552         ErrCode status = RET_OK;
553         std::shared_ptr<PointerEvent> outputEvent = EventResampleHdr->OnEventConsume(pointerEvent, frameTime, status);
554         CHKPR(outputEvent, RET_OK);
555         MMI_HILOGD("Output event received, SourceType:%{public}d, PointerAction:%{public}d, status:%{public}d",
556             outputEvent->GetSourceType(), outputEvent->GetPointerAction(), status);
557         EndLogTraceId(pointerEvent->GetId());
558         pointerEvent = outputEvent;
559         lt = LogTracer(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
560     }
561     BytraceAdapter::StopPackageEvent();
562     PointerEventSetPressedKeys(pointerEvent);
563     if (pointerEvent != nullptr) {
564         BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START);
565         if (SetOriginPointerId(pointerEvent) != RET_OK) {
566             MMI_HILOGE("Failed to set origin pointerId");
567             return RET_ERR;
568         }
569         nextHandler_->HandleTouchEvent(pointerEvent);
570     }
571     if ((pointerEvent != nullptr) && (event != nullptr)) {
572         ResetTouchUpEvent(pointerEvent, event);
573     }
574 #else
575     MMI_HILOGW("Touchscreen device does not support");
576 #endif // OHOS_BUILD_ENABLE_TOUCH
577     return RET_OK;
578 }
579 
PointerEventSetPressedKeys(std::shared_ptr<PointerEvent> pointerEvent)580 void EventNormalizeHandler::PointerEventSetPressedKeys(std::shared_ptr<PointerEvent> pointerEvent)
581 {
582 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
583     if (KeyEventHdr != nullptr) {
584         const auto &keyEvent = KeyEventHdr->GetKeyEvent();
585         if (keyEvent != nullptr && pointerEvent != nullptr) {
586             std::vector<int32_t> pressedKeys = keyEvent->GetPressedKeys();
587             pointerEvent->SetPressedKeys(pressedKeys);
588         }
589     }
590 #endif // OHOS_BUILD_ENABLE_KEYBOARD
591 }
592 
ResetTouchUpEvent(std::shared_ptr<PointerEvent> pointerEvent,struct libinput_event * event)593 void EventNormalizeHandler::ResetTouchUpEvent(std::shared_ptr<PointerEvent> pointerEvent,
594     struct libinput_event *event)
595 {
596     CHKPV(pointerEvent);
597     CHKPV(event);
598     auto type = libinput_event_get_type(event);
599     if (type == LIBINPUT_EVENT_TOUCH_UP) {
600         pointerEvent->RemovePointerItem(pointerEvent->GetPointerId());
601         MMI_HILOGD("This touch event is up remove this finger");
602         if (pointerEvent->GetPointerIds().empty()) {
603             MMI_HILOGD("This touch event is final finger up remove this finger");
604             pointerEvent->Reset();
605         }
606     }
607 }
608 
HandleTableToolEvent(libinput_event * event)609 int32_t EventNormalizeHandler::HandleTableToolEvent(libinput_event* event)
610 {
611     CHKPR(nextHandler_, ERROR_UNSUPPORT);
612 #ifdef OHOS_BUILD_ENABLE_TOUCH
613     CHKPR(event, ERROR_NULL_POINTER);
614     BytraceAdapter::StartPackageEvent("package penEvent");
615     auto pointerEvent = TOUCH_EVENT_HDR->OnLibInput(event, TouchEventNormalize::DeviceType::TABLET_TOOL);
616     BytraceAdapter::StopPackageEvent();
617     CHKPR(pointerEvent, ERROR_NULL_POINTER);
618     LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
619     BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START);
620     nextHandler_->HandleTouchEvent(pointerEvent);
621     if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_UP) {
622         pointerEvent->Reset();
623     }
624 #else
625     MMI_HILOGW("TableTool device does not support");
626 #endif // OHOS_BUILD_ENABLE_TOUCH
627     return RET_OK;
628 }
629 
HandleJoystickEvent(libinput_event * event)630 int32_t EventNormalizeHandler::HandleJoystickEvent(libinput_event* event)
631 {
632     CHKPR(nextHandler_, ERROR_UNSUPPORT);
633 #ifdef OHOS_BUILD_ENABLE_JOYSTICK
634     CHKPR(event, ERROR_NULL_POINTER);
635     BytraceAdapter::StartPackageEvent("package joystickEvent");
636     auto pointerEvent = TOUCH_EVENT_HDR->OnLibInput(event, TouchEventNormalize::DeviceType::JOYSTICK);
637     BytraceAdapter::StopPackageEvent();
638     CHKPR(pointerEvent, ERROR_NULL_POINTER);
639     BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START);
640     nextHandler_->HandlePointerEvent(pointerEvent);
641 #else
642     MMI_HILOGW("Joystick device does not support");
643 #endif // OHOS_BUILD_ENABLE_JOYSTICK
644     return RET_OK;
645 }
646 
HandleSwitchInputEvent(libinput_event * event)647 int32_t EventNormalizeHandler::HandleSwitchInputEvent(libinput_event* event)
648 {
649     CHKPR(nextHandler_, ERROR_UNSUPPORT);
650 #ifdef OHOS_BUILD_ENABLE_SWITCH
651     CHKPR(event, ERROR_NULL_POINTER);
652     struct libinput_event_switch *swev = libinput_event_get_switch_event(event);
653     CHKPR(swev, ERROR_NULL_POINTER);
654     enum libinput_switch_state state = libinput_event_switch_get_switch_state(swev);
655     enum libinput_switch sw = libinput_event_switch_get_switch(swev);
656     MMI_HILOGI("libinput_event_switch type:%{public}d, state:%{public}d", sw, state);
657     if (sw == LIBINPUT_SWITCH_PRIVACY && state == LIBINPUT_SWITCH_STATE_OFF) {
658         MMI_HILOGD("Privacy switch event ignored");
659         return RET_OK;
660     }
661 
662     auto swEvent = std::make_unique<SwitchEvent>(static_cast<int32_t>(state));
663     swEvent->SetSwitchType(static_cast<int32_t>(sw));
664     if (sw == LIBINPUT_SWITCH_LID && state == LIBINPUT_SWITCH_STATE_ON) {
665         RestoreTouchPadStatus();
666     }
667     nextHandler_->HandleSwitchEvent(std::move(swEvent));
668 #else
669     MMI_HILOGW("Switch device does not support");
670 #endif // OHOS_BUILD_ENABLE_SWITCH
671     return RET_OK;
672 }
673 
AddHandleTimer(int32_t timeout)674 int32_t EventNormalizeHandler::AddHandleTimer(int32_t timeout)
675 {
676     CALL_DEBUG_ENTER;
677     timerId_ = TimerMgr->AddTimer(timeout, 1, [this]() {
678         timerId_ = -1;
679 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
680         auto keyEvent = KeyEventHdr->GetKeyEvent();
681         CHKPV(keyEvent);
682         UpdateKeyEventHandlerChain(keyEvent);
683         int32_t triggerTime = KeyRepeat->GetIntervalTime(keyEvent->GetDeviceId());
684         this->AddHandleTimer(triggerTime);
685 #endif // OHOS_BUILD_ENABLE_KEYBOARD
686     });
687     return timerId_;
688 }
689 
SetOriginPointerId(std::shared_ptr<PointerEvent> pointerEvent)690 int32_t EventNormalizeHandler::SetOriginPointerId(std::shared_ptr<PointerEvent> pointerEvent)
691 {
692     CALL_DEBUG_ENTER;
693     CHKPR(pointerEvent, ERROR_NULL_POINTER);
694     int32_t pointerId = pointerEvent->GetPointerId();
695     PointerEvent::PointerItem pointerItem;
696     if (!pointerEvent->GetPointerItem(pointerId, pointerItem)) {
697         MMI_HILOGE("Can't find pointer item, pointer:%{public}d", pointerId);
698         return RET_ERR;
699     }
700     pointerItem.SetOriginPointerId(pointerItem.GetPointerId());
701     pointerEvent->UpdatePointerItem(pointerId, pointerItem);
702     MMI_HILOGD("pointerId:%{public}d, originPointerId:%{public}d",
703         pointerId, pointerItem.GetPointerId());
704     return RET_OK;
705 }
706 
CancelTwoFingerAxis(libinput_event * event)707 void EventNormalizeHandler::CancelTwoFingerAxis(libinput_event* event)
708 {
709     CALL_DEBUG_ENTER;
710     auto type = libinput_event_get_type(event);
711     if (type != LIBINPUT_EVENT_GESTURE_PINCH_BEGIN) {
712         MMI_HILOGE("Current event is not expected");
713         return;
714     }
715     bool result = MouseEventHdr->CheckAndPackageAxisEvent(event);
716     if (!result) {
717         MMI_HILOGE("Check or packet axis event failed");
718         return;
719     }
720     auto pointerEvent = MouseEventHdr->GetPointerEvent();
721     CHKPV(pointerEvent);
722     nextHandler_->HandlePointerEvent(pointerEvent);
723 }
724 
TerminateAxis(libinput_event * event)725 void EventNormalizeHandler::TerminateAxis(libinput_event* event)
726 {
727     CALL_DEBUG_ENTER;
728 #ifdef OHOS_BUILD_ENABLE_POINTER
729     auto type = libinput_event_get_type(event);
730     if (type == LIBINPUT_EVENT_POINTER_BUTTON_TOUCHPAD) {
731         bool result = MouseEventHdr->CheckAndPackageAxisEvent(event);
732         if (!result) {
733             MMI_HILOGE("Check or packet the axis event failed");
734             return;
735         }
736         MMI_HILOGI("Terminate axis event");
737         auto pointerEvent = MouseEventHdr->GetPointerEvent();
738         CHKPV(pointerEvent);
739         nextHandler_->HandlePointerEvent(pointerEvent);
740     }
741 #else
742     MMI_HILOGW("Pointer device does not support");
743 #endif // OHOS_BUILD_ENABLE_POINTER
744 }
745 
JudgeIfSwipeInward(std::shared_ptr<PointerEvent> pointerEvent,enum libinput_event_type type,libinput_event * event)746 bool EventNormalizeHandler::JudgeIfSwipeInward(std::shared_ptr<PointerEvent> pointerEvent,
747     enum libinput_event_type type, libinput_event* event)
748 {
749     thread_local static int32_t angleTolerance = 0;
750     thread_local static int32_t lastDirection = 0;
751     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD);
752     if (g_isSwipeInward == false &&
753         type == LIBINPUT_EVENT_TOUCHPAD_DOWN &&
754         pointerEvent->GetAllPointerItems().size() == SWIPE_INWARD_FINGER_ONE) {
755         auto touchPadDevice = libinput_event_get_device(event);
756         // product isolation
757         uint32_t touchPadDeviceId = libinput_device_get_id_product(touchPadDevice);
758         if (touchPadDeviceId != TABLET_PRODUCT_DEVICE_ID && touchPadDeviceId != BLE_PRODUCT_DEVICE_ID) {
759             return g_isSwipeInward;
760         }
761         // get touchpad physic size
762         if (libinput_device_get_size(touchPadDevice, &g_touchPadDeviceWidth, &g_touchPadDeviceHeight)) {
763             MMI_HILOGD("judgeIfSwipeInward, get touchPad physic size error");
764         }
765         // get touchpad max axis size
766         g_touchPadDeviceAxisX = libinput_device_get_axis_max(touchPadDevice, USELIB_ABS_MT_POSITION_X);
767         g_touchPadDeviceAxisY = libinput_device_get_axis_max(touchPadDevice, USELIB_ABS_MT_POSITION_Y);
768         // if down position on edge, start deliver data
769         if (pointerEvent->GetAllPointerItems().begin()->GetDisplayX() >=
770             g_touchPadDeviceWidth - SWIPE_INWARD_EDGE_X_THRE) {
771             lastDirection = -1; // -1 means direction from right to left
772             g_isSwipeInward = true;
773         } else if (pointerEvent->GetAllPointerItems().begin()->GetDisplayX() <= SWIPE_INWARD_EDGE_X_THRE) {
774             lastDirection = 1; // 1 means direction from left to right
775             g_isSwipeInward = true;
776         }
777     }
778     // judge
779     if (g_isSwipeInward == true) {
780         SwipeInwardProcess(pointerEvent, type, event, &angleTolerance, lastDirection);
781     }
782     return g_isSwipeInward;
783 }
784 
SwipeInwardProcess(std::shared_ptr<PointerEvent> pointerEvent,enum libinput_event_type type,libinput_event * event,int32_t * angleTolerance,int32_t lastDirection)785 void EventNormalizeHandler::SwipeInwardProcess(std::shared_ptr<PointerEvent> pointerEvent,
786     enum libinput_event_type type, libinput_event* event, int32_t* angleTolerance, int32_t lastDirection)
787 {
788     thread_local static int32_t lastPointerX;
789     thread_local static int32_t lastPointerY;
790     int32_t pointerMotionX;
791     int32_t pointerMotionY;
792     int32_t pointerId = pointerEvent->GetPointerId();
793     PointerEvent::PointerItem pointerItem;
794     if (!pointerEvent->GetPointerItem(pointerId, pointerItem)) {
795         MMI_HILOGD("judgeIfSwipeInward, Can't find pointerItem");
796         g_isSwipeInward = false;
797         return;
798     }
799     switch (static_cast<int32_t>(type)) {
800         case static_cast<int32_t>(LIBINPUT_EVENT_TOUCHPAD_DOWN):
801             pointerItem.SetDisplayX(g_touchPadDeviceAxisX);
802             pointerItem.SetDisplayY(g_touchPadDeviceAxisY);
803             *angleTolerance = SWIPE_INWARD_ANGLE_TOLERANCE;
804             return;
805         case static_cast<int32_t>(LIBINPUT_EVENT_TOUCHPAD_MOTION): {
806             auto touchpad = libinput_event_get_touchpad_event(event);
807             pointerItem.SetDisplayX(static_cast<int32_t>(
808                 (libinput_event_touchpad_get_x(touchpad) / g_touchPadDeviceWidth) * g_touchPadDeviceAxisX));
809             pointerItem.SetDisplayY(static_cast<int32_t>(
810                 (libinput_event_touchpad_get_y(touchpad) / g_touchPadDeviceHeight) * g_touchPadDeviceAxisY));
811             break;
812         }
813         case static_cast<int32_t>(LIBINPUT_EVENT_TOUCHPAD_UP):
814             lastPointerX = 0;
815             return;
816         default:
817             return;
818     }
819     // angle and direction judge
820     if ((std::abs(pointerItem.GetDisplayX() - lastPointerX) * SWIPE_INWARD_ANGLE_JUDGE <
821         std::abs(pointerItem.GetDisplayY() - lastPointerY) ||
822         (pointerItem.GetDisplayX() - lastPointerX) * lastDirection < 0) && lastPointerX) {
823         --(*angleTolerance); // angle judge have more weights than direction judge
824         --(*angleTolerance);
825     }
826     lastPointerX = pointerItem.GetDisplayX();
827     lastPointerY = pointerItem.GetDisplayY();
828 }
829 
830 #ifdef OHOS_BUILD_ENABLE_SWITCH
RestoreTouchPadStatus()831 void EventNormalizeHandler::RestoreTouchPadStatus()
832 {
833     CALL_INFO_TRACE;
834 #ifdef OHOS_BUILD_ENABLE_POINTER
835     auto ids = INPUT_DEV_MGR->GetTouchPadIds();
836     for (auto id : ids) {
837         MMI_HILOGI("Restore touchpad, deviceId:%{public}d", id);
838         auto mouseEvent = TOUCH_EVENT_HDR->GetPointerEvent(id);
839         if (mouseEvent != nullptr) {
840             mouseEvent->Reset();
841         }
842         mouseEvent = MouseEventHdr->GetPointerEvent(id);
843         if (mouseEvent != nullptr) {
844             mouseEvent->Reset();
845         }
846     }
847 #endif // OHOS_BUILD_ENABLE_POINTER
848     buttonIds_.clear();
849 }
850 #endif // OHOS_BUILD_ENABLE_SWITCH
851 } // namespace MMI
852 } // namespace OHOS
853