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_WM_COMMON_H
17 #define OHOS_ROSEN_WM_COMMON_H
18 
19 #include <parcel.h>
20 #include <map>
21 #include <float.h>
22 #include <sstream>
23 #include <string>
24 #include <vector>
25 
26 namespace OHOS {
27 namespace Rosen {
28 using DisplayId = uint64_t;
29 /**
30  * @brief Enumerates type of window.
31  */
32 enum class WindowType : uint32_t {
33     APP_WINDOW_BASE = 1,
34     APP_MAIN_WINDOW_BASE = APP_WINDOW_BASE,
35     WINDOW_TYPE_APP_MAIN_WINDOW = APP_MAIN_WINDOW_BASE,
36     APP_MAIN_WINDOW_END,
37 
38     APP_SUB_WINDOW_BASE = 1000,
39     WINDOW_TYPE_MEDIA = APP_SUB_WINDOW_BASE,
40     WINDOW_TYPE_APP_SUB_WINDOW,
41     WINDOW_TYPE_APP_COMPONENT,
42     APP_SUB_WINDOW_END,
43     APP_WINDOW_END = APP_SUB_WINDOW_END,
44 
45     SYSTEM_WINDOW_BASE = 2000,
46     BELOW_APP_SYSTEM_WINDOW_BASE = SYSTEM_WINDOW_BASE,
47     WINDOW_TYPE_WALLPAPER = SYSTEM_WINDOW_BASE,
48     WINDOW_TYPE_DESKTOP,
49     BELOW_APP_SYSTEM_WINDOW_END,
50 
51     ABOVE_APP_SYSTEM_WINDOW_BASE = 2100,
52     WINDOW_TYPE_APP_LAUNCHING = ABOVE_APP_SYSTEM_WINDOW_BASE,
53     WINDOW_TYPE_DOCK_SLICE,
54     WINDOW_TYPE_INCOMING_CALL,
55     WINDOW_TYPE_SEARCHING_BAR,
56     WINDOW_TYPE_SYSTEM_ALARM_WINDOW,
57     WINDOW_TYPE_INPUT_METHOD_FLOAT,
58     WINDOW_TYPE_FLOAT,
59     WINDOW_TYPE_TOAST,
60     WINDOW_TYPE_STATUS_BAR,
61     WINDOW_TYPE_PANEL,
62     WINDOW_TYPE_KEYGUARD,
63     WINDOW_TYPE_VOLUME_OVERLAY,
64     WINDOW_TYPE_NAVIGATION_BAR,
65     WINDOW_TYPE_DRAGGING_EFFECT,
66     WINDOW_TYPE_POINTER,
67     WINDOW_TYPE_LAUNCHER_RECENT,
68     WINDOW_TYPE_LAUNCHER_DOCK,
69     WINDOW_TYPE_BOOT_ANIMATION,
70     WINDOW_TYPE_FREEZE_DISPLAY,
71     WINDOW_TYPE_VOICE_INTERACTION,
72     WINDOW_TYPE_FLOAT_CAMERA,
73     WINDOW_TYPE_PLACEHOLDER,
74     WINDOW_TYPE_DIALOG,
75     WINDOW_TYPE_SCREENSHOT,
76     WINDOW_TYPE_INPUT_METHOD_STATUS_BAR,
77     WINDOW_TYPE_GLOBAL_SEARCH,
78     WINDOW_TYPE_NEGATIVE_SCREEN,
79     WINDOW_TYPE_SYSTEM_TOAST,
80     WINDOW_TYPE_SYSTEM_FLOAT,
81     WINDOW_TYPE_PIP,
82     WINDOW_TYPE_THEME_EDITOR,
83     WINDOW_TYPE_NAVIGATION_INDICATOR,
84     WINDOW_TYPE_HANDWRITE,
85     WINDOW_TYPE_SCENE_BOARD,
86     WINDOW_TYPE_KEYBOARD_PANEL,
87     WINDOW_TYPE_SCB_DEFAULT,
88     WINDOW_TYPE_TRANSPARENT_VIEW,
89     ABOVE_APP_SYSTEM_WINDOW_END,
90 
91     SYSTEM_SUB_WINDOW_BASE = 2500,
92     WINDOW_TYPE_SYSTEM_SUB_WINDOW = SYSTEM_SUB_WINDOW_BASE,
93     SYSTEM_SUB_WINDOW_END,
94 
95     SYSTEM_WINDOW_END = SYSTEM_SUB_WINDOW_END,
96 
97     WINDOW_TYPE_UI_EXTENSION = 3000
98 };
99 
100 /**
101  * @struct HookInfo.
102  *
103  * @brief hook diaplayinfo deepending on the window size.
104  */
105 struct HookInfo {
106     uint32_t width_;
107     uint32_t height_;
108     float_t density_;
109     uint32_t rotation_;
110     bool enableHookRotation_;
111 };
112 
113 /**
114  * @brief Enumerates mode of window.
115  */
116 enum class WindowMode : uint32_t {
117     WINDOW_MODE_UNDEFINED = 0,
118     WINDOW_MODE_FULLSCREEN = 1,
119     WINDOW_MODE_SPLIT_PRIMARY = 100,
120     WINDOW_MODE_SPLIT_SECONDARY,
121     WINDOW_MODE_FLOATING,
122     WINDOW_MODE_PIP
123 };
124 
125 /**
126  * @brief Enumerates modeType of window.
127  */
128 enum class WindowModeType : uint8_t {
129     WINDOW_MODE_SPLIT_FLOATING = 0,
130     WINDOW_MODE_SPLIT = 1,
131     WINDOW_MODE_FLOATING = 2,
132     WINDOW_MODE_FULLSCREEN = 3,
133     WINDOW_MODE_FULLSCREEN_FLOATING = 4,
134     WINDOW_MODE_OTHER = 5
135 };
136 
137 /**
138  * @brief Enumerates modal of sub session.
139  */
140 enum class SubWindowModalType : uint32_t {
141     TYPE_UNDEFINED = 0,
142     TYPE_NORMAL,
143     TYPE_DIALOG,
144     TYPE_WINDOW_MODALITY,
145     TYPE_TOAST,
146     TYPE_APPLICATION_MODALITY,
147 };
148 
149 /**
150  * @brief Enumerates mode supported of window.
151  */
152 enum WindowModeSupport : uint32_t {
153     WINDOW_MODE_SUPPORT_FULLSCREEN = 1 << 0,
154     WINDOW_MODE_SUPPORT_FLOATING = 1 << 1,
155     WINDOW_MODE_SUPPORT_SPLIT_PRIMARY = 1 << 2,
156     WINDOW_MODE_SUPPORT_SPLIT_SECONDARY = 1 << 3,
157     WINDOW_MODE_SUPPORT_PIP = 1 << 4,
158     WINDOW_MODE_SUPPORT_ALL = WINDOW_MODE_SUPPORT_FULLSCREEN |
159                               WINDOW_MODE_SUPPORT_SPLIT_PRIMARY |
160                               WINDOW_MODE_SUPPORT_SPLIT_SECONDARY |
161                               WINDOW_MODE_SUPPORT_FLOATING |
162                               WINDOW_MODE_SUPPORT_PIP
163 };
164 
165 /**
166  * @brief Enumerates blur style of window.
167  */
168 enum class WindowBlurStyle : uint32_t {
169     WINDOW_BLUR_OFF = 0,
170     WINDOW_BLUR_THIN,
171     WINDOW_BLUR_REGULAR,
172     WINDOW_BLUR_THICK
173 };
174 
175 /**
176  * @brief Enumerates state of window.
177  */
178 enum class WindowState : uint32_t {
179     STATE_INITIAL,
180     STATE_CREATED,
181     STATE_SHOWN,
182     STATE_HIDDEN,
183     STATE_FROZEN,
184     STATE_UNFROZEN,
185     STATE_DESTROYED,
186     STATE_BOTTOM = STATE_DESTROYED, // Add state type after STATE_DESTROYED is not allowed
187 };
188 
189 /**
190  * @brief Enumerates error code of window.
191  */
192 enum class WMError : int32_t {
193     WM_OK = 0,
194     WM_DO_NOTHING,
195     WM_ERROR_NO_MEM,
196     WM_ERROR_DESTROYED_OBJECT,
197     WM_ERROR_INVALID_WINDOW,
198     WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE,
199     WM_ERROR_INVALID_OPERATION,
200     WM_ERROR_INVALID_PERMISSION,
201     WM_ERROR_NOT_SYSTEM_APP,
202     WM_ERROR_NO_REMOTE_ANIMATION,
203     WM_ERROR_INVALID_DISPLAY,
204     WM_ERROR_INVALID_PARENT,
205     WM_ERROR_OPER_FULLSCREEN_FAILED,
206     WM_ERROR_REPEAT_OPERATION,
207     WM_ERROR_INVALID_SESSION,
208     WM_ERROR_INVALID_CALLING,
209     WM_ERROR_SYSTEM_ABNORMALLY,
210 
211     WM_ERROR_DEVICE_NOT_SUPPORT = 801, // the value do not change.It is defined on all system
212 
213     WM_ERROR_NEED_REPORT_BASE = 1000, // error code > 1000 means need report
214     WM_ERROR_NULLPTR,
215     WM_ERROR_INVALID_TYPE,
216     WM_ERROR_INVALID_PARAM,
217     WM_ERROR_SAMGR,
218     WM_ERROR_IPC_FAILED,
219     WM_ERROR_NEED_REPORT_END,
220     WM_ERROR_START_ABILITY_FAILED,
221     WM_ERROR_PIP_DESTROY_FAILED,
222     WM_ERROR_PIP_STATE_ABNORMALLY,
223     WM_ERROR_PIP_CREATE_FAILED,
224     WM_ERROR_PIP_INTERNAL_ERROR,
225     WM_ERROR_PIP_REPEAT_OPERATION,
226 };
227 
228 /**
229  * @brief Enumerates error code of window only used for js api.
230  */
231 enum class WmErrorCode : int32_t {
232     WM_OK = 0,
233     WM_ERROR_NO_PERMISSION = 201,
234     WM_ERROR_NOT_SYSTEM_APP = 202,
235     WM_ERROR_INVALID_PARAM = 401,
236     WM_ERROR_DEVICE_NOT_SUPPORT = 801,
237     WM_ERROR_REPEAT_OPERATION = 1300001,
238     WM_ERROR_STATE_ABNORMALLY = 1300002,
239     WM_ERROR_SYSTEM_ABNORMALLY = 1300003,
240     WM_ERROR_INVALID_CALLING = 1300004,
241     WM_ERROR_STAGE_ABNORMALLY = 1300005,
242     WM_ERROR_CONTEXT_ABNORMALLY = 1300006,
243     WM_ERROR_START_ABILITY_FAILED = 1300007,
244     WM_ERROR_INVALID_DISPLAY = 1300008,
245     WM_ERROR_INVALID_PARENT = 1300009,
246     WM_ERROR_OPER_FULLSCREEN_FAILED = 1300010,
247     WM_ERROR_PIP_DESTROY_FAILED = 1300011,
248     WM_ERROR_PIP_STATE_ABNORMALLY = 1300012,
249     WM_ERROR_PIP_CREATE_FAILED = 1300013,
250     WM_ERROR_PIP_INTERNAL_ERROR = 1300014,
251     WM_ERROR_PIP_REPEAT_OPERATION = 1300015,
252 };
253 
254 /**
255  * @brief Enumerates status of window.
256  */
257 enum class WindowStatus : uint32_t {
258     WINDOW_STATUS_UNDEFINED = 0,
259     WINDOW_STATUS_FULLSCREEN = 1,
260     WINDOW_STATUS_MAXIMIZE,
261     WINDOW_STATUS_MINIMIZE,
262     WINDOW_STATUS_FLOATING,
263     WINDOW_STATUS_SPLITSCREEN
264 };
265 
266 /**
267  * @brief Enumerates setting flag of systemStatusBar
268  */
269 enum class SystemBarSettingFlag : uint32_t {
270     DEFAULT_SETTING = 0,
271     COLOR_SETTING = 1,
272     ENABLE_SETTING = 1 << 1,
273     ALL_SETTING = COLOR_SETTING | ENABLE_SETTING,
274     FOLLOW_SETTING = 1 << 2
275 };
276 
operator |(SystemBarSettingFlag lhs, SystemBarSettingFlag rhs)277 inline SystemBarSettingFlag operator|(SystemBarSettingFlag lhs, SystemBarSettingFlag rhs)
278 {
279     using T = std::underlying_type_t<SystemBarSettingFlag>;
280     return static_cast<SystemBarSettingFlag>(static_cast<T>(lhs) | static_cast<T>(rhs));
281 }
282 
283 /**
284  * @brief Enumerates flag of multiWindowUIType.
285  */
286 enum class WindowUIType : uint8_t {
287     PHONE_WINDOW = 0,
288     PC_WINDOW,
289     PAD_WINDOW,
290     INVALID_WINDOW
291 };
292 
293 /**
294  * @brief Used to map from WMError to WmErrorCode.
295  */
296 extern const std::map<WMError, WmErrorCode> WM_JS_TO_ERROR_CODE_MAP;
297 
298 /**
299  * @brief Enumerates flag of window.
300  */
301 enum class WindowFlag : uint32_t {
302     WINDOW_FLAG_NEED_AVOID = 1,
303     WINDOW_FLAG_PARENT_LIMIT = 1 << 1,
304     WINDOW_FLAG_SHOW_WHEN_LOCKED = 1 << 2,
305     WINDOW_FLAG_FORBID_SPLIT_MOVE = 1 << 3,
306     WINDOW_FLAG_WATER_MARK = 1 << 4,
307     WINDOW_FLAG_IS_MODAL = 1 << 5,
308     WINDOW_FLAG_IS_APPLICATION_MODAL = 1 << 6,
309     WINDOW_FLAG_HANDWRITING = 1 << 7,
310     WINDOW_FLAG_IS_TOAST = 1 << 8,
311     WINDOW_FLAG_END = 1 << 9,
312 };
313 
314 /**
315  * @brief Flag of uiextension window.
316  */
317 union ExtensionWindowFlags {
318     uint32_t bitData;
319     struct {
320         // Each flag should be false default, true when active
321         bool hideNonSecureWindowsFlag : 1;
322         bool waterMarkFlag : 1;
323         bool privacyModeFlag : 1;
324     };
ExtensionWindowFlags()325     ExtensionWindowFlags() : bitData(0) {}
ExtensionWindowFlags(uint32_t bits)326     ExtensionWindowFlags(uint32_t bits) : bitData(bits) {}
~ExtensionWindowFlags()327     ~ExtensionWindowFlags() {}
SetAllActive()328     void SetAllActive()
329     {
330         hideNonSecureWindowsFlag = true;
331         waterMarkFlag = true;
332         privacyModeFlag = true;
333     }
334 };
335 
336 /**
337  * @brief Enumerates window size change reason.
338  */
339 enum class WindowSizeChangeReason : uint32_t {
340     UNDEFINED = 0,
341     MAXIMIZE,
342     RECOVER,
343     ROTATION,
344     DRAG,
345     DRAG_START,
346     DRAG_END,
347     RESIZE,
348     MOVE,
349     HIDE,
350     TRANSFORM,
351     CUSTOM_ANIMATION_SHOW,
352     FULL_TO_SPLIT,
353     SPLIT_TO_FULL,
354     FULL_TO_FLOATING,
355     FLOATING_TO_FULL,
356     PIP_START,
357     PIP_SHOW,
358     PIP_AUTO_START,
359     PIP_RATIO_CHANGE,
360     PIP_RESTORE,
361     UPDATE_DPI_SYNC,
362     END,
363 };
364 
365 /**
366  * @brief Enumerates layout mode of window.
367  */
368 enum class WindowLayoutMode : uint32_t {
369     BASE = 0,
370     CASCADE = BASE,
371     TILE = 1,
372     END,
373 };
374 
375 /**
376  * @brief Enumerates drag event.
377  */
378 enum class DragEvent : uint32_t {
379     DRAG_EVENT_IN  = 1,
380     DRAG_EVENT_OUT,
381     DRAG_EVENT_MOVE,
382     DRAG_EVENT_END,
383 };
384 
385 /**
386  * @brief Enumerates window tag.
387  */
388 enum class WindowTag : uint32_t {
389     MAIN_WINDOW = 0,
390     SUB_WINDOW = 1,
391     SYSTEM_WINDOW = 2,
392 };
393 
394 /**
395  * @brief Enumerates window session type.
396  */
397 enum class WindowSessionType : uint32_t {
398     SCENE_SESSION = 0,
399     EXTENSION_SESSION = 1,
400 };
401 
402 /**
403  * @brief Enumerates window gravity.
404  */
405 enum class WindowGravity : uint32_t {
406     WINDOW_GRAVITY_FLOAT = 0,
407     WINDOW_GRAVITY_BOTTOM,
408     WINDOW_GRAVITY_DEFAULT,
409 };
410 
411 /**
412  * @brief Enumerates window setuicontent type.
413  */
414 enum class WindowSetUIContentType : uint32_t {
415     DEFAULT,
416     RESTORE,
417     BY_NAME,
418     BY_ABC,
419 };
420 
421 /**
422  * @brief Enumerates restore type.
423  */
424 enum class BackupAndRestoreType : int32_t {
425     NONE = 0,                       // no backup and restore
426     CONTINUATION = 1,               // distribute
427     APP_RECOVERY = 2,               // app recovery
428     RESOURCESCHEDULE_RECOVERY = 3,  // app is killed due to resource schedule
429 };
430 
431 /**
432  * @brief Enumerates window Style type.
433  */
434 enum class WindowStyleType : uint8_t {
435     WINDOW_STYLE_DEFAULT = 0,
436     WINDOW_STYLE_FREE_MULTI_WINDOW = 1,
437 };
438 
439 /**
440  * @brief Disable Gesture Back Type
441  */
442 enum class GestureBackType : uint8_t {
443     GESTURE_SIDE = 0,
444     GESTURE_SWIPE_UP = 1,
445     GESTURE_ALL = 2,
446 };
447 
448 /**
449  * @struct PointInfo.
450  *
451  * @brief point Info.
452  */
453 struct PointInfo {
454     int32_t x;
455     int32_t y;
456 };
457 
458 /**
459  * @struct MainWindowInfo.
460  *
461  * @brief topN main window info.
462  */
463 struct MainWindowInfo : public Parcelable {
464     virtual bool Marshalling(Parcel& parcel) const override
465     {
466         if (!parcel.WriteInt32(pid_)) {
467             return false;
468         }
469 
470         if (!parcel.WriteString(bundleName_)) {
471             return false;
472         }
473 
474         if (!parcel.WriteInt32(persistentId_)) {
475             return false;
476         }
477 
478         if (!parcel.WriteInt32(bundleType_)) {
479             return false;
480         }
481         return true;
482     }
483 
UnmarshallingOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::MainWindowInfo484     static MainWindowInfo* Unmarshalling(Parcel& parcel)
485     {
486         MainWindowInfo* mainWindowInfo = new MainWindowInfo;
487         mainWindowInfo->pid_ = parcel.ReadInt32();
488         mainWindowInfo->bundleName_ = parcel.ReadString();
489         mainWindowInfo->persistentId_ = parcel.ReadInt32();
490         mainWindowInfo->bundleType_ = parcel.ReadInt32();
491         return mainWindowInfo;
492     }
493 
494     int32_t pid_ = 0;
495     std::string bundleName_ = "";
496     int32_t persistentId_ = 0;
497     int32_t bundleType_ = 0;
498 };
499 
500 /**
501  * @struct MainWindowState.
502  *
503  * @brief main window state info.
504  */
505 struct MainWindowState : public Parcelable {
506     bool Marshalling(Parcel& parcel) const override
507     {
508         if (!parcel.WriteInt32(state_)) {
509             return false;
510         }
511         if (!parcel.WriteBool(isVisible_)) {
512             return false;
513         }
514         if (!parcel.WriteBool(isForegroundInteractive_)) {
515             return false;
516         }
517         if (!parcel.WriteBool(isPcOrPadEnableActivation_)) {
518             return false;
519         }
520         return true;
521     }
522 
UnmarshallingOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::MainWindowState523     static MainWindowState* Unmarshalling(Parcel& parcel)
524     {
525         MainWindowState* mainWindowState = new MainWindowState();
526         if (!mainWindowState) {
527             return nullptr;
528         }
529         if (!parcel.ReadInt32(mainWindowState->state_) ||
530             !parcel.ReadBool(mainWindowState->isVisible_) ||
531             !parcel.ReadBool(mainWindowState->isForegroundInteractive_) ||
532             !parcel.ReadBool(mainWindowState->isPcOrPadEnableActivation_)) {
533             delete mainWindowState;
534             return nullptr;
535         }
536         return mainWindowState;
537     }
538 
539     int32_t state_ = 0;
540     bool isVisible_ = false;
541     bool isForegroundInteractive_ = false;
542     bool isPcOrPadEnableActivation_ = false;
543 };
544 
545 namespace {
546     constexpr uint32_t SYSTEM_COLOR_WHITE = 0xE5FFFFFF;
547     constexpr uint32_t SYSTEM_COLOR_BLACK = 0x66000000;
548     constexpr uint32_t INVALID_WINDOW_ID = 0;
549     constexpr float UNDEFINED_BRIGHTNESS = -1.0f;
550     constexpr float MINIMUM_BRIGHTNESS = 0.0f;
551     constexpr float MAXIMUM_BRIGHTNESS = 1.0f;
552     constexpr int32_t INVALID_PID = -1;
553     constexpr int32_t INVALID_UID = -1;
554     constexpr int32_t INVALID_USER_ID = -1;
555     constexpr int32_t SYSTEM_USERID = 0;
556     constexpr int32_t BASE_USER_RANGE = 200000;
557     constexpr int32_t DEFAULT_SCREEN_ID = 0;
558     constexpr int32_t FULL_CIRCLE_DEGREE = 360;
559     constexpr int32_t ONE_FOURTH_FULL_CIRCLE_DEGREE = 90;
560 }
561 
GetUserIdByUid(int32_t uid)562 inline int32_t GetUserIdByUid(int32_t uid)
563 {
564     return uid / BASE_USER_RANGE;
565 }
566 
567 /**
568  * @class Transform
569  *
570  * @brief parameter of transform and rotate.
571  */
572 class Transform {
573 public:
Transform()574     Transform()
575         : pivotX_(0.5f), pivotY_(0.5f), scaleX_(1.f), scaleY_(1.f), scaleZ_(1.f), rotationX_(0.f),
576           rotationY_(0.f), rotationZ_(0.f), translateX_(0.f), translateY_(0.f), translateZ_(0.f)
577     {}
~Transform()578     ~Transform() {}
579 
operator ==(const Transform& right) const580     bool operator==(const Transform& right) const
581     {
582         return NearZero(pivotX_ - right.pivotX_) &&
583             NearZero(pivotY_ - right.pivotY_) &&
584             NearZero(scaleX_ - right.scaleX_) &&
585             NearZero(scaleY_ - right.scaleY_) &&
586             NearZero(scaleZ_ - right.scaleZ_) &&
587             NearZero(rotationX_ - right.rotationX_) &&
588             NearZero(rotationY_ - right.rotationY_) &&
589             NearZero(rotationZ_ - right.rotationZ_) &&
590             NearZero(translateX_ - right.translateX_) &&
591             NearZero(translateY_ - right.translateY_) &&
592             NearZero(translateZ_ - right.translateZ_);
593     }
594 
operator !=(const Transform& right) const595     bool operator!=(const Transform& right) const
596     {
597         return !(*this == right);
598     }
599 
600     float pivotX_;
601     float pivotY_;
602     float scaleX_;
603     float scaleY_;
604     float scaleZ_;
605     float rotationX_;
606     float rotationY_;
607     float rotationZ_;
608     float translateX_;
609     float translateY_;
610     float translateZ_;
611 
Identity()612     static const Transform& Identity()
613     {
614         static Transform I;
615         return I;
616     }
617 
Marshalling(Parcel& parcel) const618     bool Marshalling(Parcel& parcel) const
619     {
620         return parcel.WriteFloat(pivotX_) && parcel.WriteFloat(pivotY_) &&
621                parcel.WriteFloat(scaleX_) && parcel.WriteFloat(scaleY_) && parcel.WriteFloat(scaleZ_) &&
622                parcel.WriteFloat(rotationX_) && parcel.WriteFloat(rotationY_) && parcel.WriteFloat(rotationZ_) &&
623                parcel.WriteFloat(translateX_) && parcel.WriteFloat(translateY_) && parcel.WriteFloat(translateZ_);
624     }
625 
Unmarshalling(Parcel& parcel)626     void Unmarshalling(Parcel& parcel)
627     {
628         pivotX_ = parcel.ReadFloat();
629         pivotY_ = parcel.ReadFloat();
630         scaleX_ = parcel.ReadFloat();
631         scaleY_ = parcel.ReadFloat();
632         scaleZ_ = parcel.ReadFloat();
633         rotationX_ = parcel.ReadFloat();
634         rotationY_ = parcel.ReadFloat();
635         rotationZ_ = parcel.ReadFloat();
636         translateX_ = parcel.ReadFloat();
637         translateY_ = parcel.ReadFloat();
638         translateZ_ = parcel.ReadFloat();
639     }
640 private:
NearZero(float val)641     static inline bool NearZero(float val)
642     {
643         return val < 0.001f && val > -0.001f;
644     }
645 };
646 
647 /**
648  * @struct SystemBarProperty
649  *
650  * @brief Property of system bar
651  */
652 struct SystemBarProperty {
653     bool enable_;
654     uint32_t backgroundColor_;
655     uint32_t contentColor_;
656     bool enableAnimation_;
657     SystemBarSettingFlag settingFlag_;
SystemBarPropertyOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::SystemBarProperty658     SystemBarProperty() : enable_(true), backgroundColor_(SYSTEM_COLOR_BLACK), contentColor_(SYSTEM_COLOR_WHITE),
659                           enableAnimation_(false), settingFlag_(SystemBarSettingFlag::DEFAULT_SETTING) {}
SystemBarPropertyOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::SystemBarProperty660     SystemBarProperty(bool enable, uint32_t background, uint32_t content)
661         : enable_(enable), backgroundColor_(background), contentColor_(content), enableAnimation_(false),
662           settingFlag_(SystemBarSettingFlag::DEFAULT_SETTING) {}
SystemBarPropertyOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::SystemBarProperty663     SystemBarProperty(bool enable, uint32_t background, uint32_t content, bool enableAnimation)
664         : enable_(enable), backgroundColor_(background), contentColor_(content), enableAnimation_(enableAnimation),
665           settingFlag_(SystemBarSettingFlag::DEFAULT_SETTING) {}
SystemBarPropertyOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::SystemBarProperty666     SystemBarProperty(bool enable, uint32_t background, uint32_t content,
667                       bool enableAnimation, SystemBarSettingFlag settingFlag)
668         : enable_(enable), backgroundColor_(background), contentColor_(content), enableAnimation_(enableAnimation),
669           settingFlag_(settingFlag) {}
operator ==OHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::SystemBarProperty670     bool operator == (const SystemBarProperty& a) const
671     {
672         return (enable_ == a.enable_ && backgroundColor_ == a.backgroundColor_ && contentColor_ == a.contentColor_ &&
673             enableAnimation_ == a.enableAnimation_);
674     }
675 };
676 
677 /**
678  * @struct SystemBarPropertyFlag
679  *
680  * @brief Flag of system bar
681  */
682 struct SystemBarPropertyFlag {
683     bool enableFlag = false;
684     bool backgroundColorFlag = false;
685     bool contentColorFlag = false;
686     bool enableAnimationFlag = false;
687 };
688 
689 /**
690  * @struct Rect
691  *
692  * @brief Window Rect
693  */
694 struct Rect {
695     int32_t posX_;
696     int32_t posY_;
697     uint32_t width_;
698     uint32_t height_;
699 
operator ==OHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::Rect700     bool operator==(const Rect& a) const
701     {
702         return (posX_ == a.posX_ && posY_ == a.posY_ && width_ == a.width_ && height_ == a.height_);
703     }
704 
operator !=OHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::Rect705     bool operator!=(const Rect& a) const
706     {
707         return !this->operator==(a);
708     }
709 
IsUninitializedRectOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::Rect710     bool IsUninitializedRect() const
711     {
712         return (posX_ == 0 && posY_ == 0 && width_ == 0 && height_ == 0);
713     }
714 
IsInsideOfOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::Rect715     bool IsInsideOf(const Rect& a) const
716     {
717         return (posX_ >= a.posX_ && posY_ >= a.posY_ &&
718             posX_ + width_ <= a.posX_ + a.width_ && posY_ + height_ <= a.posY_ + a.height_);
719     }
720 
ToStringOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::Rect721     inline std::string ToString() const
722     {
723         std::stringstream ss;
724         ss << "[" << posX_ << " " << posY_ << " " << width_ << " " << height_ << "]";
725         return ss.str();
726     }
727 };
728 
729 /**
730  * @brief UIExtension usage
731  */
732 enum class UIExtensionUsage : uint32_t {
733     MODAL = 0,
734     EMBEDDED,
735     CONSTRAINED_EMBEDDED,
736     UIEXTENSION_USAGE_END
737 };
738 
739 /**
740  * @brief UIExtension info for event
741  */
742 struct ExtensionWindowEventInfo {
743     int32_t persistentId  = 0;
744     int32_t pid = -1;
745     Rect windowRect {0, 0, 0, 0};
746 };
747 
748 /**
749  * @brief UIExtension info from ability
750  */
751 struct ExtensionWindowAbilityInfo {
752     int32_t persistentId  { 0 };
753     int32_t parentId { 0 };
754     UIExtensionUsage usage { UIExtensionUsage::UIEXTENSION_USAGE_END };
755 };
756 
757 /**
758  * @struct KeyboardPanelInfo
759  *
760  * @brief Info of keyboard panel
761  */
762 struct KeyboardPanelInfo : public Parcelable {
763     Rect rect_ = {0, 0, 0, 0};
764     WindowGravity gravity_ = WindowGravity::WINDOW_GRAVITY_BOTTOM;
765     bool isShowing_ = false;
766 
MarshallingOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::KeyboardPanelInfo767     bool Marshalling(Parcel& parcel) const
768     {
769         return parcel.WriteInt32(rect_.posX_) && parcel.WriteInt32(rect_.posY_) &&
770                parcel.WriteUint32(rect_.width_) && parcel.WriteUint32(rect_.height_) &&
771                parcel.WriteUint32(static_cast<uint32_t>(gravity_)) &&
772                parcel.WriteBool(isShowing_);
773     }
774 
UnmarshallingOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::KeyboardPanelInfo775     static KeyboardPanelInfo* Unmarshalling(Parcel& parcel)
776     {
777         KeyboardPanelInfo* keyboardPanelInfo = new(std::nothrow)KeyboardPanelInfo;
778         if (keyboardPanelInfo == nullptr) {
779             return nullptr;
780         }
781         bool res = parcel.ReadInt32(keyboardPanelInfo->rect_.posX_) &&
782             parcel.ReadInt32(keyboardPanelInfo->rect_.posY_) && parcel.ReadUint32(keyboardPanelInfo->rect_.width_) &&
783             parcel.ReadUint32(keyboardPanelInfo->rect_.height_);
784         if (!res) {
785             delete keyboardPanelInfo;
786             return nullptr;
787         }
788         keyboardPanelInfo->gravity_ = static_cast<WindowGravity>(parcel.ReadUint32());
789         keyboardPanelInfo->isShowing_ = parcel.ReadBool();
790 
791         return keyboardPanelInfo;
792     }
793 };
794 
795 /**
796  * @brief Enumerates avoid area type.
797  */
798 enum class AvoidAreaType : uint32_t {
799     TYPE_SYSTEM,           // area of SystemUI
800     TYPE_CUTOUT,           // cutout of screen
801     TYPE_SYSTEM_GESTURE,   // area for system gesture
802     TYPE_KEYBOARD,         // area for soft input keyboard
803     TYPE_NAVIGATION_INDICATOR, // area for navigation indicator
804 };
805 
806 /**
807  * @brief Enumerates occupied area type.
808  */
809 enum class OccupiedAreaType : uint32_t {
810     TYPE_INPUT, // area of input window
811 };
812 
813 /**
814  * @brief Enumerates color space.
815  */
816 enum class ColorSpace : uint32_t {
817     COLOR_SPACE_DEFAULT = 0, // Default color space.
818     COLOR_SPACE_WIDE_GAMUT,  // Wide gamut color space. The specific wide color gamut depends on the screen.
819 };
820 
821 /**
822  * @brief Enumerates window animation.
823  */
824 enum class WindowAnimation : uint32_t {
825     NONE,
826     DEFAULT,
827     INPUTE,
828     CUSTOM,
829 };
830 
831 /**
832  * @brief Enumerates window maximize mode.
833  */
834 enum class MaximizeMode : uint32_t {
835     MODE_AVOID_SYSTEM_BAR,
836     MODE_FULL_FILL,
837     MODE_RECOVER,
838     MODE_END,
839 };
840 
841 /**
842  * @class AvoidArea
843  *
844  * @brief Area needed to avoid.
845  */
846 class AvoidArea : public Parcelable {
847 public:
848     Rect topRect_ { 0, 0, 0, 0 };
849     Rect leftRect_ { 0, 0, 0, 0 };
850     Rect rightRect_ { 0, 0, 0, 0 };
851     Rect bottomRect_ { 0, 0, 0, 0 };
852 
operator ==(const AvoidArea& a) const853     bool operator==(const AvoidArea& a) const
854     {
855         return (leftRect_ == a.leftRect_ && topRect_ == a.topRect_ &&
856             rightRect_ == a.rightRect_ && bottomRect_ == a.bottomRect_);
857     }
858 
operator !=(const AvoidArea& a) const859     bool operator!=(const AvoidArea& a) const
860     {
861         return !this->operator==(a);
862     }
863 
isEmptyAvoidArea() const864     bool isEmptyAvoidArea() const
865     {
866         return topRect_.IsUninitializedRect() && leftRect_.IsUninitializedRect() &&
867             rightRect_.IsUninitializedRect() && bottomRect_.IsUninitializedRect();
868     }
869 
WriteParcel(Parcel& parcel, const Rect& rect)870     static inline bool WriteParcel(Parcel& parcel, const Rect& rect)
871     {
872         return parcel.WriteInt32(rect.posX_) && parcel.WriteInt32(rect.posY_) &&
873             parcel.WriteUint32(rect.width_) && parcel.WriteUint32(rect.height_);
874     }
875 
ReadParcel(Parcel& parcel, Rect& rect)876     static inline bool ReadParcel(Parcel& parcel, Rect& rect)
877     {
878         return parcel.ReadInt32(rect.posX_) && parcel.ReadInt32(rect.posY_) &&
879             parcel.ReadUint32(rect.width_) && parcel.ReadUint32(rect.height_);
880     }
881 
882     virtual bool Marshalling(Parcel& parcel) const override
883     {
884         return (WriteParcel(parcel, leftRect_) && WriteParcel(parcel, topRect_) &&
885             WriteParcel(parcel, rightRect_) && WriteParcel(parcel, bottomRect_));
886     }
887 
Unmarshalling(Parcel& parcel)888     static AvoidArea* Unmarshalling(Parcel& parcel)
889     {
890         AvoidArea *avoidArea = new(std::nothrow) AvoidArea();
891         if (avoidArea == nullptr) {
892             return nullptr;
893         }
894         if (ReadParcel(parcel, avoidArea->leftRect_) && ReadParcel(parcel, avoidArea->topRect_) &&
895             ReadParcel(parcel, avoidArea->rightRect_) && ReadParcel(parcel, avoidArea->bottomRect_)) {
896             return avoidArea;
897         }
898         delete avoidArea;
899         return nullptr;
900     }
901 
ToString() const902     std::string ToString() const
903     {
904         std::stringstream ss;
905         if (isEmptyAvoidArea()) {
906             ss << "empty";
907             return ss.str();
908         }
909         if (!topRect_.IsUninitializedRect()) {
910             ss << "top " << topRect_.ToString() << " ";
911         }
912         if (!bottomRect_.IsUninitializedRect()) {
913             ss << "bottom " << bottomRect_.ToString() << " ";
914         }
915         if (!leftRect_.IsUninitializedRect()) {
916             ss << "left " << leftRect_.ToString() << " ";
917         }
918         if (!rightRect_.IsUninitializedRect()) {
919             ss << "right " << rightRect_.ToString() << " ";
920         }
921         return ss.str();
922     }
923 };
924 
925 /**
926  * @brief Enumerates window update type.
927  */
928 enum class WindowUpdateType : int32_t {
929     WINDOW_UPDATE_ADDED = 1,
930     WINDOW_UPDATE_REMOVED,
931     WINDOW_UPDATE_FOCUSED,
932     WINDOW_UPDATE_BOUNDS,
933     WINDOW_UPDATE_ACTIVE,
934     WINDOW_UPDATE_PROPERTY,
935     WINDOW_UPDATE_ALL,
936 };
937 
938 /**
939  * @brief Enumerates picture in picture window state.
940  */
941 enum class PiPWindowState : uint32_t {
942     STATE_UNDEFINED = 0,
943     STATE_STARTING = 1,
944     STATE_STARTED = 2,
945     STATE_STOPPING = 3,
946     STATE_STOPPED = 4,
947     STATE_RESTORING = 5,
948 };
949 
950 /**
951  * @brief Enumerates picture in picture template type.
952  */
953 enum class PiPTemplateType : uint32_t {
954     VIDEO_PLAY = 0,
955     VIDEO_CALL = 1,
956     VIDEO_MEETING = 2,
957     VIDEO_LIVE = 3,
958     END,
959 };
960 
961 /**
962  * @brief Enumerates picture in picture control group.
963  */
964 enum class PiPControlGroup : uint32_t {
965     VIDEO_PLAY_START = 100,
966     VIDEO_PREVIOUS_NEXT = 101,
967     FAST_FORWARD_BACKWARD = 102,
968     VIDEO_PLAY_END,
969 
970     VIDEO_CALL_START = 200,
971     VIDEO_CALL_MICROPHONE_SWITCH = 201,
972     VIDEO_CALL_HANG_UP_BUTTON = 202,
973     VIDEO_CALL_CAMERA_SWITCH = 203,
974     VIDEO_CALL_MUTE_SWITCH = 204,
975     VIDEO_CALL_END,
976 
977     VIDEO_MEETING_START = 300,
978     VIDEO_MEETING_HANG_UP_BUTTON = 301,
979     VIDEO_MEETING_CAMERA_SWITCH = 302,
980     VIDEO_MEETING_MUTE_SWITCH = 303,
981     VIDEO_MEETING_MICROPHONE_SWITCH = 304,
982     VIDEO_MEETING_END,
983 
984     VIDEO_LIVE_START = 400,
985     VIDEO_PLAY_PAUSE = 401,
986     VIDEO_LIVE_MUTE_SWITCH = 402,
987     VIDEO_LIVE_END,
988     END,
989 };
990 
991 /**
992  * @brief Enumerates picture in picture state.
993  */
994 enum class PiPState : int32_t {
995     ABOUT_TO_START = 1,
996     STARTED = 2,
997     ABOUT_TO_STOP = 3,
998     STOPPED = 4,
999     ABOUT_TO_RESTORE = 5,
1000     ERROR = 6,
1001 };
1002 
1003 /**
1004  * @brief Enumerates picture in picture control status.
1005  */
1006 enum class PiPControlStatus : int32_t {
1007     PLAY = 1,
1008     PAUSE = 0,
1009     OPEN = 1,
1010     CLOSE = 0,
1011     ENABLED = -2,
1012     DISABLED = -3,
1013 };
1014 
1015 /**
1016  * @brief Enumerates picture in picture control type.
1017  */
1018 enum class PiPControlType : uint32_t {
1019     VIDEO_PLAY_PAUSE = 0,
1020     VIDEO_PREVIOUS = 1,
1021     VIDEO_NEXT = 2,
1022     FAST_FORWARD = 3,
1023     FAST_BACKWARD = 4,
1024     HANG_UP_BUTTON = 5,
1025     MICROPHONE_SWITCH = 6,
1026     CAMERA_SWITCH = 7,
1027     MUTE_SWITCH = 8,
1028     END,
1029 };
1030 
1031 struct PiPControlStatusInfo {
1032     PiPControlType controlType;
1033     PiPControlStatus status;
1034 };
1035 
1036 struct PiPControlEnableInfo {
1037     PiPControlType controlType;
1038     PiPControlStatus enabled;
1039 };
1040 
1041 struct PiPTemplateInfo {
1042     uint32_t pipTemplateType;
1043     uint32_t priority;
1044     std::vector<uint32_t> controlGroup;
1045     std::vector<PiPControlStatusInfo> pipControlStatusInfoList;
1046     std::vector<PiPControlEnableInfo> pipControlEnableInfoList;
1047 };
1048 
1049 using OnCallback = std::function<void(int64_t, int64_t)>;
1050 
1051 /**
1052  * @struct VsyncCallback
1053  *
1054  * @brief Vsync callback
1055  */
1056 struct VsyncCallback {
1057     OnCallback onCallback;
1058 };
1059 
1060 struct WindowLimits {
1061     uint32_t maxWidth_ = INT32_MAX;
1062     uint32_t maxHeight_ = INT32_MAX;
1063     uint32_t minWidth_ = 1;
1064     uint32_t minHeight_ = 1;
1065     float maxRatio_ = FLT_MAX;
1066     float minRatio_ = 0.0f;
1067     float vpRatio_ = 1.0f;
1068 
WindowLimitsOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::WindowLimits1069     WindowLimits() {}
WindowLimitsOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::WindowLimits1070     WindowLimits(uint32_t maxWidth, uint32_t maxHeight, uint32_t minWidth, uint32_t minHeight, float maxRatio,
1071         float minRatio) : maxWidth_(maxWidth), maxHeight_(maxHeight), minWidth_(minWidth), minHeight_(minHeight),
1072         maxRatio_(maxRatio), minRatio_(minRatio) {}
WindowLimitsOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::WindowLimits1073     WindowLimits(uint32_t maxWidth, uint32_t maxHeight, uint32_t minWidth, uint32_t minHeight, float maxRatio,
1074         float minRatio, float vpRatio) : maxWidth_(maxWidth), maxHeight_(maxHeight), minWidth_(minWidth),
1075         minHeight_(minHeight), maxRatio_(maxRatio), minRatio_(minRatio), vpRatio_(vpRatio) {}
1076 
IsEmptyOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::WindowLimits1077     bool IsEmpty() const
1078     {
1079         return (maxWidth_ == 0 || minWidth_ == 0 || maxHeight_ == 0 || minHeight_ == 0);
1080     }
1081 };
1082 
1083 /**
1084  * @struct TitleButtonRect
1085  *
1086  * @brief An area of title buttons relative to the upper right corner of the window.
1087  */
1088 struct TitleButtonRect {
1089     int32_t posX_;
1090     int32_t posY_;
1091     uint32_t width_;
1092     uint32_t height_;
1093 
operator ==OHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::TitleButtonRect1094     bool operator==(const TitleButtonRect& a) const
1095     {
1096         return (posX_ == a.posX_ && posY_ == a.posY_ && width_ == a.width_ && height_ == a.height_);
1097     }
1098 
operator !=OHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::TitleButtonRect1099     bool operator!=(const TitleButtonRect& a) const
1100     {
1101         return !this->operator==(a);
1102     }
1103 
IsUninitializedRectOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::TitleButtonRect1104     bool IsUninitializedRect() const
1105     {
1106         return (posX_ == 0 && posY_ == 0 && width_ == 0 && height_ == 0);
1107     }
1108 
IsInsideOfOHOS::Rosen::WindowType::WindowModeType::SystemBarSettingFlag::TitleButtonRect1109     bool IsInsideOf(const TitleButtonRect& a) const
1110     {
1111         return (posX_ >= a.posX_ && posY_ >= a.posY_ &&
1112             posX_ + width_ <= a.posX_ + a.width_ && posY_ + height_ <= a.posY_ + a.height_);
1113     }
1114 };
1115 
1116 /*
1117  * Config of keyboard animation
1118  */
1119 class KeyboardAnimationCurve : public Parcelable {
1120 public:
1121     KeyboardAnimationCurve() = default;
KeyboardAnimationCurve(const std::string& curveType, const std::vector<float>& curveParams, uint32_t duration)1122     KeyboardAnimationCurve(const std::string& curveType, const std::vector<float>& curveParams, uint32_t duration)
1123         : curveType_(curveType), duration_(duration)
1124     {
1125         curveParams_.assign(curveParams.begin(), curveParams.end());
1126     }
1127 
1128     virtual bool Marshalling(Parcel& parcel) const override
1129     {
1130         if (!parcel.WriteString(curveType_)) {
1131             return false;
1132         }
1133 
1134         auto paramSize = curveParams_.size();
1135         if (paramSize == 4) { // 4: param size
1136             if (!parcel.WriteUint32(static_cast<uint32_t>(paramSize))) {
1137                 return false;
1138             }
1139             for (auto& param : curveParams_) {
1140                 if (!parcel.WriteFloat(param)) {
1141                     return false;
1142                 }
1143             }
1144         } else {
1145             if (!parcel.WriteUint32(0)) {
1146                 return false;
1147             }
1148         }
1149 
1150         if (!parcel.WriteUint32(duration_)) {
1151             return false;
1152         }
1153         return true;
1154     }
1155 
Unmarshalling(Parcel& parcel)1156     static KeyboardAnimationCurve* Unmarshalling(Parcel& parcel)
1157     {
1158         KeyboardAnimationCurve* config = new KeyboardAnimationCurve;
1159         uint32_t paramSize = 0;
1160         if (!parcel.ReadString(config->curveType_) || !parcel.ReadUint32(paramSize)) {
1161             delete config;
1162             return nullptr;
1163         }
1164 
1165         if (paramSize == 4) { // 4: paramSize
1166             for (uint32_t i = 0; i < paramSize; i++) {
1167                 float param = 0.0f;
1168                 if (!parcel.ReadFloat(param)) {
1169                     delete config;
1170                     return nullptr;
1171                 } else {
1172                     config->curveParams_.push_back(param);
1173                 }
1174             }
1175         }
1176 
1177         if (!parcel.ReadUint32(config->duration_)) {
1178             delete config;
1179             return nullptr;
1180         }
1181         return config;
1182     }
1183 
1184     std::string curveType_ = "";
1185     std::vector<float> curveParams_ = {};
1186     uint32_t duration_ = 0;
1187 };
1188 
1189 struct KeyboardAnimationConfig {
1190     KeyboardAnimationCurve curveIn;
1191     KeyboardAnimationCurve curveOut;
1192 };
1193 
1194 enum class CaseType {
1195     CASE_WINDOW_MANAGER = 0,
1196     CASE_WINDOW,
1197     CASE_STAGE
1198 };
1199 
1200 enum class MaximizePresentation {
1201     FOLLOW_APP_IMMERSIVE_SETTING = 0,  // follow app set imersiveStateEnable
1202     EXIT_IMMERSIVE = 1,       // imersiveStateEnable will be set as false
1203     ENTER_IMMERSIVE = 2,       // imersiveStateEnable will be set as true
1204     // imersiveStateEnable will be set as true, titleHoverShowEnabled and dockHoverShowEnabled will be set as false
1205     ENTER_IMMERSIVE_DISABLE_TITLE_AND_DOCK_HOVER = 3,
1206 };
1207 
1208 enum ForceHideState : uint32_t {
1209     NOT_HIDDEN = 0,
1210     HIDDEN_WHEN_FOCUSED,
1211     HIDDEN_WHEN_UNFOCUSED
1212 };
1213 
1214 enum class ExtensionWindowAttribute : int32_t {
1215     SYSTEM_WINDOW = 0,
1216     SUB_WINDOW = 1,
1217     UNKNOWN = 2
1218 };
1219 
1220 struct SystemWindowOptions {
1221     int32_t windowType = -1;
1222 };
1223 
1224 enum class ModalityType : uint8_t {
1225     WINDOW_MODALITY,
1226     APPLICATION_MODALITY,
1227 };
1228 
1229 struct SubWindowOptions {
1230     std::string title;
1231     bool decorEnabled = false;
1232     bool isModal = false;
1233     bool isTopmost = false;
1234     ModalityType modalityType = ModalityType::WINDOW_MODALITY;
1235 };
1236 
1237 struct ExtensionWindowConfig {
1238     std::string windowName;
1239     ExtensionWindowAttribute windowAttribute = ExtensionWindowAttribute::UNKNOWN;
1240     Rect windowRect;
1241     SubWindowOptions subWindowOptions;
1242     SystemWindowOptions systemWindowOptions;
1243 };
1244 
1245 /**
1246  * @class KeyboardLayoutParams
1247  *
1248  * @brief Keyboard need adjust layout
1249  */
1250 class KeyboardLayoutParams : public Parcelable {
1251 public:
1252     WindowGravity gravity_ = WindowGravity::WINDOW_GRAVITY_BOTTOM;
1253     Rect LandscapeKeyboardRect_ { 0, 0, 0, 0 };
1254     Rect PortraitKeyboardRect_ { 0, 0, 0, 0 };
1255     Rect LandscapePanelRect_ { 0, 0, 0, 0 };
1256     Rect PortraitPanelRect_ { 0, 0, 0, 0 };
1257 
operator ==(const KeyboardLayoutParams& params) const1258     bool operator==(const KeyboardLayoutParams& params) const
1259     {
1260         return (gravity_ == params.gravity_ && LandscapeKeyboardRect_ == params.LandscapeKeyboardRect_ &&
1261             PortraitKeyboardRect_ == params.PortraitKeyboardRect_ &&
1262             LandscapePanelRect_ == params.LandscapePanelRect_ &&
1263             PortraitPanelRect_ == params.PortraitPanelRect_);
1264     }
1265 
operator !=(const KeyboardLayoutParams& params) const1266     bool operator!=(const KeyboardLayoutParams& params) const
1267     {
1268         return !this->operator==(params);
1269     }
1270 
isEmpty() const1271     bool isEmpty() const
1272     {
1273         return LandscapeKeyboardRect_.IsUninitializedRect() && PortraitKeyboardRect_.IsUninitializedRect() &&
1274             LandscapePanelRect_.IsUninitializedRect() && PortraitPanelRect_.IsUninitializedRect();
1275     }
1276 
WriteParcel(Parcel& parcel, const Rect& rect)1277     static inline bool WriteParcel(Parcel& parcel, const Rect& rect)
1278     {
1279         return parcel.WriteInt32(rect.posX_) && parcel.WriteInt32(rect.posY_) &&
1280             parcel.WriteUint32(rect.width_) && parcel.WriteUint32(rect.height_);
1281     }
1282 
ReadParcel(Parcel& parcel, Rect& rect)1283     static inline bool ReadParcel(Parcel& parcel, Rect& rect)
1284     {
1285         return parcel.ReadInt32(rect.posX_) && parcel.ReadInt32(rect.posY_) &&
1286             parcel.ReadUint32(rect.width_) && parcel.ReadUint32(rect.height_);
1287     }
1288 
1289     virtual bool Marshalling(Parcel& parcel) const override
1290     {
1291         return (parcel.WriteUint32(static_cast<uint32_t>(gravity_)) &&
1292             WriteParcel(parcel, LandscapeKeyboardRect_) &&
1293             WriteParcel(parcel, PortraitKeyboardRect_) &&
1294             WriteParcel(parcel, LandscapePanelRect_) &&
1295             WriteParcel(parcel, PortraitPanelRect_));
1296     }
1297 
Unmarshalling(Parcel& parcel)1298     static KeyboardLayoutParams* Unmarshalling(Parcel& parcel)
1299     {
1300         KeyboardLayoutParams *params = new(std::nothrow) KeyboardLayoutParams();
1301         if (params == nullptr) {
1302             return nullptr;
1303         }
1304         params->gravity_ = static_cast<WindowGravity>(parcel.ReadUint32());
1305         if (ReadParcel(parcel, params->LandscapeKeyboardRect_) &&
1306             ReadParcel(parcel, params->PortraitKeyboardRect_) &&
1307             ReadParcel(parcel, params->LandscapePanelRect_) &&
1308             ReadParcel(parcel, params->PortraitPanelRect_)) {
1309             return params;
1310         }
1311         delete params;
1312         return nullptr;
1313     }
1314 };
1315 }
1316 }
1317 #endif // OHOS_ROSEN_WM_COMMON_H
1318