src/com/android/launcher3/views/FloatingIconView.java - platform/packages/apps/Launcher3 - Gitiles

 /*
  * Copyright (C) 2019 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.launcher3.views;

 import static com.android.launcher3.Utilities.mapToRange;
 import static com.android.launcher3.anim.Interpolators.LINEAR;
 import static com.android.launcher3.config.FeatureFlags.ADAPTIVE_ICON_WINDOW_ANIM;

 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
 import android.animation.ValueAnimator;
 import android.annotation.TargetApi;
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Outline;
 import android.graphics.Path;
 import android.graphics.Rect;
 import android.graphics.RectF;
 import android.graphics.drawable.AdaptiveIconDrawable;
 import android.graphics.drawable.ColorDrawable;
 import android.graphics.drawable.Drawable;
 import android.os.Build;
 import android.os.CancellationSignal;
 import android.os.Handler;
 import android.os.Looper;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewOutlineProvider;
 import android.widget.ImageView;

 import com.android.launcher3.BubbleTextView;
 import com.android.launcher3.InsettableFrameLayout.LayoutParams;
 import com.android.launcher3.ItemInfo;
 import com.android.launcher3.Launcher;
 import com.android.launcher3.LauncherModel;
 import com.android.launcher3.R;
 import com.android.launcher3.Utilities;
 import com.android.launcher3.dragndrop.DragLayer;
 import com.android.launcher3.dragndrop.FolderAdaptiveIcon;
 import com.android.launcher3.folder.FolderIcon;
 import com.android.launcher3.graphics.IconShape;
 import com.android.launcher3.graphics.ShiftedBitmapDrawable;
 import com.android.launcher3.icons.LauncherIcons;
 import com.android.launcher3.popup.SystemShortcut;
 import com.android.launcher3.shortcuts.DeepShortcutView;

 import androidx.annotation.Nullable;
 import androidx.annotation.WorkerThread;

 /**
  * A view that is created to look like another view with the purpose of creating fluid animations.
  */
 @TargetApi(Build.VERSION_CODES.Q)
 public class FloatingIconView extends View implements Animator.AnimatorListener, ClipPathView {

     public static final float SHAPE_PROGRESS_DURATION = 0.15f;
     private static final int FADE_DURATION_MS = 200;
     private static final Rect sTmpRect = new Rect();
     private static final Object[] sTmpObjArray = new Object[1];

     private Runnable mEndRunnable;
     private CancellationSignal mLoadIconSignal;

     private final int mBlurSizeOutline;

     private boolean mIsVerticalBarLayout = false;
     private boolean mIsAdaptiveIcon = false;

     private @Nullable Drawable mForeground;
     private @Nullable Drawable mBackground;
     private float mRotation;
     private ValueAnimator mRevealAnimator;
     private final Rect mStartRevealRect = new Rect();
     private final Rect mEndRevealRect = new Rect();
     private Path mClipPath;
     private float mTaskCornerRadius;

     private final Rect mFinalDrawableBounds = new Rect();
     private final Rect mBgDrawableBounds = new Rect();
     private float mBgDrawableStartScale = 1f;
     private float mBgDrawableEndScale = 1f;

     private AnimatorSet mFadeAnimatorSet;
     private ListenerView mListenerView;

     private FloatingIconView(Context context) {
         super(context);

         mBlurSizeOutline = context.getResources().getDimensionPixelSize(
                 R.dimen.blur_size_medium_outline);
         mListenerView = new ListenerView(context, null);
     }

     /**
      * Positions this view to match the size and location of {@param rect}.
      * @param alpha The alpha to set this view.
      * @param progress A value from [0, 1] that represents the animation progress.
      * @param shapeProgressStart The progress value at which to start the shape reveal.
      * @param cornerRadius The corner radius of {@param rect}.
      */
     public void update(RectF rect, float alpha, float progress, float shapeProgressStart,
             float cornerRadius, boolean isOpening) {
         setAlpha(alpha);

         LayoutParams lp = (LayoutParams) getLayoutParams();
         float dX = rect.left - lp.leftMargin;
         float dY = rect.top - lp.topMargin;
         setTranslationX(dX);
         setTranslationY(dY);

         float scaleX = rect.width() / (float) lp.width;
         float scaleY = rect.height() / (float) lp.height;
         float scale = mIsAdaptiveIcon && !isOpening ? Math.max(scaleX, scaleY)
                 : Math.min(scaleX, scaleY);
         scale = Math.max(1f, scale);

         setPivotX(0);
         setPivotY(0);
         setScaleX(scale);
         setScaleY(scale);

         // shapeRevealProgress = 1 when progress = shapeProgressStart + SHAPE_PROGRESS_DURATION
         float toMax = isOpening ? 1 / SHAPE_PROGRESS_DURATION : 1f;
         float shapeRevealProgress = Utilities.boundToRange(mapToRange(
                 Math.max(shapeProgressStart, progress), shapeProgressStart, 1f, 0, toMax,
                 LINEAR), 0, 1);

         mTaskCornerRadius = cornerRadius;
         if (mIsAdaptiveIcon && shapeRevealProgress >= 0) {
             if (mRevealAnimator == null) {
                 mRevealAnimator = (ValueAnimator) IconShape.getShape().createRevealAnimator(this,
                         mStartRevealRect, mEndRevealRect, mTaskCornerRadius / scale, !isOpening);
                 mRevealAnimator.addListener(new AnimatorListenerAdapter() {
                     @Override
                     public void onAnimationEnd(Animator animation) {
                         mRevealAnimator = null;
                     }
                 });
                 mRevealAnimator.start();
                 // We pause here so we can set the current fraction ourselves.
                 mRevealAnimator.pause();
             }

             mRevealAnimator.setCurrentFraction(shapeRevealProgress);

             float bgScale = (mBgDrawableEndScale * shapeRevealProgress) + mBgDrawableStartScale
                     * (1 - shapeRevealProgress);
             setBackgroundDrawableBounds(bgScale);
         }
         invalidate();
         invalidateOutline();
     }

     @Override
     public void onAnimationEnd(Animator animator) {
         if (mLoadIconSignal != null) {
             mLoadIconSignal.cancel();
         }
         if (mEndRunnable != null) {
             mEndRunnable.run();
         } else {
             // End runnable also ends the reveal animator, so we manually handle it here.
             if (mRevealAnimator != null) {
                 mRevealAnimator.end();
             }
         }
     }

     /**
      * Sets the size and position of this view to match {@param v}.
      *
      * @param v The view to copy
      * @param positionOut Rect that will hold the size and position of v.
      */
     private void matchPositionOf(Launcher launcher, View v, RectF positionOut) {
         mRotation = getLocationBoundsForView(launcher, v, positionOut);
         final LayoutParams lp = new LayoutParams(
                 Math.round(positionOut.width()),
                 Math.round(positionOut.height()));
         lp.ignoreInsets = true;

         // Position the floating view exactly on top of the original
         lp.leftMargin = Math.round(positionOut.left);
         lp.topMargin = Math.round(positionOut.top);
         setLayoutParams(lp);
         // Set the properties here already to make sure they are available when running the first
         // animation frame.
         layout(lp.leftMargin, lp.topMargin, lp.leftMargin + lp.width, lp.topMargin
                 + lp.height);
     }

     /**
      * Gets the location bounds of a view and returns the overall rotation.
      * - For DeepShortcutView, we return the bounds of the icon view.
      * - For BubbleTextView, we return the icon bounds.
      */
     private float getLocationBoundsForView(Launcher launcher, View v, RectF outRect) {
         boolean ignoreTransform = true;
         if (v instanceof DeepShortcutView) {
             v = ((DeepShortcutView) v).getBubbleText();
             ignoreTransform = false;
         } else if (v.getParent() instanceof DeepShortcutView) {
             v = ((DeepShortcutView) v.getParent()).getIconView();
             ignoreTransform = false;
         }
         if (v == null) {
             return 0;
         }

         Rect iconBounds = new Rect();
         if (v instanceof BubbleTextView) {
             ((BubbleTextView) v).getIconBounds(iconBounds);
         } else if (v instanceof FolderIcon) {
             ((FolderIcon) v).getPreviewBounds(iconBounds);
         } else {
             iconBounds.set(0, 0, v.getWidth(), v.getHeight());
         }

         float[] points = new float[] {iconBounds.left, iconBounds.top, iconBounds.right,
                 iconBounds.bottom};
         float[] rotation = new float[] {0};
         Utilities.getDescendantCoordRelativeToAncestor(v, launcher.getDragLayer(), points,
                 false, ignoreTransform, rotation);
         outRect.set(
                 Math.min(points[0], points[2]),
                 Math.min(points[1], points[3]),
                 Math.max(points[0], points[2]),
                 Math.max(points[1], points[3]));
         return rotation[0];
     }

     @WorkerThread
     private void getIcon(Launcher launcher, View v, ItemInfo info, boolean isOpening,
             Runnable onIconLoadedRunnable, CancellationSignal loadIconSignal) {
         final LayoutParams lp = (LayoutParams) getLayoutParams();
         Drawable drawable = null;
         boolean supportsAdaptiveIcons = ADAPTIVE_ICON_WINDOW_ANIM.get()
                 && Build.VERSION.SDK_INT >= Build.VERSION_CODES.O;
         Drawable btvIcon = v instanceof BubbleTextView ? ((BubbleTextView) v).getIcon() : null;
         if (info instanceof SystemShortcut) {
             if (v instanceof ImageView) {
                 drawable = ((ImageView) v).getDrawable();
             } else if (v instanceof DeepShortcutView) {
                 drawable = ((DeepShortcutView) v).getIconView().getBackground();
             } else {
                 drawable = v.getBackground();
             }
         } else {
             if (supportsAdaptiveIcons) {
                 drawable = Utilities.getFullDrawable(launcher, info, lp.width, lp.height,
                         false, sTmpObjArray);
                 if (!(drawable instanceof AdaptiveIconDrawable)) {
                     // The drawable we get back is not an adaptive icon, so we need to use the
                     // BubbleTextView icon that is already legacy treated.
                     drawable = btvIcon;
                 }
             } else {
                 if (v instanceof BubbleTextView) {
                     // Similar to DragView, we simply use the BubbleTextView icon here.
                     drawable = btvIcon;
                 } else {
                     drawable = Utilities.getFullDrawable(launcher, info, lp.width, lp.height,
                             false, sTmpObjArray);
                 }
             }
         }

         Drawable finalDrawable = drawable == null ? null
                 : drawable.getConstantState().newDrawable();
         boolean isAdaptiveIcon = supportsAdaptiveIcons
                 && finalDrawable instanceof AdaptiveIconDrawable;
         int iconOffset = getOffsetForIconBounds(finalDrawable);

         new Handler(Looper.getMainLooper()).post(() -> {
             if (isAdaptiveIcon) {
                 mIsAdaptiveIcon = true;
                 boolean isFolderIcon = finalDrawable instanceof FolderAdaptiveIcon;

                 AdaptiveIconDrawable adaptiveIcon = (AdaptiveIconDrawable) finalDrawable;
                 Drawable background = adaptiveIcon.getBackground();
                 if (background == null) {
                     background = new ColorDrawable(Color.TRANSPARENT);
                 }
                 mBackground = background;
                 Drawable foreground = adaptiveIcon.getForeground();
                 if (foreground == null) {
                     foreground = new ColorDrawable(Color.TRANSPARENT);
                 }
                 mForeground = foreground;

                 if (mForeground instanceof ShiftedBitmapDrawable && v instanceof FolderIcon) {
                     ShiftedBitmapDrawable sbd = (ShiftedBitmapDrawable) mForeground;
                     ((FolderIcon) v).getPreviewBounds(sTmpRect);
                     sbd.setShiftX(sbd.getShiftX() - sTmpRect.left);
                     sbd.setShiftY(sbd.getShiftY() - sTmpRect.top);
                 }

                 final int originalHeight = lp.height;
                 final int originalWidth = lp.width;

                 int blurMargin = mBlurSizeOutline / 2;
                 mFinalDrawableBounds.set(0, 0, originalWidth, originalHeight);
                 if (!isFolderIcon) {
                     mFinalDrawableBounds.inset(iconOffset - blurMargin, iconOffset - blurMargin);
                 }
                 mForeground.setBounds(mFinalDrawableBounds);
                 mBackground.setBounds(mFinalDrawableBounds);

                 mStartRevealRect.set(0, 0, originalWidth, originalHeight);

                 if (!isFolderIcon) {
                     mStartRevealRect.inset(mBlurSizeOutline, mBlurSizeOutline);
                 }

                 float aspectRatio = launcher.getDeviceProfile().aspectRatio;
                 if (mIsVerticalBarLayout) {
                     lp.width = (int) Math.max(lp.width, lp.height * aspectRatio);
                 } else {
                     lp.height = (int) Math.max(lp.height, lp.width * aspectRatio);
                 }
                 layout(lp.leftMargin, lp.topMargin, lp.leftMargin + lp.width, lp.topMargin
                         + lp.height);

                 Rect rectOutline = new Rect();
                 float scale = Math.max((float) lp.height / originalHeight,
                         (float) lp.width / originalWidth);
                 if (isOpening) {
                     mBgDrawableStartScale = 1f;
                     mBgDrawableEndScale = scale;
                     rectOutline.set(0, 0, originalWidth, originalHeight);
                 } else {
                     mBgDrawableStartScale = scale;
                     mBgDrawableEndScale = 1f;
                     rectOutline.set(0, 0, lp.width, lp.height);
                 }
                 mEndRevealRect.set(0, 0, lp.width, lp.height);
                 setBackgroundDrawableBounds(mBgDrawableStartScale);
                 setOutlineProvider(new ViewOutlineProvider() {
                     @Override
                     public void getOutline(View view, Outline outline) {
                         outline.setRoundRect(rectOutline, mTaskCornerRadius);
                     }
                 });
                 setClipToOutline(true);
             } else {
                 setBackground(finalDrawable);
             }

             if (!loadIconSignal.isCanceled()) {
                 onIconLoadedRunnable.run();
             }
             invalidate();
             invalidateOutline();
         });
     }

     private void setBackgroundDrawableBounds(float scale) {
         mBgDrawableBounds.set(mFinalDrawableBounds);
         Utilities.scaleRectAboutCenter(mBgDrawableBounds, scale);
         // Since the drawable is at the top of the view, we need to offset to keep it centered.
         if (mIsVerticalBarLayout) {
             mBgDrawableBounds.offsetTo((int) (mFinalDrawableBounds.left  * scale),
                     mBgDrawableBounds.top);
         } else {
             mBgDrawableBounds.offsetTo(mBgDrawableBounds.left,
                     (int) (mFinalDrawableBounds.top * scale));
         }
         mBackground.setBounds(mBgDrawableBounds);
     }

     @WorkerThread
     private int getOffsetForIconBounds(Drawable drawable) {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O ||
                 !(drawable instanceof AdaptiveIconDrawable)) {
             return 0;
         }

         final LayoutParams lp = (LayoutParams) getLayoutParams();
         Rect bounds = new Rect(0, 0, lp.width + mBlurSizeOutline, lp.height + mBlurSizeOutline);
         bounds.inset(mBlurSizeOutline / 2, mBlurSizeOutline / 2);

         try (LauncherIcons li = LauncherIcons.obtain(Launcher.fromContext(getContext()))) {
             Utilities.scaleRectAboutCenter(bounds, li.getNormalizer().getScale(drawable, null));
         }

         bounds.inset(
                 (int) (-bounds.width() * AdaptiveIconDrawable.getExtraInsetFraction()),
                 (int) (-bounds.height() * AdaptiveIconDrawable.getExtraInsetFraction())
         );

         return bounds.left;
     }

     @Override
     public void setClipPath(Path clipPath) {
         mClipPath = clipPath;
         invalidate();
     }

     @Override
     public void draw(Canvas canvas) {
         int count = canvas.save();
         canvas.rotate(mRotation,
                 mFinalDrawableBounds.exactCenterX(), mFinalDrawableBounds.exactCenterY());
         if (mClipPath != null) {
             canvas.clipPath(mClipPath);
         }
         super.draw(canvas);
         if (mBackground != null) {
             mBackground.draw(canvas);
         }
         if (mForeground != null) {
             mForeground.draw(canvas);
         }
         canvas.restoreToCount(count);
     }

     public void onListenerViewClosed() {
         // Fast finish here.
         if (mEndRunnable != null) {
             mEndRunnable.run();
             mEndRunnable = null;
         }
         if (mFadeAnimatorSet != null) {
             mFadeAnimatorSet.end();
             mFadeAnimatorSet = null;
         }
     }

     @Override
     public void onAnimationStart(Animator animator) {}

     @Override
     public void onAnimationCancel(Animator animator) {}

     @Override
     public void onAnimationRepeat(Animator animator) {}

     /**
      * Creates a floating icon view for {@param originalView}.
      * @param originalView The view to copy
      * @param hideOriginal If true, it will hide {@param originalView} while this view is visible.
      *                     Else, we will not draw anything in this view.
      * @param positionOut Rect that will hold the size and position of v.
      * @param isOpening True if this view replaces the icon for app open animation.
      */
     public static FloatingIconView getFloatingIconView(Launcher launcher, View originalView,
             boolean hideOriginal, RectF positionOut, boolean isOpening, FloatingIconView recycle) {
         if (recycle != null) {
             recycle.recycle();
         }
         FloatingIconView view = recycle != null ? recycle : new FloatingIconView(launcher);
         view.mIsVerticalBarLayout = launcher.getDeviceProfile().isVerticalBarLayout();

         // Match the position of the original view.
         view.matchPositionOf(launcher, originalView, positionOut);

         // Get the drawable on the background thread
         // Must be called after matchPositionOf so that we know what size to load.
         if (originalView.getTag() instanceof ItemInfo && hideOriginal) {
             view.mLoadIconSignal = new CancellationSignal();
             Runnable onIconLoaded = () -> {
                 // Delay swapping views until the icon is loaded to prevent a flash.
                 view.setVisibility(VISIBLE);
                 originalView.setVisibility(INVISIBLE);
             };
             CancellationSignal loadIconSignal = view.mLoadIconSignal;
             new Handler(LauncherModel.getWorkerLooper()).postAtFrontOfQueue(() -> {
                 view.getIcon(launcher, originalView, (ItemInfo) originalView.getTag(), isOpening,
                         onIconLoaded, loadIconSignal);
             });
         }

         // We need to add it to the overlay, but keep it invisible until animation starts..
         final DragLayer dragLayer = launcher.getDragLayer();
         view.setVisibility(INVISIBLE);
         ((ViewGroup) dragLayer.getParent()).addView(view);
         dragLayer.addView(view.mListenerView);
         view.mListenerView.setListener(view::onListenerViewClosed);

         view.mEndRunnable = () -> {
             view.mEndRunnable = null;

             if (hideOriginal) {
                 if (isOpening) {
                     originalView.setVisibility(VISIBLE);
                     view.finish(dragLayer);
                 } else {
                     view.mFadeAnimatorSet = view.createFadeAnimation(originalView, dragLayer);
                     view.mFadeAnimatorSet.start();
                 }
             } else {
                 view.finish(dragLayer);
             }
         };
         return view;
     }

     private AnimatorSet createFadeAnimation(View originalView, DragLayer dragLayer) {
         AnimatorSet fade = new AnimatorSet();
         fade.setDuration(FADE_DURATION_MS);
         fade.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationStart(Animator animation) {
                 originalView.setVisibility(VISIBLE);
             }

             @Override
             public void onAnimationEnd(Animator animation) {
                 finish(dragLayer);
             }
         });

         if (originalView instanceof FolderIcon) {
             FolderIcon folderIcon = (FolderIcon) originalView;
             folderIcon.setBackgroundVisible(false);
             folderIcon.getFolderName().setTextVisibility(false);
             fade.play(folderIcon.getFolderName().createTextAlphaAnimator(true));
             fade.addListener(new AnimatorListenerAdapter() {
                 @Override
                 public void onAnimationEnd(Animator animation) {
                     folderIcon.setBackgroundVisible(true);
                     folderIcon.animateBgShadowAndStroke();
                     if (folderIcon.hasDot()) {
                         folderIcon.animateDotScale(0, 1f);
                     }
                 }
             });
         } else {
             fade.play(ObjectAnimator.ofFloat(originalView, ALPHA, 0f, 1f));
         }

         return fade;
     }

     private void finish(DragLayer dragLayer) {
         ((ViewGroup) dragLayer.getParent()).removeView(this);
         dragLayer.removeView(mListenerView);
         recycle();
     }

     private void recycle() {
         setTranslationX(0);
         setTranslationY(0);
         setScaleX(1);
         setScaleY(1);
         setAlpha(1);
         setBackground(null);
         if (mLoadIconSignal != null) {
             mLoadIconSignal.cancel();
         }
         mLoadIconSignal = null;
         mEndRunnable = null;
         mIsAdaptiveIcon = false;
         mForeground = null;
         mBackground = null;
         mClipPath = null;
         mFinalDrawableBounds.setEmpty();
         mBgDrawableBounds.setEmpty();
         if (mRevealAnimator != null) {
             mRevealAnimator.cancel();
         }
         mRevealAnimator = null;
         if (mFadeAnimatorSet != null) {
             mFadeAnimatorSet.cancel();
         }
         mFadeAnimatorSet = null;
         mListenerView.setListener(null);
     }
 }
	/*
	* Copyright (C) 2019 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.launcher3.views;

	import static com.android.launcher3.Utilities.mapToRange;
	import static com.android.launcher3.anim.Interpolators.LINEAR;
	import static com.android.launcher3.config.FeatureFlags.ADAPTIVE_ICON_WINDOW_ANIM;

	import android.animation.Animator;
	import android.animation.AnimatorListenerAdapter;
	import android.animation.AnimatorSet;
	import android.animation.ObjectAnimator;
	import android.animation.ValueAnimator;
	import android.annotation.TargetApi;
	import android.content.Context;
	import android.graphics.Canvas;
	import android.graphics.Color;
	import android.graphics.Outline;
	import android.graphics.Path;
	import android.graphics.Rect;
	import android.graphics.RectF;
	import android.graphics.drawable.AdaptiveIconDrawable;
	import android.graphics.drawable.ColorDrawable;
	import android.graphics.drawable.Drawable;
	import android.os.Build;
	import android.os.CancellationSignal;
	import android.os.Handler;
	import android.os.Looper;
	import android.view.View;
	import android.view.ViewGroup;
	import android.view.ViewOutlineProvider;
	import android.widget.ImageView;

	import com.android.launcher3.BubbleTextView;
	import com.android.launcher3.InsettableFrameLayout.LayoutParams;
	import com.android.launcher3.ItemInfo;
	import com.android.launcher3.Launcher;
	import com.android.launcher3.LauncherModel;
	import com.android.launcher3.R;
	import com.android.launcher3.Utilities;
	import com.android.launcher3.dragndrop.DragLayer;
	import com.android.launcher3.dragndrop.FolderAdaptiveIcon;
	import com.android.launcher3.folder.FolderIcon;
	import com.android.launcher3.graphics.IconShape;
	import com.android.launcher3.graphics.ShiftedBitmapDrawable;
	import com.android.launcher3.icons.LauncherIcons;
	import com.android.launcher3.popup.SystemShortcut;
	import com.android.launcher3.shortcuts.DeepShortcutView;

	import androidx.annotation.Nullable;
	import androidx.annotation.WorkerThread;

	/**
	* A view that is created to look like another view with the purpose of creating fluid animations.
	*/
	@TargetApi(Build.VERSION_CODES.Q)
	public class FloatingIconView extends View implements Animator.AnimatorListener, ClipPathView {

	public static final float SHAPE_PROGRESS_DURATION = 0.15f;
	private static final int FADE_DURATION_MS = 200;
	private static final Rect sTmpRect = new Rect();
	private static final Object[] sTmpObjArray = new Object[1];

	private Runnable mEndRunnable;
	private CancellationSignal mLoadIconSignal;

	private final int mBlurSizeOutline;

	private boolean mIsVerticalBarLayout = false;
	private boolean mIsAdaptiveIcon = false;

	private @Nullable Drawable mForeground;
	private @Nullable Drawable mBackground;
	private float mRotation;
	private ValueAnimator mRevealAnimator;
	private final Rect mStartRevealRect = new Rect();
	private final Rect mEndRevealRect = new Rect();
	private Path mClipPath;
	private float mTaskCornerRadius;

	private final Rect mFinalDrawableBounds = new Rect();
	private final Rect mBgDrawableBounds = new Rect();
	private float mBgDrawableStartScale = 1f;
	private float mBgDrawableEndScale = 1f;

	private AnimatorSet mFadeAnimatorSet;
	private ListenerView mListenerView;

	private FloatingIconView(Context context) {
	super(context);

	mBlurSizeOutline = context.getResources().getDimensionPixelSize(
	R.dimen.blur_size_medium_outline);
	mListenerView = new ListenerView(context, null);
	}

	/**
	* Positions this view to match the size and location of {@param rect}.
	* @param alpha The alpha to set this view.
	* @param progress A value from [0, 1] that represents the animation progress.
	* @param shapeProgressStart The progress value at which to start the shape reveal.
	* @param cornerRadius The corner radius of {@param rect}.
	*/
	public void update(RectF rect, float alpha, float progress, float shapeProgressStart,
	float cornerRadius, boolean isOpening) {
	setAlpha(alpha);

	LayoutParams lp = (LayoutParams) getLayoutParams();
	float dX = rect.left - lp.leftMargin;
	float dY = rect.top - lp.topMargin;
	setTranslationX(dX);
	setTranslationY(dY);

	float scaleX = rect.width() / (float) lp.width;
	float scaleY = rect.height() / (float) lp.height;
	float scale = mIsAdaptiveIcon && !isOpening ? Math.max(scaleX, scaleY)
	: Math.min(scaleX, scaleY);
	scale = Math.max(1f, scale);

	setPivotX(0);
	setPivotY(0);
	setScaleX(scale);
	setScaleY(scale);

	// shapeRevealProgress = 1 when progress = shapeProgressStart + SHAPE_PROGRESS_DURATION
	float toMax = isOpening ? 1 / SHAPE_PROGRESS_DURATION : 1f;
	float shapeRevealProgress = Utilities.boundToRange(mapToRange(
	Math.max(shapeProgressStart, progress), shapeProgressStart, 1f, 0, toMax,
	LINEAR), 0, 1);

	mTaskCornerRadius = cornerRadius;
	if (mIsAdaptiveIcon && shapeRevealProgress >= 0) {
	if (mRevealAnimator == null) {
	mRevealAnimator = (ValueAnimator) IconShape.getShape().createRevealAnimator(this,
	mStartRevealRect, mEndRevealRect, mTaskCornerRadius / scale, !isOpening);
	mRevealAnimator.addListener(new AnimatorListenerAdapter() {
	@Override
	public void onAnimationEnd(Animator animation) {
	mRevealAnimator = null;
	}
	});
	mRevealAnimator.start();
	// We pause here so we can set the current fraction ourselves.
	mRevealAnimator.pause();
	}

	mRevealAnimator.setCurrentFraction(shapeRevealProgress);

	float bgScale = (mBgDrawableEndScale * shapeRevealProgress) + mBgDrawableStartScale
	* (1 - shapeRevealProgress);
	setBackgroundDrawableBounds(bgScale);
	}
	invalidate();
	invalidateOutline();
	}

	@Override
	public void onAnimationEnd(Animator animator) {
	if (mLoadIconSignal != null) {
	mLoadIconSignal.cancel();
	}
	if (mEndRunnable != null) {
	mEndRunnable.run();
	} else {
	// End runnable also ends the reveal animator, so we manually handle it here.
	if (mRevealAnimator != null) {
	mRevealAnimator.end();
	}
	}
	}

	/**
	* Sets the size and position of this view to match {@param v}.
	*
	* @param v The view to copy
	* @param positionOut Rect that will hold the size and position of v.
	*/
	private void matchPositionOf(Launcher launcher, View v, RectF positionOut) {
	mRotation = getLocationBoundsForView(launcher, v, positionOut);
	final LayoutParams lp = new LayoutParams(
	Math.round(positionOut.width()),
	Math.round(positionOut.height()));
	lp.ignoreInsets = true;

	// Position the floating view exactly on top of the original
	lp.leftMargin = Math.round(positionOut.left);
	lp.topMargin = Math.round(positionOut.top);
	setLayoutParams(lp);
	// Set the properties here already to make sure they are available when running the first
	// animation frame.
	layout(lp.leftMargin, lp.topMargin, lp.leftMargin + lp.width, lp.topMargin
	+ lp.height);
	}

	/**
	* Gets the location bounds of a view and returns the overall rotation.
	* - For DeepShortcutView, we return the bounds of the icon view.
	* - For BubbleTextView, we return the icon bounds.
	*/
	private float getLocationBoundsForView(Launcher launcher, View v, RectF outRect) {
	boolean ignoreTransform = true;
	if (v instanceof DeepShortcutView) {
	v = ((DeepShortcutView) v).getBubbleText();
	ignoreTransform = false;
	} else if (v.getParent() instanceof DeepShortcutView) {
	v = ((DeepShortcutView) v.getParent()).getIconView();
	ignoreTransform = false;
	}
	if (v == null) {
	return 0;
	}

	Rect iconBounds = new Rect();
	if (v instanceof BubbleTextView) {
	((BubbleTextView) v).getIconBounds(iconBounds);
	} else if (v instanceof FolderIcon) {
	((FolderIcon) v).getPreviewBounds(iconBounds);
	} else {
	iconBounds.set(0, 0, v.getWidth(), v.getHeight());
	}

	float[] points = new float[] {iconBounds.left, iconBounds.top, iconBounds.right,
	iconBounds.bottom};
	float[] rotation = new float[] {0};
	Utilities.getDescendantCoordRelativeToAncestor(v, launcher.getDragLayer(), points,
	false, ignoreTransform, rotation);
	outRect.set(
	Math.min(points[0], points[2]),
	Math.min(points[1], points[3]),
	Math.max(points[0], points[2]),
	Math.max(points[1], points[3]));
	return rotation[0];
	}

	@WorkerThread
	private void getIcon(Launcher launcher, View v, ItemInfo info, boolean isOpening,
	Runnable onIconLoadedRunnable, CancellationSignal loadIconSignal) {
	final LayoutParams lp = (LayoutParams) getLayoutParams();
	Drawable drawable = null;
	boolean supportsAdaptiveIcons = ADAPTIVE_ICON_WINDOW_ANIM.get()
	&& Build.VERSION.SDK_INT >= Build.VERSION_CODES.O;
	Drawable btvIcon = v instanceof BubbleTextView ? ((BubbleTextView) v).getIcon() : null;
	if (info instanceof SystemShortcut) {
	if (v instanceof ImageView) {
	drawable = ((ImageView) v).getDrawable();
	} else if (v instanceof DeepShortcutView) {
	drawable = ((DeepShortcutView) v).getIconView().getBackground();
	} else {
	drawable = v.getBackground();
	}
	} else {
	if (supportsAdaptiveIcons) {
	drawable = Utilities.getFullDrawable(launcher, info, lp.width, lp.height,
	false, sTmpObjArray);
	if (!(drawable instanceof AdaptiveIconDrawable)) {
	// The drawable we get back is not an adaptive icon, so we need to use the
	// BubbleTextView icon that is already legacy treated.
	drawable = btvIcon;
	}
	} else {
	if (v instanceof BubbleTextView) {
	// Similar to DragView, we simply use the BubbleTextView icon here.
	drawable = btvIcon;
	} else {
	drawable = Utilities.getFullDrawable(launcher, info, lp.width, lp.height,
	false, sTmpObjArray);
	}
	}
	}

	Drawable finalDrawable = drawable == null ? null
	: drawable.getConstantState().newDrawable();
	boolean isAdaptiveIcon = supportsAdaptiveIcons
	&& finalDrawable instanceof AdaptiveIconDrawable;
	int iconOffset = getOffsetForIconBounds(finalDrawable);

	new Handler(Looper.getMainLooper()).post(() -> {
	if (isAdaptiveIcon) {
	mIsAdaptiveIcon = true;
	boolean isFolderIcon = finalDrawable instanceof FolderAdaptiveIcon;

	AdaptiveIconDrawable adaptiveIcon = (AdaptiveIconDrawable) finalDrawable;
	Drawable background = adaptiveIcon.getBackground();
	if (background == null) {
	background = new ColorDrawable(Color.TRANSPARENT);
	}
	mBackground = background;
	Drawable foreground = adaptiveIcon.getForeground();
	if (foreground == null) {
	foreground = new ColorDrawable(Color.TRANSPARENT);
	}
	mForeground = foreground;

	if (mForeground instanceof ShiftedBitmapDrawable && v instanceof FolderIcon) {
	ShiftedBitmapDrawable sbd = (ShiftedBitmapDrawable) mForeground;
	((FolderIcon) v).getPreviewBounds(sTmpRect);
	sbd.setShiftX(sbd.getShiftX() - sTmpRect.left);
	sbd.setShiftY(sbd.getShiftY() - sTmpRect.top);
	}

	final int originalHeight = lp.height;
	final int originalWidth = lp.width;

	int blurMargin = mBlurSizeOutline / 2;
	mFinalDrawableBounds.set(0, 0, originalWidth, originalHeight);
	if (!isFolderIcon) {
	mFinalDrawableBounds.inset(iconOffset - blurMargin, iconOffset - blurMargin);
	}
	mForeground.setBounds(mFinalDrawableBounds);
	mBackground.setBounds(mFinalDrawableBounds);

	mStartRevealRect.set(0, 0, originalWidth, originalHeight);

	if (!isFolderIcon) {
	mStartRevealRect.inset(mBlurSizeOutline, mBlurSizeOutline);
	}

	float aspectRatio = launcher.getDeviceProfile().aspectRatio;
	if (mIsVerticalBarLayout) {
	lp.width = (int) Math.max(lp.width, lp.height * aspectRatio);
	} else {
	lp.height = (int) Math.max(lp.height, lp.width * aspectRatio);
	}
	layout(lp.leftMargin, lp.topMargin, lp.leftMargin + lp.width, lp.topMargin
	+ lp.height);

	Rect rectOutline = new Rect();
	float scale = Math.max((float) lp.height / originalHeight,
	(float) lp.width / originalWidth);
	if (isOpening) {
	mBgDrawableStartScale = 1f;
	mBgDrawableEndScale = scale;
	rectOutline.set(0, 0, originalWidth, originalHeight);
	} else {
	mBgDrawableStartScale = scale;
	mBgDrawableEndScale = 1f;
	rectOutline.set(0, 0, lp.width, lp.height);
	}
	mEndRevealRect.set(0, 0, lp.width, lp.height);
	setBackgroundDrawableBounds(mBgDrawableStartScale);
	setOutlineProvider(new ViewOutlineProvider() {
	@Override
	public void getOutline(View view, Outline outline) {
	outline.setRoundRect(rectOutline, mTaskCornerRadius);
	}
	});
	setClipToOutline(true);
	} else {
	setBackground(finalDrawable);
	}

	if (!loadIconSignal.isCanceled()) {
	onIconLoadedRunnable.run();
	}
	invalidate();
	invalidateOutline();
	});
	}

	private void setBackgroundDrawableBounds(float scale) {
	mBgDrawableBounds.set(mFinalDrawableBounds);
	Utilities.scaleRectAboutCenter(mBgDrawableBounds, scale);
	// Since the drawable is at the top of the view, we need to offset to keep it centered.
	if (mIsVerticalBarLayout) {
	mBgDrawableBounds.offsetTo((int) (mFinalDrawableBounds.left * scale),
	mBgDrawableBounds.top);
	} else {
	mBgDrawableBounds.offsetTo(mBgDrawableBounds.left,
	(int) (mFinalDrawableBounds.top * scale));
	}
	mBackground.setBounds(mBgDrawableBounds);
	}

	@WorkerThread
	private int getOffsetForIconBounds(Drawable drawable) {
	if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O \|\|
	!(drawable instanceof AdaptiveIconDrawable)) {
	return 0;
	}

	final LayoutParams lp = (LayoutParams) getLayoutParams();
	Rect bounds = new Rect(0, 0, lp.width + mBlurSizeOutline, lp.height + mBlurSizeOutline);
	bounds.inset(mBlurSizeOutline / 2, mBlurSizeOutline / 2);

	try (LauncherIcons li = LauncherIcons.obtain(Launcher.fromContext(getContext()))) {
	Utilities.scaleRectAboutCenter(bounds, li.getNormalizer().getScale(drawable, null));
	}

	bounds.inset(
	(int) (-bounds.width() * AdaptiveIconDrawable.getExtraInsetFraction()),
	(int) (-bounds.height() * AdaptiveIconDrawable.getExtraInsetFraction())
	);

	return bounds.left;
	}

	@Override
	public void setClipPath(Path clipPath) {
	mClipPath = clipPath;
	invalidate();
	}

	@Override
	public void draw(Canvas canvas) {
	int count = canvas.save();
	canvas.rotate(mRotation,
	mFinalDrawableBounds.exactCenterX(), mFinalDrawableBounds.exactCenterY());
	if (mClipPath != null) {
	canvas.clipPath(mClipPath);
	}
	super.draw(canvas);
	if (mBackground != null) {
	mBackground.draw(canvas);
	}
	if (mForeground != null) {
	mForeground.draw(canvas);
	}
	canvas.restoreToCount(count);
	}

	public void onListenerViewClosed() {
	// Fast finish here.
	if (mEndRunnable != null) {
	mEndRunnable.run();
	mEndRunnable = null;
	}
	if (mFadeAnimatorSet != null) {
	mFadeAnimatorSet.end();
	mFadeAnimatorSet = null;
	}
	}

	@Override
	public void onAnimationStart(Animator animator) {}

	@Override
	public void onAnimationCancel(Animator animator) {}

	@Override
	public void onAnimationRepeat(Animator animator) {}

	/**
	* Creates a floating icon view for {@param originalView}.
	* @param originalView The view to copy
	* @param hideOriginal If true, it will hide {@param originalView} while this view is visible.
	* Else, we will not draw anything in this view.
	* @param positionOut Rect that will hold the size and position of v.
	* @param isOpening True if this view replaces the icon for app open animation.
	*/
	public static FloatingIconView getFloatingIconView(Launcher launcher, View originalView,
	boolean hideOriginal, RectF positionOut, boolean isOpening, FloatingIconView recycle) {
	if (recycle != null) {
	recycle.recycle();
	}
	FloatingIconView view = recycle != null ? recycle : new FloatingIconView(launcher);
	view.mIsVerticalBarLayout = launcher.getDeviceProfile().isVerticalBarLayout();

	// Match the position of the original view.
	view.matchPositionOf(launcher, originalView, positionOut);

	// Get the drawable on the background thread
	// Must be called after matchPositionOf so that we know what size to load.
	if (originalView.getTag() instanceof ItemInfo && hideOriginal) {
	view.mLoadIconSignal = new CancellationSignal();
	Runnable onIconLoaded = () -> {
	// Delay swapping views until the icon is loaded to prevent a flash.
	view.setVisibility(VISIBLE);
	originalView.setVisibility(INVISIBLE);
	};
	CancellationSignal loadIconSignal = view.mLoadIconSignal;
	new Handler(LauncherModel.getWorkerLooper()).postAtFrontOfQueue(() -> {
	view.getIcon(launcher, originalView, (ItemInfo) originalView.getTag(), isOpening,
	onIconLoaded, loadIconSignal);
	});
	}

	// We need to add it to the overlay, but keep it invisible until animation starts..
	final DragLayer dragLayer = launcher.getDragLayer();
	view.setVisibility(INVISIBLE);
	((ViewGroup) dragLayer.getParent()).addView(view);
	dragLayer.addView(view.mListenerView);
	view.mListenerView.setListener(view::onListenerViewClosed);

	view.mEndRunnable = () -> {
	view.mEndRunnable = null;

	if (hideOriginal) {
	if (isOpening) {
	originalView.setVisibility(VISIBLE);
	view.finish(dragLayer);
	} else {
	view.mFadeAnimatorSet = view.createFadeAnimation(originalView, dragLayer);
	view.mFadeAnimatorSet.start();
	}
	} else {
	view.finish(dragLayer);
	}
	};
	return view;
	}

	private AnimatorSet createFadeAnimation(View originalView, DragLayer dragLayer) {
	AnimatorSet fade = new AnimatorSet();
	fade.setDuration(FADE_DURATION_MS);
	fade.addListener(new AnimatorListenerAdapter() {
	@Override
	public void onAnimationStart(Animator animation) {
	originalView.setVisibility(VISIBLE);
	}

	@Override
	public void onAnimationEnd(Animator animation) {
	finish(dragLayer);
	}
	});

	if (originalView instanceof FolderIcon) {
	FolderIcon folderIcon = (FolderIcon) originalView;
	folderIcon.setBackgroundVisible(false);
	folderIcon.getFolderName().setTextVisibility(false);
	fade.play(folderIcon.getFolderName().createTextAlphaAnimator(true));
	fade.addListener(new AnimatorListenerAdapter() {
	@Override
	public void onAnimationEnd(Animator animation) {
	folderIcon.setBackgroundVisible(true);
	folderIcon.animateBgShadowAndStroke();
	if (folderIcon.hasDot()) {
	folderIcon.animateDotScale(0, 1f);
	}
	}
	});
	} else {
	fade.play(ObjectAnimator.ofFloat(originalView, ALPHA, 0f, 1f));
	}

	return fade;
	}

	private void finish(DragLayer dragLayer) {
	((ViewGroup) dragLayer.getParent()).removeView(this);
	dragLayer.removeView(mListenerView);
	recycle();
	}

	private void recycle() {
	setTranslationX(0);
	setTranslationY(0);
	setScaleX(1);
	setScaleY(1);
	setAlpha(1);
	setBackground(null);
	if (mLoadIconSignal != null) {
	mLoadIconSignal.cancel();
	}
	mLoadIconSignal = null;
	mEndRunnable = null;
	mIsAdaptiveIcon = false;
	mForeground = null;
	mBackground = null;
	mClipPath = null;
	mFinalDrawableBounds.setEmpty();
	mBgDrawableBounds.setEmpty();
	if (mRevealAnimator != null) {
	mRevealAnimator.cancel();
	}
	mRevealAnimator = null;
	if (mFadeAnimatorSet != null) {
	mFadeAnimatorSet.cancel();
	}
	mFadeAnimatorSet = null;
	mListenerView.setListener(null);
	}
	}