/* * 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.Intent; 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.os.AsyncTask; import android.util.AttributeSet; 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; import java.util.Set; 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.supportsAppInfoDropTarget() && (info instanceof AppInfo); } 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: case LauncherSettings.Favorites.ITEM_TYPE_ALLAPPS: 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 (item.itemType == LauncherSettings.Favorites.ITEM_TYPE_ALLAPPS && LauncherModel.hasMultipleAllAppsShortcuts()) { return true; } if (!LauncherAppState.isDisableAllApps() && item.itemType == LauncherSettings.Favorites.ITEM_TYPE_FOLDER) { return true; } if (!LauncherAppState.isDisableAllApps() && item.itemType == LauncherSettings.Favorites.ITEM_TYPE_APPLICATION && item instanceof AppInfo) { AppInfo appInfo = (AppInfo) info; return (appInfo.flags & AppInfo.DOWNLOADED_FLAG) != 0; } if (item.itemType == LauncherSettings.Favorites.ITEM_TYPE_APPLICATION && item instanceof ShortcutInfo) { if (LauncherAppState.isDisableAllApps()) { ShortcutInfo shortcutInfo = (ShortcutInfo) info; return (shortcutInfo.flags & AppInfo.DOWNLOADED_FLAG) != 0; } else { return true; } } } return false; } @Override public void onDragStart(DragSource source, Object info, int dragAction) { boolean isVisible = true; boolean useUninstallLabel = !LauncherAppState.isDisableAllApps() && isAllAppsApplication(source, info); boolean useDeleteLabel = !useUninstallLabel && source.supportsDeleteDropTarget(); // 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. // Hide the delete target if it is a widget from AppsCustomize. if (!willAcceptDrop(info) || isAllAppsWidget(source, info)) { isVisible = false; } if (useUninstallLabel) { setCompoundDrawablesRelativeWithIntrinsicBounds(mUninstallDrawable, null, null, null); } else if (useDeleteLabel) { setCompoundDrawablesRelativeWithIntrinsicBounds(mRemoveDrawable, null, null, null); } else { isVisible = false; } mCurrentDrawable = (TransitionDrawable) getCurrentDrawable(); mActive = isVisible; resetHoverColor(); ((ViewGroup) getParent()).setVisibility(isVisible ? View.VISIBLE : View.GONE); if (isVisible && getText().length() > 0) { setText(useUninstallLabel ? 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 (isUninstallFromWorkspace(d)) { if (d.dragSource instanceof Folder) { ((Folder) d.dragSource).deferCompleteDropAfterUninstallActivity(); } else if (d.dragSource instanceof Workspace) { ((Workspace) d.dragSource).deferCompleteDropAfterUninstallActivity(); } mWaitingForUninstall = true; } } private boolean isUninstallFromWorkspace(DragObject d) { if (LauncherAppState.isDisableAllApps() && isWorkspaceOrFolderApplication(d)) { ShortcutInfo shortcut = (ShortcutInfo) d.dragInfo; // Only allow manifest shortcuts to initiate an un-install. return !InstallShortcutReceiver.isValidShortcutLaunchIntent(shortcut.intent); } return false; } private void completeDrop(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 AppInfo appInfo = (AppInfo) item; mLauncher.startApplicationUninstallActivity(appInfo.componentName, appInfo.flags); } else if (isUninstallFromWorkspace(d)) { ShortcutInfo shortcut = (ShortcutInfo) item; if (shortcut.intent != null && shortcut.intent.getComponent() != null) { final ComponentName componentName = shortcut.intent.getComponent(); final DragSource dragSource = d.dragSource; int flags = AppInfo.initFlags( ShortcutInfo.getPackageInfo(getContext(), componentName.getPackageName())); mWaitingForUninstall = mLauncher.startApplicationUninstallActivity(componentName, flags); if (mWaitingForUninstall) { final Runnable checkIfUninstallWasSuccess = new Runnable() { @Override public void run() { mWaitingForUninstall = false; String packageName = componentName.getPackageName(); List activities = AllAppsList.findActivitiesForPackage(getContext(), packageName); boolean uninstallSuccessful = activities.size() == 0; if (dragSource instanceof Folder) { ((Folder) dragSource). onUninstallActivityReturned(uninstallSuccessful); } else if (dragSource instanceof Workspace) { ((Workspace) dragSource). onUninstallActivityReturned(uninstallSuccessful); } } }; mLauncher.addOnResumeCallback(checkIfUninstallWasSuccess); } } } 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 AsyncTask() { public Void doInBackground(Void ... args) { appWidgetHost.deleteAppWidgetId(launcherAppWidgetInfo.appWidgetId); return null; } }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void) null); } } if (wasWaitingForUninstall && !mWaitingForUninstall) { if (d.dragSource instanceof Folder) { ((Folder) d.dragSource).onUninstallActivityReturned(false); } else if (d.dragSource instanceof Workspace) { ((Workspace) d.dragSource).onUninstallActivityReturned(false); } } } 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() { // 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); } }