src/com/android/launcher3/DeleteDropTarget.java - fp2-dev/platform/packages/apps/Launcher3 - Gitiles

 /*
  * Copyright (C) 2011 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;

 import android.animation.TimeInterpolator;
 import android.animation.ValueAnimator;
 import android.animation.ValueAnimator.AnimatorUpdateListener;
 import android.content.Context;
 import android.graphics.PointF;
 import android.graphics.Rect;
 import android.os.AsyncTask;
 import android.util.AttributeSet;
 import android.view.View;
 import android.view.ViewConfiguration;
 import android.view.animation.AnimationUtils;
 import android.view.animation.DecelerateInterpolator;

 import com.android.launcher3.R;
 import com.android.launcher3.util.Thunk;
 import com.android.launcher3.widget.WidgetsContainerView;

 public class DeleteDropTarget extends ButtonDropTarget {

     private static int FLING_DELETE_ANIMATION_DURATION = 350;
     private static float FLING_TO_DELETE_FRICTION = 0.035f;
     private static int MODE_FLING_DELETE_TO_TRASH = 0;
     private static int MODE_FLING_DELETE_ALONG_VECTOR = 1;

     private final int mFlingDeleteMode = MODE_FLING_DELETE_ALONG_VECTOR;

     public DeleteDropTarget(Context context, AttributeSet attrs) {
         this(context, attrs, 0);
     }

     public DeleteDropTarget(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
     }

     @Override
     protected void onFinishInflate() {
         super.onFinishInflate();
         // Get the hover color
         mHoverColor = getResources().getColor(R.color.delete_target_hover_tint);

         setDrawable(R.drawable.remove_target_selector);
     }

     public static boolean willAcceptDrop(DragSource source, Object info) {
         return (info instanceof ItemInfo) && source.supportsDeleteDropTarget();
     }

     @Override
     protected boolean supportsDrop(DragSource source, Object info) {
         return willAcceptDrop(source, info);
     }

     @Override
     @Thunk void completeDrop(DragObject d) {
         ItemInfo item = (ItemInfo) d.dragInfo;
         if ((d.dragSource instanceof Workspace) || (d.dragSource instanceof Folder)) {
             removeWorkspaceOrFolderItem(mLauncher, item, null);
         }
     }

     /**
      * Removes the item from the workspace. If the view is not null, it also removes the view.
      * @return true if the item was removed.
      */
     public static boolean removeWorkspaceOrFolderItem(Launcher launcher, ItemInfo item, View view) {
         if (item instanceof ShortcutInfo) {
             LauncherModel.deleteItemFromDatabase(launcher, item);
         } else if (item instanceof FolderInfo) {
             FolderInfo folder = (FolderInfo) item;
             launcher.removeFolder(folder);
             LauncherModel.deleteFolderContentsFromDatabase(launcher, folder);
         } else if (item instanceof LauncherAppWidgetInfo) {
             final LauncherAppWidgetInfo widget = (LauncherAppWidgetInfo) item;

             // Remove the widget from the workspace
             launcher.removeAppWidget(widget);
             LauncherModel.deleteItemFromDatabase(launcher, widget);

             final LauncherAppWidgetHost appWidgetHost = launcher.getAppWidgetHost();

             if (appWidgetHost != null && !widget.isCustomWidget()
                     && widget.isWidgetIdValid()) {
                 // Deleting an app widget ID is a void call but writes to disk before returning
                 // to the caller...
                 new AsyncTask<Void, Void, Void>() {
                     public Void doInBackground(Void ... args) {
                         appWidgetHost.deleteAppWidgetId(widget.appWidgetId);
                         return null;
                     }
                 }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
             }
         } else {
             return false;
         }

         if (view != null) {
             launcher.getWorkspace().removeWorkspaceItem(view);
             launcher.getWorkspace().stripEmptyScreens();
         }
         return true;
     }

     /**
      * Creates an animation from the current drag view to the delete trash icon.
      */
     private AnimatorUpdateListener createFlingToTrashAnimatorListener(final DragLayer dragLayer,
             DragObject d, PointF vel, ViewConfiguration config) {

         int width = mDrawable.getIntrinsicWidth();
         int height = mDrawable.getIntrinsicHeight();
         final Rect to = getIconRect(d.dragView.getMeasuredWidth(), d.dragView.getMeasuredHeight(),
                 width, height);
         final Rect from = new Rect();
         dragLayer.getViewRectRelativeToSelf(d.dragView, from);

         // Calculate how far along the velocity vector we should put the intermediate point on
         // the bezier curve
         float velocity = Math.abs(vel.length());
         float vp = Math.min(1f, velocity / (config.getScaledMaximumFlingVelocity() / 2f));
         int offsetY = (int) (-from.top * vp);
         int offsetX = (int) (offsetY / (vel.y / vel.x));
         final float y2 = from.top + offsetY;                        // intermediate t/l
         final float x2 = from.left + offsetX;
         final float x1 = from.left;                                 // drag view t/l
         final float y1 = from.top;
         final float x3 = to.left;                                   // delete target t/l
         final float y3 = to.top;

         final TimeInterpolator scaleAlphaInterpolator = new TimeInterpolator() {
             @Override
             public float getInterpolation(float t) {
                 return t * t * t * t * t * t * t * t;
             }
         };
         return new AnimatorUpdateListener() {
             @Override
             public void onAnimationUpdate(ValueAnimator animation) {
                 final DragView dragView = (DragView) dragLayer.getAnimatedView();
                 float t = ((Float) animation.getAnimatedValue()).floatValue();
                 float tp = scaleAlphaInterpolator.getInterpolation(t);
                 float initialScale = dragView.getInitialScale();
                 float finalAlpha = 0.5f;
                 float scale = dragView.getScaleX();
                 float x1o = ((1f - scale) * dragView.getMeasuredWidth()) / 2f;
                 float y1o = ((1f - scale) * dragView.getMeasuredHeight()) / 2f;
                 float x = (1f - t) * (1f - t) * (x1 - x1o) + 2 * (1f - t) * t * (x2 - x1o) +
                         (t * t) * x3;
                 float y = (1f - t) * (1f - t) * (y1 - y1o) + 2 * (1f - t) * t * (y2 - x1o) +
                         (t * t) * y3;

                 dragView.setTranslationX(x);
                 dragView.setTranslationY(y);
                 dragView.setScaleX(initialScale * (1f - tp));
                 dragView.setScaleY(initialScale * (1f - tp));
                 dragView.setAlpha(finalAlpha + (1f - finalAlpha) * (1f - tp));
             }
         };
     }

     /**
      * Creates an animation from the current drag view along its current velocity vector.
      * For this animation, the alpha runs for a fixed duration and we update the position
      * progressively.
      */
     private static class FlingAlongVectorAnimatorUpdateListener implements AnimatorUpdateListener {
         private DragLayer mDragLayer;
         private PointF mVelocity;
         private Rect mFrom;
         private long mPrevTime;
         private boolean mHasOffsetForScale;
         private float mFriction;

         private final TimeInterpolator mAlphaInterpolator = new DecelerateInterpolator(0.75f);

         public FlingAlongVectorAnimatorUpdateListener(DragLayer dragLayer, PointF vel, Rect from,
                 long startTime, float friction) {
             mDragLayer = dragLayer;
             mVelocity = vel;
             mFrom = from;
             mPrevTime = startTime;
             mFriction = 1f - (dragLayer.getResources().getDisplayMetrics().density * friction);
         }

         @Override
         public void onAnimationUpdate(ValueAnimator animation) {
             final DragView dragView = (DragView) mDragLayer.getAnimatedView();
             float t = ((Float) animation.getAnimatedValue()).floatValue();
             long curTime = AnimationUtils.currentAnimationTimeMillis();

             if (!mHasOffsetForScale) {
                 mHasOffsetForScale = true;
                 float scale = dragView.getScaleX();
                 float xOffset = ((scale - 1f) * dragView.getMeasuredWidth()) / 2f;
                 float yOffset = ((scale - 1f) * dragView.getMeasuredHeight()) / 2f;

                 mFrom.left += xOffset;
                 mFrom.top += yOffset;
             }

             mFrom.left += (mVelocity.x * (curTime - mPrevTime) / 1000f);
             mFrom.top += (mVelocity.y * (curTime - mPrevTime) / 1000f);

             dragView.setTranslationX(mFrom.left);
             dragView.setTranslationY(mFrom.top);
             dragView.setAlpha(1f - mAlphaInterpolator.getInterpolation(t));

             mVelocity.x *= mFriction;
             mVelocity.y *= mFriction;
             mPrevTime = curTime;
         }
     };
     private AnimatorUpdateListener createFlingAlongVectorAnimatorListener(final DragLayer dragLayer,
             DragObject d, PointF vel, final long startTime, final int duration,
             ViewConfiguration config) {
         final Rect from = new Rect();
         dragLayer.getViewRectRelativeToSelf(d.dragView, from);

         return new FlingAlongVectorAnimatorUpdateListener(dragLayer, vel, from, startTime,
                 FLING_TO_DELETE_FRICTION);
     }

     public void onFlingToDelete(final DragObject d, int x, int y, PointF vel) {
         final boolean isWidgets = d.dragSource instanceof WidgetsContainerView;
         final boolean isAllapps = d.dragSource instanceof AppsContainerView;

         // Don't highlight the icon as it's animating
         d.dragView.setColor(0);
         d.dragView.updateInitialScaleToCurrentScale();
         // Don't highlight the target if we are flinging from AllApps
         if (isWidgets || isAllapps) {
             resetHoverColor();
         }

         if (mFlingDeleteMode == MODE_FLING_DELETE_TO_TRASH) {
             // Defer animating out the drop target if we are animating to it
             mSearchDropTargetBar.deferOnDragEnd();
             mSearchDropTargetBar.finishAnimations();
         }

         final ViewConfiguration config = ViewConfiguration.get(mLauncher);
         final DragLayer dragLayer = mLauncher.getDragLayer();
         final int duration = FLING_DELETE_ANIMATION_DURATION;
         final long startTime = AnimationUtils.currentAnimationTimeMillis();

         // NOTE: Because it takes time for the first frame of animation to actually be
         // called and we expect the animation to be a continuation of the fling, we have
         // to account for the time that has elapsed since the fling finished.  And since
         // we don't have a startDelay, we will always get call to update when we call
         // start() (which we want to ignore).
         final TimeInterpolator tInterpolator = new TimeInterpolator() {
             private int mCount = -1;
             private float mOffset = 0f;

             @Override
             public float getInterpolation(float t) {
                 if (mCount < 0) {
                     mCount++;
                 } else if (mCount == 0) {
                     mOffset = Math.min(0.5f, (float) (AnimationUtils.currentAnimationTimeMillis() -
                             startTime) / duration);
                     mCount++;
                 }
                 return Math.min(1f, mOffset + t);
             }
         };
         AnimatorUpdateListener updateCb = null;
         if (mFlingDeleteMode == MODE_FLING_DELETE_TO_TRASH) {
             updateCb = createFlingToTrashAnimatorListener(dragLayer, d, vel, config);
         } else if (mFlingDeleteMode == MODE_FLING_DELETE_ALONG_VECTOR) {
             updateCb = createFlingAlongVectorAnimatorListener(dragLayer, d, vel, startTime,
                     duration, config);
         }

         Runnable onAnimationEndRunnable = new Runnable() {
             @Override
             public void run() {
                 // If we are dragging from AllApps, then we allow AppsCustomizePagedView to clean up
                 // itself, otherwise, complete the drop to initiate the deletion process
                 if (!isWidgets || !isAllapps) {
                     mLauncher.exitSpringLoadedDragMode();
                     completeDrop(d);
                 }
                 mLauncher.getDragController().onDeferredEndFling(d);
             }
         };
         dragLayer.animateView(d.dragView, updateCb, duration, tInterpolator, onAnimationEndRunnable,
                 DragLayer.ANIMATION_END_DISAPPEAR, null);
     }
 }
	/*
	* Copyright (C) 2011 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;

	import android.animation.TimeInterpolator;
	import android.animation.ValueAnimator;
	import android.animation.ValueAnimator.AnimatorUpdateListener;
	import android.content.Context;
	import android.graphics.PointF;
	import android.graphics.Rect;
	import android.os.AsyncTask;
	import android.util.AttributeSet;
	import android.view.View;
	import android.view.ViewConfiguration;
	import android.view.animation.AnimationUtils;
	import android.view.animation.DecelerateInterpolator;

	import com.android.launcher3.R;
	import com.android.launcher3.util.Thunk;
	import com.android.launcher3.widget.WidgetsContainerView;

	public class DeleteDropTarget extends ButtonDropTarget {

	private static int FLING_DELETE_ANIMATION_DURATION = 350;
	private static float FLING_TO_DELETE_FRICTION = 0.035f;
	private static int MODE_FLING_DELETE_TO_TRASH = 0;
	private static int MODE_FLING_DELETE_ALONG_VECTOR = 1;

	private final int mFlingDeleteMode = MODE_FLING_DELETE_ALONG_VECTOR;

	public DeleteDropTarget(Context context, AttributeSet attrs) {
	this(context, attrs, 0);
	}

	public DeleteDropTarget(Context context, AttributeSet attrs, int defStyle) {
	super(context, attrs, defStyle);
	}

	@Override
	protected void onFinishInflate() {
	super.onFinishInflate();
	// Get the hover color
	mHoverColor = getResources().getColor(R.color.delete_target_hover_tint);

	setDrawable(R.drawable.remove_target_selector);
	}

	public static boolean willAcceptDrop(DragSource source, Object info) {
	return (info instanceof ItemInfo) && source.supportsDeleteDropTarget();
	}

	@Override
	protected boolean supportsDrop(DragSource source, Object info) {
	return willAcceptDrop(source, info);
	}

	@Override
	@Thunk void completeDrop(DragObject d) {
	ItemInfo item = (ItemInfo) d.dragInfo;
	if ((d.dragSource instanceof Workspace) \|\| (d.dragSource instanceof Folder)) {
	removeWorkspaceOrFolderItem(mLauncher, item, null);
	}
	}

	/**
	* Removes the item from the workspace. If the view is not null, it also removes the view.
	* @return true if the item was removed.
	*/
	public static boolean removeWorkspaceOrFolderItem(Launcher launcher, ItemInfo item, View view) {
	if (item instanceof ShortcutInfo) {
	LauncherModel.deleteItemFromDatabase(launcher, item);
	} else if (item instanceof FolderInfo) {
	FolderInfo folder = (FolderInfo) item;
	launcher.removeFolder(folder);
	LauncherModel.deleteFolderContentsFromDatabase(launcher, folder);
	} else if (item instanceof LauncherAppWidgetInfo) {
	final LauncherAppWidgetInfo widget = (LauncherAppWidgetInfo) item;

	// Remove the widget from the workspace
	launcher.removeAppWidget(widget);
	LauncherModel.deleteItemFromDatabase(launcher, widget);

	final LauncherAppWidgetHost appWidgetHost = launcher.getAppWidgetHost();

	if (appWidgetHost != null && !widget.isCustomWidget()
	&& widget.isWidgetIdValid()) {
	// Deleting an app widget ID is a void call but writes to disk before returning
	// to the caller...
	new AsyncTask<Void, Void, Void>() {
	public Void doInBackground(Void ... args) {
	appWidgetHost.deleteAppWidgetId(widget.appWidgetId);
	return null;
	}
	}.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
	}
	} else {
	return false;
	}

	if (view != null) {
	launcher.getWorkspace().removeWorkspaceItem(view);
	launcher.getWorkspace().stripEmptyScreens();
	}
	return true;
	}

	/**
	* Creates an animation from the current drag view to the delete trash icon.
	*/
	private AnimatorUpdateListener createFlingToTrashAnimatorListener(final DragLayer dragLayer,
	DragObject d, PointF vel, ViewConfiguration config) {

	int width = mDrawable.getIntrinsicWidth();
	int height = mDrawable.getIntrinsicHeight();
	final Rect to = getIconRect(d.dragView.getMeasuredWidth(), d.dragView.getMeasuredHeight(),
	width, height);
	final Rect from = new Rect();
	dragLayer.getViewRectRelativeToSelf(d.dragView, from);

	// Calculate how far along the velocity vector we should put the intermediate point on
	// the bezier curve
	float velocity = Math.abs(vel.length());
	float vp = Math.min(1f, velocity / (config.getScaledMaximumFlingVelocity() / 2f));
	int offsetY = (int) (-from.top * vp);
	int offsetX = (int) (offsetY / (vel.y / vel.x));
	final float y2 = from.top + offsetY; // intermediate t/l
	final float x2 = from.left + offsetX;
	final float x1 = from.left; // drag view t/l
	final float y1 = from.top;
	final float x3 = to.left; // delete target t/l
	final float y3 = to.top;

	final TimeInterpolator scaleAlphaInterpolator = new TimeInterpolator() {
	@Override
	public float getInterpolation(float t) {
	return t * t * t * t * t * t * t * t;
	}
	};
	return new AnimatorUpdateListener() {
	@Override
	public void onAnimationUpdate(ValueAnimator animation) {
	final DragView dragView = (DragView) dragLayer.getAnimatedView();
	float t = ((Float) animation.getAnimatedValue()).floatValue();
	float tp = scaleAlphaInterpolator.getInterpolation(t);
	float initialScale = dragView.getInitialScale();
	float finalAlpha = 0.5f;
	float scale = dragView.getScaleX();
	float x1o = ((1f - scale) * dragView.getMeasuredWidth()) / 2f;
	float y1o = ((1f - scale) * dragView.getMeasuredHeight()) / 2f;
	float x = (1f - t) * (1f - t) * (x1 - x1o) + 2 * (1f - t) * t * (x2 - x1o) +
	(t * t) * x3;
	float y = (1f - t) * (1f - t) * (y1 - y1o) + 2 * (1f - t) * t * (y2 - x1o) +
	(t * t) * y3;

	dragView.setTranslationX(x);
	dragView.setTranslationY(y);
	dragView.setScaleX(initialScale * (1f - tp));
	dragView.setScaleY(initialScale * (1f - tp));
	dragView.setAlpha(finalAlpha + (1f - finalAlpha) * (1f - tp));
	}
	};
	}

	/**
	* Creates an animation from the current drag view along its current velocity vector.
	* For this animation, the alpha runs for a fixed duration and we update the position
	* progressively.
	*/
	private static class FlingAlongVectorAnimatorUpdateListener implements AnimatorUpdateListener {
	private DragLayer mDragLayer;
	private PointF mVelocity;
	private Rect mFrom;
	private long mPrevTime;
	private boolean mHasOffsetForScale;
	private float mFriction;

	private final TimeInterpolator mAlphaInterpolator = new DecelerateInterpolator(0.75f);

	public FlingAlongVectorAnimatorUpdateListener(DragLayer dragLayer, PointF vel, Rect from,
	long startTime, float friction) {
	mDragLayer = dragLayer;
	mVelocity = vel;
	mFrom = from;
	mPrevTime = startTime;
	mFriction = 1f - (dragLayer.getResources().getDisplayMetrics().density * friction);
	}

	@Override
	public void onAnimationUpdate(ValueAnimator animation) {
	final DragView dragView = (DragView) mDragLayer.getAnimatedView();
	float t = ((Float) animation.getAnimatedValue()).floatValue();
	long curTime = AnimationUtils.currentAnimationTimeMillis();

	if (!mHasOffsetForScale) {
	mHasOffsetForScale = true;
	float scale = dragView.getScaleX();
	float xOffset = ((scale - 1f) * dragView.getMeasuredWidth()) / 2f;
	float yOffset = ((scale - 1f) * dragView.getMeasuredHeight()) / 2f;

	mFrom.left += xOffset;
	mFrom.top += yOffset;
	}

	mFrom.left += (mVelocity.x * (curTime - mPrevTime) / 1000f);
	mFrom.top += (mVelocity.y * (curTime - mPrevTime) / 1000f);

	dragView.setTranslationX(mFrom.left);
	dragView.setTranslationY(mFrom.top);
	dragView.setAlpha(1f - mAlphaInterpolator.getInterpolation(t));

	mVelocity.x *= mFriction;
	mVelocity.y *= mFriction;
	mPrevTime = curTime;
	}
	};
	private AnimatorUpdateListener createFlingAlongVectorAnimatorListener(final DragLayer dragLayer,
	DragObject d, PointF vel, final long startTime, final int duration,
	ViewConfiguration config) {
	final Rect from = new Rect();
	dragLayer.getViewRectRelativeToSelf(d.dragView, from);

	return new FlingAlongVectorAnimatorUpdateListener(dragLayer, vel, from, startTime,
	FLING_TO_DELETE_FRICTION);
	}

	public void onFlingToDelete(final DragObject d, int x, int y, PointF vel) {
	final boolean isWidgets = d.dragSource instanceof WidgetsContainerView;
	final boolean isAllapps = d.dragSource instanceof AppsContainerView;

	// Don't highlight the icon as it's animating
	d.dragView.setColor(0);
	d.dragView.updateInitialScaleToCurrentScale();
	// Don't highlight the target if we are flinging from AllApps
	if (isWidgets \|\| isAllapps) {
	resetHoverColor();
	}

	if (mFlingDeleteMode == MODE_FLING_DELETE_TO_TRASH) {
	// Defer animating out the drop target if we are animating to it
	mSearchDropTargetBar.deferOnDragEnd();
	mSearchDropTargetBar.finishAnimations();
	}

	final ViewConfiguration config = ViewConfiguration.get(mLauncher);
	final DragLayer dragLayer = mLauncher.getDragLayer();
	final int duration = FLING_DELETE_ANIMATION_DURATION;
	final long startTime = AnimationUtils.currentAnimationTimeMillis();

	// NOTE: Because it takes time for the first frame of animation to actually be
	// called and we expect the animation to be a continuation of the fling, we have
	// to account for the time that has elapsed since the fling finished. And since
	// we don't have a startDelay, we will always get call to update when we call
	// start() (which we want to ignore).
	final TimeInterpolator tInterpolator = new TimeInterpolator() {
	private int mCount = -1;
	private float mOffset = 0f;

	@Override
	public float getInterpolation(float t) {
	if (mCount < 0) {
	mCount++;
	} else if (mCount == 0) {
	mOffset = Math.min(0.5f, (float) (AnimationUtils.currentAnimationTimeMillis() -
	startTime) / duration);
	mCount++;
	}
	return Math.min(1f, mOffset + t);
	}
	};
	AnimatorUpdateListener updateCb = null;
	if (mFlingDeleteMode == MODE_FLING_DELETE_TO_TRASH) {
	updateCb = createFlingToTrashAnimatorListener(dragLayer, d, vel, config);
	} else if (mFlingDeleteMode == MODE_FLING_DELETE_ALONG_VECTOR) {
	updateCb = createFlingAlongVectorAnimatorListener(dragLayer, d, vel, startTime,
	duration, config);
	}

	Runnable onAnimationEndRunnable = new Runnable() {
	@Override
	public void run() {
	// If we are dragging from AllApps, then we allow AppsCustomizePagedView to clean up
	// itself, otherwise, complete the drop to initiate the deletion process
	if (!isWidgets \|\| !isAllapps) {
	mLauncher.exitSpringLoadedDragMode();
	completeDrop(d);
	}
	mLauncher.getDragController().onDeferredEndFling(d);
	}
	};
	dragLayer.animateView(d.dragView, updateCb, duration, tInterpolator, onAnimationEndRunnable,
	DragLayer.ANIMATION_END_DISAPPEAR, null);
	}
	}