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