1 /*
2 * Copyright (c) 2021-2024 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 "pointer_event.h"
17
18 #include "mmi_log.h"
19
20 #undef MMI_LOG_TAG
21 #define MMI_LOG_TAG "PointerEvent"
22
23 using namespace OHOS::HiviewDFX;
24 namespace OHOS {
25 namespace MMI {
26 namespace {
27 constexpr double MAX_PRESSURE { 1.0 };
28 constexpr size_t MAX_N_PRESSED_BUTTONS { 10 };
29 constexpr size_t MAX_N_POINTER_ITEMS { 10 };
30 constexpr int32_t SIMULATE_EVENT_START_ID { 10000 };
31 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
32 constexpr size_t MAX_N_ENHANCE_DATA_SIZE { 64 };
33 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
34 constexpr size_t MAX_N_BUFFER_SIZE { 512 };
35 constexpr size_t MAX_N_PRESSED_KEYS { 10 };
36 } // namespace
37
from(std::shared_ptr<InputEvent> inputEvent)38 std::shared_ptr<PointerEvent> PointerEvent::from(std::shared_ptr<InputEvent> inputEvent)
39 {
40 return nullptr;
41 }
42
PointerItem()43 PointerEvent::PointerItem::PointerItem() {}
44
~PointerItem()45 PointerEvent::PointerItem::~PointerItem() {}
46
GetPointerId() const47 int32_t PointerEvent::PointerItem::GetPointerId() const
48 {
49 return pointerId_;
50 }
51
SetPointerId(int32_t pointerId)52 void PointerEvent::PointerItem::SetPointerId(int32_t pointerId)
53 {
54 pointerId_ = pointerId;
55 }
56
GetDownTime() const57 int64_t PointerEvent::PointerItem::GetDownTime() const
58 {
59 return downTime_;
60 }
61
SetDownTime(int64_t downTime)62 void PointerEvent::PointerItem::SetDownTime(int64_t downTime)
63 {
64 downTime_ = downTime;
65 }
66
IsPressed() const67 bool PointerEvent::PointerItem::IsPressed() const
68 {
69 return pressed_;
70 }
71
SetPressed(bool pressed)72 void PointerEvent::PointerItem::SetPressed(bool pressed)
73 {
74 pressed_ = pressed;
75 }
76
GetDisplayX() const77 int32_t PointerEvent::PointerItem::GetDisplayX() const
78 {
79 return displayX_;
80 }
81
SetDisplayX(int32_t x)82 void PointerEvent::PointerItem::SetDisplayX(int32_t x)
83 {
84 displayX_ = x;
85 }
86
GetDisplayY() const87 int32_t PointerEvent::PointerItem::GetDisplayY() const
88 {
89 return displayY_;
90 }
91
SetDisplayY(int32_t y)92 void PointerEvent::PointerItem::SetDisplayY(int32_t y)
93 {
94 displayY_ = y;
95 }
96
GetWindowX() const97 int32_t PointerEvent::PointerItem::GetWindowX() const
98 {
99 return windowX_;
100 }
101
SetWindowX(int32_t x)102 void PointerEvent::PointerItem::SetWindowX(int32_t x)
103 {
104 windowX_ = x;
105 }
106
GetWindowY() const107 int32_t PointerEvent::PointerItem::GetWindowY() const
108 {
109 return windowY_;
110 }
111
SetWindowY(int32_t y)112 void PointerEvent::PointerItem::SetWindowY(int32_t y)
113 {
114 windowY_ = y;
115 }
116
GetDisplayXPos() const117 double PointerEvent::PointerItem::GetDisplayXPos() const
118 {
119 return displayXPos_;
120 }
121
SetDisplayXPos(double x)122 void PointerEvent::PointerItem::SetDisplayXPos(double x)
123 {
124 displayXPos_ = x;
125 }
126
GetDisplayYPos() const127 double PointerEvent::PointerItem::GetDisplayYPos() const
128 {
129 return displayYPos_;
130 }
131
SetDisplayYPos(double y)132 void PointerEvent::PointerItem::SetDisplayYPos(double y)
133 {
134 displayYPos_ = y;
135 }
136
GetWindowXPos() const137 double PointerEvent::PointerItem::GetWindowXPos() const
138 {
139 return windowXPos_;
140 }
141
SetWindowXPos(double x)142 void PointerEvent::PointerItem::SetWindowXPos(double x)
143 {
144 windowXPos_ = x;
145 }
146
GetWindowYPos() const147 double PointerEvent::PointerItem::GetWindowYPos() const
148 {
149 return windowYPos_;
150 }
151
SetWindowYPos(double y)152 void PointerEvent::PointerItem::SetWindowYPos(double y)
153 {
154 windowYPos_ = y;
155 }
156
GetFixedDisplayX() const157 int32_t PointerEvent::PointerItem::GetFixedDisplayX() const
158 {
159 return fixedDisplayX_;
160 }
161
SetFixedDisplayX(int32_t fixedDisplayX)162 void PointerEvent::PointerItem::SetFixedDisplayX(int32_t fixedDisplayX)
163 {
164 fixedDisplayX_ = fixedDisplayX;
165 }
166
GetFixedDisplayY() const167 int32_t PointerEvent::PointerItem::GetFixedDisplayY() const
168 {
169 return fixedDisplayY_;
170 }
171
SetFixedDisplayY(int32_t fixedDisplayY)172 void PointerEvent::PointerItem::SetFixedDisplayY(int32_t fixedDisplayY)
173 {
174 fixedDisplayY_ = fixedDisplayY;
175 }
176
GetWidth() const177 int32_t PointerEvent::PointerItem::GetWidth() const
178 {
179 return width_;
180 }
181
SetWidth(int32_t width)182 void PointerEvent::PointerItem::SetWidth(int32_t width)
183 {
184 width_ = width;
185 }
186
GetHeight() const187 int32_t PointerEvent::PointerItem::GetHeight() const
188 {
189 return height_;
190 }
191
SetHeight(int32_t height)192 void PointerEvent::PointerItem::SetHeight(int32_t height)
193 {
194 height_ = height;
195 }
196
GetTiltX() const197 double PointerEvent::PointerItem::GetTiltX() const
198 {
199 return tiltX_;
200 }
201
SetTiltX(double tiltX)202 void PointerEvent::PointerItem::SetTiltX(double tiltX)
203 {
204 tiltX_ = tiltX;
205 }
206
GetTiltY() const207 double PointerEvent::PointerItem::GetTiltY() const
208 {
209 return tiltY_;
210 }
211
SetTiltY(double tiltY)212 void PointerEvent::PointerItem::SetTiltY(double tiltY)
213 {
214 tiltY_ = tiltY;
215 }
216
GetToolDisplayX() const217 int32_t PointerEvent::PointerItem::GetToolDisplayX() const
218 {
219 return toolDisplayX_;
220 }
221
SetToolDisplayX(int32_t x)222 void PointerEvent::PointerItem::SetToolDisplayX(int32_t x)
223 {
224 toolDisplayX_ = x;
225 }
226
GetToolDisplayY() const227 int32_t PointerEvent::PointerItem::GetToolDisplayY() const
228 {
229 return toolDisplayY_;
230 }
231
SetToolDisplayY(int32_t y)232 void PointerEvent::PointerItem::SetToolDisplayY(int32_t y)
233 {
234 toolDisplayY_ = y;
235 }
236
GetToolWindowX() const237 int32_t PointerEvent::PointerItem::GetToolWindowX() const
238 {
239 return toolWindowX_;
240 }
241
SetToolWindowX(int32_t x)242 void PointerEvent::PointerItem::SetToolWindowX(int32_t x)
243 {
244 toolWindowX_ = x;
245 }
246
GetToolWindowY() const247 int32_t PointerEvent::PointerItem::GetToolWindowY() const
248 {
249 return toolWindowY_;
250 }
251
SetToolWindowY(int32_t y)252 void PointerEvent::PointerItem::SetToolWindowY(int32_t y)
253 {
254 toolWindowY_ = y;
255 }
256
GetToolWidth() const257 int32_t PointerEvent::PointerItem::GetToolWidth() const
258 {
259 return toolWidth_;
260 }
261
SetToolWidth(int32_t width)262 void PointerEvent::PointerItem::SetToolWidth(int32_t width)
263 {
264 toolWidth_ = width;
265 }
266
GetToolHeight() const267 int32_t PointerEvent::PointerItem::GetToolHeight() const
268 {
269 return toolHeight_;
270 }
271
SetToolHeight(int32_t height)272 void PointerEvent::PointerItem::SetToolHeight(int32_t height)
273 {
274 toolHeight_ = height;
275 }
276
GetPressure() const277 double PointerEvent::PointerItem::GetPressure() const
278 {
279 return pressure_;
280 }
281
SetPressure(double pressure)282 void PointerEvent::PointerItem::SetPressure(double pressure)
283 {
284 if (pressure < 0.0) {
285 pressure_ = 0.0;
286 } else if (TOOL_TYPE_PEN == GetToolType()) {
287 pressure_ = pressure >= MAX_PRESSURE ? MAX_PRESSURE : pressure;
288 } else {
289 pressure_ = pressure;
290 }
291 }
292
GetMoveFlag() const293 int32_t PointerEvent::PointerItem::GetMoveFlag() const
294 {
295 return moveFlag_;
296 }
297
SetMoveFlag(int32_t moveflag)298 void PointerEvent::PointerItem::SetMoveFlag(int32_t moveflag)
299 {
300 moveFlag_ = moveflag;
301 }
302
303
GetLongAxis() const304 int32_t PointerEvent::PointerItem::GetLongAxis() const
305 {
306 return longAxis_;
307 }
308
SetLongAxis(int32_t longAxis)309 void PointerEvent::PointerItem::SetLongAxis(int32_t longAxis)
310 {
311 longAxis_ = longAxis;
312 }
313
GetShortAxis() const314 int32_t PointerEvent::PointerItem::GetShortAxis() const
315 {
316 return shortAxis_;
317 }
318
SetShortAxis(int32_t shortAxis)319 void PointerEvent::PointerItem::SetShortAxis(int32_t shortAxis)
320 {
321 shortAxis_ = shortAxis;
322 }
323
GetDeviceId() const324 int32_t PointerEvent::PointerItem::GetDeviceId() const
325 {
326 return deviceId_;
327 }
328
SetDeviceId(int32_t deviceId)329 void PointerEvent::PointerItem::SetDeviceId(int32_t deviceId)
330 {
331 deviceId_ = deviceId;
332 }
333
GetToolType() const334 int32_t PointerEvent::PointerItem::GetToolType() const
335 {
336 return toolType_;
337 }
338
SetToolType(int32_t toolType)339 void PointerEvent::PointerItem::SetToolType(int32_t toolType)
340 {
341 toolType_ = toolType;
342 }
343
GetTargetWindowId() const344 int32_t PointerEvent::PointerItem::GetTargetWindowId() const
345 {
346 return targetWindowId_;
347 }
348
SetTargetWindowId(int32_t windowId)349 void PointerEvent::PointerItem::SetTargetWindowId(int32_t windowId)
350 {
351 targetWindowId_ = windowId;
352 }
353
GetRawDx() const354 int32_t PointerEvent::PointerItem::GetRawDx() const
355 {
356 return rawDx_;
357 }
358
SetRawDx(int32_t rawDx)359 void PointerEvent::PointerItem::SetRawDx(int32_t rawDx)
360 {
361 rawDx_ = rawDx;
362 }
363
GetOriginPointerId() const364 int32_t PointerEvent::PointerItem::GetOriginPointerId() const
365 {
366 return originPointerId_;
367 }
368
SetOriginPointerId(int32_t originPointerId)369 void PointerEvent::PointerItem::SetOriginPointerId(int32_t originPointerId)
370 {
371 originPointerId_ = originPointerId;
372 }
373
GetRawDy() const374 int32_t PointerEvent::PointerItem::GetRawDy() const
375 {
376 return rawDy_;
377 }
378
SetRawDy(int32_t rawDy)379 void PointerEvent::PointerItem::SetRawDy(int32_t rawDy)
380 {
381 rawDy_ = rawDy;
382 }
383
GetRawDisplayX() const384 int32_t PointerEvent::PointerItem::GetRawDisplayX() const
385 {
386 return rawDisplayX_;
387 }
388
SetRawDisplayX(int32_t rawDisplayX)389 void PointerEvent::PointerItem::SetRawDisplayX(int32_t rawDisplayX)
390 {
391 rawDisplayX_ = rawDisplayX;
392 }
393
GetRawDisplayY() const394 int32_t PointerEvent::PointerItem::GetRawDisplayY() const
395 {
396 return rawDisplayY_;
397 }
398
SetRawDisplayY(int32_t rawDisplayY)399 void PointerEvent::PointerItem::SetRawDisplayY(int32_t rawDisplayY)
400 {
401 rawDisplayY_ = rawDisplayY;
402 }
403
GetBlobId() const404 int32_t PointerEvent::PointerItem::GetBlobId() const
405 {
406 return blobId_;
407 }
408
SetBlobId(int32_t blobId)409 void PointerEvent::PointerItem::SetBlobId(int32_t blobId)
410 {
411 blobId_ = blobId;
412 }
413
GetAngle() const414 int32_t PointerEvent::PointerItem::GetAngle() const
415 {
416 return angle_;
417 }
418
SetAngle(int32_t angle)419 void PointerEvent::PointerItem::SetAngle(int32_t angle)
420 {
421 angle_ = angle;
422 }
423
IsCanceled() const424 bool PointerEvent::PointerItem::IsCanceled() const
425 {
426 return canceled_;
427 }
428
SetCanceled(bool canceled)429 void PointerEvent::PointerItem::SetCanceled(bool canceled)
430 {
431 canceled_ = canceled;
432 }
433
WriteToParcel(Parcel & out) const434 bool PointerEvent::PointerItem::WriteToParcel(Parcel &out) const
435 {
436 return (
437 out.WriteInt32(pointerId_) &&
438 out.WriteInt64(downTime_) &&
439 out.WriteBool(pressed_) &&
440 out.WriteInt32(displayX_) &&
441 out.WriteInt32(displayY_) &&
442 out.WriteInt32(windowX_) &&
443 out.WriteInt32(windowY_) &&
444 out.WriteInt32(width_) &&
445 out.WriteInt32(height_) &&
446 out.WriteInt32(toolDisplayX_) &&
447 out.WriteInt32(toolDisplayY_) &&
448 out.WriteInt32(toolWindowX_) &&
449 out.WriteInt32(toolWindowY_) &&
450 out.WriteInt32(toolWidth_) &&
451 out.WriteInt32(toolHeight_) &&
452 out.WriteDouble(tiltX_) &&
453 out.WriteDouble(tiltY_) &&
454 out.WriteDouble(pressure_) &&
455 out.WriteInt32(longAxis_) &&
456 out.WriteInt32(shortAxis_) &&
457 out.WriteInt32(toolType_) &&
458 out.WriteInt32(deviceId_) &&
459 out.WriteInt32(rawDx_) &&
460 out.WriteInt32(rawDy_) &&
461 out.WriteInt32(rawDisplayX_) &&
462 out.WriteInt32(rawDisplayY_) &&
463 out.WriteInt32(targetWindowId_) &&
464 out.WriteInt32(originPointerId_) &&
465 out.WriteDouble(displayXPos_) &&
466 out.WriteDouble(displayYPos_) &&
467 out.WriteDouble(windowXPos_) &&
468 out.WriteDouble(windowYPos_) &&
469 out.WriteInt32(blobId_) &&
470 out.WriteInt32(angle_) &&
471 out.WriteInt32(fixedDisplayX_) &&
472 out.WriteInt32(fixedDisplayY_)
473 );
474 }
475
ReadFromParcel(Parcel & in)476 bool PointerEvent::PointerItem::ReadFromParcel(Parcel &in)
477 {
478 return (
479 in.ReadInt32(pointerId_) &&
480 in.ReadInt64(downTime_) &&
481 in.ReadBool(pressed_) &&
482 in.ReadInt32(displayX_) &&
483 in.ReadInt32(displayY_) &&
484 in.ReadInt32(windowX_) &&
485 in.ReadInt32(windowY_) &&
486 in.ReadInt32(width_) &&
487 in.ReadInt32(height_) &&
488 in.ReadInt32(toolDisplayX_) &&
489 in.ReadInt32(toolDisplayY_) &&
490 in.ReadInt32(toolWindowX_) &&
491 in.ReadInt32(toolWindowY_) &&
492 in.ReadInt32(toolWidth_) &&
493 in.ReadInt32(toolHeight_) &&
494 in.ReadDouble(tiltX_) &&
495 in.ReadDouble(tiltY_) &&
496 in.ReadDouble(pressure_) &&
497 in.ReadInt32(longAxis_) &&
498 in.ReadInt32(shortAxis_) &&
499 in.ReadInt32(toolType_) &&
500 in.ReadInt32(deviceId_) &&
501 in.ReadInt32(rawDx_) &&
502 in.ReadInt32(rawDy_) &&
503 in.ReadInt32(rawDisplayX_) &&
504 in.ReadInt32(rawDisplayY_) &&
505 in.ReadInt32(targetWindowId_) &&
506 in.ReadInt32(originPointerId_) &&
507 in.ReadDouble(displayXPos_) &&
508 in.ReadDouble(displayYPos_) &&
509 in.ReadDouble(windowXPos_) &&
510 in.ReadDouble(windowYPos_) &&
511 in.ReadInt32(blobId_) &&
512 in.ReadInt32(angle_) &&
513 in.ReadInt32(fixedDisplayX_) &&
514 in.ReadInt32(fixedDisplayY_)
515 );
516 }
517
PointerEvent(int32_t eventType)518 PointerEvent::PointerEvent(int32_t eventType) : InputEvent(eventType) {}
519
PointerEvent(const PointerEvent & other)520 PointerEvent::PointerEvent(const PointerEvent& other)
521 : InputEvent(other), pointerId_(other.pointerId_), pointers_(other.pointers_),
522 pressedButtons_(other.pressedButtons_),
523 pointerAction_(other.pointerAction_), originPointerAction_(other.originPointerAction_),
524 buttonId_(other.buttonId_), fingerCount_(other.fingerCount_), pullId_(other.pullId_), zOrder_(other.zOrder_),
525 axes_(other.axes_), axisValues_(other.axisValues_), velocity_(other.velocity_),
526 pressedKeys_(other.pressedKeys_), buffer_(other.buffer_), axisEventType_(other.axisEventType_),
527 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
528 fingerprintDistanceX_(other.fingerprintDistanceX_), fingerprintDistanceY_(other.fingerprintDistanceY_),
529 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
530 dispatchTimes_(other.dispatchTimes_),
531 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
532 enhanceData_(other.enhanceData_),
533 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
534 #ifdef OHOS_BUILD_ENABLE_ANCO
535 ancoDeal_(other.ancoDeal_),
536 #endif // OHOS_BUILD_ENABLE_ANCO
537 handleEventType_(other.handleEventType_),
538 settings_(other.settings_),
539 autoToVirtualScreen_(other.autoToVirtualScreen_),
540 handOption_(other.handOption_), fixedMode_(other.fixedMode_) {}
541
~PointerEvent()542 PointerEvent::~PointerEvent() {}
543
Create()544 std::shared_ptr<PointerEvent> PointerEvent::Create()
545 {
546 auto event = std::shared_ptr<PointerEvent>(new (std::nothrow) PointerEvent(InputEvent::EVENT_TYPE_POINTER));
547 CHKPP(event);
548 return event;
549 }
550
Reset()551 void PointerEvent::Reset()
552 {
553 InputEvent::Reset();
554 handOption_ = -1;
555 pointerId_ = -1;
556 pointers_.clear();
557 pressedButtons_.clear();
558 pointerAction_ = POINTER_ACTION_UNKNOWN;
559 originPointerAction_ = POINTER_ACTION_UNKNOWN;
560 buttonId_ = -1;
561 fingerCount_ = 0;
562 zOrder_ = -1.0f;
563 dispatchTimes_ = 0;
564 axes_ = 0U;
565 axisValues_.fill(0.0);
566 velocity_ = 0.0;
567 axisEventType_ = AXIS_EVENT_TYPE_UNKNOWN;
568 pressedKeys_.clear();
569 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
570 fingerprintDistanceX_ = 0.0;
571 fingerprintDistanceY_ = 0.0;
572 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
573 }
574
ToString()575 std::string PointerEvent::ToString()
576 {
577 std::string eventStr = InputEvent::ToString();
578 eventStr += ",pointerId:" + std::to_string(pointerId_);
579 eventStr += ",pointerAction:" + std::to_string(pointerAction_);
580 eventStr += ",buttonId:" + std::to_string(buttonId_);
581 eventStr += ",pointers:[";
582 size_t pointerSize = 0;
583 for (auto it = pointers_.begin(); it != pointers_.end(); it++) {
584 pointerSize++;
585 eventStr += "{displayX:" + std::to_string((*it).GetDisplayX());
586 eventStr += ",displayY:" + std::to_string((*it).GetDisplayY());
587 eventStr += ",windowX:" + std::to_string((*it).GetWindowX());
588 eventStr += ",windowY:" + std::to_string((*it).GetWindowY());
589 eventStr += ",targetWindowId:" + std::to_string((*it).GetTargetWindowId());
590 eventStr += ",longAxis:" + std::to_string((*it).GetLongAxis());
591 eventStr += ",shortAxis:" + std::to_string((*it).GetShortAxis()) + "}";
592 if (pointerSize != pointers_.size()) {
593 eventStr += ",";
594 }
595 }
596 eventStr += "],pressedButtons:[";
597 size_t buttonsSize = 0;
598 for (auto it = pressedButtons_.begin(); it != pressedButtons_.end(); it++) {
599 buttonsSize++;
600 eventStr += std::to_string(*it);
601 if (buttonsSize != pressedButtons_.size()) {
602 eventStr += ",";
603 }
604 }
605 eventStr += "]";
606 return eventStr;
607 }
608
GetPointerAction() const609 int32_t PointerEvent::GetPointerAction() const
610 {
611 return pointerAction_;
612 }
613
SetPointerAction(int32_t pointerAction)614 void PointerEvent::SetPointerAction(int32_t pointerAction)
615 {
616 pointerAction_ = pointerAction;
617 originPointerAction_ = pointerAction;
618 }
619
GetOriginPointerAction() const620 int32_t PointerEvent::GetOriginPointerAction() const
621 {
622 return originPointerAction_;
623 }
624
SetOriginPointerAction(int32_t pointerAction)625 void PointerEvent::SetOriginPointerAction(int32_t pointerAction)
626 {
627 originPointerAction_ = pointerAction;
628 }
629
GetHandOption() const630 int32_t PointerEvent::GetHandOption() const
631 {
632 return handOption_;
633 }
634
SetHandOption(int32_t handOption)635 void PointerEvent::SetHandOption(int32_t handOption)
636 {
637 handOption_ = handOption;
638 }
639
640 static const std::unordered_map<int32_t, std::string> pointerActionMap = {
641 { PointerEvent::POINTER_ACTION_CANCEL, "cancel" },
642 { PointerEvent::POINTER_ACTION_DOWN, "down" },
643 { PointerEvent::POINTER_ACTION_MOVE, "move" },
644 { PointerEvent::POINTER_ACTION_UP, "up" },
645 { PointerEvent::POINTER_ACTION_AXIS_BEGIN, "axis-begin" },
646 { PointerEvent::POINTER_ACTION_AXIS_UPDATE, "axis-update" },
647 { PointerEvent::POINTER_ACTION_AXIS_END, "axis-end" },
648 { PointerEvent::POINTER_ACTION_BUTTON_DOWN, "button-down" },
649 { PointerEvent::POINTER_ACTION_BUTTON_UP, "button-up" },
650 { PointerEvent::POINTER_ACTION_ENTER_WINDOW, "enter-window" },
651 { PointerEvent::POINTER_ACTION_LEAVE_WINDOW, "leave-window" },
652 { PointerEvent::POINTER_ACTION_PULL_DOWN, "pull-down" },
653 { PointerEvent::POINTER_ACTION_PULL_MOVE, "pull-move" },
654 { PointerEvent::POINTER_ACTION_PULL_UP, "pull-up" },
655 { PointerEvent::POINTER_ACTION_PULL_IN_WINDOW, "pull-in-window" },
656 { PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW, "pull-out-window" },
657 { PointerEvent::POINTER_ACTION_SWIPE_BEGIN, "swipe-begin" },
658 { PointerEvent::POINTER_ACTION_SWIPE_UPDATE, "swipe-update" },
659 { PointerEvent::POINTER_ACTION_SWIPE_END, "swipe-end" },
660 { PointerEvent::POINTER_ACTION_ROTATE_BEGIN, "rotate-begin" },
661 { PointerEvent::POINTER_ACTION_ROTATE_UPDATE, "rotate-update" },
662 { PointerEvent::POINTER_ACTION_ROTATE_END, "rotate-end" },
663 { PointerEvent::POINTER_ACTION_TRIPTAP, "touchpad-triptap" },
664 { PointerEvent::POINTER_ACTION_QUADTAP, "quadtap" },
665 { PointerEvent::POINTER_ACTION_HOVER_MOVE, "hover-move" },
666 { PointerEvent::POINTER_ACTION_HOVER_ENTER, "hover-enter" },
667 { PointerEvent::POINTER_ACTION_HOVER_EXIT, "hover-exit" },
668 { PointerEvent::POINTER_ACTION_FINGERPRINT_DOWN, "fingerprint-down" },
669 { PointerEvent::POINTER_ACTION_FINGERPRINT_UP, "fingerprint-up" },
670 { PointerEvent::POINTER_ACTION_FINGERPRINT_SLIDE, "fingerprint-slide" },
671 { PointerEvent::POINTER_ACTION_FINGERPRINT_RETOUCH, "fingerprint-retouch" },
672 { PointerEvent::POINTER_ACTION_FINGERPRINT_CLICK, "fingerprint-click" },
673 { PointerEvent::TOUCH_ACTION_SWIPE_DOWN, "touch-swipe-down" },
674 { PointerEvent::TOUCH_ACTION_SWIPE_UP, "touch-swipe-up" },
675 { PointerEvent::TOUCH_ACTION_SWIPE_LEFT, "touch-swipe-left" },
676 { PointerEvent::TOUCH_ACTION_SWIPE_RIGHT, "touch-swipe-right" },
677 { PointerEvent::TOUCH_ACTION_PINCH_OPENED, "touch-pinch-open" },
678 { PointerEvent::TOUCH_ACTION_PINCH_CLOSEED, "touch-pinch-close" },
679 { PointerEvent::TOUCH_ACTION_GESTURE_END, "touch-gesture-end" },
680 { PointerEvent::POINTER_ACTION_PROXIMITY_IN, "pen-proximity-in" },
681 { PointerEvent::POINTER_ACTION_PROXIMITY_OUT, "pen-proximity-out" },
682 };
683
DumpPointerAction() const684 const char* PointerEvent::DumpPointerAction() const
685 {
686 if (pointerAction_ == PointerEvent::POINTER_ACTION_AXIS_BEGIN) {
687 if (HasAxis(axes_, PointerEvent::AXIS_TYPE_SCROLL_VERTICAL) ||
688 HasAxis(axes_, PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL)) {
689 return "axis-begin";
690 } else if (HasAxis(axes_, PointerEvent::AXIS_TYPE_PINCH)) {
691 return "pinch-begin";
692 }
693 } else if (pointerAction_ == PointerEvent::POINTER_ACTION_AXIS_UPDATE) {
694 if (HasAxis(axes_, PointerEvent::AXIS_TYPE_SCROLL_VERTICAL) ||
695 HasAxis(axes_, PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL)) {
696 return "axis-update";
697 } else if (HasAxis(axes_, PointerEvent::AXIS_TYPE_PINCH)) {
698 return "pinch-update";
699 }
700 } else if (pointerAction_ == PointerEvent::POINTER_ACTION_AXIS_END) {
701 if (HasAxis(axes_, PointerEvent::AXIS_TYPE_SCROLL_VERTICAL) ||
702 HasAxis(axes_, PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL)) {
703 return "axis-end";
704 } else if (HasAxis(axes_, PointerEvent::AXIS_TYPE_PINCH)) {
705 return "pinch-end";
706 }
707 }
708 auto it = pointerActionMap.find(pointerAction_);
709 if (it != pointerActionMap.end()) {
710 return it->second.c_str();
711 }
712 return "unknown";
713 }
714
GetPointerId() const715 int32_t PointerEvent::GetPointerId() const
716 {
717 return pointerId_;
718 }
719
SetPointerId(int32_t pointerId)720 void PointerEvent::SetPointerId(int32_t pointerId)
721 {
722 pointerId_ = pointerId;
723 }
724
GetPointerItem(int32_t pointerId,PointerItem & pointerItem) const725 bool PointerEvent::GetPointerItem(int32_t pointerId, PointerItem &pointerItem) const
726 {
727 for (const auto &item : pointers_) {
728 if (item.GetPointerId() == pointerId) {
729 pointerItem = item;
730 return true;
731 }
732 }
733 return false;
734 }
735
RemovePointerItem(int32_t pointerId)736 void PointerEvent::RemovePointerItem(int32_t pointerId)
737 {
738 for (auto it = pointers_.begin(); it != pointers_.end(); ++it) {
739 if (it->GetPointerId() == pointerId) {
740 pointers_.erase(it);
741 break;
742 }
743 }
744 }
745
RemoveAllPointerItems()746 void PointerEvent::RemoveAllPointerItems()
747 {
748 pointers_.clear();
749 }
750
AddPointerItem(PointerItem & pointerItem)751 void PointerEvent::AddPointerItem(PointerItem &pointerItem)
752 {
753 if (pointers_.size() >= MAX_N_POINTER_ITEMS) {
754 MMI_HILOGE("Exceed maximum allowed number of pointer items");
755 return;
756 }
757 int32_t pointerId = pointerItem.GetPointerId();
758 for (auto &item : pointers_) {
759 if (item.GetPointerId() == pointerId) {
760 item = pointerItem;
761 return;
762 }
763 }
764 pointers_.push_back(pointerItem);
765 }
766
UpdatePointerItem(int32_t pointerId,PointerItem & pointerItem)767 void PointerEvent::UpdatePointerItem(int32_t pointerId, PointerItem &pointerItem)
768 {
769 for (auto &item : pointers_) {
770 if ((item.GetPointerId() % SIMULATE_EVENT_START_ID) == pointerId) {
771 item = pointerItem;
772 return;
773 }
774 }
775 AddPointerItem(pointerItem);
776 }
777
GetPressedButtons() const778 std::set<int32_t> PointerEvent::GetPressedButtons() const
779 {
780 return pressedButtons_;
781 }
782
IsButtonPressed(int32_t buttonId) const783 bool PointerEvent::IsButtonPressed(int32_t buttonId) const
784 {
785 return (pressedButtons_.find(buttonId) != pressedButtons_.end());
786 }
787
SetButtonPressed(int32_t buttonId)788 void PointerEvent::SetButtonPressed(int32_t buttonId)
789 {
790 if (pressedButtons_.size() >= MAX_N_PRESSED_BUTTONS) {
791 MMI_HILOGE("Exceed maximum allowed number of pressed buttons");
792 return;
793 }
794 auto iter = pressedButtons_.insert(buttonId);
795 if (!iter.second) {
796 MMI_HILOGE("Insert value failed, button:%{public}d", buttonId);
797 }
798 }
799
DeleteReleaseButton(int32_t buttonId)800 void PointerEvent::DeleteReleaseButton(int32_t buttonId)
801 {
802 if (pressedButtons_.find(buttonId) != pressedButtons_.end()) {
803 pressedButtons_.erase(buttonId);
804 }
805 }
806
ClearButtonPressed()807 void PointerEvent::ClearButtonPressed()
808 {
809 pressedButtons_.clear();
810 }
811
GetPointerCount() const812 int32_t PointerEvent::GetPointerCount() const
813 {
814 return static_cast<int32_t>(pointers_.size());
815 }
816
GetPointerIds() const817 std::vector<int32_t> PointerEvent::GetPointerIds() const
818 {
819 std::vector<int32_t> pointerIdList;
820 for (const auto &item : pointers_) {
821 pointerIdList.push_back(item.GetPointerId());
822 }
823 return pointerIdList;
824 }
825
GetAllPointerItems() const826 std::list<PointerEvent::PointerItem> PointerEvent::GetAllPointerItems() const
827 {
828 return pointers_;
829 }
830
GetButtonId() const831 int32_t PointerEvent::GetButtonId() const
832 {
833 return buttonId_;
834 }
835
SetButtonId(int32_t buttonId)836 void PointerEvent::SetButtonId(int32_t buttonId)
837 {
838 buttonId_ = buttonId;
839 }
840
GetFingerCount() const841 int32_t PointerEvent::GetFingerCount() const
842 {
843 return fingerCount_;
844 }
845
SetFingerCount(int32_t fingerCount)846 void PointerEvent::SetFingerCount(int32_t fingerCount)
847 {
848 fingerCount_ = fingerCount;
849 }
850
GetZOrder() const851 float PointerEvent::GetZOrder() const
852 {
853 return zOrder_;
854 }
855
SetZOrder(float zOrder)856 void PointerEvent::SetZOrder(float zOrder)
857 {
858 zOrder_ = zOrder;
859 }
860
GetAxisValue(AxisType axis) const861 double PointerEvent::GetAxisValue(AxisType axis) const
862 {
863 double axisValue {};
864 if ((axis >= AXIS_TYPE_UNKNOWN) && (axis < AXIS_TYPE_MAX)) {
865 axisValue = axisValues_[axis];
866 }
867 return axisValue;
868 }
869
SetAxisValue(AxisType axis,double axisValue)870 void PointerEvent::SetAxisValue(AxisType axis, double axisValue)
871 {
872 if ((axis >= AXIS_TYPE_UNKNOWN) && (axis < AXIS_TYPE_MAX)) {
873 axisValues_[axis] = axisValue;
874 axes_ = static_cast<uint32_t>(axes_ | static_cast<uint32_t>(1 << axis));
875 }
876 }
877
ClearAxisValue()878 void PointerEvent::ClearAxisValue()
879 {
880 axisValues_ = {};
881 axes_ = 0;
882 }
883
ClearAxisStatus(AxisType axis)884 void PointerEvent::ClearAxisStatus(AxisType axis)
885 {
886 axes_ &= ~static_cast<uint32_t>(1U << axis);
887 }
888
HasAxis(uint32_t axes,AxisType axis)889 bool PointerEvent::HasAxis(uint32_t axes, AxisType axis)
890 {
891 bool ret { false };
892 if ((axis >= AXIS_TYPE_UNKNOWN) && (axis < AXIS_TYPE_MAX)) {
893 ret = static_cast<bool>(static_cast<uint32_t>(axes) & (1 << static_cast<uint32_t>(axis)));
894 }
895 return ret;
896 }
897
GetVelocity() const898 double PointerEvent::GetVelocity() const
899 {
900 return velocity_;
901 }
902
SetVelocity(double velocity)903 void PointerEvent::SetVelocity(double velocity)
904 {
905 velocity_ = velocity;
906 }
907
SetPressedKeys(const std::vector<int32_t> pressedKeys)908 void PointerEvent::SetPressedKeys(const std::vector<int32_t> pressedKeys)
909 {
910 pressedKeys_ = pressedKeys;
911 }
912
GetPressedKeys() const913 std::vector<int32_t> PointerEvent::GetPressedKeys() const
914 {
915 return pressedKeys_;
916 }
917
GetAxisEventType() const918 int32_t PointerEvent::GetAxisEventType() const
919 {
920 return axisEventType_;
921 }
922
SetAxisEventType(int32_t axisEventType)923 void PointerEvent::SetAxisEventType(int32_t axisEventType)
924 {
925 axisEventType_ = axisEventType;
926 }
927
GetPullId() const928 int32_t PointerEvent::GetPullId() const
929 {
930 return pullId_;
931 }
932
SetPullId(int32_t pullId)933 void PointerEvent::SetPullId(int32_t pullId)
934 {
935 pullId_ = pullId;
936 }
937
938 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
SetEnhanceData(const std::vector<uint8_t> & enhanceData)939 void PointerEvent::SetEnhanceData(const std::vector<uint8_t>& enhanceData)
940 {
941 enhanceData_ = enhanceData;
942 }
943
GetEnhanceData() const944 std::vector<uint8_t> PointerEvent::GetEnhanceData() const
945 {
946 return enhanceData_;
947 }
948 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
949
WriteToParcel(Parcel & out) const950 bool PointerEvent::WriteToParcel(Parcel &out) const
951 {
952 if (!InputEvent::WriteToParcel(out)) {
953 return false;
954 }
955
956 WRITEINT32(out, pointerId_);
957
958 WRITEINT32(out, static_cast<int32_t>(pointers_.size()));
959
960 for (const auto &item : pointers_) {
961 if (!item.WriteToParcel(out)) {
962 return false;
963 }
964 }
965
966 WRITEINT32(out, static_cast<int32_t>(buffer_.size()));
967
968 for (const auto& buff : buffer_) {
969 WRITEUINT8(out, buff);
970 }
971
972 WRITEINT32(out, static_cast<int32_t>(pressedButtons_.size()));
973
974 for (const auto &item : pressedButtons_) {
975 WRITEINT32(out, item);
976 }
977
978 WRITEINT32(out, static_cast<int32_t>(pressedKeys_.size()));
979
980 for (const auto &item : pressedKeys_) {
981 WRITEINT32(out, item);
982 }
983
984 WRITEINT32(out, pointerAction_);
985
986 WRITEINT32(out, originPointerAction_);
987
988 WRITEINT32(out, buttonId_);
989
990 WRITEINT32(out, fingerCount_);
991
992 WRITEFLOAT(out, zOrder_);
993
994 const uint32_t axes { GetAxes() };
995 WRITEUINT32(out, axes);
996
997 for (int32_t i = AXIS_TYPE_UNKNOWN; i < AXIS_TYPE_MAX; ++i) {
998 const AxisType axis { static_cast<AxisType>(i) };
999 if (HasAxis(axes, axis)) {
1000 WRITEDOUBLE(out, GetAxisValue(axis));
1001 }
1002 }
1003 WRITEDOUBLE(out, velocity_);
1004 WRITEINT32(out, axisEventType_);
1005 WRITEINT32(out, pullId_);
1006 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
1007 WRITEINT32(out, static_cast<int32_t>(enhanceData_.size()));
1008 for (uint32_t i = 0; i < enhanceData_.size(); i++) {
1009 WRITEUINT32(out, enhanceData_[i]);
1010 }
1011 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
1012
1013 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
1014 WRITEDOUBLE(out, fingerprintDistanceX_);
1015 WRITEDOUBLE(out, fingerprintDistanceY_);
1016 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
1017 WRITEINT32(out, handOption_);
1018 WRITEINT32(out, static_cast<int32_t>(fixedMode_));
1019 WRITEBOOL(out, autoToVirtualScreen_);
1020 return true;
1021 }
1022
ReadFromParcel(Parcel & in)1023 bool PointerEvent::ReadFromParcel(Parcel &in)
1024 {
1025 if (!InputEvent::ReadFromParcel(in)) {
1026 return false;
1027 }
1028
1029 READINT32(in, pointerId_);
1030
1031 int32_t nPointers;
1032 READINT32(in, nPointers);
1033 if (nPointers > static_cast<int32_t>(MAX_N_POINTER_ITEMS)) {
1034 return false;
1035 }
1036
1037 for (int32_t i = 0; i < nPointers; ++i) {
1038 PointerItem item;
1039 if (!item.ReadFromParcel(in)) {
1040 return false;
1041 }
1042 AddPointerItem(item);
1043 }
1044
1045 if (!ReadBufferFromParcel(in)) {
1046 return false;
1047 }
1048
1049 int32_t nPressedButtons;
1050 READINT32(in, nPressedButtons);
1051 if (nPressedButtons > static_cast<int32_t>(MAX_N_PRESSED_BUTTONS)) {
1052 return false;
1053 }
1054
1055 for (int32_t i = 0; i < nPressedButtons; ++i) {
1056 int32_t buttonId = 0;
1057 READINT32(in, buttonId);
1058 SetButtonPressed(buttonId);
1059 }
1060
1061 int32_t nPressedKeys = 0;
1062 READINT32(in, nPressedKeys);
1063 if (nPressedKeys > static_cast<int32_t>(MAX_N_PRESSED_KEYS)) {
1064 return false;
1065 }
1066
1067 for (int32_t i = 0; i < nPressedKeys; i++) {
1068 int32_t val = 0;
1069 READINT32(in, val);
1070 pressedKeys_.emplace_back(val);
1071 }
1072 READINT32(in, pointerAction_);
1073
1074 READINT32(in, originPointerAction_);
1075
1076 READINT32(in, buttonId_);
1077
1078 READINT32(in, fingerCount_);
1079
1080 READFLOAT(in, zOrder_);
1081
1082 if (!ReadAxisFromParcel(in)) {
1083 return false;
1084 }
1085 READDOUBLE(in, velocity_);
1086
1087 READINT32(in, axisEventType_);
1088 READINT32(in, pullId_);
1089 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
1090 if (!ReadEnhanceDataFromParcel(in)) {
1091 return false;
1092 }
1093 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
1094
1095 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
1096 READDOUBLE(in, fingerprintDistanceX_);
1097 READDOUBLE(in, fingerprintDistanceY_);
1098 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
1099 READINT32(in, handOption_);
1100 if (!ReadFixedModeFromParcel(in)) {
1101 return false;
1102 }
1103 READBOOL(in, autoToVirtualScreen_);
1104 return true;
1105 }
1106
ReadFixedModeFromParcel(Parcel & in)1107 bool PointerEvent::ReadFixedModeFromParcel(Parcel &in)
1108 {
1109 int32_t value = 0;
1110 READINT32(in, value);
1111 if (value < static_cast<int32_t>(FixedMode::SCREEN_MODE_UNKNOWN) ||
1112 value >= static_cast<int32_t>(FixedMode::SCREEN_MODE_MAX)) {
1113 MMI_HILOGE("invalid fixed mode %{public}d", value);
1114 return false;
1115 }
1116 fixedMode_ = static_cast<FixedMode>(value);
1117 return true;
1118 }
1119
ReadAxisFromParcel(Parcel & in)1120 bool PointerEvent::ReadAxisFromParcel(Parcel &in)
1121 {
1122 uint32_t axes = 0;
1123 READUINT32(in, axes);
1124
1125 for (int32_t i = AXIS_TYPE_UNKNOWN; i < AXIS_TYPE_MAX; ++i) {
1126 const AxisType axis { static_cast<AxisType>(i) };
1127 if (HasAxis(axes, axis)) {
1128 double val;
1129 READDOUBLE(in, val);
1130 SetAxisValue(axis, val);
1131 }
1132 }
1133 return true;
1134 }
1135
1136 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
SetFingerprintDistanceX(double x)1137 void PointerEvent::SetFingerprintDistanceX(double x)
1138 {
1139 fingerprintDistanceX_ = x;
1140 }
1141
SetFingerprintDistanceY(double y)1142 void PointerEvent::SetFingerprintDistanceY(double y)
1143 {
1144 fingerprintDistanceY_ = y;
1145 }
1146
GetFingerprintDistanceX() const1147 double PointerEvent::GetFingerprintDistanceX() const
1148 {
1149 return fingerprintDistanceX_;
1150 }
1151
GetFingerprintDistanceY() const1152 double PointerEvent::GetFingerprintDistanceY() const
1153 {
1154 return fingerprintDistanceY_;
1155 }
1156 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
1157
1158 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
ReadEnhanceDataFromParcel(Parcel & in)1159 bool PointerEvent::ReadEnhanceDataFromParcel(Parcel &in)
1160 {
1161 int32_t size = 0;
1162 READINT32(in, size);
1163 if (size > static_cast<int32_t>(MAX_N_ENHANCE_DATA_SIZE) || size < 0) {
1164 MMI_HILOGE("The enhanceData_ size is invalid");
1165 return false;
1166 }
1167
1168 for (int32_t i = 0; i < size; i++) {
1169 uint32_t val = 0;
1170 READUINT32(in, val);
1171 enhanceData_.emplace_back(val);
1172 }
1173 return true;
1174 }
1175 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
1176
ReadBufferFromParcel(Parcel & in)1177 bool PointerEvent::ReadBufferFromParcel(Parcel &in)
1178 {
1179 int32_t bufflen = 0;
1180 READINT32(in, bufflen);
1181 if (bufflen > static_cast<int32_t>(MAX_N_BUFFER_SIZE)) {
1182 return false;
1183 }
1184
1185 for (int32_t i = 0; i < bufflen; ++i) {
1186 uint8_t data;
1187 READUINT8(in, data);
1188 buffer_.push_back(data);
1189 }
1190 return true;
1191 }
1192
IsValidCheckMouseFunc() const1193 bool PointerEvent::IsValidCheckMouseFunc() const
1194 {
1195 CALL_DEBUG_ENTER;
1196 if (pointers_.size() != 1) {
1197 MMI_HILOGE("Pointers_ is invalid");
1198 return false;
1199 }
1200
1201 const size_t maxPressedButtons = 3;
1202 if (pressedButtons_.size() > maxPressedButtons) {
1203 MMI_HILOGE("PressedButtons_.size is greater than three and is invalid");
1204 return false;
1205 }
1206
1207 for (const auto &item : pressedButtons_) {
1208 if (item != MOUSE_BUTTON_LEFT && item != MOUSE_BUTTON_RIGHT && item != MOUSE_BUTTON_MIDDLE) {
1209 MMI_HILOGE("PressedButtons_ is invalid");
1210 return false;
1211 }
1212 }
1213
1214 int32_t pointAction = GetPointerAction();
1215 bool checkFlag = pointAction != POINTER_ACTION_CANCEL && pointAction != POINTER_ACTION_MOVE &&
1216 pointAction != POINTER_ACTION_AXIS_BEGIN && pointAction != POINTER_ACTION_AXIS_UPDATE &&
1217 pointAction != POINTER_ACTION_AXIS_END && pointAction != POINTER_ACTION_BUTTON_DOWN &&
1218 pointAction != POINTER_ACTION_BUTTON_UP;
1219 if (checkFlag) {
1220 MMI_HILOGE("PointAction is invalid");
1221 return false;
1222 }
1223
1224 int32_t buttonId = GetButtonId();
1225 if (pointAction == POINTER_ACTION_BUTTON_DOWN || pointAction == POINTER_ACTION_BUTTON_UP) {
1226 if (buttonId != MOUSE_BUTTON_LEFT && buttonId != MOUSE_BUTTON_RIGHT && buttonId != MOUSE_BUTTON_MIDDLE) {
1227 MMI_HILOGE("ButtonId is invalid");
1228 return false;
1229 }
1230 } else {
1231 if (buttonId != BUTTON_NONE) {
1232 MMI_HILOGE("ButtonId is not BUTTON_NONE and is invalid");
1233 return false;
1234 }
1235 }
1236 return true;
1237 }
1238
IsValidCheckMouse() const1239 bool PointerEvent::IsValidCheckMouse() const
1240 {
1241 CALL_DEBUG_ENTER;
1242 int32_t mousePointID = GetPointerId();
1243 if (mousePointID < 0) {
1244 MMI_HILOGE("MousePointID is invalid");
1245 return false;
1246 }
1247
1248 if (!IsValidCheckMouseFunc()) {
1249 MMI_HILOGE("IsValidCheckMouseFunc is invalid");
1250 return false;
1251 }
1252
1253 for (const auto &item : pointers_) {
1254 if (item.GetPointerId() < 0) {
1255 MMI_HILOGE("Item.pointerid is invalid");
1256 return false;
1257 }
1258
1259 if (item.GetPointerId() != mousePointID) {
1260 MMI_HILOGE("Item.pointerid is not same to mousePointID and is invalid");
1261 return false;
1262 }
1263
1264 if (item.GetDownTime() > 0) {
1265 MMI_HILOGE("Item.downtime is invalid");
1266 return false;
1267 }
1268
1269 if (item.IsPressed() != false) {
1270 MMI_HILOGE("Item.ispressed is not false and is invalid");
1271 return false;
1272 }
1273 }
1274 return true;
1275 }
1276
IsValidCheckTouchFunc() const1277 bool PointerEvent::IsValidCheckTouchFunc() const
1278 {
1279 CALL_DEBUG_ENTER;
1280 if (GetPointerId() < 0) {
1281 MMI_HILOGE("TouchPointID is invalid");
1282 return false;
1283 }
1284
1285 if (!pressedButtons_.empty()) {
1286 MMI_HILOGE("PressedButtons_.size is invalid");
1287 return false;
1288 }
1289
1290 int32_t pointAction = GetPointerAction();
1291 if (pointAction != POINTER_ACTION_CANCEL && pointAction != POINTER_ACTION_MOVE &&
1292 pointAction != POINTER_ACTION_DOWN && pointAction != POINTER_ACTION_UP) {
1293 MMI_HILOGE("PointAction is invalid");
1294 return false;
1295 }
1296
1297 if (GetButtonId() != BUTTON_NONE) {
1298 MMI_HILOGE("ButtonId is invalid");
1299 return false;
1300 }
1301 return true;
1302 }
1303
IsValidCheckTouch() const1304 bool PointerEvent::IsValidCheckTouch() const
1305 {
1306 CALL_DEBUG_ENTER;
1307 if (!IsValidCheckTouchFunc()) {
1308 MMI_HILOGE("IsValidCheckTouchFunc is invalid");
1309 return false;
1310 }
1311 bool isSameItem = false;
1312 int32_t touchPointID = GetPointerId();
1313 for (auto item = pointers_.begin(); item != pointers_.end(); item++) {
1314 if (item->GetPointerId() < 0) {
1315 MMI_HILOGE("Item.pointerid is invalid");
1316 return false;
1317 }
1318
1319 if (item->GetPointerId() == touchPointID) {
1320 isSameItem = true;
1321 }
1322
1323 if (item->GetDownTime() <= 0) {
1324 MMI_HILOGE("Item.downtime is invalid");
1325 return false;
1326 }
1327
1328 if (item->IsPressed() != false) {
1329 MMI_HILOGE("Item.ispressed is not false and is invalid");
1330 return false;
1331 }
1332
1333 auto itemtmp = item;
1334 for (++itemtmp; itemtmp != pointers_.end(); itemtmp++) {
1335 if (item->GetPointerId() == itemtmp->GetPointerId()) {
1336 MMI_HILOGE("Pointitems pointerid exist same items and is invalid");
1337 return false;
1338 }
1339 }
1340 }
1341
1342 if (!isSameItem) {
1343 MMI_HILOGE("Item.pointerid is not same to touchPointID and is invalid");
1344 return false;
1345 }
1346 return true;
1347 }
1348
IsValid() const1349 bool PointerEvent::IsValid() const
1350 {
1351 CALL_DEBUG_ENTER;
1352 switch (GetSourceType()) {
1353 case SOURCE_TYPE_MOUSE: {
1354 if (!IsValidCheckMouse()) {
1355 MMI_HILOGE("IsValidCheckMouse is invalid");
1356 return false;
1357 }
1358 break;
1359 }
1360 case SOURCE_TYPE_TOUCHSCREEN:
1361 case SOURCE_TYPE_TOUCHPAD: {
1362 if (!IsValidCheckTouch()) {
1363 MMI_HILOGE("IsValidCheckTouch is invalid");
1364 return false;
1365 }
1366 break;
1367 }
1368 case SOURCE_TYPE_JOYSTICK:
1369 break;
1370 default: {
1371 MMI_HILOGE("SourceType is invalid");
1372 return false;
1373 }
1374 }
1375 return true;
1376 }
1377
SetBuffer(std::vector<uint8_t> buffer)1378 void PointerEvent::SetBuffer(std::vector<uint8_t> buffer)
1379 {
1380 buffer_ = buffer;
1381 }
1382
ClearBuffer()1383 void PointerEvent::ClearBuffer()
1384 {
1385 buffer_.clear();
1386 }
1387
GetBuffer() const1388 std::vector<uint8_t> PointerEvent::GetBuffer() const
1389 {
1390 return buffer_;
1391 }
1392
GetDispatchTimes() const1393 int32_t PointerEvent::GetDispatchTimes() const
1394 {
1395 return dispatchTimes_;
1396 }
1397
SetDispatchTimes(int32_t dispatchTimes)1398 void PointerEvent::SetDispatchTimes(int32_t dispatchTimes)
1399 {
1400 dispatchTimes_ = dispatchTimes;
1401 }
1402
SetHandlerEventType(HandleEventType eventType)1403 void PointerEvent::SetHandlerEventType(HandleEventType eventType)
1404 {
1405 handleEventType_ = eventType;
1406 }
1407
GetHandlerEventType() const1408 HandleEventType PointerEvent::GetHandlerEventType() const
1409 {
1410 return handleEventType_;
1411 }
1412
1413 #ifdef OHOS_BUILD_ENABLE_ANCO
SetAncoDeal(bool ancoDeal)1414 void PointerEvent::SetAncoDeal(bool ancoDeal)
1415 {
1416 ancoDeal_ = ancoDeal;
1417 }
1418
GetAncoDeal() const1419 bool PointerEvent::GetAncoDeal() const
1420 {
1421 return ancoDeal_;
1422 }
1423 #endif // OHOS_BUILD_ENABLE_ANCO
1424
SetAutoToVirtualScreen(bool autoToVirtualScreen)1425 void PointerEvent::SetAutoToVirtualScreen(bool autoToVirtualScreen)
1426 {
1427 autoToVirtualScreen_ = autoToVirtualScreen;
1428 }
1429
GetAutoToVirtualScreen() const1430 bool PointerEvent::GetAutoToVirtualScreen() const
1431 {
1432 return autoToVirtualScreen_;
1433 }
1434
SetFixedMode(PointerEvent::FixedMode fixedMode)1435 void PointerEvent::SetFixedMode(PointerEvent::FixedMode fixedMode)
1436 {
1437 fixedMode_ = fixedMode;
1438 }
1439
GetFixedMode() const1440 PointerEvent::FixedMode PointerEvent::GetFixedMode() const
1441 {
1442 return fixedMode_;
1443 }
1444
GetFixedModeStr() const1445 std::string PointerEvent::GetFixedModeStr() const
1446 {
1447 switch (fixedMode_) {
1448 case PointerEvent::FixedMode::NORMAL:
1449 return "normal";
1450 case PointerEvent::FixedMode::ONE_HAND:
1451 return "one-hand";
1452 default:
1453 return "unknown";
1454 }
1455 }
1456
ActionToShortStr(int32_t action)1457 std::string_view PointerEvent::ActionToShortStr(int32_t action)
1458 {
1459 // 该函数逻辑简单，功能单一，考虑性能影响，使用switch-case而不是表驱动实现。
1460 switch (action) {
1461 case PointerEvent::POINTER_ACTION_CANCEL:
1462 return "P:C:";
1463 case PointerEvent::POINTER_ACTION_DOWN:
1464 return "P:D:";
1465 case PointerEvent::POINTER_ACTION_MOVE:
1466 return "P:M:";
1467 case PointerEvent::POINTER_ACTION_UP:
1468 return "P:U:";
1469 case PointerEvent::POINTER_ACTION_AXIS_BEGIN:
1470 return "P:AB:";
1471 case PointerEvent::POINTER_ACTION_AXIS_UPDATE:
1472 return "P:AU:";
1473 case PointerEvent::POINTER_ACTION_AXIS_END:
1474 return "P:AE:";
1475 case PointerEvent::POINTER_ACTION_BUTTON_DOWN:
1476 return "P:BD:";
1477 case PointerEvent::POINTER_ACTION_BUTTON_UP:
1478 return "P:BU:";
1479 case PointerEvent::POINTER_ACTION_ENTER_WINDOW:
1480 return "P:EW:";
1481 case PointerEvent::POINTER_ACTION_LEAVE_WINDOW:
1482 return "P:LW:";
1483 case PointerEvent::POINTER_ACTION_PULL_DOWN:
1484 return "P:PD:";
1485 case PointerEvent::POINTER_ACTION_PULL_MOVE:
1486 return "P:PM:";
1487 case PointerEvent::POINTER_ACTION_PULL_UP:
1488 return "P:PU:";
1489 case PointerEvent::POINTER_ACTION_PULL_IN_WINDOW:
1490 return "P:PI:";
1491 case PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW:
1492 return "P:PO:";
1493 case PointerEvent::POINTER_ACTION_SWIPE_BEGIN:
1494 return "P:SB:";
1495 case PointerEvent::POINTER_ACTION_SWIPE_UPDATE:
1496 return "P:SU:";
1497 case PointerEvent::POINTER_ACTION_SWIPE_END:
1498 return "P:SE:";
1499 case PointerEvent::POINTER_ACTION_ROTATE_BEGIN:
1500 return "P:RB:";
1501 case PointerEvent::POINTER_ACTION_ROTATE_UPDATE:
1502 return "P:RU:";
1503 case PointerEvent::POINTER_ACTION_ROTATE_END:
1504 return "P:RE:";
1505 case PointerEvent::POINTER_ACTION_TRIPTAP:
1506 return "P:TT:";
1507 case PointerEvent::POINTER_ACTION_QUADTAP:
1508 return "P:Q:";
1509 case PointerEvent::POINTER_ACTION_HOVER_MOVE:
1510 return "P:HM:";
1511 case PointerEvent::POINTER_ACTION_HOVER_ENTER:
1512 return "P:HE:";
1513 case PointerEvent::POINTER_ACTION_HOVER_EXIT:
1514 return "P:HEX:";
1515 case PointerEvent::POINTER_ACTION_FINGERPRINT_DOWN:
1516 return "P:FD:";
1517 case PointerEvent::POINTER_ACTION_FINGERPRINT_UP:
1518 return "P:FU:";
1519 case PointerEvent::POINTER_ACTION_FINGERPRINT_SLIDE:
1520 return "P:FS:";
1521 case PointerEvent::POINTER_ACTION_FINGERPRINT_RETOUCH:
1522 return "P:FR:";
1523 case PointerEvent::POINTER_ACTION_FINGERPRINT_CLICK:
1524 return "P:FC:";
1525 case PointerEvent::POINTER_ACTION_FINGERPRINT_CANCEL:
1526 return "P:FCA:";
1527 case PointerEvent::POINTER_ACTION_UNKNOWN:
1528 return "P:UK:";
1529 default:
1530 return "P:?:";
1531 }
1532 }
1533
SetScrollRows(int32_t scrollRows)1534 void PointerEvent::SetScrollRows(int32_t scrollRows)
1535 {
1536 settings_.scrollRows_ = scrollRows;
1537 }
1538
GetScrollRows() const1539 int32_t PointerEvent::GetScrollRows() const
1540 {
1541 return settings_.scrollRows_;
1542 }
1543 } // namespace MMI
1544 } // namespace OHOS
1545