1 /* 2 * Copyright (c) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef OHOS_ROSEN_WINDOW_SCENE_WS_COMMON_H 17 #define OHOS_ROSEN_WINDOW_SCENE_WS_COMMON_H 18 19 #include <inttypes.h> 20 #include <iomanip> 21 #include <map> 22 #include <sstream> 23 #include <string> 24 25 #include <iremote_broker.h> 26 #include <want.h> 27 28 namespace OHOS::AAFwk { 29 class AbilityStartSetting; 30 class ProcessOptions; 31 class StartWindowOption; 32 } 33 namespace OHOS::AppExecFwk { 34 struct AbilityInfo; 35 enum class SupportWindowMode; 36 } 37 38 namespace OHOS::Rosen { 39 class RSTransaction; 40 constexpr int32_t ROTATE_ANIMATION_DURATION = 400; 41 constexpr int32_t INVALID_SESSION_ID = 0; 42 const std::string UI_TYPE_PHONE = "phone"; 43 const std::string UI_TYPE_PC = "pc"; 44 const std::string UI_TYPE_PAD = "pad"; 45 constexpr int32_t WINDOW_SUPPORT_MODE_MAX_SIZE = 4; 46 47 enum class WSError : int32_t { 48 WS_OK = 0, 49 WS_DO_NOTHING, 50 WS_ERROR_NO_MEM, 51 WS_ERROR_DESTROYED_OBJECT, 52 WS_ERROR_INVALID_WINDOW, 53 WS_ERROR_INVALID_WINDOW_MODE_OR_SIZE, 54 WS_ERROR_INVALID_OPERATION, 55 WS_ERROR_INVALID_PERMISSION, 56 WS_ERROR_NOT_SYSTEM_APP, 57 WS_ERROR_NO_REMOTE_ANIMATION, 58 WS_ERROR_INVALID_DISPLAY, 59 WS_ERROR_INVALID_PARENT, 60 WS_ERROR_OPER_FULLSCREEN_FAILED, 61 WS_ERROR_REPEAT_OPERATION, 62 WS_ERROR_INVALID_SESSION, 63 WS_ERROR_INVALID_CALLING, 64 WS_ERROR_UNCLEARABLE_SESSION, 65 WS_ERROR_FAIL_TO_GET_SNAPSHOT, 66 WS_ERROR_INTERNAL_ERROR, 67 WS_ERROR_NO_UI_CONTENT_ERROR, 68 69 WS_ERROR_DEVICE_NOT_SUPPORT = 801, // the value do not change.It is defined on all system 70 71 WS_ERROR_NEED_REPORT_BASE = 1000, // error code > 1000 means need report 72 WS_ERROR_NULLPTR, 73 WS_ERROR_INVALID_TYPE, 74 WS_ERROR_INVALID_PARAM, 75 WS_ERROR_SAMGR, 76 WS_ERROR_IPC_FAILED, 77 WS_ERROR_NEED_REPORT_END, 78 WS_ERROR_START_ABILITY_FAILED, 79 WS_ERROR_SET_SESSION_LABEL_FAILED, 80 WS_ERROR_SET_SESSION_ICON_FAILED, 81 WS_ERROR_INVALID_SESSION_LISTENER, 82 WS_ERROR_START_UI_EXTENSION_ABILITY_FAILED, 83 WS_ERROR_MIN_UI_EXTENSION_ABILITY_FAILED, 84 WS_ERROR_TERMINATE_UI_EXTENSION_ABILITY_FAILED, 85 WS_ERROR_PRE_HANDLE_COLLABORATOR_FAILED, 86 87 WS_ERROR_EDM_CONTROLLED = 2097215, // enterprise limit 88 }; 89 90 enum class WSErrorCode : int32_t { 91 WS_OK = 0, 92 WS_ERROR_NO_PERMISSION = 201, 93 WS_ERROR_INVALID_PARAM = 401, 94 WS_ERROR_DEVICE_NOT_SUPPORT = 801, 95 WS_ERROR_NOT_REGISTER_SYNC_CALLBACK = 100011, 96 WS_ERROR_TRANSFER_DATA_FAILED = 100012, 97 WS_ERROR_REPEAT_OPERATION = 1300001, 98 WS_ERROR_STATE_ABNORMALLY = 1300002, 99 WS_ERROR_SYSTEM_ABNORMALLY = 1300003, 100 WS_ERROR_INVALID_CALLING = 1300004, 101 WS_ERROR_STAGE_ABNORMALLY = 1300005, 102 WS_ERROR_CONTEXT_ABNORMALLY = 1300006, 103 104 WS_ERROR_EDM_CONTROLLED = 16000013, // enterprise limit 105 }; 106 107 const std::map<WSError, WSErrorCode> WS_JS_TO_ERROR_CODE_MAP { 108 { WSError::WS_OK, WSErrorCode::WS_OK }, 109 { WSError::WS_DO_NOTHING, WSErrorCode::WS_ERROR_STATE_ABNORMALLY }, 110 { WSError::WS_ERROR_INVALID_SESSION, WSErrorCode::WS_ERROR_STATE_ABNORMALLY }, 111 { WSError::WS_ERROR_INVALID_PARAM, WSErrorCode::WS_ERROR_STATE_ABNORMALLY }, 112 { WSError::WS_ERROR_IPC_FAILED, WSErrorCode::WS_ERROR_SYSTEM_ABNORMALLY }, 113 { WSError::WS_ERROR_NULLPTR, WSErrorCode::WS_ERROR_STATE_ABNORMALLY }, 114 { WSError::WS_ERROR_EDM_CONTROLLED, WSErrorCode::WS_ERROR_EDM_CONTROLLED }, 115 { WSError::WS_ERROR_INVALID_WINDOW, WSErrorCode::WS_ERROR_STATE_ABNORMALLY }, 116 }; 117 118 enum class SessionState : uint32_t { 119 STATE_DISCONNECT = 0, 120 STATE_CONNECT, 121 STATE_FOREGROUND, 122 STATE_ACTIVE, 123 STATE_INACTIVE, 124 STATE_BACKGROUND, 125 STATE_END, 126 }; 127 128 enum ContinueState { 129 CONTINUESTATE_UNKNOWN = -1, 130 CONTINUESTATE_ACTIVE = 0, 131 CONTINUESTATE_INACTIVE = 1, 132 CONTINUESTATE_MAX 133 }; 134 135 enum class StartMethod : int32_t { 136 START_NORMAL, 137 START_CALL 138 }; 139 140 /** 141 * @brief collaborator type. 142 */ 143 enum CollaboratorType : int32_t { 144 DEFAULT_TYPE = 0, 145 RESERVE_TYPE, 146 OTHERS_TYPE, 147 }; 148 149 enum AncoSceneState: int32_t { 150 DEFAULT_STATE = 0, 151 NOTIFY_START, 152 NOTIFY_CREATE, 153 NOTIFY_LOAD, 154 NOTIFY_UPDATE, 155 NOTIFY_FOREGROUND, 156 }; 157 158 /** 159 * @brief collaborator type. 160 */ 161 enum SessionOperationType : int32_t { 162 TYPE_DEFAULT = 0, 163 TYPE_CLEAR, 164 }; 165 166 enum class ManagerState : uint32_t { 167 MANAGER_STATE_SCREEN_LOCKED = 0, 168 }; 169 170 /** 171 * @brief Enumerates picture in picture control status. 172 */ 173 enum class WsPiPControlStatus : int32_t { 174 PLAY = 1, 175 PAUSE = 0, 176 OPEN = 1, 177 CLOSE = 0, 178 ENABLED = -2, 179 DISABLED = -3, 180 }; 181 182 /** 183 * @brief Enumerates picture in picture control type. 184 */ 185 enum class WsPiPControlType : uint32_t { 186 VIDEO_PLAY_PAUSE = 0, 187 VIDEO_PREVIOUS = 1, 188 VIDEO_NEXT = 2, 189 FAST_FORWARD = 3, 190 FAST_BACKWARD = 4, 191 HANG_UP_BUTTON = 5, 192 MICROPHONE_SWITCH = 6, 193 CAMERA_SWITCH = 7, 194 MUTE_SWITCH = 8, 195 END, 196 }; 197 198 enum class FocusChangeReason { 199 /** 200 * default focus change reason 201 */ 202 DEFAULT = 0, 203 /** 204 * focus change for move up 205 */ 206 MOVE_UP, 207 /** 208 * focus change for click 209 */ 210 CLICK, 211 /** 212 * focus change for foreground 213 */ 214 FOREGROUND, 215 /** 216 * focus change for background 217 */ 218 BACKGROUND, 219 /** 220 * focus change for split screen.5 221 */ 222 SPLIT_SCREEN, 223 /** 224 * focus change for full screen 225 */ 226 FULL_SCREEN, 227 /** 228 * focus change for global search 229 */ 230 SCB_SESSION_REQUEST, 231 /** 232 * focus change for floating scene 233 */ 234 FLOATING_SCENE, 235 /** 236 * focus change for losing focus 237 */ 238 SCB_SESSION_REQUEST_UNFOCUS, 239 /** 240 * focus change for client requerst.10 241 */ 242 CLIENT_REQUEST, 243 /** 244 * focus change for wind 245 */ 246 WIND, 247 /** 248 * focus change for app foreground 249 */ 250 APP_FOREGROUND, 251 /** 252 * focus change for app background 253 */ 254 APP_BACKGROUND, 255 /** 256 * focus change for recent,Multitasking 257 */ 258 RECENT, 259 /** 260 * focus change for inner app. 261 */ 262 SCB_START_APP, 263 /** 264 * focus for setting focuable. 265 */ 266 FOCUSABLE, 267 /** 268 * select last focused app when requestSessionUnFocus. 269 */ 270 LAST_FOCUSED_APP, 271 /** 272 * focus for zOrder pass through VOICE_INTERACTION. 273 */ 274 VOICE_INTERACTION, 275 /** 276 * focus change max. 277 */ 278 MAX, 279 }; 280 281 enum class SceneType : uint8_t { 282 DEFAULT = 0, 283 WINDOW_SCENE, 284 SYSTEM_WINDOW_SCENE, 285 TRANSFORM_SCENE, 286 PANEL_SCENE, 287 INPUT_SCENE, 288 }; 289 290 struct SessionInfo { 291 std::string bundleName_ = ""; 292 std::string moduleName_ = ""; 293 std::string abilityName_ = ""; 294 int32_t appIndex_ = 0; 295 bool isSystem_ = false; 296 SceneType sceneType_ = SceneType::WINDOW_SCENE; 297 uint32_t windowType_ = 1; // WINDOW_TYPE_APP_MAIN_WINDOW 298 sptr<IRemoteObject> callerToken_ = nullptr; 299 sptr<IRemoteObject> rootToken_ = nullptr; 300 uint64_t screenId_ = -1ULL; // -1ULL: SCREEN_ID_INVALID 301 bool isPersistentRecover_ = false; 302 bool isFromIcon_ = false; 303 304 mutable std::shared_ptr<AAFwk::Want> want = nullptr; // want for ability start 305 std::shared_ptr<AAFwk::Want> closeAbilityWant = nullptr; 306 std::shared_ptr<AAFwk::AbilityStartSetting> startSetting = nullptr; 307 std::shared_ptr<AAFwk::ProcessOptions> processOptions = nullptr; 308 std::shared_ptr<AAFwk::StartWindowOption> startWindowOption = nullptr; 309 mutable std::shared_ptr<AppExecFwk::AbilityInfo> abilityInfo = nullptr; 310 int32_t resultCode = -1; 311 int32_t requestCode = -1; 312 int32_t errorCode = -1; 313 std::string errorReason = ""; 314 int32_t persistentId_ = INVALID_SESSION_ID; 315 int32_t callerPersistentId_ = INVALID_SESSION_ID; 316 std::string callerBundleName_ = ""; 317 std::string callerAbilityName_ = ""; 318 uint32_t callState_ = 0; 319 uint32_t callingTokenId_ = 0; 320 bool reuse = false; 321 int32_t windowMode = 0; 322 StartMethod startMethod = StartMethod::START_NORMAL; 323 bool lockedState = false; 324 std::string time = ""; 325 ContinueState continueState = ContinueState::CONTINUESTATE_ACTIVE; 326 int64_t uiAbilityId_ = 0; 327 int32_t ancoSceneState = 0; 328 bool isClearSession = false; 329 std::string sessionAffinity = ""; 330 int32_t collaboratorType_ = CollaboratorType::DEFAULT_TYPE; 331 SessionState sessionState_ = SessionState::STATE_DISCONNECT; 332 uint32_t requestOrientation_ = 0; 333 bool isRotable_ = false; 334 bool isSetPointerAreas_ = false; 335 bool isCastSession_ = false; 336 uint32_t windowInputType_ = 0; 337 std::string continueSessionId_ = ""; 338 bool isCalledRightlyByCallerId_ = false; 339 bool fullScreenStart_ = false; 340 bool isAtomicService_ = false; 341 bool isBackTransition_ = false; 342 bool needClearInNotShowRecent_ = false; 343 344 /* 345 * UIExtension 346 */ 347 int32_t realParentId_ = INVALID_SESSION_ID; 348 uint32_t uiExtensionUsage_ = 0; 349 bool isAsyncModalBinding_ = false; 350 uint32_t parentWindowType_ = 1; // WINDOW_TYPE_APP_MAIN_WINDOW 351 352 /** 353 * PC Window 354 */ 355 std::vector<AppExecFwk::SupportWindowMode> supportWindowModes; 356 }; 357 358 enum class SessionFlag : uint32_t { 359 SESSION_FLAG_NEED_AVOID = 1, 360 SESSION_FLAG_PARENT_LIMIT = 1 << 1, 361 SESSION_FLAG_SHOW_WHEN_LOCKED = 1 << 2, 362 SESSION_FLAG_FORBID_SPLIT_MOVE = 1 << 3, 363 SESSION_FLAG_WATER_MARK = 1 << 4, 364 SESSION_FLAG_END = 1 << 5, 365 }; 366 367 enum class SizeChangeReason : uint32_t { 368 UNDEFINED = 0, 369 MAXIMIZE, 370 RECOVER, 371 ROTATION, 372 DRAG, 373 DRAG_START, 374 DRAG_END, 375 RESIZE, 376 MOVE, 377 HIDE, 378 TRANSFORM, 379 CUSTOM_ANIMATION_SHOW, 380 FULL_TO_SPLIT, 381 SPLIT_TO_FULL, 382 FULL_TO_FLOATING, 383 FLOATING_TO_FULL, 384 PIP_START, 385 PIP_SHOW, 386 PIP_AUTO_START, 387 PIP_RATIO_CHANGE, 388 PIP_RESTORE, 389 UPDATE_DPI_SYNC, 390 DRAG_MOVE, 391 END, 392 }; 393 IsMoveToOrDragMove(SizeChangeReason reason)394 inline bool IsMoveToOrDragMove(SizeChangeReason reason) 395 { 396 return reason == SizeChangeReason::MOVE || reason == SizeChangeReason::DRAG_MOVE; 397 } 398 399 enum class SessionEvent : uint32_t { 400 EVENT_MAXIMIZE = 100, 401 EVENT_RECOVER, 402 EVENT_MINIMIZE, 403 EVENT_CLOSE, 404 EVENT_START_MOVE, 405 EVENT_END_MOVE, 406 EVENT_MAXIMIZE_FLOATING, 407 EVENT_TERMINATE, 408 EVENT_EXCEPTION, 409 EVENT_SPLIT_PRIMARY, 410 EVENT_SPLIT_SECONDARY, 411 EVENT_DRAG_START, 412 EVENT_DRAG, 413 }; 414 415 enum class BrokerStates: uint32_t { 416 BROKER_UNKOWN = 1, 417 BROKER_STARTED = 0, 418 BROKER_NOT_START = -1, 419 }; 420 GreatOrEqual(double left,double right)421 inline bool GreatOrEqual(double left, double right) 422 { 423 constexpr double epsilon = -0.00001f; 424 return (left - right) > epsilon; 425 } 426 LessOrEqual(double left,double right)427 inline bool LessOrEqual(double left, double right) 428 { 429 constexpr double epsilon = 0.00001f; 430 return (left - right) < epsilon; 431 } 432 NearEqual(const double left,const double right,const double epsilon)433 inline bool NearEqual(const double left, const double right, const double epsilon) 434 { 435 return (std::fabs(left - right) <= epsilon); 436 } 437 NearEqual(const float & left,const float & right)438 inline bool NearEqual(const float& left, const float& right) 439 { 440 constexpr double epsilon = 0.001f; 441 return NearEqual(left, right, epsilon); 442 } 443 NearEqual(const int32_t & left,const int32_t & right)444 inline bool NearEqual(const int32_t& left, const int32_t& right) 445 { 446 return left == right; 447 } 448 NearZero(const double left)449 inline bool NearZero(const double left) 450 { 451 constexpr double epsilon = 0.001f; 452 return NearEqual(left, 0.0, epsilon); 453 } 454 455 template<typename T> 456 struct WSRectT { 457 T posX_ = 0; 458 T posY_ = 0; 459 T width_ = 0; 460 T height_ = 0; 461 462 bool operator==(const WSRectT<T>& a) const 463 { 464 return (NearEqual(posX_, a.posX_) && NearEqual(posY_, a.posY_) && 465 NearEqual(width_, a.width_) && NearEqual(height_, a.height_)); 466 } 467 468 bool operator!=(const WSRectT<T>& a) const 469 { 470 return !this->operator==(a); 471 } 472 IsEmptyWSRectT473 bool IsEmpty() const 474 { 475 if (NearZero(posX_) && NearZero(posY_) && NearZero(width_) && NearZero(height_)) { 476 return true; 477 } 478 return false; 479 } 480 IsInRegionWSRectT481 inline bool IsInRegion(int32_t pointX, int32_t pointY) 482 { 483 return GreatOrEqual(pointX, posX_) && LessOrEqual(pointX, posX_ + width_) && 484 GreatOrEqual(pointY, posY_) && LessOrEqual(pointY, posY_ + height_); 485 } 486 IsInvalidWSRectT487 inline bool IsInvalid() const 488 { 489 return IsEmpty() || LessOrEqual(width_, 0) || LessOrEqual(height_, 0); 490 } 491 ToStringWSRectT492 inline std::string ToString() const 493 { 494 constexpr int precision = 2; 495 std::stringstream ss; 496 ss << "[" << std::fixed << std::setprecision(precision) << posX_ << " " << posY_ << " " << 497 width_ << " " << height_ << "]"; 498 return ss.str(); 499 } 500 }; 501 502 using WSRect = WSRectT<int32_t>; 503 using WSRectF = WSRectT<float>; 504 505 struct WindowShadowConfig { 506 float offsetX_ = 0.0f; 507 float offsetY_ = 0.0f; 508 float alpha_ = 0.0f; 509 float radius_ = 0.0f; 510 std::string color_ = "#000000"; 511 }; 512 513 struct KeyboardSceneAnimationConfig { 514 std::string curveType_ = "default"; 515 float ctrlX1_ = 0.2f; 516 float ctrlY1_ = 0.0f; 517 float ctrlX2_ = 0.2f; 518 float ctrlY2_ = 1.0f; 519 uint32_t duration_ = 150; 520 }; 521 522 struct WindowAnimationConfig { 523 int32_t duration_ = 0; 524 std::string curveType_ = "easeOut"; 525 float ctrlX1_ = 0.2f; 526 float ctrlY1_ = 0.0f; 527 float ctrlX2_ = 0.2f; 528 float ctrlY2_ = 1.0f; 529 float scaleX_ = 0.0f; 530 float scaleY_ = 0.0f; 531 float rotationX_ = 0.0f; 532 float rotationY_ = 0.0f; 533 float rotationZ_ = 0.0f; 534 int32_t angle_ = 0; 535 float translateX_ = 0.0f; 536 float translateY_ = 0.0f; 537 float opacity_ = 0; 538 }; 539 540 struct StartingWindowInfo { 541 int32_t startingWindowBackgroundId_; 542 int32_t startingWindowIconId_; 543 uint32_t startingWindowBackgroundColor_; 544 std::string startingWindowIconPath_; 545 }; 546 547 struct StartingWindowAnimationConfig { 548 bool enabled_ = true; 549 int duration_ = 200; 550 std::string curve_ = "linear"; 551 float opacityStart_ = 1; 552 float opacityEnd_ = 0; 553 }; 554 555 struct SystemUIStatusBarConfig { 556 bool showInLandscapeMode_ = false; 557 std::string immersiveStatusBarBgColor_ = "#4c000000"; 558 std::string immersiveStatusBarContentColor_ = "#ffffff"; 559 }; 560 561 struct StatusBarConfig { 562 bool showHide_ = false; 563 std::string contentColor_; 564 std::string backgroundColor_; 565 }; 566 567 struct WindowImmersive { 568 StatusBarConfig desktopStatusBarConfig_; 569 StatusBarConfig leftRightStatusBarConfig_; 570 StatusBarConfig upDownStatusBarConfig_; 571 }; 572 573 struct AppWindowSceneConfig { 574 float floatCornerRadius_ = 0.0f; 575 std::string uiType_ = UI_TYPE_PHONE; 576 bool backgroundScreenLock_ = false; 577 std::string rotationMode_ = "windowRotation"; 578 WindowShadowConfig focusedShadow_; 579 WindowShadowConfig unfocusedShadow_; 580 KeyboardSceneAnimationConfig keyboardAnimationIn_; 581 KeyboardSceneAnimationConfig keyboardAnimationOut_; 582 WindowAnimationConfig windowAnimation_; 583 StartingWindowAnimationConfig startingWindowAnimationConfig_; 584 SystemUIStatusBarConfig systemUIStatusBarConfig_; 585 WindowImmersive windowImmersive_; 586 }; 587 588 struct DeviceScreenConfig { 589 std::string rotationPolicy_ = "11"; // default use phone policy 590 std::string defaultRotationPolicy_ = "1"; // default unspecified policy 591 bool isRightPowerButton_ = true; 592 }; 593 594 struct SceneAnimationConfig { 595 std::shared_ptr<RSTransaction> rsTransaction_ = nullptr; 596 int32_t animationDuration_ = ROTATE_ANIMATION_DURATION; 597 }; 598 599 struct RotateAnimationConfig { 600 int32_t duration_ = ROTATE_ANIMATION_DURATION; 601 }; 602 603 604 struct SessionEventParam { 605 int32_t pointerX_ = 0; 606 int32_t pointerY_ = 0; 607 int32_t sessionWidth_ = 0; 608 int32_t sessionHeight_ = 0; 609 uint32_t dragResizeType = 0; 610 }; 611 612 /** 613 * @brief Enumerates session gravity. 614 */ 615 enum class SessionGravity : uint32_t { 616 SESSION_GRAVITY_FLOAT = 0, 617 SESSION_GRAVITY_BOTTOM, 618 SESSION_GRAVITY_DEFAULT, 619 }; 620 621 /** 622 * @brief TerminateType session terminate type. 623 */ 624 enum class TerminateType : uint32_t { 625 CLOSE_AND_KEEP_MULTITASK = 0, 626 CLOSE_AND_CLEAR_MULTITASK, 627 CLOSE_AND_START_CALLER, 628 CLOSE_BY_EXCEPTION, 629 }; 630 631 /** 632 * @brief System animaged scene type. 633 */ 634 enum class SystemAnimatedSceneType : uint32_t { 635 SCENE_ENTER_MISSION_CENTER, // Enter the mission center 636 SCENE_EXIT_MISSION_CENTER, // Exit the mission center 637 SCENE_ENTER_TFS_WINDOW, // Three-finger sliding window recovery 638 SCENE_EXIT_TFU_WINDOW, // The three-finger up window disappears 639 SCENE_ENTER_WINDOW_FULL_SCREEN, // Enter the window full screen 640 SCENE_EXIT_WINDOW_FULL_SCREEN, // Exit the window full screen 641 SCENE_ENTER_MAX_WINDOW, // Enter the window maximization state 642 SCENE_EXIT_MAX_WINDOW, // Exit the window maximization state 643 SCENE_ENTER_SPLIT_SCREEN, // Enter the split screen 644 SCENE_EXIT_SPLIT_SCREEN, // Exit the split screen 645 SCENE_ENTER_APP_CENTER, // Enter the app center 646 SCENE_EXIT_APP_CENTER, // Exit the app center 647 SCENE_APPEAR_MISSION_CENTER, // A special case scenario that displays the mission center 648 SCENE_ENTER_WIND_CLEAR, // Enter win+D in clear screen mode 649 SCENE_ENTER_WIND_RECOVER, // Enter win+D in recover mode 650 SCENE_ENTER_RECENTS, // Enter recents 651 SCENE_EXIT_RECENTS, // Exit recent. 652 SCENE_OTHERS, // 1.Default state 2.The state in which the animation ends 653 }; 654 655 /** 656 * @brief Session UI parameters 657 */ 658 struct SessionUIParam { 659 bool interactive_ { true }; 660 WSRect rect_; 661 float scaleX_ { 1.0f }; 662 float scaleY_ { 1.0f }; 663 float pivotX_ { 1.0f }; 664 float pivotY_ { 1.0f }; 665 float transX_ { 0.0f }; // global translateX 666 float transY_ { 0.0f }; // global translateY 667 uint32_t zOrder_ { 0 }; 668 std::string sessionName_; 669 bool needSync_ { true }; 670 }; 671 672 enum class SessionUIDirtyFlag { 673 NONE = 0, 674 VISIBLE = 1, 675 INTERACTIVE = 1 << 1, 676 RECT = 1 << 2, 677 SCALE = 1 << 3, 678 TOUCH_HOT_AREA = 1 << 4, 679 Z_ORDER = 1 << 5, 680 AVOID_AREA = 1 << 6, 681 GLOBAL_RECT = 1 << 8, 682 }; 683 684 /** 685 * @brief State for post-process focus 686 */ 687 struct PostProcessFocusState { 688 bool enabled_ { false }; 689 bool isFocused_ { false }; 690 FocusChangeReason reason_ { FocusChangeReason::DEFAULT }; 691 ResetPostProcessFocusState692 void Reset() 693 { 694 enabled_ = false; 695 isFocused_ = false; 696 reason_ = FocusChangeReason::DEFAULT; 697 } 698 }; 699 } // namespace OHOS::Rosen 700 #endif // OHOS_ROSEN_WINDOW_SCENE_WS_COMMON_H 701