1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "js_pointer_context.h"
17 #include "pixel_map_napi.h"
18
19 #undef MMI_LOG_TAG
20 #define MMI_LOG_TAG "JsPointerContext"
21
22 namespace OHOS {
23 namespace MMI {
24 namespace {
25 constexpr int32_t STANDARD_SPEED { 5 };
26 constexpr int32_t MAX_SPEED { 20 };
27 constexpr int32_t MAX_TOUCHPAD_SPEED { 11 };
28 constexpr int32_t MIN_SPEED { 1 };
29 constexpr int32_t DEFAULT_ROWS { 3 };
30 constexpr int32_t MIN_ROWS { 1 };
31 constexpr int32_t MAX_ROWS { 100 };
32 constexpr size_t INPUT_PARAMETER { 2 };
33 constexpr int32_t DEFAULT_POINTER_SIZE { 1 };
34 constexpr int32_t MIN_POINTER_SIZE { 1 };
35 constexpr int32_t MAX_POINTER_SIZE { 7 };
36 constexpr int32_t MIN_POINTER_COLOR { 0x000000 };
37 constexpr int32_t THREE_PARAMETERS { 3 };
38 constexpr int32_t INVALID_VALUE { -2 };
39 constexpr int32_t MAX_PIXELMAP_SIZE { 256 };
40 } // namespace
41
42 bool JsPointerContext::isCustomCursorEx_ { false };
43
JsPointerContext()44 JsPointerContext::JsPointerContext() : mgr_(std::make_shared<JsPointerManager>()) {}
45
CreateInstance(napi_env env)46 napi_value JsPointerContext::CreateInstance(napi_env env)
47 {
48 CALL_DEBUG_ENTER;
49 napi_value global = nullptr;
50 CHKRP(napi_get_global(env, &global), GET_GLOBAL);
51
52 constexpr char className[] = "JsPointerContext";
53 napi_value jsClass = nullptr;
54 napi_property_descriptor desc[] = {};
55 napi_status status = napi_define_class(env, className, sizeof(className), JsPointerContext::CreateJsObject,
56 nullptr, sizeof(desc) / sizeof(desc[0]), nullptr, &jsClass);
57 CHKRP(status, DEFINE_CLASS);
58
59 status = napi_set_named_property(env, global, "multimodalinput_pointer_class", jsClass);
60 CHKRP(status, SET_NAMED_PROPERTY);
61
62 napi_value jsInstance = nullptr;
63 CHKRP(napi_new_instance(env, jsClass, 0, nullptr, &jsInstance), NEW_INSTANCE);
64 CHKRP(napi_set_named_property(env, global, "multimodal_pointer", jsInstance), SET_NAMED_PROPERTY);
65
66 JsPointerContext *jsContext = nullptr;
67 CHKRP(napi_unwrap(env, jsInstance, (void**)&jsContext), UNWRAP);
68 CHKPP(jsContext);
69 CHKRP(napi_create_reference(env, jsInstance, 1, &(jsContext->contextRef_)), CREATE_REFERENCE);
70
71 uint32_t refCount = 0;
72 CHKRP(napi_reference_ref(env, jsContext->contextRef_, &refCount), REFERENCE_REF);
73 return jsInstance;
74 }
75
CreateJsObject(napi_env env,napi_callback_info info)76 napi_value JsPointerContext::CreateJsObject(napi_env env, napi_callback_info info)
77 {
78 CALL_DEBUG_ENTER;
79 napi_value thisVar = nullptr;
80 void *data = nullptr;
81 CHKRP(napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data), GET_CB_INFO);
82
83 JsPointerContext *jsContext = new (std::nothrow) JsPointerContext();
84 CHKPP(jsContext);
85 napi_status status = napi_wrap(env, thisVar, jsContext, [](napi_env env, void* data, void* hin) {
86 MMI_HILOGI("Jsvm ends");
87 JsPointerContext *context = static_cast<JsPointerContext*>(data);
88 delete context;
89 }, nullptr, nullptr);
90 if (status != napi_ok) {
91 delete jsContext;
92 THROWERR(env, "Failed to wrap native instance");
93 return nullptr;
94 }
95 return thisVar;
96 }
97
GetInstance(napi_env env)98 JsPointerContext* JsPointerContext::GetInstance(napi_env env)
99 {
100 CALL_DEBUG_ENTER;
101 napi_value global = nullptr;
102 CHKRP(napi_get_global(env, &global), GET_GLOBAL);
103
104 bool result = false;
105 CHKRP(napi_has_named_property(env, global, "multimodal_pointer", &result), HAS_NAMED_PROPERTY);
106 if (!result) {
107 THROWERR(env, "multimodal_pointer was not found");
108 return nullptr;
109 }
110
111 napi_value object = nullptr;
112 CHKRP(napi_get_named_property(env, global, "multimodal_pointer", &object), SET_NAMED_PROPERTY);
113 if (object == nullptr) {
114 THROWERR(env, "object is nullptr");
115 return nullptr;
116 }
117
118 JsPointerContext *instance = nullptr;
119 CHKRP(napi_unwrap(env, object, (void**)&instance), UNWRAP);
120 if (instance == nullptr) {
121 THROWERR(env, "instance is nullptr");
122 return nullptr;
123 }
124 return instance;
125 }
126
GetJsPointerMgr() const127 std::shared_ptr<JsPointerManager> JsPointerContext::GetJsPointerMgr() const
128 {
129 return mgr_;
130 }
131
SetPointerVisible(napi_env env,napi_callback_info info)132 napi_value JsPointerContext::SetPointerVisible(napi_env env, napi_callback_info info)
133 {
134 CALL_DEBUG_ENTER;
135 size_t argc = 2;
136 napi_value argv[2] = { 0 };
137 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
138 if (argc < 1) {
139 MMI_HILOGE("At least one parameter is required");
140 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "visible", "boolean");
141 return nullptr;
142 }
143 if (!JsCommon::TypeOf(env, argv[0], napi_boolean)) {
144 MMI_HILOGE("Visible parameter type is invalid");
145 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "visible", "boolean");
146 return nullptr;
147 }
148 bool visible = true;
149 CHKRP(napi_get_value_bool(env, argv[0], &visible), GET_VALUE_BOOL);
150
151 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
152 CHKPP(jsPointer);
153 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
154 if (argc == 1) {
155 return jsPointerMgr->SetPointerVisible(env, visible);
156 }
157 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
158 MMI_HILOGE("Callback parameter type is invalid");
159 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
160 return nullptr;
161 }
162 return jsPointerMgr->SetPointerVisible(env, visible, argv[1]);
163 }
164
SetPointerVisibleSync(napi_env env,napi_callback_info info)165 napi_value JsPointerContext::SetPointerVisibleSync(napi_env env, napi_callback_info info)
166 {
167 CALL_DEBUG_ENTER;
168 size_t argc = 1;
169 napi_value argv[1] = { 0 };
170 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
171 if (argc < 1) {
172 MMI_HILOGE("At least one parameter is required");
173 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "visible", "boolean");
174 return nullptr;
175 }
176 if (!JsCommon::TypeOf(env, argv[0], napi_boolean)) {
177 MMI_HILOGE("Visible parameter type is invalid");
178 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "visible", "boolean");
179 return nullptr;
180 }
181 bool visible = true;
182 CHKRP(napi_get_value_bool(env, argv[0], &visible), GET_VALUE_BOOL);
183
184 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
185 CHKPP(jsPointer);
186 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
187 return jsPointerMgr->SetPointerVisibleSync(env, visible);
188 }
189
IsPointerVisible(napi_env env,napi_callback_info info)190 napi_value JsPointerContext::IsPointerVisible(napi_env env, napi_callback_info info)
191 {
192 CALL_DEBUG_ENTER;
193 size_t argc = 1;
194 napi_value argv[1] = { 0 };
195 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
196
197 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
198 CHKPP(jsPointer);
199 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
200 if (argc < 1) {
201 return jsPointerMgr->IsPointerVisible(env);
202 }
203 if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
204 MMI_HILOGE("Callback parameter type is invalid");
205 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
206 return nullptr;
207 }
208
209 return jsPointerMgr->IsPointerVisible(env, argv[0]);
210 }
211
IsPointerVisibleSync(napi_env env,napi_callback_info info)212 napi_value JsPointerContext::IsPointerVisibleSync(napi_env env, napi_callback_info info)
213 {
214 CALL_DEBUG_ENTER;
215 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
216 CHKPP(jsPointer);
217 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
218 return jsPointerMgr->IsPointerVisibleSync(env);
219 }
220
SetPointerColor(napi_env env,napi_callback_info info)221 napi_value JsPointerContext::SetPointerColor(napi_env env, napi_callback_info info)
222 {
223 CALL_DEBUG_ENTER;
224 size_t argc = 2;
225 napi_value argv[2] = { 0 };
226 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
227 if (argc < 1) {
228 MMI_HILOGE("At least 1 parameter is required");
229 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "color", "number");
230 return nullptr;
231 }
232 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
233 MMI_HILOGE("Color parameter type is invalid");
234 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "color", "number");
235 return nullptr;
236 }
237 int32_t color = MIN_POINTER_COLOR;
238 CHKRP(napi_get_value_int32(env, argv[0], &color), GET_VALUE_INT32);
239 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
240 CHKPP(jsPointer);
241 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
242 if (argc == 1) {
243 return jsPointerMgr->SetPointerColor(env, color);
244 }
245 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
246 MMI_HILOGE("Callback parameter type is invalid");
247 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
248 return nullptr;
249 }
250 return jsPointerMgr->SetPointerColor(env, color, argv[1]);
251 }
252
GetPointerColor(napi_env env,napi_callback_info info)253 napi_value JsPointerContext::GetPointerColor(napi_env env, napi_callback_info info)
254 {
255 CALL_DEBUG_ENTER;
256 size_t argc = 1;
257 napi_value argv[1] = { 0 };
258 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
259 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
260 CHKPP(jsPointer);
261 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
262 if (argc < 1) {
263 return jsPointerMgr->GetPointerColor(env);
264 }
265 if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
266 MMI_HILOGE("Callback parameter type is invalid");
267 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
268 return nullptr;
269 }
270
271 return jsPointerMgr->GetPointerColor(env, argv[0]);
272 }
273
SetPointerColorSync(napi_env env,napi_callback_info info)274 napi_value JsPointerContext::SetPointerColorSync(napi_env env, napi_callback_info info)
275 {
276 CALL_DEBUG_ENTER;
277 size_t argc = 1;
278 napi_value argv[1] = { 0 };
279 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
280 if (argc < 1) {
281 MMI_HILOGE("At least 1 parameter is required");
282 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "color", "number");
283 return nullptr;
284 }
285 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
286 MMI_HILOGE("Color parameter type is invalid");
287 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "color", "number");
288 return nullptr;
289 }
290 int32_t color = MIN_POINTER_COLOR;
291 CHKRP(napi_get_value_int32(env, argv[0], &color), GET_VALUE_INT32);
292 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
293 CHKPP(jsPointer);
294 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
295 return jsPointerMgr->SetPointerColorSync(env, color);
296 }
297
GetPointerColorSync(napi_env env,napi_callback_info info)298 napi_value JsPointerContext::GetPointerColorSync(napi_env env, napi_callback_info info)
299 {
300 CALL_DEBUG_ENTER;
301 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
302 CHKPP(jsPointer);
303 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
304 return jsPointerMgr->GetPointerColorSync(env);
305 }
306
SetPointerSpeed(napi_env env,napi_callback_info info)307 napi_value JsPointerContext::SetPointerSpeed(napi_env env, napi_callback_info info)
308 {
309 CALL_DEBUG_ENTER;
310 size_t argc = 2;
311 napi_value argv[2] = { 0 };
312 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
313 if (argc < 1) {
314 MMI_HILOGE("At least 1 parameter is required");
315 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "speed", "number");
316 return nullptr;
317 }
318 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
319 MMI_HILOGE("Speed parameter type is invalid");
320 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "speed", "number");
321 return nullptr;
322 }
323 int32_t pointerSpeed = STANDARD_SPEED;
324 CHKRP(napi_get_value_int32(env, argv[0], &pointerSpeed), GET_VALUE_INT32);
325 if (pointerSpeed < MIN_SPEED) {
326 pointerSpeed = MIN_SPEED;
327 } else if (pointerSpeed > MAX_SPEED) {
328 pointerSpeed = MAX_SPEED;
329 }
330 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
331 CHKPP(jsPointer);
332 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
333 if (argc == 1) {
334 return jsPointerMgr->SetPointerSpeed(env, pointerSpeed);
335 }
336 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
337 MMI_HILOGE("Callback parameter type is invalid");
338 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
339 return nullptr;
340 }
341 return jsPointerMgr->SetPointerSpeed(env, pointerSpeed, argv[1]);
342 }
343
SetPointerSpeedSync(napi_env env,napi_callback_info info)344 napi_value JsPointerContext::SetPointerSpeedSync(napi_env env, napi_callback_info info)
345 {
346 CALL_DEBUG_ENTER;
347 size_t argc = 1;
348 napi_value argv[1] = { 0 };
349 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
350 if (argc < 1) {
351 MMI_HILOGE("At least 1 parameter is required");
352 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "speed", "number");
353 return nullptr;
354 }
355 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
356 MMI_HILOGE("Speed parameter type is invalid");
357 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "speed", "number");
358 return nullptr;
359 }
360 int32_t pointerSpeed = STANDARD_SPEED;
361 CHKRP(napi_get_value_int32(env, argv[0], &pointerSpeed), GET_VALUE_INT32);
362 if (pointerSpeed < MIN_SPEED) {
363 pointerSpeed = MIN_SPEED;
364 } else if (pointerSpeed > MAX_SPEED) {
365 pointerSpeed = MAX_SPEED;
366 }
367 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
368 CHKPP(jsPointer);
369 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
370 return jsPointerMgr->SetPointerSpeedSync(env, pointerSpeed);
371 }
372
GetPointerSpeed(napi_env env,napi_callback_info info)373 napi_value JsPointerContext::GetPointerSpeed(napi_env env, napi_callback_info info)
374 {
375 CALL_DEBUG_ENTER;
376 size_t argc = 1;
377 napi_value argv[1] = { 0 };
378 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
379 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
380 CHKPP(jsPointer);
381 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
382 if (argc < 1) {
383 return jsPointerMgr->GetPointerSpeed(env);
384 }
385 if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
386 MMI_HILOGE("Callback parameter type is invalid");
387 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
388 return nullptr;
389 }
390
391 return jsPointerMgr->GetPointerSpeed(env, argv[0]);
392 }
393
GetPointerSpeedSync(napi_env env,napi_callback_info info)394 napi_value JsPointerContext::GetPointerSpeedSync(napi_env env, napi_callback_info info)
395 {
396 CALL_DEBUG_ENTER;
397 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
398 CHKPP(jsPointer);
399 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
400 return jsPointerMgr->GetPointerSpeedSync(env);
401 }
402
SetMouseScrollRows(napi_env env,napi_callback_info info)403 napi_value JsPointerContext::SetMouseScrollRows(napi_env env, napi_callback_info info)
404 {
405 CALL_DEBUG_ENTER;
406 size_t argc = 2;
407 napi_value argv[2] = { 0 };
408 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
409 if (argc < 1) {
410 MMI_HILOGE("At least 1 parameter is required");
411 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "rows", "number");
412 return nullptr;
413 }
414 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
415 MMI_HILOGE("Rows parameter type is invalid");
416 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "rows", "number");
417 return nullptr;
418 }
419 int32_t rows = DEFAULT_ROWS;
420 CHKRP(napi_get_value_int32(env, argv[0], &rows), GET_VALUE_INT32);
421 if (rows < MIN_ROWS) {
422 rows = MIN_ROWS;
423 } else if (rows > MAX_ROWS) {
424 rows = MAX_ROWS;
425 }
426 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
427 CHKPP(jsPointer);
428 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
429 if (argc == 1) {
430 return jsPointerMgr->SetMouseScrollRows(env, rows);
431 }
432 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
433 MMI_HILOGE("Callback parameter type is invalid");
434 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
435 return nullptr;
436 }
437 return jsPointerMgr->SetMouseScrollRows(env, rows, argv[1]);
438 }
439
GetMouseScrollRows(napi_env env,napi_callback_info info)440 napi_value JsPointerContext::GetMouseScrollRows(napi_env env, napi_callback_info info)
441 {
442 CALL_DEBUG_ENTER;
443 size_t argc = 1;
444 napi_value argv[1] = { 0 };
445 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
446 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
447 CHKPP(jsPointer);
448 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
449 if (argc < 1) {
450 return jsPointerMgr->GetMouseScrollRows(env);
451 }
452 if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
453 MMI_HILOGE("Callback parameter type is invalid");
454 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
455 return nullptr;
456 }
457
458 return jsPointerMgr->GetMouseScrollRows(env, argv[0]);
459 }
460
SetPointerLocation(napi_env env,napi_callback_info info)461 napi_value JsPointerContext::SetPointerLocation(napi_env env, napi_callback_info info)
462 {
463 CALL_DEBUG_ENTER;
464 size_t argc = 3;
465 napi_value argv[3] = { 0 };
466 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
467 if (argc < INPUT_PARAMETER) {
468 MMI_HILOGE("At least 2 parameter is required");
469 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "x", "number");
470 return nullptr;
471 }
472 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
473 MMI_HILOGE("x parameter type is invalid");
474 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "x", "number");
475 return nullptr;
476 }
477 int32_t x = 0;
478 CHKRP(napi_get_value_int32(env, argv[0], &x), GET_VALUE_INT32);
479 if (x < 0) {
480 MMI_HILOGE("Invalid x");
481 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "x is invalid");
482 return nullptr;
483 }
484 if (!JsCommon::TypeOf(env, argv[1], napi_number)) {
485 MMI_HILOGE("y parameter type is invalid");
486 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "y", "number");
487 return nullptr;
488 }
489 int32_t y = 0;
490 CHKRP(napi_get_value_int32(env, argv[1], &y), GET_VALUE_INT32);
491 if (y < 0) {
492 MMI_HILOGE("Invalid y");
493 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "y is invalid");
494 return nullptr;
495 }
496 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
497 CHKPP(jsPointer);
498 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
499 if (argc == INPUT_PARAMETER) {
500 return jsPointerMgr->SetPointerLocation(env, x, y);
501 }
502 if (!JsCommon::TypeOf(env, argv[INPUT_PARAMETER], napi_function)) {
503 MMI_HILOGE("Callback parameter type is invalid");
504 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
505 return nullptr;
506 }
507 return jsPointerMgr->SetPointerLocation(env, x, y, argv[INPUT_PARAMETER]);
508 }
509
SetCustomCursor(napi_env env,napi_callback_info info)510 napi_value JsPointerContext::SetCustomCursor(napi_env env, napi_callback_info info)
511 {
512 CALL_DEBUG_ENTER;
513 size_t argc = 4;
514 napi_value argv[4] = { 0 };
515 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
516 if (argc < INPUT_PARAMETER) {
517 MMI_HILOGE("At least 2 parameter is required");
518 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
519 return nullptr;
520 }
521
522 int32_t windowId = GetWindowId(env, argv[0]);
523 if (windowId < 0) {
524 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "windowId is invalid");
525 return nullptr;
526 }
527 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
528 CHKPP(jsPointer);
529 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
530 bool isEx = CheckIsSetCustomCursorEx(env, argc, argv);
531 if (isEx) {
532 napi_value result = SetCustomCursorEx(env, jsPointerMgr, windowId, argc, argv);
533 return result;
534 }
535 if (!JsCommon::TypeOf(env, argv[1], napi_object)) {
536 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "pixelMap", "object");
537 return nullptr;
538 }
539 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMapNapi::GetPixelMap(env, argv[1]);
540 if (pixelMap == nullptr) {
541 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "pixelMap is invalid");
542 return nullptr;
543 }
544 CursorFocus cursorFocus;
545 if (argc == INPUT_PARAMETER) {
546 return jsPointerMgr->SetCustomCursor(env, windowId, (void *)pixelMap.get(), cursorFocus);
547 }
548
549 cursorFocus.x = GetCursorFocusX(env, argv[INPUT_PARAMETER]);
550 if (cursorFocus.x == INVALID_VALUE) {
551 return nullptr;
552 }
553 if (argc == THREE_PARAMETERS) {
554 return jsPointerMgr->SetCustomCursor(env, windowId, (void *)pixelMap.get(), cursorFocus);
555 }
556
557 cursorFocus.y = GetCursorFocusY(env, argv[THREE_PARAMETERS]);
558 if (cursorFocus.y == INVALID_VALUE) {
559 return nullptr;
560 }
561 return jsPointerMgr->SetCustomCursor(env, windowId, (void *)pixelMap.get(), cursorFocus);
562 }
563
SetCustomCursorSync(napi_env env,napi_callback_info info)564 napi_value JsPointerContext::SetCustomCursorSync(napi_env env, napi_callback_info info)
565 {
566 CALL_DEBUG_ENTER;
567 size_t argc = 4;
568 napi_value argv[4] = { 0 };
569 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
570 if (argc < INPUT_PARAMETER) {
571 MMI_HILOGE("At least 2 parameter is required");
572 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
573 return nullptr;
574 }
575
576 int32_t windowId = GetWindowId(env, argv[0]);
577 if (windowId == INVALID_VALUE) {
578 return nullptr;
579 }
580
581 if (!JsCommon::TypeOf(env, argv[1], napi_object)) {
582 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "pixelMap", "napi_object");
583 return nullptr;
584 }
585 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMapNapi::GetPixelMap(env, argv[1]);
586 if (pixelMap == nullptr) {
587 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "pixelMap is invalid");
588 return nullptr;
589 }
590 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
591 CHKPP(jsPointer);
592 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
593 CursorFocus cursorFocus;
594 if (argc == INPUT_PARAMETER) {
595 return jsPointerMgr->SetCustomCursorSync(env, windowId, (void *)pixelMap.get(), cursorFocus);
596 }
597
598 cursorFocus.x = GetCursorFocusX(env, argv[INPUT_PARAMETER]);
599 if (cursorFocus.x == INVALID_VALUE) {
600 return nullptr;
601 }
602 if (argc == THREE_PARAMETERS) {
603 return jsPointerMgr->SetCustomCursorSync(env, windowId, (void *)pixelMap.get(), cursorFocus);
604 }
605
606 cursorFocus.y = GetCursorFocusY(env, argv[THREE_PARAMETERS]);
607 if (cursorFocus.y == INVALID_VALUE) {
608 return nullptr;
609 }
610 return jsPointerMgr->SetCustomCursorSync(env, windowId, (void *)pixelMap.get(), cursorFocus);
611 }
612
SetMoveEventFilters(napi_env env,napi_callback_info info)613 napi_value JsPointerContext::SetMoveEventFilters(napi_env env, napi_callback_info info)
614 {
615 CALL_DEBUG_ENTER;
616 size_t argc = 1;
617 napi_value argv[1];
618 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
619 if (argc < 1) {
620 MMI_HILOGE("At least one parameter is required");
621 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "parameter number error");
622 return nullptr;
623 }
624
625 if (!JsCommon::TypeOf(env, argv[0], napi_boolean)) {
626 MMI_HILOGE("Flag parameter type is invalid");
627 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "parameter type error");
628 return nullptr;
629 }
630
631 bool flag = true;
632 CHKRP(napi_get_value_bool(env, argv[0], &flag), GET_VALUE_BOOL);
633
634 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
635 CHKPP(jsPointer);
636 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
637 CHKPP(jsPointerMgr);
638 return jsPointerMgr->SetMoveEventFilters(env, flag);
639 }
640
GetWindowId(napi_env env,napi_value value)641 int32_t JsPointerContext::GetWindowId(napi_env env, napi_value value)
642 {
643 if (!JsCommon::TypeOf(env, value, napi_number)) {
644 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
645 return INVALID_VALUE;
646 }
647 int32_t windowId = 0;
648 CHKRR(napi_get_value_int32(env, value, &windowId), GET_VALUE_INT32, INVALID_VALUE);
649 if (windowId < 0 && windowId != GLOBAL_WINDOW_ID) {
650 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Windowid is invalid");
651 return INVALID_VALUE;
652 }
653 return windowId;
654 }
655
GetCursorFocusX(napi_env env,napi_value value)656 int32_t JsPointerContext::GetCursorFocusX(napi_env env, napi_value value)
657 {
658 if (!JsCommon::TypeOf(env, value, napi_number)) {
659 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "focusX", "number");
660 return INVALID_VALUE;
661 }
662 int32_t focusX = 0;
663 CHKRR(napi_get_value_int32(env, value, &focusX), GET_VALUE_INT32, INVALID_VALUE);
664 if (focusX < 0) {
665 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "focusX is invalid");
666 return INVALID_VALUE;
667 }
668 return focusX;
669 }
670
GetCursorFocusY(napi_env env,napi_value value)671 int32_t JsPointerContext::GetCursorFocusY(napi_env env, napi_value value)
672 {
673 if (!JsCommon::TypeOf(env, value, napi_number)) {
674 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "focusY", "number");
675 return INVALID_VALUE;
676 }
677 int32_t focusY = 0;
678 CHKRR(napi_get_value_int32(env, value, &focusY), GET_VALUE_INT32, INVALID_VALUE);
679 if (focusY < 0) {
680 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "focusY is invalid");
681 return INVALID_VALUE;
682 }
683 return focusY;
684 }
685
SetPointerSize(napi_env env,napi_callback_info info)686 napi_value JsPointerContext::SetPointerSize(napi_env env, napi_callback_info info)
687 {
688 CALL_DEBUG_ENTER;
689 size_t argc = 2;
690 napi_value argv[2] = { 0 };
691 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
692 if (argc < 1) {
693 MMI_HILOGE("At least 1 parameter is required");
694 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "size", "number");
695 return nullptr;
696 }
697 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
698 MMI_HILOGE("Size parameter type is invalid");
699 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "size", "number");
700 return nullptr;
701 }
702 int32_t size = DEFAULT_POINTER_SIZE;
703 CHKRP(napi_get_value_int32(env, argv[0], &size), GET_VALUE_INT32);
704 if (size < MIN_POINTER_SIZE) {
705 size = MIN_POINTER_SIZE;
706 } else if (size > MAX_POINTER_SIZE) {
707 size = MAX_POINTER_SIZE;
708 }
709 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
710 CHKPP(jsPointer);
711 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
712 if (argc == 1) {
713 return jsPointerMgr->SetPointerSize(env, size);
714 }
715 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
716 MMI_HILOGE("Callback parameter type is invalid");
717 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
718 return nullptr;
719 }
720 return jsPointerMgr->SetPointerSize(env, size, argv[1]);
721 }
722
GetPointerSize(napi_env env,napi_callback_info info)723 napi_value JsPointerContext::GetPointerSize(napi_env env, napi_callback_info info)
724 {
725 CALL_DEBUG_ENTER;
726 size_t argc = 1;
727 napi_value argv[1] = { 0 };
728 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
729 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
730 CHKPP(jsPointer);
731 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
732 if (argc < 1) {
733 return jsPointerMgr->GetPointerSize(env);
734 }
735 if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
736 MMI_HILOGE("Callback parameter type is invalid");
737 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
738 return nullptr;
739 }
740
741 return jsPointerMgr->GetPointerSize(env, argv[0]);
742 }
743
SetPointerSizeSync(napi_env env,napi_callback_info info)744 napi_value JsPointerContext::SetPointerSizeSync(napi_env env, napi_callback_info info)
745 {
746 CALL_DEBUG_ENTER;
747 size_t argc = 1;
748 napi_value argv[1] = { 0 };
749 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
750 if (argc < 1) {
751 MMI_HILOGE("At least 1 parameter is required");
752 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "size", "number");
753 return nullptr;
754 }
755 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
756 MMI_HILOGE("Size parameter type is invalid");
757 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "size", "number");
758 return nullptr;
759 }
760 int32_t size = DEFAULT_POINTER_SIZE;
761 CHKRP(napi_get_value_int32(env, argv[0], &size), GET_VALUE_INT32);
762 if (size < MIN_POINTER_SIZE) {
763 size = MIN_POINTER_SIZE;
764 } else if (size > MAX_POINTER_SIZE) {
765 size = MAX_POINTER_SIZE;
766 }
767 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
768 CHKPP(jsPointer);
769 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
770 return jsPointerMgr->SetPointerSizeSync(env, size);
771 }
772
GetPointerSizeSync(napi_env env,napi_callback_info info)773 napi_value JsPointerContext::GetPointerSizeSync(napi_env env, napi_callback_info info)
774 {
775 CALL_DEBUG_ENTER;
776 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
777 CHKPP(jsPointer);
778 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
779 return jsPointerMgr->GetPointerSizeSync(env);
780 }
781
SetPointerStyle(napi_env env,napi_callback_info info)782 napi_value JsPointerContext::SetPointerStyle(napi_env env, napi_callback_info info)
783 {
784 CALL_DEBUG_ENTER;
785 size_t argc = 3;
786 napi_value argv[3] = { 0 };
787 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
788 if (argc < INPUT_PARAMETER) {
789 MMI_HILOGE("At least 2 parameter is required");
790 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
791 return nullptr;
792 }
793 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
794 MMI_HILOGE("windowId parameter type is invalid");
795 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
796 return nullptr;
797 }
798 int32_t windowid = 0;
799 CHKRP(napi_get_value_int32(env, argv[0], &windowid), GET_VALUE_INT32);
800 if (windowid < 0 && windowid != GLOBAL_WINDOW_ID) {
801 MMI_HILOGE("Invalid windowid");
802 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Windowid is invalid");
803 return nullptr;
804 }
805 if (!JsCommon::TypeOf(env, argv[1], napi_number)) {
806 MMI_HILOGE("pointerStyle parameter type is invalid");
807 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "pointerStyle", "number");
808 return nullptr;
809 }
810 int32_t pointerStyle = 0;
811 CHKRP(napi_get_value_int32(env, argv[1], &pointerStyle), GET_VALUE_INT32);
812 if ((pointerStyle < DEFAULT && pointerStyle != DEVELOPER_DEFINED_ICON) || pointerStyle > RUNNING) {
813 MMI_HILOGE("Undefined pointer style");
814 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Pointer style does not exist");
815 return nullptr;
816 }
817 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
818 CHKPP(jsPointer);
819 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
820 if (argc == INPUT_PARAMETER) {
821 return jsPointerMgr->SetPointerStyle(env, windowid, pointerStyle);
822 }
823 if (!JsCommon::TypeOf(env, argv[INPUT_PARAMETER], napi_function)) {
824 MMI_HILOGE("Callback parameter type is invalid");
825 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
826 return nullptr;
827 }
828 return jsPointerMgr->SetPointerStyle(env, windowid, pointerStyle, argv[INPUT_PARAMETER]);
829 }
830
SetPointerStyleSync(napi_env env,napi_callback_info info)831 napi_value JsPointerContext::SetPointerStyleSync(napi_env env, napi_callback_info info)
832 {
833 CALL_DEBUG_ENTER;
834 size_t argc = 2;
835 napi_value argv[2] = { 0 };
836 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
837 if (argc < INPUT_PARAMETER) {
838 MMI_HILOGE("At least 2 parameter is required");
839 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
840 return nullptr;
841 }
842 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
843 MMI_HILOGE("windowId parameter type is invalid");
844 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
845 return nullptr;
846 }
847 int32_t windowid = 0;
848 CHKRP(napi_get_value_int32(env, argv[0], &windowid), GET_VALUE_INT32);
849 if (windowid < 0 && windowid != GLOBAL_WINDOW_ID) {
850 MMI_HILOGE("Invalid windowid");
851 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Windowid is invalid");
852 return nullptr;
853 }
854 if (!JsCommon::TypeOf(env, argv[1], napi_number)) {
855 MMI_HILOGE("pointerStyle parameter type is invalid");
856 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "pointerStyle", "number");
857 return nullptr;
858 }
859 int32_t pointerStyle = 0;
860 CHKRP(napi_get_value_int32(env, argv[1], &pointerStyle), GET_VALUE_INT32);
861 if ((pointerStyle < DEFAULT && pointerStyle != DEVELOPER_DEFINED_ICON) || pointerStyle > RUNNING) {
862 MMI_HILOGE("Undefined pointer style");
863 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Pointer style does not exist");
864 return nullptr;
865 }
866 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
867 CHKPP(jsPointer);
868 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
869 return jsPointerMgr->SetPointerStyleSync(env, windowid, pointerStyle);
870 }
871
GetPointerStyle(napi_env env,napi_callback_info info)872 napi_value JsPointerContext::GetPointerStyle(napi_env env, napi_callback_info info)
873 {
874 CALL_DEBUG_ENTER;
875 size_t argc = 2;
876 napi_value argv[2] = { 0 };
877 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
878 if (argc < 1) {
879 MMI_HILOGE("At least 1 parameter is required");
880 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
881 return nullptr;
882 }
883 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
884 MMI_HILOGE("windowId parameter type is invalid");
885 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
886 return nullptr;
887 }
888 int32_t windowid = 0;
889 CHKRP(napi_get_value_int32(env, argv[0], &windowid), GET_VALUE_INT32);
890 if (windowid < 0 && windowid != GLOBAL_WINDOW_ID) {
891 MMI_HILOGE("Invalid windowid");
892 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Windowid is invalid");
893 return nullptr;
894 }
895 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
896 CHKPP(jsPointer);
897 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
898 if (argc == 1) {
899 return jsPointerMgr->GetPointerStyle(env, windowid);
900 }
901 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
902 MMI_HILOGE("Callback parameter type is invalid");
903 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
904 return nullptr;
905 }
906 return jsPointerMgr->GetPointerStyle(env, windowid, argv[1]);
907 }
908
GetPointerStyleSync(napi_env env,napi_callback_info info)909 napi_value JsPointerContext::GetPointerStyleSync(napi_env env, napi_callback_info info)
910 {
911 CALL_DEBUG_ENTER;
912 size_t argc = 1;
913 napi_value argv[1] = { 0 };
914 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
915 if (argc < 1) {
916 MMI_HILOGE("At least 1 parameter is required");
917 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
918 return nullptr;
919 }
920 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
921 MMI_HILOGE("windowId parameter type is invalid");
922 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
923 return nullptr;
924 }
925 int32_t windowId = 0;
926 CHKRP(napi_get_value_int32(env, argv[0], &windowId), GET_VALUE_INT32);
927 if (windowId < 0 && windowId != GLOBAL_WINDOW_ID) {
928 MMI_HILOGE("Invalid windowId");
929 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "WindowId is invalid");
930 return nullptr;
931 }
932 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
933 CHKPP(jsPointer);
934 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
935 return jsPointerMgr->GetPointerStyleSync(env, windowId);
936 }
937
CreatePointerStyle(napi_env env,napi_value exports)938 napi_value JsPointerContext::CreatePointerStyle(napi_env env, napi_value exports)
939 {
940 CALL_DEBUG_ENTER;
941 napi_value defaults = nullptr;
942 CHKRP(napi_create_int32(env, MOUSE_ICON::DEFAULT, &defaults), CREATE_INT32);
943 napi_value east = nullptr;
944 CHKRP(napi_create_int32(env, MOUSE_ICON::EAST, &east), CREATE_INT32);
945 napi_value west = nullptr;
946 CHKRP(napi_create_int32(env, MOUSE_ICON::WEST, &west), CREATE_INT32);
947 napi_value south = nullptr;
948 CHKRP(napi_create_int32(env, MOUSE_ICON::SOUTH, &south), CREATE_INT32);
949 napi_value north = nullptr;
950 CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH, &north), CREATE_INT32);
951 napi_value west_east = nullptr;
952 CHKRP(napi_create_int32(env, MOUSE_ICON::WEST_EAST, &west_east), CREATE_INT32);
953 napi_value north_south = nullptr;
954 CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH_SOUTH, &north_south), CREATE_INT32);
955 napi_value north_east = nullptr;
956 CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH_EAST, &north_east), CREATE_INT32);
957 napi_value north_west = nullptr;
958 CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH_WEST, &north_west), CREATE_INT32);
959 napi_value south_east = nullptr;
960 CHKRP(napi_create_int32(env, MOUSE_ICON::SOUTH_EAST, &south_east), CREATE_INT32);
961 napi_value south_west = nullptr;
962 CHKRP(napi_create_int32(env, MOUSE_ICON::SOUTH_WEST, &south_west), CREATE_INT32);
963 napi_value north_east_south_west = nullptr;
964 CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH_EAST_SOUTH_WEST, &north_east_south_west), CREATE_INT32);
965 napi_value north_west_south_east = nullptr;
966 CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH_WEST_SOUTH_EAST, &north_west_south_east), CREATE_INT32);
967 napi_value cross = nullptr;
968 CHKRP(napi_create_int32(env, MOUSE_ICON::CROSS, &cross), CREATE_INT32);
969 napi_value cursor_copy = nullptr;
970 CHKRP(napi_create_int32(env, MOUSE_ICON::CURSOR_COPY, &cursor_copy), CREATE_INT32);
971 napi_value cursor_forbid = nullptr;
972 CHKRP(napi_create_int32(env, MOUSE_ICON::CURSOR_FORBID, &cursor_forbid), CREATE_INT32);
973 napi_value color_sucker = nullptr;
974 CHKRP(napi_create_int32(env, MOUSE_ICON::COLOR_SUCKER, &color_sucker), CREATE_INT32);
975 napi_value hand_grabbing = nullptr;
976 CHKRP(napi_create_int32(env, MOUSE_ICON::HAND_GRABBING, &hand_grabbing), CREATE_INT32);
977 napi_value hand_open = nullptr;
978 CHKRP(napi_create_int32(env, MOUSE_ICON::HAND_OPEN, &hand_open), CREATE_INT32);
979 napi_value hand_pointing = nullptr;
980 CHKRP(napi_create_int32(env, MOUSE_ICON::HAND_POINTING, &hand_pointing), CREATE_INT32);
981 napi_value help = nullptr;
982 CHKRP(napi_create_int32(env, MOUSE_ICON::HELP, &help), CREATE_INT32);
983 napi_value move = nullptr;
984 CHKRP(napi_create_int32(env, MOUSE_ICON::CURSOR_MOVE, &move), CREATE_INT32);
985 napi_value resize_left_right = nullptr;
986 CHKRP(napi_create_int32(env, MOUSE_ICON::RESIZE_LEFT_RIGHT, &resize_left_right), CREATE_INT32);
987 napi_value resize_up_down = nullptr;
988 CHKRP(napi_create_int32(env, MOUSE_ICON::RESIZE_UP_DOWN, &resize_up_down), CREATE_INT32);
989 napi_value screenshot_choose = nullptr;
990 CHKRP(napi_create_int32(env, MOUSE_ICON::SCREENSHOT_CHOOSE, &screenshot_choose), CREATE_INT32);
991 napi_value screenshot_cursor = nullptr;
992 CHKRP(napi_create_int32(env, MOUSE_ICON::SCREENSHOT_CURSOR, &screenshot_cursor), CREATE_INT32);
993 napi_value text_cursor = nullptr;
994 CHKRP(napi_create_int32(env, MOUSE_ICON::TEXT_CURSOR, &text_cursor), CREATE_INT32);
995 napi_value zoom_in = nullptr;
996 CHKRP(napi_create_int32(env, MOUSE_ICON::ZOOM_IN, &zoom_in), CREATE_INT32);
997 napi_value zoom_out = nullptr;
998 CHKRP(napi_create_int32(env, MOUSE_ICON::ZOOM_OUT, &zoom_out), CREATE_INT32);
999 napi_value middle_btn_east = nullptr;
1000 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_EAST, &middle_btn_east), CREATE_INT32);
1001 napi_value middle_btn_west = nullptr;
1002 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_WEST, &middle_btn_west), CREATE_INT32);
1003 napi_value middle_btn_south = nullptr;
1004 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_SOUTH, &middle_btn_south), CREATE_INT32);
1005 napi_value middle_btn_north = nullptr;
1006 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_NORTH, &middle_btn_north), CREATE_INT32);
1007 napi_value middle_btn_north_south = nullptr;
1008 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_NORTH_SOUTH, &middle_btn_north_south), CREATE_INT32);
1009 napi_value middle_btn_east_west = nullptr;
1010 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_EAST_WEST, &middle_btn_east_west), CREATE_INT32);
1011 napi_value middle_btn_north_east = nullptr;
1012 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_NORTH_EAST, &middle_btn_north_east), CREATE_INT32);
1013 napi_value middle_btn_north_west = nullptr;
1014 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_NORTH_WEST, &middle_btn_north_west), CREATE_INT32);
1015 napi_value middle_btn_south_east = nullptr;
1016 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_SOUTH_EAST, &middle_btn_south_east), CREATE_INT32);
1017 napi_value middle_btn_south_west = nullptr;
1018 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_SOUTH_WEST, &middle_btn_south_west), CREATE_INT32);
1019 napi_value middle_btn_north_south_west_east = nullptr;
1020 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_NORTH_SOUTH_WEST_EAST,
1021 &middle_btn_north_south_west_east), CREATE_INT32);
1022 napi_value horizontal_text_cursor = nullptr;
1023 CHKRP(napi_create_int32(env, MOUSE_ICON::HORIZONTAL_TEXT_CURSOR, &horizontal_text_cursor), CREATE_INT32);
1024 napi_value cursor_cross = nullptr;
1025 CHKRP(napi_create_int32(env, MOUSE_ICON::CURSOR_CROSS, &cursor_cross), CREATE_INT32);
1026 napi_value cursor_circle = nullptr;
1027 CHKRP(napi_create_int32(env, MOUSE_ICON::CURSOR_CIRCLE, &cursor_circle), CREATE_INT32);
1028 napi_value loading = nullptr;
1029 CHKRP(napi_create_int32(env, MOUSE_ICON::LOADING, &loading), CREATE_INT32);
1030 napi_value running = nullptr;
1031 CHKRP(napi_create_int32(env, MOUSE_ICON::RUNNING, &running), CREATE_INT32);
1032 napi_value developer_defined_icon = nullptr;
1033 CHKRP(napi_create_int32(env, MOUSE_ICON::DEVELOPER_DEFINED_ICON, &developer_defined_icon), CREATE_INT32);
1034
1035 napi_property_descriptor desc[] = {
1036 DECLARE_NAPI_STATIC_PROPERTY("DEFAULT", defaults),
1037 DECLARE_NAPI_STATIC_PROPERTY("EAST", east),
1038 DECLARE_NAPI_STATIC_PROPERTY("WEST", west),
1039 DECLARE_NAPI_STATIC_PROPERTY("SOUTH", south),
1040 DECLARE_NAPI_STATIC_PROPERTY("NORTH", north),
1041 DECLARE_NAPI_STATIC_PROPERTY("WEST_EAST", west_east),
1042 DECLARE_NAPI_STATIC_PROPERTY("NORTH_SOUTH", north_south),
1043 DECLARE_NAPI_STATIC_PROPERTY("NORTH_EAST", north_east),
1044 DECLARE_NAPI_STATIC_PROPERTY("NORTH_WEST", north_west),
1045 DECLARE_NAPI_STATIC_PROPERTY("SOUTH_EAST", south_east),
1046 DECLARE_NAPI_STATIC_PROPERTY("SOUTH_WEST", south_west),
1047 DECLARE_NAPI_STATIC_PROPERTY("NORTH_EAST_SOUTH_WEST", north_east_south_west),
1048 DECLARE_NAPI_STATIC_PROPERTY("NORTH_WEST_SOUTH_EAST", north_west_south_east),
1049 DECLARE_NAPI_STATIC_PROPERTY("CROSS", cross),
1050 DECLARE_NAPI_STATIC_PROPERTY("CURSOR_COPY", cursor_copy),
1051 DECLARE_NAPI_STATIC_PROPERTY("CURSOR_FORBID", cursor_forbid),
1052 DECLARE_NAPI_STATIC_PROPERTY("COLOR_SUCKER", color_sucker),
1053 DECLARE_NAPI_STATIC_PROPERTY("HAND_GRABBING", hand_grabbing),
1054 DECLARE_NAPI_STATIC_PROPERTY("HAND_OPEN", hand_open),
1055 DECLARE_NAPI_STATIC_PROPERTY("HAND_POINTING", hand_pointing),
1056 DECLARE_NAPI_STATIC_PROPERTY("HELP", help),
1057 DECLARE_NAPI_STATIC_PROPERTY("MOVE", move),
1058 DECLARE_NAPI_STATIC_PROPERTY("RESIZE_LEFT_RIGHT", resize_left_right),
1059 DECLARE_NAPI_STATIC_PROPERTY("RESIZE_UP_DOWN", resize_up_down),
1060 DECLARE_NAPI_STATIC_PROPERTY("SCREENSHOT_CHOOSE", screenshot_choose),
1061 DECLARE_NAPI_STATIC_PROPERTY("SCREENSHOT_CURSOR", screenshot_cursor),
1062 DECLARE_NAPI_STATIC_PROPERTY("TEXT_CURSOR", text_cursor),
1063 DECLARE_NAPI_STATIC_PROPERTY("ZOOM_IN", zoom_in),
1064 DECLARE_NAPI_STATIC_PROPERTY("ZOOM_OUT", zoom_out),
1065 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_EAST", middle_btn_east),
1066 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_WEST", middle_btn_west),
1067 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_SOUTH", middle_btn_south),
1068 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_NORTH", middle_btn_north),
1069 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_NORTH_SOUTH", middle_btn_north_south),
1070 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_EAST_WEST", middle_btn_east_west),
1071 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_NORTH_EAST", middle_btn_north_east),
1072 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_NORTH_WEST", middle_btn_north_west),
1073 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_SOUTH_EAST", middle_btn_south_east),
1074 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_SOUTH_WEST", middle_btn_south_west),
1075 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_NORTH_SOUTH_WEST_EAST", middle_btn_north_south_west_east),
1076 DECLARE_NAPI_STATIC_PROPERTY("HORIZONTAL_TEXT_CURSOR", horizontal_text_cursor),
1077 DECLARE_NAPI_STATIC_PROPERTY("CURSOR_CROSS", cursor_cross),
1078 DECLARE_NAPI_STATIC_PROPERTY("CURSOR_CIRCLE", cursor_circle),
1079 DECLARE_NAPI_STATIC_PROPERTY("LOADING", loading),
1080 DECLARE_NAPI_STATIC_PROPERTY("RUNNING", running),
1081 DECLARE_NAPI_STATIC_PROPERTY("DEVELOPER_DEFINED_ICON", developer_defined_icon),
1082 };
1083 napi_value result = nullptr;
1084 CHKRP(napi_define_class(env, "PointerStyle", NAPI_AUTO_LENGTH, EnumConstructor, nullptr,
1085 sizeof(desc) / sizeof(*desc), desc, &result), DEFINE_CLASS);
1086 CHKRP(napi_set_named_property(env, exports, "PointerStyle", result), SET_NAMED_PROPERTY);
1087 return exports;
1088 }
1089
CreateTouchpadRightClickType(napi_env env,napi_value exports)1090 napi_value JsPointerContext::CreateTouchpadRightClickType(napi_env env, napi_value exports)
1091 {
1092 CALL_DEBUG_ENTER;
1093 napi_value touchpad_right_button = nullptr;
1094 CHKRP(napi_create_int32(env, RightClickType::TOUCHPAD_RIGHT_BUTTON, &touchpad_right_button), CREATE_INT32);
1095 napi_value touchpad_left_button = nullptr;
1096 CHKRP(napi_create_int32(env, RightClickType::TOUCHPAD_LEFT_BUTTON, &touchpad_left_button), CREATE_INT32);
1097 napi_value touchpad_two_finger_tap = nullptr;
1098 CHKRP(napi_create_int32(env, RightClickType::TOUCHPAD_TWO_FINGER_TAP, &touchpad_two_finger_tap), CREATE_INT32);
1099
1100 napi_property_descriptor desc[] = {
1101 DECLARE_NAPI_STATIC_PROPERTY("TOUCHPAD_RIGHT_BUTTON", touchpad_right_button),
1102 DECLARE_NAPI_STATIC_PROPERTY("TOUCHPAD_LEFT_BUTTON", touchpad_left_button),
1103 DECLARE_NAPI_STATIC_PROPERTY("TOUCHPAD_TWO_FINGER_TAP", touchpad_two_finger_tap),
1104 };
1105 napi_value result = nullptr;
1106 CHKRP(napi_define_class(env, "RightClickType", NAPI_AUTO_LENGTH, EnumConstructor, nullptr,
1107 sizeof(desc) / sizeof(*desc), desc, &result), DEFINE_CLASS);
1108 CHKRP(napi_set_named_property(env, exports, "RightClickType", result), SET_NAMED_PROPERTY);
1109 return exports;
1110 }
1111
EnumConstructor(napi_env env,napi_callback_info info)1112 napi_value JsPointerContext::EnumConstructor(napi_env env, napi_callback_info info)
1113 {
1114 CALL_DEBUG_ENTER;
1115 size_t argc = 0;
1116 napi_value args[1] = { 0 };
1117 napi_value ret = nullptr;
1118 void *data = nullptr;
1119 CHKRP(napi_get_cb_info(env, info, &argc, args, &ret, &data), GET_CB_INFO);
1120 return ret;
1121 }
1122
EnterCaptureMode(napi_env env,napi_callback_info info)1123 napi_value JsPointerContext::EnterCaptureMode(napi_env env, napi_callback_info info)
1124 {
1125 CALL_DEBUG_ENTER;
1126 size_t argc = 2;
1127 napi_value argv[2] = { 0 };
1128 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1129 if (argc < 1 || argc > INPUT_PARAMETER) {
1130 THROWERR(env, "The number of parameters is not as expected");
1131 return nullptr;
1132 }
1133 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
1134 THROWERR(env, "First parameter type is invalid");
1135 return nullptr;
1136 }
1137
1138 int32_t windowId = 0;
1139 CHKRP(napi_get_value_int32(env, argv[0], &windowId), GET_VALUE_INT32);
1140 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1141 CHKPP(jsPointer);
1142 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1143 if (argc == 1) {
1144 return jsPointerMgr->EnterCaptureMode(env, windowId);
1145 }
1146 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1147 THROWERR(env, "Second parameter type is invalid");
1148 return nullptr;
1149 }
1150 return jsPointerMgr->EnterCaptureMode(env, windowId, argv[1]);
1151 }
1152
LeaveCaptureMode(napi_env env,napi_callback_info info)1153 napi_value JsPointerContext::LeaveCaptureMode(napi_env env, napi_callback_info info)
1154 {
1155 CALL_DEBUG_ENTER;
1156 size_t argc = 2;
1157 napi_value argv[2] = { 0 };
1158 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1159 if (argc < 1 || argc > INPUT_PARAMETER) {
1160 THROWERR(env, "The number of parameters is not as expected");
1161 return nullptr;
1162 }
1163 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
1164 THROWERR(env, "First parameter type is invalid");
1165 return nullptr;
1166 }
1167
1168 int32_t windowId = 0;
1169 CHKRP(napi_get_value_int32(env, argv[0], &windowId), GET_VALUE_INT32);
1170
1171 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1172 CHKPP(jsPointer);
1173 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1174 if (argc == 1) {
1175 return jsPointerMgr->LeaveCaptureMode(env, windowId);
1176 }
1177 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1178 THROWERR(env, "Second parameter type is invalid");
1179 return nullptr;
1180 }
1181 return jsPointerMgr->LeaveCaptureMode(env, windowId, argv[1]);
1182 }
1183
CreateMousePrimaryButton(napi_env env,napi_value exports)1184 napi_value JsPointerContext::CreateMousePrimaryButton(napi_env env, napi_value exports)
1185 {
1186 CALL_DEBUG_ENTER;
1187 napi_value leftButton = nullptr;
1188 CHKRP(napi_create_int32(env, PrimaryButton::LEFT_BUTTON, &leftButton), CREATE_INT32);
1189 napi_value rightButton = nullptr;
1190 CHKRP(napi_create_int32(env, PrimaryButton::RIGHT_BUTTON, &rightButton), CREATE_INT32);
1191
1192 napi_property_descriptor desc[] = {
1193 DECLARE_NAPI_STATIC_PROPERTY("LEFT", leftButton),
1194 DECLARE_NAPI_STATIC_PROPERTY("RIGHT", rightButton),
1195 };
1196 napi_value result = nullptr;
1197 CHKRP(napi_define_class(env, "PrimaryButton", NAPI_AUTO_LENGTH, EnumConstructor, nullptr,
1198 sizeof(desc) / sizeof(*desc), desc, &result), DEFINE_CLASS);
1199 CHKRP(napi_set_named_property(env, exports, "PrimaryButton", result), SET_NAMED_PROPERTY);
1200 return exports;
1201 }
1202
SetMousePrimaryButton(napi_env env,napi_callback_info info)1203 napi_value JsPointerContext::SetMousePrimaryButton(napi_env env, napi_callback_info info)
1204 {
1205 CALL_DEBUG_ENTER;
1206 size_t argc = 2;
1207 napi_value argv[2] = { 0 };
1208 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1209 if (argc < 1) {
1210 MMI_HILOGE("At least one parameter is required");
1211 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "primaryButton", "number");
1212 return nullptr;
1213 }
1214 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
1215 MMI_HILOGE("primaryButton parameter type is invalid");
1216 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "primaryButton", "number");
1217 return nullptr;
1218 }
1219 int32_t primaryButton = 0;
1220 CHKRP(napi_get_value_int32(env, argv[0], &primaryButton), GET_VALUE_INT32);
1221 if (primaryButton < LEFT_BUTTON || primaryButton > RIGHT_BUTTON) {
1222 MMI_HILOGE("Undefined mouse primary button");
1223 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Mouse primary button does not exist");
1224 return nullptr;
1225 }
1226 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1227 CHKPP(jsPointer);
1228 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1229 if (argc == 1) {
1230 return jsPointerMgr->SetMousePrimaryButton(env, primaryButton);
1231 }
1232 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1233 MMI_HILOGE("Callback parameter type is invalid");
1234 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1235 return nullptr;
1236 }
1237 return jsPointerMgr->SetMousePrimaryButton(env, primaryButton, argv[1]);
1238 }
1239
GetMousePrimaryButton(napi_env env,napi_callback_info info)1240 napi_value JsPointerContext::GetMousePrimaryButton(napi_env env, napi_callback_info info)
1241 {
1242 CALL_DEBUG_ENTER;
1243 size_t argc = 1;
1244 napi_value argv[1] = { 0 };
1245 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1246 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1247 CHKPP(jsPointer);
1248 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1249 if (argc < 1) {
1250 return jsPointerMgr->GetMousePrimaryButton(env);
1251 }
1252 if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
1253 MMI_HILOGE("Callback parameter type is invalid");
1254 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1255 return nullptr;
1256 }
1257 return jsPointerMgr->GetMousePrimaryButton(env, argv[0]);
1258 }
1259
SetHoverScrollState(napi_env env,napi_callback_info info)1260 napi_value JsPointerContext::SetHoverScrollState(napi_env env, napi_callback_info info)
1261 {
1262 CALL_DEBUG_ENTER;
1263 size_t argc = 2;
1264 napi_value argv[2] = { 0 };
1265 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1266 if (argc < 1) {
1267 MMI_HILOGE("At least one parameter is required");
1268 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "state", "boolean");
1269 return nullptr;
1270 }
1271 if (!JsCommon::TypeOf(env, argv[0], napi_boolean)) {
1272 MMI_HILOGE("State parameter type is invalid");
1273 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "state", "boolean");
1274 return nullptr;
1275 }
1276 bool state = true;
1277 CHKRP(napi_get_value_bool(env, argv[0], &state), GET_VALUE_BOOL);
1278
1279 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1280 CHKPP(jsPointer);
1281 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1282 if (argc == 1) {
1283 return jsPointerMgr->SetHoverScrollState(env, state);
1284 }
1285 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1286 MMI_HILOGE("Callback parameter type is invalid");
1287 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1288 return nullptr;
1289 }
1290 return jsPointerMgr->SetHoverScrollState(env, state, argv[1]);
1291 }
1292
GetHoverScrollState(napi_env env,napi_callback_info info)1293 napi_value JsPointerContext::GetHoverScrollState(napi_env env, napi_callback_info info)
1294 {
1295 CALL_DEBUG_ENTER;
1296 size_t argc = 1;
1297 napi_value argv[1] = { 0 };
1298 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1299
1300 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1301 CHKPP(jsPointer);
1302 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1303 if (argc < 1) {
1304 return jsPointerMgr->GetHoverScrollState(env);
1305 }
1306 if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
1307 MMI_HILOGE("Callback parameter type is invalid");
1308 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1309 return nullptr;
1310 }
1311 return jsPointerMgr->GetHoverScrollState(env, argv[0]);
1312 }
1313
SetTouchpadBoolData(napi_env env,napi_callback_info info,SetTouchpadBoolDataFunc func)1314 napi_value JsPointerContext::SetTouchpadBoolData(napi_env env, napi_callback_info info, SetTouchpadBoolDataFunc func)
1315 {
1316 CALL_DEBUG_ENTER;
1317 if (!func) {
1318 MMI_HILOGE("The func is nullptr");
1319 return nullptr;
1320 }
1321 size_t argc = 2;
1322 napi_value argv[2] = { 0 };
1323 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1324 if (argc == 0) {
1325 MMI_HILOGE("At least one parameter is required");
1326 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "switchFlag", "boolean");
1327 return nullptr;
1328 }
1329 if (!JsCommon::TypeOf(env, argv[0], napi_boolean)) {
1330 MMI_HILOGE("Bool data parameter type is invalid");
1331 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "switchFlag", "boolean");
1332 return nullptr;
1333 }
1334 bool switchFlag = true;
1335 CHKRP(napi_get_value_bool(env, argv[0], &switchFlag), GET_VALUE_BOOL);
1336
1337 if (argc == 1) {
1338 return func(env, switchFlag, nullptr);
1339 }
1340 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1341 MMI_HILOGE("Callback parameter type is invalid");
1342 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1343 return nullptr;
1344 }
1345 return func(env, switchFlag, argv[1]);
1346 }
1347
SetTouchpadInt32Data(napi_env env,napi_callback_info info,SetTouchpadInt32DataFunc func,int32_t dataMax,int32_t dataMin)1348 napi_value JsPointerContext::SetTouchpadInt32Data(napi_env env, napi_callback_info info, SetTouchpadInt32DataFunc func,
1349 int32_t dataMax, int32_t dataMin)
1350 {
1351 CALL_DEBUG_ENTER;
1352 size_t argc = 2;
1353 napi_value argv[2] = { 0 };
1354 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1355 if (argc < 0) {
1356 MMI_HILOGE("At least 1 parameter is required");
1357 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "data", "number");
1358 return nullptr;
1359 }
1360 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
1361 MMI_HILOGE("Int32 data parameter type is invalid");
1362 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "data", "number");
1363 return nullptr;
1364 }
1365 int32_t data = 0;
1366 CHKRP(napi_get_value_int32(env, argv[0], &data), GET_VALUE_INT32);
1367 if (data < dataMin) {
1368 data = dataMin;
1369 } else if (data > dataMax) {
1370 data = dataMax;
1371 }
1372
1373 if (argc == 1) {
1374 return func(env, data, nullptr);
1375 }
1376 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1377 MMI_HILOGE("Callback parameter type is invalid");
1378 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1379 return nullptr;
1380 }
1381
1382 return func(env, data, argv[1]);
1383 }
1384
GetTouchpadData(napi_env env,napi_callback_info info,GetTouchpadFunc func)1385 napi_value JsPointerContext::GetTouchpadData(napi_env env, napi_callback_info info, GetTouchpadFunc func)
1386 {
1387 CALL_DEBUG_ENTER;
1388 size_t argc = 1;
1389 napi_value argv[1] = { 0 };
1390 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1391
1392 if (argc < 1) {
1393 return func(env, nullptr);
1394 }
1395 if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
1396 MMI_HILOGE("Callback parameter type is invalid");
1397 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1398 return nullptr;
1399 }
1400
1401 return func(env, argv[0]);
1402 }
1403
SetTouchpadScrollSwitch(napi_env env,napi_callback_info info)1404 napi_value JsPointerContext::SetTouchpadScrollSwitch(napi_env env, napi_callback_info info)
1405 {
1406 CALL_DEBUG_ENTER;
1407 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1408 CHKPP(jsPointer);
1409 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1410 CHKPP(jsPointerMgr);
1411 auto func = [jsPointerMgr] (napi_env env, bool switchFlag, napi_value handle) -> napi_value {
1412 return jsPointerMgr->SetTouchpadScrollSwitch(env, switchFlag, handle);
1413 };
1414 return SetTouchpadBoolData(env, info, func);
1415 }
1416
GetTouchpadScrollSwitch(napi_env env,napi_callback_info info)1417 napi_value JsPointerContext::GetTouchpadScrollSwitch(napi_env env, napi_callback_info info)
1418 {
1419 CALL_DEBUG_ENTER;
1420 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1421 CHKPP(jsPointer);
1422 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1423 CHKPP(jsPointerMgr);
1424 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1425 return jsPointerMgr->GetTouchpadScrollSwitch(env, handle);
1426 };
1427 return GetTouchpadData(env, info, func);
1428 }
1429
SetTouchpadScrollDirection(napi_env env,napi_callback_info info)1430 napi_value JsPointerContext::SetTouchpadScrollDirection(napi_env env, napi_callback_info info)
1431 {
1432 CALL_DEBUG_ENTER;
1433 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1434 CHKPP(jsPointer);
1435 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1436 CHKPP(jsPointerMgr);
1437 auto func = [jsPointerMgr] (napi_env env, bool state, napi_value handle) -> napi_value {
1438 return jsPointerMgr->SetTouchpadScrollDirection(env, state, handle);
1439 };
1440 return SetTouchpadBoolData(env, info, func);
1441 }
1442
GetTouchpadScrollDirection(napi_env env,napi_callback_info info)1443 napi_value JsPointerContext::GetTouchpadScrollDirection(napi_env env, napi_callback_info info)
1444 {
1445 CALL_DEBUG_ENTER;
1446 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1447 CHKPP(jsPointer);
1448 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1449 CHKPP(jsPointerMgr);
1450 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1451 return jsPointerMgr->GetTouchpadScrollDirection(env, handle);
1452 };
1453 return GetTouchpadData(env, info, func);
1454 }
1455
SetTouchpadTapSwitch(napi_env env,napi_callback_info info)1456 napi_value JsPointerContext::SetTouchpadTapSwitch(napi_env env, napi_callback_info info)
1457 {
1458 CALL_DEBUG_ENTER;
1459 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1460 CHKPP(jsPointer);
1461 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1462 CHKPP(jsPointerMgr);
1463 auto func = [jsPointerMgr] (napi_env env, bool switchFlag, napi_value handle) -> napi_value {
1464 return jsPointerMgr->SetTouchpadTapSwitch(env, switchFlag, handle);
1465 };
1466 return SetTouchpadBoolData(env, info, func);
1467 }
1468
GetTouchpadTapSwitch(napi_env env,napi_callback_info info)1469 napi_value JsPointerContext::GetTouchpadTapSwitch(napi_env env, napi_callback_info info)
1470 {
1471 CALL_DEBUG_ENTER;
1472 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1473 CHKPP(jsPointer);
1474 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1475 CHKPP(jsPointerMgr);
1476 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1477 return jsPointerMgr->GetTouchpadTapSwitch(env, handle);
1478 };
1479 return GetTouchpadData(env, info, func);
1480 }
1481
SetTouchpadPointerSpeed(napi_env env,napi_callback_info info)1482 napi_value JsPointerContext::SetTouchpadPointerSpeed(napi_env env, napi_callback_info info)
1483 {
1484 CALL_DEBUG_ENTER;
1485 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1486 CHKPP(jsPointer);
1487 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1488 CHKPP(jsPointerMgr);
1489 auto func = [jsPointerMgr] (napi_env env, int32_t data, napi_value handle) -> napi_value {
1490 return jsPointerMgr->SetTouchpadPointerSpeed(env, data, handle);
1491 };
1492 return SetTouchpadInt32Data(env, info, func, MAX_TOUCHPAD_SPEED, MIN_SPEED);
1493 }
1494
GetTouchpadPointerSpeed(napi_env env,napi_callback_info info)1495 napi_value JsPointerContext::GetTouchpadPointerSpeed(napi_env env, napi_callback_info info)
1496 {
1497 CALL_DEBUG_ENTER;
1498 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1499 CHKPP(jsPointer);
1500 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1501 CHKPP(jsPointerMgr);
1502 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1503 return jsPointerMgr->GetTouchpadPointerSpeed(env, handle);
1504 };
1505 return GetTouchpadData(env, info, func);
1506 }
1507
SetTouchpadPinchSwitch(napi_env env,napi_callback_info info)1508 napi_value JsPointerContext::SetTouchpadPinchSwitch(napi_env env, napi_callback_info info)
1509 {
1510 CALL_DEBUG_ENTER;
1511 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1512 CHKPP(jsPointer);
1513 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1514 CHKPP(jsPointerMgr);
1515 auto func = [jsPointerMgr] (napi_env env, bool switchFlag, napi_value handle) -> napi_value {
1516 return jsPointerMgr->SetTouchpadPinchSwitch(env, switchFlag, handle);
1517 };
1518 return SetTouchpadBoolData(env, info, func);
1519 }
1520
GetTouchpadPinchSwitch(napi_env env,napi_callback_info info)1521 napi_value JsPointerContext::GetTouchpadPinchSwitch(napi_env env, napi_callback_info info)
1522 {
1523 CALL_DEBUG_ENTER;
1524 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1525 CHKPP(jsPointer);
1526 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1527 CHKPP(jsPointerMgr);
1528 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1529 return jsPointerMgr->GetTouchpadPinchSwitch(env, handle);
1530 };
1531 return GetTouchpadData(env, info, func);
1532 }
1533
SetTouchpadSwipeSwitch(napi_env env,napi_callback_info info)1534 napi_value JsPointerContext::SetTouchpadSwipeSwitch(napi_env env, napi_callback_info info)
1535 {
1536 CALL_DEBUG_ENTER;
1537 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1538 CHKPP(jsPointer);
1539 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1540 CHKPP(jsPointerMgr);
1541 auto func = [jsPointerMgr] (napi_env env, bool switchFlag, napi_value handle) -> napi_value {
1542 return jsPointerMgr->SetTouchpadSwipeSwitch(env, switchFlag, handle);
1543 };
1544 return SetTouchpadBoolData(env, info, func);
1545 }
1546
GetTouchpadSwipeSwitch(napi_env env,napi_callback_info info)1547 napi_value JsPointerContext::GetTouchpadSwipeSwitch(napi_env env, napi_callback_info info)
1548 {
1549 CALL_DEBUG_ENTER;
1550 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1551 CHKPP(jsPointer);
1552 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1553 CHKPP(jsPointerMgr);
1554 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1555 return jsPointerMgr->GetTouchpadSwipeSwitch(env, handle);
1556 };
1557 return GetTouchpadData(env, info, func);
1558 }
1559
SetTouchpadRightClickType(napi_env env,napi_callback_info info)1560 napi_value JsPointerContext::SetTouchpadRightClickType(napi_env env, napi_callback_info info)
1561 {
1562 CALL_DEBUG_ENTER;
1563 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1564 CHKPP(jsPointer);
1565 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1566 CHKPP(jsPointerMgr);
1567 auto func = [jsPointerMgr] (napi_env env, int32_t data, napi_value handle) -> napi_value {
1568 return jsPointerMgr->SetTouchpadRightClickType(env, data, handle);
1569 };
1570 return SetTouchpadInt32Data(env, info, func, MAX_TOUCHPAD_SPEED, MIN_SPEED);
1571 }
1572
GetTouchpadRightClickType(napi_env env,napi_callback_info info)1573 napi_value JsPointerContext::GetTouchpadRightClickType(napi_env env, napi_callback_info info)
1574 {
1575 CALL_DEBUG_ENTER;
1576 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1577 CHKPP(jsPointer);
1578 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1579 CHKPP(jsPointerMgr);
1580 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1581 return jsPointerMgr->GetTouchpadRightClickType(env, handle);
1582 };
1583 return GetTouchpadData(env, info, func);
1584 }
1585
SetTouchpadRotateSwitch(napi_env env,napi_callback_info info)1586 napi_value JsPointerContext::SetTouchpadRotateSwitch(napi_env env, napi_callback_info info)
1587 {
1588 CALL_DEBUG_ENTER;
1589 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1590 CHKPP(jsPointer);
1591 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1592 CHKPP(jsPointerMgr);
1593 auto func = [jsPointerMgr] (napi_env env, bool rotateSwitch, napi_value handle) -> napi_value {
1594 return jsPointerMgr->SetTouchpadRotateSwitch(env, rotateSwitch, handle);
1595 };
1596 return SetTouchpadBoolData(env, info, func);
1597 }
1598
GetTouchpadRotateSwitch(napi_env env,napi_callback_info info)1599 napi_value JsPointerContext::GetTouchpadRotateSwitch(napi_env env, napi_callback_info info)
1600 {
1601 CALL_DEBUG_ENTER;
1602 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1603 CHKPP(jsPointer);
1604 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1605 CHKPP(jsPointerMgr);
1606 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1607 return jsPointerMgr->GetTouchpadRotateSwitch(env, handle);
1608 };
1609 return GetTouchpadData(env, info, func);
1610 }
1611
SetTouchpadDoubleTapAndDragState(napi_env env,napi_callback_info info)1612 napi_value JsPointerContext::SetTouchpadDoubleTapAndDragState(napi_env env, napi_callback_info info)
1613 {
1614 CALL_DEBUG_ENTER;
1615 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1616 CHKPP(jsPointer);
1617 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1618 CHKPP(jsPointerMgr);
1619 auto func = [jsPointerMgr] (napi_env env, bool switchFlag, napi_value handle) -> napi_value {
1620 return jsPointerMgr->SetTouchpadDoubleTapAndDragState(env, switchFlag, handle);
1621 };
1622 return SetTouchpadBoolData(env, info, func);
1623 }
1624
GetTouchpadDoubleTapAndDragState(napi_env env,napi_callback_info info)1625 napi_value JsPointerContext::GetTouchpadDoubleTapAndDragState(napi_env env, napi_callback_info info)
1626 {
1627 CALL_DEBUG_ENTER;
1628 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1629 CHKPP(jsPointer);
1630 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1631 CHKPP(jsPointerMgr);
1632 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1633 return jsPointerMgr->GetTouchpadDoubleTapAndDragState(env, handle);
1634 };
1635 return GetTouchpadData(env, info, func);
1636 }
1637
SetTouchpadThreeFingersTapSwitch(napi_env env,napi_callback_info info)1638 napi_value JsPointerContext::SetTouchpadThreeFingersTapSwitch(napi_env env, napi_callback_info info)
1639 {
1640 CALL_DEBUG_ENTER;
1641 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1642 CHKPP(jsPointer);
1643 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1644 CHKPP(jsPointerMgr);
1645 auto func = [jsPointerMgr] (napi_env env, bool switchFlag, napi_value handle) -> napi_value {
1646 return jsPointerMgr->SetTouchpadThreeFingersTapSwitch(env, switchFlag, handle);
1647 };
1648 return SetTouchpadBoolData(env, info, func);
1649 }
1650
GetTouchpadThreeFingersTapSwitch(napi_env env,napi_callback_info info)1651 napi_value JsPointerContext::GetTouchpadThreeFingersTapSwitch(napi_env env, napi_callback_info info)
1652 {
1653 CALL_DEBUG_ENTER;
1654 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1655 CHKPP(jsPointer);
1656 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1657 CHKPP(jsPointerMgr);
1658 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1659 return jsPointerMgr->GetTouchpadThreeFingersTapSwitch(env, handle);
1660 };
1661 return GetTouchpadData(env, info, func);
1662 }
1663
EnableHardwareCursorStats(napi_env env,napi_callback_info info)1664 napi_value JsPointerContext::EnableHardwareCursorStats(napi_env env, napi_callback_info info)
1665 {
1666 CALL_DEBUG_ENTER;
1667 size_t argc = 1;
1668 napi_value argv[1];
1669 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1670 if (argc == 0) {
1671 MMI_HILOGE("At least one parameter is required");
1672 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "enable", "boolean");
1673 return nullptr;
1674 }
1675 if (!JsCommon::TypeOf(env, argv[0], napi_boolean)) {
1676 MMI_HILOGE("Enable parameter type is invalid");
1677 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "enable", "boolean");
1678 return nullptr;
1679 }
1680 bool enable = true;
1681 CHKRP(napi_get_value_bool(env, argv[0], &enable), GET_VALUE_BOOL);
1682
1683 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1684 CHKPP(jsPointer);
1685 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1686 return jsPointerMgr->EnableHardwareCursorStats(env, enable);
1687 }
1688
GetHardwareCursorStats(napi_env env,napi_callback_info info)1689 napi_value JsPointerContext::GetHardwareCursorStats(napi_env env, napi_callback_info info)
1690 {
1691 CALL_DEBUG_ENTER;
1692 size_t argc = 1;
1693 napi_value argv[1];
1694 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1695 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1696 CHKPP(jsPointer);
1697 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1698 CHKPP(jsPointerMgr);
1699 if (argc == 0) {
1700 return jsPointerMgr->GetHardwareCursorStats(env);
1701 }
1702 return nullptr;
1703 }
1704
SetTouchpadScrollRows(napi_env env,napi_callback_info info)1705 napi_value JsPointerContext::SetTouchpadScrollRows(napi_env env, napi_callback_info info)
1706 {
1707 CALL_DEBUG_ENTER;
1708 size_t argc = 2;
1709 napi_value argv[2];
1710 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1711 if (argc == 0) {
1712 MMI_HILOGE("At least 1 parameter is required");
1713 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "touchpadScrollRows", "number");
1714 return nullptr;
1715 }
1716 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
1717 MMI_HILOGE("Rows parameter type is invalid");
1718 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "touchpadScrollRows", "number");
1719 return nullptr;
1720 }
1721 int32_t rows = DEFAULT_ROWS;
1722 CHKRP(napi_get_value_int32(env, argv[0], &rows), GET_VALUE_INT32);
1723 int32_t newRows = std::clamp(rows, MIN_ROWS, MAX_ROWS);
1724 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1725 CHKPP(jsPointer);
1726 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1727 CHKPP(jsPointerMgr);
1728 if (argc == 1) {
1729 return jsPointerMgr->SetTouchpadScrollRows(env, newRows);
1730 }
1731 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1732 MMI_HILOGE("Callback parameter type is invalid");
1733 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1734 return nullptr;
1735 }
1736 return jsPointerMgr->SetTouchpadScrollRows(env, newRows, argv[1]);
1737 }
1738
GetTouchpadScrollRows(napi_env env,napi_callback_info info)1739 napi_value JsPointerContext::GetTouchpadScrollRows(napi_env env, napi_callback_info info)
1740 {
1741 CALL_DEBUG_ENTER;
1742 size_t argc = 1;
1743 napi_value argv[1];
1744 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1745 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1746 CHKPP(jsPointer);
1747 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1748 CHKPP(jsPointerMgr);
1749 if (argc == 0) {
1750 return jsPointerMgr->GetTouchpadScrollRows(env);
1751 }
1752 if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
1753 MMI_HILOGE("Callback parameter type is invalid");
1754 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1755 return nullptr;
1756 }
1757 return jsPointerMgr->GetTouchpadScrollRows(env, argv[0]);
1758 }
1759
Export(napi_env env,napi_value exports)1760 napi_value JsPointerContext::Export(napi_env env, napi_value exports)
1761 {
1762 CALL_DEBUG_ENTER;
1763 auto instance = CreateInstance(env);
1764 if (instance == nullptr) {
1765 THROWERR(env, "Failed to create instance");
1766 return nullptr;
1767 }
1768 napi_property_descriptor desc[] = {
1769 DECLARE_NAPI_STATIC_FUNCTION("setPointerVisible", SetPointerVisible),
1770 DECLARE_NAPI_STATIC_FUNCTION("setPointerVisibleSync", SetPointerVisibleSync),
1771 DECLARE_NAPI_STATIC_FUNCTION("isPointerVisible", IsPointerVisible),
1772 DECLARE_NAPI_STATIC_FUNCTION("isPointerVisibleSync", IsPointerVisibleSync),
1773 DECLARE_NAPI_STATIC_FUNCTION("setPointerColor", SetPointerColor),
1774 DECLARE_NAPI_STATIC_FUNCTION("getPointerColor", GetPointerColor),
1775 DECLARE_NAPI_STATIC_FUNCTION("setPointerColorSync", SetPointerColorSync),
1776 DECLARE_NAPI_STATIC_FUNCTION("getPointerColorSync", GetPointerColorSync),
1777 DECLARE_NAPI_STATIC_FUNCTION("setPointerSpeed", SetPointerSpeed),
1778 DECLARE_NAPI_STATIC_FUNCTION("setPointerSpeedSync", SetPointerSpeedSync),
1779 DECLARE_NAPI_STATIC_FUNCTION("getPointerSpeed", GetPointerSpeed),
1780 DECLARE_NAPI_STATIC_FUNCTION("getPointerSpeedSync", GetPointerSpeedSync),
1781 DECLARE_NAPI_STATIC_FUNCTION("setPointerStyle", SetPointerStyle),
1782 DECLARE_NAPI_STATIC_FUNCTION("setPointerStyleSync", SetPointerStyleSync),
1783 DECLARE_NAPI_STATIC_FUNCTION("getPointerStyle", GetPointerStyle),
1784 DECLARE_NAPI_STATIC_FUNCTION("getPointerStyleSync", GetPointerStyleSync),
1785 DECLARE_NAPI_STATIC_FUNCTION("enterCaptureMode", EnterCaptureMode),
1786 DECLARE_NAPI_STATIC_FUNCTION("leaveCaptureMode", LeaveCaptureMode),
1787 DECLARE_NAPI_STATIC_FUNCTION("setMouseScrollRows", SetMouseScrollRows),
1788 DECLARE_NAPI_STATIC_FUNCTION("getMouseScrollRows", GetMouseScrollRows),
1789 DECLARE_NAPI_STATIC_FUNCTION("setPointerSize", SetPointerSize),
1790 DECLARE_NAPI_STATIC_FUNCTION("getPointerSize", GetPointerSize),
1791 DECLARE_NAPI_STATIC_FUNCTION("setPointerSizeSync", SetPointerSizeSync),
1792 DECLARE_NAPI_STATIC_FUNCTION("getPointerSizeSync", GetPointerSizeSync),
1793 DECLARE_NAPI_STATIC_FUNCTION("setMousePrimaryButton", SetMousePrimaryButton),
1794 DECLARE_NAPI_STATIC_FUNCTION("getMousePrimaryButton", GetMousePrimaryButton),
1795 DECLARE_NAPI_STATIC_FUNCTION("setHoverScrollState", SetHoverScrollState),
1796 DECLARE_NAPI_STATIC_FUNCTION("getHoverScrollState", GetHoverScrollState),
1797 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadScrollSwitch", SetTouchpadScrollSwitch),
1798 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadScrollSwitch", GetTouchpadScrollSwitch),
1799 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadScrollDirection", SetTouchpadScrollDirection),
1800 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadScrollDirection", GetTouchpadScrollDirection),
1801 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadTapSwitch", SetTouchpadTapSwitch),
1802 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadTapSwitch", GetTouchpadTapSwitch),
1803 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadPointerSpeed", SetTouchpadPointerSpeed),
1804 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadPointerSpeed", GetTouchpadPointerSpeed),
1805 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadPinchSwitch", SetTouchpadPinchSwitch),
1806 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadPinchSwitch", GetTouchpadPinchSwitch),
1807 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadSwipeSwitch", SetTouchpadSwipeSwitch),
1808 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadSwipeSwitch", GetTouchpadSwipeSwitch),
1809 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadRightClickType", SetTouchpadRightClickType),
1810 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadRightClickType", GetTouchpadRightClickType),
1811 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadRotateSwitch", SetTouchpadRotateSwitch),
1812 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadRotateSwitch", GetTouchpadRotateSwitch),
1813 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadDoubleTapAndDragState", SetTouchpadDoubleTapAndDragState),
1814 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadDoubleTapAndDragState", GetTouchpadDoubleTapAndDragState),
1815 DECLARE_NAPI_STATIC_FUNCTION("setPointerLocation", SetPointerLocation),
1816 DECLARE_NAPI_STATIC_FUNCTION("setCustomCursor", SetCustomCursor),
1817 DECLARE_NAPI_STATIC_FUNCTION("setCustomCursorSync", SetCustomCursorSync),
1818 DECLARE_NAPI_STATIC_FUNCTION("setMoveEventFilters", SetMoveEventFilters),
1819 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadThreeFingersTapSwitch", SetTouchpadThreeFingersTapSwitch),
1820 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadThreeFingersTapSwitch", GetTouchpadThreeFingersTapSwitch),
1821 DECLARE_NAPI_STATIC_FUNCTION("enableHardwareCursorStats", EnableHardwareCursorStats),
1822 DECLARE_NAPI_STATIC_FUNCTION("getHardwareCursorStats", GetHardwareCursorStats),
1823 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadScrollRows", SetTouchpadScrollRows),
1824 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadScrollRows", GetTouchpadScrollRows),
1825 };
1826 CHKRP(napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc), DEFINE_PROPERTIES);
1827 if (CreatePointerStyle(env, exports) == nullptr) {
1828 THROWERR(env, "Failed to create pointer style");
1829 return nullptr;
1830 }
1831 if (CreateMousePrimaryButton(env, exports) == nullptr) {
1832 THROWERR(env, "Failed to create mouse primary button");
1833 return nullptr;
1834 }
1835 if (CreateTouchpadRightClickType(env, exports) == nullptr) {
1836 THROWERR(env, "Failed to create touchpad right click type");
1837 return nullptr;
1838 }
1839 return exports;
1840 }
1841
GetCursorOptions(napi_env env,napi_value obj,CursorOptions & options)1842 bool JsPointerContext::GetCursorOptions(napi_env env, napi_value obj, CursorOptions& options)
1843 {
1844 if (!JsCommon::TypeOf(env, obj, napi_object)) {
1845 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "CursorOptions", "object");
1846 return false;
1847 }
1848 napi_value followSystemValue;
1849 CHKRF(napi_get_named_property(env, obj, "followSystem", &followSystemValue), GET_NAMED_PROPERTY);
1850 if (!JsCommon::TypeOf(env, followSystemValue, napi_boolean)) {
1851 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "followSystem", "boolean");
1852 return false;
1853 }
1854 CHKRF(napi_get_value_bool(env, followSystemValue, &options.followSystem), GET_VALUE_BOOL);
1855 return true;
1856 }
1857
GetCustomCursorInfo(napi_env env,napi_value obj,CustomCursor & cursor)1858 bool JsPointerContext::GetCustomCursorInfo(napi_env env, napi_value obj, CustomCursor& cursor)
1859 {
1860 if (!JsCommon::TypeOf(env, obj, napi_object)) {
1861 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "CustomCursor", "object");
1862 return false;
1863 }
1864 napi_value pixelMapValue;
1865 CHKRF(napi_get_named_property(env, obj, "pixelMap", &pixelMapValue), GET_NAMED_PROPERTY);
1866 if (!JsCommon::TypeOf(env, pixelMapValue, napi_object)) {
1867 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "pixelMap", "object");
1868 return false;
1869 }
1870 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMapNapi::GetPixelMap(env, pixelMapValue);
1871 if (pixelMap == nullptr) {
1872 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "pixelMap is invalid");
1873 return false;
1874 }
1875 if (pixelMap->GetWidth() > MAX_PIXELMAP_SIZE || pixelMap->GetHeight() > MAX_PIXELMAP_SIZE) {
1876 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "The width or height of the pixelMap exceed 256");
1877 return false;
1878 }
1879 Parcel* pixelMapData = new Parcel();
1880 CHKPF(pixelMapData);
1881 pixelMap->Marshalling(*pixelMapData);
1882 cursor.pixelMap = pixelMapData;
1883 if (!GetFocusInfo(env, obj, "focusX", cursor.focusX, pixelMap->GetWidth())) {
1884 return false;
1885 }
1886 if (!GetFocusInfo(env, obj, "focusY", cursor.focusY, pixelMap->GetHeight())) {
1887 return false;
1888 }
1889 return true;
1890 }
1891
GetFocusInfo(napi_env env,napi_value obj,const std::string & propertyName,int32_t & focusValue,int32_t maxSize)1892 bool JsPointerContext::GetFocusInfo(napi_env env, napi_value obj, const std::string& propertyName,
1893 int32_t& focusValue, int32_t maxSize)
1894 {
1895 napi_value focusValueNapi;
1896 bool isExist = false;
1897 CHKRF(napi_has_named_property(env, obj, propertyName.c_str(), &isExist), HAS_NAMED_PROPERTY);
1898 if (!isExist) {
1899 focusValue = 0;
1900 } else if (napi_get_named_property(env, obj, propertyName.c_str(), &focusValueNapi) == napi_ok) {
1901 if (!JsCommon::TypeOf(env, focusValueNapi, napi_number)) {
1902 THROWERR_API9(env, COMMON_PARAMETER_ERROR, propertyName.c_str(), "number");
1903 return false;
1904 }
1905 CHKRF(napi_get_value_int32(env, focusValueNapi, &focusValue), GET_VALUE_INT32);
1906 if (focusValue < 0 || focusValue > maxSize) {
1907 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, (propertyName + " is invalid").c_str());
1908 return false;
1909 }
1910 }
1911 return true;
1912 }
1913
CheckIsSetCustomCursorEx(napi_env env,size_t argc,napi_value * argv)1914 bool JsPointerContext::CheckIsSetCustomCursorEx(napi_env env, size_t argc, napi_value* argv)
1915 {
1916 bool followSystemValue = false;
1917 if (argc > INPUT_PARAMETER && JsCommon::TypeOf(env, argv[INPUT_PARAMETER], napi_object) &&
1918 napi_has_named_property(env, argv[INPUT_PARAMETER], "followSystem", &followSystemValue) == napi_ok &&
1919 followSystemValue) {
1920 return true;
1921 }
1922 return false;
1923 }
1924
SetCustomCursorEx(napi_env env,std::shared_ptr<JsPointerManager> jsPointerMgr,int32_t windowId,size_t argc,napi_value * argv)1925 napi_value JsPointerContext::SetCustomCursorEx(napi_env env, std::shared_ptr<JsPointerManager> jsPointerMgr,
1926 int32_t windowId, size_t argc, napi_value* argv)
1927 {
1928 CustomCursor cursor;
1929 CursorOptions options;
1930 if (!GetCustomCursorInfo(env, argv[1], cursor)) {
1931 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "cursor", "CustomCursor");
1932 return nullptr;
1933 }
1934 if (!GetCursorOptions(env, argv[INPUT_PARAMETER], options)) {
1935 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "options", "CursorOptions");
1936 return nullptr;
1937 }
1938 return jsPointerMgr->SetCustomCursor(env, windowId, cursor, options);
1939 }
1940 } // namespace MMI
1941 } // namespace OHOS
1942