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     /**
117     * @brief Register camera window changed listener.
118     *
119     * @param listener ICameraWindowChangedListener.
120     * @return WM_OK means register success, others means register failed.
121     */
122     WMError RegisterCameraWindowChangedListener(const sptr<ICameraWindowChangedListener>& listener);
123 
124     /**
125    * @brief Unregister camera window changed listener.
126    *
127    * @param listener ICameraWindowChangedListener.
128    * @return WM_OK means unregister success, others means unregister failed.
129    */
130     WMError UnregisterCameraWindowChangedListener(const sptr<ICameraWindowChangedListener>& listener);
131 
132     /**
133      * @brief Get window mode type.
134      *
135      * @param void
136      * @return WM_OK means get success, others means get failed.
137      */
138     WMError GetWindowModeType(WindowModeType& windowModeType) const;
139 
140     /**
141      * @brief Get top num main window info.
142      *
143      * @param topNum the num of top window
144      * @param topNInfo the top num window infos
145      * @return WM_OK means get success, others means get failed.
146      */
147     WMError GetMainWindowInfos(int32_t topNum, std::vector<MainWindowInfo>& topNInfo);
148 
149     /**
150      * @brief Get all main window info.
151      *
152      * @param infos the all main window info.
153      * @return WM_OK means get success, others means get failed.
154      */
155     WMError GetAllMainWindowInfos(std::vector<MainWindowInfo>& infos) const;
156 
157     /**
158      * @brief Clear a specified set of sessions.
159      *
160      * @param persistentIds a vector of session persistentId.
161      * @return WM_OK means clear session success, others means clear failed.
162      */
163     WMError ClearMainSessions(const std::vector<int32_t>& persistentIds);
164 
165     /**
166      * @brief Clear a specified set of sessions.
167      *
168      * @param persistentIds a vector of session persistentId.
169      * @param clearFailedIds a vector of session persistentId which is clear failed.
170      * @return WM_OK means clear session success, others means clear failed.
171      */
172     WMError ClearMainSessions(const std::vector<int32_t>& persistentIds, std::vector<int32_t>& clearFailedIds);
173 
174     /**
175      * @brief raise window to top by windowId
176      *
177      * @param persistentId this window to raise
178      * @return WM_OK if raise success
179      */
180     WMError RaiseWindowToTop(int32_t persistentId);
181 
182     /**
183      * @brief Register WMS connection status changed listener.
184      * @attention Callable only by u0 system user. A process only supports successful registration once.
185      * When the foundation service restarts, you need to re-register the listener.
186      * If you want to re-register, please call UnregisterWMSConnectionChangedListener first.
187      *
188      * @param listener IWMSConnectionChangedListener.
189      * @return WM_OK means register success, others means register failed.
190      */
191     WMError RegisterWMSConnectionChangedListener(const sptr<IWMSConnectionChangedListener>& listener);
192 
193     /**
194      * @brief Unregister WMS connection status changed listener.
195      * @attention Callable only by u0 system user.
196      *
197      * @return WM_OK means unregister success, others means unregister failed.
198      */
199     WMError UnregisterWMSConnectionChangedListener();
200 
201     /**
202      * @brief Register WindowStyle changed listener.
203      *
204      * @param listener IWindowStyleChangedListener
205      * @return WM_OK means register success, others means unregister failed.
206      */
207     WMError RegisterWindowStyleChangedListener(const sptr<IWindowStyleChangedListener>& listener);
208     /**
209     * @brief Unregister WindowStyle changed listener.
210     *
211     * @param listener IWindowStyleChangedListener
212     * @return WM_OK means unregister success, others means unregister failed.
213     */
214     WMError UnregisterWindowStyleChangedListener(const sptr<IWindowStyleChangedListener>& listener);
215     /**
216      * @brief Get window style type.
217      *
218      * @param windowStyleType WindowType
219      * @return @return WM_OK means get window style success, others means failed.
220      */
221     WindowStyleType GetWindowStyleType();
222 
223     /**
224      * @brief Terminate session by persistentId and start caller.
225      * @persistentId persistentId to be terminated.
226      *
227      * @return WM_OK means Terminate success, others means Terminate failed.
228      */
229     WMError TerminateSessionByPersistentId(int32_t persistentId);
230 
231     /**
232      * @brief Close target float window.
233      *
234      * @param bundleName the target float window need to be closed.
235      * @return WM_OK means Close success, others means Close failed.
236      */
237     WMError CloseTargetFloatWindow(const std::string& bundleName);
238 
239     /**
240      * @brief Register listener for PiP window state changed.
241      *
242      * @param listener the PiP state changed listener.
243      * @return WM_OK means Register success, others means Register failed.
244      */
245     WMError RegisterPiPStateChangedListener(const sptr<IPiPStateChangedListener>& listener);
246 
247     /**
248      * @brief Unregister listener for PiP window state changed.
249      *
250      * @param listener the PiP state changed listener.
251      * @return WM_OK means Unregister success, others means Unregister failed.
252      */
253     WMError UnregisterPiPStateChangedListener(const sptr<IPiPStateChangedListener>& listener);
254 
255     /**
256      * @brief Close target PiP Window by bundleName.
257      *
258      * @param bundleName the target PiP Window need to be closed.
259      * @return WM_OK means Close success, others means Close failed.
260      */
261     WMError CloseTargetPiPWindow(const std::string& bundleName);
262 
263     /**
264      * @brief Get current show PiP Window info.
265      *
266      * @param bundleName the current PiP window bundleName.
267      * @return WM_OK means Get success, others means Get failed.
268      */
269     WMError GetCurrentPiPWindowInfo(std::string& bundleName);
270 
271     /**
272      * @brief Get accessibility window info.
273      *
274      * @param infos WindowInfos used for Accessibility.
275      * @return WM_OK means get success, others means get failed.
276      */
277     WMError GetAccessibilityWindowInfo(std::vector<sptr<AccessibilityWindowInfo>>& infos) const;
278 
279     /**
280      * @brief Register window updated listener.
281      *
282      * @param listener IWindowUpdateListener.
283      * @return WM_OK means register success, others means register failed.
284      */
285     WMError RegisterWindowUpdateListener(const sptr<IWindowUpdateListener>& listener);
286 
287     /**
288      * @brief Unregister window updated listener.
289      *
290      * @param listener IWindowUpdateListener.
291      * @return WM_OK means unregister success, others means unregister failed.
292      */
293     WMError UnregisterWindowUpdateListener(const sptr<IWindowUpdateListener>& listener);
294 
295 private:
296     WindowManagerLite();
297     ~WindowManagerLite();
298     std::recursive_mutex mutex_;
299     class Impl;
300     std::unique_ptr<Impl> pImpl_;
301     bool destroyed_ = false;
302 
303     void UpdateFocusStatus(uint32_t windowId, const sptr<IRemoteObject>& abilityToken, WindowType windowType,
304         DisplayId displayId, bool focused) const;
305     void UpdateFocusChangeInfo(const sptr<FocusChangeInfo>& focusChangeInfo, bool focused) const;
306     void UpdateWindowVisibilityInfo(
307         const std::vector<sptr<WindowVisibilityInfo>>& windowVisibilityInfos) const;
308     void UpdateWindowDrawingContentInfo(
309         const std::vector<sptr<WindowDrawingContentInfo>>& windowDrawingContentInfos) const;
310     void UpdateWindowModeTypeInfo(WindowModeType type) const;
311     void UpdateCameraWindowStatus(uint32_t accessTokenId, bool isShowing) const;
312     void UpdatePiPWindowStateChanged(const std::string& bundleName, bool isForeground) const;
313     void OnRemoteDied();
314     void OnWMSConnectionChanged(int32_t userId, int32_t screenId, bool isConnected) const;
315     WMError NotifyWindowStyleChange(WindowStyleType type);
316     void NotifyAccessibilityWindowInfo(const std::vector<sptr<AccessibilityWindowInfo>>& infos,
317         WindowUpdateType type) const;
318 };
319 } // namespace Rosen
320 } // namespace OHOS
321 
322 #endif // OHOS_ROSEN_WINDOW_MANAGER_LITE_H
323