core/jni/android_view_VelocityTracker.cpp

   1 /*
   2  * Copyright (C) 2011 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 "VelocityTracker-JNI"
  18
  19 #include "JNIHelp.h"
  20
  21 #include <android_runtime/AndroidRuntime.h>
  22 #include <utils/Log.h>
  23 #include <input/Input.h>
  24 #include <input/VelocityTracker.h>
  25 #include "android_view_MotionEvent.h"
  26
  27 #include <ScopedUtfChars.h>
  28
  29 #include "core_jni_helpers.h"
  30
  31 namespace android {
  32
  33 // Special constant to request the velocity of the active pointer.
  34 static const int ACTIVE_POINTER_ID = -1;
  35
  36 static struct {
  37     jfieldID xCoeff;
  38     jfieldID yCoeff;
  39     jfieldID degree;
  40     jfieldID confidence;
  41 } gEstimatorClassInfo;
  42
  43
  44 // --- VelocityTrackerState ---
  45
  46 class VelocityTrackerState {
  47 public:
  48     VelocityTrackerState(const char* strategy);
  49
  50     void clear();
  51     void addMovement(const MotionEvent* event);
  52     void computeCurrentVelocity(int32_t units, float maxVelocity);
  53     void getVelocity(int32_t id, float* outVx, float* outVy);
  54     bool getEstimator(int32_t id, VelocityTracker::Estimator* outEstimator);
  55
  56 private:
  57     struct Velocity {
  58         float vx, vy;
  59     };
  60
  61     VelocityTracker mVelocityTracker;
  62     int32_t mActivePointerId;
  63     BitSet32 mCalculatedIdBits;
  64     Velocity mCalculatedVelocity[MAX_POINTERS];
  65 };
  66
  67 VelocityTrackerState::VelocityTrackerState(const char* strategy) :
  68         mVelocityTracker(strategy), mActivePointerId(-1) {
  69 }
  70
  71 void VelocityTrackerState::clear() {
  72     mVelocityTracker.clear();
  73     mActivePointerId = -1;
  74     mCalculatedIdBits.clear();
  75 }
  76
  77 void VelocityTrackerState::addMovement(const MotionEvent* event) {
  78     mVelocityTracker.addMovement(event);
  79 }
  80
  81 void VelocityTrackerState::computeCurrentVelocity(int32_t units, float maxVelocity) {
  82     BitSet32 idBits(mVelocityTracker.getCurrentPointerIdBits());
  83     mCalculatedIdBits = idBits;
  84
  85     for (uint32_t index = 0; !idBits.isEmpty(); index++) {
  86         uint32_t id = idBits.clearFirstMarkedBit();
  87
  88         float vx, vy;
  89         mVelocityTracker.getVelocity(id, &vx, &vy);
  90
  91         vx = vx * units / 1000;
  92         vy = vy * units / 1000;
  93
  94         if (vx > maxVelocity) {
  95             vx = maxVelocity;
  96         } else if (vx < -maxVelocity) {
  97             vx = -maxVelocity;
  98         }
  99         if (vy > maxVelocity) {
 100             vy = maxVelocity;
 101         } else if (vy < -maxVelocity) {
 102             vy = -maxVelocity;
 103         }
 104
 105         Velocity& velocity = mCalculatedVelocity[index];
 106         velocity.vx = vx;
 107         velocity.vy = vy;
 108     }
 109 }
 110
 111 void VelocityTrackerState::getVelocity(int32_t id, float* outVx, float* outVy) {
 112     if (id == ACTIVE_POINTER_ID) {
 113         id = mVelocityTracker.getActivePointerId();
 114     }
 115
 116     float vx, vy;
 117     if (id >= 0 && id <= MAX_POINTER_ID && mCalculatedIdBits.hasBit(id)) {
 118         uint32_t index = mCalculatedIdBits.getIndexOfBit(id);
 119         const Velocity& velocity = mCalculatedVelocity[index];
 120         vx = velocity.vx;
 121         vy = velocity.vy;
 122     } else {
 123         vx = 0;
 124         vy = 0;
 125     }
 126
 127     if (outVx) {
 128         *outVx = vx;
 129     }
 130     if (outVy) {
 131         *outVy = vy;
 132     }
 133 }
 134
 135 bool VelocityTrackerState::getEstimator(int32_t id, VelocityTracker::Estimator* outEstimator) {
 136     return mVelocityTracker.getEstimator(id, outEstimator);
 137 }
 138
 139
 140 // --- JNI Methods ---
 141
 142 static jlong android_view_VelocityTracker_nativeInitialize(JNIEnv* env, jclass clazz,
 143         jstring strategyStr) {
 144     if (strategyStr) {
 145         ScopedUtfChars strategy(env, strategyStr);
 146         return reinterpret_cast<jlong>(new VelocityTrackerState(strategy.c_str()));
 147     }
 148     return reinterpret_cast<jlong>(new VelocityTrackerState(NULL));
 149 }
 150
 151 static void android_view_VelocityTracker_nativeDispose(JNIEnv* env, jclass clazz, jlong ptr) {
 152     VelocityTrackerState* state = reinterpret_cast<VelocityTrackerState*>(ptr);
 153     delete state;
 154 }
 155
 156 static void android_view_VelocityTracker_nativeClear(JNIEnv* env, jclass clazz, jlong ptr) {
 157     VelocityTrackerState* state = reinterpret_cast<VelocityTrackerState*>(ptr);
 158     state->clear();
 159 }
 160
 161 static void android_view_VelocityTracker_nativeAddMovement(JNIEnv* env, jclass clazz, jlong ptr,
 162         jobject eventObj) {
 163     const MotionEvent* event = android_view_MotionEvent_getNativePtr(env, eventObj);
 164     if (!event) {
 165         ALOGW("nativeAddMovement failed because MotionEvent was finalized.");
 166         return;
 167     }
 168
 169     VelocityTrackerState* state = reinterpret_cast<VelocityTrackerState*>(ptr);
 170     state->addMovement(event);
 171 }
 172
 173 static void android_view_VelocityTracker_nativeComputeCurrentVelocity(JNIEnv* env, jclass clazz,
 174         jlong ptr, jint units, jfloat maxVelocity) {
 175     VelocityTrackerState* state = reinterpret_cast<VelocityTrackerState*>(ptr);
 176     state->computeCurrentVelocity(units, maxVelocity);
 177 }
 178
 179 static jfloat android_view_VelocityTracker_nativeGetXVelocity(JNIEnv* env, jclass clazz,
 180         jlong ptr, jint id) {
 181     VelocityTrackerState* state = reinterpret_cast<VelocityTrackerState*>(ptr);
 182     float vx;
 183     state->getVelocity(id, &vx, NULL);
 184     return vx;
 185 }
 186
 187 static jfloat android_view_VelocityTracker_nativeGetYVelocity(JNIEnv* env, jclass clazz,
 188         jlong ptr, jint id) {
 189     VelocityTrackerState* state = reinterpret_cast<VelocityTrackerState*>(ptr);
 190     float vy;
 191     state->getVelocity(id, NULL, &vy);
 192     return vy;
 193 }
 194
 195 static jboolean android_view_VelocityTracker_nativeGetEstimator(JNIEnv* env, jclass clazz,
 196         jlong ptr, jint id, jobject outEstimatorObj) {
 197     VelocityTrackerState* state = reinterpret_cast<VelocityTrackerState*>(ptr);
 198     VelocityTracker::Estimator estimator;
 199     bool result = state->getEstimator(id, &estimator);
 200
 201     jfloatArray xCoeffObj = jfloatArray(env->GetObjectField(outEstimatorObj,
 202             gEstimatorClassInfo.xCoeff));
 203     jfloatArray yCoeffObj = jfloatArray(env->GetObjectField(outEstimatorObj,
 204             gEstimatorClassInfo.yCoeff));
 205
 206     env->SetFloatArrayRegion(xCoeffObj, 0, VelocityTracker::Estimator::MAX_DEGREE + 1,
 207             estimator.xCoeff);
 208     env->SetFloatArrayRegion(yCoeffObj, 0, VelocityTracker::Estimator::MAX_DEGREE + 1,
 209             estimator.yCoeff);
 210     env->SetIntField(outEstimatorObj, gEstimatorClassInfo.degree, estimator.degree);
 211     env->SetFloatField(outEstimatorObj, gEstimatorClassInfo.confidence, estimator.confidence);
 212     return result;
 213 }
 214
 215
 216 // --- JNI Registration ---
 217
 218 static JNINativeMethod gVelocityTrackerMethods[] = {
 219     /* name, signature, funcPtr */
 220     { "nativeInitialize",
 221             "(Ljava/lang/String;)J",
 222             (void*)android_view_VelocityTracker_nativeInitialize },
 223     { "nativeDispose",
 224             "(J)V",
 225             (void*)android_view_VelocityTracker_nativeDispose },
 226     { "nativeClear",
 227             "(J)V",
 228             (void*)android_view_VelocityTracker_nativeClear },
 229     { "nativeAddMovement",
 230             "(JLandroid/view/MotionEvent;)V",
 231             (void*)android_view_VelocityTracker_nativeAddMovement },
 232     { "nativeComputeCurrentVelocity",
 233             "(JIF)V",
 234             (void*)android_view_VelocityTracker_nativeComputeCurrentVelocity },
 235     { "nativeGetXVelocity",
 236             "(JI)F",
 237             (void*)android_view_VelocityTracker_nativeGetXVelocity },
 238     { "nativeGetYVelocity",
 239             "(JI)F",
 240             (void*)android_view_VelocityTracker_nativeGetYVelocity },
 241     { "nativeGetEstimator",
 242             "(JILandroid/view/VelocityTracker$Estimator;)Z",
 243             (void*)android_view_VelocityTracker_nativeGetEstimator },
 244 };
 245
 246 int register_android_view_VelocityTracker(JNIEnv* env) {
 247     int res = RegisterMethodsOrDie(env, "android/view/VelocityTracker", gVelocityTrackerMethods,
 248                                    NELEM(gVelocityTrackerMethods));
 249
 250     jclass clazz = FindClassOrDie(env, "android/view/VelocityTracker$Estimator");
 251
 252     gEstimatorClassInfo.xCoeff = GetFieldIDOrDie(env, clazz, "xCoeff", "[F");
 253     gEstimatorClassInfo.yCoeff = GetFieldIDOrDie(env, clazz, "yCoeff", "[F");
 254     gEstimatorClassInfo.degree = GetFieldIDOrDie(env, clazz, "degree", "I");
 255     gEstimatorClassInfo.confidence = GetFieldIDOrDie(env, clazz, "confidence", "F");
 256
 257     return res;
 258 }
 259
 260 } // namespace android