1 /* 2 * Copyright (c) 2021-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_IMPL_H 17 #define OHOS_ROSEN_WINDOW_IMPL_H 18 19 #include <map> 20 #include <string> 21 22 #include <ability_context.h> 23 #include <i_input_event_consumer.h> 24 #include <key_event.h> 25 #include <refbase.h> 26 #include <ui_content.h> 27 #include <ui/rs_surface_node.h> 28 #include <struct_multimodal.h> 29 30 #include "prepare_terminate_callback_stub.h" 31 #include "input_transfer_station.h" 32 #include "vsync_station.h" 33 #include "window.h" 34 #include "window_helper.h" 35 #include "window_property.h" 36 #include "window_transition_info.h" 37 #include "wm_common_inner.h" 38 #include "wm_common.h" 39 40 using OHOS::AppExecFwk::DisplayOrientation; 41 42 namespace OHOS { 43 namespace Rosen { 44 namespace { 45 template<typename T1, typename T2, typename Ret> 46 using EnableIfSame = typename std::enable_if<std::is_same_v<T1, T2>, Ret>::type; 47 } 48 union ColorParam { 49 #if BIG_ENDIANNESS 50 struct { 51 uint8_t alpha; 52 uint8_t red; 53 uint8_t green; 54 uint8_t blue; 55 } argb; 56 #else 57 struct { 58 uint8_t blue; 59 uint8_t green; 60 uint8_t red; 61 uint8_t alpha; 62 } argb; 63 #endif 64 uint32_t value; 65 }; 66 67 const std::map<OHOS::AppExecFwk::DisplayOrientation, Orientation> ABILITY_TO_WMS_ORIENTATION_MAP { 68 {OHOS::AppExecFwk::DisplayOrientation::UNSPECIFIED, Orientation::UNSPECIFIED}, 69 {OHOS::AppExecFwk::DisplayOrientation::LANDSCAPE, Orientation::HORIZONTAL}, 70 {OHOS::AppExecFwk::DisplayOrientation::PORTRAIT, Orientation::VERTICAL}, 71 {OHOS::AppExecFwk::DisplayOrientation::FOLLOWRECENT, Orientation::LOCKED}, 72 {OHOS::AppExecFwk::DisplayOrientation::LANDSCAPE_INVERTED, Orientation::REVERSE_HORIZONTAL}, 73 {OHOS::AppExecFwk::DisplayOrientation::PORTRAIT_INVERTED, Orientation::REVERSE_VERTICAL}, 74 {OHOS::AppExecFwk::DisplayOrientation::AUTO_ROTATION, Orientation::SENSOR}, 75 {OHOS::AppExecFwk::DisplayOrientation::AUTO_ROTATION_LANDSCAPE, Orientation::SENSOR_HORIZONTAL}, 76 {OHOS::AppExecFwk::DisplayOrientation::AUTO_ROTATION_PORTRAIT, Orientation::SENSOR_VERTICAL}, 77 {OHOS::AppExecFwk::DisplayOrientation::AUTO_ROTATION_RESTRICTED, Orientation::AUTO_ROTATION_RESTRICTED}, 78 {OHOS::AppExecFwk::DisplayOrientation::AUTO_ROTATION_LANDSCAPE_RESTRICTED, 79 Orientation::AUTO_ROTATION_LANDSCAPE_RESTRICTED}, 80 {OHOS::AppExecFwk::DisplayOrientation::AUTO_ROTATION_PORTRAIT_RESTRICTED, 81 Orientation::AUTO_ROTATION_PORTRAIT_RESTRICTED}, 82 {OHOS::AppExecFwk::DisplayOrientation::LOCKED, Orientation::LOCKED}, 83 }; 84 85 class WindowImpl : public Window, AAFwk::PrepareTerminateCallbackStub { 86 #define CALL_LIFECYCLE_LISTENER(windowLifecycleCb, listeners) \ 87 do { \ 88 for (auto& listener : (listeners)) { \ 89 if (listener != nullptr) { \ 90 listener->windowLifecycleCb(); \ 91 } \ 92 } \ 93 } while (0) 94 95 #define CALL_LIFECYCLE_LISTENER_WITH_PARAM(windowLifecycleCb, listeners, param) \ 96 do { \ 97 for (auto& listener : (listeners)) { \ 98 if (listener != nullptr) { \ 99 listener->windowLifecycleCb(param); \ 100 } \ 101 } \ 102 } while (0) 103 104 #define CALL_UI_CONTENT(uiContentCb) \ 105 do { \ 106 std::lock_guard<std::recursive_mutex> lock(mutex_); \ 107 if (uiContent_ != nullptr) { \ 108 uiContent_->uiContentCb(); \ 109 } \ 110 } while (0) 111 112 public: 113 explicit WindowImpl(const sptr<WindowOption>& option); 114 ~WindowImpl(); 115 116 static sptr<Window> Find(const std::string& id); 117 static sptr<Window> GetTopWindowWithContext(const std::shared_ptr<AbilityRuntime::Context>& context = nullptr); 118 static sptr<Window> GetTopWindowWithId(uint32_t mainWinId); 119 static sptr<Window> GetWindowWithId(uint32_t winId); 120 static std::vector<sptr<Window>> GetSubWindow(uint32_t parantId); 121 static void UpdateConfigurationForAll(const std::shared_ptr<AppExecFwk::Configuration>& configuration, 122 const std::vector<std::shared_ptr<AbilityRuntime::Context>>& ignoreWindowContexts = {}); 123 virtual std::shared_ptr<RSSurfaceNode> GetSurfaceNode() const override; 124 virtual Rect GetRect() const override; 125 virtual Rect GetRequestRect() const override; 126 virtual WindowType GetType() const override; 127 virtual WindowMode GetWindowMode() const override; 128 virtual float GetAlpha() const override; 129 virtual WindowState GetWindowState() const override; 130 virtual WMError SetFocusable(bool isFocusable) override; 131 virtual bool GetFocusable() const override; 132 virtual WMError SetTouchable(bool isTouchable) override; 133 virtual bool GetTouchable() const override; 134 virtual const std::string& GetWindowName() const override; 135 virtual uint32_t GetWindowId() const override; 136 uint64_t GetDisplayId() const override; 137 virtual uint32_t GetWindowFlags() const override; 138 uint32_t GetRequestWindowModeSupportType() const override; 139 bool IsMainHandlerAvailable() const override; GetNativeDestroyCallback()140 inline NotifyNativeWinDestroyFunc GetNativeDestroyCallback() 141 { 142 return notifyNativefunc_; 143 } 144 virtual WMError SetWindowType(WindowType type) override; 145 virtual WMError SetWindowMode(WindowMode mode) override; 146 virtual WMError SetAlpha(float alpha) override; 147 virtual WMError SetTransform(const Transform& trans) override; 148 virtual WMError AddWindowFlag(WindowFlag flag) override; 149 virtual WMError RemoveWindowFlag(WindowFlag flag) override; 150 virtual WMError SetWindowFlags(uint32_t flags) override; 151 virtual const Transform& GetTransform() const override; 152 virtual const Transform& GetZoomTransform() const; 153 virtual WMError UpdateSurfaceNodeAfterCustomAnimation(bool isAdd) override; SetWindowState(WindowState state)154 inline void SetWindowState(WindowState state) 155 { 156 state_ = state; 157 } 158 159 /* 160 * Window Immersive 161 */ 162 WMError GetAvoidAreaByType(AvoidAreaType type, AvoidArea& avoidArea, const Rect& rect = Rect::EMPTY_RECT, 163 int32_t apiVersion = API_VERSION_INVALID) override; SetAvoidAreaOption(uint32_t avoidAreaOption)164 WMError SetAvoidAreaOption(uint32_t avoidAreaOption) override 165 { return WMError::WM_ERROR_DEVICE_NOT_SUPPORT; } GetAvoidAreaOption(uint32_t & avoidAreaOption)166 WMError GetAvoidAreaOption(uint32_t& avoidAreaOption) override 167 { return WMError::WM_ERROR_DEVICE_NOT_SUPPORT; } 168 SystemBarProperty GetSystemBarPropertyByType(WindowType type) const override; 169 bool IsFullScreen() const override; 170 bool IsLayoutFullScreen() const override; 171 virtual WMError UpdateSystemBarProperty(bool status); 172 WMError SetLayoutFullScreen(bool status) override; 173 WMError SetFullScreen(bool status) override; IsSystemWindow()174 bool IsSystemWindow() const override { return WindowHelper::IsSystemWindow(GetType()); } IsAppWindow()175 bool IsAppWindow() const override { return WindowHelper::IsAppWindow(GetType()); } 176 WMError UpdateSystemBarProperties(const std::unordered_map<WindowType, SystemBarProperty>& systemBarProperties, 177 const std::unordered_map<WindowType, SystemBarPropertyFlag>& systemBarPropertyFlags) override; 178 WMError SetSystemBarProperty(WindowType type, const SystemBarProperty& property) override; 179 void UpdateSpecificSystemBarEnabled(bool systemBarEnable, bool systemBarEnableAnimation, 180 SystemBarProperty& property) override; 181 182 WMError Create(uint32_t parentId, 183 const std::shared_ptr<AbilityRuntime::Context>& context = nullptr); 184 virtual WMError Destroy() override; 185 virtual WMError Show(uint32_t reason = 0, bool withAnimation = false, bool withFocus = true) override; 186 virtual WMError Hide(uint32_t reason = 0, bool withAnimation = false, bool isFromInnerkits = true) override; 187 virtual WMError MoveTo(int32_t x, int32_t y, bool isMoveToGlobal = false, 188 MoveConfiguration moveConfiguration = {}) override; 189 virtual WMError Resize(uint32_t width, uint32_t height, 190 const RectAnimationConfig& rectAnimationConfig = {}) override; 191 float GetVirtualPixelRatio() override; 192 virtual WMError SetWindowGravity(WindowGravity gravity, uint32_t percent) override; 193 virtual WMError SetKeepScreenOn(bool keepScreenOn) override; 194 virtual bool IsKeepScreenOn() const override; 195 virtual WMError SetTurnScreenOn(bool turnScreenOn) override; 196 virtual bool IsTurnScreenOn() const override; 197 virtual WMError SetBackgroundColor(const std::string& color) override; 198 virtual WMError SetTransparent(bool isTransparent) override; 199 virtual bool IsTransparent() const override; 200 virtual WMError SetBrightness(float brightness) override; 201 virtual float GetBrightness() const override; 202 virtual WMError SetCallingWindow(uint32_t windowId) override; 203 virtual WMError SetPrivacyMode(bool isPrivacyMode) override; 204 virtual bool IsPrivacyMode() const override; 205 virtual void SetSystemPrivacyMode(bool isSystemPrivacyMode) override; 206 virtual WMError DisableAppWindowDecor() override; 207 virtual WMError BindDialogTarget(sptr<IRemoteObject> targetToken) override; 208 WMError RaiseToAppTop() override; 209 virtual WMError SetAspectRatio(float ratio) override; 210 virtual WMError ResetAspectRatio() override; 211 virtual WMError SetSnapshotSkip(bool isSkip) override; 212 // window effect 213 virtual WMError SetCornerRadius(float cornerRadius) override; 214 virtual WMError SetShadowRadius(float radius) override; 215 virtual WMError SetShadowColor(std::string color) override; 216 virtual WMError SetShadowOffsetX(float offsetX) override; 217 virtual WMError SetShadowOffsetY(float offsetY) override; 218 virtual WMError SetBlur(float radius) override; 219 virtual WMError SetBackdropBlur(float radius) override; 220 virtual WMError SetBackdropBlurStyle(WindowBlurStyle blurStyle) override; 221 222 virtual bool IsDecorEnable() const override; 223 virtual WMError Maximize() override; 224 virtual WMError MaximizeFloating() override; 225 virtual WMError Minimize() override; 226 virtual WMError Recover() override; 227 virtual WMError Close() override; 228 virtual void StartMove() override; 229 virtual WMError SetGlobalMaximizeMode(MaximizeMode mode) override; 230 virtual MaximizeMode GetGlobalMaximizeMode() const override; 231 virtual WMError SetImmersiveModeEnabledState(bool enable) override; 232 virtual bool GetImmersiveModeEnabledState() const override; 233 234 virtual WMError RequestFocus() const override; 235 virtual void SetInputEventConsumer(const std::shared_ptr<IInputEventConsumer>& inputEventConsumer) override; 236 237 virtual WMError RegisterLifeCycleListener(const sptr<IWindowLifeCycle>& listener) override; 238 virtual WMError RegisterWindowChangeListener(const sptr<IWindowChangeListener>& listener) override; 239 virtual WMError UnregisterLifeCycleListener(const sptr<IWindowLifeCycle>& listener) override; 240 virtual WMError UnregisterWindowChangeListener(const sptr<IWindowChangeListener>& listener) override; 241 virtual WMError RegisterAvoidAreaChangeListener(const sptr<IAvoidAreaChangedListener>& listener) override; 242 virtual WMError UnregisterAvoidAreaChangeListener(const sptr<IAvoidAreaChangedListener>& listener) override; 243 virtual WMError RegisterDragListener(const sptr<IWindowDragListener>& listener) override; 244 virtual WMError UnregisterDragListener(const sptr<IWindowDragListener>& listener) override; 245 virtual WMError RegisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) override; 246 virtual WMError UnregisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) override; 247 virtual void RegisterWindowDestroyedListener(const NotifyNativeWinDestroyFunc& func) override; UnregisterWindowDestroyedListener()248 virtual void UnregisterWindowDestroyedListener() override { notifyNativefunc_ = nullptr; } 249 virtual WMError RegisterOccupiedAreaChangeListener(const sptr<IOccupiedAreaChangeListener>& listener) override; 250 virtual WMError UnregisterOccupiedAreaChangeListener(const sptr<IOccupiedAreaChangeListener>& listener) override; 251 virtual WMError RegisterTouchOutsideListener(const sptr<ITouchOutsideListener>& listener) override; 252 virtual WMError UnregisterTouchOutsideListener(const sptr<ITouchOutsideListener>& listener) override; 253 virtual WMError RegisterAnimationTransitionController( 254 const sptr<IAnimationTransitionController>& listener) override; 255 virtual WMError RegisterScreenshotListener(const sptr<IScreenshotListener>& listener) override; 256 virtual WMError UnregisterScreenshotListener(const sptr<IScreenshotListener>& listener) override; 257 virtual WMError RegisterDialogTargetTouchListener(const sptr<IDialogTargetTouchListener>& listener) override; 258 virtual WMError UnregisterDialogTargetTouchListener(const sptr<IDialogTargetTouchListener>& listener) override; 259 virtual void RegisterDialogDeathRecipientListener(const sptr<IDialogDeathRecipientListener>& listener) override; 260 virtual void UnregisterDialogDeathRecipientListener(const sptr<IDialogDeathRecipientListener>& listener) override; 261 virtual void SetAceAbilityHandler(const sptr<IAceAbilityHandler>& handler) override; 262 virtual void SetRequestWindowModeSupportType(uint32_t windowModeSupportType) override; 263 void UpdateRect(const struct Rect& rect, bool decoStatus, WindowSizeChangeReason reason, 264 const std::shared_ptr<RSTransaction>& rsTransaction = nullptr); 265 void ScheduleUpdateRectTask(const Rect& rectToAce, const Rect& lastOriRect, WindowSizeChangeReason reason, 266 const std::shared_ptr<RSTransaction>& rsTransaction, const sptr<class Display>& display); 267 void UpdateMode(WindowMode mode); 268 void UpdateWindowModeSupportType(uint32_t windowModeSupportType); 269 virtual void ConsumeKeyEvent(std::shared_ptr<MMI::KeyEvent>& inputEvent) override; 270 virtual void ConsumePointerEvent(const std::shared_ptr<MMI::PointerEvent>& inputEvent) override; 271 virtual void RequestVsync(const std::shared_ptr<VsyncCallback>& vsyncCallback) override; 272 virtual int64_t GetVSyncPeriod() override; 273 void UpdateFocusStatus(bool focused); 274 virtual bool IsFocused() const override; 275 virtual void UpdateConfiguration(const std::shared_ptr<AppExecFwk::Configuration>& configuration) override; 276 void UpdateConfigurationForSpecified(const std::shared_ptr<AppExecFwk::Configuration>& configuration, 277 const std::shared_ptr<Global::Resource::ResourceManager>& resourceManager) override; 278 void UpdateAvoidArea(const sptr<AvoidArea>& avoidArea, AvoidAreaType type); 279 void UpdateWindowState(WindowState state); 280 WmErrorCode UpdateSubWindowStateAndNotify(uint32_t parentId); 281 WmErrorCode UpdateWindowStateWhenShow(); 282 WmErrorCode UpdateWindowStateWhenHide(); 283 sptr<WindowProperty> GetWindowProperty(); 284 void UpdateDragEvent(const PointInfo& point, DragEvent event); 285 void UpdateDisplayId(DisplayId from, DisplayId to); 286 void UpdateOccupiedAreaChangeInfo(const sptr<OccupiedAreaChangeInfo>& info, 287 const std::shared_ptr<RSTransaction>& rsTransaction = nullptr); 288 void UpdateActiveStatus(bool isActive); 289 void NotifyTouchOutside(); 290 void NotifyScreenshot(); 291 void NotifyTouchDialogTarget(int32_t posX = 0, int32_t posY = 0) override; 292 void NotifyDestroy(); 293 void NotifyForeground(); 294 void NotifyBackground(); 295 void UpdateZoomTransform(const Transform& trans, bool isDisplayZoomOn); 296 void PerformBack() override; 297 void NotifyForegroundInteractiveStatus(bool interactive); 298 void NotifyMMIServiceOnline(uint32_t winId); 299 virtual bool PreNotifyKeyEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent) override; 300 virtual WMError NapiSetUIContent(const std::string& contentInfo, napi_env env, napi_value storage, 301 BackupAndRestoreType type, sptr<IRemoteObject> token, AppExecFwk::Ability* ability) override; 302 virtual WMError SetUIContentByName(const std::string& contentInfo, napi_env env, napi_value storage, 303 AppExecFwk::Ability* ability) override; 304 virtual WMError SetUIContentByAbc(const std::string& abcPath, napi_env env, napi_value storage, 305 AppExecFwk::Ability* ability) override; 306 virtual std::string GetContentInfo(BackupAndRestoreType type = BackupAndRestoreType::CONTINUATION) override; 307 WMError SetRestoredRouterStack(const std::string& routerStack) override; 308 virtual const std::shared_ptr<AbilityRuntime::Context> GetContext() const override; 309 virtual Ace::UIContent* GetUIContent() const override; 310 virtual Ace::UIContent* GetUIContentWithId(uint32_t winId) const override; 311 virtual void OnNewWant(const AAFwk::Want& want) override; 312 virtual void SetRequestedOrientation(Orientation orientation, bool needAnimation = true) override; 313 virtual Orientation GetRequestedOrientation() override; 314 virtual void SetNeedRemoveWindowInputChannel(bool needRemoveWindowInputChannel) override; 315 virtual WMError SetTouchHotAreas(const std::vector<Rect>& rects) override; 316 virtual void GetRequestedTouchHotAreas(std::vector<Rect>& rects) const override; 317 virtual WMError SetAPPWindowLabel(const std::string& label) override; 318 virtual WMError SetAPPWindowIcon(const std::shared_ptr<Media::PixelMap>& icon) override; 319 320 // colorspace, gamut 321 virtual bool IsSupportWideGamut() override; 322 virtual void SetColorSpace(ColorSpace colorSpace) override; 323 virtual ColorSpace GetColorSpace() override; 324 325 virtual void DumpInfo(const std::vector<std::string>& params, std::vector<std::string>& info) override; 326 virtual std::shared_ptr<Media::PixelMap> Snapshot() override; 327 WMError SnapshotIgnorePrivacy(std::shared_ptr<Media::PixelMap>& pixelMap) override; 328 virtual WMError NotifyMemoryLevel(int32_t level) override; 329 virtual bool IsAllowHaveSystemSubWindow() override; 330 virtual KeyboardAnimationConfig GetKeyboardAnimationConfig() override; 331 void RestoreSplitWindowMode(uint32_t mode); 332 333 virtual void SetNeedDefaultAnimation(bool needDefaultAnimation) override; 334 335 virtual void DoPrepareTerminate() override; 336 void PendingClose(); 337 338 WMError SetTextFieldAvoidInfo(double textFieldPositionY, double textFieldHeight) override; 339 virtual WMError SetSystemBarProperties(const std::map<WindowType, SystemBarProperty>& properties, 340 const std::map<WindowType, SystemBarPropertyFlag>& propertyFlags) override; 341 virtual WMError GetSystemBarProperties(std::map<WindowType, SystemBarProperty>& properties) override; 342 virtual WMError SetSpecificBarProperty(WindowType type, const SystemBarProperty& property) override; 343 344 /* 345 * Gesture Back 346 */ SetGestureBackEnabled(bool enable)347 WMError SetGestureBackEnabled(bool enable) override { return WMError::WM_ERROR_DEVICE_NOT_SUPPORT; } GetGestureBackEnabled(bool & enable)348 WMError GetGestureBackEnabled(bool& enable) override { return WMError::WM_ERROR_DEVICE_NOT_SUPPORT; } 349 350 /* 351 * Window Property 352 */ 353 static void UpdateConfigurationSyncForAll(const std::shared_ptr<AppExecFwk::Configuration>& configuration); 354 void UpdateConfigurationSync(const std::shared_ptr<AppExecFwk::Configuration>& configuration) override; 355 void RegisterWindowInspectorCallback(); 356 uint32_t GetApiTargetVersion() const; 357 358 /* 359 * Keyboard 360 */ 361 WMError ShowKeyboard(KeyboardViewMode mode) override; 362 363 private: 364 template<typename T> WMError RegisterListener(std::vector<sptr<T>>& holder, const sptr<T>& listener); 365 template<typename T> WMError UnregisterListener(std::vector<sptr<T>>& holder, const sptr<T>& listener); ClearUselessListeners(std::map<uint32_t,T> & listeners,uint32_t winId)366 template<typename T> void ClearUselessListeners(std::map<uint32_t, T>& listeners, uint32_t winId) 367 { 368 listeners.erase(winId); 369 } ClearUselessListeners(std::unordered_map<uint32_t,T> & listeners,uint32_t winId)370 template<typename T> void ClearUselessListeners(std::unordered_map<uint32_t, T>& listeners, uint32_t winId) 371 { 372 listeners.erase(winId); 373 } 374 template<typename T> EnableIfSame<T, IWindowLifeCycle, std::vector<sptr<IWindowLifeCycle>>> GetListeners(); 375 template<typename T> 376 EnableIfSame<T, IWindowChangeListener, std::vector<sptr<IWindowChangeListener>>> GetListeners(); 377 template<typename T> 378 EnableIfSame<T, IAvoidAreaChangedListener, std::vector<sptr<IAvoidAreaChangedListener>>> GetListeners(); 379 template<typename T> EnableIfSame<T, IDisplayMoveListener, std::vector<sptr<IDisplayMoveListener>>> GetListeners(); 380 template<typename T> EnableIfSame<T, IScreenshotListener, std::vector<sptr<IScreenshotListener>>> GetListeners(); 381 template<typename T> 382 EnableIfSame<T, ITouchOutsideListener, std::vector<sptr<ITouchOutsideListener>>> GetListeners(); 383 template<typename T> 384 EnableIfSame<T, IDialogTargetTouchListener, std::vector<sptr<IDialogTargetTouchListener>>> GetListeners(); 385 template<typename T> EnableIfSame<T, IWindowDragListener, std::vector<sptr<IWindowDragListener>>> GetListeners(); 386 template<typename T> 387 EnableIfSame<T, IOccupiedAreaChangeListener, std::vector<sptr<IOccupiedAreaChangeListener>>> GetListeners(); 388 template<typename T> 389 EnableIfSame<T, IDialogDeathRecipientListener, wptr<IDialogDeathRecipientListener>> GetListener(); 390 391 void NotifyAfterForeground(bool needNotifyListeners = true, bool needNotifyUiContent = true); 392 void NotifyAfterBackground(bool needNotifyListeners = true, bool needNotifyUiContent = true); 393 void NotifyAfterFocused(); 394 void NotifyAfterUnfocused(bool needNotifyUiContent = true); 395 void NotifyAfterResumed(); 396 void NotifyAfterPaused(); 397 void NotifyBeforeDestroy(std::string windowName); 398 void NotifyBeforeSubWindowDestroy(sptr<WindowImpl> window); 399 void NotifyAfterActive(); 400 void NotifyAfterInactive(); 401 void NotifyForegroundFailed(WMError ret); 402 void NotifyBackgroundFailed(WMError ret); 403 bool IsStretchableReason(WindowSizeChangeReason reason); 404 405 void InitWindowProperty(const sptr<WindowOption>& option); 406 void ClearListenersById(uint32_t winId); 407 void NotifySizeChange(Rect rect, WindowSizeChangeReason reason, 408 const std::shared_ptr<RSTransaction>& rsTransaction = nullptr); 409 void NotifyAvoidAreaChange(const sptr<AvoidArea>& avoidArea, AvoidAreaType type); 410 void NotifyDisplayMoveChange(DisplayId from, DisplayId to); 411 void NotifyOccupiedAreaChange(const sptr<OccupiedAreaChangeInfo>& info, 412 const std::shared_ptr<RSTransaction>& rsTransaction = nullptr); 413 void NotifyModeChange(WindowMode mode, bool hasDeco = true); 414 void NotifyDragEvent(const PointInfo& point, DragEvent event); 415 void ResetInputWindow(uint32_t winId); 416 void DestroyDialogWindow(); 417 void DestroyFloatingWindow(); 418 void DestroySubWindow(); 419 void ClearVsyncStation(); 420 void SetDefaultOption(); // for api7 421 bool IsWindowValid() const; 422 static sptr<Window> FindWindowById(uint32_t WinId); 423 void TransferPointerEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent); 424 void ConsumeMoveOrDragEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent); 425 void ReadyToMoveOrDragWindow(const std::shared_ptr<MMI::PointerEvent>& pointerEvent, 426 const MMI::PointerEvent::PointerItem& pointerItem); 427 void EndMoveOrDragWindow(int32_t posX, int32_t posY, int32_t pointId, int32_t sourceType); 428 void ResetMoveOrDragState(); 429 bool IsPointerEventConsumed(); 430 bool IsPointInDragHotZone(int32_t startPointPosX, int32_t startPointPosY, int32_t sourceType); 431 void AdjustWindowAnimationFlag(bool withAnimation = false); 432 void MapFloatingWindowToAppIfNeeded(); 433 void MapDialogWindowToAppIfNeeded(); 434 WMError UpdateProperty(PropertyChangeAction action); 435 WMError Destroy(bool needNotifyServer, bool needClearListener = true); 436 WMError SetBackgroundColor(uint32_t color); 437 uint32_t GetBackgroundColor() const; 438 void InitAbilityInfo(); 439 std::shared_ptr<AppExecFwk::AbilityInfo> GetOriginalAbilityInfo() const; 440 void RecordLifeCycleExceptionEvent(LifeCycleEvent event, WMError errCode) const; 441 std::string TransferLifeCycleEventToString(LifeCycleEvent type) const; 442 Rect GetSystemAlarmWindowDefaultSize(Rect defaultRect); 443 void HandleModeChangeHotZones(int32_t posX, int32_t posY); 444 WMError NotifyWindowTransition(TransitionReason reason); 445 void UpdatePointerEventForStretchableWindow(const std::shared_ptr<MMI::PointerEvent>& pointerEvent); 446 void UpdateDragType(int32_t startPointPosX, int32_t startPointPosY); 447 void HandleBackKeyPressedEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent); 448 bool CheckCameraFloatingWindowMultiCreated(WindowType type); 449 void GetConfigurationFromAbilityInfo(); 450 void UpdateTitleButtonVisibility(); 451 void SetWindowModeSupportType(uint32_t windowModeSupportType); 452 uint32_t GetWindowModeSupportType() const; 453 WMError PreProcessShow(uint32_t reason, bool withAnimation); 454 bool NeedToStopShowing(); 455 void CalculateStartRectExceptHotZone(float virtualPixelRatio); 456 void SetSystemConfig(); 457 void TransformSurfaceNode(const Transform& trans); 458 bool IsAppMainOrSunOrFloatingWindow(); 459 bool IsAppMainOrSubOrFloatingWindow(); 460 WMError WindowCreateCheck(uint32_t parentId); 461 uint32_t CalculatePointerDirection(int32_t pointerX, int32_t pointerY); 462 void HandlePointerStyle(const std::shared_ptr<MMI::PointerEvent>& pointerEvent); 463 RSSurfaceNode::SharedPtr CreateSurfaceNode(std::string name, WindowType type); 464 void UpdateWindowStateUnfrozen(); 465 void UpdateViewportConfig(const Rect& rect, const sptr<class Display>& display, WindowSizeChangeReason reason, 466 const std::shared_ptr<RSTransaction>& rsTransaction = nullptr, 467 const std::map<AvoidAreaType, AvoidArea>& avoidAreas = {}); 468 void UpdateDecorEnable(bool needNotify = false); 469 WMError SetFloatingMaximize(bool isEnter); 470 WMError SetUIContentInner(const std::string& contentInfo, napi_env env, napi_value storage, 471 WindowSetUIContentType setUIContentType, BackupAndRestoreType restoreType, AppExecFwk::Ability* ability); 472 std::shared_ptr<std::vector<uint8_t>> GetAbcContent(const std::string& abcPath); 473 std::string GetRestoredRouterStack(); 474 475 // colorspace, gamut 476 using ColorSpaceConvertMap = struct { 477 ColorSpace colorSpace; 478 GraphicColorGamut surfaceColorGamut; 479 }; 480 static const ColorSpaceConvertMap colorSpaceConvertMap[]; 481 static ColorSpace GetColorSpaceFromSurfaceGamut(GraphicColorGamut colorGamut); 482 static GraphicColorGamut GetSurfaceGamutFromColorSpace(ColorSpace colorSpace); 483 void ChangePropertyByApiVersion(); 484 void PerfLauncherHotAreaIfNeed(const std::shared_ptr<MMI::PointerEvent>& pointerEvent); 485 void SetDefaultDisplayIdIfNeed(); 486 487 static std::map<std::string, std::pair<uint32_t, sptr<Window>>> windowMap_; 488 static std::map<uint32_t, std::vector<sptr<WindowImpl>>> subWindowMap_; 489 static std::map<uint32_t, std::vector<sptr<WindowImpl>>> appFloatingWindowMap_; 490 static std::map<uint32_t, std::vector<sptr<WindowImpl>>> appDialogWindowMap_; 491 sptr<WindowProperty> property_; 492 WindowState state_ { WindowState::STATE_INITIAL }; 493 WindowState subWindowState_ {WindowState::STATE_INITIAL}; 494 WindowTag windowTag_; 495 sptr<IAceAbilityHandler> aceAbilityHandler_; 496 static std::map<uint32_t, std::vector<sptr<IScreenshotListener>>> screenshotListeners_; 497 static std::map<uint32_t, std::vector<sptr<ITouchOutsideListener>>> touchOutsideListeners_; 498 static std::map<uint32_t, std::vector<sptr<IDialogTargetTouchListener>>> dialogTargetTouchListeners_; 499 static std::map<uint32_t, std::vector<sptr<IWindowLifeCycle>>> lifecycleListeners_; 500 static std::map<uint32_t, std::vector<sptr<IWindowChangeListener>>> windowChangeListeners_; 501 static std::map<uint32_t, std::vector<sptr<IAvoidAreaChangedListener>>> avoidAreaChangeListeners_; 502 std::vector<sptr<IWindowDragListener>> windowDragListeners_; 503 std::vector<sptr<IDisplayMoveListener>> displayMoveListeners_; 504 static std::map<uint32_t, std::vector<sptr<IOccupiedAreaChangeListener>>> occupiedAreaChangeListeners_; 505 static std::map<uint32_t, sptr<IDialogDeathRecipientListener>> dialogDeathRecipientListener_; 506 std::shared_ptr<IInputEventConsumer> inputEventConsumer_; 507 sptr<IAnimationTransitionController> animationTransitionController_; 508 NotifyNativeWinDestroyFunc notifyNativefunc_; 509 std::shared_ptr<RSSurfaceNode> surfaceNode_; 510 std::string name_; 511 std::unique_ptr<Ace::UIContent> uiContent_; 512 std::shared_ptr<AbilityRuntime::Context> context_; 513 std::recursive_mutex mutex_; 514 std::recursive_mutex windowStateMutex_; 515 static std::recursive_mutex globalMutex_; 516 static std::shared_mutex windowMapMutex_; 517 const float SYSTEM_ALARM_WINDOW_WIDTH_RATIO = 0.8; 518 const float SYSTEM_ALARM_WINDOW_HEIGHT_RATIO = 0.3; 519 WindowSizeChangeReason lastSizeChangeReason_ = WindowSizeChangeReason::END; 520 521 sptr<MoveDragProperty> moveDragProperty_; 522 SystemConfig windowSystemConfig_; 523 bool isOriginRectSet_ = false; 524 bool needRemoveWindowInputChannel_ = false; 525 bool isMainHandlerAvailable_ = true; 526 bool isAppFloatingWindow_ = false; 527 bool isFocused_ = false; 528 uint32_t mouseStyleID_ = 0; 529 bool isIgnoreSafeAreaNeedNotify_ = false; 530 bool isIgnoreSafeArea_ = false; 531 bool needDefaultAnimation_ = true; 532 bool postTaskDone_ = false; 533 const std::map<DragType, uint32_t> STYLEID_MAP = { 534 {DragType::DRAG_UNDEFINED, MMI::MOUSE_ICON::DEFAULT}, 535 {DragType::DRAG_BOTTOM_OR_TOP, MMI::MOUSE_ICON::NORTH_SOUTH}, 536 {DragType::DRAG_LEFT_OR_RIGHT, MMI::MOUSE_ICON::WEST_EAST}, 537 {DragType::DRAG_LEFT_TOP_CORNER, MMI::MOUSE_ICON::NORTH_WEST_SOUTH_EAST}, 538 {DragType::DRAG_RIGHT_TOP_CORNER, MMI::MOUSE_ICON::NORTH_EAST_SOUTH_WEST} 539 }; ConvertRadiusToSigma(float radius)540 static float ConvertRadiusToSigma(float radius) 541 { 542 constexpr float BlurSigmaScale = 0.57735f; 543 return radius > 0.0f ? BlurSigmaScale * radius + SK_ScalarHalf : 0.0f; 544 } 545 std::shared_ptr<AppExecFwk::EventHandler> handler_ = nullptr; 546 bool needNotifyFocusLater_ = false; 547 bool escKeyEventTriggered_ = false; 548 bool enableImmersiveMode_ = false; 549 std::shared_ptr<VsyncStation> vsyncStation_ = nullptr; 550 std::atomic<float> virtualPixelRatio_ = 1.0f; 551 std::string restoredRouterStack_; // It was set and get in same thread, which is js thread. 552 }; 553 } // namespace Rosen 554 } // namespace OHOS 555 #endif // OHOS_ROSEN_WINDOW_IMPL_H 556