1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "js_scene_utils.h"
17 
18 #include <iomanip>
19 
20 #include <event_handler.h>
21 #include <js_runtime_utils.h>
22 #include <napi_common_want.h>
23 
24 #include "property/rs_properties_def.h"
25 #include "root_scene.h"
26 #include "window_manager_hilog.h"
27 #include "window_visibility_info.h"
28 #include "process_options.h"
29 
30 namespace OHOS::Rosen {
31 using namespace AbilityRuntime;
32 namespace {
33 constexpr HiviewDFX::HiLogLabel LABEL = { LOG_CORE, HILOG_DOMAIN_WINDOW, "JsSceneUtils" };
34 constexpr int32_t US_PER_NS = 1000;
35 constexpr int32_t INVALID_VAL = -9999;
36 
37 // Refer to OHOS::Ace::TouchType
38 enum class AceTouchType : int32_t {
39     DOWN = 0,
40     UP,
41     MOVE,
42     CANCEL,
43 };
44 
GetMMITouchType(int32_t aceType)45 int32_t GetMMITouchType(int32_t aceType)
46 {
47     switch (aceType) {
48         case static_cast<int32_t>(AceTouchType::DOWN):
49             return MMI::PointerEvent::POINTER_ACTION_DOWN;
50         case static_cast<int32_t>(AceTouchType::UP):
51             return MMI::PointerEvent::POINTER_ACTION_UP;
52         case static_cast<int32_t>(AceTouchType::MOVE):
53             return MMI::PointerEvent::POINTER_ACTION_MOVE;
54         case static_cast<int32_t>(AceTouchType::CANCEL):
55             return MMI::PointerEvent::POINTER_ACTION_CANCEL;
56         default:
57             return MMI::PointerEvent::POINTER_ACTION_UNKNOWN;
58     }
59 }
60 } // namespace
61 
NapiGetUndefined(napi_env env)62 napi_value NapiGetUndefined(napi_env env)
63 {
64     napi_value result = nullptr;
65     napi_get_undefined(env, &result);
66     return result;
67 }
68 
GetType(napi_env env,napi_value value)69 napi_valuetype GetType(napi_env env, napi_value value)
70 {
71     napi_valuetype res = napi_undefined;
72     napi_typeof(env, value, &res);
73     return res;
74 }
75 
GetIntValueFromString(const std::string & str,uint32_t & value)76 WSError GetIntValueFromString(const std::string& str, uint32_t& value)
77 {
78     char* end;
79     value = strtoul(str.c_str(), &end, 10); // 10 number convert base
80     if (*end == '\0' && value != 0) {
81         return WSError::WS_OK;
82     }
83     TLOGE(WmsLogTag::DEFAULT, "param %{public}s convert int failed", str.c_str());
84     return WSError::WS_ERROR_INVALID_PARAM;
85 }
86 
IsJsBundleNameUndefind(napi_env env,napi_value jsBundleName,SessionInfo & sessionInfo)87 bool IsJsBundleNameUndefind(napi_env env, napi_value jsBundleName, SessionInfo& sessionInfo)
88 {
89     if (GetType(env, jsBundleName) != napi_undefined) {
90         std::string bundleName;
91         if (!ConvertFromJsValue(env, jsBundleName, bundleName)) {
92             WLOGFE("[NAPI]Failed to convert parameter to bundleName");
93             return false;
94         }
95         sessionInfo.bundleName_ = bundleName;
96     }
97     return true;
98 }
99 
IsJsModuleNameUndefind(napi_env env,napi_value jsModuleName,SessionInfo & sessionInfo)100 bool IsJsModuleNameUndefind(napi_env env, napi_value jsModuleName, SessionInfo& sessionInfo)
101 {
102     if (GetType(env, jsModuleName) != napi_undefined) {
103         std::string moduleName;
104         if (!ConvertFromJsValue(env, jsModuleName, moduleName)) {
105             WLOGFE("[NAPI]Failed to convert parameter to moduleName");
106             return false;
107         }
108         sessionInfo.moduleName_ = moduleName;
109     }
110     return true;
111 }
112 
IsJsAbilityUndefind(napi_env env,napi_value jsAbilityName,SessionInfo & sessionInfo)113 bool IsJsAbilityUndefind(napi_env env, napi_value jsAbilityName, SessionInfo& sessionInfo)
114 {
115     if (GetType(env, jsAbilityName) != napi_undefined) {
116         std::string abilityName;
117         if (!ConvertFromJsValue(env, jsAbilityName, abilityName)) {
118             WLOGFE("[NAPI]Failed to convert parameter to abilityName");
119             return false;
120         }
121         sessionInfo.abilityName_ = abilityName;
122     }
123     return true;
124 }
125 
IsJsAppIndexUndefind(napi_env env,napi_value jsAppIndex,SessionInfo & sessionInfo)126 bool IsJsAppIndexUndefind(napi_env env, napi_value jsAppIndex, SessionInfo& sessionInfo)
127 {
128     if (GetType(env, jsAppIndex) != napi_undefined) {
129         int32_t appIndex;
130         if (!ConvertFromJsValue(env, jsAppIndex, appIndex)) {
131             WLOGFE("[NAPI]Failed to convert parameter to appIndex");
132             return false;
133         }
134         sessionInfo.appIndex_ = appIndex;
135     }
136     return true;
137 }
138 
IsJsIsSystemUndefind(napi_env env,napi_value jsIsSystem,SessionInfo & sessionInfo)139 bool IsJsIsSystemUndefind(napi_env env, napi_value jsIsSystem, SessionInfo& sessionInfo)
140 {
141     if (GetType(env, jsIsSystem) != napi_undefined) {
142         bool isSystem;
143         if (!ConvertFromJsValue(env, jsIsSystem, isSystem)) {
144             WLOGFE("[NAPI]Failed to convert parameter to isSystem");
145             return false;
146         }
147         sessionInfo.isSystem_ = isSystem;
148     }
149     return true;
150 }
151 
IsJsSceneTypeUndefined(napi_env env,napi_value jsSceneType,SessionInfo & sessionInfo)152 bool IsJsSceneTypeUndefined(napi_env env, napi_value jsSceneType, SessionInfo& sessionInfo)
153 {
154     if (GetType(env, jsSceneType) != napi_undefined) {
155         uint32_t sceneType;
156         if (!ConvertFromJsValue(env, jsSceneType, sceneType)) {
157             WLOGFE("[NAPI]Failed to convert parameter to sceneType");
158             return false;
159         }
160         sessionInfo.sceneType_ = static_cast<SceneType>(sceneType);
161     } else if (sessionInfo.isSystem_) {
162         sessionInfo.sceneType_ = SceneType::SYSTEM_WINDOW_SCENE;
163     }
164     return true;
165 }
166 
IsJsPersistentIdUndefind(napi_env env,napi_value jsPersistentId,SessionInfo & sessionInfo)167 bool IsJsPersistentIdUndefind(napi_env env, napi_value jsPersistentId, SessionInfo& sessionInfo)
168 {
169     if (GetType(env, jsPersistentId) != napi_undefined) {
170         int32_t persistentId;
171         if (!ConvertFromJsValue(env, jsPersistentId, persistentId)) {
172             WLOGFE("[NAPI]Failed to convert parameter to persistentId");
173             return false;
174         }
175         sessionInfo.persistentId_ = persistentId;
176     }
177     return true;
178 }
179 
IsJsCallStateUndefind(napi_env env,napi_value jsCallState,SessionInfo & sessionInfo)180 bool IsJsCallStateUndefind(napi_env env, napi_value jsCallState, SessionInfo& sessionInfo)
181 {
182     if (GetType(env, jsCallState) != napi_undefined) {
183         int32_t callState;
184         if (!ConvertFromJsValue(env, jsCallState, callState)) {
185             WLOGFE("[NAPI]Failed to convert parameter to callState");
186             return false;
187         }
188         sessionInfo.callState_ = static_cast<uint32_t>(callState);
189     }
190     return true;
191 }
192 
IsJsWindowInputTypeUndefind(napi_env env,napi_value jsWindowInputType,SessionInfo & sessionInfo)193 bool IsJsWindowInputTypeUndefind(napi_env env, napi_value jsWindowInputType, SessionInfo& sessionInfo)
194 {
195     if (GetType(env, jsWindowInputType) != napi_undefined) {
196         uint32_t windowInputType = 0;
197         if (!ConvertFromJsValue(env, jsWindowInputType, windowInputType)) {
198             WLOGFE("[NAPI]Failed to convert parameter to windowInputType");
199             return false;
200         }
201         sessionInfo.windowInputType_ = static_cast<uint32_t>(windowInputType);
202     }
203     return true;
204 }
205 
IsJsSessionTypeUndefind(napi_env env,napi_value jsSessionType,SessionInfo & sessionInfo)206 bool IsJsSessionTypeUndefind(napi_env env, napi_value jsSessionType, SessionInfo& sessionInfo)
207 {
208     uint32_t windowType = 0;
209     if (GetType(env, jsSessionType) != napi_undefined) {
210         if (!ConvertFromJsValue(env, jsSessionType, windowType)) {
211             WLOGFE("[NAPI]Failed to convert parameter to windowType");
212             return false;
213         }
214         if (JS_SESSION_TO_WINDOW_TYPE_MAP.count(static_cast<JsSessionType>(windowType)) != 0) {
215             sessionInfo.windowType_ = static_cast<uint32_t>(
216                 JS_SESSION_TO_WINDOW_TYPE_MAP.at(static_cast<JsSessionType>(windowType)));
217         }
218     }
219     if (windowType == 0 && sessionInfo.isSystem_) {
220         sessionInfo.windowType_ = static_cast<uint32_t>(WindowType::WINDOW_TYPE_SCB_DEFAULT);
221     }
222     return true;
223 }
224 
IsJsScreenIdUndefind(napi_env env,napi_value jsScreenId,SessionInfo & sessionInfo)225 bool IsJsScreenIdUndefind(napi_env env, napi_value jsScreenId, SessionInfo& sessionInfo)
226 {
227     if (GetType(env, jsScreenId) != napi_undefined) {
228         int32_t screenId = -1;
229         if (!ConvertFromJsValue(env, jsScreenId, screenId)) {
230             WLOGFE("[NAPI]Failed to convert parameter to screenId");
231             return false;
232         }
233         sessionInfo.screenId_ = static_cast<uint64_t>(screenId);
234     }
235     return true;
236 }
237 
IsJsIsPersistentRecoverUndefined(napi_env env,napi_value jsIsPersistentRecover,SessionInfo & sessionInfo)238 bool IsJsIsPersistentRecoverUndefined(napi_env env, napi_value jsIsPersistentRecover, SessionInfo& sessionInfo)
239 {
240     if (GetType(env, jsIsPersistentRecover) != napi_undefined) {
241         bool isPersistentRecover = false;
242         if (!ConvertFromJsValue(env, jsIsPersistentRecover, isPersistentRecover)) {
243             WLOGFE("[NAPI]Failed to convert parameter to isPersistentRecover");
244             return false;
245         }
246         sessionInfo.isPersistentRecover_ = isPersistentRecover;
247     }
248     return true;
249 }
250 
IsJsIsRotatableUndefined(napi_env env,napi_value jsIsRotatable,SessionInfo & sessionInfo)251 bool IsJsIsRotatableUndefined(napi_env env, napi_value jsIsRotatable, SessionInfo& sessionInfo)
252 {
253     if (GetType(env, jsIsRotatable) != napi_undefined) {
254         bool isRotable = false;
255         if (!ConvertFromJsValue(env, jsIsRotatable, isRotable)) {
256             WLOGFE("[NAPI]Failed to convert parameter to isRotable");
257             return false;
258         }
259         sessionInfo.isRotable_ = isRotable;
260     }
261     return true;
262 }
263 
IsJsProcessOptionUndefined(napi_env env,napi_value jsProcessOption,SessionInfo & sessionInfo)264 bool IsJsProcessOptionUndefined(napi_env env, napi_value jsProcessOption, SessionInfo& sessionInfo)
265 {
266     if (GetType(env, jsProcessOption) != napi_undefined) {
267         std::shared_ptr<AAFwk::ProcessOptions> processOptions = std::make_shared<AAFwk::ProcessOptions>();
268         if (!ConvertProcessOptionFromJs(env, jsProcessOption, processOptions)) {
269             WLOGFE("[NAPI]Failed to convert parameter to processOptions");
270             return false;
271         }
272         sessionInfo.processOptions = processOptions;
273     }
274     return true;
275 }
276 
IsJsIsSetPointerAreasUndefined(napi_env env,napi_value jsIsSetPointerAreas,SessionInfo & sessionInfo)277 bool IsJsIsSetPointerAreasUndefined(napi_env env, napi_value jsIsSetPointerAreas, SessionInfo& sessionInfo)
278 {
279     if (GetType(env, jsIsSetPointerAreas) != napi_undefined) {
280         bool isSetPointerAreas = false;
281         if (!ConvertFromJsValue(env, jsIsSetPointerAreas, isSetPointerAreas)) {
282             WLOGFE("[NAPI]Failed to convert parameter to isSetPointerAreas");
283             return false;
284         }
285         sessionInfo.isSetPointerAreas_ = isSetPointerAreas;
286     }
287     return true;
288 }
289 
IsJsFullScreenStartUndefined(napi_env env,napi_value jsFullscreenStart,SessionInfo & sessionInfo)290 bool IsJsFullScreenStartUndefined(napi_env env, napi_value jsFullscreenStart, SessionInfo& sessionInfo)
291 {
292     if (GetType(env, jsFullscreenStart) != napi_undefined) {
293         bool fullScreenStart = false;
294         if (!ConvertFromJsValue(env, jsFullscreenStart, fullScreenStart)) {
295             TLOGI(WmsLogTag::WMS_LAYOUT, "Failed to convert parameter to fullScreenStart");
296             return false;
297         }
298         sessionInfo.fullScreenStart_ = fullScreenStart;
299     }
300     return true;
301 }
302 
ConvertSessionInfoName(napi_env env,napi_value jsObject,SessionInfo & sessionInfo)303 bool ConvertSessionInfoName(napi_env env, napi_value jsObject, SessionInfo& sessionInfo)
304 {
305     napi_value jsBundleName = nullptr;
306     napi_get_named_property(env, jsObject, "bundleName", &jsBundleName);
307     napi_value jsModuleName = nullptr;
308     napi_get_named_property(env, jsObject, "moduleName", &jsModuleName);
309     napi_value jsAbilityName = nullptr;
310     napi_get_named_property(env, jsObject, "abilityName", &jsAbilityName);
311     napi_value jsAppIndex = nullptr;
312     napi_get_named_property(env, jsObject, "appIndex", &jsAppIndex);
313     napi_value jsIsSystem = nullptr;
314     napi_get_named_property(env, jsObject, "isSystem", &jsIsSystem);
315     napi_value jsSceneType = nullptr;
316     napi_get_named_property(env, jsObject, "sceneType", &jsSceneType);
317     napi_value jsWindowInputType = nullptr;
318     napi_get_named_property(env, jsObject, "windowInputType", &jsWindowInputType);
319     napi_value jsFullScreenStart = nullptr;
320     napi_get_named_property(env, jsObject, "fullScreenStart", &jsFullScreenStart);
321     if (!IsJsBundleNameUndefind(env, jsBundleName, sessionInfo)) {
322         return false;
323     }
324     if (!IsJsModuleNameUndefind(env, jsModuleName, sessionInfo)) {
325         return false;
326     }
327     if (!IsJsAbilityUndefind(env, jsAbilityName, sessionInfo)) {
328         return false;
329     }
330     if (!IsJsAppIndexUndefind(env, jsAppIndex, sessionInfo)) {
331         return false;
332     }
333     if (!IsJsIsSystemUndefind(env, jsIsSystem, sessionInfo)) {
334         return false;
335     }
336     if (!IsJsSceneTypeUndefined(env, jsSceneType, sessionInfo)) {
337         return false;
338     }
339     if (!IsJsWindowInputTypeUndefind(env, jsWindowInputType, sessionInfo)) {
340         return false;
341     }
342     if (!IsJsFullScreenStartUndefined(env, jsFullScreenStart, sessionInfo)) {
343         return false;
344     }
345     return true;
346 }
347 
ConvertProcessOptionFromJs(napi_env env,napi_value jsObject,std::shared_ptr<AAFwk::ProcessOptions> processOptions)348 bool ConvertProcessOptionFromJs(napi_env env, napi_value jsObject,
349     std::shared_ptr<AAFwk::ProcessOptions> processOptions)
350 {
351     napi_value jsProcessMode = nullptr;
352     napi_get_named_property(env, jsObject, "processMode", &jsProcessMode);
353     napi_value jsStartupVisibility = nullptr;
354     napi_get_named_property(env, jsObject, "startupVisibility", &jsStartupVisibility);
355 
356     int32_t processMode;
357     if (!ConvertFromJsValue(env, jsProcessMode, processMode)) {
358         WLOGFE("[NAPI]Failed to convert parameter to processMode");
359         return false;
360     }
361 
362     int32_t startupVisibility;
363     if (!ConvertFromJsValue(env, jsStartupVisibility, startupVisibility)) {
364         WLOGFE("[NAPI]Failed to convert parameter to startupVisibility");
365         return false;
366     }
367     processOptions->processMode = static_cast<AAFwk::ProcessMode>(processMode);
368     processOptions->startupVisibility = static_cast<AAFwk::StartupVisibility>(startupVisibility);
369 
370     return true;
371 }
372 
ConvertSessionInfoState(napi_env env,napi_value jsObject,SessionInfo & sessionInfo)373 bool ConvertSessionInfoState(napi_env env, napi_value jsObject, SessionInfo& sessionInfo)
374 {
375     napi_value jsPersistentId = nullptr;
376     napi_get_named_property(env, jsObject, "persistentId", &jsPersistentId);
377     napi_value jsCallState = nullptr;
378     napi_get_named_property(env, jsObject, "callState", &jsCallState);
379     napi_value jsSessionType = nullptr;
380     napi_get_named_property(env, jsObject, "sessionType", &jsSessionType);
381     napi_value jsIsPersistentRecover = nullptr;
382     napi_get_named_property(env, jsObject, "isPersistentRecover", &jsIsPersistentRecover);
383     napi_value jsScreenId = nullptr;
384     napi_get_named_property(env, jsObject, "screenId", &jsScreenId);
385     napi_value jsIsRotable = nullptr;
386     napi_get_named_property(env, jsObject, "isRotatable", &jsIsRotable);
387     napi_value jsIsSetPointerAreas = nullptr;
388     napi_get_named_property(env, jsObject, "isSetPointerAreas", &jsIsSetPointerAreas);
389     napi_value jsProcessOption = nullptr;
390     napi_get_named_property(env, jsObject, "processOptions", &jsProcessOption);
391 
392     if (!IsJsPersistentIdUndefind(env, jsPersistentId, sessionInfo)) {
393         return false;
394     }
395     if (!IsJsCallStateUndefind(env, jsCallState, sessionInfo)) {
396         return false;
397     }
398     if (!IsJsSessionTypeUndefind(env, jsSessionType, sessionInfo)) {
399         return false;
400     }
401     if (!IsJsScreenIdUndefind(env, jsScreenId, sessionInfo)) {
402         return false;
403     }
404     if (!IsJsIsPersistentRecoverUndefined(env, jsIsPersistentRecover, sessionInfo)) {
405         return false;
406     }
407     if (!IsJsIsRotatableUndefined(env, jsIsRotable, sessionInfo)) {
408         return false;
409     }
410     if (!IsJsIsSetPointerAreasUndefined(env, jsIsSetPointerAreas, sessionInfo)) {
411         return false;
412     }
413     if (!IsJsProcessOptionUndefined(env, jsProcessOption, sessionInfo)) {
414         return false;
415     }
416     return true;
417 }
418 
CreateJsProcessOption(napi_env env,std::shared_ptr<AAFwk::ProcessOptions> processOptions)419 napi_value CreateJsProcessOption(napi_env env, std::shared_ptr<AAFwk::ProcessOptions> processOptions)
420 {
421     napi_value objValue = nullptr;
422     napi_create_object(env, &objValue);
423     if (objValue == nullptr) {
424         WLOGFE("Failed to get object");
425         return nullptr;
426     }
427 
428     int32_t processMode = static_cast<int32_t>(processOptions->processMode);
429     int32_t startupVisibility = static_cast<int32_t>(processOptions->startupVisibility);
430 
431     napi_set_named_property(env, objValue, "processMode", CreateJsValue(env, processMode));
432     napi_set_named_property(env, objValue, "startupVisibility", CreateJsValue(env, startupVisibility));
433 
434     return objValue;
435 }
436 
ConvertSessionInfoFromJs(napi_env env,napi_value jsObject,SessionInfo & sessionInfo)437 bool ConvertSessionInfoFromJs(napi_env env, napi_value jsObject, SessionInfo& sessionInfo)
438 {
439     if (!ConvertSessionInfoName(env, jsObject, sessionInfo)) {
440         return false;
441     }
442     if (!ConvertSessionInfoState(env, jsObject, sessionInfo)) {
443         return false;
444     }
445     return true;
446 }
447 
IsJsObjNameUndefind(napi_env env,napi_value jsObjName,int32_t & objName)448 bool IsJsObjNameUndefind(napi_env env, napi_value jsObjName, int32_t& objName)
449 {
450     if (GetType(env, jsObjName) != napi_undefined) {
451         if (!ConvertFromJsValue(env, jsObjName, objName)) {
452             WLOGFE("[NAPI]Failed to convert parameter to objName");
453             return false;
454         }
455     }
456     return true;
457 }
458 
ConvertRectInfoFromJs(napi_env env,napi_value jsObject,WSRect & rect)459 bool ConvertRectInfoFromJs(napi_env env, napi_value jsObject, WSRect& rect)
460 {
461     napi_value jsLeftName = nullptr;
462     napi_get_named_property(env, jsObject, "left", &jsLeftName);
463     napi_value jsTopName = nullptr;
464     napi_get_named_property(env, jsObject, "top", &jsTopName);
465     napi_value jsRightName = nullptr;
466     napi_get_named_property(env, jsObject, "right", &jsRightName);
467     napi_value jsBottomName = nullptr;
468     napi_get_named_property(env, jsObject, "bottom", &jsBottomName);
469 
470     int32_t leftName = 0;
471     if (!IsJsObjNameUndefind(env, jsLeftName, leftName)) {
472         return false;
473     }
474     rect.posX_ = leftName;
475 
476     int32_t topName = 0;
477     if (!IsJsObjNameUndefind(env, jsTopName, topName)) {
478         return false;
479     }
480     rect.posY_ = topName;
481 
482     int32_t rightName = 0;
483     if (!IsJsObjNameUndefind(env, jsRightName, rightName)) {
484         return false;
485     }
486     rect.width_ = rightName - rect.posX_;
487 
488     int32_t bottomName = 0;
489     if (!IsJsObjNameUndefind(env, jsBottomName, bottomName)) {
490         return false;
491     }
492     rect.height_ = bottomName - rect.posY_;
493     return true;
494 }
495 
ConvertHookInfoFromJs(napi_env env,napi_value jsObject,HookInfo & hookInfo)496 bool ConvertHookInfoFromJs(napi_env env, napi_value jsObject, HookInfo& hookInfo)
497 {
498     napi_value jsWidth = nullptr;
499     napi_get_named_property(env, jsObject, "width", &jsWidth);
500     napi_value jsHeight = nullptr;
501     napi_get_named_property(env, jsObject, "height", &jsHeight);
502     napi_value jsDensity = nullptr;
503     napi_get_named_property(env, jsObject, "density", &jsDensity);
504     napi_value jsRotation = nullptr;
505     napi_get_named_property(env, jsObject, "rotation", &jsRotation);
506     napi_value jsEnableHookRotation = nullptr;
507     napi_get_named_property(env, jsObject, "enableHookRotation", &jsEnableHookRotation);
508 
509     uint32_t width = 0;
510     if (!ConvertFromJsValue(env, jsWidth, width)) {
511         TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Failed to convert parameter to width");
512         return false;
513     }
514     hookInfo.width_ = width;
515 
516     uint32_t height = 0;
517     if (!ConvertFromJsValue(env, jsHeight, height)) {
518         TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Failed to convert parameter to height");
519         return false;
520     }
521     hookInfo.height_ = height;
522 
523     double_t density = 1.0;
524     if (!ConvertFromJsValue(env, jsDensity, density)) {
525         TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Failed to convert parameter to density");
526         return false;
527     }
528     hookInfo.density_ = static_cast<float_t>(density);
529 
530     uint32_t rotation = 0;
531     if (!ConvertFromJsValue(env, jsRotation, rotation)) {
532         TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Failed to convert parameter to rotation");
533         return false;
534     }
535     hookInfo.rotation_ = rotation;
536 
537     bool enableHookRotation = false;
538     if (!ConvertFromJsValue(env, jsEnableHookRotation, enableHookRotation)) {
539         TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Failed to convert parameter to enableHookRotation");
540         return false;
541     }
542     hookInfo.enableHookRotation_ = enableHookRotation;
543     return true;
544 }
545 
ConvertPointerItemFromJs(napi_env env,napi_value touchObject,MMI::PointerEvent & pointerEvent)546 bool ConvertPointerItemFromJs(napi_env env, napi_value touchObject, MMI::PointerEvent& pointerEvent)
547 {
548     auto vpr = RootScene::staticRootScene_->GetDisplayDensity();
549     MMI::PointerEvent::PointerItem pointerItem;
550     napi_value jsId = nullptr;
551     napi_get_named_property(env, touchObject, "id", &jsId);
552     napi_value jsTouchType = nullptr;
553     napi_get_named_property(env, touchObject, "type", &jsTouchType);
554     napi_value jsWindowX = nullptr;
555     napi_get_named_property(env, touchObject, "windowX", &jsWindowX);
556     napi_value jsWindowY = nullptr;
557     napi_get_named_property(env, touchObject, "windowY", &jsWindowY);
558     napi_value jsDisplayX = nullptr;
559     napi_get_named_property(env, touchObject, "displayX", &jsDisplayX);
560     napi_value jsDisplayY = nullptr;
561     napi_get_named_property(env, touchObject, "displayY", &jsDisplayY);
562     int32_t id;
563     if (!ConvertFromJsValue(env, jsId, id)) {
564         WLOGFE("[NAPI]Failed to convert parameter to id");
565         return false;
566     }
567     pointerItem.SetPointerId(id);
568     pointerEvent.SetPointerId(id);
569     int32_t touchType;
570     if (!ConvertFromJsValue(env, jsTouchType, touchType)) {
571         WLOGFE("[NAPI]Failed to convert parameter to touchType");
572         return false;
573     }
574     pointerEvent.SetPointerAction(GetMMITouchType(touchType));
575     double windowX;
576     if (!ConvertFromJsValue(env, jsWindowX, windowX)) {
577         WLOGFE("[NAPI]Failed to convert parameter to windowX");
578         return false;
579     }
580     pointerItem.SetWindowX(std::round(windowX * vpr));
581     double windowY;
582     if (!ConvertFromJsValue(env, jsWindowY, windowY)) {
583         WLOGFE("[NAPI]Failed to convert parameter to windowY");
584         return false;
585     }
586     pointerItem.SetWindowY(std::round(windowY * vpr));
587     double displayX;
588     if (!ConvertFromJsValue(env, jsDisplayX, displayX)) {
589         WLOGFE("[NAPI]Failed to convert parameter to displayX");
590         return false;
591     }
592     pointerItem.SetDisplayX(std::round(displayX * vpr));
593     double displayY;
594     if (!ConvertFromJsValue(env, jsDisplayY, displayY)) {
595         WLOGFE("[NAPI]Failed to convert parameter to displayY");
596         return false;
597     }
598     pointerItem.SetDisplayY(std::round(displayY * vpr));
599     pointerEvent.AddPointerItem(pointerItem);
600     return true;
601 }
602 
ConvertTouchesObjectFromJs(napi_env env,napi_value jsTouches,int32_t pointerId,MMI::PointerEvent & pointerEvent)603 bool ConvertTouchesObjectFromJs(napi_env env, napi_value jsTouches, int32_t pointerId, MMI::PointerEvent& pointerEvent)
604 {
605     // iterator touches
606     if (jsTouches == nullptr) {
607         WLOGFE("[NAPI]Failed to convert to touchesObject list");
608         return false;
609     }
610     bool isArray = false;
611     napi_is_array(env, jsTouches, &isArray);
612     if (!isArray) {
613         return false;
614     }
615     uint32_t length = 0;
616     napi_get_array_length(env, jsTouches, &length);
617     for (uint32_t i = 0; i < length; i++) {
618         napi_value touchesObject = nullptr;
619         napi_get_element(env, jsTouches, i, &touchesObject);
620         if (touchesObject == nullptr) {
621             WLOGFE("[NAPI]Failed get to touchesObject");
622             return false;
623         }
624         napi_value jsNoChangedId = nullptr;
625         napi_get_named_property(env, touchesObject, "id", &jsNoChangedId);
626         int32_t noChangedId;
627         if (!ConvertFromJsValue(env, jsNoChangedId, noChangedId)) {
628             WLOGFE("[NAPI]Failed to convert parameter to jsNoChangeId");
629             return false;
630         }
631         if (pointerId == noChangedId) {
632             continue;
633         }
634         if (!ConvertPointerItemFromJs(env, touchesObject, pointerEvent)) {
635             return false;
636         }
637     }
638     return true;
639 }
640 
ConvertPointerEventFromJs(napi_env env,napi_value jsObject,MMI::PointerEvent & pointerEvent)641 bool ConvertPointerEventFromJs(napi_env env, napi_value jsObject, MMI::PointerEvent& pointerEvent)
642 {
643     napi_value jsSourceType = nullptr;
644     napi_get_named_property(env, jsObject, "source", &jsSourceType);
645     napi_value jsTimestamp = nullptr;
646     napi_get_named_property(env, jsObject, "timestamp", &jsTimestamp);
647     napi_value jsChangedTouches = nullptr;
648     napi_get_named_property(env, jsObject, "changedTouches", &jsChangedTouches);
649     napi_value jsTouches = nullptr;
650     napi_get_named_property(env, jsObject, "touches", &jsTouches);
651     int32_t sourceType;
652     if (!ConvertFromJsValue(env, jsSourceType, sourceType)) {
653         WLOGFE("[NAPI]Failed to convert parameter to sourceType");
654         return false;
655     }
656     pointerEvent.SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
657     double timestamp;
658     if (!ConvertFromJsValue(env, jsTimestamp, timestamp)) {
659         WLOGFE("[NAPI]Failed to convert parameter to timestamp");
660         return false;
661     }
662     pointerEvent.SetActionTime(std::round(timestamp / US_PER_NS));
663     if (jsChangedTouches == nullptr) {
664         WLOGFE("[NAPI]Failed to convert parameter to touchesArray");
665         return false;
666     }
667     // use changedTouches[0] only
668     napi_value touchObject = nullptr;
669     napi_get_element(env, jsChangedTouches, 0, &touchObject);
670     if (touchObject == nullptr) {
671         WLOGFE("[NAPI]Failed get to touchObject");
672         return false;
673     }
674     napi_value jsId = nullptr;
675     napi_get_named_property(env, touchObject, "id", &jsId);
676     int32_t pointerId;
677     if (!ConvertFromJsValue(env, jsId, pointerId)) {
678         WLOGFE("[NAPI]Failed to convert parameter to id");
679         return false;
680     }
681     if (!ConvertPointerItemFromJs(env, touchObject, pointerEvent)) {
682         return false;
683     }
684     if (!ConvertTouchesObjectFromJs(env, jsTouches, pointerId, pointerEvent)) {
685         return false;
686     }
687     pointerEvent.SetPointerId(pointerId);
688     if (!ConvertDeviceIdFromJs(env, jsObject, pointerEvent)) {
689         return false;
690     }
691     return true;
692 }
693 
ConvertDeviceIdFromJs(napi_env env,napi_value jsObject,MMI::PointerEvent & pointerEvent)694 bool ConvertDeviceIdFromJs(napi_env env, napi_value jsObject, MMI::PointerEvent& pointerEvent)
695 {
696     napi_value jsDeviceId = nullptr;
697     napi_get_named_property(env, jsObject, "deviceId", &jsDeviceId);
698     int32_t deviceId = 0;
699     if (!ConvertFromJsValue(env, jsDeviceId, deviceId)) {
700         WLOGFE("[NAPI]Failed to convert parameter to deviceId");
701         return false;
702     }
703     pointerEvent.SetDeviceId(deviceId);
704     return true;
705 }
706 
ConvertInt32ArrayFromJs(napi_env env,napi_value jsObject,std::vector<int32_t> & intList)707 bool ConvertInt32ArrayFromJs(napi_env env, napi_value jsObject, std::vector<int32_t>& intList)
708 {
709     bool isArray = false;
710     napi_is_array(env, jsObject, &isArray);
711     if (jsObject == nullptr || !isArray) {
712         WLOGFE("[NAPI]Failed to convert to integer list");
713         return false;
714     }
715 
716     uint32_t length = 0;
717     napi_get_array_length(env, jsObject, &length);
718     for (uint32_t i = 0; i < length; i++) {
719         int32_t persistentId;
720         napi_value elementVal = nullptr;
721         napi_get_element(env, jsObject, i, &elementVal);
722         if (!ConvertFromJsValue(env, elementVal, persistentId)) {
723             WLOGFE("[NAPI]Failed to convert to index %{public}u to integer", i);
724             return false;
725         }
726         intList.push_back(persistentId);
727     }
728 
729     return true;
730 }
731 
ConvertStringMapFromJs(napi_env env,napi_value value,std::unordered_map<std::string,std::string> & stringMap)732 bool ConvertStringMapFromJs(napi_env env, napi_value value, std::unordered_map<std::string, std::string>& stringMap)
733 {
734     if (value == nullptr) {
735         WLOGFE("value is nullptr");
736         return false;
737     }
738 
739     if (!CheckTypeForNapiValue(env, value, napi_object)) {
740         WLOGFE("The type of value is not napi_object.");
741         return false;
742     }
743 
744     std::vector<std::string> propNames;
745     napi_value array = nullptr;
746     napi_get_property_names(env, value, &array);
747     if (!ParseArrayStringValue(env, array, propNames)) {
748         WLOGFE("Failed to property names");
749         return false;
750     }
751 
752     for (const auto &propName : propNames) {
753         napi_value prop = nullptr;
754         napi_get_named_property(env, value, propName.c_str(), &prop);
755         if (prop == nullptr) {
756             WLOGFW("prop is null: %{public}s", propName.c_str());
757             continue;
758         }
759         if (!CheckTypeForNapiValue(env, prop, napi_string)) {
760             WLOGFW("prop is not string: %{public}s", propName.c_str());
761             continue;
762         }
763         std::string valName;
764         if (!ConvertFromJsValue(env, prop, valName)) {
765             WLOGFW("Failed to ConvertFromJsValue: %{public}s", propName.c_str());
766             continue;
767         }
768         stringMap.emplace(propName, valName);
769     }
770     return true;
771 }
772 
ConvertRotateAnimationConfigFromJs(napi_env env,napi_value value,RotateAnimationConfig & config)773 bool ConvertRotateAnimationConfigFromJs(napi_env env, napi_value value, RotateAnimationConfig& config)
774 {
775     napi_value jsDuration = nullptr;
776     napi_get_named_property(env, value, "duration", &jsDuration);
777     if (GetType(env, jsDuration) != napi_undefined) {
778         int32_t duration = ROTATE_ANIMATION_DURATION;
779         if (!ConvertFromJsValue(env, jsDuration, duration)) {
780             TLOGE(WmsLogTag::DEFAULT, "Failed to convert parameter to duration");
781             return false;
782         }
783         config.duration_ = duration;
784     }
785     return true;
786 }
787 
ConvertJsonFromJs(napi_env env,napi_value value,nlohmann::json & payload)788 bool ConvertJsonFromJs(napi_env env, napi_value value, nlohmann::json& payload)
789 {
790     if (value == nullptr || !CheckTypeForNapiValue(env, value, napi_object)) {
791         WLOGFE("The type of value is not napi_object or is nullptr.");
792         return false;
793     }
794 
795     napi_value array = nullptr;
796     napi_get_property_names(env, value, &array);
797     std::vector<std::string> propNames;
798     if (!ParseArrayStringValue(env, array, propNames)) {
799         WLOGFE("Failed to property names");
800         return false;
801     }
802 
803     for (const auto& propName : propNames) {
804         napi_value prop = nullptr;
805         napi_get_named_property(env, value, propName.c_str(), &prop);
806         if (prop == nullptr) {
807             WLOGFW("prop is null: %{public}s", propName.c_str());
808             continue;
809         }
810         if (!CheckTypeForNapiValue(env, prop, napi_string)) {
811             WLOGFW("prop is not string: %{public}s", propName.c_str());
812             continue;
813         }
814         std::string valName;
815         if (!ConvertFromJsValue(env, prop, valName)) {
816             WLOGFW("Failed to ConvertFromJsValue: %{public}s", propName.c_str());
817             continue;
818         }
819         payload[propName] = std::move(valName);
820     }
821     return true;
822 }
823 
ConvertDragResizeTypeFromJs(napi_env env,napi_value value,DragResizeType & dragResizeType)824 bool ConvertDragResizeTypeFromJs(napi_env env, napi_value value, DragResizeType& dragResizeType)
825 {
826     uint32_t dragResizeTypeValue;
827     if (!ConvertFromJsValue(env, value, dragResizeTypeValue)) {
828         return false;
829     }
830     if (dragResizeTypeValue > static_cast<uint32_t>(DragResizeType::RESIZE_WHEN_DRAG_END)) {
831         TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert parameter to dragResizeType");
832         return false;
833     }
834     dragResizeType = static_cast<DragResizeType>(dragResizeTypeValue);
835     return true;
836 }
837 
ParseArrayStringValue(napi_env env,napi_value array,std::vector<std::string> & vector)838 bool ParseArrayStringValue(napi_env env, napi_value array, std::vector<std::string> &vector)
839 {
840     if (array == nullptr) {
841         WLOGFE("array is nullptr!");
842         return false;
843     }
844     bool isArray = false;
845     if (napi_is_array(env, array, &isArray) != napi_ok || isArray == false) {
846         WLOGFE("not array!");
847         return false;
848     }
849 
850     uint32_t arrayLen = 0;
851     napi_get_array_length(env, array, &arrayLen);
852     if (arrayLen == 0) {
853         return true;
854     }
855     vector.reserve(arrayLen);
856     for (uint32_t i = 0; i < arrayLen; i++) {
857         std::string strItem;
858         napi_value jsValue = nullptr;
859         napi_get_element(env, array, i, &jsValue);
860         if (!ConvertFromJsValue(env, jsValue, strItem)) {
861             WLOGFW("Failed to ConvertFromJsValue, index: %{public}u", i);
862             continue;
863         }
864         vector.emplace_back(std::move(strItem));
865     }
866     return true;
867 }
868 
GetApiType(WindowType type)869 JsSessionType GetApiType(WindowType type)
870 {
871     auto iter = WINDOW_TO_JS_SESSION_TYPE_MAP.find(type);
872     if (iter == WINDOW_TO_JS_SESSION_TYPE_MAP.end()) {
873         WLOGFE("[NAPI]window type: %{public}u cannot map to api type!", type);
874         return JsSessionType::TYPE_UNDEFINED;
875     } else {
876         return iter->second;
877     }
878 }
879 
CreateSupportWindowModes(napi_env env,const std::vector<AppExecFwk::SupportWindowMode> & supportWindowModes)880 static napi_value CreateSupportWindowModes(napi_env env,
881     const std::vector<AppExecFwk::SupportWindowMode>& supportWindowModes)
882 {
883     napi_value arrayValue = nullptr;
884     napi_create_array_with_length(env, supportWindowModes.size(), &arrayValue);
885     if (arrayValue == nullptr) {
886         TLOGE(WmsLogTag::WMS_LIFE, "Failed to create napi array");
887         return NapiGetUndefined(env);
888     }
889     int32_t index = 0;
890     for (const auto supportWindowMode : supportWindowModes) {
891         napi_set_element(env, arrayValue, index++, CreateJsValue(env, static_cast<int32_t>(supportWindowMode)));
892     }
893     return arrayValue;
894 }
895 
CreateJsSessionInfo(napi_env env,const SessionInfo & sessionInfo)896 napi_value CreateJsSessionInfo(napi_env env, const SessionInfo& sessionInfo)
897 {
898     napi_value objValue = nullptr;
899     napi_create_object(env, &objValue);
900     if (objValue == nullptr) {
901         WLOGFE("[NAPI]Failed to get jsObject");
902         return nullptr;
903     }
904     napi_set_named_property(env, objValue, "bundleName", CreateJsValue(env, sessionInfo.bundleName_));
905     napi_set_named_property(env, objValue, "moduleName", CreateJsValue(env, sessionInfo.moduleName_));
906     napi_set_named_property(env, objValue, "abilityName", CreateJsValue(env, sessionInfo.abilityName_));
907     napi_set_named_property(env, objValue, "appIndex", CreateJsValue(env, sessionInfo.appIndex_));
908     napi_set_named_property(env, objValue, "isSystem", CreateJsValue(env, sessionInfo.isSystem_));
909     napi_set_named_property(env, objValue, "isCastSession", CreateJsValue(env, sessionInfo.isCastSession_));
910     napi_set_named_property(env, objValue, "persistentId",
911         CreateJsValue(env, static_cast<int32_t>(sessionInfo.persistentId_)));
912     napi_set_named_property(env, objValue, "callerPersistentId",
913         CreateJsValue(env, static_cast<int32_t>(sessionInfo.callerPersistentId_)));
914     napi_set_named_property(env, objValue, "callerBundleName", CreateJsValue(env, sessionInfo.callerBundleName_));
915     napi_set_named_property(env, objValue, "callerAbilityName", CreateJsValue(env, sessionInfo.callerAbilityName_));
916     napi_set_named_property(env, objValue, "callState",
917         CreateJsValue(env, static_cast<int32_t>(sessionInfo.callState_)));
918     napi_set_named_property(env, objValue, "windowMode",
919         CreateJsValue(env, static_cast<int32_t>(sessionInfo.windowMode)));
920     napi_set_named_property(env, objValue, "screenId",
921         CreateJsValue(env, static_cast<int32_t>(sessionInfo.screenId_)));
922     napi_set_named_property(env, objValue, "sessionType",
923         CreateJsValue(env, static_cast<uint32_t>(GetApiType(static_cast<WindowType>(sessionInfo.windowType_)))));
924     napi_set_named_property(env, objValue, "sessionState",
925         CreateJsValue(env, static_cast<int32_t>(sessionInfo.sessionState_)));
926     napi_set_named_property(env, objValue, "requestOrientation",
927         CreateJsValue(env, sessionInfo.requestOrientation_));
928     napi_set_named_property(env, objValue, "isCalledRightlyByCallerId",
929         CreateJsValue(env, sessionInfo.isCalledRightlyByCallerId_));
930     napi_set_named_property(env, objValue, "isAtomicService",
931         CreateJsValue(env, sessionInfo.isAtomicService_));
932     napi_set_named_property(env, objValue, "isBackTransition",
933         CreateJsValue(env, sessionInfo.isBackTransition_));
934     napi_set_named_property(env, objValue, "needClearInNotShowRecent",
935         CreateJsValue(env, sessionInfo.needClearInNotShowRecent_));
936     if (sessionInfo.processOptions != nullptr) {
937         napi_set_named_property(env, objValue, "processOptions",
938             CreateJsProcessOption(env, sessionInfo.processOptions));
939     }
940     napi_set_named_property(env, objValue, "errorReason",
941         CreateJsValue(env, sessionInfo.errorReason));
942     napi_set_named_property(env, objValue, "isFromIcon", CreateJsValue(env, sessionInfo.isFromIcon_));
943     SetJsSessionInfoByWant(env, sessionInfo, objValue);
944     if (sessionInfo.want != nullptr) {
945         napi_set_named_property(env, objValue, "want", AppExecFwk::WrapWant(env, *sessionInfo.want));
946     }
947     napi_set_named_property(env, objValue, "supportWindowModes",
948         CreateSupportWindowModes(env, sessionInfo.supportWindowModes));
949     return objValue;
950 }
951 
CreateJsSessionRecoverInfo(napi_env env,const SessionInfo & sessionInfo,const sptr<WindowSessionProperty> property)952 napi_value CreateJsSessionRecoverInfo(
953     napi_env env, const SessionInfo& sessionInfo, const sptr<WindowSessionProperty> property)
954 {
955     napi_value objValue = nullptr;
956     napi_create_object(env, &objValue);
957     if (objValue == nullptr) {
958         WLOGFE("[NAPI]Failed to get jsObject");
959         return nullptr;
960     }
961     napi_set_named_property(env, objValue, "bundleName", CreateJsValue(env, sessionInfo.bundleName_));
962     napi_set_named_property(env, objValue, "moduleName", CreateJsValue(env, sessionInfo.moduleName_));
963     napi_set_named_property(env, objValue, "abilityName", CreateJsValue(env, sessionInfo.abilityName_));
964     napi_set_named_property(env, objValue, "appIndex", CreateJsValue(env, sessionInfo.appIndex_));
965     napi_set_named_property(env, objValue, "screenId",
966         CreateJsValue(env, static_cast<int32_t>(sessionInfo.screenId_)));
967     napi_set_named_property(env, objValue, "windowMode",
968         CreateJsValue(env, static_cast<int32_t>(sessionInfo.windowMode)));
969     napi_set_named_property(env, objValue, "sessionState",
970         CreateJsValue(env, static_cast<int32_t>(sessionInfo.sessionState_)));
971     napi_set_named_property(env, objValue, "sessionType",
972         CreateJsValue(env, static_cast<uint32_t>(GetApiType(static_cast<WindowType>(sessionInfo.windowType_)))));
973     napi_set_named_property(env, objValue, "requestOrientation",
974         CreateJsValue(env, sessionInfo.requestOrientation_));
975     Rect rect = property->GetWindowRect();
976     WSRect wsRect = { rect.posX_, rect.posY_, rect.width_, rect.height_ };
977     napi_set_named_property(env, objValue, "recoverRect", CreateJsSessionRect(env, wsRect));
978     napi_set_named_property(env, objValue, "mainWindowTopmost", CreateJsValue(env, property->IsMainWindowTopmost()));
979     return objValue;
980 }
981 
SetJsSessionInfoByWant(napi_env env,const SessionInfo & sessionInfo,napi_value objValue)982 void SetJsSessionInfoByWant(napi_env env, const SessionInfo& sessionInfo, napi_value objValue)
983 {
984     if (sessionInfo.want != nullptr) {
985         napi_set_named_property(env, objValue, "windowTop",
986             GetWindowRectIntValue(env,
987             sessionInfo.want->GetIntParam(AAFwk::Want::PARAM_RESV_WINDOW_TOP, INVALID_VAL)));
988         napi_set_named_property(env, objValue, "windowLeft",
989             GetWindowRectIntValue(env,
990             sessionInfo.want->GetIntParam(AAFwk::Want::PARAM_RESV_WINDOW_LEFT, INVALID_VAL)));
991         napi_set_named_property(env, objValue, "windowWidth",
992             GetWindowRectIntValue(env,
993             sessionInfo.want->GetIntParam(AAFwk::Want::PARAM_RESV_WINDOW_WIDTH, INVALID_VAL)));
994         napi_set_named_property(env, objValue, "windowHeight",
995             GetWindowRectIntValue(env,
996             sessionInfo.want->GetIntParam(AAFwk::Want::PARAM_RESV_WINDOW_HEIGHT, INVALID_VAL)));
997         napi_set_named_property(env, objValue, "withAnimation",
998             CreateJsValue(env, sessionInfo.want->GetBoolParam(AAFwk::Want::PARAM_RESV_WITH_ANIMATION, true)));
999         napi_set_named_property(env, objValue, "focusedOnShow",
1000             CreateJsValue(env, sessionInfo.want->GetBoolParam(AAFwk::Want::PARAM_RESV_WINDOW_FOCUSED, true)));
1001         napi_set_named_property(env, objValue, "isStartupInstallFree",
1002             CreateJsValue(env, (sessionInfo.want->GetFlags() & AAFwk::Want::FLAG_INSTALL_ON_DEMAND) ==
1003                 AAFwk::Want::FLAG_INSTALL_ON_DEMAND));
1004         auto params = sessionInfo.want->GetParams();
1005         napi_set_named_property(env, objValue, "fileManagerMode",
1006             CreateJsValue(env, params.GetStringParam("fileManagerMode")));
1007         napi_set_named_property(env, objValue, "floatingDisplayMode",
1008             CreateJsValue(env, params.GetIntParam("floatingDisplayMode", INVALID_VAL)));
1009         auto executeParams = params.GetWantParams("ohos.insightIntent.executeParam.param");
1010         napi_set_named_property(env, objValue, "extraFormIdentity",
1011             CreateJsValue(env, executeParams.GetStringParam("ohos.extra.param.key.form_identity")));
1012         if (params.HasParam("expectWindowMode")) {
1013             napi_set_named_property(env, objValue, "expectWindowMode",
1014                 CreateJsValue(env, params.GetIntParam("expectWindowMode", INVALID_VAL)));
1015         }
1016         if (params.HasParam("isStartFromAppDock")) {
1017             napi_set_named_property(env, objValue, "isStartFromAppDock",
1018                 CreateJsValue(env, params.GetIntParam("isStartFromAppDock", INVALID_VAL)));
1019         }
1020         if (params.HasParam("dockAppDirection")) {
1021             napi_set_named_property(env, objValue, "dockAppDirection",
1022                 CreateJsValue(env, params.GetIntParam("dockAppDirection", INVALID_VAL)));
1023         }
1024         if (params.HasParam("isAppFromRecentAppsOrDockApps")) {
1025             napi_set_named_property(env, objValue, "isAppFromRecentAppsOrDockApps",
1026                 CreateJsValue(env, params.GetIntParam("isAppFromRecentAppsOrDockApps", INVALID_VAL)));
1027         }
1028     }
1029 }
1030 
GetWindowRectIntValue(napi_env env,int val)1031 napi_value GetWindowRectIntValue(napi_env env, int val)
1032 {
1033     if (val != INVALID_VAL) {
1034         return  CreateJsValue(env, val);
1035     } else {
1036         return NapiGetUndefined(env);
1037     }
1038 }
1039 
CreateJsSessionState(napi_env env)1040 napi_value CreateJsSessionState(napi_env env)
1041 {
1042     napi_value objValue = nullptr;
1043     napi_create_object(env, &objValue);
1044     if (objValue == nullptr) {
1045         WLOGFE("Failed to get object");
1046         return nullptr;
1047     }
1048 
1049     napi_set_named_property(env, objValue, "STATE_DISCONNECT", CreateJsValue(env,
1050         static_cast<int32_t>(SessionState::STATE_DISCONNECT)));
1051     napi_set_named_property(env, objValue, "STATE_CONNECT", CreateJsValue(env,
1052         static_cast<int32_t>(SessionState::STATE_CONNECT)));
1053     napi_set_named_property(env, objValue, "STATE_FOREGROUND", CreateJsValue(env,
1054         static_cast<int32_t>(SessionState::STATE_FOREGROUND)));
1055     napi_set_named_property(env, objValue, "STATE_ACTIVE", CreateJsValue(env,
1056         static_cast<int32_t>(SessionState::STATE_ACTIVE)));
1057     napi_set_named_property(env, objValue, "STATE_INACTIVE", CreateJsValue(env,
1058         static_cast<int32_t>(SessionState::STATE_INACTIVE)));
1059     napi_set_named_property(env, objValue, "STATE_BACKGROUND", CreateJsValue(env,
1060         static_cast<int32_t>(SessionState::STATE_BACKGROUND)));
1061     napi_set_named_property(env, objValue, "STATE_END", CreateJsValue(env,
1062         static_cast<int32_t>(SessionState::STATE_END)));
1063 
1064     return objValue;
1065 }
1066 
CreateJsSessionSizeChangeReason(napi_env env)1067 napi_value CreateJsSessionSizeChangeReason(napi_env env)
1068 {
1069     napi_value objValue = nullptr;
1070     napi_create_object(env, &objValue);
1071     if (objValue == nullptr) {
1072         WLOGFE("Failed to get object");
1073         return nullptr;
1074     }
1075 
1076     napi_set_named_property(env, objValue, "UNDEFINED", CreateJsValue(env,
1077         static_cast<int32_t>(SizeChangeReason::UNDEFINED)));
1078     napi_set_named_property(env, objValue, "MAXIMIZE", CreateJsValue(env,
1079         static_cast<int32_t>(SizeChangeReason::MAXIMIZE)));
1080     napi_set_named_property(env, objValue, "RECOVER", CreateJsValue(env,
1081         static_cast<int32_t>(SizeChangeReason::RECOVER)));
1082     napi_set_named_property(env, objValue, "ROTATION", CreateJsValue(env,
1083         static_cast<int32_t>(SizeChangeReason::ROTATION)));
1084     napi_set_named_property(env, objValue, "DRAG", CreateJsValue(env,
1085         static_cast<int32_t>(SizeChangeReason::DRAG)));
1086     napi_set_named_property(env, objValue, "DRAG_START", CreateJsValue(env,
1087         static_cast<int32_t>(SizeChangeReason::DRAG_START)));
1088     napi_set_named_property(env, objValue, "DRAG_MOVE", CreateJsValue(env,
1089         static_cast<int32_t>(SizeChangeReason::DRAG_MOVE)));
1090     napi_set_named_property(env, objValue, "DRAG_END", CreateJsValue(env,
1091         static_cast<int32_t>(SizeChangeReason::DRAG_END)));
1092     napi_set_named_property(env, objValue, "RESIZE", CreateJsValue(env,
1093         static_cast<int32_t>(SizeChangeReason::RESIZE)));
1094     napi_set_named_property(env, objValue, "MOVE", CreateJsValue(env,
1095         static_cast<int32_t>(SizeChangeReason::MOVE)));
1096     napi_set_named_property(env, objValue, "HIDE", CreateJsValue(env,
1097         static_cast<int32_t>(SizeChangeReason::HIDE)));
1098     napi_set_named_property(env, objValue, "TRANSFORM", CreateJsValue(env,
1099         static_cast<int32_t>(SizeChangeReason::TRANSFORM)));
1100     napi_set_named_property(env, objValue, "CUSTOM_ANIMATION_SHOW", CreateJsValue(env,
1101         static_cast<int32_t>(SizeChangeReason::CUSTOM_ANIMATION_SHOW)));
1102     napi_set_named_property(env, objValue, "FULL_TO_SPLIT", CreateJsValue(env,
1103         static_cast<int32_t>(SizeChangeReason::FULL_TO_SPLIT)));
1104     napi_set_named_property(env, objValue, "SPLIT_TO_FULL", CreateJsValue(env,
1105         static_cast<int32_t>(SizeChangeReason::SPLIT_TO_FULL)));
1106     napi_set_named_property(env, objValue, "FULL_TO_FLOATING", CreateJsValue(env,
1107         static_cast<int32_t>(SizeChangeReason::FULL_TO_FLOATING)));
1108     napi_set_named_property(env, objValue, "FLOATING_TO_FULL", CreateJsValue(env,
1109         static_cast<int32_t>(SizeChangeReason::FLOATING_TO_FULL)));
1110     CreatePiPSizeChangeReason(env, objValue);
1111     napi_set_named_property(env, objValue, "END", CreateJsValue(env,
1112         static_cast<int32_t>(SizeChangeReason::END)));
1113 
1114     return objValue;
1115 }
1116 
CreatePiPSizeChangeReason(napi_env env,napi_value objValue)1117 void CreatePiPSizeChangeReason(napi_env env, napi_value objValue)
1118 {
1119     napi_set_named_property(env, objValue, "PIP_START", CreateJsValue(env,
1120         static_cast<int32_t>(SizeChangeReason::PIP_START)));
1121     napi_set_named_property(env, objValue, "PIP_SHOW", CreateJsValue(env,
1122         static_cast<int32_t>(SizeChangeReason::PIP_SHOW)));
1123     napi_set_named_property(env, objValue, "PIP_AUTO_START", CreateJsValue(env,
1124         static_cast<int32_t>(SizeChangeReason::PIP_AUTO_START)));
1125     napi_set_named_property(env, objValue, "PIP_RATIO_CHANGE", CreateJsValue(env,
1126         static_cast<int32_t>(SizeChangeReason::PIP_RATIO_CHANGE)));
1127     napi_set_named_property(env, objValue, "PIP_RESTORE", CreateJsValue(env,
1128         static_cast<int32_t>(SizeChangeReason::PIP_RESTORE)));
1129 }
1130 
CreateJsSessionStartupVisibility(napi_env env)1131 napi_value CreateJsSessionStartupVisibility(napi_env env)
1132 {
1133     if (env == nullptr) {
1134         WLOGFE("Env is nullptr");
1135         return nullptr;
1136     }
1137     napi_value objValue = nullptr;
1138     napi_create_object(env, &objValue);
1139     if (objValue == nullptr) {
1140         WLOGFE("Failed to create object!");
1141         return NapiGetUndefined(env);
1142     }
1143 
1144     napi_set_named_property(env, objValue, "UNSPECIFIED", CreateJsValue(env,
1145         static_cast<int32_t>(AAFwk::StartupVisibility::UNSPECIFIED)));
1146     napi_set_named_property(env, objValue, "STARTUP_HIDE", CreateJsValue(env,
1147         static_cast<int32_t>(AAFwk::StartupVisibility::STARTUP_HIDE)));
1148     napi_set_named_property(env, objValue, "STARTUP_SHOW", CreateJsValue(env,
1149         static_cast<int32_t>(AAFwk::StartupVisibility::STARTUP_SHOW)));
1150     napi_set_named_property(env, objValue, "END", CreateJsValue(env,
1151         static_cast<int32_t>(AAFwk::StartupVisibility::END)));
1152     return objValue;
1153 }
1154 
CreateJsWindowVisibility(napi_env env)1155 napi_value CreateJsWindowVisibility(napi_env env)
1156 {
1157     if (env == nullptr) {
1158         WLOGFE("Env is nullptr");
1159         return nullptr;
1160     }
1161     napi_value objValue = nullptr;
1162     napi_create_object(env, &objValue);
1163     if (objValue == nullptr) {
1164         WLOGFE("Failed to create object!");
1165         return NapiGetUndefined(env);
1166     }
1167 
1168     napi_set_named_property(env, objValue, "NO_OCCLUSION", CreateJsValue(env,
1169         static_cast<int32_t>(WindowVisibilityState::WINDOW_VISIBILITY_STATE_NO_OCCLUSION)));
1170     napi_set_named_property(env, objValue, "PARTIAL_OCCLUSION", CreateJsValue(env,
1171         static_cast<int32_t>(WindowVisibilityState::WINDOW_VISIBILITY_STATE_PARTICALLY_OCCLUSION)));
1172     napi_set_named_property(env, objValue, "COMPLETE_OCCLUSION", CreateJsValue(env,
1173         static_cast<int32_t>(WindowVisibilityState::WINDOW_VISIBILITY_STATE_TOTALLY_OCCUSION)));
1174     napi_set_named_property(env, objValue, "END", CreateJsValue(env,
1175         static_cast<int32_t>(WindowVisibilityState::WINDOW_LAYER_STATE_MAX)));
1176     return objValue;
1177 }
1178 
CreateJsSessionProcessMode(napi_env env)1179 napi_value CreateJsSessionProcessMode(napi_env env)
1180 {
1181     if (env == nullptr) {
1182         WLOGFE("Env is nullptr");
1183         return nullptr;
1184     }
1185     napi_value objValue = nullptr;
1186     napi_create_object(env, &objValue);
1187     if (objValue == nullptr) {
1188         WLOGFE("Failed to create object!");
1189         return NapiGetUndefined(env);
1190     }
1191 
1192     napi_set_named_property(env, objValue, "UNSPECIFIED", CreateJsValue(env,
1193         static_cast<int32_t>(AAFwk::ProcessMode::UNSPECIFIED)));
1194     napi_set_named_property(env, objValue, "NEW_PROCESS_ATTACH_TO_PARENT", CreateJsValue(env,
1195         static_cast<int32_t>(AAFwk::ProcessMode::NEW_PROCESS_ATTACH_TO_PARENT)));
1196     napi_set_named_property(env, objValue, "NEW_PROCESS_ATTACH_TO_STATUS_BAR_ITEM", CreateJsValue(env,
1197         static_cast<int32_t>(AAFwk::ProcessMode::NEW_PROCESS_ATTACH_TO_STATUS_BAR_ITEM)));
1198     napi_set_named_property(env, objValue, "END", CreateJsValue(env,
1199         static_cast<int32_t>(AAFwk::ProcessMode::END)));
1200     return objValue;
1201 }
1202 
CreateJsSessionPiPControlType(napi_env env)1203 napi_value CreateJsSessionPiPControlType(napi_env env)
1204 {
1205     napi_value objValue = nullptr;
1206     napi_create_object(env, &objValue);
1207     if (objValue == nullptr) {
1208         WLOGFE("Failed to create object!");
1209         return NapiGetUndefined(env);
1210     }
1211 
1212     napi_set_named_property(env, objValue, "VIDEO_PLAY_PAUSE", CreateJsValue(env,
1213         static_cast<uint32_t>(PiPControlType::VIDEO_PLAY_PAUSE)));
1214     napi_set_named_property(env, objValue, "VIDEO_PREVIOUS", CreateJsValue(env,
1215         static_cast<uint32_t>(PiPControlType::VIDEO_PREVIOUS)));
1216     napi_set_named_property(env, objValue, "VIDEO_NEXT", CreateJsValue(env,
1217         static_cast<uint32_t>(PiPControlType::VIDEO_NEXT)));
1218     napi_set_named_property(env, objValue, "FAST_FORWARD", CreateJsValue(env,
1219         static_cast<uint32_t>(PiPControlType::FAST_FORWARD)));
1220     napi_set_named_property(env, objValue, "FAST_BACKWARD", CreateJsValue(env,
1221         static_cast<uint32_t>(PiPControlType::FAST_BACKWARD)));
1222     napi_set_named_property(env, objValue, "HANG_UP_BUTTON", CreateJsValue(env,
1223         static_cast<uint32_t>(PiPControlType::HANG_UP_BUTTON)));
1224     napi_set_named_property(env, objValue, "MICROPHONE_SWITCH", CreateJsValue(env,
1225         static_cast<uint32_t>(PiPControlType::MICROPHONE_SWITCH)));
1226     napi_set_named_property(env, objValue, "CAMERA_SWITCH", CreateJsValue(env,
1227         static_cast<uint32_t>(PiPControlType::CAMERA_SWITCH)));
1228     napi_set_named_property(env, objValue, "MUTE_SWITCH", CreateJsValue(env,
1229         static_cast<uint32_t>(PiPControlType::MUTE_SWITCH)));
1230     return objValue;
1231 }
1232 
CreateJsSessionPiPControlStatus(napi_env env)1233 napi_value CreateJsSessionPiPControlStatus(napi_env env)
1234 {
1235     napi_value objValue = nullptr;
1236     napi_create_object(env, &objValue);
1237     if (objValue == nullptr) {
1238         WLOGFE("Failed to create object!");
1239         return NapiGetUndefined(env);
1240     }
1241 
1242     napi_set_named_property(env, objValue, "PLAY", CreateJsValue(env,
1243         static_cast<int32_t>(PiPControlStatus::PLAY)));
1244     napi_set_named_property(env, objValue, "PAUSE", CreateJsValue(env,
1245         static_cast<int32_t>(PiPControlStatus::PAUSE)));
1246     napi_set_named_property(env, objValue, "OPEN", CreateJsValue(env,
1247         static_cast<int32_t>(PiPControlStatus::OPEN)));
1248     napi_set_named_property(env, objValue, "CLOSE", CreateJsValue(env,
1249         static_cast<int32_t>(PiPControlStatus::CLOSE)));
1250     napi_set_named_property(env, objValue, "ENABLED", CreateJsValue(env,
1251         static_cast<int32_t>(PiPControlStatus::ENABLED)));
1252     napi_set_named_property(env, objValue, "DISABLED", CreateJsValue(env,
1253         static_cast<int32_t>(PiPControlStatus::DISABLED)));
1254     return objValue;
1255 }
1256 
CreateJsSessionGravity(napi_env env)1257 napi_value CreateJsSessionGravity(napi_env env)
1258 {
1259     napi_value objValue = nullptr;
1260     napi_create_object(env, &objValue);
1261     if (objValue == nullptr) {
1262         WLOGFE("Failed to create object!");
1263         return NapiGetUndefined(env);
1264     }
1265     using T = std::underlying_type_t<Gravity>;
1266     napi_set_named_property(env, objValue, "CENTER", CreateJsValue(env,
1267         static_cast<T>(Gravity::CENTER)));
1268     napi_set_named_property(env, objValue, "TOP", CreateJsValue(env,
1269         static_cast<T>(Gravity::TOP)));
1270     napi_set_named_property(env, objValue, "BOTTOM", CreateJsValue(env,
1271         static_cast<T>(Gravity::BOTTOM)));
1272     napi_set_named_property(env, objValue, "LEFT", CreateJsValue(env,
1273         static_cast<T>(Gravity::LEFT)));
1274     napi_set_named_property(env, objValue, "RIGHT", CreateJsValue(env,
1275         static_cast<T>(Gravity::RIGHT)));
1276     napi_set_named_property(env, objValue, "TOP_LEFT", CreateJsValue(env,
1277         static_cast<T>(Gravity::TOP_LEFT)));
1278     napi_set_named_property(env, objValue, "TOP_RIGHT", CreateJsValue(env,
1279         static_cast<T>(Gravity::TOP_RIGHT)));
1280     napi_set_named_property(env, objValue, "BOTTOM_LEFT", CreateJsValue(env,
1281         static_cast<T>(Gravity::BOTTOM_LEFT)));
1282     napi_set_named_property(env, objValue, "BOTTOM_RIGHT", CreateJsValue(env,
1283         static_cast<T>(Gravity::BOTTOM_RIGHT)));
1284     napi_set_named_property(env, objValue, "RESIZE", CreateJsValue(env,
1285         static_cast<T>(Gravity::RESIZE)));
1286     napi_set_named_property(env, objValue, "RESIZE_ASPECT", CreateJsValue(env,
1287         static_cast<T>(Gravity::RESIZE_ASPECT)));
1288     napi_set_named_property(env, objValue, "RESIZE_ASPECT_TOP_LEFT", CreateJsValue(env,
1289         static_cast<T>(Gravity::RESIZE_ASPECT_TOP_LEFT)));
1290     napi_set_named_property(env, objValue, "RESIZE_ASPECT_BOTTOM_RIGHT", CreateJsValue(env,
1291         static_cast<T>(Gravity::RESIZE_ASPECT_BOTTOM_RIGHT)));
1292     napi_set_named_property(env, objValue, "RESIZE_ASPECT_FILL", CreateJsValue(env,
1293         static_cast<T>(Gravity::RESIZE_ASPECT_FILL)));
1294     napi_set_named_property(env, objValue, "RESIZE_ASPECT_FILL_TOP_LEFT", CreateJsValue(env,
1295         static_cast<T>(Gravity::RESIZE_ASPECT_FILL_TOP_LEFT)));
1296     napi_set_named_property(env, objValue, "RESIZE_ASPECT_FILL_BOTTOM_RIGHT", CreateJsValue(env,
1297         static_cast<T>(Gravity::RESIZE_ASPECT_FILL_BOTTOM_RIGHT)));
1298     return objValue;
1299 }
1300 
CreateJsSessionDragResizeType(napi_env env)1301 napi_value CreateJsSessionDragResizeType(napi_env env)
1302 {
1303     napi_value objValue = nullptr;
1304     napi_create_object(env, &objValue);
1305     if (objValue == nullptr) {
1306         TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to create object!");
1307         return NapiGetUndefined(env);
1308     }
1309 
1310     napi_set_named_property(env, objValue, "RESIZE_TYPE_UNDEFINED", CreateJsValue(env,
1311         static_cast<uint32_t>(DragResizeType::RESIZE_TYPE_UNDEFINED)));
1312     napi_set_named_property(env, objValue, "RESIZE_EACH_FRAME", CreateJsValue(env,
1313         static_cast<uint32_t>(DragResizeType::RESIZE_EACH_FRAME)));
1314     napi_set_named_property(env, objValue, "RESIZE_WHEN_DRAG_END", CreateJsValue(env,
1315         static_cast<uint32_t>(DragResizeType::RESIZE_WHEN_DRAG_END)));
1316     return objValue;
1317 }
1318 
1319 template<typename T>
CreateJsSessionRect(napi_env env,const T & rect)1320 napi_value CreateJsSessionRect(napi_env env, const T& rect)
1321 {
1322     WLOGFD("CreateJsSessionRect.");
1323     napi_value objValue = nullptr;
1324     napi_create_object(env, &objValue);
1325     if (objValue == nullptr) {
1326         WLOGFE("Failed to create object!");
1327         return NapiGetUndefined(env);
1328     }
1329 
1330     napi_set_named_property(env, objValue, "posX_", CreateJsValue(env, rect.posX_));
1331     napi_set_named_property(env, objValue, "posY_", CreateJsValue(env, rect.posY_));
1332     napi_set_named_property(env, objValue, "width_", CreateJsValue(env, rect.width_));
1333     napi_set_named_property(env, objValue, "height_", CreateJsValue(env, rect.height_));
1334     return objValue;
1335 }
1336 
CreateJsSessionEventParam(napi_env env,const SessionEventParam & param)1337 napi_value CreateJsSessionEventParam(napi_env env, const SessionEventParam& param)
1338 {
1339     WLOGFD("CreateJsSessionEventParam.");
1340     napi_value objValue = nullptr;
1341     napi_create_object(env, &objValue);
1342     if (objValue == nullptr) {
1343         WLOGFE("Failed to create object!");
1344         return NapiGetUndefined(env);
1345     }
1346 
1347     napi_set_named_property(env, objValue, "pointerX", CreateJsValue(env, param.pointerX_));
1348     napi_set_named_property(env, objValue, "pointerY", CreateJsValue(env, param.pointerY_));
1349     napi_set_named_property(env, objValue, "sessionWidth", CreateJsValue(env, param.sessionWidth_));
1350     napi_set_named_property(env, objValue, "sessionHeight", CreateJsValue(env, param.sessionHeight_));
1351     napi_set_named_property(env, objValue, "dragResizeType", CreateJsValue(env, param.dragResizeType));
1352     return objValue;
1353 }
1354 
SubWindowModalTypeInit(napi_env env)1355 napi_value SubWindowModalTypeInit(napi_env env)
1356 {
1357     if (env == nullptr) {
1358         TLOGE(WmsLogTag::WMS_SUB, "Env is nullptr");
1359         return nullptr;
1360     }
1361     napi_value objValue = nullptr;
1362     napi_create_object(env, &objValue);
1363     if (objValue == nullptr) {
1364         TLOGE(WmsLogTag::WMS_SUB, "Failed to get object");
1365         return nullptr;
1366     }
1367 
1368     napi_set_named_property(env, objValue, "TYPE_UNDEFINED", CreateJsValue(env,
1369         static_cast<int32_t>(SubWindowModalType::TYPE_UNDEFINED)));
1370     napi_set_named_property(env, objValue, "TYPE_NORMAL", CreateJsValue(env,
1371         static_cast<int32_t>(SubWindowModalType::TYPE_NORMAL)));
1372     napi_set_named_property(env, objValue, "TYPE_DIALOG", CreateJsValue(env,
1373         static_cast<int32_t>(SubWindowModalType::TYPE_DIALOG)));
1374     napi_set_named_property(env, objValue, "TYPE_WINDOW_MODALITY", CreateJsValue(env,
1375         static_cast<int32_t>(SubWindowModalType::TYPE_WINDOW_MODALITY)));
1376     napi_set_named_property(env, objValue, "TYPE_TOAST", CreateJsValue(env,
1377         static_cast<int32_t>(SubWindowModalType::TYPE_TOAST)));
1378     napi_set_named_property(env, objValue, "TYPE_APPLICATION_MODALITY", CreateJsValue(env,
1379         static_cast<int32_t>(SubWindowModalType::TYPE_APPLICATION_MODALITY)));
1380     return objValue;
1381 }
1382 
GetHexColor(uint32_t color)1383 static std::string GetHexColor(uint32_t color)
1384 {
1385     const int32_t rgbaLength = 8;
1386 
1387     std::stringstream ioss;
1388     std::string temp;
1389     ioss << std::setiosflags(std::ios::uppercase) << std::hex << color;
1390     ioss >> temp;
1391     int count = rgbaLength - static_cast<int>(temp.length());
1392     std::string finalColor("#");
1393     std::string tmpColor(count, '0');
1394     tmpColor += temp;
1395     finalColor += tmpColor;
1396 
1397     return finalColor;
1398 }
1399 
CreateJsSystemBarPropertyObject(napi_env env,const WindowType type,const SystemBarProperty & property)1400 static napi_value CreateJsSystemBarPropertyObject(
1401     napi_env env, const WindowType type, const SystemBarProperty& property)
1402 {
1403     napi_value objValue = nullptr;
1404     napi_create_object(env, &objValue);
1405     if (objValue == nullptr) {
1406         WLOGFE("Failed to get jsObject");
1407         return nullptr;
1408     }
1409     if (WINDOW_TO_JS_SESSION_TYPE_MAP.count(type) != 0) {
1410         napi_set_named_property(env, objValue, "type", CreateJsValue(env, WINDOW_TO_JS_SESSION_TYPE_MAP.at(type)));
1411     } else {
1412         napi_set_named_property(env, objValue, "type", CreateJsValue(env, type));
1413     }
1414     napi_set_named_property(env, objValue, "enable", CreateJsValue(env, property.enable_));
1415     std::string bkgColor = GetHexColor(property.backgroundColor_);
1416     napi_set_named_property(env, objValue, "backgroundcolor", CreateJsValue(env, bkgColor));
1417     std::string contentColor = GetHexColor(property.contentColor_);
1418     napi_set_named_property(env, objValue, "contentcolor", CreateJsValue(env, contentColor));
1419     napi_set_named_property(env, objValue, "enableAnimation", CreateJsValue(env, property.enableAnimation_));
1420     napi_set_named_property(
1421         env, objValue, "settingFlag", CreateJsValue(env, static_cast<uint32_t>(property.settingFlag_)));
1422 
1423     return objValue;
1424 }
1425 
CreateJsKeyboardLayoutParams(napi_env env,const KeyboardLayoutParams & params)1426 napi_value CreateJsKeyboardLayoutParams(napi_env env, const KeyboardLayoutParams& params)
1427 {
1428     napi_value objValue = nullptr;
1429     napi_create_object(env, &objValue);
1430     if (objValue == nullptr) {
1431         WLOGFE("Failed to get jsObject");
1432         return nullptr;
1433     }
1434 
1435     napi_set_named_property(env, objValue, "landscapeKeyboardRect",
1436         CreateJsSessionRect(env, params.LandscapeKeyboardRect_));
1437     napi_set_named_property(env, objValue, "portraitKeyboardRect",
1438         CreateJsSessionRect(env, params.PortraitKeyboardRect_));
1439     napi_set_named_property(env, objValue, "landscapePanelRect",
1440         CreateJsSessionRect(env, params.LandscapePanelRect_));
1441     napi_set_named_property(env, objValue, "portraitPanelRect",
1442         CreateJsSessionRect(env, params.PortraitPanelRect_));
1443     return objValue;
1444 }
1445 
CreateJsSystemBarPropertyArrayObject(napi_env env,const std::unordered_map<WindowType,SystemBarProperty> & propertyMap)1446 napi_value CreateJsSystemBarPropertyArrayObject(
1447     napi_env env, const std::unordered_map<WindowType, SystemBarProperty>& propertyMap)
1448 {
1449     if (propertyMap.empty()) {
1450         WLOGFE("Empty propertyMap");
1451         return nullptr;
1452     }
1453     napi_value arrayValue = nullptr;
1454     napi_create_array_with_length(env, propertyMap.size(), &arrayValue);
1455     if (arrayValue == nullptr) {
1456         WLOGFE("Failed to get jsArrayObject");
1457         return nullptr;
1458     }
1459     uint32_t index = 0;
1460     for (auto iter: propertyMap) {
1461         napi_set_element(env, arrayValue, index++, CreateJsSystemBarPropertyObject(env, iter.first, iter.second));
1462     }
1463     return arrayValue;
1464 }
1465 
SetTypeProperty(napi_value object,napi_env env,const std::string & name,JsSessionType type)1466 static void SetTypeProperty(napi_value object, napi_env env, const std::string& name, JsSessionType type)
1467 {
1468     napi_set_named_property(env, object, name.c_str(), CreateJsValue(env, static_cast<int32_t>(type)));
1469 }
1470 
KeyboardGravityInit(napi_env env)1471 napi_value KeyboardGravityInit(napi_env env)
1472 {
1473     WLOGFI("KeyboardGravityInit");
1474 
1475     if (env == nullptr) {
1476         WLOGFE("Env is nullptr");
1477         return nullptr;
1478     }
1479 
1480     napi_value objValue = nullptr;
1481     napi_create_object(env, &objValue);
1482     if (objValue == nullptr) {
1483         WLOGFE("Failed to get object");
1484         return nullptr;
1485     }
1486     napi_set_named_property(env, objValue, "GRAVITY_FLOAT", CreateJsValue(env,
1487         static_cast<int32_t>(SessionGravity::SESSION_GRAVITY_FLOAT)));
1488     napi_set_named_property(env, objValue, "GRAVITY_BOTTOM", CreateJsValue(env,
1489         static_cast<int32_t>(SessionGravity::SESSION_GRAVITY_BOTTOM)));
1490     napi_set_named_property(env, objValue, "GRAVITY_DEFAULT", CreateJsValue(env,
1491         static_cast<int32_t>(SessionGravity::SESSION_GRAVITY_DEFAULT)));
1492     return objValue;
1493 }
1494 
SessionTypeInit(napi_env env)1495 napi_value SessionTypeInit(napi_env env)
1496 {
1497     WLOGFD("in");
1498 
1499     if (env == nullptr) {
1500         WLOGFE("Env is nullptr");
1501         return nullptr;
1502     }
1503 
1504     napi_value objValue = nullptr;
1505     napi_create_object(env, &objValue);
1506     if (objValue == nullptr) {
1507         WLOGFE("Failed to get object");
1508         return nullptr;
1509     }
1510 
1511     SetTypeProperty(objValue, env, "TYPE_UNDEFINED", JsSessionType::TYPE_UNDEFINED);
1512     SetTypeProperty(objValue, env, "TYPE_APP", JsSessionType::TYPE_APP);
1513     SetTypeProperty(objValue, env, "TYPE_SUB_APP", JsSessionType::TYPE_SUB_APP);
1514     SetTypeProperty(objValue, env, "TYPE_SYSTEM_ALERT", JsSessionType::TYPE_SYSTEM_ALERT);
1515     SetTypeProperty(objValue, env, "TYPE_INPUT_METHOD", JsSessionType::TYPE_INPUT_METHOD);
1516     SetTypeProperty(objValue, env, "TYPE_STATUS_BAR", JsSessionType::TYPE_STATUS_BAR);
1517     SetTypeProperty(objValue, env, "TYPE_PANEL", JsSessionType::TYPE_PANEL);
1518     SetTypeProperty(objValue, env, "TYPE_KEYGUARD", JsSessionType::TYPE_KEYGUARD);
1519     SetTypeProperty(objValue, env, "TYPE_VOLUME_OVERLAY", JsSessionType::TYPE_VOLUME_OVERLAY);
1520     SetTypeProperty(objValue, env, "TYPE_NAVIGATION_BAR", JsSessionType::TYPE_NAVIGATION_BAR);
1521     SetTypeProperty(objValue, env, "TYPE_FLOAT", JsSessionType::TYPE_FLOAT);
1522     SetTypeProperty(objValue, env, "TYPE_WALLPAPER", JsSessionType::TYPE_WALLPAPER);
1523     SetTypeProperty(objValue, env, "TYPE_DESKTOP", JsSessionType::TYPE_DESKTOP);
1524     SetTypeProperty(objValue, env, "TYPE_LAUNCHER_DOCK", JsSessionType::TYPE_LAUNCHER_DOCK);
1525     SetTypeProperty(objValue, env, "TYPE_FLOAT_CAMERA", JsSessionType::TYPE_FLOAT_CAMERA);
1526     SetTypeProperty(objValue, env, "TYPE_DIALOG", JsSessionType::TYPE_DIALOG);
1527     SetTypeProperty(objValue, env, "TYPE_SCREENSHOT", JsSessionType::TYPE_SCREENSHOT);
1528     SetTypeProperty(objValue, env, "TYPE_TOAST", JsSessionType::TYPE_TOAST);
1529     SetTypeProperty(objValue, env, "TYPE_POINTER", JsSessionType::TYPE_POINTER);
1530     SetTypeProperty(objValue, env, "TYPE_LAUNCHER_RECENT", JsSessionType::TYPE_LAUNCHER_RECENT);
1531     SetTypeProperty(objValue, env, "TYPE_SCENE_BOARD", JsSessionType::TYPE_SCENE_BOARD);
1532     SetTypeProperty(objValue, env, "TYPE_DRAGGING_EFFECT", JsSessionType::TYPE_DRAGGING_EFFECT);
1533     SetTypeProperty(objValue, env, "TYPE_INPUT_METHOD_STATUS_BAR", JsSessionType::TYPE_INPUT_METHOD_STATUS_BAR);
1534     SetTypeProperty(objValue, env, "TYPE_GLOBAL_SEARCH", JsSessionType::TYPE_GLOBAL_SEARCH);
1535     SetTypeProperty(objValue, env, "TYPE_NEGATIVE_SCREEN", JsSessionType::TYPE_NEGATIVE_SCREEN);
1536     SetTypeProperty(objValue, env, "TYPE_VOICE_INTERACTION", JsSessionType::TYPE_VOICE_INTERACTION);
1537     SetTypeProperty(objValue, env, "TYPE_SYSTEM_TOAST", JsSessionType::TYPE_SYSTEM_TOAST);
1538     SetTypeProperty(objValue, env, "TYPE_SYSTEM_FLOAT", JsSessionType::TYPE_SYSTEM_FLOAT);
1539     SetTypeProperty(objValue, env, "TYPE_THEME_EDITOR", JsSessionType::TYPE_THEME_EDITOR);
1540     SetTypeProperty(objValue, env, "TYPE_PIP", JsSessionType::TYPE_PIP);
1541     SetTypeProperty(objValue, env, "TYPE_NAVIGATION_INDICATOR", JsSessionType::TYPE_NAVIGATION_INDICATOR);
1542     SetTypeProperty(objValue, env, "TYPE_HANDWRITE", JsSessionType::TYPE_HANDWRITE);
1543     SetTypeProperty(objValue, env, "TYPE_KEYBOARD_PANEL", JsSessionType::TYPE_KEYBOARD_PANEL);
1544     SetTypeProperty(objValue, env, "TYPE_DIVIDER", JsSessionType::TYPE_DIVIDER);
1545     SetTypeProperty(objValue, env, "TYPE_TRANSPARENT_VIEW", JsSessionType::TYPE_TRANSPARENT_VIEW);
1546     return objValue;
1547 }
1548 
SceneTypeInit(napi_env env)1549 napi_value SceneTypeInit(napi_env env)
1550 {
1551     WLOGFD("in");
1552 
1553     if (env == nullptr) {
1554         WLOGFE("Env is nullptr");
1555         return nullptr;
1556     }
1557 
1558     napi_value objValue = nullptr;
1559     napi_create_object(env, &objValue);
1560     if (objValue == nullptr) {
1561         WLOGFE("Failed to get object");
1562         return nullptr;
1563     }
1564     napi_set_named_property(env, objValue, "DEFAULT",
1565         CreateJsValue(env, static_cast<int32_t>(SceneType::DEFAULT)));
1566     napi_set_named_property(env, objValue, "WINDOW_SCENE",
1567         CreateJsValue(env, static_cast<int32_t>(SceneType::WINDOW_SCENE)));
1568     napi_set_named_property(env, objValue, "SYSTEM_WINDOW_SCENE",
1569         CreateJsValue(env, static_cast<int32_t>(SceneType::SYSTEM_WINDOW_SCENE)));
1570     napi_set_named_property(env, objValue, "TRANSFORM_SCENE",
1571         CreateJsValue(env, static_cast<int32_t>(SceneType::TRANSFORM_SCENE)));
1572     napi_set_named_property(env, objValue, "PANEL_SCENE",
1573         CreateJsValue(env, static_cast<int32_t>(SceneType::PANEL_SCENE)));
1574     napi_set_named_property(env, objValue, "INPUT_SCENE",
1575         CreateJsValue(env, static_cast<int32_t>(SceneType::INPUT_SCENE)));
1576     return objValue;
1577 }
1578 
1579 struct AsyncInfo {
1580     napi_env env;
1581     napi_async_work work;
1582     std::function<void()> func;
1583 };
1584 
NapiAsyncWork(napi_env env,std::function<void ()> task)1585 static void NapiAsyncWork(napi_env env, std::function<void()> task)
1586 {
1587     napi_value resource = nullptr;
1588     AsyncInfo* info = new AsyncInfo();
1589     info->env = env;
1590     info->func = task;
1591     napi_create_string_utf8(env, "AsyncWork", NAPI_AUTO_LENGTH, &resource);
1592     napi_create_async_work(env, nullptr, resource, [](napi_env env, void* data) {
1593     },
1594     [](napi_env env, napi_status status, void* data) {
1595         AsyncInfo* info = (AsyncInfo*)data;
1596         info->func();
1597         napi_delete_async_work(env, info->work);
1598         delete info;
1599     }, (void*)info, &info->work);
1600     napi_queue_async_work(env, info->work);
1601 }
1602 
MainThreadScheduler(napi_env env)1603 MainThreadScheduler::MainThreadScheduler(napi_env env)
1604     : env_(env)
1605 {
1606     GetMainEventHandler();
1607     envChecker_ = std::make_shared<int>(0);
1608 }
1609 
GetMainEventHandler()1610 inline void MainThreadScheduler::GetMainEventHandler()
1611 {
1612     if (handler_ != nullptr) {
1613         return;
1614     }
1615     auto runner = OHOS::AppExecFwk::EventRunner::GetMainEventRunner();
1616     if (runner == nullptr) {
1617         return;
1618     }
1619     handler_ = std::make_shared<OHOS::AppExecFwk::EventHandler>(runner);
1620 }
1621 
PostMainThreadTask(Task && localTask,std::string traceInfo,int64_t delayTime)1622 void MainThreadScheduler::PostMainThreadTask(Task&& localTask, std::string traceInfo, int64_t delayTime)
1623 {
1624     GetMainEventHandler();
1625     auto task = [env = env_, localTask, traceInfo, envChecker = std::weak_ptr<int>(envChecker_)]() {
1626         HITRACE_METER_FMT(HITRACE_TAG_WINDOW_MANAGER, "SCBCb:%s", traceInfo.c_str());
1627         if (envChecker.expired()) {
1628             TLOGNE(WmsLogTag::WMS_MAIN, "post task expired because of invalid scheduler");
1629             return;
1630         }
1631         napi_handle_scope scope = nullptr;
1632         napi_open_handle_scope(env, &scope);
1633         localTask();
1634         napi_close_handle_scope(env, scope);
1635     };
1636     if (handler_ && handler_->GetEventRunner()->IsCurrentRunnerThread()) {
1637         return task();
1638     } else if (handler_ && !handler_->GetEventRunner()->IsCurrentRunnerThread()) {
1639         handler_->PostTask(std::move(task), "wms:" + traceInfo, delayTime,
1640             OHOS::AppExecFwk::EventQueue::Priority::IMMEDIATE);
1641     } else {
1642         NapiAsyncWork(env_, task);
1643     }
1644 }
1645 } // namespace OHOS::Rosen