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