1 /*
2 * Copyright (c) 2021-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 #include "js_window_utils.h"
17 #include <iomanip>
18 #include <regex>
19 #include <sstream>
20 #include "accesstoken_kit.h"
21 #include "bundle_constants.h"
22 #include "ipc_skeleton.h"
23 #include "window_manager_hilog.h"
24 #include "js_window.h"
25 #include "wm_common.h"
26
27 namespace OHOS {
28 namespace Rosen {
29 using namespace AbilityRuntime;
30 namespace {
31 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "JsUtils"};
32 constexpr size_t INDEX_ZERO = 0;
33 constexpr size_t INDEX_ONE = 1;
34 constexpr size_t INDEX_TWO = 2;
35 constexpr size_t FOUR_PARAMS_SIZE = 4;
36 constexpr size_t ARG_COUNT_ZERO = 0;
37 constexpr size_t ARG_COUNT_TWO = 2;
38 constexpr size_t ARG_COUNT_THREE = 3;
39 constexpr int32_t MAX_TOUCHABLE_AREAS = 10;
40 constexpr uint32_t CURVE_TYPE_SPRING = 1;
41 constexpr uint32_t ANIMATION_FOUR_PARAMS_SIZE = 4;
42 const std::string RESOLVED_CALLBACK = "resolvedCallback";
43 const std::string REJECTED_CALLBACK = "rejectedCallback";
44 const std::string INTERPOLATINGSPRING = "interpolatingSpring";
45 constexpr std::array<DefaultSpecificZIndex, 2> DefaultSpecificZIndexList = {
46 DefaultSpecificZIndex::MUTISCREEN_COLLABORATION,
47 DefaultSpecificZIndex::SUPER_PRIVACY_ANIMATION
48 };
49 }
50
WindowTypeInit(napi_env env)51 napi_value WindowTypeInit(napi_env env)
52 {
53 WLOGFD("WindowTypeInit");
54
55 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
56
57 napi_value objValue = nullptr;
58 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
59
60 napi_set_named_property(env, objValue, "TYPE_APP", CreateJsValue(env,
61 static_cast<int32_t>(ApiWindowType::TYPE_APP)));
62 napi_set_named_property(env, objValue, "TYPE_SYSTEM_ALERT", CreateJsValue(env,
63 static_cast<int32_t>(ApiWindowType::TYPE_SYSTEM_ALERT)));
64 napi_set_named_property(env, objValue, "TYPE_INPUT_METHOD", CreateJsValue(env,
65 static_cast<int32_t>(ApiWindowType::TYPE_INPUT_METHOD)));
66 napi_set_named_property(env, objValue, "TYPE_STATUS_BAR", CreateJsValue(env,
67 static_cast<int32_t>(ApiWindowType::TYPE_STATUS_BAR)));
68 napi_set_named_property(env, objValue, "TYPE_PANEL", CreateJsValue(env,
69 static_cast<int32_t>(ApiWindowType::TYPE_PANEL)));
70 napi_set_named_property(env, objValue, "TYPE_KEYGUARD", CreateJsValue(env,
71 static_cast<int32_t>(ApiWindowType::TYPE_KEYGUARD)));
72 napi_set_named_property(env, objValue, "TYPE_VOLUME_OVERLAY", CreateJsValue(env,
73 static_cast<int32_t>(ApiWindowType::TYPE_VOLUME_OVERLAY)));
74 napi_set_named_property(env, objValue, "TYPE_NAVIGATION_BAR", CreateJsValue(env,
75 static_cast<int32_t>(ApiWindowType::TYPE_NAVIGATION_BAR)));
76 napi_set_named_property(env, objValue, "TYPE_FLOAT", CreateJsValue(env,
77 static_cast<int32_t>(ApiWindowType::TYPE_FLOAT)));
78 napi_set_named_property(env, objValue, "TYPE_FLOAT_CAMERA", CreateJsValue(env,
79 static_cast<int32_t>(ApiWindowType::TYPE_FLOAT_CAMERA)));
80 napi_set_named_property(env, objValue, "TYPE_WALLPAPER", CreateJsValue(env,
81 static_cast<int32_t>(ApiWindowType::TYPE_WALLPAPER)));
82 napi_set_named_property(env, objValue, "TYPE_DESKTOP", CreateJsValue(env,
83 static_cast<int32_t>(ApiWindowType::TYPE_DESKTOP)));
84 napi_set_named_property(env, objValue, "TYPE_LAUNCHER_RECENT", CreateJsValue(env,
85 static_cast<int32_t>(ApiWindowType::TYPE_LAUNCHER_RECENT)));
86 napi_set_named_property(env, objValue, "TYPE_LAUNCHER_DOCK", CreateJsValue(env,
87 static_cast<int32_t>(ApiWindowType::TYPE_LAUNCHER_DOCK)));
88 napi_set_named_property(env, objValue, "TYPE_VOICE_INTERACTION", CreateJsValue(env,
89 static_cast<int32_t>(ApiWindowType::TYPE_VOICE_INTERACTION)));
90 napi_set_named_property(env, objValue, "TYPE_DIALOG", CreateJsValue(env,
91 static_cast<int32_t>(ApiWindowType::TYPE_DIALOG)));
92 napi_set_named_property(env, objValue, "TYPE_POINTER", CreateJsValue(env,
93 static_cast<int32_t>(ApiWindowType::TYPE_POINTER)));
94 napi_set_named_property(env, objValue, "TYPE_SCREENSHOT", CreateJsValue(env,
95 static_cast<int32_t>(ApiWindowType::TYPE_SCREENSHOT)));
96 napi_set_named_property(env, objValue, "TYPE_SYSTEM_TOAST", CreateJsValue(env,
97 static_cast<int32_t>(ApiWindowType::TYPE_SYSTEM_TOAST)));
98 napi_set_named_property(env, objValue, "TYPE_DIVIDER", CreateJsValue(env,
99 static_cast<int32_t>(ApiWindowType::TYPE_DIVIDER)));
100 napi_set_named_property(env, objValue, "TYPE_GLOBAL_SEARCH", CreateJsValue(env,
101 static_cast<int32_t>(ApiWindowType::TYPE_GLOBAL_SEARCH)));
102 napi_set_named_property(env, objValue, "TYPE_HANDWRITE", CreateJsValue(env,
103 static_cast<int32_t>(ApiWindowType::TYPE_HANDWRITE)));
104 napi_set_named_property(env, objValue, "TYPE_WALLET_SWIPE_CARD", CreateJsValue(env,
105 static_cast<int32_t>(ApiWindowType::TYPE_WALLET_SWIPE_CARD)));
106 napi_set_named_property(env, objValue, "TYPE_SCREEN_CONTROL", CreateJsValue(env,
107 static_cast<int32_t>(ApiWindowType::TYPE_SCREEN_CONTROL)));
108 napi_set_named_property(env, objValue, "TYPE_FLOAT_NAVIGATION", CreateJsValue(env,
109 static_cast<int32_t>(ApiWindowType::TYPE_FLOAT_NAVIGATION)));
110 napi_set_named_property(env, objValue, "TYPE_DYNAMIC", CreateJsValue(env,
111 static_cast<int32_t>(ApiWindowType::TYPE_DYNAMIC)));
112 napi_set_named_property(env, objValue, "TYPE_MUTISCREEN_COLLABORATION", CreateJsValue(env,
113 static_cast<int32_t>(ApiWindowType::TYPE_MUTISCREEN_COLLABORATION)));
114
115 return objValue;
116 }
117
AvoidAreaTypeInit(napi_env env)118 napi_value AvoidAreaTypeInit(napi_env env)
119 {
120 WLOGFD("AvoidAreaTypeInit");
121
122 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
123
124 napi_value objValue = nullptr;
125 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
126
127 napi_set_named_property(env, objValue, "TYPE_SYSTEM", CreateJsValue(env,
128 static_cast<int32_t>(AvoidAreaType::TYPE_SYSTEM)));
129 napi_set_named_property(env, objValue, "TYPE_CUTOUT", CreateJsValue(env,
130 static_cast<int32_t>(AvoidAreaType::TYPE_CUTOUT)));
131 napi_set_named_property(env, objValue, "TYPE_SYSTEM_GESTURE", CreateJsValue(env,
132 static_cast<int32_t>(AvoidAreaType::TYPE_SYSTEM_GESTURE)));
133 napi_set_named_property(env, objValue, "TYPE_KEYBOARD",
134 CreateJsValue(env, static_cast<int32_t>(AvoidAreaType::TYPE_KEYBOARD)));
135 napi_set_named_property(env, objValue, "TYPE_NAVIGATION_INDICATOR",
136 CreateJsValue(env, static_cast<int32_t>(AvoidAreaType::TYPE_NAVIGATION_INDICATOR)));
137 return objValue;
138 }
139
WindowModeInit(napi_env env)140 napi_value WindowModeInit(napi_env env)
141 {
142 WLOGFD("WindowModeInit");
143
144 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
145
146 napi_value objValue = nullptr;
147 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
148
149 napi_set_named_property(env, objValue, "UNDEFINED", CreateJsValue(env,
150 static_cast<int32_t>(ApiWindowMode::UNDEFINED)));
151 napi_set_named_property(env, objValue, "FULLSCREEN", CreateJsValue(env,
152 static_cast<int32_t>(ApiWindowMode::FULLSCREEN)));
153 napi_set_named_property(env, objValue, "PRIMARY", CreateJsValue(env,
154 static_cast<int32_t>(ApiWindowMode::PRIMARY)));
155 napi_set_named_property(env, objValue, "SECONDARY", CreateJsValue(env,
156 static_cast<int32_t>(ApiWindowMode::SECONDARY)));
157 napi_set_named_property(env, objValue, "FLOATING", CreateJsValue(env,
158 static_cast<int32_t>(ApiWindowMode::FLOATING)));
159 return objValue;
160 }
161
GlobalWindowModeInit(napi_env env)162 napi_value GlobalWindowModeInit(napi_env env)
163 {
164 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
165
166 napi_value objValue = nullptr;
167 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
168
169 napi_set_named_property(env, objValue, "FULLSCREEN", CreateJsValue(env,
170 static_cast<int32_t>(GlobalWindowMode::FULLSCREEN)));
171 napi_set_named_property(env, objValue, "SPLIT", CreateJsValue(env,
172 static_cast<int32_t>(GlobalWindowMode::SPLIT)));
173 napi_set_named_property(env, objValue, "FLOAT", CreateJsValue(env,
174 static_cast<int32_t>(GlobalWindowMode::FLOAT)));
175 napi_set_named_property(env, objValue, "PIP", CreateJsValue(env,
176 static_cast<int32_t>(GlobalWindowMode::PIP)));
177 return objValue;
178 }
179
ScreenshotEventTypeInit(napi_env env)180 napi_value ScreenshotEventTypeInit(napi_env env)
181 {
182 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
183
184 napi_value objValue = nullptr;
185 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
186
187 napi_set_named_property(env, objValue, "SYSTEM_SCREENSHOT", CreateJsValue(env,
188 static_cast<int32_t>(ScreenshotEventType::SYSTEM_SCREENSHOT)));
189 napi_set_named_property(env, objValue, "SYSTEM_SCREENSHOT_ABORT", CreateJsValue(env,
190 static_cast<int32_t>(ScreenshotEventType::SYSTEM_SCREENSHOT_ABORT)));
191 napi_set_named_property(env, objValue, "SCROLL_SHOT_START", CreateJsValue(env,
192 static_cast<int32_t>(ScreenshotEventType::SCROLL_SHOT_START)));
193 napi_set_named_property(env, objValue, "SCROLL_SHOT_END", CreateJsValue(env,
194 static_cast<int32_t>(ScreenshotEventType::SCROLL_SHOT_END)));
195 napi_set_named_property(env, objValue, "SCROLL_SHOT_ABORT", CreateJsValue(env,
196 static_cast<int32_t>(ScreenshotEventType::SCROLL_SHOT_ABORT)));
197 return objValue;
198 }
199
ColorSpaceInit(napi_env env)200 napi_value ColorSpaceInit(napi_env env)
201 {
202 WLOGFD("ColorSpaceInit");
203
204 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
205
206 napi_value objValue = nullptr;
207 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
208
209 napi_set_named_property(env, objValue, "DEFAULT", CreateJsValue(env,
210 static_cast<int32_t>(ColorSpace::COLOR_SPACE_DEFAULT)));
211 napi_set_named_property(env, objValue, "WIDE_GAMUT", CreateJsValue(env,
212 static_cast<int32_t>(ColorSpace::COLOR_SPACE_WIDE_GAMUT)));
213 return objValue;
214 }
215
OrientationInit(napi_env env)216 napi_value OrientationInit(napi_env env)
217 {
218 WLOGFD("OrientationInit");
219
220 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
221
222 napi_value objValue = nullptr;
223 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
224
225 napi_set_named_property(env, objValue, "UNSPECIFIED", CreateJsValue(env,
226 static_cast<int32_t>(ApiOrientation::UNSPECIFIED)));
227 napi_set_named_property(env, objValue, "PORTRAIT", CreateJsValue(env,
228 static_cast<int32_t>(ApiOrientation::PORTRAIT)));
229 napi_set_named_property(env, objValue, "LANDSCAPE", CreateJsValue(env,
230 static_cast<int32_t>(ApiOrientation::LANDSCAPE)));
231 napi_set_named_property(env, objValue, "PORTRAIT_INVERTED", CreateJsValue(env,
232 static_cast<int32_t>(ApiOrientation::PORTRAIT_INVERTED)));
233 napi_set_named_property(env, objValue, "LANDSCAPE_INVERTED", CreateJsValue(env,
234 static_cast<int32_t>(ApiOrientation::LANDSCAPE_INVERTED)));
235 napi_set_named_property(env, objValue, "AUTO_ROTATION", CreateJsValue(env,
236 static_cast<int32_t>(ApiOrientation::AUTO_ROTATION)));
237 napi_set_named_property(env, objValue, "AUTO_ROTATION_PORTRAIT", CreateJsValue(env,
238 static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_PORTRAIT)));
239 napi_set_named_property(env, objValue, "AUTO_ROTATION_LANDSCAPE", CreateJsValue(env,
240 static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_LANDSCAPE)));
241 napi_set_named_property(env, objValue, "AUTO_ROTATION_RESTRICTED", CreateJsValue(env,
242 static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_RESTRICTED)));
243 napi_set_named_property(env, objValue, "AUTO_ROTATION_PORTRAIT_RESTRICTED", CreateJsValue(env,
244 static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_PORTRAIT_RESTRICTED)));
245 napi_set_named_property(env, objValue, "AUTO_ROTATION_LANDSCAPE_RESTRICTED", CreateJsValue(env,
246 static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_LANDSCAPE_RESTRICTED)));
247 napi_set_named_property(env, objValue, "LOCKED", CreateJsValue(env,
248 static_cast<int32_t>(ApiOrientation::LOCKED)));
249 napi_set_named_property(env, objValue, "AUTO_ROTATION_UNSPECIFIED", CreateJsValue(env,
250 static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_UNSPECIFIED)));
251 napi_set_named_property(env, objValue, "USER_ROTATION_PORTRAIT", CreateJsValue(env,
252 static_cast<int32_t>(ApiOrientation::USER_ROTATION_PORTRAIT)));
253 napi_set_named_property(env, objValue, "USER_ROTATION_LANDSCAPE", CreateJsValue(env,
254 static_cast<int32_t>(ApiOrientation::USER_ROTATION_LANDSCAPE)));
255 napi_set_named_property(env, objValue, "USER_ROTATION_PORTRAIT_INVERTED", CreateJsValue(env,
256 static_cast<int32_t>(ApiOrientation::USER_ROTATION_PORTRAIT_INVERTED)));
257 napi_set_named_property(env, objValue, "USER_ROTATION_LANDSCAPE_INVERTED", CreateJsValue(env,
258 static_cast<int32_t>(ApiOrientation::USER_ROTATION_LANDSCAPE_INVERTED)));
259 napi_set_named_property(env, objValue, "FOLLOW_DESKTOP", CreateJsValue(env,
260 static_cast<int32_t>(ApiOrientation::FOLLOW_DESKTOP)));
261 return objValue;
262 }
263
WindowStageEventTypeInit(napi_env env)264 napi_value WindowStageEventTypeInit(napi_env env)
265 {
266 WLOGFD("WindowStageEventTypeInit");
267
268 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
269
270 napi_value objValue = nullptr;
271 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
272
273 napi_set_named_property(env, objValue, "SHOWN", CreateJsValue(env,
274 static_cast<int32_t>(LifeCycleEventType::FOREGROUND)));
275 napi_set_named_property(env, objValue, "ACTIVE", CreateJsValue(env,
276 static_cast<int32_t>(LifeCycleEventType::ACTIVE)));
277 napi_set_named_property(env, objValue, "INACTIVE", CreateJsValue(env,
278 static_cast<int32_t>(LifeCycleEventType::INACTIVE)));
279 napi_set_named_property(env, objValue, "HIDDEN", CreateJsValue(env,
280 static_cast<int32_t>(LifeCycleEventType::BACKGROUND)));
281 napi_set_named_property(env, objValue, "RESUMED", CreateJsValue(env,
282 static_cast<int32_t>(LifeCycleEventType::RESUMED)));
283 napi_set_named_property(env, objValue, "PAUSED", CreateJsValue(env,
284 static_cast<int32_t>(LifeCycleEventType::PAUSED)));
285 return objValue;
286 }
287
WindowStageLifecycleEventTypeInit(napi_env env)288 napi_value WindowStageLifecycleEventTypeInit(napi_env env)
289 {
290 TLOGD(WmsLogTag::WMS_LIFE, "in");
291
292 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
293
294 napi_value objValue = nullptr;
295 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
296
297 napi_set_named_property(env, objValue, "SHOWN", CreateJsValue(env,
298 static_cast<int32_t>(WindowStageLifeCycleEventType::FOREGROUND)));
299 napi_set_named_property(env, objValue, "RESUMED", CreateJsValue(env,
300 static_cast<int32_t>(WindowStageLifeCycleEventType::RESUMED)));
301 napi_set_named_property(env, objValue, "PAUSED", CreateJsValue(env,
302 static_cast<int32_t>(WindowStageLifeCycleEventType::PAUSED)));
303 napi_set_named_property(env, objValue, "HIDDEN", CreateJsValue(env,
304 static_cast<int32_t>(WindowStageLifeCycleEventType::BACKGROUND)));
305 return objValue;
306 }
307
WindowAnchorInit(napi_env env)308 napi_value WindowAnchorInit(napi_env env)
309 {
310 WLOGFD("WindowAnchorInit");
311 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
312 napi_value objValue = nullptr;
313 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
314 napi_set_named_property(env, objValue, "TOP_START", CreateJsValue(env,
315 static_cast<int32_t>(WindowAnchor::TOP_START)));
316 napi_set_named_property(env, objValue, "TOP", CreateJsValue(env,
317 static_cast<int32_t>(WindowAnchor::TOP)));
318 napi_set_named_property(env, objValue, "TOP_END", CreateJsValue(env,
319 static_cast<int32_t>(WindowAnchor::TOP_END)));
320 napi_set_named_property(env, objValue, "START", CreateJsValue(env,
321 static_cast<int32_t>(WindowAnchor::START)));
322 napi_set_named_property(env, objValue, "CENTER", CreateJsValue(env,
323 static_cast<int32_t>(WindowAnchor::CENTER)));
324 napi_set_named_property(env, objValue, "END", CreateJsValue(env,
325 static_cast<int32_t>(WindowAnchor::END)));
326 napi_set_named_property(env, objValue, "BOTTOM_START", CreateJsValue(env,
327 static_cast<int32_t>(WindowAnchor::BOTTOM_START)));
328 napi_set_named_property(env, objValue, "BOTTOM", CreateJsValue(env,
329 static_cast<int32_t>(WindowAnchor::BOTTOM)));
330 napi_set_named_property(env, objValue, "BOTTOM_END", CreateJsValue(env,
331 static_cast<int32_t>(WindowAnchor::BOTTOM_END)));
332 return objValue;
333 }
334
WindowEventTypeInit(napi_env env)335 napi_value WindowEventTypeInit(napi_env env)
336 {
337 WLOGFD("WindowEventTypeInit");
338
339 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
340
341 napi_value objValue = nullptr;
342 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
343
344 napi_set_named_property(env, objValue, "WINDOW_SHOWN", CreateJsValue(env,
345 static_cast<int32_t>(LifeCycleEventType::FOREGROUND)));
346 napi_set_named_property(env, objValue, "WINDOW_ACTIVE", CreateJsValue(env,
347 static_cast<int32_t>(LifeCycleEventType::ACTIVE)));
348 napi_set_named_property(env, objValue, "WINDOW_INACTIVE", CreateJsValue(env,
349 static_cast<int32_t>(LifeCycleEventType::INACTIVE)));
350 napi_set_named_property(env, objValue, "WINDOW_HIDDEN", CreateJsValue(env,
351 static_cast<int32_t>(LifeCycleEventType::BACKGROUND)));
352 napi_set_named_property(env, objValue, "WINDOW_DESTROYED", CreateJsValue(env,
353 static_cast<int32_t>(LifeCycleEventType::DESTROYED)));
354 return objValue;
355 }
356
WindowLayoutModeInit(napi_env env)357 napi_value WindowLayoutModeInit(napi_env env)
358 {
359 WLOGFD("WindowLayoutModeInit");
360 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
361
362 napi_value objValue = nullptr;
363 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
364
365 napi_set_named_property(env, objValue, "WINDOW_LAYOUT_MODE_CASCADE", CreateJsValue(env,
366 static_cast<int32_t>(WindowLayoutMode::CASCADE)));
367 napi_set_named_property(env, objValue, "WINDOW_LAYOUT_MODE_TILE", CreateJsValue(env,
368 static_cast<int32_t>(WindowLayoutMode::TILE)));
369 return objValue;
370 }
371
BlurStyleInit(napi_env env)372 napi_value BlurStyleInit(napi_env env)
373 {
374 WLOGD("BlurStyleInit");
375 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
376
377 napi_value objValue = nullptr;
378 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
379
380 napi_set_named_property(env, objValue, "OFF", CreateJsValue(env,
381 static_cast<int32_t>(WindowBlurStyle::WINDOW_BLUR_OFF)));
382 napi_set_named_property(env, objValue, "THIN", CreateJsValue(env,
383 static_cast<int32_t>(WindowBlurStyle::WINDOW_BLUR_THIN)));
384 napi_set_named_property(env, objValue, "REGULAR", CreateJsValue(env,
385 static_cast<int32_t>(WindowBlurStyle::WINDOW_BLUR_REGULAR)));
386 napi_set_named_property(env, objValue, "THICK", CreateJsValue(env,
387 static_cast<int32_t>(WindowBlurStyle::WINDOW_BLUR_THICK)));
388 return objValue;
389 }
390
MaximizePresentationInit(napi_env env)391 napi_value MaximizePresentationInit(napi_env env)
392 {
393 WLOGD("MaximizePresentationInit");
394 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
395
396 napi_value objValue = nullptr;
397 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
398
399 napi_set_named_property(env, objValue, "FOLLOW_APP_IMMERSIVE_SETTING", CreateJsValue(env,
400 static_cast<int32_t>(MaximizePresentation::FOLLOW_APP_IMMERSIVE_SETTING)));
401 napi_set_named_property(env, objValue, "EXIT_IMMERSIVE", CreateJsValue(env,
402 static_cast<int32_t>(MaximizePresentation::EXIT_IMMERSIVE)));
403 napi_set_named_property(env, objValue, "ENTER_IMMERSIVE", CreateJsValue(env,
404 static_cast<int32_t>(MaximizePresentation::ENTER_IMMERSIVE)));
405 napi_set_named_property(env, objValue, "ENTER_IMMERSIVE_DISABLE_TITLE_AND_DOCK_HOVER", CreateJsValue(env,
406 static_cast<int32_t>(MaximizePresentation::ENTER_IMMERSIVE_DISABLE_TITLE_AND_DOCK_HOVER)));
407 return objValue;
408 }
409
WindowErrorInit(napi_env env)410 napi_value WindowErrorInit(napi_env env)
411 {
412 WLOGFD("WindowErrorInit");
413 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
414
415 napi_value objValue = nullptr;
416 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
417
418 napi_set_named_property(env, objValue, "WM_DO_NOTHING", CreateJsValue(env,
419 static_cast<int32_t>(WMError::WM_DO_NOTHING)));
420 napi_set_named_property(env, objValue, "WM_ERROR_NO_MEM", CreateJsValue(env,
421 static_cast<int32_t>(WMError::WM_ERROR_NO_MEM)));
422 napi_set_named_property(env, objValue, "WM_ERROR_DESTROYED_OBJECT", CreateJsValue(env,
423 static_cast<int32_t>(WMError::WM_ERROR_DESTROYED_OBJECT)));
424 napi_set_named_property(env, objValue, "WM_ERROR_INVALID_WINDOW", CreateJsValue(env,
425 static_cast<int32_t>(WMError::WM_ERROR_INVALID_WINDOW)));
426 napi_set_named_property(env, objValue, "WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE", CreateJsValue(env,
427 static_cast<int32_t>(WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE)));
428 napi_set_named_property(env, objValue, "WM_ERROR_INVALID_OPERATION", CreateJsValue(env,
429 static_cast<int32_t>(WMError::WM_ERROR_INVALID_OPERATION)));
430 napi_set_named_property(env, objValue, "WM_ERROR_INVALID_PERMISSION", CreateJsValue(env,
431 static_cast<int32_t>(WMError::WM_ERROR_INVALID_PERMISSION)));
432 napi_set_named_property(env, objValue, "WM_ERROR_NO_REMOTE_ANIMATION", CreateJsValue(env,
433 static_cast<int32_t>(WMError::WM_ERROR_NO_REMOTE_ANIMATION)));
434 napi_set_named_property(env, objValue, "WM_ERROR_DEVICE_NOT_SUPPORT", CreateJsValue(env,
435 static_cast<int32_t>(WMError::WM_ERROR_DEVICE_NOT_SUPPORT)));
436 napi_set_named_property(env, objValue, "WM_ERROR_NULLPTR", CreateJsValue(env,
437 static_cast<int32_t>(WMError::WM_ERROR_NULLPTR)));
438 napi_set_named_property(env, objValue, "WM_ERROR_INVALID_TYPE", CreateJsValue(env,
439 static_cast<int32_t>(WMError::WM_ERROR_INVALID_TYPE)));
440 napi_set_named_property(env, objValue, "WM_ERROR_INVALID_PARAM", CreateJsValue(env,
441 static_cast<int32_t>(WMError::WM_ERROR_INVALID_PARAM)));
442 napi_set_named_property(env, objValue, "WM_ERROR_SAMGR", CreateJsValue(env,
443 static_cast<int32_t>(WMError::WM_ERROR_SAMGR)));
444 napi_set_named_property(env, objValue, "WM_ERROR_IPC_FAILED", CreateJsValue(env,
445 static_cast<int32_t>(WMError::WM_ERROR_IPC_FAILED)));
446 napi_set_named_property(env, objValue, "WM_ERROR_START_ABILITY_FAILED", CreateJsValue(env,
447 static_cast<int32_t>(WMError::WM_ERROR_START_ABILITY_FAILED)));
448 return objValue;
449 }
450
WindowErrorCodeInit(napi_env env)451 napi_value WindowErrorCodeInit(napi_env env)
452 {
453 WLOGFD("WindowErrorCodeInit");
454 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
455
456 napi_value objValue = nullptr;
457 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
458 napi_set_named_property(env, objValue, "WM_ERROR_NO_PERMISSION", CreateJsValue(env,
459 static_cast<int32_t>(WmErrorCode::WM_ERROR_NO_PERMISSION)));
460 napi_set_named_property(env, objValue, "WM_ERROR_NOT_SYSTEM_APP", CreateJsValue(env,
461 static_cast<int32_t>(WmErrorCode::WM_ERROR_NOT_SYSTEM_APP)));
462 napi_set_named_property(env, objValue, "WM_ERROR_INVALID_PARAM", CreateJsValue(env,
463 static_cast<int32_t>(WmErrorCode::WM_ERROR_INVALID_PARAM)));
464 napi_set_named_property(env, objValue, "WM_ERROR_DEVICE_NOT_SUPPORT", CreateJsValue(env,
465 static_cast<int32_t>(WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT)));
466 napi_set_named_property(env, objValue, "WM_ERROR_REPEAT_OPERATION", CreateJsValue(env,
467 static_cast<int32_t>(WmErrorCode::WM_ERROR_REPEAT_OPERATION)));
468 napi_set_named_property(env, objValue, "WM_ERROR_STATE_ABNORMALLY", CreateJsValue(env,
469 static_cast<int32_t>(WmErrorCode::WM_ERROR_STATE_ABNORMALLY)));
470 napi_set_named_property(env, objValue, "WM_ERROR_SYSTEM_ABNORMALLY", CreateJsValue(env,
471 static_cast<int32_t>(WmErrorCode::WM_ERROR_SYSTEM_ABNORMALLY)));
472 napi_set_named_property(env, objValue, "WM_ERROR_INVALID_CALLING", CreateJsValue(env,
473 static_cast<int32_t>(WmErrorCode::WM_ERROR_INVALID_CALLING)));
474 napi_set_named_property(env, objValue, "WM_ERROR_STAGE_ABNORMALLY", CreateJsValue(env,
475 static_cast<int32_t>(WmErrorCode::WM_ERROR_STAGE_ABNORMALLY)));
476 napi_set_named_property(env, objValue, "WM_ERROR_CONTEXT_ABNORMALLY", CreateJsValue(env,
477 static_cast<int32_t>(WmErrorCode::WM_ERROR_CONTEXT_ABNORMALLY)));
478 napi_set_named_property(env, objValue, "WM_ERROR_START_ABILITY_FAILED", CreateJsValue(env,
479 static_cast<int32_t>(WmErrorCode::WM_ERROR_START_ABILITY_FAILED)));
480 return objValue;
481 }
482
WindowStatusTypeInit(napi_env env)483 napi_value WindowStatusTypeInit(napi_env env)
484 {
485 WLOGFD("WindowStatusTypeInit");
486 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
487
488 napi_value objValue = nullptr;
489 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
490 napi_set_named_property(env, objValue, "UNDEFINED", CreateJsValue(env,
491 static_cast<int32_t>(WindowStatus::WINDOW_STATUS_UNDEFINED)));
492 napi_set_named_property(env, objValue, "FULL_SCREEN", CreateJsValue(env,
493 static_cast<int32_t>(WindowStatus::WINDOW_STATUS_FULLSCREEN)));
494 napi_set_named_property(env, objValue, "MAXIMIZE", CreateJsValue(env,
495 static_cast<int32_t>(WindowStatus::WINDOW_STATUS_MAXIMIZE)));
496 napi_set_named_property(env, objValue, "MINIMIZE", CreateJsValue(env,
497 static_cast<int32_t>(WindowStatus::WINDOW_STATUS_MINIMIZE)));
498 napi_set_named_property(env, objValue, "FLOATING", CreateJsValue(env,
499 static_cast<int32_t>(WindowStatus::WINDOW_STATUS_FLOATING)));
500 napi_set_named_property(env, objValue, "SPLIT_SCREEN", CreateJsValue(env,
501 static_cast<int32_t>(WindowStatus::WINDOW_STATUS_SPLITSCREEN)));
502 return objValue;
503 }
504
RectChangeReasonInit(napi_env env)505 napi_value RectChangeReasonInit(napi_env env)
506 {
507 TLOGD(WmsLogTag::WMS_LAYOUT, "RectChangeReasonInit called");
508
509 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
510
511 napi_value objValue = nullptr;
512 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
513
514 napi_set_named_property(env, objValue, "UNDEFINED",
515 CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::UNDEFINED)));
516 napi_set_named_property(env, objValue, "MAXIMIZE",
517 CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::MAXIMIZE)));
518 napi_set_named_property(env, objValue, "RECOVER",
519 CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::RECOVER)));
520 napi_set_named_property(env, objValue, "MOVE",
521 CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::MOVE)));
522 napi_set_named_property(env, objValue, "DRAG",
523 CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::DRAG)));
524 napi_set_named_property(env, objValue, "DRAG_START",
525 CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::DRAG_START)));
526 napi_set_named_property(env, objValue, "DRAG_END",
527 CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::DRAG_END)));
528 return objValue;
529 }
530
GetRectAndConvertToJsValue(napi_env env,const Rect & rect)531 napi_value GetRectAndConvertToJsValue(napi_env env, const Rect& rect)
532 {
533 napi_value objValue = nullptr;
534 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
535
536 napi_set_named_property(env, objValue, "left", CreateJsValue(env, rect.posX_));
537 napi_set_named_property(env, objValue, "top", CreateJsValue(env, rect.posY_));
538 napi_set_named_property(env, objValue, "width", CreateJsValue(env, rect.width_));
539 napi_set_named_property(env, objValue, "height", CreateJsValue(env, rect.height_));
540 return objValue;
541 }
542
CreateJsWindowAnimationConfigObject(napi_env env,const KeyboardAnimationCurve & curve)543 napi_value CreateJsWindowAnimationConfigObject(napi_env env, const KeyboardAnimationCurve& curve)
544 {
545 napi_value objValue = nullptr;
546 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
547 napi_status status = napi_invalid_arg;
548 if (curve.curveType_ == INTERPOLATINGSPRING) {
549 status = napi_set_named_property(env, objValue, "curve", CreateJsValue(env, CURVE_TYPE_SPRING));
550 if (status != napi_ok) {
551 TLOGE(WmsLogTag::WMS_KEYBOARD, "Fail to set curve to napi property");
552 return NapiGetUndefined(env);
553 }
554 }
555 status = napi_set_named_property(env, objValue, "duration", CreateJsValue(env, curve.duration_));
556 if (status != napi_ok) {
557 TLOGE(WmsLogTag::WMS_KEYBOARD, "Fail to set duration to napi property");
558 return NapiGetUndefined(env);
559 }
560 auto paramSize = curve.curveParams_.size();
561 if (paramSize == ANIMATION_FOUR_PARAMS_SIZE) {
562 napi_value jsArray = nullptr;
563 status = napi_create_array_with_length(env, paramSize, &jsArray);
564 if (status != napi_ok) {
565 TLOGE(WmsLogTag::WMS_KEYBOARD, "Fail to create jsArray");
566 return NapiGetUndefined(env);
567 }
568 for (size_t i = 0; i < paramSize; i++) {
569 napi_value param = nullptr;
570 status = napi_create_double(env, static_cast<double>(curve.curveParams_[i]), ¶m);
571 if (status != napi_ok) {
572 TLOGE(WmsLogTag::WMS_KEYBOARD, "Fail to create jsDoubleValue");
573 return NapiGetUndefined(env);
574 }
575 status = napi_set_element(env, jsArray, i, param);
576 if (status != napi_ok) {
577 TLOGE(WmsLogTag::WMS_KEYBOARD, "Fail to set element to jsArray");
578 return NapiGetUndefined(env);
579 }
580 }
581 status = napi_set_named_property(env, objValue, "param", jsArray);
582 if (status != napi_ok) {
583 TLOGE(WmsLogTag::WMS_KEYBOARD, "Fail to set param to napi property");
584 return NapiGetUndefined(env);
585 }
586 }
587 return objValue;
588 }
589
CreateJsWindowPropertiesObject(napi_env env,const WindowPropertyInfo & windowPropertyInfo)590 napi_value CreateJsWindowPropertiesObject(napi_env env, const WindowPropertyInfo& windowPropertyInfo)
591 {
592 WLOGD("CreateJsWindowPropertiesObject");
593 napi_value objValue = nullptr;
594 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
595
596 napi_value windowRectObj = GetRectAndConvertToJsValue(env, windowPropertyInfo.windowRect);
597 if (windowRectObj == nullptr) {
598 TLOGE(WmsLogTag::WMS_ATTRIBUTE, "GetWindowRect failed!");
599 }
600 napi_set_named_property(env, objValue, "windowRect", windowRectObj);
601
602 napi_value drawableRectObj = GetRectAndConvertToJsValue(env, windowPropertyInfo.drawableRect);
603 if (drawableRectObj == nullptr) {
604 TLOGE(WmsLogTag::WMS_ATTRIBUTE, "GetDrawableRect failed!");
605 }
606 napi_set_named_property(env, objValue, "drawableRect", drawableRectObj);
607
608 napi_value globalDisplayRectObj = GetRectAndConvertToJsValue(env, windowPropertyInfo.globalDisplayRect);
609 if (globalDisplayRectObj == nullptr) {
610 TLOGE(WmsLogTag::WMS_ATTRIBUTE, "GetGlobalDisplayRect failed!");
611 }
612 napi_set_named_property(env, objValue, "globalDisplayRect", globalDisplayRectObj);
613
614 WindowType type = windowPropertyInfo.type;
615 if (NATIVE_JS_TO_WINDOW_TYPE_MAP.count(type) != 0) {
616 napi_set_named_property(env, objValue, "type", CreateJsValue(env, NATIVE_JS_TO_WINDOW_TYPE_MAP.at(type)));
617 } else {
618 napi_set_named_property(env, objValue, "type", CreateJsValue(env, type));
619 }
620 napi_set_named_property(env, objValue, "isLayoutFullScreen",
621 CreateJsValue(env, windowPropertyInfo.isLayoutFullScreen));
622 napi_set_named_property(env, objValue, "isFullScreen", CreateJsValue(env, windowPropertyInfo.isFullScreen));
623 napi_set_named_property(env, objValue, "touchable", CreateJsValue(env, windowPropertyInfo.isTouchable));
624 napi_set_named_property(env, objValue, "focusable", CreateJsValue(env, windowPropertyInfo.isFocusable));
625 napi_set_named_property(env, objValue, "name", CreateJsValue(env, windowPropertyInfo.name));
626 napi_set_named_property(env, objValue, "isPrivacyMode", CreateJsValue(env, windowPropertyInfo.isPrivacyMode));
627 napi_set_named_property(env, objValue, "isKeepScreenOn", CreateJsValue(env, windowPropertyInfo.isKeepScreenOn));
628 napi_set_named_property(env, objValue, "brightness", CreateJsValue(env, windowPropertyInfo.brightness));
629 napi_set_named_property(env, objValue, "isTransparent", CreateJsValue(env, windowPropertyInfo.isTransparent));
630 napi_set_named_property(env, objValue, "isRoundCorner", CreateJsValue(env, false)); // empty method
631 napi_set_named_property(env, objValue, "dimBehindValue", CreateJsValue(env, 0));
632 napi_set_named_property(env, objValue, "id", CreateJsValue(env, windowPropertyInfo.id));
633 napi_set_named_property(env, objValue, "displayId", CreateJsValue(env,
634 static_cast<int64_t>(windowPropertyInfo.displayId)));
635 return objValue;
636 }
637
GetHexColor(uint32_t color)638 static std::string GetHexColor(uint32_t color)
639 {
640 std::stringstream ioss;
641 std::string temp;
642 ioss << std::setiosflags(std::ios::uppercase) << std::hex << color;
643 ioss >> temp;
644 int count = RGBA_LENGTH - static_cast<int>(temp.length());
645 std::string tmpColor(count, '0');
646 tmpColor += temp;
647 std::string finalColor("#");
648 finalColor += tmpColor;
649 return finalColor;
650 }
651
CreateJsSystemBarPropertiesObject(napi_env env,sptr<Window> & window)652 napi_value CreateJsSystemBarPropertiesObject(napi_env env, sptr<Window>& window)
653 {
654 napi_value objValue = nullptr;
655 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
656
657 SystemBarProperty status = window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR);
658 SystemBarProperty navi = window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_NAVIGATION_BAR);
659 napi_set_named_property(env, objValue, "statusBarColor",
660 CreateJsValue(env, GetHexColor(status.backgroundColor_)));
661 napi_set_named_property(env, objValue, "statusBarContentColor",
662 CreateJsValue(env, GetHexColor(status.contentColor_)));
663 napi_set_named_property(env, objValue, "isStatusBarLightIcon",
664 CreateJsValue(env, status.contentColor_ == SYSTEM_COLOR_WHITE));
665 napi_set_named_property(env, objValue, "navigationBarColor",
666 CreateJsValue(env, GetHexColor(navi.backgroundColor_)));
667 napi_set_named_property(env, objValue, "navigationBarContentColor",
668 CreateJsValue(env, GetHexColor(navi.contentColor_)));
669 napi_set_named_property(env, objValue, "isNavigationBarLightIcon",
670 CreateJsValue(env, navi.contentColor_ == SYSTEM_COLOR_WHITE));
671 napi_set_named_property(env, objValue, "enableStatusBarAnimation",
672 CreateJsValue(env, status.enableAnimation_));
673 napi_set_named_property(env, objValue, "enableNavigationBarAnimation",
674 CreateJsValue(env, navi.enableAnimation_));
675 return objValue;
676 }
677
CreateJsSystemBarRegionTintObject(napi_env env,const SystemBarRegionTint & tint)678 static napi_value CreateJsSystemBarRegionTintObject(napi_env env, const SystemBarRegionTint& tint)
679 {
680 napi_value objValue = nullptr;
681 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
682
683 if (NATIVE_JS_TO_WINDOW_TYPE_MAP.count(tint.type_) != 0) {
684 napi_set_named_property(env, objValue, "type", CreateJsValue(env, NATIVE_JS_TO_WINDOW_TYPE_MAP.at(tint.type_)));
685 } else {
686 napi_set_named_property(env, objValue, "type", CreateJsValue(env, tint.type_));
687 }
688 napi_set_named_property(env, objValue, "isEnable", CreateJsValue(env, tint.prop_.enable_));
689 std::string bkgColor = GetHexColor(tint.prop_.backgroundColor_);
690 napi_set_named_property(env, objValue, "backgroundColor", CreateJsValue(env, bkgColor));
691 std::string contentColor = GetHexColor(tint.prop_.contentColor_);
692 napi_set_named_property(env, objValue, "contentColor", CreateJsValue(env, contentColor));
693 Rect rect = tint.region_;
694 napi_set_named_property(env, objValue, "region", GetRectAndConvertToJsValue(env, rect));
695
696 WLOGFD("Type %{public}u [%{public}u %{public}s %{public}s]",
697 tint.type_, tint.prop_.enable_, bkgColor.c_str(), contentColor.c_str());
698 WLOGFD("Region [%{public}d %{public}d %{public}u %{public}u]",
699 rect.posX_, rect.posY_, rect.width_, rect.height_);
700 return objValue;
701 }
702
CreateJsWindowLayoutInfoArrayObject(napi_env env,const std::vector<sptr<WindowLayoutInfo>> & infos)703 napi_value CreateJsWindowLayoutInfoArrayObject(napi_env env, const std::vector<sptr<WindowLayoutInfo>>& infos)
704 {
705 napi_value arrayValue = nullptr;
706 napi_create_array_with_length(env, infos.size(), &arrayValue);
707 if (arrayValue == nullptr) {
708 TLOGE(WmsLogTag::WMS_ATTRIBUTE, "arrayValue is null");
709 return nullptr;
710 }
711 for (size_t i = 0; i < infos.size(); i++) {
712 napi_set_element(env, arrayValue, i, CreateJsWindowLayoutInfoObject(env, infos[i]));
713 }
714 return arrayValue;
715 }
716
CreateJsWindowInfoArrayObject(napi_env env,const std::vector<sptr<WindowVisibilityInfo>> & infos)717 napi_value CreateJsWindowInfoArrayObject(napi_env env, const std::vector<sptr<WindowVisibilityInfo>>& infos)
718 {
719 napi_value arrayValue = nullptr;
720 napi_create_array_with_length(env, infos.size(), &arrayValue);
721 if (arrayValue == nullptr) {
722 WLOGFE("Failed to convert windowVisibilityInfo to jsArrayObject");
723 return nullptr;
724 }
725 uint32_t index = 0;
726 for (size_t i = 0; i < infos.size(); i++) {
727 auto info = infos[i];
728 auto windowType = info->GetWindowType();
729 if (windowType >= WindowType::APP_MAIN_WINDOW_BASE && windowType < WindowType::APP_MAIN_WINDOW_END) {
730 napi_set_element(env, arrayValue, index++, CreateJsWindowInfoObject(env, info));
731 }
732 }
733 return arrayValue;
734 }
735
CreateJsDecorButtonStyleObj(napi_env env,DecorButtonStyle decorButtonStyle)736 napi_value CreateJsDecorButtonStyleObj(napi_env env, DecorButtonStyle decorButtonStyle)
737 {
738 napi_value objValue = nullptr;
739 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
740 napi_set_named_property(env, objValue, "colorMode", CreateJsValue(env, decorButtonStyle.colorMode));
741 napi_set_named_property(env, objValue, "buttonBackgroundSize",
742 CreateJsValue(env, decorButtonStyle.buttonBackgroundSize));
743 napi_set_named_property(env, objValue, "spacingBetweenButtons",
744 CreateJsValue(env, decorButtonStyle.spacingBetweenButtons));
745 napi_set_named_property(env, objValue, "closeButtonRightMargin",
746 CreateJsValue(env, decorButtonStyle.closeButtonRightMargin));
747 napi_set_named_property(env, objValue, "buttonIconSize",
748 CreateJsValue(env, decorButtonStyle.buttonIconSize));
749 napi_set_named_property(env, objValue, "buttonBackgroundCornerRadius",
750 CreateJsValue(env, decorButtonStyle.buttonBackgroundCornerRadius));
751 return objValue;
752 }
753
ConvertDecorButtonStyleFromJs(napi_env env,napi_value jsObject,DecorButtonStyle & style)754 bool ConvertDecorButtonStyleFromJs(napi_env env, napi_value jsObject, DecorButtonStyle& style)
755 {
756 int32_t colorMode;
757 bool emptyParam = true;
758 if (ParseJsValue(jsObject, env, "colorMode", colorMode)) {
759 style.colorMode = colorMode;
760 emptyParam = false;
761 }
762 uint32_t buttonBackgroundSize;
763 if (ParseJsValue(jsObject, env, "buttonBackgroundSize", buttonBackgroundSize)) {
764 style.buttonBackgroundSize = buttonBackgroundSize;
765 emptyParam = false;
766 }
767 uint32_t spacingBetweenButtons;
768 if (ParseJsValue(jsObject, env, "spacingBetweenButtons", spacingBetweenButtons)) {
769 style.spacingBetweenButtons = spacingBetweenButtons;
770 emptyParam = false;
771 }
772 uint32_t closeButtonRightMargin;
773 if (ParseJsValue(jsObject, env, "closeButtonRightMargin", closeButtonRightMargin)) {
774 style.closeButtonRightMargin = closeButtonRightMargin;
775 emptyParam = false;
776 }
777 uint32_t buttonIconSize;
778 if (ParseJsValue(jsObject, env, "buttonIconSize", buttonIconSize)) {
779 style.buttonIconSize = buttonIconSize;
780 emptyParam = false;
781 }
782 uint32_t buttonBackgroundCornerRadius;
783 if (ParseJsValue(jsObject, env, "buttonBackgroundCornerRadius", buttonBackgroundCornerRadius)) {
784 style.buttonBackgroundCornerRadius = buttonBackgroundCornerRadius;
785 emptyParam = false;
786 }
787 return !emptyParam;
788 }
789
CreateJsWindowLayoutInfoObject(napi_env env,const sptr<WindowLayoutInfo> & info)790 napi_value CreateJsWindowLayoutInfoObject(napi_env env, const sptr<WindowLayoutInfo>& info)
791 {
792 napi_value objValue = nullptr;
793 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
794 napi_set_named_property(env, objValue, "windowRect", GetRectAndConvertToJsValue(env, info->rect));
795 return objValue;
796 }
797
CreateJsWindowInfoObject(napi_env env,const sptr<WindowVisibilityInfo> & info)798 napi_value CreateJsWindowInfoObject(napi_env env, const sptr<WindowVisibilityInfo>& info)
799 {
800 napi_value objValue = nullptr;
801 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
802 napi_set_named_property(env, objValue, "rect", GetRectAndConvertToJsValue(env, info->GetRect()));
803 napi_set_named_property(env, objValue, "globalDisplayRect",
804 GetRectAndConvertToJsValue(env, info->GetGlobalDisplayRect()));
805 napi_set_named_property(env, objValue, "bundleName", CreateJsValue(env, info->GetBundleName()));
806 napi_set_named_property(env, objValue, "abilityName", CreateJsValue(env, info->GetAbilityName()));
807 napi_set_named_property(env, objValue, "windowId", CreateJsValue(env, info->GetWindowId()));
808 napi_set_named_property(env, objValue, "windowStatusType",
809 CreateJsValue(env, static_cast<int32_t>(info->GetWindowStatus())));
810 napi_set_named_property(env, objValue, "isFocused", CreateJsValue(env, info->IsFocused()));
811 return objValue;
812 }
813
CreateJsSystemBarRegionTintArrayObject(napi_env env,const SystemBarRegionTints & tints)814 napi_value CreateJsSystemBarRegionTintArrayObject(napi_env env, const SystemBarRegionTints& tints)
815 {
816 if (tints.empty()) {
817 WLOGFE("Empty tints");
818 return nullptr;
819 }
820 napi_value objValue = nullptr;
821 napi_create_array_with_length(env, tints.size(), &objValue);
822 napi_value array = objValue;
823 if (array == nullptr) {
824 WLOGFE("Failed to convert SystemBarProperties to jsArrayObject");
825 return nullptr;
826 }
827 uint32_t index = 0;
828 for (size_t i = 0; i < tints.size(); i++) {
829 napi_set_element(env, array, index++, CreateJsSystemBarRegionTintObject(env, tints[i]));
830 }
831 return objValue;
832 }
833
CreateRotationChangeInfoObject(napi_env env,const RotationChangeInfo & info)834 napi_value CreateRotationChangeInfoObject(napi_env env, const RotationChangeInfo& info)
835 {
836 napi_value objValue = nullptr;
837 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
838 napi_set_named_property(env, objValue, "type", CreateJsValue(env, static_cast<uint32_t>(info.type_)));
839 napi_set_named_property(env, objValue, "orientation", CreateJsValue(env, info.orientation_));
840 napi_set_named_property(env, objValue, "displayId", CreateJsValue(env, static_cast<uint32_t>(info.displayId_)));
841 napi_set_named_property(env, objValue, "displayRect", GetRectAndConvertToJsValue(env, info.displayRect_));
842 return objValue;
843 }
844
GetSystemBarStatus(napi_env env,napi_callback_info info,std::unordered_map<WindowType,SystemBarProperty> & systemBarProperties,std::unordered_map<WindowType,SystemBarPropertyFlag> & systemBarpropertyFlags)845 bool GetSystemBarStatus(napi_env env, napi_callback_info info,
846 std::unordered_map<WindowType, SystemBarProperty>& systemBarProperties,
847 std::unordered_map<WindowType, SystemBarPropertyFlag>& systemBarpropertyFlags)
848 {
849 size_t argc = FOUR_PARAMS_SIZE;
850 napi_value argv[FOUR_PARAMS_SIZE] = { nullptr };
851 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
852 uint32_t size = INDEX_ZERO;
853 napi_value nativeArray = nullptr;
854 if (argc > ARG_COUNT_ZERO && GetType(env, argv[INDEX_ZERO]) != napi_function) {
855 nativeArray = argv[INDEX_ZERO];
856 if (nativeArray == nullptr) {
857 TLOGE(WmsLogTag::WMS_IMMS, "Failed to convert parameter to SystemBarArray");
858 return false;
859 }
860 napi_get_array_length(env, nativeArray, &size);
861 }
862 systemBarProperties[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = false;
863 systemBarProperties[WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR].enable_ = false;
864 systemBarProperties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = false;
865 for (uint32_t i = 0; i < size; i++) {
866 std::string name;
867 napi_value getElementValue = nullptr;
868 napi_get_element(env, nativeArray, i, &getElementValue);
869 if (!ConvertFromJsValue(env, getElementValue, name)) {
870 TLOGE(WmsLogTag::WMS_IMMS, "Failed to convert parameter to SystemBarName");
871 return false;
872 }
873 if (name.compare("status") == 0) {
874 systemBarProperties[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
875 systemBarProperties[WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR].enable_ = true;
876 } else if (name.compare("navigation") == 0) {
877 systemBarProperties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = true;
878 }
879 }
880 systemBarpropertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].enableFlag = true;
881 systemBarpropertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enableFlag = true;
882 systemBarpropertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR].enableFlag = true;
883 return true;
884 }
885
GetStatusBarPropertyObject(napi_env env,sptr<Window> & window)886 napi_value GetStatusBarPropertyObject(napi_env env, sptr<Window>& window)
887 {
888 napi_value objValue = nullptr;
889 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
890
891 SystemBarProperty statusBarProperty = window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR);
892 napi_set_named_property(env, objValue, "contentColor",
893 CreateJsValue(env, GetHexColor(statusBarProperty.contentColor_)));
894 return objValue;
895 }
896
CheckTypeForNapiValue(napi_env env,napi_value param,napi_valuetype expectType)897 static bool CheckTypeForNapiValue(napi_env env, napi_value param, napi_valuetype expectType)
898 {
899 napi_valuetype valueType = napi_undefined;
900 if (napi_typeof(env, param, &valueType) != napi_ok) {
901 return false;
902 }
903 return valueType == expectType;
904 }
905
ParseColorMetrics(napi_env env,napi_value value,uint32_t & colorValue)906 bool ParseColorMetrics(napi_env env, napi_value value, uint32_t& colorValue)
907 {
908 if (!CheckTypeForNapiValue(env, value, napi_object)) {
909 return false;
910 }
911 napi_value jsToNumeric = nullptr;
912 napi_get_named_property(env, value, "toNumeric", &jsToNumeric);
913 if (!CheckTypeForNapiValue(env, jsToNumeric, napi_function)) {
914 return false;
915 }
916 napi_value jsColor;
917 if (napi_call_function(env, value, jsToNumeric, 0, nullptr, &jsColor) != napi_ok) {
918 return false;
919 }
920 if (!CheckTypeForNapiValue(env, jsColor, napi_number)) {
921 return false;
922 }
923 return napi_get_value_uint32(env, jsColor, &colorValue) == napi_ok;
924 }
925
GetWindowBackgroundColorFromJs(napi_env env,napi_value value,std::string & colorStr)926 bool GetWindowBackgroundColorFromJs(napi_env env, napi_value value, std::string& colorStr)
927 {
928 napi_valuetype valueType = napi_undefined;
929 napi_typeof(env, value, &valueType);
930 if (valueType == napi_string) {
931 return ConvertFromJsValue(env, value, colorStr);
932 }
933 uint32_t colorValue = 0;
934 if (ParseColorMetrics(env, value, colorValue)) {
935 colorStr = GetHexColor(colorValue);
936 return true;
937 }
938 return false;
939 }
940
ParseAndCheckRect(napi_env env,napi_value jsObject,const Rect & windowRect,Rect & touchableRect)941 bool ParseAndCheckRect(napi_env env, napi_value jsObject,
942 const Rect& windowRect, Rect& touchableRect)
943 {
944 int32_t data = 0;
945 if (ParseJsValue(jsObject, env, "left", data)) {
946 touchableRect.posX_ = data;
947 } else {
948 TLOGE(WmsLogTag::WMS_EVENT, "Failed to convert object:legt");
949 return false;
950 }
951 if (ParseJsValue(jsObject, env, "top", data)) {
952 touchableRect.posY_ = data;
953 } else {
954 TLOGE(WmsLogTag::WMS_EVENT, "Failed to convert object:top");
955 return false;
956 }
957 uint32_t udata = 0;
958 if (ParseJsValue(jsObject, env, "width", udata)) {
959 touchableRect.width_ = udata;
960 } else {
961 TLOGE(WmsLogTag::WMS_EVENT, "Failed to convert object:width");
962 return false;
963 }
964 if (ParseJsValue(jsObject, env, "height", udata)) {
965 touchableRect.height_ = udata;
966 } else {
967 TLOGE(WmsLogTag::WMS_EVENT, "Failed to convert object:height");
968 return false;
969 }
970 if ((touchableRect.posX_ < 0) || (touchableRect.posY_ < 0) ||
971 (touchableRect.posX_ > static_cast<int32_t>(windowRect.width_)) ||
972 (touchableRect.posY_ > static_cast<int32_t>(windowRect.height_)) ||
973 (touchableRect.width_ > (windowRect.width_ - static_cast<uint32_t>(touchableRect.posX_))) ||
974 (touchableRect.height_ > (windowRect.height_ - static_cast<uint32_t>(touchableRect.posY_)))) {
975 TLOGE(WmsLogTag::WMS_EVENT, "Outside the window area, "
976 "touchRect:[%{public}d %{public}d %{public}u %{public}u], "
977 "windowRect:[%{public}d %{public}d %{public}u %{public}u]",
978 touchableRect.posX_, touchableRect.posY_, touchableRect.width_, touchableRect.height_,
979 windowRect.posX_, windowRect.posY_, windowRect.width_, windowRect.height_);
980 return false;
981 }
982 return true;
983 }
984
ParseTouchableAreas(napi_env env,napi_callback_info info,const Rect & windowRect,std::vector<Rect> & touchableAreas)985 WmErrorCode ParseTouchableAreas(napi_env env, napi_callback_info info,
986 const Rect& windowRect, std::vector<Rect>& touchableAreas)
987 {
988 WmErrorCode errCode = WmErrorCode::WM_ERROR_INVALID_PARAM;
989 size_t argc = 4;
990 napi_value argv[4] = {nullptr};
991 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
992 if (argc != 1) {
993 TLOGE(WmsLogTag::WMS_EVENT, "Argc is invalid:%{public}zu", argc);
994 return errCode;
995 }
996 if (GetType(env, argv[0]) != napi_object) {
997 TLOGE(WmsLogTag::WMS_EVENT, "GetType error");
998 return errCode;
999 }
1000 napi_value nativeArray = argv[0];
1001 if (nativeArray == nullptr) {
1002 TLOGE(WmsLogTag::WMS_EVENT, "Failed to convert parameter");
1003 return errCode;
1004 }
1005 uint32_t size = 0;
1006 napi_get_array_length(env, nativeArray, &size);
1007 if (size > MAX_TOUCHABLE_AREAS) {
1008 TLOGE(WmsLogTag::WMS_EVENT, "Exceeded maximum limit");
1009 return errCode;
1010 }
1011 errCode = WmErrorCode::WM_OK;
1012 for (uint32_t i = 0; i < size; i++) {
1013 napi_value getElementValue = nullptr;
1014 napi_get_element(env, nativeArray, i, &getElementValue);
1015 if (getElementValue == nullptr) {
1016 TLOGE(WmsLogTag::WMS_EVENT, "Failed to get element");
1017 errCode = WmErrorCode::WM_ERROR_INVALID_PARAM;
1018 break;
1019 }
1020 Rect touchableArea;
1021 if (ParseAndCheckRect(env, getElementValue, windowRect, touchableArea)) {
1022 touchableAreas.emplace_back(touchableArea);
1023 } else {
1024 errCode = WmErrorCode::WM_ERROR_INVALID_PARAM;
1025 break;
1026 }
1027 }
1028 return errCode;
1029 }
1030
GetSpecificBarStatus(napi_env env,napi_callback_info info,bool & systemBarEnable,bool & systemBarEnableAnimation)1031 bool GetSpecificBarStatus(napi_env env, napi_callback_info info, bool& systemBarEnable, bool& systemBarEnableAnimation)
1032 {
1033 size_t argc = FOUR_PARAMS_SIZE;
1034 napi_value argv[FOUR_PARAMS_SIZE] = { nullptr };
1035 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1036 if (argc < ARG_COUNT_TWO || !ConvertFromJsValue(env, argv[INDEX_ONE], systemBarEnable)) {
1037 TLOGE(WmsLogTag::WMS_IMMS, "Argc is invalid: %{public}zu or Failed to convert enable parameter to bool", argc);
1038 return false;
1039 }
1040 if (argc >= ARG_COUNT_THREE && !ConvertFromJsValue(env, argv[INDEX_TWO], systemBarEnableAnimation)) {
1041 TLOGE(WmsLogTag::WMS_IMMS, "Failed to convert enableAnimation parameter to bool");
1042 return false;
1043 }
1044 return true;
1045 }
1046
GetColorFromJs(napi_env env,napi_value jsObject,const char * name,uint32_t defaultColor,bool & flag)1047 static uint32_t GetColorFromJs(napi_env env, napi_value jsObject,
1048 const char* name, uint32_t defaultColor, bool& flag)
1049 {
1050 napi_value jsColor = nullptr;
1051 napi_get_named_property(env, jsObject, name, &jsColor);
1052 if (GetType(env, jsColor) != napi_undefined) {
1053 std::string colorStr;
1054 if (!ConvertFromJsValue(env, jsColor, colorStr)) {
1055 WLOGFE("Failed to convert parameter to color");
1056 return defaultColor;
1057 }
1058 std::regex pattern("^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$");
1059 if (!std::regex_match(colorStr, pattern)) {
1060 WLOGFD("Invalid color input");
1061 return defaultColor;
1062 }
1063 std::string color = colorStr.substr(1);
1064 if (color.length() == RGB_LENGTH) {
1065 color = "FF" + color; // ARGB
1066 }
1067 flag = true;
1068 std::stringstream ss;
1069 uint32_t hexColor;
1070 ss << std::hex << color;
1071 ss >> hexColor;
1072 TLOGD(WmsLogTag::DEFAULT, "Origin %{public}s, process %{public}s, final %{public}x",
1073 colorStr.c_str(), color.c_str(), hexColor);
1074 return hexColor;
1075 }
1076 return defaultColor;
1077 }
1078
SetWindowStatusBarContentColor(napi_env env,napi_value jsObject,std::unordered_map<WindowType,SystemBarProperty> & properties,std::unordered_map<WindowType,SystemBarPropertyFlag> & propertyFlags)1079 bool SetWindowStatusBarContentColor(napi_env env, napi_value jsObject,
1080 std::unordered_map<WindowType, SystemBarProperty>& properties,
1081 std::unordered_map<WindowType, SystemBarPropertyFlag>& propertyFlags)
1082 {
1083 auto statusProperty = properties[WindowType::WINDOW_TYPE_STATUS_BAR];
1084 napi_value jsStatusContentColor = nullptr;
1085 napi_get_named_property(env, jsObject, "statusBarContentColor", &jsStatusContentColor);
1086 napi_value jsStatusIcon = nullptr;
1087 napi_get_named_property(env, jsObject, "isStatusBarLightIcon", &jsStatusIcon);
1088 if (GetType(env, jsStatusContentColor) != napi_undefined) {
1089 properties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_ = GetColorFromJs(env,
1090 jsObject, "statusBarContentColor", statusProperty.contentColor_,
1091 propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].contentColorFlag);
1092 } else if (GetType(env, jsStatusIcon) != napi_undefined) {
1093 bool isStatusBarLightIcon;
1094 if (!ConvertFromJsValue(env, jsStatusIcon, isStatusBarLightIcon)) {
1095 TLOGE(WmsLogTag::DEFAULT, "Convert status icon value failed");
1096 return false;
1097 }
1098 if (isStatusBarLightIcon) {
1099 properties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_ = SYSTEM_COLOR_WHITE;
1100 } else {
1101 properties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_ = SYSTEM_COLOR_BLACK;
1102 }
1103 propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].contentColorFlag = true;
1104 }
1105 return true;
1106 }
1107
SetWindowNavigationBarContentColor(napi_env env,napi_value jsObject,std::unordered_map<WindowType,SystemBarProperty> & properties,std::unordered_map<WindowType,SystemBarPropertyFlag> & propertyFlags)1108 bool SetWindowNavigationBarContentColor(napi_env env, napi_value jsObject,
1109 std::unordered_map<WindowType, SystemBarProperty>& properties,
1110 std::unordered_map<WindowType, SystemBarPropertyFlag>& propertyFlags)
1111 {
1112 auto navProperty = properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR];
1113 napi_value jsNavigationContentColor = nullptr;
1114 napi_get_named_property(env, jsObject, "navigationBarContentColor", &jsNavigationContentColor);
1115 napi_value jsNavigationIcon = nullptr;
1116 napi_get_named_property(env, jsObject, "isNavigationBarLightIcon", &jsNavigationIcon);
1117 if (GetType(env, jsNavigationContentColor) != napi_undefined) {
1118 properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].contentColor_ = GetColorFromJs(env,
1119 jsObject, "navigationBarContentColor", navProperty.contentColor_,
1120 propertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_BAR].contentColorFlag);
1121 } else if (GetType(env, jsNavigationIcon) != napi_undefined) {
1122 bool isNavigationBarLightIcon;
1123 if (!ConvertFromJsValue(env, jsNavigationIcon, isNavigationBarLightIcon)) {
1124 TLOGE(WmsLogTag::DEFAULT, "Convert navigation icon value failed");
1125 return false;
1126 }
1127 if (isNavigationBarLightIcon) {
1128 properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].contentColor_ = SYSTEM_COLOR_WHITE;
1129 } else {
1130 properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].contentColor_ = SYSTEM_COLOR_BLACK;
1131 }
1132 propertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_BAR].contentColorFlag = true;
1133 }
1134 return true;
1135 }
1136
GetSystemBarPropertiesFromJs(napi_env env,napi_value jsObject,std::unordered_map<WindowType,SystemBarProperty> & properties,std::unordered_map<WindowType,SystemBarPropertyFlag> & propertyFlags)1137 bool GetSystemBarPropertiesFromJs(napi_env env, napi_value jsObject,
1138 std::unordered_map<WindowType, SystemBarProperty>& properties,
1139 std::unordered_map<WindowType, SystemBarPropertyFlag>& propertyFlags)
1140 {
1141 properties[WindowType::WINDOW_TYPE_STATUS_BAR].backgroundColor_ =
1142 GetColorFromJs(env, jsObject, "statusBarColor",
1143 properties[WindowType::WINDOW_TYPE_STATUS_BAR].backgroundColor_,
1144 propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].backgroundColorFlag);
1145 properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].backgroundColor_ =
1146 GetColorFromJs(env, jsObject, "navigationBarColor",
1147 properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].backgroundColor_,
1148 propertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_BAR].backgroundColorFlag);
1149
1150 if (!SetWindowStatusBarContentColor(env, jsObject, properties, propertyFlags) ||
1151 !SetWindowNavigationBarContentColor(env, jsObject, properties, propertyFlags)) {
1152 return false;
1153 }
1154 bool enableStatusBarAnimation = false;
1155 if (ParseJsValue(jsObject, env, "enableStatusBarAnimation", enableStatusBarAnimation)) {
1156 properties[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_ = enableStatusBarAnimation;
1157 propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimationFlag = true;
1158 }
1159 bool enableNavigationBarAnimation = false;
1160 if (ParseJsValue(jsObject, env, "enableNavigationBarAnimation", enableNavigationBarAnimation)) {
1161 properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enableAnimation_ = enableNavigationBarAnimation;
1162 propertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enableAnimationFlag = true;
1163 }
1164 return true;
1165 }
1166
ConvertJSSystemBarStyleToSystemBarProperties(napi_env env,napi_value jsObject,std::map<WindowType,SystemBarProperty> & properties,std::map<WindowType,SystemBarPropertyFlag> & propertyFlags)1167 void ConvertJSSystemBarStyleToSystemBarProperties(napi_env env, napi_value jsObject,
1168 std::map<WindowType, SystemBarProperty>& properties, std::map<WindowType, SystemBarPropertyFlag>& propertyFlags)
1169 {
1170 properties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_ = GetColorFromJs(env,
1171 jsObject, "statusBarContentColor",
1172 properties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_,
1173 propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].contentColorFlag);
1174 }
1175
ConvertAvoidAreaToJsValue(napi_env env,const AvoidArea & avoidArea,AvoidAreaType type)1176 napi_value ConvertAvoidAreaToJsValue(napi_env env, const AvoidArea& avoidArea, AvoidAreaType type)
1177 {
1178 napi_value objValue = nullptr;
1179 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1180
1181 napi_set_named_property(env, objValue, "visible",
1182 CreateJsValue(env, type == AvoidAreaType::TYPE_CUTOUT ? false : true));
1183 napi_set_named_property(env, objValue, "leftRect", GetRectAndConvertToJsValue(env, avoidArea.leftRect_));
1184 napi_set_named_property(env, objValue, "topRect", GetRectAndConvertToJsValue(env, avoidArea.topRect_));
1185 napi_set_named_property(env, objValue, "rightRect", GetRectAndConvertToJsValue(env, avoidArea.rightRect_));
1186 napi_set_named_property(env, objValue, "bottomRect", GetRectAndConvertToJsValue(env, avoidArea.bottomRect_));
1187 return objValue;
1188 }
1189
GetWindowLimitsAndConvertToJsValue(napi_env env,const WindowLimits & windowLimits)1190 napi_value GetWindowLimitsAndConvertToJsValue(napi_env env, const WindowLimits& windowLimits)
1191 {
1192 napi_value objValue = nullptr;
1193 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1194
1195 napi_set_named_property(env, objValue, "maxWidth", CreateJsValue(env, windowLimits.maxWidth_));
1196 napi_set_named_property(env, objValue, "maxHeight", CreateJsValue(env, windowLimits.maxHeight_));
1197 napi_set_named_property(env, objValue, "minWidth", CreateJsValue(env, windowLimits.minWidth_));
1198 napi_set_named_property(env, objValue, "minHeight", CreateJsValue(env, windowLimits.minHeight_));
1199 return objValue;
1200 }
1201
ConvertTitleButtonAreaToJsValue(napi_env env,const TitleButtonRect & titleButtonRect)1202 napi_value ConvertTitleButtonAreaToJsValue(napi_env env, const TitleButtonRect& titleButtonRect)
1203 {
1204 napi_value objValue = nullptr;
1205 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1206
1207 napi_set_named_property(env, objValue, "right", CreateJsValue(env, titleButtonRect.posX_));
1208 napi_set_named_property(env, objValue, "top", CreateJsValue(env, titleButtonRect.posY_));
1209 napi_set_named_property(env, objValue, "width", CreateJsValue(env, titleButtonRect.width_));
1210 napi_set_named_property(env, objValue, "height", CreateJsValue(env, titleButtonRect.height_));
1211 return objValue;
1212 }
1213
ConvertWindowDensityInfoToJsValue(napi_env env,const WindowDensityInfo & windowDensityInfo)1214 napi_value ConvertWindowDensityInfoToJsValue(napi_env env, const WindowDensityInfo& windowDensityInfo)
1215 {
1216 napi_value objValue = nullptr;
1217 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1218
1219 napi_set_named_property(
1220 env, objValue, "systemDensity", CreateJsValue(env, static_cast<double>(windowDensityInfo.systemDensity)));
1221 napi_set_named_property(
1222 env, objValue, "defaultDensity", CreateJsValue(env, static_cast<double>(windowDensityInfo.defaultDensity)));
1223 napi_set_named_property(
1224 env, objValue, "customDensity", CreateJsValue(env, static_cast<double>(windowDensityInfo.customDensity)));
1225 return objValue;
1226 }
1227
CheckCallingPermission(std::string permission)1228 bool CheckCallingPermission(std::string permission)
1229 {
1230 WLOGD("Permission: %{public}s", permission.c_str());
1231 if (!permission.empty() &&
1232 Security::AccessToken::AccessTokenKit::VerifyAccessToken(IPCSkeleton::GetCallingTokenID(), permission)
1233 != AppExecFwk::Constants::PERMISSION_GRANTED) {
1234 WLOGFE("Permission %{public}s is not granted", permission.c_str());
1235 return false;
1236 }
1237 return true;
1238 }
1239
ParseSystemWindowTypeForApiWindowType(int32_t apiWindowType,WindowType & windowType)1240 bool ParseSystemWindowTypeForApiWindowType(int32_t apiWindowType, WindowType& windowType)
1241 {
1242 if (JS_TO_NATIVE_WINDOW_TYPE_MAP.count(static_cast<ApiWindowType>(apiWindowType)) != 0) {
1243 windowType = JS_TO_NATIVE_WINDOW_TYPE_MAP.at(static_cast<ApiWindowType>(apiWindowType));
1244 if (WindowHelper::IsSystemWindow(windowType)) {
1245 return true;
1246 }
1247 }
1248 return false;
1249 }
1250
GetAPI7Ability(napi_env env,AppExecFwk::Ability * & ability)1251 bool GetAPI7Ability(napi_env env, AppExecFwk::Ability* &ability)
1252 {
1253 napi_value global;
1254 if (napi_get_global(env, &global) != napi_ok) {
1255 WLOGI("Get global failed");
1256 return false;
1257 }
1258 napi_value jsAbility;
1259 napi_status status = napi_get_named_property(env, global, "ability", &jsAbility);
1260 if (status != napi_ok || jsAbility == nullptr) {
1261 WLOGI("Get ability property failed");
1262 return false;
1263 }
1264
1265 if (napi_get_value_external(env, jsAbility, reinterpret_cast<void **>(&ability)) != napi_ok) {
1266 WLOGI("Get ability external failed");
1267 return false;
1268 }
1269 if (ability == nullptr) {
1270 return false;
1271 } else {
1272 WLOGI("Get ability");
1273 }
1274 return true;
1275 }
GetWindowMaskFromJsValue(napi_env env,napi_value jsObject,std::vector<std::vector<uint32_t>> & windowMask)1276 bool GetWindowMaskFromJsValue(napi_env env, napi_value jsObject, std::vector<std::vector<uint32_t>>& windowMask)
1277 {
1278 if (jsObject == nullptr) {
1279 WLOGFE("Failed to convert parameter to window mask");
1280 return false;
1281 }
1282 uint32_t size = 0;
1283 napi_get_array_length(env, jsObject, &size);
1284 for (uint32_t i = 0; i < size; i++) {
1285 std::vector<uint32_t> elementArray;
1286 napi_value getElementValue = nullptr;
1287 napi_get_element(env, jsObject, i, &getElementValue);
1288 if (!ConvertNativeValueToVector(env, getElementValue, elementArray)) {
1289 WLOGFE("Failed to convert parameter to window mask");
1290 return false;
1291 }
1292 windowMask.emplace_back(elementArray);
1293 }
1294 return true;
1295 }
1296
GetMoveConfigurationFromJsValue(napi_env env,napi_value jsObject,MoveConfiguration & moveConfiguration)1297 bool GetMoveConfigurationFromJsValue(napi_env env, napi_value jsObject, MoveConfiguration& moveConfiguration)
1298 {
1299 if (jsObject == nullptr) {
1300 TLOGE(WmsLogTag::WMS_LAYOUT, "jsObject is null");
1301 return false;
1302 }
1303 napi_value jsConfig = nullptr;
1304 napi_get_named_property(env, jsObject, "displayId", &jsConfig);
1305 if (GetType(env, jsConfig) != napi_undefined) {
1306 int64_t displayId = DISPLAY_ID_INVALID;
1307 if (!ConvertFromJsValue(env, jsConfig, displayId)) {
1308 TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert parameter to displayId");
1309 return false;
1310 }
1311 moveConfiguration.displayId = static_cast<DisplayId>(displayId);
1312 }
1313 napi_get_named_property(env, jsObject, "rectAnimationConfig", &jsConfig);
1314 if (GetType(env, jsConfig) != napi_undefined) {
1315 RectAnimationConfig rectAnimationConfig;
1316 if (!ParseRectAnimationConfig(env, jsConfig, rectAnimationConfig)) {
1317 TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert parameter to rectAnimationConfig");
1318 return false;
1319 }
1320 moveConfiguration.rectAnimationConfig = rectAnimationConfig;
1321 }
1322 return true;
1323 }
1324
ParseRectAnimationConfig(napi_env env,napi_value jsObject,RectAnimationConfig & rectAnimationConfig)1325 bool ParseRectAnimationConfig(napi_env env, napi_value jsObject, RectAnimationConfig& rectAnimationConfig)
1326 {
1327 uint32_t duration = 0;
1328 if (ParseJsValue(jsObject, env, "duration", duration)) {
1329 if (duration <= 0) {
1330 TLOGE(WmsLogTag::WMS_LAYOUT, "RectAnimationConfig duration invalid");
1331 return false;
1332 }
1333 rectAnimationConfig.duration = duration;
1334 } else {
1335 TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert object to rectAnimationConfig duration");
1336 return false;
1337 }
1338 double coordinate = 0.0;
1339 if (ParseJsValue(jsObject, env, "x1", coordinate)) {
1340 rectAnimationConfig.x1 = static_cast<float>(std::clamp(coordinate, 0.0, 1.0));
1341 } else {
1342 TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert object to rectAnimationConfig x1");
1343 return false;
1344 }
1345 if (ParseJsValue(jsObject, env, "y1", coordinate)) {
1346 rectAnimationConfig.y1 = static_cast<float>(coordinate);
1347 } else {
1348 TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert object to rectAnimationConfig y1");
1349 return false;
1350 }
1351 if (ParseJsValue(jsObject, env, "x2", coordinate)) {
1352 rectAnimationConfig.x2 = static_cast<float>(std::clamp(coordinate, 0.0, 1.0));
1353 } else {
1354 TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert object to rectAnimationConfig x2");
1355 return false;
1356 }
1357 if (ParseJsValue(jsObject, env, "y2", coordinate)) {
1358 rectAnimationConfig.y2 = static_cast<float>(coordinate);
1359 } else {
1360 TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert object to rectAnimationConfig y2");
1361 return false;
1362 }
1363 return true;
1364 }
1365
ConvertRectFromJsValue(napi_env env,napi_value jsObject,Rect & displayRect)1366 bool ConvertRectFromJsValue(napi_env env, napi_value jsObject, Rect& displayRect)
1367 {
1368 if (!ParseJsValue(jsObject, env, "left", displayRect.posX_)) {
1369 TLOGE(WmsLogTag::WMS_ROTATION, "[NAPI]Failed to convert parameter to posX_");
1370 return false;
1371 }
1372
1373 if (!ParseJsValue(jsObject, env, "top", displayRect.posY_)) {
1374 TLOGE(WmsLogTag::WMS_ROTATION, "[NAPI]Failed to convert parameter to posY_");
1375 return false;
1376 }
1377
1378 if (!ParseJsValue(jsObject, env, "width", displayRect.width_)) {
1379 TLOGE(WmsLogTag::WMS_ROTATION, "[NAPI]Failed to convert parameter to width_");
1380 return false;
1381 }
1382
1383 if (!ParseJsValue(jsObject, env, "height", displayRect.height_)) {
1384 TLOGE(WmsLogTag::WMS_ROTATION, "[NAPI]Failed to convert parameter to height_");
1385 return false;
1386 }
1387 return true;
1388 }
1389
GetRotationResultFromJs(napi_env env,napi_value jsObject,RotationChangeResult & rotationChangeResult)1390 bool GetRotationResultFromJs(napi_env env, napi_value jsObject, RotationChangeResult& rotationChangeResult)
1391 {
1392 napi_value jsRectType = nullptr;
1393 napi_value jsWindowRect = nullptr;
1394 napi_get_named_property(env, jsObject, "rectType", &jsRectType);
1395 napi_get_named_property(env, jsObject, "windowRect", &jsWindowRect);
1396 if (GetType(env, jsRectType) != napi_undefined) {
1397 uint32_t rectType;
1398 if (!ConvertFromJsValue(env, jsRectType, rectType)) {
1399 TLOGE(WmsLogTag::WMS_ROTATION, "[NAPI]Failed to convert parameter to rectType");
1400 return false;
1401 }
1402 rotationChangeResult.rectType_ = static_cast<RectType>(rectType);
1403 } else {
1404 TLOGE(WmsLogTag::WMS_ROTATION, "[NAPI]Failed to get object rectType");
1405 return false;
1406 }
1407 if (GetType(env, jsWindowRect) != napi_undefined) {
1408 Rect windowRect;
1409 if (!ConvertRectFromJsValue(env, jsWindowRect, windowRect)) {
1410 TLOGE(WmsLogTag::WMS_ROTATION, "[NAPI]Failed to convert parameter to windowRect");
1411 return false;
1412 }
1413 rotationChangeResult.windowRect_ = windowRect;
1414 } else {
1415 TLOGE(WmsLogTag::WMS_ROTATION, "[NAPI]Failed to get object windowRect");
1416 return false;
1417 }
1418 return true;
1419 }
1420
ExtensionWindowAttributeInit(napi_env env)1421 napi_value ExtensionWindowAttributeInit(napi_env env)
1422 {
1423 if (env == nullptr) {
1424 TLOGE(WmsLogTag::WMS_UIEXT, "env is nullptr");
1425 return nullptr;
1426 }
1427 napi_value objValue = nullptr;
1428 napi_create_object(env, &objValue);
1429 if (objValue == nullptr) {
1430 TLOGE(WmsLogTag::WMS_UIEXT, "Failed to create object");
1431 return nullptr;
1432 }
1433 napi_set_named_property(env, objValue, "SYSTEM_WINDOW",
1434 CreateJsValue(env, static_cast<int32_t>(ExtensionWindowAttribute::SYSTEM_WINDOW)));
1435 napi_set_named_property(env, objValue, "SUB_WINDOW",
1436 CreateJsValue(env, static_cast<int32_t>(ExtensionWindowAttribute::SUB_WINDOW)));
1437 return objValue;
1438 }
1439
CreateAsyncTask(napi_env env,napi_value lastParam,std::unique_ptr<NapiAsyncTask::ExecuteCallback> && execute,std::unique_ptr<NapiAsyncTask::CompleteCallback> && complete,napi_value * result)1440 std::unique_ptr<NapiAsyncTask> CreateAsyncTask(napi_env env, napi_value lastParam,
1441 std::unique_ptr<NapiAsyncTask::ExecuteCallback>&& execute,
1442 std::unique_ptr<NapiAsyncTask::CompleteCallback>&& complete, napi_value* result)
1443 {
1444 napi_valuetype type = napi_undefined;
1445 napi_typeof(env, lastParam, &type);
1446 if (lastParam == nullptr || type != napi_function) {
1447 napi_deferred nativeDeferred = nullptr;
1448 NAPI_CALL(env, napi_create_promise(env, &nativeDeferred, result));
1449 return std::make_unique<NapiAsyncTask>(nativeDeferred, std::move(execute), std::move(complete));
1450 } else {
1451 napi_get_undefined(env, result);
1452 napi_ref callbackRef = nullptr;
1453 napi_create_reference(env, lastParam, 1, &callbackRef);
1454 return std::make_unique<NapiAsyncTask>(callbackRef, std::move(execute), std::move(complete));
1455 }
1456 }
1457
CreateEmptyAsyncTask(napi_env env,napi_value lastParam,napi_value * result)1458 std::unique_ptr<NapiAsyncTask> CreateEmptyAsyncTask(napi_env env,
1459 napi_value lastParam, napi_value* result)
1460 {
1461 napi_valuetype type = napi_undefined;
1462 napi_typeof(env, lastParam, &type);
1463 if (lastParam == nullptr || type != napi_function) {
1464 napi_deferred nativeDeferred = nullptr;
1465 napi_create_promise(env, &nativeDeferred, result);
1466 return std::make_unique<NapiAsyncTask>(nativeDeferred,
1467 std::unique_ptr<NapiAsyncTask::ExecuteCallback>(),
1468 std::unique_ptr<NapiAsyncTask::CompleteCallback>());
1469 } else {
1470 napi_get_undefined(env, result);
1471 napi_ref callbackRef = nullptr;
1472 napi_create_reference(env, lastParam, 1, &callbackRef);
1473 return std::make_unique<NapiAsyncTask>(callbackRef,
1474 std::unique_ptr<NapiAsyncTask::ExecuteCallback>(),
1475 std::unique_ptr<NapiAsyncTask::CompleteCallback>());
1476 }
1477 }
1478
ModalityTypeInit(napi_env env)1479 napi_value ModalityTypeInit(napi_env env)
1480 {
1481 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
1482 napi_value objValue = nullptr;
1483 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1484
1485 napi_set_named_property(env, objValue, "WINDOW_MODALITY",
1486 CreateJsValue(env, ApiModalityType::WINDOW_MODALITY));
1487 napi_set_named_property(env, objValue, "APPLICATION_MODALITY",
1488 CreateJsValue(env, ApiModalityType::APPLICATION_MODALITY));
1489 return objValue;
1490 }
1491
RotationChangeTypeInit(napi_env env)1492 napi_value RotationChangeTypeInit(napi_env env)
1493 {
1494 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
1495 napi_value objValue = nullptr;
1496 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1497 napi_set_named_property(env, objValue, "WINDOW_WILL_ROTATE",
1498 CreateJsValue(env, static_cast<uint32_t>(RotationChangeType::WINDOW_WILL_ROTATE)));
1499 napi_set_named_property(env, objValue, "WINDOW_DID_ROTATE",
1500 CreateJsValue(env, static_cast<uint32_t>(RotationChangeType::WINDOW_DID_ROTATE)));
1501 return objValue;
1502 }
1503
RectTypeInit(napi_env env)1504 napi_value RectTypeInit(napi_env env)
1505 {
1506 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
1507 napi_value objValue = nullptr;
1508 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1509 napi_set_named_property(env, objValue, "RELATIVE_TO_SCREEN",
1510 CreateJsValue(env, static_cast<uint32_t>(RectType::RELATIVE_TO_SCREEN)));
1511 napi_set_named_property(env, objValue, "RELATIVE_TO_PARENT_WINDOW",
1512 CreateJsValue(env, static_cast<uint32_t>(RectType::RELATIVE_TO_PARENT_WINDOW)));
1513 return objValue;
1514 }
1515
AnimationTypeInit(napi_env env)1516 napi_value AnimationTypeInit(napi_env env)
1517 {
1518 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
1519 napi_value objValue = nullptr;
1520 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1521 napi_set_named_property(env, objValue, "FADE_IN_OUT",
1522 CreateJsValue(env, static_cast<uint32_t>(AnimationType::FADE_IN_OUT)));
1523 napi_set_named_property(env, objValue, "FADE_IN",
1524 CreateJsValue(env, static_cast<uint32_t>(AnimationType::FADE_IN)));
1525 return objValue;
1526 }
1527
WindowTransitionTypeInit(napi_env env)1528 napi_value WindowTransitionTypeInit(napi_env env)
1529 {
1530 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
1531 napi_value objValue = nullptr;
1532 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1533 napi_set_named_property(env, objValue, "DESTROY",
1534 CreateJsValue(env, static_cast<uint32_t>(WindowTransitionType::DESTROY)));
1535 return objValue;
1536 }
1537
WindowAnimationCurveInit(napi_env env)1538 napi_value WindowAnimationCurveInit(napi_env env)
1539 {
1540 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
1541 napi_value objValue = nullptr;
1542 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1543 napi_set_named_property(env, objValue, "LINEAR",
1544 CreateJsValue(env, static_cast<uint32_t>(WindowAnimationCurve::LINEAR)));
1545 napi_set_named_property(env, objValue, "INTERPOLATION_SPRING",
1546 CreateJsValue(env, static_cast<uint32_t>(WindowAnimationCurve::INTERPOLATION_SPRING)));
1547 napi_set_named_property(env, objValue, "CUBIC_BEZIER",
1548 CreateJsValue(env, static_cast<uint32_t>(WindowAnimationCurve::CUBIC_BEZIER)));
1549 return objValue;
1550 }
1551
ParseModalityParam(napi_env env,napi_value jsObject,const sptr<WindowOption> & windowOption)1552 static bool ParseModalityParam(napi_env env, napi_value jsObject, const sptr<WindowOption>& windowOption)
1553 {
1554 bool isModal = false;
1555 if (ParseJsValue(jsObject, env, "isModal", isModal)) {
1556 if (isModal) {
1557 windowOption->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_MODAL);
1558 }
1559 }
1560 bool isTopmost = false;
1561 if (ParseJsValue(jsObject, env, "isTopmost", isTopmost)) {
1562 if (!isModal && isTopmost) {
1563 TLOGE(WmsLogTag::WMS_SUB, "Normal subwindow not support topmost");
1564 return false;
1565 }
1566 windowOption->SetWindowTopmost(isTopmost);
1567 }
1568 ApiModalityType apiModalityType;
1569 if (ParseJsValue(jsObject, env, "modalityType", apiModalityType)) {
1570 if (!isModal) {
1571 TLOGE(WmsLogTag::WMS_SUB, "Normal subwindow not support modalityType");
1572 return false;
1573 }
1574 using T = std::underlying_type_t<ApiModalityType>;
1575 T modalityType = static_cast<T>(apiModalityType);
1576 if (modalityType >= static_cast<T>(ApiModalityType::BEGIN) &&
1577 modalityType <= static_cast<T>(ApiModalityType::END)) {
1578 auto type = JS_TO_NATIVE_MODALITY_TYPE_MAP.at(apiModalityType);
1579 if (type == ModalityType::APPLICATION_MODALITY) {
1580 windowOption->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_APPLICATION_MODAL);
1581 }
1582 } else {
1583 TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to modalityType");
1584 return false;
1585 }
1586 }
1587 TLOGI(WmsLogTag::WMS_SUB, "isModal: %{public}d, isTopmost: %{public}d, WindowFlag: %{public}d",
1588 isModal, isTopmost, windowOption->GetWindowFlags());
1589 return true;
1590 }
1591
ParseRectParam(napi_env env,napi_value jsObject,const sptr<WindowOption> & windowOption)1592 static bool ParseRectParam(napi_env env, napi_value jsObject, const sptr<WindowOption>& windowOption)
1593 {
1594 napi_value windowRect = nullptr;
1595 napi_get_named_property(env, jsObject, "windowRect", &windowRect);
1596 if (windowRect == nullptr || GetType(env, windowRect) != napi_object) {
1597 return true;
1598 }
1599 int32_t width = 0;
1600 if (!ParseJsValue(windowRect, env, "width", width)) {
1601 TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to width");
1602 return false;
1603 }
1604 int32_t height = 0;
1605 if (!ParseJsValue(windowRect, env, "height", height)) {
1606 TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to height");
1607 return false;
1608 }
1609 if (width <= 0 || height <= 0) {
1610 TLOGE(WmsLogTag::WMS_SUB, "width or height should greater than 0!");
1611 return false;
1612 }
1613 int32_t left = 0;
1614 if (!ParseJsValue(windowRect, env, "left", left)) {
1615 TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to left");
1616 return false;
1617 }
1618 int32_t top = 0;
1619 if (!ParseJsValue(windowRect, env, "top", top)) {
1620 TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to top");
1621 return false;
1622 }
1623 Rect rect = { left, top, static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
1624 windowOption->SetWindowRect(rect);
1625 TLOGI(WmsLogTag::WMS_SUB, "windowRect: %{public}s", rect.ToString().c_str());
1626 return true;
1627 }
1628
ParseZLevelParam(napi_env env,napi_value jsObject,const sptr<WindowOption> & windowOption)1629 static bool ParseZLevelParam(napi_env env, napi_value jsObject, const sptr<WindowOption>& windowOption)
1630 {
1631 int32_t zLevel = 0;
1632 bool isModal = false;
1633 if (ParseJsValue(jsObject, env, "zLevel", zLevel)) {
1634 if (zLevel < MINIMUM_Z_LEVEL || zLevel > MAXIMUM_Z_LEVEL) {
1635 TLOGE(WmsLogTag::WMS_SUB, "zLevel value %{public}d exceeds valid range [-10000, 10000]!", zLevel);
1636 return false;
1637 }
1638 if (ParseJsValue(jsObject, env, "isModal", isModal)) {
1639 if (isModal) {
1640 TLOGE(WmsLogTag::WMS_SUB, "modal window not support custom zLevel");
1641 return false;
1642 }
1643 }
1644 windowOption->SetSubWindowZLevel(zLevel);
1645 }
1646 TLOGI(WmsLogTag::WMS_SUB, "zLevel: %{public}d", zLevel);
1647 return true;
1648 }
1649
ParseSubWindowOptions(napi_env env,napi_value jsObject,const sptr<WindowOption> & windowOption)1650 bool ParseSubWindowOptions(napi_env env, napi_value jsObject, const sptr<WindowOption>& windowOption)
1651 {
1652 if (jsObject == nullptr || windowOption == nullptr) {
1653 TLOGE(WmsLogTag::WMS_SUB, "jsObject or windowOption is null");
1654 return false;
1655 }
1656 std::string title;
1657 if (!ParseJsValue(jsObject, env, "title", title)) {
1658 TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to title");
1659 return false;
1660 }
1661 bool decorEnabled = false;
1662 if (!ParseJsValue(jsObject, env, "decorEnabled", decorEnabled)) {
1663 TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to decorEnabled");
1664 return false;
1665 }
1666
1667 bool maximizeSupported = false;
1668 if (!ParseJsValue(jsObject, env, "maximizeSupported", maximizeSupported)) {
1669 TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to maximizeSupported");
1670 }
1671
1672 bool outlineEnabled = false;
1673 if (!ParseJsValue(jsObject, env, "outlineEnabled", outlineEnabled)) {
1674 TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to outlineEnabled");
1675 }
1676
1677 windowOption->SetSubWindowTitle(title);
1678 windowOption->SetSubWindowDecorEnable(decorEnabled);
1679 windowOption->SetSubWindowMaximizeSupported(maximizeSupported);
1680 windowOption->SetSubWindowOutlineEnabled(outlineEnabled);
1681 if (!ParseRectParam(env, jsObject, windowOption)) {
1682 return false;
1683 }
1684 if (!ParseModalityParam(env, jsObject, windowOption)) {
1685 return false;
1686 }
1687 return ParseZLevelParam(env, jsObject, windowOption);
1688 }
1689
ParseShowWindowOptions(napi_env env,napi_value showWindowOptions,bool & focusOnShow)1690 WmErrorCode ParseShowWindowOptions(napi_env env, napi_value showWindowOptions, bool& focusOnShow)
1691 {
1692 napi_value focusOnShowValue = nullptr;
1693 napi_get_named_property(env, showWindowOptions, "focusOnShow", &focusOnShowValue);
1694 if (focusOnShowValue != nullptr) {
1695 if (GetType(env, focusOnShowValue) == napi_undefined) {
1696 focusOnShow = true;
1697 return WmErrorCode::WM_OK;
1698 }
1699 if (GetType(env, focusOnShowValue) != napi_boolean || !ConvertFromJsValue(env, focusOnShowValue, focusOnShow)) {
1700 TLOGE(WmsLogTag::WMS_FOCUS, "failed to convert focusOnShow to boolean");
1701 return WmErrorCode::WM_ERROR_ILLEGAL_PARAM;
1702 }
1703 }
1704 return WmErrorCode::WM_OK;
1705 }
1706
ParseKeyFramePolicy(napi_env env,napi_value jsObject,KeyFramePolicy & keyFramePolicy)1707 bool ParseKeyFramePolicy(napi_env env, napi_value jsObject, KeyFramePolicy& keyFramePolicy)
1708 {
1709 if (jsObject == nullptr) {
1710 TLOGE(WmsLogTag::WMS_LAYOUT_PC, "jsObject is null");
1711 return false;
1712 }
1713 bool enable = false;
1714 if (ParseJsValue(jsObject, env, "enable", enable)) {
1715 keyFramePolicy.dragResizeType_ = enable ? DragResizeType::RESIZE_KEY_FRAME :
1716 DragResizeType::RESIZE_TYPE_UNDEFINED;
1717 } else {
1718 TLOGE(WmsLogTag::WMS_LAYOUT_PC, "Failed to convert parameter to enable");
1719 return false;
1720 }
1721 int32_t data = 0;
1722 if (ParseJsValueOrGetDefault(jsObject, env, "interval", data,
1723 static_cast<int32_t>(keyFramePolicy.interval_)) && data > 0) {
1724 keyFramePolicy.interval_ = static_cast<uint32_t>(data);
1725 } else {
1726 TLOGE(WmsLogTag::WMS_LAYOUT_PC, "Failed to convert parameter to interval");
1727 return false;
1728 }
1729 if (ParseJsValueOrGetDefault(jsObject, env, "distance", data,
1730 static_cast<int32_t>(keyFramePolicy.distance_)) && data >= 0) {
1731 keyFramePolicy.distance_ = static_cast<uint32_t>(data);
1732 } else {
1733 TLOGE(WmsLogTag::WMS_LAYOUT_PC, "Failed to convert parameter to distance");
1734 return false;
1735 }
1736 if (ParseJsValueOrGetDefault(jsObject, env, "animationDuration", data,
1737 static_cast<int32_t>(keyFramePolicy.animationDuration_)) && data >= 0) {
1738 keyFramePolicy.animationDuration_ = static_cast<uint32_t>(data);
1739 } else {
1740 TLOGE(WmsLogTag::WMS_LAYOUT_PC, "Failed to convert parameter to animationDuration");
1741 return false;
1742 }
1743 if (ParseJsValueOrGetDefault(jsObject, env, "animationDelay", data,
1744 static_cast<int32_t>(keyFramePolicy.animationDelay_)) && data >= 0) {
1745 keyFramePolicy.animationDelay_ = static_cast<uint32_t>(data);
1746 } else {
1747 TLOGE(WmsLogTag::WMS_LAYOUT_PC, "Failed to convert parameter to animationDelay");
1748 return false;
1749 }
1750 return true;
1751 }
1752
ConvertKeyFramePolicyToJsValue(napi_env env,const KeyFramePolicy & keyFramePolicy)1753 napi_value ConvertKeyFramePolicyToJsValue(napi_env env, const KeyFramePolicy& keyFramePolicy)
1754 {
1755 napi_value objValue = nullptr;
1756 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1757
1758 napi_set_named_property(
1759 env, objValue, "enable", CreateJsValue(env, keyFramePolicy.enabled()));
1760 napi_set_named_property(
1761 env, objValue, "interval", CreateJsValue(env, keyFramePolicy.interval_));
1762 napi_set_named_property(
1763 env, objValue, "distance", CreateJsValue(env, keyFramePolicy.distance_));
1764 napi_set_named_property(
1765 env, objValue, "animationDuration", CreateJsValue(env, keyFramePolicy.animationDuration_));
1766 napi_set_named_property(
1767 env, objValue, "animationDelay", CreateJsValue(env, keyFramePolicy.animationDelay_));
1768 return objValue;
1769 }
1770
CheckPromise(napi_env env,napi_value promiseObj)1771 bool CheckPromise(napi_env env, napi_value promiseObj)
1772 {
1773 if (promiseObj == nullptr) {
1774 TLOGE(WmsLogTag::WMS_PC, "promiseObj is nullptr");
1775 return false;
1776 }
1777 bool isPromise = false;
1778 napi_is_promise(env, promiseObj, &isPromise);
1779 return isPromise;
1780 }
1781
ResolvedCallback(napi_env env,napi_callback_info info)1782 napi_value ResolvedCallback(napi_env env, napi_callback_info info)
1783 {
1784 size_t argc = FOUR_PARAMS_SIZE;
1785 napi_value argv[FOUR_PARAMS_SIZE] = { nullptr };
1786 void* returnValue = nullptr;
1787 if (napi_get_cb_info(env, info, &argc, argv, nullptr, &returnValue) != napi_ok) {
1788 TLOGE(WmsLogTag::WMS_PC, "Failed to get returnValue");
1789 return nullptr;
1790 }
1791 auto* asyncCallback = static_cast<AsyncCallback*>(returnValue);
1792 if (asyncCallback == nullptr) {
1793 TLOGE(WmsLogTag::WMS_PC, "asyncCallback is nullptr");
1794 return nullptr;
1795 }
1796 if (asyncCallback->resolvedCallback_ != nullptr) {
1797 asyncCallback->resolvedCallback_(env, argc, argv);
1798 } else {
1799 TLOGW(WmsLogTag::WMS_PC, "resolvedCallback is nullptr");
1800 }
1801 returnValue = nullptr;
1802 return nullptr;
1803 }
1804
RejectedCallback(napi_env env,napi_callback_info info)1805 napi_value RejectedCallback(napi_env env, napi_callback_info info)
1806 {
1807 size_t argc = FOUR_PARAMS_SIZE;
1808 napi_value argv[FOUR_PARAMS_SIZE] = { nullptr };
1809 void* returnValue = nullptr;
1810 if (napi_get_cb_info(env, info, &argc, argv, nullptr, &returnValue) != napi_ok) {
1811 TLOGE(WmsLogTag::WMS_PC, "Failed to get returnValue");
1812 return nullptr;
1813 }
1814 auto* asyncCallback = static_cast<AsyncCallback*>(returnValue);
1815 if (asyncCallback == nullptr) {
1816 TLOGE(WmsLogTag::WMS_PC, "asyncCallback is nullptr");
1817 return nullptr;
1818 }
1819 if (asyncCallback->rejectedCallback_ != nullptr) {
1820 asyncCallback->rejectedCallback_(env, argc, argv);
1821 } else {
1822 TLOGW(WmsLogTag::WMS_PC, "rejectedCallback is nullptr");
1823 }
1824 returnValue = nullptr;
1825 return nullptr;
1826 }
1827
CallPromise(napi_env env,napi_value promiseObj,AsyncCallback * asyncCallback)1828 bool CallPromise(napi_env env, napi_value promiseObj, AsyncCallback* asyncCallback)
1829 {
1830 if (!CheckPromise(env, promiseObj)) {
1831 TLOGE(WmsLogTag::WMS_PC, "promiseObj not is promise");
1832 return false;
1833 }
1834
1835 napi_value promiseThen = nullptr;
1836 napi_get_named_property(env, promiseObj, "then", &promiseThen);
1837 if (promiseThen == nullptr) {
1838 TLOGE(WmsLogTag::WMS_PC, "promiseObj then property is nullptr");
1839 return false;
1840 }
1841 if (!NapiIsCallable(env, promiseThen)) {
1842 TLOGE(WmsLogTag::WMS_PC, "promiseThen not is callable");
1843 return false;
1844 }
1845 napi_value resolvedCallback = nullptr;
1846 napi_create_function(env, RESOLVED_CALLBACK.c_str(), RESOLVED_CALLBACK.size(),
1847 ResolvedCallback, asyncCallback, &resolvedCallback);
1848 napi_value thenArgv[] = { resolvedCallback };
1849 napi_call_function(env, promiseObj, promiseThen, ArraySize(thenArgv), thenArgv, nullptr);
1850
1851 napi_value promiseCatch = nullptr;
1852 napi_get_named_property(env, promiseObj, "catch", &promiseCatch);
1853 if (promiseCatch == nullptr) {
1854 TLOGE(WmsLogTag::WMS_PC, "promiseObj catch property is nullptr");
1855 return false;
1856 }
1857 if (!NapiIsCallable(env, promiseCatch)) {
1858 TLOGE(WmsLogTag::WMS_PC, "promiseCatch not is callable");
1859 return false;
1860 }
1861 napi_value rejectedCallback = nullptr;
1862 napi_create_function(env, REJECTED_CALLBACK.c_str(), REJECTED_CALLBACK.size(),
1863 RejectedCallback, asyncCallback, &rejectedCallback);
1864 napi_value catchArgv[] = { rejectedCallback };
1865 napi_call_function(env, promiseObj, promiseCatch, ArraySize(catchArgv), catchArgv, nullptr);
1866
1867 return true;
1868 }
1869
CheckZIndex(int32_t zIndex)1870 bool CheckZIndex(int32_t zIndex)
1871 {
1872 DefaultSpecificZIndex zIndexEnum = static_cast<DefaultSpecificZIndex>(zIndex);
1873 return std::find(DefaultSpecificZIndexList.begin(), DefaultSpecificZIndexList.end(), zIndexEnum) !=
1874 DefaultSpecificZIndexList.end();
1875 }
1876
ParseZIndex(napi_env env,napi_value jsObject,WindowOption & option)1877 bool ParseZIndex(napi_env env, napi_value jsObject, WindowOption& option)
1878 {
1879 if (!WindowHelper::IsDynamicWindow(option.GetWindowType())) {
1880 return true;
1881 }
1882 int32_t zIndex = 0;
1883 if (!ParseJsValue(jsObject, env, "zIndex", zIndex)) {
1884 TLOGE(WmsLogTag::WMS_FOCUS, "parse zIndex failed");
1885 return true;
1886 }
1887 if (!CheckZIndex(zIndex)) {
1888 TLOGE(WmsLogTag::WMS_FOCUS, "check zIndex failed, %{public}d", zIndex);
1889 return true;
1890 }
1891 option.SetZIndex(zIndex);
1892 return true;
1893 }
1894
BuildJsRectChangeOptions(napi_env env,const Rect & rect,RectChangeReason reason)1895 napi_value BuildJsRectChangeOptions(napi_env env, const Rect& rect, RectChangeReason reason)
1896 {
1897 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
1898 napi_value jsRectChangeOptions = nullptr;
1899 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, jsRectChangeOptions);
1900 napi_value jsRect = GetRectAndConvertToJsValue(env, rect);
1901 if (jsRect == nullptr || napi_set_named_property(env, jsRectChangeOptions, "rect", jsRect) != napi_ok) {
1902 TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to set rect");
1903 return nullptr;
1904 }
1905 napi_value jsReason = CreateJsValue(env, reason);
1906 if (jsReason == nullptr || napi_set_named_property(env, jsRectChangeOptions, "reason", jsReason) != napi_ok) {
1907 TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to set rectChangeReason");
1908 return nullptr;
1909 }
1910 return jsRectChangeOptions;
1911 }
1912
BuildJsPosition(napi_env env,const Position & position)1913 napi_value BuildJsPosition(napi_env env, const Position& position)
1914 {
1915 CHECK_NAPI_ENV_RETURN_IF_NULL(env);
1916 napi_value jsPosition = nullptr;
1917 CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, jsPosition);
1918 napi_value jsX = CreateJsValue(env, position.x);
1919 if (jsX == nullptr || napi_set_named_property(env, jsPosition, "x", jsX) != napi_ok) {
1920 TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to set x pos");
1921 return nullptr;
1922 }
1923 napi_value jsY = CreateJsValue(env, position.y);
1924 if (jsY == nullptr || napi_set_named_property(env, jsPosition, "y", jsY) != napi_ok) {
1925 TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to set y pos");
1926 return nullptr;
1927 }
1928 return jsPosition;
1929 }
1930 } // namespace Rosen
1931 } // namespace OHOS