From 7b7f1f460d560a3ca24f4a5ea7b3ff1d0495a74c Mon Sep 17 00:00:00 2001 From: r00447448 Date: Fri, 1 Sep 2023 15:55:41 +0800 Subject: [PATCH] =?UTF-8?q?*=20=E6=97=A0=E9=9A=9C=E7=A2=8D=E7=B3=BB?= =?UTF-8?q?=E7=BB=9F=E5=8F=8C=E6=8C=87=E6=89=8B=E5=8A=BF=E8=AF=86=E5=88=AB?= =?UTF-8?q?=20Signed-off-by:=20ranzhiqiang=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../common/include/accessibility_def.h | 5 + services/aams/BUILD.gn | 1 + .../accessibility_gesture_recognizer.h | 20 +- .../accessibility_multifinger_multitap.h | 247 +++++++ .../aams/include/accessibility_touch_guider.h | 51 ++ .../src/accessibility_gesture_recognizer.cpp | 8 +- .../accessibility_multifinger_multitap.cpp | 482 +++++++++++++ .../aams/src/accessibility_touch_guider.cpp | 152 +++- services/aams/test/BUILD.gn | 3 + .../accessibility_touch_guider_test.cpp | 88 +-- services/test/BUILD.gn | 6 + services/test/mock/mock_display.cpp | 9 +- .../aams_accessibility_touch_guider_test.cpp | 665 +++++++++++++++++- 13 files changed, 1667 insertions(+), 70 deletions(-) create mode 100644 services/aams/include/accessibility_multifinger_multitap.h create mode 100644 services/aams/src/accessibility_multifinger_multitap.cpp diff --git a/interfaces/innerkits/common/include/accessibility_def.h b/interfaces/innerkits/common/include/accessibility_def.h index 9b28282e..ab45dbb2 100644 --- a/interfaces/innerkits/common/include/accessibility_def.h +++ b/interfaces/innerkits/common/include/accessibility_def.h @@ -279,6 +279,11 @@ enum GestureType : uint32_t { GESTURE_TRIPLETAP = 0x0016, GESTURE_SCALE = 0x0017, GESTURE_SCROLL = 0x0018, + GESTURE_TWO_FINGER_SINGLE_TAP = 0x0019, + GESTURE_TWO_FINGER_DOUBLE_TAP = 0x001A, + GESTURE_TWO_FINGER_DOUBLE_TAP_AND_HOLD = 0x001B, + GESTURE_TWO_FINGER_TRIPLE_TAP = 0x001C, + GESTURE_TWO_FINGER_TRIPLE_TAP_AND_HOLD = 0x001D, GESTURE_GESTURE_ALL = 0xFFFFFFFF }; diff --git a/services/aams/BUILD.gn b/services/aams/BUILD.gn index a86bb5e5..9ec61d63 100755 --- a/services/aams/BUILD.gn +++ b/services/aams/BUILD.gn @@ -53,6 +53,7 @@ accessibleabilityms_files = [ "${services_path}/src/accessibility_touchEvent_injector.cpp", "${services_path}/src/accessibility_keyevent_filter.cpp", "${services_path}/src/accessibility_mouse_autoclick.cpp", + "${services_path}/src/accessibility_multifinger_multitap.cpp", "${services_path}/src/accessibility_mouse_key.cpp", "${services_path}/src/accessibility_short_key.cpp", "${services_path}/src/accessibility_window_manager.cpp", diff --git a/services/aams/include/accessibility_gesture_recognizer.h b/services/aams/include/accessibility_gesture_recognizer.h index f4fc721d..7f3d9eb4 100644 --- a/services/aams/include/accessibility_gesture_recognizer.h +++ b/services/aams/include/accessibility_gesture_recognizer.h @@ -35,6 +35,7 @@ const float DOUBLE_TAP_SLOP = 100.0f; const int64_t MIN_DOUBLE_TAP_TIME = 40000; // microsecond const int64_t DOUBLE_TAP_TIMEOUT = 300000; // microsecond const int64_t LONG_PRESS_TIMEOUT = 400000; // microsecond +const int64_t TAP_INTERVAL_TIMEOUT = 100000; // microsecond const float DEGREES_THRESHOLD = 0.0f; const int32_t DIRECTION_NUM = 4; const int64_t US_TO_MS = 1000; @@ -81,6 +82,11 @@ public: */ virtual bool OnStarted(); + /** + * @brief The callback function when recognized an event stream as a two finger gesture. + */ + virtual void TwoFingerGestureOnStarted(); + /** * @brief The callback function when decided the event stream is a gesture. * @param gestureId the recognized gesture ID. @@ -88,12 +94,24 @@ public: */ virtual bool OnCompleted(GestureType gestureId); + /** + * @brief The callback function when decided the event stream is a two finger gesture. + * @param gestureId the recognized gesture ID. + */ + virtual void TwoFingerGestureOnCompleted(GestureType gestureId); + /** * @brief The callback function when decided an event stream doesn't match any known gesture. * @param event the touch event received. * @return true if the event is consumed, else false */ virtual bool OnCancelled(MMI::PointerEvent &event); + + /** + * @brief The callback function when decided an event stream doesn't match any known two finger gesture. + * @param isNoDelayFlag whether the gesture recognize process is immediately canceled. + */ + virtual void TwoFingerGestureOnCancelled(const bool isNoDelayFlag); }; class AccessibilityGestureRecognizer : public AppExecFwk::EventHandler { @@ -232,7 +250,7 @@ private: /** * @brief Cancel the gesture. */ - void StandardGestureCancled(); + void StandardGestureCanceled(); /** * @brief Get pointer path. diff --git a/services/aams/include/accessibility_multifinger_multitap.h b/services/aams/include/accessibility_multifinger_multitap.h new file mode 100644 index 00000000..0b4aeb89 --- /dev/null +++ b/services/aams/include/accessibility_multifinger_multitap.h @@ -0,0 +1,247 @@ +/* + * Copyright (C) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ACCESSIBILITY_MULTIFINGER_MULTITAP_H +#define ACCESSIBILITY_MULTIFINGER_MULTITAP_H + +#include +#include + +#include "accessibility_gesture_recognizer.h" +#include "accessibility_display_manager.h" +#include "accessibility_event_info.h" +#include "accessible_ability_manager_service.h" +#include "event_handler.h" +#include "event_runner.h" +#include "pointer_event.h" +#include "singleton.h" + +namespace OHOS { +namespace Accessibility { + +enum FingerTouchUpState : int32_t { + NOT_ALL_FINGER_TOUCH_UP = 0, + ALL_FINGER_TOUCH_UP = 1, + TOUCH_DOWN_AFTER_ALL_FINGER_TOUCH_UP = 2, +}; + +enum MultiFingerGestureState : int32_t { + GESTURE_NOT_START = 0, + GESTURE_START = 1, + GESTURE_CANCLE = 2, + GESTURE_COMPLETE = 3, + GESTURE_WAIT = 4, +}; + +class AccessibilityMultiTapGestureRecognizer; +class MultiFingerGestureHandler : public AppExecFwk::EventHandler { +public: + MultiFingerGestureHandler(const std::shared_ptr &runner, + AccessibilityMultiTapGestureRecognizer &server); + virtual ~MultiFingerGestureHandler() = default; + /** + * @brief Process the event of install system bundles. + * @param event Indicates the event to be processed. + */ + virtual void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) override; +private: + /** + * @brief Process the two finger gesture event. + * @param event Indicates the event to be processed. + */ + bool ProcessTwoFingerGestureEvent(const AppExecFwk::InnerEvent::Pointer &event); + AccessibilityMultiTapGestureRecognizer &server_; +}; + +class AccessibilityMultiTapGestureRecognizer : public AppExecFwk::EventHandler { +public: + static constexpr uint32_t TWO_FINGER_SINGLE_TAP_MSG = 3; + static constexpr uint32_t TWO_FINGER_LONG_PRESS_MSG = 4; + static constexpr uint32_t TWO_FINGER_DOUBLE_TAP_MSG = 5; + static constexpr uint32_t TWO_FINGER_DOUBLE_TAP_AND_HOLD_MSG = 6; + static constexpr uint32_t TWO_FINGER_TRIPLE_TAP_AND_HOLD_MSG = 7; + static constexpr uint32_t TWO_FINGER_TRIPLE_TAP_MSG = 8; + static constexpr uint32_t WAIT_ANOTHER_FINGER_DOWN_MSG = 9; + static constexpr uint32_t CANCEL_WAIT_FINGER_DOWN_MSG = 10; + static constexpr uint32_t CANCEL_GESTURE = 11; + static constexpr uint32_t COMPLETE_GESTURE = 12; + + AccessibilityMultiTapGestureRecognizer(); + ~AccessibilityMultiTapGestureRecognizer() = default; + + /** + * @brief Register GestureRecognizeListener. + * @param listener the listener from touchguide. + */ + void RegisterListener(AccessibilityGestureRecognizeListener &listener); + + /** + * @brief Get the GestureRecognizeListener. + * @return AccessibilityGestureRecognizeListener ptr. + */ + AccessibilityGestureRecognizeListener *GetRecognizeListener() const + { + return listener_; + } + + /** + * @brief Handle a touch event. If an action is completed, the appropriate callback is called. + * + * @param event the touch event to be handled. + * @return true if the gesture be recognized, else false. + */ + bool OnPointerEvent(MMI::PointerEvent &event); + + /** + * @brief Cancle multi finger gesture rocognize state, buffer etc. + */ + void Clear(); + + /** + * @brief Get the target fingers number touch down in first round. + * @return the finger numbers touch down in first round. + */ + int32_t GetTargetFingers() const + { + return targetFingers_; + } + + /** + * @brief Get finger touch up state. + * @return the touch up state, indicates if fingers is still on the screen. + */ + int32_t GetFingerTouchUpState() const + { + return fingerTouchUpState_; + } + + /** + * @brief Set the finger touch up state when touch up or finish touch down. + * @param touchUpState the touchUpState to be set. + */ + void SetFingerTouchUpState(const int32_t touchUpState) + { + fingerTouchUpState_ = touchUpState; + } + + /** + * @brief Set multi finger gesture state, when gesture recognize start, cancel, complete etc. + * @param gestureState the multiFingerGestureState to be set. + */ + void SetMultiFingerGestureState(const int32_t gestureState) + { + multiFingerGestureState_ = gestureState; + } + + /** + * @brief Determine whether multi finger gesture is started. + * @return true if gesture recognize is started, else false. + */ + bool IsMultiFingerGestureStarted() const + { + return multiFingerGestureState_ == MultiFingerGestureState::GESTURE_START; + } + + /** + * @brief Determine whether multi finger gesture is started or finished. + * @return true if gesture recognize is started or finished, else false. + */ + bool IsMultiFingerRecognize() const + { + return (multiFingerGestureState_ == MultiFingerGestureState::GESTURE_START || + multiFingerGestureState_ == MultiFingerGestureState::GESTURE_COMPLETE); + } + + /** + * @brief Get the two finger move threshold. + * @return the two finger move threshold, indicates tap state to move state. + */ + float GetTouchSlop() const + { + return touchSlop_; + } +private: + /** + * @brief Cancle the pendding two finger gesture recognize event. + */ + void CancelTwoFingerEvent(); + + /** + * @brief Cancle All pendding inner event. + */ + void CancelAllPenddingEvent(); + + /** + * @brief Cancel the multi gesture recognize process. + * @param isNoDelayFlag if gesture cancel event is immediately processed. + */ + void CancelGesture(const bool isNoDelayFlag); + + /** + * @brief param check for two finger Double tap recognize gesture. + * @return true if the used param is ok, else false. + */ + bool ParamCheck(); + + /** + * @brief Determine whether it is a two finger double tap gesture. + * @param event the touch event from Multimodal. + * @return true if the gesture is two finger double tap, else false. + */ + bool IsTwoFingerDoubleTap(MMI::PointerEvent &event); + + /** + * @brief Handle the first touch down event. + * @param event the touch event to be handled. + */ + void HanleFirstTouchDownEvent(MMI::PointerEvent &event); + + /** + * @brief Handle the continue touch down event. + * @param event the touch event to be handled. + */ + void HandleContinueTouchDownEvent(MMI::PointerEvent &event); + + /** + * @brief Handle the two finger touch move event. + * @param event the touch event to be handled. + */ + void HandleTwoFingerMoveEvent(MMI::PointerEvent &event); + + /** + * @brief Handle the touch up event, not a move gesture. + * @param event the touch event to be handled. + */ + void HandleMultiFingerTouchUpEvent(MMI::PointerEvent &event); + + float touchSlop_ = 0.0f; + int32_t doubleTapOffsetThresh_ = 0; + int32_t targetFingers_ = -1; // touch down finger numbers before first time the finger touch up + int32_t addContinueTapNum_ = 0; // total number of touch down, except the first touch down + int32_t multiFingerGestureState_ = 0; // recognize state, value is MultiFingerGestureState + int32_t fingerTouchUpState_ = FingerTouchUpState::ALL_FINGER_TOUCH_UP; + bool isFirstUp_ = 0; // whether the first time finger touch up + + std::map> firstDownPoint_; // first round touch down points + std::map> currentDownPoint_; // current round touch down points + std::map> lastUpPoint_; // last time finger touch up points + + AccessibilityGestureRecognizeListener *listener_ = nullptr; + std::shared_ptr handler_ = nullptr; // multi finger gesture recognize event handler + std::shared_ptr runner_ = nullptr; +}; +} // namespace Accessibility +} // namespace OHOS +#endif // ACCESSIBILITY_MULTIFINGER_MULTITAP_H \ No newline at end of file diff --git a/services/aams/include/accessibility_touch_guider.h b/services/aams/include/accessibility_touch_guider.h index c702b19c..5681cc4c 100644 --- a/services/aams/include/accessibility_touch_guider.h +++ b/services/aams/include/accessibility_touch_guider.h @@ -21,6 +21,7 @@ #include "accessibility_element_operator_callback_stub.h" #include "accessibility_event_transmission.h" #include "accessibility_gesture_recognizer.h" +#include "accessibility_multifinger_multitap.h" #include "accessible_ability_manager_service.h" namespace OHOS { @@ -73,6 +74,7 @@ struct InjectedEventRecorder { struct ReceivedEventRecorder { int32_t pointerDownX[MAX_POINTER_COUNT]; int32_t pointerDownY[MAX_POINTER_COUNT]; + int64_t pointerActionTime[MAX_POINTER_COUNT]; std::shared_ptr lastEvent; }; @@ -145,6 +147,13 @@ public: */ void DestroyEvents() override; + /** + * @brief Send pointer down event to multimodal input. + * @param event event the touch event from Multimodal, set the down point to the event and send. + * @param action point action send to multimode. + */ + void SendPointerDownEventToMultimodal(MMI::PointerEvent event, int32_t action); + /** * @brief Send event to multimodal input. * @param event the event prepared to send to Multimodal @@ -192,6 +201,15 @@ public: isTouchStart_ = false; } + /** + * @brief whether touch guide end. + * @return true if touch guide end, else false. + */ + inline bool IsTouchInteractionEnd() + { + return isTouchStart_ == false; + } + /** * @brief Perform action on Accessibility Focus. * @param action the action of Accessibility node. @@ -218,18 +236,34 @@ private: */ bool OnStarted() override; + /** + * @brief Send GESTURE_BEGIN to AccessibleAbility when two finger gesture start. + */ + void TwoFingerGestureOnStarted() override; + /** * @brief Send GESTURE_END and TOUCH_END to AccessibleAbility. * @param gestureId the id of gesture */ bool OnCompleted(GestureType gestureId) override; + /** + * @brief Send GESTURE_END and TOUCH_END to AccessibleAbility when two finger gesture complete. + * @param gestureId the id of gesture. + */ + void TwoFingerGestureOnCompleted(GestureType gestureId) override; + /** * @brief The gesture has been cancelled. * @param event the touch event from Multimodal */ bool OnCancelled(MMI::PointerEvent &event) override; + /** + * @brief The gesture has been cancelled. + * @param isNoDelayFlag whether the gesture recognize process is immediately canceled. + */ + void TwoFingerGestureOnCancelled(const bool isNoDelayFlag) override; private: TouchGuider &server_; }; @@ -293,6 +327,22 @@ private: */ bool IsDragGestureAccept(MMI::PointerEvent &event); + /** + * @brief Get the offset of current points and touch down points. + * @param event the current touch event from Multimodal. + * @param firstPointOffset the first finger offset result, xAxis offset and yAxis offset. + * @param firstPointOffset the second finger offset result, xAxis offset and yAxis offset. + */ + void GetPointOffset(MMI::PointerEvent &event, std::vector &firstPointOffset, + std::vector &secondPointOffset) const; + + /** + * @brief Determine whether it is a move gesture. + * @param event the touch event from Multimodal. + * @return whether this is a scolling. + */ + bool IsRealMoveState(MMI::PointerEvent &event) const; + /** * @brief Get Angle Cos value. * @param offsetX the X value @@ -416,6 +466,7 @@ private: InjectedEventRecorder injectedRecorder_ = {}; std::list pointerEvents_ {}; AccessibilityGestureRecognizer gestureRecognizer_; + AccessibilityMultiTapGestureRecognizer multiFingerGestureRecognizer_; std::unique_ptr touchGuideListener_ = nullptr; std::shared_ptr handler_ = nullptr; std::shared_ptr runner_ = nullptr; diff --git a/services/aams/src/accessibility_gesture_recognizer.cpp b/services/aams/src/accessibility_gesture_recognizer.cpp index 8cd2a864..107cfad7 100755 --- a/services/aams/src/accessibility_gesture_recognizer.cpp +++ b/services/aams/src/accessibility_gesture_recognizer.cpp @@ -108,6 +108,7 @@ bool AccessibilityGestureRecognizer::OnPointerEvent(MMI::PointerEvent &event) if (event.GetPointerIds().size() == POINTER_COUNT_1) { HandleTouchDownEvent(event); } else { + Clear(); isRecognizingGesture_ = false; isGestureStarted_ = false; pointerRoute_.clear(); @@ -142,7 +143,7 @@ void AccessibilityGestureRecognizer::Clear() isRecognizingGesture_ = false; pointerRoute_.clear(); continueDown_ = false; - StandardGestureCancled(); + StandardGestureCanceled(); } void AccessibilityGestureRecognizer::HandleTouchDownEvent(MMI::PointerEvent &event) @@ -267,7 +268,7 @@ bool AccessibilityGestureRecognizer::StandardGestureRecognizer(MMI::PointerEvent handler_->RemoveEvent(LONG_PRESS_MSG); handler_->SendEvent(LONG_PRESS_MSG, 0, LONG_PRESS_TIMEOUT / US_TO_MS); } else { - StandardGestureCancled(); + StandardGestureCanceled(); } break; case MMI::PointerEvent::POINTER_ACTION_UP: @@ -290,7 +291,7 @@ bool AccessibilityGestureRecognizer::StandardGestureRecognizer(MMI::PointerEvent return false; } -void AccessibilityGestureRecognizer::StandardGestureCancled() +void AccessibilityGestureRecognizer::StandardGestureCanceled() { HILOG_DEBUG(); @@ -299,6 +300,7 @@ void AccessibilityGestureRecognizer::StandardGestureCancled() isLongpress_ = false; isDoubleTapdetecting_ = false; isTapDown_ = false; + isDoubleTap_ = false; } void AccessibilityGestureRecognizer::SingleTapDetected() diff --git a/services/aams/src/accessibility_multifinger_multitap.cpp b/services/aams/src/accessibility_multifinger_multitap.cpp new file mode 100644 index 00000000..d1ed50e0 --- /dev/null +++ b/services/aams/src/accessibility_multifinger_multitap.cpp @@ -0,0 +1,482 @@ +/* + * Copyright (C) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed On an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "accessibility_multifinger_multitap.h" +#include "hilog_wrapper.h" + +namespace OHOS { +namespace Accessibility { +namespace { + constexpr float SLOP_DELTA = 0.5f; + constexpr int32_t POINTER_COUNT_1 = 1; + constexpr int32_t POINTER_COUNT_2 = 2; + constexpr int32_t POINTER_COTINUE_TAP_ONE_TIME = 1; + constexpr int32_t MULTI_FINGER_MAX_CONTINUE_TAP_NUM = 3; + constexpr float TOUCH_SLOP = 8.0f; +} // namespace + +MultiFingerGestureHandler::MultiFingerGestureHandler(const std::shared_ptr &runner, + AccessibilityMultiTapGestureRecognizer &server) : AppExecFwk::EventHandler(runner), server_(server) +{ +} + +bool MultiFingerGestureHandler::ProcessTwoFingerGestureEvent(const AppExecFwk::InnerEvent::Pointer &event) +{ + HILOG_DEBUG("Inner Event Id id: %u", static_cast(event->GetInnerEventId())); + + uint32_t eventId = static_cast(event->GetInnerEventId()); + if (eventId == AccessibilityMultiTapGestureRecognizer::TWO_FINGER_SINGLE_TAP_MSG) { + if (server_.GetFingerTouchUpState() == FingerTouchUpState::ALL_FINGER_TOUCH_UP) { + server_.GetRecognizeListener()->TwoFingerGestureOnCompleted( + GestureType::GESTURE_TWO_FINGER_SINGLE_TAP); + server_.SetMultiFingerGestureState(MultiFingerGestureState::GESTURE_COMPLETE); + server_.Clear(); + } + } else if (eventId == AccessibilityMultiTapGestureRecognizer::TWO_FINGER_LONG_PRESS_MSG) { + if (server_.GetFingerTouchUpState() != FingerTouchUpState::NOT_ALL_FINGER_TOUCH_UP) { + server_.SetMultiFingerGestureState(MultiFingerGestureState::GESTURE_COMPLETE); + } + server_.Clear(); + } else if (eventId == AccessibilityMultiTapGestureRecognizer::TWO_FINGER_DOUBLE_TAP_MSG) { + if (server_.GetFingerTouchUpState() == FingerTouchUpState::ALL_FINGER_TOUCH_UP) { + server_.GetRecognizeListener()->TwoFingerGestureOnCompleted( + GestureType::GESTURE_TWO_FINGER_DOUBLE_TAP); + server_.SetMultiFingerGestureState(MultiFingerGestureState::GESTURE_COMPLETE); + server_.Clear(); + } + } else if (eventId == AccessibilityMultiTapGestureRecognizer::TWO_FINGER_DOUBLE_TAP_AND_HOLD_MSG) { + if (server_.GetFingerTouchUpState() != FingerTouchUpState::NOT_ALL_FINGER_TOUCH_UP) { + server_.GetRecognizeListener()->TwoFingerGestureOnCompleted( + GestureType::GESTURE_TWO_FINGER_DOUBLE_TAP_AND_HOLD); + server_.SetMultiFingerGestureState(MultiFingerGestureState::GESTURE_COMPLETE); + } + server_.Clear(); + } else if (eventId == AccessibilityMultiTapGestureRecognizer::TWO_FINGER_TRIPLE_TAP_MSG) { + if (server_.GetFingerTouchUpState() == FingerTouchUpState::ALL_FINGER_TOUCH_UP) { + server_.GetRecognizeListener()->TwoFingerGestureOnCompleted( + GestureType::GESTURE_TWO_FINGER_TRIPLE_TAP); + server_.SetMultiFingerGestureState(MultiFingerGestureState::GESTURE_COMPLETE); + server_.Clear(); + } + } else if (eventId == AccessibilityMultiTapGestureRecognizer::TWO_FINGER_TRIPLE_TAP_AND_HOLD_MSG) { + if (server_.GetFingerTouchUpState() != FingerTouchUpState::NOT_ALL_FINGER_TOUCH_UP) { + server_.GetRecognizeListener()->TwoFingerGestureOnCompleted( + GestureType::GESTURE_TWO_FINGER_TRIPLE_TAP_AND_HOLD); + server_.SetMultiFingerGestureState(MultiFingerGestureState::GESTURE_COMPLETE); + } + server_.Clear(); + } else { + return false; + } + + return true; +} + +void MultiFingerGestureHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) +{ + HILOG_DEBUG(); + + if (!event) { + HILOG_ERROR("event is null"); + return; + } + + if (ProcessTwoFingerGestureEvent(event)) { + return; + } + + switch (event->GetInnerEventId()) { + case AccessibilityMultiTapGestureRecognizer::WAIT_ANOTHER_FINGER_DOWN_MSG: + server_.SetFingerTouchUpState(FingerTouchUpState::NOT_ALL_FINGER_TOUCH_UP); + break; + case AccessibilityMultiTapGestureRecognizer::CANCEL_WAIT_FINGER_DOWN_MSG: + server_.SetMultiFingerGestureState(MultiFingerGestureState::GESTURE_NOT_START); + break; + case AccessibilityMultiTapGestureRecognizer::CANCEL_GESTURE: + if (server_.GetFingerTouchUpState() != FingerTouchUpState::ALL_FINGER_TOUCH_UP) { + server_.SetFingerTouchUpState(FingerTouchUpState::NOT_ALL_FINGER_TOUCH_UP); + } + server_.GetRecognizeListener()->TwoFingerGestureOnCancelled(true); + server_.SetMultiFingerGestureState(MultiFingerGestureState::GESTURE_CANCLE); + server_.Clear(); + break; + default: + break; + } +} + +AccessibilityMultiTapGestureRecognizer::AccessibilityMultiTapGestureRecognizer() +{ + HILOG_DEBUG(); + + AccessibilityDisplayManager &displayMgr = Singleton::GetInstance(); + auto display = displayMgr.GetDefaultDisplay(); + if (!display) { + HILOG_ERROR("get display is nullptr"); + return; + } + + float density = display->GetVirtualPixelRatio(); + int32_t slop = static_cast(density * DOUBLE_TAP_SLOP + SLOP_DELTA); + doubleTapOffsetThresh_ = slop * slop; + touchSlop_ = TOUCH_SLOP; + + runner_ = Singleton::GetInstance().GetMainRunner(); + if (!runner_) { + HILOG_ERROR("get runner failed"); + return; + } + + handler_ = std::make_shared(runner_, *this); + if (!handler_) { + HILOG_ERROR("create event handler failed"); + return; + } +} + +void AccessibilityMultiTapGestureRecognizer::RegisterListener(AccessibilityGestureRecognizeListener& listener) +{ + HILOG_DEBUG(); + + listener_ = &listener; +} + +void AccessibilityMultiTapGestureRecognizer::CancelTwoFingerEvent() +{ + HILOG_DEBUG(); + + if (!handler_) { + HILOG_ERROR("handler_ is null ptr"); + return; + } + + handler_->RemoveEvent(TWO_FINGER_SINGLE_TAP_MSG); + handler_->RemoveEvent(TWO_FINGER_LONG_PRESS_MSG); + handler_->RemoveEvent(TWO_FINGER_DOUBLE_TAP_MSG); + handler_->RemoveEvent(TWO_FINGER_DOUBLE_TAP_AND_HOLD_MSG); + handler_->RemoveEvent(TWO_FINGER_TRIPLE_TAP_MSG); + handler_->RemoveEvent(TWO_FINGER_TRIPLE_TAP_AND_HOLD_MSG); +} + +void AccessibilityMultiTapGestureRecognizer::CancelAllPenddingEvent() +{ + HILOG_DEBUG(); + + if (!handler_) { + HILOG_ERROR("handler_ is null ptr"); + return; + } + + handler_->RemoveEvent(CANCEL_GESTURE); + handler_->RemoveEvent(CANCEL_WAIT_FINGER_DOWN_MSG); + CancelTwoFingerEvent(); +} + +void AccessibilityMultiTapGestureRecognizer::Clear() +{ + HILOG_DEBUG(); + + targetFingers_ = -1; + addContinueTapNum_ = 0; + firstDownPoint_.clear(); + lastUpPoint_.clear(); + currentDownPoint_.clear(); + CancelAllPenddingEvent(); +} + +void AccessibilityMultiTapGestureRecognizer::CancelGesture(bool isNoDelayFlag) +{ + HILOG_DEBUG(); + + SetMultiFingerGestureState(MultiFingerGestureState::GESTURE_CANCLE); + + if (fingerTouchUpState_ != FingerTouchUpState::ALL_FINGER_TOUCH_UP) { + fingerTouchUpState_ = FingerTouchUpState::NOT_ALL_FINGER_TOUCH_UP; + } + + if (!listener_) { + HILOG_ERROR("listener_ is null ptr"); + return; + } + + listener_->TwoFingerGestureOnCancelled(isNoDelayFlag); + Clear(); +} + +bool AccessibilityMultiTapGestureRecognizer::ParamCheck() +{ + if (!lastUpPoint_.count(0) || !lastUpPoint_.count(1) || !firstDownPoint_.count(0) || !firstDownPoint_.count(1)) { + HILOG_ERROR("last_up point or first_down point container has wrong value"); + return false; + } + + if (!lastUpPoint_[0] || !lastUpPoint_[1] || !firstDownPoint_[0] || !firstDownPoint_[1]) { + HILOG_ERROR("last_up point or first_down point container has null ptr value"); + return false; + } + + return true; +} + +bool AccessibilityMultiTapGestureRecognizer::IsTwoFingerDoubleTap(MMI::PointerEvent &event) +{ + HILOG_DEBUG("doubleTapOffsetThresh: %d", doubleTapOffsetThresh_); + + if (!ParamCheck()) { + return false; + } + + // first pointer up time to second pointer down time + int64_t firstUpTime = lastUpPoint_[0]->GetActionTime() > lastUpPoint_[1]->GetActionTime() ? + lastUpPoint_[1]->GetActionTime() : lastUpPoint_[0]->GetActionTime(); + int64_t durationTime = event.GetActionTime() - firstUpTime; + if (durationTime > DOUBLE_TAP_TIMEOUT || durationTime < MIN_DOUBLE_TAP_TIME) { + HILOG_WARN("durationTime[%{public}" PRId64 "] is wrong", durationTime); + return false; + } + + std::vector pIds = event.GetPointerIds(); + if (pIds.size() != POINTER_COUNT_2) { + return false; + } + + MMI::PointerEvent::PointerItem pointerF = {}; + MMI::PointerEvent::PointerItem pointerS = {}; + if (!event.GetPointerItem(pIds[0], pointerF)) { + HILOG_ERROR("GetPointerItem(%d) failed", pIds[0]); + return false; + } + + if (!event.GetPointerItem(pIds[1], pointerS)) { + HILOG_ERROR("GetPointerItem(%d) failed", pIds[1]); + return false; + } + + MMI::PointerEvent::PointerItem firstPI; + MMI::PointerEvent::PointerItem secondPI; + firstDownPoint_[0]->GetPointerItem(firstDownPoint_[0]->GetPointerId(), firstPI); + firstDownPoint_[1]->GetPointerItem(firstDownPoint_[1]->GetPointerId(), secondPI); + HILOG_DEBUG("first finger preDown x: %d, y: %d. curDown x: %d, y: %d", + firstPI.GetDisplayX(), firstPI.GetDisplayY(), pointerF.GetDisplayX(), pointerF.GetDisplayY()); + HILOG_DEBUG("second finger preDown x: %d, y: %d. curDown x: %d, y: %d", + secondPI.GetDisplayX(), secondPI.GetDisplayY(), pointerS.GetDisplayX(), pointerS.GetDisplayY()); + + int32_t durationXff = firstPI.GetDisplayX() - pointerF.GetDisplayX(); + int32_t durationYff = firstPI.GetDisplayY() - pointerF.GetDisplayY(); + int32_t durationXss = secondPI.GetDisplayX() - pointerS.GetDisplayX(); + int32_t durationYss = secondPI.GetDisplayY() - pointerS.GetDisplayY(); + + int32_t durationXfs = firstPI.GetDisplayX() - pointerS.GetDisplayX(); + int32_t durationYfs = firstPI.GetDisplayY() - pointerS.GetDisplayY(); + int32_t durationXsf = secondPI.GetDisplayX() - pointerF.GetDisplayX(); + int32_t durationYsf = secondPI.GetDisplayY() - pointerF.GetDisplayY(); + + return ((durationXff * durationXff + durationYff * durationYff < doubleTapOffsetThresh_ && + durationXss * durationXss + durationYss * durationYss < doubleTapOffsetThresh_) || + (durationXfs * durationXfs + durationYfs * durationYfs < doubleTapOffsetThresh_ && + durationXsf * durationXsf + durationYsf * durationYsf < doubleTapOffsetThresh_)); +} + +void AccessibilityMultiTapGestureRecognizer::HanleFirstTouchDownEvent(MMI::PointerEvent &event) +{ + HILOG_DEBUG("gestureState is %d, touchUpState is %d", multiFingerGestureState_, fingerTouchUpState_); + + if (multiFingerGestureState_ == MultiFingerGestureState::GESTURE_WAIT) { + if (event.GetPointerId() == 0) { + fingerTouchUpState_ = FingerTouchUpState::NOT_ALL_FINGER_TOUCH_UP; + Clear(); + return; + } else if (!handler_->HasInnerEvent(WAIT_ANOTHER_FINGER_DOWN_MSG)) { + HILOG_DEBUG("do not have WAIT_ANOTHER_FINGER_DOWN_MSG"); + SetMultiFingerGestureState(MultiFingerGestureState::GESTURE_NOT_START); + } + } + + // NOT_ALL_FINGER_TOUCH_UP state can not revice touch down event + if (fingerTouchUpState_ == FingerTouchUpState::NOT_ALL_FINGER_TOUCH_UP) { + Clear(); + return; + } + + // start touch down, change fingerTouchUpState_ to TOUCH_DOWN_AFTER_ALL_FINGER_TOUCH_UP state + fingerTouchUpState_ = FingerTouchUpState::TOUCH_DOWN_AFTER_ALL_FINGER_TOUCH_UP; + firstDownPoint_[event.GetPointerId()] = std::make_shared(event); + handler_->SendEvent(WAIT_ANOTHER_FINGER_DOWN_MSG, 0, TAP_INTERVAL_TIMEOUT / US_TO_MS); + if (event.GetPointerIds().size() == POINTER_COUNT_1) { + SetMultiFingerGestureState(MultiFingerGestureState::GESTURE_WAIT); + } else if (event.GetPointerIds().size() == POINTER_COUNT_2) { + listener_->TwoFingerGestureOnStarted(); + SetMultiFingerGestureState(MultiFingerGestureState::GESTURE_START); + handler_->SendEvent(TWO_FINGER_SINGLE_TAP_MSG, 0, DOUBLE_TAP_TIMEOUT / US_TO_MS); + handler_->SendEvent(TWO_FINGER_LONG_PRESS_MSG, 0, LONG_PRESS_TIMEOUT / US_TO_MS); + } else { + CancelGesture(true); + } +} + +void AccessibilityMultiTapGestureRecognizer::HandleContinueTouchDownEvent(MMI::PointerEvent &event) +{ + HILOG_DEBUG("fingerNum is %d, gestureState is %d, touchUpstate is %d", + targetFingers_, multiFingerGestureState_, fingerTouchUpState_); + + if (targetFingers_ == POINTER_COUNT_1) { + return; + } + + if (multiFingerGestureState_ != MultiFingerGestureState::GESTURE_START) { + CancelGesture(true); + return; + } + + if (fingerTouchUpState_ == FingerTouchUpState::NOT_ALL_FINGER_TOUCH_UP) { + CancelGesture(true); + return; + } + + fingerTouchUpState_ = FingerTouchUpState::TOUCH_DOWN_AFTER_ALL_FINGER_TOUCH_UP; + int32_t pointerSize = static_cast(event.GetPointerIds().size()); + if (pointerSize < targetFingers_) { + handler_->SendEvent(CANCEL_GESTURE, 0, TAP_INTERVAL_TIMEOUT / US_TO_MS); + } else if (pointerSize == targetFingers_) { + // check is double tap + if (firstDownPoint_.size() == POINTER_COUNT_2 && lastUpPoint_.size() == POINTER_COUNT_2 && + IsTwoFingerDoubleTap(event)) { + HILOG_DEBUG("two finger Double tap is recognized, addContinueTapNum %d", addContinueTapNum_); + addContinueTapNum_ = (addContinueTapNum_ + 1) % MULTI_FINGER_MAX_CONTINUE_TAP_NUM; + } else { + addContinueTapNum_ = 0; + } + + if (addContinueTapNum_ == 0) { + handler_->SendEvent(TWO_FINGER_SINGLE_TAP_MSG, 0, DOUBLE_TAP_TIMEOUT / US_TO_MS); + handler_->SendEvent(TWO_FINGER_LONG_PRESS_MSG, 0, LONG_PRESS_TIMEOUT / US_TO_MS); + } else if (addContinueTapNum_ == POINTER_COTINUE_TAP_ONE_TIME) { + handler_->SendEvent(TWO_FINGER_DOUBLE_TAP_AND_HOLD_MSG, 0, LONG_PRESS_TIMEOUT / US_TO_MS); + handler_->SendEvent(TWO_FINGER_DOUBLE_TAP_MSG, 0, DOUBLE_TAP_TIMEOUT / US_TO_MS); + } else { + handler_->SendEvent(TWO_FINGER_TRIPLE_TAP_AND_HOLD_MSG, 0, LONG_PRESS_TIMEOUT / US_TO_MS); + handler_->SendEvent(TWO_FINGER_TRIPLE_TAP_MSG, 0, DOUBLE_TAP_TIMEOUT / US_TO_MS); + } + } else { + HILOG_DEBUG("current fingers is more than last touch down finger nums"); + CancelGesture(true); + } +} + +void AccessibilityMultiTapGestureRecognizer::HandleTwoFingerMoveEvent(MMI::PointerEvent &event) +{ + HILOG_DEBUG("finger num is %d, pId is %d", static_cast(currentDownPoint_.size()), event.GetPointerId()); + + int32_t pId = event.GetPointerId(); + MMI::PointerEvent::PointerItem pointerIterm; + if (!event.GetPointerItem(pId, pointerIterm)) { + HILOG_ERROR("get GetPointerItem(%d) failed", pId); + return; + } + + if (currentDownPoint_.size() != POINTER_COUNT_2 || currentDownPoint_.count(pId) == 0 || + !currentDownPoint_[pId]) { + CancelGesture(false); + return; + } + + MMI::PointerEvent::PointerItem firstDownPointerIterm; + if (!currentDownPoint_[pId]->GetPointerItem(currentDownPoint_[pId]->GetPointerId(), firstDownPointerIterm)) { + HILOG_ERROR("first down point get GetPointerItem(%d) failed", pId); + return; + } + + int32_t offsetX = firstDownPointerIterm.GetDisplayX() - pointerIterm.GetDisplayX(); + int32_t offsetY = firstDownPointerIterm.GetDisplayY() - pointerIterm.GetDisplayY(); + HILOG_DEBUG("current point and first down point: %d, %d, %d, %d", pointerIterm.GetDisplayX(), + pointerIterm.GetDisplayY(), firstDownPointerIterm.GetDisplayX(), firstDownPointerIterm.GetDisplayY()); + + // two finger move not recognize as a gesture + if (hypot(offsetX, offsetY) >= TOUCH_SLOP * event.GetPointerIds().size()) { + HILOG_DEBUG("cancel gesture because finger move"); + CancelGesture(false); + } +} + +void AccessibilityMultiTapGestureRecognizer::HandleMultiFingerTouchUpEvent(MMI::PointerEvent &event) +{ + HILOG_DEBUG("gestureState is %d, isFirstUp is %d, target finger num is %d", + multiFingerGestureState_, isFirstUp_, targetFingers_); + + handler_->RemoveEvent(WAIT_ANOTHER_FINGER_DOWN_MSG); + handler_->RemoveEvent(TWO_FINGER_LONG_PRESS_MSG); + handler_->RemoveEvent(TWO_FINGER_DOUBLE_TAP_AND_HOLD_MSG); + handler_->RemoveEvent(TWO_FINGER_TRIPLE_TAP_AND_HOLD_MSG); + + if (multiFingerGestureState_ == MultiFingerGestureState::GESTURE_WAIT) { + handler_->SendEvent(CANCEL_WAIT_FINGER_DOWN_MSG, event.GetPointerIds().size(), DOUBLE_TAP_TIMEOUT / US_TO_MS); + } + + if (event.GetPointerIds().size() == POINTER_COUNT_1) { + fingerTouchUpState_ = FingerTouchUpState::ALL_FINGER_TOUCH_UP; + currentDownPoint_.clear(); + } else { + fingerTouchUpState_ = FingerTouchUpState::NOT_ALL_FINGER_TOUCH_UP; + } + + if (isFirstUp_) { + isFirstUp_ = false; + if (targetFingers_ != -1 && static_cast(event.GetPointerIds().size()) != targetFingers_) { + CancelGesture(true); + return; + } + } + + lastUpPoint_[event.GetPointerId()] = std::make_shared(event); + if (targetFingers_ == -1 && multiFingerGestureState_ == MultiFingerGestureState::GESTURE_START) { + targetFingers_ = event.GetPointerIds().size(); + } +} + +bool AccessibilityMultiTapGestureRecognizer::OnPointerEvent(MMI::PointerEvent &event) +{ + HILOG_DEBUG("gestureState is %d", multiFingerGestureState_); + + switch (event.GetPointerAction()) { + case MMI::PointerEvent::POINTER_ACTION_DOWN: + // cancel last cancel event when recevie a new down event + CancelAllPenddingEvent(); + isFirstUp_ = true; + currentDownPoint_[event.GetPointerId()] = std::make_shared(event); + if (targetFingers_ == -1) { + HanleFirstTouchDownEvent(event); + } else { + HandleContinueTouchDownEvent(event); + } + break; + case MMI::PointerEvent::POINTER_ACTION_MOVE: + if (multiFingerGestureState_ != MultiFingerGestureState::GESTURE_START) { + return false; + } + + if (event.GetPointerIds().size() == POINTER_COUNT_2) { + HandleTwoFingerMoveEvent(event); + } + break; + case MMI::PointerEvent::POINTER_ACTION_UP: + HandleMultiFingerTouchUpEvent(event); + break; + default: + break; + } + return false; +} +} // namespace Accessibility +} // namespace OHOS diff --git a/services/aams/src/accessibility_touch_guider.cpp b/services/aams/src/accessibility_touch_guider.cpp index 71b50d01..a62711fe 100755 --- a/services/aams/src/accessibility_touch_guider.cpp +++ b/services/aams/src/accessibility_touch_guider.cpp @@ -23,6 +23,7 @@ namespace Accessibility { namespace { constexpr int32_t POINTER_COUNT_1 = 1; constexpr int32_t POINTER_COUNT_2 = 2; + constexpr int32_t SCREEN_AXIS_NUM = 2; } // namespace TGEventHandler::TGEventHandler( @@ -42,6 +43,8 @@ void TouchGuider::StartUp() HILOG_DEBUG(); touchGuideListener_ = std::make_unique(*this); gestureRecognizer_.RegisterListener(*touchGuideListener_.get()); + multiFingerGestureRecognizer_.RegisterListener(*touchGuideListener_.get()); + runner_ = Singleton::GetInstance().GetMainRunner(); if (!runner_) { HILOG_ERROR("get runner failed"); @@ -91,9 +94,15 @@ bool TouchGuider::OnPointerEvent(MMI::PointerEvent &event) return true; } RecordReceivedEvent(event); - if (gestureRecognizer_.OnPointerEvent(event)) { + if (!multiFingerGestureRecognizer_.IsMultiFingerGestureStarted() && + gestureRecognizer_.OnPointerEvent(event)) { return true; } + + if (multiFingerGestureRecognizer_.OnPointerEvent(event)) { + return true; + } + switch (static_cast(currentState_)) { case TouchGuideState::TOUCH_GUIDING: HandleTouchGuidingState(event); @@ -223,6 +232,16 @@ bool TouchGuider::TouchGuideListener::OnStarted() return true; } +void TouchGuider::TouchGuideListener::TwoFingerGestureOnStarted() +{ + HILOG_DEBUG(); + + server_.CancelPostEventIfNeed(SEND_HOVER_ENTER_MOVE_MSG); + server_.CancelPostEventIfNeed(SEND_HOVER_EXIT_MSG); + server_.PostGestureRecognizeExit(); + server_.SendAccessibilityEventToAA(EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN); +} + bool TouchGuider::TouchGuideListener::OnCompleted(GestureType gestureId) { HILOG_DEBUG("gestureId is %{public}d", gestureId); @@ -242,16 +261,30 @@ bool TouchGuider::TouchGuideListener::OnCompleted(GestureType gestureId) return true; } +void TouchGuider::TouchGuideListener::TwoFingerGestureOnCompleted(GestureType gestureId) +{ + HILOG_DEBUG("gestureId is %{public}d", gestureId); + + server_.OnTouchInteractionEnd(); + server_.SendAccessibilityEventToAA(EventType::TYPE_TOUCH_GUIDE_GESTURE_END); + server_.SendAccessibilityEventToAA(EventType::TYPE_TOUCH_END); + server_.CancelPostEvent(EXIT_GESTURE_REC_MSG); + server_.currentState_ = static_cast(TouchGuideState::TOUCH_GUIDING); + + // Send customize gesture type to aa + server_.SendGestureEventToAA(gestureId); +} + bool TouchGuider::TouchGuideListener::OnCancelled(MMI::PointerEvent &event) { HILOG_DEBUG(); switch (static_cast(server_.currentState_)) { case TouchGuideState::TRANSMITTING: - server_.OnTouchInteractionEnd(); server_.SendAccessibilityEventToAA(EventType::TYPE_TOUCH_GUIDE_GESTURE_END); if (event.GetPointerAction() == MMI::PointerEvent::POINTER_ACTION_UP && event.GetPointerIds().size() == POINTER_COUNT_1) { + server_.OnTouchInteractionEnd(); server_.SendAccessibilityEventToAA(EventType::TYPE_TOUCH_END); } server_.CancelPostEvent(EXIT_GESTURE_REC_MSG); @@ -269,6 +302,18 @@ bool TouchGuider::TouchGuideListener::OnCancelled(MMI::PointerEvent &event) return true; } +void TouchGuider::TouchGuideListener::TwoFingerGestureOnCancelled(const bool isNoDelayFlag) +{ + HILOG_DEBUG(); + + server_.SendAccessibilityEventToAA(EventType::TYPE_TOUCH_GUIDE_GESTURE_END); + server_.CancelPostEvent(EXIT_GESTURE_REC_MSG); + if (isNoDelayFlag) { + server_.OnTouchInteractionEnd(); + server_.SendAccessibilityEventToAA(EventType::TYPE_TOUCH_END); + } +} + void TouchGuider::ElementOperatorCallbackImpl::SetFindFocusedElementInfoResult(const AccessibilityElementInfo &info, const int32_t requestId) { @@ -325,11 +370,12 @@ void TouchGuider::HandleTouchGuidingState(MMI::PointerEvent &event) HandleTouchGuidingStateInnerMove(event); break; case MMI::PointerEvent::POINTER_ACTION_UP: - if (event.GetPointerIds().size() == POINTER_COUNT_1) { + if (event.GetPointerIds().size() == POINTER_COUNT_1 && !IsTouchInteractionEnd() && + !multiFingerGestureRecognizer_.IsMultiFingerRecognize()) { OnTouchInteractionEnd(); if (HasEventPending(SEND_HOVER_ENTER_MOVE_MSG)) { PostHoverExit(); - } else { + } else if (isTouchGuiding_) { SendExitEvents(); } if (!HasEventPending(SEND_TOUCH_INTERACTION_END_MSG)) { @@ -467,7 +513,7 @@ void TouchGuider::HandleTouchGuidingStateInnerDown(MMI::PointerEvent &event) if (isTouchGuiding_) { SendExitEvents(); } - if (!gestureRecognizer_.IsfirstTap()) { + if (!gestureRecognizer_.IsfirstTap() && !multiFingerGestureRecognizer_.IsMultiFingerGestureStarted()) { ForceSendAndRemoveEvent(SEND_TOUCH_GUIDE_END_MSG, event); ForceSendAndRemoveEvent(SEND_TOUCH_INTERACTION_END_MSG, event); SendAccessibilityEventToAA(EventType::TYPE_TOUCH_BEGIN); @@ -483,6 +529,29 @@ void TouchGuider::HandleTouchGuidingStateInnerDown(MMI::PointerEvent &event) } } +void TouchGuider::SendPointerDownEventToMultimodal(MMI::PointerEvent event, int32_t action) +{ + int32_t currentPid = event.GetPointerId(); + if (currentPid >= MAX_POINTER_COUNT) { + return; + } + + int32_t xPointDown = receivedRecorder_.pointerDownX[currentPid]; + int32_t yPointDown = receivedRecorder_.pointerDownY[currentPid]; + int64_t actionTime = receivedRecorder_.pointerActionTime[currentPid]; + + HILOG_DEBUG("first down point info is: xPos: %d, yPos: %d, actionTime: [%{public}" PRId64 "], " + "currentTime: [%{public}" PRId64 "]", xPointDown, yPointDown, actionTime, event.GetActionTime()); + MMI::PointerEvent::PointerItem pointer = {}; + event.GetPointerItem(currentPid, pointer); + pointer.SetDisplayX(xPointDown); + pointer.SetDisplayY(yPointDown); + event.RemovePointerItem(currentPid); + event.AddPointerItem(pointer); + event.SetActionTime(actionTime); + SendEventToMultimodal(event, action); +} + void TouchGuider::HandleTouchGuidingStateInnerMove(MMI::PointerEvent &event) { HILOG_DEBUG(); @@ -498,9 +567,14 @@ void TouchGuider::HandleTouchGuidingStateInnerMove(MMI::PointerEvent &event) case POINTER_COUNT_2: CancelPostEventIfNeed(SEND_HOVER_ENTER_MOVE_MSG); CancelPostEventIfNeed(SEND_HOVER_EXIT_MSG); + if (!IsRealMoveState(event)) { + HILOG_DEBUG("not a move"); + break; + } if (IsDragGestureAccept(event)) { - currentState_ = static_cast(TouchGuideState::DRAGGING); - SendEventToMultimodal(event, POINTER_DOWN); + currentState_ = static_cast(TouchGuideState::DRAGGING); + SendPointerDownEventToMultimodal(event, POINTER_DOWN); + SendEventToMultimodal(event, NO_CHANGE); } else { currentState_ = static_cast(TouchGuideState::TRANSMITTING); SendAllDownEvents(event); @@ -573,18 +647,26 @@ float TouchGuider::GetAngleCos(float offsetX, float offsetY, bool isGetX) return ret; } -bool TouchGuider::IsDragGestureAccept(MMI::PointerEvent &event) +void TouchGuider::GetPointOffset(MMI::PointerEvent &event, std::vector &firstPointOffset, + std::vector &secondPointOffset) const { HILOG_DEBUG(); std::vector pIds = event.GetPointerIds(); + if (pIds.size() != POINTER_COUNT_2) { + return; + } + MMI::PointerEvent::PointerItem pointerF = {}; MMI::PointerEvent::PointerItem pointerS = {}; if (!event.GetPointerItem(pIds[0], pointerF)) { - HILOG_WARN("GetPointerItem(%d) failed", pIds[0]); + HILOG_ERROR("GetPointerItem(%d) failed", pIds[0]); + return; } + if (!event.GetPointerItem(pIds[1], pointerS)) { - HILOG_WARN("GetPointerItem(%d) failed", pIds[1]); + HILOG_ERROR("GetPointerItem(%d) failed", pIds[1]); + return; } float xPointF = pointerF.GetDisplayX(); @@ -595,10 +677,28 @@ bool TouchGuider::IsDragGestureAccept(MMI::PointerEvent &event) float xPointDownS = receivedRecorder_.pointerDownX[INDEX_1]; float yPointDownF = receivedRecorder_.pointerDownY[INDEX_0]; float yPointDownS = receivedRecorder_.pointerDownY[INDEX_1]; - float firstOffsetX = xPointF - xPointDownF; - float firstOffsetY = yPointF - yPointDownF; - float secondOffsetX = xPointS - xPointDownS; - float secondOffsetY = yPointS - yPointDownS; + + firstPointOffset.push_back(xPointF - xPointDownF); // firstOffsetX + firstPointOffset.push_back (yPointF - yPointDownF); // firstOffsetY + secondPointOffset.push_back(xPointS - xPointDownS); // secondOffsetX + secondPointOffset.push_back(yPointS - yPointDownS); // secondOffsetY +} + +bool TouchGuider::IsDragGestureAccept(MMI::PointerEvent &event) +{ + HILOG_DEBUG(); + + std::vector firstPointOffset; + std::vector secondPointOffset; + GetPointOffset(event, firstPointOffset, secondPointOffset); + if (firstPointOffset.size() != SCREEN_AXIS_NUM || secondPointOffset.size() != SCREEN_AXIS_NUM) { + return false; + } + + float firstOffsetX = firstPointOffset[0]; + float firstOffsetY = firstPointOffset[1]; + float secondOffsetX = secondPointOffset[0]; + float secondOffsetY = secondPointOffset[1]; if ((!firstOffsetX && !firstOffsetY) || (!secondOffsetX && !secondOffsetY)) { return true; @@ -614,6 +714,26 @@ bool TouchGuider::IsDragGestureAccept(MMI::PointerEvent &event) return true; } +bool TouchGuider::IsRealMoveState(MMI::PointerEvent &event) const +{ + HILOG_DEBUG("moveThreshold: %f", multiFingerGestureRecognizer_.GetTouchSlop()); + + std::vector firstPointOffset; + std::vector secondPointOffset; + GetPointOffset(event, firstPointOffset, secondPointOffset); + if (firstPointOffset.size() != SCREEN_AXIS_NUM || secondPointOffset.size() != SCREEN_AXIS_NUM) { + return false; + } + + HILOG_DEBUG("offset of fisrt down points and current points: %f, %f,%f, %f", + firstPointOffset[0], firstPointOffset[1], secondPointOffset[0],secondPointOffset[1]); + if (hypot(firstPointOffset[0], firstPointOffset[1]) >= multiFingerGestureRecognizer_.GetTouchSlop() && + hypot(secondPointOffset[0], secondPointOffset[1]) >= multiFingerGestureRecognizer_.GetTouchSlop()) { + return true; + } + return false; +} + void TouchGuider::RecordInjectedEvent(MMI::PointerEvent &event) { HILOG_DEBUG(); @@ -656,10 +776,12 @@ void TouchGuider::RecordReceivedEvent(MMI::PointerEvent &event) case MMI::PointerEvent::POINTER_ACTION_DOWN: receivedRecorder_.pointerDownX[pointId] = pointer.GetDisplayX(); receivedRecorder_.pointerDownY[pointId] = pointer.GetDisplayY(); + receivedRecorder_.pointerActionTime[pointId] = event.GetActionTime(); break; case MMI::PointerEvent::POINTER_ACTION_UP: receivedRecorder_.pointerDownX[pointId] = 0; receivedRecorder_.pointerDownY[pointId] = 0; + receivedRecorder_.pointerActionTime[pointId] = 0; break; default: break; @@ -674,6 +796,8 @@ void TouchGuider::ClearReceivedEventRecorder() 0, sizeof(receivedRecorder_.pointerDownX)); (void)memset_s(receivedRecorder_.pointerDownY, sizeof(receivedRecorder_.pointerDownY), 0, sizeof(receivedRecorder_.pointerDownY)); + (void)memset_s(receivedRecorder_.pointerActionTime, sizeof(receivedRecorder_.pointerActionTime), + 0, sizeof(receivedRecorder_.pointerActionTime)); receivedRecorder_.lastEvent = nullptr; } diff --git a/services/aams/test/BUILD.gn b/services/aams/test/BUILD.gn index 1552bf82..c9eedd1b 100644 --- a/services/aams/test/BUILD.gn +++ b/services/aams/test/BUILD.gn @@ -183,6 +183,7 @@ ohos_unittest("accessibility_touch_guider_test") { "../../test/mock/mock_matching_skill.cpp", "../src/accessibility_display_manager.cpp", "../src/accessibility_gesture_recognizer.cpp", + "../src/accessibility_multifinger_multitap.cpp", "../src/accessibility_settings_config.cpp", "../src/accessibility_touch_guider.cpp", "../src/accessibility_window_connection.cpp", @@ -319,6 +320,7 @@ ohos_unittest("accessibility_input_interceptor_test") { "../src/accessibility_input_interceptor.cpp", "../src/accessibility_mouse_autoclick.cpp", "../src/accessibility_mouse_key.cpp", + "../src/accessibility_multifinger_multitap.cpp", "../src/accessibility_short_key.cpp", "../src/accessibility_touch_guider.cpp", "../src/accessible_ability_manager_service_event_handler.cpp", @@ -508,6 +510,7 @@ ohos_unittest("accessible_ability_connection_test") { "../src/accessibility_input_interceptor.cpp", "../src/accessibility_mouse_autoclick.cpp", "../src/accessibility_mouse_key.cpp", + "../src/accessibility_multifinger_multitap.cpp", "../src/accessibility_settings_config.cpp", "../src/accessibility_short_key.cpp", "../src/accessibility_touchEvent_injector.cpp", diff --git a/services/aams/test/unittest/accessibility_touch_guider_test.cpp b/services/aams/test/unittest/accessibility_touch_guider_test.cpp index fa591410..ceb4a0cc 100755 --- a/services/aams/test/unittest/accessibility_touch_guider_test.cpp +++ b/services/aams/test/unittest/accessibility_touch_guider_test.cpp @@ -31,6 +31,9 @@ namespace { constexpr int64_t MS_TO_US = 1000; constexpr int32_t ACCOUNT_ID = 100; constexpr int32_t WINDOW_ID = 2; + constexpr int32_t POINT_ID_1 = 1; + constexpr int32_t POINT_ID_2 = 2; + constexpr int32_t POINT_ID_3 = 3; } // namespace class TouchGuiderTest : public testing::Test { @@ -386,28 +389,37 @@ HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_005, TestSize.Leve points.emplace_back(point); std::shared_ptr event = - CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0); + CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1, 0, 0); touchGuider_->OnPointerEvent(*event); bool retOnPointerEvent5 = TestEventType(); EXPECT_TRUE(retOnPointerEvent5); points.emplace_back(otherPoint); - event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_2, 0, 0); touchGuider_->OnPointerEvent(*event); - event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_2, 0, 0); touchGuider_->OnPointerEvent(*event); - retOnPointerEvent5 = TestEventAction(); + retOnPointerEvent5 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { + if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) != + MMI::PointerEvent::POINTER_ACTION_DOWN) { + return true; + } else { + return false; + } + }), SLEEP_TIME_3); EXPECT_TRUE(retOnPointerEvent5); points.clear(); points.emplace_back(otherPoint); - event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 2, 0, 0); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, POINT_ID_2, 0, 0); touchGuider_->OnPointerEvent(*event); points.clear(); - event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 1, 0, 0); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, POINT_ID_1, 0, 0); touchGuider_->OnPointerEvent(*event); retOnPointerEvent5 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { - if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1) == + int32_t eventTypeSize = + static_cast(AccessibilityAbilityHelper::GetInstance().GetEventTypeVector().size()); + if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(eventTypeSize - 1) == EventType::TYPE_TOUCH_END) { return true; } else { @@ -530,33 +542,24 @@ HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_008, TestSize.Leve points.emplace_back(point); std::shared_ptr event = - CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0); + CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1, 0, 0); touchGuider_->OnPointerEvent(*event); points.emplace_back(otherPoint); - event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_2, 0, 0); touchGuider_->OnPointerEvent(*event); - event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_2, 0, 0); touchGuider_->OnPointerEvent(*event); bool retOnPointerEvent8 = TestEventType(); EXPECT_TRUE(retOnPointerEvent8); - retOnPointerEvent8 = TestEventAction(); - EXPECT_TRUE(retOnPointerEvent8); - points.emplace_back(otherPoint1); - event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 3, 0, 0); - touchGuider_->OnPointerEvent(*event); - retOnPointerEvent8 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { - if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1) == - MMI::PointerEvent::POINTER_ACTION_UP) { - return true; - } else { - return false; - } - }), SLEEP_TIME_3); - EXPECT_TRUE(retOnPointerEvent8); + EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionVector().size(), 0); + points.emplace_back(otherPoint1); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_3, 0, 0); + touchGuider_->OnPointerEvent(*event); + EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionVector().size(), 0); GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_008 end"; } @@ -577,30 +580,31 @@ HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_009, TestSize.Leve points.emplace_back(point); std::shared_ptr event = - CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0); + CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1, 0, 0); touchGuider_->OnPointerEvent(*event); bool retOnPointerEvent9 = TestEventType(); EXPECT_TRUE(retOnPointerEvent9); points.emplace_back(otherPoint); - event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_2, 0, 0); touchGuider_->OnPointerEvent(*event); - event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_2, 0, 0); touchGuider_->OnPointerEvent(*event); - retOnPointerEvent9 = TestEventAction(); + retOnPointerEvent9 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { + if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) != + MMI::PointerEvent::POINTER_ACTION_DOWN) { + return true; + } else { + return false; + } + }), SLEEP_TIME_3); EXPECT_TRUE(retOnPointerEvent9); - event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_2, 0, 0); touchGuider_->OnPointerEvent(*event); - retOnPointerEvent9 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { - if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1) == - MMI::PointerEvent::POINTER_ACTION_MOVE) { - return true; - } else { - return false; - } - }), SLEEP_TIME_3); - EXPECT_TRUE(retOnPointerEvent9); + int32_t touchEventSize = + static_cast(AccessibilityAbilityHelper::GetInstance().GetTouchEventActionVector().size()); + EXPECT_EQ(touchEventSize, 0); GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_009 end"; } @@ -637,16 +641,16 @@ HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_010, TestSize.Leve EXPECT_TRUE(retOnPointerEvent10); points.emplace_back(otherPoint); - event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_2, 0, 0); touchGuider_->OnPointerEvent(*event); - event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 2, 0, 0); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_2, 0, 0); touchGuider_->OnPointerEvent(*event); points.emplace_back(otherPoint1); - event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 3, 0, 0); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_3, 0, 0); touchGuider_->OnPointerEvent(*event); retOnPointerEvent10 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1) == - MMI::PointerEvent::POINTER_ACTION_UP) { + MMI::PointerEvent::POINTER_ACTION_DOWN) { return true; } else { return false; diff --git a/services/test/BUILD.gn b/services/test/BUILD.gn index f28c7c5e..001f2e19 100644 --- a/services/test/BUILD.gn +++ b/services/test/BUILD.gn @@ -75,6 +75,7 @@ ohos_moduletest("aams_accessibility_touch_guider_test") { "../aams/src/accessibility_keyevent_filter.cpp", "../aams/src/accessibility_mouse_autoclick.cpp", "../aams/src/accessibility_mouse_key.cpp", + "../aams/src/accessibility_multifinger_multitap.cpp", "../aams/src/accessibility_settings_config.cpp", "../aams/src/accessibility_short_key.cpp", "../aams/src/accessibility_touchEvent_injector.cpp", @@ -153,6 +154,7 @@ ohos_moduletest("aams_accessibility_touchEvent_injector_test") { "../aams/src/accessibility_keyevent_filter.cpp", "../aams/src/accessibility_mouse_autoclick.cpp", "../aams/src/accessibility_mouse_key.cpp", + "../aams/src/accessibility_multifinger_multitap.cpp", "../aams/src/accessibility_settings_config.cpp", "../aams/src/accessibility_short_key.cpp", "../aams/src/accessibility_touchEvent_injector.cpp", @@ -232,6 +234,7 @@ ohos_moduletest("aams_accessible_ability_channel_test") { "../aams/src/accessibility_keyevent_filter.cpp", "../aams/src/accessibility_mouse_autoclick.cpp", "../aams/src/accessibility_mouse_key.cpp", + "../aams/src/accessibility_multifinger_multitap.cpp", "../aams/src/accessibility_settings_config.cpp", "../aams/src/accessibility_short_key.cpp", "../aams/src/accessibility_touchEvent_injector.cpp", @@ -316,6 +319,7 @@ ohos_moduletest("aams_server_test") { "../aams/src/accessibility_keyevent_filter.cpp", "../aams/src/accessibility_mouse_autoclick.cpp", "../aams/src/accessibility_mouse_key.cpp", + "../aams/src/accessibility_multifinger_multitap.cpp", "../aams/src/accessibility_settings_config.cpp", "../aams/src/accessibility_short_key.cpp", "../aams/src/accessibility_touchEvent_injector.cpp", @@ -398,6 +402,7 @@ ohos_moduletest("aams_accessibility_keyevent_filter_test") { "../aams/src/accessibility_keyevent_filter.cpp", "../aams/src/accessibility_mouse_autoclick.cpp", "../aams/src/accessibility_mouse_key.cpp", + "../aams/src/accessibility_multifinger_multitap.cpp", "../aams/src/accessibility_settings_config.cpp", "../aams/src/accessibility_short_key.cpp", "../aams/src/accessibility_touchEvent_injector.cpp", @@ -475,6 +480,7 @@ ohos_moduletest("aams_common_event_registry_test") { "../aams/src/accessibility_keyevent_filter.cpp", "../aams/src/accessibility_mouse_autoclick.cpp", "../aams/src/accessibility_mouse_key.cpp", + "../aams/src/accessibility_multifinger_multitap.cpp", "../aams/src/accessibility_settings_config.cpp", "../aams/src/accessibility_short_key.cpp", "../aams/src/accessibility_touchEvent_injector.cpp", diff --git a/services/test/mock/mock_display.cpp b/services/test/mock/mock_display.cpp index 72f061fd..dd79ff1f 100644 --- a/services/test/mock/mock_display.cpp +++ b/services/test/mock/mock_display.cpp @@ -17,6 +17,11 @@ #include "window/window_manager/utils/include/display_info.h" namespace OHOS::Rosen { +namespace { + const int32_t HEIGHT_VALUE = 1000; + const int32_t WEIGHT_VALUE = 600; +} // namespace + class Display::Impl : public RefBase { public: Impl(const std::string& name, sptr info) @@ -43,12 +48,12 @@ DisplayId Display::GetId() const int32_t Display::GetWidth() const { - return 0; + return WEIGHT_VALUE; } int32_t Display::GetHeight() const { - return 0; + return HEIGHT_VALUE; } uint32_t Display::GetRefreshRate() const diff --git a/services/test/moduletest/aamstest/aams_accessibility_touch_guider_test/aams_accessibility_touch_guider_test.cpp b/services/test/moduletest/aamstest/aams_accessibility_touch_guider_test/aams_accessibility_touch_guider_test.cpp index 6d4776bd..7b5675d5 100755 --- a/services/test/moduletest/aamstest/aams_accessibility_touch_guider_test/aams_accessibility_touch_guider_test.cpp +++ b/services/test/moduletest/aamstest/aams_accessibility_touch_guider_test/aams_accessibility_touch_guider_test.cpp @@ -37,8 +37,14 @@ using namespace testing::ext; namespace OHOS { namespace Accessibility { namespace { - constexpr uint32_t POINT_ID_2 = 2; + constexpr int32_t POINT_ID_0 = 0; + constexpr int32_t POINT_ID_1 = 1; + constexpr int32_t POINT_ID_2 = 2; const int32_t SLEEP_TIME_3 = 3; + const int32_t TAP_TIMES_1 = 1; + const int32_t TAP_TIMES_2 = 2; + const int32_t TAP_TIMES_3 = 3; + const int64_t TAP_TIME_INTERVAL = 100000; } // namespace class AamsTouchGuideTest : public testing::Test { @@ -59,6 +65,16 @@ public: bool OnPointerEventOnePointsTest7(std::vector &points, MMI::PointerEvent::PointerItem point1, MMI::PointerEvent::PointerItem point2, MMI::PointerEvent::PointerItem point3); + bool TwoFingerTapEventProduce(std::vector &points, + MMI::PointerEvent::PointerItem point1, MMI::PointerEvent::PointerItem point2, int32_t tapTimes, + bool holdFlag); + bool TwoFingerMoveEventProduce(std::vector &points, + MMI::PointerEvent::PointerItem point1, MMI::PointerEvent::PointerItem point2, + MMI::PointerEvent::PointerItem point3, MMI::PointerEvent::PointerItem point4); + bool OneFingerTapAndTwoFingerTapEventProduce(std::vector &points, + MMI::PointerEvent::PointerItem point1, MMI::PointerEvent::PointerItem point2, bool isSeparateFlag); + bool TwoFingerTapAndOneFingerTapEventProduce(std::vector &points, + MMI::PointerEvent::PointerItem point1, MMI::PointerEvent::PointerItem point2); void SetUp(); void TearDown(); @@ -76,8 +92,8 @@ protected: }; bool AamsTouchGuideTest::OnPointerEventOnePointsTest1(std::vector &points, - MMI::PointerEvent::PointerItem point1, MMI::PointerEvent::PointerItem point2, MMI::PointerEvent::PointerItem point3, - MMI::PointerEvent::PointerItem point4) + MMI::PointerEvent::PointerItem point1, MMI::PointerEvent::PointerItem point2, + MMI::PointerEvent::PointerItem point3, MMI::PointerEvent::PointerItem point4) { points.emplace_back(point1); std::shared_ptr event = @@ -114,8 +130,8 @@ bool AamsTouchGuideTest::OnPointerEventOnePointsTest1(std::vector &point, - MMI::PointerEvent::PointerItem point1, MMI::PointerEvent::PointerItem point2, MMI::PointerEvent::PointerItem point3, - MMI::PointerEvent::PointerItem point4) + MMI::PointerEvent::PointerItem point1, MMI::PointerEvent::PointerItem point2, + MMI::PointerEvent::PointerItem point3, MMI::PointerEvent::PointerItem point4) { point.emplace_back(point1); std::shared_ptr event = @@ -148,7 +164,8 @@ bool AamsTouchGuideTest::OnPointerEventOnePointsTest3(std::vector &points, - MMI::PointerEvent::PointerItem point1, MMI::PointerEvent::PointerItem point2, MMI::PointerEvent::PointerItem point3) + MMI::PointerEvent::PointerItem point1, MMI::PointerEvent::PointerItem point2, + MMI::PointerEvent::PointerItem point3) { points.emplace_back(point1); std::shared_ptr event = @@ -174,6 +191,176 @@ bool AamsTouchGuideTest::OnPointerEventOnePointsTest7(std::vector &points, + MMI::PointerEvent::PointerItem point1, MMI::PointerEvent::PointerItem point2, int32_t tapTimes, bool holdFlag) +{ + auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer(); + if (!inputEventConsumer) { + GTEST_LOG_(INFO) << "AamsTouchGuideTest TwoFingerTapEventProduce inputEventConsumer is null"; + return false; + } + + std::shared_ptr event; + int64_t occurredTime = 0; + for (int32_t tapIndex = 1; tapIndex <= tapTimes; tapIndex++) { + points.clear(); + points.emplace_back(point1); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, occurredTime, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + points.emplace_back(point2); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, occurredTime, 0, POINT_ID_1); + inputEventConsumer->OnInputEvent(event); + + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 0, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + if (holdFlag && tapIndex == tapTimes) { + sleep(1); + } + + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 0, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + points.clear(); + points.emplace_back(point2); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 0, 0, POINT_ID_1); + inputEventConsumer->OnInputEvent(event); + + occurredTime += TAP_TIME_INTERVAL; + } + return true; +} + +bool AamsTouchGuideTest::TwoFingerMoveEventProduce(std::vector &points, + MMI::PointerEvent::PointerItem point1, MMI::PointerEvent::PointerItem point2, + MMI::PointerEvent::PointerItem point3, MMI::PointerEvent::PointerItem point4) +{ + auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer(); + if (!inputEventConsumer) { + GTEST_LOG_(INFO) << "AamsTouchGuideTest TwoFingerMoveEventProduce inputEventConsumer is null"; + return false; + } + + std::shared_ptr event; + points.clear(); + points.emplace_back(point1); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 0, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + points.emplace_back(point2); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 0, 0, POINT_ID_1); + inputEventConsumer->OnInputEvent(event); + + points.clear(); + points.emplace_back(point3); + points.emplace_back(point4); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 0, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 0, 0, POINT_ID_1); + inputEventConsumer->OnInputEvent(event); + + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 0, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + points.clear(); + points.emplace_back(point4); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 0, 0, POINT_ID_1); + inputEventConsumer->OnInputEvent(event); + + return true; +} + +bool AamsTouchGuideTest::OneFingerTapAndTwoFingerTapEventProduce(std::vector &points, + MMI::PointerEvent::PointerItem point1, MMI::PointerEvent::PointerItem point2, bool isSeparateFlag) +{ + auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer(); + if (!inputEventConsumer) { + GTEST_LOG_(INFO) << "AamsTouchGuideTest OneFingerTapAndTwoFingerTapEventProduce inputEventConsumer is null"; + return false; + } + + std::shared_ptr event; + // one finger event start + points.clear(); + points.emplace_back(point1); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 0, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 0, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + if (isSeparateFlag) { + sleep(1); + } + // two finger event start + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, TAP_TIME_INTERVAL, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + points.emplace_back(point2); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, TAP_TIME_INTERVAL, 0, POINT_ID_1); + inputEventConsumer->OnInputEvent(event); + + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 0, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 0, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + points.clear(); + points.emplace_back(point2); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 0, 0, POINT_ID_1); + inputEventConsumer->OnInputEvent(event); + + return true; +} + +bool AamsTouchGuideTest::TwoFingerTapAndOneFingerTapEventProduce(std::vector &points, + MMI::PointerEvent::PointerItem point1, MMI::PointerEvent::PointerItem point2) +{ + auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer(); + if (!inputEventConsumer) { + GTEST_LOG_(INFO) << "AamsTouchGuideTest TwoFingerTapAndOneFingerTapEventProduce inputEventConsumer is null"; + return false; + } + + std::shared_ptr event; + // two finger event start + points.clear(); + points.emplace_back(point1); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 0, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + points.emplace_back(point2); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 0, 0, POINT_ID_1); + inputEventConsumer->OnInputEvent(event); + + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 0, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 0, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + points.clear(); + points.emplace_back(point2); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 0, 0, POINT_ID_1); + + // one finger event start + points.clear(); + points.emplace_back(point1); + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, TAP_TIME_INTERVAL, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 0, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, 0, 0, POINT_ID_0); + inputEventConsumer->OnInputEvent(event); + + return true; +} + void AamsTouchGuideTest::TouchGuiderPointSet(MMI::PointerEvent::PointerItem &point, int id, int x, int y) { point.SetPointerId(id); @@ -333,7 +520,9 @@ HWTEST_F(AamsTouchGuideTest, AamsTouchGuideTest_Moduletest_OnPointerEvent001, Te } bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { - if (AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(1) == + int32_t eventTypeSize = + static_cast(AccessibilityHelper::GetInstance().GetEventType().size()); + if (AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(eventTypeSize - 1) == EventType::TYPE_TOUCH_END) { return true; } else { @@ -344,7 +533,7 @@ HWTEST_F(AamsTouchGuideTest, AamsTouchGuideTest_Moduletest_OnPointerEvent001, Te EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(0), EventType::TYPE_TOUCH_BEGIN); ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { - if (MMI::MockInputManager::GetTouchActionOfTargetIndex(2) == MMI::PointerEvent::POINTER_ACTION_UP) { + if (MMI::MockInputManager::GetTouchActionOfTargetIndex(3) == MMI::PointerEvent::POINTER_ACTION_UP) { return true; } else { return false; @@ -353,6 +542,7 @@ HWTEST_F(AamsTouchGuideTest, AamsTouchGuideTest_Moduletest_OnPointerEvent001, Te EXPECT_TRUE(ret); EXPECT_EQ(MMI::MockInputManager::GetTouchActionOfTargetIndex(0), MMI::PointerEvent::POINTER_ACTION_DOWN); EXPECT_EQ(MMI::MockInputManager::GetTouchActionOfTargetIndex(1), MMI::PointerEvent::POINTER_ACTION_MOVE); + EXPECT_EQ(MMI::MockInputManager::GetTouchActionOfTargetIndex(2), MMI::PointerEvent::POINTER_ACTION_MOVE); GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent001 ENDs"; } @@ -845,5 +1035,464 @@ HWTEST_F(AamsTouchGuideTest, AamsTouchGuideTest_Moduletest_OnPointerEvent010, Te GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent010 ends"; } + +/** + * @tc.number: OnPointerEvent011 + * @tc.name:OnPointerEvent + * @tc.desc: Check the two finger tap event. + */ +HWTEST_F(AamsTouchGuideTest, AamsTouchGuideTest_Moduletest_OnPointerEvent011, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent011 starts"; + + AccessibilityHelper::GetInstance().GetEventType() = {}; + MMI::MockInputManager::ClearTouchActions(); + std::vector points = {}; + MMI::PointerEvent::PointerItem point1 = {}; + TouchGuiderPointSet(point1, 0, 100, 100); + MMI::PointerEvent::PointerItem point2 = {}; + TouchGuiderPointSet(point2, 1, 200, 100); + + bool eventProduceRst = TwoFingerTapEventProduce(points, point1, point2, TAP_TIMES_1, false); + if (!eventProduceRst) { + GTEST_LOG_(INFO) << "AamsTouchGuideTest OnPointerEvent0011 inputEventConsumer is null"; + return; + } + + // eventType + bool retOnPointerEvent11 = + AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { + if (AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) == + EventType::TYPE_TOUCH_END) { + return true; + } else { + return false; + } + }), SLEEP_TIME_3); + EXPECT_TRUE(retOnPointerEvent11); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(0), + EventType::TYPE_TOUCH_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(1), + EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(2), + EventType::TYPE_TOUCH_GUIDE_GESTURE_END); + + // gestureId + EXPECT_EQ(AccessibilityHelper::GetInstance().GetGestureId(), + static_cast(GestureType::GESTURE_TWO_FINGER_SINGLE_TAP)); + + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent011 ends"; +} + +/** + * @tc.number: OnPointerEvent012 + * @tc.name:OnPointerEvent + * @tc.desc: Check the two finger double tap event. + */ +HWTEST_F(AamsTouchGuideTest, AamsTouchGuideTest_Moduletest_OnPointerEvent012, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent012 starts"; + + AccessibilityHelper::GetInstance().GetEventType() = {}; + MMI::MockInputManager::ClearTouchActions(); + + std::vector points = {}; + MMI::PointerEvent::PointerItem point1 = {}; + TouchGuiderPointSet(point1, 0, 100, 100); + MMI::PointerEvent::PointerItem point2 = {}; + TouchGuiderPointSet(point2, 1, 200, 100); + + bool eventProduceRst = TwoFingerTapEventProduce(points, point1, point2, TAP_TIMES_2, false); + if (!eventProduceRst) { + GTEST_LOG_(INFO) << "AamsTouchGuideTest OnPointerEvent0011 inputEventConsumer is null"; + return; + } + + // eventType + bool retOnPointerEvent12 = + AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { + if (AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) == + EventType::TYPE_TOUCH_END) { + return true; + } else { + return false; + } + }), SLEEP_TIME_3); + EXPECT_TRUE(retOnPointerEvent12); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(0), + EventType::TYPE_TOUCH_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(1), + EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(2), + EventType::TYPE_TOUCH_GUIDE_GESTURE_END); + + // gestureId + EXPECT_EQ(AccessibilityHelper::GetInstance().GetGestureId(), + static_cast(GestureType::GESTURE_TWO_FINGER_DOUBLE_TAP)); + + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent012 ends"; +} + +/** + * @tc.number: OnPointerEvent013 + * @tc.name:OnPointerEvent + * @tc.desc: Check the two finger triple tap event. + */ +HWTEST_F(AamsTouchGuideTest, AamsTouchGuideTest_Moduletest_OnPointerEvent013, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent013 starts"; + + AccessibilityHelper::GetInstance().GetEventType() = {}; + MMI::MockInputManager::ClearTouchActions(); + + std::vector points = {}; + MMI::PointerEvent::PointerItem point1 = {}; + TouchGuiderPointSet(point1, 0, 100, 100); + MMI::PointerEvent::PointerItem point2 = {}; + TouchGuiderPointSet(point2, 1, 200, 100); + + bool eventProduceRst = TwoFingerTapEventProduce(points, point1, point2, TAP_TIMES_3, false); + if (!eventProduceRst) { + GTEST_LOG_(INFO) << "AamsTouchGuideTest OnPointerEvent0011 inputEventConsumer is null"; + return; + } + + // eventType + bool retOnPointerEvent13 = + AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { + if (AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) == + EventType::TYPE_TOUCH_END) { + return true; + } else { + return false; + } + }), SLEEP_TIME_3); + EXPECT_TRUE(retOnPointerEvent13); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(0), + EventType::TYPE_TOUCH_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(1), + EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(2), + EventType::TYPE_TOUCH_GUIDE_GESTURE_END); + + // gestureId + EXPECT_EQ(AccessibilityHelper::GetInstance().GetGestureId(), + static_cast(GestureType::GESTURE_TWO_FINGER_TRIPLE_TAP)); + + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent013 ends"; +} + +/** + * @tc.number: OnPointerEvent014 + * @tc.name:OnPointerEvent + * @tc.desc: Check the two finger double tap and hold event. + */ +HWTEST_F(AamsTouchGuideTest, AamsTouchGuideTest_Moduletest_OnPointerEvent014, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent014 starts"; + + AccessibilityHelper::GetInstance().GetEventType() = {}; + MMI::MockInputManager::ClearTouchActions(); + + std::vector points = {}; + MMI::PointerEvent::PointerItem point1 = {}; + TouchGuiderPointSet(point1, 0, 100, 100); + MMI::PointerEvent::PointerItem point2 = {}; + TouchGuiderPointSet(point2, 1, 200, 100); + + bool eventProduceRst = TwoFingerTapEventProduce(points, point1, point2, TAP_TIMES_2, true); + if (!eventProduceRst) { + GTEST_LOG_(INFO) << "AamsTouchGuideTest OnPointerEvent0014 inputEventConsumer is null"; + return; + } + + // eventType + bool retOnPointerEvent14 = + AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { + if (AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) == + EventType::TYPE_TOUCH_END) { + return true; + } else { + return false; + } + }), SLEEP_TIME_3); + EXPECT_TRUE(retOnPointerEvent14); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(0), + EventType::TYPE_TOUCH_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(1), + EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(2), + EventType::TYPE_TOUCH_GUIDE_GESTURE_END); + + // gestureId + EXPECT_EQ(AccessibilityHelper::GetInstance().GetGestureId(), + static_cast(GestureType::GESTURE_TWO_FINGER_DOUBLE_TAP_AND_HOLD)); + + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent014 ends"; +} + +/** + * @tc.number: OnPointerEvent015 + * @tc.name:OnPointerEvent + * @tc.desc: Check the two finger triple tap and hold event. + */ +HWTEST_F(AamsTouchGuideTest, AamsTouchGuideTest_Moduletest_OnPointerEvent015, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent015 starts"; + + AccessibilityHelper::GetInstance().GetEventType() = {}; + MMI::MockInputManager::ClearTouchActions(); + + std::vector points = {}; + MMI::PointerEvent::PointerItem point1 = {}; + TouchGuiderPointSet(point1, 0, 100, 100); + MMI::PointerEvent::PointerItem point2 = {}; + TouchGuiderPointSet(point2, 1, 200, 100); + + bool eventProduceRst = TwoFingerTapEventProduce(points, point1, point2, TAP_TIMES_3, true); + if (!eventProduceRst) { + GTEST_LOG_(INFO) << "AamsTouchGuideTest OnPointerEvent0015 inputEventConsumer is null"; + return; + } + + // eventType + bool retOnPointerEvent15 = + AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { + if (AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) == + EventType::TYPE_TOUCH_END) { + return true; + } else { + return false; + } + }), SLEEP_TIME_3); + EXPECT_TRUE(retOnPointerEvent15); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(0), + EventType::TYPE_TOUCH_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(1), + EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(2), + EventType::TYPE_TOUCH_GUIDE_GESTURE_END); + + // gestureId + EXPECT_EQ(AccessibilityHelper::GetInstance().GetGestureId(), + static_cast(GestureType::GESTURE_TWO_FINGER_TRIPLE_TAP_AND_HOLD)); + + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent015 ends"; +} + +/** + * @tc.number: OnPointerEvent016 + * @tc.name:OnPointerEvent + * @tc.desc: Check the two finger move event. + */ +HWTEST_F(AamsTouchGuideTest, AamsTouchGuideTest_Moduletest_OnPointerEvent016, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent016 starts"; + + AccessibilityHelper::GetInstance().GetEventType() = {}; + MMI::MockInputManager::ClearTouchActions(); + + std::vector points = {}; + MMI::PointerEvent::PointerItem point1 = {}; + TouchGuiderPointSet(point1, 0, 100, 100); + MMI::PointerEvent::PointerItem point2 = {}; + TouchGuiderPointSet(point2, 1, 200, 100); + MMI::PointerEvent::PointerItem point3 = {}; + TouchGuiderPointSet(point3, 0, 100, 400); + MMI::PointerEvent::PointerItem point4 = {}; + TouchGuiderPointSet(point4, 1, 200, 400); + + bool eventProduceRst = TwoFingerMoveEventProduce(points, point1, point2, point3, point4); + if (!eventProduceRst) { + GTEST_LOG_(INFO) << "AamsTouchGuideTest OnPointerEvent0016 inputEventConsumer is null"; + return; + } + + // eventType + bool retOnPointerEvent15 = + AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { + if (AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) == + EventType::TYPE_TOUCH_END) { + return true; + } else { + return false; + } + }), SLEEP_TIME_3); + EXPECT_TRUE(retOnPointerEvent15); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(0), + EventType::TYPE_TOUCH_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(1), + EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(2), + EventType::TYPE_TOUCH_GUIDE_GESTURE_END); + + EXPECT_EQ(MMI::MockInputManager::GetTouchActionOfTargetIndex(0), MMI::PointerEvent::POINTER_ACTION_DOWN); + EXPECT_EQ(MMI::MockInputManager::GetTouchActionOfTargetIndex(1), MMI::PointerEvent::POINTER_ACTION_MOVE); + EXPECT_EQ(MMI::MockInputManager::GetTouchActionOfTargetIndex(2), MMI::PointerEvent::POINTER_ACTION_MOVE); + EXPECT_EQ(MMI::MockInputManager::GetTouchActionOfTargetIndex(3), MMI::PointerEvent::POINTER_ACTION_UP); + EXPECT_EQ(MMI::MockInputManager::GetTouchActionOfTargetIndex(4), MMI::PointerEvent::POINTER_ACTION_UP); + + // gestureId + EXPECT_EQ(AccessibilityHelper::GetInstance().GetGestureId(), static_cast(GestureType::GESTURE_INVALID)); + + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent016 ends"; +} + +/** + * @tc.number: OnPointerEvent017 + * @tc.name:OnPointerEvent + * @tc.desc: Check the one finger tap and then two finger tap event, expect do not recognize as any gesture. + */ +HWTEST_F(AamsTouchGuideTest, AamsTouchGuideTest_Moduletest_OnPointerEvent017, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent017 starts"; + + AccessibilityHelper::GetInstance().GetEventType() = {}; + MMI::MockInputManager::ClearTouchActions(); + + std::vector points = {}; + MMI::PointerEvent::PointerItem point1 = {}; + TouchGuiderPointSet(point1, 0, 100, 100); + MMI::PointerEvent::PointerItem point2 = {}; + TouchGuiderPointSet(point2, 1, 200, 100); + + bool eventProduceRst = OneFingerTapAndTwoFingerTapEventProduce(points, point1, point2, false); + if (!eventProduceRst) { + GTEST_LOG_(INFO) << "AamsTouchGuideTest OnPointerEvent0017 inputEventConsumer is null"; + return; + } + + // eventType + bool retOnPointerEvent15 = + AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { + if (AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(1) == + EventType::TYPE_TOUCH_END) { + return true; + } else { + return false; + } + }), SLEEP_TIME_3); + EXPECT_TRUE(retOnPointerEvent15); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(0), EventType::TYPE_TOUCH_BEGIN); + EXPECT_EQ(static_cast(AccessibilityHelper::GetInstance().GetEventType().size()), 2); + + // gestureId + EXPECT_EQ(AccessibilityHelper::GetInstance().GetGestureId(), static_cast(GestureType::GESTURE_INVALID)); + + // touch action to multimode + EXPECT_EQ(static_cast(MMI::MockInputManager::GetTouchActions().size()), 0); + + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent017 ends"; +} + +/** + * @tc.number: OnPointerEvent018 + * @tc.name:OnPointerEvent + * @tc.desc: Check the two finger tap and then one finger tap event, expect do not recognize as any gesture. + */ +HWTEST_F(AamsTouchGuideTest, AamsTouchGuideTest_Moduletest_OnPointerEvent018, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent018 starts"; + + AccessibilityHelper::GetInstance().GetEventType() = {}; + MMI::MockInputManager::ClearTouchActions(); + + std::vector points = {}; + MMI::PointerEvent::PointerItem point1 = {}; + TouchGuiderPointSet(point1, 0, 100, 100); + MMI::PointerEvent::PointerItem point2 = {}; + TouchGuiderPointSet(point2, 1, 200, 100); + + bool eventProduceRst = TwoFingerTapAndOneFingerTapEventProduce(points, point1, point2); + if (!eventProduceRst) { + GTEST_LOG_(INFO) << "AamsTouchGuideTest OnPointerEvent0018 inputEventConsumer is null"; + return; + } + + // eventType + bool retOnPointerEvent15 = + AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { + if (AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) == + EventType::TYPE_TOUCH_END) { + return true; + } else { + return false; + } + }), SLEEP_TIME_3); + EXPECT_TRUE(retOnPointerEvent15); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(0), + EventType::TYPE_TOUCH_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(1), + EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(2), + EventType::TYPE_TOUCH_GUIDE_GESTURE_END); + + // gestureId + EXPECT_EQ(AccessibilityHelper::GetInstance().GetGestureId(), static_cast(GestureType::GESTURE_INVALID)); + + // touch action to multimode + EXPECT_EQ(static_cast(MMI::MockInputManager::GetTouchActions().size()), 0); + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent018 ends"; +} + +/** + * @tc.number: OnPointerEvent019 + * @tc.name:OnPointerEvent + * @tc.desc: Check the one finger tap and then two finger tap event, interval > 300ms, expect two gesture event. + */ +HWTEST_F(AamsTouchGuideTest, AamsTouchGuideTest_Moduletest_OnPointerEvent019, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent019 starts"; + + AccessibilityHelper::GetInstance().GetEventType() = {}; + MMI::MockInputManager::ClearTouchActions(); + + std::vector points = {}; + MMI::PointerEvent::PointerItem point1 = {}; + TouchGuiderPointSet(point1, 0, 100, 100); + MMI::PointerEvent::PointerItem point2 = {}; + TouchGuiderPointSet(point2, 1, 200, 100); + + bool eventProduceRst = OneFingerTapAndTwoFingerTapEventProduce(points, point1, point2, true); + if (!eventProduceRst) { + GTEST_LOG_(INFO) << "AamsTouchGuideTest OnPointerEvent0019 inputEventConsumer is null"; + return; + } + + // eventType + bool retOnPointerEvent15 = + AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool { + if (AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(7) == + EventType::TYPE_TOUCH_END) { + return true; + } else { + return false; + } + }), SLEEP_TIME_3); + EXPECT_TRUE(retOnPointerEvent15); + EXPECT_EQ(static_cast(AccessibilityHelper::GetInstance().GetEventType().size()), 8); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(0), EventType::TYPE_TOUCH_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(1), EventType::TYPE_TOUCH_GUIDE_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(2), EventType::TYPE_TOUCH_GUIDE_END); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(3), EventType::TYPE_TOUCH_END); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(4), EventType::TYPE_TOUCH_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(5), + EventType::TYPE_TOUCH_GUIDE_GESTURE_BEGIN); + EXPECT_EQ(AccessibilityHelper::GetInstance().GetEventTypeOfTargetIndex(6), + EventType::TYPE_TOUCH_GUIDE_GESTURE_END); + + // gestureId + EXPECT_EQ(AccessibilityHelper::GetInstance().GetGestureId(), + static_cast(GestureType::GESTURE_TWO_FINGER_SINGLE_TAP)); + + // touch action to multimode + int32_t touchActionSize = static_cast(MMI::MockInputManager::GetTouchActions().size()); + for (int32_t touchActionIndex = 0; touchActionIndex < touchActionSize; touchActionIndex++) { + EXPECT_EQ(MMI::MockInputManager::GetTouchActionOfTargetIndex(touchActionIndex), + MMI::PointerEvent::POINTER_ACTION_MOVE); + } + + GTEST_LOG_(INFO) << "AamsTouchGuideTest AamsTouchGuideTest_Moduletest_OnPointerEvent019 ends"; +} } // namespace Accessibility } // namespace OHOS \ No newline at end of file -- Gitee