Android launcher 桌面抽屉切换动画

最新推荐文章于 2024-05-14 08:17:33 发布
最新推荐文章于 2024-05-14 08:17:33 发布
阅读量1w 收藏 8
点赞数 3
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangjinyu501/article/details/41082379
版权
版本：1.0
日期：2014.11.10 2014.11.11
版权：© 2014 kince 转载注明出处

一、概述

    桌面抽屉之间的切换时Android用户经常触发的行为，好的交互会给用户一个舒适的体验。百度桌面默认是随机切换不同的动画，Android默认是一个大小和透明的渐变的动画，如下：

  
  下面开始分析在Launcher2（KitKat）的源码里面是如何实现这种效果的。

二、下面列举相关的方法和变量 

4082：
interface LauncherTransitionable {
    View getContent();
    void onLauncherTransitionPrepare(Launcher l, boolean animated, boolean toWorkspace);
    void onLauncherTransitionStart(Launcher l, boolean animated, boolean toWorkspace);
    void onLauncherTransitionStep(Launcher l, float t);
    void onLauncherTransitionEnd(Launcher l, boolean animated, boolean toWorkspace);
}
2948：
exitSpringLoadedDragMode()
2926：
exitSpringLoadedDragModeDelayed()

2918：
enterSpringLoadedDragMode()

2899：
showAllApps()

2864：
showWorkspace()

2860：
showWorkspace()

2740：
hideAppsCustomizeHelper()

2573：
showAppsCustomizeHelper()

2498：
dispatchOnLauncherTransitionPrepare()

2097：
onClickAllAppsButton()

2048：
onTouch()

2008：
onClick()

1976：
onBackPressed()

1456：
onNewIntent

1273：
mReceiver

749：
onResume()

三、分析

  首先从最直观的方式开始，就是Dock栏进入抽屉的按钮。点击它会从桌面到抽屉，进入抽屉后再按返回键会从抽屉到桌面。这个按钮在Launcher类中对应的变量是 mAllAppsButton， 因为Launcher类继承了 View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks,View.OnTouchListener这几个接口，所以点击事情需要由 onClick(View v)方法来处理。在Launcher类的 onClick(View v)方法中， 
/**
     * Launches the intent referred by the clicked shortcut.
     *
     * @param v The view representing the clicked shortcut.
     */
    public void onClick(View v) {
        // Make sure that rogue clicks don't get through while allapps is launching, or after the
        // view has detached (it's possible for this to happen if the view is removed mid touch).
        if (v.getWindowToken() == null) {
            return;
        }

        if (!mWorkspace .isFinishedSwitchingState()) {
            return;
        }

        Object tag = v.getTag();
        if (tag instanceof ShortcutInfo) {
            // Open shortcut
            final Intent intent = ((ShortcutInfo) tag).intent;
            int[] pos = new int[2];
            v.getLocationOnScreen(pos);
            intent.setSourceBounds( new Rect(pos[0], pos[1],
                    pos[0] + v.getWidth(), pos[1] + v.getHeight()));

            boolean success = startActivitySafely(v, intent, tag);

            if (success && v instanceof BubbleTextView) {
                mWaitingForResume = (BubbleTextView) v;
                mWaitingForResume.setStayPressed(true);
            }
        } else if (tag instanceof FolderInfo) {
            if (v instanceof FolderIcon) {
                FolderIcon fi = (FolderIcon) v;
                handleFolderClick(fi);
            }
        } else if (v == mAllAppsButton ) {
            if (isAllAppsVisible()) {
                showWorkspace( true);
            } else {
                onClickAllAppsButton(v);
            }
        }
    }
  
  从标注地方可以看出，首先对View进行一个判断，如果是mAllAppsButton则开始下面的判断。如果是在抽屉里面，则进入到桌面；如果不是抽屉，则调用onClickAllAppsButton(v)方法。而onClickAllAppsButton(v)方法就是调用showAllApps方法，顾名思义就是进入后抽屉显示所有的app。接着在抽屉里面，如果要返回桌面，按Back键的话会调用onKeyDown或者onBackPressed()方法。
   
 @Override
    public boolean onKeyDown( int keyCode, KeyEvent event) {
        final int uniChar = event.getUnicodeChar();
        final boolean handled = super.onKeyDown(keyCode, event);
        final boolean isKeyNotWhitespace = uniChar > 0 && !Character.isWhitespace(uniChar);
        if (!handled && acceptFilter() && isKeyNotWhitespace) {
            boolean gotKey = TextKeyListener.getInstance().onKeyDown( mWorkspace, mDefaultKeySsb,
                    keyCode, event);
            if (gotKey && mDefaultKeySsb != null && mDefaultKeySsb.length() > 0) {
                // something usable has been typed - start a search
                // the typed text will be retrieved and cleared by
                // showSearchDialog()
                // If there are multiple keystrokes before the search dialog takes focus,
                // onSearchRequested() will be called for every keystroke,
                // but it is idempotent , so it's fine.
                return onSearchRequested();
            }
        }

        // Eat the long press event so the keyboard doesn't come up.
        if (keyCode == KeyEvent.KEYCODE_MENU && event.isLongPress()) {
            return true ;
        }

        return handled;
    }
    可以看到在onKeyDown方法中，没有任何关于进出抽屉或者桌面的方法。那么再来看一下onBackPressed()方法： 
  @Override
    public void onBackPressed() {
        if (isAllAppsVisible()) {
            showWorkspace( true);
        } else if (mWorkspace .getOpenFolder() != null) {
            Folder openFolder = mWorkspace.getOpenFolder();
            if (openFolder.isEditingName()) {
                openFolder.dismissEditingName();
            } else {
                closeFolder();
            }
        } else {
            mWorkspace.exitWidgetResizeMode();

            // Back button is a no-op here, but give at least some feedback for the button press
            mWorkspace.showOutlinesTemporarily();
        }
    }
 发现在这里处理了切换的过程。现在可以确定是显示桌面调用的是showWorkspace()方法，进入抽屉调用的是showAllApps()方法。在这两个方法中，又各自调用不同的方法实现各自的逻辑。
  那么这两个方法都是在上面情况下调用的呢？先看showAllApps()方法。
launcher.java类：
1、onResume()
2、onClickAllAppsButton

  再看一下showWorkspace()的情况，
1、onResume()
2、mReceiver()
3、onNewIntent()
4、startSearch()
5、startWallpaper()
6、onBackPressed()
7、onClick()
8、onTouch()
9、showWorkspace()
10、exitSpringLoadedDragModeDelayed()
  可以发现showAllApps()方法只有被调用两次，而showWorkspace()有十次之多。这说明返回桌面的情形比返回抽屉的情况要多很多，而实际的使用情况也确实是这样的。
  
  接着分别看一下showAllApps()和showWorkspace()各自的具体实现。 
 void showAllApps( boolean animated) {
        if (mState != State.WORKSPACE) return;
        showAppsCustomizeHelper(animated, false);
        mAppsCustomizeTabHost.requestFocus();
        // Change the state *after* we've called all the transition code
        mState = State. APPS_CUSTOMIZE;
        // Pause the auto-advance of widgets until we are out of AllApps
        mUserPresent = false ;
        updateRunning();
        closeFolder();
        // Send an accessibility event to announce the context change
        getWindow().getDecorView()
                .sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
    }
   逐行分析下，第一行是一个判断，如果当前的状态不是在桌面，那么就退出这个方法。第二行代码就是进入抽屉的动画方法。
第三行代码是给抽屉界面焦点。第四行代码进入抽屉后更改当前的状态。之后就不细说了。重点还是showAppsCustomizeHelper(animated, false );这个方法，它就是实现进入抽屉动画的方法。来到这个方法，发现其上面有很长的注释： 
 /**
     * Things to test when changing the following seven functions.
     *   - Home from workspace
     *          - from center screen
     *          - from other screens
     *   - Home from all apps
     *          - from center screen
     *          - from other screens
     *   - Back from all apps
     *          - from center screen
     *          - from other screens
     *   - Launch app from workspace and quit
     *          - with back
     *          - with home
     *   - Launch app from all apps and quit
     *          - with back
     *          - with home
     *   - Go to a screen that's not the default, then all
     *     apps, and launch and app, and go back
     *          - with back
     *          -with home
     *   - On workspace, long press power and go back
     *          - with back
     *          - with home
     *   - On all apps, long press power and go back
     *          - with back
     *          - with home
     *   - On workspace, power off
     *   - On all apps, power off
     *   - Launch an app and turn off the screen while in that app
     *          - Go back with home key
     *          - Go back with back key  TODO: make this not go to workspace
     *          - From all apps
     *          - From workspace
     *   - Enter and exit car mode (becuase it causes an extra configuration changed)
     *          - From all apps
     *          - From the center workspace
     *          - From another workspace
     */
  注释下面是 showAppsCustomizeHelper()和 hideAppsCustomizeHelper()两个方法，顾名思义 hideAppsCustomizeHelper就是离开抽屉的动画实现方法，这两个方法是相对立的。 
/**
     * Zoom the camera out from the workspace to reveal 'toView'.
     * Assumes that the view to show is anchored at either the very top or very bottom
     * of the screen.
     */
    private void showAppsCustomizeHelper(final boolean animated, final boolean springLoaded) {
        if (mStateAnimation != null) {
            mStateAnimation.setDuration(0);
            mStateAnimation.cancel();
            mStateAnimation = null ;
        }
        final Resources res = getResources();

        final int duration = res.getInteger(R.integer.config_appsCustomizeZoomInTime );
        final int fadeDuration = res.getInteger(R.integer.config_appsCustomizeFadeInTime );
        final float scale = (float) res.getInteger(R.integer.config_appsCustomizeZoomScaleFactor );
        final View fromView = mWorkspace ;
        final AppsCustomizeTabHost toView = mAppsCustomizeTabHost;
        final int startDelay =
                res.getInteger(R.integer.config_workspaceAppsCustomizeAnimationStagger );

        setPivotsForZoom(toView, scale);

        // Shrink workspaces away if going to AppsCustomize from workspace
        Animator workspaceAnim =
                mWorkspace.getChangeStateAnimation(Workspace.State.SMALL, animated);

        if (animated) {
            toView.setScaleX(scale);
            toView.setScaleY(scale);
            final LauncherViewPropertyAnimator scaleAnim = new LauncherViewPropertyAnimator(toView);
            scaleAnim.
                scaleX(1f).scaleY(1f).
                setDuration(duration).
                setInterpolator( new Workspace.ZoomOutInterpolator());

            toView.setVisibility(View. VISIBLE);
            toView.setAlpha(0f);
            final ObjectAnimator alphaAnim = LauncherAnimUtils
                . ofFloat(toView, "alpha", 0f, 1f)
                .setDuration(fadeDuration);
            alphaAnim.setInterpolator( new DecelerateInterpolator(1.5f));
            alphaAnim.addUpdateListener( new AnimatorUpdateListener() {
                @Override
                public void onAnimationUpdate(ValueAnimator animation) {
                    if (animation == null) {
                        throw new RuntimeException("animation is null" );
                    }
                    float t = (Float) animation.getAnimatedValue();
                    dispatchOnLauncherTransitionStep(fromView, t);
                    dispatchOnLauncherTransitionStep(toView, t);
                }
            });

            // toView should appear right at the end of the workspace shrink
            // animation
            mStateAnimation = LauncherAnimUtils.createAnimatorSet();
            mStateAnimation.play(scaleAnim).after(startDelay);
            mStateAnimation.play(alphaAnim).after(startDelay);

            mStateAnimation.addListener(new AnimatorListenerAdapter() {
                boolean animationCancelled = false;

                @Override
                public void onAnimationStart(Animator animation) {
                    updateWallpaperVisibility( true);
                    // Prepare the position
                    toView.setTranslationX(0.0f);
                    toView.setTranslationY(0.0f);
                    toView.setVisibility(View. VISIBLE);
                    toView.bringToFront();
                }
                @Override
                public void onAnimationEnd(Animator animation) {
                    dispatchOnLauncherTransitionEnd(fromView, animated, false);
                    dispatchOnLauncherTransitionEnd(toView, animated, false);

                    if (mWorkspace != null && !springLoaded && !LauncherApplication.isScreenLarge()) {
                        // Hide the workspace scrollbar
                        mWorkspace.hideScrollingIndicator(true);
                        hideDockDivider();
                    }
                    if (!animationCancelled ) {
                        updateWallpaperVisibility( false);
                    }

                    // Hide the search bar
                    if (mSearchDropTargetBar != null) {
                        mSearchDropTargetBar.hideSearchBar(false);
                    }
                }

                @Override
                public void onAnimationCancel(Animator animation) {
                    animationCancelled = true ;
                }
            });

            if (workspaceAnim != null) {
                mStateAnimation.play(workspaceAnim);
            }

            boolean delayAnim = false;

            dispatchOnLauncherTransitionPrepare(fromView, animated, false);
            dispatchOnLauncherTransitionPrepare(toView, animated, false);

            // If any of the objects being animated haven't been measured/laid out
            // yet, delay the animation until we get a layout pass
            if ((((LauncherTransitionable) toView).getContent().getMeasuredWidth() == 0) ||
                    ( mWorkspace.getMeasuredWidth() == 0) ||
                    (toView.getMeasuredWidth() == 0)) {
                delayAnim = true;
            }

            final AnimatorSet stateAnimation = mStateAnimation;
            final Runnable startAnimRunnable = new Runnable() {
                public void run() {
                    // Check that mStateAnimation hasn't changed while
                    // we waited for a layout/draw pass
                    if (mStateAnimation != stateAnimation)
                        return;
                    setPivotsForZoom(toView, scale);
                    dispatchOnLauncherTransitionStart(fromView, animated, false);
                    dispatchOnLauncherTransitionStart(toView, animated, false);
                    LauncherAnimUtils.startAnimationAfterNextDraw( mStateAnimation, toView);
                }
            };
            if (delayAnim) {
                final ViewTreeObserver observer = toView.getViewTreeObserver();
                observer.addOnGlobalLayoutListener( new OnGlobalLayoutListener() {
                        public void onGlobalLayout() {
                            startAnimRunnable.run();
                            toView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
                        }
                    });
            } else {
                startAnimRunnable.run();
            }
        } else {
            toView.setTranslationX(0.0f);
            toView.setTranslationY(0.0f);
            toView.setScaleX(1.0f);
            toView.setScaleY(1.0f);
            toView.setVisibility(View. VISIBLE);
            toView.bringToFront();

            if (!springLoaded && !LauncherApplication.isScreenLarge()) {
                // Hide the workspace scrollbar
                mWorkspace.hideScrollingIndicator(true);
                hideDockDivider();

                // Hide the search bar
                if (mSearchDropTargetBar != null) {
                    mSearchDropTargetBar.hideSearchBar(false);
                }
            }
            dispatchOnLauncherTransitionPrepare(fromView, animated, false);
            dispatchOnLauncherTransitionStart(fromView, animated, false);
            dispatchOnLauncherTransitionEnd(fromView, animated, false);
            dispatchOnLauncherTransitionPrepare(toView, animated, false);
            dispatchOnLauncherTransitionStart(toView, animated, false);
            dispatchOnLauncherTransitionEnd(toView, animated, false);
            updateWallpaperVisibility( false);
        }
    }
   变量mStateAnimation的类型是AnimatorSet，是专门负责上述两个方法里面的动画执行。变量duration、fadeDuration、scale分别是进入抽屉动画的伸缩的时间、透明度改变的时间以及伸缩的大小。从下面两行代码可以看出 
final View fromView = mWorkspace;
final AppsCustomizeTabHost toView = mAppsCustomizeTabHost ;
fromView就是桌面，而toView就是抽屉。startDelay是动画之前的准备时间。
setPivotsForZoom(toView, scale);方法是对View进行一个缩放，scale是缩放的参数。
workspaceAnim是桌面消失的动画，先不去看具体实现。如果有动画需求进入if判断，在这里有一个scaleAnim和alphaAnim，这就是抽屉出现的动画，从代码 
mStateAnimation = LauncherAnimUtils.createAnimatorSet();
mStateAnimation.play(scaleAnim).after(startDelay);
mStateAnimation.play(alphaAnim).after(startDelay);
可以看出二者同时执行。接着是mStateAnimation动画的回调接口，具体逻辑不再分析。然后如果workspaceAnim不为空的话，就执行说明消失的动画。再看delayAnim变量，这是用来判断是否需要延迟动画执行。如果需要的话就监听View树是绘制，绘制完毕之后再执行动画；否则执行进入抽屉的动画。 还有一个重要的地方是在在上面的方法中出现了 
dispatchOnLauncherTransitionPrepare(fromView, animated, false);
dispatchOnLauncherTransitionStart(fromView, animated, false);
dispatchOnLauncherTransitionEnd(fromView, animated, false);
等方法。其实这是在Launcher类中定义的接口里面的方法，具体如下： 
interface LauncherTransitionable {
     View getContent();

      void onLauncherTransitionPrepare(Launcher l, boolean animated,
               boolean toWorkspace);

      void onLauncherTransitionStart(Launcher l, boolean animated,
               boolean toWorkspace);

      void onLauncherTransitionStep(Launcher l, float t);

      void onLauncherTransitionEnd(Launcher l, boolean animated,
               boolean toWorkspace);
}
  分别在Workspace、AppsCustomizePagedView、AppsCustomizeTabHost、PagedView中继承这个接口。 最后回过头看一下桌面消失动画的实现，它是在Workspace类里面处理的。 
  Animator getChangeStateAnimation (final SizeState state, boolean animated, int delay) {
     Log.i(TAG, "getChangeStateAnimation");
     
        if (mSizeState == state) {
            return null ;
        }
        // Initialize animation arrays for the first time if necessary
        initAnimationArrays();

        AnimatorSet anim = animated ? LauncherAnimUtils.createAnimatorSet() : null;

        // Stop any scrolling, move to the current page right away
        setCurrentPage(getNextPage());

        final boolean isEditViewMode = isEditViewMode(state);
       
        final SizeState oldState = mSizeState ;
        final boolean oldStateIsNormal = (oldState == SizeState.NORMAL);
        final boolean oldStateIsSpringLoaded = (oldState == SizeState.SPRING_LOADED );
        final boolean oldStateIsSmall = (oldState == SizeState.SMALL);
        mSizeState = state;
        final boolean stateIsNormal = (state == SizeState.NORMAL);
        final boolean stateIsSpringLoaded = (state == SizeState.SPRING_LOADED );
        final boolean stateIsSmall = (state == SizeState.SMALL);
        float finalScaleFactor = 1.0f;
        float finalBackgroundAlpha = (stateIsSpringLoaded || isEditViewMode) ? 1.0f: 0f;
        float translationX = 0;
        float translationY = 0;

        boolean zoomIn = true;

        if (state != SizeState.NORMAL) {
               if (isEditViewMode) {
                   finalScaleFactor = getCellLayoutScale(state);
              } else {
                   finalScaleFactor = mSpringLoadedShrinkFactor- (state == SizeState.SMALL ? 0.1f : 0);
              }
            finalScaleFactor = mSpringLoadedShrinkFactor - (stateIsSmall ? 0.1f : 0);
            setPageSpacing(mSpringLoadedPageSpacing);
            if (oldStateIsNormal && stateIsSmall) {
                zoomIn = false;
                setLayoutScale(finalScaleFactor);
                updateChildrenLayersEnabled( false);
            } else {
                finalBackgroundAlpha = 1.0f;
                setLayoutScale(finalScaleFactor);
            }
        } else {
            setPageSpacing(mOriginalPageSpacing);
            setLayoutScale(1.0f);
        }

        final int duration;
        if (isEditViewMode) {
              duration = getResources().getInteger(R.integer.config_overviewTransitionTime );
          } else if (zoomIn) {
              duration = getResources().getInteger(R.integer.config_workspaceUnshrinkTime );
          } else {
              duration = getResources().getInteger(R.integer.config_appsCustomizeWorkspaceShrinkTime );
          }
       
        for (int i = 0; i < getChildCount(); i++) {
            final CellLayout cl = (CellLayout) getChildAt(i);
            float finalAlpha = (!mWorkspaceFadeInAdjacentScreens || stateIsSpringLoaded ||(i == mCurrentPage)) ? 1f : 0f;                   
            float currentAlpha = cl.getShortcutsAndWidgets().getAlpha();
            float initialAlpha = currentAlpha;
           
            // Determine the pages alpha during the state transition
            if ((oldStateIsSmall && stateIsNormal) || (oldStateIsNormal && stateIsSmall)) {
                // To/from workspace - only show the current page unless the transition is not
                //                     animated and the animation end callback below doesn't run;
                //                     or, if we're in spring-loaded mode
                if (i == mCurrentPage || !animated || oldStateIsSpringLoaded) {         
                    finalAlpha = 1f;
                } else {
                    initialAlpha = 0f;
                    finalAlpha = 0f;
                }
            }

            mOldAlphas[i] = initialAlpha;
            mNewAlphas[i] = finalAlpha;
            if (animated) {
                mOldTranslationXs[i] = cl.getTranslationX();
                mOldTranslationYs[i] = cl.getTranslationY();
                mOldScaleXs[i] = cl.getScaleX();
                mOldScaleYs[i] = cl.getScaleY();
                mOldBackgroundAlphas[i] = cl.getBackgroundAlpha();

                mNewTranslationXs[i] = translationX;
                mNewTranslationYs[i] = translationY;
                mNewScaleXs[i] = finalScaleFactor;
                mNewScaleYs[i] = finalScaleFactor;
                mNewBackgroundAlphas[i] = finalBackgroundAlpha;
            } else {
                cl.setTranslationX(translationX);
                cl.setTranslationY(translationY);
                cl.setScaleX(finalScaleFactor);
                cl.setScaleY(finalScaleFactor);
                cl.setBackgroundAlpha(finalBackgroundAlpha);
                cl.setShortcutAndWidgetAlpha(finalAlpha);
            }
            cl.isEditViewMode(isEditViewMode);
        }

        if (animated) {
            for (int index = 0; index < getChildCount(); index++) {
                final int i = index;
                final CellLayout cl = (CellLayout) getChildAt(i);
                float currentAlpha = cl.getShortcutsAndWidgets().getAlpha();
                if (mOldAlphas [i] == 0 && mNewAlphas[i] == 0) {
                    cl.setTranslationX(mNewTranslationXs [i]);
                    cl.setTranslationY(mNewTranslationYs [i]);
                    cl.setScaleX( mNewScaleXs[i]);
                    cl.setScaleY( mNewScaleYs[i]);
                    cl.setBackgroundAlpha(mNewBackgroundAlphas [i]);
                    cl.setShortcutAndWidgetAlpha(mNewAlphas [i]);
                    cl.setRotationY( mNewRotationYs[i]);
                } else {
                    LauncherViewPropertyAnimator a = new LauncherViewPropertyAnimator(cl);
                    a.translationX( mNewTranslationXs[i])
                        .translationY(mNewTranslationYs [i])
                        .scaleX( mNewScaleXs[i])
                        .scaleY( mNewScaleYs[i])
                        .setDuration(duration)
                        .setInterpolator(mZoomInInterpolator );
                    anim.play(a);

                    if (mOldAlphas [i] != mNewAlphas [i] || currentAlpha != mNewAlphas [i]) {
                        LauncherViewPropertyAnimator alphaAnim =
                            new LauncherViewPropertyAnimator(cl.getShortcutsAndWidgets());
                        alphaAnim.alpha( mNewAlphas[i])
                            .setDuration(duration)
                            .setInterpolator(mZoomInInterpolator );
                        anim.play(alphaAnim);
                    }
                    if (mOldBackgroundAlphas [i] != 0 ||
                        mNewBackgroundAlphas[i] != 0) {
                        ValueAnimator bgAnim =
                                LauncherAnimUtils.ofFloat(cl, 0f, 1f).setDuration(duration);
                        bgAnim.setInterpolator(mZoomInInterpolator );
                        bgAnim.addUpdateListener( new LauncherAnimatorUpdateListener() {
                                public void onAnimationUpdate(float a, float b) {
                                    cl.setBackgroundAlpha(
                                            a * mOldBackgroundAlphas[i] +
                                            b * mNewBackgroundAlphas[i]);
                                }
                            });
                        anim.play(bgAnim);
                    }
                }
            }
            anim.setStartDelay(delay);
        }

        if (stateIsSpringLoaded) {
            // Right now we're covered by Apps Customize
            // Show the background gradient immediately, so the gradient will
            // be showing once AppsCustomize disappears
            animateBackgroundGradient(getResources().getInteger(
                    R.integer.config_appsCustomizeSpringLoadedBgAlpha ) / 100f, false);
        } else {
            // Fade the background gradient away
            animateBackgroundGradient(0f, true);
        }
        return anim;
    }
  在说明方法之前先说一下，Launcher2和Launcher3桌面消失动画的区别。Launcher2进入抽屉后是一个黑色的背景，没有壁纸显示效果，而Launcher3可以看到壁纸。所以getChangeStateAnimation 方法也是有一定区别的。关于这个方法大体可以分为三个部分，一是变量初始赋值阶段，二是动画设置阶段，三是动画返回阶段。重点是第二个动画设置阶段，因为桌面的消失、出现都会调用这个方法。同样的关于这个动画最主要的部分还是伸缩和透明度的变化，理论上应该是这样的，桌面消失时开始变小、透明度逐渐不可见；桌面出现时开始变大、透明度逐渐可见。
  不过从这个方法的实现来看，其性能消耗比较大。它是用一个for循环来遍历Workspace的CellLayout的个数，也就是有几个桌面。然后再对每个CellLayout进行一个动画效果。亲测在低端机器上比如联想s868t是非常卡顿的。
  hideAppsCustomizeHelper()的实现就不再赘述，和showAppsCustomizeHelper()实现机制都是一样的。那么最后总结一下，从桌面进入抽屉调用
hideAppsCustomizeHelper()方法，这个方法实现进入抽屉的动画效果，具体说就是对抽屉这个View进行一个动画。在这方法里面还有一个桌面消失的动画getChangeStateAnimation ，在这个动画执行完毕后才会执行进入抽屉的动画。然后从抽屉返回桌面正好是相反的流程。现在很多桌面进入抽屉都会有其他的动画效果，比如反转、上下等效果，其实就是对以上三个方法进行修改添加就可以了。











凤凰星河
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
猿创征文｜Android 11.0 12.0Launcher3 时钟动态图标的定制化
安卓兼职framework和app工程师的博客
09-13 831
在Launcher3桌面的app列表页中，时钟图标默认是静态图标，但是由于时钟是时时刻刻在变化的，所以动态 图标更符合实际要求，所以根据需要定制动态时钟图标
Android13 launcher循环切页
纵容的博客
11-24 667
launcher 常规切页：https://blog.csdn.net/a396604593/article/details/125305234。 基于Android 13 原生launcher实现循环切页功能
launcher3切屏动态效果
04-07
launcher3动画效果源码，只供学习使用。
2024年Android最新Android Launcher——ui框架(1)，嵌入式开发工程师面试
最新发布
2401_84561807的博客
05-14 482
写到这里也结束了，在文章最后放上一个小小的福利，以下为小编自己在学习过程中整理出的一个关于Flutter的学习思路及方向，从事互联网开发，最主要的是要学好技术，而学习技术是一条慢长而艰苦的道路，不能靠一时激情，也不是熬几天几夜就能学好的，必须养成平时努力学习的习惯，更加需要准确的学习方向达到有效的学习效果。由于内容较多就只放上一个大概的大纲，需要更及详细的学习思维导图的。
Android Launcher修改--左右滑动屏幕切换源码追踪
xujiangang_mmi的专栏
12-22 890
在Android的源代码中，屏幕之间的跳转是如何实现的呢？在workspace.java中开始。在这个类中，为实现屏幕切换主要重写了以下几个方法：onMeasure（）、onLayout（）、onInterceptTouchEvent（）、onTouchEvent（）方法，另外还是用了CustomScroller mScroller来平滑过渡各个页面之间的切换。 首先，我们看一下onMe
android页指示动画,Android动画（launcher 的平滑和立体翻页效果）
weixin_30719609的博客
05-25 404
我们这里把 Android launcher 程序的 Workspace 相关的代码抽取出来，以一个比较简单的代码来展示launcher 程序是如何实现多页以及不同页面之间的切换效果。本示例代码在 SDK 2.1 中运行，设置的是 WVGA的屏幕大小。首先我们来看一下程序运行的效果来一些感性的认识。图 1：平滑移动效果图 2：立体翻页效果接着我们来看一下程序 UI(即 View 和 ViewGro...
Android应用源码之Android Launcher 桌面分页滑动代码.zip
10-22
本压缩包提供的"Android应用源码之Android Launcher 桌面分页滑动代码"是一个深入理解Android Launcher工作原理的好资源，特别是对于想了解如何实现桌面滑动效果的开发者来说，这是非常有价值的参考资料。...
Android11 Launcher3
06-27
Android 11中的Launcher3是系统启动器的主要组件，它是用户与设备交互的门户，负责显示应用图标、桌面壁纸、小部件等。Launcher3不仅承担着应用启动的任务，还管理着用户的主屏幕布局、搜索功能以及各种个性化设置。...
Launcher3_android原生launcher_
10-01
- Android 5.1的Launcher3引入了流畅的动画效果，如平滑的页面切换、缩放和淡入淡出。 - 动画效果的实现基于Android的`PropertyAnimator`和`ViewPropertyAnimator`类。 8. **内存管理和内存泄漏**： - Launcher3...
Launcher3_androidlauncher_android开发_
09-29
【Android Launcher 开发详解】 Android Launcher，作为用户与设备交互的入口，是Android系统的核心组件之一。本主题将深入探讨如何开发一个自定义的Android Launcher，以"Launcher3"为例，它是Android开源项目AOSP...
android 8.0 launcher3 增加动态日历图标
maikel0maikel的专栏
12-09 641
在android 8.0 launcher3 增加动态日历图标，做个记录。 第一步：在LauncherAppState.java里添加过滤器（主要是监听时间、日期改变广播action): //*********add start*********************************// filter.addAction(Intent.ACTION_DATE_CHANGED); filter.addAction(Intent.A...
Android13-修改主界面apk摆放位置（Launcher3）
李予浙的博客
08-02 1164
Android13-修改主界面apk摆放位置（Launcher3）
Android页面滑动加旋转特效总结 !!!!
dylancao的专栏
06-13 1758
ViewPage代码改写增加翻转和缩放效果 （本文属于个人经验总结，如有理解偏差，即使沟通）   1.     一般平移滑动效果原理： 拿ViewPager源码举例（ViewPager代码可以在新版SDK中找到），它继承了ViewGroup，如果实现3屏滑动，需将3个将要展示的页面添加到ViewGroup中去，通过触摸事件来计算滑动距离，使用scrollTo或者Scroller中的st
android 添加Launcher的旋转效果
weixin_30762087的博客
02-07 255
此配置合适Launcher2以及3 Changed paths: M /trunk/LINUX/android/packages/apps/Launcher3/res/values/config.xml Modified: trunk/LINUX/android/packages/apps/Launcher3/res/values/config.xml --- trunk/LINUX/androi...
Android 手势导航（Launcher3 部分）
tq501501的博客
09-01 5710
手势导航功能的实现主要由 SystemUI + Launcher3 共同处理，在 Launcher3 中启动一个Services Launcher3/quickstep/recents_ui_overrides/src/com/android/quickstep/TouchInteractionService.java
android跳转界面动画,android页面之间切换的转场动画的两种方法
weixin_29409045的博客
05-25 1243
首先新建一个anim的资源包，分别创建slide_in_from_right 、slide_out_to_left slide_out_to_right、slide_in_from_left 这里是实现的左右切换 使用到的动画主要是位移动画好了 我们先来看一下slide_in_from_right根据文件名可以知道是页面从左到右进入的动画，从100到0 我们又知道根据手机的坐标特性 如图：从...
Android抽屉动画-----DrawerLayout的简单使用
m0_47761892的博客
07-29 1354
文章目录一、简介二、修改布局文件三、添加主界面和侧滑界面四、控制侧滑界面的状态五、为侧滑界面添加事件监听器六、侧滑界面上控件的响应事件 一、简介 DrawerLayout 是 Google 推出的一款能够实现侧滑效果的控件，可以实现如同网易云音乐的左侧菜单效果。实现简单，且提供了很多操作方法，可满足日常的使用。由于 AndroidX 已替代 support 使用，故 DrawerLayout 类目前位于 androidx.drawerlayout.widget 包下。 官方文档：https://develo
Android 动画实现原理
lin327332599的专栏
03-03 1172
最近在Android上做了一些动画效果，网上查了一些资料，有各种各样的使用方式，于是乘热打铁，想具体分析一下动画是如何实现的，Animation, Animator都有哪些区别等等。
Android P Car Launcher
凡人的专栏
06-11 918
Android P Automotive开机后的待机界面如下： 许久为做UI界面了，不知从何时起，Android系统的一些icon用的是Vector来实现的 界面底部的Navigation Bar：car_navigation_bar.xml //对应Navigation Bar的圆圈Button <com.android.systemui.statusbar.car.CarNavigationButton android:id="@+id/home"
android 实现launcher式抽屉
03-28
要实现一个Launcher式抽屉，需要使用以下步骤： 1. 创建一个Activity，作为抽屉的主界面。 2. 在该Activity中，使用RecyclerView或ListView等控件来展示应用程序列表。 3. 为每个应用程序创建一个图标和标签，并将它们添加到RecyclerView或ListView中。 4. 实现适配器(Adapter)，用于管理应用程序列表和图标。 5. 实现点击应用程序时打开应用程序的功能。 6. 实现拖动应用程序图标的功能，以便用户可以重新排列应用程序列表。 7. 添加搜索功能，使用户可以根据应用程序名称搜索应用程序。 8. 实现滑动手势，使用户可以从任何屏幕滑动打开抽屉。 9. 添加设置选项，使用户可以自定义抽屉的外观和行为。 10. 最后，测试应用程序以确保它能够正常工作并提供良好的用户体验。 以上是实现Launcher式抽屉的基本步骤，可以根据实际需求进行适当调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值