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
IsJsIsUseControlSessionUndefined(napi_env env,napi_value jsIsUseControlSession,SessionInfo & sessionInfo)303 static bool IsJsIsUseControlSessionUndefined(napi_env env, napi_value jsIsUseControlSession, SessionInfo& sessionInfo)
304 {
305 if (GetType(env, jsIsUseControlSession) != napi_undefined) {
306 bool isUseControlSession = false;
307 if (!ConvertFromJsValue(env, jsIsUseControlSession, isUseControlSession)) {
308 TLOGI(WmsLogTag::WMS_LIFE, "Failed to convert parameter to isUseControlSession");
309 return false;
310 }
311 sessionInfo.isUseControlSession = isUseControlSession;
312 }
313 return true;
314 }
315
ConvertSessionInfoName(napi_env env,napi_value jsObject,SessionInfo & sessionInfo)316 bool ConvertSessionInfoName(napi_env env, napi_value jsObject, SessionInfo& sessionInfo)
317 {
318 napi_value jsBundleName = nullptr;
319 napi_get_named_property(env, jsObject, "bundleName", &jsBundleName);
320 napi_value jsModuleName = nullptr;
321 napi_get_named_property(env, jsObject, "moduleName", &jsModuleName);
322 napi_value jsAbilityName = nullptr;
323 napi_get_named_property(env, jsObject, "abilityName", &jsAbilityName);
324 napi_value jsAppIndex = nullptr;
325 napi_get_named_property(env, jsObject, "appIndex", &jsAppIndex);
326 napi_value jsIsSystem = nullptr;
327 napi_get_named_property(env, jsObject, "isSystem", &jsIsSystem);
328 napi_value jsSceneType = nullptr;
329 napi_get_named_property(env, jsObject, "sceneType", &jsSceneType);
330 napi_value jsWindowInputType = nullptr;
331 napi_get_named_property(env, jsObject, "windowInputType", &jsWindowInputType);
332 napi_value jsFullScreenStart = nullptr;
333 napi_get_named_property(env, jsObject, "fullScreenStart", &jsFullScreenStart);
334 if (!IsJsBundleNameUndefind(env, jsBundleName, sessionInfo)) {
335 return false;
336 }
337 if (!IsJsModuleNameUndefind(env, jsModuleName, sessionInfo)) {
338 return false;
339 }
340 if (!IsJsAbilityUndefind(env, jsAbilityName, sessionInfo)) {
341 return false;
342 }
343 if (!IsJsAppIndexUndefind(env, jsAppIndex, sessionInfo)) {
344 return false;
345 }
346 if (!IsJsIsSystemUndefind(env, jsIsSystem, sessionInfo)) {
347 return false;
348 }
349 if (!IsJsSceneTypeUndefined(env, jsSceneType, sessionInfo)) {
350 return false;
351 }
352 if (!IsJsWindowInputTypeUndefind(env, jsWindowInputType, sessionInfo)) {
353 return false;
354 }
355 if (!IsJsFullScreenStartUndefined(env, jsFullScreenStart, sessionInfo)) {
356 return false;
357 }
358 return true;
359 }
360
ConvertProcessOptionFromJs(napi_env env,napi_value jsObject,std::shared_ptr<AAFwk::ProcessOptions> processOptions)361 bool ConvertProcessOptionFromJs(napi_env env, napi_value jsObject,
362 std::shared_ptr<AAFwk::ProcessOptions> processOptions)
363 {
364 napi_value jsProcessMode = nullptr;
365 napi_get_named_property(env, jsObject, "processMode", &jsProcessMode);
366 napi_value jsStartupVisibility = nullptr;
367 napi_get_named_property(env, jsObject, "startupVisibility", &jsStartupVisibility);
368
369 int32_t processMode;
370 if (!ConvertFromJsValue(env, jsProcessMode, processMode)) {
371 WLOGFE("[NAPI]Failed to convert parameter to processMode");
372 return false;
373 }
374
375 int32_t startupVisibility;
376 if (!ConvertFromJsValue(env, jsStartupVisibility, startupVisibility)) {
377 WLOGFE("[NAPI]Failed to convert parameter to startupVisibility");
378 return false;
379 }
380 processOptions->processMode = static_cast<AAFwk::ProcessMode>(processMode);
381 processOptions->startupVisibility = static_cast<AAFwk::StartupVisibility>(startupVisibility);
382
383 return true;
384 }
385
ConvertSessionInfoState(napi_env env,napi_value jsObject,SessionInfo & sessionInfo)386 bool ConvertSessionInfoState(napi_env env, napi_value jsObject, SessionInfo& sessionInfo)
387 {
388 napi_value jsPersistentId = nullptr;
389 napi_get_named_property(env, jsObject, "persistentId", &jsPersistentId);
390 napi_value jsCallState = nullptr;
391 napi_get_named_property(env, jsObject, "callState", &jsCallState);
392 napi_value jsSessionType = nullptr;
393 napi_get_named_property(env, jsObject, "sessionType", &jsSessionType);
394 napi_value jsIsPersistentRecover = nullptr;
395 napi_get_named_property(env, jsObject, "isPersistentRecover", &jsIsPersistentRecover);
396 napi_value jsScreenId = nullptr;
397 napi_get_named_property(env, jsObject, "screenId", &jsScreenId);
398 napi_value jsIsRotable = nullptr;
399 napi_get_named_property(env, jsObject, "isRotatable", &jsIsRotable);
400 napi_value jsIsSetPointerAreas = nullptr;
401 napi_get_named_property(env, jsObject, "isSetPointerAreas", &jsIsSetPointerAreas);
402 napi_value jsProcessOption = nullptr;
403 napi_get_named_property(env, jsObject, "processOptions", &jsProcessOption);
404 napi_value jsIsUseControlSession = nullptr;
405 napi_get_named_property(env, jsObject, "isAppUseControl", &jsIsUseControlSession);
406
407 if (!IsJsPersistentIdUndefind(env, jsPersistentId, sessionInfo)) {
408 return false;
409 }
410 if (!IsJsCallStateUndefind(env, jsCallState, sessionInfo)) {
411 return false;
412 }
413 if (!IsJsSessionTypeUndefind(env, jsSessionType, sessionInfo)) {
414 return false;
415 }
416 if (!IsJsScreenIdUndefind(env, jsScreenId, sessionInfo)) {
417 return false;
418 }
419 if (!IsJsIsPersistentRecoverUndefined(env, jsIsPersistentRecover, sessionInfo)) {
420 return false;
421 }
422 if (!IsJsIsRotatableUndefined(env, jsIsRotable, sessionInfo)) {
423 return false;
424 }
425 if (!IsJsIsSetPointerAreasUndefined(env, jsIsSetPointerAreas, sessionInfo)) {
426 return false;
427 }
428 if (!IsJsProcessOptionUndefined(env, jsProcessOption, sessionInfo)) {
429 return false;
430 }
431 if (!IsJsIsUseControlSessionUndefined(env, jsIsUseControlSession, sessionInfo)) {
432 return false;
433 }
434 return true;
435 }
436
CreateJsProcessOption(napi_env env,std::shared_ptr<AAFwk::ProcessOptions> processOptions)437 napi_value CreateJsProcessOption(napi_env env, std::shared_ptr<AAFwk::ProcessOptions> processOptions)
438 {
439 napi_value objValue = nullptr;
440 napi_create_object(env, &objValue);
441 if (objValue == nullptr) {
442 WLOGFE("Failed to get object");
443 return nullptr;
444 }
445
446 int32_t processMode = static_cast<int32_t>(processOptions->processMode);
447 int32_t startupVisibility = static_cast<int32_t>(processOptions->startupVisibility);
448
449 napi_set_named_property(env, objValue, "processMode", CreateJsValue(env, processMode));
450 napi_set_named_property(env, objValue, "startupVisibility", CreateJsValue(env, startupVisibility));
451
452 return objValue;
453 }
454
ConvertSessionInfoFromJs(napi_env env,napi_value jsObject,SessionInfo & sessionInfo)455 bool ConvertSessionInfoFromJs(napi_env env, napi_value jsObject, SessionInfo& sessionInfo)
456 {
457 if (!ConvertSessionInfoName(env, jsObject, sessionInfo)) {
458 return false;
459 }
460 if (!ConvertSessionInfoState(env, jsObject, sessionInfo)) {
461 return false;
462 }
463 return true;
464 }
465
IsJsObjNameUndefind(napi_env env,napi_value jsObjName,int32_t & objName)466 bool IsJsObjNameUndefind(napi_env env, napi_value jsObjName, int32_t& objName)
467 {
468 if (GetType(env, jsObjName) != napi_undefined) {
469 if (!ConvertFromJsValue(env, jsObjName, objName)) {
470 WLOGFE("[NAPI]Failed to convert parameter to objName");
471 return false;
472 }
473 }
474 return true;
475 }
476
ConvertRectInfoFromJs(napi_env env,napi_value jsObject,WSRect & rect)477 bool ConvertRectInfoFromJs(napi_env env, napi_value jsObject, WSRect& rect)
478 {
479 napi_value jsLeftName = nullptr;
480 napi_get_named_property(env, jsObject, "left", &jsLeftName);
481 napi_value jsTopName = nullptr;
482 napi_get_named_property(env, jsObject, "top", &jsTopName);
483 napi_value jsRightName = nullptr;
484 napi_get_named_property(env, jsObject, "right", &jsRightName);
485 napi_value jsBottomName = nullptr;
486 napi_get_named_property(env, jsObject, "bottom", &jsBottomName);
487
488 int32_t leftName = 0;
489 if (!IsJsObjNameUndefind(env, jsLeftName, leftName)) {
490 return false;
491 }
492 rect.posX_ = leftName;
493
494 int32_t topName = 0;
495 if (!IsJsObjNameUndefind(env, jsTopName, topName)) {
496 return false;
497 }
498 rect.posY_ = topName;
499
500 int32_t rightName = 0;
501 if (!IsJsObjNameUndefind(env, jsRightName, rightName)) {
502 return false;
503 }
504 rect.width_ = rightName - rect.posX_;
505
506 int32_t bottomName = 0;
507 if (!IsJsObjNameUndefind(env, jsBottomName, bottomName)) {
508 return false;
509 }
510 rect.height_ = bottomName - rect.posY_;
511 return true;
512 }
513
ConvertHookInfoFromJs(napi_env env,napi_value jsObject,HookInfo & hookInfo)514 bool ConvertHookInfoFromJs(napi_env env, napi_value jsObject, HookInfo& hookInfo)
515 {
516 napi_value jsWidth = nullptr;
517 napi_get_named_property(env, jsObject, "width", &jsWidth);
518 napi_value jsHeight = nullptr;
519 napi_get_named_property(env, jsObject, "height", &jsHeight);
520 napi_value jsDensity = nullptr;
521 napi_get_named_property(env, jsObject, "density", &jsDensity);
522 napi_value jsRotation = nullptr;
523 napi_get_named_property(env, jsObject, "rotation", &jsRotation);
524 napi_value jsEnableHookRotation = nullptr;
525 napi_get_named_property(env, jsObject, "enableHookRotation", &jsEnableHookRotation);
526
527 uint32_t width = 0;
528 if (!ConvertFromJsValue(env, jsWidth, width)) {
529 TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Failed to convert parameter to width");
530 return false;
531 }
532 hookInfo.width_ = width;
533
534 uint32_t height = 0;
535 if (!ConvertFromJsValue(env, jsHeight, height)) {
536 TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Failed to convert parameter to height");
537 return false;
538 }
539 hookInfo.height_ = height;
540
541 double_t density = 1.0;
542 if (!ConvertFromJsValue(env, jsDensity, density)) {
543 TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Failed to convert parameter to density");
544 return false;
545 }
546 hookInfo.density_ = static_cast<float_t>(density);
547
548 uint32_t rotation = 0;
549 if (!ConvertFromJsValue(env, jsRotation, rotation)) {
550 TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Failed to convert parameter to rotation");
551 return false;
552 }
553 hookInfo.rotation_ = rotation;
554
555 bool enableHookRotation = false;
556 if (!ConvertFromJsValue(env, jsEnableHookRotation, enableHookRotation)) {
557 TLOGE(WmsLogTag::WMS_LAYOUT, "[NAPI]Failed to convert parameter to enableHookRotation");
558 return false;
559 }
560 hookInfo.enableHookRotation_ = enableHookRotation;
561 return true;
562 }
563
ConvertPointerItemFromJs(napi_env env,napi_value touchObject,MMI::PointerEvent & pointerEvent)564 bool ConvertPointerItemFromJs(napi_env env, napi_value touchObject, MMI::PointerEvent& pointerEvent)
565 {
566 auto vpr = RootScene::staticRootScene_->GetDisplayDensity();
567 MMI::PointerEvent::PointerItem pointerItem;
568 napi_value jsId = nullptr;
569 napi_get_named_property(env, touchObject, "id", &jsId);
570 napi_value jsTouchType = nullptr;
571 napi_get_named_property(env, touchObject, "type", &jsTouchType);
572 napi_value jsWindowX = nullptr;
573 napi_get_named_property(env, touchObject, "windowX", &jsWindowX);
574 napi_value jsWindowY = nullptr;
575 napi_get_named_property(env, touchObject, "windowY", &jsWindowY);
576 napi_value jsDisplayX = nullptr;
577 napi_get_named_property(env, touchObject, "displayX", &jsDisplayX);
578 napi_value jsDisplayY = nullptr;
579 napi_get_named_property(env, touchObject, "displayY", &jsDisplayY);
580 int32_t id;
581 if (!ConvertFromJsValue(env, jsId, id)) {
582 WLOGFE("[NAPI]Failed to convert parameter to id");
583 return false;
584 }
585 pointerItem.SetPointerId(id);
586 pointerEvent.SetPointerId(id);
587 int32_t touchType;
588 if (!ConvertFromJsValue(env, jsTouchType, touchType)) {
589 WLOGFE("[NAPI]Failed to convert parameter to touchType");
590 return false;
591 }
592 pointerEvent.SetPointerAction(GetMMITouchType(touchType));
593 double windowX;
594 if (!ConvertFromJsValue(env, jsWindowX, windowX)) {
595 WLOGFE("[NAPI]Failed to convert parameter to windowX");
596 return false;
597 }
598 pointerItem.SetWindowX(std::round(windowX * vpr));
599 double windowY;
600 if (!ConvertFromJsValue(env, jsWindowY, windowY)) {
601 WLOGFE("[NAPI]Failed to convert parameter to windowY");
602 return false;
603 }
604 pointerItem.SetWindowY(std::round(windowY * vpr));
605 double displayX;
606 if (!ConvertFromJsValue(env, jsDisplayX, displayX)) {
607 WLOGFE("[NAPI]Failed to convert parameter to displayX");
608 return false;
609 }
610 pointerItem.SetDisplayX(std::round(displayX * vpr));
611 double displayY;
612 if (!ConvertFromJsValue(env, jsDisplayY, displayY)) {
613 WLOGFE("[NAPI]Failed to convert parameter to displayY");
614 return false;
615 }
616 pointerItem.SetDisplayY(std::round(displayY * vpr));
617 pointerEvent.AddPointerItem(pointerItem);
618 return true;
619 }
620
ConvertTouchesObjectFromJs(napi_env env,napi_value jsTouches,int32_t pointerId,MMI::PointerEvent & pointerEvent)621 bool ConvertTouchesObjectFromJs(napi_env env, napi_value jsTouches, int32_t pointerId, MMI::PointerEvent& pointerEvent)
622 {
623 // iterator touches
624 if (jsTouches == nullptr) {
625 WLOGFE("[NAPI]Failed to convert to touchesObject list");
626 return false;
627 }
628 bool isArray = false;
629 napi_is_array(env, jsTouches, &isArray);
630 if (!isArray) {
631 return false;
632 }
633 uint32_t length = 0;
634 napi_get_array_length(env, jsTouches, &length);
635 for (uint32_t i = 0; i < length; i++) {
636 napi_value touchesObject = nullptr;
637 napi_get_element(env, jsTouches, i, &touchesObject);
638 if (touchesObject == nullptr) {
639 WLOGFE("[NAPI]Failed get to touchesObject");
640 return false;
641 }
642 napi_value jsNoChangedId = nullptr;
643 napi_get_named_property(env, touchesObject, "id", &jsNoChangedId);
644 int32_t noChangedId;
645 if (!ConvertFromJsValue(env, jsNoChangedId, noChangedId)) {
646 WLOGFE("[NAPI]Failed to convert parameter to jsNoChangeId");
647 return false;
648 }
649 if (pointerId == noChangedId) {
650 continue;
651 }
652 if (!ConvertPointerItemFromJs(env, touchesObject, pointerEvent)) {
653 return false;
654 }
655 }
656 return true;
657 }
658
ConvertPointerEventFromJs(napi_env env,napi_value jsObject,MMI::PointerEvent & pointerEvent)659 bool ConvertPointerEventFromJs(napi_env env, napi_value jsObject, MMI::PointerEvent& pointerEvent)
660 {
661 napi_value jsSourceType = nullptr;
662 napi_get_named_property(env, jsObject, "source", &jsSourceType);
663 napi_value jsTimestamp = nullptr;
664 napi_get_named_property(env, jsObject, "timestamp", &jsTimestamp);
665 napi_value jsChangedTouches = nullptr;
666 napi_get_named_property(env, jsObject, "changedTouches", &jsChangedTouches);
667 napi_value jsTouches = nullptr;
668 napi_get_named_property(env, jsObject, "touches", &jsTouches);
669 int32_t sourceType;
670 if (!ConvertFromJsValue(env, jsSourceType, sourceType)) {
671 WLOGFE("[NAPI]Failed to convert parameter to sourceType");
672 return false;
673 }
674 pointerEvent.SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
675 double timestamp;
676 if (!ConvertFromJsValue(env, jsTimestamp, timestamp)) {
677 WLOGFE("[NAPI]Failed to convert parameter to timestamp");
678 return false;
679 }
680 pointerEvent.SetActionTime(std::round(timestamp / US_PER_NS));
681 if (jsChangedTouches == nullptr) {
682 WLOGFE("[NAPI]Failed to convert parameter to touchesArray");
683 return false;
684 }
685 // use changedTouches[0] only
686 napi_value touchObject = nullptr;
687 napi_get_element(env, jsChangedTouches, 0, &touchObject);
688 if (touchObject == nullptr) {
689 WLOGFE("[NAPI]Failed get to touchObject");
690 return false;
691 }
692 napi_value jsId = nullptr;
693 napi_get_named_property(env, touchObject, "id", &jsId);
694 int32_t pointerId;
695 if (!ConvertFromJsValue(env, jsId, pointerId)) {
696 WLOGFE("[NAPI]Failed to convert parameter to id");
697 return false;
698 }
699 if (!ConvertPointerItemFromJs(env, touchObject, pointerEvent)) {
700 return false;
701 }
702 if (!ConvertTouchesObjectFromJs(env, jsTouches, pointerId, pointerEvent)) {
703 return false;
704 }
705 pointerEvent.SetPointerId(pointerId);
706 if (!ConvertDeviceIdFromJs(env, jsObject, pointerEvent)) {
707 return false;
708 }
709 return true;
710 }
711
ConvertDeviceIdFromJs(napi_env env,napi_value jsObject,MMI::PointerEvent & pointerEvent)712 bool ConvertDeviceIdFromJs(napi_env env, napi_value jsObject, MMI::PointerEvent& pointerEvent)
713 {
714 napi_value jsDeviceId = nullptr;
715 napi_get_named_property(env, jsObject, "deviceId", &jsDeviceId);
716 int32_t deviceId = 0;
717 if (!ConvertFromJsValue(env, jsDeviceId, deviceId)) {
718 WLOGFE("[NAPI]Failed to convert parameter to deviceId");
719 return false;
720 }
721 pointerEvent.SetDeviceId(deviceId);
722 return true;
723 }
724
ConvertInt32ArrayFromJs(napi_env env,napi_value jsObject,std::vector<int32_t> & intList)725 bool ConvertInt32ArrayFromJs(napi_env env, napi_value jsObject, std::vector<int32_t>& intList)
726 {
727 bool isArray = false;
728 napi_is_array(env, jsObject, &isArray);
729 if (jsObject == nullptr || !isArray) {
730 WLOGFE("[NAPI]Failed to convert to integer list");
731 return false;
732 }
733
734 uint32_t length = 0;
735 napi_get_array_length(env, jsObject, &length);
736 for (uint32_t i = 0; i < length; i++) {
737 int32_t persistentId;
738 napi_value elementVal = nullptr;
739 napi_get_element(env, jsObject, i, &elementVal);
740 if (!ConvertFromJsValue(env, elementVal, persistentId)) {
741 WLOGFE("[NAPI]Failed to convert to index %{public}u to integer", i);
742 return false;
743 }
744 intList.push_back(persistentId);
745 }
746
747 return true;
748 }
749
ConvertStringMapFromJs(napi_env env,napi_value value,std::unordered_map<std::string,std::string> & stringMap)750 bool ConvertStringMapFromJs(napi_env env, napi_value value, std::unordered_map<std::string, std::string>& stringMap)
751 {
752 if (value == nullptr) {
753 WLOGFE("value is nullptr");
754 return false;
755 }
756
757 if (!CheckTypeForNapiValue(env, value, napi_object)) {
758 WLOGFE("The type of value is not napi_object.");
759 return false;
760 }
761
762 std::vector<std::string> propNames;
763 napi_value array = nullptr;
764 napi_get_property_names(env, value, &array);
765 if (!ParseArrayStringValue(env, array, propNames)) {
766 WLOGFE("Failed to property names");
767 return false;
768 }
769
770 for (const auto &propName : propNames) {
771 napi_value prop = nullptr;
772 napi_get_named_property(env, value, propName.c_str(), &prop);
773 if (prop == nullptr) {
774 WLOGFW("prop is null: %{public}s", propName.c_str());
775 continue;
776 }
777 if (!CheckTypeForNapiValue(env, prop, napi_string)) {
778 WLOGFW("prop is not string: %{public}s", propName.c_str());
779 continue;
780 }
781 std::string valName;
782 if (!ConvertFromJsValue(env, prop, valName)) {
783 WLOGFW("Failed to ConvertFromJsValue: %{public}s", propName.c_str());
784 continue;
785 }
786 stringMap.emplace(propName, valName);
787 }
788 return true;
789 }
790
ConvertRotateAnimationConfigFromJs(napi_env env,napi_value value,RotateAnimationConfig & config)791 bool ConvertRotateAnimationConfigFromJs(napi_env env, napi_value value, RotateAnimationConfig& config)
792 {
793 napi_value jsDuration = nullptr;
794 napi_get_named_property(env, value, "duration", &jsDuration);
795 if (GetType(env, jsDuration) != napi_undefined) {
796 int32_t duration = ROTATE_ANIMATION_DURATION;
797 if (!ConvertFromJsValue(env, jsDuration, duration)) {
798 TLOGE(WmsLogTag::DEFAULT, "Failed to convert parameter to duration");
799 return false;
800 }
801 config.duration_ = duration;
802 }
803 return true;
804 }
805
ConvertJsonFromJs(napi_env env,napi_value value,nlohmann::json & payload)806 bool ConvertJsonFromJs(napi_env env, napi_value value, nlohmann::json& payload)
807 {
808 if (value == nullptr || !CheckTypeForNapiValue(env, value, napi_object)) {
809 WLOGFE("The type of value is not napi_object or is nullptr.");
810 return false;
811 }
812
813 napi_value array = nullptr;
814 napi_get_property_names(env, value, &array);
815 std::vector<std::string> propNames;
816 if (!ParseArrayStringValue(env, array, propNames)) {
817 WLOGFE("Failed to property names");
818 return false;
819 }
820
821 for (const auto& propName : propNames) {
822 napi_value prop = nullptr;
823 napi_get_named_property(env, value, propName.c_str(), &prop);
824 if (prop == nullptr) {
825 WLOGFW("prop is null: %{public}s", propName.c_str());
826 continue;
827 }
828 if (!CheckTypeForNapiValue(env, prop, napi_string)) {
829 WLOGFW("prop is not string: %{public}s", propName.c_str());
830 continue;
831 }
832 std::string valName;
833 if (!ConvertFromJsValue(env, prop, valName)) {
834 WLOGFW("Failed to ConvertFromJsValue: %{public}s", propName.c_str());
835 continue;
836 }
837 payload[propName] = std::move(valName);
838 }
839 return true;
840 }
841
ConvertDragResizeTypeFromJs(napi_env env,napi_value value,DragResizeType & dragResizeType)842 bool ConvertDragResizeTypeFromJs(napi_env env, napi_value value, DragResizeType& dragResizeType)
843 {
844 uint32_t dragResizeTypeValue;
845 if (!ConvertFromJsValue(env, value, dragResizeTypeValue)) {
846 return false;
847 }
848 if (dragResizeTypeValue > static_cast<uint32_t>(DragResizeType::RESIZE_WHEN_DRAG_END)) {
849 TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to convert parameter to dragResizeType");
850 return false;
851 }
852 dragResizeType = static_cast<DragResizeType>(dragResizeTypeValue);
853 return true;
854 }
855
ParseArrayStringValue(napi_env env,napi_value array,std::vector<std::string> & vector)856 bool ParseArrayStringValue(napi_env env, napi_value array, std::vector<std::string>& vector)
857 {
858 if (array == nullptr) {
859 WLOGFE("array is nullptr!");
860 return false;
861 }
862 bool isArray = false;
863 if (napi_is_array(env, array, &isArray) != napi_ok || isArray == false) {
864 WLOGFE("not array!");
865 return false;
866 }
867
868 uint32_t arrayLen = 0;
869 napi_get_array_length(env, array, &arrayLen);
870 if (arrayLen == 0) {
871 return true;
872 }
873 vector.reserve(arrayLen);
874 for (uint32_t i = 0; i < arrayLen; i++) {
875 std::string strItem;
876 napi_value jsValue = nullptr;
877 napi_get_element(env, array, i, &jsValue);
878 if (!ConvertFromJsValue(env, jsValue, strItem)) {
879 WLOGFW("Failed to ConvertFromJsValue, index: %{public}u", i);
880 continue;
881 }
882 vector.emplace_back(std::move(strItem));
883 }
884 return true;
885 }
886
GetApiType(WindowType type)887 JsSessionType GetApiType(WindowType type)
888 {
889 auto iter = WINDOW_TO_JS_SESSION_TYPE_MAP.find(type);
890 if (iter == WINDOW_TO_JS_SESSION_TYPE_MAP.end()) {
891 WLOGFE("[NAPI]window type: %{public}u cannot map to api type!", type);
892 return JsSessionType::TYPE_UNDEFINED;
893 } else {
894 return iter->second;
895 }
896 }
897
CreateSupportWindowModes(napi_env env,const std::vector<AppExecFwk::SupportWindowMode> & supportedWindowModes)898 napi_value CreateSupportWindowModes(napi_env env,
899 const std::vector<AppExecFwk::SupportWindowMode>& supportedWindowModes)
900 {
901 napi_value arrayValue = nullptr;
902 napi_create_array_with_length(env, supportedWindowModes.size(), &arrayValue);
903 if (arrayValue == nullptr) {
904 TLOGE(WmsLogTag::WMS_LIFE, "Failed to create napi array");
905 return NapiGetUndefined(env);
906 }
907 int32_t index = 0;
908 for (const auto supportWindowMode : supportedWindowModes) {
909 napi_set_element(env, arrayValue, index++, CreateJsValue(env, static_cast<int32_t>(supportWindowMode)));
910 }
911 return arrayValue;
912 }
913
CreateJsSessionInfo(napi_env env,const SessionInfo & sessionInfo)914 napi_value CreateJsSessionInfo(napi_env env, const SessionInfo& sessionInfo)
915 {
916 napi_value objValue = nullptr;
917 napi_create_object(env, &objValue);
918 if (objValue == nullptr) {
919 WLOGFE("[NAPI]Failed to get jsObject");
920 return nullptr;
921 }
922 napi_set_named_property(env, objValue, "bundleName", CreateJsValue(env, sessionInfo.bundleName_));
923 napi_set_named_property(env, objValue, "moduleName", CreateJsValue(env, sessionInfo.moduleName_));
924 napi_set_named_property(env, objValue, "abilityName", CreateJsValue(env, sessionInfo.abilityName_));
925 napi_set_named_property(env, objValue, "appIndex", CreateJsValue(env, sessionInfo.appIndex_));
926 napi_set_named_property(env, objValue, "isSystem", CreateJsValue(env, sessionInfo.isSystem_));
927 napi_set_named_property(env, objValue, "isCastSession", CreateJsValue(env, sessionInfo.isCastSession_));
928 napi_set_named_property(env, objValue, "persistentId",
929 CreateJsValue(env, static_cast<int32_t>(sessionInfo.persistentId_)));
930 napi_set_named_property(env, objValue, "callerPersistentId",
931 CreateJsValue(env, static_cast<int32_t>(sessionInfo.callerPersistentId_)));
932 napi_set_named_property(env, objValue, "callerBundleName", CreateJsValue(env, sessionInfo.callerBundleName_));
933 napi_set_named_property(env, objValue, "callerAbilityName", CreateJsValue(env, sessionInfo.callerAbilityName_));
934 napi_set_named_property(env, objValue, "callState",
935 CreateJsValue(env, static_cast<int32_t>(sessionInfo.callState_)));
936 napi_set_named_property(env, objValue, "windowMode",
937 CreateJsValue(env, static_cast<int32_t>(sessionInfo.windowMode)));
938 napi_set_named_property(env, objValue, "screenId",
939 CreateJsValue(env, static_cast<int32_t>(sessionInfo.screenId_)));
940 napi_set_named_property(env, objValue, "sessionType",
941 CreateJsValue(env, static_cast<uint32_t>(GetApiType(static_cast<WindowType>(sessionInfo.windowType_)))));
942 napi_set_named_property(env, objValue, "sessionState",
943 CreateJsValue(env, static_cast<int32_t>(sessionInfo.sessionState_)));
944 napi_set_named_property(env, objValue, "requestOrientation",
945 CreateJsValue(env, sessionInfo.requestOrientation_));
946 napi_set_named_property(env, objValue, "isCalledRightlyByCallerId",
947 CreateJsValue(env, sessionInfo.isCalledRightlyByCallerId_));
948 napi_set_named_property(env, objValue, "isAtomicService",
949 CreateJsValue(env, sessionInfo.isAtomicService_));
950 napi_set_named_property(env, objValue, "isBackTransition",
951 CreateJsValue(env, sessionInfo.isBackTransition_));
952 napi_set_named_property(env, objValue, "needClearInNotShowRecent",
953 CreateJsValue(env, sessionInfo.needClearInNotShowRecent_));
954 if (sessionInfo.processOptions != nullptr) {
955 napi_set_named_property(env, objValue, "processOptions",
956 CreateJsProcessOption(env, sessionInfo.processOptions));
957 }
958 napi_set_named_property(env, objValue, "errorReason",
959 CreateJsValue(env, sessionInfo.errorReason));
960 napi_set_named_property(env, objValue, "isFromIcon", CreateJsValue(env, sessionInfo.isFromIcon_));
961 SetJsSessionInfoByWant(env, sessionInfo, objValue);
962 if (sessionInfo.want != nullptr) {
963 napi_set_named_property(env, objValue, "want", AppExecFwk::WrapWant(env, *sessionInfo.want));
964 }
965 napi_set_named_property(env, objValue, "supportWindowModes",
966 CreateSupportWindowModes(env, sessionInfo.supportedWindowModes));
967 return objValue;
968 }
969
CreateJsSessionRecoverInfo(napi_env env,const SessionInfo & sessionInfo,const sptr<WindowSessionProperty> property)970 napi_value CreateJsSessionRecoverInfo(
971 napi_env env, const SessionInfo& sessionInfo, const sptr<WindowSessionProperty> property)
972 {
973 napi_value objValue = nullptr;
974 napi_create_object(env, &objValue);
975 if (objValue == nullptr) {
976 WLOGFE("[NAPI]Failed to get jsObject");
977 return nullptr;
978 }
979 napi_set_named_property(env, objValue, "bundleName", CreateJsValue(env, sessionInfo.bundleName_));
980 napi_set_named_property(env, objValue, "moduleName", CreateJsValue(env, sessionInfo.moduleName_));
981 napi_set_named_property(env, objValue, "abilityName", CreateJsValue(env, sessionInfo.abilityName_));
982 napi_set_named_property(env, objValue, "appIndex", CreateJsValue(env, sessionInfo.appIndex_));
983 napi_set_named_property(env, objValue, "screenId",
984 CreateJsValue(env, static_cast<int32_t>(sessionInfo.screenId_)));
985 napi_set_named_property(env, objValue, "windowMode",
986 CreateJsValue(env, static_cast<int32_t>(sessionInfo.windowMode)));
987 napi_set_named_property(env, objValue, "sessionState",
988 CreateJsValue(env, static_cast<int32_t>(sessionInfo.sessionState_)));
989 napi_set_named_property(env, objValue, "sessionType",
990 CreateJsValue(env, static_cast<uint32_t>(GetApiType(static_cast<WindowType>(sessionInfo.windowType_)))));
991 napi_set_named_property(env, objValue, "requestOrientation",
992 CreateJsValue(env, sessionInfo.requestOrientation_));
993 Rect rect = property->GetWindowRect();
994 WSRect wsRect = { rect.posX_, rect.posY_, rect.width_, rect.height_ };
995 napi_set_named_property(env, objValue, "recoverRect", CreateJsSessionRect(env, wsRect));
996 napi_set_named_property(env, objValue, "mainWindowTopmost", CreateJsValue(env, property->IsMainWindowTopmost()));
997 napi_set_named_property(env, objValue, "layoutFullScreen", CreateJsValue(env, property->IsLayoutFullScreen()));
998 return objValue;
999 }
1000
SetJsSessionInfoByWant(napi_env env,const SessionInfo & sessionInfo,napi_value objValue)1001 void SetJsSessionInfoByWant(napi_env env, const SessionInfo& sessionInfo, napi_value objValue)
1002 {
1003 if (sessionInfo.want != nullptr) {
1004 napi_set_named_property(env, objValue, "windowTop",
1005 GetWindowRectIntValue(env,
1006 sessionInfo.want->GetIntParam(AAFwk::Want::PARAM_RESV_WINDOW_TOP, INVALID_VAL)));
1007 napi_set_named_property(env, objValue, "windowLeft",
1008 GetWindowRectIntValue(env,
1009 sessionInfo.want->GetIntParam(AAFwk::Want::PARAM_RESV_WINDOW_LEFT, INVALID_VAL)));
1010 napi_set_named_property(env, objValue, "windowWidth",
1011 GetWindowRectIntValue(env,
1012 sessionInfo.want->GetIntParam(AAFwk::Want::PARAM_RESV_WINDOW_WIDTH, INVALID_VAL)));
1013 napi_set_named_property(env, objValue, "windowHeight",
1014 GetWindowRectIntValue(env,
1015 sessionInfo.want->GetIntParam(AAFwk::Want::PARAM_RESV_WINDOW_HEIGHT, INVALID_VAL)));
1016 napi_set_named_property(env, objValue, "withAnimation",
1017 CreateJsValue(env, sessionInfo.want->GetBoolParam(AAFwk::Want::PARAM_RESV_WITH_ANIMATION, true)));
1018 napi_set_named_property(env, objValue, "focusedOnShow",
1019 CreateJsValue(env, sessionInfo.want->GetBoolParam(AAFwk::Want::PARAM_RESV_WINDOW_FOCUSED, true)));
1020 napi_set_named_property(env, objValue, "isStartupInstallFree",
1021 CreateJsValue(env, (sessionInfo.want->GetFlags() & AAFwk::Want::FLAG_INSTALL_ON_DEMAND) ==
1022 AAFwk::Want::FLAG_INSTALL_ON_DEMAND));
1023 auto params = sessionInfo.want->GetParams();
1024 napi_set_named_property(env, objValue, "fileManagerMode",
1025 CreateJsValue(env, params.GetStringParam("fileManagerMode")));
1026 napi_set_named_property(env, objValue, "floatingDisplayMode",
1027 CreateJsValue(env, params.GetIntParam("floatingDisplayMode", INVALID_VAL)));
1028 auto executeParams = params.GetWantParams("ohos.insightIntent.executeParam.param");
1029 napi_set_named_property(env, objValue, "extraFormIdentity",
1030 CreateJsValue(env, executeParams.GetStringParam("ohos.extra.param.key.form_identity")));
1031 if (params.HasParam("expectWindowMode")) {
1032 napi_set_named_property(env, objValue, "expectWindowMode",
1033 CreateJsValue(env, params.GetIntParam("expectWindowMode", INVALID_VAL)));
1034 }
1035 if (params.HasParam("isStartFromAppDock")) {
1036 napi_set_named_property(env, objValue, "isStartFromAppDock",
1037 CreateJsValue(env, params.GetIntParam("isStartFromAppDock", INVALID_VAL)));
1038 }
1039 if (params.HasParam("dockAppDirection")) {
1040 napi_set_named_property(env, objValue, "dockAppDirection",
1041 CreateJsValue(env, params.GetIntParam("dockAppDirection", INVALID_VAL)));
1042 }
1043 if (params.HasParam("isAppFromRecentAppsOrDockApps")) {
1044 napi_set_named_property(env, objValue, "isAppFromRecentAppsOrDockApps",
1045 CreateJsValue(env, params.GetIntParam("isAppFromRecentAppsOrDockApps", INVALID_VAL)));
1046 }
1047 }
1048 }
1049
GetWindowRectIntValue(napi_env env,int val)1050 napi_value GetWindowRectIntValue(napi_env env, int val)
1051 {
1052 if (val != INVALID_VAL) {
1053 return CreateJsValue(env, val);
1054 } else {
1055 return NapiGetUndefined(env);
1056 }
1057 }
1058
CreateJsSessionState(napi_env env)1059 napi_value CreateJsSessionState(napi_env env)
1060 {
1061 napi_value objValue = nullptr;
1062 napi_create_object(env, &objValue);
1063 if (objValue == nullptr) {
1064 WLOGFE("Failed to get object");
1065 return nullptr;
1066 }
1067
1068 napi_set_named_property(env, objValue, "STATE_DISCONNECT", CreateJsValue(env,
1069 static_cast<int32_t>(SessionState::STATE_DISCONNECT)));
1070 napi_set_named_property(env, objValue, "STATE_CONNECT", CreateJsValue(env,
1071 static_cast<int32_t>(SessionState::STATE_CONNECT)));
1072 napi_set_named_property(env, objValue, "STATE_FOREGROUND", CreateJsValue(env,
1073 static_cast<int32_t>(SessionState::STATE_FOREGROUND)));
1074 napi_set_named_property(env, objValue, "STATE_ACTIVE", CreateJsValue(env,
1075 static_cast<int32_t>(SessionState::STATE_ACTIVE)));
1076 napi_set_named_property(env, objValue, "STATE_INACTIVE", CreateJsValue(env,
1077 static_cast<int32_t>(SessionState::STATE_INACTIVE)));
1078 napi_set_named_property(env, objValue, "STATE_BACKGROUND", CreateJsValue(env,
1079 static_cast<int32_t>(SessionState::STATE_BACKGROUND)));
1080 napi_set_named_property(env, objValue, "STATE_END", CreateJsValue(env,
1081 static_cast<int32_t>(SessionState::STATE_END)));
1082
1083 return objValue;
1084 }
1085
CreateJsSessionSizeChangeReason(napi_env env)1086 napi_value CreateJsSessionSizeChangeReason(napi_env env)
1087 {
1088 napi_value objValue = nullptr;
1089 napi_create_object(env, &objValue);
1090 if (objValue == nullptr) {
1091 WLOGFE("Failed to get object");
1092 return nullptr;
1093 }
1094
1095 napi_set_named_property(env, objValue, "UNDEFINED", CreateJsValue(env,
1096 static_cast<int32_t>(SizeChangeReason::UNDEFINED)));
1097 napi_set_named_property(env, objValue, "MAXIMIZE", CreateJsValue(env,
1098 static_cast<int32_t>(SizeChangeReason::MAXIMIZE)));
1099 napi_set_named_property(env, objValue, "RECOVER", CreateJsValue(env,
1100 static_cast<int32_t>(SizeChangeReason::RECOVER)));
1101 napi_set_named_property(env, objValue, "ROTATION", CreateJsValue(env,
1102 static_cast<int32_t>(SizeChangeReason::ROTATION)));
1103 napi_set_named_property(env, objValue, "DRAG", CreateJsValue(env,
1104 static_cast<int32_t>(SizeChangeReason::DRAG)));
1105 napi_set_named_property(env, objValue, "DRAG_START", CreateJsValue(env,
1106 static_cast<int32_t>(SizeChangeReason::DRAG_START)));
1107 napi_set_named_property(env, objValue, "DRAG_MOVE", CreateJsValue(env,
1108 static_cast<int32_t>(SizeChangeReason::DRAG_MOVE)));
1109 napi_set_named_property(env, objValue, "DRAG_END", CreateJsValue(env,
1110 static_cast<int32_t>(SizeChangeReason::DRAG_END)));
1111 napi_set_named_property(env, objValue, "RESIZE", CreateJsValue(env,
1112 static_cast<int32_t>(SizeChangeReason::RESIZE)));
1113 napi_set_named_property(env, objValue, "MOVE", CreateJsValue(env,
1114 static_cast<int32_t>(SizeChangeReason::MOVE)));
1115 napi_set_named_property(env, objValue, "HIDE", CreateJsValue(env,
1116 static_cast<int32_t>(SizeChangeReason::HIDE)));
1117 napi_set_named_property(env, objValue, "TRANSFORM", CreateJsValue(env,
1118 static_cast<int32_t>(SizeChangeReason::TRANSFORM)));
1119 napi_set_named_property(env, objValue, "CUSTOM_ANIMATION_SHOW", CreateJsValue(env,
1120 static_cast<int32_t>(SizeChangeReason::CUSTOM_ANIMATION_SHOW)));
1121 napi_set_named_property(env, objValue, "FULL_TO_SPLIT", CreateJsValue(env,
1122 static_cast<int32_t>(SizeChangeReason::FULL_TO_SPLIT)));
1123 napi_set_named_property(env, objValue, "SPLIT_TO_FULL", CreateJsValue(env,
1124 static_cast<int32_t>(SizeChangeReason::SPLIT_TO_FULL)));
1125 napi_set_named_property(env, objValue, "FULL_TO_FLOATING", CreateJsValue(env,
1126 static_cast<int32_t>(SizeChangeReason::FULL_TO_FLOATING)));
1127 napi_set_named_property(env, objValue, "FLOATING_TO_FULL", CreateJsValue(env,
1128 static_cast<int32_t>(SizeChangeReason::FLOATING_TO_FULL)));
1129 CreatePiPSizeChangeReason(env, objValue);
1130 napi_set_named_property(env, objValue, "END", CreateJsValue(env,
1131 static_cast<int32_t>(SizeChangeReason::END)));
1132
1133 return objValue;
1134 }
1135
CreateJsRSUIFirstSwitch(napi_env env)1136 napi_value CreateJsRSUIFirstSwitch(napi_env env)
1137 {
1138 napi_value objValue = nullptr;
1139 napi_create_object(env, &objValue);
1140 if (objValue == nullptr) {
1141 TLOGE(WmsLogTag::DEFAULT, "Failed to get object");
1142 return nullptr;
1143 }
1144 napi_set_named_property(env, objValue, "NONE", CreateJsValue(env,
1145 static_cast<int32_t>(RSUIFirstSwitch::NONE)));
1146 napi_set_named_property(env, objValue, "MODAL_WINDOW_CLOSE", CreateJsValue(env,
1147 static_cast<int32_t>(RSUIFirstSwitch::MODAL_WINDOW_CLOSE)));
1148 napi_set_named_property(env, objValue, "FORCE_DISABLE", CreateJsValue(env,
1149 static_cast<int32_t>(RSUIFirstSwitch::FORCE_DISABLE)));
1150 napi_set_named_property(env, objValue, "FORCE_ENABLE", CreateJsValue(env,
1151 static_cast<int32_t>(RSUIFirstSwitch::FORCE_ENABLE)));
1152 napi_set_named_property(env, objValue, "FORCE_ENABLE_LIMIT", CreateJsValue(env,
1153 static_cast<int32_t>(RSUIFirstSwitch::FORCE_ENABLE_LIMIT)));
1154 napi_set_named_property(env, objValue, "FORCE_DISABLE_NONFOCUS", CreateJsValue(env,
1155 static_cast<int32_t>(RSUIFirstSwitch::FORCE_DISABLE_NONFOCUS)));
1156 return objValue;
1157 }
1158
CreatePiPSizeChangeReason(napi_env env,napi_value objValue)1159 void CreatePiPSizeChangeReason(napi_env env, napi_value objValue)
1160 {
1161 napi_set_named_property(env, objValue, "PIP_START", CreateJsValue(env,
1162 static_cast<int32_t>(SizeChangeReason::PIP_START)));
1163 napi_set_named_property(env, objValue, "PIP_SHOW", CreateJsValue(env,
1164 static_cast<int32_t>(SizeChangeReason::PIP_SHOW)));
1165 napi_set_named_property(env, objValue, "PIP_AUTO_START", CreateJsValue(env,
1166 static_cast<int32_t>(SizeChangeReason::PIP_AUTO_START)));
1167 napi_set_named_property(env, objValue, "PIP_RATIO_CHANGE", CreateJsValue(env,
1168 static_cast<int32_t>(SizeChangeReason::PIP_RATIO_CHANGE)));
1169 napi_set_named_property(env, objValue, "PIP_RESTORE", CreateJsValue(env,
1170 static_cast<int32_t>(SizeChangeReason::PIP_RESTORE)));
1171 }
1172
CreateJsSessionStartupVisibility(napi_env env)1173 napi_value CreateJsSessionStartupVisibility(napi_env env)
1174 {
1175 if (env == nullptr) {
1176 WLOGFE("Env is nullptr");
1177 return nullptr;
1178 }
1179 napi_value objValue = nullptr;
1180 napi_create_object(env, &objValue);
1181 if (objValue == nullptr) {
1182 WLOGFE("Failed to create object!");
1183 return NapiGetUndefined(env);
1184 }
1185
1186 napi_set_named_property(env, objValue, "UNSPECIFIED", CreateJsValue(env,
1187 static_cast<int32_t>(AAFwk::StartupVisibility::UNSPECIFIED)));
1188 napi_set_named_property(env, objValue, "STARTUP_HIDE", CreateJsValue(env,
1189 static_cast<int32_t>(AAFwk::StartupVisibility::STARTUP_HIDE)));
1190 napi_set_named_property(env, objValue, "STARTUP_SHOW", CreateJsValue(env,
1191 static_cast<int32_t>(AAFwk::StartupVisibility::STARTUP_SHOW)));
1192 napi_set_named_property(env, objValue, "END", CreateJsValue(env,
1193 static_cast<int32_t>(AAFwk::StartupVisibility::END)));
1194 return objValue;
1195 }
1196
CreateJsWindowVisibility(napi_env env)1197 napi_value CreateJsWindowVisibility(napi_env env)
1198 {
1199 if (env == nullptr) {
1200 WLOGFE("Env is nullptr");
1201 return nullptr;
1202 }
1203 napi_value objValue = nullptr;
1204 napi_create_object(env, &objValue);
1205 if (objValue == nullptr) {
1206 WLOGFE("Failed to create object!");
1207 return NapiGetUndefined(env);
1208 }
1209
1210 napi_set_named_property(env, objValue, "NO_OCCLUSION", CreateJsValue(env,
1211 static_cast<int32_t>(WindowVisibilityState::WINDOW_VISIBILITY_STATE_NO_OCCLUSION)));
1212 napi_set_named_property(env, objValue, "PARTIAL_OCCLUSION", CreateJsValue(env,
1213 static_cast<int32_t>(WindowVisibilityState::WINDOW_VISIBILITY_STATE_PARTICALLY_OCCLUSION)));
1214 napi_set_named_property(env, objValue, "COMPLETE_OCCLUSION", CreateJsValue(env,
1215 static_cast<int32_t>(WindowVisibilityState::WINDOW_VISIBILITY_STATE_TOTALLY_OCCUSION)));
1216 napi_set_named_property(env, objValue, "END", CreateJsValue(env,
1217 static_cast<int32_t>(WindowVisibilityState::WINDOW_LAYER_STATE_MAX)));
1218 return objValue;
1219 }
1220
CreateJsSessionProcessMode(napi_env env)1221 napi_value CreateJsSessionProcessMode(napi_env env)
1222 {
1223 if (env == nullptr) {
1224 WLOGFE("Env is nullptr");
1225 return nullptr;
1226 }
1227 napi_value objValue = nullptr;
1228 napi_create_object(env, &objValue);
1229 if (objValue == nullptr) {
1230 WLOGFE("Failed to create object!");
1231 return NapiGetUndefined(env);
1232 }
1233
1234 napi_set_named_property(env, objValue, "UNSPECIFIED", CreateJsValue(env,
1235 static_cast<int32_t>(AAFwk::ProcessMode::UNSPECIFIED)));
1236 napi_set_named_property(env, objValue, "NEW_PROCESS_ATTACH_TO_PARENT", CreateJsValue(env,
1237 static_cast<int32_t>(AAFwk::ProcessMode::NEW_PROCESS_ATTACH_TO_PARENT)));
1238 napi_set_named_property(env, objValue, "NEW_PROCESS_ATTACH_TO_STATUS_BAR_ITEM", CreateJsValue(env,
1239 static_cast<int32_t>(AAFwk::ProcessMode::NEW_PROCESS_ATTACH_TO_STATUS_BAR_ITEM)));
1240 napi_set_named_property(env, objValue, "END", CreateJsValue(env,
1241 static_cast<int32_t>(AAFwk::ProcessMode::END)));
1242 return objValue;
1243 }
1244
CreateJsSessionPiPControlType(napi_env env)1245 napi_value CreateJsSessionPiPControlType(napi_env env)
1246 {
1247 napi_value objValue = nullptr;
1248 napi_create_object(env, &objValue);
1249 if (objValue == nullptr) {
1250 WLOGFE("Failed to create object!");
1251 return NapiGetUndefined(env);
1252 }
1253
1254 napi_set_named_property(env, objValue, "VIDEO_PLAY_PAUSE", CreateJsValue(env,
1255 static_cast<uint32_t>(PiPControlType::VIDEO_PLAY_PAUSE)));
1256 napi_set_named_property(env, objValue, "VIDEO_PREVIOUS", CreateJsValue(env,
1257 static_cast<uint32_t>(PiPControlType::VIDEO_PREVIOUS)));
1258 napi_set_named_property(env, objValue, "VIDEO_NEXT", CreateJsValue(env,
1259 static_cast<uint32_t>(PiPControlType::VIDEO_NEXT)));
1260 napi_set_named_property(env, objValue, "FAST_FORWARD", CreateJsValue(env,
1261 static_cast<uint32_t>(PiPControlType::FAST_FORWARD)));
1262 napi_set_named_property(env, objValue, "FAST_BACKWARD", CreateJsValue(env,
1263 static_cast<uint32_t>(PiPControlType::FAST_BACKWARD)));
1264 napi_set_named_property(env, objValue, "HANG_UP_BUTTON", CreateJsValue(env,
1265 static_cast<uint32_t>(PiPControlType::HANG_UP_BUTTON)));
1266 napi_set_named_property(env, objValue, "MICROPHONE_SWITCH", CreateJsValue(env,
1267 static_cast<uint32_t>(PiPControlType::MICROPHONE_SWITCH)));
1268 napi_set_named_property(env, objValue, "CAMERA_SWITCH", CreateJsValue(env,
1269 static_cast<uint32_t>(PiPControlType::CAMERA_SWITCH)));
1270 napi_set_named_property(env, objValue, "MUTE_SWITCH", CreateJsValue(env,
1271 static_cast<uint32_t>(PiPControlType::MUTE_SWITCH)));
1272 return objValue;
1273 }
1274
CreateJsSessionPiPControlStatus(napi_env env)1275 napi_value CreateJsSessionPiPControlStatus(napi_env env)
1276 {
1277 napi_value objValue = nullptr;
1278 napi_create_object(env, &objValue);
1279 if (objValue == nullptr) {
1280 WLOGFE("Failed to create object!");
1281 return NapiGetUndefined(env);
1282 }
1283
1284 napi_set_named_property(env, objValue, "PLAY", CreateJsValue(env,
1285 static_cast<int32_t>(PiPControlStatus::PLAY)));
1286 napi_set_named_property(env, objValue, "PAUSE", CreateJsValue(env,
1287 static_cast<int32_t>(PiPControlStatus::PAUSE)));
1288 napi_set_named_property(env, objValue, "OPEN", CreateJsValue(env,
1289 static_cast<int32_t>(PiPControlStatus::OPEN)));
1290 napi_set_named_property(env, objValue, "CLOSE", CreateJsValue(env,
1291 static_cast<int32_t>(PiPControlStatus::CLOSE)));
1292 napi_set_named_property(env, objValue, "ENABLED", CreateJsValue(env,
1293 static_cast<int32_t>(PiPControlStatus::ENABLED)));
1294 napi_set_named_property(env, objValue, "DISABLED", CreateJsValue(env,
1295 static_cast<int32_t>(PiPControlStatus::DISABLED)));
1296 return objValue;
1297 }
1298
CreateJsSessionGravity(napi_env env)1299 napi_value CreateJsSessionGravity(napi_env env)
1300 {
1301 napi_value objValue = nullptr;
1302 napi_create_object(env, &objValue);
1303 if (objValue == nullptr) {
1304 WLOGFE("Failed to create object!");
1305 return NapiGetUndefined(env);
1306 }
1307 using T = std::underlying_type_t<Gravity>;
1308 napi_set_named_property(env, objValue, "CENTER", CreateJsValue(env,
1309 static_cast<T>(Gravity::CENTER)));
1310 napi_set_named_property(env, objValue, "TOP", CreateJsValue(env,
1311 static_cast<T>(Gravity::TOP)));
1312 napi_set_named_property(env, objValue, "BOTTOM", CreateJsValue(env,
1313 static_cast<T>(Gravity::BOTTOM)));
1314 napi_set_named_property(env, objValue, "LEFT", CreateJsValue(env,
1315 static_cast<T>(Gravity::LEFT)));
1316 napi_set_named_property(env, objValue, "RIGHT", CreateJsValue(env,
1317 static_cast<T>(Gravity::RIGHT)));
1318 napi_set_named_property(env, objValue, "TOP_LEFT", CreateJsValue(env,
1319 static_cast<T>(Gravity::TOP_LEFT)));
1320 napi_set_named_property(env, objValue, "TOP_RIGHT", CreateJsValue(env,
1321 static_cast<T>(Gravity::TOP_RIGHT)));
1322 napi_set_named_property(env, objValue, "BOTTOM_LEFT", CreateJsValue(env,
1323 static_cast<T>(Gravity::BOTTOM_LEFT)));
1324 napi_set_named_property(env, objValue, "BOTTOM_RIGHT", CreateJsValue(env,
1325 static_cast<T>(Gravity::BOTTOM_RIGHT)));
1326 napi_set_named_property(env, objValue, "RESIZE", CreateJsValue(env,
1327 static_cast<T>(Gravity::RESIZE)));
1328 napi_set_named_property(env, objValue, "RESIZE_ASPECT", CreateJsValue(env,
1329 static_cast<T>(Gravity::RESIZE_ASPECT)));
1330 napi_set_named_property(env, objValue, "RESIZE_ASPECT_TOP_LEFT", CreateJsValue(env,
1331 static_cast<T>(Gravity::RESIZE_ASPECT_TOP_LEFT)));
1332 napi_set_named_property(env, objValue, "RESIZE_ASPECT_BOTTOM_RIGHT", CreateJsValue(env,
1333 static_cast<T>(Gravity::RESIZE_ASPECT_BOTTOM_RIGHT)));
1334 napi_set_named_property(env, objValue, "RESIZE_ASPECT_FILL", CreateJsValue(env,
1335 static_cast<T>(Gravity::RESIZE_ASPECT_FILL)));
1336 napi_set_named_property(env, objValue, "RESIZE_ASPECT_FILL_TOP_LEFT", CreateJsValue(env,
1337 static_cast<T>(Gravity::RESIZE_ASPECT_FILL_TOP_LEFT)));
1338 napi_set_named_property(env, objValue, "RESIZE_ASPECT_FILL_BOTTOM_RIGHT", CreateJsValue(env,
1339 static_cast<T>(Gravity::RESIZE_ASPECT_FILL_BOTTOM_RIGHT)));
1340 return objValue;
1341 }
1342
CreateJsSessionDragResizeType(napi_env env)1343 napi_value CreateJsSessionDragResizeType(napi_env env)
1344 {
1345 napi_value objValue = nullptr;
1346 napi_create_object(env, &objValue);
1347 if (objValue == nullptr) {
1348 TLOGE(WmsLogTag::WMS_LAYOUT, "Failed to create object!");
1349 return NapiGetUndefined(env);
1350 }
1351
1352 napi_set_named_property(env, objValue, "RESIZE_TYPE_UNDEFINED", CreateJsValue(env,
1353 static_cast<uint32_t>(DragResizeType::RESIZE_TYPE_UNDEFINED)));
1354 napi_set_named_property(env, objValue, "RESIZE_EACH_FRAME", CreateJsValue(env,
1355 static_cast<uint32_t>(DragResizeType::RESIZE_EACH_FRAME)));
1356 napi_set_named_property(env, objValue, "RESIZE_WHEN_DRAG_END", CreateJsValue(env,
1357 static_cast<uint32_t>(DragResizeType::RESIZE_WHEN_DRAG_END)));
1358 return objValue;
1359 }
1360
1361 template<typename T>
CreateJsSessionRect(napi_env env,const T & rect)1362 napi_value CreateJsSessionRect(napi_env env, const T& rect)
1363 {
1364 WLOGFD("CreateJsSessionRect.");
1365 napi_value objValue = nullptr;
1366 napi_create_object(env, &objValue);
1367 if (objValue == nullptr) {
1368 WLOGFE("Failed to create object!");
1369 return NapiGetUndefined(env);
1370 }
1371
1372 napi_set_named_property(env, objValue, "posX_", CreateJsValue(env, rect.posX_));
1373 napi_set_named_property(env, objValue, "posY_", CreateJsValue(env, rect.posY_));
1374 napi_set_named_property(env, objValue, "width_", CreateJsValue(env, rect.width_));
1375 napi_set_named_property(env, objValue, "height_", CreateJsValue(env, rect.height_));
1376 return objValue;
1377 }
1378
CreateJsSessionEventParam(napi_env env,const SessionEventParam & param)1379 napi_value CreateJsSessionEventParam(napi_env env, const SessionEventParam& param)
1380 {
1381 WLOGFD("CreateJsSessionEventParam.");
1382 napi_value objValue = nullptr;
1383 napi_create_object(env, &objValue);
1384 if (objValue == nullptr) {
1385 WLOGFE("Failed to create object!");
1386 return NapiGetUndefined(env);
1387 }
1388
1389 napi_set_named_property(env, objValue, "pointerX", CreateJsValue(env, param.pointerX_));
1390 napi_set_named_property(env, objValue, "pointerY", CreateJsValue(env, param.pointerY_));
1391 napi_set_named_property(env, objValue, "sessionWidth", CreateJsValue(env, param.sessionWidth_));
1392 napi_set_named_property(env, objValue, "sessionHeight", CreateJsValue(env, param.sessionHeight_));
1393 napi_set_named_property(env, objValue, "dragResizeType", CreateJsValue(env, param.dragResizeType));
1394 return objValue;
1395 }
1396
SubWindowModalTypeInit(napi_env env)1397 napi_value SubWindowModalTypeInit(napi_env env)
1398 {
1399 if (env == nullptr) {
1400 TLOGE(WmsLogTag::WMS_SUB, "Env is nullptr");
1401 return nullptr;
1402 }
1403 napi_value objValue = nullptr;
1404 napi_create_object(env, &objValue);
1405 if (objValue == nullptr) {
1406 TLOGE(WmsLogTag::WMS_SUB, "Failed to get object");
1407 return nullptr;
1408 }
1409
1410 napi_set_named_property(env, objValue, "TYPE_UNDEFINED", CreateJsValue(env,
1411 static_cast<int32_t>(SubWindowModalType::TYPE_UNDEFINED)));
1412 napi_set_named_property(env, objValue, "TYPE_NORMAL", CreateJsValue(env,
1413 static_cast<int32_t>(SubWindowModalType::TYPE_NORMAL)));
1414 napi_set_named_property(env, objValue, "TYPE_DIALOG", CreateJsValue(env,
1415 static_cast<int32_t>(SubWindowModalType::TYPE_DIALOG)));
1416 napi_set_named_property(env, objValue, "TYPE_WINDOW_MODALITY", CreateJsValue(env,
1417 static_cast<int32_t>(SubWindowModalType::TYPE_WINDOW_MODALITY)));
1418 napi_set_named_property(env, objValue, "TYPE_TOAST", CreateJsValue(env,
1419 static_cast<int32_t>(SubWindowModalType::TYPE_TOAST)));
1420 napi_set_named_property(env, objValue, "TYPE_APPLICATION_MODALITY", CreateJsValue(env,
1421 static_cast<int32_t>(SubWindowModalType::TYPE_APPLICATION_MODALITY)));
1422 return objValue;
1423 }
1424
GetHexColor(uint32_t color)1425 static std::string GetHexColor(uint32_t color)
1426 {
1427 const int32_t rgbaLength = 8;
1428
1429 std::stringstream ioss;
1430 std::string temp;
1431 ioss << std::setiosflags(std::ios::uppercase) << std::hex << color;
1432 ioss >> temp;
1433 int count = rgbaLength - static_cast<int>(temp.length());
1434 std::string finalColor("#");
1435 std::string tmpColor(count, '0');
1436 tmpColor += temp;
1437 finalColor += tmpColor;
1438
1439 return finalColor;
1440 }
1441
CreateJsSystemBarPropertyObject(napi_env env,const WindowType type,const SystemBarProperty & property)1442 static napi_value CreateJsSystemBarPropertyObject(
1443 napi_env env, const WindowType type, const SystemBarProperty& property)
1444 {
1445 napi_value objValue = nullptr;
1446 napi_create_object(env, &objValue);
1447 if (objValue == nullptr) {
1448 WLOGFE("Failed to get jsObject");
1449 return nullptr;
1450 }
1451 if (WINDOW_TO_JS_SESSION_TYPE_MAP.count(type) != 0) {
1452 napi_set_named_property(env, objValue, "type", CreateJsValue(env, WINDOW_TO_JS_SESSION_TYPE_MAP.at(type)));
1453 } else {
1454 napi_set_named_property(env, objValue, "type", CreateJsValue(env, type));
1455 }
1456 napi_set_named_property(env, objValue, "enable", CreateJsValue(env, property.enable_));
1457 std::string bkgColor = GetHexColor(property.backgroundColor_);
1458 napi_set_named_property(env, objValue, "backgroundcolor", CreateJsValue(env, bkgColor));
1459 std::string contentColor = GetHexColor(property.contentColor_);
1460 napi_set_named_property(env, objValue, "contentcolor", CreateJsValue(env, contentColor));
1461 napi_set_named_property(env, objValue, "enableAnimation", CreateJsValue(env, property.enableAnimation_));
1462 napi_set_named_property(
1463 env, objValue, "settingFlag", CreateJsValue(env, static_cast<uint32_t>(property.settingFlag_)));
1464
1465 return objValue;
1466 }
1467
CreateJsKeyboardLayoutParams(napi_env env,const KeyboardLayoutParams & params)1468 napi_value CreateJsKeyboardLayoutParams(napi_env env, const KeyboardLayoutParams& params)
1469 {
1470 napi_value objValue = nullptr;
1471 napi_create_object(env, &objValue);
1472 if (objValue == nullptr) {
1473 WLOGFE("Failed to get jsObject");
1474 return nullptr;
1475 }
1476
1477 napi_set_named_property(env, objValue, "landscapeAvoidHeight",
1478 CreateJsValue(env, params.landscapeAvoidHeight_));
1479 napi_set_named_property(env, objValue, "portraitAvoidHeight",
1480 CreateJsValue(env, params.portraitAvoidHeight_));
1481 napi_set_named_property(env, objValue, "landscapeKeyboardRect",
1482 CreateJsSessionRect(env, params.LandscapeKeyboardRect_));
1483 napi_set_named_property(env, objValue, "portraitKeyboardRect",
1484 CreateJsSessionRect(env, params.PortraitKeyboardRect_));
1485 napi_set_named_property(env, objValue, "landscapePanelRect",
1486 CreateJsSessionRect(env, params.LandscapePanelRect_));
1487 napi_set_named_property(env, objValue, "portraitPanelRect",
1488 CreateJsSessionRect(env, params.PortraitPanelRect_));
1489 return objValue;
1490 }
1491
CreateJsSystemBarPropertyArrayObject(napi_env env,const std::unordered_map<WindowType,SystemBarProperty> & propertyMap)1492 napi_value CreateJsSystemBarPropertyArrayObject(
1493 napi_env env, const std::unordered_map<WindowType, SystemBarProperty>& propertyMap)
1494 {
1495 if (propertyMap.empty()) {
1496 WLOGFE("Empty propertyMap");
1497 return nullptr;
1498 }
1499 napi_value arrayValue = nullptr;
1500 napi_create_array_with_length(env, propertyMap.size(), &arrayValue);
1501 if (arrayValue == nullptr) {
1502 WLOGFE("Failed to get jsArrayObject");
1503 return nullptr;
1504 }
1505 uint32_t index = 0;
1506 for (auto iter: propertyMap) {
1507 napi_set_element(env, arrayValue, index++, CreateJsSystemBarPropertyObject(env, iter.first, iter.second));
1508 }
1509 return arrayValue;
1510 }
1511
SetTypeProperty(napi_value object,napi_env env,const std::string & name,JsSessionType type)1512 static void SetTypeProperty(napi_value object, napi_env env, const std::string& name, JsSessionType type)
1513 {
1514 napi_set_named_property(env, object, name.c_str(), CreateJsValue(env, static_cast<int32_t>(type)));
1515 }
1516
KeyboardGravityInit(napi_env env)1517 napi_value KeyboardGravityInit(napi_env env)
1518 {
1519 WLOGFI("KeyboardGravityInit");
1520
1521 if (env == nullptr) {
1522 WLOGFE("Env is nullptr");
1523 return nullptr;
1524 }
1525
1526 napi_value objValue = nullptr;
1527 napi_create_object(env, &objValue);
1528 if (objValue == nullptr) {
1529 WLOGFE("Failed to get object");
1530 return nullptr;
1531 }
1532 napi_set_named_property(env, objValue, "GRAVITY_FLOAT", CreateJsValue(env,
1533 static_cast<int32_t>(SessionGravity::SESSION_GRAVITY_FLOAT)));
1534 napi_set_named_property(env, objValue, "GRAVITY_BOTTOM", CreateJsValue(env,
1535 static_cast<int32_t>(SessionGravity::SESSION_GRAVITY_BOTTOM)));
1536 napi_set_named_property(env, objValue, "GRAVITY_DEFAULT", CreateJsValue(env,
1537 static_cast<int32_t>(SessionGravity::SESSION_GRAVITY_DEFAULT)));
1538 return objValue;
1539 }
1540
KeyboardViewModeInit(napi_env env)1541 napi_value KeyboardViewModeInit(napi_env env)
1542 {
1543 TLOGI(WmsLogTag::WMS_KEYBOARD, "In");
1544 if (env == nullptr) {
1545 TLOGE(WmsLogTag::WMS_KEYBOARD, "Env is nullptr");
1546 return nullptr;
1547 }
1548
1549 napi_value objValue = nullptr;
1550 napi_create_object(env, &objValue);
1551 if (objValue == nullptr) {
1552 TLOGE(WmsLogTag::WMS_KEYBOARD, "Failed to get object");
1553 return nullptr;
1554 }
1555 napi_set_named_property(env, objValue, "NON_IMMERSIVE_MODE", CreateJsValue(env,
1556 static_cast<int32_t>(KeyboardViewMode::NON_IMMERSIVE_MODE)));
1557 napi_set_named_property(env, objValue, "IMMERSIVE_MODE", CreateJsValue(env,
1558 static_cast<int32_t>(KeyboardViewMode::IMMERSIVE_MODE)));
1559 napi_set_named_property(env, objValue, "LIGHT_IMMERSIVE_MODE", CreateJsValue(env,
1560 static_cast<int32_t>(KeyboardViewMode::LIGHT_IMMERSIVE_MODE)));
1561 napi_set_named_property(env, objValue, "DARK_IMMERSIVE_MODE", CreateJsValue(env,
1562 static_cast<int32_t>(KeyboardViewMode::DARK_IMMERSIVE_MODE)));
1563 napi_set_named_property(env, objValue, "VIEW_MODE_END", CreateJsValue(env,
1564 static_cast<int32_t>(KeyboardViewMode::VIEW_MODE_END)));
1565 return objValue;
1566 }
1567
SessionTypeInit(napi_env env)1568 napi_value SessionTypeInit(napi_env env)
1569 {
1570 WLOGFD("in");
1571
1572 if (env == nullptr) {
1573 WLOGFE("Env is nullptr");
1574 return nullptr;
1575 }
1576
1577 napi_value objValue = nullptr;
1578 napi_create_object(env, &objValue);
1579 if (objValue == nullptr) {
1580 WLOGFE("Failed to get object");
1581 return nullptr;
1582 }
1583
1584 SetTypeProperty(objValue, env, "TYPE_UNDEFINED", JsSessionType::TYPE_UNDEFINED);
1585 SetTypeProperty(objValue, env, "TYPE_APP", JsSessionType::TYPE_APP);
1586 SetTypeProperty(objValue, env, "TYPE_SUB_APP", JsSessionType::TYPE_SUB_APP);
1587 SetTypeProperty(objValue, env, "TYPE_SYSTEM_ALERT", JsSessionType::TYPE_SYSTEM_ALERT);
1588 SetTypeProperty(objValue, env, "TYPE_INPUT_METHOD", JsSessionType::TYPE_INPUT_METHOD);
1589 SetTypeProperty(objValue, env, "TYPE_STATUS_BAR", JsSessionType::TYPE_STATUS_BAR);
1590 SetTypeProperty(objValue, env, "TYPE_PANEL", JsSessionType::TYPE_PANEL);
1591 SetTypeProperty(objValue, env, "TYPE_KEYGUARD", JsSessionType::TYPE_KEYGUARD);
1592 SetTypeProperty(objValue, env, "TYPE_VOLUME_OVERLAY", JsSessionType::TYPE_VOLUME_OVERLAY);
1593 SetTypeProperty(objValue, env, "TYPE_NAVIGATION_BAR", JsSessionType::TYPE_NAVIGATION_BAR);
1594 SetTypeProperty(objValue, env, "TYPE_FLOAT", JsSessionType::TYPE_FLOAT);
1595 SetTypeProperty(objValue, env, "TYPE_WALLPAPER", JsSessionType::TYPE_WALLPAPER);
1596 SetTypeProperty(objValue, env, "TYPE_DESKTOP", JsSessionType::TYPE_DESKTOP);
1597 SetTypeProperty(objValue, env, "TYPE_LAUNCHER_DOCK", JsSessionType::TYPE_LAUNCHER_DOCK);
1598 SetTypeProperty(objValue, env, "TYPE_FLOAT_CAMERA", JsSessionType::TYPE_FLOAT_CAMERA);
1599 SetTypeProperty(objValue, env, "TYPE_DIALOG", JsSessionType::TYPE_DIALOG);
1600 SetTypeProperty(objValue, env, "TYPE_SCREENSHOT", JsSessionType::TYPE_SCREENSHOT);
1601 SetTypeProperty(objValue, env, "TYPE_TOAST", JsSessionType::TYPE_TOAST);
1602 SetTypeProperty(objValue, env, "TYPE_POINTER", JsSessionType::TYPE_POINTER);
1603 SetTypeProperty(objValue, env, "TYPE_LAUNCHER_RECENT", JsSessionType::TYPE_LAUNCHER_RECENT);
1604 SetTypeProperty(objValue, env, "TYPE_SCENE_BOARD", JsSessionType::TYPE_SCENE_BOARD);
1605 SetTypeProperty(objValue, env, "TYPE_DRAGGING_EFFECT", JsSessionType::TYPE_DRAGGING_EFFECT);
1606 SetTypeProperty(objValue, env, "TYPE_INPUT_METHOD_STATUS_BAR", JsSessionType::TYPE_INPUT_METHOD_STATUS_BAR);
1607 SetTypeProperty(objValue, env, "TYPE_GLOBAL_SEARCH", JsSessionType::TYPE_GLOBAL_SEARCH);
1608 SetTypeProperty(objValue, env, "TYPE_NEGATIVE_SCREEN", JsSessionType::TYPE_NEGATIVE_SCREEN);
1609 SetTypeProperty(objValue, env, "TYPE_VOICE_INTERACTION", JsSessionType::TYPE_VOICE_INTERACTION);
1610 SetTypeProperty(objValue, env, "TYPE_SYSTEM_TOAST", JsSessionType::TYPE_SYSTEM_TOAST);
1611 SetTypeProperty(objValue, env, "TYPE_SYSTEM_FLOAT", JsSessionType::TYPE_SYSTEM_FLOAT);
1612 SetTypeProperty(objValue, env, "TYPE_THEME_EDITOR", JsSessionType::TYPE_THEME_EDITOR);
1613 SetTypeProperty(objValue, env, "TYPE_PIP", JsSessionType::TYPE_PIP);
1614 SetTypeProperty(objValue, env, "TYPE_NAVIGATION_INDICATOR", JsSessionType::TYPE_NAVIGATION_INDICATOR);
1615 SetTypeProperty(objValue, env, "TYPE_HANDWRITE", JsSessionType::TYPE_HANDWRITE);
1616 SetTypeProperty(objValue, env, "TYPE_KEYBOARD_PANEL", JsSessionType::TYPE_KEYBOARD_PANEL);
1617 SetTypeProperty(objValue, env, "TYPE_DIVIDER", JsSessionType::TYPE_DIVIDER);
1618 SetTypeProperty(objValue, env, "TYPE_TRANSPARENT_VIEW", JsSessionType::TYPE_TRANSPARENT_VIEW);
1619 SetTypeProperty(objValue, env, "TYPE_WALLET_SWIPE_CARD", JsSessionType::TYPE_WALLET_SWIPE_CARD);
1620 SetTypeProperty(objValue, env, "TYPE_SCREEN_CONTROL", JsSessionType::TYPE_SCREEN_CONTROL);
1621 SetTypeProperty(objValue, env, "TYPE_FLOAT_NAVIGATION", JsSessionType::TYPE_FLOAT_NAVIGATION);
1622 return objValue;
1623 }
1624
SceneTypeInit(napi_env env)1625 napi_value SceneTypeInit(napi_env env)
1626 {
1627 WLOGFD("in");
1628
1629 if (env == nullptr) {
1630 WLOGFE("Env is nullptr");
1631 return nullptr;
1632 }
1633
1634 napi_value objValue = nullptr;
1635 napi_create_object(env, &objValue);
1636 if (objValue == nullptr) {
1637 WLOGFE("Failed to get object");
1638 return nullptr;
1639 }
1640 napi_set_named_property(env, objValue, "DEFAULT",
1641 CreateJsValue(env, static_cast<int32_t>(SceneType::DEFAULT)));
1642 napi_set_named_property(env, objValue, "WINDOW_SCENE",
1643 CreateJsValue(env, static_cast<int32_t>(SceneType::WINDOW_SCENE)));
1644 napi_set_named_property(env, objValue, "SYSTEM_WINDOW_SCENE",
1645 CreateJsValue(env, static_cast<int32_t>(SceneType::SYSTEM_WINDOW_SCENE)));
1646 napi_set_named_property(env, objValue, "TRANSFORM_SCENE",
1647 CreateJsValue(env, static_cast<int32_t>(SceneType::TRANSFORM_SCENE)));
1648 napi_set_named_property(env, objValue, "PANEL_SCENE",
1649 CreateJsValue(env, static_cast<int32_t>(SceneType::PANEL_SCENE)));
1650 napi_set_named_property(env, objValue, "INPUT_SCENE",
1651 CreateJsValue(env, static_cast<int32_t>(SceneType::INPUT_SCENE)));
1652 return objValue;
1653 }
1654
1655 struct AsyncInfo {
1656 napi_env env;
1657 napi_async_work work;
1658 std::function<void()> func;
1659 };
1660
NapiAsyncWork(napi_env env,std::function<void ()> task)1661 static void NapiAsyncWork(napi_env env, std::function<void()> task)
1662 {
1663 napi_value resource = nullptr;
1664 AsyncInfo* info = new AsyncInfo();
1665 info->env = env;
1666 info->func = task;
1667 napi_create_string_utf8(env, "AsyncWork", NAPI_AUTO_LENGTH, &resource);
1668 napi_create_async_work(env, nullptr, resource, [](napi_env env, void* data) {
1669 },
1670 [](napi_env env, napi_status status, void* data) {
1671 AsyncInfo* info = (AsyncInfo*)data;
1672 info->func();
1673 napi_delete_async_work(env, info->work);
1674 delete info;
1675 }, (void*)info, &info->work);
1676 napi_queue_async_work(env, info->work);
1677 }
1678
MainThreadScheduler(napi_env env)1679 MainThreadScheduler::MainThreadScheduler(napi_env env)
1680 : env_(env)
1681 {
1682 GetMainEventHandler();
1683 envChecker_ = std::make_shared<int>(0);
1684 }
1685
GetMainEventHandler()1686 inline void MainThreadScheduler::GetMainEventHandler()
1687 {
1688 if (handler_ != nullptr) {
1689 return;
1690 }
1691 auto runner = OHOS::AppExecFwk::EventRunner::GetMainEventRunner();
1692 if (runner == nullptr) {
1693 return;
1694 }
1695 handler_ = std::make_shared<OHOS::AppExecFwk::EventHandler>(runner);
1696 }
1697
PostMainThreadTask(Task && localTask,std::string traceInfo,int64_t delayTime)1698 void MainThreadScheduler::PostMainThreadTask(Task&& localTask, std::string traceInfo, int64_t delayTime)
1699 {
1700 GetMainEventHandler();
1701 auto task = [env = env_, localTask, traceInfo, envChecker = std::weak_ptr<int>(envChecker_)]() {
1702 HITRACE_METER_FMT(HITRACE_TAG_WINDOW_MANAGER, "SCBCb:%s", traceInfo.c_str());
1703 if (envChecker.expired()) {
1704 TLOGNE(WmsLogTag::WMS_MAIN, "post task expired because of invalid scheduler");
1705 return;
1706 }
1707 napi_handle_scope scope = nullptr;
1708 napi_open_handle_scope(env, &scope);
1709 localTask();
1710 napi_close_handle_scope(env, scope);
1711 };
1712 if (handler_ && handler_->GetEventRunner()->IsCurrentRunnerThread()) {
1713 return task();
1714 } else if (handler_ && !handler_->GetEventRunner()->IsCurrentRunnerThread()) {
1715 handler_->PostTask(std::move(task), "wms:" + traceInfo, delayTime,
1716 OHOS::AppExecFwk::EventQueue::Priority::IMMEDIATE);
1717 } else {
1718 NapiAsyncWork(env_, task);
1719 }
1720 }
1721 } // namespace OHOS::Rosen