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 #include "js_window_utils.h"
16 #include <iomanip>
17 #include <regex>
18 #include <sstream>
19 #include "accesstoken_kit.h"
20 #include "bundle_constants.h"
21 #include "ipc_skeleton.h"
22 #include "window_manager_hilog.h"
23 #include "js_window.h"
24 
25 namespace OHOS {
26 namespace Rosen {
27 using namespace AbilityRuntime;
28 namespace {
29 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "JsUtils"};
30 constexpr size_t INDEX_ZERO = 0;
31 constexpr size_t INDEX_ONE = 1;
32 constexpr size_t INDEX_TWO = 2;
33 constexpr size_t FOUR_PARAMS_SIZE = 4;
34 constexpr size_t ARG_COUNT_ZERO = 0;
35 constexpr size_t ARG_COUNT_TWO = 2;
36 constexpr size_t ARG_COUNT_THREE = 3;
37 constexpr int32_t MAX_TOUCHABLE_AREAS = 10;
38 }
39 
WindowTypeInit(napi_env env)40 napi_value WindowTypeInit(napi_env env)
41 {
42     WLOGFD("WindowTypeInit");
43 
44     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
45 
46     napi_value objValue = nullptr;
47     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
48 
49     napi_set_named_property(env, objValue, "TYPE_APP", CreateJsValue(env,
50         static_cast<int32_t>(ApiWindowType::TYPE_APP)));
51     napi_set_named_property(env, objValue, "TYPE_SYSTEM_ALERT", CreateJsValue(env,
52         static_cast<int32_t>(ApiWindowType::TYPE_SYSTEM_ALERT)));
53     napi_set_named_property(env, objValue, "TYPE_INPUT_METHOD", CreateJsValue(env,
54         static_cast<int32_t>(ApiWindowType::TYPE_INPUT_METHOD)));
55     napi_set_named_property(env, objValue, "TYPE_STATUS_BAR", CreateJsValue(env,
56         static_cast<int32_t>(ApiWindowType::TYPE_STATUS_BAR)));
57     napi_set_named_property(env, objValue, "TYPE_PANEL", CreateJsValue(env,
58         static_cast<int32_t>(ApiWindowType::TYPE_PANEL)));
59     napi_set_named_property(env, objValue, "TYPE_KEYGUARD", CreateJsValue(env,
60         static_cast<int32_t>(ApiWindowType::TYPE_KEYGUARD)));
61     napi_set_named_property(env, objValue, "TYPE_VOLUME_OVERLAY", CreateJsValue(env,
62         static_cast<int32_t>(ApiWindowType::TYPE_VOLUME_OVERLAY)));
63     napi_set_named_property(env, objValue, "TYPE_NAVIGATION_BAR", CreateJsValue(env,
64         static_cast<int32_t>(ApiWindowType::TYPE_NAVIGATION_BAR)));
65     napi_set_named_property(env, objValue, "TYPE_FLOAT", CreateJsValue(env,
66         static_cast<int32_t>(ApiWindowType::TYPE_FLOAT)));
67     napi_set_named_property(env, objValue, "TYPE_FLOAT_CAMERA", CreateJsValue(env,
68         static_cast<int32_t>(ApiWindowType::TYPE_FLOAT_CAMERA)));
69     napi_set_named_property(env, objValue, "TYPE_WALLPAPER", CreateJsValue(env,
70         static_cast<int32_t>(ApiWindowType::TYPE_WALLPAPER)));
71     napi_set_named_property(env, objValue, "TYPE_DESKTOP", CreateJsValue(env,
72         static_cast<int32_t>(ApiWindowType::TYPE_DESKTOP)));
73     napi_set_named_property(env, objValue, "TYPE_LAUNCHER_RECENT", CreateJsValue(env,
74         static_cast<int32_t>(ApiWindowType::TYPE_LAUNCHER_RECENT)));
75     napi_set_named_property(env, objValue, "TYPE_LAUNCHER_DOCK", CreateJsValue(env,
76         static_cast<int32_t>(ApiWindowType::TYPE_LAUNCHER_DOCK)));
77     napi_set_named_property(env, objValue, "TYPE_VOICE_INTERACTION", CreateJsValue(env,
78         static_cast<int32_t>(ApiWindowType::TYPE_VOICE_INTERACTION)));
79     napi_set_named_property(env, objValue, "TYPE_DIALOG", CreateJsValue(env,
80         static_cast<int32_t>(ApiWindowType::TYPE_DIALOG)));
81     napi_set_named_property(env, objValue, "TYPE_POINTER", CreateJsValue(env,
82         static_cast<int32_t>(ApiWindowType::TYPE_POINTER)));
83     napi_set_named_property(env, objValue, "TYPE_SCREENSHOT", CreateJsValue(env,
84         static_cast<int32_t>(ApiWindowType::TYPE_SCREENSHOT)));
85     napi_set_named_property(env, objValue, "TYPE_SYSTEM_TOAST", CreateJsValue(env,
86         static_cast<int32_t>(ApiWindowType::TYPE_SYSTEM_TOAST)));
87     napi_set_named_property(env, objValue, "TYPE_DIVIDER", CreateJsValue(env,
88         static_cast<int32_t>(ApiWindowType::TYPE_DIVIDER)));
89     napi_set_named_property(env, objValue, "TYPE_GLOBAL_SEARCH", CreateJsValue(env,
90         static_cast<int32_t>(ApiWindowType::TYPE_GLOBAL_SEARCH)));
91     napi_set_named_property(env, objValue, "TYPE_HANDWRITE", CreateJsValue(env,
92         static_cast<int32_t>(ApiWindowType::TYPE_HANDWRITE)));
93 
94     return objValue;
95 }
96 
AvoidAreaTypeInit(napi_env env)97 napi_value AvoidAreaTypeInit(napi_env env)
98 {
99     WLOGFD("AvoidAreaTypeInit");
100 
101     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
102 
103     napi_value objValue = nullptr;
104     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
105 
106     napi_set_named_property(env, objValue, "TYPE_SYSTEM", CreateJsValue(env,
107         static_cast<int32_t>(AvoidAreaType::TYPE_SYSTEM)));
108     napi_set_named_property(env, objValue, "TYPE_CUTOUT", CreateJsValue(env,
109         static_cast<int32_t>(AvoidAreaType::TYPE_CUTOUT)));
110     napi_set_named_property(env, objValue, "TYPE_SYSTEM_GESTURE", CreateJsValue(env,
111         static_cast<int32_t>(AvoidAreaType::TYPE_SYSTEM_GESTURE)));
112     napi_set_named_property(env, objValue, "TYPE_KEYBOARD",
113         CreateJsValue(env, static_cast<int32_t>(AvoidAreaType::TYPE_KEYBOARD)));
114     napi_set_named_property(env, objValue, "TYPE_NAVIGATION_INDICATOR",
115         CreateJsValue(env, static_cast<int32_t>(AvoidAreaType::TYPE_NAVIGATION_INDICATOR)));
116     return objValue;
117 }
118 
WindowModeInit(napi_env env)119 napi_value WindowModeInit(napi_env env)
120 {
121     WLOGFD("WindowModeInit");
122 
123     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
124 
125     napi_value objValue = nullptr;
126     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
127 
128     napi_set_named_property(env, objValue, "UNDEFINED", CreateJsValue(env,
129         static_cast<int32_t>(ApiWindowMode::UNDEFINED)));
130     napi_set_named_property(env, objValue, "FULLSCREEN", CreateJsValue(env,
131         static_cast<int32_t>(ApiWindowMode::FULLSCREEN)));
132     napi_set_named_property(env, objValue, "PRIMARY", CreateJsValue(env,
133         static_cast<int32_t>(ApiWindowMode::PRIMARY)));
134     napi_set_named_property(env, objValue, "SECONDARY", CreateJsValue(env,
135         static_cast<int32_t>(ApiWindowMode::SECONDARY)));
136     napi_set_named_property(env, objValue, "FLOATING", CreateJsValue(env,
137         static_cast<int32_t>(ApiWindowMode::FLOATING)));
138     return objValue;
139 }
140 
ColorSpaceInit(napi_env env)141 napi_value ColorSpaceInit(napi_env env)
142 {
143     WLOGFD("ColorSpaceInit");
144 
145     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
146 
147     napi_value objValue = nullptr;
148     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
149 
150     napi_set_named_property(env, objValue, "DEFAULT", CreateJsValue(env,
151         static_cast<int32_t>(ColorSpace::COLOR_SPACE_DEFAULT)));
152     napi_set_named_property(env, objValue, "WIDE_GAMUT", CreateJsValue(env,
153         static_cast<int32_t>(ColorSpace::COLOR_SPACE_WIDE_GAMUT)));
154     return objValue;
155 }
156 
OrientationInit(napi_env env)157 napi_value OrientationInit(napi_env env)
158 {
159     WLOGFD("OrientationInit");
160 
161     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
162 
163     napi_value objValue = nullptr;
164     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
165 
166     napi_set_named_property(env, objValue, "UNSPECIFIED", CreateJsValue(env,
167         static_cast<int32_t>(ApiOrientation::UNSPECIFIED)));
168     napi_set_named_property(env, objValue, "PORTRAIT", CreateJsValue(env,
169         static_cast<int32_t>(ApiOrientation::PORTRAIT)));
170     napi_set_named_property(env, objValue, "LANDSCAPE", CreateJsValue(env,
171         static_cast<int32_t>(ApiOrientation::LANDSCAPE)));
172     napi_set_named_property(env, objValue, "PORTRAIT_INVERTED", CreateJsValue(env,
173         static_cast<int32_t>(ApiOrientation::PORTRAIT_INVERTED)));
174     napi_set_named_property(env, objValue, "LANDSCAPE_INVERTED", CreateJsValue(env,
175         static_cast<int32_t>(ApiOrientation::LANDSCAPE_INVERTED)));
176     napi_set_named_property(env, objValue, "AUTO_ROTATION", CreateJsValue(env,
177         static_cast<int32_t>(ApiOrientation::AUTO_ROTATION)));
178     napi_set_named_property(env, objValue, "AUTO_ROTATION_PORTRAIT", CreateJsValue(env,
179         static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_PORTRAIT)));
180     napi_set_named_property(env, objValue, "AUTO_ROTATION_LANDSCAPE", CreateJsValue(env,
181         static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_LANDSCAPE)));
182     napi_set_named_property(env, objValue, "AUTO_ROTATION_RESTRICTED", CreateJsValue(env,
183         static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_RESTRICTED)));
184     napi_set_named_property(env, objValue, "AUTO_ROTATION_PORTRAIT_RESTRICTED", CreateJsValue(env,
185         static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_PORTRAIT_RESTRICTED)));
186     napi_set_named_property(env, objValue, "AUTO_ROTATION_LANDSCAPE_RESTRICTED", CreateJsValue(env,
187         static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_LANDSCAPE_RESTRICTED)));
188     napi_set_named_property(env, objValue, "LOCKED", CreateJsValue(env,
189         static_cast<int32_t>(ApiOrientation::LOCKED)));
190     napi_set_named_property(env, objValue, "AUTO_ROTATION_UNSPECIFIED", CreateJsValue(env,
191         static_cast<int32_t>(ApiOrientation::AUTO_ROTATION_UNSPECIFIED)));
192     napi_set_named_property(env, objValue, "USER_ROTATION_PORTRAIT", CreateJsValue(env,
193         static_cast<int32_t>(ApiOrientation::USER_ROTATION_PORTRAIT)));
194     napi_set_named_property(env, objValue, "USER_ROTATION_LANDSCAPE", CreateJsValue(env,
195         static_cast<int32_t>(ApiOrientation::USER_ROTATION_LANDSCAPE)));
196     napi_set_named_property(env, objValue, "USER_ROTATION_PORTRAIT_INVERTED", CreateJsValue(env,
197         static_cast<int32_t>(ApiOrientation::USER_ROTATION_PORTRAIT_INVERTED)));
198     napi_set_named_property(env, objValue, "USER_ROTATION_LANDSCAPE_INVERTED", CreateJsValue(env,
199         static_cast<int32_t>(ApiOrientation::USER_ROTATION_LANDSCAPE_INVERTED)));
200     napi_set_named_property(env, objValue, "FOLLOW_DESKTOP", CreateJsValue(env,
201         static_cast<int32_t>(ApiOrientation::FOLLOW_DESKTOP)));
202     return objValue;
203 }
204 
WindowStageEventTypeInit(napi_env env)205 napi_value WindowStageEventTypeInit(napi_env env)
206 {
207     WLOGFD("WindowStageEventTypeInit");
208 
209     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
210 
211     napi_value objValue = nullptr;
212     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
213 
214     napi_set_named_property(env, objValue, "SHOWN", CreateJsValue(env,
215         static_cast<int32_t>(LifeCycleEventType::FOREGROUND)));
216     napi_set_named_property(env, objValue, "ACTIVE", CreateJsValue(env,
217         static_cast<int32_t>(LifeCycleEventType::ACTIVE)));
218     napi_set_named_property(env, objValue, "INACTIVE", CreateJsValue(env,
219         static_cast<int32_t>(LifeCycleEventType::INACTIVE)));
220     napi_set_named_property(env, objValue, "HIDDEN", CreateJsValue(env,
221         static_cast<int32_t>(LifeCycleEventType::BACKGROUND)));
222     napi_set_named_property(env, objValue, "RESUMED", CreateJsValue(env,
223         static_cast<int32_t>(LifeCycleEventType::RESUMED)));
224     napi_set_named_property(env, objValue, "PAUSED", CreateJsValue(env,
225         static_cast<int32_t>(LifeCycleEventType::PAUSED)));
226     return objValue;
227 }
228 
WindowEventTypeInit(napi_env env)229 napi_value WindowEventTypeInit(napi_env env)
230 {
231     WLOGFD("WindowEventTypeInit");
232 
233     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
234 
235     napi_value objValue = nullptr;
236     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
237 
238     napi_set_named_property(env, objValue, "WINDOW_SHOWN", CreateJsValue(env,
239         static_cast<int32_t>(LifeCycleEventType::FOREGROUND)));
240     napi_set_named_property(env, objValue, "WINDOW_ACTIVE", CreateJsValue(env,
241         static_cast<int32_t>(LifeCycleEventType::ACTIVE)));
242     napi_set_named_property(env, objValue, "WINDOW_INACTIVE", CreateJsValue(env,
243         static_cast<int32_t>(LifeCycleEventType::INACTIVE)));
244     napi_set_named_property(env, objValue, "WINDOW_HIDDEN", CreateJsValue(env,
245         static_cast<int32_t>(LifeCycleEventType::BACKGROUND)));
246     napi_set_named_property(env, objValue, "WINDOW_DESTROYED", CreateJsValue(env,
247         static_cast<int32_t>(LifeCycleEventType::DESTROYED)));
248     return objValue;
249 }
250 
WindowLayoutModeInit(napi_env env)251 napi_value WindowLayoutModeInit(napi_env env)
252 {
253     WLOGFD("WindowLayoutModeInit");
254     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
255 
256     napi_value objValue = nullptr;
257     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
258 
259     napi_set_named_property(env, objValue, "WINDOW_LAYOUT_MODE_CASCADE", CreateJsValue(env,
260         static_cast<int32_t>(WindowLayoutMode::CASCADE)));
261     napi_set_named_property(env, objValue, "WINDOW_LAYOUT_MODE_TILE", CreateJsValue(env,
262         static_cast<int32_t>(WindowLayoutMode::TILE)));
263     return objValue;
264 }
265 
BlurStyleInit(napi_env env)266 napi_value BlurStyleInit(napi_env env)
267 {
268     WLOGD("BlurStyleInit");
269     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
270 
271     napi_value objValue = nullptr;
272     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
273 
274     napi_set_named_property(env, objValue, "OFF", CreateJsValue(env,
275         static_cast<int32_t>(WindowBlurStyle::WINDOW_BLUR_OFF)));
276     napi_set_named_property(env, objValue, "THIN", CreateJsValue(env,
277         static_cast<int32_t>(WindowBlurStyle::WINDOW_BLUR_THIN)));
278     napi_set_named_property(env, objValue, "REGULAR", CreateJsValue(env,
279         static_cast<int32_t>(WindowBlurStyle::WINDOW_BLUR_REGULAR)));
280     napi_set_named_property(env, objValue, "THICK", CreateJsValue(env,
281         static_cast<int32_t>(WindowBlurStyle::WINDOW_BLUR_THICK)));
282     return objValue;
283 }
284 
MaximizePresentationInit(napi_env env)285 napi_value MaximizePresentationInit(napi_env env)
286 {
287     WLOGD("MaximizePresentationInit");
288     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
289 
290     napi_value objValue = nullptr;
291     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
292 
293     napi_set_named_property(env, objValue, "FOLLOW_APP_IMMERSIVE_SETTING", CreateJsValue(env,
294         static_cast<int32_t>(MaximizePresentation::FOLLOW_APP_IMMERSIVE_SETTING)));
295     napi_set_named_property(env, objValue, "EXIT_IMMERSIVE", CreateJsValue(env,
296         static_cast<int32_t>(MaximizePresentation::EXIT_IMMERSIVE)));
297     napi_set_named_property(env, objValue, "ENTER_IMMERSIVE", CreateJsValue(env,
298         static_cast<int32_t>(MaximizePresentation::ENTER_IMMERSIVE)));
299     napi_set_named_property(env, objValue, "ENTER_IMMERSIVE_DISABLE_TITLE_AND_DOCK_HOVER", CreateJsValue(env,
300         static_cast<int32_t>(MaximizePresentation::ENTER_IMMERSIVE_DISABLE_TITLE_AND_DOCK_HOVER)));
301     return objValue;
302 }
303 
WindowErrorInit(napi_env env)304 napi_value WindowErrorInit(napi_env env)
305 {
306     WLOGFD("WindowErrorInit");
307     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
308 
309     napi_value objValue = nullptr;
310     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
311 
312     napi_set_named_property(env, objValue, "WM_DO_NOTHING", CreateJsValue(env,
313         static_cast<int32_t>(WMError::WM_DO_NOTHING)));
314     napi_set_named_property(env, objValue, "WM_ERROR_NO_MEM", CreateJsValue(env,
315         static_cast<int32_t>(WMError::WM_ERROR_NO_MEM)));
316     napi_set_named_property(env, objValue, "WM_ERROR_DESTROYED_OBJECT", CreateJsValue(env,
317         static_cast<int32_t>(WMError::WM_ERROR_DESTROYED_OBJECT)));
318     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_WINDOW", CreateJsValue(env,
319         static_cast<int32_t>(WMError::WM_ERROR_INVALID_WINDOW)));
320     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE", CreateJsValue(env,
321         static_cast<int32_t>(WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE)));
322     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_OPERATION", CreateJsValue(env,
323         static_cast<int32_t>(WMError::WM_ERROR_INVALID_OPERATION)));
324     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_PERMISSION", CreateJsValue(env,
325         static_cast<int32_t>(WMError::WM_ERROR_INVALID_PERMISSION)));
326     napi_set_named_property(env, objValue, "WM_ERROR_NO_REMOTE_ANIMATION", CreateJsValue(env,
327         static_cast<int32_t>(WMError::WM_ERROR_NO_REMOTE_ANIMATION)));
328     napi_set_named_property(env, objValue, "WM_ERROR_DEVICE_NOT_SUPPORT", CreateJsValue(env,
329         static_cast<int32_t>(WMError::WM_ERROR_DEVICE_NOT_SUPPORT)));
330     napi_set_named_property(env, objValue, "WM_ERROR_NULLPTR", CreateJsValue(env,
331         static_cast<int32_t>(WMError::WM_ERROR_NULLPTR)));
332     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_TYPE", CreateJsValue(env,
333         static_cast<int32_t>(WMError::WM_ERROR_INVALID_TYPE)));
334     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_PARAM", CreateJsValue(env,
335         static_cast<int32_t>(WMError::WM_ERROR_INVALID_PARAM)));
336     napi_set_named_property(env, objValue, "WM_ERROR_SAMGR", CreateJsValue(env,
337         static_cast<int32_t>(WMError::WM_ERROR_SAMGR)));
338     napi_set_named_property(env, objValue, "WM_ERROR_IPC_FAILED", CreateJsValue(env,
339         static_cast<int32_t>(WMError::WM_ERROR_IPC_FAILED)));
340     napi_set_named_property(env, objValue, "WM_ERROR_START_ABILITY_FAILED", CreateJsValue(env,
341         static_cast<int32_t>(WMError::WM_ERROR_START_ABILITY_FAILED)));
342     return objValue;
343 }
344 
WindowErrorCodeInit(napi_env env)345 napi_value WindowErrorCodeInit(napi_env env)
346 {
347     WLOGFD("WindowErrorCodeInit");
348     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
349 
350     napi_value objValue = nullptr;
351     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
352     napi_set_named_property(env, objValue, "WM_ERROR_NO_PERMISSION", CreateJsValue(env,
353         static_cast<int32_t>(WmErrorCode::WM_ERROR_NO_PERMISSION)));
354     napi_set_named_property(env, objValue, "WM_ERROR_NOT_SYSTEM_APP", CreateJsValue(env,
355         static_cast<int32_t>(WmErrorCode::WM_ERROR_NOT_SYSTEM_APP)));
356     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_PARAM", CreateJsValue(env,
357         static_cast<int32_t>(WmErrorCode::WM_ERROR_INVALID_PARAM)));
358     napi_set_named_property(env, objValue, "WM_ERROR_DEVICE_NOT_SUPPORT", CreateJsValue(env,
359         static_cast<int32_t>(WmErrorCode::WM_ERROR_DEVICE_NOT_SUPPORT)));
360     napi_set_named_property(env, objValue, "WM_ERROR_REPEAT_OPERATION", CreateJsValue(env,
361         static_cast<int32_t>(WmErrorCode::WM_ERROR_REPEAT_OPERATION)));
362     napi_set_named_property(env, objValue, "WM_ERROR_STATE_ABNORMALLY", CreateJsValue(env,
363         static_cast<int32_t>(WmErrorCode::WM_ERROR_STATE_ABNORMALLY)));
364     napi_set_named_property(env, objValue, "WM_ERROR_SYSTEM_ABNORMALLY", CreateJsValue(env,
365         static_cast<int32_t>(WmErrorCode::WM_ERROR_SYSTEM_ABNORMALLY)));
366     napi_set_named_property(env, objValue, "WM_ERROR_INVALID_CALLING", CreateJsValue(env,
367         static_cast<int32_t>(WmErrorCode::WM_ERROR_INVALID_CALLING)));
368     napi_set_named_property(env, objValue, "WM_ERROR_STAGE_ABNORMALLY", CreateJsValue(env,
369         static_cast<int32_t>(WmErrorCode::WM_ERROR_STAGE_ABNORMALLY)));
370     napi_set_named_property(env, objValue, "WM_ERROR_CONTEXT_ABNORMALLY", CreateJsValue(env,
371         static_cast<int32_t>(WmErrorCode::WM_ERROR_CONTEXT_ABNORMALLY)));
372     napi_set_named_property(env, objValue, "WM_ERROR_START_ABILITY_FAILED", CreateJsValue(env,
373         static_cast<int32_t>(WmErrorCode::WM_ERROR_START_ABILITY_FAILED)));
374     return objValue;
375 }
376 
WindowStatusTypeInit(napi_env env)377 napi_value WindowStatusTypeInit(napi_env env)
378 {
379     WLOGFD("WindowStatusTypeInit");
380     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
381 
382     napi_value objValue = nullptr;
383     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
384     napi_set_named_property(env, objValue, "UNDEFINED", CreateJsValue(env,
385         static_cast<int32_t>(WindowStatus::WINDOW_STATUS_UNDEFINED)));
386     napi_set_named_property(env, objValue, "FULL_SCREEN", CreateJsValue(env,
387         static_cast<int32_t>(WindowStatus::WINDOW_STATUS_FULLSCREEN)));
388     napi_set_named_property(env, objValue, "MAXIMIZE", CreateJsValue(env,
389         static_cast<int32_t>(WindowStatus::WINDOW_STATUS_MAXIMIZE)));
390     napi_set_named_property(env, objValue, "MINIMIZE", CreateJsValue(env,
391         static_cast<int32_t>(WindowStatus::WINDOW_STATUS_MINIMIZE)));
392     napi_set_named_property(env, objValue, "FLOATING", CreateJsValue(env,
393         static_cast<int32_t>(WindowStatus::WINDOW_STATUS_FLOATING)));
394     napi_set_named_property(env, objValue, "SPLIT_SCREEN", CreateJsValue(env,
395         static_cast<int32_t>(WindowStatus::WINDOW_STATUS_SPLITSCREEN)));
396     return objValue;
397 }
398 
RectChangeReasonInit(napi_env env)399 napi_value RectChangeReasonInit(napi_env env)
400 {
401     TLOGD(WmsLogTag::WMS_LAYOUT, "RectChangeReasonInit called");
402 
403     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
404 
405     napi_value objValue = nullptr;
406     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
407 
408     napi_set_named_property(env, objValue, "UNDEFINED",
409         CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::UNDEFINED)));
410     napi_set_named_property(env, objValue, "MAXIMIZE",
411         CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::MAXIMIZE)));
412     napi_set_named_property(env, objValue, "RECOVER",
413         CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::RECOVER)));
414     napi_set_named_property(env, objValue, "MOVE",
415         CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::MOVE)));
416     napi_set_named_property(env, objValue, "DRAG",
417         CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::DRAG)));
418     napi_set_named_property(env, objValue, "DRAG_START",
419         CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::DRAG_START)));
420     napi_set_named_property(env, objValue, "DRAG_END",
421         CreateJsValue(env, static_cast<uint32_t>(RectChangeReason::DRAG_END)));
422     return objValue;
423 }
424 
GetRectAndConvertToJsValue(napi_env env,const Rect & rect)425 napi_value GetRectAndConvertToJsValue(napi_env env, const Rect& rect)
426 {
427     napi_value objValue = nullptr;
428     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
429 
430     napi_set_named_property(env, objValue, "left", CreateJsValue(env, rect.posX_));
431     napi_set_named_property(env, objValue, "top", CreateJsValue(env, rect.posY_));
432     napi_set_named_property(env, objValue, "width", CreateJsValue(env, rect.width_));
433     napi_set_named_property(env, objValue, "height", CreateJsValue(env, rect.height_));
434     return objValue;
435 }
436 
CreateJsWindowPropertiesObject(napi_env env,sptr<Window> & window,const Rect & drawableRect)437 napi_value CreateJsWindowPropertiesObject(napi_env env, sptr<Window>& window, const Rect& drawableRect)
438 {
439     WLOGD("CreateJsWindowPropertiesObject");
440     napi_value objValue = nullptr;
441     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
442 
443     Rect windowRect = window->GetRect();
444     napi_value windowRectObj = GetRectAndConvertToJsValue(env, windowRect);
445     if (windowRectObj == nullptr) {
446         WLOGFE("GetWindowRect failed!");
447     }
448     napi_set_named_property(env, objValue, "windowRect", windowRectObj);
449 
450     napi_value drawableRectObj = GetRectAndConvertToJsValue(env, drawableRect);
451     if (drawableRectObj == nullptr) {
452         WLOGFE("GetDrawableRect failed!");
453     }
454     napi_set_named_property(env, objValue, "drawableRect", drawableRectObj);
455 
456     WindowType type = window->GetType();
457     if (NATIVE_JS_TO_WINDOW_TYPE_MAP.count(type) != 0) {
458         napi_set_named_property(env, objValue, "type", CreateJsValue(env, NATIVE_JS_TO_WINDOW_TYPE_MAP.at(type)));
459     } else {
460         napi_set_named_property(env, objValue, "type", CreateJsValue(env, type));
461     }
462     napi_set_named_property(env, objValue, "isLayoutFullScreen", CreateJsValue(env, window->IsLayoutFullScreen()));
463     napi_set_named_property(env, objValue, "isFullScreen", CreateJsValue(env, window->IsFullScreen()));
464     napi_set_named_property(env, objValue, "touchable", CreateJsValue(env, window->GetTouchable()));
465     napi_set_named_property(env, objValue, "focusable", CreateJsValue(env, window->GetFocusable()));
466     napi_set_named_property(env, objValue, "name", CreateJsValue(env, window->GetWindowName()));
467     napi_set_named_property(env, objValue, "isPrivacyMode", CreateJsValue(env, window->IsPrivacyMode()));
468     napi_set_named_property(env, objValue, "isKeepScreenOn", CreateJsValue(env, window->IsKeepScreenOn()));
469     napi_set_named_property(env, objValue, "brightness", CreateJsValue(env, window->GetBrightness()));
470     napi_set_named_property(env, objValue, "isTransparent", CreateJsValue(env, window->IsTransparent()));
471     napi_set_named_property(env, objValue, "isRoundCorner", CreateJsValue(env, false)); // empty method
472     napi_set_named_property(env, objValue, "dimBehindValue", CreateJsValue(env, 0));
473     napi_set_named_property(env, objValue, "id", CreateJsValue(env, window->GetWindowId()));
474     napi_set_named_property(env, objValue, "displayId", CreateJsValue(env,
475         static_cast<int64_t>(window->GetDisplayId())));
476     return objValue;
477 }
478 
GetHexColor(uint32_t color)479 static std::string GetHexColor(uint32_t color)
480 {
481     std::stringstream ioss;
482     std::string temp;
483     ioss << std::setiosflags(std::ios::uppercase) << std::hex << color;
484     ioss >> temp;
485     int count = RGBA_LENGTH - static_cast<int>(temp.length());
486     std::string tmpColor(count, '0');
487     tmpColor += temp;
488     std::string finalColor("#");
489     finalColor += tmpColor;
490     return finalColor;
491 }
492 
CreateJsSystemBarPropertiesObject(napi_env env,sptr<Window> & window)493 napi_value CreateJsSystemBarPropertiesObject(napi_env env, sptr<Window>& window)
494 {
495     napi_value objValue = nullptr;
496     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
497 
498     SystemBarProperty status = window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_STATUS_BAR);
499     SystemBarProperty navi = window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_NAVIGATION_BAR);
500     napi_set_named_property(env, objValue, "statusBarColor",
501         CreateJsValue(env, GetHexColor(status.backgroundColor_)));
502     napi_set_named_property(env, objValue, "statusBarContentColor",
503         CreateJsValue(env, GetHexColor(status.contentColor_)));
504     napi_set_named_property(env, objValue, "isStatusBarLightIcon",
505         CreateJsValue(env, status.contentColor_ == SYSTEM_COLOR_WHITE));
506     napi_set_named_property(env, objValue, "navigationBarColor",
507         CreateJsValue(env, GetHexColor(navi.backgroundColor_)));
508     napi_set_named_property(env, objValue, "navigationBarContentColor",
509         CreateJsValue(env, GetHexColor(navi.contentColor_)));
510     napi_set_named_property(env, objValue, "isNavigationBarLightIcon",
511         CreateJsValue(env, navi.contentColor_ == SYSTEM_COLOR_WHITE));
512     napi_set_named_property(env, objValue, "enableStatusBarAnimation",
513                             CreateJsValue(env, status.enableAnimation_));
514     napi_set_named_property(env, objValue, "enableNavigationBarAnimation",
515                             CreateJsValue(env, navi.enableAnimation_));
516     return objValue;
517 }
518 
CreateJsSystemBarRegionTintObject(napi_env env,const SystemBarRegionTint & tint)519 static napi_value CreateJsSystemBarRegionTintObject(napi_env env, const SystemBarRegionTint& tint)
520 {
521     napi_value objValue = nullptr;
522     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
523 
524     if (NATIVE_JS_TO_WINDOW_TYPE_MAP.count(tint.type_) != 0) {
525         napi_set_named_property(env, objValue, "type", CreateJsValue(env, NATIVE_JS_TO_WINDOW_TYPE_MAP.at(tint.type_)));
526     } else {
527         napi_set_named_property(env, objValue, "type", CreateJsValue(env, tint.type_));
528     }
529     napi_set_named_property(env, objValue, "isEnable", CreateJsValue(env, tint.prop_.enable_));
530     std::string bkgColor = GetHexColor(tint.prop_.backgroundColor_);
531     napi_set_named_property(env, objValue, "backgroundColor", CreateJsValue(env, bkgColor));
532     std::string contentColor = GetHexColor(tint.prop_.contentColor_);
533     napi_set_named_property(env, objValue, "contentColor", CreateJsValue(env, contentColor));
534     Rect rect = tint.region_;
535     napi_set_named_property(env, objValue, "region", GetRectAndConvertToJsValue(env, rect));
536 
537     WLOGFD("Type %{public}u [%{public}u %{public}s %{public}s]",
538         tint.type_, tint.prop_.enable_, bkgColor.c_str(), contentColor.c_str());
539     WLOGFD("Region [%{public}d %{public}d %{public}u %{public}u]",
540         rect.posX_, rect.posY_, rect.width_, rect.height_);
541     return objValue;
542 }
543 
CreateJsWindowInfoArrayObject(napi_env env,const std::vector<sptr<WindowVisibilityInfo>> & infos)544 napi_value CreateJsWindowInfoArrayObject(napi_env env, const std::vector<sptr<WindowVisibilityInfo>>& infos)
545 {
546     napi_value arrayValue = nullptr;
547     napi_create_array_with_length(env, infos.size(), &arrayValue);
548     if (arrayValue == nullptr) {
549         WLOGFE("[NAPI]Failed to convert windowVisibilityInfo to jsArrayObject");
550         return nullptr;
551     }
552     uint32_t index = 0;
553     for (size_t i = 0; i < infos.size(); i++) {
554         auto info = infos[i];
555         auto windowType = info->GetWindowType();
556         auto windowVisibilityState = info->GetWindowVisibilityState();
557         if (windowType >= WindowType::APP_MAIN_WINDOW_BASE && windowType < WindowType::APP_MAIN_WINDOW_END &&
558             windowVisibilityState != WindowVisibilityState::WINDOW_VISIBILITY_STATE_TOTALLY_OCCUSION) {
559             napi_set_element(env, arrayValue, index++, CreateJsWindowInfoObject(env, info));
560         }
561     }
562     return arrayValue;
563 }
564 
CreateJsWindowInfoObject(napi_env env,const sptr<WindowVisibilityInfo> & info)565 napi_value CreateJsWindowInfoObject(napi_env env, const sptr<WindowVisibilityInfo>& info)
566 {
567     napi_value objValue = nullptr;
568     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
569     napi_set_named_property(env, objValue, "rect", GetRectAndConvertToJsValue(env, info->GetRect()));
570     napi_set_named_property(env, objValue, "bundleName", CreateJsValue(env, info->GetBundleName()));
571     napi_set_named_property(env, objValue, "abilityName", CreateJsValue(env, info->GetAbilityName()));
572     napi_set_named_property(env, objValue, "windowId", CreateJsValue(env, info->GetWindowId()));
573     napi_set_named_property(env, objValue, "windowStatusType",
574         CreateJsValue(env, static_cast<int32_t>(info->GetWindowStatus())));
575     napi_set_named_property(env, objValue, "isFocused", CreateJsValue(env, info->IsFocused()));
576     return objValue;
577 }
578 
CreateJsSystemBarRegionTintArrayObject(napi_env env,const SystemBarRegionTints & tints)579 napi_value CreateJsSystemBarRegionTintArrayObject(napi_env env, const SystemBarRegionTints& tints)
580 {
581     if (tints.empty()) {
582         WLOGFE("Empty tints");
583         return nullptr;
584     }
585     napi_value objValue = nullptr;
586     napi_create_array_with_length(env, tints.size(), &objValue);
587     napi_value array = objValue;
588     if (array == nullptr) {
589         WLOGFE("Failed to convert SystemBarProperties to jsArrayObject");
590         return nullptr;
591     }
592     uint32_t index = 0;
593     for (size_t i = 0; i < tints.size(); i++) {
594         napi_set_element(env, array, index++, CreateJsSystemBarRegionTintObject(env, tints[i]));
595     }
596     return objValue;
597 }
598 
GetSystemBarStatus(napi_env env,napi_callback_info info,std::map<WindowType,SystemBarProperty> & systemBarProperties,std::map<WindowType,SystemBarPropertyFlag> & systemBarpropertyFlags)599 bool GetSystemBarStatus(napi_env env, napi_callback_info info,
600     std::map<WindowType, SystemBarProperty>& systemBarProperties,
601     std::map<WindowType, SystemBarPropertyFlag>& systemBarpropertyFlags)
602 {
603     size_t argc = FOUR_PARAMS_SIZE;
604     napi_value argv[FOUR_PARAMS_SIZE] = { nullptr };
605     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
606     uint32_t size = INDEX_ZERO;
607     napi_value nativeArray = nullptr;
608     if (argc > ARG_COUNT_ZERO && GetType(env, argv[INDEX_ZERO]) != napi_function) {
609         nativeArray = argv[INDEX_ZERO];
610         if (nativeArray == nullptr) {
611             TLOGE(WmsLogTag::WMS_IMMS, "Failed to convert parameter to SystemBarArray");
612             return false;
613         }
614         napi_get_array_length(env, nativeArray, &size);
615     }
616     systemBarProperties[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = false;
617     systemBarProperties[WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR].enable_ = false;
618     systemBarProperties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = false;
619     for (uint32_t i = 0; i < size; i++) {
620         std::string name;
621         napi_value getElementValue = nullptr;
622         napi_get_element(env, nativeArray, i, &getElementValue);
623         if (!ConvertFromJsValue(env, getElementValue, name)) {
624             TLOGE(WmsLogTag::WMS_IMMS, "Failed to convert parameter to SystemBarName");
625             return false;
626         }
627         if (name.compare("status") == 0) {
628             systemBarProperties[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
629             systemBarProperties[WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR].enable_ = true;
630         } else if (name.compare("navigation") == 0) {
631             systemBarProperties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = true;
632         }
633     }
634     systemBarpropertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].enableFlag = true;
635     systemBarpropertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enableFlag = true;
636     systemBarpropertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_INDICATOR].enableFlag = true;
637     return true;
638 }
639 
ParseAndCheckRect(napi_env env,napi_value jsObject,const Rect & windowRect,Rect & touchableRect)640 bool ParseAndCheckRect(napi_env env, napi_value jsObject,
641     const Rect& windowRect, Rect& touchableRect)
642 {
643     int32_t data = 0;
644     if (ParseJsValue(jsObject, env, "left", data)) {
645         touchableRect.posX_ = data;
646     } else {
647         TLOGE(WmsLogTag::WMS_EVENT, "Failed to convert object:legt");
648         return false;
649     }
650     if (ParseJsValue(jsObject, env, "top", data)) {
651         touchableRect.posY_ = data;
652     } else {
653         TLOGE(WmsLogTag::WMS_EVENT, "Failed to convert object:top");
654         return false;
655     }
656     uint32_t udata = 0;
657     if (ParseJsValue(jsObject, env, "width", udata)) {
658         touchableRect.width_ = udata;
659     } else {
660         TLOGE(WmsLogTag::WMS_EVENT, "Failed to convert object:width");
661         return false;
662     }
663     if (ParseJsValue(jsObject, env, "height", udata)) {
664         touchableRect.height_ = udata;
665     } else {
666         TLOGE(WmsLogTag::WMS_EVENT, "Failed to convert object:height");
667         return false;
668     }
669     if ((touchableRect.posX_ < 0) || (touchableRect.posY_ < 0) ||
670         (touchableRect.posX_ > static_cast<int32_t>(windowRect.width_)) ||
671         (touchableRect.posY_ > static_cast<int32_t>(windowRect.height_)) ||
672         (touchableRect.width_ > (windowRect.width_ - static_cast<uint32_t>(touchableRect.posX_))) ||
673         (touchableRect.height_ > (windowRect.height_ - static_cast<uint32_t>(touchableRect.posY_)))) {
674         TLOGE(WmsLogTag::WMS_EVENT, "Outside the window area");
675         return false;
676     }
677     return true;
678 }
679 
ParseTouchableAreas(napi_env env,napi_callback_info info,const Rect & windowRect,std::vector<Rect> & touchableAreas)680 WmErrorCode ParseTouchableAreas(napi_env env, napi_callback_info info,
681     const Rect& windowRect, std::vector<Rect>& touchableAreas)
682 {
683     WmErrorCode errCode = WmErrorCode::WM_ERROR_INVALID_PARAM;
684     size_t argc = 4;
685     napi_value argv[4] = {nullptr};
686     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
687     if (argc != 1) {
688         TLOGE(WmsLogTag::WMS_EVENT, "Argc is invalid:%{public}zu", argc);
689         return errCode;
690     }
691     if (GetType(env, argv[0]) != napi_object) {
692         TLOGE(WmsLogTag::WMS_EVENT, "GetType error");
693         return errCode;
694     }
695     napi_value nativeArray = argv[0];
696     if (nativeArray == nullptr) {
697         TLOGE(WmsLogTag::WMS_EVENT, "Failed to convert parameter");
698         return errCode;
699     }
700     uint32_t size = 0;
701     napi_get_array_length(env, nativeArray, &size);
702     if (size > MAX_TOUCHABLE_AREAS) {
703         TLOGE(WmsLogTag::WMS_EVENT, "Exceeded maximum limit");
704         return errCode;
705     }
706     errCode = WmErrorCode::WM_OK;
707     for (uint32_t i = 0; i < size; i++) {
708         napi_value getElementValue = nullptr;
709         napi_get_element(env, nativeArray, i, &getElementValue);
710         if (getElementValue == nullptr) {
711             TLOGE(WmsLogTag::WMS_EVENT, "Failed to get element");
712             errCode = WmErrorCode::WM_ERROR_INVALID_PARAM;
713             break;
714         }
715         Rect touchableArea;
716         if (ParseAndCheckRect(env, getElementValue, windowRect, touchableArea)) {
717             touchableAreas.emplace_back(touchableArea);
718         } else {
719             errCode = WmErrorCode::WM_ERROR_INVALID_PARAM;
720             break;
721         }
722     }
723     return errCode;
724 }
725 
GetSpecificBarStatus(napi_env env,napi_callback_info info,bool & systemBarEnable,bool & systemBarEnableAnimation)726 bool GetSpecificBarStatus(napi_env env, napi_callback_info info, bool& systemBarEnable, bool& systemBarEnableAnimation)
727 {
728     size_t argc = FOUR_PARAMS_SIZE;
729     napi_value argv[FOUR_PARAMS_SIZE] = { nullptr };
730     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
731     if (argc < ARG_COUNT_TWO || !ConvertFromJsValue(env, argv[INDEX_ONE], systemBarEnable)) {
732         TLOGE(WmsLogTag::WMS_IMMS, "Argc is invalid: %{public}zu or Failed to convert enable parameter to bool", argc);
733         return false;
734     }
735     if (argc >= ARG_COUNT_THREE && !ConvertFromJsValue(env, argv[INDEX_TWO], systemBarEnableAnimation)) {
736         TLOGE(WmsLogTag::WMS_IMMS, "Failed to convert enableAnimation parameter to bool");
737         return false;
738     }
739     return true;
740 }
741 
GetColorFromJs(napi_env env,napi_value jsObject,const char * name,uint32_t defaultColor,bool & flag)742 static uint32_t GetColorFromJs(napi_env env, napi_value jsObject,
743     const char* name, uint32_t defaultColor, bool& flag)
744 {
745     napi_value jsColor = nullptr;
746     napi_get_named_property(env, jsObject, name, &jsColor);
747     if (GetType(env, jsColor) != napi_undefined) {
748         std::string colorStr;
749         if (!ConvertFromJsValue(env, jsColor, colorStr)) {
750             WLOGFE("Failed to convert parameter to color");
751             return defaultColor;
752         }
753         std::regex pattern("^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$");
754         if (!std::regex_match(colorStr, pattern)) {
755             WLOGFD("Invalid color input");
756             return defaultColor;
757         }
758         std::string color = colorStr.substr(1);
759         if (color.length() == RGB_LENGTH) {
760             color = "FF" + color; // ARGB
761         }
762         flag = true;
763         std::stringstream ss;
764         uint32_t hexColor;
765         ss << std::hex << color;
766         ss >> hexColor;
767         WLOGI("Origin %{public}s, process %{public}s, final %{public}x",
768             colorStr.c_str(), color.c_str(), hexColor);
769         return hexColor;
770     }
771     return defaultColor;
772 }
773 
SetWindowStatusBarContentColor(napi_env env,napi_value jsObject,std::map<WindowType,SystemBarProperty> & properties,std::map<WindowType,SystemBarPropertyFlag> & propertyFlags)774 bool SetWindowStatusBarContentColor(napi_env env, napi_value jsObject,
775     std::map<WindowType, SystemBarProperty>& properties, std::map<WindowType, SystemBarPropertyFlag>& propertyFlags)
776 {
777     auto statusProperty = properties[WindowType::WINDOW_TYPE_STATUS_BAR];
778     napi_value jsStatusContentColor = nullptr;
779     napi_get_named_property(env, jsObject, "statusBarContentColor", &jsStatusContentColor);
780     napi_value jsStatusIcon = nullptr;
781     napi_get_named_property(env, jsObject, "isStatusBarLightIcon", &jsStatusIcon);
782     if (GetType(env, jsStatusContentColor) != napi_undefined) {
783         properties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_ =  GetColorFromJs(env,
784             jsObject, "statusBarContentColor", statusProperty.contentColor_,
785             propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].contentColorFlag);
786     } else if (GetType(env, jsStatusIcon) != napi_undefined) {
787         bool isStatusBarLightIcon;
788         if (!ConvertFromJsValue(env, jsStatusIcon, isStatusBarLightIcon)) {
789             TLOGE(WmsLogTag::DEFAULT, "Convert status icon value failed");
790             return false;
791         }
792         if (isStatusBarLightIcon) {
793             properties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_ = SYSTEM_COLOR_WHITE;
794         } else {
795             properties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_ = SYSTEM_COLOR_BLACK;
796         }
797         propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].contentColorFlag = true;
798     }
799     return true;
800 }
801 
SetWindowNavigationBarContentColor(napi_env env,napi_value jsObject,std::map<WindowType,SystemBarProperty> & properties,std::map<WindowType,SystemBarPropertyFlag> & propertyFlags)802 bool SetWindowNavigationBarContentColor(napi_env env, napi_value jsObject,
803     std::map<WindowType, SystemBarProperty>& properties, std::map<WindowType, SystemBarPropertyFlag>& propertyFlags)
804 {
805     auto navProperty = properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR];
806     napi_value jsNavigationContentColor = nullptr;
807     napi_get_named_property(env, jsObject, "navigationBarContentColor", &jsNavigationContentColor);
808     napi_value jsNavigationIcon = nullptr;
809     napi_get_named_property(env, jsObject, "isNavigationBarLightIcon", &jsNavigationIcon);
810     if (GetType(env, jsNavigationContentColor) != napi_undefined) {
811         properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].contentColor_ = GetColorFromJs(env,
812             jsObject, "navigationBarContentColor", navProperty.contentColor_,
813             propertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_BAR].contentColorFlag);
814     } else if (GetType(env, jsNavigationIcon) != napi_undefined) {
815         bool isNavigationBarLightIcon;
816         if (!ConvertFromJsValue(env, jsNavigationIcon, isNavigationBarLightIcon)) {
817             TLOGE(WmsLogTag::DEFAULT, "Convert navigation icon value failed");
818             return false;
819         }
820         if (isNavigationBarLightIcon) {
821             properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].contentColor_ = SYSTEM_COLOR_WHITE;
822         } else {
823             properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].contentColor_ = SYSTEM_COLOR_BLACK;
824         }
825         propertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_BAR].contentColorFlag = true;
826     }
827     return true;
828 }
829 
GetSystemBarPropertiesFromJs(napi_env env,napi_value jsObject,std::map<WindowType,SystemBarProperty> & properties,std::map<WindowType,SystemBarPropertyFlag> & propertyFlags)830 bool GetSystemBarPropertiesFromJs(napi_env env, napi_value jsObject,
831     std::map<WindowType, SystemBarProperty>& properties,
832     std::map<WindowType, SystemBarPropertyFlag>& propertyFlags)
833 {
834     properties[WindowType::WINDOW_TYPE_STATUS_BAR].backgroundColor_ =
835         GetColorFromJs(env, jsObject, "statusBarColor",
836             properties[WindowType::WINDOW_TYPE_STATUS_BAR].backgroundColor_,
837             propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].backgroundColorFlag);
838     properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].backgroundColor_ =
839         GetColorFromJs(env, jsObject, "navigationBarColor",
840             properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].backgroundColor_,
841             propertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_BAR].backgroundColorFlag);
842 
843     if (!SetWindowStatusBarContentColor(env, jsObject, properties, propertyFlags) ||
844         !SetWindowNavigationBarContentColor(env, jsObject, properties, propertyFlags)) {
845         return false;
846     }
847     bool enableStatusBarAnimation = false;
848     if (ParseJsValue(jsObject, env, "enableStatusBarAnimation", enableStatusBarAnimation)) {
849         properties[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimation_ = enableStatusBarAnimation;
850         propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].enableAnimationFlag = true;
851     }
852     bool enableNavigationBarAnimation = false;
853     if (ParseJsValue(jsObject, env, "enableNavigationBarAnimation", enableNavigationBarAnimation)) {
854         properties[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enableAnimation_ = enableNavigationBarAnimation;
855         propertyFlags[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enableAnimationFlag = true;
856     }
857     return true;
858 }
859 
ConvertJSSystemBarStyleToSystemBarProperties(napi_env env,napi_value jsObject,std::map<WindowType,SystemBarProperty> & properties,std::map<WindowType,SystemBarPropertyFlag> & propertyFlags)860 void ConvertJSSystemBarStyleToSystemBarProperties(napi_env env, napi_value jsObject,
861     std::map<WindowType, SystemBarProperty>& properties, std::map<WindowType, SystemBarPropertyFlag>& propertyFlags)
862 {
863     properties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_ = GetColorFromJs(env,
864         jsObject, "statusBarContentColor",
865         properties[WindowType::WINDOW_TYPE_STATUS_BAR].contentColor_,
866         propertyFlags[WindowType::WINDOW_TYPE_STATUS_BAR].contentColorFlag);
867 }
868 
ConvertAvoidAreaToJsValue(napi_env env,const AvoidArea & avoidArea,AvoidAreaType type)869 napi_value ConvertAvoidAreaToJsValue(napi_env env, const AvoidArea& avoidArea, AvoidAreaType type)
870 {
871     napi_value objValue = nullptr;
872     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
873 
874     napi_set_named_property(env, objValue, "visible",
875         CreateJsValue(env, type == AvoidAreaType::TYPE_CUTOUT ? false : true));
876     napi_set_named_property(env, objValue, "leftRect", GetRectAndConvertToJsValue(env, avoidArea.leftRect_));
877     napi_set_named_property(env, objValue, "topRect", GetRectAndConvertToJsValue(env, avoidArea.topRect_));
878     napi_set_named_property(env, objValue, "rightRect", GetRectAndConvertToJsValue(env, avoidArea.rightRect_));
879     napi_set_named_property(env, objValue, "bottomRect", GetRectAndConvertToJsValue(env, avoidArea.bottomRect_));
880     return objValue;
881 }
882 
GetWindowLimitsAndConvertToJsValue(napi_env env,const WindowLimits & windowLimits)883 napi_value GetWindowLimitsAndConvertToJsValue(napi_env env, const WindowLimits& windowLimits)
884 {
885     napi_value objValue = nullptr;
886     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
887 
888     napi_set_named_property(env, objValue, "maxWidth", CreateJsValue(env, windowLimits.maxWidth_));
889     napi_set_named_property(env, objValue, "maxHeight", CreateJsValue(env, windowLimits.maxHeight_));
890     napi_set_named_property(env, objValue, "minWidth", CreateJsValue(env, windowLimits.minWidth_));
891     napi_set_named_property(env, objValue, "minHeight", CreateJsValue(env, windowLimits.minHeight_));
892     return objValue;
893 }
894 
ConvertTitleButtonAreaToJsValue(napi_env env,const TitleButtonRect & titleButtonRect)895 napi_value ConvertTitleButtonAreaToJsValue(napi_env env, const TitleButtonRect& titleButtonRect)
896 {
897     napi_value objValue = nullptr;
898     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
899 
900     napi_set_named_property(env, objValue, "right", CreateJsValue(env, titleButtonRect.posX_));
901     napi_set_named_property(env, objValue, "top", CreateJsValue(env, titleButtonRect.posY_));
902     napi_set_named_property(env, objValue, "width", CreateJsValue(env, titleButtonRect.width_));
903     napi_set_named_property(env, objValue, "height", CreateJsValue(env, titleButtonRect.height_));
904     return objValue;
905 }
906 
CheckCallingPermission(std::string permission)907 bool CheckCallingPermission(std::string permission)
908 {
909     WLOGD("Permission: %{public}s", permission.c_str());
910     if (!permission.empty() &&
911         Security::AccessToken::AccessTokenKit::VerifyAccessToken(IPCSkeleton::GetCallingTokenID(), permission)
912         != AppExecFwk::Constants::PERMISSION_GRANTED) {
913         WLOGFE("Permission %{public}s is not granted", permission.c_str());
914         return false;
915     }
916     return true;
917 }
918 
ParseSystemWindowTypeForApiWindowType(int32_t apiWindowType,WindowType & windowType)919 bool ParseSystemWindowTypeForApiWindowType(int32_t apiWindowType, WindowType& windowType)
920 {
921     if (JS_TO_NATIVE_WINDOW_TYPE_MAP.count(static_cast<ApiWindowType>(apiWindowType)) != 0) {
922         windowType = JS_TO_NATIVE_WINDOW_TYPE_MAP.at(static_cast<ApiWindowType>(apiWindowType));
923         if (WindowHelper::IsSystemWindow(windowType)) {
924             return true;
925         }
926     }
927     return false;
928 }
929 
930 
GetAPI7Ability(napi_env env,AppExecFwk::Ability * & ability)931 bool GetAPI7Ability(napi_env env, AppExecFwk::Ability* &ability)
932 {
933     napi_value global;
934     if (napi_get_global(env, &global) != napi_ok) {
935         WLOGI("Get global failed");
936         return false;
937     }
938     napi_value jsAbility;
939     napi_status status = napi_get_named_property(env, global, "ability", &jsAbility);
940     if (status != napi_ok || jsAbility == nullptr) {
941         WLOGI("Get ability property failed");
942         return false;
943     }
944 
945     if (napi_get_value_external(env, jsAbility, reinterpret_cast<void **>(&ability)) != napi_ok) {
946         WLOGI("Get ability external failed");
947         return false;
948     }
949     if (ability == nullptr) {
950         return false;
951     } else {
952         WLOGI("Get ability");
953     }
954     return true;
955 }
GetWindowMaskFromJsValue(napi_env env,napi_value jsObject,std::vector<std::vector<uint32_t>> & windowMask)956 bool GetWindowMaskFromJsValue(napi_env env, napi_value jsObject, std::vector<std::vector<uint32_t>>& windowMask)
957 {
958     if (jsObject == nullptr) {
959         WLOGFE("Failed to convert parameter to window mask");
960         return false;
961     }
962     uint32_t size = 0;
963     napi_get_array_length(env, jsObject, &size);
964     for (uint32_t i = 0; i < size; i++) {
965         std::vector<uint32_t> elementArray;
966         napi_value getElementValue = nullptr;
967         napi_get_element(env, jsObject, i, &getElementValue);
968         if (!ConvertNativeValueToVector(env, getElementValue, elementArray)) {
969             WLOGFE("Failed to convert parameter to window mask");
970             return false;
971         }
972         windowMask.emplace_back(elementArray);
973     }
974     return true;
975 }
976 
CreateAsyncTask(napi_env env,napi_value lastParam,std::unique_ptr<NapiAsyncTask::ExecuteCallback> && execute,std::unique_ptr<NapiAsyncTask::CompleteCallback> && complete,napi_value * result)977 std::unique_ptr<NapiAsyncTask> CreateAsyncTask(napi_env env, napi_value lastParam,
978     std::unique_ptr<NapiAsyncTask::ExecuteCallback>&& execute,
979     std::unique_ptr<NapiAsyncTask::CompleteCallback>&& complete, napi_value* result)
980 {
981     napi_valuetype type = napi_undefined;
982     napi_typeof(env, lastParam, &type);
983     if (lastParam == nullptr || type != napi_function) {
984         napi_deferred nativeDeferred = nullptr;
985         NAPI_CALL(env, napi_create_promise(env, &nativeDeferred, result));
986         return std::make_unique<NapiAsyncTask>(nativeDeferred, std::move(execute), std::move(complete));
987     } else {
988         napi_get_undefined(env, result);
989         napi_ref callbackRef = nullptr;
990         napi_create_reference(env, lastParam, 1, &callbackRef);
991         return std::make_unique<NapiAsyncTask>(callbackRef, std::move(execute), std::move(complete));
992     }
993 }
994 
CreateEmptyAsyncTask(napi_env env,napi_value lastParam,napi_value * result)995 std::unique_ptr<NapiAsyncTask> CreateEmptyAsyncTask(napi_env env,
996     napi_value lastParam, napi_value* result)
997 {
998     napi_valuetype type = napi_undefined;
999     napi_typeof(env, lastParam, &type);
1000     if (lastParam == nullptr || type != napi_function) {
1001         napi_deferred nativeDeferred = nullptr;
1002         napi_create_promise(env, &nativeDeferred, result);
1003         return std::make_unique<NapiAsyncTask>(nativeDeferred,
1004             std::unique_ptr<NapiAsyncTask::ExecuteCallback>(),
1005             std::unique_ptr<NapiAsyncTask::CompleteCallback>());
1006     } else {
1007         napi_get_undefined(env, result);
1008         napi_ref callbackRef = nullptr;
1009         napi_create_reference(env, lastParam, 1, &callbackRef);
1010         return std::make_unique<NapiAsyncTask>(callbackRef,
1011             std::unique_ptr<NapiAsyncTask::ExecuteCallback>(),
1012             std::unique_ptr<NapiAsyncTask::CompleteCallback>());
1013     }
1014 }
1015 
ModalityTypeInit(napi_env env)1016 napi_value ModalityTypeInit(napi_env env)
1017 {
1018     CHECK_NAPI_ENV_RETURN_IF_NULL(env);
1019     napi_value objValue = nullptr;
1020     CHECK_NAPI_CREATE_OBJECT_RETURN_IF_NULL(env, objValue);
1021 
1022     napi_set_named_property(env, objValue, "WINDOW_MODALITY",
1023         CreateJsValue(env, ApiModalityType::WINDOW_MODALITY));
1024     napi_set_named_property(env, objValue, "APPLICATION_MODALITY",
1025         CreateJsValue(env, ApiModalityType::APPLICATION_MODALITY));
1026     return objValue;
1027 }
1028 
ParseModalityParam(napi_env env,napi_value jsObject,const sptr<WindowOption> & windowOption)1029 static bool ParseModalityParam(napi_env env, napi_value jsObject, const sptr<WindowOption>& windowOption)
1030 {
1031     bool isModal = false;
1032     if (ParseJsValue(jsObject, env, "isModal", isModal)) {
1033         if (isModal) {
1034             windowOption->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_MODAL);
1035         }
1036     }
1037     bool isTopmost = false;
1038     if (ParseJsValue(jsObject, env, "isTopmost", isTopmost)) {
1039         if (!isModal && isTopmost) {
1040             TLOGE(WmsLogTag::WMS_SUB, "Normal subwindow not support topmost");
1041             return false;
1042         }
1043         windowOption->SetWindowTopmost(isTopmost);
1044     }
1045     ApiModalityType apiModalityType;
1046     if (ParseJsValue(jsObject, env, "modalityType", apiModalityType)) {
1047         if (!isModal) {
1048             TLOGE(WmsLogTag::WMS_SUB, "Normal subwindow not support modalityType");
1049             return false;
1050         }
1051         using T = std::underlying_type_t<ApiModalityType>;
1052         T modalityType = static_cast<T>(apiModalityType);
1053         if (modalityType >= static_cast<T>(ApiModalityType::BEGIN) &&
1054             modalityType <= static_cast<T>(ApiModalityType::END)) {
1055             auto type = JS_TO_NATIVE_MODALITY_TYPE_MAP.at(apiModalityType);
1056             if (type == ModalityType::APPLICATION_MODALITY) {
1057                 windowOption->AddWindowFlag(WindowFlag::WINDOW_FLAG_IS_APPLICATION_MODAL);
1058             }
1059         } else {
1060             TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to modalityType");
1061             return false;
1062         }
1063     }
1064     return true;
1065 }
1066 
ParseSubWindowOptions(napi_env env,napi_value jsObject,const sptr<WindowOption> & windowOption)1067 bool ParseSubWindowOptions(napi_env env, napi_value jsObject, const sptr<WindowOption>& windowOption)
1068 {
1069     if (jsObject == nullptr || windowOption == nullptr) {
1070         TLOGE(WmsLogTag::WMS_SUB, "jsObject or windowOption is null");
1071         return false;
1072     }
1073     std::string title;
1074     if (!ParseJsValue(jsObject, env, "title", title)) {
1075         TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to title");
1076         return false;
1077     }
1078     bool decorEnabled = false;
1079     if (!ParseJsValue(jsObject, env, "decorEnabled", decorEnabled)) {
1080         TLOGE(WmsLogTag::WMS_SUB, "Failed to convert parameter to decorEnabled");
1081         return false;
1082     }
1083 
1084     windowOption->SetSubWindowTitle(title);
1085     windowOption->SetSubWindowDecorEnable(decorEnabled);
1086     return ParseModalityParam(env, jsObject, windowOption);
1087 }
1088 
ExtensionWindowAttributeInit(napi_env env)1089 napi_value ExtensionWindowAttributeInit(napi_env env)
1090 {
1091     if (env == nullptr) {
1092         TLOGE(WmsLogTag::WMS_UIEXT, "env is nullptr");
1093         return nullptr;
1094     }
1095     napi_value objValue = nullptr;
1096     napi_create_object(env, &objValue);
1097     if (objValue == nullptr) {
1098         TLOGE(WmsLogTag::WMS_UIEXT, "Failed to create object");
1099         return nullptr;
1100     }
1101     napi_set_named_property(env, objValue, "SYSTEM_WINDOW",
1102         CreateJsValue(env, static_cast<int32_t>(ExtensionWindowAttribute::SYSTEM_WINDOW)));
1103     napi_set_named_property(env, objValue, "SUB_WINDOW",
1104         CreateJsValue(env, static_cast<int32_t>(ExtensionWindowAttribute::SUB_WINDOW)));
1105     return objValue;
1106 }
1107 } // namespace Rosen
1108 } // namespace OHOS
1109