1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define LOG_TAG "MotionEvent-JNI" 18 19 #include <nativehelper/JNIHelp.h> 20 21 #include <SkMatrix.h> 22 #include <android_runtime/AndroidRuntime.h> 23 #include <android_runtime/Log.h> 24 #include <utils/Log.h> 25 #include <input/Input.h> 26 #include <nativehelper/ScopedUtfChars.h> 27 #include "android_os_Parcel.h" 28 #include "android_view_MotionEvent.h" 29 #include "android_util_Binder.h" 30 #include "android/graphics/Matrix.h" 31 32 #include "core_jni_helpers.h" 33 34 namespace android { 35 36 // ---------------------------------------------------------------------------- 37 38 static struct { 39 jclass clazz; 40 41 jmethodID obtain; 42 jmethodID recycle; 43 44 jfieldID mNativePtr; 45 } gMotionEventClassInfo; 46 47 static struct { 48 jfieldID mPackedAxisBits; 49 jfieldID mPackedAxisValues; 50 jfieldID x; 51 jfieldID y; 52 jfieldID pressure; 53 jfieldID size; 54 jfieldID touchMajor; 55 jfieldID touchMinor; 56 jfieldID toolMajor; 57 jfieldID toolMinor; 58 jfieldID orientation; 59 } gPointerCoordsClassInfo; 60 61 static struct { 62 jfieldID id; 63 jfieldID toolType; 64 } gPointerPropertiesClassInfo; 65 66 // ---------------------------------------------------------------------------- 67 68 MotionEvent* android_view_MotionEvent_getNativePtr(JNIEnv* env, jobject eventObj) { 69 if (!eventObj) { 70 return NULL; 71 } 72 return reinterpret_cast<MotionEvent*>( 73 env->GetLongField(eventObj, gMotionEventClassInfo.mNativePtr)); 74 } 75 76 static void android_view_MotionEvent_setNativePtr(JNIEnv* env, jobject eventObj, 77 MotionEvent* event) { 78 env->SetLongField(eventObj, gMotionEventClassInfo.mNativePtr, 79 reinterpret_cast<jlong>(event)); 80 } 81 82 jobject android_view_MotionEvent_obtainAsCopy(JNIEnv* env, const MotionEvent* event) { 83 jobject eventObj = env->CallStaticObjectMethod(gMotionEventClassInfo.clazz, 84 gMotionEventClassInfo.obtain); 85 if (env->ExceptionCheck() || !eventObj) { 86 ALOGE("An exception occurred while obtaining a motion event."); 87 LOGE_EX(env); 88 env->ExceptionClear(); 89 return NULL; 90 } 91 92 MotionEvent* destEvent = android_view_MotionEvent_getNativePtr(env, eventObj); 93 if (!destEvent) { 94 destEvent = new MotionEvent(); 95 android_view_MotionEvent_setNativePtr(env, eventObj, destEvent); 96 } 97 98 destEvent->copyFrom(event, true); 99 return eventObj; 100 } 101 102 status_t android_view_MotionEvent_recycle(JNIEnv* env, jobject eventObj) { 103 env->CallVoidMethod(eventObj, gMotionEventClassInfo.recycle); 104 if (env->ExceptionCheck()) { 105 ALOGW("An exception occurred while recycling a motion event."); 106 LOGW_EX(env); 107 env->ExceptionClear(); 108 return UNKNOWN_ERROR; 109 } 110 return OK; 111 } 112 113 // ---------------------------------------------------------------------------- 114 115 static const jint HISTORY_CURRENT = -0x80000000; 116 117 static bool validatePointerCount(JNIEnv* env, jint pointerCount) { 118 if (pointerCount < 1) { 119 jniThrowException(env, "java/lang/IllegalArgumentException", 120 "pointerCount must be at least 1"); 121 return false; 122 } 123 return true; 124 } 125 126 static bool validatePointerPropertiesArray(JNIEnv* env, jobjectArray pointerPropertiesObjArray, 127 size_t pointerCount) { 128 if (!pointerPropertiesObjArray) { 129 jniThrowException(env, "java/lang/IllegalArgumentException", 130 "pointerProperties array must not be null"); 131 return false; 132 } 133 size_t length = size_t(env->GetArrayLength(pointerPropertiesObjArray)); 134 if (length < pointerCount) { 135 jniThrowException(env, "java/lang/IllegalArgumentException", 136 "pointerProperties array must be large enough to hold all pointers"); 137 return false; 138 } 139 return true; 140 } 141 142 static bool validatePointerCoordsObjArray(JNIEnv* env, jobjectArray pointerCoordsObjArray, 143 size_t pointerCount) { 144 if (!pointerCoordsObjArray) { 145 jniThrowException(env, "java/lang/IllegalArgumentException", 146 "pointerCoords array must not be null"); 147 return false; 148 } 149 size_t length = size_t(env->GetArrayLength(pointerCoordsObjArray)); 150 if (length < pointerCount) { 151 jniThrowException(env, "java/lang/IllegalArgumentException", 152 "pointerCoords array must be large enough to hold all pointers"); 153 return false; 154 } 155 return true; 156 } 157 158 static bool validatePointerIndex(JNIEnv* env, jint pointerIndex, size_t pointerCount) { 159 if (pointerIndex < 0 || size_t(pointerIndex) >= pointerCount) { 160 jniThrowException(env, "java/lang/IllegalArgumentException", 161 "pointerIndex out of range"); 162 return false; 163 } 164 return true; 165 } 166 167 static bool validateHistoryPos(JNIEnv* env, jint historyPos, size_t historySize) { 168 if (historyPos < 0 || size_t(historyPos) >= historySize) { 169 jniThrowException(env, "java/lang/IllegalArgumentException", 170 "historyPos out of range"); 171 return false; 172 } 173 return true; 174 } 175 176 static bool validatePointerCoords(JNIEnv* env, jobject pointerCoordsObj) { 177 if (!pointerCoordsObj) { 178 jniThrowException(env, "java/lang/IllegalArgumentException", 179 "pointerCoords must not be null"); 180 return false; 181 } 182 return true; 183 } 184 185 static bool validatePointerProperties(JNIEnv* env, jobject pointerPropertiesObj) { 186 if (!pointerPropertiesObj) { 187 jniThrowException(env, "java/lang/IllegalArgumentException", 188 "pointerProperties must not be null"); 189 return false; 190 } 191 return true; 192 } 193 194 static void pointerCoordsToNative(JNIEnv* env, jobject pointerCoordsObj, 195 float xOffset, float yOffset, PointerCoords* outRawPointerCoords) { 196 outRawPointerCoords->clear(); 197 outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_X, 198 env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.x) - xOffset); 199 outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_Y, 200 env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.y) - yOffset); 201 outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 202 env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.pressure)); 203 outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_SIZE, 204 env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.size)); 205 outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 206 env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.touchMajor)); 207 outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 208 env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.touchMinor)); 209 outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 210 env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.toolMajor)); 211 outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 212 env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.toolMinor)); 213 outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 214 env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.orientation)); 215 216 BitSet64 bits = 217 BitSet64(env->GetLongField(pointerCoordsObj, gPointerCoordsClassInfo.mPackedAxisBits)); 218 if (!bits.isEmpty()) { 219 jfloatArray valuesArray = jfloatArray(env->GetObjectField(pointerCoordsObj, 220 gPointerCoordsClassInfo.mPackedAxisValues)); 221 if (valuesArray) { 222 jfloat* values = static_cast<jfloat*>( 223 env->GetPrimitiveArrayCritical(valuesArray, NULL)); 224 225 uint32_t index = 0; 226 do { 227 uint32_t axis = bits.clearFirstMarkedBit(); 228 outRawPointerCoords->setAxisValue(axis, values[index++]); 229 } while (!bits.isEmpty()); 230 231 env->ReleasePrimitiveArrayCritical(valuesArray, values, JNI_ABORT); 232 env->DeleteLocalRef(valuesArray); 233 } 234 } 235 } 236 237 static jfloatArray obtainPackedAxisValuesArray(JNIEnv* env, uint32_t minSize, 238 jobject outPointerCoordsObj) { 239 jfloatArray outValuesArray = jfloatArray(env->GetObjectField(outPointerCoordsObj, 240 gPointerCoordsClassInfo.mPackedAxisValues)); 241 if (outValuesArray) { 242 uint32_t size = env->GetArrayLength(outValuesArray); 243 if (minSize <= size) { 244 return outValuesArray; 245 } 246 env->DeleteLocalRef(outValuesArray); 247 } 248 uint32_t size = 8; 249 while (size < minSize) { 250 size *= 2; 251 } 252 outValuesArray = env->NewFloatArray(size); 253 env->SetObjectField(outPointerCoordsObj, 254 gPointerCoordsClassInfo.mPackedAxisValues, outValuesArray); 255 return outValuesArray; 256 } 257 258 static void pointerCoordsFromNative(JNIEnv* env, const PointerCoords* rawPointerCoords, 259 float xOffset, float yOffset, jobject outPointerCoordsObj) { 260 env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.x, 261 rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_X) + xOffset); 262 env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.y, 263 rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_Y) + yOffset); 264 env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.pressure, 265 rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_PRESSURE)); 266 env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.size, 267 rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_SIZE)); 268 env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.touchMajor, 269 rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR)); 270 env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.touchMinor, 271 rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR)); 272 env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.toolMajor, 273 rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR)); 274 env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.toolMinor, 275 rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR)); 276 env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.orientation, 277 rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION)); 278 279 uint64_t outBits = 0; 280 BitSet64 bits = BitSet64(rawPointerCoords->bits); 281 bits.clearBit(AMOTION_EVENT_AXIS_X); 282 bits.clearBit(AMOTION_EVENT_AXIS_Y); 283 bits.clearBit(AMOTION_EVENT_AXIS_PRESSURE); 284 bits.clearBit(AMOTION_EVENT_AXIS_SIZE); 285 bits.clearBit(AMOTION_EVENT_AXIS_TOUCH_MAJOR); 286 bits.clearBit(AMOTION_EVENT_AXIS_TOUCH_MINOR); 287 bits.clearBit(AMOTION_EVENT_AXIS_TOOL_MAJOR); 288 bits.clearBit(AMOTION_EVENT_AXIS_TOOL_MINOR); 289 bits.clearBit(AMOTION_EVENT_AXIS_ORIENTATION); 290 if (!bits.isEmpty()) { 291 uint32_t packedAxesCount = bits.count(); 292 jfloatArray outValuesArray = obtainPackedAxisValuesArray(env, packedAxesCount, 293 outPointerCoordsObj); 294 if (!outValuesArray) { 295 return; // OOM 296 } 297 298 jfloat* outValues = static_cast<jfloat*>(env->GetPrimitiveArrayCritical( 299 outValuesArray, NULL)); 300 301 uint32_t index = 0; 302 do { 303 uint32_t axis = bits.clearFirstMarkedBit(); 304 outBits |= BitSet64::valueForBit(axis); 305 outValues[index++] = rawPointerCoords->getAxisValue(axis); 306 } while (!bits.isEmpty()); 307 308 env->ReleasePrimitiveArrayCritical(outValuesArray, outValues, 0); 309 env->DeleteLocalRef(outValuesArray); 310 } 311 env->SetLongField(outPointerCoordsObj, gPointerCoordsClassInfo.mPackedAxisBits, outBits); 312 } 313 314 static void pointerPropertiesToNative(JNIEnv* env, jobject pointerPropertiesObj, 315 PointerProperties* outPointerProperties) { 316 outPointerProperties->clear(); 317 outPointerProperties->id = env->GetIntField(pointerPropertiesObj, 318 gPointerPropertiesClassInfo.id); 319 outPointerProperties->toolType = env->GetIntField(pointerPropertiesObj, 320 gPointerPropertiesClassInfo.toolType); 321 } 322 323 static void pointerPropertiesFromNative(JNIEnv* env, const PointerProperties* pointerProperties, 324 jobject outPointerPropertiesObj) { 325 env->SetIntField(outPointerPropertiesObj, gPointerPropertiesClassInfo.id, 326 pointerProperties->id); 327 env->SetIntField(outPointerPropertiesObj, gPointerPropertiesClassInfo.toolType, 328 pointerProperties->toolType); 329 } 330 331 332 // ---------------------------------------------------------------------------- 333 334 static jlong android_view_MotionEvent_nativeInitialize(JNIEnv* env, jclass clazz, 335 jlong nativePtr, 336 jint deviceId, jint source, jint action, jint flags, jint edgeFlags, 337 jint metaState, jint buttonState, 338 jfloat xOffset, jfloat yOffset, jfloat xPrecision, jfloat yPrecision, 339 jlong downTimeNanos, jlong eventTimeNanos, 340 jint pointerCount, jobjectArray pointerPropertiesObjArray, 341 jobjectArray pointerCoordsObjArray) { 342 if (!validatePointerCount(env, pointerCount) 343 || !validatePointerPropertiesArray(env, pointerPropertiesObjArray, pointerCount) 344 || !validatePointerCoordsObjArray(env, pointerCoordsObjArray, pointerCount)) { 345 return 0; 346 } 347 348 MotionEvent* event; 349 if (nativePtr) { 350 event = reinterpret_cast<MotionEvent*>(nativePtr); 351 } else { 352 event = new MotionEvent(); 353 } 354 355 PointerProperties pointerProperties[pointerCount]; 356 PointerCoords rawPointerCoords[pointerCount]; 357 358 for (jint i = 0; i < pointerCount; i++) { 359 jobject pointerPropertiesObj = env->GetObjectArrayElement(pointerPropertiesObjArray, i); 360 if (!pointerPropertiesObj) { 361 goto Error; 362 } 363 pointerPropertiesToNative(env, pointerPropertiesObj, &pointerProperties[i]); 364 env->DeleteLocalRef(pointerPropertiesObj); 365 366 jobject pointerCoordsObj = env->GetObjectArrayElement(pointerCoordsObjArray, i); 367 if (!pointerCoordsObj) { 368 jniThrowNullPointerException(env, "pointerCoords"); 369 goto Error; 370 } 371 pointerCoordsToNative(env, pointerCoordsObj, xOffset, yOffset, &rawPointerCoords[i]); 372 env->DeleteLocalRef(pointerCoordsObj); 373 } 374 375 event->initialize(deviceId, source, action, 0, flags, edgeFlags, metaState, buttonState, 376 xOffset, yOffset, xPrecision, yPrecision, 377 downTimeNanos, eventTimeNanos, pointerCount, pointerProperties, rawPointerCoords); 378 379 return reinterpret_cast<jlong>(event); 380 381 Error: 382 if (!nativePtr) { 383 delete event; 384 } 385 return 0; 386 } 387 388 static void android_view_MotionEvent_nativeDispose(JNIEnv* env, jclass clazz, 389 jlong nativePtr) { 390 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 391 delete event; 392 } 393 394 static void android_view_MotionEvent_nativeAddBatch(JNIEnv* env, jclass clazz, 395 jlong nativePtr, jlong eventTimeNanos, jobjectArray pointerCoordsObjArray, 396 jint metaState) { 397 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 398 size_t pointerCount = event->getPointerCount(); 399 if (!validatePointerCoordsObjArray(env, pointerCoordsObjArray, pointerCount)) { 400 return; 401 } 402 403 PointerCoords rawPointerCoords[pointerCount]; 404 405 for (size_t i = 0; i < pointerCount; i++) { 406 jobject pointerCoordsObj = env->GetObjectArrayElement(pointerCoordsObjArray, i); 407 if (!pointerCoordsObj) { 408 jniThrowNullPointerException(env, "pointerCoords"); 409 return; 410 } 411 pointerCoordsToNative(env, pointerCoordsObj, 412 event->getXOffset(), event->getYOffset(), &rawPointerCoords[i]); 413 env->DeleteLocalRef(pointerCoordsObj); 414 } 415 416 event->addSample(eventTimeNanos, rawPointerCoords); 417 event->setMetaState(event->getMetaState() | metaState); 418 } 419 420 static void android_view_MotionEvent_nativeGetPointerCoords(JNIEnv* env, jclass clazz, 421 jlong nativePtr, jint pointerIndex, jint historyPos, jobject outPointerCoordsObj) { 422 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 423 size_t pointerCount = event->getPointerCount(); 424 if (!validatePointerIndex(env, pointerIndex, pointerCount) 425 || !validatePointerCoords(env, outPointerCoordsObj)) { 426 return; 427 } 428 429 const PointerCoords* rawPointerCoords; 430 if (historyPos == HISTORY_CURRENT) { 431 rawPointerCoords = event->getRawPointerCoords(pointerIndex); 432 } else { 433 size_t historySize = event->getHistorySize(); 434 if (!validateHistoryPos(env, historyPos, historySize)) { 435 return; 436 } 437 rawPointerCoords = event->getHistoricalRawPointerCoords(pointerIndex, historyPos); 438 } 439 pointerCoordsFromNative(env, rawPointerCoords, event->getXOffset(), event->getYOffset(), 440 outPointerCoordsObj); 441 } 442 443 static void android_view_MotionEvent_nativeGetPointerProperties(JNIEnv* env, jclass clazz, 444 jlong nativePtr, jint pointerIndex, jobject outPointerPropertiesObj) { 445 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 446 size_t pointerCount = event->getPointerCount(); 447 if (!validatePointerIndex(env, pointerIndex, pointerCount) 448 || !validatePointerProperties(env, outPointerPropertiesObj)) { 449 return; 450 } 451 452 const PointerProperties* pointerProperties = event->getPointerProperties(pointerIndex); 453 pointerPropertiesFromNative(env, pointerProperties, outPointerPropertiesObj); 454 } 455 456 static jlong android_view_MotionEvent_nativeReadFromParcel(JNIEnv* env, jclass clazz, 457 jlong nativePtr, jobject parcelObj) { 458 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 459 if (!event) { 460 event = new MotionEvent(); 461 } 462 463 Parcel* parcel = parcelForJavaObject(env, parcelObj); 464 465 status_t status = event->readFromParcel(parcel); 466 if (status) { 467 if (!nativePtr) { 468 delete event; 469 } 470 jniThrowRuntimeException(env, "Failed to read MotionEvent parcel."); 471 return 0; 472 } 473 return reinterpret_cast<jlong>(event); 474 } 475 476 static void android_view_MotionEvent_nativeWriteToParcel(JNIEnv* env, jclass clazz, 477 jlong nativePtr, jobject parcelObj) { 478 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 479 Parcel* parcel = parcelForJavaObject(env, parcelObj); 480 481 status_t status = event->writeToParcel(parcel); 482 if (status) { 483 jniThrowRuntimeException(env, "Failed to write MotionEvent parcel."); 484 } 485 } 486 487 static jstring android_view_MotionEvent_nativeAxisToString(JNIEnv* env, jclass clazz, 488 jint axis) { 489 return env->NewStringUTF(MotionEvent::getLabel(static_cast<int32_t>(axis))); 490 } 491 492 static jint android_view_MotionEvent_nativeAxisFromString(JNIEnv* env, jclass clazz, 493 jstring label) { 494 ScopedUtfChars axisLabel(env, label); 495 return static_cast<jint>(MotionEvent::getAxisFromLabel(axisLabel.c_str())); 496 } 497 498 // ---------------- @FastNative ---------------------------------- 499 500 static jint android_view_MotionEvent_nativeGetPointerId(JNIEnv* env, jclass clazz, 501 jlong nativePtr, jint pointerIndex) { 502 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 503 size_t pointerCount = event->getPointerCount(); 504 if (!validatePointerIndex(env, pointerIndex, pointerCount)) { 505 return -1; 506 } 507 return event->getPointerId(pointerIndex); 508 } 509 510 static jint android_view_MotionEvent_nativeGetToolType(JNIEnv* env, jclass clazz, 511 jlong nativePtr, jint pointerIndex) { 512 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 513 size_t pointerCount = event->getPointerCount(); 514 if (!validatePointerIndex(env, pointerIndex, pointerCount)) { 515 return -1; 516 } 517 return event->getToolType(pointerIndex); 518 } 519 520 static jlong android_view_MotionEvent_nativeGetEventTimeNanos(JNIEnv* env, jclass clazz, 521 jlong nativePtr, jint historyPos) { 522 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 523 if (historyPos == HISTORY_CURRENT) { 524 return event->getEventTime(); 525 } else { 526 size_t historySize = event->getHistorySize(); 527 if (!validateHistoryPos(env, historyPos, historySize)) { 528 return 0; 529 } 530 return event->getHistoricalEventTime(historyPos); 531 } 532 } 533 534 static jfloat android_view_MotionEvent_nativeGetRawAxisValue(JNIEnv* env, jclass clazz, 535 jlong nativePtr, jint axis, 536 jint pointerIndex, jint historyPos) { 537 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 538 size_t pointerCount = event->getPointerCount(); 539 if (!validatePointerIndex(env, pointerIndex, pointerCount)) { 540 return 0; 541 } 542 543 if (historyPos == HISTORY_CURRENT) { 544 return event->getRawAxisValue(axis, pointerIndex); 545 } else { 546 size_t historySize = event->getHistorySize(); 547 if (!validateHistoryPos(env, historyPos, historySize)) { 548 return 0; 549 } 550 return event->getHistoricalRawAxisValue(axis, pointerIndex, historyPos); 551 } 552 } 553 554 static jfloat android_view_MotionEvent_nativeGetAxisValue(JNIEnv* env, jclass clazz, 555 jlong nativePtr, jint axis, jint pointerIndex, jint historyPos) { 556 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 557 size_t pointerCount = event->getPointerCount(); 558 if (!validatePointerIndex(env, pointerIndex, pointerCount)) { 559 return 0; 560 } 561 562 if (historyPos == HISTORY_CURRENT) { 563 return event->getAxisValue(axis, pointerIndex); 564 } else { 565 size_t historySize = event->getHistorySize(); 566 if (!validateHistoryPos(env, historyPos, historySize)) { 567 return 0; 568 } 569 return event->getHistoricalAxisValue(axis, pointerIndex, historyPos); 570 } 571 } 572 573 // ----------------- @CriticalNative ------------------------------ 574 575 static jlong android_view_MotionEvent_nativeCopy(jlong destNativePtr, jlong sourceNativePtr, 576 jboolean keepHistory) { 577 MotionEvent* destEvent = reinterpret_cast<MotionEvent*>(destNativePtr); 578 if (!destEvent) { 579 destEvent = new MotionEvent(); 580 } 581 MotionEvent* sourceEvent = reinterpret_cast<MotionEvent*>(sourceNativePtr); 582 destEvent->copyFrom(sourceEvent, keepHistory); 583 return reinterpret_cast<jlong>(destEvent); 584 } 585 586 static jint android_view_MotionEvent_nativeGetDeviceId(jlong nativePtr) { 587 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 588 return event->getDeviceId(); 589 } 590 591 static jint android_view_MotionEvent_nativeGetSource(jlong nativePtr) { 592 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 593 return event->getSource(); 594 } 595 596 static void android_view_MotionEvent_nativeSetSource(jlong nativePtr, jint source) { 597 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 598 event->setSource(source); 599 } 600 601 static jint android_view_MotionEvent_nativeGetAction(jlong nativePtr) { 602 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 603 return event->getAction(); 604 } 605 606 static void android_view_MotionEvent_nativeSetAction(jlong nativePtr, jint action) { 607 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 608 event->setAction(action); 609 } 610 611 static int android_view_MotionEvent_nativeGetActionButton(jlong nativePtr) { 612 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 613 return event->getActionButton(); 614 } 615 616 static void android_view_MotionEvent_nativeSetActionButton(jlong nativePtr, jint button) { 617 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 618 event->setActionButton(button); 619 } 620 621 static jboolean android_view_MotionEvent_nativeIsTouchEvent(jlong nativePtr) { 622 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 623 return event->isTouchEvent(); 624 } 625 626 static jint android_view_MotionEvent_nativeGetFlags(jlong nativePtr) { 627 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 628 return event->getFlags(); 629 } 630 631 static void android_view_MotionEvent_nativeSetFlags(jlong nativePtr, jint flags) { 632 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 633 event->setFlags(flags); 634 } 635 636 static jint android_view_MotionEvent_nativeGetEdgeFlags(jlong nativePtr) { 637 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 638 return event->getEdgeFlags(); 639 } 640 641 static void android_view_MotionEvent_nativeSetEdgeFlags(jlong nativePtr, jint edgeFlags) { 642 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 643 event->setEdgeFlags(edgeFlags); 644 } 645 646 static jint android_view_MotionEvent_nativeGetMetaState(jlong nativePtr) { 647 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 648 return event->getMetaState(); 649 } 650 651 static jint android_view_MotionEvent_nativeGetButtonState(jlong nativePtr) { 652 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 653 return event->getButtonState(); 654 } 655 656 static void android_view_MotionEvent_nativeSetButtonState(jlong nativePtr, jint buttonState) { 657 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 658 event->setButtonState(buttonState); 659 } 660 661 static void android_view_MotionEvent_nativeOffsetLocation(jlong nativePtr, jfloat deltaX, 662 jfloat deltaY) { 663 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 664 return event->offsetLocation(deltaX, deltaY); 665 } 666 667 static jfloat android_view_MotionEvent_nativeGetXOffset(jlong nativePtr) { 668 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 669 return event->getXOffset(); 670 } 671 672 static jfloat android_view_MotionEvent_nativeGetYOffset(jlong nativePtr) { 673 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 674 return event->getYOffset(); 675 } 676 677 static jfloat android_view_MotionEvent_nativeGetXPrecision(jlong nativePtr) { 678 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 679 return event->getXPrecision(); 680 } 681 682 static jfloat android_view_MotionEvent_nativeGetYPrecision(jlong nativePtr) { 683 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 684 return event->getYPrecision(); 685 } 686 687 static jlong android_view_MotionEvent_nativeGetDownTimeNanos(jlong nativePtr) { 688 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 689 return event->getDownTime(); 690 } 691 692 static void android_view_MotionEvent_nativeSetDownTimeNanos(jlong nativePtr, jlong downTimeNanos) { 693 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 694 event->setDownTime(downTimeNanos); 695 } 696 697 static jint android_view_MotionEvent_nativeGetPointerCount(jlong nativePtr) { 698 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 699 return jint(event->getPointerCount()); 700 } 701 702 static jint android_view_MotionEvent_nativeFindPointerIndex(jlong nativePtr, jint pointerId) { 703 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 704 return jint(event->findPointerIndex(pointerId)); 705 } 706 707 static jint android_view_MotionEvent_nativeGetHistorySize(jlong nativePtr) { 708 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 709 return jint(event->getHistorySize()); 710 } 711 712 static void android_view_MotionEvent_nativeScale(jlong nativePtr, jfloat scale) { 713 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 714 event->scale(scale); 715 } 716 717 static void android_view_MotionEvent_nativeTransform(jlong nativePtr, jlong matrixPtr) { 718 MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); 719 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr); 720 721 static_assert(SkMatrix::kMScaleX == 0, "SkMatrix unexpected index"); 722 static_assert(SkMatrix::kMSkewX == 1, "SkMatrix unexpected index"); 723 static_assert(SkMatrix::kMTransX == 2, "SkMatrix unexpected index"); 724 static_assert(SkMatrix::kMSkewY == 3, "SkMatrix unexpected index"); 725 static_assert(SkMatrix::kMScaleY == 4, "SkMatrix unexpected index"); 726 static_assert(SkMatrix::kMTransY == 5, "SkMatrix unexpected index"); 727 static_assert(SkMatrix::kMPersp0 == 6, "SkMatrix unexpected index"); 728 static_assert(SkMatrix::kMPersp1 == 7, "SkMatrix unexpected index"); 729 static_assert(SkMatrix::kMPersp2 == 8, "SkMatrix unexpected index"); 730 float m[9]; 731 matrix->get9(m); 732 event->transform(m); 733 } 734 735 // ---------------------------------------------------------------------------- 736 737 static const JNINativeMethod gMotionEventMethods[] = { 738 /* name, signature, funcPtr */ 739 { "nativeInitialize", 740 "(JIIIIIIIFFFFJJI[Landroid/view/MotionEvent$PointerProperties;" 741 "[Landroid/view/MotionEvent$PointerCoords;)J", 742 (void*)android_view_MotionEvent_nativeInitialize }, 743 { "nativeDispose", 744 "(J)V", 745 (void*)android_view_MotionEvent_nativeDispose }, 746 { "nativeAddBatch", 747 "(JJ[Landroid/view/MotionEvent$PointerCoords;I)V", 748 (void*)android_view_MotionEvent_nativeAddBatch }, 749 { "nativeReadFromParcel", 750 "(JLandroid/os/Parcel;)J", 751 (void*)android_view_MotionEvent_nativeReadFromParcel }, 752 { "nativeWriteToParcel", 753 "(JLandroid/os/Parcel;)V", 754 (void*)android_view_MotionEvent_nativeWriteToParcel }, 755 { "nativeAxisToString", "(I)Ljava/lang/String;", 756 (void*)android_view_MotionEvent_nativeAxisToString }, 757 { "nativeAxisFromString", "(Ljava/lang/String;)I", 758 (void*)android_view_MotionEvent_nativeAxisFromString }, 759 { "nativeGetPointerProperties", 760 "(JILandroid/view/MotionEvent$PointerProperties;)V", 761 (void*)android_view_MotionEvent_nativeGetPointerProperties }, 762 { "nativeGetPointerCoords", 763 "(JIILandroid/view/MotionEvent$PointerCoords;)V", 764 (void*)android_view_MotionEvent_nativeGetPointerCoords }, 765 766 // --------------- @FastNative ---------------------- 767 { "nativeGetPointerId", 768 "(JI)I", 769 (void*)android_view_MotionEvent_nativeGetPointerId }, 770 { "nativeGetToolType", 771 "(JI)I", 772 (void*)android_view_MotionEvent_nativeGetToolType }, 773 { "nativeGetEventTimeNanos", 774 "(JI)J", 775 (void*)android_view_MotionEvent_nativeGetEventTimeNanos }, 776 { "nativeGetRawAxisValue", 777 "(JIII)F", 778 (void*)android_view_MotionEvent_nativeGetRawAxisValue }, 779 { "nativeGetAxisValue", 780 "(JIII)F", 781 (void*)android_view_MotionEvent_nativeGetAxisValue }, 782 783 // --------------- @CriticalNative ------------------ 784 785 { "nativeCopy", 786 "(JJZ)J", 787 (void*)android_view_MotionEvent_nativeCopy }, 788 { "nativeGetDeviceId", 789 "(J)I", 790 (void*)android_view_MotionEvent_nativeGetDeviceId }, 791 { "nativeGetSource", 792 "(J)I", 793 (void*)android_view_MotionEvent_nativeGetSource }, 794 { "nativeSetSource", 795 "(JI)I", 796 (void*)android_view_MotionEvent_nativeSetSource }, 797 { "nativeGetAction", 798 "(J)I", 799 (void*)android_view_MotionEvent_nativeGetAction }, 800 { "nativeSetAction", 801 "(JI)V", 802 (void*)android_view_MotionEvent_nativeSetAction }, 803 { "nativeGetActionButton", 804 "(J)I", 805 (void*)android_view_MotionEvent_nativeGetActionButton}, 806 { "nativeSetActionButton", 807 "(JI)V", 808 (void*)android_view_MotionEvent_nativeSetActionButton}, 809 { "nativeIsTouchEvent", 810 "(J)Z", 811 (void*)android_view_MotionEvent_nativeIsTouchEvent }, 812 { "nativeGetFlags", 813 "(J)I", 814 (void*)android_view_MotionEvent_nativeGetFlags }, 815 { "nativeSetFlags", 816 "(JI)V", 817 (void*)android_view_MotionEvent_nativeSetFlags }, 818 { "nativeGetEdgeFlags", 819 "(J)I", 820 (void*)android_view_MotionEvent_nativeGetEdgeFlags }, 821 { "nativeSetEdgeFlags", 822 "(JI)V", 823 (void*)android_view_MotionEvent_nativeSetEdgeFlags }, 824 { "nativeGetMetaState", 825 "(J)I", 826 (void*)android_view_MotionEvent_nativeGetMetaState }, 827 { "nativeGetButtonState", 828 "(J)I", 829 (void*)android_view_MotionEvent_nativeGetButtonState }, 830 { "nativeSetButtonState", 831 "(JI)V", 832 (void*)android_view_MotionEvent_nativeSetButtonState }, 833 { "nativeOffsetLocation", 834 "(JFF)V", 835 (void*)android_view_MotionEvent_nativeOffsetLocation }, 836 { "nativeGetXOffset", 837 "(J)F", 838 (void*)android_view_MotionEvent_nativeGetXOffset }, 839 { "nativeGetYOffset", 840 "(J)F", 841 (void*)android_view_MotionEvent_nativeGetYOffset }, 842 { "nativeGetXPrecision", 843 "(J)F", 844 (void*)android_view_MotionEvent_nativeGetXPrecision }, 845 { "nativeGetYPrecision", 846 "(J)F", 847 (void*)android_view_MotionEvent_nativeGetYPrecision }, 848 { "nativeGetDownTimeNanos", 849 "(J)J", 850 (void*)android_view_MotionEvent_nativeGetDownTimeNanos }, 851 { "nativeSetDownTimeNanos", 852 "(JJ)V", 853 (void*)android_view_MotionEvent_nativeSetDownTimeNanos }, 854 { "nativeGetPointerCount", 855 "(J)I", 856 (void*)android_view_MotionEvent_nativeGetPointerCount }, 857 { "nativeFindPointerIndex", 858 "(JI)I", 859 (void*)android_view_MotionEvent_nativeFindPointerIndex }, 860 { "nativeGetHistorySize", 861 "(J)I", 862 (void*)android_view_MotionEvent_nativeGetHistorySize }, 863 { "nativeScale", 864 "(JF)V", 865 (void*)android_view_MotionEvent_nativeScale }, 866 { "nativeTransform", 867 "(JJ)V", 868 (void*)android_view_MotionEvent_nativeTransform }, 869 }; 870 871 int register_android_view_MotionEvent(JNIEnv* env) { 872 int res = RegisterMethodsOrDie(env, "android/view/MotionEvent", gMotionEventMethods, 873 NELEM(gMotionEventMethods)); 874 875 gMotionEventClassInfo.clazz = FindClassOrDie(env, "android/view/MotionEvent"); 876 gMotionEventClassInfo.clazz = MakeGlobalRefOrDie(env, gMotionEventClassInfo.clazz); 877 878 gMotionEventClassInfo.obtain = GetStaticMethodIDOrDie(env, gMotionEventClassInfo.clazz, 879 "obtain", "()Landroid/view/MotionEvent;"); 880 gMotionEventClassInfo.recycle = GetMethodIDOrDie(env, gMotionEventClassInfo.clazz, 881 "recycle", "()V"); 882 gMotionEventClassInfo.mNativePtr = GetFieldIDOrDie(env, gMotionEventClassInfo.clazz, 883 "mNativePtr", "J"); 884 885 jclass clazz = FindClassOrDie(env, "android/view/MotionEvent$PointerCoords"); 886 887 gPointerCoordsClassInfo.mPackedAxisBits = GetFieldIDOrDie(env, clazz, "mPackedAxisBits", "J"); 888 gPointerCoordsClassInfo.mPackedAxisValues = GetFieldIDOrDie(env, clazz, "mPackedAxisValues", 889 "[F"); 890 gPointerCoordsClassInfo.x = GetFieldIDOrDie(env, clazz, "x", "F"); 891 gPointerCoordsClassInfo.y = GetFieldIDOrDie(env, clazz, "y", "F"); 892 gPointerCoordsClassInfo.pressure = GetFieldIDOrDie(env, clazz, "pressure", "F"); 893 gPointerCoordsClassInfo.size = GetFieldIDOrDie(env, clazz, "size", "F"); 894 gPointerCoordsClassInfo.touchMajor = GetFieldIDOrDie(env, clazz, "touchMajor", "F"); 895 gPointerCoordsClassInfo.touchMinor = GetFieldIDOrDie(env, clazz, "touchMinor", "F"); 896 gPointerCoordsClassInfo.toolMajor = GetFieldIDOrDie(env, clazz, "toolMajor", "F"); 897 gPointerCoordsClassInfo.toolMinor = GetFieldIDOrDie(env, clazz, "toolMinor", "F"); 898 gPointerCoordsClassInfo.orientation = GetFieldIDOrDie(env, clazz, "orientation", "F"); 899 900 clazz = FindClassOrDie(env, "android/view/MotionEvent$PointerProperties"); 901 902 gPointerPropertiesClassInfo.id = GetFieldIDOrDie(env, clazz, "id", "I"); 903 gPointerPropertiesClassInfo.toolType = GetFieldIDOrDie(env, clazz, "toolType", "I"); 904 905 return res; 906 } 907 908 } // namespace android 909