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