代码分析Android实现侧滑菜单

Android 侧滑菜单的实现，参考网上的代码，实现侧滑菜单。最重要的是这个动画类UgcAnimations，如何使用动画类来侧滑的封装FlipperLayout。

1、实现效果

2、动画类UgcAnimations

package com.mmsx.base;
import android.content.Context;
import android.view.View;
import android.view.ViewGroup.MarginLayoutParams;
import android.view.animation.AlphaAnimation;
import android.view.animation.Animation;
import android.view.animation.AnimationSet;
import android.view.animation.AnticipateInterpolator;
import android.view.animation.OvershootInterpolator;
import android.view.animation.RotateAnimation;
import android.view.animation.ScaleAnimation;
import android.view.animation.TranslateAnimation;
import android.widget.ImageView;
import android.widget.RelativeLayout;

/**
* Pat * 类
*
*/
public class UgcAnimations {
 private static int xOffset = 15;
 private static int yOffset = -13;

public static void initOffset(Context context) {
   xOffset = (int) (15 * context.getResources().getDisplayMetrics().density);
   yOffset = -(int) (13 * context.getResources().getDisplayMetrics().density);
 }

public static Animation getRotateAnimation(float fromDegrees,
     float toDegrees, long durationMillis) {
   RotateAnimation rotate = new RotateAnimation(fromDegrees, toDegrees,
       Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,
       0.5f);
   rotate.setDuration(durationMillis);
   rotate.setFillAfter(true);
   return rotate;
 }

public static Animation getAlphaAnimation(float fromAlpha, float toAlpha,
     long durationMillis) {
   AlphaAnimation alpha = new AlphaAnimation(fromAlpha, toAlpha);
   alpha.setDuration(durationMillis);
   alpha.setFillAfter(true);
   return alpha;
 }

public static Animation getScaleAnimation(long durationMillis) {
   ScaleAnimation scale = new ScaleAnimation(1.0f, 1.5f, 1.0f, 1.5f,
       Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,
       0.5f);
   scale.setDuration(durationMillis);
   return scale;
 }

public static Animation getTranslateAnimation(float fromXDelta,
     float toXDelta, float fromYDelta, float toYDelta,
     long durationMillis) {
   TranslateAnimation translate = new TranslateAnimation(fromXDelta,
       toXDelta, fromYDelta, toYDelta);
   translate.setDuration(durationMillis);
   translate.setFillAfter(true);
   return translate;
 }

public static void startOpenAnimation(RelativeLayout relativeLayout,
     ImageView background, ImageView menu, long durationMillis) {
   background.setVisibility(View.VISIBLE);
   relativeLayout.setVisibility(View.VISIBLE);
   background.startAnimation(getAlphaAnimation(0f, 1f, durationMillis));
   menu.startAnimation(getRotateAnimation(0, 90, durationMillis));
   for (int i = 0; i < relativeLayout.getChildCount(); i++) {
     ImageView imageView = (ImageView) relativeLayout.getChildAt(i);
     imageView.setVisibility(View.VISIBLE);
     MarginLayoutParams params = (MarginLayoutParams) imageView
         .getLayoutParams();
     AnimationSet set = new AnimationSet(true);
     set.addAnimation(getRotateAnimation(-270, 0, durationMillis));
     set.addAnimation(getAlphaAnimation(0.5f, 1.0f, durationMillis));
     set.addAnimation(getTranslateAnimation(
         -params.leftMargin + xOffset, 0f, params.bottomMargin
             + yOffset, 0f, durationMillis));
     set.setFillAfter(true);
     set.setDuration(durationMillis);
     set.setStartOffset((i * 100)
         / (-1 + relativeLayout.getChildCount()));
     set.setInterpolator(new OvershootInterpolator(1f));
     imageView.startAnimation(set);
   }
 }
 public static void startCloseAnimation(final RelativeLayout relativeLayout,
     final ImageView background, ImageView menu, long durationMillis) {
   background.startAnimation(getAlphaAnimation(1f, 0f, durationMillis));
   menu.startAnimation(getRotateAnimation(90, 0, durationMillis));
   for (int i = 0; i < relativeLayout.getChildCount(); i++) {
     final ImageView imageView = (ImageView) relativeLayout
         .getChildAt(i);
     MarginLayoutParams params = (MarginLayoutParams) imageView
         .getLayoutParams();
     AnimationSet set = new AnimationSet(true);
     set.addAnimation(getRotateAnimation(0, -270, durationMillis));
     set.addAnimation(getAlphaAnimation(1.0f, 0.5f, durationMillis));
     set.addAnimation(getTranslateAnimation(0f, -params.leftMargin
         + xOffset, 0f, params.bottomMargin + yOffset,
         durationMillis));
     set.setFillAfter(true);
     set.setDuration(durationMillis);
     set.setStartOffset(((relativeLayout.getChildCount() - i) * 100)
         / (-1 + relativeLayout.getChildCount()));
     set.setInterpolator(new AnticipateInterpolator(1f));
     set.setAnimationListener(new Animation.AnimationListener() {
       public void onAnimationStart(Animation arg0) {
       }
       public void onAnimationRepeat(Animation arg0) {
       }
       public void onAnimationEnd(Animation arg0) {
         relativeLayout.setVisibility(View.GONE);
         background.setVisibility(View.GONE);
       }
     });
     imageView.startAnimation(set);
   }
 }
 public static Animation clickAnimation(long durationMillis) {
   AnimationSet set = new AnimationSet(true);
   set.addAnimation(getAlphaAnimation(1.0f, 0.3f, durationMillis));
   set.addAnimation(getScaleAnimation(durationMillis));
   set.setDuration(durationMillis);
   return set;
 }
}

3、封装使用动画类FlipperLayout

package com.mmsx.base;
import android.content.Context;
import android.util.AttributeSet;
import android.util.TypedValue;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.widget.Scroller;

/**
* 自己重写的ViewGroup,用与滑动切换界面使用,代码不详解,慢点看的话应该能看懂的...
*/
public class FlipperLayout extends ViewGroup {

private Scroller mScroller;
 private VelocityTracker mVelocityTracker;
 private int mWidth;

public static final int SCREEN_STATE_CLOSE = 0;
 public static final int SCREEN_STATE_OPEN = 1;
 public static final int TOUCH_STATE_RESTART = 0;
 public static final int TOUCH_STATE_SCROLLING = 1;
 public static final int SCROLL_STATE_NO_ALLOW = 0;
 public static final int SCROLL_STATE_ALLOW = 1;
 private int mScreenState = 0;
 private int mTouchState = 0;
 private int mScrollState = 0;
 private int mVelocityValue = 0;
 private boolean mOnClick = false;
 private onUgcDismissListener mOnUgcDismissListener;
 private onUgcShowListener mOnUgcShowListener;

public FlipperLayout(Context context) {
   super(context);
   mScroller = new Scroller(context);
   mWidth = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
       54, getResources().getDisplayMetrics());

}

public FlipperLayout(Context context, AttributeSet attrs, int defStyle) {
   super(context, attrs, defStyle);
 }

public FlipperLayout(Context context, AttributeSet attrs) {
   super(context, attrs);
 }

protected void onLayout(boolean changed, int l, int t, int r, int b) {
   for (int i = 0; i < getChildCount(); i++) {
     View child = getChildAt(i);
     int height = child.getMeasuredHeight();
     int width = child.getMeasuredWidth();
     child.layout(0, 0, width, height);
   }
 }

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
   super.onMeasure(widthMeasureSpec, heightMeasureSpec);
   int width = MeasureSpec.getSize(widthMeasureSpec);
   int height = MeasureSpec.getSize(heightMeasureSpec);
   setMeasuredDimension(width, height);
   for (int i = 0; i < getChildCount(); i++) {
     getChildAt(i).measure(widthMeasureSpec, heightMeasureSpec);
   }
 }

public boolean dispatchTouchEvent(MotionEvent ev) {
   obtainVelocityTracker(ev);
   switch (ev.getAction()) {
   case MotionEvent.ACTION_DOWN:
     mTouchState = mScroller.isFinished() ? TOUCH_STATE_RESTART
         : TOUCH_STATE_SCROLLING;
     if (mTouchState == TOUCH_STATE_RESTART) {
       int x = (int) ev.getX();
       int screenWidth = getWidth();
       if (x <= mWidth && mScreenState == SCREEN_STATE_CLOSE
           && mTouchState == TOUCH_STATE_RESTART
           || x >= screenWidth - mWidth
           && mScreenState == SCREEN_STATE_OPEN
           && mTouchState == TOUCH_STATE_RESTART) {
         if (mScreenState == SCREEN_STATE_OPEN) {
           mOnClick = true;
         }
         mScrollState = SCROLL_STATE_ALLOW;
       } else {
         mOnClick = false;
         mScrollState = SCROLL_STATE_NO_ALLOW;
       }
     } else {
       return false;
     }
     break;
   case MotionEvent.ACTION_MOVE:
     mVelocityTracker.computeCurrentVelocity(1000,
         ViewConfiguration.getMaximumFlingVelocity());
     if (mScrollState == SCROLL_STATE_ALLOW
         && getWidth() - (int) ev.getX() < mWidth) {
       return true;
     }
     break;
   case MotionEvent.ACTION_UP:
     releaseVelocityTracker();
     if (mOnClick) {
       mOnClick = false;
       mScreenState = SCREEN_STATE_CLOSE;
       mScroller.startScroll(getChildAt(1).getScrollX(), 0,
           -getChildAt(1).getScrollX(), 0, 800);
       invalidate();
     }
     break;
   }
   return super.dispatchTouchEvent(ev);
 }

public boolean onInterceptTouchEvent(MotionEvent ev) {
   obtainVelocityTracker(ev);
   switch (ev.getAction()) {
   case MotionEvent.ACTION_DOWN:
     mTouchState = mScroller.isFinished() ? TOUCH_STATE_RESTART
         : TOUCH_STATE_SCROLLING;
     if (mTouchState == TOUCH_STATE_SCROLLING) {
       return false;
     }
     break;

case MotionEvent.ACTION_MOVE:
     mOnClick = false;
     mVelocityTracker.computeCurrentVelocity(1000,
         ViewConfiguration.getMaximumFlingVelocity());
     if (mScrollState == SCROLL_STATE_ALLOW
         && Math.abs(mVelocityTracker.getXVelocity()) > 200) {
       return true;
     }
     break;

case MotionEvent.ACTION_UP:
     releaseVelocityTracker();
     if (mScrollState == SCROLL_STATE_ALLOW
         && mScreenState == SCREEN_STATE_OPEN) {
       return true;
     }
     break;
   }
   return super.onInterceptTouchEvent(ev);
 }

public boolean onTouchEvent(MotionEvent event) {
   obtainVelocityTracker(event);
   switch (event.getAction()) {
   case MotionEvent.ACTION_DOWN:
     mTouchState = mScroller.isFinished() ? TOUCH_STATE_RESTART
         : TOUCH_STATE_SCROLLING;
     if (mTouchState == TOUCH_STATE_SCROLLING) {
       return false;
     }
     break;

case MotionEvent.ACTION_MOVE:
     mVelocityTracker.computeCurrentVelocity(1000,
         ViewConfiguration.getMaximumFlingVelocity());
     mVelocityValue = (int) mVelocityTracker.getXVelocity();
     getChildAt(1).scrollTo(-(int) event.getX(), 0);
     break;

case MotionEvent.ACTION_UP:
     if (mScrollState == SCROLL_STATE_ALLOW) {
       if (mVelocityValue > 2000) {
         mScreenState = SCREEN_STATE_OPEN;
         mScroller
             .startScroll(
                 getChildAt(1).getScrollX(),
                 0,
                 -(getWidth()
                     - Math.abs(getChildAt(1)
                         .getScrollX()) -

mWidth), 0, 250);
         invalidate();

} else if (mVelocityValue < -2000) {
         mScreenState = SCREEN_STATE_CLOSE;
         mScroller.startScroll(getChildAt(1).getScrollX(), 0,
             -getChildAt(1).getScrollX(), 0, 250);
         invalidate();
       } else if (event.getX() < getWidth() / 2) {
         mScreenState = SCREEN_STATE_CLOSE;
         mScroller.startScroll(getChildAt(1).getScrollX(), 0,
             -getChildAt(1).getScrollX(), 0, 800);
         invalidate();
       } else {
         mScreenState = SCREEN_STATE_OPEN;
         mScroller
             .startScroll(
                 getChildAt(1).getScrollX(),
                 0,
                 -(getWidth()
                     - Math.abs(getChildAt(1)
                         .getScrollX()) -

mWidth), 0, 800);
         invalidate();
       }
     }
     break;
   }
   return super.onTouchEvent(event);
 }

public void open() {
   mTouchState = mScroller.isFinished() ? TOUCH_STATE_RESTART
       : TOUCH_STATE_SCROLLING;
   if (mTouchState == TOUCH_STATE_RESTART) {
     mScreenState = SCREEN_STATE_OPEN;
     mScroller.startScroll(getChildAt(1).getScrollX(), 0, -(getWidth()
         - Math.abs(getChildAt(1).getScrollX()) -

mWidth), 0, 800);
     invalidate();
   }
 }

//关闭当前的侧滑菜单，用view打开点击事件的页面
 public void close(View view) {
   mScreenState = SCREEN_STATE_CLOSE;
   mScroller.startScroll(getChildAt(1).getScrollX(), 0, -getChildAt(1)
       .getScrollX(), 0, 800);
   invalidate();
   setContentView(view);
 }

public void computeScroll() {
   super.computeScroll();
   if (mScroller.computeScrollOffset()) {
     getChildAt(1).scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
     postInvalidate();
   } else {
     if (mScreenState == SCREEN_STATE_OPEN) {
       if (mOnUgcDismissListener != null) {
         mOnUgcDismissListener.dismiss();
       }
     } else if (mScreenState == SCREEN_STATE_CLOSE) {
       if (mOnUgcShowListener != null) {
         mOnUgcShowListener.show();
       }
     }
   }
 }
 private void obtainVelocityTracker(MotionEvent event) {
   if (mVelocityTracker == null) {
     mVelocityTracker = VelocityTracker.obtain();
   }
   mVelocityTracker.addMovement(event);
 }
 private void releaseVelocityTracker() {
   if (mVelocityTracker != null) {
     mVelocityTracker.recycle();
     mVelocityTracker = null;
   }
 }
 public int getScreenState() {
   return mScreenState;
 }
 public void setContentView(View view) {
   removeViewAt(1);
   addView(view, 1, getLayoutParams());
 }
 public interface OnOpenListener {
   public abstract void open();
 }
 public interface OnCloseListener {
   public abstract void close();
 }
 public interface onUgcDismissListener {
   public abstract void dismiss();
 }
 public interface onUgcShowListener {
   public abstract void show();
 }
 public void setOnUgcDismissListener(
     onUgcDismissListener onUgcDismissListener) {
   mOnUgcDismissListener = onUgcDismissListener;
 }
 public void setOnUgcShowListener(onUgcShowListener onUgcShowListener) {
   mOnUgcShowListener = onUgcShowListener;
 }
}

4、主界面MainActivity

package com.mmsx.activity;  
import com.mmsx.activity.SideslipMenu.onChangeViewListener;
import com.mmsx.activity.SideslipOther.onDataListener;
import com.mmsx.base.FlipperLayout;
import com.mmsx.base.FlipperLayout.OnOpenListener;
import com.mmsx.base.ViewUtil;
import android.os.Bundle;
import android.app.Activity;
import android.view.ViewGroup.LayoutParams;
import android.widget.Toast;

public class MainActivity extends Activity implements OnOpenListener{

//侧滑主要控制类，设置跟布局
 private FlipperLayout mRoot;
 //侧滑的默认界面，主界面
 private SideslipHome mHome;
 //侧滑的菜单，进行选择的
 private SideslipMenu mSideslipMenu;
 //其他菜单列表选择的效果
 private SideslipOther mOther;
 //退出时间间隔变量
 private long mExitTime;
 //时间间隔2s
 private static final int INTERVAL = 2000;
 //侧滑菜单选中的item
 private int mViewPosition;
 //侧滑传递的标题
 private String mstrTitle;
 @Override
 protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
    //创建容器,并设置全屏大小
   mRoot = new FlipperLayout(this);
   //布局的参数
   LayoutParams params = new LayoutParams(LayoutParams.FILL_PARENT,
       LayoutParams.FILL_PARENT);
   mRoot.setLayoutParams(params);
   //创建菜单界面和内容首页界面,并添加到容器中,用于初始显示
   mHome = new SideslipHome(this, this);
   mSideslipMenu = new SideslipMenu(this);
   mRoot.addView(mSideslipMenu.getView(), params);
   mRoot.addView(mHome.getView(), params);
   //设置跟布局
   setContentView(mRoot);
   //设置监听
   setListener();
 }

//设置监听
 private void setListener() {
   mHome.setOnOpenListener(this);
    //监听菜单界面切换显示内容(onChangeViewListener接口在SideslipMenu中定义)
   mSideslipMenu.setOnChangeViewListener(new onChangeViewListener() {

public void onChangeView(int arg0) {
       mViewPosition = arg0;
       mOther = new SideslipOther(MainActivity.this);
       switch (arg0) {
       case ViewUtil.HOME:
         mRoot.close(mHome.getView());
         break;
       case ViewUtil.MESSAGE:
         mstrTitle = "消息";
         //设置数据接口监听
         mOther.setDataTitle(new DataTitle());
         mRoot.close(mOther.getView());
         break;
       case ViewUtil.FRIENDS:
         mstrTitle = "好友";
         mOther.setDataTitle(new DataTitle());
         mRoot.close(mOther.getView());
         break;
       case ViewUtil.PHOTO:
         mstrTitle = "照片";
         mOther.setDataTitle(new DataTitle());
         mRoot.close(mOther.getView());
         break;
       case ViewUtil.VIEWED:
         mstrTitle = "转帖";
         mOther.setDataTitle(new DataTitle());
         mRoot.close(mOther.getView());
         break;
       case ViewUtil.GIFTS:
         mstrTitle = "礼物";
         mOther.setDataTitle(new DataTitle());
         mRoot.close(mOther.getView());
         break;
       case ViewUtil.RECOMMEND:
         mstrTitle = "游戏";
         mOther.setDataTitle(new DataTitle());
         mRoot.close(mOther.getView());
         break;
       case ViewUtil.LBS:
         mstrTitle = "附近 ";
         mOther.setDataTitle(new DataTitle());
         mRoot.close(mOther.getView());
         break;
       default:
         break;
       }
     }
   });
 }

//传递数据到侧滑选中的页面
 private class DataTitle implements onDataListener{
   @Override
   public String getDataTitle() {
     return mstrTitle;
   }

}

@Override
 public void open() {
   if (mRoot.getScreenState() == FlipperLayout.SCREEN_STATE_CLOSE) {
     mRoot.open();
   }
 }

/**
  * 返回键监听
  */
 public void onBackPressed() {
   /**
    * 如果界面的path菜单没有关闭时,先将path菜单关闭,否则则判断两次返回时间间隔,小于两秒则退出程序
    */
   if (mRoot.getScreenState() == FlipperLayout.SCREEN_STATE_OPEN) {
     if (mSideslipMenu.getUgcIsShowing()) {
       mSideslipMenu.closeUgc();
     } else {
       exit();
     }
   } else {
     switch (mViewPosition) {
     case ViewUtil.HOME:
       if (mHome.getUgcIsShowing()) {
         mHome.closeUgc();
       } else {
         exit();
       }
       break;
     default:
       exit();
       break;
     }

}

}  
 /**
  * 判断两次返回时间间隔,小于两秒则退出程序
  */
 private void exit() {
   if (System.currentTimeMillis() - mExitTime > INTERVAL) {
     Toast.makeText(this, "再按一次返回键,可直接退出程序", Toast.LENGTH_SHORT).show();
     mExitTime = System.currentTimeMillis();
   } else {
     finish();
     android.os.Process.killProcess(android.os.Process.myPid());
     System.exit(0);
   }
 }
}

5、SideslipHome

package com.mmsx.activity;
import com.mmsx.base.FlipperLayout.OnOpenListener;

import android.app.Activity;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.TextView;

public class SideslipHome {
 private Context mContext;
 private Activity mActivity;
 private View mHomeView;
 private boolean mUgcIsShowing = false;  
 private OnOpenListener mOnOpenListener;
 public SideslipHome(Context context, Activity activity) {
   mContext = context;
   mActivity = activity;
   mHomeView = LayoutInflater.from(context).inflate(R.layout.sideslip_home, null);

initUI();
 }

private void initUI() {
   TextView ivTitleName = (TextView)mHomeView.findViewById(R.id.ivTitleName);  
   ivTitleName.setText("主页动态");

}

public void setOnOpenListener(OnOpenListener onOpenListener) {
   mOnOpenListener = onOpenListener;
 }

public View getView() {
   return mHomeView;
 }

/**
  * 获取Path菜单显示状态
  */
 public boolean getUgcIsShowing() {
   return mUgcIsShowing;
 }

/**
  * 关闭Path菜单
  */
 public void closeUgc() {
   mUgcIsShowing = false;
 }

}

好了，以上就是本文的全部叙述，希望大家喜欢。