• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 API_VERSION_18 = 18;
41 const std::string RESOLVED_CALLBACK = "resolvedCallback";
42 const std::string REJECTED_CALLBACK = "rejectedCallback";
43 }
44 
WindowTypeInit(napi_env env)45 napi_value WindowTypeInit(napi_env env)
46 {
47     WLOGFD("WindowTypeInit");
48 
49     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
50 
51     napi_value objValue = nullptr;
52     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
53 
54     napi_set_named_property(env, objValue, "TYPE_APP", CreateJsValue(env,
55         static_cast<int32_t>(ApiWindowType::TYPE_APP)));
56     napi_set_named_property(env, objValue, "TYPE_SYSTEM_ALERT", CreateJsValue(env,
57         static_cast<int32_t>(ApiWindowType::TYPE_SYSTEM_ALERT)));
58     napi_set_named_property(env, objValue, "TYPE_INPUT_METHOD", CreateJsValue(env,
59         static_cast<int32_t>(ApiWindowType::TYPE_INPUT_METHOD)));
60     napi_set_named_property(env, objValue, "TYPE_STATUS_BAR", CreateJsValue(env,
61         static_cast<int32_t>(ApiWindowType::TYPE_STATUS_BAR)));
62     napi_set_named_property(env, objValue, "TYPE_PANEL", CreateJsValue(env,
63         static_cast<int32_t>(ApiWindowType::TYPE_PANEL)));
64     napi_set_named_property(env, objValue, "TYPE_KEYGUARD", CreateJsValue(env,
65         static_cast<int32_t>(ApiWindowType::TYPE_KEYGUARD)));
66     napi_set_named_property(env, objValue, "TYPE_VOLUME_OVERLAY", CreateJsValue(env,
67         static_cast<int32_t>(ApiWindowType::TYPE_VOLUME_OVERLAY)));
68     napi_set_named_property(env, objValue, "TYPE_NAVIGATION_BAR", CreateJsValue(env,
69         static_cast<int32_t>(ApiWindowType::TYPE_NAVIGATION_BAR)));
70     napi_set_named_property(env, objValue, "TYPE_FLOAT", CreateJsValue(env,
71         static_cast<int32_t>(ApiWindowType::TYPE_FLOAT)));
72     napi_set_named_property(env, objValue, "TYPE_FLOAT_CAMERA", CreateJsValue(env,
73         static_cast<int32_t>(ApiWindowType::TYPE_FLOAT_CAMERA)));
74     napi_set_named_property(env, objValue, "TYPE_WALLPAPER", CreateJsValue(env,
75         static_cast<int32_t>(ApiWindowType::TYPE_WALLPAPER)));
76     napi_set_named_property(env, objValue, "TYPE_DESKTOP", CreateJsValue(env,
77         static_cast<int32_t>(ApiWindowType::TYPE_DESKTOP)));
78     napi_set_named_property(env, objValue, "TYPE_LAUNCHER_RECENT", CreateJsValue(env,
79         static_cast<int32_t>(ApiWindowType::TYPE_LAUNCHER_RECENT)));
80     napi_set_named_property(env, objValue, "TYPE_LAUNCHER_DOCK", CreateJsValue(env,
81         static_cast<int32_t>(ApiWindowType::TYPE_LAUNCHER_DOCK)));
82     napi_set_named_property(env, objValue, "TYPE_VOICE_INTERACTION", CreateJsValue(env,
83         static_cast<int32_t>(ApiWindowType::TYPE_VOICE_INTERACTION)));
84     napi_set_named_property(env, objValue, "TYPE_DIALOG", CreateJsValue(env,
85         static_cast<int32_t>(ApiWindowType::TYPE_DIALOG)));
86     napi_set_named_property(env, objValue, "TYPE_POINTER", CreateJsValue(env,
87         static_cast<int32_t>(ApiWindowType::TYPE_POINTER)));
88     napi_set_named_property(env, objValue, "TYPE_SCREENSHOT", CreateJsValue(env,
89         static_cast<int32_t>(ApiWindowType::TYPE_SCREENSHOT)));
90     napi_set_named_property(env, objValue, "TYPE_SYSTEM_TOAST", CreateJsValue(env,
91         static_cast<int32_t>(ApiWindowType::TYPE_SYSTEM_TOAST)));
92     napi_set_named_property(env, objValue, "TYPE_DIVIDER", CreateJsValue(env,
93         static_cast<int32_t>(ApiWindowType::TYPE_DIVIDER)));
94     napi_set_named_property(env, objValue, "TYPE_GLOBAL_SEARCH", CreateJsValue(env,
95         static_cast<int32_t>(ApiWindowType::TYPE_GLOBAL_SEARCH)));
96     napi_set_named_property(env, objValue, "TYPE_HANDWRITE", CreateJsValue(env,
97         static_cast<int32_t>(ApiWindowType::TYPE_HANDWRITE)));
98     napi_set_named_property(env, objValue, "TYPE_WALLET_SWIPE_CARD", CreateJsValue(env,
99         static_cast<int32_t>(ApiWindowType::TYPE_WALLET_SWIPE_CARD)));
100     napi_set_named_property(env, objValue, "TYPE_SCREEN_CONTROL", CreateJsValue(env,
101         static_cast<int32_t>(ApiWindowType::TYPE_SCREEN_CONTROL)));
102     napi_set_named_property(env, objValue, "TYPE_FLOAT_NAVIGATION", CreateJsValue(env,
103         static_cast<int32_t>(ApiWindowType::TYPE_FLOAT_NAVIGATION)));
104 
105     return objValue;
106 }
107 
AvoidAreaTypeInit(napi_env env)108 napi_value AvoidAreaTypeInit(napi_env env)
109 {
110     WLOGFD("AvoidAreaTypeInit");
111 
112     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
113 
114     napi_value objValue = nullptr;
115     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
116 
117     napi_set_named_property(env, objValue, "TYPE_SYSTEM", CreateJsValue(env,
118         static_cast<int32_t>(AvoidAreaType::TYPE_SYSTEM)));
119     napi_set_named_property(env, objValue, "TYPE_CUTOUT", CreateJsValue(env,
120         static_cast<int32_t>(AvoidAreaType::TYPE_CUTOUT)));
121     napi_set_named_property(env, objValue, "TYPE_SYSTEM_GESTURE", CreateJsValue(env,
122         static_cast<int32_t>(AvoidAreaType::TYPE_SYSTEM_GESTURE)));
123     napi_set_named_property(env, objValue, "TYPE_KEYBOARD",
124         CreateJsValue(env, static_cast<int32_t>(AvoidAreaType::TYPE_KEYBOARD)));
125     napi_set_named_property(env, objValue, "TYPE_NAVIGATION_INDICATOR",
126         CreateJsValue(env, static_cast<int32_t>(AvoidAreaType::TYPE_NAVIGATION_INDICATOR)));
127     return objValue;
128 }
129 
WindowModeInit(napi_env env)130 napi_value WindowModeInit(napi_env env)
131 {
132     WLOGFD("WindowModeInit");
133 
134     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
135 
136     napi_value objValue = nullptr;
137     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
138 
139     napi_set_named_property(env, objValue, "UNDEFINED", CreateJsValue(env,
140         static_cast<int32_t>(ApiWindowMode::UNDEFINED)));
141     napi_set_named_property(env, objValue, "FULLSCREEN", CreateJsValue(env,
142         static_cast<int32_t>(ApiWindowMode::FULLSCREEN)));
143     napi_set_named_property(env, objValue, "PRIMARY", CreateJsValue(env,
144         static_cast<int32_t>(ApiWindowMode::PRIMARY)));
145     napi_set_named_property(env, objValue, "SECONDARY", CreateJsValue(env,
146         static_cast<int32_t>(ApiWindowMode::SECONDARY)));
147     napi_set_named_property(env, objValue, "FLOATING", CreateJsValue(env,
148         static_cast<int32_t>(ApiWindowMode::FLOATING)));
149     return objValue;
150 }
151 
ColorSpaceInit(napi_env env)152 napi_value ColorSpaceInit(napi_env env)
153 {
154     WLOGFD("ColorSpaceInit");
155 
156     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
157 
158     napi_value objValue = nullptr;
159     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
160 
161     napi_set_named_property(env, objValue, "DEFAULT", CreateJsValue(env,
162         static_cast<int32_t>(ColorSpace::COLOR_SPACE_DEFAULT)));
163     napi_set_named_property(env, objValue, "WIDE_GAMUT", CreateJsValue(env,
164         static_cast<int32_t>(ColorSpace::COLOR_SPACE_WIDE_GAMUT)));
165     return objValue;
166 }
167 
OrientationInit(napi_env env)168 napi_value OrientationInit(napi_env env)
169 {
170     WLOGFD("OrientationInit");
171 
172     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
173 
174     napi_value objValue = nullptr;
175     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
176 
177     napi_set_named_property(env, objValue, "UNSPECIFIED", CreateJsValue(env,
178         static_cast<int32_t>(ApiOrientation::UNSPECIFIED)));
179     napi_set_named_property(env, objValue, "PORTRAIT", CreateJsValue(env,
180         static_cast<int32_t>(ApiOrientation::PORTRAIT)));
181     napi_set_named_property(env, objValue, "LANDSCAPE", CreateJsValue(env,
182         static_cast<int32_t>(ApiOrientation::LANDSCAPE)));
183     napi_set_named_property(env, objValue, "PORTRAIT_INVERTED", CreateJsValue(env,
184         static_cast<int32_t>(ApiOrientation::PORTRAIT_INVERTED)));
185     napi_set_named_property(env, objValue, "LANDSCAPE_INVERTED", CreateJsValue(env,
186         static_cast<int32_t>(ApiOrientation::LANDSCAPE_INVERTED)));
187     napi_set_named_property(env, objValue, "AUTO_ROTATION", CreateJsValue(env,
188         static_cast<int32_t>(ApiOrientation::AUTO_ROTATION)));
189     napi_set_named_property(env, objValue, "AUTO_ROTATION_PORTRAIT", CreateJsValue(env,
190         static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_PORTRAIT)));
191     napi_set_named_property(env, objValue, "AUTO_ROTATION_LANDSCAPE", CreateJsValue(env,
192         static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_LANDSCAPE)));
193     napi_set_named_property(env, objValue, "AUTO_ROTATION_RESTRICTED", CreateJsValue(env,
194         static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_RESTRICTED)));
195     napi_set_named_property(env, objValue, "AUTO_ROTATION_PORTRAIT_RESTRICTED", CreateJsValue(env,
196         static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_PORTRAIT_RESTRICTED)));
197     napi_set_named_property(env, objValue, "AUTO_ROTATION_LANDSCAPE_RESTRICTED", CreateJsValue(env,
198         static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_LANDSCAPE_RESTRICTED)));
199     napi_set_named_property(env, objValue, "LOCKED", CreateJsValue(env,
200         static_cast<int32_t>(ApiOrientation::LOCKED)));
201     napi_set_named_property(env, objValue, "AUTO_ROTATION_UNSPECIFIED", CreateJsValue(env,
202         static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_UNSPECIFIED)));
203     napi_set_named_property(env, objValue, "USER_ROTATION_PORTRAIT", CreateJsValue(env,
204         static_cast<int32_t>(ApiOrientation::USER_ROTATION_PORTRAIT)));
205     napi_set_named_property(env, objValue, "USER_ROTATION_LANDSCAPE", CreateJsValue(env,
206         static_cast<int32_t>(ApiOrientation::USER_ROTATION_LANDSCAPE)));
207     napi_set_named_property(env, objValue, "USER_ROTATION_PORTRAIT_INVERTED", CreateJsValue(env,
208         static_cast<int32_t>(ApiOrientation::USER_ROTATION_PORTRAIT_INVERTED)));
209     napi_set_named_property(env, objValue, "USER_ROTATION_LANDSCAPE_INVERTED", CreateJsValue(env,
210         static_cast<int32_t>(ApiOrientation::USER_ROTATION_LANDSCAPE_INVERTED)));
211     napi_set_named_property(env, objValue, "FOLLOW_DESKTOP", CreateJsValue(env,
212         static_cast<int32_t>(ApiOrientation::FOLLOW_DESKTOP)));
213     return objValue;
214 }
215 
WindowStageEventTypeInit(napi_env env)216 napi_value WindowStageEventTypeInit(napi_env env)
217 {
218     WLOGFD("WindowStageEventTypeInit");
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, "SHOWN", CreateJsValue(env,
226         static_cast<int32_t>(LifeCycleEventType::FOREGROUND)));
227     napi_set_named_property(env, objValue, "ACTIVE", CreateJsValue(env,
228         static_cast<int32_t>(LifeCycleEventType::ACTIVE)));
229     napi_set_named_property(env, objValue, "INACTIVE", CreateJsValue(env,
230         static_cast<int32_t>(LifeCycleEventType::INACTIVE)));
231     napi_set_named_property(env, objValue, "HIDDEN", CreateJsValue(env,
232         static_cast<int32_t>(LifeCycleEventType::BACKGROUND)));
233     napi_set_named_property(env, objValue, "RESUMED", CreateJsValue(env,
234         static_cast<int32_t>(LifeCycleEventType::RESUMED)));
235     napi_set_named_property(env, objValue, "PAUSED", CreateJsValue(env,
236         static_cast<int32_t>(LifeCycleEventType::PAUSED)));
237     return objValue;
238 }
239 
WindowEventTypeInit(napi_env env)240 napi_value WindowEventTypeInit(napi_env env)
241 {
242     WLOGFD("WindowEventTypeInit");
243 
244     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
245 
246     napi_value objValue = nullptr;
247     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
248 
249     napi_set_named_property(env, objValue, "WINDOW_SHOWN", CreateJsValue(env,
250         static_cast<int32_t>(LifeCycleEventType::FOREGROUND)));
251     napi_set_named_property(env, objValue, "WINDOW_ACTIVE", CreateJsValue(env,
252         static_cast<int32_t>(LifeCycleEventType::ACTIVE)));
253     napi_set_named_property(env, objValue, "WINDOW_INACTIVE", CreateJsValue(env,
254         static_cast<int32_t>(LifeCycleEventType::INACTIVE)));
255     napi_set_named_property(env, objValue, "WINDOW_HIDDEN", CreateJsValue(env,
256         static_cast<int32_t>(LifeCycleEventType::BACKGROUND)));
257     napi_set_named_property(env, objValue, "WINDOW_DESTROYED", CreateJsValue(env,
258         static_cast<int32_t>(LifeCycleEventType::DESTROYED)));
259     return objValue;
260 }
261 
WindowLayoutModeInit(napi_env env)262 napi_value WindowLayoutModeInit(napi_env env)
263 {
264     WLOGFD("WindowLayoutModeInit");
265     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
266 
267     napi_value objValue = nullptr;
268     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
269 
270     napi_set_named_property(env, objValue, "WINDOW_LAYOUT_MODE_CASCADE", CreateJsValue(env,
271         static_cast<int32_t>(WindowLayoutMode::CASCADE)));
272     napi_set_named_property(env, objValue, "WINDOW_LAYOUT_MODE_TILE", CreateJsValue(env,
273         static_cast<int32_t>(WindowLayoutMode::TILE)));
274     return objValue;
275 }
276 
BlurStyleInit(napi_env env)277 napi_value BlurStyleInit(napi_env env)
278 {
279     WLOGD("BlurStyleInit");
280     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
281 
282     napi_value objValue = nullptr;
283     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
284 
285     napi_set_named_property(env, objValue, "OFF", CreateJsValue(env,
286         static_cast<int32_t>(WindowBlurStyle::WINDOW_BLUR_OFF)));
287     napi_set_named_property(env, objValue, "THIN", CreateJsValue(env,
288         static_cast<int32_t>(WindowBlurStyle::WINDOW_BLUR_THIN)));
289     napi_set_named_property(env, objValue, "REGULAR", CreateJsValue(env,
290         static_cast<int32_t>(WindowBlurStyle::WINDOW_BLUR_REGULAR)));
291     napi_set_named_property(env, objValue, "THICK", CreateJsValue(env,
292         static_cast<int32_t>(WindowBlurStyle::WINDOW_BLUR_THICK)));
293     return objValue;
294 }
295 
MaximizePresentationInit(napi_env env)296 napi_value MaximizePresentationInit(napi_env env)
297 {
298     WLOGD("MaximizePresentationInit");
299     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
300 
301     napi_value objValue = nullptr;
302     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
303 
304     napi_set_named_property(env, objValue, "FOLLOW_APP_IMMERSIVE_SETTING", CreateJsValue(env,
305         static_cast<int32_t>(MaximizePresentation::FOLLOW_APP_IMMERSIVE_SETTING)));
306     napi_set_named_property(env, objValue, "EXIT_IMMERSIVE", CreateJsValue(env,
307         static_cast<int32_t>(MaximizePresentation::EXIT_IMMERSIVE)));
308     napi_set_named_property(env, objValue, "ENTER_IMMERSIVE", CreateJsValue(env,
309         static_cast<int32_t>(MaximizePresentation::ENTER_IMMERSIVE)));
310     napi_set_named_property(env, objValue, "ENTER_IMMERSIVE_DISABLE_TITLE_AND_DOCK_HOVER", CreateJsValue(env,
311         static_cast<int32_t>(MaximizePresentation::ENTER_IMMERSIVE_DISABLE_TITLE_AND_DOCK_HOVER)));
312     return objValue;
313 }
314 
WindowErrorInit(napi_env env)315 napi_value WindowErrorInit(napi_env env)
316 {
317     WLOGFD("WindowErrorInit");
318     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
319 
320     napi_value objValue = nullptr;
321     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
322 
323     napi_set_named_property(env, objValue, "WM_DO_NOTHING", CreateJsValue(env,
324         static_cast<int32_t>(WMError::WM_DO_NOTHING)));
325     napi_set_named_property(env, objValue, "WM_ERROR_NO_MEM", CreateJsValue(env,
326         static_cast<int32_t>(WMError::WM_ERROR_NO_MEM)));
327     napi_set_named_property(env, objValue, "WM_ERROR_DESTROYED_OBJECT", CreateJsValue(env,
328         static_cast<int32_t>(WMError::WM_ERROR_DESTROYED_OBJECT)));
329     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_WINDOW", CreateJsValue(env,
330         static_cast<int32_t>(WMError::WM_ERROR_INVALID_WINDOW)));
331     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE", CreateJsValue(env,
332         static_cast<int32_t>(WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE)));
333     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_OPERATION", CreateJsValue(env,
334         static_cast<int32_t>(WMError::WM_ERROR_INVALID_OPERATION)));
335     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_PERMISSION", CreateJsValue(env,
336         static_cast<int32_t>(WMError::WM_ERROR_INVALID_PERMISSION)));
337     napi_set_named_property(env, objValue, "WM_ERROR_NO_REMOTE_ANIMATION", CreateJsValue(env,
338         static_cast<int32_t>(WMError::WM_ERROR_NO_REMOTE_ANIMATION)));
339     napi_set_named_property(env, objValue, "WM_ERROR_DEVICE_NOT_SUPPORT", CreateJsValue(env,
340         static_cast<int32_t>(WMError::WM_ERROR_DEVICE_NOT_SUPPORT)));
341     napi_set_named_property(env, objValue, "WM_ERROR_NULLPTR", CreateJsValue(env,
342         static_cast<int32_t>(WMError::WM_ERROR_NULLPTR)));
343     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_TYPE", CreateJsValue(env,
344         static_cast<int32_t>(WMError::WM_ERROR_INVALID_TYPE)));
345     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_PARAM", CreateJsValue(env,
346         static_cast<int32_t>(WMError::WM_ERROR_INVALID_PARAM)));
347     napi_set_named_property(env, objValue, "WM_ERROR_SAMGR", CreateJsValue(env,
348         static_cast<int32_t>(WMError::WM_ERROR_SAMGR)));
349     napi_set_named_property(env, objValue, "WM_ERROR_IPC_FAILED", CreateJsValue(env,
350         static_cast<int32_t>(WMError::WM_ERROR_IPC_FAILED)));
351     napi_set_named_property(env, objValue, "WM_ERROR_START_ABILITY_FAILED", CreateJsValue(env,
352         static_cast<int32_t>(WMError::WM_ERROR_START_ABILITY_FAILED)));
353     return objValue;
354 }
355 
WindowErrorCodeInit(napi_env env)356 napi_value WindowErrorCodeInit(napi_env env)
357 {
358     WLOGFD("WindowErrorCodeInit");
359     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
360 
361     napi_value objValue = nullptr;
362     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
363     napi_set_named_property(env, objValue, "WM_ERROR_NO_PERMISSION", CreateJsValue(env,
364         static_cast<int32_t>(WmErrorCode::WM_ERROR_NO_PERMISSION)));
365     napi_set_named_property(env, objValue, "WM_ERROR_NOT_SYSTEM_APP", CreateJsValue(env,
366         static_cast<int32_t>(WmErrorCode::WM_ERROR_NOT_SYSTEM_APP)));
367     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_PARAM", CreateJsValue(env,
368         static_cast<int32_t>(WmErrorCode::WM_ERROR_INVALID_PARAM)));
369     napi_set_named_property(env, objValue, "WM_ERROR_DEVICE_NOT_SUPPORT", CreateJsValue(env,
370         static_cast<int32_t>(WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT)));
371     napi_set_named_property(env, objValue, "WM_ERROR_REPEAT_OPERATION", CreateJsValue(env,
372         static_cast<int32_t>(WmErrorCode::WM_ERROR_REPEAT_OPERATION)));
373     napi_set_named_property(env, objValue, "WM_ERROR_STATE_ABNORMALLY", CreateJsValue(env,
374         static_cast<int32_t>(WmErrorCode::WM_ERROR_STATE_ABNORMALLY)));
375     napi_set_named_property(env, objValue, "WM_ERROR_SYSTEM_ABNORMALLY", CreateJsValue(env,
376         static_cast<int32_t>(WmErrorCode::WM_ERROR_SYSTEM_ABNORMALLY)));
377     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_CALLING", CreateJsValue(env,
378         static_cast<int32_t>(WmErrorCode::WM_ERROR_INVALID_CALLING)));
379     napi_set_named_property(env, objValue, "WM_ERROR_STAGE_ABNORMALLY", CreateJsValue(env,
380         static_cast<int32_t>(WmErrorCode::WM_ERROR_STAGE_ABNORMALLY)));
381     napi_set_named_property(env, objValue, "WM_ERROR_CONTEXT_ABNORMALLY", CreateJsValue(env,
382         static_cast<int32_t>(WmErrorCode::WM_ERROR_CONTEXT_ABNORMALLY)));
383     napi_set_named_property(env, objValue, "WM_ERROR_START_ABILITY_FAILED", CreateJsValue(env,
384         static_cast<int32_t>(WmErrorCode::WM_ERROR_START_ABILITY_FAILED)));
385     return objValue;
386 }
387 
WindowStatusTypeInit(napi_env env)388 napi_value WindowStatusTypeInit(napi_env env)
389 {
390     WLOGFD("WindowStatusTypeInit");
391     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
392 
393     napi_value objValue = nullptr;
394     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
395     napi_set_named_property(env, objValue, "UNDEFINED", CreateJsValue(env,
396         static_cast<int32_t>(WindowStatus::WINDOW_STATUS_UNDEFINED)));
397     napi_set_named_property(env, objValue, "FULL_SCREEN", CreateJsValue(env,
398         static_cast<int32_t>(WindowStatus::WINDOW_STATUS_FULLSCREEN)));
399     napi_set_named_property(env, objValue, "MAXIMIZE", CreateJsValue(env,
400         static_cast<int32_t>(WindowStatus::WINDOW_STATUS_MAXIMIZE)));
401     napi_set_named_property(env, objValue, "MINIMIZE", CreateJsValue(env,
402         static_cast<int32_t>(WindowStatus::WINDOW_STATUS_MINIMIZE)));
403     napi_set_named_property(env, objValue, "FLOATING", CreateJsValue(env,
404         static_cast<int32_t>(WindowStatus::WINDOW_STATUS_FLOATING)));
405     napi_set_named_property(env, objValue, "SPLIT_SCREEN", CreateJsValue(env,
406         static_cast<int32_t>(WindowStatus::WINDOW_STATUS_SPLITSCREEN)));
407     return objValue;
408 }
409 
RectChangeReasonInit(napi_env env)410 napi_value RectChangeReasonInit(napi_env env)
411 {
412     TLOGD(WmsLogTag::WMS_LAYOUT, "RectChangeReasonInit called");
413 
414     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
415 
416     napi_value objValue = nullptr;
417     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
418 
419     napi_set_named_property(env, objValue, "UNDEFINED",
420         CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::UNDEFINED)));
421     napi_set_named_property(env, objValue, "MAXIMIZE",
422         CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::MAXIMIZE)));
423     napi_set_named_property(env, objValue, "RECOVER",
424         CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::RECOVER)));
425     napi_set_named_property(env, objValue, "MOVE",
426         CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::MOVE)));
427     napi_set_named_property(env, objValue, "DRAG",
428         CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::DRAG)));
429     napi_set_named_property(env, objValue, "DRAG_START",
430         CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::DRAG_START)));
431     napi_set_named_property(env, objValue, "DRAG_END",
432         CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::DRAG_END)));
433     return objValue;
434 }
435 
GetRectAndConvertToJsValue(napi_env env,const Rect & rect)436 napi_value GetRectAndConvertToJsValue(napi_env env, const Rect& rect)
437 {
438     napi_value objValue = nullptr;
439     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
440 
441     napi_set_named_property(env, objValue, "left", CreateJsValue(env, rect.posX_));
442     napi_set_named_property(env, objValue, "top", CreateJsValue(env, rect.posY_));
443     napi_set_named_property(env, objValue, "width", CreateJsValue(env, rect.width_));
444     napi_set_named_property(env, objValue, "height", CreateJsValue(env, rect.height_));
445     return objValue;
446 }
447 
CreateJsWindowPropertiesObject(napi_env env,sptr<Window> & window,const Rect & drawableRect)448 napi_value CreateJsWindowPropertiesObject(napi_env env, sptr<Window>& window, const Rect& drawableRect)
449 {
450     WLOGD("CreateJsWindowPropertiesObject");
451     napi_value objValue = nullptr;
452     if (window == nullptr) {
453         TLOGE(WmsLogTag::WMS_ATTRIBUTE, "window is nullptr.");
454         return objValue;
455     }
456     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
457     Rect windowRect = window->GetRect();
458     napi_value windowRectObj = GetRectAndConvertToJsValue(env, windowRect);
459     if (windowRectObj == nullptr) {
460         TLOGE(WmsLogTag::WMS_ATTRIBUTE, "GetWindowRect failed!");
461     }
462     napi_set_named_property(env, objValue, "windowRect", windowRectObj);
463 
464     napi_value drawableRectObj = GetRectAndConvertToJsValue(env, drawableRect);
465     if (drawableRectObj == nullptr) {
466         TLOGE(WmsLogTag::WMS_ATTRIBUTE, "GetDrawableRect failed!");
467     }
468     napi_set_named_property(env, objValue, "drawableRect", drawableRectObj);
469 
470     WindowType type = window->GetType();
471     uint32_t apiVersion = window->GetApiCompatibleVersion();
472     if (apiVersion < API_VERSION_18 && type == WindowType::WINDOW_TYPE_APP_MAIN_WINDOW) {
473         TLOGI(WmsLogTag::WMS_ATTRIBUTE, "api version %{public}d.", apiVersion);
474         napi_set_named_property(env, objValue, "type", CreateJsValue(env, type));
475     } else if (NATIVE_JS_TO_WINDOW_TYPE_MAP.count(type) != 0) {
476         napi_set_named_property(env, objValue, "type", CreateJsValue(env, NATIVE_JS_TO_WINDOW_TYPE_MAP.at(type)));
477     } else {
478         napi_set_named_property(env, objValue, "type", CreateJsValue(env, type));
479     }
480     napi_set_named_property(env, objValue, "isLayoutFullScreen", CreateJsValue(env, window->IsLayoutFullScreen()));
481     napi_set_named_property(env, objValue, "isFullScreen", CreateJsValue(env, window->IsFullScreen()));
482     napi_set_named_property(env, objValue, "touchable", CreateJsValue(env, window->GetTouchable()));
483     napi_set_named_property(env, objValue, "focusable", CreateJsValue(env, window->GetFocusable()));
484     napi_set_named_property(env, objValue, "name", CreateJsValue(env, window->GetWindowName()));
485     napi_set_named_property(env, objValue, "isPrivacyMode", CreateJsValue(env, window->IsPrivacyMode()));
486     napi_set_named_property(env, objValue, "isKeepScreenOn", CreateJsValue(env, window->IsKeepScreenOn()));
487     napi_set_named_property(env, objValue, "brightness", CreateJsValue(env, window->GetBrightness()));
488     napi_set_named_property(env, objValue, "isTransparent", CreateJsValue(env, window->IsTransparent()));
489     napi_set_named_property(env, objValue, "isRoundCorner", CreateJsValue(env, false)); // empty method
490     napi_set_named_property(env, objValue, "dimBehindValue", CreateJsValue(env, 0));
491     napi_set_named_property(env, objValue, "id", CreateJsValue(env, window->GetWindowId()));
492     napi_set_named_property(env, objValue, "displayId", CreateJsValue(env,
493         static_cast<int64_t>(window->GetDisplayId())));
494     return objValue;
495 }
496 
GetHexColor(uint32_t color)497 static std::string GetHexColor(uint32_t color)
498 {
499     std::stringstream ioss;
500     std::string temp;
501     ioss << std::setiosflags(std::ios::uppercase) << std::hex << color;
502     ioss >> temp;
503     int count = RGBA_LENGTH - static_cast<int>(temp.length());
504     std::string tmpColor(count, '0');
505     tmpColor += temp;
506     std::string finalColor("#");
507     finalColor += tmpColor;
508     return finalColor;
509 }
510 
CreateJsSystemBarPropertiesObject(napi_env env,sptr<Window> & window)511 napi_value CreateJsSystemBarPropertiesObject(napi_env env, sptr<Window>& window)
512 {
513     napi_value objValue = nullptr;
514     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
515 
516     SystemBarProperty status = window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR);
517     SystemBarProperty navi = window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_NAVIGATION_BAR);
518     napi_set_named_property(env, objValue, "statusBarColor",
519         CreateJsValue(env, GetHexColor(status.backgroundColor_)));
520     napi_set_named_property(env, objValue, "statusBarContentColor",
521         CreateJsValue(env, GetHexColor(status.contentColor_)));
522     napi_set_named_property(env, objValue, "isStatusBarLightIcon",
523         CreateJsValue(env, status.contentColor_ == SYSTEM_COLOR_WHITE));
524     napi_set_named_property(env, objValue, "navigationBarColor",
525         CreateJsValue(env, GetHexColor(navi.backgroundColor_)));
526     napi_set_named_property(env, objValue, "navigationBarContentColor",
527         CreateJsValue(env, GetHexColor(navi.contentColor_)));
528     napi_set_named_property(env, objValue, "isNavigationBarLightIcon",
529         CreateJsValue(env, navi.contentColor_ == SYSTEM_COLOR_WHITE));
530     napi_set_named_property(env, objValue, "enableStatusBarAnimation",
531                             CreateJsValue(env, status.enableAnimation_));
532     napi_set_named_property(env, objValue, "enableNavigationBarAnimation",
533                             CreateJsValue(env, navi.enableAnimation_));
534     return objValue;
535 }
536 
CreateJsSystemBarRegionTintObject(napi_env env,const SystemBarRegionTint & tint)537 static napi_value CreateJsSystemBarRegionTintObject(napi_env env, const SystemBarRegionTint& tint)
538 {
539     napi_value objValue = nullptr;
540     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
541 
542     if (NATIVE_JS_TO_WINDOW_TYPE_MAP.count(tint.type_) != 0) {
543         napi_set_named_property(env, objValue, "type", CreateJsValue(env, NATIVE_JS_TO_WINDOW_TYPE_MAP.at(tint.type_)));
544     } else {
545         napi_set_named_property(env, objValue, "type", CreateJsValue(env, tint.type_));
546     }
547     napi_set_named_property(env, objValue, "isEnable", CreateJsValue(env, tint.prop_.enable_));
548     std::string bkgColor = GetHexColor(tint.prop_.backgroundColor_);
549     napi_set_named_property(env, objValue, "backgroundColor", CreateJsValue(env, bkgColor));
550     std::string contentColor = GetHexColor(tint.prop_.contentColor_);
551     napi_set_named_property(env, objValue, "contentColor", CreateJsValue(env, contentColor));
552     Rect rect = tint.region_;
553     napi_set_named_property(env, objValue, "region", GetRectAndConvertToJsValue(env, rect));
554 
555     WLOGFD("Type %{public}u [%{public}u %{public}s %{public}s]",
556         tint.type_, tint.prop_.enable_, bkgColor.c_str(), contentColor.c_str());
557     WLOGFD("Region [%{public}d %{public}d %{public}u %{public}u]",
558         rect.posX_, rect.posY_, rect.width_, rect.height_);
559     return objValue;
560 }
561 
CreateJsWindowLayoutInfoArrayObject(napi_env env,const std::vector<sptr<WindowLayoutInfo>> & infos)562 napi_value CreateJsWindowLayoutInfoArrayObject(napi_env env, const std::vector<sptr<WindowLayoutInfo>>& infos)
563 {
564     napi_value arrayValue = nullptr;
565     napi_create_array_with_length(env, infos.size(), &arrayValue);
566     if (arrayValue == nullptr) {
567         TLOGE(WmsLogTag::WMS_ATTRIBUTE, "arrayValue is null");
568         return nullptr;
569     }
570     for (size_t i = 0; i < infos.size(); i++) {
571         napi_set_element(env, arrayValue, i, CreateJsWindowLayoutInfoObject(env, infos[i]));
572     }
573     return arrayValue;
574 }
575 
CreateJsWindowInfoArrayObject(napi_env env,const std::vector<sptr<WindowVisibilityInfo>> & infos)576 napi_value CreateJsWindowInfoArrayObject(napi_env env, const std::vector<sptr<WindowVisibilityInfo>>& infos)
577 {
578     napi_value arrayValue = nullptr;
579     napi_create_array_with_length(env, infos.size(), &arrayValue);
580     if (arrayValue == nullptr) {
581         WLOGFE("Failed to convert windowVisibilityInfo to jsArrayObject");
582         return nullptr;
583     }
584     uint32_t index = 0;
585     for (size_t i = 0; i < infos.size(); i++) {
586         auto info = infos[i];
587         auto windowType = info->GetWindowType();
588         if (windowType >= WindowType::APP_MAIN_WINDOW_BASE && windowType < WindowType::APP_MAIN_WINDOW_END) {
589             napi_set_element(env, arrayValue, index++, CreateJsWindowInfoObject(env, info));
590         }
591     }
592     return arrayValue;
593 }
594 
CreateJsDecorButtonStyleObj(napi_env env,DecorButtonStyle decorButtonStyle)595 napi_value CreateJsDecorButtonStyleObj(napi_env env, DecorButtonStyle decorButtonStyle)
596 {
597     napi_value objValue = nullptr;
598     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
599     napi_set_named_property(env, objValue, "colorMode", CreateJsValue(env, decorButtonStyle.colorMode));
600     napi_set_named_property(env, objValue, "buttonBackgroundSize",
601         CreateJsValue(env, decorButtonStyle.buttonBackgroundSize));
602     napi_set_named_property(env, objValue, "spacingBetweenButtons",
603         CreateJsValue(env, decorButtonStyle.spacingBetweenButtons));
604     napi_set_named_property(env, objValue, "closeButtonRightMargin",
605         CreateJsValue(env, decorButtonStyle.closeButtonRightMargin));
606     return objValue;
607 }
608 
ConvertDecorButtonStyleFromJs(napi_env env,napi_value jsObject,DecorButtonStyle & style)609 bool ConvertDecorButtonStyleFromJs(napi_env env, napi_value jsObject, DecorButtonStyle& style)
610 {
611     int32_t colorMode;
612     bool emptyParam = true;
613     if (ParseJsValue(jsObject, env, "colorMode", colorMode)) {
614         style.colorMode = colorMode;
615         emptyParam = false;
616     }
617     uint32_t buttonBackgroundSize;
618     if (ParseJsValue(jsObject, env, "buttonBackgroundSize", buttonBackgroundSize)) {
619         style.buttonBackgroundSize = buttonBackgroundSize;
620         emptyParam = false;
621     }
622     uint32_t spacingBetweenButtons;
623     if (ParseJsValue(jsObject, env, "spacingBetweenButtons", spacingBetweenButtons)) {
624         style.spacingBetweenButtons = spacingBetweenButtons;
625         emptyParam = false;
626     }
627     uint32_t closeButtonRightMargin;
628     if (ParseJsValue(jsObject, env, "closeButtonRightMargin", closeButtonRightMargin)) {
629         style.closeButtonRightMargin = closeButtonRightMargin;
630         emptyParam = false;
631     }
632     return !emptyParam;
633 }
634 
CreateJsWindowLayoutInfoObject(napi_env env,const sptr<WindowLayoutInfo> & info)635 napi_value CreateJsWindowLayoutInfoObject(napi_env env, const sptr<WindowLayoutInfo>& info)
636 {
637     napi_value objValue = nullptr;
638     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
639     napi_set_named_property(env, objValue, "rect", GetRectAndConvertToJsValue(env, info->rect));
640     return objValue;
641 }
642 
CreateJsWindowInfoObject(napi_env env,const sptr<WindowVisibilityInfo> & info)643 napi_value CreateJsWindowInfoObject(napi_env env, const sptr<WindowVisibilityInfo>& info)
644 {
645     napi_value objValue = nullptr;
646     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
647     napi_set_named_property(env, objValue, "rect", GetRectAndConvertToJsValue(env, info->GetRect()));
648     napi_set_named_property(env, objValue, "bundleName", CreateJsValue(env, info->GetBundleName()));
649     napi_set_named_property(env, objValue, "abilityName", CreateJsValue(env, info->GetAbilityName()));
650     napi_set_named_property(env, objValue, "windowId", CreateJsValue(env, info->GetWindowId()));
651     napi_set_named_property(env, objValue, "windowStatusType",
652         CreateJsValue(env, static_cast<int32_t>(info->GetWindowStatus())));
653     napi_set_named_property(env, objValue, "isFocused", CreateJsValue(env, info->IsFocused()));
654     return objValue;
655 }
656 
CreateJsSystemBarRegionTintArrayObject(napi_env env,const SystemBarRegionTints & tints)657 napi_value CreateJsSystemBarRegionTintArrayObject(napi_env env, const SystemBarRegionTints& tints)
658 {
659     if (tints.empty()) {
660         WLOGFE("Empty tints");
661         return nullptr;
662     }
663     napi_value objValue = nullptr;
664     napi_create_array_with_length(env, tints.size(), &objValue);
665     napi_value array = objValue;
666     if (array == nullptr) {
667         WLOGFE("Failed to convert SystemBarProperties to jsArrayObject");
668         return nullptr;
669     }
670     uint32_t index = 0;
671     for (size_t i = 0; i < tints.size(); i++) {
672         napi_set_element(env, array, index++, CreateJsSystemBarRegionTintObject(env, tints[i]));
673     }
674     return objValue;
675 }
676 
GetSystemBarStatus(napi_env env,napi_callback_info info,std::unordered_map<WindowType,SystemBarProperty> & systemBarProperties,std::unordered_map<WindowType,SystemBarPropertyFlag> & systemBarpropertyFlags)677 bool GetSystemBarStatus(napi_env env, napi_callback_info info,
678     std::unordered_map<WindowType, SystemBarProperty>& systemBarProperties,
679     std::unordered_map<WindowType, SystemBarPropertyFlag>& systemBarpropertyFlags)
680 {
681     size_t argc = FOUR_PARAMS_SIZE;
682     napi_value argv[FOUR_PARAMS_SIZE] = { nullptr };
683     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
684     uint32_t size = INDEX_ZERO;
685     napi_value nativeArray = nullptr;
686     if (argc > ARG_COUNT_ZERO && GetType(env, argv[INDEX_ZERO]) != napi_function) {
687         nativeArray = argv[INDEX_ZERO];
688         if (nativeArray == nullptr) {
689             TLOGE(WmsLogTag::WMS_IMMS, "Failed to convert parameter to SystemBarArray");
690             return false;
691         }
692         napi_get_array_length(env, nativeArray, &size);
693     }
694     systemBarProperties[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = false;
695     systemBarProperties[WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR].enable_ = false;
696     systemBarProperties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = false;
697     for (uint32_t i = 0; i < size; i++) {
698         std::string name;
699         napi_value getElementValue = nullptr;
700         napi_get_element(env, nativeArray, i, &getElementValue);
701         if (!ConvertFromJsValue(env, getElementValue, name)) {
702             TLOGE(WmsLogTag::WMS_IMMS, "Failed to convert parameter to SystemBarName");
703             return false;
704         }
705         if (name.compare("status") == 0) {
706             systemBarProperties[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
707             systemBarProperties[WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR].enable_ = true;
708         } else if (name.compare("navigation") == 0) {
709             systemBarProperties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = true;
710         }
711     }
712     systemBarpropertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].enableFlag = true;
713     systemBarpropertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enableFlag = true;
714     systemBarpropertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR].enableFlag = true;
715     return true;
716 }
717 
GetStatusBarPropertyObject(napi_env env,sptr<Window> & window)718 napi_value GetStatusBarPropertyObject(napi_env env, sptr<Window>& window)
719 {
720     napi_value objValue = nullptr;
721     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
722 
723     SystemBarProperty statusBarProperty = window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR);
724     napi_set_named_property(env, objValue, "contentColor",
725         CreateJsValue(env, GetHexColor(statusBarProperty.contentColor_)));
726     return objValue;
727 }
728 
CheckTypeForNapiValue(napi_env env,napi_value param,napi_valuetype expectType)729 static bool CheckTypeForNapiValue(napi_env env, napi_value param, napi_valuetype expectType)
730 {
731     napi_valuetype valueType = napi_undefined;
732     if (napi_typeof(env, param, &valueType) != napi_ok) {
733         return false;
734     }
735     return valueType == expectType;
736 }
737 
ParseColorMetrics(napi_env env,napi_value value,uint32_t & colorValue)738 bool ParseColorMetrics(napi_env env, napi_value value, uint32_t& colorValue)
739 {
740     if (!CheckTypeForNapiValue(env, value, napi_object)) {
741         return false;
742     }
743     napi_value jsToNumeric = nullptr;
744     napi_get_named_property(env, value, "toNumeric", &jsToNumeric);
745     if (!CheckTypeForNapiValue(env, jsToNumeric, napi_function)) {
746         return false;
747     }
748     napi_value jsColor;
749     if (napi_call_function(env, value, jsToNumeric, 0, nullptr, &jsColor) != napi_ok) {
750         return false;
751     }
752     if (!CheckTypeForNapiValue(env, jsColor, napi_number)) {
753         return false;
754     }
755     return napi_get_value_uint32(env, jsColor, &colorValue) == napi_ok;
756 }
757 
GetWindowBackgroundColorFromJs(napi_env env,napi_value value,std::string & colorStr)758 bool GetWindowBackgroundColorFromJs(napi_env env, napi_value value, std::string& colorStr)
759 {
760     napi_valuetype valueType = napi_undefined;
761     napi_typeof(env, value, &valueType);
762     if (valueType == napi_string) {
763         return ConvertFromJsValue(env, value, colorStr);
764     }
765     uint32_t colorValue = 0;
766     if (ParseColorMetrics(env, value, colorValue)) {
767         colorStr = GetHexColor(colorValue);
768         return true;
769     }
770     return false;
771 }
772 
ParseAndCheckRect(napi_env env,napi_value jsObject,const Rect & windowRect,Rect & touchableRect)773 bool ParseAndCheckRect(napi_env env, napi_value jsObject,
774     const Rect& windowRect, Rect& touchableRect)
775 {
776     int32_t data = 0;
777     if (ParseJsValue(jsObject, env, "left", data)) {
778         touchableRect.posX_ = data;
779     } else {
780         TLOGE(WmsLogTag::WMS_EVENT, "Failed to convert object:legt");
781         return false;
782     }
783     if (ParseJsValue(jsObject, env, "top", data)) {
784         touchableRect.posY_ = data;
785     } else {
786         TLOGE(WmsLogTag::WMS_EVENT, "Failed to convert object:top");
787         return false;
788     }
789     uint32_t udata = 0;
790     if (ParseJsValue(jsObject, env, "width", udata)) {
791         touchableRect.width_ = udata;
792     } else {
793         TLOGE(WmsLogTag::WMS_EVENT, "Failed to convert object:width");
794         return false;
795     }
796     if (ParseJsValue(jsObject, env, "height", udata)) {
797         touchableRect.height_ = udata;
798     } else {
799         TLOGE(WmsLogTag::WMS_EVENT, "Failed to convert object:height");
800         return false;
801     }
802     if ((touchableRect.posX_ < 0) || (touchableRect.posY_ < 0) ||
803         (touchableRect.posX_ > static_cast<int32_t>(windowRect.width_)) ||
804         (touchableRect.posY_ > static_cast<int32_t>(windowRect.height_)) ||
805         (touchableRect.width_ > (windowRect.width_ - static_cast<uint32_t>(touchableRect.posX_))) ||
806         (touchableRect.height_ > (windowRect.height_ - static_cast<uint32_t>(touchableRect.posY_)))) {
807         TLOGE(WmsLogTag::WMS_EVENT, "Outside the window area, "
808             "touchRect:[%{public}d %{public}d %{public}u %{public}u], "
809             "windowRect:[%{public}d %{public}d %{public}u %{public}u]",
810             touchableRect.posX_, touchableRect.posY_, touchableRect.width_, touchableRect.height_,
811             windowRect.posX_, windowRect.posY_, windowRect.width_, windowRect.height_);
812         return false;
813     }
814     return true;
815 }
816 
ParseTouchableAreas(napi_env env,napi_callback_info info,const Rect & windowRect,std::vector<Rect> & touchableAreas)817 WmErrorCode ParseTouchableAreas(napi_env env, napi_callback_info info,
818     const Rect& windowRect, std::vector<Rect>& touchableAreas)
819 {
820     WmErrorCode errCode = WmErrorCode::WM_ERROR_INVALID_PARAM;
821     size_t argc = 4;
822     napi_value argv[4] = {nullptr};
823     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
824     if (argc != 1) {
825         TLOGE(WmsLogTag::WMS_EVENT, "Argc is invalid:%{public}zu", argc);
826         return errCode;
827     }
828     if (GetType(env, argv[0]) != napi_object) {
829         TLOGE(WmsLogTag::WMS_EVENT, "GetType error");
830         return errCode;
831     }
832     napi_value nativeArray = argv[0];
833     if (nativeArray == nullptr) {
834         TLOGE(WmsLogTag::WMS_EVENT, "Failed to convert parameter");
835         return errCode;
836     }
837     uint32_t size = 0;
838     napi_get_array_length(env, nativeArray, &size);
839     if (size > MAX_TOUCHABLE_AREAS) {
840         TLOGE(WmsLogTag::WMS_EVENT, "Exceeded maximum limit");
841         return errCode;
842     }
843     errCode = WmErrorCode::WM_OK;
844     for (uint32_t i = 0; i < size; i++) {
845         napi_value getElementValue = nullptr;
846         napi_get_element(env, nativeArray, i, &getElementValue);
847         if (getElementValue == nullptr) {
848             TLOGE(WmsLogTag::WMS_EVENT, "Failed to get element");
849             errCode = WmErrorCode::WM_ERROR_INVALID_PARAM;
850             break;
851         }
852         Rect touchableArea;
853         if (ParseAndCheckRect(env, getElementValue, windowRect, touchableArea)) {
854             touchableAreas.emplace_back(touchableArea);
855         } else {
856             errCode = WmErrorCode::WM_ERROR_INVALID_PARAM;
857             break;
858         }
859     }
860     return errCode;
861 }
862 
GetSpecificBarStatus(napi_env env,napi_callback_info info,bool & systemBarEnable,bool & systemBarEnableAnimation)863 bool GetSpecificBarStatus(napi_env env, napi_callback_info info, bool& systemBarEnable, bool& systemBarEnableAnimation)
864 {
865     size_t argc = FOUR_PARAMS_SIZE;
866     napi_value argv[FOUR_PARAMS_SIZE] = { nullptr };
867     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
868     if (argc < ARG_COUNT_TWO || !ConvertFromJsValue(env, argv[INDEX_ONE], systemBarEnable)) {
869         TLOGE(WmsLogTag::WMS_IMMS, "Argc is invalid: %{public}zu or Failed to convert enable parameter to bool", argc);
870         return false;
871     }
872     if (argc >= ARG_COUNT_THREE && !ConvertFromJsValue(env, argv[INDEX_TWO], systemBarEnableAnimation)) {
873         TLOGE(WmsLogTag::WMS_IMMS, "Failed to convert enableAnimation parameter to bool");
874         return false;
875     }
876     return true;
877 }
878 
GetColorFromJs(napi_env env,napi_value jsObject,const char * name,uint32_t defaultColor,bool & flag)879 static uint32_t GetColorFromJs(napi_env env, napi_value jsObject,
880     const char* name, uint32_t defaultColor, bool& flag)
881 {
882     napi_value jsColor = nullptr;
883     napi_get_named_property(env, jsObject, name, &jsColor);
884     if (GetType(env, jsColor) != napi_undefined) {
885         std::string colorStr;
886         if (!ConvertFromJsValue(env, jsColor, colorStr)) {
887             WLOGFE("Failed to convert parameter to color");
888             return defaultColor;
889         }
890         std::regex pattern("^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$");
891         if (!std::regex_match(colorStr, pattern)) {
892             WLOGFD("Invalid color input");
893             return defaultColor;
894         }
895         std::string color = colorStr.substr(1);
896         if (color.length() == RGB_LENGTH) {
897             color = "FF" + color; // ARGB
898         }
899         flag = true;
900         std::stringstream ss;
901         uint32_t hexColor;
902         ss << std::hex << color;
903         ss >> hexColor;
904         TLOGD(WmsLogTag::DEFAULT, "Origin %{public}s, process %{public}s, final %{public}x",
905             colorStr.c_str(), color.c_str(), hexColor);
906         return hexColor;
907     }
908     return defaultColor;
909 }
910 
SetWindowStatusBarContentColor(napi_env env,napi_value jsObject,std::unordered_map<WindowType,SystemBarProperty> & properties,std::unordered_map<WindowType,SystemBarPropertyFlag> & propertyFlags)911 bool SetWindowStatusBarContentColor(napi_env env, napi_value jsObject,
912     std::unordered_map<WindowType, SystemBarProperty>& properties,
913     std::unordered_map<WindowType, SystemBarPropertyFlag>& propertyFlags)
914 {
915     auto statusProperty = properties[WindowType::WINDOW_TYPE_STATUS_BAR];
916     napi_value jsStatusContentColor = nullptr;
917     napi_get_named_property(env, jsObject, "statusBarContentColor", &jsStatusContentColor);
918     napi_value jsStatusIcon = nullptr;
919     napi_get_named_property(env, jsObject, "isStatusBarLightIcon", &jsStatusIcon);
920     if (GetType(env, jsStatusContentColor) != napi_undefined) {
921         properties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_ =  GetColorFromJs(env,
922             jsObject, "statusBarContentColor", statusProperty.contentColor_,
923             propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].contentColorFlag);
924     } else if (GetType(env, jsStatusIcon) != napi_undefined) {
925         bool isStatusBarLightIcon;
926         if (!ConvertFromJsValue(env, jsStatusIcon, isStatusBarLightIcon)) {
927             TLOGE(WmsLogTag::DEFAULT, "Convert status icon value failed");
928             return false;
929         }
930         if (isStatusBarLightIcon) {
931             properties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_ = SYSTEM_COLOR_WHITE;
932         } else {
933             properties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_ = SYSTEM_COLOR_BLACK;
934         }
935         propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].contentColorFlag = true;
936     }
937     return true;
938 }
939 
SetWindowNavigationBarContentColor(napi_env env,napi_value jsObject,std::unordered_map<WindowType,SystemBarProperty> & properties,std::unordered_map<WindowType,SystemBarPropertyFlag> & propertyFlags)940 bool SetWindowNavigationBarContentColor(napi_env env, napi_value jsObject,
941     std::unordered_map<WindowType, SystemBarProperty>& properties,
942     std::unordered_map<WindowType, SystemBarPropertyFlag>& propertyFlags)
943 {
944     auto navProperty = properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR];
945     napi_value jsNavigationContentColor = nullptr;
946     napi_get_named_property(env, jsObject, "navigationBarContentColor", &jsNavigationContentColor);
947     napi_value jsNavigationIcon = nullptr;
948     napi_get_named_property(env, jsObject, "isNavigationBarLightIcon", &jsNavigationIcon);
949     if (GetType(env, jsNavigationContentColor) != napi_undefined) {
950         properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].contentColor_ = GetColorFromJs(env,
951             jsObject, "navigationBarContentColor", navProperty.contentColor_,
952             propertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_BAR].contentColorFlag);
953     } else if (GetType(env, jsNavigationIcon) != napi_undefined) {
954         bool isNavigationBarLightIcon;
955         if (!ConvertFromJsValue(env, jsNavigationIcon, isNavigationBarLightIcon)) {
956             TLOGE(WmsLogTag::DEFAULT, "Convert navigation icon value failed");
957             return false;
958         }
959         if (isNavigationBarLightIcon) {
960             properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].contentColor_ = SYSTEM_COLOR_WHITE;
961         } else {
962             properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].contentColor_ = SYSTEM_COLOR_BLACK;
963         }
964         propertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_BAR].contentColorFlag = true;
965     }
966     return true;
967 }
968 
GetSystemBarPropertiesFromJs(napi_env env,napi_value jsObject,std::unordered_map<WindowType,SystemBarProperty> & properties,std::unordered_map<WindowType,SystemBarPropertyFlag> & propertyFlags)969 bool GetSystemBarPropertiesFromJs(napi_env env, napi_value jsObject,
970     std::unordered_map<WindowType, SystemBarProperty>& properties,
971     std::unordered_map<WindowType, SystemBarPropertyFlag>& propertyFlags)
972 {
973     properties[WindowType::WINDOW_TYPE_STATUS_BAR].backgroundColor_ =
974         GetColorFromJs(env, jsObject, "statusBarColor",
975             properties[WindowType::WINDOW_TYPE_STATUS_BAR].backgroundColor_,
976             propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].backgroundColorFlag);
977     properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].backgroundColor_ =
978         GetColorFromJs(env, jsObject, "navigationBarColor",
979             properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].backgroundColor_,
980             propertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_BAR].backgroundColorFlag);
981 
982     if (!SetWindowStatusBarContentColor(env, jsObject, properties, propertyFlags) ||
983         !SetWindowNavigationBarContentColor(env, jsObject, properties, propertyFlags)) {
984         return false;
985     }
986     bool enableStatusBarAnimation = false;
987     if (ParseJsValue(jsObject, env, "enableStatusBarAnimation", enableStatusBarAnimation)) {
988         properties[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_ = enableStatusBarAnimation;
989         propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimationFlag = true;
990     }
991     bool enableNavigationBarAnimation = false;
992     if (ParseJsValue(jsObject, env, "enableNavigationBarAnimation", enableNavigationBarAnimation)) {
993         properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enableAnimation_ = enableNavigationBarAnimation;
994         propertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enableAnimationFlag = true;
995     }
996     return true;
997 }
998 
ConvertJSSystemBarStyleToSystemBarProperties(napi_env env,napi_value jsObject,std::map<WindowType,SystemBarProperty> & properties,std::map<WindowType,SystemBarPropertyFlag> & propertyFlags)999 void ConvertJSSystemBarStyleToSystemBarProperties(napi_env env, napi_value jsObject,
1000     std::map<WindowType, SystemBarProperty>& properties, std::map<WindowType, SystemBarPropertyFlag>& propertyFlags)
1001 {
1002     properties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_ = GetColorFromJs(env,
1003         jsObject, "statusBarContentColor",
1004         properties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_,
1005         propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].contentColorFlag);
1006 }
1007 
ConvertAvoidAreaToJsValue(napi_env env,const AvoidArea & avoidArea,AvoidAreaType type)1008 napi_value ConvertAvoidAreaToJsValue(napi_env env, const AvoidArea& avoidArea, AvoidAreaType type)
1009 {
1010     napi_value objValue = nullptr;
1011     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1012 
1013     napi_set_named_property(env, objValue, "visible",
1014         CreateJsValue(env, type == AvoidAreaType::TYPE_CUTOUT ? false : true));
1015     napi_set_named_property(env, objValue, "leftRect", GetRectAndConvertToJsValue(env, avoidArea.leftRect_));
1016     napi_set_named_property(env, objValue, "topRect", GetRectAndConvertToJsValue(env, avoidArea.topRect_));
1017     napi_set_named_property(env, objValue, "rightRect", GetRectAndConvertToJsValue(env, avoidArea.rightRect_));
1018     napi_set_named_property(env, objValue, "bottomRect", GetRectAndConvertToJsValue(env, avoidArea.bottomRect_));
1019     return objValue;
1020 }
1021 
GetWindowLimitsAndConvertToJsValue(napi_env env,const WindowLimits & windowLimits)1022 napi_value GetWindowLimitsAndConvertToJsValue(napi_env env, const WindowLimits& windowLimits)
1023 {
1024     napi_value objValue = nullptr;
1025     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1026 
1027     napi_set_named_property(env, objValue, "maxWidth", CreateJsValue(env, windowLimits.maxWidth_));
1028     napi_set_named_property(env, objValue, "maxHeight", CreateJsValue(env, windowLimits.maxHeight_));
1029     napi_set_named_property(env, objValue, "minWidth", CreateJsValue(env, windowLimits.minWidth_));
1030     napi_set_named_property(env, objValue, "minHeight", CreateJsValue(env, windowLimits.minHeight_));
1031     return objValue;
1032 }
1033 
ConvertTitleButtonAreaToJsValue(napi_env env,const TitleButtonRect & titleButtonRect)1034 napi_value ConvertTitleButtonAreaToJsValue(napi_env env, const TitleButtonRect& titleButtonRect)
1035 {
1036     napi_value objValue = nullptr;
1037     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1038 
1039     napi_set_named_property(env, objValue, "right", CreateJsValue(env, titleButtonRect.posX_));
1040     napi_set_named_property(env, objValue, "top", CreateJsValue(env, titleButtonRect.posY_));
1041     napi_set_named_property(env, objValue, "width", CreateJsValue(env, titleButtonRect.width_));
1042     napi_set_named_property(env, objValue, "height", CreateJsValue(env, titleButtonRect.height_));
1043     return objValue;
1044 }
1045 
ConvertWindowDensityInfoToJsValue(napi_env env,const WindowDensityInfo & windowDensityInfo)1046 napi_value ConvertWindowDensityInfoToJsValue(napi_env env, const WindowDensityInfo& windowDensityInfo)
1047 {
1048     napi_value objValue = nullptr;
1049     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1050 
1051     napi_set_named_property(
1052         env, objValue, "systemDensity", CreateJsValue(env, static_cast<double>(windowDensityInfo.systemDensity)));
1053     napi_set_named_property(
1054         env, objValue, "defaultDensity", CreateJsValue(env, static_cast<double>(windowDensityInfo.defaultDensity)));
1055     napi_set_named_property(
1056         env, objValue, "customDensity", CreateJsValue(env, static_cast<double>(windowDensityInfo.customDensity)));
1057     return objValue;
1058 }
1059 
CheckCallingPermission(std::string permission)1060 bool CheckCallingPermission(std::string permission)
1061 {
1062     WLOGD("Permission: %{public}s", permission.c_str());
1063     if (!permission.empty() &&
1064         Security::AccessToken::AccessTokenKit::VerifyAccessToken(IPCSkeleton::GetCallingTokenID(), permission)
1065         != AppExecFwk::Constants::PERMISSION_GRANTED) {
1066         WLOGFE("Permission %{public}s is not granted", permission.c_str());
1067         return false;
1068     }
1069     return true;
1070 }
1071 
ParseSystemWindowTypeForApiWindowType(int32_t apiWindowType,WindowType & windowType)1072 bool ParseSystemWindowTypeForApiWindowType(int32_t apiWindowType, WindowType& windowType)
1073 {
1074     if (JS_TO_NATIVE_WINDOW_TYPE_MAP.count(static_cast<ApiWindowType>(apiWindowType)) != 0) {
1075         windowType = JS_TO_NATIVE_WINDOW_TYPE_MAP.at(static_cast<ApiWindowType>(apiWindowType));
1076         if (WindowHelper::IsSystemWindow(windowType)) {
1077             return true;
1078         }
1079     }
1080     return false;
1081 }
1082 
GetAPI7Ability(napi_env env,AppExecFwk::Ability * & ability)1083 bool GetAPI7Ability(napi_env env, AppExecFwk::Ability* &ability)
1084 {
1085     napi_value global;
1086     if (napi_get_global(env, &global) != napi_ok) {
1087         WLOGI("Get global failed");
1088         return false;
1089     }
1090     napi_value jsAbility;
1091     napi_status status = napi_get_named_property(env, global, "ability", &jsAbility);
1092     if (status != napi_ok || jsAbility == nullptr) {
1093         WLOGI("Get ability property failed");
1094         return false;
1095     }
1096 
1097     if (napi_get_value_external(env, jsAbility, reinterpret_cast<void **>(&ability)) != napi_ok) {
1098         WLOGI("Get ability external failed");
1099         return false;
1100     }
1101     if (ability == nullptr) {
1102         return false;
1103     } else {
1104         WLOGI("Get ability");
1105     }
1106     return true;
1107 }
GetWindowMaskFromJsValue(napi_env env,napi_value jsObject,std::vector<std::vector<uint32_t>> & windowMask)1108 bool GetWindowMaskFromJsValue(napi_env env, napi_value jsObject, std::vector<std::vector<uint32_t>>& windowMask)
1109 {
1110     if (jsObject == nullptr) {
1111         WLOGFE("Failed to convert parameter to window mask");
1112         return false;
1113     }
1114     uint32_t size = 0;
1115     napi_get_array_length(env, jsObject, &size);
1116     for (uint32_t i = 0; i < size; i++) {
1117         std::vector<uint32_t> elementArray;
1118         napi_value getElementValue = nullptr;
1119         napi_get_element(env, jsObject, i, &getElementValue);
1120         if (!ConvertNativeValueToVector(env, getElementValue, elementArray)) {
1121             WLOGFE("Failed to convert parameter to window mask");
1122             return false;
1123         }
1124         windowMask.emplace_back(elementArray);
1125     }
1126     return true;
1127 }
1128 
GetMoveConfigurationFromJsValue(napi_env env,napi_value jsObject,MoveConfiguration & moveConfiguration)1129 bool GetMoveConfigurationFromJsValue(napi_env env, napi_value jsObject, MoveConfiguration& moveConfiguration)
1130 {
1131     if (jsObject == nullptr) {
1132         TLOGE(WmsLogTag::WMS_LAYOUT, "jsObject is null");
1133         return false;
1134     }
1135     napi_value jsConfig = nullptr;
1136     napi_get_named_property(env, jsObject, "displayId", &jsConfig);
1137     if (GetType(env, jsConfig) != napi_undefined) {
1138         int64_t displayId = DISPLAY_ID_INVALID;
1139         if (!ConvertFromJsValue(env, jsConfig, displayId)) {
1140             TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert parameter to displayId");
1141             return false;
1142         }
1143         moveConfiguration.displayId = static_cast<DisplayId>(displayId);
1144     }
1145     napi_get_named_property(env, jsObject, "rectAnimationConfig", &jsConfig);
1146     if (GetType(env, jsConfig) != napi_undefined) {
1147         RectAnimationConfig rectAnimationConfig;
1148         if (!ParseRectAnimationConfig(env, jsConfig, rectAnimationConfig)) {
1149             TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert parameter to rectAnimationConfig");
1150             return false;
1151         }
1152         moveConfiguration.rectAnimationConfig = rectAnimationConfig;
1153     }
1154     return true;
1155 }
1156 
ParseRectAnimationConfig(napi_env env,napi_value jsObject,RectAnimationConfig & rectAnimationConfig)1157 bool ParseRectAnimationConfig(napi_env env, napi_value jsObject, RectAnimationConfig& rectAnimationConfig)
1158 {
1159     uint32_t duration = 0;
1160     if (ParseJsValue(jsObject, env, "duration", duration)) {
1161         if (duration <= 0) {
1162             TLOGE(WmsLogTag::WMS_LAYOUT, "RectAnimationConfig duration invalid");
1163             return false;
1164         }
1165         rectAnimationConfig.duration = duration;
1166     } else {
1167         TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert object to rectAnimationConfig duration");
1168         return false;
1169     }
1170     double coordinate = 0.0;
1171     if (ParseJsValue(jsObject, env, "x1", coordinate)) {
1172         rectAnimationConfig.x1 = static_cast<float>(std::clamp(coordinate, 0.0, 1.0));
1173     } else {
1174         TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert object to rectAnimationConfig x1");
1175         return false;
1176     }
1177     if (ParseJsValue(jsObject, env, "y1", coordinate)) {
1178         rectAnimationConfig.y1 = static_cast<float>(coordinate);
1179     } else {
1180         TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert object to rectAnimationConfig y1");
1181         return false;
1182     }
1183     if (ParseJsValue(jsObject, env, "x2", coordinate)) {
1184         rectAnimationConfig.x2 = static_cast<float>(std::clamp(coordinate, 0.0, 1.0));
1185     } else {
1186         TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert object to rectAnimationConfig x2");
1187         return false;
1188     }
1189     if (ParseJsValue(jsObject, env, "y2", coordinate)) {
1190         rectAnimationConfig.y2 = static_cast<float>(coordinate);
1191     } else {
1192         TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert object to rectAnimationConfig y2");
1193         return false;
1194     }
1195     return true;
1196 }
1197 
ExtensionWindowAttributeInit(napi_env env)1198 napi_value ExtensionWindowAttributeInit(napi_env env)
1199 {
1200     if (env == nullptr) {
1201         TLOGE(WmsLogTag::WMS_UIEXT, "env is nullptr");
1202         return nullptr;
1203     }
1204     napi_value objValue = nullptr;
1205     napi_create_object(env, &objValue);
1206     if (objValue == nullptr) {
1207         TLOGE(WmsLogTag::WMS_UIEXT, "Failed to create object");
1208         return nullptr;
1209     }
1210     napi_set_named_property(env, objValue, "SYSTEM_WINDOW",
1211         CreateJsValue(env, static_cast<int32_t>(ExtensionWindowAttribute::SYSTEM_WINDOW)));
1212     napi_set_named_property(env, objValue, "SUB_WINDOW",
1213         CreateJsValue(env, static_cast<int32_t>(ExtensionWindowAttribute::SUB_WINDOW)));
1214     return objValue;
1215 }
1216 
CreateAsyncTask(napi_env env,napi_value lastParam,std::unique_ptr<NapiAsyncTask::ExecuteCallback> && execute,std::unique_ptr<NapiAsyncTask::CompleteCallback> && complete,napi_value * result)1217 std::unique_ptr<NapiAsyncTask> CreateAsyncTask(napi_env env, napi_value lastParam,
1218     std::unique_ptr<NapiAsyncTask::ExecuteCallback>&& execute,
1219     std::unique_ptr<NapiAsyncTask::CompleteCallback>&& complete, napi_value* result)
1220 {
1221     napi_valuetype type = napi_undefined;
1222     napi_typeof(env, lastParam, &type);
1223     if (lastParam == nullptr || type != napi_function) {
1224         napi_deferred nativeDeferred = nullptr;
1225         NAPI_CALL(env, napi_create_promise(env, &nativeDeferred, result));
1226         return std::make_unique<NapiAsyncTask>(nativeDeferred, std::move(execute), std::move(complete));
1227     } else {
1228         napi_get_undefined(env, result);
1229         napi_ref callbackRef = nullptr;
1230         napi_create_reference(env, lastParam, 1, &callbackRef);
1231         return std::make_unique<NapiAsyncTask>(callbackRef, std::move(execute), std::move(complete));
1232     }
1233 }
1234 
CreateEmptyAsyncTask(napi_env env,napi_value lastParam,napi_value * result)1235 std::unique_ptr<NapiAsyncTask> CreateEmptyAsyncTask(napi_env env,
1236     napi_value lastParam, napi_value* result)
1237 {
1238     napi_valuetype type = napi_undefined;
1239     napi_typeof(env, lastParam, &type);
1240     if (lastParam == nullptr || type != napi_function) {
1241         napi_deferred nativeDeferred = nullptr;
1242         napi_create_promise(env, &nativeDeferred, result);
1243         return std::make_unique<NapiAsyncTask>(nativeDeferred,
1244             std::unique_ptr<NapiAsyncTask::ExecuteCallback>(),
1245             std::unique_ptr<NapiAsyncTask::CompleteCallback>());
1246     } else {
1247         napi_get_undefined(env, result);
1248         napi_ref callbackRef = nullptr;
1249         napi_create_reference(env, lastParam, 1, &callbackRef);
1250         return std::make_unique<NapiAsyncTask>(callbackRef,
1251             std::unique_ptr<NapiAsyncTask::ExecuteCallback>(),
1252             std::unique_ptr<NapiAsyncTask::CompleteCallback>());
1253     }
1254 }
1255 
ModalityTypeInit(napi_env env)1256 napi_value ModalityTypeInit(napi_env env)
1257 {
1258     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
1259     napi_value objValue = nullptr;
1260     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1261 
1262     napi_set_named_property(env, objValue, "WINDOW_MODALITY",
1263         CreateJsValue(env, ApiModalityType::WINDOW_MODALITY));
1264     napi_set_named_property(env, objValue, "APPLICATION_MODALITY",
1265         CreateJsValue(env, ApiModalityType::APPLICATION_MODALITY));
1266     return objValue;
1267 }
1268 
ParseModalityParam(napi_env env,napi_value jsObject,const sptr<WindowOption> & windowOption)1269 static bool ParseModalityParam(napi_env env, napi_value jsObject, const sptr<WindowOption>& windowOption)
1270 {
1271     bool isModal = false;
1272     if (ParseJsValue(jsObject, env, "isModal", isModal)) {
1273         if (isModal) {
1274             windowOption->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_MODAL);
1275         }
1276     }
1277     bool isTopmost = false;
1278     if (ParseJsValue(jsObject, env, "isTopmost", isTopmost)) {
1279         if (!isModal && isTopmost) {
1280             TLOGE(WmsLogTag::WMS_SUB, "Normal subwindow not support topmost");
1281             return false;
1282         }
1283         windowOption->SetWindowTopmost(isTopmost);
1284     }
1285     ApiModalityType apiModalityType;
1286     if (ParseJsValue(jsObject, env, "modalityType", apiModalityType)) {
1287         if (!isModal) {
1288             TLOGE(WmsLogTag::WMS_SUB, "Normal subwindow not support modalityType");
1289             return false;
1290         }
1291         using T = std::underlying_type_t<ApiModalityType>;
1292         T modalityType = static_cast<T>(apiModalityType);
1293         if (modalityType >= static_cast<T>(ApiModalityType::BEGIN) &&
1294             modalityType <= static_cast<T>(ApiModalityType::END)) {
1295             auto type = JS_TO_NATIVE_MODALITY_TYPE_MAP.at(apiModalityType);
1296             if (type == ModalityType::APPLICATION_MODALITY) {
1297                 windowOption->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_APPLICATION_MODAL);
1298             }
1299         } else {
1300             TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to modalityType");
1301             return false;
1302         }
1303     }
1304     TLOGI(WmsLogTag::WMS_SUB, "isModal: %{public}d, isTopmost: %{public}d, WindowFlag: %{public}d",
1305         isModal, isTopmost, windowOption->GetWindowFlags());
1306     return true;
1307 }
1308 
ParseRectParam(napi_env env,napi_value jsObject,const sptr<WindowOption> & windowOption)1309 static bool ParseRectParam(napi_env env, napi_value jsObject, const sptr<WindowOption>& windowOption)
1310 {
1311     napi_value windowRect = nullptr;
1312     napi_get_named_property(env, jsObject, "windowRect", &windowRect);
1313     if (windowRect == nullptr || GetType(env, windowRect) != napi_object) {
1314         return true;
1315     }
1316     int32_t width = 0;
1317     if (!ParseJsValue(windowRect, env, "width", width)) {
1318         TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to width");
1319         return false;
1320     }
1321     int32_t height = 0;
1322     if (!ParseJsValue(windowRect, env, "height", height)) {
1323         TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to height");
1324         return false;
1325     }
1326     if (width <= 0 || height <= 0) {
1327         TLOGE(WmsLogTag::WMS_SUB, "width or height should greater than 0!");
1328         return false;
1329     }
1330     int32_t left = 0;
1331     if (!ParseJsValue(windowRect, env, "left", left)) {
1332         TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to left");
1333         return false;
1334     }
1335     int32_t top = 0;
1336     if (!ParseJsValue(windowRect, env, "top", top)) {
1337         TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to top");
1338         return false;
1339     }
1340     Rect rect = { left, top, static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
1341     windowOption->SetWindowRect(rect);
1342     TLOGI(WmsLogTag::WMS_SUB, "windowRect: %{public}s", rect.ToString().c_str());
1343     return true;
1344 }
1345 
ParseZLevelParam(napi_env env,napi_value jsObject,const sptr<WindowOption> & windowOption)1346 static bool ParseZLevelParam(napi_env env, napi_value jsObject, const sptr<WindowOption>& windowOption)
1347 {
1348     int32_t zLevel = 0;
1349     bool isModal = false;
1350     if (ParseJsValue(jsObject, env, "zLevel", zLevel)) {
1351         if (zLevel < MINIMUM_Z_LEVEL || zLevel > MAXIMUM_Z_LEVEL) {
1352             TLOGE(WmsLogTag::WMS_SUB, "zLevel value %{public}d exceeds valid range [-10000, 10000]!", zLevel);
1353             return false;
1354         }
1355         if (ParseJsValue(jsObject, env, "isModal", isModal)) {
1356             if (isModal) {
1357                 TLOGE(WmsLogTag::WMS_SUB, "modal window not support custom zLevel");
1358                 return false;
1359             }
1360         }
1361         windowOption->SetSubWindowZLevel(zLevel);
1362     }
1363     TLOGI(WmsLogTag::WMS_SUB, "zLevel: %{public}d", zLevel);
1364     return true;
1365 }
1366 
ParseSubWindowOptions(napi_env env,napi_value jsObject,const sptr<WindowOption> & windowOption)1367 bool ParseSubWindowOptions(napi_env env, napi_value jsObject, const sptr<WindowOption>& windowOption)
1368 {
1369     if (jsObject == nullptr || windowOption == nullptr) {
1370         TLOGE(WmsLogTag::WMS_SUB, "jsObject or windowOption is null");
1371         return false;
1372     }
1373     std::string title;
1374     if (!ParseJsValue(jsObject, env, "title", title)) {
1375         TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to title");
1376         return false;
1377     }
1378     bool decorEnabled = false;
1379     if (!ParseJsValue(jsObject, env, "decorEnabled", decorEnabled)) {
1380         TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to decorEnabled");
1381         return false;
1382     }
1383 
1384     bool maximizeSupported = false;
1385     if (!ParseJsValue(jsObject, env, "maximizeSupported", maximizeSupported)) {
1386         TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to maximizeSupported");
1387     }
1388 
1389     windowOption->SetSubWindowTitle(title);
1390     windowOption->SetSubWindowDecorEnable(decorEnabled);
1391     windowOption->SetSubWindowMaximizeSupported(maximizeSupported);
1392     if (!ParseRectParam(env, jsObject, windowOption)) {
1393         return false;
1394     }
1395     if (!ParseModalityParam(env, jsObject, windowOption)) {
1396         return false;
1397     }
1398     return ParseZLevelParam(env, jsObject, windowOption);
1399 }
1400 
CheckPromise(napi_env env,napi_value promiseObj)1401 bool CheckPromise(napi_env env, napi_value promiseObj)
1402 {
1403     if (promiseObj == nullptr) {
1404         TLOGE(WmsLogTag::WMS_PC, "promiseObj is nullptr");
1405         return false;
1406     }
1407     bool isPromise = false;
1408     napi_is_promise(env, promiseObj, &isPromise);
1409     return isPromise;
1410 }
1411 
ResolvedCallback(napi_env env,napi_callback_info info)1412 napi_value ResolvedCallback(napi_env env, napi_callback_info info)
1413 {
1414     size_t argc = FOUR_PARAMS_SIZE;
1415     napi_value argv[FOUR_PARAMS_SIZE] = { nullptr };
1416     void* returnValue = nullptr;
1417     if (napi_get_cb_info(env, info, &argc, argv, nullptr, &returnValue) != napi_ok) {
1418         TLOGE(WmsLogTag::WMS_PC, "Failed to get returnValue");
1419         return nullptr;
1420     }
1421     auto* asyncCallback = static_cast<AsyncCallback*>(returnValue);
1422     if (asyncCallback == nullptr) {
1423         TLOGE(WmsLogTag::WMS_PC, "asyncCallback is nullptr");
1424         return nullptr;
1425     }
1426     if (asyncCallback->resolvedCallback_ != nullptr) {
1427         asyncCallback->resolvedCallback_(env, argc, argv);
1428     } else {
1429         TLOGW(WmsLogTag::WMS_PC, "resolvedCallback is nullptr");
1430     }
1431     returnValue = nullptr;
1432     return nullptr;
1433 }
1434 
RejectedCallback(napi_env env,napi_callback_info info)1435 napi_value RejectedCallback(napi_env env, napi_callback_info info)
1436 {
1437     size_t argc = FOUR_PARAMS_SIZE;
1438     napi_value argv[FOUR_PARAMS_SIZE] = { nullptr };
1439     void* returnValue = nullptr;
1440     if (napi_get_cb_info(env, info, &argc, argv, nullptr, &returnValue) != napi_ok) {
1441         TLOGE(WmsLogTag::WMS_PC, "Failed to get returnValue");
1442         return nullptr;
1443     }
1444     auto* asyncCallback = static_cast<AsyncCallback*>(returnValue);
1445     if (asyncCallback == nullptr) {
1446         TLOGE(WmsLogTag::WMS_PC, "asyncCallback is nullptr");
1447         return nullptr;
1448     }
1449     if (asyncCallback->rejectedCallback_ != nullptr) {
1450         asyncCallback->rejectedCallback_(env, argc, argv);
1451     } else {
1452         TLOGW(WmsLogTag::WMS_PC, "rejectedCallback is nullptr");
1453     }
1454     returnValue = nullptr;
1455     return nullptr;
1456 }
1457 
CallPromise(napi_env env,napi_value promiseObj,AsyncCallback * asyncCallback)1458 bool CallPromise(napi_env env, napi_value promiseObj, AsyncCallback* asyncCallback)
1459 {
1460     if (!CheckPromise(env, promiseObj)) {
1461         TLOGE(WmsLogTag::WMS_PC, "promiseObj not is promise");
1462         return false;
1463     }
1464 
1465     napi_value promiseThen = nullptr;
1466     napi_get_named_property(env, promiseObj, "then", &promiseThen);
1467     if (promiseThen == nullptr) {
1468         TLOGE(WmsLogTag::WMS_PC, "promiseObj then property is nullptr");
1469         return false;
1470     }
1471     if (!NapiIsCallable(env, promiseThen)) {
1472         TLOGE(WmsLogTag::WMS_PC, "promiseThen not is callable");
1473         return false;
1474     }
1475     napi_value resolvedCallback = nullptr;
1476     napi_create_function(env, RESOLVED_CALLBACK.c_str(), RESOLVED_CALLBACK.size(),
1477         ResolvedCallback, asyncCallback, &resolvedCallback);
1478     napi_value thenArgv[] = { resolvedCallback };
1479     napi_call_function(env, promiseObj, promiseThen, ArraySize(thenArgv), thenArgv, nullptr);
1480 
1481     napi_value promiseCatch = nullptr;
1482     napi_get_named_property(env, promiseObj, "catch", &promiseCatch);
1483     if (promiseCatch == nullptr) {
1484         TLOGE(WmsLogTag::WMS_PC, "promiseObj catch property is nullptr");
1485         return false;
1486     }
1487     if (!NapiIsCallable(env, promiseCatch)) {
1488         TLOGE(WmsLogTag::WMS_PC, "promiseCatch not is callable");
1489         return false;
1490     }
1491     napi_value rejectedCallback = nullptr;
1492     napi_create_function(env, REJECTED_CALLBACK.c_str(), REJECTED_CALLBACK.size(),
1493         RejectedCallback, asyncCallback, &rejectedCallback);
1494     napi_value catchArgv[] = { rejectedCallback };
1495     napi_call_function(env, promiseObj, promiseCatch, ArraySize(catchArgv), catchArgv, nullptr);
1496 
1497     return true;
1498 }
1499 } // namespace Rosen
1500 } // namespace OHOS