Minor refactoring before starting on velocity tracker changes. (8a90e6e3) · Commits · e / os / android_frameworks_base

core/java/android/view/VelocityTracker.java

+18 −0

Original line number	Original line	Diff line number	Diff line
	@@ -298,6 +298,24 @@ public final class VelocityTracker implements Poolable<VelocityTracker> {
	return estimate(time, yCoeff);		return estimate(time, yCoeff);
	}		}

			/**
			* Gets the X coefficient with the specified index.
			* @param index The index of the coefficient to return.
			* @return The X coefficient, or 0 if the index is greater than the degree.
			*/
			public float getXCoeff(int index) {
			return index <= degree ? xCoeff[index] : 0;
			}

			/**
			* Gets the Y coefficient with the specified index.
			* @param index The index of the coefficient to return.
			* @return The Y coefficient, or 0 if the index is greater than the degree.
			*/
			public float getYCoeff(int index) {
			return index <= degree ? yCoeff[index] : 0;
			}

	private float estimate(float time, float[] c) {		private float estimate(float time, float[] c) {
	float a = 0;		float a = 0;
	float scale = 1;		float scale = 1;

core/jni/android_view_VelocityTracker.cpp

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -21,6 +21,7 @@
	#include <android_runtime/AndroidRuntime.h>		#include <android_runtime/AndroidRuntime.h>
	#include <utils/Log.h>		#include <utils/Log.h>
	#include <androidfw/Input.h>		#include <androidfw/Input.h>
			#include <androidfw/VelocityTracker.h>
	#include "android_view_MotionEvent.h"		#include "android_view_MotionEvent.h"

include/androidfw/Input.h

+0 −177

Original line number	Original line	Diff line number	Diff line
	@@ -27,7 +27,6 @@
	#include <utils/Timers.h>		#include <utils/Timers.h>
	#include <utils/RefBase.h>		#include <utils/RefBase.h>
	#include <utils/String8.h>		#include <utils/String8.h>
	#include <utils/BitSet.h>

	#ifdef HAVE_ANDROID_OS		#ifdef HAVE_ANDROID_OS
	class SkMatrix;		class SkMatrix;
	@@ -607,182 +606,6 @@ private:
	Vector<MotionEvent*> mMotionEventPool;		Vector<MotionEvent*> mMotionEventPool;
	};		};

	/*
	* Calculates the velocity of pointer movements over time.
	*/
	class VelocityTracker {
	public:
	// Default polynomial degree. (used by getVelocity)
	static const uint32_t DEFAULT_DEGREE = 2;

	// Default sample horizon. (used by getVelocity)
	// We don't use too much history by default since we want to react to quick
	// changes in direction.
	static const nsecs_t DEFAULT_HORIZON = 100 * 1000000; // 100 ms

	struct Position {
	float x, y;
	};

	struct Estimator {
	static const size_t MAX_DEGREE = 2;

	// Polynomial coefficients describing motion in X and Y.
	float xCoeff[MAX_DEGREE + 1], yCoeff[MAX_DEGREE + 1];

	// Polynomial degree (number of coefficients), or zero if no information is
	// available.
	uint32_t degree;

	// Confidence (coefficient of determination), between 0 (no fit) and 1 (perfect fit).
	float confidence;

	inline void clear() {
	degree = 0;
	confidence = 0;
	for (size_t i = 0; i <= MAX_DEGREE; i++) {
	xCoeff[i] = 0;
	yCoeff[i] = 0;
	}
	}
	};

	VelocityTracker();

	// Resets the velocity tracker state.
	void clear();

	// Resets the velocity tracker state for specific pointers.
	// Call this method when some pointers have changed and may be reusing
	// an id that was assigned to a different pointer earlier.
	void clearPointers(BitSet32 idBits);

	// Adds movement information for a set of pointers.
	// The idBits bitfield specifies the pointer ids of the pointers whose positions
	// are included in the movement.
	// The positions array contains position information for each pointer in order by
	// increasing id. Its size should be equal to the number of one bits in idBits.
	void addMovement(nsecs_t eventTime, BitSet32 idBits, const Position* positions);

	// Adds movement information for all pointers in a MotionEvent, including historical samples.
	void addMovement(const MotionEvent* event);

	// Gets the velocity of the specified pointer id in position units per second.
	// Returns false and sets the velocity components to zero if there is
	// insufficient movement information for the pointer.
	bool getVelocity(uint32_t id, float* outVx, float* outVy) const;

	// Gets a quadratic estimator for the movements of the specified pointer id.
	// Returns false and clears the estimator if there is no information available
	// about the pointer.
	bool getEstimator(uint32_t id, uint32_t degree, nsecs_t horizon,
	Estimator* outEstimator) const;

	// Gets the active pointer id, or -1 if none.
	inline int32_t getActivePointerId() const { return mActivePointerId; }

	// Gets a bitset containing all pointer ids from the most recent movement.
	inline BitSet32 getCurrentPointerIdBits() const { return mMovements[mIndex].idBits; }

	private:
	// Number of samples to keep.
	static const uint32_t HISTORY_SIZE = 20;

	struct Movement {
	nsecs_t eventTime;
	BitSet32 idBits;
	Position positions[MAX_POINTERS];

	inline const Position& getPosition(uint32_t id) const {
	return positions[idBits.getIndexOfBit(id)];
	}
	};

	uint32_t mIndex;
	Movement mMovements[HISTORY_SIZE];
	int32_t mActivePointerId;
	};


	/*
	* Specifies parameters that govern pointer or wheel acceleration.
	*/
	struct VelocityControlParameters {
	// A scale factor that is multiplied with the raw velocity deltas
	// prior to applying any other velocity control factors. The scale
	// factor should be used to adapt the input device resolution
	// (eg. counts per inch) to the output device resolution (eg. pixels per inch).
	//
	// Must be a positive value.
	// Default is 1.0 (no scaling).
	float scale;

	// The scaled speed at which acceleration begins to be applied.
	// This value establishes the upper bound of a low speed regime for
	// small precise motions that are performed without any acceleration.
	//
	// Must be a non-negative value.
	// Default is 0.0 (no low threshold).
	float lowThreshold;

	// The scaled speed at which maximum acceleration is applied.
	// The difference between highThreshold and lowThreshold controls
	// the range of speeds over which the acceleration factor is interpolated.
	// The wider the range, the smoother the acceleration.
	//
	// Must be a non-negative value greater than or equal to lowThreshold.
	// Default is 0.0 (no high threshold).
	float highThreshold;

	// The acceleration factor.
	// When the speed is above the low speed threshold, the velocity will scaled
	// by an interpolated value between 1.0 and this amount.
	//
	// Must be a positive greater than or equal to 1.0.
	// Default is 1.0 (no acceleration).
	float acceleration;

	VelocityControlParameters() :
	scale(1.0f), lowThreshold(0.0f), highThreshold(0.0f), acceleration(1.0f) {
	}

	VelocityControlParameters(float scale, float lowThreshold,
	float highThreshold, float acceleration) :
	scale(scale), lowThreshold(lowThreshold),
	highThreshold(highThreshold), acceleration(acceleration) {
	}
	};

	/*
	* Implements mouse pointer and wheel speed control and acceleration.
	*/
	class VelocityControl {
	public:
	VelocityControl();

	/* Sets the various parameters. */
	void setParameters(const VelocityControlParameters& parameters);

	/* Resets the current movement counters to zero.
	* This has the effect of nullifying any acceleration. */
	void reset();

	/* Translates a raw movement delta into an appropriately
	* scaled / accelerated delta based on the current velocity. */
	void move(nsecs_t eventTime, float* deltaX, float* deltaY);

	private:
	// If no movements are received within this amount of time,
	// we assume the movement has stopped and reset the movement counters.
	static const nsecs_t STOP_TIME = 500 * 1000000; // 500 ms

	VelocityControlParameters mParameters;

	nsecs_t mLastMovementTime;
	VelocityTracker::Position mRawPosition;
	VelocityTracker mVelocityTracker;
	};

	} // namespace android		} // namespace android

	#endif // _ANDROIDFW_INPUT_H		#endif // _ANDROIDFW_INPUT_H

include/androidfw/VelocityControl.h

0 → 100644

+107 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2012 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.
			*/

			#ifndef _ANDROIDFW_VELOCITY_CONTROL_H
			#define _ANDROIDFW_VELOCITY_CONTROL_H

			#include <androidfw/Input.h>
			#include <androidfw/VelocityTracker.h>
			#include <utils/Timers.h>

			namespace android {

			/*
			* Specifies parameters that govern pointer or wheel acceleration.
			*/
			struct VelocityControlParameters {
			// A scale factor that is multiplied with the raw velocity deltas
			// prior to applying any other velocity control factors. The scale
			// factor should be used to adapt the input device resolution
			// (eg. counts per inch) to the output device resolution (eg. pixels per inch).
			//
			// Must be a positive value.
			// Default is 1.0 (no scaling).
			float scale;

			// The scaled speed at which acceleration begins to be applied.
			// This value establishes the upper bound of a low speed regime for
			// small precise motions that are performed without any acceleration.
			//
			// Must be a non-negative value.
			// Default is 0.0 (no low threshold).
			float lowThreshold;

			// The scaled speed at which maximum acceleration is applied.
			// The difference between highThreshold and lowThreshold controls
			// the range of speeds over which the acceleration factor is interpolated.
			// The wider the range, the smoother the acceleration.
			//
			// Must be a non-negative value greater than or equal to lowThreshold.
			// Default is 0.0 (no high threshold).
			float highThreshold;

			// The acceleration factor.
			// When the speed is above the low speed threshold, the velocity will scaled
			// by an interpolated value between 1.0 and this amount.
			//
			// Must be a positive greater than or equal to 1.0.
			// Default is 1.0 (no acceleration).
			float acceleration;

			VelocityControlParameters() :
			scale(1.0f), lowThreshold(0.0f), highThreshold(0.0f), acceleration(1.0f) {
			}

			VelocityControlParameters(float scale, float lowThreshold,
			float highThreshold, float acceleration) :
			scale(scale), lowThreshold(lowThreshold),
			highThreshold(highThreshold), acceleration(acceleration) {
			}
			};

			/*
			* Implements mouse pointer and wheel speed control and acceleration.
			*/
			class VelocityControl {
			public:
			VelocityControl();

			/* Sets the various parameters. */
			void setParameters(const VelocityControlParameters& parameters);

			/* Resets the current movement counters to zero.
			* This has the effect of nullifying any acceleration. */
			void reset();

			/* Translates a raw movement delta into an appropriately
			* scaled / accelerated delta based on the current velocity. */
			void move(nsecs_t eventTime, float* deltaX, float* deltaY);

			private:
			// If no movements are received within this amount of time,
			// we assume the movement has stopped and reset the movement counters.
			static const nsecs_t STOP_TIME = 500 * 1000000; // 500 ms

			VelocityControlParameters mParameters;

			nsecs_t mLastMovementTime;
			VelocityTracker::Position mRawPosition;
			VelocityTracker mVelocityTracker;
			};

			} // namespace android

			#endif // _ANDROIDFW_VELOCITY_CONTROL_H

include/androidfw/VelocityTracker.h

0 → 100644

+124 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2012 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.
			*/

			#ifndef _ANDROIDFW_VELOCITY_TRACKER_H
			#define _ANDROIDFW_VELOCITY_TRACKER_H

			#include <androidfw/Input.h>
			#include <utils/Timers.h>
			#include <utils/BitSet.h>

			namespace android {

			/*
			* Calculates the velocity of pointer movements over time.
			*/
			class VelocityTracker {
			public:
			// Default polynomial degree. (used by getVelocity)
			static const uint32_t DEFAULT_DEGREE = 2;

			// Default sample horizon. (used by getVelocity)
			// We don't use too much history by default since we want to react to quick
			// changes in direction.
			static const nsecs_t DEFAULT_HORIZON = 100 * 1000000; // 100 ms

			struct Position {
			float x, y;
			};

			struct Estimator {
			static const size_t MAX_DEGREE = 2;

			// Polynomial coefficients describing motion in X and Y.
			float xCoeff[MAX_DEGREE + 1], yCoeff[MAX_DEGREE + 1];

			// Polynomial degree (number of coefficients), or zero if no information is
			// available.
			uint32_t degree;

			// Confidence (coefficient of determination), between 0 (no fit) and 1 (perfect fit).
			float confidence;

			inline void clear() {
			degree = 0;
			confidence = 0;
			for (size_t i = 0; i <= MAX_DEGREE; i++) {
			xCoeff[i] = 0;
			yCoeff[i] = 0;
			}
			}
			};

			VelocityTracker();

			// Resets the velocity tracker state.
			void clear();

			// Resets the velocity tracker state for specific pointers.
			// Call this method when some pointers have changed and may be reusing
			// an id that was assigned to a different pointer earlier.
			void clearPointers(BitSet32 idBits);

			// Adds movement information for a set of pointers.
			// The idBits bitfield specifies the pointer ids of the pointers whose positions
			// are included in the movement.
			// The positions array contains position information for each pointer in order by
			// increasing id. Its size should be equal to the number of one bits in idBits.
			void addMovement(nsecs_t eventTime, BitSet32 idBits, const Position* positions);

			// Adds movement information for all pointers in a MotionEvent, including historical samples.
			void addMovement(const MotionEvent* event);

			// Gets the velocity of the specified pointer id in position units per second.
			// Returns false and sets the velocity components to zero if there is
			// insufficient movement information for the pointer.
			bool getVelocity(uint32_t id, float* outVx, float* outVy) const;

			// Gets a quadratic estimator for the movements of the specified pointer id.
			// Returns false and clears the estimator if there is no information available
			// about the pointer.
			bool getEstimator(uint32_t id, uint32_t degree, nsecs_t horizon,
			Estimator* outEstimator) const;

			// Gets the active pointer id, or -1 if none.
			inline int32_t getActivePointerId() const { return mActivePointerId; }

			// Gets a bitset containing all pointer ids from the most recent movement.
			inline BitSet32 getCurrentPointerIdBits() const { return mMovements[mIndex].idBits; }

			private:
			// Number of samples to keep.
			static const uint32_t HISTORY_SIZE = 20;

			struct Movement {
			nsecs_t eventTime;
			BitSet32 idBits;
			Position positions[MAX_POINTERS];

			inline const Position& getPosition(uint32_t id) const {
			return positions[idBits.getIndexOfBit(id)];
			}
			};

			uint32_t mIndex;
			Movement mMovements[HISTORY_SIZE];
			int32_t mActivePointerId;
			};

			} // namespace android

			#endif // _ANDROIDFW_VELOCITY_TRACKER_H