Android UI效果实现——Activity滑动退出效果

更新说明：

1、在QQ网友北京-旭的提醒下，在SlideFrame的initilize方法中添加了focusable、focusableInTouch、clickable的状态设置，否则会导致部分情况下无法滑动，感谢！

 

一、效果动图

 

二、使用说明

使用方法很简单，只有一个类HorizontalActivity，继承自FragmentActivity类，实现了contentView的滑动事件触发和动画效果，要在自己的代码里实现，方法两种：

1、如果对Activity没特殊要求，直接继承HorizontalActivity即可

2、如果Activity的父类必须是某一特定类型的Activity子类，则可以仿照我的写法对该类进行继承

 

三、HorizontalActivity类的代码

package com.beifeng.widget;

import android.content.Context;
import android.support.v4.app.FragmentActivity;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup.LayoutParams;
import android.view.animation.Animation;
import android.view.animation.Animation.AnimationListener;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.Transformation;
import android.widget.FrameLayout;

/**
 * HorizontalActivity:可滑动Activity
 * 
 * 注意事项： 本Activity中与滑动方向相同的滑动操作会被拦截
 * 
 * @author HalfmanG2
 * @version 1.0.0
 * @since JDK7 SDK19
 */
public class HorizontalActivity extends FragmentActivity {

    /** 框架视图 */
    protected SlideFrame frameView;
    /** 内容视图 */
    protected View contentView;

    @Override
    public void setContentView(int layoutResID) {
        // 初始化frame
        if (frameView == null) {
            // 未初始化则初始化
            frameView = new SlideFrame(this);
        } else {
            // 已经初始化则清空
            frameView.removeAllViews();
        }
        // 创造framelayout的填充参数
        FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(-1, -1);
        // 获取layoutResId对应的contentView视图并插入frameView
        LayoutInflater inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        contentView = inflater.inflate(layoutResID, null);
        frameView.addView(contentView, params);
        // 设置frameview为根视图
        super.setContentView(frameView);
    }

    @Override
    public void setContentView(View view) {
        // 初始化frame
        if (frameView == null) {
            // 未初始化则初始化
            frameView = new SlideFrame(this);
        } else {
            // 已经初始化则清空
            frameView.removeAllViews();
        }
        // 创造framelayout的填充参数
        FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(-1, -1);
        // 获取view为contentView视图并插入frameView
        contentView = view;
        frameView.addView(contentView, params);
        // 设置frameview为根视图
        super.setContentView(frameView);
    }

    @Override
    public void setContentView(View view, LayoutParams params) {
        // 初始化frame
        if (frameView == null) {
            // 未初始化则初始化
            frameView = new SlideFrame(this);
        } else {
            // 已经初始化则清空
            frameView.removeAllViews();
        }
        // 创造framelayout的填充参数
        FrameLayout.LayoutParams fp = new FrameLayout.LayoutParams(-1, -1);
        // 获取view为contentView视图并插入frameView
        contentView = view;
        frameView.addView(contentView, fp);
        // 设置frameview为根视图
        super.setContentView(frameView, params);
    }

    /**
     * 推出页面
     */
    protected void onSlideFinish() {
        finish();
    }

    /**
     * 位移内容视图到
     * 
     * @param position
     *            目标位置
     */
    public void slideTo(int position) {
        if (android.os.Build.VERSION.SDK_INT > 10) {
            contentView.setX(position);
        } else {
            android.widget.FrameLayout.LayoutParams params = (android.widget.FrameLayout.LayoutParams) contentView
                    .getLayoutParams();
            params.setMargins(position, 0, -position, 0);
            contentView.setLayoutParams(params);
        }
    }

    /**
     * 获得当前容器位移
     * 
     * @return 当前容器位移
     */
    public int getSlide() {
        if (android.os.Build.VERSION.SDK_INT > 10) {
            return (int) contentView.getX();
        } else {
            return ((android.widget.FrameLayout.LayoutParams) contentView
                    .getLayoutParams()).leftMargin;
        }
    }

    /**
     * 滑动框架
     * 
     * @author HalfmanG2
     * @version 1.0.0
     * @since JDK7 SDK19
     */
    public class SlideFrame extends FrameLayout {
        /** 默认滑动阀值 */
        private final static int DEFAULT_SLIDE_DUMPING = 8;
        /** 默认状态改变阀值 */
        private final static int DEFAULT_DO_DUMPING = 100;
        /** 滑动起始位置与当前位置 */
        private int startX, currentX, startY, currentY;
        /** 是否拦截事件，是否已经完成滑动检查 */
        private boolean doNotIntercept, hasChecked;
        /** 滑动阀值 */
        private int slideDumping;
        /** 操作阀值 */
        private int doDumping;
        /** 滑屏动画 */
        protected SlideAnimation slideAnimation;

        @Override
        public boolean onInterceptTouchEvent(MotionEvent ev) {
            super.onInterceptTouchEvent(ev);
            // 若当前处在侧滑状态中，则拦截信号
            if ((!doNotIntercept) && hasChecked) {
                return true;
            }
            // 否则使用默认
            return false;
        }

        @Override
        public boolean dispatchTouchEvent(MotionEvent ev) {
            if (ev.getAction() == MotionEvent.ACTION_DOWN) {
                // 获得起始滑动坐标
                startX = (int) ev.getX();
                startY = (int) ev.getY();
                // 初始化状态
                doNotIntercept = false;
                hasChecked = false;
            } else if (!doNotIntercept) {
                // 获得当前滑动坐标
                currentX = (int) ev.getX();
                currentY = (int) ev.getY();
                // 根据滑动类型区分
                switch (ev.getAction()) {
                case MotionEvent.ACTION_MOVE: // 移动状态
                    if (hasChecked) {
                        doSlide();
                    } else {
                        doCheck();
                    }
                    break;
                case MotionEvent.ACTION_CANCEL: // 取消状态
                case MotionEvent.ACTION_UP: // 抬起状态
                    // 初始化状态
                    doNotIntercept = false;
                    hasChecked = false;
                    if (Math.abs(currentX - startX) > doDumping) {
                        if (currentX > startX) {
                            // 右滑
                            slideAnimation = new SlideAnimation(getSlide(),
                                    contentView.getWidth(), 0);
                            slideAnimation
                                    .setAnimationListener(new AnimationListener() {
                                        @Override
                                        public void onAnimationStart(
                                                Animation animation) {
                                        }

                                        @Override
                                        public void onAnimationRepeat(
                                                Animation animation) {
                                        }

                                        @Override
                                        public void onAnimationEnd(
                                                Animation animation) {
                                            onSlideFinish();
                                        }
                                    });
                            startAnimation(slideAnimation);
                        }
                    } else {
                        // 返回0位置
                        slideAnimation = new SlideAnimation(getSlide(), 0, 0);
                        startAnimation(slideAnimation);
                    }
                    break;
                default:
                    break;
                }
            }
            return super.dispatchTouchEvent(ev);
        }

        /**
         * 检查是否超过滑动阀值开启滑动状态
         */
        private void doCheck() {
            if (Math.abs(startY - currentY) > slideDumping) {
                hasChecked = true;
                doNotIntercept = true;
                slideTo(0);
            } else if (currentX - startX > slideDumping) {
                hasChecked = true;
                doNotIntercept = false;
            }
        }

        /**
         * 进行滑动
         */
        private void doSlide() {
            if (currentX > startX) {
                slideTo(currentX - startX);
            } else {
                slideTo(0);
            }
        }

        /**
         * 设置滑动阀值
         * 
         * @param dpValue
         */
        public void setSlideDumping(int dpValue) {
            slideDumping = dip2px(dpValue);
        }

        /**
         * 设置状态改变阀值
         * 
         * @param dpValue
         */
        public void setDoDumping(int dpValue) {
            doDumping = dip2px(dpValue);
        }

        /**
         * 二级构造方法
         */
        private void initilize() {
            setSlideDumping(DEFAULT_SLIDE_DUMPING);
            setDoDumping(DEFAULT_DO_DUMPING);
            doNotIntercept = false;
            hasChecked = false;
            setClickable(true);
            setFocusable(true);
            setFocusableInTouchMode(true);
        }

        /**
         * 构造方法
         * 
         * @param context
         * @param attrs
         * @param defStyle
         */
        public SlideFrame(Context context, AttributeSet attrs, int defStyle) {
            super(context, attrs, defStyle);
            initilize();
        }

        /**
         * 构造方法
         * 
         * @param context
         * @param attrs
         */
        public SlideFrame(Context context, AttributeSet attrs) {
            super(context, attrs);
            initilize();
        }

        /**
         * 构造方法
         * 
         * @param context
         */
        public SlideFrame(Context context) {
            super(context);
            initilize();
        }

        /**
         * 讲dip值转换为px值，像素密度距离转像素距离
         * 
         * @param dipValue dp值
         * @return px值
         */
        private int dip2px(float dipValue) {
            // 获得像素密度
            final float scale = getContext().getResources().getDisplayMetrics().density;
            // 四舍五入dp值乘像素密度
            return (int) (dipValue * scale + 0.5f);
        }
    }

    /**
     * 滑动动画类
     * 
     * @author HalfmanG2
     */
    public class SlideAnimation extends Animation {
        /** 起始位置，目标位置 */
        private float from, to;
        /**
         * 构造方法
         * @param from 起始位置
         * @param to 目标位置
         * @param startOffset 起始延迟
         */
        public SlideAnimation(int from, int to, int startOffset) {
            this.from = from;
            this.to = to;
            setFillEnabled(false);
            setDuration(200);
            setRepeatCount(0);
            setStartOffset(startOffset);
            setInterpolator(new DecelerateInterpolator());
        }
        @Override
        protected void applyTransformation(float interpolatedTime,
                Transformation t) {
            float current = from + (to - from) * interpolatedTime;
            slideTo((int) current);
            super.applyTransformation(interpolatedTime, t);
        }
    }
}

 

四、使用详细步骤

1、建立一个Android工程，项目最小api level必须在api level 11及以上

2、把本类考入任意代码包下

3、项目中想要实现Activity滑动退出效果的Activity继承本类

4、如果要在滑动过程中显示上一个Activity的话，将Activity的背景设置为透明，方法建议通过设置Activity的Style或者说theme来实现

5、如果滑动过程中需要加入一些特殊效果，可以复写slideTo(int)方法，记得别把super.slideTo(int)给漏了，否则滑动失效

6、如果滑动结束后不希望立即返回上一页，可以复写onSlideFinish()方法

 

PS、

很简单的实现方法，但离我觉得完美还太远，所以如果有更好的实现方法希望可以一起交流下：

联系方式QQ：811868948，备注加上Android交流，有好的想法一定要联系我，谢谢！

联系方式E-Mail：halfmanhuang@gmail.com