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