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_SESSION_IMPL_H 17 #define OHOS_ROSEN_WINDOW_SESSION_IMPL_H 18 19 #include <atomic> 20 #include <optional> 21 #include <shared_mutex> 22 #include <ability_context.h> 23 #include <event_handler.h> 24 #include <i_input_event_consumer.h> 25 #include <refbase.h> 26 #include <ui_content.h> 27 #include <ui/rs_surface_node.h> 28 #include "display_manager.h" 29 #include "singleton_container.h" 30 31 #include "common/include/window_session_property.h" 32 #include "display_info.h" 33 #include "future_callback.h" 34 #include "interfaces/include/ws_common.h" 35 #include "interfaces/include/ws_common_inner.h" 36 #include "session/container/include/zidl/session_stage_stub.h" 37 #include "session/host/include/zidl/session_interface.h" 38 #include "vsync_station.h" 39 #include "window.h" 40 #include "window_option.h" 41 #include "wm_common.h" 42 43 namespace OHOS { 44 namespace Rosen { 45 namespace { 46 template<typename T1, typename T2, typename Ret> 47 using EnableIfSame = typename std::enable_if<std::is_same_v<T1, T2>, Ret>::type; 48 49 /* 50 * DFX 51 */ 52 const std::string SET_UICONTENT_TIMEOUT_LISTENER_TASK_NAME = "SetUIContentTimeoutListener"; 53 constexpr int64_t SET_UICONTENT_TIMEOUT_TIME_MS = 4000; 54 constexpr int64_t SET_UICONTENT_TIMEOUT_TIME_AFTER_FREEZE_MS = 5000; 55 } 56 57 struct WindowTitleVisibleFlags { 58 bool isMaximizeVisible = true; 59 bool isMinimizeVisible = true; 60 bool isSplitVisible = true; 61 bool isCloseVisible = true; 62 }; 63 64 class WindowSessionImpl : public Window, public virtual SessionStageStub { 65 public: 66 explicit WindowSessionImpl(const sptr<WindowOption>& option); 67 ~WindowSessionImpl(); 68 void ConsumePointerEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent) override; 69 void ConsumeKeyEvent(std::shared_ptr<MMI::KeyEvent>& inputEvent) override; 70 bool PreNotifyKeyEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent) override; 71 virtual bool NotifyOnKeyPreImeEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent) override; 72 static sptr<Window> Find(const std::string& name); 73 static std::vector<sptr<Window>> GetSubWindow(int parentId); 74 // inherits from window 75 virtual WMError Create(const std::shared_ptr<AbilityRuntime::Context>& context, 76 const sptr<Rosen::ISession>& iSession, const std::string& identityToken = ""); 77 WMError Show(uint32_t reason = 0, bool withAnimation = false, bool withFocus = true) override; 78 WMError Hide(uint32_t reason = 0, bool withAnimation = false, bool isFromInnerkits = true) override; 79 WMError Destroy() override; 80 virtual WMError Destroy(bool needNotifyServer, bool needClearListener = true); 81 WMError NapiSetUIContent(const std::string& contentInfo, napi_env env, napi_value storage, 82 BackupAndRestoreType type, sptr<IRemoteObject> token, AppExecFwk::Ability* ability) override; 83 WMError SetUIContentByName(const std::string& contentInfo, napi_env env, napi_value storage, 84 AppExecFwk::Ability* ability) override; 85 WMError SetUIContentByAbc(const std::string& abcPath, napi_env env, napi_value storage, 86 AppExecFwk::Ability* ability) override; 87 std::shared_ptr<RSSurfaceNode> GetSurfaceNode() const override; 88 const std::shared_ptr<AbilityRuntime::Context> GetContext() const override; 89 Rect GetRequestRect() const override; 90 WindowType GetType() const override; 91 const std::string& GetWindowName() const override; 92 WindowState GetWindowState() const override; 93 WindowState GetRequestWindowState() const; 94 WMError SetFocusable(bool isFocusable) override; 95 WMError SetTouchable(bool isTouchable) override; 96 97 /* 98 * Window Hierarchy 99 */ 100 WMError SetTopmost(bool topmost) override; 101 bool IsTopmost() const override; 102 WMError SetMainWindowTopmost(bool isTopmost) override; 103 bool IsMainWindowTopmost() const override; 104 105 WMError SetResizeByDragEnabled(bool dragEnabled) override; 106 WMError SetRaiseByClickEnabled(bool raiseEnabled) override; 107 WMError HideNonSystemFloatingWindows(bool shouldHide) override; 108 WMError SetSingleFrameComposerEnabled(bool enable) override; 109 bool IsFloatingWindowAppType() const override; 110 111 /* 112 * PC Window 113 */ 114 bool IsPcWindow() const override; 115 bool IsPcOrPadCapabilityEnabled() const override; 116 bool IsPcOrPadFreeMultiWindowMode() const override; 117 WMError SetTitleButtonVisible(bool isMaximizeVisible, bool isMinimizeVisible, bool isSplitVisible, 118 bool isCloseVisible) override; 119 WMError SetSubWindowModal(bool isModal, ModalityType modalityType = ModalityType::WINDOW_MODALITY) override; 120 WMError SetWindowModal(bool isModal) override; 121 void SetTargetAPIVersion(uint32_t targetAPIVersion); 122 uint32_t GetTargetAPIVersion() const; 123 124 WMError SetWindowType(WindowType type) override; 125 WMError SetBrightness(float brightness) override; 126 virtual float GetBrightness() const override; 127 void SetRequestedOrientation(Orientation orientation) override; 128 bool GetTouchable() const override; 129 uint32_t GetWindowId() const override; 130 uint64_t GetDisplayId() const override; 131 Rect GetRect() const override; 132 bool GetFocusable() const override; 133 std::string GetContentInfo(BackupAndRestoreType type = BackupAndRestoreType::CONTINUATION) override; 134 WMError SetRestoredRouterStack(const std::string& routerStack) override; 135 Ace::UIContent* GetUIContent() const override; 136 std::shared_ptr<Ace::UIContent> GetUIContentSharedPtr() const; 137 Ace::UIContent* GetUIContentWithId(uint32_t winId) const override; 138 void OnNewWant(const AAFwk::Want& want) override; 139 WMError SetAPPWindowLabel(const std::string& label) override; 140 WMError SetAPPWindowIcon(const std::shared_ptr<Media::PixelMap>& icon) override; 141 void RequestVsync(const std::shared_ptr<VsyncCallback>& vsyncCallback) override; 142 int64_t GetVSyncPeriod() override; 143 void FlushFrameRate(uint32_t rate, int32_t animatorExpectedFrameRate, uint32_t rateType = 0) override; 144 // inherits from session stage 145 WSError SetActive(bool active) override; 146 WSError UpdateRect(const WSRect& rect, SizeChangeReason reason, 147 const SceneAnimationConfig& config = { nullptr, ROTATE_ANIMATION_DURATION }) override; 148 void UpdateDensity() override; 149 void SetUniqueVirtualPixelRatio(bool useUniqueDensity, float virtualPixelRatio) override; 150 WSError UpdateOrientation() override; 151 WSError UpdateDisplayId(uint64_t displayId) override; 152 WSError UpdateFocus(bool focus) override; 153 bool IsFocused() const override; 154 WMError RequestFocus() const override; 155 WMError RequestFocusByClient(bool isFocused) const override; 156 WSError UpdateWindowMode(WindowMode mode) override; 157 WSError HandleBackEvent() override; 158 WMError SetSystemBarProperty(WindowType type, const SystemBarProperty& property) override; 159 KeyboardAnimationConfig GetKeyboardAnimationConfig() override; 160 161 void NotifyPointerEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent) override; 162 void NotifyKeyEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent, bool& isConsumed, 163 bool notifyInputMethod = true) override; 164 void NotifyOccupiedAreaChangeInfoInner(sptr<OccupiedAreaChangeInfo> info); 165 void NotifyOccupiedAreaChangeInfo(sptr<OccupiedAreaChangeInfo> info, 166 const std::shared_ptr<RSTransaction>& rsTransaction = nullptr) override; 167 void NotifyForegroundInteractiveStatus(bool interactive) override; 168 void NotifyDisplayMove(DisplayId from, DisplayId to) override; 169 170 WMError RegisterLifeCycleListener(const sptr<IWindowLifeCycle>& listener) override; 171 WMError UnregisterLifeCycleListener(const sptr<IWindowLifeCycle>& listener) override; 172 WMError RegisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) override; 173 WMError UnregisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) override; 174 WMError RegisterWindowChangeListener(const sptr<IWindowChangeListener>& listener) override; 175 WMError UnregisterWindowChangeListener(const sptr<IWindowChangeListener>& listener) override; 176 WMError RegisterAvoidAreaChangeListener(sptr<IAvoidAreaChangedListener>& listener) override; 177 WMError UnregisterAvoidAreaChangeListener(sptr<IAvoidAreaChangedListener>& listener) override; 178 void RegisterDialogDeathRecipientListener(const sptr<IDialogDeathRecipientListener>& listener) override; 179 void UnregisterDialogDeathRecipientListener(const sptr<IDialogDeathRecipientListener>& listener) override; 180 WMError RegisterDialogTargetTouchListener(const sptr<IDialogTargetTouchListener>& listener) override; 181 WMError UnregisterDialogTargetTouchListener(const sptr<IDialogTargetTouchListener>& listener) override; 182 WMError RegisterOccupiedAreaChangeListener(const sptr<IOccupiedAreaChangeListener>& listener) override; 183 WMError UnregisterOccupiedAreaChangeListener(const sptr<IOccupiedAreaChangeListener>& listener) override; 184 WMError RegisterTouchOutsideListener(const sptr<ITouchOutsideListener>& listener) override; 185 WMError UnregisterTouchOutsideListener(const sptr<ITouchOutsideListener>& listener) override; 186 WMError RegisterWindowVisibilityChangeListener(const IWindowVisibilityListenerSptr& listener) override; 187 WMError UnregisterWindowVisibilityChangeListener(const IWindowVisibilityListenerSptr& listener) override; 188 WMError RegisterDisplayIdChangeListener(const IDisplayIdChangeListenerSptr& listener) override; 189 WMError UnregisterDisplayIdChangeListener(const IDisplayIdChangeListenerSptr& listener) override; 190 WMError RegisterWindowNoInteractionListener(const IWindowNoInteractionListenerSptr& listener) override; 191 WMError UnregisterWindowNoInteractionListener(const IWindowNoInteractionListenerSptr& listener) override; 192 void RegisterWindowDestroyedListener(const NotifyNativeWinDestroyFunc& func) override; UnregisterWindowDestroyedListener()193 void UnregisterWindowDestroyedListener() override { notifyNativeFunc_ = nullptr; } 194 WMError RegisterScreenshotListener(const sptr<IScreenshotListener>& listener) override; 195 WMError UnregisterScreenshotListener(const sptr<IScreenshotListener>& listener) override; 196 void SetAceAbilityHandler(const sptr<IAceAbilityHandler>& handler) override; 197 void SetInputEventConsumer(const std::shared_ptr<IInputEventConsumer>& inputEventConsumer) override; 198 199 WMError SetBackgroundColor(const std::string& color) override; 200 virtual Orientation GetRequestedOrientation() override; 201 202 int32_t GetParentId() const; 203 int32_t GetPersistentId() const override; 204 sptr<WindowSessionProperty> GetProperty() const; 205 SystemSessionConfig GetSystemSessionConfig() const; 206 sptr<ISession> GetHostSession() const; 207 int32_t GetFloatingWindowParentId(); 208 void NotifyAfterForeground(bool needNotifyListeners = true, bool needNotifyUiContent = true); 209 void NotifyAfterBackground(bool needNotifyListeners = true, bool needNotifyUiContent = true); 210 void NotifyForegroundFailed(WMError ret); 211 void NotifyBackgroundFailed(WMError ret); 212 WSError MarkProcessed(int32_t eventId) override; 213 void UpdateTitleButtonVisibility(); 214 WSError NotifyDestroy() override; 215 WSError NotifyTransferComponentData(const AAFwk::WantParams& wantParams) override; 216 WSErrorCode NotifyTransferComponentDataSync(const AAFwk::WantParams& wantParams, 217 AAFwk::WantParams& reWantParams) override; 218 void NotifyAvoidAreaChange(const sptr<AvoidArea>& avoidArea, AvoidAreaType type); 219 WSError UpdateAvoidArea(const sptr<AvoidArea>& avoidArea, AvoidAreaType type) override; 220 void NotifyTouchDialogTarget(int32_t posX = 0, int32_t posY = 0) override; 221 void NotifyScreenshot() override; 222 void DumpSessionElementInfo(const std::vector<std::string>& params) override; 223 // colorspace, gamut 224 virtual bool IsSupportWideGamut() override; 225 virtual void SetColorSpace(ColorSpace colorSpace) override; 226 virtual ColorSpace GetColorSpace() override; 227 WSError NotifyTouchOutside() override; 228 WMError SetLandscapeMultiWindow(bool isLandscapeMultiWindow) override; 229 WSError NotifyWindowVisibility(bool isVisible) override; 230 WSError NotifyNoInteractionTimeout(const IWindowNoInteractionListenerSptr& listener); 231 WMError TransferAccessibilityEvent(const Accessibility::AccessibilityEventInfo& info, 232 int64_t uiExtensionIdLevel) override; 233 WindowState state_ { WindowState::STATE_INITIAL }; 234 WindowState requestState_ { WindowState::STATE_INITIAL }; 235 WSError UpdateMaximizeMode(MaximizeMode mode) override; 236 void NotifySessionForeground(uint32_t reason, bool withAnimation) override; 237 void NotifySessionBackground(uint32_t reason, bool withAnimation, bool isFromInnerkits) override; 238 WSError UpdateTitleInTargetPos(bool isShow, int32_t height) override; 239 WSError NotifyDialogStateChange(bool isForeground) override; 240 bool IsMainHandlerAvailable() const override; 241 242 /* 243 * PiP Window 244 */ 245 WSError NotifyCloseExistPipWindow() override; 246 WSError SetPipActionEvent(const std::string& action, int32_t status) override; 247 WSError SetPiPControlEvent(WsPiPControlType controlType, WsPiPControlStatus status) override; 248 void UpdatePiPRect(const Rect& rect, WindowSizeChangeReason reason) override; 249 void UpdatePiPControlStatus(PiPControlType controlType, PiPControlStatus status) override; 250 void SetAutoStartPiP(bool isAutoStart, uint32_t priority) override; 251 252 void SetDrawingContentState(bool drawingContentState); 253 WMError RegisterWindowStatusChangeListener(const sptr<IWindowStatusChangeListener>& listener) override; 254 WMError UnregisterWindowStatusChangeListener(const sptr<IWindowStatusChangeListener>& listener) override; 255 WMError SetSpecificBarProperty(WindowType type, const SystemBarProperty& property) override; 256 virtual WMError SetDecorVisible(bool isVisible) override; 257 virtual WMError SetWindowTitleMoveEnabled(bool enable) override; 258 virtual WMError SetDecorHeight(int32_t decorHeight) override; 259 virtual WMError GetDecorHeight(int32_t& height) override; 260 virtual WMError GetTitleButtonArea(TitleButtonRect& titleButtonRect) override; 261 WSError GetUIContentRemoteObj(sptr<IRemoteObject>& uiContentRemoteObj) override; 262 virtual WMError RegisterWindowTitleButtonRectChangeListener( 263 const sptr<IWindowTitleButtonRectChangedListener>& listener) override; 264 virtual WMError UnregisterWindowTitleButtonRectChangeListener( 265 const sptr<IWindowTitleButtonRectChangedListener>& listener) override; 266 void NotifyWindowTitleButtonRectChange(TitleButtonRect titleButtonRect); 267 void RecoverSessionListener(); 268 void SetDefaultDisplayIdIfNeed(); 269 WMError RegisterWindowRectChangeListener(const sptr<IWindowRectChangeListener>& listener) override; 270 WMError UnregisterWindowRectChangeListener(const sptr<IWindowRectChangeListener>& listener) override; 271 WMError RegisterSubWindowCloseListeners(const sptr<ISubWindowCloseListener>& listener) override; 272 WMError UnregisterSubWindowCloseListeners(const sptr<ISubWindowCloseListener>& listener) override; 273 WMError RegisterMainWindowCloseListeners(const sptr<IMainWindowCloseListener>& listener) override; 274 WMError UnregisterMainWindowCloseListeners(const sptr<IMainWindowCloseListener>& listener) override; 275 WMError RegisterSwitchFreeMultiWindowListener(const sptr<ISwitchFreeMultiWindowListener>& listener) override; 276 WMError UnregisterSwitchFreeMultiWindowListener(const sptr<ISwitchFreeMultiWindowListener>& listener) override; 277 virtual WMError GetCallingWindowWindowStatus(WindowStatus& windowStatus) const override; 278 virtual WMError GetCallingWindowRect(Rect& rect) const override; 279 virtual void SetUiDvsyncSwitch(bool dvsyncSwitch) override; 280 WMError SetContinueState(int32_t continueState) override; 281 282 /* 283 * Window Layout 284 */ 285 WMError EnableDrag(bool enableDrag) override; 286 WSError SetEnableDragBySystem(bool enableDrag) override; 287 288 /* 289 * Window Property 290 */ 291 WSError NotifyDisplayIdChange(DisplayId displayId); 292 293 protected: 294 WMError Connect(); 295 bool IsWindowSessionInvalid() const; 296 void NotifyWindowAfterUnfocused(); 297 void NotifyWindowAfterFocused(); 298 void NotifyAfterActive(); 299 void NotifyAfterInactive(); 300 void NotifyBeforeDestroy(std::string windowName); 301 void NotifyAfterDestroy(); 302 void ClearListenersById(int32_t persistentId); 303 void ClearSwitchFreeMultiWindowListenersById(int32_t persistentId); 304 void ClearVsyncStation(); 305 WMError WindowSessionCreateCheck(); 306 void UpdateDecorEnableToAce(bool isDecorEnable); 307 void UpdateDecorEnable(bool needNotify = false, WindowMode mode = WindowMode::WINDOW_MODE_UNDEFINED); 308 void NotifyModeChange(WindowMode mode, bool hasDeco = true); 309 WMError UpdateProperty(WSPropertyChangeAction action); 310 WMError SetBackgroundColor(uint32_t color); 311 uint32_t GetBackgroundColor() const; 312 virtual WMError SetLayoutFullScreenByApiVersion(bool status); 313 float GetVirtualPixelRatio() override; 314 virtual float GetVirtualPixelRatio(sptr<DisplayInfo> displayInfo); 315 void UpdateViewportConfig(const Rect& rect, WindowSizeChangeReason reason, 316 const std::shared_ptr<RSTransaction>& rsTransaction = nullptr, 317 const sptr<DisplayInfo>& info = nullptr, 318 const std::map<AvoidAreaType, AvoidArea>& avoidAreas = {}); 319 void NotifySizeChange(Rect rect, WindowSizeChangeReason reason); 320 void NotifySubWindowClose(bool& terminateCloseProcess); 321 WMError NotifyMainWindowClose(bool& terminateCloseProcess); 322 void NotifySwitchFreeMultiWindow(bool enable); 323 static sptr<Window> FindWindowById(uint32_t winId); 324 void NotifyWindowStatusChange(WindowMode mode); 325 void NotifyTransformChange(const Transform& transForm) override; 326 bool IsKeyboardEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent) const; 327 void DispatchKeyEventCallback(const std::shared_ptr<MMI::KeyEvent>& keyEvent, bool& isConsumed); 328 bool FilterKeyEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent); 329 void CopyUniqueDensityParameter(sptr<WindowSessionImpl> parentWindow); 330 sptr<WindowSessionImpl> FindMainWindowWithContext(); 331 sptr<WindowSessionImpl> FindExtensionWindowWithContext(); 332 333 WMError RegisterExtensionAvoidAreaChangeListener(sptr<IAvoidAreaChangedListener>& listener); 334 WMError UnregisterExtensionAvoidAreaChangeListener(sptr<IAvoidAreaChangedListener>& listener); 335 336 void RefreshNoInteractionTimeoutMonitor(); 337 WindowStatus GetWindowStatusInner(WindowMode mode); 338 339 /** 340 * Sub Window 341 */ 342 void UpdateSubWindowStateAndNotify(int32_t parentPersistentId, const WindowState newState); 343 void DestroySubWindow(); 344 345 sptr<ISession> hostSession_; 346 mutable std::mutex hostSessionMutex_; 347 std::shared_ptr<Ace::UIContent> uiContent_; 348 mutable std::shared_mutex uiContentMutex_; 349 std::shared_ptr<AbilityRuntime::Context> context_; 350 std::shared_ptr<RSSurfaceNode> surfaceNode_; 351 352 sptr<WindowSessionProperty> property_; 353 SystemSessionConfig windowSystemConfig_; 354 NotifyNativeWinDestroyFunc notifyNativeFunc_; 355 356 std::recursive_mutex mutex_; 357 static std::map<std::string, std::pair<int32_t, sptr<WindowSessionImpl>>> windowSessionMap_; 358 // protect windowSessionMap_ 359 static std::shared_mutex windowSessionMutex_; 360 static std::set<sptr<WindowSessionImpl>> windowExtensionSessionSet_; 361 // protect windowExtensionSessionSet_ 362 static std::shared_mutex windowExtensionSessionMutex_; 363 static std::map<int32_t, std::vector<sptr<WindowSessionImpl>>> subWindowSessionMap_; 364 bool isSystembarPropertiesSet_ = false; 365 bool isIgnoreSafeAreaNeedNotify_ = false; 366 bool isIgnoreSafeArea_ = false; 367 std::atomic_bool isFocused_ = false; 368 std::shared_ptr<AppExecFwk::EventHandler> handler_ = nullptr; 369 bool shouldReNotifyFocus_ = false; 370 std::shared_ptr<VsyncStation> vsyncStation_ = nullptr; 371 std::shared_ptr<IInputEventConsumer> inputEventConsumer_; 372 bool useUniqueDensity_ { false }; 373 float virtualPixelRatio_ { 1.0f }; 374 bool escKeyEventTriggered_ = false; 375 // Check whether the UIExtensionAbility process is started 376 static bool isUIExtensionAbilityProcess_; 377 virtual WMError SetKeyEventFilter(KeyEventFilterFunc filter) override; 378 virtual WMError ClearKeyEventFilter() override; 379 WSError SwitchFreeMultiWindow(bool enable) override; 380 std::string identityToken_ = { "" }; 381 void MakeSubOrDialogWindowDragableAndMoveble(); IsFreeMultiWindowMode()382 bool IsFreeMultiWindowMode() const 383 { 384 return windowSystemConfig_.IsFreeMultiWindowMode(); 385 } 386 387 /* 388 * DFX 389 */ 390 void SetUIContentComplete(); 391 void AddSetUIContentTimeoutCheck(); 392 void NotifySetUIContentComplete(); NotifyExtensionTimeout(int32_t errorCode)393 virtual void NotifyExtensionTimeout(int32_t errorCode) {} 394 std::atomic_bool setUIContentCompleted_ { false }; 395 void SetUIExtensionDestroyComplete(); 396 void SetUIExtensionDestroyCompleteInSubWindow(); 397 void AddSetUIExtensionDestroyTimeoutCheck(); 398 std::atomic_bool setUIExtensionDestroyCompleted_ { false }; 399 std::atomic_bool startUIExtensionDestroyTimer_ { false }; 400 enum TimeoutErrorCode : int32_t { 401 SET_UICONTENT_TIMEOUT = 1000, 402 SET_UIEXTENSION_DESTROY_TIMEOUT 403 }; 404 405 /* 406 * Window Lifecycle 407 */ 408 bool hasFirstNotifyInteractive_ = false; 409 bool interactive_ = true; 410 411 /* 412 * Window Layout 413 */ 414 void FlushLayoutSize(int32_t width, int32_t height) override; 415 sptr<FutureCallback> layoutCallback_ = nullptr; 416 void UpdateVirtualPixelRatio(const sptr<Display>& display); 417 418 private: 419 //Trans between colorGamut and colorSpace 420 static ColorSpace GetColorSpaceFromSurfaceGamut(GraphicColorGamut colorGamut); 421 static GraphicColorGamut GetSurfaceGamutFromColorSpace(ColorSpace colorSpace); 422 423 template<typename T> WMError RegisterListener(std::vector<sptr<T>>& holder, const sptr<T>& listener); 424 template<typename T> WMError UnregisterListener(std::vector<sptr<T>>& holder, const sptr<T>& listener); 425 template<typename T> EnableIfSame<T, IWindowLifeCycle, std::vector<sptr<IWindowLifeCycle>>> GetListeners(); 426 template<typename T> EnableIfSame<T, IDisplayMoveListener, std::vector<sptr<IDisplayMoveListener>>> GetListeners(); 427 template<typename T> 428 EnableIfSame<T, IWindowChangeListener, std::vector<sptr<IWindowChangeListener>>> GetListeners(); 429 template<typename T> 430 EnableIfSame<T, IAvoidAreaChangedListener, std::vector<sptr<IAvoidAreaChangedListener>>> GetListeners(); 431 template<typename T> 432 EnableIfSame<T, IDialogDeathRecipientListener, std::vector<sptr<IDialogDeathRecipientListener>>> GetListeners(); 433 template<typename T> 434 EnableIfSame<T, IDialogTargetTouchListener, std::vector<sptr<IDialogTargetTouchListener>>> GetListeners(); 435 template<typename T> 436 EnableIfSame<T, IOccupiedAreaChangeListener, std::vector<sptr<IOccupiedAreaChangeListener>>> GetListeners(); 437 template<typename T> 438 EnableIfSame<T, IScreenshotListener, std::vector<sptr<IScreenshotListener>>> GetListeners(); 439 template<typename T> 440 EnableIfSame<T, ITouchOutsideListener, std::vector<sptr<ITouchOutsideListener>>> GetListeners(); 441 template<typename T> 442 EnableIfSame<T, IWindowVisibilityChangedListener, std::vector<IWindowVisibilityListenerSptr>> GetListeners(); 443 template<typename T> 444 EnableIfSame<T, IDisplayIdChangeListener, std::vector<IDisplayIdChangeListenerSptr>> GetListeners(); 445 template<typename T> 446 EnableIfSame<T, IWindowNoInteractionListener, std::vector<IWindowNoInteractionListenerSptr>> GetListeners(); 447 template<typename T> 448 EnableIfSame<T, IWindowTitleButtonRectChangedListener, 449 std::vector<sptr<IWindowTitleButtonRectChangedListener>>> GetListeners(); 450 template<typename T> void ClearUselessListeners(std::map<int32_t, T>& listeners, int32_t persistentId); 451 RSSurfaceNode::SharedPtr CreateSurfaceNode(std::string name, WindowType type); 452 template<typename T> 453 EnableIfSame<T, IWindowStatusChangeListener, std::vector<sptr<IWindowStatusChangeListener>>> GetListeners(); 454 template<typename T> 455 EnableIfSame<T, IWindowRectChangeListener, std::vector<sptr<IWindowRectChangeListener>>> GetListeners(); 456 template<typename T> 457 EnableIfSame<T, ISubWindowCloseListener, sptr<ISubWindowCloseListener>> GetListeners(); 458 template<typename T> 459 EnableIfSame<T, IMainWindowCloseListener, sptr<IMainWindowCloseListener>> GetListeners(); 460 template<typename T> 461 EnableIfSame<T, ISwitchFreeMultiWindowListener, std::vector<sptr<ISwitchFreeMultiWindowListener>>> GetListeners(); 462 void NotifyAfterFocused(); 463 void NotifyUIContentFocusStatus(); 464 void NotifyAfterUnfocused(bool needNotifyUiContent = true); 465 void NotifyAfterResumed(); 466 void NotifyAfterPaused(); 467 468 WMError InitUIContent(const std::string& contentInfo, napi_env env, napi_value storage, 469 WindowSetUIContentType setUIContentType, BackupAndRestoreType restoreType, AppExecFwk::Ability* ability, 470 OHOS::Ace::UIContentErrorCode& aceRet); 471 WMError SetUIContentInner(const std::string& contentInfo, napi_env env, napi_value storage, 472 WindowSetUIContentType setUIContentType, BackupAndRestoreType restoreType, AppExecFwk::Ability* ability); 473 std::shared_ptr<std::vector<uint8_t>> GetAbcContent(const std::string& abcPath); 474 inline void DestroyExistUIContent(); 475 std::string GetRestoredRouterStack(); 476 477 void UpdateRectForRotation(const Rect& wmRect, const Rect& preRect, WindowSizeChangeReason wmReason, 478 const SceneAnimationConfig& config); 479 void UpdateRectForOtherReason(const Rect& wmRect, const Rect& preRect, WindowSizeChangeReason wmReason, 480 const std::shared_ptr<RSTransaction>& rsTransaction = nullptr); 481 void UpdateRectForOtherReasonTask(const Rect& wmRect, const Rect& preRect, WindowSizeChangeReason wmReason, 482 const std::shared_ptr<RSTransaction>& rsTransaction); 483 void NotifyRotationAnimationEnd(); 484 void SubmitNoInteractionMonitorTask(int32_t eventId, const IWindowNoInteractionListenerSptr& listener); 485 bool IsUserOrientation(Orientation orientation) const; 486 WMError GetAppForceLandscapeConfig(AppForceLandscapeConfig& config); 487 void SetForceSplitEnable(bool isForceSplit, const std::string& homePage = ""); 488 void SetFrameLayoutCallbackEnable(bool enable); 489 void UpdateFrameLayoutCallbackIfNeeded(WindowSizeChangeReason wmReason); 490 void SetUniqueVirtualPixelRatioForSub(bool useUniqueDensity, float virtualPixelRatio); 491 bool IsNotifyInteractiveDuplicative(bool interactive); 492 493 /* 494 * PC Window 495 */ 496 void GetTitleButtonVisible(bool& hideMaximizeButton, bool& hideMinimizeButton, bool& hideSplitButton, 497 bool& hideCloseButton); 498 499 static std::recursive_mutex lifeCycleListenerMutex_; 500 static std::recursive_mutex windowChangeListenerMutex_; 501 static std::recursive_mutex avoidAreaChangeListenerMutex_; 502 static std::recursive_mutex dialogDeathRecipientListenerMutex_; 503 static std::recursive_mutex dialogTargetTouchListenerMutex_; 504 static std::recursive_mutex occupiedAreaChangeListenerMutex_; 505 static std::recursive_mutex screenshotListenerMutex_; 506 static std::recursive_mutex touchOutsideListenerMutex_; 507 static std::recursive_mutex windowVisibilityChangeListenerMutex_; 508 static std::recursive_mutex windowNoInteractionListenerMutex_; 509 static std::recursive_mutex windowStatusChangeListenerMutex_; 510 static std::recursive_mutex windowTitleButtonRectChangeListenerMutex_; 511 static std::mutex displayMoveListenerMutex_; 512 static std::mutex windowRectChangeListenerMutex_; 513 static std::mutex subWindowCloseListenersMutex_; 514 static std::mutex mainWindowCloseListenersMutex_; 515 static std::mutex switchFreeMultiWindowListenerMutex_; 516 static std::map<int32_t, std::vector<sptr<IWindowLifeCycle>>> lifecycleListeners_; 517 static std::map<int32_t, std::vector<sptr<IDisplayMoveListener>>> displayMoveListeners_; 518 static std::map<int32_t, std::vector<sptr<IWindowChangeListener>>> windowChangeListeners_; 519 static std::map<int32_t, std::vector<sptr<IAvoidAreaChangedListener>>> avoidAreaChangeListeners_; 520 static std::map<int32_t, std::vector<sptr<IDialogDeathRecipientListener>>> dialogDeathRecipientListeners_; 521 static std::map<int32_t, std::vector<sptr<IDialogTargetTouchListener>>> dialogTargetTouchListener_; 522 static std::map<int32_t, std::vector<sptr<IOccupiedAreaChangeListener>>> occupiedAreaChangeListeners_; 523 static std::map<int32_t, std::vector<sptr<IScreenshotListener>>> screenshotListeners_; 524 static std::map<int32_t, std::vector<sptr<ITouchOutsideListener>>> touchOutsideListeners_; 525 static std::map<int32_t, std::vector<IWindowVisibilityListenerSptr>> windowVisibilityChangeListeners_; 526 static std::mutex displayIdChangeListenerMutex_; 527 static std::map<int32_t, std::vector<IDisplayIdChangeListenerSptr>> displayIdChangeListeners_; 528 static std::map<int32_t, std::vector<IWindowNoInteractionListenerSptr>> windowNoInteractionListeners_; 529 static std::map<int32_t, std::vector<sptr<IWindowStatusChangeListener>>> windowStatusChangeListeners_; 530 static std::map<int32_t, std::vector<sptr<IWindowTitleButtonRectChangedListener>>> 531 windowTitleButtonRectChangeListeners_; 532 static std::map<int32_t, std::vector<sptr<IWindowRectChangeListener>>> windowRectChangeListeners_; 533 static std::map<int32_t, sptr<ISubWindowCloseListener>> subWindowCloseListeners_; 534 static std::map<int32_t, sptr<IMainWindowCloseListener>> mainWindowCloseListeners_; 535 static std::map<int32_t, std::vector<sptr<ISwitchFreeMultiWindowListener>>> switchFreeMultiWindowListeners_; 536 537 // FA only 538 sptr<IAceAbilityHandler> aceAbilityHandler_; 539 540 std::atomic<int32_t> lastInteractionEventId_ { 0 }; 541 542 bool isMainHandlerAvailable_ = true; 543 544 std::string subWindowTitle_ = { "" }; 545 std::string dialogTitle_ = { "" }; 546 std::shared_mutex keyEventFilterMutex_; 547 KeyEventFilterFunc keyEventFilter_; 548 WindowTitleVisibleFlags windowTitleVisibleFlags_; 549 sptr<WindowOption> windowOption_; 550 std::string restoredRouterStack_; // It was set and get in same thread, which is js thread. 551 552 /* 553 * Window Layout 554 */ 555 WSRect layoutRect_; 556 std::atomic_bool windowSizeChanged_ = false; 557 std::atomic_bool enableFrameLayoutFinishCb_ = false; 558 WindowSizeChangeReason lastSizeChangeReason_ = WindowSizeChangeReason::END; 559 bool postTaskDone_ = false; 560 int16_t rotationAnimationCount_ { 0 }; 561 562 /* 563 * PC Window 564 */ 565 uint32_t targetAPIVersion_ = 0; 566 }; 567 } // namespace Rosen 568 } // namespace OHOS 569 570 #endif // OHOS_ROSEN_WINDOW_SESSION_IMPL_H 571