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