mirror of
https://github.com/LawnchairLauncher/lawnchair.git
synced 2026-02-19 18:58:19 +00:00
520 lines
22 KiB
Java
520 lines
22 KiB
Java
/*
|
|
* 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.ComponentName;
|
|
import android.content.Context;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.pm.PackageManager.NameNotFoundException;
|
|
import android.content.pm.ResolveInfo;
|
|
import android.content.res.ColorStateList;
|
|
import android.content.res.Configuration;
|
|
import android.content.res.Resources;
|
|
import android.graphics.PointF;
|
|
import android.graphics.Rect;
|
|
import android.graphics.drawable.TransitionDrawable;
|
|
import android.util.AttributeSet;
|
|
import android.util.Log;
|
|
import android.view.View;
|
|
import android.view.ViewConfiguration;
|
|
import android.view.ViewGroup;
|
|
import android.view.animation.AnimationUtils;
|
|
import android.view.animation.DecelerateInterpolator;
|
|
import android.view.animation.LinearInterpolator;
|
|
|
|
import java.util.List;
|
|
|
|
public class DeleteDropTarget extends ButtonDropTarget {
|
|
private static int DELETE_ANIMATION_DURATION = 285;
|
|
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;
|
|
|
|
private ColorStateList mOriginalTextColor;
|
|
private TransitionDrawable mUninstallDrawable;
|
|
private TransitionDrawable mRemoveDrawable;
|
|
private TransitionDrawable mCurrentDrawable;
|
|
|
|
private boolean mWaitingForUninstall = false;
|
|
|
|
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 drawable
|
|
mOriginalTextColor = getTextColors();
|
|
|
|
// Get the hover color
|
|
Resources r = getResources();
|
|
mHoverColor = r.getColor(R.color.delete_target_hover_tint);
|
|
mUninstallDrawable = (TransitionDrawable)
|
|
r.getDrawable(R.drawable.uninstall_target_selector);
|
|
mRemoveDrawable = (TransitionDrawable) r.getDrawable(R.drawable.remove_target_selector);
|
|
|
|
mRemoveDrawable.setCrossFadeEnabled(true);
|
|
mUninstallDrawable.setCrossFadeEnabled(true);
|
|
|
|
// The current drawable is set to either the remove drawable or the uninstall drawable
|
|
// and is initially set to the remove drawable, as set in the layout xml.
|
|
mCurrentDrawable = (TransitionDrawable) getCurrentDrawable();
|
|
|
|
// Remove the text in the Phone UI in landscape
|
|
int orientation = getResources().getConfiguration().orientation;
|
|
if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
|
|
if (!LauncherAppState.getInstance().isScreenLarge()) {
|
|
setText("");
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean isAllAppsApplication(DragSource source, Object info) {
|
|
return (source instanceof AppsCustomizePagedView) && (info instanceof ApplicationInfo);
|
|
}
|
|
private boolean isAllAppsWidget(DragSource source, Object info) {
|
|
if (source instanceof AppsCustomizePagedView) {
|
|
if (info instanceof PendingAddItemInfo) {
|
|
PendingAddItemInfo addInfo = (PendingAddItemInfo) info;
|
|
switch (addInfo.itemType) {
|
|
case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
|
|
case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
private boolean isDragSourceWorkspaceOrFolder(DragObject d) {
|
|
return (d.dragSource instanceof Workspace) || (d.dragSource instanceof Folder);
|
|
}
|
|
private boolean isWorkspaceOrFolderApplication(DragObject d) {
|
|
return isDragSourceWorkspaceOrFolder(d) && (d.dragInfo instanceof ShortcutInfo);
|
|
}
|
|
private boolean isWorkspaceOrFolderWidget(DragObject d) {
|
|
return isDragSourceWorkspaceOrFolder(d) && (d.dragInfo instanceof LauncherAppWidgetInfo);
|
|
}
|
|
private boolean isWorkspaceFolder(DragObject d) {
|
|
return (d.dragSource instanceof Workspace) && (d.dragInfo instanceof FolderInfo);
|
|
}
|
|
|
|
private void setHoverColor() {
|
|
mCurrentDrawable.startTransition(mTransitionDuration);
|
|
setTextColor(mHoverColor);
|
|
}
|
|
private void resetHoverColor() {
|
|
mCurrentDrawable.resetTransition();
|
|
setTextColor(mOriginalTextColor);
|
|
}
|
|
|
|
@Override
|
|
public boolean acceptDrop(DragObject d) {
|
|
return willAcceptDrop(d.dragInfo);
|
|
}
|
|
|
|
public static boolean willAcceptDrop(Object info) {
|
|
if (info instanceof ItemInfo) {
|
|
ItemInfo item = (ItemInfo) info;
|
|
if (item.itemType == LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET ||
|
|
item.itemType == LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT) {
|
|
return true;
|
|
}
|
|
if (AppsCustomizePagedView.DISABLE_ALL_APPS &&
|
|
item.itemType == LauncherSettings.Favorites.ITEM_TYPE_APPLICATION &&
|
|
item instanceof ShortcutInfo) {
|
|
ShortcutInfo shortcutInfo = (ShortcutInfo) info;
|
|
return (shortcutInfo.flags & ApplicationInfo.DOWNLOADED_FLAG) != 0;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void onDragStart(DragSource source, Object info, int dragAction) {
|
|
boolean isVisible = true;
|
|
boolean isUninstall = false;
|
|
|
|
// If we are dragging a widget from AppsCustomize, hide the delete target
|
|
if (isAllAppsWidget(source, info)) {
|
|
isVisible = false;
|
|
}
|
|
|
|
// If we are dragging an application from AppsCustomize, only show the control if we can
|
|
// delete the app (it was downloaded), and rename the string to "uninstall" in such a case
|
|
if (willAcceptDrop(info)) {
|
|
isVisible = true;
|
|
} else {
|
|
isVisible = false;
|
|
}
|
|
|
|
if (isUninstall) {
|
|
setCompoundDrawablesRelativeWithIntrinsicBounds(mUninstallDrawable, null, null, null);
|
|
} else {
|
|
setCompoundDrawablesRelativeWithIntrinsicBounds(mRemoveDrawable, null, null, null);
|
|
}
|
|
mCurrentDrawable = (TransitionDrawable) getCurrentDrawable();
|
|
|
|
mActive = isVisible;
|
|
resetHoverColor();
|
|
((ViewGroup) getParent()).setVisibility(isVisible ? View.VISIBLE : View.GONE);
|
|
if (getText().length() > 0) {
|
|
setText(isUninstall ? R.string.delete_target_uninstall_label
|
|
: R.string.delete_target_label);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onDragEnd() {
|
|
super.onDragEnd();
|
|
mActive = false;
|
|
}
|
|
|
|
public void onDragEnter(DragObject d) {
|
|
super.onDragEnter(d);
|
|
|
|
setHoverColor();
|
|
}
|
|
|
|
public void onDragExit(DragObject d) {
|
|
super.onDragExit(d);
|
|
|
|
if (!d.dragComplete) {
|
|
resetHoverColor();
|
|
} else {
|
|
// Restore the hover color if we are deleting
|
|
d.dragView.setColor(mHoverColor);
|
|
}
|
|
}
|
|
|
|
private void animateToTrashAndCompleteDrop(final DragObject d) {
|
|
final DragLayer dragLayer = mLauncher.getDragLayer();
|
|
final Rect from = new Rect();
|
|
dragLayer.getViewRectRelativeToSelf(d.dragView, from);
|
|
final Rect to = getIconRect(d.dragView.getMeasuredWidth(), d.dragView.getMeasuredHeight(),
|
|
mCurrentDrawable.getIntrinsicWidth(), mCurrentDrawable.getIntrinsicHeight());
|
|
final float scale = (float) to.width() / from.width();
|
|
|
|
mSearchDropTargetBar.deferOnDragEnd();
|
|
deferCompleteDropIfUninstalling(d);
|
|
|
|
Runnable onAnimationEndRunnable = new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
completeDrop(d);
|
|
mSearchDropTargetBar.onDragEnd();
|
|
mLauncher.exitSpringLoadedDragMode();
|
|
}
|
|
};
|
|
dragLayer.animateView(d.dragView, from, to, scale, 1f, 1f, 0.1f, 0.1f,
|
|
DELETE_ANIMATION_DURATION, new DecelerateInterpolator(2),
|
|
new LinearInterpolator(), onAnimationEndRunnable,
|
|
DragLayer.ANIMATION_END_DISAPPEAR, null);
|
|
}
|
|
|
|
private void deferCompleteDropIfUninstalling(DragObject d) {
|
|
mWaitingForUninstall = false;
|
|
if (isUninstall(d)) {
|
|
if (d.dragSource instanceof Folder) {
|
|
((Folder) d.dragSource).deferCompleteDropAfterUninstallActivity();
|
|
} else if (d.dragSource instanceof Workspace) {
|
|
((Workspace) d.dragSource).deferCompleteDropAfterUninstallActivity();
|
|
}
|
|
mWaitingForUninstall = true;
|
|
}
|
|
}
|
|
|
|
private boolean isUninstall(DragObject d) {
|
|
return AppsCustomizePagedView.DISABLE_ALL_APPS && isWorkspaceOrFolderApplication(d);
|
|
}
|
|
|
|
private void completeDrop(final DragObject d) {
|
|
ItemInfo item = (ItemInfo) d.dragInfo;
|
|
boolean wasWaitingForUninstall = mWaitingForUninstall;
|
|
mWaitingForUninstall = false;
|
|
if (isAllAppsApplication(d.dragSource, item)) {
|
|
// Uninstall the application if it is being dragged from AppsCustomize
|
|
ApplicationInfo appInfo = (ApplicationInfo) item;
|
|
mLauncher.startApplicationUninstallActivity(appInfo.componentName, appInfo.flags);
|
|
} else if (AppsCustomizePagedView.DISABLE_ALL_APPS && isWorkspaceOrFolderApplication(d)) {
|
|
ShortcutInfo shortcut = (ShortcutInfo) item;
|
|
if (shortcut.intent != null && shortcut.intent.getComponent() != null) {
|
|
ComponentName componentName = shortcut.intent.getComponent();
|
|
int flags = ApplicationInfo.initFlags(
|
|
ShortcutInfo.getPackageInfo(getContext(), componentName.getPackageName()));
|
|
mWaitingForUninstall =
|
|
mLauncher.startApplicationUninstallActivity(componentName, flags);
|
|
}
|
|
} else if (isWorkspaceOrFolderApplication(d)) {
|
|
LauncherModel.deleteItemFromDatabase(mLauncher, item);
|
|
} else if (isWorkspaceFolder(d)) {
|
|
// Remove the folder from the workspace and delete the contents from launcher model
|
|
FolderInfo folderInfo = (FolderInfo) item;
|
|
mLauncher.removeFolder(folderInfo);
|
|
LauncherModel.deleteFolderContentsFromDatabase(mLauncher, folderInfo);
|
|
} else if (isWorkspaceOrFolderWidget(d)) {
|
|
// Remove the widget from the workspace
|
|
mLauncher.removeAppWidget((LauncherAppWidgetInfo) item);
|
|
LauncherModel.deleteItemFromDatabase(mLauncher, item);
|
|
|
|
final LauncherAppWidgetInfo launcherAppWidgetInfo = (LauncherAppWidgetInfo) item;
|
|
final LauncherAppWidgetHost appWidgetHost = mLauncher.getAppWidgetHost();
|
|
if (appWidgetHost != null) {
|
|
// Deleting an app widget ID is a void call but writes to disk before returning
|
|
// to the caller...
|
|
new Thread("deleteAppWidgetId") {
|
|
public void run() {
|
|
appWidgetHost.deleteAppWidgetId(launcherAppWidgetInfo.appWidgetId);
|
|
}
|
|
}.start();
|
|
}
|
|
}
|
|
if (wasWaitingForUninstall && !mWaitingForUninstall) {
|
|
if (d.dragSource instanceof Folder) {
|
|
((Folder) d.dragSource).onUninstallActivityReturned(false);
|
|
} else if (d.dragSource instanceof Workspace) {
|
|
((Workspace) d.dragSource).onUninstallActivityReturned(false);
|
|
}
|
|
}
|
|
if (mWaitingForUninstall) {
|
|
final Runnable checkIfUninstallWasSuccess = new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mWaitingForUninstall = false;
|
|
ShortcutInfo shortcut = (ShortcutInfo) d.dragInfo;
|
|
if (shortcut.intent != null && shortcut.intent.getComponent() != null) {
|
|
String packageName = shortcut.intent.getComponent().getPackageName();
|
|
List<ResolveInfo> activities =
|
|
AllAppsList.findActivitiesForPackage(getContext(), packageName);
|
|
boolean uninstallSuccessful = activities.size() == 0;
|
|
mLauncher.removeOnResumeCallback(this);
|
|
if (d.dragSource instanceof Folder) {
|
|
((Folder) d.dragSource).
|
|
onUninstallActivityReturned(uninstallSuccessful);
|
|
} else if (d.dragSource instanceof Workspace) {
|
|
((Workspace) d.dragSource).
|
|
onUninstallActivityReturned(uninstallSuccessful);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
mLauncher.addOnResumeCallback(checkIfUninstallWasSuccess);
|
|
}
|
|
}
|
|
|
|
public void onDrop(DragObject d) {
|
|
animateToTrashAndCompleteDrop(d);
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
final Rect to = getIconRect(d.dragView.getMeasuredWidth(), d.dragView.getMeasuredHeight(),
|
|
mCurrentDrawable.getIntrinsicWidth(), mCurrentDrawable.getIntrinsicHeight());
|
|
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 isAllApps = d.dragSource instanceof AppsCustomizePagedView;
|
|
|
|
// 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 (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);
|
|
}
|
|
deferCompleteDropIfUninstalling(d);
|
|
|
|
Runnable onAnimationEndRunnable = new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mSearchDropTargetBar.onDragEnd();
|
|
|
|
// If we are dragging from AllApps, then we allow AppsCustomizePagedView to clean up
|
|
// itself, otherwise, complete the drop to initiate the deletion process
|
|
if (!isAllApps) {
|
|
mLauncher.exitSpringLoadedDragMode();
|
|
completeDrop(d);
|
|
}
|
|
mLauncher.getDragController().onDeferredEndFling(d);
|
|
}
|
|
};
|
|
dragLayer.animateView(d.dragView, updateCb, duration, tInterpolator, onAnimationEndRunnable,
|
|
DragLayer.ANIMATION_END_DISAPPEAR, null);
|
|
}
|
|
}
|