仿QQ5.0侧滑菜单ResideMenu

〔文章原始地址 http://blog.csdn.net/manoel/article/details/39013095〕

最近项目要做一个QQ5.0的侧滑菜单效果，和传统的侧滑菜单存在着一些差异。想必大家都已经见识过了。

为了不重复发明轮子，先去github上面搜索了一番。

发现了几个类似的，但是还是有一些不同。

下面是搜索到的类似的开源项目。

RESideMenu（ios项目）

https://github.com/romaonthego/RESideMenu

AndroidResideMenu

https://github.com/SpecialCyCi/AndroidResideMenu

ResideLayout

https://github.com/kyze8439690/ResideLayout

研究了一下这些开源项目的源代码。感觉并不是特别适用于我们自己的项目。所以，我自己又研究了一下。最后的效果如下。当然了，还有很多可以优化的地方，后续再慢慢优化。

备注：如果图片动画显示不出来，可以点击这个网址查看。

https://img-blog.csdn.net/20140902225149282?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvbWFub2Vs/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast

我是基于SlidingMenu库进行的二次修改，增加了一些转场动画。

大家对这个库应该比较熟悉，下面是SlidingMenu的github地址。非常感谢Jeremy Feinstein提供的这个库，让广大Android Developers省去了非常多的麻烦。

https://github.com/jfeinstein10/SlidingMenu

备注：SlidingMenu使用了SherlockActionBar这个库，配置起来会比较麻烦，在文章的最后我会把demo上传，供大家下载，减去了大家自己配置项目的麻烦。

我主要修改了2个类，SlidingMenu.java和CustonViewAbove.java，只是增加了一些功能，并没有修改原本的功能。

做了修改的地方，我做了中文注释，其实实现很简单，几行代码而已。推荐大家下载Demo，然后自己调试一下。Demo的下载地址在文章的末尾。

废话不多说，直接上代码，略微有点长。

 public class SlidingMenu extends RelativeLayout {

     private static final String TAG = SlidingMenu.class.getSimpleName();

     public static final int SLIDING_WINDOW = 0;
     public static final int SLIDING_CONTENT = 1;
     private boolean mActionbarOverlay = false;

     /**
      * Constant value for use with setTouchModeAbove(). Allows the SlidingMenu
      * to be opened with a swipe gesture on the screen's margin
      */
     public static final int TOUCHMODE_MARGIN = 0;

     /**
      * Constant value for use with setTouchModeAbove(). Allows the SlidingMenu
      * to be opened with a swipe gesture anywhere on the screen
      */
     public static final int TOUCHMODE_FULLSCREEN = 1;

     /**
      * Constant value for use with setTouchModeAbove(). Denies the SlidingMenu
      * to be opened with a swipe gesture
      */
     public static final int TOUCHMODE_NONE = 2;

     /**
      * Constant value for use with setMode(). Puts the menu to the left of the
      * content.
      */
     public static final int LEFT = 0;

     /**
      * Constant value for use with setMode(). Puts the menu to the right of the
      * content.
      */
     public static final int RIGHT = 1;

     /**
      * Constant value for use with setMode(). Puts menus to the left and right
      * of the content.
      */
     public static final int LEFT_RIGHT = 2;

     private CustomViewAbove mViewAbove;

     private CustomViewBehind mViewBehind;

         /** 整体的背景，用一个ImageView代替 */
     private ImageView mViewBackground;

     private OnOpenListener mOpenListener;

     private OnOpenListener mSecondaryOpenListner;

     private OnCloseListener mCloseListener;

     /**
      * The listener interface for receiving onOpen events. The class that is
      * interested in processing a onOpen event implements this interface, and
      * the object created with that class is registered with a component using
      * the component's addOnOpenListener method. When

 public class CustomViewAbove extends ViewGroup {

     private static final String TAG = "CustomViewAbove";
     private static final boolean DEBUG = false;

     private static final boolean USE_CACHE = false;

     private static final int MAX_SETTLE_DURATION = 600; // ms
     private static final int MIN_DISTANCE_FOR_FLING = 25; // dips

     private static final Interpolator sInterpolator = new Interpolator() {
         public float getInterpolation(float t) {
             t -= 1.0f;
             return t * t * t * t * t + 1.0f;
         }
     };

     private View mContent;

     private int mCurItem;
     private Scroller mScroller;

     private boolean mScrollingCacheEnabled;

     private boolean mScrolling;

     private boolean mIsBeingDragged;
     private boolean mIsUnableToDrag;
     private int mTouchSlop;
     private float mInitialMotionX;
     /**
      * Position of the last motion event.
      */
     private float mLastMotionX;
     private float mLastMotionY;
     /**
      * ID of the active pointer. This is used to retain consistency during
      * drags/flings if multiple pointers are used.
      */
     protected int mActivePointerId = INVALID_POINTER;
     /**
      * Sentinel value for no current active pointer.
      * Used by {@link #mActivePointerId}.
      */
     private static final int INVALID_POINTER = -1;
         /** 保存转场动画的变量*/
     private CanvasTransformer mTransformer;

     /**
      * Determines speed during touch scrolling
      */
     protected VelocityTracker mVelocityTracker;
     private int mMinimumVelocity;
     protected int mMaximumVelocity;
     private int mFlingDistance;

     private CustomViewBehind mViewBehind;
     //  private int mMode;
     private boolean mEnabled = true;

     private OnPageChangeListener mOnPageChangeListener;
     private OnPageChangeListener mInternalPageChangeListener;

     //  private OnCloseListener mCloseListener;
     //  private OnOpenListener mOpenListener;
     private OnClosedListener mClosedListener;
     private OnOpenedListener mOpenedListener;

     private List mIgnoredViews = new ArrayList();

     //  private int mScrollState = SCROLL_STATE_IDLE;

     /**
      * Callback interface for responding to changing state of the selected page.
      */
     public interface OnPageChangeListener {

         /**
          * This method will be invoked when the current page is scrolled, either as part
          * of a programmatically initiated smooth scroll or a user initiated touch scroll.
          *
          * @param position Position index of the first page currently being displayed.
          *                 Page position+1 will be visible if positionOffset is nonzero.
          * @param positionOffset Value from [0, 1) indicating the offset from the page at position.
          * @param positionOffsetPixels Value in pixels indicating the offset from position.
          */
         public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels);

         /**
          * This method will be invoked when a new page becomes selected. Animation is not
          * necessarily complete.
          *
          * @param position Position index of the new selected page.
          */
         public void onPageSelected(int position);

     }

     /**
      * Simple implementation of the {@link OnPageChangeListener} interface with stub
      * implementations of each method. Extend this if you do not intend to override
      * every method of {@link OnPageChangeListener}.
      */
     public static class SimpleOnPageChangeListener implements OnPageChangeListener {

         public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
             // This space for rent
         }

         public void onPageSelected(int position) {
             // This space for rent
         }

         public void onPageScrollStateChanged(int state) {
             // This space for rent
         }

     }

     public CustomViewAbove(Context context) {
         this(context, null);
     }

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

     void initCustomViewAbove() {
         setWillNotDraw(false);
         setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);
         setFocusable(true);
         final Context context = getContext();
         mScroller = new Scroller(context, sInterpolator);
         final ViewConfiguration configuration = ViewConfiguration.get(context);
         mTouchSlop = ViewConfigurationCompat.getScaledPagingTouchSlop(configuration);
         mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
         mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
         setInternalPageChangeListener(new SimpleOnPageChangeListener() {
             public void onPageSelected(int position) {
                 if (mViewBehind != null) {
                     switch (position) {
                     case 0:
                     case 2:
                         mViewBehind.setChildrenEnabled(true);
                         break;
                     case 1:
                         mViewBehind.setChildrenEnabled(false);
                         break;
                     }
                 }
             }
         });

         final float density = context.getResources().getDisplayMetrics().density;
         mFlingDistance = (int) (MIN_DISTANCE_FOR_FLING * density);
     }

     /**
      * Set the currently selected page. If the CustomViewPager has already been through its first
      * layout there will be a smooth animated transition between the current item and the
      * specified item.
      *
      * @param item Item index to select
      */
     public void setCurrentItem(int item) {
         setCurrentItemInternal(item, true, false);
     }

     /**
      * Set the currently selected page.
      *
      * @param item Item index to select
      * @param smoothScroll True to smoothly scroll to the new item, false to transition immediately
      */
     public void setCurrentItem(int item, boolean smoothScroll) {
         setCurrentItemInternal(item, smoothScroll, false);
     }

     public int getCurrentItem() {
         return mCurItem;
     }

     void setCurrentItemInternal(int item, boolean smoothScroll, boolean always) {
         setCurrentItemInternal(item, smoothScroll, always, 0);
     }

     void setCurrentItemInternal(int item, boolean smoothScroll, boolean always, int velocity) {
         if (!always && mCurItem == item) {
             setScrollingCacheEnabled(false);
             return;
         }

         item = mViewBehind.getMenuPage(item);

         final boolean dispatchSelected = mCurItem != item;
         mCurItem = item;
         final int destX = getDestScrollX(mCurItem);
         if (dispatchSelected && mOnPageChangeListener != null) {
             mOnPageChangeListener.onPageSelected(item);
         }
         if (dispatchSelected && mInternalPageChangeListener != null) {
             mInternalPageChangeListener.onPageSelected(item);
         }
         if (smoothScroll) {
             smoothScrollTo(destX, 0, velocity);
         } else {
             completeScroll();
             scrollTo(destX, 0);
         }
     }

     /**
      * Set a listener that will be invoked whenever the page changes or is incrementally
      * scrolled. See {@link OnPageChangeListener}.
      *
      * @param listener Listener to set
      */
     public void setOnPageChangeListener(OnPageChangeListener listener) {
         mOnPageChangeListener = listener;
     }
     /*
     public void setOnOpenListener(OnOpenListener l) {
         mOpenListener = l;
     }

     public void setOnCloseListener(OnCloseListener l) {
         mCloseListener = l;
     }
      */
     public void setOnOpenedListener(OnOpenedListener l) {
         mOpenedListener = l;
     }

     public void setOnClosedListener(OnClosedListener l) {
         mClosedListener = l;
     }

     /**
      * Set a separate OnPageChangeListener for internal use by the support library.
      *
      * @param listener Listener to set
      * @return The old listener that was set, if any.
      */
     OnPageChangeListener setInternalPageChangeListener(OnPageChangeListener listener) {
         OnPageChangeListener oldListener = mInternalPageChangeListener;
         mInternalPageChangeListener = listener;
         return oldListener;
     }