【android】SlidingMenu源码分析

本章算是自定义控件系列的一个实例分析,SlidingMenu算是自定义控件里比较优秀的一个了,所以选了这个研究

看之前最好先简单看下我文章里的自定义控件教程以及ScrollView原理分析~可以点开个人资料查看相关文章~

< Scroll效果研究-系统ScrollView源码分析>
http://www.eoeandroid.com/thread-553375-1-1.html

自定义控件教程第一篇
http://www.eoeandroid.com/thread-548644-1-1.html


SlidingMenu设计思路 三个主要的ViewGroup, 主ViewGroup里面包含两个重叠的ViewGroup,盖在上面的就是显示内容,而下面的就是菜单
上面的侧滑以后露出后面的View~
主ViewGroup作为一个自定义控件,里面的内容和菜单利用自定义属性设置

SlidingMenu(继承RelativeLayout),就是这个主ViewGroup,
其中又包含两个,内容CustomViewAbove和菜单CustomViewBehind(都继承ViewGroup),
SlidingMenu提供两个自定义属性,供使用者传入两个布局id,对应主体内容和菜单布局,
此外还有其他一些属性供开发者设置菜单效果

下面是代码分析
----------------------------------------------------------------------------------------

构造函数中主要代码如下:

1. LayoutParams behindParams = new LayoutParams(LayoutParams. MATCH_PARENT, LayoutParams.MATCH_PARENT);
   
2. mViewBehind = new CustomViewBehind(context);
   
3. addView(mViewBehind , behindParams);
   
4. LayoutParams aboveParams = new LayoutParams(LayoutParams. MATCH_PARENT, LayoutParams.MATCH_PARENT);
   
5. mViewAbove = new CustomViewAbove(context);
   
6. addView(mViewAbove , aboveParams);
   
7. // register the CustomViewBehind with the CustomViewAbove
   
8. mViewAbove.setCustomViewBehind(mViewBehind );
   
9. mViewBehind.setCustomViewAbove(mViewAbove );
   
10. mViewAbove.setOnPageChangeListener(new OnPageChangeListener() {
    
11.       public static final int POSITION_OPEN = 0;
    
12.       public static final int POSITION_CLOSE = 1;
    
13.       public static final int POSITION_SECONDARY_OPEN = 2;
    
14. 
    
15.       public void onPageScrolled( int position, float positionOffset,
    
16.                    int positionOffsetPixels) { }
    
17. 
    
18.       public void onPageSelected( int position) {
    
19.              if (position == POSITION_OPEN && mOpenListener != null) {
    
20.                    mOpenListener.onOpen();
    
21.             } else if (position == POSITION_CLOSE && mCloseListener != null) {
    
22.                    mCloseListener.onClose();
    
23.             } else if (position == POSITION_SECONDARY_OPEN && mSecondaryOpenListner != null ) {
    
24.                    mSecondaryOpenListner.onOpen();
    
25.             }
    
26.       }
    
27. });
    
28. 
    
29. // now style everything!
    
30. TypedArray ta = context.obtainStyledAttributes(attrs, R.styleable.SlidingMenu);
    
31. // set the above and behind views if defined in xml
    
32. int mode = ta.getInt(R.styleable.SlidingMenu_mode, LEFT);
    
33. setMode(mode);
    
34. int viewAbove = ta.getResourceId(R.styleable. SlidingMenu_viewAbove, -1);
    
35. if (viewAbove != -1) {
    
36.       setContent(viewAbove );
    
37. } else {
    
38.       setContent( new FrameLayout(context));
    
39. }
    
40. int viewBehind = ta.getResourceId(R.styleable.SlidingMenu_viewBehind, -1);
    
41. if (viewBehind != -1) {
    
42.       setMenu(viewBehind);
    
43. } else {
    
44.       setMenu(new FrameLayout(context));
    
45. }

复制代码

新建两个自定义控件CustomViewAbove/Behind将其addView到SlidingMenu中,

然后在通过属性获取到view的id后会在setContent/Menu方法中设置对应布局

下面是content处理相关代码,menu同理

1. /**
   
2. * Set the above view content to the given View.
   
3. *
   
4. * @param view The desired content to display.
   
5. */
   
6. public void setContent(View view) {
   
7.       mViewAbove.setContent(view);
   
8.       showContent();
   
9. }

复制代码

mViewAbove的setContent方法代码为

1. /**
   
2. * Set the behind view (menu) content to the given View.
   
3. *
   
4. * @param view The desired content to display.
   
5. */
   
6. public void setMenu(View v) {
   
7.       mViewBehind.setContent(v);
   
8. }

复制代码

下面分别介绍Above和Behind两部分

-----------------------------------------------------------------------------------------

CustViewAbove类,包含主要内容的类,即显示在SlidingMenu上面/前端的部分
由于SlidingMenu实现效果重点在于滑动,滑动前端显示的内容然后展现出下面的菜单部分,
所以重中之重自然就是这个CustViewAbove类里的onTouchEvent里的处理了

以下是核心方法ouTouchEvent中的分析,请先看完教程  Scroll效果研究-系统ScrollView源码分析



SlidingMenu的CustomViewAbove和ScrollView处理没什么区别,看注释就知道很多都是直接拷贝过去的

同理分按下,滑动,抬起几部分看
1.按下

1. case MotionEvent.ACTION_DOWN :
   
2.       /*
   
3.        * If being flinged and user touches, stop the fling. isFinished
   
4.        * will be false if being flinged.
   
5.        */
   
6.       completeScroll();
   
7. 
   
8.       // Remember where the motion event started
   
9.       int index = MotionEventCompat. getActionIndex(ev);
   
10.       mActivePointerId = MotionEventCompat. getPointerId(ev, index);
    
11.       mLastMotionX = mInitialMotionX = ev.getX();

复制代码

如果还在滚动则停止~
记住开始在哪里点下的,这里只记录了x轴坐标,因为侧滑只关注横线移动~
mActivityPointerId是记录多点触碰的activity第一个点的id,总之是用来处理多点除控时拖动的稳定性


2.滑动

1. case MotionEvent.ACTION_MOVE :
   
2.       if (!mIsBeingDragged) { 
   
3.             determineDrag(ev);
   
4.              if ( mIsUnableToDrag)
   
5.                    return false;
   
6.       }
   
7.       if (mIsBeingDragged) {
   
8.              // Scroll to follow the motion event
   
9.              final int activePointerIndex = getPointerIndex(ev, mActivePointerId);
   
10.              if ( mActivePointerId == INVALID_POINTER)
    
11.                    break;
    
12.              final float x = MotionEventCompat. getX(ev, activePointerIndex);
    
13.              final float deltaX = mLastMotionX - x;
    
14.              mLastMotionX = x;
    
15.              float oldScrollX = getScrollX();
    
16.              float scrollX = oldScrollX + deltaX;
    
17.              final float leftBound = getLeftBound();
    
18.              final float rightBound = getRightBound();
    
19.              if (scrollX < leftBound) {
    
20.                   scrollX = leftBound;
    
21.             } else if (scrollX > rightBound) {
    
22.                   scrollX = rightBound;
    
23.             }
    
24.              // Don't lose the rounded component
    
25.              mLastMotionX += scrollX - ( int) scrollX;
    
26.             scrollTo(( int) scrollX, getScrollY());
    
27.             pageScrolled(( int) scrollX);
    
28.       }
    
29.       break;

复制代码

挑重点介绍了
首先是determineDrag方法,即确定当前动作是否算是一个我们需要的拖动事件,是否要消费处理之~
方法如下

1. private void determineDrag(MotionEvent ev) {
   
2.       final int activePointerId = mActivePointerId;
   
3.       final int pointerIndex = getPointerIndex(ev, activePointerId);
   
4.       if (activePointerId == INVALID_POINTER || pointerIndex == INVALID_POINTER)
   
5.              return;
   
6.       final float x = MotionEventCompat. getX(ev, pointerIndex);
   
7.       final float dx = x - mLastMotionX;
   
8.       final float xDiff = Math.abs(dx);
   
9.       final float y = MotionEventCompat. getY(ev, pointerIndex);
   
10.       final float dy = y - mLastMotionY;
    
11.       final float yDiff = Math.abs(dy);
    
12.       if (xDiff > (isMenuOpen()? mTouchSlop/2: mTouchSlop) && xDiff > yDiff && thisSlideAllowed(dx)) {          
    
13.             startDrag();
    
14.              mLastMotionX = x;
    
15.              mLastMotionY = y;
    
16.             setScrollingCacheEnabled( true);
    
17.              // TODO add back in touch slop check
    
18.       } else if (xDiff > mTouchSlop) {
    
19.              mIsUnableToDrag = true;
    
20.       }
    
21. }

复制代码

最主要是地方在于if 对diff的判断语句
其中x/yDiff是x和y轴的移动距离长度,
mTouchSlop是系统对于拖动的最低长度判断,即至少移动多少多少距离,才算是一个拖动的动作~

所以判断的条件就是:
当菜单没打开时,xDiff大于mTouchSlop时才视为一个我们所需要的拖动,打开时则只要一半即可,
并且要同时满足xDiff>yDiff,即拖动是一个横向大于45度的
thisSlideAllowed可以理解为是判断是否是在菜单打开时touch到了菜单部分的位置

总结起来就是
如果拖动距离达到最小阀值且大于横向45度角度,且是touch到主体部分,则为我们需要的触摸事件

然后记录x,y的赋值给mLastMotionX/Y


当determineDrag判断这是一个我们需要的拖动事件了以后,就开始让aboveView随着动作滚动了
首先是最后一行pageScrolled(( int) scrollX);设置监听数据的,先无视
最重要是scrollTo方法,在系统的scrollTo基础上又加了点其他处理,如下

1. @Override
   
2. public void scrollTo(int x, int y) {
   
3.       super.scrollTo(x, y);
   
4.       mScrollX = x;
   
5.       mViewBehind.scrollBehindTo( mContent, x, y);     
   
6.       ((SlidingMenu)getParent()).manageLayers(getPercentOpen());
   
7. }

复制代码

下面代码中manageLayers是提高性能用的,不深入研究了

super.scrollTo就是让aboveView随着手势拖动滚动,这个比较简单

此外,
使用SlidingMenu的时候可以注意到,滚动上面主体内容展示后面菜单时,菜单也有一个滚动展开效果
这个mViewBehind.scrollBehindTo( mContent, x, y);就是处理这个的
这里先知道作用,分析完above部分后再详细分析behind部分,会介绍这个作用

然后是抬起方法,对于SlidingMenu,如果使用过肯定会有一定了解,以下是一些效果需求
如果菜单打开到一定位置,则抬起时菜单会完全打开
如果菜单打开部分太小,则抬起时菜单会收回去
还要有甩的处理,随着手势甩开菜单,甩关闭菜单~

下面是代码部分

1. case MotionEvent.ACTION_UP :
   
2.       if (mIsBeingDragged) {
   
3.              final VelocityTracker velocityTracker = mVelocityTracker;
   
4.             velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
   
5.              int initialVelocity = ( int) VelocityTrackerCompat.getXVelocity(
   
6.                         velocityTracker, mActivePointerId);
   
7.              final int scrollX = getScrollX();
   
8.              final float pageOffset = ( float) (scrollX - getDestScrollX(mCurItem)) / getBehindWidth();
   
9.              final int activePointerIndex = getPointerIndex(ev, mActivePointerId);
   
10.              if ( mActivePointerId != INVALID_POINTER) {
    
11.                    final float x = MotionEventCompat. getX(ev, activePointerIndex);
    
12.                    final int totalDelta = ( int) (x - mInitialMotionX);
    
13.                    int nextPage = determineTargetPage(pageOffset, initialVelocity, totalDelta);
    
14.                   setCurrentItemInternal(nextPage, true, true, initialVelocity);
    
15.             } else {    
    
16.                   setCurrentItemInternal( mCurItem, true, true, initialVelocity);
    
17.             }
    
18.              mActivePointerId = INVALID_POINTER;
    
19.             endDrag();
    
20.       } else if (mQuickReturn && mViewBehind.menuTouchInQuickReturn( mContent, mCurItem, ev.getX() + mScrollX)) {
    
21.              // close the menu
    
22.             setCurrentItem(1);
    
23.             endDrag();
    
24.       }
    
25.       break;

复制代码

同样,简单的不介绍了,参考之前的ScrollView源码分析教程
直接定位到SlidingMenu中特殊处理的部分

pageOffset为菜单当前打开比例,是一个0~1的值,比如打开一半了比例就是0.5,
该值可以是正可以是负,用于表示方向,向右为正向左为负~
计算方法为

1. final float pageOffset = ( float) (scrollX - getDestScrollX(mCurItem )) / getBehindWidth();

复制代码

mCurItem为当前页索引,可能是0,1,2
0代表左边的菜单打开状态,1是没有菜单打开,2是右边菜单打开

计算出页pageOffset后再根据速度和移动距离最终算出目标页位置,方法如下

1. private int determineTargetPage (float pageOffset, int velocity, int deltaX) {
   
2.       int targetPage = mCurItem;
   
3.       if (Math.abs(deltaX) > mFlingDistance && Math.abs(velocity) > mMinimumVelocity) {
   
4.              if (velocity > 0 && deltaX > 0) {
   
5.                   targetPage -= 1;
   
6.             } else if (velocity < 0 && deltaX < 0){
   
7.                   targetPage += 1;
   
8.             }
   
9.       } else {
   
10.             targetPage = ( int) Math. round(mCurItem + pageOffset);
    
11.       }
    
12.       return targetPage;
    
13. }

复制代码

速度和距离达到最小值后,则根据速度和距离的正负控制当前页索引加或减1,
当达不到if条件时,则计算当前页索引mCurItem与菜单打开状态比例值pageOffset和的四舍五入值~


举个else处理的例子
比如当前页为1即未打开菜单状态,此时左移了菜单宽度十分之三的距离,即pageOffset=-0.3
那结果就是 1 - 0.3 = 0.7 取四舍五入就是1~ 当前页还是1,即速度不够时移动三分之一抬起菜单还会收回去
还是刚才的条件,左移换成了十分之八的距离,即pageOffset=-0.8,
结果就是1 - 0.8 = 0.2 四舍五入就是0~ 即当前页应该是0左菜单了


以上简单总结就是,速度距离足够后,根据速度控制左右滑动来显示菜单或者内容
如果速度不够,则移动超过菜单一半距离时就切换菜单打开关闭状态,不然就收回去


注意,determineTargetPage方法只是获取目标页位置,实际跳转工作是下面的方法

1. void setCurrentItemInternal(int item, boolean smoothScroll, boolean always, int velocity) {
   
2.       if (!always && mCurItem == item) {
   
3.             setScrollingCacheEnabled( false);
   
4.              return;
   
5.       }
   
6. 
   
7.       item = mViewBehind.getMenuPage(item);
   
8. 
   
9.       final boolean dispatchSelected = mCurItem != item;
   
10.       mCurItem = item;
    
11.       final int destX = getDestScrollX(mCurItem );
    
12.       if (dispatchSelected && mOnPageChangeListener != null) {
    
13.              mOnPageChangeListener.onPageSelected(item);
    
14.       }
    
15.       if (dispatchSelected && mInternalPageChangeListener != null ) {
    
16.              mInternalPageChangeListener.onPageSelected(item);
    
17.       }
    
18.       if (smoothScroll) {
    
19.             smoothScrollTo(destX, 0, velocity);
    
20.       } else {
    
21.             completeScroll();
    
22.             scrollTo(destX, 0);
    
23.       }
    
24. }

复制代码

监听设置无视,核心方法是smoothScrollTo方法,如下

1. /**
   
2. * Like {@link View#scrollBy}, but scroll smoothly instead of immediately.
   
3. *
   
4. * @param x the number of pixels to scroll by on the X axis
   
5. * @param y the number of pixels to scroll by on the Y axis
   
6. * @param velocity the velocity associated with a fling, if applicable. (0 otherwise)
   
7. */
   
8. void smoothScrollTo(int x, int y, int velocity) {
   
9.       if (getChildCount() == 0) {
   
10.              // Nothing to do.
    
11.             setScrollingCacheEnabled( false);
    
12.              return;
    
13.       }
    
14.       int sx = getScrollX();
    
15.       int sy = getScrollY();
    
16.       int dx = x - sx;
    
17.       int dy = y - sy;
    
18.       if (dx == 0 && dy == 0) {
    
19.             completeScroll();
    
20.              if (isMenuOpen()) {
    
21.                    if ( mOpenedListener != null)
    
22.                          mOpenedListener.onOpened();
    
23.             } else {
    
24.                    if ( mClosedListener != null)
    
25.                          mClosedListener.onClosed();
    
26.             }
    
27.              return;
    
28.       }
    
29. 
    
30.       setScrollingCacheEnabled( true);
    
31.       mScrolling = true;
    
32. 
    
33.       final int width = getBehindWidth();
    
34.       final int halfWidth = width / 2;
    
35.       final float distanceRatio = Math. min(1f, 1.0f * Math.abs(dx) / width);
    
36.       final float distance = halfWidth + halfWidth *
    
37.                   distanceInfluenceForSnapDuration(distanceRatio);
    
38. 
    
39.       int duration = 0;
    
40.       velocity = Math.abs(velocity);
    
41.       if (velocity > 0) {
    
42.             duration = 4 * Math. round(1000 * Math.abs (distance / velocity));
    
43.       } else {
    
44.              final float pageDelta = ( float) Math. abs(dx) / width;
    
45.             duration = ( int) ((pageDelta + 1) * 100);
    
46.             duration = MAX_SETTLE_DURATION;
    
47.       }
    
48.       duration = Math.min(duration, MAX_SETTLE_DURATION);
    
49. 
    
50.       mScroller.startScroll(sx, sy, dx, dy, duration);
    
51.       invalidate();
    
52. }

复制代码

最后发现内部实现最终还是Scroller类的startScroll方法~让它继续完成打开/关闭菜单的剩下动画
至于duration滑动持续时间的计算算法就不研究了~Scroller用法也不介绍了,之前ScrollView教程里有

------------------------------------------------------------------------------------------------------

以上部分其实看懂ScrollView原理以后看完全没压力理解,但还有一个没介绍的知识点,touch事件分发问题~

问题场景:
在菜单打开的时候要进行判断,
如果点击在主体部分,则自动收回菜单,即让主体部分消费这个touch事件,
如果此时点击在菜单部分,那above中应该不消费此事件,要将其传给behind部分,
然后让behind中的listview或者button等自定义设置的控件去获取处理touch事件~


事件分发可以参考
http://www.eoeandroid.com/thread-277371-1-1.html

此外还有菜单状态打开时点主体部分则直接关闭菜单,或者back键直接关闭菜单等,原理上面都介绍了,
这些逻辑方面的处理还有其他一些优化部分就不介绍了~

------------------------------------------------------------------------------------------------------

菜单部分CustomViewBehind中内容不多,主要有两大块内容

1.滚动
研究主体内容部分的时候已经提到过,当前端内容部分拖动显示/关闭菜单时,菜单也有一个随之滚动的效果~

2.效果绘制
包括阴影,淡入淡出效果等


绘制部分比较复杂需要以后有时间专门介绍,先介绍滚动相关的部分即1
相关方法如下,该方法在CustomViewAbove的scrollTo中调用

1. public void scrollBehindTo(View content, int x, int y) {
   
2.       int vis = View. VISIBLE;
   
3.       if (mMode == SlidingMenu. LEFT) {
   
4.              if (x >= content.getLeft()) vis = View. INVISIBLE;
   
5.             scrollTo(( int)((x + getBehindWidth())* mScrollScale), y);
   
6.       } else if (mMode == SlidingMenu. RIGHT) {
   
7.              if (x <= content.getLeft()) vis = View. INVISIBLE;
   
8.             scrollTo(( int)(getBehindWidth() - getWidth() +
   
9.                         (x-getBehindWidth())* mScrollScale), y);
   
10.       } else if (mMode == SlidingMenu. LEFT_RIGHT) {
    
11.              mContent.setVisibility(x >= content.getLeft() ? View.INVISIBLE : View.VISIBLE );
    
12.              mSecondaryContent.setVisibility(x <= content.getLeft() ? View.INVISIBLE : View.VISIBLE );
    
13.             vis = x == 0 ? View. INVISIBLE : View. VISIBLE;
    
14.              if (x <= content.getLeft()) {
    
15.                   scrollTo(( int)((x + getBehindWidth())* mScrollScale), y);                     
    
16.             } else {
    
17.                   scrollTo(( int)(getBehindWidth() - getWidth() +
    
18.                               (x-getBehindWidth())* mScrollScale), y);                        
    
19.             }
    
20.       }
    
21.       if (vis == View. INVISIBLE)
    
22.             Log. v(TAG, "behind INVISIBLE" );
    
23.       setVisibility(vis);
    
24. }

复制代码

只分析LEFT的情况(请他情况同理)
比如菜单的width即getBehindWidth的宽度为300
那从菜单关闭状态一直滚到菜单完全打开状态,above主体内容x轴上的scroll变化就是0 ~ -300
此时如果mScrollScale即滚动比例为0.3
那按照上面scrollBehindTo中的算法, behind菜单部分x轴上的scroll变化就是
(0+300)*0.3 ~ (-300+300)*0.3即100~0

如果比例换成0.6,那behind的x变化就是180~0


极端情况下
1.mScrollScale=0, behind的x变化为 0~0, 此时会发现behind菜单部分在打开关闭的过程中无任何滚动
2.mScrollScale=1,behind的换标为300~0, 此时的效果就是主体和菜单紧挨着以同一个速度滚动


注意,这里的x为滚动的偏移量,即scrollTo使用的参数,
比如scrollView中,scrollTo(0, 100)会往下滚动到y偏移量100的位置,
此时scrollView里面的内容视觉上看其实是向上移了~
这里同理
虽然朝右拖动的时候view看上去是朝右运动,但x轴上滚动偏移量是减少的

------------------------------------------------------------------------------------------------------

最后是demo,自定义底部滑出菜单控件
根据SlidingMenu修改的,删除了SlidingMenu中大量代码,只保留了最核心的部分方便理解~

缺陷
限定死了behind菜单部分的高度和底部运动的比例值等在SlidingMenu中是可以设定的信息

转自 http://www.eoeandroid.com/thread-555167-1-1.html

链接： http://pan.baidu.com/s/1bnCPQiF 密码：pa0v