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 21 #include <shared_mutex> 22 #include <ability_context.h> 23 #include <event_handler.h> 24 #include <i_input_event_consumer.h> 25 #include <ui_content.h> 26 #include <ui/rs_surface_node.h> 27 #include "display_manager.h" 28 #include "singleton_container.h" 29 30 #include "common/include/window_session_property.h" 31 #include "display_info.h" 32 #include "future_callback.h" 33 #include "interfaces/include/ws_common.h" 34 #include "interfaces/include/ws_common_inner.h" 35 #include "session/container/include/zidl/session_stage_stub.h" 36 #include "session/host/include/zidl/session_interface.h" 37 #include "vsync_station.h" 38 #include "window.h" 39 #include "window_helper.h" 40 #include "window_option.h" 41 #include "wm_common.h" 42 #include "wm_common_inner.h" 43 44 namespace OHOS { 45 namespace Rosen { 46 namespace { 47 template<typename T1, typename T2, typename Ret> 48 using EnableIfSame = typename std::enable_if<std::is_same_v<T1, T2>, Ret>::type; 49 50 /* 51 * DFX 52 */ 53 const std::string SET_UICONTENT_TIMEOUT_LISTENER_TASK_NAME = "SetUIContentTimeoutListener"; 54 constexpr int64_t SET_UICONTENT_TIMEOUT_TIME_MS = 4000; 55 constexpr int64_t SET_UICONTENT_TIMEOUT_TIME_AFTER_FREEZE_MS = 5000; 56 } 57 58 struct WindowTitleVisibleFlags { 59 bool isMaximizeVisible = true; 60 bool isMinimizeVisible = true; 61 bool isSplitVisible = true; 62 bool isCloseVisible = true; 63 }; 64 65 class WindowSessionImpl : public Window, public virtual SessionStageStub { 66 public: 67 explicit WindowSessionImpl(const sptr<WindowOption>& option); 68 ~WindowSessionImpl(); 69 70 static sptr<Window> Find(const std::string& name); 71 static std::vector<sptr<Window>> GetSubWindow(int parentId); 72 73 virtual WMError Create(const std::shared_ptr<AbilityRuntime::Context>& context, 74 const sptr<Rosen::ISession>& iSession, 75 const std::string& identityToken = "") { return WMError::WM_OK; } 76 77 /* 78 * inherits from window 79 */ 80 WMError Show(uint32_t reason = 0, bool withAnimation = false, bool withFocus = true) override; 81 WMError Hide(uint32_t reason = 0, bool withAnimation = false, bool isFromInnerkits = true) override; 82 WMError Destroy() override; 83 virtual WMError Destroy(bool needNotifyServer, bool needClearListener = true); 84 WMError NapiSetUIContent(const std::string& contentInfo, napi_env env, napi_value storage, 85 BackupAndRestoreType type, sptr<IRemoteObject> token, AppExecFwk::Ability* ability) override; 86 WMError SetUIContentByName(const std::string& contentInfo, napi_env env, napi_value storage, 87 AppExecFwk::Ability* ability) override; 88 WMError SetUIContentByAbc(const std::string& abcPath, napi_env env, napi_value storage, 89 AppExecFwk::Ability* ability) override; 90 std::shared_ptr<RSSurfaceNode> GetSurfaceNode() const override; 91 const std::shared_ptr<AbilityRuntime::Context> GetContext() const override; 92 Rect GetRequestRect() const override; 93 WindowType GetType() const override; 94 const std::string& GetWindowName() const override; 95 WindowState GetWindowState() const override; 96 WindowState GetRequestWindowState() const; 97 WMError SetFocusable(bool isFocusable) override; 98 WMError SetTouchable(bool isTouchable) override; 99 100 /* 101 * Window Hierarchy 102 */ 103 WMError SetTopmost(bool topmost) override; 104 bool IsTopmost() const override; 105 WMError SetMainWindowTopmost(bool isTopmost) override; 106 bool IsMainWindowTopmost() const override; 107 void SetSubWindowZLevelToProperty(); 108 int32_t GetSubWindowZLevelByFlags(WindowType type, uint32_t windowFlags, bool isTopmost); 109 110 WMError SetResizeByDragEnabled(bool dragEnabled) override; 111 WMError SetRaiseByClickEnabled(bool raiseEnabled) override; 112 WMError HideNonSystemFloatingWindows(bool shouldHide) override; 113 WMError SetSingleFrameComposerEnabled(bool enable) override; 114 bool IsFloatingWindowAppType() const override; 115 116 /* 117 * PC Window 118 */ 119 bool IsPcWindow() const override; 120 bool IsPcOrPadCapabilityEnabled() const override; 121 bool IsPcOrPadFreeMultiWindowMode() const override; 122 bool IsSceneBoardEnabled() const override; 123 bool GetCompatibleModeInPc() const override; 124 WMError SetWindowDelayRaiseEnabled(bool isEnabled) override; 125 bool IsWindowDelayRaiseEnabled() const override; 126 WMError SetTitleButtonVisible(bool isMaximizeVisible, bool isMinimizeVisible, bool isSplitVisible, 127 bool isCloseVisible) override; 128 WMError SetSubWindowModal(bool isModal, ModalityType modalityType = ModalityType::WINDOW_MODALITY) override; 129 WMError SetWindowModal(bool isModal) override; 130 void SetTargetAPIVersion(uint32_t targetAPIVersion); 131 uint32_t GetTargetAPIVersion() const; 132 133 WMError SetWindowType(WindowType type) override; 134 WMError SetBrightness(float brightness) override; 135 virtual float GetBrightness() const override; 136 void SetRequestedOrientation(Orientation orientation, bool needAnimation = true) override; 137 bool GetTouchable() const override; 138 uint32_t GetWindowId() const override; 139 uint64_t GetDisplayId() const override; 140 Rect GetRect() const override; 141 bool GetFocusable() const override; 142 std::string GetContentInfo(BackupAndRestoreType type = BackupAndRestoreType::CONTINUATION) override; 143 WMError SetRestoredRouterStack(const std::string& routerStack) override; 144 Ace::UIContent* GetUIContent() const override; 145 std::shared_ptr<Ace::UIContent> GetUIContentSharedPtr() const; 146 Ace::UIContent* GetUIContentWithId(uint32_t winId) const override; 147 void OnNewWant(const AAFwk::Want& want) override; 148 void RequestVsync(const std::shared_ptr<VsyncCallback>& vsyncCallback) override; 149 int64_t GetVSyncPeriod() override; 150 void FlushFrameRate(uint32_t rate, int32_t animatorExpectedFrameRate, uint32_t rateType = 0) override; 151 void ConsumePointerEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent) override; 152 void ConsumeKeyEvent(std::shared_ptr<MMI::KeyEvent>& inputEvent) override; 153 bool PreNotifyKeyEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent) override; 154 155 /* 156 * inherits from session stage 157 */ 158 WSError SetActive(bool active) override; 159 WSError UpdateRect(const WSRect& rect, SizeChangeReason reason, 160 const SceneAnimationConfig& config = { nullptr, ROTATE_ANIMATION_DURATION }, 161 const std::map<AvoidAreaType, AvoidArea>& avoidAreas = {}) override; 162 void UpdateDensity() override; 163 void SetUniqueVirtualPixelRatio(bool useUniqueDensity, float virtualPixelRatio) override; 164 WSError UpdateOrientation() override; 165 WSError UpdateDisplayId(uint64_t displayId) override; 166 WSError UpdateFocus(bool focus) override; 167 bool IsFocused() const override; 168 WMError RequestFocus() const override; 169 WMError RequestFocusByClient(bool isFocused) const override; 170 WSError UpdateWindowMode(WindowMode mode) override; 171 WSError HandleBackEvent() override; 172 KeyboardAnimationConfig GetKeyboardAnimationConfig() override; 173 bool NotifyOnKeyPreImeEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent) override; 174 void NotifyPointerEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent) override; 175 void NotifyKeyEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent, bool& isConsumed, 176 bool notifyInputMethod = true) override; 177 void NotifyOccupiedAreaChangeInfoInner(sptr<OccupiedAreaChangeInfo> info); 178 void NotifyOccupiedAreaChangeInfo(sptr<OccupiedAreaChangeInfo> info, 179 const std::shared_ptr<RSTransaction>& rsTransaction = nullptr) override; 180 void NotifyKeyboardDidShow(const KeyboardPanelInfo& keyboardPanelInfo); 181 void NotifyKeyboardDidHide(const KeyboardPanelInfo& keyboardPanelInfo); 182 void NotifyKeyboardAnimationCompleted(const KeyboardPanelInfo& keyboardPanelInfo) override; 183 void NotifyForegroundInteractiveStatus(bool interactive) override; 184 void NotifyDisplayMove(DisplayId from, DisplayId to) override; 185 void NotifyWindowCrossAxisChange(CrossAxisState state) override; 186 187 WMError RegisterLifeCycleListener(const sptr<IWindowLifeCycle>& listener) override; 188 WMError UnregisterLifeCycleListener(const sptr<IWindowLifeCycle>& listener) override; 189 WMError RegisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) override; 190 WMError UnregisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) override; 191 WMError RegisterWindowChangeListener(const sptr<IWindowChangeListener>& listener) override; 192 WMError UnregisterWindowChangeListener(const sptr<IWindowChangeListener>& listener) override; 193 WMError RegisterWindowCrossAxisListener(const sptr<IWindowCrossAxisListener>& listener) override; 194 WMError UnregisterWindowCrossAxisListener(const sptr<IWindowCrossAxisListener>& listener) override; 195 void RegisterDialogDeathRecipientListener(const sptr<IDialogDeathRecipientListener>& listener) override; 196 void UnregisterDialogDeathRecipientListener(const sptr<IDialogDeathRecipientListener>& listener) override; 197 WMError RegisterDialogTargetTouchListener(const sptr<IDialogTargetTouchListener>& listener) override; 198 WMError UnregisterDialogTargetTouchListener(const sptr<IDialogTargetTouchListener>& listener) override; 199 WMError RegisterOccupiedAreaChangeListener(const sptr<IOccupiedAreaChangeListener>& listener) override; 200 WMError UnregisterOccupiedAreaChangeListener(const sptr<IOccupiedAreaChangeListener>& listener) override; 201 WMError RegisterKeyboardDidShowListener(const sptr<IKeyboardDidShowListener>& listener) override; 202 WMError UnregisterKeyboardDidShowListener(const sptr<IKeyboardDidShowListener>& listener) override; 203 WMError RegisterKeyboardDidHideListener(const sptr<IKeyboardDidHideListener>& listener) override; 204 WMError UnregisterKeyboardDidHideListener(const sptr<IKeyboardDidHideListener>& listener) override; 205 WMError RegisterTouchOutsideListener(const sptr<ITouchOutsideListener>& listener) override; 206 WMError UnregisterTouchOutsideListener(const sptr<ITouchOutsideListener>& listener) override; 207 WMError RegisterWindowVisibilityChangeListener(const IWindowVisibilityListenerSptr& listener) override; 208 WMError UnregisterWindowVisibilityChangeListener(const IWindowVisibilityListenerSptr& listener) override; 209 WMError RegisterDisplayIdChangeListener(const IDisplayIdChangeListenerSptr& listener) override; 210 WMError UnregisterDisplayIdChangeListener(const IDisplayIdChangeListenerSptr& listener) override; 211 WMError RegisterSystemDensityChangeListener(const ISystemDensityChangeListenerSptr& listener) override; 212 WMError UnregisterSystemDensityChangeListener(const ISystemDensityChangeListenerSptr& listener) override; 213 WMError RegisterWindowNoInteractionListener(const IWindowNoInteractionListenerSptr& listener) override; 214 WMError UnregisterWindowNoInteractionListener(const IWindowNoInteractionListenerSptr& listener) override; 215 void RegisterWindowDestroyedListener(const NotifyNativeWinDestroyFunc& func) override; UnregisterWindowDestroyedListener()216 void UnregisterWindowDestroyedListener() override { notifyNativeFunc_ = nullptr; } 217 WMError RegisterScreenshotListener(const sptr<IScreenshotListener>& listener) override; 218 WMError UnregisterScreenshotListener(const sptr<IScreenshotListener>& listener) override; 219 void SetAceAbilityHandler(const sptr<IAceAbilityHandler>& handler) override; 220 void SetInputEventConsumer(const std::shared_ptr<IInputEventConsumer>& inputEventConsumer) override; 221 void GetExtensionConfig(AAFwk::WantParams& want) const override; 222 void UpdateExtensionConfig(const std::shared_ptr<AAFwk::Want>& want) override; 223 224 WMError SetBackgroundColor(const std::string& color) override; 225 virtual Orientation GetRequestedOrientation() override; 226 227 int32_t GetParentId() const; 228 int32_t GetPersistentId() const override; 229 sptr<WindowSessionProperty> GetProperty() const; 230 SystemSessionConfig GetSystemSessionConfig() const; 231 sptr<ISession> GetHostSession() const; 232 int32_t GetFloatingWindowParentId(); 233 void NotifyAfterForeground(bool needNotifyListeners = true, bool needNotifyUiContent = true); 234 void NotifyAfterBackground(bool needNotifyListeners = true, bool needNotifyUiContent = true); 235 void NotifyAfterDidForeground(uint32_t reason = static_cast<uint32_t>(WindowStateChangeReason::NORMAL)); 236 void NotifyAfterDidBackground(uint32_t reason = static_cast<uint32_t>(WindowStateChangeReason::NORMAL)); 237 void NotifyForegroundFailed(WMError ret); 238 void NotifyBackgroundFailed(WMError ret); 239 WSError MarkProcessed(int32_t eventId) override; 240 void UpdateTitleButtonVisibility(); 241 WSError NotifyDestroy() override; 242 WSError NotifyTransferComponentData(const AAFwk::WantParams& wantParams) override; 243 WSErrorCode NotifyTransferComponentDataSync(const AAFwk::WantParams& wantParams, 244 AAFwk::WantParams& reWantParams) override; 245 void NotifyTouchDialogTarget(int32_t posX = 0, int32_t posY = 0) override; 246 void NotifyScreenshot() override; 247 void DumpSessionElementInfo(const std::vector<std::string>& params) override; 248 // colorspace, gamut 249 virtual bool IsSupportWideGamut() override; 250 virtual void SetColorSpace(ColorSpace colorSpace) override; 251 virtual ColorSpace GetColorSpace() override; 252 WSError NotifyTouchOutside() override; 253 WMError SetLandscapeMultiWindow(bool isLandscapeMultiWindow) override; 254 WSError NotifyWindowVisibility(bool isVisible) override; 255 WSError NotifyNoInteractionTimeout(const IWindowNoInteractionListenerSptr& listener); 256 WMError TransferAccessibilityEvent(const Accessibility::AccessibilityEventInfo& info, 257 int64_t uiExtensionIdLevel) override; 258 WindowState state_ { WindowState::STATE_INITIAL }; 259 WindowState requestState_ { WindowState::STATE_INITIAL }; 260 WSError UpdateMaximizeMode(MaximizeMode mode) override; 261 void NotifySessionForeground(uint32_t reason, bool withAnimation) override; 262 void NotifySessionBackground(uint32_t reason, bool withAnimation, bool isFromInnerkits) override; 263 WSError UpdateTitleInTargetPos(bool isShow, int32_t height) override; 264 WSError NotifyDialogStateChange(bool isForeground) override; 265 bool IsMainHandlerAvailable() const override; 266 267 /* 268 * PiP Window 269 */ 270 WSError NotifyCloseExistPipWindow() override; 271 WSError SetPipActionEvent(const std::string& action, int32_t status) override; 272 WSError SetPiPControlEvent(WsPiPControlType controlType, WsPiPControlStatus status) override; 273 WSError NotifyPipWindowSizeChange(double width, double height, double scale) override; 274 void UpdatePiPRect(const Rect& rect, WindowSizeChangeReason reason) override; 275 void UpdatePiPControlStatus(PiPControlType controlType, PiPControlStatus status) override; 276 void SetAutoStartPiP(bool isAutoStart, uint32_t priority, uint32_t width, uint32_t height) override; 277 278 void SetDrawingContentState(bool drawingContentState); 279 WMError RegisterWindowStatusChangeListener(const sptr<IWindowStatusChangeListener>& listener) override; 280 WMError UnregisterWindowStatusChangeListener(const sptr<IWindowStatusChangeListener>& listener) override; 281 WMError SetSpecificBarProperty(WindowType type, const SystemBarProperty& property) override; 282 void SetLayoutTransform(const Transform& trans); 283 Transform GetLayoutTransform() const override; 284 285 /* 286 * Window Decor 287 */ 288 WMError SetDecorVisible(bool isVisible) override; 289 WMError GetDecorVisible(bool& isVisible) override; 290 WMError SetWindowTitleMoveEnabled(bool enable) override; 291 WMError SetDecorHeight(int32_t decorHeight) override; 292 WMError GetDecorHeight(int32_t& height) override; 293 WMError SetDecorButtonStyle(const DecorButtonStyle& decorButtonStyle) override; 294 WMError GetDecorButtonStyle(DecorButtonStyle& decorButtonStyle) override; 295 WMError GetTitleButtonArea(TitleButtonRect& titleButtonRect) override; 296 WMError SetAPPWindowLabel(const std::string& label) override; 297 WMError SetAPPWindowIcon(const std::shared_ptr<Media::PixelMap>& icon) override; 298 WMError SetWindowContainerColor(const std::string& activeColor, const std::string& inactiveColor) override; 299 300 /* 301 * Window Decor listener 302 */ 303 WMError RegisterWindowTitleButtonRectChangeListener( 304 const sptr<IWindowTitleButtonRectChangedListener>& listener) override; 305 WMError UnregisterWindowTitleButtonRectChangeListener( 306 const sptr<IWindowTitleButtonRectChangedListener>& listener) override; 307 void NotifyWindowTitleButtonRectChange(TitleButtonRect titleButtonRect); 308 WMError RegisterSubWindowCloseListeners(const sptr<ISubWindowCloseListener>& listener) override; 309 WMError UnregisterSubWindowCloseListeners(const sptr<ISubWindowCloseListener>& listener) override; 310 void NotifySubWindowClose(bool& terminateCloseProcess); 311 WMError RegisterMainWindowCloseListeners(const sptr<IMainWindowCloseListener>& listener) override; 312 WMError UnregisterMainWindowCloseListeners(const sptr<IMainWindowCloseListener>& listener) override; 313 WMError NotifyMainWindowClose(bool& terminateCloseProcess); 314 WMError RegisterWindowWillCloseListeners(const sptr<IWindowWillCloseListener>& listener) override; 315 WMError UnRegisterWindowWillCloseListeners(const sptr<IWindowWillCloseListener>& listener) override; 316 WMError NotifyWindowWillClose(sptr<Window> window); 317 318 WSError GetUIContentRemoteObj(sptr<IRemoteObject>& uiContentRemoteObj) override; 319 void RecoverSessionListener(); 320 void SetDefaultDisplayIdIfNeed(); 321 WMError RegisterWindowRectChangeListener(const sptr<IWindowRectChangeListener>& listener) override; 322 WMError UnregisterWindowRectChangeListener(const sptr<IWindowRectChangeListener>& listener) override; 323 virtual WMError GetCallingWindowWindowStatus(WindowStatus& windowStatus) const override; 324 virtual WMError GetCallingWindowRect(Rect& rect) const override; 325 virtual void SetUiDvsyncSwitch(bool dvsyncSwitch) override; 326 WMError SetContinueState(int32_t continueState) override; 327 328 /* 329 * Multi Window 330 */ 331 WSError SetSplitButtonVisible(bool isVisible) override; 332 WMError GetIsMidScene(bool& isMidScene) override; 333 WSError SendContainerModalEvent(const std::string& eventName, const std::string& eventValue) override; 334 335 /* 336 * Window Layout 337 */ 338 WMError EnableDrag(bool enableDrag) override; 339 WSError SetDragActivated(bool dragActivated) override; 340 WSError SetEnableDragBySystem(bool enableDrag) override; 341 bool IsWindowDraggable(); 342 float GetVirtualPixelRatio() override; 343 CrossAxisState GetCrossAxisState() override; 344 345 /* 346 * Free Multi Window 347 */ 348 WMError RegisterSwitchFreeMultiWindowListener(const sptr<ISwitchFreeMultiWindowListener>& listener) override; 349 WMError UnregisterSwitchFreeMultiWindowListener(const sptr<ISwitchFreeMultiWindowListener>& listener) override; SetFreeMultiWindowMode(bool enable)350 void SetFreeMultiWindowMode(bool enable) 351 { 352 windowSystemConfig_.freeMultiWindowEnable_ = enable; 353 } 354 355 /* 356 * Window Immersive 357 */ 358 WMError RegisterAvoidAreaChangeListener(const sptr<IAvoidAreaChangedListener>& listener) override; 359 WMError UnregisterAvoidAreaChangeListener(const sptr<IAvoidAreaChangedListener>& listener) override; 360 WMError SetAvoidAreaOption(uint32_t avoidAreaOption) override; 361 WMError GetAvoidAreaOption(uint32_t& avoidAreaOption) override; 362 void NotifyAvoidAreaChange(const sptr<AvoidArea>& avoidArea, AvoidAreaType type); 363 WSError UpdateAvoidArea(const sptr<AvoidArea>& avoidArea, AvoidAreaType type) override; IsSystemWindow()364 bool IsSystemWindow() const override { return WindowHelper::IsSystemWindow(GetType()); } IsAppWindow()365 bool IsAppWindow() const override { return WindowHelper::IsAppWindow(GetType()); } GetRootHostWindowType()366 WindowType GetRootHostWindowType() const override { return rootHostWindowType_; } SetRootHostWindowType(WindowType & rootHostWindowType)367 void SetRootHostWindowType(WindowType& rootHostWindowType) override { rootHostWindowType_ = rootHostWindowType; } 368 WMError UpdateSystemBarProperties(const std::unordered_map<WindowType, SystemBarProperty>& systemBarProperties, 369 const std::unordered_map<WindowType, SystemBarPropertyFlag>& systemBarPropertyFlags) override; 370 void UpdateSpecificSystemBarEnabled(bool systemBarEnable, bool systemBarEnableAnimation, 371 SystemBarProperty& property) override; 372 WMError SetSystemBarProperty(WindowType type, const SystemBarProperty& property) override; 373 374 /* 375 * Window Property 376 */ 377 WSError NotifyDisplayIdChange(DisplayId displayId); 378 379 /* 380 * Window Input Event 381 */ 382 WMError NotifyWatchGestureConsumeResult(int32_t keyCode, bool isConsumed); 383 WMError NotifyWatchFocusActiveChange(bool isActive); 384 void RegisterWatchFocusActiveChangeCallback(); 385 void NotifyConsumeResultToFloatWindow(const std::shared_ptr<MMI::KeyEvent>& keyEvent, bool isConsumed); 386 387 /* 388 * HightLight Window 389 */ 390 bool GetExclusivelyHighlighted() const; 391 WMError IsWindowHighlighted(bool& highlighted) const override; 392 WMError SetExclusivelyHighlighted(bool isExclusivelyHighlighted) override; 393 WMError RegisterWindowHighlightChangeListeners(const sptr<IWindowHighlightChangeListener>& listener) override; 394 WMError UnregisterWindowHighlightChangeListeners(const sptr<IWindowHighlightChangeListener>& listener) override; 395 WSError NotifyHighlightChange(bool isHighlight) override; 396 397 protected: 398 WMError Connect(); 399 bool IsWindowSessionInvalid() const; 400 void NotifyWindowAfterUnfocused(); 401 void NotifyWindowAfterFocused(); 402 void NotifyAfterActive(); 403 void NotifyAfterInactive(); 404 void NotifyBeforeDestroy(std::string windowName); 405 void NotifyAfterDestroy(); 406 void ClearListenersById(int32_t persistentId); 407 408 /* 409 * Free Multi Window 410 */ 411 void ClearSwitchFreeMultiWindowListenersById(int32_t persistentId); 412 void NotifySwitchFreeMultiWindow(bool enable); 413 414 void ClearVsyncStation(); 415 WMError WindowSessionCreateCheck(); 416 void UpdateDecorEnableToAce(bool isDecorEnable); 417 void UpdateDecorEnable(bool needNotify = false, WindowMode mode = WindowMode::WINDOW_MODE_UNDEFINED); 418 void NotifyModeChange(WindowMode mode, bool hasDeco = true); 419 WMError UpdateProperty(WSPropertyChangeAction action); 420 WMError SetBackgroundColor(uint32_t color); 421 uint32_t GetBackgroundColor() const; 422 virtual WMError SetLayoutFullScreenByApiVersion(bool status); 423 virtual float GetVirtualPixelRatio(const sptr<DisplayInfo>& displayInfo); 424 void UpdateViewportConfig(const Rect& rect, WindowSizeChangeReason reason, 425 const std::shared_ptr<RSTransaction>& rsTransaction = nullptr, 426 const sptr<DisplayInfo>& info = nullptr, 427 const std::map<AvoidAreaType, AvoidArea>& avoidAreas = {}); 428 void NotifySizeChange(Rect rect, WindowSizeChangeReason reason); 429 static sptr<Window> FindWindowById(uint32_t winId); 430 void NotifyWindowStatusChange(WindowMode mode); 431 void NotifyTransformChange(const Transform& transForm) override; 432 void NotifySingleHandTransformChange(const SingleHandTransform& singleHandTransform) override; 433 bool IsKeyboardEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent) const; 434 void DispatchKeyEventCallback(const std::shared_ptr<MMI::KeyEvent>& keyEvent, bool& isConsumed); 435 bool IsVerticalOrientation(Orientation orientation) const; 436 void CopyUniqueDensityParameter(sptr<WindowSessionImpl> parentWindow); 437 sptr<WindowSessionImpl> FindMainWindowWithContext(); 438 sptr<WindowSessionImpl> FindExtensionWindowWithContext(); 439 440 WMError RegisterExtensionAvoidAreaChangeListener(const sptr<IAvoidAreaChangedListener>& listener); 441 WMError UnregisterExtensionAvoidAreaChangeListener(const sptr<IAvoidAreaChangedListener>& listener); 442 443 void RefreshNoInteractionTimeoutMonitor(); 444 WindowStatus GetWindowStatusInner(WindowMode mode); 445 446 /* 447 * PC Event Filter 448 */ 449 bool FilterKeyEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent); 450 bool FilterPointerEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent); 451 WMError SetKeyEventFilter(KeyEventFilterFunc filter) override; 452 WMError ClearKeyEventFilter() override; 453 WMError SetMouseEventFilter(MouseEventFilterFunc filter) override; 454 WMError ClearMouseEventFilter() override; 455 WMError SetTouchEventFilter(TouchEventFilterFunc filter) override; 456 WMError ClearTouchEventFilter() override; 457 458 /* 459 * Sub Window 460 */ 461 void UpdateSubWindowStateAndNotify(int32_t parentPersistentId, const WindowState newState); 462 void DestroySubWindow(); 463 bool IsSubWindowMaximizeSupported() const override; 464 void UpdateSubWindowLevel(uint32_t subWindowLevel); 465 void GetSubWidnows(int32_t parentPersistentId, std::vector<sptr<WindowSessionImpl>>& subWindows); 466 void RemoveSubWindow(int32_t parentPersistentId); 467 468 sptr<WindowOption> windowOption_; 469 sptr<ISession> hostSession_; 470 mutable std::mutex hostSessionMutex_; 471 std::shared_ptr<Ace::UIContent> uiContent_; 472 mutable std::shared_mutex uiContentMutex_; 473 std::shared_ptr<AbilityRuntime::Context> context_; 474 std::shared_ptr<RSSurfaceNode> surfaceNode_; 475 476 sptr<WindowSessionProperty> property_; 477 SystemSessionConfig windowSystemConfig_; 478 NotifyNativeWinDestroyFunc notifyNativeFunc_; 479 480 std::recursive_mutex mutex_; 481 static std::map<std::string, std::pair<int32_t, sptr<WindowSessionImpl>>> windowSessionMap_; 482 // protect windowSessionMap_ 483 static std::shared_mutex windowSessionMutex_; 484 static std::set<sptr<WindowSessionImpl>> windowExtensionSessionSet_; 485 // protect windowExtensionSessionSet_ 486 static std::shared_mutex windowExtensionSessionMutex_; 487 bool isSystembarPropertiesSet_ = false; 488 bool isIgnoreSafeAreaNeedNotify_ = false; 489 bool isIgnoreSafeArea_ = false; 490 std::atomic_bool isFocused_ = false; 491 std::atomic_bool isHighlighted_ = false; 492 std::atomic_bool shouldReNotifyHighlight_ = false; 493 std::shared_ptr<AppExecFwk::EventHandler> handler_ = nullptr; 494 bool shouldReNotifyFocus_ = false; 495 std::shared_ptr<VsyncStation> vsyncStation_ = nullptr; 496 std::shared_ptr<IInputEventConsumer> inputEventConsumer_; 497 bool useUniqueDensity_ { false }; 498 float virtualPixelRatio_ { 1.0f }; 499 bool escKeyEventTriggered_ = false; 500 // Check whether the UIExtensionAbility process is started 501 static bool isUIExtensionAbilityProcess_; 502 WSError SwitchFreeMultiWindow(bool enable) override; 503 std::string identityToken_ = { "" }; 504 void MakeSubOrDialogWindowDragableAndMoveble(); IsFreeMultiWindowMode()505 bool IsFreeMultiWindowMode() const 506 { 507 return windowSystemConfig_.IsFreeMultiWindowMode(); 508 } 509 510 /* 511 * Sub Window 512 */ 513 static std::recursive_mutex subWindowSessionMutex_; 514 static std::map<int32_t, std::vector<sptr<WindowSessionImpl>>> subWindowSessionMap_; 515 516 /* 517 * DFX 518 */ 519 void SetUIContentComplete(); 520 void AddSetUIContentTimeoutCheck(); 521 void NotifySetUIContentComplete(); 522 std::atomic_bool setUIContentCompleted_ { false }; 523 void SetUIExtensionDestroyComplete(); 524 void SetUIExtensionDestroyCompleteInSubWindow(); 525 void AddSetUIExtensionDestroyTimeoutCheck(); 526 std::atomic_bool setUIExtensionDestroyCompleted_ { false }; 527 std::atomic_bool startUIExtensionDestroyTimer_ { false }; 528 enum TimeoutErrorCode : int32_t { 529 SET_UICONTENT_TIMEOUT = 1000, 530 SET_UIEXTENSION_DESTROY_TIMEOUT 531 }; 532 533 /* 534 * Window Lifecycle 535 */ 536 bool hasFirstNotifyInteractive_ = false; 537 bool interactive_ = true; 538 bool isDidForeground_ = false; 539 540 /* 541 * Window Layout 542 */ 543 std::atomic_bool isDragTaskPostDone_ = true; 544 void FlushLayoutSize(int32_t width, int32_t height) override; 545 sptr<FutureCallback> layoutCallback_ = nullptr; 546 void UpdateVirtualPixelRatio(const sptr<Display>& display); 547 WMError GetVirtualPixelRatio(float& vpr); 548 void SetCurrentTransform(const Transform& transform); 549 Transform GetCurrentTransform() const; 550 void NotifyAfterUIContentReady(); SetNeedRenotifyTransform(bool isNeedRenotify)551 void SetNeedRenotifyTransform(bool isNeedRenotify) { needRenotifyTransform_.store(isNeedRenotify); } IsNeedRenotifyTransform()552 bool IsNeedRenotifyTransform() const { return needRenotifyTransform_.load(); } 553 mutable std::recursive_mutex transformMutex_; 554 std::atomic<CrossAxisState> crossAxisState_ = CrossAxisState::STATE_INVALID; 555 bool IsValidCrossState(int32_t state) const; 556 557 /* 558 * Window Immersive 559 */ 560 std::map<AvoidAreaType, AvoidArea> lastAvoidAreaMap_; 561 uint32_t GetStatusBarHeight() override; 562 WindowType rootHostWindowType_ = WindowType::APP_MAIN_WINDOW_BASE; 563 564 /* 565 * PC Fold Screen 566 */ 567 bool supportEnterWaterfallMode_ { false }; 568 569 /* 570 * Window Property 571 */ 572 float lastSystemDensity_ = UNDEFINED_DENSITY; 573 WSError NotifySystemDensityChange(float density); 574 void RegisterWindowInspectorCallback(); 575 uint32_t GetTargetAPIVersionByApplicationInfo() const; 576 577 /* 578 * Window Input Event 579 */ 580 bool GetWatchGestureConsumed() const; 581 void SetWatchGestureConsumed(bool isWatchGestureConsumed); 582 583 private: 584 //Trans between colorGamut and colorSpace 585 static ColorSpace GetColorSpaceFromSurfaceGamut(GraphicColorGamut colorGamut); 586 static GraphicColorGamut GetSurfaceGamutFromColorSpace(ColorSpace colorSpace); 587 588 template<typename T> WMError RegisterListener(std::vector<sptr<T>>& holder, const sptr<T>& listener); 589 template<typename T> WMError UnregisterListener(std::vector<sptr<T>>& holder, const sptr<T>& listener); 590 template<typename T> EnableIfSame<T, IWindowLifeCycle, std::vector<sptr<IWindowLifeCycle>>> GetListeners(); 591 template<typename T> EnableIfSame<T, IDisplayMoveListener, std::vector<sptr<IDisplayMoveListener>>> GetListeners(); 592 template<typename T> 593 EnableIfSame<T, IWindowChangeListener, std::vector<sptr<IWindowChangeListener>>> GetListeners(); 594 template <typename T> 595 EnableIfSame<T, IWindowCrossAxisListener, std::vector<sptr<IWindowCrossAxisListener>>> GetListeners(); 596 template<typename T> 597 EnableIfSame<T, IAvoidAreaChangedListener, std::vector<sptr<IAvoidAreaChangedListener>>> GetListeners(); 598 template<typename T> 599 EnableIfSame<T, IDialogDeathRecipientListener, std::vector<sptr<IDialogDeathRecipientListener>>> GetListeners(); 600 template<typename T> 601 EnableIfSame<T, IDialogTargetTouchListener, std::vector<sptr<IDialogTargetTouchListener>>> GetListeners(); 602 template<typename T> 603 EnableIfSame<T, IOccupiedAreaChangeListener, std::vector<sptr<IOccupiedAreaChangeListener>>> GetListeners(); 604 template<typename T> 605 EnableIfSame<T, IKeyboardDidShowListener, std::vector<sptr<IKeyboardDidShowListener>>> GetListeners(); 606 template<typename T> 607 EnableIfSame<T, IKeyboardDidHideListener, std::vector<sptr<IKeyboardDidHideListener>>> GetListeners(); 608 template<typename T> 609 EnableIfSame<T, IScreenshotListener, std::vector<sptr<IScreenshotListener>>> GetListeners(); 610 template<typename T> 611 EnableIfSame<T, ITouchOutsideListener, std::vector<sptr<ITouchOutsideListener>>> GetListeners(); 612 template<typename T> 613 EnableIfSame<T, IWindowVisibilityChangedListener, std::vector<IWindowVisibilityListenerSptr>> GetListeners(); 614 template<typename T> 615 EnableIfSame<T, IDisplayIdChangeListener, std::vector<IDisplayIdChangeListenerSptr>> GetListeners(); 616 template<typename T> 617 EnableIfSame<T, ISystemDensityChangeListener, std::vector<ISystemDensityChangeListenerSptr>> GetListeners(); 618 template<typename T> 619 EnableIfSame<T, IWindowNoInteractionListener, std::vector<IWindowNoInteractionListenerSptr>> GetListeners(); 620 template<typename T> void ClearUselessListeners(std::map<int32_t, T>& listeners, int32_t persistentId); 621 template<typename T> void ClearUselessListeners(std::unordered_map<int32_t, T>& listeners, int32_t persistentId); 622 RSSurfaceNode::SharedPtr CreateSurfaceNode(const std::string& name, WindowType type); 623 template<typename T> 624 EnableIfSame<T, IWindowStatusChangeListener, std::vector<sptr<IWindowStatusChangeListener>>> GetListeners(); 625 template<typename T> 626 EnableIfSame<T, IWindowRectChangeListener, std::vector<sptr<IWindowRectChangeListener>>> GetListeners(); 627 template<typename T> 628 EnableIfSame<T, ISwitchFreeMultiWindowListener, std::vector<sptr<ISwitchFreeMultiWindowListener>>> GetListeners(); 629 template<typename T> 630 EnableIfSame<T, IWindowHighlightChangeListener, std::vector<sptr<IWindowHighlightChangeListener>>> GetListeners(); 631 void NotifyAfterFocused(); 632 void NotifyUIContentFocusStatus(); 633 void NotifyAfterUnfocused(bool needNotifyUiContent = true); 634 void NotifyAfterResumed(); 635 void NotifyAfterPaused(); 636 void NotifyUIContentHighlightStatus(bool isHighlighted); 637 638 /* 639 * Window Decor listener 640 */ 641 template<typename T> 642 EnableIfSame<T, IWindowTitleButtonRectChangedListener, 643 std::vector<sptr<IWindowTitleButtonRectChangedListener>>> GetListeners(); 644 template<typename T> 645 EnableIfSame<T, ISubWindowCloseListener, sptr<ISubWindowCloseListener>> GetListeners(); 646 template<typename T> 647 EnableIfSame<T, IMainWindowCloseListener, sptr<IMainWindowCloseListener>> GetListeners(); 648 template<typename T> 649 EnableIfSame<T, IWindowWillCloseListener, std::vector<sptr<IWindowWillCloseListener>>> GetListeners(); 650 651 WMError InitUIContent(const std::string& contentInfo, napi_env env, napi_value storage, 652 WindowSetUIContentType setUIContentType, BackupAndRestoreType restoreType, AppExecFwk::Ability* ability, 653 OHOS::Ace::UIContentErrorCode& aceRet); 654 WMError SetUIContentInner(const std::string& contentInfo, napi_env env, napi_value storage, 655 WindowSetUIContentType setUIContentType, BackupAndRestoreType restoreType, AppExecFwk::Ability* ability); 656 std::shared_ptr<std::vector<uint8_t>> GetAbcContent(const std::string& abcPath); 657 inline void DestroyExistUIContent(); 658 std::string GetRestoredRouterStack(); 659 660 bool CheckIfNeedCommitRsTransaction(WindowSizeChangeReason wmReason); 661 void UpdateRectForRotation(const Rect& wmRect, const Rect& preRect, WindowSizeChangeReason wmReason, 662 const SceneAnimationConfig& config, const std::map<AvoidAreaType, AvoidArea>& avoidAreas = {}); 663 void UpdateRectForOtherReason(const Rect& wmRect, const Rect& preRect, WindowSizeChangeReason wmReason, 664 const std::shared_ptr<RSTransaction>& rsTransaction = nullptr, 665 const std::map<AvoidAreaType, AvoidArea>& avoidAreas = {}); 666 void UpdateRectForOtherReasonTask(const Rect& wmRect, const Rect& preRect, WindowSizeChangeReason wmReason, 667 const std::shared_ptr<RSTransaction>& rsTransaction, 668 const std::map<AvoidAreaType, AvoidArea>& avoidAreas = {}); 669 void UpdateRectForResizeWithAnimation(const Rect& wmRect, const Rect& preRect, WindowSizeChangeReason wmReason, 670 const RectAnimationConfig& rectAnimationConfig, const std::shared_ptr<RSTransaction>& rsTransaction = nullptr, 671 const std::map<AvoidAreaType, AvoidArea>& avoidAreas = {}); 672 void NotifyRotationAnimationEnd(); 673 void SubmitNoInteractionMonitorTask(int32_t eventId, const IWindowNoInteractionListenerSptr& listener); 674 bool IsUserOrientation(Orientation orientation) const; 675 WMError GetAppForceLandscapeConfig(AppForceLandscapeConfig& config); 676 void SetForceSplitEnable(bool isForceSplit, const std::string& homePage = ""); 677 void SetFrameLayoutCallbackEnable(bool enable); 678 void UpdateFrameLayoutCallbackIfNeeded(WindowSizeChangeReason wmReason); 679 bool IsNotifyInteractiveDuplicative(bool interactive); 680 void SetUniqueVirtualPixelRatioForSub(bool useUniqueDensity, float virtualPixelRatio); 681 682 /* 683 * PC Window 684 */ 685 void GetTitleButtonVisible(bool& hideMaximizeButton, bool& hideMinimizeButton, bool& hideSplitButton, 686 bool& hideCloseButton); 687 688 static std::recursive_mutex lifeCycleListenerMutex_; 689 static std::recursive_mutex windowChangeListenerMutex_; 690 static std::recursive_mutex windowCrossAxisListenerMutex_; 691 static std::recursive_mutex avoidAreaChangeListenerMutex_; 692 static std::recursive_mutex dialogDeathRecipientListenerMutex_; 693 static std::recursive_mutex dialogTargetTouchListenerMutex_; 694 static std::recursive_mutex occupiedAreaChangeListenerMutex_; 695 static std::recursive_mutex keyboardDidShowListenerMutex_; 696 static std::recursive_mutex keyboardDidHideListenerMutex_; 697 static std::recursive_mutex screenshotListenerMutex_; 698 static std::recursive_mutex touchOutsideListenerMutex_; 699 static std::recursive_mutex windowVisibilityChangeListenerMutex_; 700 static std::recursive_mutex windowNoInteractionListenerMutex_; 701 static std::recursive_mutex windowStatusChangeListenerMutex_; 702 static std::mutex displayMoveListenerMutex_; 703 static std::mutex windowRectChangeListenerMutex_; 704 static std::mutex switchFreeMultiWindowListenerMutex_; 705 static std::mutex highlightChangeListenerMutex_; 706 static std::map<int32_t, std::vector<sptr<IWindowLifeCycle>>> lifecycleListeners_; 707 static std::map<int32_t, std::vector<sptr<IDisplayMoveListener>>> displayMoveListeners_; 708 static std::map<int32_t, std::vector<sptr<IWindowChangeListener>>> windowChangeListeners_; 709 static std::map<int32_t, std::vector<sptr<IWindowCrossAxisListener>>> windowCrossAxisListeners_; 710 static std::map<int32_t, std::vector<sptr<IAvoidAreaChangedListener>>> avoidAreaChangeListeners_; 711 static std::map<int32_t, std::vector<sptr<IDialogDeathRecipientListener>>> dialogDeathRecipientListeners_; 712 static std::map<int32_t, std::vector<sptr<IDialogTargetTouchListener>>> dialogTargetTouchListener_; 713 static std::map<int32_t, std::vector<sptr<IOccupiedAreaChangeListener>>> occupiedAreaChangeListeners_; 714 static std::map<int32_t, std::vector<sptr<IKeyboardDidShowListener>>> keyboardDidShowListeners_; 715 static std::map<int32_t, std::vector<sptr<IKeyboardDidHideListener>>> keyboardDidHideListeners_; 716 static std::map<int32_t, std::vector<sptr<IScreenshotListener>>> screenshotListeners_; 717 static std::map<int32_t, std::vector<sptr<ITouchOutsideListener>>> touchOutsideListeners_; 718 static std::map<int32_t, std::vector<IWindowVisibilityListenerSptr>> windowVisibilityChangeListeners_; 719 static std::mutex displayIdChangeListenerMutex_; 720 static std::map<int32_t, std::vector<IDisplayIdChangeListenerSptr>> displayIdChangeListeners_; 721 static std::mutex systemDensityChangeListenerMutex_; 722 static std::unordered_map<int32_t, std::vector<ISystemDensityChangeListenerSptr>> systemDensityChangeListeners_; 723 static std::map<int32_t, std::vector<IWindowNoInteractionListenerSptr>> windowNoInteractionListeners_; 724 static std::map<int32_t, std::vector<sptr<IWindowStatusChangeListener>>> windowStatusChangeListeners_; 725 static std::map<int32_t, std::vector<sptr<IWindowRectChangeListener>>> windowRectChangeListeners_; 726 static std::map<int32_t, std::vector<sptr<ISwitchFreeMultiWindowListener>>> switchFreeMultiWindowListeners_; 727 static std::map<int32_t, std::vector<sptr<IWindowHighlightChangeListener>>> highlightChangeListeners_; 728 729 // FA only 730 sptr<IAceAbilityHandler> aceAbilityHandler_; 731 732 std::atomic<int32_t> lastInteractionEventId_ { 0 }; 733 734 bool isMainHandlerAvailable_ = true; 735 736 std::string subWindowTitle_ = { "" }; 737 std::string dialogTitle_ = { "" }; 738 WindowTitleVisibleFlags windowTitleVisibleFlags_; 739 740 std::string restoredRouterStack_; // It was set and get in same thread, which is js thread. 741 742 /* 743 * Window Layout 744 */ 745 WSRect layoutRect_; 746 std::atomic_bool windowSizeChanged_ = false; 747 std::atomic_bool enableFrameLayoutFinishCb_ = false; 748 std::atomic_bool dragActivated_ = true; 749 WindowSizeChangeReason lastSizeChangeReason_ = WindowSizeChangeReason::END; 750 bool postTaskDone_ = false; 751 int16_t rotationAnimationCount_ { 0 }; 752 Transform layoutTransform_; 753 SingleHandTransform singleHandTransform_; 754 mutable std::mutex currentTransformMutex_; 755 Transform currentTransform_; 756 std::atomic_bool needRenotifyTransform_ = false; 757 758 /* 759 * Window Decor 760 */ 761 DecorButtonStyle decorButtonStyle_; 762 int32_t decorHeight_ = 0; 763 764 /* 765 * Window Decor listener 766 */ 767 static std::recursive_mutex windowTitleButtonRectChangeListenerMutex_; 768 static std::map<int32_t, std::vector<sptr<IWindowTitleButtonRectChangedListener>>> 769 windowTitleButtonRectChangeListeners_; 770 static std::mutex subWindowCloseListenersMutex_; 771 static std::map<int32_t, sptr<ISubWindowCloseListener>> subWindowCloseListeners_; 772 static std::mutex mainWindowCloseListenersMutex_; 773 static std::map<int32_t, sptr<IMainWindowCloseListener>> mainWindowCloseListeners_; 774 static std::mutex windowWillCloseListenersMutex_; 775 static std::unordered_map<int32_t, std::vector<sptr<IWindowWillCloseListener>>> windowWillCloseListeners_; 776 777 /* 778 * Multi Window 779 */ 780 bool isSplitButtonVisible_ = true; 781 782 /* 783 * PC Window 784 */ 785 uint32_t targetAPIVersion_ = 0; 786 787 /* 788 * Window Input Event 789 */ 790 bool isWatchGestureConsumed_ = false; 791 792 /* 793 * PC Event Filter 794 */ 795 std::mutex keyEventFilterMutex_; 796 KeyEventFilterFunc keyEventFilter_; 797 std::mutex mouseEventFilterMutex_; 798 MouseEventFilterFunc mouseEventFilter_; 799 std::mutex touchEventFilterMutex_; 800 TouchEventFilterFunc touchEventFilter_; 801 802 /* 803 * Window Scene 804 */ NotifyWindowAttachStateChange(bool isAttach)805 WSError NotifyWindowAttachStateChange(bool isAttach) override { return WSError::WS_OK; } 806 807 /* 808 * keyboard 809 */ 810 bool isKeyboardDidShowRegistered_ = false; 811 bool isKeyboardDidHideRegistered_ = false; 812 }; 813 } // namespace Rosen 814 } // namespace OHOS 815 816 #endif // OHOS_ROSEN_WINDOW_SESSION_IMPL_H 817