| /* |
| * 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(context.getColor(R.color.search_panel_circle_color)); |
| mRipplePaint.setColor(context.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); |
| } |
| } |
| |
| } |