1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef OHOS_ROSEN_WINDOW_MANAGER_LITE_H
17 #define OHOS_ROSEN_WINDOW_MANAGER_LITE_H
18 
19 #include <iremote_object.h>
20 #include <memory>
21 #include <mutex>
22 #include <refbase.h>
23 #include <vector>
24 #include "focus_change_info.h"
25 #include "window_drawing_content_info.h"
26 #include "window_manager.h"
27 #include "window_visibility_info.h"
28 #include "wm_common.h"
29 #include "wm_single_instance.h"
30 
31 namespace OHOS {
32 namespace Rosen {
33 /**
34  * @class WindowManagerLite
35  *
36  * @brief WindowManagerLite used to manage window.
37  */
38 class WindowManagerLite {
39 WM_DECLARE_SINGLE_INSTANCE_BASE(WindowManagerLite);
40 friend class WindowManagerAgentLite;
41 friend class WMSDeathRecipient;
42 friend class SSMDeathRecipient;
43 public:
44     /**
45      * @brief Register focus changed listener.
46      *
47      * @param listener IFocusChangedListener.
48      * @return WM_OK means register success, others means register failed.
49      */
50     WMError RegisterFocusChangedListener(const sptr<IFocusChangedListener>& listener);
51     /**
52      * @brief Unregister focus changed listener.
53      *
54      * @param listener IFocusChangedListener.
55      * @return WM_OK means unregister success, others means unregister failed.
56      */
57     WMError UnregisterFocusChangedListener(const sptr<IFocusChangedListener>& listener);
58     /**
59      * @brief Register visibility changed listener.
60      *
61      * @param listener IVisibilityChangedListener.
62      * @return WM_OK means register success, others means register failed.
63      */
64     WMError RegisterVisibilityChangedListener(const sptr<IVisibilityChangedListener>& listener);
65     /**
66      * @brief Unregister visibility changed listener.
67      *
68      * @param listener IVisibilityChangedListener.
69      * @return WM_OK means unregister success, others means unregister failed.
70      */
71     WMError UnregisterVisibilityChangedListener(const sptr<IVisibilityChangedListener>& listener);
72     /**
73      * @brief Get visibility window info.
74      *
75      * @param infos Visible window infos
76      * @return WM_OK means get success, others means get failed.
77      */
78     WMError GetVisibilityWindowInfo(std::vector<sptr<WindowVisibilityInfo>>& infos) const;
79     /**
80      * @brief Get focus window.
81      *
82      * @param focusInfo Focus window info.
83      * @return FocusChangeInfo object about focus window.
84      */
85     void GetFocusWindowInfo(FocusChangeInfo& focusInfo);
86     /**
87     * @brief Register drawingcontent changed listener.
88     *
89     * @param listener IDrawingContentChangedListener.
90     * @return WM_OK means register success, others means register failed.
91     */
92     WMError RegisterDrawingContentChangedListener(const sptr<IDrawingContentChangedListener>& listener);
93 
94     /**
95      * @brief Unregister drawingcontent changed listener.
96      *
97      * @param listener IDrawingContentChangedListener.
98      * @return WM_OK means unregister success, others means unregister failed.
99      */
100     WMError UnregisterDrawingContentChangedListener(const sptr<IDrawingContentChangedListener>& listener);
101     /**
102      * @brief Register window mode listener.
103      *
104      * @param listener IWindowModeChangedListener.
105      * @return WM_OK means register success, others means register failed.
106      */
107     WMError RegisterWindowModeChangedListener(const sptr<IWindowModeChangedListener>& listener);
108     /**
109      * @brief Unregister window mode listener.
110      *
111      * @param listener IWindowModeChangedListener.
112      * @return WM_OK means unregister success, others means unregister failed.
113      */
114     WMError UnregisterWindowModeChangedListener(const sptr<IWindowModeChangedListener>& listener);
115     /**
116      * @brief Get window mode type.
117      *
118      * @param void
119      * @return WM_OK means get success, others means get failed.
120      */
121     WMError GetWindowModeType(WindowModeType& windowModeType) const;
122 
123     /**
124     * @brief Register camera window changed listener.
125     *
126     * @param listener ICameraWindowChangedListener.
127     * @return WM_OK means register success, others means register failed.
128     */
129     WMError RegisterCameraWindowChangedListener(const sptr<ICameraWindowChangedListener>& listener);
130 
131     /**
132    * @brief Unregister camera window changed listener.
133    *
134    * @param listener ICameraWindowChangedListener.
135    * @return WM_OK means unregister success, others means unregister failed.
136    */
137     WMError UnregisterCameraWindowChangedListener(const sptr<ICameraWindowChangedListener>& listener);
138     /**
139      * @brief raise window to top by windowId
140      *
141      * @param persistentId this window to raise
142      * @return WM_OK if raise success
143      */
144     WMError RaiseWindowToTop(int32_t persistentId);
145     /**
146      * @brief Get top num main window info.
147      *
148      * @param topNum the num of top window
149      * @param topNInfo the top num window infos
150      * @return WM_OK means get success, others means get failed.
151      */
152     WMError GetMainWindowInfos(int32_t topNum, std::vector<MainWindowInfo>& topNInfo);
153 
154     /**
155      * @brief Register WMS connection status changed listener.
156      * @attention Callable only by u0 system user. A process only supports successful registration once.
157      * When the foundation service restarts, you need to re-register the listener.
158      * If you want to re-register, please call UnregisterWMSConnectionChangedListener first.
159      *
160      * @param listener IWMSConnectionChangedListener.
161      * @return WM_OK means register success, others means register failed.
162      */
163     WMError RegisterWMSConnectionChangedListener(const sptr<IWMSConnectionChangedListener>& listener);
164 
165     /**
166      * @brief Unregister WMS connection status changed listener.
167      * @attention Callable only by u0 system user.
168      *
169      * @return WM_OK means unregister success, others means unregister failed.
170      */
171     WMError UnregisterWMSConnectionChangedListener();
172 
173     /**
174      * @brief Get all main window info.
175      *
176      * @param infos the all main window info.
177      * @return WM_OK means get success, others means get failed.
178      */
179     WMError GetAllMainWindowInfos(std::vector<MainWindowInfo>& infos) const;
180 
181     /**
182      * @brief Clear a specified set of sessions.
183      *
184      * @param persistentIds a vector of session persistentId.
185      * @return WM_OK means clear session success, others means clear failed.
186      */
187     WMError ClearMainSessions(const std::vector<int32_t>& persistentIds);
188 
189     /**
190      * @brief Clear a specified set of sessions.
191      *
192      * @param persistentIds a vector of session persistentId.
193      * @param clearFailedIds a vector of session persistentId which is clear failed.
194      * @return WM_OK means clear session success, others means clear failed.
195      */
196     WMError ClearMainSessions(const std::vector<int32_t>& persistentIds, std::vector<int32_t>& clearFailedIds);
197 
198     /**
199      * @brief Register WindowStyle changed listener.
200      *
201      * @param listener IWindowStyleChangedListener
202      * @return WM_OK means register success, others means unregister failed.
203      */
204     WMError RegisterWindowStyleChangedListener(const sptr<IWindowStyleChangedListener>& listener);
205 
206     /**
207     * @brief Unregister WindowStyle changed listener.
208     *
209     * @param listener IWindowStyleChangedListener
210     * @return WM_OK means unregister success, others means unregister failed.
211     */
212     WMError UnregisterWindowStyleChangedListener(const sptr<IWindowStyleChangedListener>& listener);
213 
214     /**
215      * @brief Get window style type.
216      *
217      * @param windowStyleType WindowType
218      * @return @return WM_OK means get window style success, others means failed.
219      */
220     WindowStyleType GetWindowStyleType();
221 
222     /**
223      * @brief Terminate session by persistentId and start caller.
224      * @persistentId persistentId to be terminated.
225      *
226      * @return WM_OK means Terminate success, others means Terminate failed.
227      */
228     WMError TerminateSessionByPersistentId(int32_t persistentId);
229 
230     /**
231      * @brief Get accessibility window info.
232      *
233      * @param infos WindowInfos used for Accessibility.
234      * @return WM_OK means get success, others means get failed.
235      */
236     WMError GetAccessibilityWindowInfo(std::vector<sptr<AccessibilityWindowInfo>>& infos) const;
237 
238     /**
239      * @brief Register window updated listener.
240      *
241      * @param listener IWindowUpdateListener.
242      * @return WM_OK means register success, others means register failed.
243      */
244     WMError RegisterWindowUpdateListener(const sptr<IWindowUpdateListener>& listener);
245 
246     /**
247      * @brief Unregister window updated listener.
248      *
249      * @param listener IWindowUpdateListener.
250      * @return WM_OK means unregister success, others means unregister failed.
251      */
252     WMError UnregisterWindowUpdateListener(const sptr<IWindowUpdateListener>& listener);
253 
254     /**
255      * @brief Close target float window.
256      *
257      * @param bundleName the target float window need to be closed.
258      * @return WM_OK means Close success, others means Close failed.
259      */
260     WMError CloseTargetFloatWindow(const std::string& bundleName);
261 
262     /**
263      * @brief Register listener for PiP window state changed.
264      *
265      * @param listener the PiP state changed listener.
266      * @return WM_OK means Register success, others means Register failed.
267      */
268     WMError RegisterPiPStateChangedListener(const sptr<IPiPStateChangedListener>& listener);
269 
270     /**
271      * @brief Unregister listener for PiP window state changed.
272      *
273      * @param listener the PiP state changed listener.
274      * @return WM_OK means Unregister success, others means Unregister failed.
275      */
276     WMError UnregisterPiPStateChangedListener(const sptr<IPiPStateChangedListener>& listener);
277 
278     /**
279      * @brief Close target PiP Window by bundleName.
280      *
281      * @param bundleName the target PiP Window need to be closed.
282      * @return WM_OK means Close success, others means Close failed.
283      */
284     WMError CloseTargetPiPWindow(const std::string& bundleName);
285 
286     /**
287      * @brief Get current show PiP Window info.
288      *
289      * @param bundleName the current PiP window bundleName.
290      * @return WM_OK means Get success, others means Get failed.
291      */
292     WMError GetCurrentPiPWindowInfo(std::string& bundleName);
293 
294 private:
295     WindowManagerLite();
296     ~WindowManagerLite();
297     std::recursive_mutex mutex_;
298     class Impl;
299     std::unique_ptr<Impl> pImpl_;
300     bool destroyed_ = false;
301 
302     void UpdateFocusStatus(uint32_t windowId, const sptr<IRemoteObject>& abilityToken, WindowType windowType,
303         DisplayId displayId, bool focused) const;
304     void UpdateFocusChangeInfo(const sptr<FocusChangeInfo>& focusChangeInfo, bool focused) const;
305     void UpdateWindowVisibilityInfo(
306         const std::vector<sptr<WindowVisibilityInfo>>& windowVisibilityInfos) const;
307     void UpdateWindowDrawingContentInfo(
308         const std::vector<sptr<WindowDrawingContentInfo>>& windowDrawingContentInfos) const;
309     void UpdateWindowModeTypeInfo(WindowModeType type) const;
310     void UpdateCameraWindowStatus(uint32_t accessTokenId, bool isShowing) const;
311     void UpdatePiPWindowStateChanged(const std::string& bundleName, bool isForeground) const;
312     void OnRemoteDied();
313     void OnWMSConnectionChanged(int32_t userId, int32_t screenId, bool isConnected) const;
314     WMError NotifyWindowStyleChange(WindowStyleType type);
315     void NotifyAccessibilityWindowInfo(const std::vector<sptr<AccessibilityWindowInfo>>& infos,
316         WindowUpdateType type) const;
317 };
318 } // namespace Rosen
319 } // namespace OHOS
320 
321 #endif // OHOS_ROSEN_WINDOW_MANAGER_LITE_H
322