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