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