Examples with LINEAR com.android.launcher3.anim.Interpolators.LINEAR used on opensource projects

Example 11 with LINEAR

use of com.android.launcher3.anim.Interpolators.LINEAR in project android_packages_apps_Launcher3 by AOSPA.

the class FloatingTaskView method addAnimation.

public void addAnimation(PendingAnimation animation, RectF startingBounds, Rect endBounds, View viewToCover, boolean fadeWithThumbnail) {
    final BaseDragLayer dragLayer = mActivity.getDragLayer();
    int[] dragLayerBounds = new int[2];
    dragLayer.getLocationOnScreen(dragLayerBounds);
    SplitOverlayProperties prop = new SplitOverlayProperties(endBounds, startingBounds, viewToCover, dragLayerBounds[0], dragLayerBounds[1]);
    ValueAnimator transitionAnimator = ValueAnimator.ofFloat(0, 1);
    animation.add(transitionAnimator);
    long animDuration = animation.getDuration();
    Rect crop = new Rect();
    RectF floatingTaskViewBounds = new RectF();
    final float initialWindowRadius = supportsRoundedCornersOnWindows(getResources()) ? Math.max(crop.width(), crop.height()) / 2f : 0f;
    if (fadeWithThumbnail) {
        animation.addFloat(mSplitPlaceholderView, SplitPlaceholderView.ALPHA_FLOAT, 0, 1, ACCEL);
        animation.addFloat(mImageView, LauncherAnimUtils.VIEW_ALPHA, 1, 0, DEACCEL_3);
    }
    MultiValueUpdateListener listener = new MultiValueUpdateListener() {

        final FloatProp mWindowRadius = new FloatProp(initialWindowRadius, initialWindowRadius, 0, animDuration, LINEAR);

        final FloatProp mDx = new FloatProp(0, prop.dX, 0, animDuration, LINEAR);

        final FloatProp mDy = new FloatProp(0, prop.dY, 0, animDuration, LINEAR);

        final FloatProp mTaskViewScaleX = new FloatProp(prop.initialTaskViewScaleX, prop.finalTaskViewScaleX, 0, animDuration, LINEAR);

        final FloatProp mTaskViewScaleY = new FloatProp(prop.initialTaskViewScaleY, prop.finalTaskViewScaleY, 0, animDuration, LINEAR);

        @Override
        public void onUpdate(float percent, boolean initOnly) {
            // Calculate the icon position.
            floatingTaskViewBounds.set(startingBounds);
            floatingTaskViewBounds.offset(mDx.value, mDy.value);
            Utilities.scaleRectFAboutCenter(floatingTaskViewBounds, mTaskViewScaleX.value, mTaskViewScaleY.value);
            update(floatingTaskViewBounds, percent, mWindowRadius.value * 1);
        }
    };
    transitionAnimator.addUpdateListener(listener);
}

Example 12 with LINEAR

use of com.android.launcher3.anim.Interpolators.LINEAR in project android_packages_apps_Launcher3 by AOSPA.

the class StaggeredWorkspaceAnim method addStaggeredAnimationForView.

/**
 * Adds an alpha/trans animator for {@param v}, with a start delay based on the view's row.
 *
 * @param v A view on the workspace.
 * @param row The bottom-most row that contains the view.
 * @param totalRows Total number of rows.
 */
private void addStaggeredAnimationForView(View v, int row, int totalRows) {
    if (mIgnoredView != null && mIgnoredView == v)
        return;
    // Invert the rows, because we stagger starting from the bottom of the screen.
    int invertedRow = totalRows - row;
    // Add 1 to the inverted row so that the bottom most row has a start delay.
    long startDelay = (long) ((invertedRow + 1) * APP_CLOSE_ROW_START_DELAY_MS);
    v.setTranslationY(mSpringTransY);
    ResourceProvider rp = DynamicResource.provider(v.getContext());
    float stiffness = rp.getFloat(R.dimen.staggered_stiffness);
    float damping = rp.getFloat(R.dimen.staggered_damping_ratio);
    float endTransY = 0;
    float springVelocity = Math.abs(mVelocity) * Math.signum(endTransY - mSpringTransY);
    ValueAnimator springTransY = new SpringAnimationBuilder(v.getContext()).setStiffness(stiffness).setDampingRatio(damping).setMinimumVisibleChange(1f).setStartValue(mSpringTransY).setEndValue(endTransY).setStartVelocity(springVelocity).build(v, VIEW_TRANSLATE_Y);
    springTransY.setStartDelay(startDelay);
    springTransY.addListener(new AnimatorListenerAdapter() {

        @Override
        public void onAnimationEnd(Animator animation) {
            v.setTranslationY(0f);
        }
    });
    mAnimators.play(springTransY);
    v.setAlpha(0);
    ObjectAnimator alpha = ObjectAnimator.ofFloat(v, View.ALPHA, 0f, 1f);
    alpha.setInterpolator(LINEAR);
    alpha.setDuration(ALPHA_DURATION_MS);
    alpha.setStartDelay(startDelay);
    alpha.addListener(new AnimatorListenerAdapter() {

        @Override
        public void onAnimationEnd(Animator animation) {
            v.setAlpha(1f);
        }
    });
    mAnimators.play(alpha);
}

Example 13 with LINEAR

use of com.android.launcher3.anim.Interpolators.LINEAR in project android_packages_apps_Launcher3 by AOSPA.

the class TaskViewUtils method createRecentsWindowAnimator.

public static void createRecentsWindowAnimator(@NonNull TaskView v, boolean skipViewChanges, @NonNull RemoteAnimationTargetCompat[] appTargets, @NonNull RemoteAnimationTargetCompat[] wallpaperTargets, @NonNull RemoteAnimationTargetCompat[] nonAppTargets, @Nullable DepthController depthController, PendingAnimation out) {
    RecentsView recentsView = v.getRecentsView();
    boolean isQuickSwitch = v.isEndQuickswitchCuj();
    v.setEndQuickswitchCuj(false);
    boolean inLiveTileMode = ENABLE_QUICKSTEP_LIVE_TILE.get() && v.getRecentsView().getRunningTaskIndex() != -1;
    final RemoteAnimationTargets targets = new RemoteAnimationTargets(appTargets, wallpaperTargets, nonAppTargets, inLiveTileMode ? MODE_CLOSING : MODE_OPENING);
    final RemoteAnimationTargetCompat navBarTarget = targets.getNavBarRemoteAnimationTarget();
    SurfaceTransactionApplier applier = new SurfaceTransactionApplier(v);
    targets.addReleaseCheck(applier);
    RemoteTargetHandle[] remoteTargetHandles;
    RemoteTargetHandle[] recentsViewHandles = recentsView.getRemoteTargetHandles();
    if (v.isRunningTask() && recentsViewHandles != null) {
        // Re-use existing handles
        remoteTargetHandles = recentsViewHandles;
    } else {
        RemoteTargetGluer gluer = new RemoteTargetGluer(v.getContext(), recentsView.getSizeStrategy(), targets);
        if (v.containsMultipleTasks()) {
            remoteTargetHandles = gluer.assignTargetsForSplitScreen(targets, v.getTaskIds());
        } else {
            remoteTargetHandles = gluer.assignTargets(targets);
        }
    }
    for (RemoteTargetHandle remoteTargetGluer : remoteTargetHandles) {
        remoteTargetGluer.getTransformParams().setSyncTransactionApplier(applier);
    }
    int taskIndex = recentsView.indexOfChild(v);
    Context context = v.getContext();
    DeviceProfile dp = BaseActivity.fromContext(context).getDeviceProfile();
    boolean showAsGrid = dp.overviewShowAsGrid;
    boolean parallaxCenterAndAdjacentTask = taskIndex != recentsView.getCurrentPage() && !showAsGrid;
    int taskRectTranslationPrimary = recentsView.getScrollOffset(taskIndex);
    int taskRectTranslationSecondary = showAsGrid ? (int) v.getGridTranslationY() : 0;
    RemoteTargetHandle[] topMostSimulators = null;
    if (!v.isRunningTask()) {
        // TVSs already initialized from the running task, no need to re-init
        for (RemoteTargetHandle targetHandle : remoteTargetHandles) {
            TaskViewSimulator tvsLocal = targetHandle.getTaskViewSimulator();
            tvsLocal.setDp(dp);
            // RecentsView never updates the display rotation until swipe-up so the value may
            // be stale. Use the display value instead.
            int displayRotation = DisplayController.INSTANCE.get(context).getInfo().rotation;
            tvsLocal.getOrientationState().update(displayRotation, displayRotation);
            tvsLocal.fullScreenProgress.value = 0;
            tvsLocal.recentsViewScale.value = 1;
            tvsLocal.setIsGridTask(v.isGridTask());
            tvsLocal.getOrientationState().getOrientationHandler().set(tvsLocal, TaskViewSimulator::setTaskRectTranslation, taskRectTranslationPrimary, taskRectTranslationSecondary);
            // Fade in the task during the initial 20% of the animation
            out.addFloat(targetHandle.getTransformParams(), TransformParams.TARGET_ALPHA, 0, 1, clampToProgress(LINEAR, 0, 0.2f));
        }
    }
    for (RemoteTargetHandle targetHandle : remoteTargetHandles) {
        TaskViewSimulator tvsLocal = targetHandle.getTaskViewSimulator();
        out.setFloat(tvsLocal.fullScreenProgress, AnimatedFloat.VALUE, 1, TOUCH_RESPONSE_INTERPOLATOR);
        out.setFloat(tvsLocal.recentsViewScale, AnimatedFloat.VALUE, tvsLocal.getFullScreenScale(), TOUCH_RESPONSE_INTERPOLATOR);
        out.setFloat(tvsLocal.recentsViewScroll, AnimatedFloat.VALUE, 0, TOUCH_RESPONSE_INTERPOLATOR);
        out.addOnFrameCallback(() -> {
            for (RemoteTargetHandle handle : remoteTargetHandles) {
                handle.getTaskViewSimulator().apply(handle.getTransformParams());
            }
        });
        if (navBarTarget != null) {
            final Rect cropRect = new Rect();
            out.addOnFrameListener(new MultiValueUpdateListener() {

                FloatProp mNavFadeOut = new FloatProp(1f, 0f, 0, ANIMATION_NAV_FADE_OUT_DURATION, NAV_FADE_OUT_INTERPOLATOR);

                FloatProp mNavFadeIn = new FloatProp(0f, 1f, ANIMATION_DELAY_NAV_FADE_IN, ANIMATION_NAV_FADE_IN_DURATION, NAV_FADE_IN_INTERPOLATOR);

                @Override
                public void onUpdate(float percent, boolean initOnly) {
                    final SurfaceParams.Builder navBuilder = new SurfaceParams.Builder(navBarTarget.leash);
                    // TODO Do we need to operate over multiple TVSs for the navbar leash?
                    for (RemoteTargetHandle handle : remoteTargetHandles) {
                        if (mNavFadeIn.value > mNavFadeIn.getStartValue()) {
                            TaskViewSimulator taskViewSimulator = handle.getTaskViewSimulator();
                            taskViewSimulator.getCurrentCropRect().round(cropRect);
                            navBuilder.withMatrix(taskViewSimulator.getCurrentMatrix()).withWindowCrop(cropRect).withAlpha(mNavFadeIn.value);
                        } else {
                            navBuilder.withAlpha(mNavFadeOut.value);
                        }
                        handle.getTransformParams().applySurfaceParams(navBuilder.build());
                    }
                }
            });
        } else if (inLiveTileMode) {
            // There is no transition animation for app launch from recent in live tile mode so
            // we have to trigger the navigation bar animation from system here.
            final RecentsAnimationController controller = recentsView.getRecentsAnimationController();
            if (controller != null) {
                controller.animateNavigationBarToApp(RECENTS_LAUNCH_DURATION);
            }
        }
        topMostSimulators = remoteTargetHandles;
    }
    if (!skipViewChanges && parallaxCenterAndAdjacentTask && topMostSimulators.length > 0) {
        out.addFloat(v, VIEW_ALPHA, 1, 0, clampToProgress(LINEAR, 0.2f, 0.4f));
        RemoteTargetHandle[] simulatorCopies = topMostSimulators;
        for (RemoteTargetHandle handle : simulatorCopies) {
            handle.getTaskViewSimulator().apply(handle.getTransformParams());
        }
        // Mt represents the overall transformation on the thumbnailView relative to the
        // Launcher's rootView
        // K(t) represents transformation on the running window by the taskViewSimulator at
        // any time t.
        // at t = 0, we know that the simulator matches the thumbnailView. So if we apply K(0)`
        // on the Launcher's rootView, the thumbnailView would match the full running task
        // window. If we apply "K(0)` K(t)" thumbnailView will match the final transformed
        // window at any time t. This gives the overall matrix on thumbnailView to be:
        // Mt K(0)` K(t)
        // During animation we apply transformation on the thumbnailView (and not the rootView)
        // to follow the TaskViewSimulator. So the final matrix applied on the thumbnailView is:
        // Mt K(0)` K(t) Mt`
        TaskThumbnailView[] thumbnails = v.getThumbnails();
        Matrix[] mt = new Matrix[simulatorCopies.length];
        Matrix[] mti = new Matrix[simulatorCopies.length];
        for (int i = 0; i < thumbnails.length; i++) {
            TaskThumbnailView ttv = thumbnails[i];
            RectF localBounds = new RectF(0, 0, ttv.getWidth(), ttv.getHeight());
            float[] tvBoundsMapped = new float[] { 0, 0, ttv.getWidth(), ttv.getHeight() };
            getDescendantCoordRelativeToAncestor(ttv, ttv.getRootView(), tvBoundsMapped, false);
            RectF localBoundsInRoot = new RectF(tvBoundsMapped[0], tvBoundsMapped[1], tvBoundsMapped[2], tvBoundsMapped[3]);
            Matrix localMt = new Matrix();
            localMt.setRectToRect(localBounds, localBoundsInRoot, ScaleToFit.FILL);
            mt[i] = localMt;
            Matrix localMti = new Matrix();
            localMt.invert(localMti);
            mti[i] = localMti;
        }
        Matrix[] k0i = new Matrix[simulatorCopies.length];
        for (int i = 0; i < simulatorCopies.length; i++) {
            k0i[i] = new Matrix();
            simulatorCopies[i].getTaskViewSimulator().getCurrentMatrix().invert(k0i[i]);
        }
        Matrix animationMatrix = new Matrix();
        out.addOnFrameCallback(() -> {
            for (int i = 0; i < simulatorCopies.length; i++) {
                animationMatrix.set(mt[i]);
                animationMatrix.postConcat(k0i[i]);
                animationMatrix.postConcat(simulatorCopies[i].getTaskViewSimulator().getCurrentMatrix());
                animationMatrix.postConcat(mti[i]);
                thumbnails[i].setAnimationMatrix(animationMatrix);
            }
        });
        out.addListener(new AnimatorListenerAdapter() {

            @Override
            public void onAnimationEnd(Animator animation) {
                for (TaskThumbnailView ttv : thumbnails) {
                    ttv.setAnimationMatrix(null);
                }
            }
        });
    }
    out.addListener(new AnimationSuccessListener() {

        @Override
        public void onAnimationSuccess(Animator animator) {
            if (isQuickSwitch) {
                InteractionJankMonitorWrapper.end(InteractionJankMonitorWrapper.CUJ_QUICK_SWITCH);
            }
        }

        @Override
        public void onAnimationEnd(Animator animation) {
            targets.release();
            super.onAnimationEnd(animation);
        }
    });
    if (depthController != null) {
        out.setFloat(depthController, DEPTH, BACKGROUND_APP.getDepth(context), TOUCH_RESPONSE_INTERPOLATOR);
    }
}

Example 14 with LINEAR

use of com.android.launcher3.anim.Interpolators.LINEAR in project android_packages_apps_Launcher3 by AOSPA.

the class SwipeUpAnimationLogic method initTransitionEndpoints.

protected void initTransitionEndpoints(DeviceProfile dp) {
    mDp = dp;
    mTransitionDragLength = mGestureState.getActivityInterface().getSwipeUpDestinationAndLength(dp, mContext, TEMP_RECT, mRemoteTargetHandles[0].getTaskViewSimulator().getOrientationState().getOrientationHandler());
    mDragLengthFactor = (float) dp.heightPx / mTransitionDragLength;
    for (RemoteTargetHandle remoteHandle : mRemoteTargetHandles) {
        PendingAnimation pendingAnimation = new PendingAnimation(mTransitionDragLength * 2);
        TaskViewSimulator taskViewSimulator = remoteHandle.getTaskViewSimulator();
        taskViewSimulator.setDp(dp);
        taskViewSimulator.addAppToOverviewAnim(pendingAnimation, LINEAR);
        AnimatorPlaybackController playbackController = pendingAnimation.createPlaybackController();
        remoteHandle.setPlaybackController(AnimatorControllerWithResistance.createForRecents(playbackController, mContext, taskViewSimulator.getOrientationState(), mDp, taskViewSimulator.recentsViewScale, AnimatedFloat.VALUE, taskViewSimulator.recentsViewSecondaryTranslation, AnimatedFloat.VALUE));
    }
}

Example 15 with LINEAR

use of com.android.launcher3.anim.Interpolators.LINEAR in project android_packages_apps_Trebuchet by LineageOS.

the class WorkspaceStateTransitionAnimation method setWorkspaceProperty.

/**
 * Starts a transition animation for the workspace.
 */
private void setWorkspaceProperty(LauncherState state, PropertySetter propertySetter, StateAnimationConfig config) {
    ScaleAndTranslation scaleAndTranslation = state.getWorkspaceScaleAndTranslation(mLauncher);
    ScaleAndTranslation hotseatScaleAndTranslation = state.getHotseatScaleAndTranslation(mLauncher);
    ScaleAndTranslation qsbScaleAndTranslation = state.getQsbScaleAndTranslation(mLauncher);
    mNewScale = scaleAndTranslation.scale;
    PageAlphaProvider pageAlphaProvider = state.getWorkspacePageAlphaProvider(mLauncher);
    final int childCount = mWorkspace.getChildCount();
    for (int i = 0; i < childCount; i++) {
        applyChildState(state, (CellLayout) mWorkspace.getChildAt(i), i, pageAlphaProvider, propertySetter, config);
    }
    int elements = state.getVisibleElements(mLauncher);
    Interpolator fadeInterpolator = config.getInterpolator(ANIM_WORKSPACE_FADE, pageAlphaProvider.interpolator);
    boolean playAtomicComponent = config.playAtomicOverviewScaleComponent();
    Hotseat hotseat = mWorkspace.getHotseat();
    // Since we set the pivot relative to mWorkspace, we need to scale a sibling of Workspace.
    AllAppsContainerView qsbScaleView = mLauncher.getAppsView();
    View qsbView = qsbScaleView.getSearchView();
    if (playAtomicComponent) {
        Interpolator scaleInterpolator = config.getInterpolator(ANIM_WORKSPACE_SCALE, ZOOM_OUT);
        LauncherState fromState = mLauncher.getStateManager().getState();
        boolean shouldSpring = propertySetter instanceof PendingAnimation && fromState == HINT_STATE && state == NORMAL;
        if (shouldSpring) {
            ((PendingAnimation) propertySetter).add(getSpringScaleAnimator(mLauncher, mWorkspace, mNewScale));
        } else {
            propertySetter.setFloat(mWorkspace, SCALE_PROPERTY, mNewScale, scaleInterpolator);
        }
        setPivotToScaleWithWorkspace(hotseat);
        setPivotToScaleWithWorkspace(qsbScaleView);
        float hotseatScale = hotseatScaleAndTranslation.scale;
        if (shouldSpring) {
            PendingAnimation pa = (PendingAnimation) propertySetter;
            pa.add(getSpringScaleAnimator(mLauncher, hotseat, hotseatScale));
            pa.add(getSpringScaleAnimator(mLauncher, qsbScaleView, qsbScaleAndTranslation.scale));
        } else {
            Interpolator hotseatScaleInterpolator = config.getInterpolator(ANIM_HOTSEAT_SCALE, scaleInterpolator);
            propertySetter.setFloat(hotseat, SCALE_PROPERTY, hotseatScale, hotseatScaleInterpolator);
            propertySetter.setFloat(qsbScaleView, SCALE_PROPERTY, qsbScaleAndTranslation.scale, hotseatScaleInterpolator);
        }
        float hotseatIconsAlpha = (elements & HOTSEAT_ICONS) != 0 ? 1 : 0;
        propertySetter.setViewAlpha(hotseat, hotseatIconsAlpha, fadeInterpolator);
        propertySetter.setViewAlpha(mLauncher.getWorkspace().getPageIndicator(), hotseatIconsAlpha, fadeInterpolator);
    }
    if (config.onlyPlayAtomicComponent()) {
        // Only the alpha and scale, handled above, are included in the atomic animation.
        return;
    }
    Interpolator translationInterpolator = !playAtomicComponent ? LINEAR : config.getInterpolator(ANIM_WORKSPACE_TRANSLATE, ZOOM_OUT);
    propertySetter.setFloat(mWorkspace, VIEW_TRANSLATE_X, scaleAndTranslation.translationX, translationInterpolator);
    propertySetter.setFloat(mWorkspace, VIEW_TRANSLATE_Y, scaleAndTranslation.translationY, translationInterpolator);
    Interpolator hotseatTranslationInterpolator = config.getInterpolator(ANIM_HOTSEAT_TRANSLATE, translationInterpolator);
    propertySetter.setFloat(hotseat, VIEW_TRANSLATE_Y, hotseatScaleAndTranslation.translationY, hotseatTranslationInterpolator);
    propertySetter.setFloat(mWorkspace.getPageIndicator(), VIEW_TRANSLATE_Y, hotseatScaleAndTranslation.translationY, hotseatTranslationInterpolator);
    propertySetter.setFloat(qsbView, VIEW_TRANSLATE_Y, qsbScaleAndTranslation.translationY, hotseatTranslationInterpolator);
    setScrim(propertySetter, state);
}