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