1 /* 2 * Copyright (c) 2022 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 FOUNDATION_ACE_FRAMEWORKS_CORE_PIPELINE_CONTAINER_WINDOW_MANAGER_H 17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_PIPELINE_CONTAINER_WINDOW_MANAGER_H 18 19 #include <functional> 20 #include <optional> 21 22 #include "base/memory/ace_type.h" 23 #include "base/system_bar/system_bar_style.h" 24 #include "core/common/window.h" 25 #include "core/components/common/layout/constants.h" 26 27 namespace OHOS::Ace { 28 class PageViewportConfig; 29 30 using WindowCallback = std::function<void(void)>; 31 using WindowModeCallback = std::function<WindowMode(void)>; 32 using WindowMidSceneCallback = std::function<int32_t(bool&)>; 33 using WindowTypeCallback = std::function<WindowType(void)>; 34 using WindowSetMaximizeModeCallback = std::function<void(MaximizeMode)>; 35 using WindowGetMaximizeModeCallback = std::function<MaximizeMode(void)>; 36 using GetSystemBarStyleCallback = std::function<RefPtr<SystemBarStyle>(void)>; 37 using SetSystemBarStyleCallback = std::function<void(const RefPtr<SystemBarStyle>&)>; 38 using GetFreeMultiWindowModeEnabledStateCallback = std::function<bool(void)>; 39 using WindowIsStartMovingCallback = std::function<bool(void)>; 40 using WindowCallNativeCallback = std::function<void(const std::string&, const std::string&)>; 41 using WindowSetSystemBarEnabledCallback = std::function<bool(SystemBarType, std::optional<bool>, std::optional<bool>)>; 42 using GetCurrentViewportConfigCallback = std::function<RefPtr<PageViewportConfig>(void)>; 43 using GetTargetViewportConfigCallback = std::function<RefPtr<PageViewportConfig>(std::optional<Orientation>, 44 std::optional<bool>, std::optional<bool>, std::optional<bool>)>; 45 using IsSetOrientationNeededCallback = std::function<bool(std::optional<Orientation>)>; 46 using SetRequestedOrientationCallback = std::function<void(std::optional<Orientation>, bool)>; 47 using GetRequestedOrientationCallback = std::function<Orientation(void)>; 48 using IsFullScreenWindowCallback = std::function<bool(void)>; 49 using IsPcOrPadFreeMultiWindowModeCallback = std::function<bool(void)>; 50 using GetHeightBreakpoint = std::function<HeightBreakpoint(void)>; 51 using GetWidthBreakpoint = std::function<WidthBreakpoint(void)>; 52 53 struct DecorButtonStyle { 54 int32_t colorMode; 55 uint32_t spacingBetweenButtons; 56 uint32_t closeButtonRightMargin; 57 uint32_t buttonBackgroundSize; 58 uint32_t buttonIconSize; 59 uint32_t buttonBackgroundCornerRadius; 60 }; 61 62 class WindowManager : public virtual AceType { 63 DECLARE_ACE_TYPE(WindowManager, AceType); 64 65 public: 66 WindowManager() = default; 67 ~WindowManager() override = default; 68 SetAppIconId(int32_t id)69 void SetAppIconId(int32_t id) 70 { 71 appIconId_ = id; 72 } 73 GetAppIconId()74 int32_t GetAppIconId() const 75 { 76 return appIconId_; 77 } 78 SetAppLabelId(int32_t id)79 void SetAppLabelId(int32_t id) 80 { 81 appLabelId_ = id; 82 } 83 GetAppLabelId()84 int32_t GetAppLabelId() const 85 { 86 return appLabelId_; 87 } 88 SetWindowMinimizeCallBack(WindowCallback && callback)89 void SetWindowMinimizeCallBack(WindowCallback&& callback) 90 { 91 windowMinimizeCallback_ = std::move(callback); 92 } 93 SetWindowMaximizeCallBack(WindowCallback && callback)94 void SetWindowMaximizeCallBack(WindowCallback&& callback) 95 { 96 windowMaximizeCallback_ = std::move(callback); 97 } 98 SetWindowMaximizeFloatingCallBack(WindowCallback && callback)99 void SetWindowMaximizeFloatingCallBack(WindowCallback&& callback) 100 { 101 windowMaximizeFloatingCallback_ = std::move(callback); 102 } 103 SetWindowRecoverCallBack(WindowCallback && callback)104 void SetWindowRecoverCallBack(WindowCallback&& callback) 105 { 106 windowRecoverCallback_ = std::move(callback); 107 } 108 SetWindowCloseCallBack(WindowCallback && callback)109 void SetWindowCloseCallBack(WindowCallback&& callback) 110 { 111 windowCloseCallback_ = std::move(callback); 112 } 113 SetWindowSplitPrimaryCallBack(WindowCallback && callback)114 void SetWindowSplitPrimaryCallBack(WindowCallback&& callback) 115 { 116 windowSplitPrimaryCallback_ = std::move(callback); 117 } 118 SetWindowSplitSecondaryCallBack(WindowCallback && callback)119 void SetWindowSplitSecondaryCallBack(WindowCallback&& callback) 120 { 121 windowSplitSecondaryCallback_ = std::move(callback); 122 } 123 SetWindowGetModeCallBack(WindowModeCallback && callback)124 void SetWindowGetModeCallBack(WindowModeCallback&& callback) 125 { 126 windowGetModeCallback_ = std::move(callback); 127 } 128 SetWindowGetIsMidSceneCallBack(WindowMidSceneCallback && callback)129 void SetWindowGetIsMidSceneCallBack(WindowMidSceneCallback&& callback) 130 { 131 windowGetIsMidSceneCallback_ = std::move(callback); 132 } 133 SetWindowGetTypeCallBack(WindowTypeCallback && callback)134 void SetWindowGetTypeCallBack(WindowTypeCallback&& callback) 135 { 136 windowGetTypeCallback_ = std::move(callback); 137 } 138 SetWindowStartMoveCallBack(WindowCallback && callback)139 void SetWindowStartMoveCallBack(WindowCallback&& callback) 140 { 141 windowStartMoveCallback_ = std::move(callback); 142 } 143 SetWindowIsStartMovingCallBack(WindowIsStartMovingCallback && callback)144 void SetWindowIsStartMovingCallBack(WindowIsStartMovingCallback&& callback) 145 { 146 WindowIsStartMovingCallback_ = std::move(callback); 147 } 148 SetWindowSetMaximizeModeCallBack(WindowSetMaximizeModeCallback && callback)149 void SetWindowSetMaximizeModeCallBack(WindowSetMaximizeModeCallback&& callback) 150 { 151 windowSetMaximizeModeCallback_ = std::move(callback); 152 } 153 SetWindowGetMaximizeModeCallBack(WindowGetMaximizeModeCallback && callback)154 void SetWindowGetMaximizeModeCallBack(WindowGetMaximizeModeCallback&& callback) 155 { 156 windowGetMaximizeModeCallback_ = std::move(callback); 157 } 158 SetGetSystemBarStyleCallBack(GetSystemBarStyleCallback && callback)159 void SetGetSystemBarStyleCallBack(GetSystemBarStyleCallback&& callback) 160 { 161 getSystemBarStyleCallback_ = std::move(callback); 162 } 163 SetSetSystemBarStyleCallBack(SetSystemBarStyleCallback && callback)164 void SetSetSystemBarStyleCallBack(SetSystemBarStyleCallback&& callback) 165 { 166 setSystemBarStyleCallback_ = std::move(callback); 167 } 168 SetWindowSetSystemBarEnabledCallback(WindowSetSystemBarEnabledCallback && callback)169 void SetWindowSetSystemBarEnabledCallback(WindowSetSystemBarEnabledCallback&& callback) 170 { 171 windowSetSystemBarEnabledCallback_ = std::move(callback); 172 } 173 SetGetCurrentViewportConfigCallback(GetCurrentViewportConfigCallback && callback)174 void SetGetCurrentViewportConfigCallback(GetCurrentViewportConfigCallback&& callback) 175 { 176 getCurrentViewportConfigCallback_ = std::move(callback); 177 } 178 SetGetTargetViewportConfigCallback(GetTargetViewportConfigCallback && callback)179 void SetGetTargetViewportConfigCallback(GetTargetViewportConfigCallback&& callback) 180 { 181 getTargetViewportConfigCallback_ = std::move(callback); 182 } 183 SetIsSetOrientationNeededCallback(IsSetOrientationNeededCallback && callback)184 void SetIsSetOrientationNeededCallback(IsSetOrientationNeededCallback&& callback) 185 { 186 isSetOrientationNeededCallback_ = std::move(callback); 187 } 188 SetSetRequestedOrientationCallback(SetRequestedOrientationCallback && callback)189 void SetSetRequestedOrientationCallback(SetRequestedOrientationCallback&& callback) 190 { 191 setRequestedOrientationCallback_ = std::move(callback); 192 } 193 SetGetRequestedOrientationCallback(GetRequestedOrientationCallback && callback)194 void SetGetRequestedOrientationCallback(GetRequestedOrientationCallback&& callback) 195 { 196 getRequestedOrientationCallback_ = std::move(callback); 197 } 198 SetIsFullScreenWindowCallback(IsFullScreenWindowCallback && callback)199 void SetIsFullScreenWindowCallback(IsFullScreenWindowCallback&& callback) 200 { 201 isFullScreenWindowCallback_ = std::move(callback); 202 } 203 SetIsPcOrPadFreeMultiWindowModeCallback(IsPcOrPadFreeMultiWindowModeCallback && callback)204 void SetIsPcOrPadFreeMultiWindowModeCallback(IsPcOrPadFreeMultiWindowModeCallback&& callback) 205 { 206 isPcOrPadFreeMultiWindowModeCallback_ = std::move(callback); 207 } 208 SetGetFreeMultiWindowModeEnabledStateCallback(GetFreeMultiWindowModeEnabledStateCallback && callback)209 void SetGetFreeMultiWindowModeEnabledStateCallback(GetFreeMultiWindowModeEnabledStateCallback&& callback) 210 { 211 getFreeMultiWindowModeEnabledStateCallback_ = std::move(callback); 212 } 213 SetPerformBackCallback(WindowCallback && callback)214 void SetPerformBackCallback(WindowCallback&& callback) 215 { 216 windowPerformBackCallback_ = callback; 217 } 218 SetWindowCallNativeCallback(WindowCallNativeCallback && callback)219 void SetWindowCallNativeCallback(WindowCallNativeCallback&& callback) 220 { 221 callNativeCallback_ = std::move(callback); 222 } 223 FireWindowCallNativeCallback(const std::string & name,const std::string & value)224 void FireWindowCallNativeCallback(const std::string& name, const std::string& value) 225 { 226 if (callNativeCallback_) { 227 callNativeCallback_(name, value); 228 } 229 } 230 WindowMinimize()231 void WindowMinimize() const 232 { 233 if (windowMinimizeCallback_) { 234 windowMinimizeCallback_(); 235 } 236 } 237 238 void WindowMaximize(bool supportFloatingMaximize = false) 239 { 240 if (supportFloatingMaximize && windowMaximizeFloatingCallback_) { 241 windowMaximizeFloatingCallback_(); 242 maximizeMode_ = GetWindowMaximizeMode(); 243 } 244 if (!supportFloatingMaximize && windowMaximizeCallback_) { 245 windowMaximizeCallback_(); 246 } 247 } 248 WindowRecover()249 void WindowRecover() 250 { 251 if (windowRecoverCallback_) { 252 windowRecoverCallback_(); 253 maximizeMode_ = MaximizeMode::MODE_RECOVER; 254 } 255 } 256 257 void FireWindowSplitCallBack(bool isPrimary = true) const 258 { 259 if (isPrimary && windowSplitPrimaryCallback_) { 260 windowSplitPrimaryCallback_(); 261 } 262 if (!isPrimary && windowSplitSecondaryCallback_) { 263 windowSplitSecondaryCallback_(); 264 } 265 } 266 WindowClose()267 void WindowClose() const 268 { 269 if (windowCloseCallback_) { 270 windowCloseCallback_(); 271 } 272 } 273 WindowStartMove()274 void WindowStartMove() const 275 { 276 if (windowStartMoveCallback_) { 277 windowStartMoveCallback_(); 278 } 279 } 280 WindowIsStartMoving()281 bool WindowIsStartMoving() const 282 { 283 if (WindowIsStartMovingCallback_) { 284 return WindowIsStartMovingCallback_(); 285 } 286 return false; 287 } 288 WindowPerformBack()289 void WindowPerformBack() const 290 { 291 if (windowPerformBackCallback_) { 292 windowPerformBackCallback_(); 293 } 294 } 295 GetWindowMode()296 WindowMode GetWindowMode() const 297 { 298 if (windowGetModeCallback_) { 299 return windowGetModeCallback_(); 300 } 301 return WindowMode::WINDOW_MODE_UNDEFINED; 302 } 303 GetIsMidScene(bool & isMidScene)304 int32_t GetIsMidScene(bool& isMidScene) const 305 { 306 if (windowGetIsMidSceneCallback_) { 307 return windowGetIsMidSceneCallback_(isMidScene); 308 } 309 return -1; 310 } 311 GetWindowType()312 WindowType GetWindowType() const 313 { 314 if (windowGetTypeCallback_) { 315 return windowGetTypeCallback_(); 316 } 317 return WindowType::WINDOW_TYPE_UNDEFINED; 318 } 319 SetWindowMaximizeMode(MaximizeMode mode)320 void SetWindowMaximizeMode(MaximizeMode mode) 321 { 322 if (windowSetMaximizeModeCallback_) { 323 windowSetMaximizeModeCallback_(mode); 324 } 325 } 326 GetWindowMaximizeMode()327 MaximizeMode GetWindowMaximizeMode() const 328 { 329 if (windowGetMaximizeModeCallback_) { 330 return windowGetMaximizeModeCallback_(); 331 } 332 return MaximizeMode::MODE_RECOVER; 333 } 334 GetCurrentWindowMaximizeMode()335 MaximizeMode GetCurrentWindowMaximizeMode() const 336 { 337 return maximizeMode_; 338 } 339 SetCurrentWindowMaximizeMode(MaximizeMode mode)340 void SetCurrentWindowMaximizeMode(MaximizeMode mode) 341 { 342 maximizeMode_ = mode; 343 } 344 GetSystemBarStyle()345 RefPtr<SystemBarStyle> GetSystemBarStyle() 346 { 347 if (getSystemBarStyleCallback_) { 348 return getSystemBarStyleCallback_(); 349 } 350 return nullptr; 351 } 352 SetSystemBarStyle(const RefPtr<SystemBarStyle> & style)353 void SetSystemBarStyle(const RefPtr<SystemBarStyle>& style) 354 { 355 if (setSystemBarStyleCallback_) { 356 setSystemBarStyleCallback_(style); 357 } 358 } 359 SetWindowSystemBarEnabled(SystemBarType type,std::optional<bool> enabled,std::optional<bool> needAnimation)360 bool SetWindowSystemBarEnabled(SystemBarType type, std::optional<bool> enabled, std::optional<bool> needAnimation) 361 { 362 if (windowSetSystemBarEnabledCallback_) { 363 return windowSetSystemBarEnabledCallback_(type, enabled, needAnimation); 364 } 365 return false; 366 } 367 368 RefPtr<PageViewportConfig> GetCurrentViewportConfig(); 369 RefPtr<PageViewportConfig> GetTargetViewportConfig( 370 std::optional<Orientation> orientation, std::optional<bool> enableStatusBar, 371 std::optional<bool> statusBarAnimation, std::optional<bool> enableNavIndicator); 372 IsSetOrientationNeeded(std::optional<Orientation> orientation)373 bool IsSetOrientationNeeded(std::optional<Orientation> orientation) 374 { 375 if (isSetOrientationNeededCallback_) { 376 return isSetOrientationNeededCallback_(orientation); 377 } 378 return false; 379 } 380 381 void SetRequestedOrientation(std::optional<Orientation> orientation, bool needAnimation = true) 382 { 383 if (setRequestedOrientationCallback_) { 384 setRequestedOrientationCallback_(orientation, needAnimation); 385 } 386 } 387 GetRequestedOrientation()388 Orientation GetRequestedOrientation() const 389 { 390 if (getRequestedOrientationCallback_) { 391 return getRequestedOrientationCallback_(); 392 } 393 return Orientation::UNSPECIFIED; 394 } 395 IsFullScreenWindow()396 bool IsFullScreenWindow() const 397 { 398 if (isFullScreenWindowCallback_) { 399 return isFullScreenWindowCallback_(); 400 } 401 return false; 402 } 403 IsPcOrPadFreeMultiWindowMode()404 bool IsPcOrPadFreeMultiWindowMode() const 405 { 406 if (isPcOrPadFreeMultiWindowModeCallback_) { 407 return isPcOrPadFreeMultiWindowModeCallback_(); 408 } 409 return false; 410 } 411 GetFreeMultiWindowModeEnabledState()412 bool GetFreeMultiWindowModeEnabledState() const 413 { 414 if (getFreeMultiWindowModeEnabledStateCallback_) { 415 return getFreeMultiWindowModeEnabledStateCallback_(); 416 } 417 return false; 418 } 419 SetWindowUseImplicitAnimationCallBack(std::function<void (bool)> && callback)420 void SetWindowUseImplicitAnimationCallBack(std::function<void(bool)>&& callback) 421 { 422 useImplicitAnimationCallback_ = std::move(callback); 423 } 424 SetWindowUseImplicitAnimation(bool useImplicit)425 void SetWindowUseImplicitAnimation(bool useImplicit) 426 { 427 if (useImplicitAnimationCallback_) { 428 useImplicitAnimationCallback_(useImplicit); 429 } 430 } 431 SetHeightBreakpointCallback(GetHeightBreakpoint && callback)432 void SetHeightBreakpointCallback(GetHeightBreakpoint&& callback) 433 { 434 getHeightBreakpointCallback_ = std::move(callback); 435 } 436 SetWidthBreakpointCallback(GetWidthBreakpoint && callback)437 void SetWidthBreakpointCallback(GetWidthBreakpoint&& callback) 438 { 439 getWidthBreakpointCallback_ = std::move(callback); 440 } 441 GetHeightBreakpointCallback()442 HeightBreakpoint GetHeightBreakpointCallback() const 443 { 444 if (getHeightBreakpointCallback_) { 445 return getHeightBreakpointCallback_(); 446 } 447 return HeightBreakpoint::HEIGHT_SM; 448 } 449 GetWidthBreakpointCallback()450 WidthBreakpoint GetWidthBreakpointCallback() const 451 { 452 if (getWidthBreakpointCallback_) { 453 return getWidthBreakpointCallback_(); 454 } 455 return WidthBreakpoint::WIDTH_SM; 456 } 457 458 private: 459 int32_t appLabelId_ = 0; 460 int32_t appIconId_ = 0; 461 MaximizeMode maximizeMode_ = MaximizeMode::MODE_RECOVER; 462 WindowCallback windowMinimizeCallback_; 463 WindowCallback windowRecoverCallback_; 464 WindowCallback windowCloseCallback_; 465 WindowCallback windowSplitPrimaryCallback_; 466 WindowCallback windowSplitSecondaryCallback_; 467 WindowCallback windowStartMoveCallback_; 468 WindowIsStartMovingCallback WindowIsStartMovingCallback_; 469 WindowCallback windowPerformBackCallback_; 470 WindowCallback windowMaximizeCallback_; 471 WindowCallback windowMaximizeFloatingCallback_; 472 WindowSetMaximizeModeCallback windowSetMaximizeModeCallback_; 473 WindowGetMaximizeModeCallback windowGetMaximizeModeCallback_; 474 WindowModeCallback windowGetModeCallback_; 475 WindowMidSceneCallback windowGetIsMidSceneCallback_; 476 WindowTypeCallback windowGetTypeCallback_; 477 GetSystemBarStyleCallback getSystemBarStyleCallback_; 478 SetSystemBarStyleCallback setSystemBarStyleCallback_; 479 WindowSetSystemBarEnabledCallback windowSetSystemBarEnabledCallback_; 480 GetCurrentViewportConfigCallback getCurrentViewportConfigCallback_; 481 GetTargetViewportConfigCallback getTargetViewportConfigCallback_; 482 IsSetOrientationNeededCallback isSetOrientationNeededCallback_; 483 SetRequestedOrientationCallback setRequestedOrientationCallback_; 484 GetRequestedOrientationCallback getRequestedOrientationCallback_; 485 IsFullScreenWindowCallback isFullScreenWindowCallback_; 486 IsPcOrPadFreeMultiWindowModeCallback isPcOrPadFreeMultiWindowModeCallback_; 487 GetFreeMultiWindowModeEnabledStateCallback getFreeMultiWindowModeEnabledStateCallback_; 488 WindowCallNativeCallback callNativeCallback_; 489 std::function<void(bool)> useImplicitAnimationCallback_; 490 GetHeightBreakpoint getHeightBreakpointCallback_; 491 GetWidthBreakpoint getWidthBreakpointCallback_; 492 }; 493 494 } // namespace OHOS::Ace 495 496 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_PIPELINE_CONTAINER_WINDOW_MANAGER_H 497