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