Android example source code file (VelocityTest.java)

This example Android source code file (VelocityTest.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Android by Example" ^TM.

Java - Android tags/keywords

accelerateinterpolator, android, decelerateinterpolator, expected, instrumentationtestcase, linearinterpolator, mediumtest, motionevent, test, ui, velocity, velocitytest, velocitytracker, view

The VelocityTest.java Android example source code

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.frameworktest.view;

import junit.framework.Assert;

import android.test.InstrumentationTestCase;
import android.test.suitebuilder.annotation.MediumTest;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.animation.AccelerateInterpolator;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.Interpolator;
import android.view.animation.LinearInterpolator;

/**
 * Exercises {@link android.view.VelocityTracker} to compute correct velocity.<br>
 * To launch this test, use :<br>
 * <code>./development/testrunner/runtest.py framework -c com.android.frameworktest.view.VelocityTest
 */
public class VelocityTest extends InstrumentationTestCase {

    @MediumTest
    public void testInitialCondiditions() {
        VelocityTracker vt = VelocityTracker.obtain();
        assertNotNull(vt);
        vt.recycle();
    }

    /**
     * Test that {@link android.view.VelocityTracker}.clear() clears
     * the previous values after a call to computeCurrentVelocity()
     */
    @MediumTest
    public void testClear() {
        long t = System.currentTimeMillis();
        VelocityTracker vt = VelocityTracker.obtain();
        drag(vt, 100, 200, 100, 200, 10, t, 300);
        vt.computeCurrentVelocity(1);
        assertFalse("Velocity should not be null", vt.getXVelocity() == 0.0f);
        assertFalse("Velocity should not be null", vt.getYVelocity() == 0.0f);
        vt.clear();
        vt.computeCurrentVelocity(1);
        assertEquals(0.0f, vt.getXVelocity());
        assertEquals(0.0f, vt.getYVelocity());
        vt.recycle();
    }

    @MediumTest
    public void testDragAcceleration () {
        long t = System.currentTimeMillis();
        VelocityTracker vt = VelocityTracker.obtain();
        drag(vt, 100, 200, 100, 200, 15, t, 400, new AccelerateInterpolator());
        vt.computeCurrentVelocity(1000);
        assertGreater(250.0f, vt.getXVelocity());
        assertGreater(250.0f, vt.getYVelocity());
        vt.recycle();
    }

    @MediumTest
    public void testDragDeceleration () {
        long t = System.currentTimeMillis();
        VelocityTracker vt = VelocityTracker.obtain();
        drag(vt, 100, 200, 100, 200, 15, t, 400, new DecelerateInterpolator());
        vt.computeCurrentVelocity(1000);
        assertLower(250.0f, vt.getXVelocity());
        assertLower(250.0f, vt.getYVelocity());
        vt.recycle();
    }

    @MediumTest
    public void testDragLinearHorizontal() {
        long t = System.currentTimeMillis();
        VelocityTracker vt = VelocityTracker.obtain();
        // 100px in 400ms => 250px/s
        drag(vt, 100, 200, 200, 200, 15, t, 400);
        vt.computeCurrentVelocity(1000);
        assertEquals(0.0f, vt.getYVelocity());
        assertEqualFuzzy(250.0f, vt.getXVelocity(), 4f);
        vt.recycle();
    }

    @MediumTest
    public void testDragLinearVertical() {
        long t = System.currentTimeMillis();
        VelocityTracker vt = VelocityTracker.obtain();
        // 100px in 400ms => 250px/s
        drag(vt, 200, 200, 100, 200, 15, t, 400);
        vt.computeCurrentVelocity(1000);
        assertEquals(0.0f, vt.getXVelocity());
        assertEqualFuzzy(250.0f, vt.getYVelocity(), 4f);
        vt.recycle();
    }

    /**
     * Test dragging with two points only
     * (velocity must be an exact value)
     */
    @MediumTest
    public void testDragWith2Points () {
        long t = System.currentTimeMillis();
        VelocityTracker vt = VelocityTracker.obtain();
        // 100px, 2 steps, 100ms => 1000px/s
        drag(vt, 100, 200, 100, 200, 2, t, 100);
        vt.computeCurrentVelocity(1000);
        assertEquals(1000.0f, vt.getXVelocity());
        assertEquals(1000.0f, vt.getYVelocity());
        vt.recycle();
    }

    /**
     * Velocity is independent of the number of points used during
     * the same interval
     */
    @MediumTest
    public void testStabilityInNbPoints () {
        long t = System.currentTimeMillis();
        VelocityTracker vt = VelocityTracker.obtain();
        drag(vt, 100, 200, 100, 200, 10, t, 400); // 10 steps over 400ms
        vt.computeCurrentVelocity(1);
        float firstX = vt.getXVelocity();
        float firstY = vt.getYVelocity();
        vt.clear();
        drag(vt, 100, 200, 100, 200, 20, t, 400); // 20 steps over 400ms
        vt.computeCurrentVelocity(1);
        float secondX = vt.getXVelocity();
        float secondY = vt.getYVelocity();
        assertEqualFuzzy(firstX, secondX, 0.1f);
        assertEqualFuzzy(firstY, secondY, 0.1f);
        vt.recycle();
    }

    /**
     * Velocity is independent of the time when the events occurs,
     * it only depends on delays between the events.
     */
    @MediumTest
    public void testStabilityInTime () {
        long t = System.currentTimeMillis();
        VelocityTracker vt = VelocityTracker.obtain();
        drag(vt, 100, 200, 100, 200, 10, t, 400);
        vt.computeCurrentVelocity(1);
        float firstX = vt.getXVelocity();
        float firstY = vt.getYVelocity();
        vt.clear();
        drag(vt, 100, 200, 100, 200, 10, t + 3600*1000, 400); // on hour later
        vt.computeCurrentVelocity(1);
        float secondX = vt.getXVelocity();
        float secondY = vt.getYVelocity();
        assertEqualFuzzy(firstX, secondX, 0.1f);
        assertEqualFuzzy(firstY, secondY, 0.1f);
        vt.recycle();
    }

    /**
     * Velocity is independent of the position of the events,
     * it only depends on their relative distance.
     */
    @MediumTest
    public void testStabilityInSpace () {
        long t = System.currentTimeMillis();
        VelocityTracker vt = VelocityTracker.obtain();
        drag(vt, 100, 200, 100, 200, 10, t, 400);
        vt.computeCurrentVelocity(1);
        float firstX = vt.getXVelocity();
        float firstY = vt.getYVelocity();
        vt.clear();
        drag(vt, 200, 300, 200, 300, 10, t, 400); // 100px further
        vt.computeCurrentVelocity(1);
        float secondX = vt.getXVelocity();
        float secondY = vt.getYVelocity();
        assertEqualFuzzy(firstX, secondX, 0.1f);
        assertEqualFuzzy(firstY, secondY, 0.1f);
        vt.recycle();
    }

    /**
     * Test that calls to {@link android.view.VelocityTracker}.computeCurrentVelocity()
     * will output same values when using the same data.
     */
    @MediumTest
    public void testStabilityOfComputation() {
        long t = System.currentTimeMillis();
        VelocityTracker vt = VelocityTracker.obtain();
        drag(vt, 100, 200, 100, 200, 10, t, 300);
        vt.computeCurrentVelocity(1);
        float firstX = vt.getXVelocity();
        float firstY = vt.getYVelocity();
        vt.computeCurrentVelocity(1);
        float secondX = vt.getXVelocity();
        float secondY = vt.getYVelocity();
        assertEquals(firstX, secondX);
        assertEquals(firstY, secondY);
        vt.recycle();
    }

    /**
     * Test the units parameter of {@link android.view.VelocityTracker}.computeCurrentVelocity()
     */
    @MediumTest
    public void testStabilityOfUnits() {
        long t = System.currentTimeMillis();
        VelocityTracker vt = VelocityTracker.obtain();
        drag(vt, 100, 200, 100, 200, 10, t, 300);
        vt.computeCurrentVelocity(1);
        float firstX = vt.getXVelocity();
        float firstY = vt.getYVelocity();
        vt.computeCurrentVelocity(1000);
        float secondX = vt.getXVelocity();
        float secondY = vt.getYVelocity();
        assertEqualFuzzy(firstX, secondX / 1000.0f, 0.1f);
        assertEqualFuzzy(firstY, secondY / 1000.0f, 0.1f);
        vt.recycle();
    }

    /**
     * Simulate a drag by giving directly MotionEvents to
     * the VelocityTracker using a linear interpolator
     */
    private void drag(VelocityTracker vt, int startX, int endX, int startY, int endY, int steps,
            long startime, int duration) {
        drag(vt, startX, endX, startY, endY, steps, startime, duration, new LinearInterpolator());
    }

    /**
     * Simulate a drag by giving directly MotionEvents to
     * the VelocityTracker using a given interpolator
     */
    private void drag(VelocityTracker vt, int startX, int endX, int startY, int endY, int steps,
            long startime, int duration, Interpolator interpolator) {
        addMotionEvent(vt, startX, startY, startime, MotionEvent.ACTION_DOWN);
        float dt = duration / (float)steps;
        int distX = endX - startX;
        int distY = endY - startY;
        for (int i=1; i<steps-1; i++) {
            float ii = interpolator.getInterpolation(i / (float)steps);
            int x = (int) (startX + distX * ii);
            int y = (int) (startY + distY * ii);
            long time = startime + (int) (i * dt);
            addMotionEvent(vt, x, y, time, MotionEvent.ACTION_MOVE);
        }
        addMotionEvent(vt, endX, endY, startime + duration, MotionEvent.ACTION_UP);
    }

    private void addMotionEvent(VelocityTracker vt, int x, int y, long time, int action) {
        MotionEvent me = MotionEvent.obtain(time, time, action, x, y, 0);
        vt.addMovement(me);
        me.recycle();
    }

    /**
     * Float imprecision of the average computations and filtering
     * (removing last MotionEvent for N > 3) implies that tests
     *  accepts some approximated values.
     */
    private void assertEqualFuzzy(float expected, float actual, float threshold) {
        boolean fuzzyEqual = actual >= expected - threshold && actual <= expected + threshold;
        Assert.assertTrue("Expected: <"+expected+"> but was: <"+actual+
                "> while accepting a variation of: <"+threshold+">", fuzzyEqual);
    }

    private void assertGreater(float minExpected, float actual) {
        Assert.assertTrue("Expected: minimum <"+minExpected+"> but was: <"+actual+">",
                actual > minExpected);
    }

    private void assertLower(float maxExpected, float actual) {
        Assert.assertTrue("Expected: maximum <"+maxExpected+"> but was: <"+actual+">",
                actual < maxExpected);
    }
}