core/java/android/widget/EdgeGlow.java - platform/frameworks/base - Git at Google

 /*
  * 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 android.widget;

 import android.graphics.Canvas;
 import android.graphics.drawable.Drawable;
 import android.view.animation.AnimationUtils;
 import android.view.animation.DecelerateInterpolator;
 import android.view.animation.Interpolator;

 /**
  * This class performs the glow effect used at the edges of scrollable widgets.
  * @hide
  */
 public class EdgeGlow {
     private static final String TAG = "EdgeGlow";

     // Time it will take the effect to fully recede in ms
     private static final int RECEDE_TIME = 1000;

     // Time it will take before a pulled glow begins receding
     private static final int PULL_TIME = 250;

     // Time it will take for a pulled glow to decay to partial strength before release
     private static final int PULL_DECAY_TIME = 10000;

     private static final float MAX_ALPHA = 1.f;
     private static final float HELD_EDGE_ALPHA = 0.7f;
     private static final float HELD_EDGE_SCALE_Y = 0.5f;
     private static final float HELD_GLOW_ALPHA = 0.5f;
     private static final float HELD_GLOW_SCALE_Y = 0.5f;

     private static final float MAX_GLOW_HEIGHT = 3.f;

     private static final float PULL_GLOW_BEGIN = 1.f;
     private static final float PULL_EDGE_BEGIN = 0.6f;

     // Minimum velocity that will be absorbed
     private static final int MIN_VELOCITY = 100;

     private static final float EPSILON = 0.001f;

     private final Drawable mEdge;
     private final Drawable mGlow;
     private int mWidth;
     private int mHeight;

     private float mEdgeAlpha;
     private float mEdgeScaleY;
     private float mGlowAlpha;
     private float mGlowScaleY;

     private float mEdgeAlphaStart;
     private float mEdgeAlphaFinish;
     private float mEdgeScaleYStart;
     private float mEdgeScaleYFinish;
     private float mGlowAlphaStart;
     private float mGlowAlphaFinish;
     private float mGlowScaleYStart;
     private float mGlowScaleYFinish;

     private long mStartTime;
     private float mDuration;

     private final Interpolator mInterpolator;

     private static final int STATE_IDLE = 0;
     private static final int STATE_PULL = 1;
     private static final int STATE_ABSORB = 2;
     private static final int STATE_RECEDE = 3;
     private static final int STATE_PULL_DECAY = 4;

     // How much dragging should effect the height of the edge image.
     // Number determined by user testing.
     private static final int PULL_DISTANCE_EDGE_FACTOR = 5;

     // How much dragging should effect the height of the glow image.
     // Number determined by user testing.
     private static final int PULL_DISTANCE_GLOW_FACTOR = 5;

     private static final int VELOCITY_EDGE_FACTOR = 8;
     private static final int VELOCITY_GLOW_FACTOR = 16;

     private int mState = STATE_IDLE;

     private float mPullDistance;

     public EdgeGlow(Drawable edge, Drawable glow) {
         mEdge = edge;
         mGlow = glow;

         mInterpolator = new DecelerateInterpolator();
     }

     public void setSize(int width, int height) {
         mWidth = width;
         mHeight = height;
     }

     public boolean isFinished() {
         return mState == STATE_IDLE;
     }

     public void finish() {
         mState = STATE_IDLE;
     }

     /**
      * Call when the object is pulled by the user.
      *
      * @param deltaDistance Change in distance since the last call
      */
     public void onPull(float deltaDistance) {
         final long now = AnimationUtils.currentAnimationTimeMillis();
         if (mState == STATE_PULL_DECAY && now - mStartTime < mDuration) {
             return;
         }
         if (mState != STATE_PULL) {
             mGlowScaleY = PULL_GLOW_BEGIN;
         }
         mState = STATE_PULL;

         mStartTime = now;
         mDuration = PULL_TIME;

         mPullDistance += deltaDistance;
         float distance = Math.abs(mPullDistance);

         mEdgeAlpha = mEdgeAlphaStart = Math.max(PULL_EDGE_BEGIN, Math.min(distance, MAX_ALPHA));
         mEdgeScaleY = mEdgeScaleYStart = Math.max(
                 HELD_EDGE_SCALE_Y, Math.min(distance * PULL_DISTANCE_EDGE_FACTOR, 1.f));

         mGlowAlpha = mGlowAlphaStart = Math.max(
                 0.5f, Math.min(mGlowAlpha + Math.abs(deltaDistance), MAX_ALPHA));

         float glowChange = Math.abs(deltaDistance);
         if (deltaDistance > 0 && mPullDistance < 0) {
             glowChange = -glowChange;
         }
         if (mPullDistance == 0) {
             mGlowScaleY = 0;
         }
         mGlowScaleY = mGlowScaleYStart = Math.max(
                 0, mGlowScaleY + glowChange * PULL_DISTANCE_GLOW_FACTOR);

         mEdgeAlphaFinish = mEdgeAlpha;
         mEdgeScaleYFinish = mEdgeScaleY;
         mGlowAlphaFinish = mGlowAlpha;
         mGlowScaleYFinish = mGlowScaleY;
     }

     /**
      * Call when the object is released after being pulled.
      */
     public void onRelease() {
         mPullDistance = 0;

         if (mState != STATE_PULL && mState != STATE_PULL_DECAY) {
             return;
         }

         mState = STATE_RECEDE;
         mEdgeAlphaStart = mEdgeAlpha;
         mEdgeScaleYStart = mEdgeScaleY;
         mGlowAlphaStart = mGlowAlpha;
         mGlowScaleYStart = mGlowScaleY;

         mEdgeAlphaFinish = 0.f;
         mEdgeScaleYFinish = 0.f;
         mGlowAlphaFinish = 0.f;
         mGlowScaleYFinish = 0.f;

         mStartTime = AnimationUtils.currentAnimationTimeMillis();
         mDuration = RECEDE_TIME;
     }

     /**
      * Call when the effect absorbs an impact at the given velocity.
      *
      * @param velocity Velocity at impact in pixels per second.
      */
     public void onAbsorb(int velocity) {
         mState = STATE_ABSORB;
         velocity = Math.max(MIN_VELOCITY, Math.abs(velocity));

         mStartTime = AnimationUtils.currentAnimationTimeMillis();
         mDuration = 0.1f + (velocity * 0.03f);

         // The edge should always be at least partially visible, regardless
         // of velocity.
         mEdgeAlphaStart = 0.5f;
         mEdgeScaleYStart = 0.2f;
         // The glow depends more on the velocity, and therefore starts out
         // nearly invisible.
         mGlowAlphaStart = 0.5f;
         mGlowScaleYStart = 0.f;

         // Factor the velocity by 8. Testing on device shows this works best to
         // reflect the strength of the user's scrolling.
         mEdgeAlphaFinish = Math.max(0, Math.min(velocity * VELOCITY_EDGE_FACTOR, 1));
         // Edge should never get larger than the size of its asset.
         mEdgeScaleYFinish = 1.f;

         // Growth for the size of the glow should be quadratic to properly
         // respond
         // to a user's scrolling speed. The faster the scrolling speed, the more
         // intense the effect should be for both the size and the saturation.
         mGlowScaleYFinish = Math.min(0.025f + (velocity * (velocity / 100) * 0.00015f), 1.75f);
         // Alpha should change for the glow as well as size.
         mGlowAlphaFinish = Math.max(
                 mGlowAlphaStart, Math.min(velocity * VELOCITY_GLOW_FACTOR * .00001f, MAX_ALPHA));
     }


     /**
      * Draw into the provided canvas. Assumes that the canvas has been rotated
      * accordingly and the size has been set. The effect will be drawn the full
      * width of X=0 to X=width, emitting from Y=0 and extending to some factor <
      * 1.f of height.
      *
      * @param canvas Canvas to draw into
      * @return true if drawing should continue beyond this frame to continue the
      *         animation
      */
     public boolean draw(Canvas canvas) {
         update();

         final int edgeHeight = mEdge.getIntrinsicHeight();
         final int glowHeight = mGlow.getIntrinsicHeight();

         final float distScale = (float) mHeight / mWidth;

         mGlow.setAlpha((int) (Math.max(0, Math.min(mGlowAlpha, 1)) * 255));
         // Width of the image should be 3 * the width of the screen.
         // Should start off screen to the left.
         mGlow.setBounds(-mWidth, 0, mWidth * 2, (int) Math.min(
                 glowHeight * mGlowScaleY * distScale * 0.6f, mHeight * MAX_GLOW_HEIGHT));
         mGlow.draw(canvas);

         mEdge.setAlpha((int) (Math.max(0, Math.min(mEdgeAlpha, 1)) * 255));
         mEdge.setBounds(0, 0, mWidth, (int) (edgeHeight * mEdgeScaleY));
         mEdge.draw(canvas);

         return mState != STATE_IDLE;
     }

     private void update() {
         final long time = AnimationUtils.currentAnimationTimeMillis();
         final float t = Math.min((time - mStartTime) / mDuration, 1.f);

         final float interp = mInterpolator.getInterpolation(t);

         mEdgeAlpha = mEdgeAlphaStart + (mEdgeAlphaFinish - mEdgeAlphaStart) * interp;
         mEdgeScaleY = mEdgeScaleYStart + (mEdgeScaleYFinish - mEdgeScaleYStart) * interp;
         mGlowAlpha = mGlowAlphaStart + (mGlowAlphaFinish - mGlowAlphaStart) * interp;
         mGlowScaleY = mGlowScaleYStart + (mGlowScaleYFinish - mGlowScaleYStart) * interp;

         if (t >= 1.f - EPSILON) {
             switch (mState) {
                 case STATE_ABSORB:
                     mState = STATE_RECEDE;
                     mStartTime = AnimationUtils.currentAnimationTimeMillis();
                     mDuration = RECEDE_TIME;

                     mEdgeAlphaStart = mEdgeAlpha;
                     mEdgeScaleYStart = mEdgeScaleY;
                     mGlowAlphaStart = mGlowAlpha;
                     mGlowScaleYStart = mGlowScaleY;

                     mEdgeAlphaFinish = 0.f;
                     mEdgeScaleYFinish = mEdgeScaleY;
                     mGlowAlphaFinish = 0.f;
                     mGlowScaleYFinish = mGlowScaleY;
                     break;
                 case STATE_PULL:
                     mState = STATE_PULL_DECAY;
                     mStartTime = AnimationUtils.currentAnimationTimeMillis();
                     mDuration = PULL_DECAY_TIME;

                     mEdgeAlphaStart = mEdgeAlpha;
                     mEdgeScaleYStart = mEdgeScaleY;
                     mGlowAlphaStart = mGlowAlpha;
                     mGlowScaleYStart = mGlowScaleY;

                     // After a pull, the glow should fade to nothing.
                     mEdgeAlphaFinish = 0.f;
                     mEdgeScaleYFinish = 0.f;
                     mGlowAlphaFinish = 0.f;
                     mGlowScaleYFinish = 0.f;
                     break;
                 case STATE_PULL_DECAY:
                     // Do nothing; wait for release
                     break;
                 case STATE_RECEDE:
                     mState = STATE_IDLE;
                     break;
             }
         }
     }
 }
	/*
	* 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 android.widget;

	import android.graphics.Canvas;
	import android.graphics.drawable.Drawable;
	import android.view.animation.AnimationUtils;
	import android.view.animation.DecelerateInterpolator;
	import android.view.animation.Interpolator;

	/**
	* This class performs the glow effect used at the edges of scrollable widgets.
	* @hide
	*/
	public class EdgeGlow {
	private static final String TAG = "EdgeGlow";

	// Time it will take the effect to fully recede in ms
	private static final int RECEDE_TIME = 1000;

	// Time it will take before a pulled glow begins receding
	private static final int PULL_TIME = 250;

	// Time it will take for a pulled glow to decay to partial strength before release
	private static final int PULL_DECAY_TIME = 10000;

	private static final float MAX_ALPHA = 1.f;
	private static final float HELD_EDGE_ALPHA = 0.7f;
	private static final float HELD_EDGE_SCALE_Y = 0.5f;
	private static final float HELD_GLOW_ALPHA = 0.5f;
	private static final float HELD_GLOW_SCALE_Y = 0.5f;

	private static final float MAX_GLOW_HEIGHT = 3.f;

	private static final float PULL_GLOW_BEGIN = 1.f;
	private static final float PULL_EDGE_BEGIN = 0.6f;

	// Minimum velocity that will be absorbed
	private static final int MIN_VELOCITY = 100;

	private static final float EPSILON = 0.001f;

	private final Drawable mEdge;
	private final Drawable mGlow;
	private int mWidth;
	private int mHeight;

	private float mEdgeAlpha;
	private float mEdgeScaleY;
	private float mGlowAlpha;
	private float mGlowScaleY;

	private float mEdgeAlphaStart;
	private float mEdgeAlphaFinish;
	private float mEdgeScaleYStart;
	private float mEdgeScaleYFinish;
	private float mGlowAlphaStart;
	private float mGlowAlphaFinish;
	private float mGlowScaleYStart;
	private float mGlowScaleYFinish;

	private long mStartTime;
	private float mDuration;

	private final Interpolator mInterpolator;

	private static final int STATE_IDLE = 0;
	private static final int STATE_PULL = 1;
	private static final int STATE_ABSORB = 2;
	private static final int STATE_RECEDE = 3;
	private static final int STATE_PULL_DECAY = 4;

	// How much dragging should effect the height of the edge image.
	// Number determined by user testing.
	private static final int PULL_DISTANCE_EDGE_FACTOR = 5;

	// How much dragging should effect the height of the glow image.
	// Number determined by user testing.
	private static final int PULL_DISTANCE_GLOW_FACTOR = 5;

	private static final int VELOCITY_EDGE_FACTOR = 8;
	private static final int VELOCITY_GLOW_FACTOR = 16;

	private int mState = STATE_IDLE;

	private float mPullDistance;

	public EdgeGlow(Drawable edge, Drawable glow) {
	mEdge = edge;
	mGlow = glow;

	mInterpolator = new DecelerateInterpolator();
	}

	public void setSize(int width, int height) {
	mWidth = width;
	mHeight = height;
	}

	public boolean isFinished() {
	return mState == STATE_IDLE;
	}

	public void finish() {
	mState = STATE_IDLE;
	}

	/**
	* Call when the object is pulled by the user.
	*
	* @param deltaDistance Change in distance since the last call
	*/
	public void onPull(float deltaDistance) {
	final long now = AnimationUtils.currentAnimationTimeMillis();
	if (mState == STATE_PULL_DECAY && now - mStartTime < mDuration) {
	return;
	}
	if (mState != STATE_PULL) {
	mGlowScaleY = PULL_GLOW_BEGIN;
	}
	mState = STATE_PULL;

	mStartTime = now;
	mDuration = PULL_TIME;

	mPullDistance += deltaDistance;
	float distance = Math.abs(mPullDistance);

	mEdgeAlpha = mEdgeAlphaStart = Math.max(PULL_EDGE_BEGIN, Math.min(distance, MAX_ALPHA));
	mEdgeScaleY = mEdgeScaleYStart = Math.max(
	HELD_EDGE_SCALE_Y, Math.min(distance * PULL_DISTANCE_EDGE_FACTOR, 1.f));

	mGlowAlpha = mGlowAlphaStart = Math.max(
	0.5f, Math.min(mGlowAlpha + Math.abs(deltaDistance), MAX_ALPHA));

	float glowChange = Math.abs(deltaDistance);
	if (deltaDistance > 0 && mPullDistance < 0) {
	glowChange = -glowChange;
	}
	if (mPullDistance == 0) {
	mGlowScaleY = 0;
	}
	mGlowScaleY = mGlowScaleYStart = Math.max(
	0, mGlowScaleY + glowChange * PULL_DISTANCE_GLOW_FACTOR);

	mEdgeAlphaFinish = mEdgeAlpha;
	mEdgeScaleYFinish = mEdgeScaleY;
	mGlowAlphaFinish = mGlowAlpha;
	mGlowScaleYFinish = mGlowScaleY;
	}

	/**
	* Call when the object is released after being pulled.
	*/
	public void onRelease() {
	mPullDistance = 0;

	if (mState != STATE_PULL && mState != STATE_PULL_DECAY) {
	return;
	}

	mState = STATE_RECEDE;
	mEdgeAlphaStart = mEdgeAlpha;
	mEdgeScaleYStart = mEdgeScaleY;
	mGlowAlphaStart = mGlowAlpha;
	mGlowScaleYStart = mGlowScaleY;

	mEdgeAlphaFinish = 0.f;
	mEdgeScaleYFinish = 0.f;
	mGlowAlphaFinish = 0.f;
	mGlowScaleYFinish = 0.f;

	mStartTime = AnimationUtils.currentAnimationTimeMillis();
	mDuration = RECEDE_TIME;
	}

	/**
	* Call when the effect absorbs an impact at the given velocity.
	*
	* @param velocity Velocity at impact in pixels per second.
	*/
	public void onAbsorb(int velocity) {
	mState = STATE_ABSORB;
	velocity = Math.max(MIN_VELOCITY, Math.abs(velocity));

	mStartTime = AnimationUtils.currentAnimationTimeMillis();
	mDuration = 0.1f + (velocity * 0.03f);

	// The edge should always be at least partially visible, regardless
	// of velocity.
	mEdgeAlphaStart = 0.5f;
	mEdgeScaleYStart = 0.2f;
	// The glow depends more on the velocity, and therefore starts out
	// nearly invisible.
	mGlowAlphaStart = 0.5f;
	mGlowScaleYStart = 0.f;

	// Factor the velocity by 8. Testing on device shows this works best to
	// reflect the strength of the user's scrolling.
	mEdgeAlphaFinish = Math.max(0, Math.min(velocity * VELOCITY_EDGE_FACTOR, 1));
	// Edge should never get larger than the size of its asset.
	mEdgeScaleYFinish = 1.f;

	// Growth for the size of the glow should be quadratic to properly
	// respond
	// to a user's scrolling speed. The faster the scrolling speed, the more
	// intense the effect should be for both the size and the saturation.
	mGlowScaleYFinish = Math.min(0.025f + (velocity * (velocity / 100) * 0.00015f), 1.75f);
	// Alpha should change for the glow as well as size.
	mGlowAlphaFinish = Math.max(
	mGlowAlphaStart, Math.min(velocity * VELOCITY_GLOW_FACTOR * .00001f, MAX_ALPHA));
	}


	/**
	* Draw into the provided canvas. Assumes that the canvas has been rotated
	* accordingly and the size has been set. The effect will be drawn the full
	* width of X=0 to X=width, emitting from Y=0 and extending to some factor <
	* 1.f of height.
	*
	* @param canvas Canvas to draw into
	* @return true if drawing should continue beyond this frame to continue the
	* animation
	*/
	public boolean draw(Canvas canvas) {
	update();

	final int edgeHeight = mEdge.getIntrinsicHeight();
	final int glowHeight = mGlow.getIntrinsicHeight();

	final float distScale = (float) mHeight / mWidth;

	mGlow.setAlpha((int) (Math.max(0, Math.min(mGlowAlpha, 1)) * 255));
	// Width of the image should be 3 * the width of the screen.
	// Should start off screen to the left.
	mGlow.setBounds(-mWidth, 0, mWidth * 2, (int) Math.min(
	glowHeight * mGlowScaleY * distScale * 0.6f, mHeight * MAX_GLOW_HEIGHT));
	mGlow.draw(canvas);

	mEdge.setAlpha((int) (Math.max(0, Math.min(mEdgeAlpha, 1)) * 255));
	mEdge.setBounds(0, 0, mWidth, (int) (edgeHeight * mEdgeScaleY));
	mEdge.draw(canvas);

	return mState != STATE_IDLE;
	}

	private void update() {
	final long time = AnimationUtils.currentAnimationTimeMillis();
	final float t = Math.min((time - mStartTime) / mDuration, 1.f);

	final float interp = mInterpolator.getInterpolation(t);

	mEdgeAlpha = mEdgeAlphaStart + (mEdgeAlphaFinish - mEdgeAlphaStart) * interp;
	mEdgeScaleY = mEdgeScaleYStart + (mEdgeScaleYFinish - mEdgeScaleYStart) * interp;
	mGlowAlpha = mGlowAlphaStart + (mGlowAlphaFinish - mGlowAlphaStart) * interp;
	mGlowScaleY = mGlowScaleYStart + (mGlowScaleYFinish - mGlowScaleYStart) * interp;

	if (t >= 1.f - EPSILON) {
	switch (mState) {
	case STATE_ABSORB:
	mState = STATE_RECEDE;
	mStartTime = AnimationUtils.currentAnimationTimeMillis();
	mDuration = RECEDE_TIME;

	mEdgeAlphaStart = mEdgeAlpha;
	mEdgeScaleYStart = mEdgeScaleY;
	mGlowAlphaStart = mGlowAlpha;
	mGlowScaleYStart = mGlowScaleY;

	mEdgeAlphaFinish = 0.f;
	mEdgeScaleYFinish = mEdgeScaleY;
	mGlowAlphaFinish = 0.f;
	mGlowScaleYFinish = mGlowScaleY;
	break;
	case STATE_PULL:
	mState = STATE_PULL_DECAY;
	mStartTime = AnimationUtils.currentAnimationTimeMillis();
	mDuration = PULL_DECAY_TIME;

	mEdgeAlphaStart = mEdgeAlpha;
	mEdgeScaleYStart = mEdgeScaleY;
	mGlowAlphaStart = mGlowAlpha;
	mGlowScaleYStart = mGlowScaleY;

	// After a pull, the glow should fade to nothing.
	mEdgeAlphaFinish = 0.f;
	mEdgeScaleYFinish = 0.f;
	mGlowAlphaFinish = 0.f;
	mGlowScaleYFinish = 0.f;
	break;
	case STATE_PULL_DECAY:
	// Do nothing; wait for release
	break;
	case STATE_RECEDE:
	mState = STATE_IDLE;
	break;
	}
	}
	}
	}