Android UI 之SlidingMenu实现方法（二）

分类： Android UI 整理 2013-05-09 21:08  830人阅读  评论(3)  收藏  举报

SlidingMenu ANDROID

           前一段时间写了一篇 Android小教程 滑动菜单 SlidingMenu 实现方法 （一） 今天拓展一下，实现一个可以实现菜单页联动的SlidingMenu。

    其实SlidingMenu的实现方实在太多太多，今天的实现思路在主体上也和上一篇文章中有所不同，尽量和大家分享多一些方法。另外功能上也更丰富一下。

先来解释一下我们要实现的效果：

    联动菜单页的意思就是我们在滑动主页面，以显示出或者隐藏菜单页的时候，菜单页相应的也会有一定的移动效果，就好像是主页面带着菜单页面一起滑动一样，

这样在用户体验上比静止不动的菜单页面要更好。除此之外我们额外添加手指快速略过检测速率以及在菜单打开状态下点击主页面关闭菜单的功能。

可能用文字来表述不是很形象，具体的一下效果可以看下面的GIF:

    因为我是在虚拟机里面跑的应用然后屏幕截图，总是一卡一卡的，大家先将就看吧，至于点击关闭菜单页以及快速略过打开和关闭菜单页的效果，大家可以在我最下面提供的源码下载里下载代码，然后跑到自己的手机上进行试验。

    下面来说我们的实现思路。

    我们要实现的这个效果，总体上包含了两部分，菜单页面部分和主页面（美女）部分。我们今天的实现思路是，在初次绘制的过程中，先布局菜单页面，让菜单页面的左上角坐标相对于SlidingMenu坐标系的原点向左侧偏移一定的距离。然后布局主页面，主页面就是整体填充我们的自定义SlidingMenu。

    具体的代码如下：

[java]  view plain copy

1. @Override  
2.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
3.         //设置容器大小，直接填充窗口  
4.         int width = MeasureSpec.getSize(widthMeasureSpec);  
5.         int height = MeasureSpec.getSize(heightMeasureSpec);  
6.         setMeasuredDimension(width, height);  
7.           
8.         //内部包含两个页面 一个menuPage,一个mainPage  
9.         //先来设置menuPage的大小，设置为父容器的1/3宽，高度与父容器相同  
10.         int menuPageWidthMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth() / 3, MeasureSpec.EXACTLY);  
11.         int menuPageHeightMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredHeight(), MeasureSpec.EXACTLY);  
12.         this.menuPage.measure(menuPageWidthMeasureSpec, menuPageHeightMeasureSpec);  
13.         //设置mainPage的大小，填充父容器的大小  
14.         int mainPageWidthMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth(), MeasureSpec.EXACTLY);  
15.         int mainPageHeightMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredHeight(), MeasureSpec.EXACTLY);  
16.         this.mainPage.measure(mainPageWidthMeasureSpec, mainPageHeightMeasureSpec);  
17.     }  
18.       
19.     @Override  
20.     protected void onLayout(boolean changed, int l, int t, int r, int b) {  
21.         if (!hasMeasured) {  
22.             //初始化菜单页面左上角坐标，用来第一次布局菜单页面  
23.             menuPageLeft = -getMeasuredWidth() / 12;  
24.             hasMeasured = true;  
25.         }  
26.           
27.         //校正  
28.         if (menuPageLeft > 0) {  
29.             menuPageLeft = 0;  
30.         }  
31.         if (menuPageLeft < -getMeasuredWidth() / 12) {  
32.             menuPageLeft = -getMeasuredWidth() / 12;  
33.         }  
34.         if (mainPageLeft > getMeasuredWidth() / 3) {  
35.             mainPageLeft = getMeasuredWidth() / 3;  
36.         }  
37.         if (mainPageLeft < 0) {  
38.             mainPageLeft = 0;  
39.         }  
40.           
41.         int menuPageTop = 0;  
42.         int mainPageTop = 0;  
43.         this.menuPage.layout((int)menuPageLeft, menuPageTop, (int) (menuPageLeft + getMeasuredWidth() / 3), menuPageTop + getMeasuredHeight());  
44.         this.mainPage.layout((int)mainPageLeft, mainPageTop, (int) (mainPageLeft + getMeasuredWidth()), mainPageTop + getMeasuredHeight());  
45.     }  

    在上面这部分代码 layout过程中，我们把菜单页面向左侧偏移了  -getMeasuredWidth() / 12   距离 也就是 SLidingMenu宽度的 1/12，我们规定的菜单页宽度是getMeasuredWidth() / 3  这个在measure过程中进行了定义，这两个值之间的比例是  1：:4 这个比例在后面也有用到。

    布局完成之后，我们就应该处理触摸过程了，我们的思路是在用户触摸的时候，根据坐标变化，动态的改变menuPage和mainPage的左上角坐标，然后请求重新布局来实现两个页面的滑动效果。具体代码片段如下：

[java]  view plain copy

1. @Override  
2.     public boolean onInterceptTouchEvent(MotionEvent ev) {  
3.         float x = ev.getX();  
4.         if (x < mainPageLeft) {  
5.             return false;  
6.         }  
7.           
8.         int action = ev.getAction();  
9.         if (action == MotionEvent.ACTION_MOVE && mTouchState != TOUCH_STATE_REST) {  
10.             return true;  
11.         }  
12.         switch (action) {  
13.         case MotionEvent.ACTION_MOVE:  
14.             int xDiff = (int) Math.abs(mLastMotionX - x);  
15.             if (xDiff > mTouchSlop) {  
16.                 //拦截  
17.                 mTouchState = TOUCH_STATE_SCROLLING;  
18.             }  
19.             break;  
20.         case MotionEvent.ACTION_DOWN:  
21.             mLastMotionX = x;  
22.             break;  
23.         case MotionEvent.ACTION_CANCEL:  
24.         case MotionEvent.ACTION_UP:  
25.             mTouchState = TOUCH_STATE_REST;  
26.             break;  
27.         }  
28.         return mTouchState != TOUCH_STATE_REST;  
29.     }  
30.       
31.     @Override  
32.     public boolean onTouchEvent(MotionEvent event) {  
33.         if (mVelocityTracker == null) {  
34.             mVelocityTracker = VelocityTracker.obtain();  
35.         }  
36.         mVelocityTracker.addMovement(event);  
37.           
38.         float x = event.getX();  
39.           
40.         switch (event.getAction()) {  
41.         case MotionEvent.ACTION_DOWN:  
42.             break;  
43.         case MotionEvent.ACTION_MOVE:  
44.             float deltaX = mLastMotionX - x;  
45.             mainPageLeft -= deltaX;  
46.             menuPageLeft -= deltaX / 4;  
47.             requestLayout();  
48.             mLastMotionX = x;  
49.             break;  
50.         case MotionEvent.ACTION_UP:  
51.             mVelocityTracker.computeCurrentVelocity(1000);  
52.             int velocityX = (int) mVelocityTracker.getXVelocity();  
53.             if (velocityX > SNAP_VELOCITY) {  
54.                 //显示菜单页面  
55.                 openMenu();  
56.             } else if (velocityX < -SNAP_VELOCITY) {  
57.                 //关闭菜单页面  
58.                 closeMenu();  
59.             } else {  
60.                 snapToDestination();  
61.             }  
62.             if (mVelocityTracker != null) {  
63.                 mVelocityTracker.recycle();  
64.                 mVelocityTracker = null;  
65.             }  
66.             mTouchState = TOUCH_STATE_REST;  
67.             break;  
68.         case MotionEvent.ACTION_CANCEL:  
69.             mTouchState = TOUCH_STATE_REST;  
70.             break;  
71.         }  
72.         return true;  
73.     }  

    在onTouchEvent中，我们在处理Move事件的时候，有这样两行代码，mainPageLeft -= deltaX;menuPageLeft -= deltaX / 4;  这里用到了我们前面用到的1:4 的比例关系。

    openMenu()和closeMenu()代码片段如下：这一段需要解释的地方不多：

[java]  view plain copy

1. /** 
2.      * 快速略过，显示菜单页面 
3.      */  
4.     public void openMenu() {  
5.         //主界面  
6.         new Thread(new Runnable() {  
7.               
8.             @Override  
9.             public void run() {  
10.                 while(mainPageLeft <= getMeasuredWidth() / 3) {  
11.                     mainPageLeft += 10;  
12.                     try {  
13.                         Thread.sleep(10);  
14.                     } catch (InterruptedException e) {  
15.                         e.printStackTrace();  
16.                     }  
17.                     uiHandler.obtainMessage(0x00, 0x01, 0x00).sendToTarget();  
18.                 }  
19.             }  
20.         }).start();  
21.         //菜单界面  
22.         new Thread(new Runnable() {  
23.               
24.             @Override  
25.             public void run() {  
26.                 while (menuPageLeft <= 0) {  
27.                     menuPageLeft += 2.5;  
28.                     try {  
29.                         Thread.sleep(10);  
30.                     } catch (InterruptedException e) {  
31.                         e.printStackTrace();  
32.                     }  
33.                     uiHandler.obtainMessage(0x00, 0x01, 0x00).sendToTarget();  
34.                 }  
35.             }  
36.         }).start();  
37.     }  
38.     /** 
39.      * 快速略过，关闭菜单页面 
40.      */  
41.     public void closeMenu() {  
42.         //主界面  
43.         new Thread(new Runnable() {  
44.               
45.             @Override  
46.             public void run() {  
47.                 while(mainPageLeft >= 0) {  
48.                     mainPageLeft -= 10;  
49.                     try {  
50.                         Thread.sleep(10);  
51.                     } catch (InterruptedException e) {  
52.                         e.printStackTrace();  
53.                     }  
54.                     uiHandler.obtainMessage(0x00, 0x01, 0x00).sendToTarget();  
55.                 }  
56.             }  
57.         }).start();  
58.         //菜单页面  
59.         new Thread(new Runnable() {  
60.               
61.             @Override  
62.             public void run() {  
63.                 while (menuPageLeft >= -getMeasuredWidth() / 12) {  
64.                     menuPageLeft -= 2.5;  
65.                     try {  
66.                         Thread.sleep(10);  
67.                     } catch (InterruptedException e) {  
68.                         e.printStackTrace();  
69.                     }  
70.                     uiHandler.obtainMessage(0x00, 0x01, 0x00).sendToTarget();  
71.                 }  
72.             }  
73.         }).start();  
74.     }  

    上面代码中 10 与 2.5 这两个值也是用到了前面 1:4的比例关系。

    好了，相信大家仔细读完上面的文字都会明白我实现的思路了，下面是完整的代码和源码下载，我做的注释还是比较全的，仔细看一定能明白原理！

[java]  view plain copy

1. package com.example.demo;  
2.   
3. import java.lang.ref.WeakReference;  
4.   
5. import android.content.Context;  
6. import android.os.Handler;  
7. import android.os.Message;  
8. import android.util.AttributeSet;  
9. import android.view.MotionEvent;  
10. import android.view.VelocityTracker;  
11. import android.view.View;  
12. import android.view.ViewConfiguration;  
13. import android.view.ViewGroup;  
14. import android.widget.FrameLayout;  
15. import android.view.View.OnClickListener;  
16. /** 
17.  * 滑动菜单界面容器 
18.  * @author carrey 
19.  * 
20.  */  
21. public class SlidingMenuViewGroup extends ViewGroup implements OnClickListener {  
22.     /** 场景 */  
23.     private Context mContext;  
24.     /** 菜单页面 */  
25.     private ViewGroup menuPage;  
26.     /** 主页面 */  
27.     private FrameLayout mainPage;  
28.     /** 静止状态值 */  
29.     private final int TOUCH_STATE_REST = 0;  
30.     /** 滚动状态值 */  
31.     private final int TOUCH_STATE_SCROLLING = 1;  
32.     /** 当前的滚动与否状态 */  
33.     private int mTouchState = TOUCH_STATE_REST;  
34.     /** 能够拦截左右划屏事件的最小判断距离 */  
35.     private int mTouchSlop;  
36.     /** 记录上一次触摸事件的x坐标 */  
37.     private float mLastMotionX;  
38.     /** 检测快速略过屏幕动作的速率 */  
39.     private VelocityTracker mVelocityTracker;  
40.     /** 快速略过动作有效的最小速度 */  
41.     private final int SNAP_VELOCITY = 600;  
42.     /** 主页面左上角坐标 */  
43.     private float mainPageLeft;  
44.     /** 菜单页面左上角坐标 */  
45.     private float menuPageLeft;  
46.     /** 是否经历过measure过程的标记 */  
47.     private boolean hasMeasured;  
48.     /** 页面Handler */  
49.     private UIHandler uiHandler;  
50.       
51.     public SlidingMenuViewGroup(Context context) {  
52.         super(context);  
53.         this.mContext = context;  
54.         init();  
55.     }  
56.     public SlidingMenuViewGroup(Context context, AttributeSet attrs) {  
57.         super(context, attrs);  
58.         this.mContext = context;  
59.         init();  
60.     }  
61.     /** 
62.      * 一些参数的初始化操作 
63.      */  
64.     private void init() {  
65.         mTouchSlop = ViewConfiguration.get(mContext).getScaledEdgeSlop();  
66.         uiHandler = new UIHandler(this);  
67.     }  
68.     /** 
69.      * 把菜单页面和主页面添加安装进容器内 
70.      * @param menuPage 
71.      * @param mainPage 
72.      */  
73.     public void setupMenuAndMainPage(ViewGroup menuPage, FrameLayout mainPage) {  
74.         this.menuPage = menuPage;  
75.         this.mainPage = mainPage;  
76.           
77.         this.mainPage.setOnClickListener(this);  
78.           
79.         this.addView(this.menuPage);  
80.         this.addView(this.mainPage);  
81.     }  
82.     /** 
83.      * 点击主界面，在打开的情况下，会关闭菜单页面 
84.      */  
85.     @Override  
86.     public void onClick(View v) {  
87.         if (mainPageLeft == getMeasuredWidth() / 3) {  
88.             closeMenu();  
89.         }  
90.     }  
91.       
92.     @Override  
93.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
94.         //设置容器大小，直接填充窗口  
95.         int width = MeasureSpec.getSize(widthMeasureSpec);  
96.         int height = MeasureSpec.getSize(heightMeasureSpec);  
97.         setMeasuredDimension(width, height);  
98.           
99.         //内部包含两个页面 一个menuPage,一个mainPage  
100.         //先来设置menuPage的大小，设置为父容器的1/3宽，高度与父容器相同  
101.         int menuPageWidthMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth() / 3, MeasureSpec.EXACTLY);  
102.         int menuPageHeightMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredHeight(), MeasureSpec.EXACTLY);  
103.         this.menuPage.measure(menuPageWidthMeasureSpec, menuPageHeightMeasureSpec);  
104.         //设置mainPage的大小，填充父容器的大小  
105.         int mainPageWidthMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth(), MeasureSpec.EXACTLY);  
106.         int mainPageHeightMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredHeight(), MeasureSpec.EXACTLY);  
107.         this.mainPage.measure(mainPageWidthMeasureSpec, mainPageHeightMeasureSpec);  
108.     }  
109.       
110.     @Override  
111.     protected void onLayout(boolean changed, int l, int t, int r, int b) {  
112.         if (!hasMeasured) {  
113.             //初始化菜单页面左上角坐标，用来第一次布局菜单页面  
114.             menuPageLeft = -getMeasuredWidth() / 12;  
115.             hasMeasured = true;  
116.         }  
117.           
118.         //校正  
119.         if (menuPageLeft > 0) {  
120.             menuPageLeft = 0;  
121.         }  
122.         if (menuPageLeft < -getMeasuredWidth() / 12) {  
123.             menuPageLeft = -getMeasuredWidth() / 12;  
124.         }  
125.         if (mainPageLeft > getMeasuredWidth() / 3) {  
126.             mainPageLeft = getMeasuredWidth() / 3;  
127.         }  
128.         if (mainPageLeft < 0) {  
129.             mainPageLeft = 0;  
130.         }  
131.           
132.         int menuPageTop = 0;  
133.         int mainPageTop = 0;  
134.         this.menuPage.layout((int)menuPageLeft, menuPageTop, (int) (menuPageLeft + getMeasuredWidth() / 3), menuPageTop + getMeasuredHeight());  
135.         this.mainPage.layout((int)mainPageLeft, mainPageTop, (int) (mainPageLeft + getMeasuredWidth()), mainPageTop + getMeasuredHeight());  
136.     }  
137.   
138.     @Override  
139.     public boolean onInterceptTouchEvent(MotionEvent ev) {  
140.         float x = ev.getX();  
141.         if (x < mainPageLeft) {  
142.             return false;  
143.         }  
144.           
145.         int action = ev.getAction();  
146.         if (action == MotionEvent.ACTION_MOVE && mTouchState != TOUCH_STATE_REST) {  
147.             return true;  
148.         }  
149.         switch (action) {  
150.         case MotionEvent.ACTION_MOVE:  
151.             int xDiff = (int) Math.abs(mLastMotionX - x);  
152.             if (xDiff > mTouchSlop) {  
153.                 //拦截  
154.                 mTouchState = TOUCH_STATE_SCROLLING;  
155.             }  
156.             break;  
157.         case MotionEvent.ACTION_DOWN:  
158.             mLastMotionX = x;  
159.             break;  
160.         case MotionEvent.ACTION_CANCEL:  
161.         case MotionEvent.ACTION_UP:  
162.             mTouchState = TOUCH_STATE_REST;  
163.             break;  
164.         }  
165.         return mTouchState != TOUCH_STATE_REST;  
166.     }  
167.       
168.     @Override  
169.     public boolean onTouchEvent(MotionEvent event) {  
170.         if (mVelocityTracker == null) {  
171.             mVelocityTracker = VelocityTracker.obtain();  
172.         }  
173.         mVelocityTracker.addMovement(event);  
174.           
175.         float x = event.getX();  
176.           
177.         switch (event.getAction()) {  
178.         case MotionEvent.ACTION_DOWN:  
179.             break;  
180.         case MotionEvent.ACTION_MOVE:  
181.             float deltaX = mLastMotionX - x;  
182.             mainPageLeft -= deltaX;  
183.             menuPageLeft -= deltaX / 4;  
184.             requestLayout();  
185.             mLastMotionX = x;  
186.             break;  
187.         case MotionEvent.ACTION_UP:  
188.             mVelocityTracker.computeCurrentVelocity(1000);  
189.             int velocityX = (int) mVelocityTracker.getXVelocity();  
190.             if (velocityX > SNAP_VELOCITY) {  
191.                 //显示菜单页面  
192.                 openMenu();  
193.             } else if (velocityX < -SNAP_VELOCITY) {  
194.                 //关闭菜单页面  
195.                 closeMenu();  
196.             } else {  
197.                 snapToDestination();  
198.             }  
199.             if (mVelocityTracker != null) {  
200.                 mVelocityTracker.recycle();  
201.                 mVelocityTracker = null;  
202.             }  
203.             mTouchState = TOUCH_STATE_REST;  
204.             break;  
205.         case MotionEvent.ACTION_CANCEL:  
206.             mTouchState = TOUCH_STATE_REST;  
207.             break;  
208.         }  
209.         return true;  
210.     }  
211.     /** 
212.      * UIHandler 
213.      * @author carrey 
214.      * 
215.      */  
216.     private static class UIHandler extends Handler {  
217.         private ViewGroup container;  
218.         private WeakReference<ViewGroup> containerWR;  
219.         public UIHandler(ViewGroup container) {  
220.             this.containerWR = new WeakReference<ViewGroup>(container);  
221.             this.container = containerWR.get();  
222.         }  
223.           
224.         @Override  
225.         public void handleMessage(Message msg) {  
226.             switch (msg.arg1) {  
227.             case 0x01:  
228.                 container.requestLayout();  
229.                 break;  
230.             }  
231.             super.handleMessage(msg);  
232.         }  
233.     }     
234.     /** 
235.      * 手指缓缓滑动后离开屏幕的处理 
236.      */  
237.     private void snapToDestination() {  
238.         //通过mainPageLeft来判断滚动到的页面  
239.         if (mainPageLeft >= getMeasuredWidth() / 6) {  
240.             openMenu();  
241.         } else {  
242.             closeMenu();  
243.         }  
244.     }  
245.     /** 
246.      * 快速略过，显示菜单页面 
247.      */  
248.     public void openMenu() {  
249.         //主界面  
250.         new Thread(new Runnable() {  
251.               
252.             @Override  
253.             public void run() {  
254.                 while(mainPageLeft <= getMeasuredWidth() / 3) {  
255.                     mainPageLeft += 10;  
256.                     try {  
257.                         Thread.sleep(10);  
258.                     } catch (InterruptedException e) {  
259.                         e.printStackTrace();  
260.                     }  
261.                     uiHandler.obtainMessage(0x00, 0x01, 0x00).sendToTarget();  
262.                 }  
263.             }  
264.         }).start();  
265.         //菜单界面  
266.         new Thread(new Runnable() {  
267.               
268.             @Override  
269.             public void run() {  
270.                 while (menuPageLeft <= 0) {  
271.                     menuPageLeft += 2.5;  
272.                     try {  
273.                         Thread.sleep(10);  
274.                     } catch (InterruptedException e) {  
275.                         e.printStackTrace();  
276.                     }  
277.                     uiHandler.obtainMessage(0x00, 0x01, 0x00).sendToTarget();  
278.                 }  
279.             }  
280.         }).start();  
281.     }  
282.     /** 
283.      * 快速略过，关闭菜单页面 
284.      */  
285.     public void closeMenu() {  
286.         //主界面  
287.         new Thread(new Runnable() {  
288.               
289.             @Override  
290.             public void run() {  
291.                 while(mainPageLeft >= 0) {  
292.                     mainPageLeft -= 10;  
293.                     try {  
294.                         Thread.sleep(10);  
295.                     } catch (InterruptedException e) {  
296.                         e.printStackTrace();  
297.                     }  
298.                     uiHandler.obtainMessage(0x00, 0x01, 0x00).sendToTarget();  
299.                 }  
300.             }  
301.         }).start();  
302.         //菜单页面  
303.         new Thread(new Runnable() {  
304.               
305.             @Override  
306.             public void run() {  
307.                 while (menuPageLeft >= -getMeasuredWidth() / 12) {  
308.                     menuPageLeft -= 2.5;  
309.                     try {  
310.                         Thread.sleep(10);  
311.                     } catch (InterruptedException e) {  
312.                         e.printStackTrace();  
313.                     }  
314.                     uiHandler.obtainMessage(0x00, 0x01, 0x00).sendToTarget();  
315.                 }  
316.             }  
317.         }).start();  
318.     }  
319. }  

源码下载