1 /*
2  * Copyright (c) 2022 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 #ifndef FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_GESTURES_RECOGNIZERS_RECOGNIZER_GROUP_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_GESTURES_RECOGNIZERS_RECOGNIZER_GROUP_H
18 
19 #include <list>
20 
21 #include "base/geometry/ng/size_t.h"
22 #include "base/memory/ace_type.h"
23 #include "base/memory/referenced.h"
24 #include "core/components_ng/event/touch_event.h"
25 #include "core/components_ng/gestures/gesture_info.h"
26 #include "core/components_ng/gestures/recognizers/multi_fingers_recognizer.h"
27 
28 namespace OHOS::Ace::NG {
29 
30 class ACE_EXPORT RecognizerGroup : public MultiFingersRecognizer {
31     DECLARE_ACE_TYPE(RecognizerGroup, MultiFingersRecognizer);
32 
33 public:
RecognizerGroup(const std::vector<RefPtr<NGGestureRecognizer>> & recognizers)34     explicit RecognizerGroup(const std::vector<RefPtr<NGGestureRecognizer>>& recognizers)
35     {
36         for (const auto& recognizer : recognizers) {
37             if (recognizer && recognizer->SetGestureGroup(AceType::WeakClaim(this))) {
38                 recognizers_.emplace_back(recognizer);
39             }
40         }
41     }
42 
RecognizerGroup(std::list<RefPtr<NGGestureRecognizer>> && recognizers)43     explicit RecognizerGroup(std::list<RefPtr<NGGestureRecognizer>>&& recognizers)
44     {
45         recognizers_.clear();
46         for (const auto& recognizer : recognizers) {
47             if (recognizer && recognizer->SetGestureGroup(AceType::WeakClaim(this))) {
48                 recognizers_.emplace_back(recognizer);
49             }
50         }
51     }
52 
53     ~RecognizerGroup() override = default;
54 
55     void AddChildren(const std::list<RefPtr<NGGestureRecognizer>>& recognizers);
56 
57     void OnFlushTouchEventsBegin() override;
58     void OnFlushTouchEventsEnd() override;
59     virtual RefereeState CheckStates(size_t touchId);
60     void ForceReject();
61 
RemainChildOnResetStatus()62     void RemainChildOnResetStatus()
63     {
64         remainChildOnResetStatus_ = true;
65     }
66 
SetInnerFlag(bool value)67     virtual void SetInnerFlag(bool value) override {
68         NGGestureRecognizer::SetInnerFlag(value);
69         for (auto& recognizer : recognizers_) {
70             if (recognizer) {
71                 recognizer->SetInnerFlag(value);
72             }
73         }
74     }
75 
AttachFrameNode(const WeakPtr<NG::FrameNode> & node)76     void AttachFrameNode(const WeakPtr<NG::FrameNode>& node) override
77     {
78         TouchEventTarget::AttachFrameNode(node);
79         auto recognizers = GetGroupRecognizer();
80         for (const auto& recognizer : recognizers) {
81             recognizer->AttachFrameNode(node);
82         }
83     }
84 
85     const std::list<RefPtr<NGGestureRecognizer>>& GetGroupRecognizer();
86 
GetAxisDirection()87     Axis GetAxisDirection() override
88     {
89         uint8_t horizontalFlag = 0;
90         uint8_t verticalFlag = 0;
91         uint8_t freeFlag = 0;
92         for (const auto& recognizer : recognizers_) {
93             if (!recognizer) {
94                 continue;
95             }
96             auto direction = recognizer->GetAxisDirection();
97             switch (direction) {
98                 case Axis::HORIZONTAL:
99                     horizontalFlag = 0x1;
100                     break;
101                 case Axis::VERTICAL:
102                     verticalFlag = 0x2;
103                     break;
104                 case Axis::FREE:
105                     freeFlag = 0x3;
106                     break;
107                 default:
108                     break;
109             }
110         }
111         uint8_t directionFlag = horizontalFlag | verticalFlag | freeFlag;
112         switch (directionFlag) {
113             case 0x1:
114                 return Axis::HORIZONTAL;
115             case 0x2:
116                 return Axis::VERTICAL;
117             case 0x3:
118                 return Axis::FREE;
119             default:
120                 return Axis::NONE;
121         }
122     }
123 
SetChildrenTargetComponent(const RefPtr<TargetComponent> & targetComponent)124     void SetChildrenTargetComponent(const RefPtr<TargetComponent>& targetComponent)
125     {
126         for (const auto& child : recognizers_) {
127             if (child) {
128                 child->SetTargetComponent(targetComponent);
129             }
130         }
131     }
132 
ForceCleanRecognizer()133     void ForceCleanRecognizer() override
134     {
135         for (const auto& child : recognizers_) {
136             if (child) {
137                 child->ForceCleanRecognizer();
138             }
139         }
140         touchPoints_.clear();
141         fingersId_.clear();
142         fingerList_.clear();
143         activeFingers_.clear();
144         currentFingers_ = 0;
145         refereeState_ = RefereeState::READY;
146         disposal_ = GestureDisposal::NONE;
147     }
148 
149     void CleanRecognizerState() override;
150 
SetIsPostEventResultRecursively(bool isPostEventResult)151     void SetIsPostEventResultRecursively(bool isPostEventResult)
152     {
153         for (const auto& item : recognizers_) {
154             item->SetIsPostEventResult(isPostEventResult);
155             auto group = AceType::DynamicCast<RecognizerGroup>(item);
156             if (group) {
157                 group->SetIsPostEventResultRecursively(isPostEventResult);
158             }
159         }
160     }
161 
SetResponseLinkRecognizersRecursively(const ResponseLinkResult & responseLinkResult)162     void SetResponseLinkRecognizersRecursively(const ResponseLinkResult& responseLinkResult)
163     {
164         for (const auto& item : recognizers_) {
165             auto group = AceType::DynamicCast<RecognizerGroup>(item);
166             if (group) {
167                 group->SetResponseLinkRecognizersRecursively(responseLinkResult);
168                 continue;
169             }
170             item->SetResponseLinkRecognizers(responseLinkResult);
171         }
172     }
173 
CollectResponseLinkRecognizersRecursively(ResponseLinkResult & responseLinkResult)174     void CollectResponseLinkRecognizersRecursively(ResponseLinkResult& responseLinkResult)
175     {
176         for (const auto& item : recognizers_) {
177             auto group = AceType::DynamicCast<RecognizerGroup>(item);
178             if (group) {
179                 group->CollectResponseLinkRecognizersRecursively(responseLinkResult);
180                 continue;
181             }
182             auto recognizer = AceType::DynamicCast<NG::NGGestureRecognizer>(item);
183             if (recognizer) {
184                 responseLinkResult.emplace_back(recognizer);
185             }
186         }
187     }
188 
189     RefPtr<Gesture> CreateGestureFromRecognizer() const override;
190     virtual GestureMode GetGestureMode() const = 0;
191 
192     void SetRecognizerInfoRecursively(const Offset& coordinateOffset, const RefPtr<NG::FrameNode>& node,
193         const RefPtr<NG::TargetComponent>& targetComponent, const GetEventTargetImpl& getEventTargetImpl);
194 
195     void AddHittedRecognizerType(std::map<std::string, std::list<TouchTestResultInfo>>& hittedRecognizerInfo);
196 
197     bool IsReady() override;
198 
CheckGroupState()199     virtual bool CheckGroupState()
200     {
201         return false;
202     }
203 
204 protected:
205     void OnBeginGestureReferee(int32_t touchId, bool needUpdateChild = false) override;
206     void OnFinishGestureReferee(int32_t touchId, bool isBlocked = false) override;
207     void GroupAdjudicate(const RefPtr<NGGestureRecognizer>& recognizer, GestureDisposal disposal);
208 
209     bool Existed(const RefPtr<NGGestureRecognizer>& recognizer);
210     bool CheckAllFailed();
211 
212     void OnResetStatus() override;
213 
214     std::list<RefPtr<NGGestureRecognizer>> recognizers_;
215     bool remainChildOnResetStatus_ = false;
216 };
217 
218 } // namespace OHOS::Ace::NG
219 
220 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_GESTURES_RECOGNIZERS_RECOGNIZER_GROUP_H
221