| /* |
| * Copyright (C) 2008 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.folder; |
| |
| import static android.text.TextUtils.isEmpty; |
| |
| import static com.android.launcher3.LauncherAnimUtils.SPRING_LOADED_EXIT_DELAY; |
| import static com.android.launcher3.LauncherState.EDIT_MODE; |
| import static com.android.launcher3.LauncherState.NORMAL; |
| import static com.android.launcher3.compat.AccessibilityManagerCompat.sendCustomAccessibilityEvent; |
| import static com.android.launcher3.config.FeatureFlags.ALWAYS_USE_HARDWARE_OPTIMIZATION_FOR_FOLDER_ANIMATIONS; |
| import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_FOLDER_LABEL_UPDATED; |
| import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ITEM_DROP_COMPLETED; |
| import static com.android.launcher3.testing.shared.TestProtocol.FOLDER_OPENED_MESSAGE; |
| import static com.android.launcher3.util.window.RefreshRateTracker.getSingleFrameMs; |
| |
| import android.animation.Animator; |
| import android.animation.AnimatorListenerAdapter; |
| import android.animation.AnimatorSet; |
| import android.annotation.SuppressLint; |
| import android.appwidget.AppWidgetHostView; |
| import android.content.Context; |
| import android.graphics.Canvas; |
| import android.graphics.Insets; |
| import android.graphics.Path; |
| import android.graphics.Rect; |
| import android.graphics.drawable.Drawable; |
| import android.graphics.drawable.GradientDrawable; |
| import android.text.InputType; |
| import android.text.Selection; |
| import android.text.TextUtils; |
| import android.util.AttributeSet; |
| import android.util.Log; |
| import android.util.Pair; |
| import android.util.TypedValue; |
| import android.view.FocusFinder; |
| import android.view.KeyEvent; |
| import android.view.LayoutInflater; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.ViewDebug; |
| import android.view.WindowInsets; |
| import android.view.accessibility.AccessibilityEvent; |
| import android.view.animation.AnimationUtils; |
| import android.view.inputmethod.EditorInfo; |
| import android.widget.TextView; |
| |
| import androidx.annotation.IntDef; |
| import androidx.annotation.Nullable; |
| import androidx.core.content.res.ResourcesCompat; |
| |
| import com.android.launcher3.AbstractFloatingView; |
| import com.android.launcher3.Alarm; |
| import com.android.launcher3.BubbleTextView; |
| import com.android.launcher3.CellLayout; |
| import com.android.launcher3.DeviceProfile; |
| import com.android.launcher3.DragSource; |
| import com.android.launcher3.DropTarget; |
| import com.android.launcher3.ExtendedEditText; |
| import com.android.launcher3.Launcher; |
| import com.android.launcher3.LauncherSettings; |
| import com.android.launcher3.OnAlarmListener; |
| import com.android.launcher3.R; |
| import com.android.launcher3.ShortcutAndWidgetContainer; |
| import com.android.launcher3.Utilities; |
| import com.android.launcher3.accessibility.AccessibleDragListenerAdapter; |
| import com.android.launcher3.accessibility.FolderAccessibilityHelper; |
| import com.android.launcher3.anim.KeyboardInsetAnimationCallback; |
| import com.android.launcher3.compat.AccessibilityManagerCompat; |
| import com.android.launcher3.config.FeatureFlags; |
| import com.android.launcher3.dragndrop.DragController; |
| import com.android.launcher3.dragndrop.DragController.DragListener; |
| import com.android.launcher3.dragndrop.DragOptions; |
| import com.android.launcher3.logger.LauncherAtom.FromState; |
| import com.android.launcher3.logger.LauncherAtom.ToState; |
| import com.android.launcher3.logging.StatsLogManager; |
| import com.android.launcher3.logging.StatsLogManager.StatsLogger; |
| import com.android.launcher3.model.data.FolderInfo; |
| import com.android.launcher3.model.data.FolderInfo.FolderListener; |
| import com.android.launcher3.model.data.ItemInfo; |
| import com.android.launcher3.model.data.WorkspaceItemFactory; |
| import com.android.launcher3.model.data.WorkspaceItemInfo; |
| import com.android.launcher3.pageindicators.PageIndicatorDots; |
| import com.android.launcher3.util.Executors; |
| import com.android.launcher3.util.LauncherBindableItemsContainer.ItemOperator; |
| import com.android.launcher3.util.Thunk; |
| import com.android.launcher3.views.ActivityContext; |
| import com.android.launcher3.views.BaseDragLayer; |
| import com.android.launcher3.views.ClipPathView; |
| import com.android.launcher3.widget.PendingAddShortcutInfo; |
| |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.List; |
| import java.util.Objects; |
| import java.util.StringJoiner; |
| import java.util.stream.Collectors; |
| import java.util.stream.Stream; |
| |
| /** |
| * Represents a set of icons chosen by the user or generated by the system. |
| */ |
| public class Folder extends AbstractFloatingView implements ClipPathView, DragSource, |
| View.OnLongClickListener, DropTarget, FolderListener, TextView.OnEditorActionListener, |
| View.OnFocusChangeListener, DragListener, ExtendedEditText.OnBackKeyListener { |
| private static final String TAG = "Launcher.Folder"; |
| private static final boolean DEBUG = false; |
| |
| /** |
| * Used for separating folder title when logging together. |
| */ |
| private static final CharSequence FOLDER_LABEL_DELIMITER = "~"; |
| |
| /** |
| * We avoid measuring {@link #mContent} with a 0 width or height, as this |
| * results in CellLayout being measured as UNSPECIFIED, which it does not support. |
| */ |
| private static final int MIN_CONTENT_DIMEN = 5; |
| |
| public static final int STATE_CLOSED = 0; |
| public static final int STATE_ANIMATING = 1; |
| public static final int STATE_OPEN = 2; |
| |
| @Retention(RetentionPolicy.SOURCE) |
| @IntDef({STATE_CLOSED, STATE_ANIMATING, STATE_OPEN}) |
| public @interface FolderState {} |
| |
| /** |
| * Time for which the scroll hint is shown before automatically changing page. |
| */ |
| public static final int SCROLL_HINT_DURATION = 500; |
| private static final int RESCROLL_EXTRA_DELAY = 150; |
| |
| public static final int SCROLL_NONE = -1; |
| public static final int SCROLL_LEFT = 0; |
| public static final int SCROLL_RIGHT = 1; |
| |
| /** |
| * Fraction of icon width which behave as scroll region. |
| */ |
| private static final float ICON_OVERSCROLL_WIDTH_FACTOR = 0.45f; |
| |
| private static final int FOLDER_NAME_ANIMATION_DURATION = 633; |
| private static final int FOLDER_COLOR_ANIMATION_DURATION = 200; |
| |
| private static final int REORDER_DELAY = 250; |
| private static final int ON_EXIT_CLOSE_DELAY = 400; |
| private static final Rect sTempRect = new Rect(); |
| private static final int MIN_FOLDERS_FOR_HARDWARE_OPTIMIZATION = 10; |
| |
| private final Alarm mReorderAlarm = new Alarm(); |
| private final Alarm mOnExitAlarm = new Alarm(); |
| private final Alarm mOnScrollHintAlarm = new Alarm(); |
| final Alarm mScrollPauseAlarm = new Alarm(); |
| |
| final ArrayList<View> mItemsInReadingOrder = new ArrayList<View>(); |
| |
| private AnimatorSet mCurrentAnimator; |
| private boolean mIsAnimatingClosed = false; |
| |
| // Folder can be displayed in Launcher's activity or a separate window (e.g. Taskbar). |
| // Anything specific to Launcher should use mLauncherDelegate, otherwise should |
| // use mActivityContext. |
| protected final LauncherDelegate mLauncherDelegate; |
| protected final ActivityContext mActivityContext; |
| |
| protected DragController mDragController; |
| public FolderInfo mInfo; |
| private CharSequence mFromTitle; |
| private FromState mFromLabelState; |
| |
| @Thunk |
| FolderIcon mFolderIcon; |
| |
| @Thunk |
| FolderPagedView mContent; |
| public FolderNameEditText mFolderName; |
| private PageIndicatorDots mPageIndicator; |
| |
| protected View mFooter; |
| private int mFooterHeight; |
| |
| // Cell ranks used for drag and drop |
| @Thunk |
| int mTargetRank, mPrevTargetRank, mEmptyCellRank; |
| |
| private Path mClipPath; |
| |
| @ViewDebug.ExportedProperty(category = "launcher", |
| mapping = { |
| @ViewDebug.IntToString(from = STATE_CLOSED, to = "STATE_CLOSED"), |
| @ViewDebug.IntToString(from = STATE_ANIMATING, to = "STATE_ANIMATING"), |
| @ViewDebug.IntToString(from = STATE_OPEN, to = "STATE_OPEN"), |
| }) |
| private int mState = STATE_CLOSED; |
| private final List<OnFolderStateChangedListener> mOnFolderStateChangedListeners = |
| new ArrayList<>(); |
| private OnFolderStateChangedListener mPriorityOnFolderStateChangedListener; |
| @ViewDebug.ExportedProperty(category = "launcher") |
| private boolean mRearrangeOnClose = false; |
| boolean mItemsInvalidated = false; |
| private View mCurrentDragView; |
| private boolean mIsExternalDrag; |
| private boolean mDragInProgress = false; |
| private boolean mDeleteFolderOnDropCompleted = false; |
| private boolean mSuppressFolderDeletion = false; |
| private boolean mItemAddedBackToSelfViaIcon = false; |
| private boolean mIsEditingName = false; |
| |
| @ViewDebug.ExportedProperty(category = "launcher") |
| private boolean mDestroyed; |
| |
| // Folder scrolling |
| private int mScrollAreaOffset; |
| |
| @Thunk |
| int mScrollHintDir = SCROLL_NONE; |
| @Thunk |
| int mCurrentScrollDir = SCROLL_NONE; |
| |
| private StatsLogManager mStatsLogManager; |
| |
| @Nullable |
| private KeyboardInsetAnimationCallback mKeyboardInsetAnimationCallback; |
| |
| private GradientDrawable mBackground; |
| |
| /** |
| * Used to inflate the Workspace from XML. |
| * |
| * @param context The application's context. |
| * @param attrs The attributes set containing the Workspace's customization values. |
| */ |
| public Folder(Context context, AttributeSet attrs) { |
| super(context, attrs); |
| setAlwaysDrawnWithCacheEnabled(false); |
| |
| mActivityContext = ActivityContext.lookupContext(context); |
| mLauncherDelegate = LauncherDelegate.from(mActivityContext); |
| |
| mStatsLogManager = StatsLogManager.newInstance(context); |
| // We need this view to be focusable in touch mode so that when text editing of the folder |
| // name is complete, we have something to focus on, thus hiding the cursor and giving |
| // reliable behavior when clicking the text field (since it will always gain focus on |
| // click). |
| setFocusableInTouchMode(true); |
| |
| } |
| |
| @Override |
| public Drawable getBackground() { |
| return mBackground; |
| } |
| |
| @Override |
| protected void onFinishInflate() { |
| super.onFinishInflate(); |
| final DeviceProfile dp = mActivityContext.getDeviceProfile(); |
| final int paddingLeftRight = dp.folderContentPaddingLeftRight; |
| |
| mBackground = (GradientDrawable) ResourcesCompat.getDrawable(getResources(), |
| R.drawable.round_rect_folder, getContext().getTheme()); |
| |
| mContent = findViewById(R.id.folder_content); |
| mContent.setPadding(paddingLeftRight, dp.folderContentPaddingTop, paddingLeftRight, 0); |
| mContent.setFolder(this); |
| |
| mPageIndicator = findViewById(R.id.folder_page_indicator); |
| mFolderName = findViewById(R.id.folder_name); |
| mFolderName.setTextSize(TypedValue.COMPLEX_UNIT_PX, dp.folderLabelTextSizePx); |
| mFolderName.setOnBackKeyListener(this); |
| mFolderName.setOnEditorActionListener(this); |
| mFolderName.setSelectAllOnFocus(true); |
| mFolderName.setInputType(mFolderName.getInputType() |
| & ~InputType.TYPE_TEXT_FLAG_AUTO_CORRECT |
| | InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS |
| | InputType.TYPE_TEXT_FLAG_CAP_WORDS); |
| mFolderName.forceDisableSuggestions(true); |
| |
| mFooter = findViewById(R.id.folder_footer); |
| mFooterHeight = dp.folderFooterHeightPx; |
| |
| if (Utilities.ATLEAST_R) { |
| mKeyboardInsetAnimationCallback = new KeyboardInsetAnimationCallback(this); |
| setWindowInsetsAnimationCallback(mKeyboardInsetAnimationCallback); |
| } |
| } |
| |
| public boolean onLongClick(View v) { |
| // Return if global dragging is not enabled |
| if (!mLauncherDelegate.isDraggingEnabled()) return true; |
| return startDrag(v, new DragOptions()); |
| } |
| |
| public boolean startDrag(View v, DragOptions options) { |
| Object tag = v.getTag(); |
| if (tag instanceof WorkspaceItemInfo) { |
| WorkspaceItemInfo item = (WorkspaceItemInfo) tag; |
| |
| mEmptyCellRank = item.rank; |
| mCurrentDragView = v; |
| |
| mDragController.addDragListener(this); |
| if (options.isAccessibleDrag) { |
| mDragController.addDragListener(new AccessibleDragListenerAdapter( |
| mContent, FolderAccessibilityHelper::new) { |
| @Override |
| protected void enableAccessibleDrag(boolean enable) { |
| super.enableAccessibleDrag(enable); |
| mFooter.setImportantForAccessibility(enable |
| ? IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS |
| : IMPORTANT_FOR_ACCESSIBILITY_AUTO); |
| } |
| }); |
| } |
| |
| mLauncherDelegate.beginDragShared(v, this, options); |
| } |
| return true; |
| } |
| |
| @Override |
| public void onDragStart(DropTarget.DragObject dragObject, DragOptions options) { |
| if (dragObject.dragSource != this) { |
| return; |
| } |
| |
| mContent.removeItem(mCurrentDragView); |
| if (dragObject.dragInfo instanceof WorkspaceItemInfo) { |
| mItemsInvalidated = true; |
| |
| // We do not want to get events for the item being removed, as they will get handled |
| // when the drop completes |
| try (SuppressInfoChanges s = new SuppressInfoChanges()) { |
| mInfo.remove((WorkspaceItemInfo) dragObject.dragInfo, true); |
| } |
| } |
| mDragInProgress = true; |
| mItemAddedBackToSelfViaIcon = false; |
| } |
| |
| @Override |
| public void onDragEnd() { |
| if (mIsExternalDrag && mDragInProgress) { |
| completeDragExit(); |
| } |
| mDragInProgress = false; |
| mDragController.removeDragListener(this); |
| } |
| |
| public boolean isEditingName() { |
| return mIsEditingName; |
| } |
| |
| public void startEditingFolderName() { |
| post(() -> { |
| showLabelSuggestions(); |
| mFolderName.setHint(""); |
| mIsEditingName = true; |
| }); |
| } |
| |
| @Override |
| public boolean onBackKey() { |
| // Convert to a string here to ensure that no other state associated with the text field |
| // gets saved. |
| String newTitle = mFolderName.getText().toString(); |
| if (DEBUG) { |
| Log.d(TAG, "onBackKey newTitle=" + newTitle); |
| } |
| mInfo.setTitle(newTitle, mLauncherDelegate.getModelWriter()); |
| mFolderIcon.onTitleChanged(newTitle); |
| |
| if (TextUtils.isEmpty(mInfo.title)) { |
| mFolderName.setHint(R.string.folder_hint_text); |
| mFolderName.setText(""); |
| } else { |
| mFolderName.setHint(null); |
| } |
| |
| sendCustomAccessibilityEvent( |
| this, AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED, |
| getContext().getString(R.string.folder_renamed, newTitle)); |
| |
| // This ensures that focus is gained every time the field is clicked, which selects all |
| // the text and brings up the soft keyboard if necessary. |
| mFolderName.clearFocus(); |
| |
| Selection.setSelection(mFolderName.getText(), 0, 0); |
| mIsEditingName = false; |
| return true; |
| } |
| |
| public boolean onEditorAction(TextView v, int actionId, KeyEvent event) { |
| if (DEBUG) { |
| Log.d(TAG, "onEditorAction actionId=" + actionId + " key=" |
| + (event != null ? event.getKeyCode() : "null event")); |
| } |
| if (actionId == EditorInfo.IME_ACTION_DONE) { |
| mFolderName.dispatchBackKey(); |
| return true; |
| } |
| return false; |
| } |
| |
| @Override |
| public WindowInsets onApplyWindowInsets(WindowInsets windowInsets) { |
| if (Utilities.ATLEAST_R) { |
| this.setTranslationY(0); |
| |
| if (windowInsets.isVisible(WindowInsets.Type.ime())) { |
| Insets keyboardInsets = windowInsets.getInsets(WindowInsets.Type.ime()); |
| int folderHeightFromBottom = getHeightFromBottom(); |
| |
| if (keyboardInsets.bottom > folderHeightFromBottom) { |
| // Translate this folder above the keyboard, then add the folder name's padding |
| this.setTranslationY(folderHeightFromBottom - keyboardInsets.bottom |
| - mFolderName.getPaddingBottom()); |
| } |
| } |
| } |
| |
| return windowInsets; |
| } |
| |
| public FolderIcon getFolderIcon() { |
| return mFolderIcon; |
| } |
| |
| public void setDragController(DragController dragController) { |
| mDragController = dragController; |
| } |
| |
| public void setFolderIcon(FolderIcon icon) { |
| mFolderIcon = icon; |
| mLauncherDelegate.init(this, icon); |
| } |
| |
| @Override |
| protected void onAttachedToWindow() { |
| // requestFocus() causes the focus onto the folder itself, which doesn't cause visual |
| // effect but the next arrow key can start the keyboard focus inside of the folder, not |
| // the folder itself. |
| requestFocus(); |
| super.onAttachedToWindow(); |
| mFolderName.addOnFocusChangeListener(this); |
| } |
| |
| @Override |
| protected void onDetachedFromWindow() { |
| super.onDetachedFromWindow(); |
| mFolderName.removeOnFocusChangeListener(this); |
| } |
| |
| @Override |
| public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) { |
| // When the folder gets focus, we don't want to announce the list of items. |
| return true; |
| } |
| |
| @Override |
| public View focusSearch(int direction) { |
| // When the folder is focused, further focus search should be within the folder contents. |
| return FocusFinder.getInstance().findNextFocus(this, null, direction); |
| } |
| |
| /** |
| * @return the FolderInfo object associated with this folder |
| */ |
| public FolderInfo getInfo() { |
| return mInfo; |
| } |
| |
| void bind(FolderInfo info) { |
| mInfo = info; |
| mFromTitle = info.title; |
| mFromLabelState = info.getFromLabelState(); |
| ArrayList<WorkspaceItemInfo> children = info.contents; |
| Collections.sort(children, ITEM_POS_COMPARATOR); |
| updateItemLocationsInDatabaseBatch(true); |
| |
| BaseDragLayer.LayoutParams lp = (BaseDragLayer.LayoutParams) getLayoutParams(); |
| if (lp == null) { |
| lp = new BaseDragLayer.LayoutParams(0, 0); |
| lp.customPosition = true; |
| setLayoutParams(lp); |
| } |
| mItemsInvalidated = true; |
| mInfo.addListener(this); |
| |
| if (!isEmpty(mInfo.title)) { |
| mFolderName.setText(mInfo.title); |
| mFolderName.setHint(null); |
| } else { |
| mFolderName.setText(""); |
| mFolderName.setHint(R.string.folder_hint_text); |
| } |
| // In case any children didn't come across during loading, clean up the folder accordingly |
| mFolderIcon.post(() -> { |
| if (getItemCount() <= 1) { |
| replaceFolderWithFinalItem(); |
| } |
| }); |
| } |
| |
| |
| /** |
| * Show suggested folder title in FolderEditText if the first suggestion is non-empty, push |
| * rest of the suggestions to InputMethodManager. |
| */ |
| private void showLabelSuggestions() { |
| if (mInfo.suggestedFolderNames == null) { |
| return; |
| } |
| if (mInfo.suggestedFolderNames.hasSuggestions()) { |
| // update the primary suggestion if the folder name is empty. |
| if (isEmpty(mFolderName.getText())) { |
| if (mInfo.suggestedFolderNames.hasPrimary()) { |
| mFolderName.setHint(""); |
| mFolderName.setText(mInfo.suggestedFolderNames.getLabels()[0]); |
| mFolderName.selectAll(); |
| } |
| } |
| mFolderName.showKeyboard(); |
| mFolderName.displayCompletions( |
| Stream.of(mInfo.suggestedFolderNames.getLabels()) |
| .filter(Objects::nonNull) |
| .map(Object::toString) |
| .filter(s -> !s.isEmpty()) |
| .filter(s -> !s.equalsIgnoreCase(mFolderName.getText().toString())) |
| .collect(Collectors.toList())); |
| } |
| } |
| |
| /** |
| * Creates a new UserFolder, inflated from R.layout.user_folder. |
| * |
| * @param activityContext The main ActivityContext in which to inflate this Folder. It must also |
| * be an instance or ContextWrapper around the Launcher activity context. |
| * @return A new UserFolder. |
| */ |
| @SuppressLint("InflateParams") |
| static <T extends Context & ActivityContext> Folder fromXml(T activityContext) { |
| return (Folder) LayoutInflater.from(activityContext).cloneInContext(activityContext) |
| .inflate(R.layout.user_folder_icon_normalized, null); |
| } |
| |
| private void addAnimationStartListeners(AnimatorSet a) { |
| mLauncherDelegate.forEachVisibleWorkspacePage( |
| visiblePage -> addAnimatorListenerForPage(a, (CellLayout) visiblePage)); |
| |
| a.addListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationStart(Animator animation) { |
| setState(STATE_ANIMATING); |
| mCurrentAnimator = a; |
| } |
| |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| mCurrentAnimator = null; |
| } |
| }); |
| } |
| |
| private void addAnimatorListenerForPage(AnimatorSet a, CellLayout currentCellLayout) { |
| final boolean useHardware = shouldUseHardwareLayerForAnimation(currentCellLayout); |
| final boolean wasHardwareAccelerated = currentCellLayout.isHardwareLayerEnabled(); |
| |
| a.addListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationStart(Animator animation) { |
| if (useHardware) { |
| currentCellLayout.enableHardwareLayer(true); |
| } |
| } |
| |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| if (useHardware) { |
| currentCellLayout.enableHardwareLayer(wasHardwareAccelerated); |
| } |
| } |
| }); |
| } |
| |
| private boolean shouldUseHardwareLayerForAnimation(CellLayout currentCellLayout) { |
| if (ALWAYS_USE_HARDWARE_OPTIMIZATION_FOR_FOLDER_ANIMATIONS.get()) return true; |
| |
| int folderCount = 0; |
| final ShortcutAndWidgetContainer container = currentCellLayout.getShortcutsAndWidgets(); |
| for (int i = container.getChildCount() - 1; i >= 0; --i) { |
| final View child = container.getChildAt(i); |
| if (child instanceof AppWidgetHostView) return false; |
| if (child instanceof FolderIcon) ++folderCount; |
| } |
| return folderCount >= MIN_FOLDERS_FOR_HARDWARE_OPTIMIZATION; |
| } |
| |
| /** |
| * Opens the folder as part of a drag operation |
| */ |
| public void beginExternalDrag() { |
| mIsExternalDrag = true; |
| mDragInProgress = true; |
| |
| // Since this folder opened by another controller, it might not get onDrop or |
| // onDropComplete. Perform cleanup once drag-n-drop ends. |
| mDragController.addDragListener(this); |
| |
| ArrayList<WorkspaceItemInfo> items = new ArrayList<>(mInfo.contents); |
| mEmptyCellRank = items.size(); |
| items.add(null); // Add an empty spot at the end |
| |
| animateOpen(items, mEmptyCellRank / mContent.itemsPerPage()); |
| } |
| |
| /** |
| * Opens the user folder described by the specified tag. The opening of the folder |
| * is animated relative to the specified View. If the View is null, no animation |
| * is played. |
| */ |
| public void animateOpen() { |
| animateOpen(mInfo.contents, 0); |
| } |
| |
| /** |
| * Opens the user folder described by the specified tag. The opening of the folder |
| * is animated relative to the specified View. If the View is null, no animation |
| * is played. |
| */ |
| private void animateOpen(List<WorkspaceItemInfo> items, int pageNo) { |
| if (items == null || items.size() <= 1) { |
| Log.d(TAG, "Couldn't animate folder open because items is: " + items); |
| return; |
| } |
| |
| Folder openFolder = getOpen(mActivityContext); |
| if (openFolder != null && openFolder != this) { |
| // Close any open folder before opening a folder. |
| openFolder.close(true); |
| } |
| |
| mContent.bindItems(items); |
| centerAboutIcon(); |
| mItemsInvalidated = true; |
| updateTextViewFocus(); |
| |
| mIsOpen = true; |
| |
| BaseDragLayer dragLayer = mActivityContext.getDragLayer(); |
| // Just verify that the folder hasn't already been added to the DragLayer. |
| // There was a one-off crash where the folder had a parent already. |
| if (getParent() == null) { |
| dragLayer.addView(this); |
| mDragController.addDropTarget(this); |
| } else { |
| if (FeatureFlags.IS_STUDIO_BUILD) { |
| Log.e(TAG, "Opening folder (" + this + ") which already has a parent:" |
| + getParent()); |
| } |
| } |
| |
| mContent.completePendingPageChanges(); |
| mContent.setCurrentPage(pageNo); |
| |
| // This is set to true in close(), but isn't reset to false until onDropCompleted(). This |
| // leads to an inconsistent state if you drag out of the folder and drag back in without |
| // dropping. One resulting issue is that replaceFolderWithFinalItem() can be called twice. |
| mDeleteFolderOnDropCompleted = false; |
| |
| cancelRunningAnimations(); |
| FolderAnimationManager fam = new FolderAnimationManager(this, true /* isOpening */); |
| AnimatorSet anim = fam.getAnimator(); |
| anim.addListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationStart(Animator animation) { |
| mFolderIcon.setIconVisible(false); |
| mFolderIcon.drawLeaveBehindIfExists(); |
| } |
| |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| setState(STATE_OPEN); |
| announceAccessibilityChanges(); |
| AccessibilityManagerCompat.sendTestProtocolEventToTest(getContext(), |
| FOLDER_OPENED_MESSAGE); |
| |
| mContent.setFocusOnFirstChild(); |
| } |
| }); |
| |
| // Footer animation |
| if (mContent.getPageCount() > 1 && !mInfo.hasOption(FolderInfo.FLAG_MULTI_PAGE_ANIMATION)) { |
| int footerWidth = mContent.getDesiredWidth() |
| - mFooter.getPaddingLeft() - mFooter.getPaddingRight(); |
| |
| float textWidth = mFolderName.getPaint().measureText(mFolderName.getText().toString()); |
| float translation = (footerWidth - textWidth) / 2; |
| mFolderName.setTranslationX(mContent.mIsRtl ? -translation : translation); |
| mPageIndicator.prepareEntryAnimation(); |
| |
| // Do not update the flag if we are in drag mode. The flag will be updated, when we |
| // actually drop the icon. |
| final boolean updateAnimationFlag = !mDragInProgress; |
| anim.addListener(new AnimatorListenerAdapter() { |
| |
| @SuppressLint("InlinedApi") |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| mFolderName.animate().setDuration(FOLDER_NAME_ANIMATION_DURATION) |
| .translationX(0) |
| .setInterpolator(AnimationUtils.loadInterpolator( |
| getContext(), android.R.interpolator.fast_out_slow_in)); |
| mPageIndicator.playEntryAnimation(); |
| |
| if (updateAnimationFlag) { |
| mInfo.setOption(FolderInfo.FLAG_MULTI_PAGE_ANIMATION, true, |
| mLauncherDelegate.getModelWriter()); |
| } |
| } |
| }); |
| } else { |
| mFolderName.setTranslationX(0); |
| } |
| |
| mPageIndicator.stopAllAnimations(); |
| |
| // b/282158620 because setCurrentPlayTime() below will start animator, we need to register |
| // {@link AnimatorListener} before it so that {@link AnimatorListener#onAnimationStart} can |
| // be called to register mCurrentAnimator, which will be used to cancel animator |
| addAnimationStartListeners(anim); |
| // Because t=0 has the folder match the folder icon, we can skip the |
| // first frame and have the same movement one frame earlier. |
| anim.setCurrentPlayTime(Math.min(getSingleFrameMs(getContext()), anim.getTotalDuration())); |
| anim.start(); |
| |
| // Make sure the folder picks up the last drag move even if the finger doesn't move. |
| if (mDragController.isDragging()) { |
| mDragController.forceTouchMove(); |
| } |
| mContent.verifyVisibleHighResIcons(mContent.getNextPage()); |
| } |
| |
| @Override |
| protected boolean isOfType(int type) { |
| return (type & TYPE_FOLDER) != 0; |
| } |
| |
| @Override |
| protected void handleClose(boolean animate) { |
| mIsOpen = false; |
| |
| if (!animate && mCurrentAnimator != null && mCurrentAnimator.isRunning()) { |
| mCurrentAnimator.cancel(); |
| } |
| |
| if (isEditingName()) { |
| mFolderName.dispatchBackKey(); |
| } |
| |
| if (mFolderIcon != null) { |
| mFolderIcon.clearLeaveBehindIfExists(); |
| } |
| |
| if (animate) { |
| animateClosed(); |
| } else { |
| closeComplete(false); |
| post(this::announceAccessibilityChanges); |
| } |
| |
| // Notify the accessibility manager that this folder "window" has disappeared and no |
| // longer occludes the workspace items |
| mActivityContext.getDragLayer().sendAccessibilityEvent( |
| AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED); |
| } |
| |
| private void cancelRunningAnimations() { |
| if (mCurrentAnimator != null && mCurrentAnimator.isRunning()) { |
| mCurrentAnimator.cancel(); |
| } |
| } |
| |
| private void animateClosed() { |
| if (mIsAnimatingClosed) { |
| return; |
| } |
| |
| mContent.completePendingPageChanges(); |
| mContent.snapToPageImmediately(mContent.getDestinationPage()); |
| |
| cancelRunningAnimations(); |
| AnimatorSet a = new FolderAnimationManager(this, false /* isOpening */).getAnimator(); |
| a.addListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationStart(Animator animation) { |
| if (Utilities.ATLEAST_R) { |
| setWindowInsetsAnimationCallback(null); |
| } |
| mIsAnimatingClosed = true; |
| } |
| |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| if (Utilities.ATLEAST_R && mKeyboardInsetAnimationCallback != null) { |
| setWindowInsetsAnimationCallback(mKeyboardInsetAnimationCallback); |
| } |
| closeComplete(true); |
| announceAccessibilityChanges(); |
| mIsAnimatingClosed = false; |
| } |
| }); |
| addAnimationStartListeners(a); |
| a.start(); |
| } |
| |
| @Override |
| protected Pair<View, String> getAccessibilityTarget() { |
| return Pair.create(mContent, mIsOpen ? mContent.getAccessibilityDescription() |
| : getContext().getString(R.string.folder_closed)); |
| } |
| |
| @Override |
| protected View getAccessibilityInitialFocusView() { |
| View firstItem = mContent.getFirstItem(); |
| return firstItem != null ? firstItem : super.getAccessibilityInitialFocusView(); |
| } |
| |
| private void closeComplete(boolean wasAnimated) { |
| // TODO: Clear all active animations. |
| BaseDragLayer parent = (BaseDragLayer) getParent(); |
| if (parent != null) { |
| parent.removeView(this); |
| } |
| mDragController.removeDropTarget(this); |
| clearFocus(); |
| if (mFolderIcon != null) { |
| mFolderIcon.setVisibility(View.VISIBLE); |
| mFolderIcon.setIconVisible(true); |
| mFolderIcon.mFolderName.setTextVisibility(true); |
| if (wasAnimated) { |
| mFolderIcon.animateBgShadowAndStroke(); |
| mFolderIcon.onFolderClose(mContent.getCurrentPage()); |
| if (mFolderIcon.hasDot()) { |
| mFolderIcon.animateDotScale(0f, 1f); |
| } |
| mFolderIcon.requestFocus(); |
| } |
| } |
| |
| if (mRearrangeOnClose) { |
| rearrangeChildren(); |
| mRearrangeOnClose = false; |
| } |
| if (getItemCount() <= 1) { |
| if (!mDragInProgress && !mSuppressFolderDeletion) { |
| replaceFolderWithFinalItem(); |
| } else if (mDragInProgress) { |
| mDeleteFolderOnDropCompleted = true; |
| } |
| } else if (!mDragInProgress) { |
| mContent.unbindItems(); |
| } |
| mSuppressFolderDeletion = false; |
| clearDragInfo(); |
| setState(STATE_CLOSED); |
| mContent.setCurrentPage(0); |
| } |
| |
| @Override |
| public boolean acceptDrop(DragObject d) { |
| final ItemInfo item = d.dragInfo; |
| final int itemType = item.itemType; |
| return ((itemType == LauncherSettings.Favorites.ITEM_TYPE_APPLICATION || |
| itemType == LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT)); |
| } |
| |
| public void onDragEnter(DragObject d) { |
| mPrevTargetRank = -1; |
| mOnExitAlarm.cancelAlarm(); |
| // Get the area offset such that the folder only closes if half the drag icon width |
| // is outside the folder area |
| mScrollAreaOffset = d.dragView.getDragRegionWidth() / 2 - d.xOffset; |
| } |
| |
| OnAlarmListener mReorderAlarmListener = new OnAlarmListener() { |
| public void onAlarm(Alarm alarm) { |
| mContent.realTimeReorder(mEmptyCellRank, mTargetRank); |
| mEmptyCellRank = mTargetRank; |
| } |
| }; |
| |
| public boolean isLayoutRtl() { |
| return (getLayoutDirection() == LAYOUT_DIRECTION_RTL); |
| } |
| |
| private int getTargetRank(DragObject d, float[] recycle) { |
| recycle = d.getVisualCenter(recycle); |
| return mContent.findNearestArea( |
| (int) recycle[0] - getPaddingLeft(), (int) recycle[1] - getPaddingTop()); |
| } |
| |
| @Override |
| public void onDragOver(DragObject d) { |
| if (mScrollPauseAlarm.alarmPending()) { |
| return; |
| } |
| final float[] r = new float[2]; |
| mTargetRank = getTargetRank(d, r); |
| |
| if (mTargetRank != mPrevTargetRank) { |
| mReorderAlarm.cancelAlarm(); |
| mReorderAlarm.setOnAlarmListener(mReorderAlarmListener); |
| mReorderAlarm.setAlarm(REORDER_DELAY); |
| mPrevTargetRank = mTargetRank; |
| |
| if (d.stateAnnouncer != null) { |
| d.stateAnnouncer.announce(getContext().getString(R.string.move_to_position, |
| mTargetRank + 1)); |
| } |
| } |
| |
| float x = r[0]; |
| int currentPage = mContent.getNextPage(); |
| |
| float cellOverlap = mContent.getCurrentCellLayout().getCellWidth() |
| * ICON_OVERSCROLL_WIDTH_FACTOR; |
| boolean isOutsideLeftEdge = x < cellOverlap; |
| boolean isOutsideRightEdge = x > (getWidth() - cellOverlap); |
| |
| if (currentPage > 0 && (mContent.mIsRtl ? isOutsideRightEdge : isOutsideLeftEdge)) { |
| showScrollHint(SCROLL_LEFT, d); |
| } else if (currentPage < (mContent.getPageCount() - 1) |
| && (mContent.mIsRtl ? isOutsideLeftEdge : isOutsideRightEdge)) { |
| showScrollHint(SCROLL_RIGHT, d); |
| } else { |
| mOnScrollHintAlarm.cancelAlarm(); |
| if (mScrollHintDir != SCROLL_NONE) { |
| mContent.clearScrollHint(); |
| mScrollHintDir = SCROLL_NONE; |
| } |
| } |
| } |
| |
| private void showScrollHint(int direction, DragObject d) { |
| // Show scroll hint on the right |
| if (mScrollHintDir != direction) { |
| mContent.showScrollHint(direction); |
| mScrollHintDir = direction; |
| } |
| |
| // Set alarm for when the hint is complete |
| if (!mOnScrollHintAlarm.alarmPending() || mCurrentScrollDir != direction) { |
| mCurrentScrollDir = direction; |
| mOnScrollHintAlarm.cancelAlarm(); |
| mOnScrollHintAlarm.setOnAlarmListener(new OnScrollHintListener(d)); |
| mOnScrollHintAlarm.setAlarm(SCROLL_HINT_DURATION); |
| |
| mReorderAlarm.cancelAlarm(); |
| mTargetRank = mEmptyCellRank; |
| } |
| } |
| |
| OnAlarmListener mOnExitAlarmListener = new OnAlarmListener() { |
| public void onAlarm(Alarm alarm) { |
| completeDragExit(); |
| } |
| }; |
| |
| public void completeDragExit() { |
| if (mIsOpen) { |
| close(true); |
| mRearrangeOnClose = true; |
| } else if (mState == STATE_ANIMATING) { |
| mRearrangeOnClose = true; |
| } else { |
| rearrangeChildren(); |
| clearDragInfo(); |
| } |
| } |
| |
| private void clearDragInfo() { |
| mCurrentDragView = null; |
| mIsExternalDrag = false; |
| } |
| |
| public void onDragExit(DragObject d) { |
| // We only close the folder if this is a true drag exit, ie. not because |
| // a drop has occurred above the folder. |
| if (!d.dragComplete) { |
| mOnExitAlarm.setOnAlarmListener(mOnExitAlarmListener); |
| mOnExitAlarm.setAlarm(ON_EXIT_CLOSE_DELAY); |
| } |
| mReorderAlarm.cancelAlarm(); |
| |
| mOnScrollHintAlarm.cancelAlarm(); |
| mScrollPauseAlarm.cancelAlarm(); |
| if (mScrollHintDir != SCROLL_NONE) { |
| mContent.clearScrollHint(); |
| mScrollHintDir = SCROLL_NONE; |
| } |
| } |
| |
| /** |
| * When performing an accessibility drop, onDrop is sent immediately after onDragEnter. So we |
| * need to complete all transient states based on timers. |
| */ |
| @Override |
| public void prepareAccessibilityDrop() { |
| if (mReorderAlarm.alarmPending()) { |
| mReorderAlarm.cancelAlarm(); |
| mReorderAlarmListener.onAlarm(mReorderAlarm); |
| } |
| } |
| |
| @Override |
| public void onDropCompleted(final View target, final DragObject d, |
| final boolean success) { |
| if (success) { |
| if (mDeleteFolderOnDropCompleted && !mItemAddedBackToSelfViaIcon && target != this) { |
| replaceFolderWithFinalItem(); |
| } |
| } else { |
| // The drag failed, we need to return the item to the folder |
| WorkspaceItemInfo info = (WorkspaceItemInfo) d.dragInfo; |
| View icon = (mCurrentDragView != null && mCurrentDragView.getTag() == info) |
| ? mCurrentDragView : mContent.createNewView(info); |
| ArrayList<View> views = getIconsInReadingOrder(); |
| info.rank = Utilities.boundToRange(info.rank, 0, views.size()); |
| views.add(info.rank, icon); |
| mContent.arrangeChildren(views); |
| mItemsInvalidated = true; |
| |
| try (SuppressInfoChanges s = new SuppressInfoChanges()) { |
| mFolderIcon.onDrop(d, true /* itemReturnedOnFailedDrop */); |
| } |
| } |
| |
| if (target != this) { |
| if (mOnExitAlarm.alarmPending()) { |
| mOnExitAlarm.cancelAlarm(); |
| if (!success) { |
| mSuppressFolderDeletion = true; |
| } |
| mScrollPauseAlarm.cancelAlarm(); |
| completeDragExit(); |
| } |
| } |
| |
| mDeleteFolderOnDropCompleted = false; |
| mDragInProgress = false; |
| mItemAddedBackToSelfViaIcon = false; |
| mCurrentDragView = null; |
| |
| // Reordering may have occured, and we need to save the new item locations. We do this once |
| // at the end to prevent unnecessary database operations. |
| updateItemLocationsInDatabaseBatch(false); |
| // Use the item count to check for multi-page as the folder UI may not have |
| // been refreshed yet. |
| if (getItemCount() <= mContent.itemsPerPage()) { |
| // Show the animation, next time something is added to the folder. |
| mInfo.setOption(FolderInfo.FLAG_MULTI_PAGE_ANIMATION, false, |
| mLauncherDelegate.getModelWriter()); |
| } |
| } |
| |
| private void updateItemLocationsInDatabaseBatch(boolean isBind) { |
| FolderGridOrganizer verifier = new FolderGridOrganizer( |
| mActivityContext.getDeviceProfile()).setFolderInfo(mInfo); |
| |
| ArrayList<ItemInfo> items = new ArrayList<>(); |
| int total = mInfo.contents.size(); |
| for (int i = 0; i < total; i++) { |
| WorkspaceItemInfo itemInfo = mInfo.contents.get(i); |
| if (verifier.updateRankAndPos(itemInfo, i)) { |
| items.add(itemInfo); |
| } |
| } |
| |
| if (!items.isEmpty()) { |
| mLauncherDelegate.getModelWriter().moveItemsInDatabase(items, mInfo.id, 0); |
| } |
| if (!isBind && total > 1 /* no need to update if there's one icon */) { |
| Executors.MODEL_EXECUTOR.post(() -> { |
| FolderNameInfos nameInfos = new FolderNameInfos(); |
| FolderNameProvider fnp = FolderNameProvider.newInstance(getContext()); |
| fnp.getSuggestedFolderName( |
| getContext(), mInfo.contents, nameInfos); |
| mInfo.suggestedFolderNames = nameInfos; |
| }); |
| } |
| } |
| |
| public void notifyDrop() { |
| if (mDragInProgress) { |
| mItemAddedBackToSelfViaIcon = true; |
| } |
| } |
| |
| public boolean isDropEnabled() { |
| return mState != STATE_ANIMATING; |
| } |
| |
| private void centerAboutIcon() { |
| BaseDragLayer.LayoutParams lp = (BaseDragLayer.LayoutParams) getLayoutParams(); |
| BaseDragLayer parent = mActivityContext.getDragLayer(); |
| int width = getFolderWidth(); |
| int height = getFolderHeight(); |
| |
| parent.getDescendantRectRelativeToSelf(mFolderIcon, sTempRect); |
| int centerX = sTempRect.centerX(); |
| int centerY = sTempRect.centerY(); |
| int centeredLeft = centerX - width / 2; |
| int centeredTop = centerY - height / 2; |
| |
| sTempRect.set(mActivityContext.getFolderBoundingBox()); |
| int left = Utilities.boundToRange(centeredLeft, sTempRect.left, sTempRect.right - width); |
| int top = Utilities.boundToRange(centeredTop, sTempRect.top, sTempRect.bottom - height); |
| int[] inOutPosition = new int[]{left, top}; |
| mActivityContext.updateOpenFolderPosition(inOutPosition, sTempRect, width, height); |
| left = inOutPosition[0]; |
| top = inOutPosition[1]; |
| |
| int folderPivotX = width / 2 + (centeredLeft - left); |
| int folderPivotY = height / 2 + (centeredTop - top); |
| setPivotX(folderPivotX); |
| setPivotY(folderPivotY); |
| |
| lp.width = width; |
| lp.height = height; |
| lp.x = left; |
| lp.y = top; |
| |
| mBackground.setBounds(0, 0, width, height); |
| } |
| |
| protected int getContentAreaHeight() { |
| DeviceProfile grid = mActivityContext.getDeviceProfile(); |
| int maxContentAreaHeight = grid.availableHeightPx - grid.getTotalWorkspacePadding().y |
| - mFooterHeight; |
| int height = Math.min(maxContentAreaHeight, |
| mContent.getDesiredHeight()); |
| return Math.max(height, MIN_CONTENT_DIMEN); |
| } |
| |
| private int getContentAreaWidth() { |
| return Math.max(mContent.getDesiredWidth(), MIN_CONTENT_DIMEN); |
| } |
| |
| private int getFolderWidth() { |
| return getPaddingLeft() + getPaddingRight() + mContent.getDesiredWidth(); |
| } |
| |
| private int getFolderHeight() { |
| return getFolderHeight(getContentAreaHeight()); |
| } |
| |
| private int getFolderHeight(int contentAreaHeight) { |
| return getPaddingTop() + getPaddingBottom() + contentAreaHeight + mFooterHeight; |
| } |
| |
| protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { |
| int contentWidth = getContentAreaWidth(); |
| int contentHeight = getContentAreaHeight(); |
| |
| int contentAreaWidthSpec = MeasureSpec.makeMeasureSpec(contentWidth, MeasureSpec.EXACTLY); |
| int contentAreaHeightSpec = MeasureSpec.makeMeasureSpec(contentHeight, MeasureSpec.EXACTLY); |
| |
| mContent.setFixedSize(contentWidth, contentHeight); |
| mContent.measure(contentAreaWidthSpec, contentAreaHeightSpec); |
| |
| mFooter.measure(contentAreaWidthSpec, |
| MeasureSpec.makeMeasureSpec(mFooterHeight, MeasureSpec.EXACTLY)); |
| |
| int folderWidth = getPaddingLeft() + getPaddingRight() + contentWidth; |
| int folderHeight = getFolderHeight(contentHeight); |
| setMeasuredDimension(folderWidth, folderHeight); |
| } |
| |
| /** |
| * Rearranges the children based on their rank. |
| */ |
| public void rearrangeChildren() { |
| if (!mContent.areViewsBound()) { |
| return; |
| } |
| mContent.arrangeChildren(getIconsInReadingOrder()); |
| mItemsInvalidated = true; |
| } |
| |
| public int getItemCount() { |
| return mInfo.contents.size(); |
| } |
| |
| void replaceFolderWithFinalItem() { |
| mDestroyed = mLauncherDelegate.replaceFolderWithFinalItem(this); |
| } |
| |
| public boolean isDestroyed() { |
| return mDestroyed; |
| } |
| |
| // This method keeps track of the first and last item in the folder for the purposes |
| // of keyboard focus |
| public void updateTextViewFocus() { |
| final View firstChild = mContent.getFirstItem(); |
| final View lastChild = mContent.getLastItem(); |
| if (firstChild != null && lastChild != null) { |
| mFolderName.setNextFocusDownId(lastChild.getId()); |
| mFolderName.setNextFocusRightId(lastChild.getId()); |
| mFolderName.setNextFocusLeftId(lastChild.getId()); |
| mFolderName.setNextFocusUpId(lastChild.getId()); |
| // Hitting TAB from the folder name wraps around to the first item on the current |
| // folder page, and hitting SHIFT+TAB from that item wraps back to the folder name. |
| mFolderName.setNextFocusForwardId(firstChild.getId()); |
| // When clicking off the folder when editing the name, this Folder gains focus. When |
| // pressing an arrow key from that state, give the focus to the first item. |
| this.setNextFocusDownId(firstChild.getId()); |
| this.setNextFocusRightId(firstChild.getId()); |
| this.setNextFocusLeftId(firstChild.getId()); |
| this.setNextFocusUpId(firstChild.getId()); |
| // When pressing shift+tab in the above state, give the focus to the last item. |
| setOnKeyListener(new OnKeyListener() { |
| @Override |
| public boolean onKey(View v, int keyCode, KeyEvent event) { |
| boolean isShiftPlusTab = keyCode == KeyEvent.KEYCODE_TAB && |
| event.hasModifiers(KeyEvent.META_SHIFT_ON); |
| if (isShiftPlusTab && Folder.this.isFocused()) { |
| return lastChild.requestFocus(); |
| } |
| return false; |
| } |
| }); |
| } else { |
| setOnKeyListener(null); |
| } |
| } |
| |
| @Override |
| public void onDrop(DragObject d, DragOptions options) { |
| // If the icon was dropped while the page was being scrolled, we need to compute |
| // the target location again such that the icon is placed of the final page. |
| if (!mContent.rankOnCurrentPage(mEmptyCellRank)) { |
| // Reorder again. |
| mTargetRank = getTargetRank(d, null); |
| |
| // Rearrange items immediately. |
| mReorderAlarmListener.onAlarm(mReorderAlarm); |
| |
| mOnScrollHintAlarm.cancelAlarm(); |
| mScrollPauseAlarm.cancelAlarm(); |
| } |
| mContent.completePendingPageChanges(); |
| Launcher launcher = mLauncherDelegate.getLauncher(); |
| if (launcher == null) { |
| return; |
| } |
| |
| PendingAddShortcutInfo pasi = d.dragInfo instanceof PendingAddShortcutInfo |
| ? (PendingAddShortcutInfo) d.dragInfo : null; |
| WorkspaceItemInfo pasiSi = |
| pasi != null ? pasi.getActivityInfo(launcher).createWorkspaceItemInfo() : null; |
| if (pasi != null && pasiSi == null) { |
| // There is no WorkspaceItemInfo, so we have to go through a configuration activity. |
| pasi.container = mInfo.id; |
| pasi.rank = mEmptyCellRank; |
| |
| launcher.addPendingItem(pasi, pasi.container, pasi.screenId, null, pasi.spanX, |
| pasi.spanY); |
| d.deferDragViewCleanupPostAnimation = false; |
| mRearrangeOnClose = true; |
| } else { |
| final WorkspaceItemInfo si; |
| if (pasiSi != null) { |
| si = pasiSi; |
| } else if (d.dragInfo instanceof WorkspaceItemFactory) { |
| // Came from all apps -- make a copy. |
| si = ((WorkspaceItemFactory) d.dragInfo).makeWorkspaceItem(launcher); |
| } else { |
| // WorkspaceItemInfo |
| si = (WorkspaceItemInfo) d.dragInfo; |
| } |
| |
| View currentDragView; |
| if (mIsExternalDrag) { |
| currentDragView = mContent.createAndAddViewForRank(si, mEmptyCellRank); |
| |
| // Actually move the item in the database if it was an external drag. Call this |
| // before creating the view, so that WorkspaceItemInfo is updated appropriately. |
| mLauncherDelegate.getModelWriter().addOrMoveItemInDatabase( |
| si, mInfo.id, 0, si.cellX, si.cellY); |
| mIsExternalDrag = false; |
| } else { |
| currentDragView = mCurrentDragView; |
| mContent.addViewForRank(currentDragView, si, mEmptyCellRank); |
| } |
| |
| if (d.dragView.hasDrawn()) { |
| // Temporarily reset the scale such that the animation target gets calculated |
| // correctly. |
| float scaleX = getScaleX(); |
| float scaleY = getScaleY(); |
| setScaleX(1.0f); |
| setScaleY(1.0f); |
| launcher.getDragLayer().animateViewIntoPosition(d.dragView, currentDragView, null); |
| setScaleX(scaleX); |
| setScaleY(scaleY); |
| } else { |
| d.deferDragViewCleanupPostAnimation = false; |
| currentDragView.setVisibility(VISIBLE); |
| } |
| |
| mItemsInvalidated = true; |
| rearrangeChildren(); |
| |
| // Temporarily suppress the listener, as we did all the work already here. |
| try (SuppressInfoChanges s = new SuppressInfoChanges()) { |
| mInfo.add(si, mEmptyCellRank, false); |
| } |
| |
| // We only need to update the locations if it doesn't get handled in |
| // #onDropCompleted. |
| if (d.dragSource != this) { |
| updateItemLocationsInDatabaseBatch(false); |
| } |
| } |
| |
| // Clear the drag info, as it is no longer being dragged. |
| mDragInProgress = false; |
| |
| if (mContent.getPageCount() > 1) { |
| // The animation has already been shown while opening the folder. |
| mInfo.setOption(FolderInfo.FLAG_MULTI_PAGE_ANIMATION, true, |
| mLauncherDelegate.getModelWriter()); |
| } |
| |
| if (!launcher.isInState(EDIT_MODE)) { |
| launcher.getStateManager().goToState(NORMAL, SPRING_LOADED_EXIT_DELAY); |
| } |
| |
| if (d.stateAnnouncer != null) { |
| d.stateAnnouncer.completeAction(R.string.item_moved); |
| } |
| mStatsLogManager.logger().withItemInfo(d.dragInfo).withInstanceId(d.logInstanceId) |
| .log(LAUNCHER_ITEM_DROP_COMPLETED); |
| } |
| |
| // This is used so the item doesn't immediately appear in the folder when added. In one case |
| // we need to create the illusion that the item isn't added back to the folder yet, to |
| // to correspond to the animation of the icon back into the folder. This is |
| public void hideItem(WorkspaceItemInfo info) { |
| View v = getViewForInfo(info); |
| if (v != null) { |
| v.setVisibility(INVISIBLE); |
| } |
| } |
| |
| public void showItem(WorkspaceItemInfo info) { |
| View v = getViewForInfo(info); |
| if (v != null) { |
| v.setVisibility(VISIBLE); |
| } |
| } |
| |
| @Override |
| public void onAdd(WorkspaceItemInfo item, int rank) { |
| FolderGridOrganizer verifier = new FolderGridOrganizer( |
| mActivityContext.getDeviceProfile()).setFolderInfo(mInfo); |
| verifier.updateRankAndPos(item, rank); |
| mLauncherDelegate.getModelWriter().addOrMoveItemInDatabase(item, mInfo.id, 0, item.cellX, |
| item.cellY); |
| updateItemLocationsInDatabaseBatch(false); |
| |
| if (mContent.areViewsBound()) { |
| mContent.createAndAddViewForRank(item, rank); |
| } |
| mItemsInvalidated = true; |
| } |
| |
| @Override |
| public void onRemove(List<WorkspaceItemInfo> items) { |
| mItemsInvalidated = true; |
| items.stream().map(this::getViewForInfo).forEach(mContent::removeItem); |
| if (mState == STATE_ANIMATING) { |
| mRearrangeOnClose = true; |
| } else { |
| rearrangeChildren(); |
| } |
| if (getItemCount() <= 1) { |
| if (mIsOpen) { |
| close(true); |
| } else { |
| replaceFolderWithFinalItem(); |
| } |
| } |
| } |
| |
| private View getViewForInfo(final WorkspaceItemInfo item) { |
| return mContent.iterateOverItems((info, view) -> info == item); |
| } |
| |
| @Override |
| public void onItemsChanged(boolean animate) { |
| updateTextViewFocus(); |
| } |
| |
| /** |
| * Utility methods to iterate over items of the view |
| */ |
| public void iterateOverItems(ItemOperator op) { |
| mContent.iterateOverItems(op); |
| } |
| |
| /** |
| * Returns the sorted list of all the icons in the folder |
| */ |
| public ArrayList<View> getIconsInReadingOrder() { |
| if (mItemsInvalidated) { |
| mItemsInReadingOrder.clear(); |
| mContent.iterateOverItems((i, v) -> !mItemsInReadingOrder.add(v)); |
| mItemsInvalidated = false; |
| } |
| return mItemsInReadingOrder; |
| } |
| |
| public List<BubbleTextView> getItemsOnPage(int page) { |
| ArrayList<View> allItems = getIconsInReadingOrder(); |
| int lastPage = mContent.getPageCount() - 1; |
| int totalItemsInFolder = allItems.size(); |
| int itemsPerPage = mContent.itemsPerPage(); |
| int numItemsOnCurrentPage = page == lastPage |
| ? totalItemsInFolder - (itemsPerPage * page) |
| : itemsPerPage; |
| |
| int startIndex = page * itemsPerPage; |
| int endIndex = Math.min(startIndex + numItemsOnCurrentPage, allItems.size()); |
| |
| List<BubbleTextView> itemsOnCurrentPage = new ArrayList<>(numItemsOnCurrentPage); |
| for (int i = startIndex; i < endIndex; ++i) { |
| itemsOnCurrentPage.add((BubbleTextView) allItems.get(i)); |
| } |
| return itemsOnCurrentPage; |
| } |
| |
| @Override |
| public void onFocusChange(View v, boolean hasFocus) { |
| if (v == mFolderName) { |
| if (hasFocus) { |
| mFromLabelState = mInfo.getFromLabelState(); |
| mFromTitle = mInfo.title; |
| startEditingFolderName(); |
| } else { |
| StatsLogger statsLogger = mStatsLogManager.logger() |
| .withItemInfo(mInfo) |
| .withFromState(mFromLabelState); |
| |
| // If the folder label is suggested, it is logged to improve prediction model. |
| // When both old and new labels are logged together delimiter is used. |
| StringJoiner labelInfoBuilder = new StringJoiner(FOLDER_LABEL_DELIMITER); |
| if (mFromLabelState.equals(FromState.FROM_SUGGESTED)) { |
| labelInfoBuilder.add(mFromTitle); |
| } |
| |
| ToState toLabelState; |
| if (mFromTitle != null && mFromTitle.equals(mInfo.title)) { |
| toLabelState = ToState.UNCHANGED; |
| } else { |
| toLabelState = mInfo.getToLabelState(); |
| if (toLabelState.toString().startsWith("TO_SUGGESTION")) { |
| labelInfoBuilder.add(mInfo.title); |
| } |
| } |
| statsLogger.withToState(toLabelState); |
| |
| if (labelInfoBuilder.length() > 0) { |
| statsLogger.withEditText(labelInfoBuilder.toString()); |
| } |
| |
| statsLogger.log(LAUNCHER_FOLDER_LABEL_UPDATED); |
| mFolderName.dispatchBackKey(); |
| } |
| } |
| } |
| |
| @Override |
| public void getHitRectRelativeToDragLayer(Rect outRect) { |
| getHitRect(outRect); |
| outRect.left -= mScrollAreaOffset; |
| outRect.right += mScrollAreaOffset; |
| } |
| |
| private class OnScrollHintListener implements OnAlarmListener { |
| |
| private final DragObject mDragObject; |
| |
| OnScrollHintListener(DragObject object) { |
| mDragObject = object; |
| } |
| |
| /** |
| * Scroll hint has been shown long enough. Now scroll to appropriate page. |
| */ |
| @Override |
| public void onAlarm(Alarm alarm) { |
| if (mCurrentScrollDir == SCROLL_LEFT) { |
| mContent.scrollLeft(); |
| mScrollHintDir = SCROLL_NONE; |
| } else if (mCurrentScrollDir == SCROLL_RIGHT) { |
| mContent.scrollRight(); |
| mScrollHintDir = SCROLL_NONE; |
| } else { |
| // This should not happen |
| return; |
| } |
| mCurrentScrollDir = SCROLL_NONE; |
| |
| // Pause drag event until the scrolling is finished |
| mScrollPauseAlarm.setOnAlarmListener(new OnScrollFinishedListener(mDragObject)); |
| int rescrollDelay = getResources().getInteger( |
| R.integer.config_pageSnapAnimationDuration) + RESCROLL_EXTRA_DELAY; |
| mScrollPauseAlarm.setAlarm(rescrollDelay); |
| } |
| } |
| |
| private class OnScrollFinishedListener implements OnAlarmListener { |
| |
| private final DragObject mDragObject; |
| |
| OnScrollFinishedListener(DragObject object) { |
| mDragObject = object; |
| } |
| |
| /** |
| * Page scroll is complete. |
| */ |
| @Override |
| public void onAlarm(Alarm alarm) { |
| // Reorder immediately on page change. |
| onDragOver(mDragObject); |
| } |
| } |
| |
| // Compares item position based on rank and position giving priority to the rank. |
| public static final Comparator<ItemInfo> ITEM_POS_COMPARATOR = new Comparator<ItemInfo>() { |
| |
| @Override |
| public int compare(ItemInfo lhs, ItemInfo rhs) { |
| if (lhs.rank != rhs.rank) { |
| return lhs.rank - rhs.rank; |
| } else if (lhs.cellY != rhs.cellY) { |
| return lhs.cellY - rhs.cellY; |
| } else { |
| return lhs.cellX - rhs.cellX; |
| } |
| } |
| }; |
| |
| /** |
| * Temporary resource held while we don't want to handle info changes |
| */ |
| private class SuppressInfoChanges implements AutoCloseable { |
| |
| SuppressInfoChanges() { |
| mInfo.removeListener(Folder.this); |
| } |
| |
| @Override |
| public void close() { |
| mInfo.addListener(Folder.this); |
| updateTextViewFocus(); |
| } |
| } |
| |
| /** |
| * Returns a folder which is already open or null |
| */ |
| public static Folder getOpen(ActivityContext activityContext) { |
| return getOpenView(activityContext, TYPE_FOLDER); |
| } |
| |
| /** Navigation bar back key or hardware input back key has been issued. */ |
| @Override |
| public void onBackInvoked() { |
| if (isEditingName()) { |
| mFolderName.dispatchBackKey(); |
| } else { |
| super.onBackInvoked(); |
| } |
| } |
| |
| @Override |
| public boolean onControllerInterceptTouchEvent(MotionEvent ev) { |
| if (ev.getAction() == MotionEvent.ACTION_DOWN) { |
| BaseDragLayer dl = (BaseDragLayer) getParent(); |
| |
| if (isEditingName()) { |
| if (!dl.isEventOverView(mFolderName, ev)) { |
| mFolderName.dispatchBackKey(); |
| return true; |
| } |
| return false; |
| } else if (!dl.isEventOverView(this, ev) |
| && mLauncherDelegate.interceptOutsideTouch(ev, dl, this)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean canInterceptEventsInSystemGestureRegion() { |
| return true; |
| } |
| |
| /** |
| * Alternative to using {@link #getClipToOutline()} as it only works with derivatives of |
| * rounded rect. |
| */ |
| @Override |
| public void setClipPath(Path clipPath) { |
| mClipPath = clipPath; |
| invalidate(); |
| } |
| |
| @Override |
| protected void dispatchDraw(Canvas canvas) { |
| if (mClipPath != null) { |
| int count = canvas.save(); |
| canvas.clipPath(mClipPath); |
| mBackground.draw(canvas); |
| canvas.restoreToCount(count); |
| super.dispatchDraw(canvas); |
| } else { |
| mBackground.draw(canvas); |
| super.dispatchDraw(canvas); |
| } |
| } |
| |
| public FolderPagedView getContent() { |
| return mContent; |
| } |
| |
| /** Returns the height of the current folder's bottom edge from the bottom of the screen. */ |
| private int getHeightFromBottom() { |
| BaseDragLayer.LayoutParams layoutParams = (BaseDragLayer.LayoutParams) getLayoutParams(); |
| int folderBottomPx = layoutParams.y + layoutParams.height; |
| int windowBottomPx = mActivityContext.getDeviceProfile().heightPx; |
| |
| return windowBottomPx - folderBottomPx; |
| } |
| |
| /** |
| * Save this listener for the special case of when we update the state and concurrently |
| * add another listener to {@link #mOnFolderStateChangedListeners} to avoid a |
| * ConcurrentModificationException |
| */ |
| public void setPriorityOnFolderStateChangedListener(OnFolderStateChangedListener listener) { |
| mPriorityOnFolderStateChangedListener = listener; |
| } |
| |
| private void setState(@FolderState int newState) { |
| mState = newState; |
| if (mPriorityOnFolderStateChangedListener != null) { |
| mPriorityOnFolderStateChangedListener.onFolderStateChanged(mState); |
| } |
| for (OnFolderStateChangedListener listener : mOnFolderStateChangedListeners) { |
| if (listener != null) { |
| listener.onFolderStateChanged(mState); |
| } |
| } |
| } |
| |
| /** |
| * Adds the provided listener to the running list of Folder listeners |
| * {@link #mOnFolderStateChangedListeners} |
| */ |
| public void addOnFolderStateChangedListener(@Nullable OnFolderStateChangedListener listener) { |
| if (listener != null) { |
| mOnFolderStateChangedListeners.add(listener); |
| } |
| } |
| |
| /** Removes the provided listener from the running list of Folder listeners */ |
| public void removeOnFolderStateChangedListener(OnFolderStateChangedListener listener) { |
| mOnFolderStateChangedListeners.remove(listener); |
| } |
| |
| /** Listener that can be registered via {@link #addOnFolderStateChangedListener} */ |
| public interface OnFolderStateChangedListener { |
| /** See {@link Folder.FolderState} */ |
| void onFolderStateChanged(@FolderState int newState); |
| } |
| } |