• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
18 namespace OHOS {
19 namespace MMI {
20 namespace {
21 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, MMI_LOG_DOMAIN, "JsPointerContext" };
22 constexpr int32_t STANDARD_SPEED = 5;
23 constexpr int32_t MAX_SPEED = 11;
24 constexpr int32_t MIN_SPEED = 1;
25 constexpr int32_t DEFAULT_ROWS = 3;
26 constexpr int32_t MIN_ROWS = 1;
27 constexpr int32_t MAX_ROWS = 100;
28 constexpr size_t INPUT_PARAMETER = 2;
29 constexpr int32_t DEFAULT_POINTER_SIZE = 1;
30 constexpr int32_t MIN_POINTER_SIZE = 1;
31 constexpr int32_t MAX_POINTER_SIZE = 7;
32 constexpr int32_t MIN_POINTER_COLOR = 0x000000;
33 constexpr int32_t MAX_POINTER_COLOR = 0xffffff;
34 } // namespace
35 
JsPointerContext()36 JsPointerContext::JsPointerContext() : mgr_(std::make_shared<JsPointerManager>()) {}
37 
CreateInstance(napi_env env)38 napi_value JsPointerContext::CreateInstance(napi_env env)
39 {
40     CALL_DEBUG_ENTER;
41     napi_value global = nullptr;
42     CHKRP(napi_get_global(env, &global), GET_GLOBAL);
43 
44     constexpr char className[] = "JsPointerContext";
45     napi_value jsClass = nullptr;
46     napi_property_descriptor desc[] = {};
47     napi_status status = napi_define_class(env, className, sizeof(className), JsPointerContext::CreateJsObject,
48                                            nullptr, sizeof(desc) / sizeof(desc[0]), nullptr, &jsClass);
49     CHKRP(status, DEFINE_CLASS);
50 
51     status = napi_set_named_property(env, global, "multimodalinput_pointer_class", jsClass);
52     CHKRP(status, SET_NAMED_PROPERTY);
53 
54     napi_value jsInstance = nullptr;
55     CHKRP(napi_new_instance(env, jsClass, 0, nullptr, &jsInstance), NEW_INSTANCE);
56     CHKRP(napi_set_named_property(env, global, "multimodal_pointer", jsInstance), SET_NAMED_PROPERTY);
57 
58     JsPointerContext *jsContext = nullptr;
59     CHKRP(napi_unwrap(env, jsInstance, (void**)&jsContext), UNWRAP);
60     CHKPP(jsContext);
61     CHKRP(napi_create_reference(env, jsInstance, 1, &(jsContext->contextRef_)), CREATE_REFERENCE);
62 
63     uint32_t refCount = 0;
64     CHKRP(napi_reference_ref(env, jsContext->contextRef_, &refCount), REFERENCE_REF);
65     return jsInstance;
66 }
67 
CreateJsObject(napi_env env,napi_callback_info info)68 napi_value JsPointerContext::CreateJsObject(napi_env env, napi_callback_info info)
69 {
70     CALL_DEBUG_ENTER;
71     napi_value thisVar = nullptr;
72     void *data = nullptr;
73     CHKRP(napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, &data), GET_CB_INFO);
74 
75     JsPointerContext *jsContext = new (std::nothrow) JsPointerContext();
76     CHKPP(jsContext);
77     napi_status status = napi_wrap(env, thisVar, jsContext, [](napi_env env, void* data, void* hin) {
78         MMI_HILOGI("jsvm ends");
79         JsPointerContext *context = static_cast<JsPointerContext*>(data);
80         delete context;
81     }, nullptr, nullptr);
82     if (status != napi_ok) {
83         delete jsContext;
84         THROWERR(env, "Failed to wrap native instance");
85         return nullptr;
86     }
87     return thisVar;
88 }
89 
GetInstance(napi_env env)90 JsPointerContext* JsPointerContext::GetInstance(napi_env env)
91 {
92     CALL_DEBUG_ENTER;
93     napi_value global = nullptr;
94     CHKRP(napi_get_global(env, &global), GET_GLOBAL);
95 
96     bool result = false;
97     CHKRP(napi_has_named_property(env, global, "multimodal_pointer", &result), HAS_NAMED_PROPERTY);
98     if (!result) {
99         THROWERR(env, "multimodal_pointer was not found");
100         return nullptr;
101     }
102 
103     napi_value object = nullptr;
104     CHKRP(napi_get_named_property(env, global, "multimodal_pointer", &object), SET_NAMED_PROPERTY);
105     if (object == nullptr) {
106         THROWERR(env, "object is nullptr");
107         return nullptr;
108     }
109 
110     JsPointerContext *instance = nullptr;
111     CHKRP(napi_unwrap(env, object, (void**)&instance), UNWRAP);
112     if (instance == nullptr) {
113         THROWERR(env, "instance is nullptr");
114         return nullptr;
115     }
116     return instance;
117 }
118 
GetJsPointerMgr() const119 std::shared_ptr<JsPointerManager> JsPointerContext::GetJsPointerMgr() const
120 {
121     return mgr_;
122 }
123 
SetPointerVisible(napi_env env,napi_callback_info info)124 napi_value JsPointerContext::SetPointerVisible(napi_env env, napi_callback_info info)
125 {
126     CALL_DEBUG_ENTER;
127     size_t argc = 2;
128     napi_value argv[2];
129     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
130     if (argc == 0) {
131         MMI_HILOGE("At least one parameter is required");
132         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "visible", "boolean");
133         return nullptr;
134     }
135     if (!JsCommon::TypeOf(env, argv[0], napi_boolean)) {
136         MMI_HILOGE("visible parameter type is invalid");
137         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "visible", "boolean");
138         return nullptr;
139     }
140     bool visible = true;
141     CHKRP(napi_get_value_bool(env, argv[0], &visible), GET_VALUE_BOOL);
142 
143     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
144     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
145     if (argc == 1) {
146         return jsPointerMgr->SetPointerVisible(env, visible);
147     }
148     if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
149         MMI_HILOGE("callback parameter type is invalid ");
150         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
151         return nullptr;
152     }
153     return jsPointerMgr->SetPointerVisible(env, visible, argv[1]);
154 }
155 
SetPointerVisibleSync(napi_env env,napi_callback_info info)156 napi_value JsPointerContext::SetPointerVisibleSync(napi_env env, napi_callback_info info)
157 {
158     CALL_DEBUG_ENTER;
159     size_t argc = 1;
160     napi_value argv[1];
161     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
162     if (argc == 0) {
163         MMI_HILOGE("At least one parameter is required");
164         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "visible", "boolean");
165         return nullptr;
166     }
167     if (!JsCommon::TypeOf(env, argv[0], napi_boolean)) {
168         MMI_HILOGE("visible parameter type is invalid");
169         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "visible", "boolean");
170         return nullptr;
171     }
172     bool visible = true;
173     CHKRP(napi_get_value_bool(env, argv[0], &visible), GET_VALUE_BOOL);
174 
175     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
176     CHKPP(jsPointer);
177     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
178     return jsPointerMgr->SetPointerVisibleSync(env, visible);
179 }
180 
IsPointerVisible(napi_env env,napi_callback_info info)181 napi_value JsPointerContext::IsPointerVisible(napi_env env, napi_callback_info info)
182 {
183     CALL_DEBUG_ENTER;
184     size_t argc = 1;
185     napi_value argv[1];
186     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
187 
188     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
189     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
190     if (argc == 0) {
191         return jsPointerMgr->IsPointerVisible(env);
192     }
193     if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
194         MMI_HILOGE("callback parameter type is invalid");
195         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
196         return nullptr;
197     }
198 
199     return jsPointerMgr->IsPointerVisible(env, argv[0]);
200 }
201 
IsPointerVisibleSync(napi_env env,napi_callback_info info)202 napi_value JsPointerContext::IsPointerVisibleSync(napi_env env, napi_callback_info info)
203 {
204     CALL_DEBUG_ENTER;
205     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
206     CHKPP(jsPointer);
207     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
208     return jsPointerMgr->IsPointerVisibleSync(env);
209 }
210 
SetPointerColor(napi_env env,napi_callback_info info)211 napi_value JsPointerContext::SetPointerColor(napi_env env, napi_callback_info info)
212 {
213     CALL_DEBUG_ENTER;
214     size_t argc = 2;
215     napi_value argv[2];
216     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
217     if (argc == 0) {
218         MMI_HILOGE("At least 1 parameter is required");
219         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "color", "number");
220         return nullptr;
221     }
222     if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
223         MMI_HILOGE("color parameter type is invalid");
224         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "color", "number");
225         return nullptr;
226     }
227     int32_t color = MIN_POINTER_COLOR;
228     CHKRP(napi_get_value_int32(env, argv[0], &color), GET_VALUE_INT32);
229     if (color < MIN_POINTER_COLOR) {
230         color = MIN_POINTER_COLOR;
231     } else if (color > MAX_POINTER_COLOR) {
232         color = MAX_POINTER_COLOR;
233     }
234     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
235     CHKPP(jsPointer);
236     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
237     if (argc == 1) {
238         return jsPointerMgr->SetPointerColor(env, color);
239     }
240     if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
241         MMI_HILOGE("callback parameter type is invalid");
242         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
243         return nullptr;
244     }
245     return jsPointerMgr->SetPointerColor(env, color, argv[1]);
246 }
247 
GetPointerColor(napi_env env,napi_callback_info info)248 napi_value JsPointerContext::GetPointerColor(napi_env env, napi_callback_info info)
249 {
250     CALL_DEBUG_ENTER;
251     size_t argc = 1;
252     napi_value argv[1];
253     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
254     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
255     CHKPP(jsPointer);
256     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
257     if (argc == 0) {
258         return jsPointerMgr->GetPointerColor(env);
259     }
260     if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
261         MMI_HILOGE("callback parameter type is invalid");
262         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
263         return nullptr;
264     }
265 
266     return jsPointerMgr->GetPointerColor(env, argv[0]);
267 }
268 
SetPointerColorSync(napi_env env,napi_callback_info info)269 napi_value JsPointerContext::SetPointerColorSync(napi_env env, napi_callback_info info)
270 {
271     CALL_DEBUG_ENTER;
272     size_t argc = 1;
273     napi_value argv[1];
274     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
275     if (argc == 0) {
276         MMI_HILOGE("At least 1 parameter is required");
277         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "color", "number");
278         return nullptr;
279     }
280     if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
281         MMI_HILOGE("color parameter type is invalid");
282         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "color", "number");
283         return nullptr;
284     }
285     int32_t color = MIN_POINTER_COLOR;
286     CHKRP(napi_get_value_int32(env, argv[0], &color), GET_VALUE_INT32);
287     if (color < MIN_POINTER_COLOR) {
288         color = MIN_POINTER_COLOR;
289     } else if (color > MAX_POINTER_COLOR) {
290         color = MAX_POINTER_COLOR;
291     }
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];
312     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
313     if (argc == 0) {
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     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
332     if (argc == 1) {
333         return jsPointerMgr->SetPointerSpeed(env, pointerSpeed);
334     }
335     if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
336         MMI_HILOGE("callback parameter type is invalid");
337         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
338         return nullptr;
339     }
340     return jsPointerMgr->SetPointerSpeed(env, pointerSpeed, argv[1]);
341 }
342 
SetPointerSpeedSync(napi_env env,napi_callback_info info)343 napi_value JsPointerContext::SetPointerSpeedSync(napi_env env, napi_callback_info info)
344 {
345     CALL_DEBUG_ENTER;
346     size_t argc = 1;
347     napi_value argv[1];
348     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
349     if (argc == 0) {
350         MMI_HILOGE("At least 1 parameter is required");
351         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "speed", "number");
352         return nullptr;
353     }
354     if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
355         MMI_HILOGE("speed parameter type is invalid");
356         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "speed", "number");
357         return nullptr;
358     }
359     int32_t pointerSpeed = STANDARD_SPEED;
360     CHKRP(napi_get_value_int32(env, argv[0], &pointerSpeed), GET_VALUE_INT32);
361     if (pointerSpeed < MIN_SPEED) {
362         pointerSpeed = MIN_SPEED;
363     } else if (pointerSpeed > MAX_SPEED) {
364         pointerSpeed = MAX_SPEED;
365     }
366     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
367     CHKPP(jsPointer);
368     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
369     return jsPointerMgr->SetPointerSpeedSync(env, pointerSpeed);
370 }
371 
GetPointerSpeed(napi_env env,napi_callback_info info)372 napi_value JsPointerContext::GetPointerSpeed(napi_env env, napi_callback_info info)
373 {
374     CALL_DEBUG_ENTER;
375     size_t argc = 1;
376     napi_value argv[1];
377     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
378     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
379     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
380     if (argc == 0) {
381         return jsPointerMgr->GetPointerSpeed(env);
382     }
383     if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
384         MMI_HILOGE("callback parameter type is invalid");
385         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
386         return nullptr;
387     }
388 
389     return jsPointerMgr->GetPointerSpeed(env, argv[0]);
390 }
391 
GetPointerSpeedSync(napi_env env,napi_callback_info info)392 napi_value JsPointerContext::GetPointerSpeedSync(napi_env env, napi_callback_info info)
393 {
394     CALL_DEBUG_ENTER;
395     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
396     CHKPP(jsPointer);
397     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
398     return jsPointerMgr->GetPointerSpeedSync(env);
399 }
400 
SetMouseScrollRows(napi_env env,napi_callback_info info)401 napi_value JsPointerContext::SetMouseScrollRows(napi_env env, napi_callback_info info)
402 {
403     CALL_DEBUG_ENTER;
404     size_t argc = 2;
405     napi_value argv[2];
406     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
407     if (argc == 0) {
408         MMI_HILOGE("At least 1 parameter is required");
409         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "rows", "number");
410         return nullptr;
411     }
412     if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
413         MMI_HILOGE("rows parameter type is invalid");
414         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "rows", "number");
415         return nullptr;
416     }
417     int32_t rows = DEFAULT_ROWS;
418     CHKRP(napi_get_value_int32(env, argv[0], &rows), GET_VALUE_INT32);
419     if (rows < MIN_ROWS) {
420         rows = MIN_ROWS;
421     } else if (rows > MAX_ROWS) {
422         rows = MAX_ROWS;
423     }
424     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
425     CHKPP(jsPointer);
426     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
427     if (argc == 1) {
428         return jsPointerMgr->SetMouseScrollRows(env, rows);
429     }
430     if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
431         MMI_HILOGE("callback parameter type is invalid");
432         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
433         return nullptr;
434     }
435     return jsPointerMgr->SetMouseScrollRows(env, rows, argv[1]);
436 }
437 
GetMouseScrollRows(napi_env env,napi_callback_info info)438 napi_value JsPointerContext::GetMouseScrollRows(napi_env env, napi_callback_info info)
439 {
440     CALL_DEBUG_ENTER;
441     size_t argc = 1;
442     napi_value argv[1];
443     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
444     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
445     CHKPP(jsPointer);
446     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
447     if (argc == 0) {
448         return jsPointerMgr->GetMouseScrollRows(env);
449     }
450     if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
451         MMI_HILOGE("callback parameter type is invalid");
452         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
453         return nullptr;
454     }
455 
456     return jsPointerMgr->GetMouseScrollRows(env, argv[0]);
457 }
458 
SetPointerSize(napi_env env,napi_callback_info info)459 napi_value JsPointerContext::SetPointerSize(napi_env env, napi_callback_info info)
460 {
461     CALL_DEBUG_ENTER;
462     size_t argc = 2;
463     napi_value argv[2];
464     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
465     if (argc == 0) {
466         MMI_HILOGE("At least 1 parameter is required");
467         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "size", "number");
468         return nullptr;
469     }
470     if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
471         MMI_HILOGE("size parameter type is invalid");
472         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "size", "number");
473         return nullptr;
474     }
475     int32_t size = DEFAULT_POINTER_SIZE;
476     CHKRP(napi_get_value_int32(env, argv[0], &size), GET_VALUE_INT32);
477     if (size < MIN_POINTER_SIZE) {
478         size = MIN_POINTER_SIZE;
479     } else if (size > MAX_POINTER_SIZE) {
480         size = MAX_POINTER_SIZE;
481     }
482     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
483     CHKPP(jsPointer);
484     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
485     if (argc == 1) {
486         return jsPointerMgr->SetPointerSize(env, size);
487     }
488     if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
489         MMI_HILOGE("callback parameter type is invalid");
490         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
491         return nullptr;
492     }
493     return jsPointerMgr->SetPointerSize(env, size, argv[1]);
494 }
495 
GetPointerSize(napi_env env,napi_callback_info info)496 napi_value JsPointerContext::GetPointerSize(napi_env env, napi_callback_info info)
497 {
498     CALL_DEBUG_ENTER;
499     size_t argc = 1;
500     napi_value argv[1];
501     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
502     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
503     CHKPP(jsPointer);
504     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
505     if (argc == 0) {
506         return jsPointerMgr->GetPointerSize(env);
507     }
508     if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
509         MMI_HILOGE("callback parameter type is invalid");
510         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
511         return nullptr;
512     }
513 
514     return jsPointerMgr->GetPointerSize(env, argv[0]);
515 }
516 
SetPointerSizeSync(napi_env env,napi_callback_info info)517 napi_value JsPointerContext::SetPointerSizeSync(napi_env env, napi_callback_info info)
518 {
519     CALL_DEBUG_ENTER;
520     size_t argc = 1;
521     napi_value argv[1];
522     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
523     if (argc == 0) {
524         MMI_HILOGE("At least 1 parameter is required");
525         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "size", "number");
526         return nullptr;
527     }
528     if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
529         MMI_HILOGE("size parameter type is invalid");
530         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "size", "number");
531         return nullptr;
532     }
533     int32_t size = DEFAULT_POINTER_SIZE;
534     CHKRP(napi_get_value_int32(env, argv[0], &size), GET_VALUE_INT32);
535     if (size < MIN_POINTER_SIZE) {
536         size = MIN_POINTER_SIZE;
537     } else if (size > MAX_POINTER_SIZE) {
538         size = MAX_POINTER_SIZE;
539     }
540     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
541     CHKPP(jsPointer);
542     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
543     return jsPointerMgr->SetPointerSizeSync(env, size);
544 }
545 
GetPointerSizeSync(napi_env env,napi_callback_info info)546 napi_value JsPointerContext::GetPointerSizeSync(napi_env env, napi_callback_info info)
547 {
548     CALL_DEBUG_ENTER;
549     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
550     CHKPP(jsPointer);
551     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
552     return jsPointerMgr->GetPointerSizeSync(env);
553 }
554 
SetPointerStyle(napi_env env,napi_callback_info info)555 napi_value JsPointerContext::SetPointerStyle(napi_env env, napi_callback_info info)
556 {
557     CALL_DEBUG_ENTER;
558     size_t argc = 3;
559     napi_value argv[3];
560     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
561     if (argc < INPUT_PARAMETER) {
562         MMI_HILOGE("At least 2 parameter is required");
563         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
564         return nullptr;
565     }
566     if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
567         MMI_HILOGE("windowId parameter type is invalid");
568         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
569         return nullptr;
570     }
571     int32_t windowid = 0;
572     CHKRP(napi_get_value_int32(env, argv[0], &windowid), GET_VALUE_INT32);
573     if (windowid < 0 && windowid != GLOBAL_WINDOW_ID) {
574         MMI_HILOGE("Invalid windowid");
575         THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Windowid is invalid");
576         return nullptr;
577     }
578     if (!JsCommon::TypeOf(env, argv[1], napi_number)) {
579         MMI_HILOGE("pointerStyle parameter type is invalid");
580         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "pointerStyle", "number");
581         return nullptr;
582     }
583     int32_t pointerStyle = 0;
584     CHKRP(napi_get_value_int32(env, argv[1], &pointerStyle), GET_VALUE_INT32);
585     if (pointerStyle < DEFAULT || pointerStyle > RUNNING) {
586         MMI_HILOGE("Undefined pointer style");
587         THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Pointer style does not exist");
588         return nullptr;
589     }
590     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
591     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
592     if (argc == INPUT_PARAMETER) {
593         return jsPointerMgr->SetPointerStyle(env, windowid, pointerStyle);
594     }
595     if (!JsCommon::TypeOf(env, argv[INPUT_PARAMETER], napi_function)) {
596         MMI_HILOGE("callback parameter type is invalid");
597         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
598         return nullptr;
599     }
600     return jsPointerMgr->SetPointerStyle(env, windowid, pointerStyle, argv[INPUT_PARAMETER]);
601 }
602 
SetPointerStyleSync(napi_env env,napi_callback_info info)603 napi_value JsPointerContext::SetPointerStyleSync(napi_env env, napi_callback_info info)
604 {
605     CALL_DEBUG_ENTER;
606     size_t argc = 2;
607     napi_value argv[2];
608     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
609     if (argc < INPUT_PARAMETER) {
610         MMI_HILOGE("At least 2 parameter is required");
611         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
612         return nullptr;
613     }
614     if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
615         MMI_HILOGE("windowId parameter type is invalid");
616         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
617         return nullptr;
618     }
619     int32_t windowid = 0;
620     CHKRP(napi_get_value_int32(env, argv[0], &windowid), GET_VALUE_INT32);
621     if (windowid < 0 && windowid != GLOBAL_WINDOW_ID) {
622         MMI_HILOGE("Invalid windowid");
623         THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Windowid is invalid");
624         return nullptr;
625     }
626     if (!JsCommon::TypeOf(env, argv[1], napi_number)) {
627         MMI_HILOGE("pointerStyle parameter type is invalid");
628         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "pointerStyle", "number");
629         return nullptr;
630     }
631     int32_t pointerStyle = 0;
632     CHKRP(napi_get_value_int32(env, argv[1], &pointerStyle), GET_VALUE_INT32);
633     if (pointerStyle < DEFAULT || pointerStyle > RUNNING) {
634         MMI_HILOGE("Undefined pointer style");
635         THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Pointer style does not exist");
636         return nullptr;
637     }
638     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
639     CHKPP(jsPointer);
640     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
641     return jsPointerMgr->SetPointerStyleSync(env, windowid, pointerStyle);
642 }
643 
GetPointerStyle(napi_env env,napi_callback_info info)644 napi_value JsPointerContext::GetPointerStyle(napi_env env, napi_callback_info info)
645 {
646     CALL_DEBUG_ENTER;
647     size_t argc = 2;
648     napi_value argv[2];
649     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
650     if (argc == 0) {
651         MMI_HILOGE("At least 1 parameter is required");
652         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
653         return nullptr;
654     }
655     if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
656         MMI_HILOGE("windowId parameter type is invalid");
657         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
658         return nullptr;
659     }
660     int32_t windowid = 0;
661     CHKRP(napi_get_value_int32(env, argv[0], &windowid), GET_VALUE_INT32);
662     if (windowid < 0 && windowid != GLOBAL_WINDOW_ID) {
663         MMI_HILOGE("Invalid windowid");
664         THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Windowid is invalid");
665         return nullptr;
666     }
667     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
668     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
669     if (argc == 1) {
670         return jsPointerMgr->GetPointerStyle(env, windowid);
671     }
672     if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
673         MMI_HILOGE("callback parameter type is invalid");
674         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
675         return nullptr;
676     }
677     return jsPointerMgr->GetPointerStyle(env, windowid, argv[1]);
678 }
679 
GetPointerStyleSync(napi_env env,napi_callback_info info)680 napi_value JsPointerContext::GetPointerStyleSync(napi_env env, napi_callback_info info)
681 {
682     CALL_DEBUG_ENTER;
683     size_t argc = 1;
684     napi_value argv[1];
685     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
686     if (argc == 0) {
687         MMI_HILOGE("At least 1 parameter is required");
688         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
689         return nullptr;
690     }
691     if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
692         MMI_HILOGE("windowId parameter type is invalid");
693         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "windowId", "number");
694         return nullptr;
695     }
696     int32_t windowId = 0;
697     CHKRP(napi_get_value_int32(env, argv[0], &windowId), GET_VALUE_INT32);
698     if (windowId < 0 && windowId != GLOBAL_WINDOW_ID) {
699         MMI_HILOGE("Invalid windowId");
700         THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "WindowId is invalid");
701         return nullptr;
702     }
703     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
704     CHKPP(jsPointer);
705     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
706     return jsPointerMgr->GetPointerStyleSync(env, windowId);
707 }
708 
CreatePointerStyle(napi_env env,napi_value exports)709 napi_value JsPointerContext::CreatePointerStyle(napi_env env, napi_value exports)
710 {
711     CALL_DEBUG_ENTER;
712     napi_value defaults = nullptr;
713     CHKRP(napi_create_int32(env, MOUSE_ICON::DEFAULT, &defaults), CREATE_INT32);
714     napi_value east = nullptr;
715     CHKRP(napi_create_int32(env, MOUSE_ICON::EAST, &east), CREATE_INT32);
716     napi_value west = nullptr;
717     CHKRP(napi_create_int32(env, MOUSE_ICON::WEST, &west), CREATE_INT32);
718     napi_value south = nullptr;
719     CHKRP(napi_create_int32(env, MOUSE_ICON::SOUTH, &south), CREATE_INT32);
720     napi_value north = nullptr;
721     CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH, &north), CREATE_INT32);
722     napi_value west_east = nullptr;
723     CHKRP(napi_create_int32(env, MOUSE_ICON::WEST_EAST, &west_east), CREATE_INT32);
724     napi_value north_south = nullptr;
725     CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH_SOUTH, &north_south), CREATE_INT32);
726     napi_value north_east = nullptr;
727     CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH_EAST, &north_east), CREATE_INT32);
728     napi_value north_west = nullptr;
729     CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH_WEST, &north_west), CREATE_INT32);
730     napi_value south_east = nullptr;
731     CHKRP(napi_create_int32(env, MOUSE_ICON::SOUTH_EAST, &south_east), CREATE_INT32);
732     napi_value south_west = nullptr;
733     CHKRP(napi_create_int32(env, MOUSE_ICON::SOUTH_WEST, &south_west), CREATE_INT32);
734     napi_value north_east_south_west = nullptr;
735     CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH_EAST_SOUTH_WEST, &north_east_south_west), CREATE_INT32);
736     napi_value north_west_south_east = nullptr;
737     CHKRP(napi_create_int32(env, MOUSE_ICON::NORTH_WEST_SOUTH_EAST, &north_west_south_east), CREATE_INT32);
738     napi_value cross = nullptr;
739     CHKRP(napi_create_int32(env, MOUSE_ICON::CROSS, &cross), CREATE_INT32);
740     napi_value cursor_copy = nullptr;
741     CHKRP(napi_create_int32(env, MOUSE_ICON::CURSOR_COPY, &cursor_copy), CREATE_INT32);
742     napi_value cursor_forbid = nullptr;
743     CHKRP(napi_create_int32(env, MOUSE_ICON::CURSOR_FORBID, &cursor_forbid), CREATE_INT32);
744     napi_value color_sucker = nullptr;
745     CHKRP(napi_create_int32(env, MOUSE_ICON::COLOR_SUCKER, &color_sucker), CREATE_INT32);
746     napi_value hand_grabbing = nullptr;
747     CHKRP(napi_create_int32(env, MOUSE_ICON::HAND_GRABBING, &hand_grabbing), CREATE_INT32);
748     napi_value hand_open = nullptr;
749     CHKRP(napi_create_int32(env, MOUSE_ICON::HAND_OPEN, &hand_open), CREATE_INT32);
750     napi_value hand_pointing = nullptr;
751     CHKRP(napi_create_int32(env, MOUSE_ICON::HAND_POINTING, &hand_pointing), CREATE_INT32);
752     napi_value help = nullptr;
753     CHKRP(napi_create_int32(env, MOUSE_ICON::HELP, &help), CREATE_INT32);
754     napi_value move = nullptr;
755     CHKRP(napi_create_int32(env, MOUSE_ICON::CURSOR_MOVE, &move), CREATE_INT32);
756     napi_value resize_left_right = nullptr;
757     CHKRP(napi_create_int32(env, MOUSE_ICON::RESIZE_LEFT_RIGHT, &resize_left_right), CREATE_INT32);
758     napi_value resize_up_down = nullptr;
759     CHKRP(napi_create_int32(env, MOUSE_ICON::RESIZE_UP_DOWN, &resize_up_down), CREATE_INT32);
760     napi_value screenshot_choose = nullptr;
761     CHKRP(napi_create_int32(env, MOUSE_ICON::SCREENSHOT_CHOOSE, &screenshot_choose), CREATE_INT32);
762     napi_value screenshot_cursor = nullptr;
763     CHKRP(napi_create_int32(env, MOUSE_ICON::SCREENSHOT_CURSOR, &screenshot_cursor), CREATE_INT32);
764     napi_value text_cursor = nullptr;
765     CHKRP(napi_create_int32(env, MOUSE_ICON::TEXT_CURSOR, &text_cursor), CREATE_INT32);
766     napi_value zoom_in = nullptr;
767     CHKRP(napi_create_int32(env, MOUSE_ICON::ZOOM_IN, &zoom_in), CREATE_INT32);
768     napi_value zoom_out = nullptr;
769     CHKRP(napi_create_int32(env, MOUSE_ICON::ZOOM_OUT, &zoom_out), CREATE_INT32);
770     napi_value middle_btn_east = nullptr;
771     CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_EAST, &middle_btn_east), CREATE_INT32);
772     napi_value middle_btn_west = nullptr;
773     CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_WEST, &middle_btn_west), CREATE_INT32);
774     napi_value middle_btn_south = nullptr;
775     CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_SOUTH, &middle_btn_south), CREATE_INT32);
776     napi_value middle_btn_north = nullptr;
777     CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_NORTH, &middle_btn_north), CREATE_INT32);
778     napi_value middle_btn_north_south = nullptr;
779     CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_NORTH_SOUTH, &middle_btn_north_south), CREATE_INT32);
780     napi_value middle_btn_north_east = nullptr;
781     CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_NORTH_EAST, &middle_btn_north_east), CREATE_INT32);
782     napi_value middle_btn_north_west = nullptr;
783     CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_NORTH_WEST, &middle_btn_north_west), CREATE_INT32);
784     napi_value middle_btn_south_east = nullptr;
785     CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_SOUTH_EAST, &middle_btn_south_east), CREATE_INT32);
786     napi_value middle_btn_south_west = nullptr;
787     CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_SOUTH_WEST, &middle_btn_south_west), CREATE_INT32);
788     napi_value middle_btn_north_south_west_east = nullptr;
789     CHKRP(napi_create_int32(env, MOUSE_ICON::MIDDLE_BTN_NORTH_SOUTH_WEST_EAST,
790         &middle_btn_north_south_west_east), CREATE_INT32);
791     napi_value horizontal_text_cursor = nullptr;
792     CHKRP(napi_create_int32(env, MOUSE_ICON::HORIZONTAL_TEXT_CURSOR, &horizontal_text_cursor), CREATE_INT32);
793     napi_value cursor_cross = nullptr;
794     CHKRP(napi_create_int32(env, MOUSE_ICON::CURSOR_CROSS, &cursor_cross), CREATE_INT32);
795     napi_value cursor_circle = nullptr;
796     CHKRP(napi_create_int32(env, MOUSE_ICON::CURSOR_CIRCLE, &cursor_circle), CREATE_INT32);
797     napi_value loading = nullptr;
798     CHKRP(napi_create_int32(env, MOUSE_ICON::LOADING, &loading), CREATE_INT32);
799     napi_value running = nullptr;
800     CHKRP(napi_create_int32(env, MOUSE_ICON::RUNNING, &running), CREATE_INT32);
801 
802     napi_property_descriptor desc[] = {
803         DECLARE_NAPI_STATIC_PROPERTY("DEFAULT", defaults),
804         DECLARE_NAPI_STATIC_PROPERTY("EAST", east),
805         DECLARE_NAPI_STATIC_PROPERTY("WEST", west),
806         DECLARE_NAPI_STATIC_PROPERTY("SOUTH", south),
807         DECLARE_NAPI_STATIC_PROPERTY("NORTH", north),
808         DECLARE_NAPI_STATIC_PROPERTY("WEST_EAST", west_east),
809         DECLARE_NAPI_STATIC_PROPERTY("NORTH_SOUTH", north_south),
810         DECLARE_NAPI_STATIC_PROPERTY("NORTH_EAST", north_east),
811         DECLARE_NAPI_STATIC_PROPERTY("NORTH_WEST", north_west),
812         DECLARE_NAPI_STATIC_PROPERTY("SOUTH_EAST", south_east),
813         DECLARE_NAPI_STATIC_PROPERTY("SOUTH_WEST", south_west),
814         DECLARE_NAPI_STATIC_PROPERTY("NORTH_EAST_SOUTH_WEST", north_east_south_west),
815         DECLARE_NAPI_STATIC_PROPERTY("NORTH_WEST_SOUTH_EAST", north_west_south_east),
816         DECLARE_NAPI_STATIC_PROPERTY("CROSS", cross),
817         DECLARE_NAPI_STATIC_PROPERTY("CURSOR_COPY", cursor_copy),
818         DECLARE_NAPI_STATIC_PROPERTY("CURSOR_FORBID", cursor_forbid),
819         DECLARE_NAPI_STATIC_PROPERTY("COLOR_SUCKER", color_sucker),
820         DECLARE_NAPI_STATIC_PROPERTY("HAND_GRABBING", hand_grabbing),
821         DECLARE_NAPI_STATIC_PROPERTY("HAND_OPEN", hand_open),
822         DECLARE_NAPI_STATIC_PROPERTY("HAND_POINTING", hand_pointing),
823         DECLARE_NAPI_STATIC_PROPERTY("HELP", help),
824         DECLARE_NAPI_STATIC_PROPERTY("MOVE", move),
825         DECLARE_NAPI_STATIC_PROPERTY("RESIZE_LEFT_RIGHT", resize_left_right),
826         DECLARE_NAPI_STATIC_PROPERTY("RESIZE_UP_DOWN", resize_up_down),
827         DECLARE_NAPI_STATIC_PROPERTY("SCREENSHOT_CHOOSE", screenshot_choose),
828         DECLARE_NAPI_STATIC_PROPERTY("SCREENSHOT_CURSOR", screenshot_cursor),
829         DECLARE_NAPI_STATIC_PROPERTY("TEXT_CURSOR", text_cursor),
830         DECLARE_NAPI_STATIC_PROPERTY("ZOOM_IN", zoom_in),
831         DECLARE_NAPI_STATIC_PROPERTY("ZOOM_OUT", zoom_out),
832         DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_EAST", middle_btn_east),
833         DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_WEST", middle_btn_west),
834         DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_SOUTH", middle_btn_south),
835         DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_NORTH", middle_btn_north),
836         DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_NORTH_SOUTH", middle_btn_north_south),
837         DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_NORTH_EAST", middle_btn_north_east),
838         DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_NORTH_WEST", middle_btn_north_west),
839         DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_SOUTH_EAST", middle_btn_south_east),
840         DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_SOUTH_WEST", middle_btn_south_west),
841         DECLARE_NAPI_STATIC_PROPERTY("MIDDLE_BTN_NORTH_SOUTH_WEST_EAST", middle_btn_north_south_west_east),
842         DECLARE_NAPI_STATIC_PROPERTY("HORIZONTAL_TEXT_CURSOR", horizontal_text_cursor),
843         DECLARE_NAPI_STATIC_PROPERTY("CURSOR_CROSS", cursor_cross),
844         DECLARE_NAPI_STATIC_PROPERTY("CURSOR_CIRCLE", cursor_circle),
845         DECLARE_NAPI_STATIC_PROPERTY("LOADING", loading),
846         DECLARE_NAPI_STATIC_PROPERTY("RUNNING", running),
847     };
848     napi_value result = nullptr;
849     CHKRP(napi_define_class(env, "PointerStyle", NAPI_AUTO_LENGTH, EnumConstructor, nullptr,
850         sizeof(desc) / sizeof(*desc), desc, &result), DEFINE_CLASS);
851     CHKRP(napi_set_named_property(env, exports, "PointerStyle", result), SET_NAMED_PROPERTY);
852     return exports;
853 }
854 
CreateTouchpadRightClickType(napi_env env,napi_value exports)855 napi_value JsPointerContext::CreateTouchpadRightClickType(napi_env env, napi_value exports)
856 {
857     CALL_DEBUG_ENTER;
858     napi_value touchpad_right_button = nullptr;
859     CHKRP(napi_create_int32(env, RightClickType::TOUCHPAD_RIGHT_BUTTON, &touchpad_right_button), CREATE_INT32);
860     napi_value touchpad_left_button = nullptr;
861     CHKRP(napi_create_int32(env, RightClickType::TOUCHPAD_LEFT_BUTTON, &touchpad_left_button), CREATE_INT32);
862     napi_value touchpad_two_finger_tap = nullptr;
863     CHKRP(napi_create_int32(env, RightClickType::TOUCHPAD_TWO_FINGER_TAP, &touchpad_two_finger_tap), CREATE_INT32);
864 
865     napi_property_descriptor desc[] = {
866         DECLARE_NAPI_STATIC_PROPERTY("TOUCHPAD_RIGHT_BUTTON", touchpad_right_button),
867         DECLARE_NAPI_STATIC_PROPERTY("TOUCHPAD_LEFT_BUTTON", touchpad_left_button),
868         DECLARE_NAPI_STATIC_PROPERTY("TOUCHPAD_TWO_FINGER_TAP", touchpad_two_finger_tap),
869     };
870     napi_value result = nullptr;
871     CHKRP(napi_define_class(env, "RightClickType", NAPI_AUTO_LENGTH, EnumConstructor, nullptr,
872         sizeof(desc) / sizeof(*desc), desc, &result), DEFINE_CLASS);
873     CHKRP(napi_set_named_property(env, exports, "RightClickType", result), SET_NAMED_PROPERTY);
874     return exports;
875 }
876 
EnumConstructor(napi_env env,napi_callback_info info)877 napi_value JsPointerContext::EnumConstructor(napi_env env, napi_callback_info info)
878 {
879     CALL_DEBUG_ENTER;
880     size_t argc = 0;
881     napi_value args[1] = { 0 };
882     napi_value ret = nullptr;
883     void *data = nullptr;
884     CHKRP(napi_get_cb_info(env, info, &argc, args, &ret, &data), GET_CB_INFO);
885     return ret;
886 }
887 
EnterCaptureMode(napi_env env,napi_callback_info info)888 napi_value JsPointerContext::EnterCaptureMode(napi_env env, napi_callback_info info)
889 {
890     CALL_DEBUG_ENTER;
891     size_t argc = 2;
892     napi_value argv[2];
893     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
894     if (argc < 1 || argc > INPUT_PARAMETER) {
895         THROWERR(env, "The number of parameters is not as expected");
896         return nullptr;
897     }
898     if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
899         THROWERR(env, "The first parameter type is invalid");
900         return nullptr;
901     }
902 
903     int32_t windowId = 0;
904     CHKRP(napi_get_value_int32(env, argv[0], &windowId), GET_VALUE_INT32);
905     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
906     CHKPP(jsPointer);
907     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
908     if (argc == 1) {
909         return jsPointerMgr->EnterCaptureMode(env, windowId);
910     }
911     if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
912         THROWERR(env, "The second parameter type is invalid");
913         return nullptr;
914     }
915     return jsPointerMgr->EnterCaptureMode(env, windowId, argv[1]);
916 }
917 
LeaveCaptureMode(napi_env env,napi_callback_info info)918 napi_value JsPointerContext::LeaveCaptureMode(napi_env env, napi_callback_info info)
919 {
920     CALL_DEBUG_ENTER;
921     size_t argc = 2;
922     napi_value argv[2];
923     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
924     if (argc < 1 || argc > INPUT_PARAMETER) {
925         THROWERR(env, "The number of parameters is not as expected");
926         return nullptr;
927     }
928     if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
929         THROWERR(env, "The first parameter type is invalid");
930         return nullptr;
931     }
932 
933     int32_t windowId = 0;
934     CHKRP(napi_get_value_int32(env, argv[0], &windowId), GET_VALUE_INT32);
935 
936     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
937     CHKPP(jsPointer);
938     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
939     if (argc == 1) {
940         return jsPointerMgr->LeaveCaptureMode(env, windowId);
941     }
942     if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
943         THROWERR(env, "The second parameter type is invalid");
944         return nullptr;
945     }
946     return jsPointerMgr->LeaveCaptureMode(env, windowId, argv[1]);
947 }
948 
CreateMousePrimaryButton(napi_env env,napi_value exports)949 napi_value JsPointerContext::CreateMousePrimaryButton(napi_env env, napi_value exports)
950 {
951     CALL_DEBUG_ENTER;
952     napi_value leftButton = nullptr;
953     CHKRP(napi_create_int32(env, PrimaryButton::LEFT_BUTTON, &leftButton), CREATE_INT32);
954     napi_value rightButton = nullptr;
955     CHKRP(napi_create_int32(env, PrimaryButton::RIGHT_BUTTON, &rightButton), CREATE_INT32);
956 
957     napi_property_descriptor desc[] = {
958         DECLARE_NAPI_STATIC_PROPERTY("LEFT", leftButton),
959         DECLARE_NAPI_STATIC_PROPERTY("RIGHT", rightButton),
960     };
961     napi_value result = nullptr;
962     CHKRP(napi_define_class(env, "PrimaryButton", NAPI_AUTO_LENGTH, EnumConstructor, nullptr,
963         sizeof(desc) / sizeof(*desc), desc, &result), DEFINE_CLASS);
964     CHKRP(napi_set_named_property(env, exports, "PrimaryButton", result), SET_NAMED_PROPERTY);
965     return exports;
966 }
967 
SetMousePrimaryButton(napi_env env,napi_callback_info info)968 napi_value JsPointerContext::SetMousePrimaryButton(napi_env env, napi_callback_info info)
969 {
970     CALL_DEBUG_ENTER;
971     size_t argc = 2;
972     napi_value argv[2];
973     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
974     if (argc == 0) {
975         MMI_HILOGE("At least one parameter is required");
976         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "primaryButton", "number");
977         return nullptr;
978     }
979     if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
980         MMI_HILOGE("primaryButton parameter type is invalid");
981         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "primaryButton", "number");
982         return nullptr;
983     }
984     int32_t primaryButton = 0;
985     CHKRP(napi_get_value_int32(env, argv[0], &primaryButton), GET_VALUE_INT32);
986     if (primaryButton < LEFT_BUTTON || primaryButton > RIGHT_BUTTON) {
987         MMI_HILOGE("Undefined mouse primary button");
988         THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Mouse primary button does not exist");
989         return nullptr;
990     }
991     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
992     CHKPP(jsPointer);
993     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
994     if (argc == 1) {
995         return jsPointerMgr->SetMousePrimaryButton(env, primaryButton);
996     }
997     if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
998         MMI_HILOGE("callback parameter type is invalid ");
999         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1000         return nullptr;
1001     }
1002     return jsPointerMgr->SetMousePrimaryButton(env, primaryButton, argv[1]);
1003 }
1004 
GetMousePrimaryButton(napi_env env,napi_callback_info info)1005 napi_value JsPointerContext::GetMousePrimaryButton(napi_env env, napi_callback_info info)
1006 {
1007     CALL_DEBUG_ENTER;
1008     size_t argc = 1;
1009     napi_value argv[1];
1010     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1011     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1012     CHKPP(jsPointer);
1013     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1014     if (argc == 0) {
1015         return jsPointerMgr->GetMousePrimaryButton(env);
1016     }
1017     if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
1018         MMI_HILOGE("callback parameter type is invalid");
1019         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1020         return nullptr;
1021     }
1022     return jsPointerMgr->GetMousePrimaryButton(env, argv[0]);
1023 }
1024 
SetHoverScrollState(napi_env env,napi_callback_info info)1025 napi_value JsPointerContext::SetHoverScrollState(napi_env env, napi_callback_info info)
1026 {
1027     CALL_DEBUG_ENTER;
1028     size_t argc = 2;
1029     napi_value argv[2];
1030     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1031     if (argc == 0) {
1032         MMI_HILOGE("At least one parameter is required");
1033         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "state", "boolean");
1034         return nullptr;
1035     }
1036     if (!JsCommon::TypeOf(env, argv[0], napi_boolean)) {
1037         MMI_HILOGE("state parameter type is invalid");
1038         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "state", "boolean");
1039         return nullptr;
1040     }
1041     bool state = true;
1042     CHKRP(napi_get_value_bool(env, argv[0], &state), GET_VALUE_BOOL);
1043 
1044     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1045     CHKPP(jsPointer);
1046     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1047     if (argc == 1) {
1048         return jsPointerMgr->SetHoverScrollState(env, state);
1049     }
1050     if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1051         MMI_HILOGE("callback parameter type is invalid");
1052         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1053         return nullptr;
1054     }
1055     return jsPointerMgr->SetHoverScrollState(env, state, argv[1]);
1056 }
1057 
GetHoverScrollState(napi_env env,napi_callback_info info)1058 napi_value JsPointerContext::GetHoverScrollState(napi_env env, napi_callback_info info)
1059 {
1060     CALL_DEBUG_ENTER;
1061     size_t argc = 1;
1062     napi_value argv[1];
1063     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1064 
1065     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1066     CHKPP(jsPointer);
1067     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1068     if (argc == 0) {
1069         return jsPointerMgr->GetHoverScrollState(env);
1070     }
1071     if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
1072         MMI_HILOGE("callback parameter type is invalid");
1073         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1074         return nullptr;
1075     }
1076     return jsPointerMgr->GetHoverScrollState(env, argv[0]);
1077 }
1078 
SetTouchpadBoolData(napi_env env,napi_callback_info info,SetTouchpadBoolDataFunc func)1079 napi_value JsPointerContext::SetTouchpadBoolData(napi_env env, napi_callback_info info, SetTouchpadBoolDataFunc func)
1080 {
1081     CALL_DEBUG_ENTER;
1082     size_t argc = 2;
1083     napi_value argv[2];
1084     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1085     if (argc == 0) {
1086         MMI_HILOGE("At least one parameter is required");
1087         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "switchFlag", "boolean");
1088         return nullptr;
1089     }
1090     if (!JsCommon::TypeOf(env, argv[0], napi_boolean)) {
1091         MMI_HILOGE("Bool data parameter type is invalid");
1092         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "switchFlag", "boolean");
1093         return nullptr;
1094     }
1095     bool switchFlag = true;
1096     CHKRP(napi_get_value_bool(env, argv[0], &switchFlag), GET_VALUE_BOOL);
1097 
1098     if (argc == 1) {
1099         return func(env, switchFlag, nullptr);
1100     }
1101     if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1102         MMI_HILOGE("Callback parameter type is invalid ");
1103         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1104         return nullptr;
1105     }
1106     return func(env, switchFlag, argv[1]);
1107 }
1108 
SetTouchpadInt32Data(napi_env env,napi_callback_info info,SetTouchpadInt32DataFunc func,int32_t dataMax,int32_t dataMin)1109 napi_value JsPointerContext::SetTouchpadInt32Data(napi_env env, napi_callback_info info, SetTouchpadInt32DataFunc func,
1110     int32_t dataMax, int32_t dataMin)
1111 {
1112     CALL_DEBUG_ENTER;
1113     size_t argc = 2;
1114     napi_value argv[2];
1115     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1116     if (argc == 0) {
1117         MMI_HILOGE("At least 1 parameter is required");
1118         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "data", "number");
1119         return nullptr;
1120     }
1121     if (!JsCommon::TypeOf(env, argv[0], napi_number)) {
1122         MMI_HILOGE("Int32 data parameter type is invalid");
1123         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "data", "number");
1124         return nullptr;
1125     }
1126     int32_t data = 0;
1127     CHKRP(napi_get_value_int32(env, argv[0], &data), GET_VALUE_INT32);
1128     if (data < dataMin) {
1129         data = dataMin;
1130     } else if (data > dataMax) {
1131         data = dataMax;
1132     }
1133 
1134     if (argc == 1) {
1135         return func(env, data, nullptr);
1136     }
1137     if (!JsCommon::TypeOf(env, argv[1], napi_function)) {
1138         MMI_HILOGE("Callback parameter type is invalid");
1139         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1140         return nullptr;
1141     }
1142 
1143     return func(env, data, argv[1]);
1144 }
1145 
GetTouchpadData(napi_env env,napi_callback_info info,GetTouchpadFunc func)1146 napi_value JsPointerContext::GetTouchpadData(napi_env env, napi_callback_info info, GetTouchpadFunc func)
1147 {
1148     CALL_DEBUG_ENTER;
1149     size_t argc = 1;
1150     napi_value argv[1];
1151     CHKRP(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO);
1152 
1153     if (argc == 0) {
1154         return func(env, nullptr);
1155     }
1156     if (!JsCommon::TypeOf(env, argv[0], napi_function)) {
1157         MMI_HILOGE("Callback parameter type is invalid");
1158         THROWERR_API9(env, COMMON_PARAMETER_ERROR, "callback", "function");
1159         return nullptr;
1160     }
1161 
1162     return func(env, argv[0]);
1163 }
1164 
SetTouchpadScrollSwitch(napi_env env,napi_callback_info info)1165 napi_value JsPointerContext::SetTouchpadScrollSwitch(napi_env env, napi_callback_info info)
1166 {
1167     CALL_DEBUG_ENTER;
1168     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1169     CHKPP(jsPointer);
1170     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1171     CHKPP(jsPointerMgr);
1172     auto func = [jsPointerMgr] (napi_env env, bool switchFlag, napi_value handle) -> napi_value {
1173         return jsPointerMgr->SetTouchpadScrollSwitch(env, switchFlag, handle);
1174     };
1175     return SetTouchpadBoolData(env, info, func);
1176 }
1177 
GetTouchpadScrollSwitch(napi_env env,napi_callback_info info)1178 napi_value JsPointerContext::GetTouchpadScrollSwitch(napi_env env, napi_callback_info info)
1179 {
1180     CALL_DEBUG_ENTER;
1181     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1182     CHKPP(jsPointer);
1183     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1184     CHKPP(jsPointerMgr);
1185     auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1186         return jsPointerMgr->GetTouchpadScrollSwitch(env, handle);
1187     };
1188     return GetTouchpadData(env, info, func);
1189 }
1190 
SetTouchpadScrollDirection(napi_env env,napi_callback_info info)1191 napi_value JsPointerContext::SetTouchpadScrollDirection(napi_env env, napi_callback_info info)
1192 {
1193     CALL_DEBUG_ENTER;
1194     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1195     CHKPP(jsPointer);
1196     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1197     CHKPP(jsPointerMgr);
1198     auto func = [jsPointerMgr] (napi_env env, bool state, napi_value handle) -> napi_value {
1199         return jsPointerMgr->SetTouchpadScrollDirection(env, state, handle);
1200     };
1201     return SetTouchpadBoolData(env, info, func);
1202 }
1203 
GetTouchpadScrollDirection(napi_env env,napi_callback_info info)1204 napi_value JsPointerContext::GetTouchpadScrollDirection(napi_env env, napi_callback_info info)
1205 {
1206     CALL_DEBUG_ENTER;
1207     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1208     CHKPP(jsPointer);
1209     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1210     CHKPP(jsPointerMgr);
1211     auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1212         return jsPointerMgr->GetTouchpadScrollDirection(env, handle);
1213     };
1214     return GetTouchpadData(env, info, func);
1215 }
1216 
SetTouchpadTapSwitch(napi_env env,napi_callback_info info)1217 napi_value JsPointerContext::SetTouchpadTapSwitch(napi_env env, napi_callback_info info)
1218 {
1219     CALL_DEBUG_ENTER;
1220     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1221     CHKPP(jsPointer);
1222     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1223     CHKPP(jsPointerMgr);
1224     auto func = [jsPointerMgr] (napi_env env, bool switchFlag, napi_value handle) -> napi_value {
1225         return jsPointerMgr->SetTouchpadTapSwitch(env, switchFlag, handle);
1226     };
1227     return SetTouchpadBoolData(env, info, func);
1228 }
1229 
GetTouchpadTapSwitch(napi_env env,napi_callback_info info)1230 napi_value JsPointerContext::GetTouchpadTapSwitch(napi_env env, napi_callback_info info)
1231 {
1232     CALL_DEBUG_ENTER;
1233     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1234     CHKPP(jsPointer);
1235     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1236     CHKPP(jsPointerMgr);
1237     auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1238         return jsPointerMgr->GetTouchpadTapSwitch(env, handle);
1239     };
1240     return GetTouchpadData(env, info, func);
1241 }
1242 
SetTouchpadPointerSpeed(napi_env env,napi_callback_info info)1243 napi_value JsPointerContext::SetTouchpadPointerSpeed(napi_env env, napi_callback_info info)
1244 {
1245     CALL_DEBUG_ENTER;
1246     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1247     CHKPP(jsPointer);
1248     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1249     CHKPP(jsPointerMgr);
1250     auto func = [jsPointerMgr] (napi_env env, int32_t data, napi_value handle) -> napi_value {
1251         return jsPointerMgr->SetTouchpadPointerSpeed(env, data, handle);
1252     };
1253     return SetTouchpadInt32Data(env, info, func, MAX_SPEED, MIN_SPEED);
1254 }
1255 
GetTouchpadPointerSpeed(napi_env env,napi_callback_info info)1256 napi_value JsPointerContext::GetTouchpadPointerSpeed(napi_env env, napi_callback_info info)
1257 {
1258     CALL_DEBUG_ENTER;
1259     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1260     CHKPP(jsPointer);
1261     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1262     CHKPP(jsPointerMgr);
1263     auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1264         return jsPointerMgr->GetTouchpadPointerSpeed(env, handle);
1265     };
1266     return GetTouchpadData(env, info, func);
1267 }
1268 
SetTouchpadPinchSwitch(napi_env env,napi_callback_info info)1269 napi_value JsPointerContext::SetTouchpadPinchSwitch(napi_env env, napi_callback_info info)
1270 {
1271     CALL_DEBUG_ENTER;
1272     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1273     CHKPP(jsPointer);
1274     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1275     CHKPP(jsPointerMgr);
1276     auto func = [jsPointerMgr] (napi_env env, bool switchFlag, napi_value handle) -> napi_value {
1277         return jsPointerMgr->SetTouchpadPinchSwitch(env, switchFlag, handle);
1278     };
1279     return SetTouchpadBoolData(env, info, func);
1280 }
1281 
GetTouchpadPinchSwitch(napi_env env,napi_callback_info info)1282 napi_value JsPointerContext::GetTouchpadPinchSwitch(napi_env env, napi_callback_info info)
1283 {
1284     CALL_DEBUG_ENTER;
1285     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1286     CHKPP(jsPointer);
1287     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1288     CHKPP(jsPointerMgr);
1289     auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1290         return jsPointerMgr->GetTouchpadPinchSwitch(env, handle);
1291     };
1292     return GetTouchpadData(env, info, func);
1293 }
1294 
SetTouchpadSwipeSwitch(napi_env env,napi_callback_info info)1295 napi_value JsPointerContext::SetTouchpadSwipeSwitch(napi_env env, napi_callback_info info)
1296 {
1297     CALL_DEBUG_ENTER;
1298     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1299     CHKPP(jsPointer);
1300     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1301     CHKPP(jsPointerMgr);
1302     auto func = [jsPointerMgr] (napi_env env, bool switchFlag, napi_value handle) -> napi_value {
1303         return jsPointerMgr->SetTouchpadSwipeSwitch(env, switchFlag, handle);
1304     };
1305     return SetTouchpadBoolData(env, info, func);
1306 }
1307 
GetTouchpadSwipeSwitch(napi_env env,napi_callback_info info)1308 napi_value JsPointerContext::GetTouchpadSwipeSwitch(napi_env env, napi_callback_info info)
1309 {
1310     CALL_DEBUG_ENTER;
1311     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1312     CHKPP(jsPointer);
1313     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1314     CHKPP(jsPointerMgr);
1315     auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1316         return jsPointerMgr->GetTouchpadSwipeSwitch(env, handle);
1317     };
1318     return GetTouchpadData(env, info, func);
1319 }
1320 
SetTouchpadRightClickType(napi_env env,napi_callback_info info)1321 napi_value JsPointerContext::SetTouchpadRightClickType(napi_env env, napi_callback_info info)
1322 {
1323     CALL_DEBUG_ENTER;
1324     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1325     CHKPP(jsPointer);
1326     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1327     CHKPP(jsPointerMgr);
1328     auto func = [jsPointerMgr] (napi_env env, int32_t data, napi_value handle) -> napi_value {
1329         return jsPointerMgr->SetTouchpadRightClickType(env, data, handle);
1330     };
1331     return SetTouchpadInt32Data(env, info, func, MAX_SPEED, MIN_SPEED);
1332 }
1333 
GetTouchpadRightClickType(napi_env env,napi_callback_info info)1334 napi_value JsPointerContext::GetTouchpadRightClickType(napi_env env, napi_callback_info info)
1335 {
1336     CALL_DEBUG_ENTER;
1337     JsPointerContext *jsPointer = JsPointerContext::GetInstance(env);
1338     CHKPP(jsPointer);
1339     auto jsPointerMgr = jsPointer->GetJsPointerMgr();
1340     CHKPP(jsPointerMgr);
1341     auto func = [jsPointerMgr] (napi_env env, napi_value handle) -> napi_value {
1342         return jsPointerMgr->GetTouchpadRightClickType(env, handle);
1343     };
1344     return GetTouchpadData(env, info, func);
1345 }
1346 
Export(napi_env env,napi_value exports)1347 napi_value JsPointerContext::Export(napi_env env, napi_value exports)
1348 {
1349     CALL_DEBUG_ENTER;
1350     auto instance = CreateInstance(env);
1351     if (instance == nullptr) {
1352         THROWERR(env, "failed to create instance");
1353         return nullptr;
1354     }
1355     napi_property_descriptor desc[] = {
1356         DECLARE_NAPI_STATIC_FUNCTION("setPointerVisible", SetPointerVisible),
1357         DECLARE_NAPI_STATIC_FUNCTION("setPointerVisibleSync", SetPointerVisibleSync),
1358         DECLARE_NAPI_STATIC_FUNCTION("isPointerVisible", IsPointerVisible),
1359         DECLARE_NAPI_STATIC_FUNCTION("setPointerColor", SetPointerColor),
1360         DECLARE_NAPI_STATIC_FUNCTION("getPointerColor", GetPointerColor),
1361         DECLARE_NAPI_STATIC_FUNCTION("setPointerColorSync", SetPointerColorSync),
1362         DECLARE_NAPI_STATIC_FUNCTION("getPointerColorSync", GetPointerColorSync),
1363         DECLARE_NAPI_STATIC_FUNCTION("isPointerVisibleSync", IsPointerVisibleSync),
1364         DECLARE_NAPI_STATIC_FUNCTION("setPointerSpeed", SetPointerSpeed),
1365         DECLARE_NAPI_STATIC_FUNCTION("setPointerSpeedSync", SetPointerSpeedSync),
1366         DECLARE_NAPI_STATIC_FUNCTION("getPointerSpeed", GetPointerSpeed),
1367         DECLARE_NAPI_STATIC_FUNCTION("getPointerSpeedSync", GetPointerSpeedSync),
1368         DECLARE_NAPI_STATIC_FUNCTION("setPointerStyle", SetPointerStyle),
1369         DECLARE_NAPI_STATIC_FUNCTION("setPointerStyleSync", SetPointerStyleSync),
1370         DECLARE_NAPI_STATIC_FUNCTION("getPointerStyle", GetPointerStyle),
1371         DECLARE_NAPI_STATIC_FUNCTION("getPointerStyleSync", GetPointerStyleSync),
1372         DECLARE_NAPI_STATIC_FUNCTION("enterCaptureMode", EnterCaptureMode),
1373         DECLARE_NAPI_STATIC_FUNCTION("leaveCaptureMode", LeaveCaptureMode),
1374         DECLARE_NAPI_STATIC_FUNCTION("setMouseScrollRows", SetMouseScrollRows),
1375         DECLARE_NAPI_STATIC_FUNCTION("getMouseScrollRows", GetMouseScrollRows),
1376         DECLARE_NAPI_STATIC_FUNCTION("setPointerSize", SetPointerSize),
1377         DECLARE_NAPI_STATIC_FUNCTION("getPointerSize", GetPointerSize),
1378         DECLARE_NAPI_STATIC_FUNCTION("setPointerSizeSync", SetPointerSizeSync),
1379         DECLARE_NAPI_STATIC_FUNCTION("getPointerSizeSync", GetPointerSizeSync),
1380         DECLARE_NAPI_STATIC_FUNCTION("setMousePrimaryButton", SetMousePrimaryButton),
1381         DECLARE_NAPI_STATIC_FUNCTION("getMousePrimaryButton", GetMousePrimaryButton),
1382         DECLARE_NAPI_STATIC_FUNCTION("setHoverScrollState", SetHoverScrollState),
1383         DECLARE_NAPI_STATIC_FUNCTION("getHoverScrollState", GetHoverScrollState),
1384         DECLARE_NAPI_STATIC_FUNCTION("setTouchpadScrollSwitch", SetTouchpadScrollSwitch),
1385         DECLARE_NAPI_STATIC_FUNCTION("getTouchpadScrollSwitch", GetTouchpadScrollSwitch),
1386         DECLARE_NAPI_STATIC_FUNCTION("setTouchpadScrollDirection", SetTouchpadScrollDirection),
1387         DECLARE_NAPI_STATIC_FUNCTION("getTouchpadScrollDirection", GetTouchpadScrollDirection),
1388         DECLARE_NAPI_STATIC_FUNCTION("setTouchpadTapSwitch", SetTouchpadTapSwitch),
1389         DECLARE_NAPI_STATIC_FUNCTION("getTouchpadTapSwitch", GetTouchpadTapSwitch),
1390         DECLARE_NAPI_STATIC_FUNCTION("setTouchpadPointerSpeed", SetTouchpadPointerSpeed),
1391         DECLARE_NAPI_STATIC_FUNCTION("getTouchpadPointerSpeed", GetTouchpadPointerSpeed),
1392         DECLARE_NAPI_STATIC_FUNCTION("setTouchpadPinchSwitch", SetTouchpadPinchSwitch),
1393         DECLARE_NAPI_STATIC_FUNCTION("getTouchpadPinchSwitch", GetTouchpadPinchSwitch),
1394         DECLARE_NAPI_STATIC_FUNCTION("setTouchpadSwipeSwitch", SetTouchpadSwipeSwitch),
1395         DECLARE_NAPI_STATIC_FUNCTION("getTouchpadSwipeSwitch", GetTouchpadSwipeSwitch),
1396         DECLARE_NAPI_STATIC_FUNCTION("setTouchpadRightClickType", SetTouchpadRightClickType),
1397         DECLARE_NAPI_STATIC_FUNCTION("getTouchpadRightClickType", GetTouchpadRightClickType),
1398     };
1399     CHKRP(napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc), DEFINE_PROPERTIES);
1400     if (CreatePointerStyle(env, exports) == nullptr) {
1401         THROWERR(env, "Failed to create pointer style");
1402         return nullptr;
1403     }
1404     if (CreateMousePrimaryButton(env, exports) == nullptr) {
1405         THROWERR(env, "Failed to create mouse primary button");
1406         return nullptr;
1407     }
1408     if (CreateTouchpadRightClickType(env, exports) == nullptr) {
1409         THROWERR(env, "Failed to create touchpad right click type");
1410         return nullptr;
1411     }
1412     return exports;
1413 }
1414 } // namespace MMI
1415 } // namespace OHOS
1416