1 /*
2 * Copyright (C) 2023 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 <map>
17 #include "accessibility_screen_touch.h"
18 #include "accessibility_circle_drawing_manager.h"
19 #include "accessible_ability_manager_service.h"
20 #include "hilog_wrapper.h"
21 #include "utils.h"
22
23 namespace OHOS {
24 namespace Accessibility {
25
26 constexpr int32_t POINTER_COUNT_1 = 1;
27
28 constexpr uint32_t CLICK_RESPONSE_DELAY_SHORT = 0;
29 constexpr uint32_t CLICK_RESPONSE_DELAY_MEDIUM = 1;
30 constexpr uint32_t CLICK_RESPONSE_DELAY_LONG = 2;
31
32 constexpr uint32_t CLICK_RESPONSE_TIME_SHORT = 0; // ms
33 constexpr uint32_t CLICK_RESPONSE_TIME_MEDIUM = 300; // ms
34 constexpr uint32_t CLICK_RESPONSE_TIME_LONG = 600; // ms
35
36 constexpr uint32_t IGNORE_REPEAT_CLICK_SHORTEST = 0;
37 constexpr uint32_t IGNORE_REPEAT_CLICK_SHORT = 1;
38 constexpr uint32_t IGNORE_REPEAT_CLICK_MEDIUM = 2;
39 constexpr uint32_t IGNORE_REPEAT_CLICK_LONG = 3;
40 constexpr uint32_t IGNORE_REPEAT_CLICK_LONGEST = 4;
41
42 constexpr uint32_t IGNORE_REPEAT_CLICK_TIME_SHORTEST = 100; // ms
43 constexpr uint32_t IGNORE_REPEAT_CLICK_TIME_SHORT = 400; // ms
44 constexpr uint32_t IGNORE_REPEAT_CLICK_TIME_MEDIUM = 700; // ms
45 constexpr uint32_t IGNORE_REPEAT_CLICK_TIME_LONG = 1000; // ms
46 constexpr uint32_t IGNORE_REPEAT_CLICK_TIME_LONGEST = 1300; // ms
47
48 constexpr uint32_t CIRCLE_ANGLE = 360;
49 #ifdef OHOS_BUILD_ENABLE_DISPLAY_MANAGER
50 constexpr uint32_t START_ANGLE_PORTRAIT = -90;
51 constexpr uint32_t START_ANGLE_LANDSCAPE = 180;
52 constexpr uint32_t START_ANGLE_PORTRAIT_INVERTED = 90;
53 constexpr uint32_t START_ANGLE_LANDSCAPE_INVERTED = 0;
54 #endif
55 constexpr uint32_t NUMBER_10 = 10;
56
57 constexpr float TOUCH_SLOP = 8.0f;
58
59 const std::map<uint32_t, uint32_t> CLICK_RESPONSE_TIME_MAP = {
60 {CLICK_RESPONSE_DELAY_SHORT, CLICK_RESPONSE_TIME_SHORT},
61 {CLICK_RESPONSE_DELAY_MEDIUM, CLICK_RESPONSE_TIME_MEDIUM},
62 {CLICK_RESPONSE_DELAY_LONG, CLICK_RESPONSE_TIME_LONG}
63 };
64
65 const std::map<uint32_t, uint32_t> IGNORE_REPEAT_CLICK_TIME_MAP = {
66 {IGNORE_REPEAT_CLICK_SHORTEST, IGNORE_REPEAT_CLICK_TIME_SHORTEST},
67 {IGNORE_REPEAT_CLICK_SHORT, IGNORE_REPEAT_CLICK_TIME_SHORT},
68 {IGNORE_REPEAT_CLICK_MEDIUM, IGNORE_REPEAT_CLICK_TIME_MEDIUM},
69 {IGNORE_REPEAT_CLICK_LONG, IGNORE_REPEAT_CLICK_TIME_LONG},
70 {IGNORE_REPEAT_CLICK_LONGEST, IGNORE_REPEAT_CLICK_TIME_LONGEST}
71 };
72
73 int64_t AccessibilityScreenTouch::lastUpTime = 0; // global last up time
74
ScreenTouchHandler(const std::shared_ptr<AppExecFwk::EventRunner> & runner,AccessibilityScreenTouch & server)75 ScreenTouchHandler::ScreenTouchHandler(const std::shared_ptr<AppExecFwk::EventRunner> &runner,
76 AccessibilityScreenTouch &server) : AppExecFwk::EventHandler(runner), server_(server)
77 {
78 }
79
AccessibilityScreenTouch()80 AccessibilityScreenTouch::AccessibilityScreenTouch()
81 {
82 HILOG_DEBUG();
83 // get from account data directly
84 sptr<AccessibilityAccountData> accountData =
85 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
86 clickResponseTime_ = accountData->GetConfig()->GetClickResponseTime();
87 ignoreRepeatClickState_ = accountData->GetConfig()->GetIgnoreRepeatClickState();
88 ignoreRepeatClickTime_ = accountData->GetConfig()->GetIgnoreRepeatClickTime();
89
90 if (clickResponseTime_ > 0 && ignoreRepeatClickState_ == true) {
91 currentState_ = BOTH_RESPONSE_DELAY_IGNORE_REPEAT_CLICK;
92 } else if (clickResponseTime_ > 0) {
93 currentState_ = CLICK_RESPONSE_DELAY_STATE;
94 } else if (ignoreRepeatClickState_ == true) {
95 currentState_ = IGNORE_REPEAT_CLICK_STATE;
96 } else {
97 currentState_ = DEFAULT_STATE;
98 }
99
100 lastUpTime_ = lastUpTime;
101
102 runner_ = Singleton<AccessibleAbilityManagerService>::GetInstance().GetMainRunner();
103 if (!runner_) {
104 HILOG_ERROR("get runner failed");
105 return;
106 }
107 handler_ = std::make_shared<ScreenTouchHandler>(runner_, *this);
108 if (!handler_) {
109 HILOG_ERROR("create event handler failed");
110 return;
111 }
112 }
113
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)114 void ScreenTouchHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
115 {
116 HILOG_DEBUG();
117 switch (event->GetInnerEventId()) {
118 case AccessibilityScreenTouch::FINGER_DOWN_DELAY_MSG:
119 server_.SendInterceptedEvent();
120 break;
121 default:
122 break;
123 }
124 }
125
~AccessibilityScreenTouch()126 AccessibilityScreenTouch::~AccessibilityScreenTouch()
127 {
128 lastUpTime = lastUpTime_;
129 if (drawCircleThread_ && drawCircleThread_->joinable()) {
130 drawCircleThread_->join();
131 }
132 drawCircleThread_ = nullptr;
133 AccessibilityCircleDrawingManager::DeleteInstance();
134 }
135
SendInterceptedEvent()136 void AccessibilityScreenTouch::SendInterceptedEvent()
137 {
138 HILOG_DEBUG();
139 isStopDrawCircle_ = true;
140
141 if (cachedDownPointerEvents_.empty()) {
142 HILOG_ERROR("Cached down pointer event is empty!");
143 return;
144 }
145
146 for (auto iter = cachedDownPointerEvents_.begin(); iter != cachedDownPointerEvents_.end(); ++iter) {
147 iter->SetActionTime(Utils::GetSystemTime() * US_TO_MS);
148 EventTransmission::OnPointerEvent(*iter);
149 }
150 }
151
GetRealClickResponseTime()152 uint32_t AccessibilityScreenTouch::GetRealClickResponseTime()
153 {
154 auto iter = CLICK_RESPONSE_TIME_MAP.find(clickResponseTime_);
155 if (iter != CLICK_RESPONSE_TIME_MAP.end()) {
156 return iter->second;
157 }
158
159 return CLICK_RESPONSE_TIME_MAP.at(CLICK_RESPONSE_DELAY_SHORT);
160 }
161
GetRealIgnoreRepeatClickTime()162 uint32_t AccessibilityScreenTouch::GetRealIgnoreRepeatClickTime()
163 {
164 auto iter = IGNORE_REPEAT_CLICK_TIME_MAP.find(ignoreRepeatClickTime_);
165 if (iter != IGNORE_REPEAT_CLICK_TIME_MAP.end()) {
166 return iter->second;
167 }
168
169 return IGNORE_REPEAT_CLICK_TIME_MAP.at(IGNORE_REPEAT_CLICK_SHORTEST);
170 }
171
GetRealIgnoreRepeatClickState()172 bool AccessibilityScreenTouch::GetRealIgnoreRepeatClickState()
173 {
174 return ignoreRepeatClickState_;
175 }
176
ConversionCoordinates(MMI::PointerEvent::PointerItem & pointerItem)177 void AccessibilityScreenTouch::ConversionCoordinates(MMI::PointerEvent::PointerItem &pointerItem)
178 {
179 #ifdef OHOS_BUILD_ENABLE_DISPLAY_MANAGER
180 AccessibilityDisplayManager &displayMgr = Singleton<AccessibilityDisplayManager>::GetInstance();
181 int32_t displayWidth = displayMgr.GetWidth();
182 int32_t displayHeight = displayMgr.GetHeight();
183 int32_t originalX = pointerItem.GetDisplayX();
184 int32_t originalY = pointerItem.GetDisplayY();
185
186 OHOS::Rosen::DisplayOrientation orientation = displayMgr.GetOrientation();
187 switch (orientation) {
188 case OHOS::Rosen::DisplayOrientation::PORTRAIT:
189 circleCenterPhysicalX_ = originalX;
190 circleCenterPhysicalY_ = originalY;
191 startAngle_ = START_ANGLE_PORTRAIT;
192 break;
193 case OHOS::Rosen::DisplayOrientation::LANDSCAPE:
194 circleCenterPhysicalX_ = originalY;
195 circleCenterPhysicalY_ = displayWidth - originalX;
196 startAngle_ = START_ANGLE_LANDSCAPE;
197 break;
198 case OHOS::Rosen::DisplayOrientation::PORTRAIT_INVERTED:
199 circleCenterPhysicalX_ = displayWidth - originalX;
200 circleCenterPhysicalY_ = displayHeight - originalY;
201 startAngle_ = START_ANGLE_PORTRAIT_INVERTED;
202 break;
203 case OHOS::Rosen::DisplayOrientation::LANDSCAPE_INVERTED:
204 circleCenterPhysicalX_ = displayHeight - originalY;
205 circleCenterPhysicalY_ = originalX;
206 startAngle_ = START_ANGLE_LANDSCAPE_INVERTED;
207 break;
208 default:
209 break;
210 }
211 #endif
212 }
213
DrawCircleProgress()214 void AccessibilityScreenTouch::DrawCircleProgress()
215 {
216 HILOG_DEBUG();
217
218 AccessibilityCircleDrawingManager::GetInstance()->DrawPointer(circleCenterPhysicalX_,
219 circleCenterPhysicalY_, 0, screenId_, startAngle_);
220 AccessibilityCircleDrawingManager::GetInstance()->UpdatePointerVisible(true);
221 uint32_t times = GetRealClickResponseTime() / NUMBER_10;
222 uint32_t step = CIRCLE_ANGLE / times;
223 uint32_t time = 0;
224 while (time < times && isStopDrawCircle_ == false) {
225 AccessibilityCircleDrawingManager::GetInstance()->DrawPointer(circleCenterPhysicalX_,
226 circleCenterPhysicalY_, step * time, screenId_, startAngle_);
227 time++;
228 std::this_thread::yield();
229 std::this_thread::sleep_for(std::chrono::milliseconds(NUMBER_10));
230 }
231
232 AccessibilityCircleDrawingManager::GetInstance()->UpdatePointerVisible(false);
233 }
234
HandleResponseDelayStateInnerDown(MMI::PointerEvent & event)235 void AccessibilityScreenTouch::HandleResponseDelayStateInnerDown(MMI::PointerEvent &event)
236 {
237 HILOG_DEBUG();
238 MMI::PointerEvent::PointerItem pointerItem;
239 if (!event.GetPointerItem(event.GetPointerId(), pointerItem)) {
240 HILOG_WARN("get GetPointerItem %{public}d failed", event.GetPointerId());
241 }
242
243 if (event.GetPointerIds().size() > POINTER_COUNT_1) {
244 if (cachedDownPointerEvents_.empty()) {
245 HILOG_ERROR("cached down pointer event is empty!");
246 return;
247 }
248 if (isMoveBeyondThreshold_ == true) {
249 cachedDownPointerEvents_.push_back(event);
250 EventTransmission::OnPointerEvent(event);
251 return;
252 } else if (isStopDrawCircle_ == true) {
253 return;
254 } else {
255 cachedDownPointerEvents_.push_back(event);
256 return;
257 }
258 }
259
260 screenId_ = event.GetTargetDisplayId();
261 startTime_ = event.GetActionTime();
262 startPointer_ = std::make_shared<MMI::PointerEvent::PointerItem>(pointerItem);
263 isMoveBeyondThreshold_ = false;
264
265 ConversionCoordinates(pointerItem);
266 isStopDrawCircle_ = false;
267 if (drawCircleThread_ && drawCircleThread_->joinable()) {
268 drawCircleThread_->join();
269 }
270
271 drawCircleThread_ = nullptr;
272 drawCircleThread_ = std::make_shared<std::thread>([this] {this->DrawCircleProgress();});
273 if (drawCircleThread_ == nullptr) {
274 HILOG_ERROR("create draw circle progress fail");
275 }
276
277 handler_->RemoveEvent(FINGER_DOWN_DELAY_MSG);
278 cachedDownPointerEvents_.clear();
279 cachedDownPointerEvents_.push_back(event);
280 handler_->SendEvent(FINGER_DOWN_DELAY_MSG, 0, static_cast<int32_t>(GetRealClickResponseTime()));
281 }
282
HandleResponseDelayStateInnerMove(MMI::PointerEvent & event)283 void AccessibilityScreenTouch::HandleResponseDelayStateInnerMove(MMI::PointerEvent &event)
284 {
285 HILOG_DEBUG();
286 if (cachedDownPointerEvents_.empty()) {
287 HILOG_ERROR("cached down pointer event is empty!");
288 return;
289 }
290
291 if (isMoveBeyondThreshold_ == true) {
292 handler_->RemoveEvent(FINGER_DOWN_DELAY_MSG);
293 EventTransmission::OnPointerEvent(event);
294 return;
295 }
296
297 if (startPointer_ == nullptr) {
298 return;
299 }
300
301 if (event.GetPointerId() != startPointer_->GetPointerId()) {
302 if (isStopDrawCircle_ == true) {
303 EventTransmission::OnPointerEvent(event);
304 }
305 return;
306 }
307
308 MMI::PointerEvent::PointerItem pointerItem;
309 if (!event.GetPointerItem(event.GetPointerId(), pointerItem)) {
310 HILOG_WARN("get GetPointerItem %{public}d failed", event.GetPointerId());
311 }
312
313 float offsetX = startPointer_->GetDisplayX() - pointerItem.GetDisplayX();
314 float offsetY = startPointer_->GetDisplayY() - pointerItem.GetDisplayY();
315 double duration = hypot(offsetX, offsetY);
316 if (duration > TOUCH_SLOP) {
317 handler_->RemoveEvent(FINGER_DOWN_DELAY_MSG);
318 if (isStopDrawCircle_ != true && !cachedDownPointerEvents_.empty()) {
319 for (auto iter = cachedDownPointerEvents_.begin(); iter != cachedDownPointerEvents_.end(); ++iter) {
320 iter->SetActionTime(Utils::GetSystemTime() * US_TO_MS);
321 EventTransmission::OnPointerEvent(*iter);
322 }
323 }
324 EventTransmission::OnPointerEvent(event);
325 isMoveBeyondThreshold_ = true;
326 isStopDrawCircle_ = true;
327 return;
328 }
329
330 if (isStopDrawCircle_ != true) {
331 ConversionCoordinates(pointerItem);
332 return;
333 }
334
335 EventTransmission::OnPointerEvent(event);
336 }
337
HandleResponseDelayStateInnerUp(MMI::PointerEvent & event)338 void AccessibilityScreenTouch::HandleResponseDelayStateInnerUp(MMI::PointerEvent &event)
339 {
340 HILOG_DEBUG();
341
342 if (cachedDownPointerEvents_.empty()) {
343 HILOG_ERROR("cached down pointer event is empty!");
344 handler_->RemoveEvent(FINGER_DOWN_DELAY_MSG);
345 isStopDrawCircle_ = true;
346 return;
347 }
348
349 if (isStopDrawCircle_ == true) {
350 for (auto iter = cachedDownPointerEvents_.begin(); iter != cachedDownPointerEvents_.end(); ++iter) {
351 if (iter->GetPointerId() == event.GetPointerId()) {
352 EventTransmission::OnPointerEvent(event);
353 }
354 }
355 if (event.GetPointerIds().size() == POINTER_COUNT_1) {
356 cachedDownPointerEvents_.clear();
357 }
358 return;
359 }
360
361 if (startPointer_ != nullptr && event.GetPointerId() == startPointer_->GetPointerId()) {
362 handler_->RemoveEvent(FINGER_DOWN_DELAY_MSG);
363 isStopDrawCircle_ = true;
364 cachedDownPointerEvents_.clear();
365 } else {
366 auto iter = std::find_if(cachedDownPointerEvents_.begin(), cachedDownPointerEvents_.end(),
367 [&](const MMI::PointerEvent &e) {
368 return e.GetPointerId() == event.GetPointerId();
369 });
370 if (iter != cachedDownPointerEvents_.end()) {
371 cachedDownPointerEvents_.erase(iter);
372 }
373 }
374 }
375
HandleResponseDelayState(MMI::PointerEvent & event)376 void AccessibilityScreenTouch::HandleResponseDelayState(MMI::PointerEvent &event)
377 {
378 HILOG_DEBUG();
379
380 switch (event.GetPointerAction()) {
381 case MMI::PointerEvent::POINTER_ACTION_DOWN:
382 HandleResponseDelayStateInnerDown(event);
383 break;
384 case MMI::PointerEvent::POINTER_ACTION_MOVE:
385 HandleResponseDelayStateInnerMove(event);
386 break;
387 case MMI::PointerEvent::POINTER_ACTION_UP:
388 HandleResponseDelayStateInnerUp(event);
389 break;
390 default:
391 EventTransmission::OnPointerEvent(event);
392 break;
393 }
394 }
395
HandleIgnoreRepeatClickStateInnerDown(MMI::PointerEvent & event)396 void AccessibilityScreenTouch::HandleIgnoreRepeatClickStateInnerDown(MMI::PointerEvent &event)
397 {
398 HILOG_DEBUG();
399
400 int64_t downTime = event.GetActionTime();
401 if ((event.GetPointerIds().size() == POINTER_COUNT_1) &&
402 ((downTime - lastUpTime_) / US_TO_MS < GetRealIgnoreRepeatClickTime())) {
403 isInterceptClick_ = true;
404 return;
405 } else if ((event.GetPointerIds().size() > POINTER_COUNT_1) && (isInterceptClick_ == true)) {
406 return;
407 }
408
409 EventTransmission::OnPointerEvent(event);
410 isInterceptClick_ = false;
411 }
412
HandleIgnoreRepeatClickStateInnerMove(MMI::PointerEvent & event)413 void AccessibilityScreenTouch::HandleIgnoreRepeatClickStateInnerMove(MMI::PointerEvent &event)
414 {
415 HILOG_DEBUG();
416
417 if (isInterceptClick_ == false) {
418 EventTransmission::OnPointerEvent(event);
419 }
420 }
421
HandleIgnoreRepeatClickStateInnerUp(MMI::PointerEvent & event)422 void AccessibilityScreenTouch::HandleIgnoreRepeatClickStateInnerUp(MMI::PointerEvent &event)
423 {
424 HILOG_DEBUG();
425
426 if (isInterceptClick_ == false) {
427 EventTransmission::OnPointerEvent(event);
428 if (event.GetPointerIds().size() == POINTER_COUNT_1) {
429 lastUpTime_ = event.GetActionTime();
430 }
431 }
432 }
433
HandleIgnoreRepeatClickState(MMI::PointerEvent & event)434 void AccessibilityScreenTouch::HandleIgnoreRepeatClickState(MMI::PointerEvent &event)
435 {
436 HILOG_DEBUG();
437 switch (event.GetPointerAction()) {
438 case MMI::PointerEvent::POINTER_ACTION_DOWN:
439 HandleIgnoreRepeatClickStateInnerDown(event);
440 break;
441 case MMI::PointerEvent::POINTER_ACTION_MOVE:
442 HandleIgnoreRepeatClickStateInnerMove(event);
443 break;
444 case MMI::PointerEvent::POINTER_ACTION_UP:
445 HandleIgnoreRepeatClickStateInnerUp(event);
446 break;
447 default:
448 EventTransmission::OnPointerEvent(event);
449 break;
450 }
451 }
452
HandleBothStateInnerDown(MMI::PointerEvent & event)453 void AccessibilityScreenTouch::HandleBothStateInnerDown(MMI::PointerEvent &event)
454 {
455 HILOG_DEBUG();
456
457 int64_t downTime = event.GetActionTime();
458 if ((event.GetPointerIds().size() == POINTER_COUNT_1) &&
459 ((downTime - lastUpTime_) / US_TO_MS < GetRealIgnoreRepeatClickTime())) {
460 isInterceptClick_ = true;
461 return;
462 } else if ((event.GetPointerIds().size() > POINTER_COUNT_1) && (isInterceptClick_ == true)) {
463 return;
464 }
465
466 isInterceptClick_ = false;
467
468 HandleResponseDelayStateInnerDown(event);
469 }
470
HandleBothStateInnerMove(MMI::PointerEvent & event)471 void AccessibilityScreenTouch::HandleBothStateInnerMove(MMI::PointerEvent &event)
472 {
473 HILOG_DEBUG();
474
475 if (isInterceptClick_ == true) {
476 return;
477 }
478
479 HandleResponseDelayStateInnerMove(event);
480 }
481
HandleBothStateInnerUp(MMI::PointerEvent & event)482 void AccessibilityScreenTouch::HandleBothStateInnerUp(MMI::PointerEvent &event)
483 {
484 HILOG_DEBUG();
485
486 if (isInterceptClick_ == true) {
487 return;
488 }
489
490 if (event.GetPointerIds().size() == POINTER_COUNT_1) {
491 lastUpTime_ = event.GetActionTime();
492 }
493
494 HandleResponseDelayStateInnerUp(event);
495 }
496
HandleBothState(MMI::PointerEvent & event)497 void AccessibilityScreenTouch::HandleBothState(MMI::PointerEvent &event)
498 {
499 HILOG_DEBUG();
500 switch (event.GetPointerAction()) {
501 case MMI::PointerEvent::POINTER_ACTION_DOWN:
502 HandleBothStateInnerDown(event);
503 break;
504 case MMI::PointerEvent::POINTER_ACTION_MOVE:
505 HandleBothStateInnerMove(event);
506 break;
507 case MMI::PointerEvent::POINTER_ACTION_UP:
508 HandleBothStateInnerUp(event);
509 break;
510 default:
511 EventTransmission::OnPointerEvent(event);
512 break;
513 }
514 }
515
Clear()516 void AccessibilityScreenTouch::Clear()
517 {
518 isMoveBeyondThreshold_ = false;
519 isInterceptClick_ = false;
520 startPointer_ = nullptr;
521 }
522
OnPointerEvent(MMI::PointerEvent & event)523 bool AccessibilityScreenTouch::OnPointerEvent(MMI::PointerEvent &event)
524 {
525 HILOG_DEBUG();
526 MMI::PointerEvent::PointerItem pointerItem;
527 if (!event.GetPointerItem(event.GetPointerId(), pointerItem)) {
528 HILOG_WARN("get GetPointerItem %{public}d failed", event.GetPointerId());
529 return false;
530 }
531 if (pointerItem.GetToolType() == MMI::PointerEvent::TOOL_TYPE_KNUCKLE) {
532 EventTransmission::OnPointerEvent(event);
533 return false;
534 }
535
536 if (event.GetSourceType() != MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
537 EventTransmission::OnPointerEvent(event);
538 return false;
539 }
540
541 if (event.GetPointerAction() == MMI::PointerEvent::POINTER_ACTION_CANCEL) {
542 Clear();
543 return true;
544 }
545
546 switch (currentState_) {
547 case ScreenTouchState::CLICK_RESPONSE_DELAY_STATE:
548 HandleResponseDelayState(event);
549 break;
550 case ScreenTouchState::IGNORE_REPEAT_CLICK_STATE:
551 HandleIgnoreRepeatClickState(event);
552 break;
553 case ScreenTouchState::BOTH_RESPONSE_DELAY_IGNORE_REPEAT_CLICK:
554 HandleBothState(event);
555 break;
556 case ScreenTouchState::DEFAULT_STATE:
557 default:
558 EventTransmission::OnPointerEvent(event);
559 }
560
561 return true;
562 }
563 } // namespace Accessibility
564 } // namespace OHOS