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 /** 53 * @brief Unregister focus changed listener. 54 * 55 * @param listener IFocusChangedListener. 56 * @return WM_OK means unregister success, others means unregister failed. 57 */ 58 WMError UnregisterFocusChangedListener(const sptr<IFocusChangedListener>& listener); 59 60 /** 61 * @brief Register visibility changed listener. 62 * 63 * @param listener IVisibilityChangedListener. 64 * @return WM_OK means register success, others means register failed. 65 */ 66 WMError RegisterVisibilityChangedListener(const sptr<IVisibilityChangedListener>& listener); 67 68 /** 69 * @brief Unregister visibility changed listener. 70 * 71 * @param listener IVisibilityChangedListener. 72 * @return WM_OK means unregister success, others means unregister failed. 73 */ 74 WMError UnregisterVisibilityChangedListener(const sptr<IVisibilityChangedListener>& listener); 75 76 /** 77 * @brief Get visibility window info. 78 * 79 * @param infos Visible window infos 80 * @return WM_OK means get success, others means get failed. 81 */ 82 WMError GetVisibilityWindowInfo(std::vector<sptr<WindowVisibilityInfo>>& infos) const; 83 84 /** 85 * @brief Get focus window. 86 * 87 * @param focusInfo Focus window info. 88 * @return FocusChangeInfo object about focus window. 89 */ 90 void GetFocusWindowInfo(FocusChangeInfo& focusInfo, DisplayId displayId = DEFAULT_DISPLAY_ID); 91 92 /** 93 * @brief Register drawingcontent changed listener. 94 * 95 * @param listener IDrawingContentChangedListener. 96 * @return WM_OK means register success, others means register failed. 97 */ 98 WMError RegisterDrawingContentChangedListener(const sptr<IDrawingContentChangedListener>& listener); 99 100 /** 101 * @brief Unregister drawingcontent changed listener. 102 * 103 * @param listener IDrawingContentChangedListener. 104 * @return WM_OK means unregister success, others means unregister failed. 105 */ 106 WMError UnregisterDrawingContentChangedListener(const sptr<IDrawingContentChangedListener>& listener); 107 108 /** 109 * @brief Register window mode listener. 110 * 111 * @param listener IWindowModeChangedListener. 112 * @return WM_OK means register success, others means register failed. 113 */ 114 WMError RegisterWindowModeChangedListener(const sptr<IWindowModeChangedListener>& listener); 115 116 /** 117 * @brief Unregister window mode listener. 118 * 119 * @param listener IWindowModeChangedListener. 120 * @return WM_OK means unregister success, others means unregister failed. 121 */ 122 WMError UnregisterWindowModeChangedListener(const sptr<IWindowModeChangedListener>& listener); 123 124 /** 125 * @brief Register camera window changed listener. 126 * 127 * @param listener ICameraWindowChangedListener. 128 * @return WM_OK means register success, others means register failed. 129 */ 130 WMError RegisterCameraWindowChangedListener(const sptr<ICameraWindowChangedListener>& listener); 131 132 /** 133 * @brief Unregister camera window changed listener. 134 * 135 * @param listener ICameraWindowChangedListener. 136 * @return WM_OK means unregister success, others means unregister failed. 137 */ 138 WMError UnregisterCameraWindowChangedListener(const sptr<ICameraWindowChangedListener>& listener); 139 140 /** 141 * @brief Get window mode type. 142 * 143 * @param void 144 * @return WM_OK means get success, others means get failed. 145 */ 146 WMError GetWindowModeType(WindowModeType& windowModeType) const; 147 148 /** 149 * @brief Get top num main window info. 150 * 151 * @param topNum the num of top window 152 * @param topNInfo the top num window infos 153 * @return WM_OK means get success, others means get failed. 154 */ 155 WMError GetMainWindowInfos(int32_t topNum, std::vector<MainWindowInfo>& topNInfo); 156 157 /** 158 * @brief Get keyboard calling window information. 159 * 160 * @param callingWindowInfo calling window information 161 * @return WM_OK means get success, others means get failed. 162 */ 163 WMError GetCallingWindowInfo(CallingWindowInfo& callingWindowInfo); 164 165 /** 166 * @brief Get all main window info. 167 * 168 * @param infos the all main window info. 169 * @return WM_OK means get success, others means get failed. 170 */ 171 WMError GetAllMainWindowInfos(std::vector<MainWindowInfo>& infos) const; 172 173 /** 174 * @brief Clear a specified set of sessions. 175 * 176 * @param persistentIds a vector of session persistentId. 177 * @return WM_OK means clear session success, others means clear failed. 178 */ 179 WMError ClearMainSessions(const std::vector<int32_t>& persistentIds); 180 181 /** 182 * @brief Clear a specified set of sessions. 183 * 184 * @param persistentIds a vector of session persistentId. 185 * @param clearFailedIds a vector of session persistentId which is clear failed. 186 * @return WM_OK means clear session success, others means clear failed. 187 */ 188 WMError ClearMainSessions(const std::vector<int32_t>& persistentIds, std::vector<int32_t>& clearFailedIds); 189 190 /** 191 * @brief raise window to top by windowId 192 * 193 * @param persistentId this window to raise 194 * @return WM_OK if raise success 195 */ 196 WMError RaiseWindowToTop(int32_t persistentId); 197 198 /** 199 * @brief Register WMS connection status changed listener. 200 * @attention Callable only by u0 system user. A process only supports successful registration once. 201 * When the foundation service restarts, you need to re-register the listener. 202 * If you want to re-register, please call UnregisterWMSConnectionChangedListener first. 203 * 204 * @param listener IWMSConnectionChangedListener. 205 * @return WM_OK means register success, others means register failed. 206 */ 207 WMError RegisterWMSConnectionChangedListener(const sptr<IWMSConnectionChangedListener>& listener); 208 209 /** 210 * @brief Unregister WMS connection status changed listener. 211 * @attention Callable only by u0 system user. 212 * 213 * @return WM_OK means unregister success, others means unregister failed. 214 */ 215 WMError UnregisterWMSConnectionChangedListener(); 216 217 /** 218 * @brief Register WindowStyle changed listener. 219 * 220 * @param listener IWindowStyleChangedListener 221 * @return WM_OK means register success, others means unregister failed. 222 */ 223 WMError RegisterWindowStyleChangedListener(const sptr<IWindowStyleChangedListener>& listener); 224 225 /** 226 * @brief Unregister WindowStyle changed listener. 227 * 228 * @param listener IWindowStyleChangedListener 229 * @return WM_OK means unregister success, others means unregister failed. 230 */ 231 WMError UnregisterWindowStyleChangedListener(const sptr<IWindowStyleChangedListener>& listener); 232 233 /** 234 * @brief Register a listener to detect display changes for the keyboard calling window. 235 * 236 * @param listener IKeyboardCallingWindowDisplayChangedListener 237 * @return WM_OK means register success, others means unregister failed. 238 */ 239 WMError RegisterCallingWindowDisplayChangedListener( 240 const sptr<IKeyboardCallingWindowDisplayChangedListener>& listener); 241 242 /** 243 * @brief Unregister the listener that detects display changes for the keyboard calling window. 244 * 245 * @param listener IKeyboardCallingWindowDisplayChangedListener 246 * @return WM_OK means unregister success, others means unregister failed. 247 */ 248 WMError UnregisterCallingWindowDisplayChangedListener( 249 const sptr<IKeyboardCallingWindowDisplayChangedListener>& listener); 250 251 /** 252 * @brief Get window style type. 253 * 254 * @param windowStyleType WindowType 255 * @return @return WM_OK means get window style success, others means failed. 256 */ 257 WindowStyleType GetWindowStyleType(); 258 259 /** 260 * @brief Terminate session by persistentId and start caller. 261 * @persistentId persistentId to be terminated. 262 * 263 * @return WM_OK means Terminate success, others means Terminate failed. 264 */ 265 WMError TerminateSessionByPersistentId(int32_t persistentId); 266 267 /** 268 * @brief Close target float window. 269 * 270 * @param bundleName the target float window need to be closed. 271 * @return WM_OK means Close success, others means Close failed. 272 */ 273 WMError CloseTargetFloatWindow(const std::string& bundleName); 274 275 /** 276 * @brief Register listener for PiP window state changed. 277 * 278 * @param listener the PiP state changed listener. 279 * @return WM_OK means Register success, others means Register failed. 280 */ 281 WMError RegisterPiPStateChangedListener(const sptr<IPiPStateChangedListener>& listener); 282 283 /** 284 * @brief Unregister listener for PiP window state changed. 285 * 286 * @param listener the PiP state changed listener. 287 * @return WM_OK means Unregister success, others means Unregister failed. 288 */ 289 WMError UnregisterPiPStateChangedListener(const sptr<IPiPStateChangedListener>& listener); 290 291 /** 292 * @brief Close target PiP Window by bundleName. 293 * 294 * @param bundleName the target PiP Window need to be closed. 295 * @return WM_OK means Close success, others means Close failed. 296 */ 297 WMError CloseTargetPiPWindow(const std::string& bundleName); 298 299 /** 300 * @brief Get current show PiP Window info. 301 * 302 * @param bundleName the current PiP window bundleName. 303 * @return WM_OK means Get success, others means Get failed. 304 */ 305 WMError GetCurrentPiPWindowInfo(std::string& bundleName); 306 307 /** 308 * @brief Get accessibility window info. 309 * 310 * @param infos WindowInfos used for Accessibility. 311 * @return WM_OK means get success, others means get failed. 312 */ 313 WMError GetAccessibilityWindowInfo(std::vector<sptr<AccessibilityWindowInfo>>& infos) const; 314 315 /** 316 * @brief Register window updated listener. 317 * 318 * @param listener IWindowUpdateListener. 319 * @return WM_OK means register success, others means register failed. 320 */ 321 WMError RegisterWindowUpdateListener(const sptr<IWindowUpdateListener>& listener); 322 323 /** 324 * @brief Unregister window updated listener. 325 * 326 * @param listener IWindowUpdateListener. 327 * @return WM_OK means unregister success, others means unregister failed. 328 */ 329 WMError UnregisterWindowUpdateListener(const sptr<IWindowUpdateListener>& listener); 330 331 /** 332 * @brief Register window info change callback. 333 * 334 * @param observedInfo Property which to observe. 335 * @param listener Listener to observe window info. 336 * @return WM_OK means register success, others means failed. 337 */ 338 WMError RegisterWindowInfoChangeCallback(const std::unordered_set<WindowInfoKey>& observedInfo, 339 const sptr<IWindowInfoChangedListener>& listener); 340 341 /** 342 * @brief Unregister window info change callback. 343 * 344 * @param observedInfo Property which to observe. 345 * @param listener Listener to observe window info. 346 * @return WM_OK means unregister success, others means failed. 347 */ 348 WMError UnregisterWindowInfoChangeCallback(const std::unordered_set<WindowInfoKey>& observedInfo, 349 const sptr<IWindowInfoChangedListener>& listener); 350 351 /** 352 * @brief List window info. 353 * 354 * @param windowInfoOption Option for selecting window info. 355 * @param infos Window info. 356 * @return WM_OK means get success, others means get failed. 357 */ 358 WMError ListWindowInfo(const WindowInfoOption& windowInfoOption, std::vector<sptr<WindowInfo>>& infos) const; 359 360 private: 361 WindowManagerLite(); 362 ~WindowManagerLite(); 363 std::recursive_mutex mutex_; 364 class Impl; 365 std::unique_ptr<Impl> pImpl_; 366 bool destroyed_ = false; 367 368 void UpdateFocusStatus(uint32_t windowId, const sptr<IRemoteObject>& abilityToken, WindowType windowType, 369 DisplayId displayId, bool focused) const; 370 void UpdateFocusChangeInfo(const sptr<FocusChangeInfo>& focusChangeInfo, bool focused) const; 371 void UpdateWindowVisibilityInfo( 372 const std::vector<sptr<WindowVisibilityInfo>>& windowVisibilityInfos) const; 373 void UpdateWindowDrawingContentInfo( 374 const std::vector<sptr<WindowDrawingContentInfo>>& windowDrawingContentInfos) const; 375 void UpdateWindowModeTypeInfo(WindowModeType type) const; 376 void UpdateCameraWindowStatus(uint32_t accessTokenId, bool isShowing) const; 377 void UpdatePiPWindowStateChanged(const std::string& bundleName, bool isForeground) const; 378 void OnRemoteDied(); 379 void OnWMSConnectionChanged(int32_t userId, int32_t screenId, bool isConnected) const; 380 WMError NotifyWindowStyleChange(WindowStyleType type); 381 void NotifyAccessibilityWindowInfo(const std::vector<sptr<AccessibilityWindowInfo>>& infos, 382 WindowUpdateType type) const; 383 WMError NotifyCallingWindowDisplayChanged(const CallingWindowInfo& callingWindowInfo); 384 WMError ProcessRegisterWindowInfoChangeCallback(WindowInfoKey observedInfo, 385 const sptr<IWindowInfoChangedListener>& listener); 386 WMError ProcessUnregisterWindowInfoChangeCallback(WindowInfoKey observedInfo, 387 const sptr<IWindowInfoChangedListener>& listener); 388 WMError RegisterVisibilityStateChangedListener(const sptr<IWindowInfoChangedListener>& listener); 389 WMError UnregisterVisibilityStateChangedListener(const sptr<IWindowInfoChangedListener>& listener); 390 }; 391 } // namespace Rosen 392 } // namespace OHOS 393 394 #endif // OHOS_ROSEN_WINDOW_MANAGER_LITE_H 395