launcher滑屏特效集合汇总

下面是本人从CM源码中摘录出来的Android Launcher屏幕滑动特效大集合。做记录用，有兴趣的看看。

protected static abstract class TransitionEffect {
	//定义各种动画效果
        public static final String TRANSITION_EFFECT_NONE = "none";
        public static final String TRANSITION_EFFECT_ZOOM_IN = "zoom-in";
        public static final String TRANSITION_EFFECT_ZOOM_OUT = "zoom-out";
        public static final String TRANSITION_EFFECT_ROTATE_UP = "rotate-up";
        public static final String TRANSITION_EFFECT_ROTATE_DOWN = "rotate-down";
        public static final String TRANSITION_EFFECT_CUBE_IN = "cube-in";
        public static final String TRANSITION_EFFECT_CUBE_OUT = "cube-out";
        public static final String TRANSITION_EFFECT_STACK = "stack";
        public static final String TRANSITION_EFFECT_ACCORDION = "accordion";
        public static final String TRANSITION_EFFECT_FLIP = "flip";
        public static final String TRANSITION_EFFECT_CYLINDER_IN = "cylinder-in";
        public static final String TRANSITION_EFFECT_CYLINDER_OUT = "cylinder-out";
        public static final String TRANSITION_EFFECT_CROSSFADE = "crossfade";
        public static final String TRANSITION_EFFECT_OVERVIEW = "overview";


        protected final Workspace mWorkspace;
        private final String mName;


        public TransitionEffect(Workspace workspace, String name) {
            mWorkspace = workspace;
            mName = name;
        }


        public abstract void screenScrolled(View v, int i, float scrollProgress);


        public final String getName() {
            return mName;
        }


        public static void setFromString(Workspace workspace, String effect) { 
            if (effect.equals(Workspace.TransitionEffect.TRANSITION_EFFECT_NONE)) {
                workspace.setTransitionEffect(null);
            } else if (effect.equals(Workspace.TransitionEffect.TRANSITION_EFFECT_ZOOM_IN)) {
                workspace.setTransitionEffect(new Workspace.TransitionEffect.Zoom(workspace, true));
            } else if (effect.equals(Workspace.TransitionEffect.TRANSITION_EFFECT_ZOOM_OUT)) {
                workspace.setTransitionEffect(new Workspace.TransitionEffect.Zoom(workspace, false));
            } else if (effect.equals(Workspace.TransitionEffect.TRANSITION_EFFECT_CUBE_IN)) {
                workspace.setTransitionEffect(new Workspace.TransitionEffect.Cube(workspace, true));
            } else if (effect.equals(Workspace.TransitionEffect.TRANSITION_EFFECT_CUBE_OUT)) {
                workspace.setTransitionEffect(new Workspace.TransitionEffect.Cube(workspace, false));
            } else if (effect.equals(Workspace.TransitionEffect.TRANSITION_EFFECT_ROTATE_UP)) {
                workspace.setTransitionEffect(new Workspace.TransitionEffect.Rotate(workspace, true));
            } else if (effect.equals(Workspace.TransitionEffect.TRANSITION_EFFECT_ROTATE_DOWN)) {
                workspace.setTransitionEffect(new Workspace.TransitionEffect.Rotate(workspace, false));
            } else if (effect.equals(Workspace.TransitionEffect.TRANSITION_EFFECT_STACK)) {
                workspace.setTransitionEffect(new Workspace.TransitionEffect.Stack(workspace));
            } else if (effect.equals(Workspace.TransitionEffect.TRANSITION_EFFECT_ACCORDION)) {
                workspace.setTransitionEffect(new Workspace.TransitionEffect.Accordion(workspace));
            } else if (effect.equals(Workspace.TransitionEffect.TRANSITION_EFFECT_FLIP)) {
                workspace.setTransitionEffect(new Workspace.TransitionEffect.Flip(workspace));
            } else if (effect.equals(Workspace.TransitionEffect.TRANSITION_EFFECT_CYLINDER_IN)) {
                workspace.setTransitionEffect(new Workspace.TransitionEffect.Cylinder(workspace, true));
            } else if (effect.equals(Workspace.TransitionEffect.TRANSITION_EFFECT_CYLINDER_OUT)) {
                workspace.setTransitionEffect(new Workspace.TransitionEffect.Cylinder(workspace, false));
            } else if (effect.equals(Workspace.TransitionEffect.TRANSITION_EFFECT_CROSSFADE)) {
                workspace.setTransitionEffect(new Workspace.TransitionEffect.Crossfade(workspace));
            } else if (effect.equals(Workspace.TransitionEffect.TRANSITION_EFFECT_OVERVIEW)) {
                workspace.setTransitionEffect(new Workspace.TransitionEffect.Overview(workspace));
            }
        }


        public static class Zoom extends TransitionEffect {
            private boolean mIn;


            public Zoom(Workspace workspace, boolean in) {
                super(workspace, in ? TRANSITION_EFFECT_ZOOM_IN : TRANSITION_EFFECT_ZOOM_OUT);
                mIn = in;
            }


            @Override
            public void screenScrolled(View v, int i, float scrollProgress) {
                float scale = 1.0f + (mIn ? -0.8f : 0.4f) * Math.abs(scrollProgress);


                // Extra translation to account for the increase in size
                if (!mIn) {
                    float translationX = v.getMeasuredWidth() * 0.1f * -scrollProgress;
                    v.setTranslationX(translationX);
                }


                v.setScaleX(scale);
                v.setScaleY(scale);
            }
        }


        public static class Rotate extends TransitionEffect {
            private boolean mUp;


            public Rotate(Workspace pagedView, boolean up) {
                super(pagedView, up ? TRANSITION_EFFECT_ROTATE_UP : TRANSITION_EFFECT_ROTATE_DOWN);
                mUp = up;
            }


            @Override
            public void screenScrolled(View v, int i, float scrollProgress) {
                float rotation =
                        (mUp ? TRANSITION_SCREEN_ROTATION : -TRANSITION_SCREEN_ROTATION) * scrollProgress;


                float translationX = v.getMeasuredWidth() * scrollProgress;


                float rotatePoint =
                        (v.getMeasuredWidth() * 0.5f) /
                                (float) Math.tan(Math.toRadians((double) (TRANSITION_SCREEN_ROTATION * 0.5f)));


                v.setPivotX(v.getMeasuredWidth() * 0.5f);
                if (mUp) {
                    v.setPivotY(-rotatePoint);
                } else {
                    v.setPivotY(v.getMeasuredHeight() + rotatePoint);
                }
                v.setRotation(rotation);
                v.setTranslationX(translationX);
            }
        }


        public static class Cube extends TransitionEffect {
            private boolean mIn;


            public Cube(Workspace workspace, boolean in) {
                super(workspace, in ? TRANSITION_EFFECT_CUBE_IN : TRANSITION_EFFECT_CUBE_OUT);
                mIn = in;
            }


            @Override
            public void screenScrolled(View v, int i, float scrollProgress) {
                float rotation = (mIn ? 90.0f : -90.0f) * scrollProgress;


                v.setPivotX(scrollProgress < 0 ? 0 : v.getMeasuredWidth());
                v.setPivotY(v.getMeasuredHeight() * 0.5f);
                v.setRotationY(rotation);
            }
        }


        public static class Stack extends TransitionEffect {
            private ZInterpolator mZInterpolator = new ZInterpolator(0.5f);
            private DecelerateInterpolator mLeftScreenAlphaInterpolator = new DecelerateInterpolator(4);
            protected AccelerateInterpolator mAlphaInterpolator = new AccelerateInterpolator(0.9f);


            public Stack(Workspace workspace) {
                super(workspace, TRANSITION_EFFECT_STACK);
            }


            @Override
            public void screenScrolled(View v, int i, float scrollProgress) {
                final boolean isRtl = mWorkspace.isLayoutRtl();
                float interpolatedProgress;
                float translationX;
                float maxScrollProgress = Math.max(0, scrollProgress);
                float minScrollProgress = Math.min(0, scrollProgress);


                if (mWorkspace.isLayoutRtl()) {
                    translationX = maxScrollProgress * v.getMeasuredWidth();
                    interpolatedProgress = mZInterpolator.getInterpolation(Math.abs(maxScrollProgress));
                } else {
                    translationX = minScrollProgress * v.getMeasuredWidth();
                    interpolatedProgress = mZInterpolator.getInterpolation(Math.abs(minScrollProgress));
                }
                float scale = (1 - interpolatedProgress) +
                        interpolatedProgress * TRANSITION_SCALE_FACTOR;


                float alpha;
                if (isRtl && (scrollProgress > 0)) {
                    alpha = mAlphaInterpolator.getInterpolation(1 - Math.abs(maxScrollProgress));
                } else if (!isRtl && (scrollProgress < 0)) {
                    alpha = mAlphaInterpolator.getInterpolation(1 - Math.abs(scrollProgress));
                } else {
                    //  On large screens we need to fade the page as it nears its leftmost position
                    alpha = mLeftScreenAlphaInterpolator.getInterpolation(1 - scrollProgress);
                }


                v.setTranslationX(translationX);
                v.setScaleX(scale);
                v.setScaleY(scale);
                if (v instanceof CellLayout) {
                    ((CellLayout) v).getShortcutsAndWidgets().setAlpha(alpha);
                } else {
                    v.setAlpha(alpha);
                }


                // If the view has 0 alpha, we set it to be invisible so as to prevent
                // it from accepting touches
                if (alpha == 0) {
                    v.setVisibility(INVISIBLE);
                } else if (v.getVisibility() != VISIBLE) {
                    v.setVisibility(VISIBLE);
                }
            }
        }


        public static class Accordion extends TransitionEffect {
            public Accordion(Workspace workspace) {
                super(workspace, TRANSITION_EFFECT_ACCORDION);
            }


            @Override
            public void screenScrolled(View v, int i, float scrollProgress) {
                float scale = 1.0f - Math.abs(scrollProgress);


                v.setScaleX(scale);
                v.setPivotX(scrollProgress < 0 ? 0 : v.getMeasuredWidth());
                v.setPivotY(v.getMeasuredHeight() / 2f);
            }
        }


        public static class Flip extends TransitionEffect {
            public Flip(Workspace workspace) {
                super(workspace, TRANSITION_EFFECT_FLIP);
            }


            @Override
            public void screenScrolled(View v, int i, float scrollProgress) {
                float rotation = -180.0f * Math.max(-1f, Math.min(1f, scrollProgress));


                v.setCameraDistance(mWorkspace.mDensity * Workspace.CAMERA_DISTANCE);
                v.setPivotX(v.getMeasuredWidth() * 0.5f);
                v.setPivotY(v.getMeasuredHeight() * 0.5f);
                v.setRotationY(rotation);


                if (scrollProgress >= -0.5f && scrollProgress <= 0.5f) {
                    v.setTranslationX(v.getMeasuredWidth() * scrollProgress);
                } else {
                    v.setTranslationX(0f);
                }
            }
        }


        public static class Cylinder extends TransitionEffect {
            private boolean mIn;


            public Cylinder(Workspace workspace, boolean in) {
                super(workspace, in ? TRANSITION_EFFECT_CYLINDER_IN : TRANSITION_EFFECT_CYLINDER_OUT);
                mIn = in;
            }


            @Override
            public void screenScrolled(View v, int i, float scrollProgress) {
                float rotation = (mIn ? TRANSITION_SCREEN_ROTATION : -TRANSITION_SCREEN_ROTATION) * scrollProgress;


                v.setPivotX((scrollProgress + 1) * v.getMeasuredWidth() * 0.5f);
                v.setPivotY(v.getMeasuredHeight() * 0.5f);
                v.setRotationY(rotation);
            }
        }


        public static class Crossfade extends TransitionEffect {
            public Crossfade(Workspace workspace) {
                super(workspace, TRANSITION_EFFECT_CROSSFADE);
            }


            @Override
            public void screenScrolled(View v, int i, float scrollProgress) {
                float alpha = 1 - Math.abs(scrollProgress);
                v.setPivotX(v.getMeasuredWidth() * 0.5f);
                v.setPivotY(v.getMeasuredHeight() * 0.5f);
                v.setAlpha(alpha);
            }
        }


        public static class Overview extends TransitionEffect {
            private AccelerateDecelerateInterpolator mScaleInterpolator = new AccelerateDecelerateInterpolator();


            public Overview(Workspace workspace) {
                super(workspace, TRANSITION_EFFECT_OVERVIEW);
            }


            @Override
            public void screenScrolled(View v, int i, float scrollProgress) {
                float scale = 1.0f - 0.1f *
                        mScaleInterpolator.getInterpolation(Math.min(0.3f, Math.abs(scrollProgress)) / 0.3f);


                v.setPivotX(scrollProgress < 0 ? 0 : v.getMeasuredWidth());
                v.setPivotY(v.getMeasuredHeight() * 0.5f);
                v.setScaleX(scale);
                v.setScaleY(scale);
                mWorkspace.setChildAlpha(v, scale);
            }
        }
    }