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