Examples with OVERVIEW com.android.launcher3.LauncherState.OVERVIEW used on opensource projects

Example 96 with OVERVIEW

use of com.android.launcher3.LauncherState.OVERVIEW in project android_packages_apps_404Launcher by P-404.

the class RecentsView method updateDeadZoneRects.

private void updateDeadZoneRects() {
    // Get the deadzone rect surrounding the clear all button to not dismiss overview to home
    mClearAllButtonDeadZoneRect.setEmpty();
    if (mClearAllButton.getWidth() > 0) {
        int verticalMargin = getResources().getDimensionPixelSize(R.dimen.recents_clear_all_deadzone_vertical_margin);
        mClearAllButton.getHitRect(mClearAllButtonDeadZoneRect);
        mClearAllButtonDeadZoneRect.inset(-getPaddingRight() / 2, -verticalMargin);
    }
    // Get the deadzone rect between the task views
    mTaskViewDeadZoneRect.setEmpty();
    int count = getTaskViewCount();
    if (count > 0) {
        final View taskView = requireTaskViewAt(0);
        requireTaskViewAt(count - 1).getHitRect(mTaskViewDeadZoneRect);
        mTaskViewDeadZoneRect.union(taskView.getLeft(), taskView.getTop(), taskView.getRight(), taskView.getBottom());
    }
}

Example 97 with OVERVIEW

use of com.android.launcher3.LauncherState.OVERVIEW in project android_packages_apps_404Launcher by P-404.

the class RecentsView method updateGridProperties.

/**
 * Updates TaskView and ClearAllButton scaling and translation required to turn into grid
 * layout.
 *
 * This method only calculates the potential position and depends on {@link #setGridProgress} to
 * apply the actual scaling and translation.
 *
 * @param isTaskDismissal    indicates if update was called due to task dismissal
 * @param startRebalanceAfter which view index to start rebalancing from. Use Integer.MAX_VALUE
 *                           to skip rebalance
 */
private void updateGridProperties(boolean isTaskDismissal, int startRebalanceAfter) {
    int taskCount = getTaskViewCount();
    if (taskCount == 0) {
        return;
    }
    int taskTopMargin = mActivity.getDeviceProfile().overviewTaskThumbnailTopMarginPx;
    int topRowWidth = 0;
    int bottomRowWidth = 0;
    float topAccumulatedTranslationX = 0;
    float bottomAccumulatedTranslationX = 0;
    // Contains whether the child index is in top or bottom of grid (for non-focused task)
    // Different from mTopRowIdSet, which contains the taskViewId of what task is in top row
    IntSet topSet = new IntSet();
    IntSet bottomSet = new IntSet();
    // Horizontal grid translation for each task
    float[] gridTranslations = new float[taskCount];
    int focusedTaskIndex = Integer.MAX_VALUE;
    int focusedTaskShift = 0;
    int focusedTaskWidthAndSpacing = 0;
    int snappedTaskRowWidth = 0;
    int snappedPage = getNextPage();
    TaskView snappedTaskView = getTaskViewAt(snappedPage);
    TaskView homeTaskView = getHomeTaskView();
    TaskView nextFocusedTaskView = null;
    if (!isTaskDismissal) {
        mTopRowIdSet.clear();
    }
    for (int i = 0; i < taskCount; i++) {
        TaskView taskView = requireTaskViewAt(i);
        int taskWidthAndSpacing = taskView.getLayoutParams().width + mPageSpacing;
        // the grid.
        if (taskView.isFocusedTask()) {
            topRowWidth += taskWidthAndSpacing;
            bottomRowWidth += taskWidthAndSpacing;
            focusedTaskIndex = i;
            focusedTaskWidthAndSpacing = taskWidthAndSpacing;
            gridTranslations[i] += focusedTaskShift;
            gridTranslations[i] += mIsRtl ? taskWidthAndSpacing : -taskWidthAndSpacing;
            // Center view vertically in case it's from different orientation.
            taskView.setGridTranslationY((mLastComputedTaskSize.height() + taskTopMargin - taskView.getLayoutParams().height) / 2f);
            if (taskView == snappedTaskView) {
                // If focused task is snapped, the row width is just task width and spacing.
                snappedTaskRowWidth = taskWidthAndSpacing;
            }
        } else {
            if (i > focusedTaskIndex) {
                // For tasks after the focused task, shift by focused task's width and spacing.
                gridTranslations[i] += mIsRtl ? focusedTaskWidthAndSpacing : -focusedTaskWidthAndSpacing;
            } else {
                // For task before the focused task, accumulate the width and spacing to
                // calculate the distance focused task need to shift.
                focusedTaskShift += mIsRtl ? taskWidthAndSpacing : -taskWidthAndSpacing;
            }
            int taskViewId = taskView.getTaskViewId();
            // Rebalance the grid starting after a certain index
            boolean isTopRow;
            if (isTaskDismissal) {
                if (i > startRebalanceAfter) {
                    mTopRowIdSet.remove(taskViewId);
                    isTopRow = topRowWidth <= bottomRowWidth;
                } else {
                    isTopRow = mTopRowIdSet.contains(taskViewId);
                }
            } else {
                isTopRow = topRowWidth <= bottomRowWidth;
            }
            if (isTopRow) {
                if (homeTaskView != null && nextFocusedTaskView == null) {
                    // TaskView will be focused when swipe up, don't count towards row width.
                    nextFocusedTaskView = taskView;
                } else {
                    topRowWidth += taskWidthAndSpacing;
                }
                topSet.add(i);
                mTopRowIdSet.add(taskViewId);
                taskView.setGridTranslationY(mTaskGridVerticalDiff);
                // Move horizontally into empty space.
                float widthOffset = 0;
                for (int j = i - 1; !topSet.contains(j) && j >= 0; j--) {
                    if (j == focusedTaskIndex) {
                        continue;
                    }
                    widthOffset += requireTaskViewAt(j).getLayoutParams().width + mPageSpacing;
                }
                float currentTaskTranslationX = mIsRtl ? widthOffset : -widthOffset;
                gridTranslations[i] += topAccumulatedTranslationX + currentTaskTranslationX;
                topAccumulatedTranslationX += currentTaskTranslationX;
            } else {
                bottomRowWidth += taskWidthAndSpacing;
                bottomSet.add(i);
                // Move into bottom row.
                taskView.setGridTranslationY(mTopBottomRowHeightDiff + mTaskGridVerticalDiff);
                // Move horizontally into empty space.
                float widthOffset = 0;
                for (int j = i - 1; !bottomSet.contains(j) && j >= 0; j--) {
                    if (j == focusedTaskIndex) {
                        continue;
                    }
                    widthOffset += requireTaskViewAt(j).getLayoutParams().width + mPageSpacing;
                }
                float currentTaskTranslationX = mIsRtl ? widthOffset : -widthOffset;
                gridTranslations[i] += bottomAccumulatedTranslationX + currentTaskTranslationX;
                bottomAccumulatedTranslationX += currentTaskTranslationX;
            }
            if (taskView == snappedTaskView) {
                snappedTaskRowWidth = isTopRow ? topRowWidth : bottomRowWidth;
            }
        }
    }
    // We need to maintain snapped task's page scroll invariant between quick switch and
    // overview, so we sure snapped task's grid translation is 0, and add a non-fullscreen
    // translationX that is the same as snapped task's full scroll adjustment.
    float snappedTaskNonGridScrollAdjustment = 0;
    float snappedTaskGridTranslationX = 0;
    if (snappedTaskView != null) {
        snappedTaskNonGridScrollAdjustment = snappedTaskView.getScrollAdjustment(/*fullscreenEnabled=*/
        true, /*gridEnabled=*/
        false);
        snappedTaskGridTranslationX = gridTranslations[snappedPage];
    }
    // Use the accumulated translation of the row containing the last task.
    float clearAllAccumulatedTranslation = topSet.contains(taskCount - 1) ? topAccumulatedTranslationX : bottomAccumulatedTranslationX;
    // If the last task is on the shorter row, ClearAllButton will embed into the shorter row
    // which is not what we want. Compensate the width difference of the 2 rows in that case.
    float shorterRowCompensation = 0;
    if (topRowWidth <= bottomRowWidth) {
        if (topSet.contains(taskCount - 1)) {
            shorterRowCompensation = bottomRowWidth - topRowWidth;
        }
    } else {
        if (bottomSet.contains(taskCount - 1)) {
            shorterRowCompensation = topRowWidth - bottomRowWidth;
        }
    }
    float clearAllShorterRowCompensation = mIsRtl ? -shorterRowCompensation : shorterRowCompensation;
    // If the total width is shorter than one grid's width, move ClearAllButton further away
    // accordingly. Update longRowWidth if ClearAllButton has been moved.
    float clearAllShortTotalCompensation = 0;
    int longRowWidth = Math.max(topRowWidth, bottomRowWidth);
    if (longRowWidth < mLastComputedGridSize.width()) {
        float shortTotalCompensation = mLastComputedGridSize.width() - longRowWidth;
        clearAllShortTotalCompensation = mIsRtl ? -shortTotalCompensation : shortTotalCompensation;
        longRowWidth = mLastComputedGridSize.width();
    }
    float clearAllTotalTranslationX = clearAllAccumulatedTranslation + clearAllShorterRowCompensation + clearAllShortTotalCompensation + snappedTaskNonGridScrollAdjustment;
    if (focusedTaskIndex < taskCount) {
        // Shift by focused task's width and spacing if a task is focused.
        clearAllTotalTranslationX += mIsRtl ? focusedTaskWidthAndSpacing : -focusedTaskWidthAndSpacing;
    }
    // of swiping up after quick switch.
    if (snappedTaskView != null) {
        int distanceFromClearAll = longRowWidth - snappedTaskRowWidth + mPageSpacing;
        // ClearAllButton should be off screen when snapped task is in its snapped position.
        int minimumDistance = mTaskWidth - snappedTaskView.getLayoutParams().width + (mLastComputedGridSize.width() - mTaskWidth) / 2;
        if (distanceFromClearAll < minimumDistance) {
            int distanceDifference = minimumDistance - distanceFromClearAll;
            snappedTaskGridTranslationX += mIsRtl ? distanceDifference : -distanceDifference;
        }
    }
    for (int i = 0; i < taskCount; i++) {
        TaskView taskView = requireTaskViewAt(i);
        taskView.setGridTranslationX(gridTranslations[i] - snappedTaskGridTranslationX + snappedTaskNonGridScrollAdjustment);
    }
    mClearAllButton.setGridTranslationPrimary(clearAllTotalTranslationX - snappedTaskGridTranslationX);
    mClearAllButton.setGridScrollOffset(mIsRtl ? mLastComputedTaskSize.left - mLastComputedGridSize.left : mLastComputedTaskSize.right - mLastComputedGridSize.right);
    setGridProgress(mGridProgress);
}

Example 98 with OVERVIEW

use of com.android.launcher3.LauncherState.OVERVIEW in project android_packages_apps_404Launcher by P-404.

the class TaskView method onTaskListVisibilityChanged.

/**
 * See {@link TaskDataChanges}
 * @param visible If this task view will be visible to the user in overview or hidden
 */
public void onTaskListVisibilityChanged(boolean visible, @TaskDataChanges int changes) {
    if (mTask == null) {
        return;
    }
    cancelPendingLoadTasks();
    if (visible) {
        // These calls are no-ops if the data is already loaded, try and load the high
        // resolution thumbnail if the state permits
        RecentsModel model = RecentsModel.INSTANCE.get(getContext());
        TaskThumbnailCache thumbnailCache = model.getThumbnailCache();
        TaskIconCache iconCache = model.getIconCache();
        if (needsUpdate(changes, FLAG_UPDATE_THUMBNAIL)) {
            mThumbnailLoadRequest = thumbnailCache.updateThumbnailInBackground(mTask, thumbnail -> {
                mSnapshotView.setThumbnail(mTask, thumbnail);
            });
        }
        if (needsUpdate(changes, FLAG_UPDATE_ICON)) {
            mIconLoadRequest = iconCache.updateIconInBackground(mTask, (task) -> {
                setIcon(mIconView, task.icon);
                mDigitalWellBeingToast.initialize(mTask);
            });
        }
    } else {
        if (needsUpdate(changes, FLAG_UPDATE_THUMBNAIL)) {
            mSnapshotView.setThumbnail(null, null);
            // Reset the task thumbnail reference as well (it will be fetched from the cache or
            // reloaded next time we need it)
            mTask.thumbnail = null;
        }
        if (needsUpdate(changes, FLAG_UPDATE_ICON)) {
            setIcon(mIconView, null);
        }
    }
}

Example 99 with OVERVIEW

use of com.android.launcher3.LauncherState.OVERVIEW in project android_packages_apps_404Launcher by P-404.

the class FallbackRecentsTest method testOverview.

// b/143488140
// @NavigationModeSwitch
@Test
public void testOverview() {
    startAppFast(getAppPackageName());
    startAppFast(resolveSystemApp(Intent.CATEGORY_APP_CALCULATOR));
    startTestActivity(2);
    Wait.atMost("Expected three apps in the task list", () -> mLauncher.getRecentTasks().size() >= 3, DEFAULT_ACTIVITY_TIMEOUT, mLauncher);
    BaseOverview overview = mLauncher.getBackground().switchToOverview();
    executeOnRecents(recents -> {
        assertTrue("Don't have at least 3 tasks", getTaskCount(recents) >= 3);
    });
    // Test flinging forward and backward.
    overview.flingForward();
    final Integer currentTaskAfterFlingForward = getFromRecents(this::getCurrentOverviewPage);
    executeOnRecents(recents -> assertTrue("Current task in Overview is still 0", currentTaskAfterFlingForward > 0));
    overview.flingBackward();
    executeOnRecents(recents -> assertTrue("Flinging back in Overview did nothing", getCurrentOverviewPage(recents) < currentTaskAfterFlingForward));
    // Test opening a task.
    overview = pressHomeAndGoToOverview();
    OverviewTask task = overview.getCurrentTask();
    assertNotNull("overview.getCurrentTask() returned null (1)", task);
    assertNotNull("OverviewTask.open returned null", task.open());
    assertTrue("Test activity didn't open from Overview", TestHelpers.wait(Until.hasObject(By.pkg(getAppPackageName()).text("TestActivity2")), DEFAULT_UI_TIMEOUT));
    // Test dismissing a task.
    overview = pressHomeAndGoToOverview();
    final Integer numTasks = getFromRecents(this::getTaskCount);
    task = overview.getCurrentTask();
    assertNotNull("overview.getCurrentTask() returned null (2)", task);
    task.dismiss();
    executeOnRecents(recents -> assertEquals("Dismissing a task didn't remove 1 task from Overview", numTasks - 1, getTaskCount(recents)));
    // Test dismissing all tasks.
    pressHomeAndGoToOverview().dismissAllTasks();
    assertTrue("Fallback Launcher not visible", TestHelpers.wait(Until.hasObject(By.pkg(mOtherLauncherActivity.packageName)), WAIT_TIME_MS));
}

Example 100 with OVERVIEW

use of com.android.launcher3.LauncherState.OVERVIEW in project android_packages_apps_404Launcher by P-404.

the class TaplTestsQuickstep method testOverviewActions.

/**
 * Smoke test for action buttons: Presses all the buttons and makes sure no crashes occur.
 */
@Test
@NavigationModeSwitch
@PortraitLandscape
// b/195673272
@ScreenRecord
public void testOverviewActions() throws Exception {
    // Experimenting for b/165029151:
    final Overview overview = mLauncher.pressHome().switchToOverview();
    if (overview.hasTasks())
        overview.dismissAllTasks();
    mLauncher.pressHome();
    // 
    startTestAppsWithCheck();
    OverviewActions actionsView = mLauncher.pressHome().switchToOverview().getOverviewActions();
    actionsView.clickAndDismissScreenshot();
}