1 /*
2 * Copyright (c) 2021-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 "touchpad_transform_processor.h"
17
18 #include <linux/input.h>
19
20 #include <sstream>
21
22 #include "dfx_hisysevent.h"
23 #include "event_log_helper.h"
24 #include "i_input_windows_manager.h"
25 #include "i_preference_manager.h"
26 #include "mmi_log.h"
27 #include "mouse_device_state.h"
28 #include "preferences.h"
29 #include "preferences_errno.h"
30 #include "preferences_helper.h"
31
32 #undef MMI_LOG_DOMAIN
33 #define MMI_LOG_DOMAIN MMI_LOG_DISPATCH
34 #undef MMI_LOG_TAG
35 #define MMI_LOG_TAG "TouchPadTransformProcessor"
36
37 namespace OHOS {
38 namespace MMI {
39 namespace {
40 constexpr int32_t MT_TOOL_NONE { -1 };
41 constexpr int32_t BTN_DOWN { 1 };
42 constexpr int32_t FINGER_COUNT_MAX { 5 };
43 constexpr int32_t FINGER_TAP_MIN { 3 };
44 constexpr int32_t TP_SYSTEM_PINCH_FINGER_CNT { 2 };
45 constexpr int32_t DEFAULT_POINTER_ID { 0 };
46
47 const std::string TOUCHPAD_FILE_NAME = "touchpad_settings.xml";
48 } // namespace
49
TouchPadTransformProcessor(int32_t deviceId)50 TouchPadTransformProcessor::TouchPadTransformProcessor(int32_t deviceId)
51 : deviceId_(deviceId)
52 {
53 InitToolType();
54 }
55
OnEventTouchPadDown(struct libinput_event * event)56 int32_t TouchPadTransformProcessor::OnEventTouchPadDown(struct libinput_event *event)
57 {
58 CALL_INFO_TRACE;
59 CHKPR(event, RET_ERR);
60 auto touchpad = libinput_event_get_touchpad_event(event);
61 CHKPR(touchpad, RET_ERR);
62 auto device = libinput_event_get_device(event);
63 CHKPR(device, RET_ERR);
64
65 uint64_t time = libinput_event_touchpad_get_time_usec(touchpad);
66 auto pointIds = pointerEvent_->GetPointerIds();
67 if (pointIds.empty()) {
68 pointerEvent_->SetActionStartTime(time);
69 }
70 pointerEvent_->SetActionTime(time);
71 pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
72 PointerEvent::PointerItem item;
73 int32_t longAxis = libinput_event_touchpad_get_touch_contact_long_axis(touchpad);
74 int32_t shortAxis = libinput_event_touchpad_get_touch_contact_short_axis(touchpad);
75 double pressure = libinput_event_touchpad_get_pressure(touchpad);
76 int32_t seatSlot = libinput_event_touchpad_get_seat_slot(touchpad);
77 double logicalX = libinput_event_touchpad_get_x(touchpad);
78 double logicalY = libinput_event_touchpad_get_y(touchpad);
79 double toolPhysicalX = libinput_event_touchpad_get_tool_x(touchpad);
80 double toolPhysicalY = libinput_event_touchpad_get_tool_y(touchpad);
81 double toolWidth = libinput_event_touchpad_get_tool_width(touchpad);
82 double toolHeight = libinput_event_touchpad_get_tool_height(touchpad);
83 int32_t toolType = GetTouchPadToolType(touchpad, device);
84 if (toolType == PointerEvent::TOOL_TYPE_PALM) {
85 pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
86 }
87
88 item.SetLongAxis(longAxis);
89 item.SetShortAxis(shortAxis);
90 item.SetPressure(pressure);
91 item.SetToolType(toolType);
92 item.SetPointerId(seatSlot);
93 item.SetDownTime(time);
94 item.SetPressed(true);
95 item.SetDisplayX(static_cast<int32_t>(logicalX));
96 item.SetDisplayY(static_cast<int32_t>(logicalY));
97 item.SetToolDisplayX(static_cast<int32_t>(toolPhysicalX));
98 item.SetToolDisplayY(static_cast<int32_t>(toolPhysicalY));
99 item.SetToolWidth(static_cast<int32_t>(toolWidth));
100 item.SetToolHeight(static_cast<int32_t>(toolHeight));
101 item.SetDeviceId(deviceId_);
102 pointerEvent_->SetDeviceId(deviceId_);
103 pointerEvent_->AddPointerItem(item);
104 pointerEvent_->SetPointerId(seatSlot);
105
106 return RET_OK;
107 }
108
OnEventTouchPadMotion(struct libinput_event * event)109 int32_t TouchPadTransformProcessor::OnEventTouchPadMotion(struct libinput_event *event)
110 {
111 CALL_DEBUG_ENTER;
112 CHKPR(event, RET_ERR);
113 auto touchpad = libinput_event_get_touchpad_event(event);
114 CHKPR(touchpad, RET_ERR);
115 int32_t seatSlot = libinput_event_touchpad_get_seat_slot(touchpad);
116 auto device = libinput_event_get_device(event);
117 CHKPR(device, RET_ERR);
118
119 uint64_t time = libinput_event_touchpad_get_time_usec(touchpad);
120 pointerEvent_->SetActionTime(time);
121 pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
122 PointerEvent::PointerItem item;
123 if (!pointerEvent_->GetPointerItem(seatSlot, item)) {
124 MMI_HILOGD("Can't find the pointer item data, seatSlot:%{public}d, errCode:%{public}d",
125 seatSlot, PARAM_INPUT_FAIL);
126 return RET_ERR;
127 }
128 int32_t longAxis = libinput_event_touchpad_get_touch_contact_long_axis(touchpad);
129 int32_t shortAxis = libinput_event_touchpad_get_touch_contact_short_axis(touchpad);
130 double pressure = libinput_event_touchpad_get_pressure(touchpad);
131 double logicalX = libinput_event_touchpad_get_x(touchpad);
132 double logicalY = libinput_event_touchpad_get_y(touchpad);
133 double toolPhysicalX = libinput_event_touchpad_get_tool_x(touchpad);
134 double toolPhysicalY = libinput_event_touchpad_get_tool_y(touchpad);
135 double toolWidth = libinput_event_touchpad_get_tool_width(touchpad);
136 double toolHeight = libinput_event_touchpad_get_tool_height(touchpad);
137 int32_t toolType = GetTouchPadToolType(touchpad, device);
138 if (toolType == PointerEvent::TOOL_TYPE_PALM) {
139 pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
140 }
141
142 item.SetLongAxis(longAxis);
143 item.SetShortAxis(shortAxis);
144 item.SetPressure(pressure);
145 item.SetDisplayX(static_cast<int32_t>(logicalX));
146 item.SetDisplayY(static_cast<int32_t>(logicalY));
147 item.SetToolDisplayX(static_cast<int32_t>(toolPhysicalX));
148 item.SetToolDisplayY(static_cast<int32_t>(toolPhysicalY));
149 item.SetToolWidth(static_cast<int32_t>(toolWidth));
150 item.SetToolHeight(static_cast<int32_t>(toolHeight));
151 pointerEvent_->UpdatePointerItem(seatSlot, item);
152 pointerEvent_->SetPointerId(seatSlot);
153
154 return RET_OK;
155 }
156
OnEventTouchPadUp(struct libinput_event * event)157 int32_t TouchPadTransformProcessor::OnEventTouchPadUp(struct libinput_event *event)
158 {
159 CALL_DEBUG_ENTER;
160 CHKPR(event, RET_ERR);
161 auto touchpad = libinput_event_get_touchpad_event(event);
162 CHKPR(touchpad, RET_ERR);
163 int32_t seatSlot = libinput_event_touchpad_get_seat_slot(touchpad);
164
165 uint64_t time = libinput_event_touchpad_get_time_usec(touchpad);
166 pointerEvent_->SetActionTime(time);
167 if (MULTI_FINGERTAP_HDR->GetMultiFingersState() == MulFingersTap::TRIPLE_TAP) {
168 SetTouchPadMultiTapData();
169 } else {
170 pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
171 }
172 PointerEvent::PointerItem item;
173 if (!pointerEvent_->GetPointerItem(seatSlot, item)) {
174 MMI_HILOGE("Can't find the pointer item data, seatSlot:%{public}d, errCode:%{public}d",
175 seatSlot, PARAM_INPUT_FAIL);
176 return RET_ERR;
177 }
178 item.SetPressed(false);
179 pointerEvent_->UpdatePointerItem(seatSlot, item);
180 pointerEvent_->SetPointerId(seatSlot);
181
182 return RET_OK;
183 }
184
OnEvent(struct libinput_event * event)185 std::shared_ptr<PointerEvent> TouchPadTransformProcessor::OnEvent(struct libinput_event *event)
186 {
187 CALL_DEBUG_ENTER;
188 CHKPP(event);
189 if (pointerEvent_ == nullptr) {
190 pointerEvent_ = PointerEvent::Create();
191 CHKPP(pointerEvent_);
192 }
193
194 int32_t ret = RET_OK;
195 int32_t type = libinput_event_get_type(event);
196 switch (type) {
197 case LIBINPUT_EVENT_TOUCHPAD_DOWN: {
198 ret = OnEventTouchPadDown(event);
199 break;
200 }
201 case LIBINPUT_EVENT_TOUCHPAD_UP: {
202 ret = OnEventTouchPadUp(event);
203 break;
204 }
205 case LIBINPUT_EVENT_TOUCHPAD_MOTION: {
206 ret = OnEventTouchPadMotion(event);
207 break;
208 }
209 case LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN: {
210 ret = OnEventTouchPadSwipeBegin(event);
211 break;
212 }
213 case LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE: {
214 ret = OnEventTouchPadSwipeUpdate(event);
215 break;
216 }
217 case LIBINPUT_EVENT_GESTURE_SWIPE_END: {
218 ret = OnEventTouchPadSwipeEnd(event);
219 break;
220 }
221
222 case LIBINPUT_EVENT_GESTURE_PINCH_BEGIN: {
223 ret = OnEventTouchPadPinchBegin(event);
224 break;
225 }
226 case LIBINPUT_EVENT_GESTURE_PINCH_UPDATE: {
227 ret = OnEventTouchPadPinchUpdate(event);
228 break;
229 }
230 case LIBINPUT_EVENT_GESTURE_PINCH_END: {
231 ret = OnEventTouchPadPinchEnd(event);
232 break;
233 }
234 default: {
235 MMI_HILOGW("Touch pad action is not found");
236 return nullptr;
237 }
238 }
239
240 if (ret != RET_OK) {
241 return nullptr;
242 }
243
244 pointerEvent_->UpdateId();
245 StartLogTraceId(pointerEvent_->GetId(), pointerEvent_->GetEventType(), pointerEvent_->GetPointerAction());
246 MMI_HILOGD("Pointer event dispatcher of server:");
247 EventLogHelper::PrintEventData(pointerEvent_, pointerEvent_->GetPointerAction(),
248 pointerEvent_->GetPointerIds().size(), MMI_LOG_FREEZE);
249 auto device = INPUT_DEV_MGR->GetInputDevice(pointerEvent_->GetDeviceId());
250 CHKPP(device);
251 if (pointerEvent_->GetPointerAction() != PointerEvent::POINTER_ACTION_MOVE &&
252 pointerEvent_->GetPointerAction() != PointerEvent::POINTER_ACTION_SWIPE_UPDATE) {
253 aggregator_.Record(MMI_LOG_FREEZE, device->GetName() + ", TW: " +
254 std::to_string(pointerEvent_->GetTargetWindowId()), std::to_string(pointerEvent_->GetId()));
255 }
256
257 return pointerEvent_;
258 }
259
GetTouchPadToolType(struct libinput_event_touch * touchpad,struct libinput_device * device)260 int32_t TouchPadTransformProcessor::GetTouchPadToolType(
261 struct libinput_event_touch *touchpad, struct libinput_device *device)
262 {
263 int32_t toolType = libinput_event_touchpad_get_tool_type(touchpad);
264 switch (toolType) {
265 case MT_TOOL_NONE: {
266 return GetTouchPadToolType(device);
267 }
268 case MT_TOOL_FINGER: {
269 return PointerEvent::TOOL_TYPE_FINGER;
270 }
271 case MT_TOOL_PEN: {
272 return PointerEvent::TOOL_TYPE_PEN;
273 }
274 case MT_TOOL_PALM: {
275 MMI_HILOGD("toolType is MT_TOOL_PALM");
276 return PointerEvent::TOOL_TYPE_PALM;
277 }
278 default : {
279 MMI_HILOGW("Unknown tool type, identified as finger, toolType:%{public}d", toolType);
280 return PointerEvent::TOOL_TYPE_FINGER;
281 }
282 }
283 }
284
GetTouchPadToolType(struct libinput_device * device)285 int32_t TouchPadTransformProcessor::GetTouchPadToolType(struct libinput_device *device)
286 {
287 for (const auto &item : vecToolType_) {
288 if (libinput_device_touchpad_btn_tool_type_down(device, item.first) == BTN_DOWN) {
289 return item.second;
290 }
291 }
292 MMI_HILOGD("Unknown Btn tool type, identified as finger");
293 return PointerEvent::TOOL_TYPE_FINGER;
294 }
295
SetTouchPadSwipeData(struct libinput_event * event,int32_t action)296 int32_t TouchPadTransformProcessor::SetTouchPadSwipeData(struct libinput_event *event, int32_t action)
297 {
298 CALL_DEBUG_ENTER;
299
300 bool tpSwipeSwitch = true;
301 GetTouchpadSwipeSwitch(tpSwipeSwitch);
302
303 if (!tpSwipeSwitch) {
304 MMI_HILOGD("Touchpad swipe switch is false");
305 return RET_ERR;
306 }
307
308 CHKPR(event, RET_ERR);
309 struct libinput_event_gesture *gesture = libinput_event_get_gesture_event(event);
310 CHKPR(gesture, RET_ERR);
311
312 int64_t time = static_cast<int64_t>(libinput_event_gesture_get_time(gesture));
313 pointerEvent_->SetActionTime(GetSysClockTime());
314 pointerEvent_->SetActionStartTime(time);
315 pointerEvent_->SetPointerAction(action);
316 pointerEvent_->SetDeviceId(deviceId_);
317
318 int32_t fingerCount = libinput_event_gesture_get_finger_count(gesture);
319 if (fingerCount < 0 || fingerCount > FINGER_COUNT_MAX) {
320 MMI_HILOGE("Finger count is invalid");
321 return RET_ERR;
322 }
323 pointerEvent_->SetFingerCount(fingerCount);
324
325 if (fingerCount == 0) {
326 MMI_HILOGD("There is no finger in swipe action:%{public}d", action);
327 return RET_ERR;
328 }
329
330 int32_t sumX = 0;
331 int32_t sumY = 0;
332 for (int32_t i = 0; i < fingerCount; i++) {
333 sumX += libinput_event_gesture_get_device_coords_x(gesture, i);
334 sumY += libinput_event_gesture_get_device_coords_y(gesture, i);
335 }
336
337 PointerEvent::PointerItem pointerItem;
338 pointerEvent_->GetPointerItem(DEFAULT_POINTER_ID, pointerItem);
339 pointerItem.SetPressed(MouseState->IsLeftBtnPressed());
340 pointerItem.SetDownTime(time);
341 pointerItem.SetDisplayX(sumX / fingerCount);
342 pointerItem.SetDisplayY(sumY / fingerCount);
343 pointerItem.SetDeviceId(deviceId_);
344 pointerItem.SetPointerId(DEFAULT_POINTER_ID);
345 pointerEvent_->SetPointerId(DEFAULT_POINTER_ID);
346 pointerEvent_->UpdatePointerItem(DEFAULT_POINTER_ID, pointerItem);
347 pointerEvent_->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD);
348
349 if (action == PointerEvent::POINTER_ACTION_SWIPE_BEGIN) {
350 MMI_HILOGE("Start report for POINTER_ACTION_SWIPE_BEGIN");
351 DfxHisysevent::StatisticTouchpadGesture(pointerEvent_);
352 }
353
354 return RET_OK;
355 }
356
OnEventTouchPadSwipeBegin(struct libinput_event * event)357 int32_t TouchPadTransformProcessor::OnEventTouchPadSwipeBegin(struct libinput_event *event)
358 {
359 CALL_DEBUG_ENTER;
360 return SetTouchPadSwipeData(event, PointerEvent::POINTER_ACTION_SWIPE_BEGIN);
361 }
362
OnEventTouchPadSwipeUpdate(struct libinput_event * event)363 int32_t TouchPadTransformProcessor::OnEventTouchPadSwipeUpdate(struct libinput_event *event)
364 {
365 CALL_DEBUG_ENTER;
366 return SetTouchPadSwipeData(event, PointerEvent::POINTER_ACTION_SWIPE_UPDATE);
367 }
368
OnEventTouchPadSwipeEnd(struct libinput_event * event)369 int32_t TouchPadTransformProcessor::OnEventTouchPadSwipeEnd(struct libinput_event *event)
370 {
371 CALL_DEBUG_ENTER;
372 return SetTouchPadSwipeData(event, PointerEvent::POINTER_ACTION_SWIPE_END);
373 }
374
SetTouchPadMultiTapData()375 void TouchPadTransformProcessor::SetTouchPadMultiTapData()
376 {
377 pointerEvent_->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD);
378 pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_TRIPTAP);
379 auto state = MULTI_FINGERTAP_HDR->GetMultiFingersState();
380 pointerEvent_->SetFingerCount(static_cast<int32_t>(state));
381 }
382
SetTouchPadPinchData(struct libinput_event * event,int32_t action)383 int32_t TouchPadTransformProcessor::SetTouchPadPinchData(struct libinput_event *event, int32_t action)
384 {
385 CALL_DEBUG_ENTER;
386
387 bool tpPinchSwitch = true;
388 GetTouchpadPinchSwitch(tpPinchSwitch);
389
390 CHKPR(event, RET_ERR);
391 auto gesture = libinput_event_get_gesture_event(event);
392 CHKPR(gesture, RET_ERR);
393 int32_t fingerCount = libinput_event_gesture_get_finger_count(gesture);
394 if (fingerCount <= 0 || fingerCount > FINGER_COUNT_MAX) {
395 MMI_HILOGE("Finger count is invalid");
396 return RET_ERR;
397 }
398
399 if (!tpPinchSwitch && fingerCount == TP_SYSTEM_PINCH_FINGER_CNT) {
400 MMI_HILOGD("Touchpad pinch switch is false");
401 return RET_ERR;
402 }
403
404 int64_t time = static_cast<int64_t>(libinput_event_gesture_get_time(gesture));
405 double scale = libinput_event_gesture_get_scale(gesture);
406
407 pointerEvent_->SetActionTime(GetSysClockTime());
408 pointerEvent_->SetActionStartTime(time);
409
410 SetPinchPointerItem(time);
411
412 ProcessTouchPadPinchDataEvent(fingerCount, action, scale);
413
414 return RET_OK;
415 }
416
SetPinchPointerItem(int64_t time)417 void TouchPadTransformProcessor::SetPinchPointerItem(int64_t time)
418 {
419 PointerEvent::PointerItem pointerItem;
420 pointerItem.SetDownTime(time);
421 pointerItem.SetPressed(MouseState->IsLeftBtnPressed());
422 pointerItem.SetPointerId(DEFAULT_POINTER_ID);
423 pointerItem.SetWindowX(0);
424 pointerItem.SetWindowY(0);
425 auto mouseInfo = WIN_MGR->GetMouseInfo();
426 pointerItem.SetDisplayX(mouseInfo.physicalX);
427 pointerItem.SetDisplayY(mouseInfo.physicalY);
428 pointerItem.SetToolType(PointerEvent::TOOL_TYPE_TOUCHPAD);
429 pointerEvent_->UpdatePointerItem(DEFAULT_POINTER_ID, pointerItem);
430 }
431
ProcessTouchPadPinchDataEvent(int32_t fingerCount,int32_t action,double scale)432 void TouchPadTransformProcessor::ProcessTouchPadPinchDataEvent(int32_t fingerCount, int32_t action, double scale)
433 {
434 pointerEvent_->ClearButtonPressed();
435 std::vector<int32_t> pressedButtons;
436 MouseState->GetPressedButtons(pressedButtons);
437 for (const auto &item : pressedButtons) {
438 pointerEvent_->SetButtonPressed(item);
439 }
440
441 pointerEvent_->SetFingerCount(fingerCount);
442 pointerEvent_->SetDeviceId(deviceId_);
443 auto mouseInfo = WIN_MGR->GetMouseInfo();
444 pointerEvent_->SetTargetDisplayId(mouseInfo.displayId);
445 pointerEvent_->SetTargetWindowId(-1);
446 pointerEvent_->SetPointerId(DEFAULT_POINTER_ID);
447 pointerEvent_->SetPointerAction(action);
448 pointerEvent_->SetAxisValue(PointerEvent::AXIS_TYPE_PINCH, scale);
449
450 if (fingerCount == TP_SYSTEM_PINCH_FINGER_CNT) {
451 pointerEvent_->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
452 pointerEvent_->SetAxisValue(PointerEvent::AXIS_TYPE_PINCH, scale);
453 pointerEvent_->SetAxisEventType(PointerEvent::AXIS_EVENT_TYPE_PINCH);
454 } else {
455 pointerEvent_->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD);
456 pointerEvent_->SetAxisValue(PointerEvent::AXIS_TYPE_PINCH, scale);
457 }
458
459 if (pointerEvent_->GetFingerCount() == TP_SYSTEM_PINCH_FINGER_CNT) {
460 WIN_MGR->UpdateTargetPointer(pointerEvent_);
461 }
462
463 // only three or four finger pinch need to statistic
464 if (action == PointerEvent::POINTER_ACTION_AXIS_BEGIN && fingerCount > TP_SYSTEM_PINCH_FINGER_CNT) {
465 DfxHisysevent::StatisticTouchpadGesture(pointerEvent_);
466 }
467 }
468
OnEventTouchPadPinchBegin(struct libinput_event * event)469 int32_t TouchPadTransformProcessor::OnEventTouchPadPinchBegin(struct libinput_event *event)
470 {
471 CALL_DEBUG_ENTER;
472 return SetTouchPadPinchData(event, PointerEvent::POINTER_ACTION_AXIS_BEGIN);
473 }
474
OnEventTouchPadPinchUpdate(struct libinput_event * event)475 int32_t TouchPadTransformProcessor::OnEventTouchPadPinchUpdate(struct libinput_event *event)
476 {
477 CALL_DEBUG_ENTER;
478 return SetTouchPadPinchData(event, PointerEvent::POINTER_ACTION_AXIS_UPDATE);
479 }
480
OnEventTouchPadPinchEnd(struct libinput_event * event)481 int32_t TouchPadTransformProcessor::OnEventTouchPadPinchEnd(struct libinput_event *event)
482 {
483 CALL_DEBUG_ENTER;
484 return SetTouchPadPinchData(event, PointerEvent::POINTER_ACTION_AXIS_END);
485 }
486
InitToolType()487 void TouchPadTransformProcessor::InitToolType()
488 {
489 vecToolType_.push_back(std::make_pair(BTN_TOOL_PEN, PointerEvent::TOOL_TYPE_PEN));
490 vecToolType_.push_back(std::make_pair(BTN_TOOL_RUBBER, PointerEvent::TOOL_TYPE_RUBBER));
491 vecToolType_.push_back(std::make_pair(BTN_TOOL_BRUSH, PointerEvent::TOOL_TYPE_BRUSH));
492 vecToolType_.push_back(std::make_pair(BTN_TOOL_PENCIL, PointerEvent::TOOL_TYPE_PENCIL));
493 vecToolType_.push_back(std::make_pair(BTN_TOOL_AIRBRUSH, PointerEvent::TOOL_TYPE_AIRBRUSH));
494 vecToolType_.push_back(std::make_pair(BTN_TOOL_FINGER, PointerEvent::TOOL_TYPE_FINGER));
495 vecToolType_.push_back(std::make_pair(BTN_TOOL_MOUSE, PointerEvent::TOOL_TYPE_MOUSE));
496 vecToolType_.push_back(std::make_pair(BTN_TOOL_LENS, PointerEvent::TOOL_TYPE_LENS));
497 }
498
SetTouchpadSwipeSwitch(bool switchFlag)499 int32_t TouchPadTransformProcessor::SetTouchpadSwipeSwitch(bool switchFlag)
500 {
501 std::string name = "touchpadSwipe";
502 if (PutConfigDataToDatabase(name, switchFlag) != RET_OK) {
503 MMI_HILOGE("Failed to set touchpad swpie switch flag to mem");
504 return RET_ERR;
505 }
506
507 DfxHisysevent::ReportTouchpadSettingState(DfxHisysevent::TOUCHPAD_SETTING_CODE::TOUCHPAD_SWIPE_SETTING,
508 switchFlag);
509 return RET_OK;
510 }
511
GetTouchpadSwipeSwitch(bool & switchFlag)512 void TouchPadTransformProcessor::GetTouchpadSwipeSwitch(bool &switchFlag)
513 {
514 std::string name = "touchpadSwipe";
515 GetConfigDataFromDatabase(name, switchFlag);
516 }
517
SetTouchpadPinchSwitch(bool switchFlag)518 int32_t TouchPadTransformProcessor::SetTouchpadPinchSwitch(bool switchFlag)
519 {
520 std::string name = "touchpadPinch";
521 if (PutConfigDataToDatabase(name, switchFlag) != RET_OK) {
522 MMI_HILOGE("Failed to set touchpad pinch switch flag to mem");
523 return RET_ERR;
524 }
525
526 DfxHisysevent::ReportTouchpadSettingState(DfxHisysevent::TOUCHPAD_SETTING_CODE::TOUCHPAD_PINCH_SETTING,
527 switchFlag);
528 return RET_OK;
529 }
530
GetTouchpadPinchSwitch(bool & switchFlag)531 void TouchPadTransformProcessor::GetTouchpadPinchSwitch(bool &switchFlag)
532 {
533 std::string name = "touchpadPinch";
534 GetConfigDataFromDatabase(name, switchFlag);
535 }
536
SetTouchpadRotateSwitch(bool rotateSwitch)537 int32_t TouchPadTransformProcessor::SetTouchpadRotateSwitch(bool rotateSwitch)
538 {
539 std::string name = "touchpadRotate";
540 if (PutConfigDataToDatabase(name, rotateSwitch) != RET_OK) {
541 MMI_HILOGE("PutConfigDataToDatabase failed");
542 return RET_ERR;
543 }
544
545 DfxHisysevent::ReportTouchpadSettingState(DfxHisysevent::TOUCHPAD_SETTING_CODE::TOUCHPAD_ROTATE_SETTING,
546 rotateSwitch);
547 return RET_OK;
548 }
549
GetTouchpadRotateSwitch(bool & rotateSwitch)550 void TouchPadTransformProcessor::GetTouchpadRotateSwitch(bool &rotateSwitch)
551 {
552 std::string name = "touchpadRotate";
553 GetConfigDataFromDatabase(name, rotateSwitch);
554 }
555
PutConfigDataToDatabase(std::string & key,bool value)556 int32_t TouchPadTransformProcessor::PutConfigDataToDatabase(std::string &key, bool value)
557 {
558 return PREFERENCES_MGR->SetBoolValue(key, TOUCHPAD_FILE_NAME, value);
559 }
560
GetConfigDataFromDatabase(std::string & key,bool & value)561 void TouchPadTransformProcessor::GetConfigDataFromDatabase(std::string &key, bool &value)
562 {
563 value = PREFERENCES_MGR->GetBoolValue(key, true);
564 }
565
GetPointerEvent()566 std::shared_ptr<PointerEvent> TouchPadTransformProcessor::GetPointerEvent()
567 {
568 return pointerEvent_;
569 }
570
MultiFingersTapHandler()571 MultiFingersTapHandler::MultiFingersTapHandler() {}
572
~MultiFingersTapHandler()573 MultiFingersTapHandler::~MultiFingersTapHandler() {}
574
HandleMulFingersTap(struct libinput_event_touch * event,int32_t type)575 int32_t MultiFingersTapHandler::HandleMulFingersTap(struct libinput_event_touch *event, int32_t type)
576 {
577 CALL_DEBUG_ENTER;
578 CHKPR(event, RET_ERR);
579 // if is not multifigners tap, return.
580 if (tapTrends_ == TapTrends::NO_MULTAP) {
581 return RET_OK;
582 }
583 // calculator delta time, if is larger than threshold, return.
584 auto time = libinput_event_touchpad_get_time_usec(event);
585 uint64_t deltaTime = 0;
586 if (tapTrends_ != TapTrends::BEGIN) {
587 deltaTime = time - lastTime;
588 } else {
589 beginTime = time;
590 }
591 lastTime = time;
592 if ((deltaTime > perTimeThreshold) || ((lastTime - beginTime) > totalTimeThreshold)) {
593 MMI_HILOGD("Not multitap, single time interval or total time interval is out of range."
594 "single:%{public}" PRId64 ", total:%{public}" PRId64, deltaTime, (lastTime - beginTime));
595 SetMultiFingersTapHdrDefault();
596 return RET_OK;
597 }
598 if (type == LIBINPUT_EVENT_TOUCHPAD_DOWN) {
599 // if trends is up, is not multifigners tap, return.
600 if ((tapTrends_ == TapTrends::UPING) || !CanAddToPointerMaps(event)) {
601 MMI_HILOGD("The trends is up, is not a multifigners tap event");
602 SetMultiFingersTapHdrDefault();
603 return RET_OK;
604 } else {
605 downCnt++;
606 tapTrends_ = TapTrends::DOWNING;
607 }
608 } else if ((type == LIBINPUT_EVENT_TOUCHPAD_UP) && !CanUnsetPointerItem(event)) {
609 upCnt++;
610 tapTrends_ = TapTrends::UPING;
611 }
612 if ((upCnt == downCnt) && (upCnt >= FINGER_TAP_MIN) && (upCnt <= FINGER_COUNT_MAX)) {
613 multiFingersState_ = static_cast<MulFingersTap>(upCnt);
614 MMI_HILOGD("This is multifinger tap event, finger count:%{public}d", upCnt);
615 }
616 return RET_OK;
617 }
618
SetMultiFingersTapHdrDefault(bool isAllDefault)619 void MultiFingersTapHandler::SetMultiFingersTapHdrDefault(bool isAllDefault)
620 {
621 downCnt = 0;
622 upCnt = 0;
623 tapTrends_ = TapTrends::BEGIN;
624 beginTime = 0;
625 lastTime = 0;
626 if (isAllDefault) {
627 multiFingersState_ = MulFingersTap::NO_TAP;
628 }
629 pointerMaps.clear();
630 }
631
ClearPointerItems(std::shared_ptr<PointerEvent> pointer)632 bool MultiFingersTapHandler::ClearPointerItems(std::shared_ptr<PointerEvent> pointer)
633 {
634 CHKPR(pointer, ERROR_NULL_POINTER);
635 auto ids_ = pointer->GetPointerIds();
636 for (const auto &id : ids_) {
637 pointer->RemovePointerItem(id);
638 }
639 return true;
640 }
641
GetMultiFingersState()642 MulFingersTap MultiFingersTapHandler::GetMultiFingersState()
643 {
644 return multiFingersState_;
645 }
646
CanAddToPointerMaps(struct libinput_event_touch * event)647 bool MultiFingersTapHandler::CanAddToPointerMaps(struct libinput_event_touch *event)
648 {
649 CHKPR(event, RET_ERR);
650 int32_t seatSlot = libinput_event_touchpad_get_seat_slot(event);
651 if (pointerMaps.find(seatSlot) != pointerMaps.end()) {
652 return false;
653 }
654 auto currentX = libinput_event_touchpad_get_x(event);
655 auto currentY = libinput_event_touchpad_get_y(event);
656 pointerMaps[seatSlot] = {currentX, currentY};
657 return true;
658 }
659
CanUnsetPointerItem(struct libinput_event_touch * event)660 bool MultiFingersTapHandler::CanUnsetPointerItem(struct libinput_event_touch *event)
661 {
662 CHKPR(event, RET_ERR);
663 int32_t seatSlot = libinput_event_touchpad_get_seat_slot(event);
664 if (pointerMaps.find(seatSlot) != pointerMaps.end()) {
665 return false;
666 } else {
667 pointerMaps[seatSlot] = {-1.0F, -1.0F};
668 return true;
669 }
670 }
671 } // namespace MMI
672 } // namespace OHOS
673