1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_MANAGER_FOCUS_FOCUS_MANAGER_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_MANAGER_FOCUS_FOCUS_MANAGER_H
18 
19 #include <list>
20 #include <optional>
21 
22 #include "base/memory/ace_type.h"
23 #include "base/memory/referenced.h"
24 #include "core/components_ng/manager/focus/focus_view.h"
25 
26 namespace OHOS::Ace::NG {
27 
28 class PipelineContext;
29 
30 using FocusViewMap = std::unordered_map<int32_t, std::pair<WeakPtr<FocusView>, std::list<WeakPtr<FocusView>>>>;
31 using RequestFocusCallback = std::function<void(NG::RequestFocusResult result)>;
32 using FocusHubScopeMap = std::unordered_map<std::string, std::pair<WeakPtr<FocusHub>, std::list<WeakPtr<FocusHub>>>>;
33 using FocusChangeCallback = std::function<void(const WeakPtr<FocusHub>& last,
34     const RefPtr<FocusHub>& current, FocusReason focusReason)>;
35 
36 enum class FocusViewStackState : int32_t {
37     IDLE = 0,
38     SHOW = 1,
39     CLOSE = 2,
40 };
41 
42 enum class FocusActiveReason : int32_t {
43     POINTER_EVENT = 0,
44     KEYBOARD_EVENT = 1,
45     USE_API = 2,
46 };
47 
48 class FocusManager : public virtual AceType {
49     DECLARE_ACE_TYPE(FocusManager, AceType);
50 
51 public:
52     class FocusGuard {
53     public:
54         explicit FocusGuard(const RefPtr<FocusHub>& focushub, SwitchingStartReason reason);
55         FocusGuard() = delete;
56         ~FocusGuard();
57         void CreateFocusGuard(const RefPtr<FocusHub>& focushub, const RefPtr<FocusManager>& focusManager,
58             SwitchingStartReason reason);
59     private:
60         RefPtr<FocusManager> focusMng_;
61     };
62     friend FocusGuard;
63 
64     explicit FocusManager(const RefPtr<PipelineContext>& pipeline);
65     ~FocusManager() override = default;
66 
67     void FocusViewShow(const RefPtr<FocusView>& focusView, bool isTriggerByStep = false);
68     void FocusViewHide(const RefPtr<FocusView>& focusView);
69     void FocusViewClose(const RefPtr<FocusView>& focusView, bool isDetachFromTree = false);
70 
71     void FlushFocusView();
72 
73     void DumpFocusManager();
74 
GetLastFocusView()75     WeakPtr<FocusView> GetLastFocusView() const
76     {
77         return lastFocusView_;
78     }
79 
GetWeakFocusViewList()80     const std::list<WeakPtr<FocusView>>& GetWeakFocusViewList() const
81     {
82         return focusViewStack_;
83     }
84 
SetRequestFocusCallback(const RequestFocusCallback & callback)85     void SetRequestFocusCallback(const RequestFocusCallback& callback)
86     {
87         requestCallback_ = std::move(callback);
88     }
89 
ResetRequestFocusCallback()90     void ResetRequestFocusCallback()
91     {
92         requestCallback_ = nullptr;
93     }
94 
TriggerRequestFocusCallback(NG::RequestFocusResult result)95     void TriggerRequestFocusCallback(NG::RequestFocusResult result)
96     {
97         if (requestCallback_) {
98             requestCallback_(result);
99             requestCallback_ = nullptr;
100         }
101     }
102 
SetLastFocusStateNode(const RefPtr<FocusHub> & node)103     void SetLastFocusStateNode(const RefPtr<FocusHub>& node)
104     {
105         lastFocusStateNode_ = AceType::WeakClaim(AceType::RawPtr(node));
106         isNeedTriggerScroll_ = true;
107     }
GetLastFocusStateNode()108     RefPtr<FocusHub> GetLastFocusStateNode() const
109     {
110         return lastFocusStateNode_.Upgrade();
111     }
112 
SetNeedTriggerScroll(bool isNeedTriggerScroll)113     void SetNeedTriggerScroll(bool isNeedTriggerScroll)
114     {
115         isNeedTriggerScroll_ = isNeedTriggerScroll;
116     }
GetNeedTriggerScroll()117     bool GetNeedTriggerScroll() const
118     {
119         return isNeedTriggerScroll_;
120     }
121 
SetIsAutoFocusTransfer(bool isAutoFocusTransfer)122     void SetIsAutoFocusTransfer(bool isAutoFocusTransfer)
123     {
124         isAutoFocusTransfer_ = isAutoFocusTransfer;
125     }
126 
IsAutoFocusTransfer()127     bool IsAutoFocusTransfer() const
128     {
129         return isAutoFocusTransfer_;
130     }
131 
132     bool RearrangeViewStack();
133 
SetFocusViewStackState(FocusViewStackState focusViewStackState)134     void SetFocusViewStackState(FocusViewStackState focusViewStackState)
135     {
136         focusViewStackState_ = focusViewStackState;
137     }
138 
139     bool SetFocusViewRootScope(const RefPtr<FocusView>& focusView);
140 
141     void PaintFocusState();
142 
143     bool AddFocusScope(const std::string& focusScopeId, const RefPtr<FocusHub>& scopeFocusHub);
144     void RemoveFocusScope(const std::string& focusScopeId);
145     void AddScopePriorityNode(const std::string& focusScopeId, const RefPtr<FocusHub>& priorFocusHub, bool pushFront);
146     void RemoveScopePriorityNode(const std::string& focusScopeId, const RefPtr<FocusHub>& priorFocusHub);
147     std::optional<std::list<WeakPtr<FocusHub>>*> GetFocusScopePriorityList(const std::string& focusScopeId);
148 
149     void UpdateCurrentFocus(const RefPtr<FocusHub>& current, SwitchingUpdateReason reason);
150     RefPtr<FocusHub> GetCurrentFocus();
UpdateSwitchingEndReason(SwitchingEndReason reason)151     void UpdateSwitchingEndReason(SwitchingEndReason reason)
152     {
153         if (isSwitchingFocus_.value_or(false)) {
154             endReason_ = reason;
155         }
156     }
157     int32_t AddFocusListener(FocusChangeCallback&& callback);
158     void RemoveFocusListener(int32_t id);
159     void FocusSwitchingStart(const RefPtr<FocusHub>& focusHub, SwitchingStartReason reason);
160     void FocusSwitchingEnd(SwitchingEndReason reason = SwitchingEndReason::FOCUS_GUARD_DESTROY);
161     void WindowFocusMoveStart();
162     void WindowFocusMoveEnd();
163     void WindowFocus(bool isFocus);
164 
165     static RefPtr<FocusManager> GetFocusManager(RefPtr<FrameNode>& node);
166 
167 private:
168     void GetFocusViewMap(FocusViewMap& focusViewMap);
169     void ReportFocusSwitching(FocusReason focusReason);
170 
171     std::list<WeakPtr<FocusView>> focusViewStack_;
172     WeakPtr<FocusView> lastFocusView_;
173     const WeakPtr<PipelineContext> pipeline_;
174 
175     RequestFocusCallback requestCallback_;
176 
177     WeakPtr<FocusHub> lastFocusStateNode_;
178     WeakPtr<FocusHub> currentFocus_;
179     bool isNeedTriggerScroll_ = false;
180     FocusHubScopeMap focusHubScopeMap_;
181 
182     std::map<int32_t, FocusChangeCallback> listeners_;
183     int32_t nextListenerHdl_ = -1;
184     std::optional<bool> isSwitchingFocus_;
185     bool isSwitchingWindow_ = false;
186     RefPtr<FocusHub> switchingFocus_;
187 
188     std::optional<SwitchingStartReason> startReason_;
189     std::optional<SwitchingEndReason> endReason_;
190     std::optional<SwitchingUpdateReason> updateReason_;
191 
192     bool isAutoFocusTransfer_ = true;
193     FocusViewStackState focusViewStackState_ = FocusViewStackState::IDLE;
194 
195     ACE_DISALLOW_COPY_AND_MOVE(FocusManager);
196 };
197 } // namespace OHOS::Ace::NG
198 
199 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_MANAGER_FOCUS_FOCUS_MANAGER_H
200