/*
* Copyright (C) 2014 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.systemui;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.PropertyValuesHolder;
import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Outline;
import android.graphics.Paint;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewOutlineProvider;
import android.view.animation.AnimationUtils;
import android.view.animation.Interpolator;
import android.view.animation.LinearInterpolator;
import android.widget.FrameLayout;
import android.widget.ImageView;
import com.android.systemui.statusbar.phone.PhoneStatusBar;
import java.util.ArrayList;
public class SearchPanelCircleView extends FrameLayout {
private final int mCircleMinSize;
private final int mBaseMargin;
private final int mStaticOffset;
private final Paint mBackgroundPaint = new Paint();
private final Paint mRipplePaint = new Paint();
private final Rect mCircleRect = new Rect();
private final Rect mStaticRect = new Rect();
private final Interpolator mFastOutSlowInInterpolator;
private final Interpolator mAppearInterpolator;
private final Interpolator mDisappearInterpolator;
private boolean mClipToOutline;
private final int mMaxElevation;
private boolean mAnimatingOut;
private float mOutlineAlpha;
private float mOffset;
private float mCircleSize;
private boolean mHorizontal;
private boolean mCircleHidden;
private ImageView mLogo;
private boolean mDraggedFarEnough;
private boolean mOffsetAnimatingIn;
private float mCircleAnimationEndValue;
private ArrayList<Ripple> mRipples = new ArrayList<Ripple>();
private ValueAnimator mOffsetAnimator;
private ValueAnimator mCircleAnimator;
private ValueAnimator mFadeOutAnimator;
private ValueAnimator.AnimatorUpdateListener mCircleUpdateListener
= new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
applyCircleSize((float) animation.getAnimatedValue());
updateElevation();
}
};
private AnimatorListenerAdapter mClearAnimatorListener = new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
mCircleAnimator = null;
}
};
private ValueAnimator.AnimatorUpdateListener mOffsetUpdateListener
= new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
setOffset((float) animation.getAnimatedValue());
}
};
public SearchPanelCircleView(Context context) {
this(context, null);
}
public SearchPanelCircleView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public SearchPanelCircleView(Context context, AttributeSet attrs, int defStyleAttr) {
this(context, attrs, defStyleAttr, 0);
}
public SearchPanelCircleView(Context context, AttributeSet attrs, int defStyleAttr,
int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
setOutlineProvider(new ViewOutlineProvider() {
@Override
public void getOutline(View view, Outline outline) {
if (mCircleSize > 0.0f) {
outline.setOval(mCircleRect);
} else {
outline.setEmpty();
}
outline.setAlpha(mOutlineAlpha);
}
});
setWillNotDraw(false);
mCircleMinSize = context.getResources().getDimensionPixelSize(
R.dimen.search_panel_circle_size);
mBaseMargin = context.getResources().getDimensionPixelSize(
R.dimen.search_panel_circle_base_margin);
mStaticOffset = context.getResources().getDimensionPixelSize(
R.dimen.search_panel_circle_travel_distance);
mMaxElevation = context.getResources().getDimensionPixelSize(
R.dimen.search_panel_circle_elevation);
mAppearInterpolator = AnimationUtils.loadInterpolator(mContext,
android.R.interpolator.linear_out_slow_in);
mFastOutSlowInInterpolator = AnimationUtils.loadInterpolator(mContext,
android.R.interpolator.fast_out_slow_in);
mDisappearInterpolator = AnimationUtils.loadInterpolator(mContext,
android.R.interpolator.fast_out_linear_in);
mBackgroundPaint.setAntiAlias(true);
mBackgroundPaint.setColor(getResources().getColor(R.color.search_panel_circle_color));
mRipplePaint.setColor(getResources().getColor(R.color.search_panel_ripple_color));
mRipplePaint.setAntiAlias(true);
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
drawBackground(canvas);
drawRipples(canvas);
}
private void drawRipples(Canvas canvas) {
for (int i = 0; i < mRipples.size(); i++) {
Ripple ripple = mRipples.get(i);
ripple.draw(canvas);
}
}
private void drawBackground(Canvas canvas) {
canvas.drawCircle(mCircleRect.centerX(), mCircleRect.centerY(), mCircleSize / 2,
mBackgroundPaint);
}
@Override
protected void onFinishInflate() {
super.onFinishInflate();
mLogo = (ImageView) findViewById(R.id.search_logo);
}
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
mLogo.layout(0, 0, mLogo.getMeasuredWidth(), mLogo.getMeasuredHeight());
if (changed) {
updateCircleRect(mStaticRect, mStaticOffset, true);
}
}
public void setCircleSize(float circleSize) {
setCircleSize(circleSize, false, null, 0, null);
}
public void setCircleSize(float circleSize, boolean animated, final Runnable endRunnable,
int startDelay, Interpolator interpolator) {
boolean isAnimating = mCircleAnimator != null;
boolean animationPending = isAnimating && !mCircleAnimator.isRunning();
boolean animatingOut = isAnimating && mCircleAnimationEndValue == 0;
if (animated || animationPending || animatingOut) {
if (isAnimating) {
if (circleSize == mCircleAnimationEndValue) {
return;
}
mCircleAnimator.cancel();
}
mCircleAnimator = ValueAnimator.ofFloat(mCircleSize, circleSize);
mCircleAnimator.addUpdateListener(mCircleUpdateListener);
mCircleAnimator.addListener(mClearAnimatorListener);
mCircleAnimator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
if (endRunnable != null) {
endRunnable.run();
}
}
});
Interpolator desiredInterpolator = interpolator != null ? interpolator
: circleSize == 0 ? mDisappearInterpolator : mAppearInterpolator;
mCircleAnimator.setInterpolator(desiredInterpolator);
mCircleAnimator.setDuration(300);
mCircleAnimator.setStartDelay(startDelay);
mCircleAnimator.start();
mCircleAnimationEndValue = circleSize;
} else {
if (isAnimating) {
float diff = circleSize - mCircleAnimationEndValue;
PropertyValuesHolder[] values = mCircleAnimator.getValues();
values[0].setFloatValues(diff, circleSize);
mCircleAnimator.setCurrentPlayTime(mCircleAnimator.getCurrentPlayTime());
mCircleAnimationEndValue = circleSize;
} else {
applyCircleSize(circleSize);
updateElevation();
}
}
}
private void applyCircleSize(float circleSize) {
mCircleSize = circleSize;
updateLayout();
}
private void updateElevation() {
float t = (mStaticOffset - mOffset) / (float) mStaticOffset;
t = 1.0f - Math.max(t, 0.0f);
float offset = t * mMaxElevation;
setElevation(offset);
}
/**
* Sets the offset to the edge of the screen. By default this not not animated.
*
* @param offset The offset to apply.
*/
public void setOffset(float offset) {
setOffset(offset, false, 0, null, null);
}
/**
* Sets the offset to the edge of the screen.
*
* @param offset The offset to apply.
* @param animate Whether an animation should be performed.
* @param startDelay The desired start delay if animated.
* @param interpolator The desired interpolator if animated. If null,
* a default interpolator will be taken designed for appearing or
* disappearing.
* @param endRunnable The end runnable which should be executed when the animation is finished.
*/
private void setOffset(float offset, boolean animate, int startDelay,
Interpolator interpolator, final Runnable endRunnable) {
if (!animate) {
mOffset = offset;
updateLayout();
if (endRunnable != null) {
endRunnable.run();
}
} else {
if (mOffsetAnimator != null) {
mOffsetAnimator.removeAllListeners();
mOffsetAnimator.cancel();
}
mOffsetAnimator = ValueAnimator.ofFloat(mOffset, offset);
mOffsetAnimator.addUpdateListener(mOffsetUpdateListener);
mOffsetAnimator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
mOffsetAnimator = null;
if (endRunnable != null) {
endRunnable.run();
}
}
});
Interpolator desiredInterpolator = interpolator != null ?
interpolator : offset == 0 ? mDisappearInterpolator : mAppearInterpolator;
mOffsetAnimator.setInterpolator(desiredInterpolator);
mOffsetAnimator.setStartDelay(startDelay);
mOffsetAnimator.setDuration(300);
mOffsetAnimator.start();
mOffsetAnimatingIn = offset != 0;
}
}
private void updateLayout() {
updateCircleRect();
updateLogo();
invalidateOutline();
invalidate();
updateClipping();
}
private void updateClipping() {
boolean clip = mCircleSize < mCircleMinSize || !mRipples.isEmpty();
if (clip != mClipToOutline) {
setClipToOutline(clip);
mClipToOutline = clip;
}
}
private void updateLogo() {
boolean exitAnimationRunning = mFadeOutAnimator != null;
Rect rect = exitAnimationRunning ? mCircleRect : mStaticRect;
float translationX = (rect.left + rect.right) / 2.0f - mLogo.getWidth() / 2.0f;
float translationY = (rect.top + rect.bottom) / 2.0f - mLogo.getHeight() / 2.0f;
float t = (mStaticOffset - mOffset) / (float) mStaticOffset;
if (!exitAnimationRunning) {
if (mHorizontal) {
translationX += t * mStaticOffset * 0.3f;
} else {
translationY += t * mStaticOffset * 0.3f;
}
float alpha = 1.0f-t;
alpha = Math.max((alpha - 0.5f) * 2.0f, 0);
mLogo.setAlpha(alpha);
} else {
translationY += (mOffset - mStaticOffset) / 2;
}
mLogo.setTranslationX(translationX);
mLogo.setTranslationY(translationY);
}
private void updateCircleRect() {
updateCircleRect(mCircleRect, mOffset, false);
}
private void updateCircleRect(Rect rect, float offset, boolean useStaticSize) {
int left, top;
float circleSize = useStaticSize ? mCircleMinSize : mCircleSize;
if (mHorizontal) {
left = (int) (getWidth() - circleSize / 2 - mBaseMargin - offset);
top = (int) ((getHeight() - circleSize) / 2);
} else {
left = (int) (getWidth() - circleSize) / 2;
top = (int) (getHeight() - circleSize / 2 - mBaseMargin - offset);
}
rect.set(left, top, (int) (left + circleSize), (int) (top + circleSize));
}
public void setHorizontal(boolean horizontal) {
mHorizontal = horizontal;
updateCircleRect(mStaticRect, mStaticOffset, true);
updateLayout();
}
public void setDragDistance(float distance) {
if (!mAnimatingOut && (!mCircleHidden || mDraggedFarEnough)) {
float circleSize = mCircleMinSize + rubberband(distance);
setCircleSize(circleSize);
}
}
private float rubberband(float diff) {
return (float) Math.pow(Math.abs(diff), 0.6f);
}
public void startAbortAnimation(Runnable endRunnable) {
if (mAnimatingOut) {
if (endRunnable != null) {
endRunnable.run();
}
return;
}
setCircleSize(0, true, null, 0, null);
setOffset(0, true, 0, null, endRunnable);
mCircleHidden = true;
}
public void startEnterAnimation() {
if (mAnimatingOut) {
return;
}
applyCircleSize(0);
setOffset(0);
setCircleSize(mCircleMinSize, true, null, 50, null);
setOffset(mStaticOffset, true, 50, null, null);
mCircleHidden = false;
}
public void startExitAnimation(final Runnable endRunnable) {
if (!mHorizontal) {
float offset = getHeight() / 2.0f;
setOffset(offset - mBaseMargin, true, 50, mFastOutSlowInInterpolator, null);
float xMax = getWidth() / 2;
float yMax = getHeight() / 2;
float maxRadius = (float) Math.ceil(Math.hypot(xMax, yMax) * 2);
setCircleSize(maxRadius, true, null, 50, mFastOutSlowInInterpolator);
performExitFadeOutAnimation(50, 300, endRunnable);
} else {
// when in landscape, we don't wan't the animation as it interferes with the general
// rotation animation to the homescreen.
endRunnable.run();
}
}
private void performExitFadeOutAnimation(int startDelay, int duration,
final Runnable endRunnable) {
mFadeOutAnimator = ValueAnimator.ofFloat(mBackgroundPaint.getAlpha() / 255.0f, 0.0f);
// Linear since we are animating multiple values
mFadeOutAnimator.setInterpolator(new LinearInterpolator());
mFadeOutAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
float animatedFraction = animation.getAnimatedFraction();
float logoValue = animatedFraction > 0.5f ? 1.0f : animatedFraction / 0.5f;
logoValue = PhoneStatusBar.ALPHA_OUT.getInterpolation(1.0f - logoValue);
float backgroundValue = animatedFraction < 0.2f ? 0.0f :
PhoneStatusBar.ALPHA_OUT.getInterpolation((animatedFraction - 0.2f) / 0.8f);
backgroundValue = 1.0f - backgroundValue;
mBackgroundPaint.setAlpha((int) (backgroundValue * 255));
mOutlineAlpha = backgroundValue;
mLogo.setAlpha(logoValue);
invalidateOutline();
invalidate();
}
});
mFadeOutAnimator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
if (endRunnable != null) {
endRunnable.run();
}
mLogo.setAlpha(1.0f);
mBackgroundPaint.setAlpha(255);
mOutlineAlpha = 1.0f;
mFadeOutAnimator = null;
}
});
mFadeOutAnimator.setStartDelay(startDelay);
mFadeOutAnimator.setDuration(duration);
mFadeOutAnimator.start();
}
public void setDraggedFarEnough(boolean farEnough) {
if (farEnough != mDraggedFarEnough) {
if (farEnough) {
if (mCircleHidden) {
startEnterAnimation();
}
if (mOffsetAnimator == null) {
addRipple();
} else {
postDelayed(new Runnable() {
@Override
public void run() {
addRipple();
}
}, 100);
}
} else {
startAbortAnimation(null);
}
mDraggedFarEnough = farEnough;
}
}
private void addRipple() {
if (mRipples.size() > 1) {
// we only want 2 ripples at the time
return;
}
float xInterpolation, yInterpolation;
if (mHorizontal) {
xInterpolation = 0.75f;
yInterpolation = 0.5f;
} else {
xInterpolation = 0.5f;
yInterpolation = 0.75f;
}
float circleCenterX = mStaticRect.left * (1.0f - xInterpolation)
+ mStaticRect.right * xInterpolation;
float circleCenterY = mStaticRect.top * (1.0f - yInterpolation)
+ mStaticRect.bottom * yInterpolation;
float radius = Math.max(mCircleSize, mCircleMinSize * 1.25f) * 0.75f;
Ripple ripple = new Ripple(circleCenterX, circleCenterY, radius);
ripple.start();
}
public void reset() {
mDraggedFarEnough = false;
mAnimatingOut = false;
mCircleHidden = true;
mClipToOutline = false;
if (mFadeOutAnimator != null) {
mFadeOutAnimator.cancel();
}
mBackgroundPaint.setAlpha(255);
mOutlineAlpha = 1.0f;
}
/**
* Check if an animation is currently running
*
* @param enterAnimation Is the animating queried the enter animation.
*/
public boolean isAnimationRunning(boolean enterAnimation) {
return mOffsetAnimator != null && (enterAnimation == mOffsetAnimatingIn);
}
public void performOnAnimationFinished(final Runnable runnable) {
if (mOffsetAnimator != null) {
mOffsetAnimator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
if (runnable != null) {
runnable.run();
}
}
});
} else {
if (runnable != null) {
runnable.run();
}
}
}
public void setAnimatingOut(boolean animatingOut) {
mAnimatingOut = animatingOut;
}
/**
* @return Whether the circle is currently launching to the search activity or aborting the
* interaction
*/
public boolean isAnimatingOut() {
return mAnimatingOut;
}
@Override
public boolean hasOverlappingRendering() {
// not really true but it's ok during an animation, as it's never permanent
return false;
}
private class Ripple {
float x;
float y;
float radius;
float endRadius;
float alpha;
Ripple(float x, float y, float endRadius) {
this.x = x;
this.y = y;
this.endRadius = endRadius;
}
void start() {
ValueAnimator animator = ValueAnimator.ofFloat(0.0f, 1.0f);
// Linear since we are animating multiple values
animator.setInterpolator(new LinearInterpolator());
animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
alpha = 1.0f - animation.getAnimatedFraction();
alpha = mDisappearInterpolator.getInterpolation(alpha);
radius = mAppearInterpolator.getInterpolation(animation.getAnimatedFraction());
radius *= endRadius;
invalidate();
}
});
animator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
mRipples.remove(Ripple.this);
updateClipping();
}
public void onAnimationStart(Animator animation) {
mRipples.add(Ripple.this);
updateClipping();
}
});
animator.setDuration(400);
animator.start();
}
public void draw(Canvas canvas) {
mRipplePaint.setAlpha((int) (alpha * 255));
canvas.drawCircle(x, y, radius, mRipplePaint);
}
}
}
|
