/*
|
* 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.annotation.ColorInt;
|
import android.annotation.Nullable;
|
import android.annotation.UnsupportedAppUsage;
|
import android.content.Context;
|
import android.content.res.TypedArray;
|
import android.graphics.BlendMode;
|
import android.graphics.Canvas;
|
import android.graphics.Paint;
|
import android.graphics.Rect;
|
import android.os.Build;
|
import android.view.animation.AnimationUtils;
|
import android.view.animation.DecelerateInterpolator;
|
import android.view.animation.Interpolator;
|
|
/**
|
* This class performs the graphical effect used at the edges of scrollable widgets
|
* when the user scrolls beyond the content bounds in 2D space.
|
*
|
* <p>EdgeEffect is stateful. Custom widgets using EdgeEffect should create an
|
* instance for each edge that should show the effect, feed it input data using
|
* the methods {@link #onAbsorb(int)}, {@link #onPull(float)}, and {@link #onRelease()},
|
* and draw the effect using {@link #draw(Canvas)} in the widget's overridden
|
* {@link android.view.View#draw(Canvas)} method. If {@link #isFinished()} returns
|
* false after drawing, the edge effect's animation is not yet complete and the widget
|
* should schedule another drawing pass to continue the animation.</p>
|
*
|
* <p>When drawing, widgets should draw their main content and child views first,
|
* usually by invoking <code>super.draw(canvas)</code> from an overridden <code>draw</code>
|
* method. (This will invoke onDraw and dispatch drawing to child views as needed.)
|
* The edge effect may then be drawn on top of the view's content using the
|
* {@link #draw(Canvas)} method.</p>
|
*/
|
public class EdgeEffect {
|
|
/**
|
* The default blend mode used by {@link EdgeEffect}.
|
*/
|
public static final BlendMode DEFAULT_BLEND_MODE = BlendMode.SRC_ATOP;
|
|
@SuppressWarnings("UnusedDeclaration")
|
private static final String TAG = "EdgeEffect";
|
|
// Time it will take the effect to fully recede in ms
|
private static final int RECEDE_TIME = 600;
|
|
// Time it will take before a pulled glow begins receding in ms
|
private static final int PULL_TIME = 167;
|
|
// Time it will take in ms for a pulled glow to decay to partial strength before release
|
private static final int PULL_DECAY_TIME = 2000;
|
|
private static final float MAX_ALPHA = 0.15f;
|
private static final float GLOW_ALPHA_START = .09f;
|
|
private static final float MAX_GLOW_SCALE = 2.f;
|
|
private static final float PULL_GLOW_BEGIN = 0.f;
|
|
// Minimum velocity that will be absorbed
|
private static final int MIN_VELOCITY = 100;
|
// Maximum velocity, clamps at this value
|
private static final int MAX_VELOCITY = 10000;
|
|
private static final float EPSILON = 0.001f;
|
|
private static final double ANGLE = Math.PI / 6;
|
private static final float SIN = (float) Math.sin(ANGLE);
|
private static final float COS = (float) Math.cos(ANGLE);
|
private static final float RADIUS_FACTOR = 0.6f;
|
|
private float mGlowAlpha;
|
@UnsupportedAppUsage
|
private float mGlowScaleY;
|
|
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;
|
|
private static final float PULL_DISTANCE_ALPHA_GLOW_FACTOR = 0.8f;
|
|
private static final int VELOCITY_GLOW_FACTOR = 6;
|
|
private int mState = STATE_IDLE;
|
|
private float mPullDistance;
|
|
private final Rect mBounds = new Rect();
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 123769450)
|
private final Paint mPaint = new Paint();
|
private float mRadius;
|
private float mBaseGlowScale;
|
private float mDisplacement = 0.5f;
|
private float mTargetDisplacement = 0.5f;
|
|
/**
|
* Construct a new EdgeEffect with a theme appropriate for the provided context.
|
* @param context Context used to provide theming and resource information for the EdgeEffect
|
*/
|
public EdgeEffect(Context context) {
|
mPaint.setAntiAlias(true);
|
final TypedArray a = context.obtainStyledAttributes(
|
com.android.internal.R.styleable.EdgeEffect);
|
final int themeColor = a.getColor(
|
com.android.internal.R.styleable.EdgeEffect_colorEdgeEffect, 0xff666666);
|
a.recycle();
|
mPaint.setColor((themeColor & 0xffffff) | 0x33000000);
|
mPaint.setStyle(Paint.Style.FILL);
|
mPaint.setBlendMode(DEFAULT_BLEND_MODE);
|
mInterpolator = new DecelerateInterpolator();
|
}
|
|
/**
|
* Set the size of this edge effect in pixels.
|
*
|
* @param width Effect width in pixels
|
* @param height Effect height in pixels
|
*/
|
public void setSize(int width, int height) {
|
final float r = width * RADIUS_FACTOR / SIN;
|
final float y = COS * r;
|
final float h = r - y;
|
final float or = height * RADIUS_FACTOR / SIN;
|
final float oy = COS * or;
|
final float oh = or - oy;
|
|
mRadius = r;
|
mBaseGlowScale = h > 0 ? Math.min(oh / h, 1.f) : 1.f;
|
|
mBounds.set(mBounds.left, mBounds.top, width, (int) Math.min(height, h));
|
}
|
|
/**
|
* Reports if this EdgeEffect's animation is finished. If this method returns false
|
* after a call to {@link #draw(Canvas)} the host widget should schedule another
|
* drawing pass to continue the animation.
|
*
|
* @return true if animation is finished, false if drawing should continue on the next frame.
|
*/
|
public boolean isFinished() {
|
return mState == STATE_IDLE;
|
}
|
|
/**
|
* Immediately finish the current animation.
|
* After this call {@link #isFinished()} will return true.
|
*/
|
public void finish() {
|
mState = STATE_IDLE;
|
}
|
|
/**
|
* A view should call this when content is pulled away from an edge by the user.
|
* This will update the state of the current visual effect and its associated animation.
|
* The host view should always {@link android.view.View#invalidate()} after this
|
* and draw the results accordingly.
|
*
|
* <p>Views using EdgeEffect should favor {@link #onPull(float, float)} when the displacement
|
* of the pull point is known.</p>
|
*
|
* @param deltaDistance Change in distance since the last call. Values may be 0 (no change) to
|
* 1.f (full length of the view) or negative values to express change
|
* back toward the edge reached to initiate the effect.
|
*/
|
public void onPull(float deltaDistance) {
|
onPull(deltaDistance, 0.5f);
|
}
|
|
/**
|
* A view should call this when content is pulled away from an edge by the user.
|
* This will update the state of the current visual effect and its associated animation.
|
* The host view should always {@link android.view.View#invalidate()} after this
|
* and draw the results accordingly.
|
*
|
* @param deltaDistance Change in distance since the last call. Values may be 0 (no change) to
|
* 1.f (full length of the view) or negative values to express change
|
* back toward the edge reached to initiate the effect.
|
* @param displacement The displacement from the starting side of the effect of the point
|
* initiating the pull. In the case of touch this is the finger position.
|
* Values may be from 0-1.
|
*/
|
public void onPull(float deltaDistance, float displacement) {
|
final long now = AnimationUtils.currentAnimationTimeMillis();
|
mTargetDisplacement = displacement;
|
if (mState == STATE_PULL_DECAY && now - mStartTime < mDuration) {
|
return;
|
}
|
if (mState != STATE_PULL) {
|
mGlowScaleY = Math.max(PULL_GLOW_BEGIN, mGlowScaleY);
|
}
|
mState = STATE_PULL;
|
|
mStartTime = now;
|
mDuration = PULL_TIME;
|
|
mPullDistance += deltaDistance;
|
|
final float absdd = Math.abs(deltaDistance);
|
mGlowAlpha = mGlowAlphaStart = Math.min(MAX_ALPHA,
|
mGlowAlpha + (absdd * PULL_DISTANCE_ALPHA_GLOW_FACTOR));
|
|
if (mPullDistance == 0) {
|
mGlowScaleY = mGlowScaleYStart = 0;
|
} else {
|
final float scale = (float) (Math.max(0, 1 - 1 /
|
Math.sqrt(Math.abs(mPullDistance) * mBounds.height()) - 0.3d) / 0.7d);
|
|
mGlowScaleY = mGlowScaleYStart = scale;
|
}
|
|
mGlowAlphaFinish = mGlowAlpha;
|
mGlowScaleYFinish = mGlowScaleY;
|
}
|
|
/**
|
* Call when the object is released after being pulled.
|
* This will begin the "decay" phase of the effect. After calling this method
|
* the host view should {@link android.view.View#invalidate()} and thereby
|
* draw the results accordingly.
|
*/
|
public void onRelease() {
|
mPullDistance = 0;
|
|
if (mState != STATE_PULL && mState != STATE_PULL_DECAY) {
|
return;
|
}
|
|
mState = STATE_RECEDE;
|
mGlowAlphaStart = mGlowAlpha;
|
mGlowScaleYStart = mGlowScaleY;
|
|
mGlowAlphaFinish = 0.f;
|
mGlowScaleYFinish = 0.f;
|
|
mStartTime = AnimationUtils.currentAnimationTimeMillis();
|
mDuration = RECEDE_TIME;
|
}
|
|
/**
|
* Call when the effect absorbs an impact at the given velocity.
|
* Used when a fling reaches the scroll boundary.
|
*
|
* <p>When using a {@link android.widget.Scroller} or {@link android.widget.OverScroller},
|
* the method <code>getCurrVelocity</code> will provide a reasonable approximation
|
* to use here.</p>
|
*
|
* @param velocity Velocity at impact in pixels per second.
|
*/
|
public void onAbsorb(int velocity) {
|
mState = STATE_ABSORB;
|
velocity = Math.min(Math.max(MIN_VELOCITY, Math.abs(velocity)), MAX_VELOCITY);
|
|
mStartTime = AnimationUtils.currentAnimationTimeMillis();
|
mDuration = 0.15f + (velocity * 0.02f);
|
|
// The glow depends more on the velocity, and therefore starts out
|
// nearly invisible.
|
mGlowAlphaStart = GLOW_ALPHA_START;
|
mGlowScaleYStart = Math.max(mGlowScaleY, 0.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) / 2, 1.f);
|
// Alpha should change for the glow as well as size.
|
mGlowAlphaFinish = Math.max(
|
mGlowAlphaStart, Math.min(velocity * VELOCITY_GLOW_FACTOR * .00001f, MAX_ALPHA));
|
mTargetDisplacement = 0.5f;
|
}
|
|
/**
|
* Set the color of this edge effect in argb.
|
*
|
* @param color Color in argb
|
*/
|
public void setColor(@ColorInt int color) {
|
mPaint.setColor(color);
|
}
|
|
/**
|
* Set or clear the blend mode. A blend mode defines how source pixels
|
* (generated by a drawing command) are composited with the destination pixels
|
* (content of the render target).
|
* <p />
|
* Pass null to clear any previous blend mode.
|
* <p />
|
*
|
* @see BlendMode
|
*
|
* @param blendmode May be null. The blend mode to be installed in the paint
|
*/
|
public void setBlendMode(@Nullable BlendMode blendmode) {
|
mPaint.setBlendMode(blendmode);
|
}
|
|
/**
|
* Return the color of this edge effect in argb.
|
* @return The color of this edge effect in argb
|
*/
|
@ColorInt
|
public int getColor() {
|
return mPaint.getColor();
|
}
|
|
|
/**
|
* Returns the blend mode. A blend mode defines how source pixels
|
* (generated by a drawing command) are composited with the destination pixels
|
* (content of the render target).
|
* <p />
|
*
|
* @return BlendMode
|
*/
|
@Nullable
|
public BlendMode getBlendMode() {
|
return mPaint.getBlendMode();
|
}
|
|
/**
|
* 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, beginning 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 count = canvas.save();
|
|
final float centerX = mBounds.centerX();
|
final float centerY = mBounds.height() - mRadius;
|
|
canvas.scale(1.f, Math.min(mGlowScaleY, 1.f) * mBaseGlowScale, centerX, 0);
|
|
final float displacement = Math.max(0, Math.min(mDisplacement, 1.f)) - 0.5f;
|
float translateX = mBounds.width() * displacement / 2;
|
|
canvas.clipRect(mBounds);
|
canvas.translate(translateX, 0);
|
mPaint.setAlpha((int) (0xff * mGlowAlpha));
|
canvas.drawCircle(centerX, centerY, mRadius, mPaint);
|
canvas.restoreToCount(count);
|
|
boolean oneLastFrame = false;
|
if (mState == STATE_RECEDE && mGlowScaleY == 0) {
|
mState = STATE_IDLE;
|
oneLastFrame = true;
|
}
|
|
return mState != STATE_IDLE || oneLastFrame;
|
}
|
|
/**
|
* Return the maximum height that the edge effect will be drawn at given the original
|
* {@link #setSize(int, int) input size}.
|
* @return The maximum height of the edge effect
|
*/
|
public int getMaxHeight() {
|
return (int) (mBounds.height() * MAX_GLOW_SCALE + 0.5f);
|
}
|
|
private void update() {
|
final long time = AnimationUtils.currentAnimationTimeMillis();
|
final float t = Math.min((time - mStartTime) / mDuration, 1.f);
|
|
final float interp = mInterpolator.getInterpolation(t);
|
|
mGlowAlpha = mGlowAlphaStart + (mGlowAlphaFinish - mGlowAlphaStart) * interp;
|
mGlowScaleY = mGlowScaleYStart + (mGlowScaleYFinish - mGlowScaleYStart) * interp;
|
mDisplacement = (mDisplacement + mTargetDisplacement) / 2;
|
|
if (t >= 1.f - EPSILON) {
|
switch (mState) {
|
case STATE_ABSORB:
|
mState = STATE_RECEDE;
|
mStartTime = AnimationUtils.currentAnimationTimeMillis();
|
mDuration = RECEDE_TIME;
|
|
mGlowAlphaStart = mGlowAlpha;
|
mGlowScaleYStart = mGlowScaleY;
|
|
// After absorb, the glow should fade to nothing.
|
mGlowAlphaFinish = 0.f;
|
mGlowScaleYFinish = 0.f;
|
break;
|
case STATE_PULL:
|
mState = STATE_PULL_DECAY;
|
mStartTime = AnimationUtils.currentAnimationTimeMillis();
|
mDuration = PULL_DECAY_TIME;
|
|
mGlowAlphaStart = mGlowAlpha;
|
mGlowScaleYStart = mGlowScaleY;
|
|
// After pull, the glow should fade to nothing.
|
mGlowAlphaFinish = 0.f;
|
mGlowScaleYFinish = 0.f;
|
break;
|
case STATE_PULL_DECAY:
|
mState = STATE_RECEDE;
|
break;
|
case STATE_RECEDE:
|
mState = STATE_IDLE;
|
break;
|
}
|
}
|
}
|
}
|
