Я разрабатывал управление масштабированием в Android на основе учебника: Учебник по Android-зуму с одним пальцем
public abstract class Dynamics {
/**
* The maximum delta time, in milliseconds, between two updates
*/
private static final int MAX_TIMESTEP = 50;
/** The current position */
protected float mPosition;
/** The current velocity */
protected float mVelocity;
/** The current maximum position */
protected float mMaxPosition = Float.MAX_VALUE;
/** The current minimum position */
protected float mMinPosition = -Float.MAX_VALUE;
/** The time of the last update */
protected long mLastTime = 0;
/**
* Sets the state of the dynamics object. Should be called before starting
* to call update.
*
* @param position The current position.
* @param velocity The current velocity in pixels per second.
* @param now The current time
*/
public void setState(final float position, final float velocity, final long now) {
mVelocity = velocity;
mPosition = position;
mLastTime = now;
}
/**
* Returns the current position. Normally used after a call to update() in
* order to get the updated position.
*
* @return The current position
*/
public float getPosition() {
return mPosition;
}
/**
* Gets the velocity. Unit is in pixels per second.
*
* @return The velocity in pixels per second
*/
public float getVelocity() {
return mVelocity;
}
/**
* Used to find out if the list is at rest, that is, has no velocity and is
* inside the the limits. Normally used to know if more calls to update are
* needed.
*
* @param velocityTolerance Velocity is regarded as 0 if less than
* velocityTolerance
* @param positionTolerance Position is regarded as inside the limits even
* if positionTolerance above or below
*
* @return true if list is at rest, false otherwise
*/
public boolean isAtRest(final float velocityTolerance, final float positionTolerance) {
final boolean standingStill = Math.abs(mVelocity) < velocityTolerance;
final boolean withinLimits = mPosition - positionTolerance < mMaxPosition
&& mPosition + positionTolerance > mMinPosition;
return standingStill && withinLimits;
}
/**
* Sets the maximum position.
*
* @param maxPosition The maximum value of the position
*/
public void setMaxPosition(final float maxPosition) {
mMaxPosition = maxPosition;
}
/**
* Sets the minimum position.
*
* @param minPosition The minimum value of the position
*/
public void setMinPosition(final float minPosition) {
mMinPosition = minPosition;
}
/**
* Updates the position and velocity.
*
* @param now The current time
*/
public void update(final long now) {
int dt = (int)(now - mLastTime);
if (dt > MAX_TIMESTEP) {
dt = MAX_TIMESTEP;
}
onUpdate(dt);
mLastTime = now;
}
/**
* Gets the distance to the closest limit (max and min position).
*
* @return If position is more than max position: distance to max position. If
* position is less than min position: distance to min position. If
* within limits: 0
*/
protected float getDistanceToLimit() {
float distanceToLimit = 0;
if (mPosition > mMaxPosition) {
distanceToLimit = mMaxPosition - mPosition;
} else if (mPosition < mMinPosition) {
distanceToLimit = mMinPosition - mPosition;
}
return distanceToLimit;
}
/**
* Updates the position and velocity.
*
* @param dt The delta time since last time
*/
abstract protected void onUpdate(int dt);
}
public class SpringDynamics extends Dynamics {
/** Friction factor */
private float mFriction;
/** Spring stiffness factor */
private float mStiffness;
/** Spring damping */
private float mDamping;
/**
* Set friction parameter, friction physics are applied when inside of snap
* bounds.
*
* @param friction Friction factor
*/
public void setFriction(float friction) {
mFriction = friction;
}
/**
* Set spring parameters, spring physics are applied when outside of snap
* bounds.
*
* @param stiffness Spring stiffness
* @param dampingRatio Damping ratio, < 1 underdamped, > 1 overdamped
*/
public void setSpring(float stiffness, float dampingRatio) {
mStiffness = stiffness;
mDamping = dampingRatio * 2 * (float)Math.sqrt(stiffness);
}
/**
* Calculate acceleration at the current state
*
* @return Current acceleration
*/
private float calculateAcceleration() {
float acceleration;
final float distanceFromLimit = getDistanceToLimit();
if (distanceFromLimit != 0) {
acceleration = distanceFromLimit * mStiffness - mDamping * mVelocity;
} else {
acceleration = -mFriction * mVelocity;
}
return acceleration;
}
@Override
protected void onUpdate(int dt) {
// Calculate dt in seconds as float
final float fdt = dt / 1000f;
// Calculate current acceleration
final float a = calculateAcceleration();
// Calculate next position based on current velocity and acceleration
mPosition += mVelocity * fdt + .5f * a * fdt * fdt;
// Update velocity
mVelocity += a * fdt;
}
}
Может ли кто-нибудь дать мне представление о том, как включить поворот изображения в это (аналогично iphone pinch)?
Спасибо