src/com/android/launcher3/popup/PopupItemView.java

   1 /*
   2  * Copyright (C) 2017 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.launcher3.popup;
  18
  19 import android.animation.Animator;
  20 import android.animation.AnimatorListenerAdapter;
  21 import android.animation.ValueAnimator;
  22 import android.content.Context;
  23 import android.graphics.Bitmap;
  24 import android.graphics.Canvas;
  25 import android.graphics.Matrix;
  26 import android.graphics.Paint;
  27 import android.graphics.Point;
  28 import android.graphics.PorterDuff;
  29 import android.graphics.PorterDuffXfermode;
  30 import android.graphics.Rect;
  31 import android.util.AttributeSet;
  32 import android.view.View;
  33 import android.widget.FrameLayout;
  34
  35 import com.android.launcher3.LogAccelerateInterpolator;
  36 import com.android.launcher3.R;
  37 import com.android.launcher3.Utilities;
  38 import com.android.launcher3.util.PillRevealOutlineProvider;
  39
  40 /**
  41  * An abstract {@link FrameLayout} that supports animating an item's content
  42  * (e.g. icon and text) separate from the item's background.
  43  */
  44 public abstract class PopupItemView extends FrameLayout
  45         implements ValueAnimator.AnimatorUpdateListener {
  46
  47     protected static final Point sTempPoint = new Point();
  48
  49     protected final Rect mPillRect;
  50     private float mOpenAnimationProgress;
  51     protected final boolean mIsRtl;
  52     protected View mIconView;
  53
  54     private final Paint mBackgroundClipPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG);
  55     private final Matrix mMatrix = new Matrix();
  56     private Bitmap mRoundedCornerBitmap;
  57
  58     public PopupItemView(Context context) {
  59         this(context, null, 0);
  60     }
  61
  62     public PopupItemView(Context context, AttributeSet attrs) {
  63         this(context, attrs, 0);
  64     }
  65
  66     public PopupItemView(Context context, AttributeSet attrs, int defStyle) {
  67         super(context, attrs, defStyle);
  68
  69         mPillRect = new Rect();
  70
  71         // Initialize corner clipping Bitmap and Paint.
  72         int radius = (int) getBackgroundRadius();
  73         mRoundedCornerBitmap = Bitmap.createBitmap(radius, radius, Bitmap.Config.ALPHA_8);
  74         Canvas canvas = new Canvas();
  75         canvas.setBitmap(mRoundedCornerBitmap);
  76         canvas.drawArc(0, 0, radius*2, radius*2, 180, 90, true, mBackgroundClipPaint);
  77         mBackgroundClipPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
  78
  79         mIsRtl = Utilities.isRtl(getResources());
  80     }
  81
  82     @Override
  83     protected void onFinishInflate() {
  84         super.onFinishInflate();
  85         mIconView = findViewById(R.id.popup_item_icon);
  86     }
  87
  88     @Override
  89     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  90         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  91         mPillRect.set(0, 0, getMeasuredWidth(), getMeasuredHeight());
  92     }
  93
  94     @Override
  95     protected void dispatchDraw(Canvas canvas) {
  96         int saveCount = canvas.saveLayer(0, 0, getWidth(), getHeight(), null);
  97         super.dispatchDraw(canvas);
  98
  99         int cornerWidth = mRoundedCornerBitmap.getWidth();
 100         int cornerHeight = mRoundedCornerBitmap.getHeight();
 101         // Clip top left corner.
 102         mMatrix.reset();
 103         canvas.drawBitmap(mRoundedCornerBitmap, mMatrix, mBackgroundClipPaint);
 104         // Clip top right corner.
 105         mMatrix.setRotate(90, cornerWidth / 2, cornerHeight / 2);
 106         mMatrix.postTranslate(canvas.getWidth() - cornerWidth, 0);
 107         canvas.drawBitmap(mRoundedCornerBitmap, mMatrix, mBackgroundClipPaint);
 108         // Clip bottom right corner.
 109         mMatrix.setRotate(180, cornerWidth / 2, cornerHeight / 2);
 110         mMatrix.postTranslate(canvas.getWidth() - cornerWidth, canvas.getHeight() - cornerHeight);
 111         canvas.drawBitmap(mRoundedCornerBitmap, mMatrix, mBackgroundClipPaint);
 112         // Clip bottom left corner.
 113         mMatrix.setRotate(270, cornerWidth / 2, cornerHeight / 2);
 114         mMatrix.postTranslate(0, canvas.getHeight() - cornerHeight);
 115         canvas.drawBitmap(mRoundedCornerBitmap, mMatrix, mBackgroundClipPaint);
 116
 117         canvas.restoreToCount(saveCount);
 118     }
 119
 120     /**
 121      * Creates an animator to play when the shortcut container is being opened.
 122      */
 123     public Animator createOpenAnimation(boolean isContainerAboveIcon, boolean pivotLeft) {
 124         Point center = getIconCenter();
 125         int arrowCenter = getResources().getDimensionPixelSize(pivotLeft ^ mIsRtl ?
 126                 R.dimen.popup_arrow_horizontal_center_start:
 127                 R.dimen.popup_arrow_horizontal_center_end);
 128         ValueAnimator openAnimator =  new ZoomRevealOutlineProvider(center.x, center.y,
 129                 mPillRect, this, mIconView, isContainerAboveIcon, pivotLeft, arrowCenter)
 130                         .createRevealAnimator(this, false);
 131         mOpenAnimationProgress = 0f;
 132         openAnimator.addUpdateListener(this);
 133         return openAnimator;
 134     }
 135
 136     @Override
 137     public void onAnimationUpdate(ValueAnimator valueAnimator) {
 138         mOpenAnimationProgress = valueAnimator.getAnimatedFraction();
 139     }
 140
 141     public boolean isOpenOrOpening() {
 142         return mOpenAnimationProgress > 0;
 143     }
 144
 145     /**
 146      * Creates an animator to play when the shortcut container is being closed.
 147      */
 148     public Animator createCloseAnimation(boolean isContainerAboveIcon, boolean pivotLeft,
 149             long duration) {
 150         Point center = getIconCenter();
 151         int arrowCenter = getResources().getDimensionPixelSize(pivotLeft ^ mIsRtl ?
 152                 R.dimen.popup_arrow_horizontal_center_start :
 153                 R.dimen.popup_arrow_horizontal_center_end);
 154         ValueAnimator closeAnimator = new ZoomRevealOutlineProvider(center.x, center.y,
 155                 mPillRect, this, mIconView, isContainerAboveIcon, pivotLeft, arrowCenter)
 156                         .createRevealAnimator(this, true);
 157         // Scale down the duration and interpolator according to the progress
 158         // that the open animation was at when the close started.
 159         closeAnimator.setDuration((long) (duration * mOpenAnimationProgress));
 160         closeAnimator.setInterpolator(new CloseInterpolator(mOpenAnimationProgress));
 161         closeAnimator.addListener(new AnimatorListenerAdapter() {
 162             @Override
 163             public void onAnimationEnd(Animator animation) {
 164                 mOpenAnimationProgress = 0;
 165             }
 166         });
 167         return closeAnimator;
 168     }
 169
 170     /**
 171      * Returns the position of the center of the icon relative to the container.
 172      */
 173     public Point getIconCenter() {
 174         sTempPoint.y = getMeasuredHeight() / 2;
 175         sTempPoint.x = getResources().getDimensionPixelSize(R.dimen.bg_popup_item_height) / 2;
 176         if (Utilities.isRtl(getResources())) {
 177             sTempPoint.x = getMeasuredWidth() - sTempPoint.x;
 178         }
 179         return sTempPoint;
 180     }
 181
 182     protected float getBackgroundRadius() {
 183         return getResources().getDimensionPixelSize(R.dimen.bg_round_rect_radius);
 184     }
 185
 186     public abstract int getArrowColor(boolean isArrowAttachedToBottom);
 187
 188     /**
 189      * Extension of {@link PillRevealOutlineProvider} which scales the icon based on the height.
 190      */
 191     private static class ZoomRevealOutlineProvider extends PillRevealOutlineProvider {
 192
 193         private final View mTranslateView;
 194         private final View mZoomView;
 195
 196         private final float mFullHeight;
 197         private final float mTranslateYMultiplier;
 198
 199         private final boolean mPivotLeft;
 200         private final float mTranslateX;
 201         private final float mArrowCenter;
 202
 203         public ZoomRevealOutlineProvider(int x, int y, Rect pillRect, PopupItemView translateView,
 204                 View zoomView, boolean isContainerAboveIcon, boolean pivotLeft, float arrowCenter) {
 205             super(x, y, pillRect, translateView.getBackgroundRadius());
 206             mTranslateView = translateView;
 207             mZoomView = zoomView;
 208             mFullHeight = pillRect.height();
 209
 210             mTranslateYMultiplier = isContainerAboveIcon ? 0.5f : -0.5f;
 211
 212             mPivotLeft = pivotLeft;
 213             mTranslateX = pivotLeft ? arrowCenter : pillRect.right - arrowCenter;
 214             mArrowCenter = arrowCenter;
 215         }
 216
 217         @Override
 218         public void setProgress(float progress) {
 219             super.setProgress(progress);
 220
 221             if (mZoomView != null) {
 222                 mZoomView.setScaleX(progress);
 223                 mZoomView.setScaleY(progress);
 224             }
 225
 226             float height = mOutline.height();
 227             mTranslateView.setTranslationY(mTranslateYMultiplier * (mFullHeight - height));
 228
 229             float offsetX = Math.min(mOutline.width(), mArrowCenter);
 230             float pivotX = mPivotLeft ? (mOutline.left + offsetX) : (mOutline.right - offsetX);
 231             mTranslateView.setTranslationX(mTranslateX - pivotX);
 232         }
 233     }
 234
 235     /**
 236      * An interpolator that reverses the current open animation progress.
 237      */
 238     private static class CloseInterpolator extends LogAccelerateInterpolator {
 239         private float mStartProgress;
 240         private float mRemainingProgress;
 241
 242         /**
 243          * @param openAnimationProgress The progress that the open interpolator ended at.
 244          */
 245         public CloseInterpolator(float openAnimationProgress) {
 246             super(100, 0);
 247             mStartProgress = 1f - openAnimationProgress;
 248             mRemainingProgress = openAnimationProgress;
 249         }
 250
 251         @Override
 252         public float getInterpolation(float v) {
 253             return mStartProgress + super.getInterpolation(v) * mRemainingProgress;
 254         }
 255     }
 256 }