diff --git a/lawnchair/res/color/edit_mode_page_strip_home_tint.xml b/lawnchair/res/color/edit_mode_page_strip_home_tint.xml new file mode 100644 index 0000000000..39e73dacfb --- /dev/null +++ b/lawnchair/res/color/edit_mode_page_strip_home_tint.xml @@ -0,0 +1,7 @@ + + + + + diff --git a/lawnchair/res/drawable/bg_edit_mode_page_strip_item.xml b/lawnchair/res/drawable/bg_edit_mode_page_strip_item.xml new file mode 100644 index 0000000000..818e035bce --- /dev/null +++ b/lawnchair/res/drawable/bg_edit_mode_page_strip_item.xml @@ -0,0 +1,9 @@ + + + + + diff --git a/lawnchair/res/drawable/bg_edit_mode_page_strip_item_default.xml b/lawnchair/res/drawable/bg_edit_mode_page_strip_item_default.xml new file mode 100644 index 0000000000..5363cfd490 --- /dev/null +++ b/lawnchair/res/drawable/bg_edit_mode_page_strip_item_default.xml @@ -0,0 +1,9 @@ + + + + + + diff --git a/lawnchair/res/drawable/bg_edit_mode_page_strip_item_unselected.xml b/lawnchair/res/drawable/bg_edit_mode_page_strip_item_unselected.xml new file mode 100644 index 0000000000..ef8fcbd551 --- /dev/null +++ b/lawnchair/res/drawable/bg_edit_mode_page_strip_item_unselected.xml @@ -0,0 +1,9 @@ + + + + + + diff --git a/lawnchair/res/layout/edit_mode_page_strip_item.xml b/lawnchair/res/layout/edit_mode_page_strip_item.xml new file mode 100644 index 0000000000..f190e0607d --- /dev/null +++ b/lawnchair/res/layout/edit_mode_page_strip_item.xml @@ -0,0 +1,36 @@ + + + + + + + + diff --git a/lawnchair/res/layout/launcher.xml b/lawnchair/res/layout/launcher.xml new file mode 100644 index 0000000000..db1bebcc0e --- /dev/null +++ b/lawnchair/res/layout/launcher.xml @@ -0,0 +1,95 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/lawnchair/res/values/dimens.xml b/lawnchair/res/values/dimens.xml index 32232bc807..b518d0b39f 100644 --- a/lawnchair/res/values/dimens.xml +++ b/lawnchair/res/values/dimens.xml @@ -28,6 +28,11 @@ 24dp + + 88dp + 8dp + 8dp + 36dp 30dp diff --git a/lawnchair/res/values/strings.xml b/lawnchair/res/values/strings.xml index aa7f12d5d1..c5c7ea695c 100644 --- a/lawnchair/res/values/strings.xml +++ b/lawnchair/res/values/strings.xml @@ -692,6 +692,14 @@ Set as default page Default home page updated + Move page left + Move page right + Page order updated + Default + Page %1$d + Set as home page + Default home page + Drag pages to reorder. Tap the home icon to set your default page. Pop-up menu Pop-up menu items diff --git a/lawnchair/src/app/lawnchair/views/EditModePageStrip.kt b/lawnchair/src/app/lawnchair/views/EditModePageStrip.kt new file mode 100644 index 0000000000..2a1f23ff1e --- /dev/null +++ b/lawnchair/src/app/lawnchair/views/EditModePageStrip.kt @@ -0,0 +1,321 @@ +package app.lawnchair.views + +import android.content.Context +import android.util.AttributeSet +import android.view.LayoutInflater +import android.view.View +import android.view.View.GONE +import android.view.View.VISIBLE +import android.view.ViewGroup +import android.widget.ImageButton +import android.widget.TextView +import androidx.recyclerview.widget.DefaultItemAnimator +import androidx.recyclerview.widget.ItemTouchHelper +import androidx.recyclerview.widget.LinearLayoutManager +import androidx.recyclerview.widget.RecyclerView +import com.android.app.animation.Interpolators +import com.android.launcher3.Launcher +import com.android.launcher3.LauncherPrefs +import com.android.launcher3.R +import com.android.launcher3.Utilities +import com.android.launcher3.Workspace +import com.android.launcher3.util.IntArray +import com.android.launcher3.util.OnboardingPrefs +import com.android.launcher3.views.ArrowTipView + +class EditModePageStrip @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null, + defStyleAttr: Int = 0, +) : RecyclerView(context, attrs, defStyleAttr) { + + private val pageStripAdapter = PageStripAdapter() + private var workspace: Workspace<*>? = null + private var educationTip: ArrowTipView? = null + private val showEducationTipRunnable = Runnable { showEducationTipIfNeeded() } + + init { + layoutManager = LinearLayoutManager(context, HORIZONTAL, false) + overScrollMode = OVER_SCROLL_NEVER + itemAnimator = DefaultItemAnimator().apply { + moveDuration = 200 + changeDuration = 150 + supportsChangeAnimations = true + } + adapter = pageStripAdapter + ItemTouchHelper(DragCallback()).attachToRecyclerView(this) + } + + fun bindWorkspace(workspace: Workspace<*>) { + this.workspace = workspace + refreshItems() + } + + fun showForEditMode(workspace: Workspace<*>, duration: Long) { + cancelVisibilityAnimation() + bindWorkspace(workspace) + if (duration <= 0) { + applyVisibleState() + return + } + val offset = stripSlideOffset() + visibility = VISIBLE + alpha = 0f + translationY = offset + animate() + .alpha(1f) + .translationY(0f) + .setDuration(duration) + .setInterpolator(Interpolators.DECELERATE_2) + .start() + } + + fun maybeShowEducationTip(launcher: Launcher) { + if (OnboardingPrefs.EDIT_MODE_PAGE_STRIP_TIP_SEEN.get(launcher)) { + return + } + if (visibility != VISIBLE) { + return + } + removeCallbacks(showEducationTipRunnable) + postDelayed(showEducationTipRunnable, 150) + } + + fun dismissEducationTip() { + removeCallbacks(showEducationTipRunnable) + educationTip?.close(true) + educationTip = null + } + + private fun showEducationTipIfNeeded() { + if (visibility != VISIBLE || width == 0) { + return + } + val launcher = context as? Launcher ?: return + if (OnboardingPrefs.EDIT_MODE_PAGE_STRIP_TIP_SEEN.get(launcher)) { + return + } + val bounds = Utilities.getViewBounds(this) + val margin = resources.getDimensionPixelSize(R.dimen.edit_mode_page_strip_tip_margin) + val tip = + ArrowTipView(launcher, false).showAtLocation( + resources.getString(R.string.edit_mode_page_strip_tip), + bounds.centerX(), + bounds.top - margin, + ) ?: return + educationTip = tip + LauncherPrefs.get(launcher).put(OnboardingPrefs.EDIT_MODE_PAGE_STRIP_TIP_SEEN, true) + } + + fun hideForEditMode(duration: Long) { + dismissEducationTip() + cancelVisibilityAnimation() + if (duration <= 0) { + applyHiddenState() + return + } + val offset = stripSlideOffset() + animate() + .alpha(0f) + .translationY(offset) + .setDuration(duration) + .setInterpolator(Interpolators.ACCELERATE) + .withEndAction { applyHiddenState() } + .start() + } + + private fun cancelVisibilityAnimation() { + animate().cancel() + } + + private fun stripSlideOffset(): Float { + if (height > 0) { + return height.toFloat() + } + return resources.getDimension(R.dimen.edit_mode_page_strip_height) + } + + private fun applyVisibleState() { + visibility = VISIBLE + alpha = 1f + translationY = 0f + } + + private fun applyHiddenState() { + visibility = GONE + alpha = 1f + translationY = 0f + } + + fun refreshItems() { + val ws = workspace + if (ws == null) { + pageStripAdapter.setItems(emptyList()) + return + } + val starts = ws.reorderablePageGroupStarts + val defaultGroupIndex = ws.defaultPageGroupIndex + val items = (0 until starts.size()).map { i -> + PageItem(isDefault = i == defaultGroupIndex) + } + pageStripAdapter.setItems(items) + } + + private fun moveGroup(from: Int, to: Int): Boolean { + val ws = workspace ?: return false + if (!ws.moveReorderablePageGroup(from, to)) { + return false + } + pageStripAdapter.moveItem(from, to) + return true + } + + private fun setHomeGroup(position: Int): Boolean { + val ws = workspace ?: return false + val oldDefaultIndex = pageStripAdapter.indexOfDefault() + val set = ws.setDefaultPageForReorderableGroup(position) + if (!set) { + return false + } + pageStripAdapter.updateDefaultHome(oldDefaultIndex, position) + dismissEducationTip() + return true + } + + private fun resetDragView(view: View) { + view.animate() + .scaleX(1f) + .scaleY(1f) + .translationZ(0f) + .setDuration(150) + .start() + } + + private inner class DragCallback : + ItemTouchHelper.SimpleCallback( + ItemTouchHelper.LEFT or ItemTouchHelper.RIGHT, + 0, + ) { + override fun isLongPressDragEnabled(): Boolean = true + + override fun onMove( + recyclerView: RecyclerView, + viewHolder: ViewHolder, + target: ViewHolder, + ): Boolean { + val from = viewHolder.bindingAdapterPosition + val to = target.bindingAdapterPosition + if (from == NO_POSITION || to == NO_POSITION) { + return false + } + return moveGroup(from, to) + } + + override fun onSwiped(viewHolder: ViewHolder, direction: Int) { + // No-op. + } + + override fun onSelectedChanged(viewHolder: ViewHolder?, actionState: Int) { + val itemView = viewHolder?.itemView ?: return + when (actionState) { + ItemTouchHelper.ACTION_STATE_DRAG -> { + dismissEducationTip() + itemView.animate() + .scaleX(1.05f) + .scaleY(1.05f) + .translationZ(8f) + .setDuration(150) + .start() + } + + else -> resetDragView(itemView) + } + } + + override fun clearView(recyclerView: RecyclerView, viewHolder: ViewHolder) { + super.clearView(recyclerView, viewHolder) + resetDragView(viewHolder.itemView) + } + } + + private inner class PageStripAdapter : Adapter() { + private val items = mutableListOf() + + fun setItems(newItems: List) { + items.clear() + items.addAll(newItems) + notifyDataSetChanged() + } + + fun moveItem(from: Int, to: Int) { + if (from == to || from !in items.indices || to !in items.indices) { + return + } + val item = items.removeAt(from) + items.add(to, item) + notifyItemMoved(from, to) + val start = minOf(from, to) + notifyItemRangeChanged(start, maxOf(from, to) - start + 1) + } + + fun indexOfDefault(): Int = items.indexOfFirst { it.isDefault } + + fun updateDefaultHome(oldIndex: Int, newIndex: Int) { + if (oldIndex in items.indices) { + items[oldIndex] = items[oldIndex].copy(isDefault = false) + notifyItemChanged(oldIndex) + } + if (newIndex in items.indices) { + items[newIndex] = items[newIndex].copy(isDefault = true) + notifyItemChanged(newIndex) + } + } + + override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PageStripViewHolder { + val view = LayoutInflater.from(parent.context) + .inflate(R.layout.edit_mode_page_strip_item, parent, false) + return PageStripViewHolder(view) + } + + override fun onBindViewHolder(holder: PageStripViewHolder, position: Int) { + val item = items[position] + holder.itemView.isSelected = item.isDefault + holder.title.text = if (item.isDefault) { + resources.getString(R.string.edit_mode_page_strip_default) + } else { + resources.getString(R.string.edit_mode_page_strip_page, position + 1) + } + holder.homeButton.isSelected = item.isDefault + holder.homeButton.contentDescription = if (item.isDefault) { + resources.getString(R.string.edit_mode_page_strip_home_selected) + } else { + resources.getString(R.string.edit_mode_page_strip_set_home) + } + holder.homeButton.setOnClickListener { + val index = holder.bindingAdapterPosition + if (index != NO_POSITION) { + setHomeGroup(index) + } + } + holder.itemView.setOnClickListener { + val ws = workspace ?: return@setOnClickListener + val starts = ws.reorderablePageGroupStarts + val index = holder.bindingAdapterPosition + if (index in 0 until starts.size()) { + ws.snapToPage(starts[index]) + } + } + } + + override fun getItemCount(): Int = items.size + } + + private class PageStripViewHolder(itemView: View) : ViewHolder(itemView) { + val title: TextView = itemView.findViewById(R.id.page_strip_title) + val homeButton: ImageButton = itemView.findViewById(R.id.page_strip_home_button) + } + + private data class PageItem( + val isDefault: Boolean, + ) +} diff --git a/src/com/android/launcher3/Launcher.java b/src/com/android/launcher3/Launcher.java index a1b5c6b978..02a6572575 100644 --- a/src/com/android/launcher3/Launcher.java +++ b/src/com/android/launcher3/Launcher.java @@ -252,6 +252,7 @@ import com.android.launcher3.util.WallpaperThemeManager; import com.android.launcher3.views.FloatingIconView; import com.android.launcher3.views.FloatingSurfaceView; import com.android.launcher3.views.OptionsPopupView; +import app.lawnchair.views.EditModePageStrip; import com.android.launcher3.views.ScrimView; import com.android.launcher3.widget.LauncherAppWidgetHostView; import com.android.launcher3.widget.LauncherAppWidgetProviderInfo; @@ -364,6 +365,7 @@ public class Launcher extends StatefulActivity // UI and state for the overview panel private View mOverviewPanel; + private EditModePageStrip mEditModePageStrip; // Used to notify when an activity launch has been deferred because launcher is not yet resumed // TODO: See if we can remove this later @@ -1307,6 +1309,28 @@ public class Launcher extends StatefulActivity mDragLayer = findViewById(R.id.drag_layer); mFocusHandler = mDragLayer.getFocusIndicatorHelper(); mWorkspace = mDragLayer.findViewById(R.id.workspace); + mEditModePageStrip = mDragLayer.findViewById(R.id.edit_mode_page_strip); + if (mEditModePageStrip != null) { + mStateManager.addStateListener(new StateManager.StateListener() { + @Override + public void onStateTransitionStart(LauncherState toState) { + if (toState == EDIT_MODE) { + long duration = EDIT_MODE.getTransitionDuration(Launcher.this, true); + mEditModePageStrip.showForEditMode(mWorkspace, duration); + } else if (mStateManager.getCurrentStableState() == EDIT_MODE) { + long duration = EDIT_MODE.getTransitionDuration(Launcher.this, false); + mEditModePageStrip.hideForEditMode(duration); + } + } + + @Override + public void onStateTransitionComplete(LauncherState finalState) { + if (finalState == EDIT_MODE) { + mEditModePageStrip.maybeShowEducationTip(Launcher.this); + } + } + }); + } mWorkspace.initParentViews(mDragLayer); mOverviewPanel = findViewById(R.id.overview_panel); mHotseat = findViewById(R.id.hotseat); diff --git a/src/com/android/launcher3/LauncherPrefs.kt b/src/com/android/launcher3/LauncherPrefs.kt index d167201193..a0069e44ea 100644 --- a/src/com/android/launcher3/LauncherPrefs.kt +++ b/src/com/android/launcher3/LauncherPrefs.kt @@ -282,6 +282,7 @@ constructor(@ApplicationContext private val encryptedContext: Context) { nonRestorableItem(FIRST_LOAD_AFTER_RESTORE_KEY, false, EncryptionType.ENCRYPTED) @JvmField val APP_WIDGET_IDS = backedUpItem(RestoreDbTask.APPWIDGET_IDS, "") @JvmField val OLD_APP_WIDGET_IDS = backedUpItem(RestoreDbTask.APPWIDGET_OLD_IDS, "") + @JvmField val WORKSPACE_SCREEN_ORDER = backedUpItem("workspace_screen_order", "") @JvmField val GRID_NAME = diff --git a/src/com/android/launcher3/ModelCallbacks.kt b/src/com/android/launcher3/ModelCallbacks.kt index ead4f584f1..8b16da0121 100644 --- a/src/com/android/launcher3/ModelCallbacks.kt +++ b/src/com/android/launcher3/ModelCallbacks.kt @@ -231,7 +231,6 @@ class ModelCallbacks(private var launcher: Launcher) : BgDataModel.Callbacks { bindItems(it, false) } } - workspace.stripEmptyScreens() } /** @@ -292,15 +291,15 @@ class ModelCallbacks(private var launcher: Launcher) : BgDataModel.Callbacks { /*pause=*/ true, launcher.deviceProfile.deviceProperties.isTwoPanels, ) - val firstScreenPosition = 0 - if (orderedScreenIds.indexOf(FIRST_SCREEN_ID) != firstScreenPosition) { - orderedScreenIds.removeValue(FIRST_SCREEN_ID) - orderedScreenIds.add(firstScreenPosition, FIRST_SCREEN_ID) - } else if (orderedScreenIds.isEmpty) { + if (orderedScreenIds.isEmpty) { // If there are no screens, we need to have an empty screen launcher.workspace.addExtraEmptyScreens() + } else if (orderedScreenIds.indexOf(FIRST_SCREEN_ID) < 0) { + // Keep persisted order stable; only add FIRST_SCREEN_ID if missing. + orderedScreenIds.add(0, FIRST_SCREEN_ID) } bindAddScreens(orderedScreenIds) + launcher.workspace.reorderBoundWorkspaceScreens(orderedScreenIds) // After we have added all the screens, if the wallpaper was locked to the default state, // then notify to indicate that it can be released and a proper wallpaper offset can be diff --git a/src/com/android/launcher3/Workspace.java b/src/com/android/launcher3/Workspace.java index c5a5e30e85..9c98f4c60f 100644 --- a/src/com/android/launcher3/Workspace.java +++ b/src/com/android/launcher3/Workspace.java @@ -61,6 +61,7 @@ import android.os.Parcelable; import android.util.AttributeSet; import android.util.Log; import android.util.SparseArray; +import android.util.SparseIntArray; import android.view.HapticFeedbackConstants; import android.view.Gravity; import android.view.LayoutInflater; @@ -253,6 +254,8 @@ public class Workspace extends PagedView boolean mChildrenLayersEnabled = true; private boolean mStripScreensOnPageStopMoving = false; + + private boolean mDeferStripEmptyScreensForScreenRemap = false; public boolean mHasOnLayoutBeenCalled = false; private boolean mWorkspaceFadeInAdjacentScreens; @@ -702,7 +705,7 @@ public class Workspace extends PagedView mScreenOrder.clear(); mWorkspaceScreens.clear(); - // Ensure that the first page is always present + // Ensure there is always at least one page during bind lifecycle. bindAndInitFirstWorkspaceScreen(); // Re-enable the layout transitions @@ -938,6 +941,8 @@ public class Workspace extends PagedView stripEmptyScreens(); } + persistCurrentScreenOrderSync(); + if (onComplete != null) { onComplete.run(); } @@ -985,6 +990,7 @@ public class Workspace extends PagedView mWorkspaceScreens.put(newScreenId, cl); mScreenOrder.add(newScreenId); + persistCurrentScreenOrderSync(); return newScreenId; } @@ -1081,11 +1087,20 @@ public class Workspace extends PagedView return; } + if (mDeferStripEmptyScreensForScreenRemap) { + return; + } + + if (mLauncher.isInState(EDIT_MODE)) { + return; + } + if (isPageInTransition()) { mStripScreensOnPageStopMoving = true; return; } + IntSet persistedScreenIds = getPersistedWorkspaceScreenIds(); int currentPage = getNextPage(); IntArray removeScreens = new IntArray(); int total = mWorkspaceScreens.size(); @@ -1093,6 +1108,10 @@ public class Workspace extends PagedView int id = mWorkspaceScreens.keyAt(i); CellLayout cl = mWorkspaceScreens.valueAt(i); // FIRST_SCREEN_ID can never be removed. + if (shouldPreserveEmptyScreenWhenStripping( + id, persistedScreenIds, isExtraEmptyScreen(id))) { + continue; + } if ((!PreferenceExtensionsKt.firstBlocking(PreferenceManager2.INSTANCE.get(getContext()).getEnableSmartspace()) || id > FIRST_SCREEN_ID) && cl.getShortcutsAndWidgets().getChildCount() == 0) { removeScreens.add(id); @@ -1158,6 +1177,7 @@ public class Workspace extends PagedView if (storedDefault >= getChildCount()) { setDefaultPage(DEFAULT_PAGE); } + persistCurrentScreenOrderSync(); } /** @@ -3264,6 +3284,240 @@ public class Workspace extends PagedView updateChildrenLayersEnabled(); } + private boolean isExtraEmptyScreen(int screenId) { + return screenId == EXTRA_EMPTY_SCREEN_ID || screenId == EXTRA_EMPTY_SCREEN_SECOND_ID; + } + + private boolean isPageGroupMovable(int pageGroupStart) { + int panelCount = getPanelCount(); + if (pageGroupStart < 0 || pageGroupStart + panelCount > mScreenOrder.size()) { + return false; + } + for (int i = 0; i < panelCount; i++) { + if (isExtraEmptyScreen(mScreenOrder.get(pageGroupStart + i))) { + return false; + } + } + return true; + } + + private boolean canMovePageGroup(int pageGroupStart, int direction) { + int panelCount = getPanelCount(); + int targetStart = pageGroupStart + direction * panelCount; + return isPageGroupMovable(pageGroupStart) && isPageGroupMovable(targetStart); + } + + private boolean movePageGroup(int pageIndex, int direction) { + int panelCount = getPanelCount(); + int fromStart = getLeftmostVisiblePageForIndex(pageIndex); + int targetStart = fromStart + direction * panelCount; + if (!canMovePageGroup(fromStart, direction)) { + return false; + } + int defaultPage = getDefaultPage(); + int defaultScreenId = getScreenIdForPageIndex(defaultPage); + IntArray screenOrderSnapshot = new IntArray(); + for (int i = 0; i < mScreenOrder.size(); i++) { + screenOrderSnapshot.add(mScreenOrder.get(i)); + } + SparseIntArray screenSwapMap = + createPageGroupSwapMap(screenOrderSnapshot, fromStart, targetStart, panelCount); + if (screenSwapMap.size() == 0) { + return false; + } + for (int i = 0; i < panelCount; i++) { + int fromIndex = fromStart + i; + int targetIndex = targetStart + i; + int fromScreenId = mScreenOrder.get(fromIndex); + int targetScreenId = mScreenOrder.get(targetIndex); + mScreenOrder.set(fromIndex, targetScreenId); + mScreenOrder.set(targetIndex, fromScreenId); + } + applyScreenOrderToChildViews(); + if (screenSwapMap.size() > 0) { + mLauncher.getModelWriter().persistWorkspaceScreenOrderSync(getPersistableScreenOrder()); + mDeferStripEmptyScreensForScreenRemap = true; + mLauncher.getModelWriter().moveWorkspaceScreensInDatabase( + screenSwapMap, this::onWorkspaceScreenRemapFinished); + } + int remappedDefaultPage = mScreenOrder.indexOf(defaultScreenId); + if (remappedDefaultPage >= 0 && remappedDefaultPage != defaultPage) { + setDefaultPage(remappedDefaultPage); + } + updateAccessibilityViewPageDescription(); + int pageOffset = pageIndex - fromStart; + int destinationPage = targetStart + pageOffset; + setCurrentPage(destinationPage, destinationPage); + showPageIndicatorAtCurrentScroll(); + return true; + } + + public IntArray getReorderablePageGroupStarts() { + IntArray starts = new IntArray(); + int panelCount = getPanelCount(); + IntArray candidateStarts = getPageGroupStarts(mScreenOrder, panelCount); + for (int i = 0; i < candidateStarts.size(); i++) { + int start = candidateStarts.get(i); + if (isPageGroupMovable(start)) { + starts.add(start); + } + } + return starts; + } + + @VisibleForTesting + static IntArray getPageGroupStarts(IntArray screenOrder, int panelCount) { + IntArray starts = new IntArray(); + for (int i = 0; i < screenOrder.size(); i += panelCount) { + starts.add(i); + } + return starts; + } + + public boolean moveReorderablePageGroup(int fromGroupIndex, int toGroupIndex) { + if (fromGroupIndex == toGroupIndex) { + return true; + } + IntArray starts = getReorderablePageGroupStarts(); + if (fromGroupIndex < 0 || fromGroupIndex >= starts.size() + || toGroupIndex < 0 || toGroupIndex >= starts.size()) { + return false; + } + int fromPage = starts.get(fromGroupIndex); + int currentGroup = fromGroupIndex; + int direction = toGroupIndex > fromGroupIndex ? 1 : -1; + while (currentGroup != toGroupIndex) { + if (!movePageGroup(fromPage, direction)) { + return false; + } + currentGroup += direction; + fromPage += direction * getPanelCount(); + } + return true; + } + + public boolean setDefaultPageForReorderableGroup(int groupIndex) { + IntArray starts = getReorderablePageGroupStarts(); + if (groupIndex < 0 || groupIndex >= starts.size()) { + return false; + } + int pageIndex = starts.get(groupIndex); + setDefaultPage(pageIndex); + Toast.makeText(mLauncher, R.string.default_home_page_set, Toast.LENGTH_SHORT).show(); + return true; + } + + public int getDefaultPageGroupIndex() { + IntArray starts = getReorderablePageGroupStarts(); + int defaultPage = getDefaultPage(); + int leftmostPage = getLeftmostVisiblePageForIndex(defaultPage); + return starts.indexOf(leftmostPage); + } + + private IntArray getPersistableScreenOrder() { + IntArray persistableOrder = new IntArray(); + for (int i = 0; i < mScreenOrder.size(); i++) { + int screenId = mScreenOrder.get(i); + if (!isExtraEmptyScreen(screenId)) { + persistableOrder.add(screenId); + } + } + return persistableOrder; + } + + private IntSet getPersistedWorkspaceScreenIds() { + return getPersistedWorkspaceScreenIds( + LauncherPrefs.get(getContext()).get(LauncherPrefs.WORKSPACE_SCREEN_ORDER)); + } + + @VisibleForTesting + static IntSet getPersistedWorkspaceScreenIds(String persistedOrder) { + IntSet ids = new IntSet(); + if (persistedOrder == null || persistedOrder.isBlank()) { + return ids; + } + for (String part : persistedOrder.split(",")) { + try { + int id = Integer.parseInt(part.trim()); + if (id >= 0) { + ids.add(id); + } + } catch (NumberFormatException ignored) { + // Skip invalid entries. + } + } + return ids; + } + + @VisibleForTesting + static boolean shouldPreserveEmptyScreenWhenStripping( + int screenId, IntSet persistedScreenIds, boolean isExtraEmptyScreen) { + return persistedScreenIds.contains(screenId) && !isExtraEmptyScreen; + } + + private void onWorkspaceScreenRemapFinished() { + mDeferStripEmptyScreensForScreenRemap = false; + } + + private void persistCurrentScreenOrderSync() { + if (mLauncher.isWorkspaceLoading()) { + return; + } + mLauncher.getModelWriter().persistWorkspaceScreenOrderSync(getPersistableScreenOrder()); + } + + private void applyScreenOrderToChildViews() { + for (int i = 0; i < mScreenOrder.size(); i++) { + CellLayout layout = mWorkspaceScreens.get(mScreenOrder.get(i)); + if (layout == null) { + continue; + } + int currentIndex = indexOfChild(layout); + if (currentIndex != i) { + removeView(layout); + addView(layout, i); + } + } + updatePageScrollValues(); + } + + public void reorderBoundWorkspaceScreens(IntArray orderedScreenIds) { + if (orderedScreenIds == null || orderedScreenIds.isEmpty()) { + return; + } + IntArray reordered = new IntArray(); + for (int i = 0; i < orderedScreenIds.size(); i++) { + int screenId = orderedScreenIds.get(i); + if (mWorkspaceScreens.containsKey(screenId) && !reordered.contains(screenId)) { + reordered.add(screenId); + } + } + for (int i = 0; i < mScreenOrder.size(); i++) { + int existingId = mScreenOrder.get(i); + if (!reordered.contains(existingId)) { + reordered.add(existingId); + } + } + mScreenOrder.clear(); + mScreenOrder.addAll(reordered); + applyScreenOrderToChildViews(); + } + + @VisibleForTesting + static SparseIntArray createPageGroupSwapMap( + IntArray screenOrder, int fromStart, int targetStart, int panelCount) { + SparseIntArray swapMap = new SparseIntArray(panelCount * 2); + for (int i = 0; i < panelCount; i++) { + int fromScreen = screenOrder.get(fromStart + i); + int targetScreen = screenOrder.get(targetStart + i); + if (fromScreen != targetScreen) { + swapMap.put(fromScreen, targetScreen); + swapMap.put(targetScreen, fromScreen); + } + } + return swapMap; + } + /** * Called at the end of a drag which originated on the workspace. */ diff --git a/src/com/android/launcher3/model/ModelWriter.java b/src/com/android/launcher3/model/ModelWriter.java index 1867119b94..c9c8967944 100644 --- a/src/com/android/launcher3/model/ModelWriter.java +++ b/src/com/android/launcher3/model/ModelWriter.java @@ -24,11 +24,13 @@ import android.content.ContentValues; import android.content.Context; import android.text.TextUtils; import android.util.Log; +import android.util.SparseIntArray; import androidx.annotation.NonNull; import androidx.annotation.Nullable; import com.android.launcher3.LauncherModel; +import com.android.launcher3.LauncherPrefs; import com.android.launcher3.LauncherModel.CallbackTask; import com.android.launcher3.LauncherSettings.Favorites; import com.android.launcher3.Utilities; @@ -44,6 +46,7 @@ import com.android.launcher3.model.data.WorkspaceItemInfo; import com.android.launcher3.provider.LauncherDbUtils.SQLiteTransaction; import com.android.launcher3.util.ContentWriter; import com.android.launcher3.util.Executors; +import com.android.launcher3.util.IntArray; import com.android.launcher3.util.ItemInfoMatcher; import com.android.launcher3.util.LooperExecutor; import com.android.launcher3.widget.LauncherWidgetHolder; @@ -218,6 +221,105 @@ public class ModelWriter { enqueueDeleteRunnable(new UpdateItemsRunnable(items, contentValues)); } + /** + * Remaps workspace screen ids for all desktop items using the provided mapping. + */ + public void moveWorkspaceScreensInDatabase(SparseIntArray screenIdMap) { + moveWorkspaceScreensInDatabase(screenIdMap, null); + } + + /** + * Remaps workspace screen ids for all desktop items using the provided mapping. + * + * @param onComplete optional runnable executed on the main thread after item callbacks are + * dispatched (always runs, including when there are no item updates). + */ + public void moveWorkspaceScreensInDatabase(SparseIntArray screenIdMap, Runnable onComplete) { + if (screenIdMap == null || screenIdMap.size() == 0) { + if (onComplete != null) { + mUiExecutor.execute(onComplete); + } + return; + } + ModelVerifier verifier = new ModelVerifier(); + enqueueDeleteRunnable(newModelTask(() -> { + try (SQLiteTransaction t = mModel.getModelDbController().newTransaction()) { + // First pass to temporary ids to avoid collisions in cycles. + for (int i = 0; i < screenIdMap.size(); i++) { + int fromScreenId = screenIdMap.keyAt(i); + int tempScreenId = Integer.MIN_VALUE + i; + ContentValues tempValues = new ContentValues(); + tempValues.put(Favorites.SCREEN, tempScreenId); + mModel.getModelDbController().update( + tempValues, + Favorites.CONTAINER + "=" + Favorites.CONTAINER_DESKTOP + " AND " + + Favorites.SCREEN + "=" + fromScreenId, + null); + } + // Second pass to final ids. + for (int i = 0; i < screenIdMap.size(); i++) { + int toScreenId = screenIdMap.valueAt(i); + int tempScreenId = Integer.MIN_VALUE + i; + ContentValues finalValues = new ContentValues(); + finalValues.put(Favorites.SCREEN, toScreenId); + mModel.getModelDbController().update( + finalValues, + Favorites.CONTAINER + "=" + Favorites.CONTAINER_DESKTOP + " AND " + + Favorites.SCREEN + "=" + tempScreenId, + null); + } + t.commit(); + } catch (Exception e) { + Log.e(TAG, "Failed to remap workspace screens", e); + if (onComplete != null) { + mUiExecutor.execute(onComplete); + } + return; + } + + ArrayList updatedItems = new ArrayList<>(); + synchronized (mBgDataModel) { + for (ItemInfo item : mBgDataModel.itemsIdMap) { + if (item.container != Favorites.CONTAINER_DESKTOP) { + continue; + } + int newScreenId = screenIdMap.get(item.screenId, item.screenId); + if (newScreenId != item.screenId) { + item.screenId = newScreenId; + updatedItems.add(item); + } + } + if (!updatedItems.isEmpty()) { + mBgDataModel.updateItems(updatedItems, mOwner); + } + verifier.verifyModel(); + } + final HashSet updates = new HashSet<>(updatedItems); + mUiExecutor.execute(() -> { + if (!updates.isEmpty()) { + if (mOwner != null) { + mOwner.bindItemsUpdated(updates); + } + notifyOtherCallbacks(c -> c.bindItemsUpdated(updates)); + } + if (onComplete != null) { + onComplete.run(); + } + }); + })); + } + + /** + * Persists explicit workspace screen order synchronously. + */ + public void persistWorkspaceScreenOrderSync(IntArray screenOrder) { + if (screenOrder == null || screenOrder.isEmpty()) { + return; + } + String serialized = screenOrder.toConcatString(); + LauncherPrefs.get(mContext).putSync(LauncherPrefs.WORKSPACE_SCREEN_ORDER.to(serialized)); + } + /** * Move and/or resize item in the DB to a new diff --git a/src/com/android/launcher3/model/data/WorkspaceData.kt b/src/com/android/launcher3/model/data/WorkspaceData.kt index 692d0d36c3..7cd52f6811 100644 --- a/src/com/android/launcher3/model/data/WorkspaceData.kt +++ b/src/com/android/launcher3/model/data/WorkspaceData.kt @@ -24,6 +24,7 @@ import androidx.core.util.valueIterator import app.lawnchair.preferences2.PreferenceManager2 import com.android.launcher3.BuildConfig import com.android.launcher3.BuildConfigs +import com.android.launcher3.LauncherPrefs import com.android.launcher3.LauncherSettings.Favorites.CONTAINER_DESKTOP import com.android.launcher3.Workspace import com.android.launcher3.model.data.WorkspaceChangeEvent.AddEvent @@ -54,7 +55,8 @@ sealed class WorkspaceData : Iterable { if (smartspaceEnabled || screenSet.isEmpty) { screenSet.add(Workspace.FIRST_SCREEN_ID) } - return screenSet.array + val persistedOrder = LauncherPrefs.get(context).get(LauncherPrefs.WORKSPACE_SCREEN_ORDER) + return mergeWorkspaceScreens(screenSet.array, persistedOrder) } /** Returns the [ItemInfo] associated with the [id] or null */ @@ -187,5 +189,28 @@ sealed class WorkspaceData : Iterable { @VisibleForTesting const val MAX_HISTORY_SIZE = 4 private val VERSION_COUNTER = AtomicInteger() + + @VisibleForTesting + fun mergeWorkspaceScreens(itemScreens: IntArray, persistedOrder: String): IntArray { + if (persistedOrder.isBlank()) return itemScreens + + val merged = IntArray() + val persistedScreens = + persistedOrder + .split(",") + .mapNotNull { it.trim().toIntOrNull() } + .filter { it >= 0 } + persistedScreens.forEach { screenId -> + if (!merged.contains(screenId)) { + merged.add(screenId) + } + } + itemScreens.forEach { screenId -> + if (!merged.contains(screenId)) { + merged.add(screenId) + } + } + return merged + } } } diff --git a/src/com/android/launcher3/states/EditModeState.kt b/src/com/android/launcher3/states/EditModeState.kt index 268a37301d..066758b84c 100644 --- a/src/com/android/launcher3/states/EditModeState.kt +++ b/src/com/android/launcher3/states/EditModeState.kt @@ -19,8 +19,10 @@ import android.content.Context import com.android.launcher3.Flags.enableScalingRevealHomeAnimation import com.android.launcher3.Launcher import com.android.launcher3.LauncherState +import com.android.launcher3.R import com.android.launcher3.logging.StatsLogManager import com.android.launcher3.views.ActivityContext +import kotlin.math.min /** Definition for Edit Mode state used for home gardening multi-select */ class EditModeState(id: Int) : LauncherState(id, StatsLogManager.LAUNCHER_STATE_HOME, STATE_FLAGS) { @@ -34,6 +36,65 @@ class EditModeState(id: Int) : LauncherState(id, StatsLogManager.LAUNCHER_STATE_ FLAG_DISABLE_RESTORE or FLAG_WORKSPACE_ICONS_CAN_BE_DRAGGED or FLAG_WORKSPACE_HAS_BACKGROUNDS) + + private fun getEditModePageStripHeightPx(launcher: Launcher): Int = + launcher.resources.getDimensionPixelSize(R.dimen.edit_mode_page_strip_height) + + private fun getEditModeWorkspaceVerticalBounds(launcher: Launcher): Pair { + val grid = launcher.deviceProfile + val top = (grid.getInsets().top + grid.workspacePadding.top).toFloat() + + val stripHeightPx = getEditModePageStripHeightPx(launcher) + val bottomGap = + launcher.resources.getDimensionPixelSize( + R.dimen.edit_mode_workspace_bottom_gap, + ) + val hotseat = launcher.hotseat + val bottom = + if (hotseat.top > 0) { + hotseat.top + hotseat.translationY - bottomGap + } else { + grid.getCellLayoutSpringLoadShrunkBottom(launcher) - stripHeightPx + } + return top to bottom + } + + private fun getEditModeWorkspaceScale( + launcher: Launcher, + top: Float, + bottom: Float, + ): Float { + val grid = launcher.deviceProfile + var scale = (bottom - top) / grid.cellLayoutHeight.toFloat() + scale = min(scale, 1f) + + val workspaceWidth = grid.deviceProperties.availableWidthPx + val scaledWorkspaceWidth = workspaceWidth * scale + val maxAvailableWidth = + workspaceWidth - (2 * grid.workspaceSpringLoadedMinNextPageVisiblePx) + if (scaledWorkspaceWidth > maxAvailableWidth) { + scale *= maxAvailableWidth / scaledWorkspaceWidth + } + return scale + } + + private fun getEditModeWorkspaceScaleAndTranslation( + launcher: Launcher, + ): ScaleAndTranslation { + val ws = launcher.workspace + if (ws.childCount == 0) { + return ScaleAndTranslation(1f, 0f, 0f) + } + + val (top, bottom) = getEditModeWorkspaceVerticalBounds(launcher) + val scale = getEditModeWorkspaceScale(launcher, top, bottom) + + val halfHeight = ws.height / 2f + val myCenter = ws.top + halfHeight + val cellTopFromCenter = halfHeight - ws.getChildAt(0).top + val actualCellTop = myCenter - cellTopFromCenter * scale + return ScaleAndTranslation(scale, 0f, top - actualCellTop) + } } override fun getTransitionDuration(context: ActivityContext, isToState: Boolean) = 150 @@ -46,14 +107,12 @@ class EditModeState(id: Int) : LauncherState(id, StatsLogManager.LAUNCHER_STATE_ } } - override fun getWorkspaceScaleAndTranslation(launcher: Launcher): ScaleAndTranslation { - val scale = launcher.deviceProfile.getWorkspaceSpringLoadScale(launcher) - return ScaleAndTranslation(scale, 0f, 0f) - } + override fun getWorkspaceScaleAndTranslation(launcher: Launcher): ScaleAndTranslation = + getEditModeWorkspaceScaleAndTranslation(launcher) override fun getHotseatScaleAndTranslation(launcher: Launcher): ScaleAndTranslation { - val scale = launcher.deviceProfile.getWorkspaceSpringLoadScale(launcher) - return ScaleAndTranslation(scale, 0f, 0f) + val offset = getEditModePageStripHeightPx(launcher).toFloat() + return ScaleAndTranslation(1f, 0f, -offset) } override fun getWorkspaceBackgroundAlpha(launcher: Launcher): Float { diff --git a/src/com/android/launcher3/util/OnboardingPrefs.kt b/src/com/android/launcher3/util/OnboardingPrefs.kt index 771594ea9d..705b44dca0 100644 --- a/src/com/android/launcher3/util/OnboardingPrefs.kt +++ b/src/com/android/launcher3/util/OnboardingPrefs.kt @@ -78,4 +78,8 @@ object OnboardingPrefs { val HOTSEAT_LONGPRESS_TIP_SEEN = backedUpItem("launcher.hotseat_longpress_tip_seen", false) @JvmField val TASKBAR_SEARCH_EDU_SEEN = backedUpItem("launcher.taskbar_search_edu_seen", false) + + @JvmField + val EDIT_MODE_PAGE_STRIP_TIP_SEEN = + backedUpItem("launcher.edit_mode_page_strip_tip_seen", false) } diff --git a/tests/multivalentTests/src/com/android/launcher3/WorkspacePageReorderTest.kt b/tests/multivalentTests/src/com/android/launcher3/WorkspacePageReorderTest.kt new file mode 100644 index 0000000000..f20ec16770 --- /dev/null +++ b/tests/multivalentTests/src/com/android/launcher3/WorkspacePageReorderTest.kt @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2026 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.util.SparseIntArray +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.filters.SmallTest +import com.android.launcher3.util.IntArray +import com.android.launcher3.util.IntSet +import com.google.common.truth.Truth.assertThat +import org.junit.Test +import org.junit.runner.RunWith + +@SmallTest +@RunWith(AndroidJUnit4::class) +class WorkspacePageReorderTest { + + @Test + fun createPageGroupSwapMap_singlePanel_swapsBothScreens() { + val screenOrder = IntArray.wrap(0, 1, 2, 3) + + val swapMap = Workspace.createPageGroupSwapMap(screenOrder, 1, 2, 1) + + assertSwap(swapMap, 1, 2) + assertSwap(swapMap, 2, 1) + } + + @Test + fun createPageGroupSwapMap_twoPanel_swapsPagePairs() { + val screenOrder = IntArray.wrap(0, 1, 2, 3, 4, 5) + + val swapMap = Workspace.createPageGroupSwapMap(screenOrder, 2, 4, 2) + + assertSwap(swapMap, 2, 4) + assertSwap(swapMap, 3, 5) + assertSwap(swapMap, 4, 2) + assertSwap(swapMap, 5, 3) + } + + @Test + fun getPageGroupStarts_singlePanel_returnsEveryPageStart() { + val starts = Workspace.getPageGroupStarts(IntArray.wrap(0, 1, 2, 3), 1) + assertThat(starts.toArray().asList()).containsExactly(0, 1, 2, 3).inOrder() + } + + @Test + fun getPageGroupStarts_twoPanel_returnsPairStarts() { + val starts = Workspace.getPageGroupStarts(IntArray.wrap(0, 1, 2, 3, 4, 5), 2) + assertThat(starts.toArray().asList()).containsExactly(0, 2, 4).inOrder() + } + + @Test + fun getPersistedWorkspaceScreenIds_parsesCommaSeparatedOrder() { + val ids = Workspace.getPersistedWorkspaceScreenIds("0,1,2") + assertThat(ids.getArray().toArray().asList()).containsExactly(0, 1, 2).inOrder() + } + + @Test + fun getPersistedWorkspaceScreenIds_ignoresInvalidEntries() { + val ids = Workspace.getPersistedWorkspaceScreenIds("2, ,x,0") + assertThat(ids.getArray().toArray().asList()).containsExactly(0, 2).inOrder() + } + + @Test + fun shouldPreserveEmptyScreenWhenStripping_skipsPersistedNonExtraScreens() { + val persisted = IntSet.wrap(0, 1, 2) + assertThat( + Workspace.shouldPreserveEmptyScreenWhenStripping(2, persisted, false), + ).isTrue() + assertThat( + Workspace.shouldPreserveEmptyScreenWhenStripping( + Workspace.EXTRA_EMPTY_SCREEN_ID, + persisted, + true, + ), + ).isFalse() + assertThat( + Workspace.shouldPreserveEmptyScreenWhenStripping(3, persisted, false), + ).isFalse() + } + + private fun assertSwap(map: SparseIntArray, from: Int, to: Int) { + assertThat(map.indexOfKey(from)).isAtLeast(0) + assertThat(map.get(from)).isEqualTo(to) + } +} diff --git a/tests/multivalentTests/src/com/android/launcher3/model/data/WorkspaceDataTest.kt b/tests/multivalentTests/src/com/android/launcher3/model/data/WorkspaceDataTest.kt index 44d9a502e5..9a0913ea2b 100644 --- a/tests/multivalentTests/src/com/android/launcher3/model/data/WorkspaceDataTest.kt +++ b/tests/multivalentTests/src/com/android/launcher3/model/data/WorkspaceDataTest.kt @@ -23,7 +23,9 @@ import com.android.launcher3.model.data.WorkspaceChangeEvent.AddEvent import com.android.launcher3.model.data.WorkspaceChangeEvent.RemoveEvent import com.android.launcher3.model.data.WorkspaceChangeEvent.UpdateEvent import com.android.launcher3.model.data.WorkspaceData.Companion.MAX_HISTORY_SIZE +import com.android.launcher3.model.data.WorkspaceData.Companion.mergeWorkspaceScreens import com.android.launcher3.model.data.WorkspaceData.MutableWorkspaceData +import com.android.launcher3.util.IntArray import com.google.common.truth.Truth.assertThat import org.junit.Test import org.junit.runner.RunWith @@ -127,6 +129,36 @@ class WorkspaceDataTest { assertThat(data.diff(start)).isNull() } + @Test + fun mergeWorkspaceScreens_usesPersistedOrder_first() { + val merged = mergeWorkspaceScreens(IntArray.wrap(0, 1, 2), "2,0,1") + assertThat(merged.toArray().asList()).containsExactly(2, 0, 1).inOrder() + } + + @Test + fun mergeWorkspaceScreens_keepsPersistedEmptyScreens() { + val merged = mergeWorkspaceScreens(IntArray.wrap(0, 2), "9,2,0") + assertThat(merged.toArray().asList()).containsExactly(9, 2, 0).inOrder() + } + + @Test + fun mergeWorkspaceScreens_appendsMissingItemScreens() { + val merged = mergeWorkspaceScreens(IntArray.wrap(0, 1, 2, 3), "2,0") + assertThat(merged.toArray().asList()).containsExactly(2, 0, 1, 3).inOrder() + } + + @Test + fun mergeWorkspaceScreens_preservesFirstScreenPositionFromPersistedOrder() { + val merged = mergeWorkspaceScreens(IntArray.wrap(0, 1, 2), "1,0,2") + assertThat(merged.toArray().asList()).containsExactly(1, 0, 2).inOrder() + } + + @Test + fun mergeWorkspaceScreens_emptyPersistedFallsBackToItemOrder() { + val merged = mergeWorkspaceScreens(IntArray.wrap(0, 1, 2), "") + assertThat(merged.toArray().asList()).containsExactly(0, 1, 2).inOrder() + } + private fun createItemSparseArray(size: Int) = SparseArray().apply { for (i in 0..