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.h"
18 #include "pixel_map_napi.h"
19
20 #undef MMI_LOG_TAG
21 #define MMI_LOG_TAG "JsPointerContext"
22
23 namespace OHOS {
24 namespace MMI {
25 namespace {
26 constexpr int32_t STANDARD_SPEED { 5 };
27 constexpr int32_t MAX_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
GetWindowId(napi_env env,napi_value value)613 int32_t JsPointerContext::GetWindowId(napi_env env, napi_value value)
614 {
615 if (!JsCommon::TypeOf(env, value, napi_number)) {
616 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
617 return INVALID_VALUE;
618 }
619 int32_t windowId = 0;
620 CHKRR(napi_get_value_int32(env, value, &windowId), GET_VALUE_INT32, INVALID_VALUE);
621 if (windowId < 0 && windowId != GLOBAL_WINDOW_ID) {
622 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Windowid is invalid");
623 return INVALID_VALUE;
624 }
625 return windowId;
626 }
627
GetCursorFocusX(napi_env env,napi_value value)628 int32_t JsPointerContext::GetCursorFocusX(napi_env env, napi_value value)
629 {
630 if (!JsCommon::TypeOf(env, value, napi_number)) {
631 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "focusX", "number");
632 return INVALID_VALUE;
633 }
634 int32_t focusX = 0;
635 CHKRR(napi_get_value_int32(env, value, &focusX), GET_VALUE_INT32, INVALID_VALUE);
636 if (focusX < 0) {
637 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "focusX is invalid");
638 return INVALID_VALUE;
639 }
640 return focusX;
641 }
642
GetCursorFocusY(napi_env env,napi_value value)643 int32_t JsPointerContext::GetCursorFocusY(napi_env env, napi_value value)
644 {
645 if (!JsCommon::TypeOf(env, value, napi_number)) {
646 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "focusY", "number");
647 return INVALID_VALUE;
648 }
649 int32_t focusY = 0;
650 CHKRR(napi_get_value_int32(env, value, &focusY), GET_VALUE_INT32, INVALID_VALUE);
651 if (focusY < 0) {
652 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "focusY is invalid");
653 return INVALID_VALUE;
654 }
655 return focusY;
656 }
657
SetPointerSize(napi_env env,napi_callback_info info)658 napi_value JsPointerContext::SetPointerSize(napi_env env, napi_callback_info info)
659 {
660 CALL_DEBUG_ENTER;
661 size_t argc = 2;
662 napi_value argv[2] = { 0 };
663 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
664 if (argc < 1) {
665 MMI_HILOGE("At least 1 parameter is required");
666 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "size", "number");
667 return nullptr;
668 }
669 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
670 MMI_HILOGE("Size parameter type is invalid");
671 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "size", "number");
672 return nullptr;
673 }
674 int32_t size = DEFAULT_POINTER_SIZE;
675 CHKRP(napi_get_value_int32(env, argv[0], &size), GET_VALUE_INT32);
676 if (size < MIN_POINTER_SIZE) {
677 size = MIN_POINTER_SIZE;
678 } else if (size > MAX_POINTER_SIZE) {
679 size = MAX_POINTER_SIZE;
680 }
681 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
682 CHKPP(jsPointer);
683 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
684 if (argc == 1) {
685 return jsPointerMgr->SetPointerSize(env, size);
686 }
687 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
688 MMI_HILOGE("Callback parameter type is invalid");
689 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
690 return nullptr;
691 }
692 return jsPointerMgr->SetPointerSize(env, size, argv[1]);
693 }
694
GetPointerSize(napi_env env,napi_callback_info info)695 napi_value JsPointerContext::GetPointerSize(napi_env env, napi_callback_info info)
696 {
697 CALL_DEBUG_ENTER;
698 size_t argc = 1;
699 napi_value argv[1] = { 0 };
700 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
701 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
702 CHKPP(jsPointer);
703 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
704 if (argc < 1) {
705 return jsPointerMgr->GetPointerSize(env);
706 }
707 if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
708 MMI_HILOGE("Callback parameter type is invalid");
709 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
710 return nullptr;
711 }
712
713 return jsPointerMgr->GetPointerSize(env, argv[0]);
714 }
715
SetPointerSizeSync(napi_env env,napi_callback_info info)716 napi_value JsPointerContext::SetPointerSizeSync(napi_env env, napi_callback_info info)
717 {
718 CALL_DEBUG_ENTER;
719 size_t argc = 1;
720 napi_value argv[1] = { 0 };
721 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
722 if (argc < 1) {
723 MMI_HILOGE("At least 1 parameter is required");
724 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "size", "number");
725 return nullptr;
726 }
727 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
728 MMI_HILOGE("Size parameter type is invalid");
729 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "size", "number");
730 return nullptr;
731 }
732 int32_t size = DEFAULT_POINTER_SIZE;
733 CHKRP(napi_get_value_int32(env, argv[0], &size), GET_VALUE_INT32);
734 if (size < MIN_POINTER_SIZE) {
735 size = MIN_POINTER_SIZE;
736 } else if (size > MAX_POINTER_SIZE) {
737 size = MAX_POINTER_SIZE;
738 }
739 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
740 CHKPP(jsPointer);
741 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
742 return jsPointerMgr->SetPointerSizeSync(env, size);
743 }
744
GetPointerSizeSync(napi_env env,napi_callback_info info)745 napi_value JsPointerContext::GetPointerSizeSync(napi_env env, napi_callback_info info)
746 {
747 CALL_DEBUG_ENTER;
748 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
749 CHKPP(jsPointer);
750 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
751 return jsPointerMgr->GetPointerSizeSync(env);
752 }
753
SetPointerStyle(napi_env env,napi_callback_info info)754 napi_value JsPointerContext::SetPointerStyle(napi_env env, napi_callback_info info)
755 {
756 CALL_DEBUG_ENTER;
757 size_t argc = 3;
758 napi_value argv[3] = { 0 };
759 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
760 if (argc < INPUT_PARAMETER) {
761 MMI_HILOGE("At least 2 parameter is required");
762 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
763 return nullptr;
764 }
765 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
766 MMI_HILOGE("windowId parameter type is invalid");
767 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
768 return nullptr;
769 }
770 int32_t windowid = 0;
771 CHKRP(napi_get_value_int32(env, argv[0], &windowid), GET_VALUE_INT32);
772 if (windowid < 0 && windowid != GLOBAL_WINDOW_ID) {
773 MMI_HILOGE("Invalid windowid");
774 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Windowid is invalid");
775 return nullptr;
776 }
777 if (!JsCommon::TypeOf(env, argv[1], napi_number)) {
778 MMI_HILOGE("pointerStyle parameter type is invalid");
779 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "pointerStyle", "number");
780 return nullptr;
781 }
782 int32_t pointerStyle = 0;
783 CHKRP(napi_get_value_int32(env, argv[1], &pointerStyle), GET_VALUE_INT32);
784 if ((pointerStyle < DEFAULT && pointerStyle != DEVELOPER_DEFINED_ICON) || pointerStyle > RUNNING) {
785 MMI_HILOGE("Undefined pointer style");
786 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Pointer style does not exist");
787 return nullptr;
788 }
789 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
790 CHKPP(jsPointer);
791 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
792 if (argc == INPUT_PARAMETER) {
793 return jsPointerMgr->SetPointerStyle(env, windowid, pointerStyle);
794 }
795 if (!JsCommon::TypeOf(env, argv[INPUT_PARAMETER], napi_function)) {
796 MMI_HILOGE("Callback parameter type is invalid");
797 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
798 return nullptr;
799 }
800 return jsPointerMgr->SetPointerStyle(env, windowid, pointerStyle, argv[INPUT_PARAMETER]);
801 }
802
SetPointerStyleSync(napi_env env,napi_callback_info info)803 napi_value JsPointerContext::SetPointerStyleSync(napi_env env, napi_callback_info info)
804 {
805 CALL_DEBUG_ENTER;
806 size_t argc = 2;
807 napi_value argv[2] = { 0 };
808 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
809 if (argc < INPUT_PARAMETER) {
810 MMI_HILOGE("At least 2 parameter is required");
811 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
812 return nullptr;
813 }
814 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
815 MMI_HILOGE("windowId parameter type is invalid");
816 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
817 return nullptr;
818 }
819 int32_t windowid = 0;
820 CHKRP(napi_get_value_int32(env, argv[0], &windowid), GET_VALUE_INT32);
821 if (windowid < 0 && windowid != GLOBAL_WINDOW_ID) {
822 MMI_HILOGE("Invalid windowid");
823 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Windowid is invalid");
824 return nullptr;
825 }
826 if (!JsCommon::TypeOf(env, argv[1], napi_number)) {
827 MMI_HILOGE("pointerStyle parameter type is invalid");
828 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "pointerStyle", "number");
829 return nullptr;
830 }
831 int32_t pointerStyle = 0;
832 CHKRP(napi_get_value_int32(env, argv[1], &pointerStyle), GET_VALUE_INT32);
833 if ((pointerStyle < DEFAULT && pointerStyle != DEVELOPER_DEFINED_ICON) || pointerStyle > RUNNING) {
834 MMI_HILOGE("Undefined pointer style");
835 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Pointer style does not exist");
836 return nullptr;
837 }
838 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
839 CHKPP(jsPointer);
840 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
841 return jsPointerMgr->SetPointerStyleSync(env, windowid, pointerStyle);
842 }
843
GetPointerStyle(napi_env env,napi_callback_info info)844 napi_value JsPointerContext::GetPointerStyle(napi_env env, napi_callback_info info)
845 {
846 CALL_DEBUG_ENTER;
847 size_t argc = 2;
848 napi_value argv[2] = { 0 };
849 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
850 if (argc < 1) {
851 MMI_HILOGE("At least 1 parameter is required");
852 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
853 return nullptr;
854 }
855 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
856 MMI_HILOGE("windowId parameter type is invalid");
857 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
858 return nullptr;
859 }
860 int32_t windowid = 0;
861 CHKRP(napi_get_value_int32(env, argv[0], &windowid), GET_VALUE_INT32);
862 if (windowid < 0 && windowid != GLOBAL_WINDOW_ID) {
863 MMI_HILOGE("Invalid windowid");
864 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Windowid is invalid");
865 return nullptr;
866 }
867 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
868 CHKPP(jsPointer);
869 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
870 if (argc == 1) {
871 return jsPointerMgr->GetPointerStyle(env, windowid);
872 }
873 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
874 MMI_HILOGE("Callback parameter type is invalid");
875 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
876 return nullptr;
877 }
878 return jsPointerMgr->GetPointerStyle(env, windowid, argv[1]);
879 }
880
GetPointerStyleSync(napi_env env,napi_callback_info info)881 napi_value JsPointerContext::GetPointerStyleSync(napi_env env, napi_callback_info info)
882 {
883 CALL_DEBUG_ENTER;
884 size_t argc = 1;
885 napi_value argv[1] = { 0 };
886 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
887 if (argc < 1) {
888 MMI_HILOGE("At least 1 parameter is required");
889 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
890 return nullptr;
891 }
892 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
893 MMI_HILOGE("windowId parameter type is invalid");
894 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
895 return nullptr;
896 }
897 int32_t windowId = 0;
898 CHKRP(napi_get_value_int32(env, argv[0], &windowId), GET_VALUE_INT32);
899 if (windowId < 0 && windowId != GLOBAL_WINDOW_ID) {
900 MMI_HILOGE("Invalid windowId");
901 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "WindowId is invalid");
902 return nullptr;
903 }
904 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
905 CHKPP(jsPointer);
906 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
907 return jsPointerMgr->GetPointerStyleSync(env, windowId);
908 }
909
CreatePointerStyle(napi_env env,napi_value exports)910 napi_value JsPointerContext::CreatePointerStyle(napi_env env, napi_value exports)
911 {
912 CALL_DEBUG_ENTER;
913 napi_value defaults = nullptr;
914 CHKRP(napi_create_int32(env, MOUSE_ICON::DEFAULT, &defaults), CREATE_INT32);
915 napi_value east = nullptr;
916 CHKRP(napi_create_int32(env, MOUSE_ICON::EAST, &east), CREATE_INT32);
917 napi_value west = nullptr;
918 CHKRP(napi_create_int32(env, MOUSE_ICON::WEST, &west), CREATE_INT32);
919 napi_value south = nullptr;
920 CHKRP(napi_create_int32(env, MOUSE_ICON::SOUTH, &south), CREATE_INT32);
921 napi_value north = nullptr;
922 CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH, &north), CREATE_INT32);
923 napi_value west_east = nullptr;
924 CHKRP(napi_create_int32(env, MOUSE_ICON::WEST_EAST, &west_east), CREATE_INT32);
925 napi_value north_south = nullptr;
926 CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH_SOUTH, &north_south), CREATE_INT32);
927 napi_value north_east = nullptr;
928 CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH_EAST, &north_east), CREATE_INT32);
929 napi_value north_west = nullptr;
930 CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH_WEST, &north_west), CREATE_INT32);
931 napi_value south_east = nullptr;
932 CHKRP(napi_create_int32(env, MOUSE_ICON::SOUTH_EAST, &south_east), CREATE_INT32);
933 napi_value south_west = nullptr;
934 CHKRP(napi_create_int32(env, MOUSE_ICON::SOUTH_WEST, &south_west), CREATE_INT32);
935 napi_value north_east_south_west = nullptr;
936 CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH_EAST_SOUTH_WEST, &north_east_south_west), CREATE_INT32);
937 napi_value north_west_south_east = nullptr;
938 CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH_WEST_SOUTH_EAST, &north_west_south_east), CREATE_INT32);
939 napi_value cross = nullptr;
940 CHKRP(napi_create_int32(env, MOUSE_ICON::CROSS, &cross), CREATE_INT32);
941 napi_value cursor_copy = nullptr;
942 CHKRP(napi_create_int32(env, MOUSE_ICON::CURSOR_COPY, &cursor_copy), CREATE_INT32);
943 napi_value cursor_forbid = nullptr;
944 CHKRP(napi_create_int32(env, MOUSE_ICON::CURSOR_FORBID, &cursor_forbid), CREATE_INT32);
945 napi_value color_sucker = nullptr;
946 CHKRP(napi_create_int32(env, MOUSE_ICON::COLOR_SUCKER, &color_sucker), CREATE_INT32);
947 napi_value hand_grabbing = nullptr;
948 CHKRP(napi_create_int32(env, MOUSE_ICON::HAND_GRABBING, &hand_grabbing), CREATE_INT32);
949 napi_value hand_open = nullptr;
950 CHKRP(napi_create_int32(env, MOUSE_ICON::HAND_OPEN, &hand_open), CREATE_INT32);
951 napi_value hand_pointing = nullptr;
952 CHKRP(napi_create_int32(env, MOUSE_ICON::HAND_POINTING, &hand_pointing), CREATE_INT32);
953 napi_value help = nullptr;
954 CHKRP(napi_create_int32(env, MOUSE_ICON::HELP, &help), CREATE_INT32);
955 napi_value move = nullptr;
956 CHKRP(napi_create_int32(env, MOUSE_ICON::CURSOR_MOVE, &move), CREATE_INT32);
957 napi_value resize_left_right = nullptr;
958 CHKRP(napi_create_int32(env, MOUSE_ICON::RESIZE_LEFT_RIGHT, &resize_left_right), CREATE_INT32);
959 napi_value resize_up_down = nullptr;
960 CHKRP(napi_create_int32(env, MOUSE_ICON::RESIZE_UP_DOWN, &resize_up_down), CREATE_INT32);
961 napi_value screenshot_choose = nullptr;
962 CHKRP(napi_create_int32(env, MOUSE_ICON::SCREENSHOT_CHOOSE, &screenshot_choose), CREATE_INT32);
963 napi_value screenshot_cursor = nullptr;
964 CHKRP(napi_create_int32(env, MOUSE_ICON::SCREENSHOT_CURSOR, &screenshot_cursor), CREATE_INT32);
965 napi_value text_cursor = nullptr;
966 CHKRP(napi_create_int32(env, MOUSE_ICON::TEXT_CURSOR, &text_cursor), CREATE_INT32);
967 napi_value zoom_in = nullptr;
968 CHKRP(napi_create_int32(env, MOUSE_ICON::ZOOM_IN, &zoom_in), CREATE_INT32);
969 napi_value zoom_out = nullptr;
970 CHKRP(napi_create_int32(env, MOUSE_ICON::ZOOM_OUT, &zoom_out), CREATE_INT32);
971 napi_value middle_btn_east = nullptr;
972 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_EAST, &middle_btn_east), CREATE_INT32);
973 napi_value middle_btn_west = nullptr;
974 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_WEST, &middle_btn_west), CREATE_INT32);
975 napi_value middle_btn_south = nullptr;
976 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_SOUTH, &middle_btn_south), CREATE_INT32);
977 napi_value middle_btn_north = nullptr;
978 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_NORTH, &middle_btn_north), CREATE_INT32);
979 napi_value middle_btn_north_south = nullptr;
980 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_NORTH_SOUTH, &middle_btn_north_south), CREATE_INT32);
981 napi_value middle_btn_north_east = nullptr;
982 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_NORTH_EAST, &middle_btn_north_east), CREATE_INT32);
983 napi_value middle_btn_north_west = nullptr;
984 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_NORTH_WEST, &middle_btn_north_west), CREATE_INT32);
985 napi_value middle_btn_south_east = nullptr;
986 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_SOUTH_EAST, &middle_btn_south_east), CREATE_INT32);
987 napi_value middle_btn_south_west = nullptr;
988 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_SOUTH_WEST, &middle_btn_south_west), CREATE_INT32);
989 napi_value middle_btn_north_south_west_east = nullptr;
990 CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_NORTH_SOUTH_WEST_EAST,
991 &middle_btn_north_south_west_east), CREATE_INT32);
992 napi_value horizontal_text_cursor = nullptr;
993 CHKRP(napi_create_int32(env, MOUSE_ICON::HORIZONTAL_TEXT_CURSOR, &horizontal_text_cursor), CREATE_INT32);
994 napi_value cursor_cross = nullptr;
995 CHKRP(napi_create_int32(env, MOUSE_ICON::CURSOR_CROSS, &cursor_cross), CREATE_INT32);
996 napi_value cursor_circle = nullptr;
997 CHKRP(napi_create_int32(env, MOUSE_ICON::CURSOR_CIRCLE, &cursor_circle), CREATE_INT32);
998 napi_value loading = nullptr;
999 CHKRP(napi_create_int32(env, MOUSE_ICON::LOADING, &loading), CREATE_INT32);
1000 napi_value running = nullptr;
1001 CHKRP(napi_create_int32(env, MOUSE_ICON::RUNNING, &running), CREATE_INT32);
1002 napi_value developer_defined_icon = nullptr;
1003 CHKRP(napi_create_int32(env, MOUSE_ICON::DEVELOPER_DEFINED_ICON, &developer_defined_icon), CREATE_INT32);
1004
1005 napi_property_descriptor desc[] = {
1006 DECLARE_NAPI_STATIC_PROPERTY("DEFAULT", defaults),
1007 DECLARE_NAPI_STATIC_PROPERTY("EAST", east),
1008 DECLARE_NAPI_STATIC_PROPERTY("WEST", west),
1009 DECLARE_NAPI_STATIC_PROPERTY("SOUTH", south),
1010 DECLARE_NAPI_STATIC_PROPERTY("NORTH", north),
1011 DECLARE_NAPI_STATIC_PROPERTY("WEST_EAST", west_east),
1012 DECLARE_NAPI_STATIC_PROPERTY("NORTH_SOUTH", north_south),
1013 DECLARE_NAPI_STATIC_PROPERTY("NORTH_EAST", north_east),
1014 DECLARE_NAPI_STATIC_PROPERTY("NORTH_WEST", north_west),
1015 DECLARE_NAPI_STATIC_PROPERTY("SOUTH_EAST", south_east),
1016 DECLARE_NAPI_STATIC_PROPERTY("SOUTH_WEST", south_west),
1017 DECLARE_NAPI_STATIC_PROPERTY("NORTH_EAST_SOUTH_WEST", north_east_south_west),
1018 DECLARE_NAPI_STATIC_PROPERTY("NORTH_WEST_SOUTH_EAST", north_west_south_east),
1019 DECLARE_NAPI_STATIC_PROPERTY("CROSS", cross),
1020 DECLARE_NAPI_STATIC_PROPERTY("CURSOR_COPY", cursor_copy),
1021 DECLARE_NAPI_STATIC_PROPERTY("CURSOR_FORBID", cursor_forbid),
1022 DECLARE_NAPI_STATIC_PROPERTY("COLOR_SUCKER", color_sucker),
1023 DECLARE_NAPI_STATIC_PROPERTY("HAND_GRABBING", hand_grabbing),
1024 DECLARE_NAPI_STATIC_PROPERTY("HAND_OPEN", hand_open),
1025 DECLARE_NAPI_STATIC_PROPERTY("HAND_POINTING", hand_pointing),
1026 DECLARE_NAPI_STATIC_PROPERTY("HELP", help),
1027 DECLARE_NAPI_STATIC_PROPERTY("MOVE", move),
1028 DECLARE_NAPI_STATIC_PROPERTY("RESIZE_LEFT_RIGHT", resize_left_right),
1029 DECLARE_NAPI_STATIC_PROPERTY("RESIZE_UP_DOWN", resize_up_down),
1030 DECLARE_NAPI_STATIC_PROPERTY("SCREENSHOT_CHOOSE", screenshot_choose),
1031 DECLARE_NAPI_STATIC_PROPERTY("SCREENSHOT_CURSOR", screenshot_cursor),
1032 DECLARE_NAPI_STATIC_PROPERTY("TEXT_CURSOR", text_cursor),
1033 DECLARE_NAPI_STATIC_PROPERTY("ZOOM_IN", zoom_in),
1034 DECLARE_NAPI_STATIC_PROPERTY("ZOOM_OUT", zoom_out),
1035 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_EAST", middle_btn_east),
1036 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_WEST", middle_btn_west),
1037 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_SOUTH", middle_btn_south),
1038 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_NORTH", middle_btn_north),
1039 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_NORTH_SOUTH", middle_btn_north_south),
1040 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_NORTH_EAST", middle_btn_north_east),
1041 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_NORTH_WEST", middle_btn_north_west),
1042 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_SOUTH_EAST", middle_btn_south_east),
1043 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_SOUTH_WEST", middle_btn_south_west),
1044 DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_NORTH_SOUTH_WEST_EAST", middle_btn_north_south_west_east),
1045 DECLARE_NAPI_STATIC_PROPERTY("HORIZONTAL_TEXT_CURSOR", horizontal_text_cursor),
1046 DECLARE_NAPI_STATIC_PROPERTY("CURSOR_CROSS", cursor_cross),
1047 DECLARE_NAPI_STATIC_PROPERTY("CURSOR_CIRCLE", cursor_circle),
1048 DECLARE_NAPI_STATIC_PROPERTY("LOADING", loading),
1049 DECLARE_NAPI_STATIC_PROPERTY("RUNNING", running),
1050 DECLARE_NAPI_STATIC_PROPERTY("DEVELOPER_DEFINED_ICON", developer_defined_icon),
1051 };
1052 napi_value result = nullptr;
1053 CHKRP(napi_define_class(env, "PointerStyle", NAPI_AUTO_LENGTH, EnumConstructor, nullptr,
1054 sizeof(desc) / sizeof(*desc), desc, &result), DEFINE_CLASS);
1055 CHKRP(napi_set_named_property(env, exports, "PointerStyle", result), SET_NAMED_PROPERTY);
1056 return exports;
1057 }
1058
CreateTouchpadRightClickType(napi_env env,napi_value exports)1059 napi_value JsPointerContext::CreateTouchpadRightClickType(napi_env env, napi_value exports)
1060 {
1061 CALL_DEBUG_ENTER;
1062 napi_value touchpad_right_button = nullptr;
1063 CHKRP(napi_create_int32(env, RightClickType::TOUCHPAD_RIGHT_BUTTON, &touchpad_right_button), CREATE_INT32);
1064 napi_value touchpad_left_button = nullptr;
1065 CHKRP(napi_create_int32(env, RightClickType::TOUCHPAD_LEFT_BUTTON, &touchpad_left_button), CREATE_INT32);
1066 napi_value touchpad_two_finger_tap = nullptr;
1067 CHKRP(napi_create_int32(env, RightClickType::TOUCHPAD_TWO_FINGER_TAP, &touchpad_two_finger_tap), CREATE_INT32);
1068
1069 napi_property_descriptor desc[] = {
1070 DECLARE_NAPI_STATIC_PROPERTY("TOUCHPAD_RIGHT_BUTTON", touchpad_right_button),
1071 DECLARE_NAPI_STATIC_PROPERTY("TOUCHPAD_LEFT_BUTTON", touchpad_left_button),
1072 DECLARE_NAPI_STATIC_PROPERTY("TOUCHPAD_TWO_FINGER_TAP", touchpad_two_finger_tap),
1073 };
1074 napi_value result = nullptr;
1075 CHKRP(napi_define_class(env, "RightClickType", NAPI_AUTO_LENGTH, EnumConstructor, nullptr,
1076 sizeof(desc) / sizeof(*desc), desc, &result), DEFINE_CLASS);
1077 CHKRP(napi_set_named_property(env, exports, "RightClickType", result), SET_NAMED_PROPERTY);
1078 return exports;
1079 }
1080
EnumConstructor(napi_env env,napi_callback_info info)1081 napi_value JsPointerContext::EnumConstructor(napi_env env, napi_callback_info info)
1082 {
1083 CALL_DEBUG_ENTER;
1084 size_t argc = 0;
1085 napi_value args[1] = { 0 };
1086 napi_value ret = nullptr;
1087 void *data = nullptr;
1088 CHKRP(napi_get_cb_info(env, info, &argc, args, &ret, &data), GET_CB_INFO);
1089 return ret;
1090 }
1091
EnterCaptureMode(napi_env env,napi_callback_info info)1092 napi_value JsPointerContext::EnterCaptureMode(napi_env env, napi_callback_info info)
1093 {
1094 CALL_DEBUG_ENTER;
1095 size_t argc = 2;
1096 napi_value argv[2] = { 0 };
1097 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1098 if (argc < 1 || argc > INPUT_PARAMETER) {
1099 THROWERR(env, "The number of parameters is not as expected");
1100 return nullptr;
1101 }
1102 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
1103 THROWERR(env, "The first parameter type is invalid");
1104 return nullptr;
1105 }
1106
1107 int32_t windowId = 0;
1108 CHKRP(napi_get_value_int32(env, argv[0], &windowId), GET_VALUE_INT32);
1109 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1110 CHKPP(jsPointer);
1111 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1112 if (argc == 1) {
1113 return jsPointerMgr->EnterCaptureMode(env, windowId);
1114 }
1115 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1116 THROWERR(env, "The second parameter type is invalid");
1117 return nullptr;
1118 }
1119 return jsPointerMgr->EnterCaptureMode(env, windowId, argv[1]);
1120 }
1121
LeaveCaptureMode(napi_env env,napi_callback_info info)1122 napi_value JsPointerContext::LeaveCaptureMode(napi_env env, napi_callback_info info)
1123 {
1124 CALL_DEBUG_ENTER;
1125 size_t argc = 2;
1126 napi_value argv[2] = { 0 };
1127 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1128 if (argc < 1 || argc > INPUT_PARAMETER) {
1129 THROWERR(env, "The number of parameters is not as expected");
1130 return nullptr;
1131 }
1132 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
1133 THROWERR(env, "The first parameter type is invalid");
1134 return nullptr;
1135 }
1136
1137 int32_t windowId = 0;
1138 CHKRP(napi_get_value_int32(env, argv[0], &windowId), GET_VALUE_INT32);
1139
1140 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1141 CHKPP(jsPointer);
1142 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1143 if (argc == 1) {
1144 return jsPointerMgr->LeaveCaptureMode(env, windowId);
1145 }
1146 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1147 THROWERR(env, "The second parameter type is invalid");
1148 return nullptr;
1149 }
1150 return jsPointerMgr->LeaveCaptureMode(env, windowId, argv[1]);
1151 }
1152
CreateMousePrimaryButton(napi_env env,napi_value exports)1153 napi_value JsPointerContext::CreateMousePrimaryButton(napi_env env, napi_value exports)
1154 {
1155 CALL_DEBUG_ENTER;
1156 napi_value leftButton = nullptr;
1157 CHKRP(napi_create_int32(env, PrimaryButton::LEFT_BUTTON, &leftButton), CREATE_INT32);
1158 napi_value rightButton = nullptr;
1159 CHKRP(napi_create_int32(env, PrimaryButton::RIGHT_BUTTON, &rightButton), CREATE_INT32);
1160
1161 napi_property_descriptor desc[] = {
1162 DECLARE_NAPI_STATIC_PROPERTY("LEFT", leftButton),
1163 DECLARE_NAPI_STATIC_PROPERTY("RIGHT", rightButton),
1164 };
1165 napi_value result = nullptr;
1166 CHKRP(napi_define_class(env, "PrimaryButton", NAPI_AUTO_LENGTH, EnumConstructor, nullptr,
1167 sizeof(desc) / sizeof(*desc), desc, &result), DEFINE_CLASS);
1168 CHKRP(napi_set_named_property(env, exports, "PrimaryButton", result), SET_NAMED_PROPERTY);
1169 return exports;
1170 }
1171
SetMousePrimaryButton(napi_env env,napi_callback_info info)1172 napi_value JsPointerContext::SetMousePrimaryButton(napi_env env, napi_callback_info info)
1173 {
1174 CALL_DEBUG_ENTER;
1175 size_t argc = 2;
1176 napi_value argv[2] = { 0 };
1177 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1178 if (argc < 1) {
1179 MMI_HILOGE("At least one parameter is required");
1180 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "primaryButton", "number");
1181 return nullptr;
1182 }
1183 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
1184 MMI_HILOGE("primaryButton parameter type is invalid");
1185 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "primaryButton", "number");
1186 return nullptr;
1187 }
1188 int32_t primaryButton = 0;
1189 CHKRP(napi_get_value_int32(env, argv[0], &primaryButton), GET_VALUE_INT32);
1190 if (primaryButton < LEFT_BUTTON || primaryButton > RIGHT_BUTTON) {
1191 MMI_HILOGE("Undefined mouse primary button");
1192 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Mouse primary button does not exist");
1193 return nullptr;
1194 }
1195 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1196 CHKPP(jsPointer);
1197 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1198 if (argc == 1) {
1199 return jsPointerMgr->SetMousePrimaryButton(env, primaryButton);
1200 }
1201 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1202 MMI_HILOGE("Callback parameter type is invalid");
1203 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1204 return nullptr;
1205 }
1206 return jsPointerMgr->SetMousePrimaryButton(env, primaryButton, argv[1]);
1207 }
1208
GetMousePrimaryButton(napi_env env,napi_callback_info info)1209 napi_value JsPointerContext::GetMousePrimaryButton(napi_env env, napi_callback_info info)
1210 {
1211 CALL_DEBUG_ENTER;
1212 size_t argc = 1;
1213 napi_value argv[1] = { 0 };
1214 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1215 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1216 CHKPP(jsPointer);
1217 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1218 if (argc < 1) {
1219 return jsPointerMgr->GetMousePrimaryButton(env);
1220 }
1221 if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
1222 MMI_HILOGE("Callback parameter type is invalid");
1223 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1224 return nullptr;
1225 }
1226 return jsPointerMgr->GetMousePrimaryButton(env, argv[0]);
1227 }
1228
SetHoverScrollState(napi_env env,napi_callback_info info)1229 napi_value JsPointerContext::SetHoverScrollState(napi_env env, napi_callback_info info)
1230 {
1231 CALL_DEBUG_ENTER;
1232 size_t argc = 2;
1233 napi_value argv[2] = { 0 };
1234 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1235 if (argc < 1) {
1236 MMI_HILOGE("At least one parameter is required");
1237 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "state", "boolean");
1238 return nullptr;
1239 }
1240 if (!JsCommon::TypeOf(env, argv[0], napi_boolean)) {
1241 MMI_HILOGE("State parameter type is invalid");
1242 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "state", "boolean");
1243 return nullptr;
1244 }
1245 bool state = true;
1246 CHKRP(napi_get_value_bool(env, argv[0], &state), GET_VALUE_BOOL);
1247
1248 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1249 CHKPP(jsPointer);
1250 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1251 if (argc == 1) {
1252 return jsPointerMgr->SetHoverScrollState(env, state);
1253 }
1254 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1255 MMI_HILOGE("Callback parameter type is invalid");
1256 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1257 return nullptr;
1258 }
1259 return jsPointerMgr->SetHoverScrollState(env, state, argv[1]);
1260 }
1261
GetHoverScrollState(napi_env env,napi_callback_info info)1262 napi_value JsPointerContext::GetHoverScrollState(napi_env env, napi_callback_info info)
1263 {
1264 CALL_DEBUG_ENTER;
1265 size_t argc = 1;
1266 napi_value argv[1] = { 0 };
1267 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1268
1269 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1270 CHKPP(jsPointer);
1271 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1272 if (argc < 1) {
1273 return jsPointerMgr->GetHoverScrollState(env);
1274 }
1275 if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
1276 MMI_HILOGE("Callback parameter type is invalid");
1277 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1278 return nullptr;
1279 }
1280 return jsPointerMgr->GetHoverScrollState(env, argv[0]);
1281 }
1282
SetTouchpadBoolData(napi_env env,napi_callback_info info,SetTouchpadBoolDataFunc func)1283 napi_value JsPointerContext::SetTouchpadBoolData(napi_env env, napi_callback_info info, SetTouchpadBoolDataFunc func)
1284 {
1285 CALL_DEBUG_ENTER;
1286 if (!func) {
1287 MMI_HILOGE("func is nullptr");
1288 return nullptr;
1289 }
1290 size_t argc = 2;
1291 napi_value argv[2] = { 0 };
1292 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1293 if (argc < 1) {
1294 MMI_HILOGE("At least one parameter is required");
1295 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "switchFlag", "boolean");
1296 return nullptr;
1297 }
1298 if (!JsCommon::TypeOf(env, argv[0], napi_boolean)) {
1299 MMI_HILOGE("Bool data parameter type is invalid");
1300 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "switchFlag", "boolean");
1301 return nullptr;
1302 }
1303 bool switchFlag = true;
1304 CHKRP(napi_get_value_bool(env, argv[0], &switchFlag), GET_VALUE_BOOL);
1305
1306 if (argc == 1) {
1307 return func(env, switchFlag, nullptr);
1308 }
1309 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1310 MMI_HILOGE("Callback parameter type is invalid");
1311 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1312 return nullptr;
1313 }
1314 return func(env, switchFlag, argv[1]);
1315 }
1316
SetTouchpadInt32Data(napi_env env,napi_callback_info info,SetTouchpadInt32DataFunc func,int32_t dataMax,int32_t dataMin)1317 napi_value JsPointerContext::SetTouchpadInt32Data(napi_env env, napi_callback_info info, SetTouchpadInt32DataFunc func,
1318 int32_t dataMax, int32_t dataMin)
1319 {
1320 CALL_DEBUG_ENTER;
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 < 1) {
1325 MMI_HILOGE("At least 1 parameter is required");
1326 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "data", "number");
1327 return nullptr;
1328 }
1329 if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
1330 MMI_HILOGE("Int32 data parameter type is invalid");
1331 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "data", "number");
1332 return nullptr;
1333 }
1334 int32_t data = 0;
1335 CHKRP(napi_get_value_int32(env, argv[0], &data), GET_VALUE_INT32);
1336 if (data < dataMin) {
1337 data = dataMin;
1338 } else if (data > dataMax) {
1339 data = dataMax;
1340 }
1341
1342 if (argc == 1) {
1343 return func(env, data, nullptr);
1344 }
1345 if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1346 MMI_HILOGE("Callback parameter type is invalid");
1347 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1348 return nullptr;
1349 }
1350
1351 return func(env, data, argv[1]);
1352 }
1353
GetTouchpadData(napi_env env,napi_callback_info info,GetTouchpadFunc func)1354 napi_value JsPointerContext::GetTouchpadData(napi_env env, napi_callback_info info, GetTouchpadFunc func)
1355 {
1356 CALL_DEBUG_ENTER;
1357 size_t argc = 1;
1358 napi_value argv[1] = { 0 };
1359 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1360
1361 if (argc < 1) {
1362 return func(env, nullptr);
1363 }
1364 if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
1365 MMI_HILOGE("Callback parameter type is invalid");
1366 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1367 return nullptr;
1368 }
1369
1370 return func(env, argv[0]);
1371 }
1372
SetTouchpadScrollSwitch(napi_env env,napi_callback_info info)1373 napi_value JsPointerContext::SetTouchpadScrollSwitch(napi_env env, napi_callback_info info)
1374 {
1375 CALL_DEBUG_ENTER;
1376 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1377 CHKPP(jsPointer);
1378 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1379 CHKPP(jsPointerMgr);
1380 auto func = [jsPointerMgr] (napi_env env, bool switchFlag, napi_value handle) -> napi_value {
1381 return jsPointerMgr->SetTouchpadScrollSwitch(env, switchFlag, handle);
1382 };
1383 return SetTouchpadBoolData(env, info, func);
1384 }
1385
GetTouchpadScrollSwitch(napi_env env,napi_callback_info info)1386 napi_value JsPointerContext::GetTouchpadScrollSwitch(napi_env env, napi_callback_info info)
1387 {
1388 CALL_DEBUG_ENTER;
1389 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1390 CHKPP(jsPointer);
1391 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1392 CHKPP(jsPointerMgr);
1393 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1394 return jsPointerMgr->GetTouchpadScrollSwitch(env, handle);
1395 };
1396 return GetTouchpadData(env, info, func);
1397 }
1398
SetTouchpadScrollDirection(napi_env env,napi_callback_info info)1399 napi_value JsPointerContext::SetTouchpadScrollDirection(napi_env env, napi_callback_info info)
1400 {
1401 CALL_DEBUG_ENTER;
1402 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1403 CHKPP(jsPointer);
1404 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1405 CHKPP(jsPointerMgr);
1406 auto func = [jsPointerMgr] (napi_env env, bool state, napi_value handle) -> napi_value {
1407 return jsPointerMgr->SetTouchpadScrollDirection(env, state, handle);
1408 };
1409 return SetTouchpadBoolData(env, info, func);
1410 }
1411
GetTouchpadScrollDirection(napi_env env,napi_callback_info info)1412 napi_value JsPointerContext::GetTouchpadScrollDirection(napi_env env, napi_callback_info info)
1413 {
1414 CALL_DEBUG_ENTER;
1415 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1416 CHKPP(jsPointer);
1417 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1418 CHKPP(jsPointerMgr);
1419 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1420 return jsPointerMgr->GetTouchpadScrollDirection(env, handle);
1421 };
1422 return GetTouchpadData(env, info, func);
1423 }
1424
SetTouchpadTapSwitch(napi_env env,napi_callback_info info)1425 napi_value JsPointerContext::SetTouchpadTapSwitch(napi_env env, napi_callback_info info)
1426 {
1427 CALL_DEBUG_ENTER;
1428 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1429 CHKPP(jsPointer);
1430 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1431 CHKPP(jsPointerMgr);
1432 auto func = [jsPointerMgr] (napi_env env, bool switchFlag, napi_value handle) -> napi_value {
1433 return jsPointerMgr->SetTouchpadTapSwitch(env, switchFlag, handle);
1434 };
1435 return SetTouchpadBoolData(env, info, func);
1436 }
1437
GetTouchpadTapSwitch(napi_env env,napi_callback_info info)1438 napi_value JsPointerContext::GetTouchpadTapSwitch(napi_env env, napi_callback_info info)
1439 {
1440 CALL_DEBUG_ENTER;
1441 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1442 CHKPP(jsPointer);
1443 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1444 CHKPP(jsPointerMgr);
1445 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1446 return jsPointerMgr->GetTouchpadTapSwitch(env, handle);
1447 };
1448 return GetTouchpadData(env, info, func);
1449 }
1450
SetTouchpadPointerSpeed(napi_env env,napi_callback_info info)1451 napi_value JsPointerContext::SetTouchpadPointerSpeed(napi_env env, napi_callback_info info)
1452 {
1453 CALL_DEBUG_ENTER;
1454 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1455 CHKPP(jsPointer);
1456 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1457 CHKPP(jsPointerMgr);
1458 auto func = [jsPointerMgr] (napi_env env, int32_t data, napi_value handle) -> napi_value {
1459 return jsPointerMgr->SetTouchpadPointerSpeed(env, data, handle);
1460 };
1461 return SetTouchpadInt32Data(env, info, func, MAX_SPEED, MIN_SPEED);
1462 }
1463
GetTouchpadPointerSpeed(napi_env env,napi_callback_info info)1464 napi_value JsPointerContext::GetTouchpadPointerSpeed(napi_env env, napi_callback_info info)
1465 {
1466 CALL_DEBUG_ENTER;
1467 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1468 CHKPP(jsPointer);
1469 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1470 CHKPP(jsPointerMgr);
1471 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1472 return jsPointerMgr->GetTouchpadPointerSpeed(env, handle);
1473 };
1474 return GetTouchpadData(env, info, func);
1475 }
1476
SetTouchpadPinchSwitch(napi_env env,napi_callback_info info)1477 napi_value JsPointerContext::SetTouchpadPinchSwitch(napi_env env, napi_callback_info info)
1478 {
1479 CALL_DEBUG_ENTER;
1480 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1481 CHKPP(jsPointer);
1482 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1483 CHKPP(jsPointerMgr);
1484 auto func = [jsPointerMgr] (napi_env env, bool switchFlag, napi_value handle) -> napi_value {
1485 return jsPointerMgr->SetTouchpadPinchSwitch(env, switchFlag, handle);
1486 };
1487 return SetTouchpadBoolData(env, info, func);
1488 }
1489
GetTouchpadPinchSwitch(napi_env env,napi_callback_info info)1490 napi_value JsPointerContext::GetTouchpadPinchSwitch(napi_env env, napi_callback_info info)
1491 {
1492 CALL_DEBUG_ENTER;
1493 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1494 CHKPP(jsPointer);
1495 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1496 CHKPP(jsPointerMgr);
1497 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1498 return jsPointerMgr->GetTouchpadPinchSwitch(env, handle);
1499 };
1500 return GetTouchpadData(env, info, func);
1501 }
1502
SetTouchpadSwipeSwitch(napi_env env,napi_callback_info info)1503 napi_value JsPointerContext::SetTouchpadSwipeSwitch(napi_env env, napi_callback_info info)
1504 {
1505 CALL_DEBUG_ENTER;
1506 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1507 CHKPP(jsPointer);
1508 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1509 CHKPP(jsPointerMgr);
1510 auto func = [jsPointerMgr] (napi_env env, bool switchFlag, napi_value handle) -> napi_value {
1511 return jsPointerMgr->SetTouchpadSwipeSwitch(env, switchFlag, handle);
1512 };
1513 return SetTouchpadBoolData(env, info, func);
1514 }
1515
GetTouchpadSwipeSwitch(napi_env env,napi_callback_info info)1516 napi_value JsPointerContext::GetTouchpadSwipeSwitch(napi_env env, napi_callback_info info)
1517 {
1518 CALL_DEBUG_ENTER;
1519 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1520 CHKPP(jsPointer);
1521 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1522 CHKPP(jsPointerMgr);
1523 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1524 return jsPointerMgr->GetTouchpadSwipeSwitch(env, handle);
1525 };
1526 return GetTouchpadData(env, info, func);
1527 }
1528
SetTouchpadRightClickType(napi_env env,napi_callback_info info)1529 napi_value JsPointerContext::SetTouchpadRightClickType(napi_env env, napi_callback_info info)
1530 {
1531 CALL_DEBUG_ENTER;
1532 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1533 CHKPP(jsPointer);
1534 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1535 CHKPP(jsPointerMgr);
1536 auto func = [jsPointerMgr] (napi_env env, int32_t data, napi_value handle) -> napi_value {
1537 return jsPointerMgr->SetTouchpadRightClickType(env, data, handle);
1538 };
1539 return SetTouchpadInt32Data(env, info, func, MAX_SPEED, MIN_SPEED);
1540 }
1541
GetTouchpadRightClickType(napi_env env,napi_callback_info info)1542 napi_value JsPointerContext::GetTouchpadRightClickType(napi_env env, napi_callback_info info)
1543 {
1544 CALL_DEBUG_ENTER;
1545 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1546 CHKPP(jsPointer);
1547 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1548 CHKPP(jsPointerMgr);
1549 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1550 return jsPointerMgr->GetTouchpadRightClickType(env, handle);
1551 };
1552 return GetTouchpadData(env, info, func);
1553 }
1554
SetTouchpadRotateSwitch(napi_env env,napi_callback_info info)1555 napi_value JsPointerContext::SetTouchpadRotateSwitch(napi_env env, napi_callback_info info)
1556 {
1557 CALL_DEBUG_ENTER;
1558 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1559 CHKPP(jsPointer);
1560 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1561 CHKPP(jsPointerMgr);
1562 auto func = [jsPointerMgr] (napi_env env, bool rotateSwitch, napi_value handle) -> napi_value {
1563 return jsPointerMgr->SetTouchpadRotateSwitch(env, rotateSwitch, handle);
1564 };
1565 return SetTouchpadBoolData(env, info, func);
1566 }
1567
GetTouchpadRotateSwitch(napi_env env,napi_callback_info info)1568 napi_value JsPointerContext::GetTouchpadRotateSwitch(napi_env env, napi_callback_info info)
1569 {
1570 CALL_DEBUG_ENTER;
1571 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1572 CHKPP(jsPointer);
1573 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1574 CHKPP(jsPointerMgr);
1575 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1576 return jsPointerMgr->GetTouchpadRotateSwitch(env, handle);
1577 };
1578 return GetTouchpadData(env, info, func);
1579 }
1580
SetTouchpadDoubleTapAndDragState(napi_env env,napi_callback_info info)1581 napi_value JsPointerContext::SetTouchpadDoubleTapAndDragState(napi_env env, napi_callback_info info)
1582 {
1583 CALL_DEBUG_ENTER;
1584 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1585 CHKPP(jsPointer);
1586 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1587 CHKPP(jsPointerMgr);
1588 auto func = [jsPointerMgr] (napi_env env, bool switchFlag, napi_value handle) -> napi_value {
1589 return jsPointerMgr->SetTouchpadDoubleTapAndDragState(env, switchFlag, handle);
1590 };
1591 return SetTouchpadBoolData(env, info, func);
1592 }
1593
GetTouchpadDoubleTapAndDragState(napi_env env,napi_callback_info info)1594 napi_value JsPointerContext::GetTouchpadDoubleTapAndDragState(napi_env env, napi_callback_info info)
1595 {
1596 CALL_DEBUG_ENTER;
1597 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1598 CHKPP(jsPointer);
1599 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1600 CHKPP(jsPointerMgr);
1601 auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1602 return jsPointerMgr->GetTouchpadDoubleTapAndDragState(env, handle);
1603 };
1604 return GetTouchpadData(env, info, func);
1605 }
1606
EnableHardwareCursorStats(napi_env env,napi_callback_info info)1607 napi_value JsPointerContext::EnableHardwareCursorStats(napi_env env, napi_callback_info info)
1608 {
1609 CALL_DEBUG_ENTER;
1610 size_t argc = 1;
1611 napi_value argv[1];
1612 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1613 if (argc == 0) {
1614 MMI_HILOGE("At least one parameter is required");
1615 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "enable", "boolean");
1616 return nullptr;
1617 }
1618 if (!JsCommon::TypeOf(env, argv[0], napi_boolean)) {
1619 MMI_HILOGE("Enable parameter type is invalid");
1620 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "enable", "boolean");
1621 return nullptr;
1622 }
1623 bool enable = true;
1624 CHKRP(napi_get_value_bool(env, argv[0], &enable), GET_VALUE_BOOL);
1625
1626 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1627 CHKPP(jsPointer);
1628 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1629 return jsPointerMgr->EnableHardwareCursorStats(env, enable);
1630 }
1631
GetHardwareCursorStats(napi_env env,napi_callback_info info)1632 napi_value JsPointerContext::GetHardwareCursorStats(napi_env env, napi_callback_info info)
1633 {
1634 CALL_DEBUG_ENTER;
1635 size_t argc = 1;
1636 napi_value argv[1];
1637 CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1638 JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1639 CHKPP(jsPointer);
1640 auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1641 if (argc == 0) {
1642 return jsPointerMgr->GetHardwareCursorStats(env);
1643 }
1644 return nullptr;
1645 }
1646
Export(napi_env env,napi_value exports)1647 napi_value JsPointerContext::Export(napi_env env, napi_value exports)
1648 {
1649 CALL_DEBUG_ENTER;
1650 auto instance = CreateInstance(env);
1651 if (instance == nullptr) {
1652 THROWERR(env, "failed to create instance");
1653 return nullptr;
1654 }
1655 napi_property_descriptor desc[] = {
1656 DECLARE_NAPI_STATIC_FUNCTION("setPointerVisible", SetPointerVisible),
1657 DECLARE_NAPI_STATIC_FUNCTION("setPointerVisibleSync", SetPointerVisibleSync),
1658 DECLARE_NAPI_STATIC_FUNCTION("isPointerVisible", IsPointerVisible),
1659 DECLARE_NAPI_STATIC_FUNCTION("isPointerVisibleSync", IsPointerVisibleSync),
1660 DECLARE_NAPI_STATIC_FUNCTION("setPointerColor", SetPointerColor),
1661 DECLARE_NAPI_STATIC_FUNCTION("getPointerColor", GetPointerColor),
1662 DECLARE_NAPI_STATIC_FUNCTION("setPointerColorSync", SetPointerColorSync),
1663 DECLARE_NAPI_STATIC_FUNCTION("getPointerColorSync", GetPointerColorSync),
1664 DECLARE_NAPI_STATIC_FUNCTION("setPointerSpeed", SetPointerSpeed),
1665 DECLARE_NAPI_STATIC_FUNCTION("setPointerSpeedSync", SetPointerSpeedSync),
1666 DECLARE_NAPI_STATIC_FUNCTION("getPointerSpeed", GetPointerSpeed),
1667 DECLARE_NAPI_STATIC_FUNCTION("getPointerSpeedSync", GetPointerSpeedSync),
1668 DECLARE_NAPI_STATIC_FUNCTION("setPointerStyle", SetPointerStyle),
1669 DECLARE_NAPI_STATIC_FUNCTION("setPointerStyleSync", SetPointerStyleSync),
1670 DECLARE_NAPI_STATIC_FUNCTION("getPointerStyle", GetPointerStyle),
1671 DECLARE_NAPI_STATIC_FUNCTION("getPointerStyleSync", GetPointerStyleSync),
1672 DECLARE_NAPI_STATIC_FUNCTION("enterCaptureMode", EnterCaptureMode),
1673 DECLARE_NAPI_STATIC_FUNCTION("leaveCaptureMode", LeaveCaptureMode),
1674 DECLARE_NAPI_STATIC_FUNCTION("setMouseScrollRows", SetMouseScrollRows),
1675 DECLARE_NAPI_STATIC_FUNCTION("getMouseScrollRows", GetMouseScrollRows),
1676 DECLARE_NAPI_STATIC_FUNCTION("setPointerSize", SetPointerSize),
1677 DECLARE_NAPI_STATIC_FUNCTION("getPointerSize", GetPointerSize),
1678 DECLARE_NAPI_STATIC_FUNCTION("setPointerSizeSync", SetPointerSizeSync),
1679 DECLARE_NAPI_STATIC_FUNCTION("getPointerSizeSync", GetPointerSizeSync),
1680 DECLARE_NAPI_STATIC_FUNCTION("setMousePrimaryButton", SetMousePrimaryButton),
1681 DECLARE_NAPI_STATIC_FUNCTION("getMousePrimaryButton", GetMousePrimaryButton),
1682 DECLARE_NAPI_STATIC_FUNCTION("setHoverScrollState", SetHoverScrollState),
1683 DECLARE_NAPI_STATIC_FUNCTION("getHoverScrollState", GetHoverScrollState),
1684 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadScrollSwitch", SetTouchpadScrollSwitch),
1685 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadScrollSwitch", GetTouchpadScrollSwitch),
1686 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadScrollDirection", SetTouchpadScrollDirection),
1687 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadScrollDirection", GetTouchpadScrollDirection),
1688 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadTapSwitch", SetTouchpadTapSwitch),
1689 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadTapSwitch", GetTouchpadTapSwitch),
1690 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadPointerSpeed", SetTouchpadPointerSpeed),
1691 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadPointerSpeed", GetTouchpadPointerSpeed),
1692 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadPinchSwitch", SetTouchpadPinchSwitch),
1693 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadPinchSwitch", GetTouchpadPinchSwitch),
1694 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadSwipeSwitch", SetTouchpadSwipeSwitch),
1695 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadSwipeSwitch", GetTouchpadSwipeSwitch),
1696 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadRightClickType", SetTouchpadRightClickType),
1697 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadRightClickType", GetTouchpadRightClickType),
1698 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadRotateSwitch", SetTouchpadRotateSwitch),
1699 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadRotateSwitch", GetTouchpadRotateSwitch),
1700 DECLARE_NAPI_STATIC_FUNCTION("setTouchpadDoubleTapAndDragState", SetTouchpadDoubleTapAndDragState),
1701 DECLARE_NAPI_STATIC_FUNCTION("getTouchpadDoubleTapAndDragState", GetTouchpadDoubleTapAndDragState),
1702 DECLARE_NAPI_STATIC_FUNCTION("setPointerLocation", SetPointerLocation),
1703 DECLARE_NAPI_STATIC_FUNCTION("setCustomCursor", SetCustomCursor),
1704 DECLARE_NAPI_STATIC_FUNCTION("setCustomCursorSync", SetCustomCursorSync),
1705 DECLARE_NAPI_STATIC_FUNCTION("enableHardwareCursorStats", EnableHardwareCursorStats),
1706 DECLARE_NAPI_STATIC_FUNCTION("getHardwareCursorStats", GetHardwareCursorStats),
1707 };
1708 CHKRP(napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc), DEFINE_PROPERTIES);
1709 if (CreatePointerStyle(env, exports) == nullptr) {
1710 THROWERR(env, "Failed to create pointer style");
1711 return nullptr;
1712 }
1713 if (CreateMousePrimaryButton(env, exports) == nullptr) {
1714 THROWERR(env, "Failed to create mouse primary button");
1715 return nullptr;
1716 }
1717 if (CreateTouchpadRightClickType(env, exports) == nullptr) {
1718 THROWERR(env, "Failed to create touchpad right click type");
1719 return nullptr;
1720 }
1721 return exports;
1722 }
1723
GetCursorOptions(napi_env env,napi_value obj,CursorOptions & options)1724 bool JsPointerContext::GetCursorOptions(napi_env env, napi_value obj, CursorOptions& options)
1725 {
1726 if (!JsCommon::TypeOf(env, obj, napi_object)) {
1727 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "CursorOptions", "object");
1728 return false;
1729 }
1730 napi_value followSystemValue;
1731 CHKRF(napi_get_named_property(env, obj, "followSystem", &followSystemValue), GET_NAMED_PROPERTY);
1732 if (!JsCommon::TypeOf(env, followSystemValue, napi_boolean)) {
1733 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "followSystem", "boolean");
1734 return false;
1735 }
1736 CHKRF(napi_get_value_bool(env, followSystemValue, &options.followSystem), GET_VALUE_BOOL);
1737 return true;
1738 }
1739
GetCustomCursorInfo(napi_env env,napi_value obj,CustomCursor & cursor)1740 bool JsPointerContext::GetCustomCursorInfo(napi_env env, napi_value obj, CustomCursor& cursor)
1741 {
1742 if (!JsCommon::TypeOf(env, obj, napi_object)) {
1743 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "CustomCursor", "object");
1744 return false;
1745 }
1746 napi_value pixelMapValue;
1747 CHKRF(napi_get_named_property(env, obj, "pixelMap", &pixelMapValue), GET_NAMED_PROPERTY);
1748 if (!JsCommon::TypeOf(env, pixelMapValue, napi_object)) {
1749 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "pixelMap", "object");
1750 return false;
1751 }
1752 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMapNapi::GetPixelMap(env, pixelMapValue);
1753 if (pixelMap == nullptr) {
1754 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "pixelMap is invalid");
1755 return false;
1756 }
1757 if (pixelMap->GetWidth() > MAX_PIXELMAP_SIZE || pixelMap->GetHeight() > MAX_PIXELMAP_SIZE) {
1758 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "The width or height of the pixelMap exceed 256");
1759 return false;
1760 }
1761 Parcel* pixelMapData = new Parcel();
1762 CHKPF(pixelMapData);
1763 pixelMap->Marshalling(*pixelMapData);
1764 cursor.pixelMap = pixelMapData;
1765 if (!GetFocusInfo(env, obj, "focusX", cursor.focusX, pixelMap->GetWidth())) {
1766 return false;
1767 }
1768 if (!GetFocusInfo(env, obj, "focusY", cursor.focusY, pixelMap->GetHeight())) {
1769 return false;
1770 }
1771 return true;
1772 }
1773
GetFocusInfo(napi_env env,napi_value obj,const std::string & propertyName,int32_t & focusValue,int32_t maxSize)1774 bool JsPointerContext::GetFocusInfo(napi_env env, napi_value obj, const std::string& propertyName,
1775 int32_t& focusValue, int32_t maxSize)
1776 {
1777 napi_value focusValueNapi;
1778 bool isExist = false;
1779 CHKRF(napi_has_named_property(env, obj, propertyName.c_str(), &isExist), HAS_NAMED_PROPERTY);
1780 if (!isExist) {
1781 focusValue = 0;
1782 } else if (napi_get_named_property(env, obj, propertyName.c_str(), &focusValueNapi) == napi_ok) {
1783 if (!JsCommon::TypeOf(env, focusValueNapi, napi_number)) {
1784 THROWERR_API9(env, COMMON_PARAMETER_ERROR, propertyName.c_str(), "number");
1785 return false;
1786 }
1787 CHKRF(napi_get_value_int32(env, focusValueNapi, &focusValue), GET_VALUE_INT32);
1788 if (focusValue < 0 || focusValue > maxSize) {
1789 THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, (propertyName + " is invalid").c_str());
1790 return false;
1791 }
1792 }
1793 return true;
1794 }
1795
CheckIsSetCustomCursorEx(napi_env env,size_t argc,napi_value * argv)1796 bool JsPointerContext::CheckIsSetCustomCursorEx(napi_env env, size_t argc, napi_value* argv)
1797 {
1798 bool followSystemValue = false;
1799 if (argc > INPUT_PARAMETER && JsCommon::TypeOf(env, argv[INPUT_PARAMETER], napi_object) &&
1800 napi_has_named_property(env, argv[INPUT_PARAMETER], "followSystem", &followSystemValue) == napi_ok &&
1801 followSystemValue) {
1802 return true;
1803 }
1804 return false;
1805 }
1806
SetCustomCursorEx(napi_env env,std::shared_ptr<JsPointerManager> jsPointerMgr,int32_t windowId,size_t argc,napi_value * argv)1807 napi_value JsPointerContext::SetCustomCursorEx(napi_env env, std::shared_ptr<JsPointerManager> jsPointerMgr,
1808 int32_t windowId, size_t argc, napi_value* argv)
1809 {
1810 CustomCursor cursor;
1811 CursorOptions options;
1812 if (!GetCustomCursorInfo(env, argv[1], cursor)) {
1813 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "cursor", "CustomCursor");
1814 return nullptr;
1815 }
1816 if (!GetCursorOptions(env, argv[INPUT_PARAMETER], options)) {
1817 THROWERR_API9(env, COMMON_PARAMETER_ERROR, "options", "CursorOptions");
1818 return nullptr;
1819 }
1820 return jsPointerMgr->SetCustomCursor(env, windowId, cursor, options);
1821 }
1822 } // namespace MMI
1823 } // namespace OHOS
1824