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