/* * Copyright (C) 2016 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.popup; import android.animation.Animator; import android.animation.AnimatorListenerAdapter; import android.animation.AnimatorSet; import android.animation.ObjectAnimator; import android.animation.TimeInterpolator; import android.animation.ValueAnimator; import android.annotation.TargetApi; import android.content.Context; import android.content.res.Resources; import android.graphics.CornerPathEffect; import android.graphics.Paint; import android.graphics.PointF; import android.graphics.Rect; import android.graphics.drawable.ShapeDrawable; import android.os.Build; import android.os.Handler; import android.os.Looper; import android.util.AttributeSet; import android.view.Gravity; import android.view.LayoutInflater; import android.view.MotionEvent; import android.view.View; import android.view.ViewConfiguration; import android.view.accessibility.AccessibilityEvent; import android.view.animation.DecelerateInterpolator; import android.widget.FrameLayout; import com.android.launcher3.AbstractFloatingView; import com.android.launcher3.BubbleTextView; import com.android.launcher3.DragSource; import com.android.launcher3.DropTarget; import com.android.launcher3.ItemInfo; import com.android.launcher3.Launcher; import com.android.launcher3.LauncherAnimUtils; import com.android.launcher3.LauncherModel; import com.android.launcher3.LauncherSettings; import com.android.launcher3.LogAccelerateInterpolator; import com.android.launcher3.R; import com.android.launcher3.Utilities; import com.android.launcher3.accessibility.LauncherAccessibilityDelegate; import com.android.launcher3.accessibility.ShortcutMenuAccessibilityDelegate; import com.android.launcher3.anim.PropertyListBuilder; import com.android.launcher3.anim.PropertyResetListener; import com.android.launcher3.badge.BadgeInfo; import com.android.launcher3.dragndrop.DragController; import com.android.launcher3.dragndrop.DragLayer; import com.android.launcher3.dragndrop.DragOptions; import com.android.launcher3.graphics.IconPalette; import com.android.launcher3.graphics.TriangleShape; import com.android.launcher3.notification.NotificationItemView; import com.android.launcher3.notification.NotificationKeyData; import com.android.launcher3.shortcuts.DeepShortcutManager; import com.android.launcher3.shortcuts.DeepShortcutView; import com.android.launcher3.shortcuts.ShortcutsItemView; import com.android.launcher3.util.PackageUserKey; import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Set; import static com.android.launcher3.userevent.nano.LauncherLogProto.ContainerType; import static com.android.launcher3.userevent.nano.LauncherLogProto.ItemType; import static com.android.launcher3.userevent.nano.LauncherLogProto.Target; /** * A container for shortcuts to deep links within apps. */ @TargetApi(Build.VERSION_CODES.N) public class PopupContainerWithArrow extends AbstractFloatingView implements DragSource, DragController.DragListener { protected final Launcher mLauncher; private final int mStartDragThreshold; private LauncherAccessibilityDelegate mAccessibilityDelegate; private final boolean mIsRtl; public ShortcutsItemView mShortcutsItemView; private NotificationItemView mNotificationItemView; protected BubbleTextView mOriginalIcon; private final Rect mTempRect = new Rect(); private PointF mInterceptTouchDown = new PointF(); private boolean mIsLeftAligned; protected boolean mIsAboveIcon; private View mArrow; protected Animator mOpenCloseAnimator; private boolean mDeferContainerRemoval; private AnimatorSet mReduceHeightAnimatorSet; public PopupContainerWithArrow(Context context, AttributeSet attrs, int defStyleAttr) { super(context, attrs, defStyleAttr); mLauncher = Launcher.getLauncher(context); mStartDragThreshold = getResources().getDimensionPixelSize( R.dimen.deep_shortcuts_start_drag_threshold); mAccessibilityDelegate = new ShortcutMenuAccessibilityDelegate(mLauncher); mIsRtl = Utilities.isRtl(getResources()); } public PopupContainerWithArrow(Context context, AttributeSet attrs) { this(context, attrs, 0); } public PopupContainerWithArrow(Context context) { this(context, null, 0); } public LauncherAccessibilityDelegate getAccessibilityDelegate() { return mAccessibilityDelegate; } /** * Shows the notifications and deep shortcuts associated with {@param icon}. * @return the container if shown or null. */ public static PopupContainerWithArrow showForIcon(BubbleTextView icon) { Launcher launcher = Launcher.getLauncher(icon.getContext()); if (getOpen(launcher) != null) { // There is already an items container open, so don't open this one. icon.clearFocus(); return null; } ItemInfo itemInfo = (ItemInfo) icon.getTag(); if (!DeepShortcutManager.supportsShortcuts(itemInfo)) { return null; } PopupDataProvider popupDataProvider = launcher.getPopupDataProvider(); List shortcutIds = popupDataProvider.getShortcutIdsForItem(itemInfo); List notificationKeys = popupDataProvider .getNotificationKeysForItem(itemInfo); List systemShortcuts = popupDataProvider .getEnabledSystemShortcutsForItem(itemInfo); final PopupContainerWithArrow container = (PopupContainerWithArrow) launcher.getLayoutInflater().inflate( R.layout.popup_container, launcher.getDragLayer(), false); container.setVisibility(View.INVISIBLE); launcher.getDragLayer().addView(container); container.populateAndShow(icon, shortcutIds, notificationKeys, systemShortcuts); return container; } public void populateAndShow(final BubbleTextView originalIcon, final List shortcutIds, final List notificationKeys, List systemShortcuts) { final Resources resources = getResources(); final int arrowWidth = resources.getDimensionPixelSize(R.dimen.popup_arrow_width); final int arrowHeight = resources.getDimensionPixelSize(R.dimen.popup_arrow_height); final int arrowVerticalOffset = resources.getDimensionPixelSize( R.dimen.popup_arrow_vertical_offset); mOriginalIcon = originalIcon; // Add dummy views first, and populate with real info when ready. PopupPopulator.Item[] itemsToPopulate = PopupPopulator .getItemsToPopulate(shortcutIds, notificationKeys, systemShortcuts); addDummyViews(itemsToPopulate, notificationKeys.size() > 1); measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED); orientAboutIcon(originalIcon, arrowHeight + arrowVerticalOffset); boolean reverseOrder = mIsAboveIcon; if (reverseOrder) { removeAllViews(); mNotificationItemView = null; mShortcutsItemView = null; itemsToPopulate = PopupPopulator.reverseItems(itemsToPopulate); addDummyViews(itemsToPopulate, notificationKeys.size() > 1); measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED); orientAboutIcon(originalIcon, arrowHeight + arrowVerticalOffset); } ItemInfo originalItemInfo = (ItemInfo) originalIcon.getTag(); List shortcutViews = mShortcutsItemView == null ? Collections.EMPTY_LIST : mShortcutsItemView.getDeepShortcutViews(reverseOrder); List systemShortcutViews = mShortcutsItemView == null ? Collections.EMPTY_LIST : mShortcutsItemView.getSystemShortcutViews(reverseOrder); if (mNotificationItemView != null) { updateNotificationHeader(); } int numShortcuts = shortcutViews.size() + systemShortcutViews.size(); int numNotifications = notificationKeys.size(); if (numNotifications == 0) { setContentDescription(getContext().getString(R.string.shortcuts_menu_description, numShortcuts, originalIcon.getContentDescription().toString())); } else { setContentDescription(getContext().getString( R.string.shortcuts_menu_with_notifications_description, numShortcuts, numNotifications, originalIcon.getContentDescription().toString())); } // Add the arrow. final int arrowHorizontalOffset = resources.getDimensionPixelSize(isAlignedWithStart() ? R.dimen.popup_arrow_horizontal_offset_start : R.dimen.popup_arrow_horizontal_offset_end); mArrow = addArrowView(arrowHorizontalOffset, arrowVerticalOffset, arrowWidth, arrowHeight); mArrow.setPivotX(arrowWidth / 2); mArrow.setPivotY(mIsAboveIcon ? 0 : arrowHeight); animateOpen(); mLauncher.getDragController().addDragListener(this); mOriginalIcon.forceHideBadge(true); // Load the shortcuts on a background thread and update the container as it animates. final Looper workerLooper = LauncherModel.getWorkerLooper(); new Handler(workerLooper).postAtFrontOfQueue(PopupPopulator.createUpdateRunnable( mLauncher, originalItemInfo, new Handler(Looper.getMainLooper()), this, shortcutIds, shortcutViews, notificationKeys, mNotificationItemView, systemShortcuts, systemShortcutViews)); } private void addDummyViews(PopupPopulator.Item[] itemTypesToPopulate, boolean notificationFooterHasIcons) { final Resources res = getResources(); final int spacing = res.getDimensionPixelSize(R.dimen.popup_items_spacing); final LayoutInflater inflater = mLauncher.getLayoutInflater(); int numItems = itemTypesToPopulate.length; for (int i = 0; i < numItems; i++) { PopupPopulator.Item itemTypeToPopulate = itemTypesToPopulate[i]; PopupPopulator.Item nextItemTypeToPopulate = i < numItems - 1 ? itemTypesToPopulate[i + 1] : null; final View item = inflater.inflate(itemTypeToPopulate.layoutId, this, false); if (itemTypeToPopulate == PopupPopulator.Item.NOTIFICATION) { mNotificationItemView = (NotificationItemView) item; int footerHeight = notificationFooterHasIcons ? res.getDimensionPixelSize(R.dimen.notification_footer_height) : 0; item.findViewById(R.id.footer).getLayoutParams().height = footerHeight; mNotificationItemView.getMainView().setAccessibilityDelegate(mAccessibilityDelegate); } else if (itemTypeToPopulate == PopupPopulator.Item.SHORTCUT) { item.setAccessibilityDelegate(mAccessibilityDelegate); } boolean shouldAddBottomMargin = nextItemTypeToPopulate != null && itemTypeToPopulate.isShortcut ^ nextItemTypeToPopulate.isShortcut; if (itemTypeToPopulate.isShortcut) { if (mShortcutsItemView == null) { mShortcutsItemView = (ShortcutsItemView) inflater.inflate( R.layout.shortcuts_item, this, false); addView(mShortcutsItemView); } mShortcutsItemView.addShortcutView(item, itemTypeToPopulate); if (shouldAddBottomMargin) { ((LayoutParams) mShortcutsItemView.getLayoutParams()).bottomMargin = spacing; } } else { addView(item); if (shouldAddBottomMargin) { ((LayoutParams) item.getLayoutParams()).bottomMargin = spacing; } } } } protected PopupItemView getItemViewAt(int index) { if (!mIsAboveIcon) { // Opening down, so arrow is the first view. index++; } return (PopupItemView) getChildAt(index); } protected int getItemCount() { // All children except the arrow are items. return getChildCount() - 1; } private void animateOpen() { setVisibility(View.VISIBLE); mIsOpen = true; final AnimatorSet shortcutAnims = LauncherAnimUtils.createAnimatorSet(); final int itemCount = getItemCount(); final long duration = getResources().getInteger( R.integer.config_deepShortcutOpenDuration); final long arrowScaleDuration = getResources().getInteger( R.integer.config_deepShortcutArrowOpenDuration); final long arrowScaleDelay = duration - arrowScaleDuration; final long stagger = getResources().getInteger( R.integer.config_deepShortcutOpenStagger); final TimeInterpolator fadeInterpolator = new LogAccelerateInterpolator(100, 0); // Animate shortcuts DecelerateInterpolator interpolator = new DecelerateInterpolator(); for (int i = 0; i < itemCount; i++) { final PopupItemView popupItemView = getItemViewAt(i); popupItemView.setVisibility(INVISIBLE); popupItemView.setAlpha(0); Animator anim = popupItemView.createOpenAnimation(mIsAboveIcon, mIsLeftAligned); anim.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationStart(Animator animation) { popupItemView.setVisibility(VISIBLE); } }); anim.setDuration(duration); int animationIndex = mIsAboveIcon ? itemCount - i - 1 : i; anim.setStartDelay(stagger * animationIndex); anim.setInterpolator(interpolator); shortcutAnims.play(anim); Animator fadeAnim = ObjectAnimator.ofFloat(popupItemView, View.ALPHA, 1); fadeAnim.setInterpolator(fadeInterpolator); // We want the shortcut to be fully opaque before the arrow starts animating. fadeAnim.setDuration(arrowScaleDelay); shortcutAnims.play(fadeAnim); } shortcutAnims.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { mOpenCloseAnimator = null; Utilities.sendCustomAccessibilityEvent( PopupContainerWithArrow.this, AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED, getContext().getString(R.string.action_deep_shortcut)); } }); // Animate the arrow mArrow.setScaleX(0); mArrow.setScaleY(0); Animator arrowScale = createArrowScaleAnim(1).setDuration(arrowScaleDuration); arrowScale.setStartDelay(arrowScaleDelay); shortcutAnims.play(arrowScale); mOpenCloseAnimator = shortcutAnims; shortcutAnims.start(); } /** * Orients this container above or below the given icon, aligning with the left or right. * * These are the preferred orientations, in order (RTL prefers right-aligned over left): * - Above and left-aligned * - Above and right-aligned * - Below and left-aligned * - Below and right-aligned * * So we always align left if there is enough horizontal space * and align above if there is enough vertical space. */ private void orientAboutIcon(BubbleTextView icon, int arrowHeight) { int width = getMeasuredWidth(); int height = getMeasuredHeight() + arrowHeight; DragLayer dragLayer = mLauncher.getDragLayer(); dragLayer.getDescendantRectRelativeToSelf(icon, mTempRect); Rect insets = dragLayer.getInsets(); // Align left (right in RTL) if there is room. int leftAlignedX = mTempRect.left + icon.getPaddingLeft(); int rightAlignedX = mTempRect.right - width - icon.getPaddingRight(); int x = leftAlignedX; boolean canBeLeftAligned = leftAlignedX + width + insets.left < dragLayer.getRight() - insets.right; boolean canBeRightAligned = rightAlignedX > dragLayer.getLeft() + insets.left; if (!canBeLeftAligned || (mIsRtl && canBeRightAligned)) { x = rightAlignedX; } mIsLeftAligned = x == leftAlignedX; if (mIsRtl) { x -= dragLayer.getWidth() - width; } // Offset x so that the arrow and shortcut icons are center-aligned with the original icon. int iconWidth = icon.getWidth() - icon.getTotalPaddingLeft() - icon.getTotalPaddingRight(); iconWidth *= icon.getScaleX(); Resources resources = getResources(); int xOffset; if (isAlignedWithStart()) { // Aligning with the shortcut icon. int shortcutIconWidth = resources.getDimensionPixelSize(R.dimen.deep_shortcut_icon_size); int shortcutPaddingStart = resources.getDimensionPixelSize( R.dimen.popup_padding_start); xOffset = iconWidth / 2 - shortcutIconWidth / 2 - shortcutPaddingStart; } else { // Aligning with the drag handle. int shortcutDragHandleWidth = resources.getDimensionPixelSize( R.dimen.deep_shortcut_drag_handle_size); int shortcutPaddingEnd = resources.getDimensionPixelSize( R.dimen.popup_padding_end); xOffset = iconWidth / 2 - shortcutDragHandleWidth / 2 - shortcutPaddingEnd; } x += mIsLeftAligned ? xOffset : -xOffset; // Open above icon if there is room. int iconHeight = icon.getIcon().getBounds().height(); int y = mTempRect.top + icon.getPaddingTop() - height; mIsAboveIcon = y > dragLayer.getTop() + insets.top; if (!mIsAboveIcon) { y = mTempRect.top + icon.getPaddingTop() + iconHeight; } // Insets are added later, so subtract them now. if (mIsRtl) { x += insets.right; } else { x -= insets.left; } y -= insets.top; if (y < dragLayer.getTop() || y + height > dragLayer.getBottom()) { // The container is opening off the screen, so just center it in the drag layer instead. ((FrameLayout.LayoutParams) getLayoutParams()).gravity = Gravity.CENTER_VERTICAL; // Put the container next to the icon, preferring the right side in ltr (left in rtl). int rightSide = leftAlignedX + iconWidth - insets.left; int leftSide = rightAlignedX - iconWidth - insets.left; if (!mIsRtl) { if (rightSide + width < dragLayer.getRight()) { x = rightSide; mIsLeftAligned = true; } else { x = leftSide; mIsLeftAligned = false; } } else { if (leftSide > dragLayer.getLeft()) { x = leftSide; mIsLeftAligned = false; } else { x = rightSide; mIsLeftAligned = true; } } mIsAboveIcon = true; } if (x < dragLayer.getLeft() || x + width > dragLayer.getRight()) { // If we are still off screen, center horizontally too. ((FrameLayout.LayoutParams) getLayoutParams()).gravity |= Gravity.CENTER_HORIZONTAL; } int gravity = ((FrameLayout.LayoutParams) getLayoutParams()).gravity; if (!Gravity.isHorizontal(gravity)) { setX(x); } if (!Gravity.isVertical(gravity)) { setY(y); } } private boolean isAlignedWithStart() { return mIsLeftAligned && !mIsRtl || !mIsLeftAligned && mIsRtl; } /** * Adds an arrow view pointing at the original icon. * @param horizontalOffset the horizontal offset of the arrow, so that it * points at the center of the original icon */ private View addArrowView(int horizontalOffset, int verticalOffset, int width, int height) { LayoutParams layoutParams = new LayoutParams(width, height); if (mIsLeftAligned) { layoutParams.gravity = Gravity.LEFT; layoutParams.leftMargin = horizontalOffset; } else { layoutParams.gravity = Gravity.RIGHT; layoutParams.rightMargin = horizontalOffset; } if (mIsAboveIcon) { layoutParams.topMargin = verticalOffset; } else { layoutParams.bottomMargin = verticalOffset; } View arrowView = new View(getContext()); if (Gravity.isVertical(((FrameLayout.LayoutParams) getLayoutParams()).gravity)) { // This is only true if there wasn't room for the container next to the icon, // so we centered it instead. In that case we don't want to show the arrow. arrowView.setVisibility(INVISIBLE); } else { ShapeDrawable arrowDrawable = new ShapeDrawable(TriangleShape.create( width, height, !mIsAboveIcon)); Paint arrowPaint = arrowDrawable.getPaint(); // Note that we have to use getChildAt() instead of getItemViewAt(), // since the latter expects the arrow which hasn't been added yet. PopupItemView itemAttachedToArrow = (PopupItemView) (getChildAt(mIsAboveIcon ? getChildCount() - 1 : 0)); arrowPaint.setColor(itemAttachedToArrow.getArrowColor(mIsAboveIcon)); // The corner path effect won't be reflected in the shadow, but shouldn't be noticeable. int radius = getResources().getDimensionPixelSize(R.dimen.popup_arrow_corner_radius); arrowPaint.setPathEffect(new CornerPathEffect(radius)); arrowView.setBackground(arrowDrawable); arrowView.setElevation(getElevation()); } addView(arrowView, mIsAboveIcon ? getChildCount() : 0, layoutParams); return arrowView; } @Override public View getExtendedTouchView() { return mOriginalIcon; } /** * Determines when the deferred drag should be started. * * Current behavior: * - Start the drag if the touch passes a certain distance from the original touch down. */ public DragOptions.PreDragCondition createPreDragCondition() { return new DragOptions.PreDragCondition() { @Override public boolean shouldStartDrag(double distanceDragged) { return distanceDragged > mStartDragThreshold; } @Override public void onPreDragStart(DropTarget.DragObject dragObject) { mOriginalIcon.setVisibility(INVISIBLE); } @Override public void onPreDragEnd(DropTarget.DragObject dragObject, boolean dragStarted) { if (!dragStarted) { mOriginalIcon.setVisibility(VISIBLE); mLauncher.getUserEventDispatcher().logDeepShortcutsOpen(mOriginalIcon); if (!mIsAboveIcon) { mOriginalIcon.setTextVisibility(false); } } } }; } @Override public boolean onInterceptTouchEvent(MotionEvent ev) { if (ev.getAction() == MotionEvent.ACTION_DOWN) { mInterceptTouchDown.set(ev.getX(), ev.getY()); return false; } // Stop sending touch events to deep shortcut views if user moved beyond touch slop. return Math.hypot(mInterceptTouchDown.x - ev.getX(), mInterceptTouchDown.y - ev.getY()) > ViewConfiguration.get(getContext()).getScaledTouchSlop(); } /** * Updates the notification header if the original icon's badge updated. */ public void updateNotificationHeader(Set updatedBadges) { ItemInfo itemInfo = (ItemInfo) mOriginalIcon.getTag(); PackageUserKey packageUser = PackageUserKey.fromItemInfo(itemInfo); if (updatedBadges.contains(packageUser)) { updateNotificationHeader(); } } private void updateNotificationHeader() { ItemInfo itemInfo = (ItemInfo) mOriginalIcon.getTag(); BadgeInfo badgeInfo = mLauncher.getPopupDataProvider().getBadgeInfoForItem(itemInfo); if (mNotificationItemView != null && badgeInfo != null) { IconPalette palette = mOriginalIcon.getBadgePalette(); mNotificationItemView.updateHeader(badgeInfo.getNotificationCount(), palette); } } public void trimNotifications(Map updatedBadges) { if (mNotificationItemView == null) { return; } ItemInfo originalInfo = (ItemInfo) mOriginalIcon.getTag(); BadgeInfo badgeInfo = updatedBadges.get(PackageUserKey.fromItemInfo(originalInfo)); if (badgeInfo == null || badgeInfo.getNotificationKeys().size() == 0) { AnimatorSet removeNotification = LauncherAnimUtils.createAnimatorSet(); final int duration = getResources().getInteger( R.integer.config_removeNotificationViewDuration); final int spacing = getResources().getDimensionPixelSize(R.dimen.popup_items_spacing); removeNotification.play(reduceNotificationViewHeight( mNotificationItemView.getHeightMinusFooter() + spacing, duration)); final View removeMarginView = mIsAboveIcon ? getItemViewAt(getItemCount() - 2) : mNotificationItemView; if (removeMarginView != null) { ValueAnimator removeMargin = ValueAnimator.ofFloat(1, 0).setDuration(duration); removeMargin.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { @Override public void onAnimationUpdate(ValueAnimator valueAnimator) { ((MarginLayoutParams) removeMarginView.getLayoutParams()).bottomMargin = (int) (spacing * (float) valueAnimator.getAnimatedValue()); } }); removeNotification.play(removeMargin); } Animator fade = ObjectAnimator.ofFloat(mNotificationItemView, ALPHA, 0) .setDuration(duration); fade.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { removeView(mNotificationItemView); mNotificationItemView = null; if (getItemCount() == 0) { close(false); return; } } }); removeNotification.play(fade); final long arrowScaleDuration = getResources().getInteger( R.integer.config_deepShortcutArrowOpenDuration); Animator hideArrow = createArrowScaleAnim(0).setDuration(arrowScaleDuration); hideArrow.setStartDelay(0); Animator showArrow = createArrowScaleAnim(1).setDuration(arrowScaleDuration); showArrow.setStartDelay((long) (duration - arrowScaleDuration * 1.5)); removeNotification.playSequentially(hideArrow, showArrow); removeNotification.start(); return; } mNotificationItemView.trimNotifications(NotificationKeyData.extractKeysOnly( badgeInfo.getNotificationKeys())); } @Override protected void onWidgetsBound() { if (mShortcutsItemView != null) { mShortcutsItemView.enableWidgetsIfExist(mOriginalIcon); } } private ObjectAnimator createArrowScaleAnim(float scale) { return LauncherAnimUtils.ofPropertyValuesHolder( mArrow, new PropertyListBuilder().scale(scale).build()); } /** * Animates the height of the notification item and the translationY of other items accordingly. */ public Animator reduceNotificationViewHeight(int heightToRemove, int duration) { if (mReduceHeightAnimatorSet != null) { mReduceHeightAnimatorSet.cancel(); } final int translateYBy = mIsAboveIcon ? heightToRemove : -heightToRemove; mReduceHeightAnimatorSet = LauncherAnimUtils.createAnimatorSet(); mReduceHeightAnimatorSet.play(mNotificationItemView.animateHeightRemoval(heightToRemove)); PropertyResetListener resetTranslationYListener = new PropertyResetListener<>(TRANSLATION_Y, 0f); for (int i = 0; i < getItemCount(); i++) { final PopupItemView itemView = getItemViewAt(i); if (!mIsAboveIcon && itemView == mNotificationItemView) { // The notification view is already in the right place when container is below icon. continue; } ValueAnimator translateItem = ObjectAnimator.ofFloat(itemView, TRANSLATION_Y, itemView.getTranslationY() + translateYBy).setDuration(duration); translateItem.addListener(resetTranslationYListener); mReduceHeightAnimatorSet.play(translateItem); } mReduceHeightAnimatorSet.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { if (mIsAboveIcon) { // All the items, including the notification item, translated down, but the // container itself did not. This means the items would jump back to their // original translation unless we update the container's translationY here. setTranslationY(getTranslationY() + translateYBy); } mReduceHeightAnimatorSet = null; } }); return mReduceHeightAnimatorSet; } @Override public boolean supportsAppInfoDropTarget() { return true; } @Override public boolean supportsDeleteDropTarget() { return false; } @Override public float getIntrinsicIconScaleFactor() { return 1f; } @Override public void onDropCompleted(View target, DropTarget.DragObject d, boolean isFlingToDelete, boolean success) { if (!success) { d.dragView.remove(); mLauncher.showWorkspace(true); mLauncher.getDropTargetBar().onDragEnd(); } } @Override public void onDragStart(DropTarget.DragObject dragObject, DragOptions options) { // Either the original icon or one of the shortcuts was dragged. // Hide the container, but don't remove it yet because that interferes with touch events. mDeferContainerRemoval = true; animateClose(); } @Override public void onDragEnd() { if (!mIsOpen) { if (mOpenCloseAnimator != null) { // Close animation is running. mDeferContainerRemoval = false; } else { // Close animation is not running. if (mDeferContainerRemoval) { closeComplete(); } } } } @Override public void fillInLogContainerData(View v, ItemInfo info, Target target, Target targetParent) { target.itemType = ItemType.DEEPSHORTCUT; targetParent.containerType = ContainerType.DEEPSHORTCUTS; } @Override protected void handleClose(boolean animate) { if (animate) { animateClose(); } else { closeComplete(); } } protected void animateClose() { if (!mIsOpen) { return; } if (mOpenCloseAnimator != null) { mOpenCloseAnimator.cancel(); } mIsOpen = false; final AnimatorSet shortcutAnims = LauncherAnimUtils.createAnimatorSet(); final int itemCount = getItemCount(); int numOpenShortcuts = 0; for (int i = 0; i < itemCount; i++) { if (getItemViewAt(i).isOpenOrOpening()) { numOpenShortcuts++; } } final long duration = getResources().getInteger( R.integer.config_deepShortcutCloseDuration); final long arrowScaleDuration = getResources().getInteger( R.integer.config_deepShortcutArrowOpenDuration); final long stagger = getResources().getInteger( R.integer.config_deepShortcutCloseStagger); final TimeInterpolator fadeInterpolator = new LogAccelerateInterpolator(100, 0); int firstOpenItemIndex = mIsAboveIcon ? itemCount - numOpenShortcuts : 0; for (int i = firstOpenItemIndex; i < firstOpenItemIndex + numOpenShortcuts; i++) { final PopupItemView view = getItemViewAt(i); Animator anim; anim = view.createCloseAnimation(mIsAboveIcon, mIsLeftAligned, duration); int animationIndex = mIsAboveIcon ? i - firstOpenItemIndex : numOpenShortcuts - i - 1; anim.setStartDelay(stagger * animationIndex); Animator fadeAnim = ObjectAnimator.ofFloat(view, View.ALPHA, 0); // Don't start fading until the arrow is gone. fadeAnim.setStartDelay(stagger * animationIndex + arrowScaleDuration); fadeAnim.setDuration(duration - arrowScaleDuration); fadeAnim.setInterpolator(fadeInterpolator); shortcutAnims.play(fadeAnim); anim.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { view.setVisibility(INVISIBLE); } }); shortcutAnims.play(anim); } Animator arrowAnim = createArrowScaleAnim(0).setDuration(arrowScaleDuration); arrowAnim.setStartDelay(0); shortcutAnims.play(arrowAnim); shortcutAnims.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { mOpenCloseAnimator = null; if (mDeferContainerRemoval) { setVisibility(INVISIBLE); } else { closeComplete(); } } }); mOpenCloseAnimator = shortcutAnims; shortcutAnims.start(); mOriginalIcon.forceHideBadge(false); } /** * Closes the folder without animation. */ protected void closeComplete() { if (mOpenCloseAnimator != null) { mOpenCloseAnimator.cancel(); mOpenCloseAnimator = null; } mIsOpen = false; mDeferContainerRemoval = false; boolean isInHotseat = ((ItemInfo) mOriginalIcon.getTag()).container == LauncherSettings.Favorites.CONTAINER_HOTSEAT; mOriginalIcon.setTextVisibility(!isInHotseat); mOriginalIcon.forceHideBadge(false); mLauncher.getDragController().removeDragListener(this); mLauncher.getDragLayer().removeView(this); } @Override protected boolean isOfType(int type) { return (type & TYPE_POPUP_CONTAINER_WITH_ARROW) != 0; } /** * Returns a DeepShortcutsContainer which is already open or null */ public static PopupContainerWithArrow getOpen(Launcher launcher) { return getOpenView(launcher, TYPE_POPUP_CONTAINER_WITH_ARROW); } @Override public int getLogContainerType() { return ContainerType.DEEPSHORTCUTS; } }