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 }, 148 const std::map<AvoidAreaType, AvoidArea>& avoidAreas = {}) override; 149 void UpdateDensity() override; 150 void SetUniqueVirtualPixelRatio(bool useUniqueDensity, float virtualPixelRatio) override; 151 WSError UpdateOrientation() override; 152 WSError UpdateDisplayId(uint64_t displayId) override; 153 WSError UpdateFocus(bool focus) override; 154 bool IsFocused() const override; 155 WMError RequestFocus() const override; 156 WMError RequestFocusByClient(bool isFocused) const override; 157 WSError UpdateWindowMode(WindowMode mode) override; 158 WSError HandleBackEvent() override; 159 WMError SetSystemBarProperty(WindowType type, const SystemBarProperty& property) override; 160 KeyboardAnimationConfig GetKeyboardAnimationConfig() override; 161 162 void NotifyPointerEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent) override; 163 void NotifyKeyEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent, bool& isConsumed, 164 bool notifyInputMethod = true) override; 165 void NotifyOccupiedAreaChangeInfoInner(sptr<OccupiedAreaChangeInfo> info); 166 void NotifyOccupiedAreaChangeInfo(sptr<OccupiedAreaChangeInfo> info, 167 const std::shared_ptr<RSTransaction>& rsTransaction = nullptr) override; 168 void NotifyForegroundInteractiveStatus(bool interactive) override; 169 void NotifyDisplayMove(DisplayId from, DisplayId to) override; 170 171 WMError RegisterLifeCycleListener(const sptr<IWindowLifeCycle>& listener) override; 172 WMError UnregisterLifeCycleListener(const sptr<IWindowLifeCycle>& listener) override; 173 WMError RegisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) override; 174 WMError UnregisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) override; 175 WMError RegisterWindowChangeListener(const sptr<IWindowChangeListener>& listener) override; 176 WMError UnregisterWindowChangeListener(const sptr<IWindowChangeListener>& listener) override; 177 WMError RegisterAvoidAreaChangeListener(sptr<IAvoidAreaChangedListener>& listener) override; 178 WMError UnregisterAvoidAreaChangeListener(sptr<IAvoidAreaChangedListener>& listener) override; 179 void RegisterDialogDeathRecipientListener(const sptr<IDialogDeathRecipientListener>& listener) override; 180 void UnregisterDialogDeathRecipientListener(const sptr<IDialogDeathRecipientListener>& listener) override; 181 WMError RegisterDialogTargetTouchListener(const sptr<IDialogTargetTouchListener>& listener) override; 182 WMError UnregisterDialogTargetTouchListener(const sptr<IDialogTargetTouchListener>& listener) override; 183 WMError RegisterOccupiedAreaChangeListener(const sptr<IOccupiedAreaChangeListener>& listener) override; 184 WMError UnregisterOccupiedAreaChangeListener(const sptr<IOccupiedAreaChangeListener>& listener) override; 185 WMError RegisterTouchOutsideListener(const sptr<ITouchOutsideListener>& listener) override; 186 WMError UnregisterTouchOutsideListener(const sptr<ITouchOutsideListener>& listener) override; 187 WMError RegisterWindowVisibilityChangeListener(const IWindowVisibilityListenerSptr& listener) override; 188 WMError UnregisterWindowVisibilityChangeListener(const IWindowVisibilityListenerSptr& listener) override; 189 WMError RegisterDisplayIdChangeListener(const IDisplayIdChangeListenerSptr& listener) override; 190 WMError UnregisterDisplayIdChangeListener(const IDisplayIdChangeListenerSptr& listener) override; 191 WMError RegisterSystemDensityChangeListener(const ISystemDensityChangeListenerSptr& listener) override; 192 WMError UnregisterSystemDensityChangeListener(const ISystemDensityChangeListenerSptr& listener) override; 193 WMError RegisterWindowNoInteractionListener(const IWindowNoInteractionListenerSptr& listener) override; 194 WMError UnregisterWindowNoInteractionListener(const IWindowNoInteractionListenerSptr& listener) override; 195 void RegisterWindowDestroyedListener(const NotifyNativeWinDestroyFunc& func) override; UnregisterWindowDestroyedListener()196 void UnregisterWindowDestroyedListener() override { notifyNativeFunc_ = nullptr; } 197 WMError RegisterScreenshotListener(const sptr<IScreenshotListener>& listener) override; 198 WMError UnregisterScreenshotListener(const sptr<IScreenshotListener>& listener) override; 199 void SetAceAbilityHandler(const sptr<IAceAbilityHandler>& handler) override; 200 void SetInputEventConsumer(const std::shared_ptr<IInputEventConsumer>& inputEventConsumer) override; 201 202 WMError SetBackgroundColor(const std::string& color) override; 203 virtual Orientation GetRequestedOrientation() override; 204 205 int32_t GetParentId() const; 206 int32_t GetPersistentId() const override; 207 sptr<WindowSessionProperty> GetProperty() const; 208 SystemSessionConfig GetSystemSessionConfig() const; 209 sptr<ISession> GetHostSession() const; 210 int32_t GetFloatingWindowParentId(); 211 void NotifyAfterForeground(bool needNotifyListeners = true, bool needNotifyUiContent = true); 212 void NotifyAfterBackground(bool needNotifyListeners = true, bool needNotifyUiContent = true); 213 void NotifyForegroundFailed(WMError ret); 214 void NotifyBackgroundFailed(WMError ret); 215 WSError MarkProcessed(int32_t eventId) override; 216 void UpdateTitleButtonVisibility(); 217 WSError NotifyDestroy() override; 218 WSError NotifyTransferComponentData(const AAFwk::WantParams& wantParams) override; 219 WSErrorCode NotifyTransferComponentDataSync(const AAFwk::WantParams& wantParams, 220 AAFwk::WantParams& reWantParams) override; 221 void NotifyAvoidAreaChange(const sptr<AvoidArea>& avoidArea, AvoidAreaType type); 222 WSError UpdateAvoidArea(const sptr<AvoidArea>& avoidArea, AvoidAreaType type) override; 223 void NotifyTouchDialogTarget(int32_t posX = 0, int32_t posY = 0) override; 224 void NotifyScreenshot() override; 225 void DumpSessionElementInfo(const std::vector<std::string>& params) override; 226 // colorspace, gamut 227 virtual bool IsSupportWideGamut() override; 228 virtual void SetColorSpace(ColorSpace colorSpace) override; 229 virtual ColorSpace GetColorSpace() override; 230 WSError NotifyTouchOutside() override; 231 WMError SetLandscapeMultiWindow(bool isLandscapeMultiWindow) override; 232 WSError NotifyWindowVisibility(bool isVisible) override; 233 WSError NotifyNoInteractionTimeout(const IWindowNoInteractionListenerSptr& listener); 234 WMError TransferAccessibilityEvent(const Accessibility::AccessibilityEventInfo& info, 235 int64_t uiExtensionIdLevel) override; 236 WindowState state_ { WindowState::STATE_INITIAL }; 237 WindowState requestState_ { WindowState::STATE_INITIAL }; 238 WSError UpdateMaximizeMode(MaximizeMode mode) override; 239 void NotifySessionForeground(uint32_t reason, bool withAnimation) override; 240 void NotifySessionBackground(uint32_t reason, bool withAnimation, bool isFromInnerkits) override; 241 WSError UpdateTitleInTargetPos(bool isShow, int32_t height) override; 242 WSError NotifyDialogStateChange(bool isForeground) override; 243 bool IsMainHandlerAvailable() const override; 244 245 /* 246 * PiP Window 247 */ 248 WSError NotifyCloseExistPipWindow() override; 249 WSError SetPipActionEvent(const std::string& action, int32_t status) override; 250 WSError SetPiPControlEvent(WsPiPControlType controlType, WsPiPControlStatus status) override; 251 WSError NotifyPipWindowSizeChange(uint32_t width, uint32_t height, double scale) override; 252 void UpdatePiPRect(const Rect& rect, WindowSizeChangeReason reason) override; 253 void UpdatePiPControlStatus(PiPControlType controlType, PiPControlStatus status) override; 254 void SetAutoStartPiP(bool isAutoStart, uint32_t priority) override; 255 256 void SetDrawingContentState(bool drawingContentState); 257 WMError RegisterWindowStatusChangeListener(const sptr<IWindowStatusChangeListener>& listener) override; 258 WMError UnregisterWindowStatusChangeListener(const sptr<IWindowStatusChangeListener>& listener) override; 259 WMError SetSpecificBarProperty(WindowType type, const SystemBarProperty& property) override; 260 void SetLayoutTransform(const Transform& trans); 261 Transform GetLayoutTransform() const override; 262 virtual WMError SetDecorVisible(bool isVisible) override; 263 virtual WMError SetWindowTitleMoveEnabled(bool enable) override; 264 virtual WMError SetDecorHeight(int32_t decorHeight) override; 265 virtual WMError GetDecorHeight(int32_t& height) override; 266 virtual WMError GetTitleButtonArea(TitleButtonRect& titleButtonRect) override; 267 268 /* 269 * Window Decor listener 270 */ 271 WMError RegisterWindowTitleButtonRectChangeListener( 272 const sptr<IWindowTitleButtonRectChangedListener>& listener) override; 273 WMError UnregisterWindowTitleButtonRectChangeListener( 274 const sptr<IWindowTitleButtonRectChangedListener>& listener) override; 275 void NotifyWindowTitleButtonRectChange(TitleButtonRect titleButtonRect); 276 WMError RegisterSubWindowCloseListeners(const sptr<ISubWindowCloseListener>& listener) override; 277 WMError UnregisterSubWindowCloseListeners(const sptr<ISubWindowCloseListener>& listener) override; 278 void NotifySubWindowClose(bool& terminateCloseProcess); 279 WMError RegisterMainWindowCloseListeners(const sptr<IMainWindowCloseListener>& listener) override; 280 WMError UnregisterMainWindowCloseListeners(const sptr<IMainWindowCloseListener>& listener) override; 281 WMError NotifyMainWindowClose(bool& terminateCloseProcess); 282 WMError RegisterWindowWillCloseListeners(const sptr<IWindowWillCloseListener>& listener) override; 283 WMError UnRegisterWindowWillCloseListeners(const sptr<IWindowWillCloseListener>& listener) override; 284 WMError NotifyWindowWillClose(sptr<Window> window); 285 286 WSError GetUIContentRemoteObj(sptr<IRemoteObject>& uiContentRemoteObj) override; 287 void RecoverSessionListener(); 288 void SetDefaultDisplayIdIfNeed(); 289 WMError RegisterWindowRectChangeListener(const sptr<IWindowRectChangeListener>& listener) override; 290 WMError UnregisterWindowRectChangeListener(const sptr<IWindowRectChangeListener>& listener) override; 291 WMError RegisterSwitchFreeMultiWindowListener(const sptr<ISwitchFreeMultiWindowListener>& listener) override; 292 WMError UnregisterSwitchFreeMultiWindowListener(const sptr<ISwitchFreeMultiWindowListener>& listener) override; 293 virtual WMError GetCallingWindowWindowStatus(WindowStatus& windowStatus) const override; 294 virtual WMError GetCallingWindowRect(Rect& rect) const override; 295 virtual void SetUiDvsyncSwitch(bool dvsyncSwitch) override; 296 WMError SetContinueState(int32_t continueState) override; 297 298 /* 299 * Multi Window 300 */ 301 WMError GetIsMidScene(bool& isMidScene) override; 302 303 /* 304 * Window Layout 305 */ 306 WMError EnableDrag(bool enableDrag) override; 307 WSError SetDragActivated(bool dragActivated) override; 308 WSError SetEnableDragBySystem(bool enableDrag) override; 309 bool IsWindowDraggable(); 310 311 /* 312 * Window Property 313 */ 314 WSError NotifyDisplayIdChange(DisplayId displayId); 315 316 /* 317 * HightLight Window 318 */ 319 bool GetExclusivelyHighlighted() const; 320 WMError IsWindowHighlighted(bool& highlighted) const override; 321 WMError SetExclusivelyHighlighted(bool isExclusivelyHighlighted) override; 322 WMError RegisterWindowHighlightChangeListeners(const sptr<IWindowHighlightChangeListener>& listener) override; 323 WMError UnregisterWindowHighlightChangeListeners(const sptr<IWindowHighlightChangeListener>& listener) override; 324 WSError NotifyHighlightChange(bool isHighlight) override; 325 protected: 326 WMError Connect(); 327 bool IsWindowSessionInvalid() const; 328 void NotifyWindowAfterUnfocused(); 329 void NotifyWindowAfterFocused(); 330 void NotifyAfterActive(); 331 void NotifyAfterInactive(); 332 void NotifyBeforeDestroy(std::string windowName); 333 void NotifyAfterDestroy(); 334 void ClearListenersById(int32_t persistentId); 335 void ClearSwitchFreeMultiWindowListenersById(int32_t persistentId); 336 void ClearVsyncStation(); 337 WMError WindowSessionCreateCheck(); 338 void UpdateDecorEnableToAce(bool isDecorEnable); 339 void UpdateDecorEnable(bool needNotify = false, WindowMode mode = WindowMode::WINDOW_MODE_UNDEFINED); 340 void NotifyModeChange(WindowMode mode, bool hasDeco = true); 341 WMError UpdateProperty(WSPropertyChangeAction action); 342 WMError SetBackgroundColor(uint32_t color); 343 uint32_t GetBackgroundColor() const; 344 virtual WMError SetLayoutFullScreenByApiVersion(bool status); 345 float GetVirtualPixelRatio() override; 346 virtual float GetVirtualPixelRatio(const sptr<DisplayInfo>& displayInfo); 347 void UpdateViewportConfig(const Rect& rect, WindowSizeChangeReason reason, 348 const std::shared_ptr<RSTransaction>& rsTransaction = nullptr, 349 const sptr<DisplayInfo>& info = nullptr, 350 const std::map<AvoidAreaType, AvoidArea>& avoidAreas = {}); 351 void NotifySizeChange(Rect rect, WindowSizeChangeReason reason); 352 void NotifySwitchFreeMultiWindow(bool enable); 353 static sptr<Window> FindWindowById(uint32_t winId); 354 void NotifyWindowStatusChange(WindowMode mode); 355 void NotifyTransformChange(const Transform& transForm) override; 356 void NotifySingleHandTransformChange(const SingleHandTransform& singleHandTransform) override; 357 bool IsKeyboardEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent) const; 358 void DispatchKeyEventCallback(const std::shared_ptr<MMI::KeyEvent>& keyEvent, bool& isConsumed); 359 void CopyUniqueDensityParameter(sptr<WindowSessionImpl> parentWindow); 360 sptr<WindowSessionImpl> FindMainWindowWithContext(); 361 sptr<WindowSessionImpl> FindExtensionWindowWithContext(); 362 363 WMError RegisterExtensionAvoidAreaChangeListener(sptr<IAvoidAreaChangedListener>& listener); 364 WMError UnregisterExtensionAvoidAreaChangeListener(sptr<IAvoidAreaChangedListener>& listener); 365 366 void RefreshNoInteractionTimeoutMonitor(); 367 WindowStatus GetWindowStatusInner(WindowMode mode); 368 369 /* 370 * PC Event Filter 371 */ 372 bool FilterKeyEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent); 373 bool FilterPointerEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent); 374 WMError SetKeyEventFilter(KeyEventFilterFunc filter) override; 375 WMError ClearKeyEventFilter() override; 376 WMError SetMouseEventFilter(MouseEventFilterFunc filter) override; 377 WMError ClearMouseEventFilter() override; 378 WMError SetTouchEventFilter(TouchEventFilterFunc filter) override; 379 WMError ClearTouchEventFilter() override; 380 381 /** 382 * Sub Window 383 */ 384 void UpdateSubWindowStateAndNotify(int32_t parentPersistentId, const WindowState newState); 385 void DestroySubWindow(); 386 387 sptr<ISession> hostSession_; 388 mutable std::mutex hostSessionMutex_; 389 std::shared_ptr<Ace::UIContent> uiContent_; 390 mutable std::shared_mutex uiContentMutex_; 391 std::shared_ptr<AbilityRuntime::Context> context_; 392 std::shared_ptr<RSSurfaceNode> surfaceNode_; 393 394 sptr<WindowSessionProperty> property_; 395 SystemSessionConfig windowSystemConfig_; 396 NotifyNativeWinDestroyFunc notifyNativeFunc_; 397 398 std::recursive_mutex mutex_; 399 static std::map<std::string, std::pair<int32_t, sptr<WindowSessionImpl>>> windowSessionMap_; 400 // protect windowSessionMap_ 401 static std::shared_mutex windowSessionMutex_; 402 static std::set<sptr<WindowSessionImpl>> windowExtensionSessionSet_; 403 // protect windowExtensionSessionSet_ 404 static std::shared_mutex windowExtensionSessionMutex_; 405 static std::map<int32_t, std::vector<sptr<WindowSessionImpl>>> subWindowSessionMap_; 406 bool isSystembarPropertiesSet_ = false; 407 bool isIgnoreSafeAreaNeedNotify_ = false; 408 bool isIgnoreSafeArea_ = false; 409 std::atomic_bool isFocused_ = false; 410 std::atomic_bool isHighlighted_ = false; 411 std::shared_ptr<AppExecFwk::EventHandler> handler_ = nullptr; 412 bool shouldReNotifyFocus_ = false; 413 std::shared_ptr<VsyncStation> vsyncStation_ = nullptr; 414 std::shared_ptr<IInputEventConsumer> inputEventConsumer_; 415 bool useUniqueDensity_ { false }; 416 float virtualPixelRatio_ { 1.0f }; 417 bool escKeyEventTriggered_ = false; 418 // Check whether the UIExtensionAbility process is started 419 static bool isUIExtensionAbilityProcess_; 420 WSError SwitchFreeMultiWindow(bool enable) override; 421 std::string identityToken_ = { "" }; 422 void MakeSubOrDialogWindowDragableAndMoveble(); IsFreeMultiWindowMode()423 bool IsFreeMultiWindowMode() const 424 { 425 return windowSystemConfig_.IsFreeMultiWindowMode(); 426 } 427 428 /* 429 * DFX 430 */ 431 void SetUIContentComplete(); 432 void AddSetUIContentTimeoutCheck(); 433 void NotifySetUIContentComplete(); NotifyExtensionTimeout(int32_t errorCode)434 virtual void NotifyExtensionTimeout(int32_t errorCode) {} 435 std::atomic_bool setUIContentCompleted_ { false }; 436 void SetUIExtensionDestroyComplete(); 437 void SetUIExtensionDestroyCompleteInSubWindow(); 438 void AddSetUIExtensionDestroyTimeoutCheck(); 439 std::atomic_bool setUIExtensionDestroyCompleted_ { false }; 440 std::atomic_bool startUIExtensionDestroyTimer_ { false }; 441 enum TimeoutErrorCode : int32_t { 442 SET_UICONTENT_TIMEOUT = 1000, 443 SET_UIEXTENSION_DESTROY_TIMEOUT 444 }; 445 446 /* 447 * Window Lifecycle 448 */ 449 bool hasFirstNotifyInteractive_ = false; 450 bool interactive_ = true; 451 452 /* 453 * Window Layout 454 */ 455 sptr<FutureCallback> layoutCallback_ = nullptr; 456 void FlushLayoutSize(int32_t width, int32_t height) override; 457 void UpdateVirtualPixelRatio(const sptr<Display>& display); 458 mutable std::recursive_mutex transformMutex_; 459 460 /* 461 * Window Immersive 462 */ 463 std::map<AvoidAreaType, AvoidArea> lastAvoidAreaMap_; 464 465 /* 466 * Window Property 467 */ 468 float lastSystemDensity_ = UNDEFINED_DENSITY; 469 WSError NotifySystemDensityChange(float density); 470 471 private: 472 //Trans between colorGamut and colorSpace 473 static ColorSpace GetColorSpaceFromSurfaceGamut(GraphicColorGamut colorGamut); 474 static GraphicColorGamut GetSurfaceGamutFromColorSpace(ColorSpace colorSpace); 475 476 template<typename T> WMError RegisterListener(std::vector<sptr<T>>& holder, const sptr<T>& listener); 477 template<typename T> WMError UnregisterListener(std::vector<sptr<T>>& holder, const sptr<T>& listener); 478 template<typename T> EnableIfSame<T, IWindowLifeCycle, std::vector<sptr<IWindowLifeCycle>>> GetListeners(); 479 template<typename T> EnableIfSame<T, IDisplayMoveListener, std::vector<sptr<IDisplayMoveListener>>> GetListeners(); 480 template<typename T> 481 EnableIfSame<T, IWindowChangeListener, std::vector<sptr<IWindowChangeListener>>> GetListeners(); 482 template<typename T> 483 EnableIfSame<T, IAvoidAreaChangedListener, std::vector<sptr<IAvoidAreaChangedListener>>> GetListeners(); 484 template<typename T> 485 EnableIfSame<T, IDialogDeathRecipientListener, std::vector<sptr<IDialogDeathRecipientListener>>> GetListeners(); 486 template<typename T> 487 EnableIfSame<T, IDialogTargetTouchListener, std::vector<sptr<IDialogTargetTouchListener>>> GetListeners(); 488 template<typename T> 489 EnableIfSame<T, IOccupiedAreaChangeListener, std::vector<sptr<IOccupiedAreaChangeListener>>> GetListeners(); 490 template<typename T> 491 EnableIfSame<T, IScreenshotListener, std::vector<sptr<IScreenshotListener>>> GetListeners(); 492 template<typename T> 493 EnableIfSame<T, ITouchOutsideListener, std::vector<sptr<ITouchOutsideListener>>> GetListeners(); 494 template<typename T> 495 EnableIfSame<T, IWindowVisibilityChangedListener, std::vector<IWindowVisibilityListenerSptr>> GetListeners(); 496 template<typename T> 497 EnableIfSame<T, IDisplayIdChangeListener, std::vector<IDisplayIdChangeListenerSptr>> GetListeners(); 498 template<typename T> 499 EnableIfSame<T, ISystemDensityChangeListener, std::vector<ISystemDensityChangeListenerSptr>> GetListeners(); 500 template<typename T> 501 EnableIfSame<T, IWindowNoInteractionListener, std::vector<IWindowNoInteractionListenerSptr>> GetListeners(); 502 template<typename T> void ClearUselessListeners(std::map<int32_t, T>& listeners, int32_t persistentId); 503 template<typename T> void ClearUselessListeners(std::unordered_map<int32_t, T>& listeners, int32_t persistentId); 504 RSSurfaceNode::SharedPtr CreateSurfaceNode(std::string name, WindowType type); 505 template<typename T> 506 EnableIfSame<T, IWindowStatusChangeListener, std::vector<sptr<IWindowStatusChangeListener>>> GetListeners(); 507 template<typename T> 508 EnableIfSame<T, IWindowRectChangeListener, std::vector<sptr<IWindowRectChangeListener>>> GetListeners(); 509 template<typename T> 510 EnableIfSame<T, ISwitchFreeMultiWindowListener, std::vector<sptr<ISwitchFreeMultiWindowListener>>> GetListeners(); 511 template<typename T> 512 EnableIfSame<T, IWindowHighlightChangeListener, std::vector<sptr<IWindowHighlightChangeListener>>> GetListeners(); 513 void NotifyAfterFocused(); 514 void NotifyUIContentFocusStatus(); 515 void NotifyAfterUnfocused(bool needNotifyUiContent = true); 516 void NotifyAfterResumed(); 517 void NotifyAfterPaused(); 518 519 /* 520 * Window Decor listener 521 */ 522 template<typename T> 523 EnableIfSame<T, IWindowTitleButtonRectChangedListener, 524 std::vector<sptr<IWindowTitleButtonRectChangedListener>>> GetListeners(); 525 template<typename T> 526 EnableIfSame<T, ISubWindowCloseListener, sptr<ISubWindowCloseListener>> GetListeners(); 527 template<typename T> 528 EnableIfSame<T, IMainWindowCloseListener, sptr<IMainWindowCloseListener>> GetListeners(); 529 template<typename T> 530 EnableIfSame<T, IWindowWillCloseListener, std::vector<sptr<IWindowWillCloseListener>>> GetListeners(); 531 532 WMError InitUIContent(const std::string& contentInfo, napi_env env, napi_value storage, 533 WindowSetUIContentType setUIContentType, BackupAndRestoreType restoreType, AppExecFwk::Ability* ability, 534 OHOS::Ace::UIContentErrorCode& aceRet); 535 WMError SetUIContentInner(const std::string& contentInfo, napi_env env, napi_value storage, 536 WindowSetUIContentType setUIContentType, BackupAndRestoreType restoreType, AppExecFwk::Ability* ability); 537 std::shared_ptr<std::vector<uint8_t>> GetAbcContent(const std::string& abcPath); 538 inline void DestroyExistUIContent(); 539 std::string GetRestoredRouterStack(); 540 541 void UpdateRectForRotation(const Rect& wmRect, const Rect& preRect, WindowSizeChangeReason wmReason, 542 const SceneAnimationConfig& config, const std::map<AvoidAreaType, AvoidArea>& avoidAreas = {}); 543 void UpdateRectForOtherReason(const Rect& wmRect, const Rect& preRect, WindowSizeChangeReason wmReason, 544 const std::shared_ptr<RSTransaction>& rsTransaction = nullptr, 545 const std::map<AvoidAreaType, AvoidArea>& avoidAreas = {}); 546 void UpdateRectForOtherReasonTask(const Rect& wmRect, const Rect& preRect, WindowSizeChangeReason wmReason, 547 const std::shared_ptr<RSTransaction>& rsTransaction, 548 const std::map<AvoidAreaType, AvoidArea>& avoidAreas = {}); 549 void NotifyRotationAnimationEnd(); 550 void SubmitNoInteractionMonitorTask(int32_t eventId, const IWindowNoInteractionListenerSptr& listener); 551 bool IsUserOrientation(Orientation orientation) const; 552 WMError GetAppForceLandscapeConfig(AppForceLandscapeConfig& config); 553 void SetForceSplitEnable(bool isForceSplit, const std::string& homePage = ""); 554 void SetFrameLayoutCallbackEnable(bool enable); 555 void UpdateFrameLayoutCallbackIfNeeded(WindowSizeChangeReason wmReason); 556 void SetUniqueVirtualPixelRatioForSub(bool useUniqueDensity, float virtualPixelRatio); 557 bool IsNotifyInteractiveDuplicative(bool interactive); 558 559 /* 560 * PC Window 561 */ 562 void GetTitleButtonVisible(bool& hideMaximizeButton, bool& hideMinimizeButton, bool& hideSplitButton, 563 bool& hideCloseButton); 564 565 static std::recursive_mutex lifeCycleListenerMutex_; 566 static std::recursive_mutex windowChangeListenerMutex_; 567 static std::recursive_mutex avoidAreaChangeListenerMutex_; 568 static std::recursive_mutex dialogDeathRecipientListenerMutex_; 569 static std::recursive_mutex dialogTargetTouchListenerMutex_; 570 static std::recursive_mutex occupiedAreaChangeListenerMutex_; 571 static std::recursive_mutex screenshotListenerMutex_; 572 static std::recursive_mutex touchOutsideListenerMutex_; 573 static std::recursive_mutex windowVisibilityChangeListenerMutex_; 574 static std::recursive_mutex windowNoInteractionListenerMutex_; 575 static std::recursive_mutex windowStatusChangeListenerMutex_; 576 static std::mutex displayMoveListenerMutex_; 577 static std::mutex windowRectChangeListenerMutex_; 578 static std::mutex switchFreeMultiWindowListenerMutex_; 579 static std::mutex highlightChangeListenerMutex_; 580 static std::map<int32_t, std::vector<sptr<IWindowLifeCycle>>> lifecycleListeners_; 581 static std::map<int32_t, std::vector<sptr<IDisplayMoveListener>>> displayMoveListeners_; 582 static std::map<int32_t, std::vector<sptr<IWindowChangeListener>>> windowChangeListeners_; 583 static std::map<int32_t, std::vector<sptr<IAvoidAreaChangedListener>>> avoidAreaChangeListeners_; 584 static std::map<int32_t, std::vector<sptr<IDialogDeathRecipientListener>>> dialogDeathRecipientListeners_; 585 static std::map<int32_t, std::vector<sptr<IDialogTargetTouchListener>>> dialogTargetTouchListener_; 586 static std::map<int32_t, std::vector<sptr<IOccupiedAreaChangeListener>>> occupiedAreaChangeListeners_; 587 static std::map<int32_t, std::vector<sptr<IScreenshotListener>>> screenshotListeners_; 588 static std::map<int32_t, std::vector<sptr<ITouchOutsideListener>>> touchOutsideListeners_; 589 static std::map<int32_t, std::vector<IWindowVisibilityListenerSptr>> windowVisibilityChangeListeners_; 590 static std::mutex displayIdChangeListenerMutex_; 591 static std::map<int32_t, std::vector<IDisplayIdChangeListenerSptr>> displayIdChangeListeners_; 592 static std::mutex systemDensityChangeListenerMutex_; 593 static std::unordered_map<int32_t, std::vector<ISystemDensityChangeListenerSptr>> systemDensityChangeListeners_; 594 static std::map<int32_t, std::vector<IWindowNoInteractionListenerSptr>> windowNoInteractionListeners_; 595 static std::map<int32_t, std::vector<sptr<IWindowStatusChangeListener>>> windowStatusChangeListeners_; 596 static std::map<int32_t, std::vector<sptr<IWindowRectChangeListener>>> windowRectChangeListeners_; 597 static std::map<int32_t, std::vector<sptr<ISwitchFreeMultiWindowListener>>> switchFreeMultiWindowListeners_; 598 static std::map<int32_t, std::vector<sptr<IWindowHighlightChangeListener>>> highlightChangeListeners_; 599 600 // FA only 601 sptr<IAceAbilityHandler> aceAbilityHandler_; 602 603 std::atomic<int32_t> lastInteractionEventId_ { 0 }; 604 605 bool isMainHandlerAvailable_ = true; 606 607 std::string subWindowTitle_ = { "" }; 608 std::string dialogTitle_ = { "" }; 609 WindowTitleVisibleFlags windowTitleVisibleFlags_; 610 sptr<WindowOption> windowOption_; 611 std::string restoredRouterStack_; // It was set and get in same thread, which is js thread. 612 613 /* 614 * Window Layout 615 */ 616 WSRect layoutRect_; 617 std::atomic_bool windowSizeChanged_ = false; 618 std::atomic_bool enableFrameLayoutFinishCb_ = false; 619 std::atomic_bool dragActivated_ = true; 620 WindowSizeChangeReason lastSizeChangeReason_ = WindowSizeChangeReason::END; 621 bool postTaskDone_ = false; 622 int16_t rotationAnimationCount_ { 0 }; 623 Transform layoutTransform_; 624 SingleHandTransform singleHandTransform_; 625 626 /* 627 * Window Decor listener 628 */ 629 static std::recursive_mutex windowTitleButtonRectChangeListenerMutex_; 630 static std::map<int32_t, std::vector<sptr<IWindowTitleButtonRectChangedListener>>> 631 windowTitleButtonRectChangeListeners_; 632 static std::mutex subWindowCloseListenersMutex_; 633 static std::map<int32_t, sptr<ISubWindowCloseListener>> subWindowCloseListeners_; 634 static std::mutex mainWindowCloseListenersMutex_; 635 static std::map<int32_t, sptr<IMainWindowCloseListener>> mainWindowCloseListeners_; 636 static std::mutex windowWillCloseListenersMutex_; 637 static std::unordered_map<int32_t, std::vector<sptr<IWindowWillCloseListener>>> windowWillCloseListeners_; 638 639 /* 640 * PC Window 641 */ 642 uint32_t targetAPIVersion_ = 0; 643 644 /* 645 * PC Event Filter 646 */ 647 std::mutex keyEventFilterMutex_; 648 KeyEventFilterFunc keyEventFilter_; 649 std::mutex mouseEventFilterMutex_; 650 MouseEventFilterFunc mouseEventFilter_; 651 std::mutex touchEventFilterMutex_; 652 TouchEventFilterFunc touchEventFilter_; 653 654 /* 655 * Window Scene 656 */ NotifyWindowAttachStateChange(bool isAttach)657 WSError NotifyWindowAttachStateChange(bool isAttach) override { return WSError::WS_OK; } 658 }; 659 } // namespace Rosen 660 } // namespace OHOS 661 662 #endif // OHOS_ROSEN_WINDOW_SESSION_IMPL_H 663