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