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