Android FoldingLayout 折叠布局 原理及实现（二）

转载请标明出处： http://blog.csdn.net/lmj623565791/article/details/44283093 ，本文出自： 【张鸿洋的博客】

1、概述

在上一篇Android FoldingLayout 折叠布局 原理及实现（一）我们实现了下面的1，2，3。

1、Matrix的setPolyToPoly使用

2、在图片上使用渐变和阴影

3、初步的FoldingLayout的实现，完成图片的折叠显示（可控制折叠次数、包含阴影的绘制）

4、引入手势，手指可以可以FoldingLayout的折叠

5、结合DrawerLayout实现折叠式侧滑

6、结合SlidingPaneLayout实现折叠式侧滑

本篇博客将继续完成4，5，6的内容。

上一篇博客中，我们实现了在一个自定义View种绘制我们的折叠图片，使用的是一个固定的图片，当然我们在实际使用中，希望可以折叠某一个布局而不是一张固定的图片。

所以首先我们把上一篇的博客进行修改，改为一个自定义的ViewGroup，我们叫做FoldLayout。

2、FoldLayout的实现

1、实现

我们的想法是这样的，我们的FoldLayout只能有一个直接子元素，当然这个子元素可以是RelativeLayout什么的，可以很复杂。然后只要外层套了我们的FoldLayout，就能实现折叠效果。

那么也就是说，我们的FoldLayout折叠效果展示的是它的子元素的“样子”，那么如何或者这个“样子”呢？

大家都知道，我们的ViewGroup有个方法叫做：dispatchDraw(Canvas)主要用来绘制子元素，我们可以对这个canvas进行设置matrix，以及重复调用dispatchDraw(Canvas)来实现类似上篇博客最后的效果，这样就完成了我们的可行性的分析。

[java]  view plain  copy

 

1. package com.zhy.view;  
2.   
3. import android.content.Context;  
4. import android.graphics.Bitmap;  
5. import android.graphics.Bitmap.Config;  
6. import android.graphics.Canvas;  
7. import android.graphics.Color;  
8. import android.graphics.LinearGradient;  
9. import android.graphics.Matrix;  
10. import android.graphics.Paint;  
11. import android.graphics.Paint.Style;  
12. import android.graphics.Shader.TileMode;  
13. import android.util.AttributeSet;  
14. import android.view.View;  
15. import android.view.ViewGroup;  
16.   
17. public class FoldLayout extends ViewGroup  
18. {  
19.   
20.     private static final int NUM_OF_POINT = 8;  
21.     /** 
22.      * 图片的折叠后的总宽度 
23.      */  
24.     private float mTranslateDis;  
25.   
26.     protected float mFactor = 0.6f;  
27.   
28.     private int mNumOfFolds = 8;  
29.   
30.     private Matrix[] mMatrices = new Matrix[mNumOfFolds];  
31.   
32.     private Paint mSolidPaint;  
33.   
34.     private Paint mShadowPaint;  
35.     private Matrix mShadowGradientMatrix;  
36.     private LinearGradient mShadowGradientShader;  
37.   
38.     private float mFlodWidth;  
39.     private float mTranslateDisPerFlod;  
40.   
41.     public FoldLayout(Context context)  
42.     {  
43.         this(context, null);  
44.     }  
45.   
46.     public FoldLayout(Context context, AttributeSet attrs)  
47.     {  
48.         super(context, attrs);  
49.   
50.         for (int i = 0; i < mNumOfFolds; i++)  
51.         {  
52.             mMatrices[i] = new Matrix();  
53.         }  
54.   
55.         mSolidPaint = new Paint();  
56.         mShadowPaint = new Paint();  
57.         mShadowPaint.setStyle(Style.FILL);  
58.         mShadowGradientShader = new LinearGradient(0, 0, 0.5f, 0, Color.BLACK,  
59.                 Color.TRANSPARENT, TileMode.CLAMP);  
60.         mShadowPaint.setShader(mShadowGradientShader);  
61.         mShadowGradientMatrix = new Matrix();  
62.         this.setWillNotDraw(false);  
63.   
64.     }  
65.   
66.     @Override  
67.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)  
68.     {  
69.         View child = getChildAt(0);  
70.         measureChild(child, widthMeasureSpec, heightMeasureSpec);  
71.         setMeasuredDimension(child.getMeasuredWidth(),  
72.                 child.getMeasuredHeight());  
73.   
74.     }  
75.   
76.     @Override  
77.     protected void onLayout(boolean changed, int l, int t, int r, int b)  
78.     {  
79.         View child = getChildAt(0);  
80.         child.layout(0, 0, child.getMeasuredWidth(), child.getMeasuredHeight());  
81.   
82.         mBitmap = Bitmap.createBitmap(getMeasuredWidth(), getMeasuredHeight(),  
83.                 Config.ARGB_8888);  
84.         mCanvas.setBitmap(mBitmap);  
85.         updateFold();  
86.   
87.     }  
88.   
89.     private void updateFold()  
90.     {  
91.         int w = getMeasuredWidth();  
92.         int h = getMeasuredHeight();  
93.   
94.         mTranslateDis = w * mFactor;  
95.         mFlodWidth = w / mNumOfFolds;  
96.         mTranslateDisPerFlod = mTranslateDis / mNumOfFolds;  
97.   
98.         int alpha = (int) (255 * (1 - mFactor));  
99.         mSolidPaint.setColor(Color.argb((int) (alpha * 0.8F), 0, 0, 0));  
100.   
101.         mShadowGradientMatrix.setScale(mFlodWidth, 1);  
102.         mShadowGradientShader.setLocalMatrix(mShadowGradientMatrix);  
103.         mShadowPaint.setAlpha(alpha);  
104.   
105.         float depth = (float) (Math.sqrt(mFlodWidth * mFlodWidth  
106.                 - mTranslateDisPerFlod * mTranslateDisPerFlod) / 2);  
107.   
108.         float[] src = new float[NUM_OF_POINT];  
109.         float[] dst = new float[NUM_OF_POINT];  
110.   
111.         for (int i = 0; i < mNumOfFolds; i++)  
112.         {  
113.             mMatrices[i].reset();  
114.             src[0] = i * mFlodWidth;  
115.             src[1] = 0;  
116.             src[2] = src[0] + mFlodWidth;  
117.             src[3] = 0;  
118.             src[4] = src[2];  
119.             src[5] = h;  
120.             src[6] = src[0];  
121.             src[7] = src[5];  
122.   
123.             boolean isEven = i % 2 == 0;  
124.   
125.             dst[0] = i * mTranslateDisPerFlod;  
126.             dst[1] = isEven ? 0 : depth;  
127.   
128.             dst[2] = dst[0] + mTranslateDisPerFlod;  
129.             dst[3] = isEven ? depth : 0;  
130.             dst[4] = dst[2];  
131.             dst[5] = isEven ? h - depth : h;  
132.             dst[6] = dst[0];  
133.             dst[7] = isEven ? h : h - depth;  
134.   
135.             for (int y = 0; y < 8; y++)  
136.             {  
137.                 dst[y] = Math.round(dst[y]);  
138.             }  
139.   
140.             mMatrices[i].setPolyToPoly(src, 0, dst, 0, src.length >> 1);  
141.         }  
142.     }  
143.   
144.     private Canvas mCanvas = new Canvas();  
145.     private Bitmap mBitmap;  
146.     private boolean isReady;  
147.   
148.     @Override  
149.     protected void dispatchDraw(Canvas canvas)  
150.     {  
151.   
152.         if (mFactor == 0)  
153.             return;  
154.         if (mFactor == 1)  
155.         {  
156.             super.dispatchDraw(canvas);  
157.             return;  
158.         }  
159.         for (int i = 0; i < mNumOfFolds; i++)  
160.         {  
161.             canvas.save();  
162.   
163.             canvas.concat(mMatrices[i]);  
164.             canvas.clipRect(mFlodWidth * i, 0, mFlodWidth * i + mFlodWidth,  
165.                     getHeight());  
166.             if (isReady)  
167.             {  
168.                 canvas.drawBitmap(mBitmap, 0, 0, null);  
169.             } else  
170.             {  
171.                 // super.dispatchDraw(canvas);  
172.                 super.dispatchDraw(mCanvas);  
173.                 canvas.drawBitmap(mBitmap, 0, 0, null);  
174.                 isReady = true;  
175.             }  
176.             canvas.translate(mFlodWidth * i, 0);  
177.             if (i % 2 == 0)  
178.             {  
179.                 canvas.drawRect(0, 0, mFlodWidth, getHeight(), mSolidPaint);  
180.             } else  
181.             {  
182.                 canvas.drawRect(0, 0, mFlodWidth, getHeight(), mShadowPaint);  
183.             }  
184.             canvas.restore();  
185.         }  
186.     }  
187.         //...dispatchDraw  
188.   
189.     public void setFactor(float factor)  
190.     {  
191.         this.mFactor = factor;  
192.         updateFold();  
193.         invalidate();  
194.     }  
195.   
196.     public float getFactor()  
197.     {  
198.         return mFactor;  
199.     }  
200.   
201. }  

上述代码大家应该不陌生，只是把从View对单个图片进行绘制的修改为了ViewGroup。

既然是ViewGroup少不了onMeasure,onLayout等。测量和布局完全依赖于它的子View。

然后将需要初始化的一些东西，不依赖于宽度的，比如画笔什么的都放在构造中；依赖宽高的，都在onLayout之后，调用了updateFold();进行初始化相关代码。

updateFold中的代码，我们也不陌生，因为和上篇博客基本一致。主要就是计算mFlodWidth，mTranslateDisPerFlod以及根据设置的mNumOfFolds去循环初始化我们的matrix.

matrix完成setPolyToPoly以后，我们就可以去绘制了：

[java]  view plain  copy

 

1. private Canvas mCanvas = new Canvas();  
2.     private Bitmap mBitmap;  
3.     private boolean isReady;  
4.   
5.     @Override  
6.     protected void dispatchDraw(Canvas canvas)  
7.     {  
8.   
9.         if (mFactor == 0)  
10.             return;  
11.         if (mFactor == 1)  
12.         {  
13.             super.dispatchDraw(canvas);  
14.             return;  
15.         }  
16.         for (int i = 0; i < mNumOfFolds; i++)  
17.         {  
18.             canvas.save();  
19.   
20.             canvas.concat(mMatrices[i]);  
21.             canvas.clipRect(mFlodWidth * i, 0, mFlodWidth * i + mFlodWidth,  
22.                     getHeight());  
23.             if (isReady)  
24.             {  
25.                 canvas.drawBitmap(mBitmap, 0, 0, null);  
26.             } else  
27.             {  
28.                 // super.dispatchDraw(canvas);  
29.                 super.dispatchDraw(mCanvas);  
30.                 canvas.drawBitmap(mBitmap, 0, 0, null);  
31.                 isReady = true;  
32.             }  
33.             canvas.translate(mFlodWidth * i, 0);  
34.             if (i % 2 == 0)  
35.             {  
36.                 canvas.drawRect(0, 0, mFlodWidth, getHeight(), mSolidPaint);  
37.             } else  
38.             {  
39.                 canvas.drawRect(0, 0, mFlodWidth, getHeight(), mShadowPaint);  
40.             }  
41.             canvas.restore();  
42.         }  
43.     }  

mFactor主要代表折叠后的总宽度与原宽度的比值，默认不折叠时为1，所以直接调用super.dispatchDraw(canvas);
那么如果为0，说明全部折起来了，我们直接if (mFactor == 0)return;就不要绘制了。

如果(0,1)之间就是正常情况了，如果还记得上一篇博客内容，无非就是根据mNumOfFolds循环绘制多次，每次绘制的时候设置matrix,利用clipRect就可以实现我们的折叠。

这里大家注意看，我在第一次绘制的时候，调用了：

[java]  view plain  copy

 

1. super.dispatchDraw(mCanvas);  
2. canvas.drawBitmap(mBitmap, 0, 0, null);  
3. isReady = true;  

在我们自己new的mBitmap中也绘制了一份图片，因为我不希望每次都是调用super.dispatchDraw，所以只要isReady=true，我们就可以去调用绘制mBitmap而避免调用super.dispatchDraw()。

绘制完成图片，就是绘制黑色的遮盖和阴影了~~，就是两个Rect的绘制。

完成这些以后，我们可以简单的坐下测试，使用我们的布局。

2、测试

布局文件:

[html]  view plain  copy

 

1. <com.zhy.view.FoldLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2.     xmlns:tools="http://schemas.android.com/tools"  
3.     android:id="@+id/id_fold_layout"  
4.     android:layout_width="match_parent"  
5.     android:layout_height="match_parent" >  
6.   
7.     <ImageView  
8.         android:layout_width="match_parent"  
9.         android:layout_height="match_parent"  
10.         android:scaleType="fitXY"  
11.         android:src="@drawable/xueshan" />  
12.   
13. </com.zhy.view.FoldLayout>  

Activity

[java]  view plain  copy

 

1. package com.zhy.sample.folderlayout;  
2.   
3. import com.zhy.view.FoldLayout;  
4.   
5. import android.animation.ObjectAnimator;  
6. import android.annotation.SuppressLint;  
7. import android.app.Activity;  
8. import android.os.Bundle;  
9.   
10. public class FoldLayoutActivity extends Activity  
11. {  
12.     private FoldLayout mFoldLayout;  
13.   
14.     @Override  
15.     protected void onCreate(Bundle savedInstanceState)  
16.     {  
17.         super.onCreate(savedInstanceState);  
18.         setContentView(R.layout.activity_fold);  
19.   
20.         mFoldLayout = (FoldLayout) findViewById(R.id.id_fold_layout);  
21.       
22.         /*mFoldLayout.post(new Runnable() 
23.         { 
24.  
25.             @SuppressLint("NewApi") 
26.             @Override 
27.             public void run() 
28.             { 
29.                 ObjectAnimator.ofFloat(mFoldLayout, "factor", 1, 0, 1) 
30.                         .setDuration(5000).start(); 
31.             } 
32.         });*/  
33.   
34.     }  
35. }  

现在的效果是，我们把mFactor改为0.6f:

当然了，此时只是静态的，但是我们成功的完成了绘制一个静态图到FlodLayout。

接下来我们为其增加手指的触摸折叠功能。

3、TouchFoldLayout

1、实现

增加触摸功能其实很简单，我们的绘制依赖mFactor这个值，我们只要在onTouchEvent里面去累加手指移动距离，然后动态更新这个值就可以了。

[java]  view plain  copy

 

1. package com.zhy.view;  
2.   
3. import android.content.Context;  
4. import android.graphics.Canvas;  
5. import android.util.AttributeSet;  
6. import android.view.GestureDetector;  
7. import android.view.MotionEvent;  
8.   
9. public class TouchFoldLayout extends FoldLayout  
10. {  
11.   
12.     private GestureDetector mScrollGestureDetector;  
13.   
14.     public TouchFoldLayout(Context context, AttributeSet attrs)  
15.     {  
16.         super(context, attrs);  
17.         init(context, attrs);  
18.     }  
19.   
20.     public void init(Context context, AttributeSet attrs)  
21.     {  
22.         mScrollGestureDetector = new GestureDetector(context,  
23.                 new ScrollGestureDetector());  
24.   
25.     }  
26.   
27.     @Override  
28.     public boolean onTouchEvent(MotionEvent event)  
29.     {  
30.         return mScrollGestureDetector.onTouchEvent(event);  
31.     }  
32.   
33.     private int mTranslation = -1;  
34.   
35.     @Override  
36.     protected void dispatchDraw(Canvas canvas)  
37.     {  
38.         if (mTranslation == -1)  
39.             mTranslation = getWidth();  
40.         super.dispatchDraw(canvas);  
41.     }  
42.   
43.     class ScrollGestureDetector extends GestureDetector.SimpleOnGestureListener  
44.     {  
45.         @Override  
46.         public boolean onDown(MotionEvent e)  
47.         {  
48.             return true;  
49.         }  
50.   
51.         @Override  
52.         public boolean onScroll(MotionEvent e1, MotionEvent e2,  
53.                 float distanceX, float distanceY)  
54.         {  
55.             mTranslation -= distanceX;  
56.   
57.             if (mTranslation < 0)  
58.             {  
59.                 mTranslation = 0;  
60.             }  
61.             if (mTranslation > getWidth())  
62.             {  
63.                 mTranslation = getWidth();  
64.             }  
65.   
66.             float factor = Math.abs(((float) mTranslation)  
67.                     / ((float) getWidth()));  
68.   
69.             setFactor(factor);  
70.   
71.             return true;  
72.         }  
73.     }  
74.   
75. }  

我们选择继承FoldLayout，重写其onTouchEvent，然后通过mScrollGestureDetector获取移动的距离，最终和width做比值得到我们的factor，然后调用setFactor进行改变。

[java]  view plain  copy

 

1. public void setFactor(float factor)  
2. {  
3.     this.mFactor = factor;  
4.     updateFold();  
5.     invalidate();  
6. }  

ok,这样就完成了引入手指的控制。

2、测试

现在改变下布局文件里面的类：

[java]  view plain  copy

 

1. <com.zhy.view.TouchFoldLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2.     xmlns:tools="http://schemas.android.com/tools"  
3.     android:id="@+id/id_fold_layout"  
4.     android:layout_width="match_parent"  
5.     android:layout_height="match_parent" >  
6.   
7.     <ImageView  
8.         android:layout_width="match_parent"  
9.         android:layout_height="match_parent"  
10.         android:scaleType="fitXY"  
11.         android:src="@drawable/xueshan" />  
12.   
13. </com.zhy.view.TouchFoldLayout>  

Activity不变，看一下测试效果：（测试前记得把mFactor改为默认值1.0f）

至此我们完成了炫酷的效果，但是我们还需要应用到具体的案例上，否则就是特技，有必要duang一下。

于是我们首先考虑增加到侧滑菜单中去，侧滑菜单有很多选择，google也提供了两个，一个是DrawerLayout，另一个是SlidingPaneLayout。

下面分别展示如何整合入这两个布局。

首先看SlidingPaneLayout，因为DrawerLayout还有些地方需要修改。

4、FoldSlidingPanelLayout

1、实现

对于SlidingPaneLayout的使用，应该没什么问题吧，就是把布局文件的根布局设置为SlidingPaneLayout，然后里面放两个子布局，一个代表侧滑菜单，一个代表内容区域。

那么，我们怎么整合到SlidingPaneLayout种去呢？大致两种方法：

1、把我们的折叠菜单作为侧滑布局的根布局，然后在Activity种去监听setPanelSlideListener做出改变。

2、直接继承SlidingPaneLayout，再其内部将child(0)用FoldLayout包起来，然后监听setPanelSlideListener。

这里我们选择后者，因为后者封装好了，就能直接按照SlidingPaneLayout原本的方式去使用了，不需要做多余的操作。

下面看代码：

[java]  view plain  copy

 

1. package com.zhy.view;  
2.   
3. import android.content.Context;  
4. import android.support.v4.widget.SlidingPaneLayout;  
5. import android.util.AttributeSet;  
6. import android.view.View;  
7. import android.view.ViewGroup;  
8.   
9. public class FoldSlidingPanelLayout extends SlidingPaneLayout  
10. {  
11.     public FoldSlidingPanelLayout(Context context, AttributeSet attrs)  
12.     {  
13.         super(context, attrs);  
14.     }  
15.     @Override  
16.     protected void onAttachedToWindow()  
17.     {  
18.         super.onAttachedToWindow();  
19.           
20.         View child = getChildAt(0);  
21.         if (child != null) {  
22.   
23.             removeView(child);  
24.             final FoldLayout foldLayout = new FoldLayout(getContext());  
25.             //foldLayout.setAnchor(0);  
26.             foldLayout.addView(child);  
27.             ViewGroup.LayoutParams layPar = child.getLayoutParams();  
28.             addView(foldLayout, 0, layPar);  
29.               
30.             setPanelSlideListener(new PanelSlideListener()  
31.             {  
32.                   
33.                 @Override  
34.                 public void onPanelSlide(View arg0, float arg1)  
35.                 {  
36.                     foldLayout.setFactor(arg1);  
37.                 }  
38.                   
39.                 @Override  
40.                 public void onPanelOpened(View arg0)  
41.                 {  
42.                     // TODO Auto-generated method stub  
43.                       
44.                 }  
45.                   
46.                 @Override  
47.                 public void onPanelClosed(View arg0)  
48.                 {  
49.                       
50.                 }  
51.             });  
52.               
53.         }  
54.     }  
55. }  

我们继承了SlidingPaneLayout，然后在onAttachedToWindow中，取出侧滑的布局，在外层包上一个FoldLayout；并且在内部去监听setPanelSlideListener，在onPanelSlide种根据参数，去动态设置FoldLayout的factor.

2、测试

1、布局文件

[html]  view plain  copy

 

1. <com.zhy.view.FoldSlidingPanelLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2.     xmlns:tools="http://schemas.android.com/tools"  
3.     android:id="@+id/id_drawerLayout"  
4.     android:layout_width="match_parent"  
5.     android:layout_height="match_parent" >  
6.   
7.     <fragment  
8.         android:id="@+id/id_left_menu"  
9.         android:name="com.zhy.sample.folderlayout.LeftMenuFragment"  
10.         android:layout_width="240dp"  
11.         android:layout_height="match_parent" />  
12.   
13.     <RelativeLayout  
14.         android:layout_width="match_parent"  
15.         android:layout_height="match_parent" >  
16.   
17.         <ImageView  
18.             android:layout_width="match_parent"  
19.             android:layout_height="match_parent"  
20.             android:scaleType="fitCenter"  
21.             android:src="@drawable/xueshan" />  
22.     </RelativeLayout>  
23.   
24. </com.zhy.view.FoldSlidingPanelLayout>  

我们的菜单使用的是一个fragment。

2、菜单布局

[java]  view plain  copy

 

1. package com.zhy.sample.folderlayout;  
2.   
3. import android.os.Bundle;  
4. import android.support.v4.app.Fragment;  
5. import android.view.LayoutInflater;  
6. import android.view.View;  
7. import android.view.ViewGroup;  
8. import android.widget.ArrayAdapter;  
9. import android.widget.ListView;  
10.   
11. public class LeftMenuFragment extends Fragment  
12. {  
13.     private ListView mMenus;  
14.     private String[] mMenuItemStr = { "Bear", "Bird", "Cat", "Tigers", "Panda" };  
15.   
16.     @Override  
17.     public View onCreateView(LayoutInflater inflater, ViewGroup container,  
18.             Bundle savedInstanceState)  
19.     {  
20.   
21.         View view = inflater.inflate(R.layout.fragment_left_menu, container,  
22.                 false);  
23.         mMenus = (ListView) view.findViewById(R.id.id_left_menu_lv);  
24.         mMenus.setAdapter(new ArrayAdapter<String>(getActivity(),  
25.                 R.layout.item_left_menu, mMenuItemStr));  
26.         return view;  
27.     }  
28. }  

[html]  view plain  copy

 

1. <ListView xmlns:android="http://schemas.android.com/apk/res/android"  
2.     xmlns:tools="http://schemas.android.com/tools"  
3.     android:id="@+id/id_left_menu_lv"  
4.     android:layout_width="240dp"  
5.     android:layout_height="match_parent"  
6.     android:layout_gravity="start"  
7.     android:background="#FFF"  
8.     android:choiceMode="singleChoice" />  

Item就是一个TextView，就不贴了~~

3、Activity

[java]  view plain  copy

 

1. package com.zhy.sample.folderlayout;  
2.   
3. import android.os.Bundle;  
4. import android.support.v4.app.FragmentActivity;  
5.   
6. public class SlidingPanelLayoutSampleActivity extends FragmentActivity  
7. {  
8.     @Override  
9.     protected void onCreate(Bundle arg0)  
10.     {  
11.         super.onCreate(arg0);  
12.         setContentView(R.layout.activity_slidingpanellayout);  
13.     }  
14. }  

恩，Activity里面什么都不用做，引入布局文件就行了。

最好看看效果图。

3、效果图

这里菜单块数比较多，大家可以自行修改运行。

ok，到此我们将FoldLayout与SlidingPaneLayout进行了整合，构造了这么个个性的侧滑。

最好还剩下与Drawerlayout的整合。

5、FoldDrawerLayout

1、实现

关于DrawerLayout的使用，与上面的SlidingPaneLayout类似，写写布局文件，引入Activity就好了。我们依然使用上述的方法2，去实现一个DrawerLayout的子类。

[java]  view plain  copy

 

1. package com.zhy.view;  
2.   
3. import android.content.Context;  
4. import android.support.v4.view.GravityCompat;  
5. import android.support.v4.view.ViewCompat;  
6. import android.support.v4.widget.DrawerLayout;  
7. import android.util.AttributeSet;  
8. import android.util.Log;  
9. import android.view.Gravity;  
10. import android.view.View;  
11. import android.view.ViewGroup;  
12.   
13. public class FoldDrawerLayout extends DrawerLayout  
14. {  
15.     private static final String TAG = "DrawerFoldLayout";  
16.   
17.     public FoldDrawerLayout(Context context, AttributeSet attrs)  
18.     {  
19.         super(context, attrs);  
20.     }  
21.   
22.     @Override  
23.     protected void onAttachedToWindow()  
24.     {  
25.         super.onAttachedToWindow();  
26.   
27.         final int childCount = getChildCount();  
28.         for (int i = 0; i < childCount; i++)  
29.         {  
30.             final View child = getChildAt(i);  
31.             if (isDrawerView2(child))  
32.             {  
33.                 Log.e(TAG, "at" + i);  
34.                 FoldLayout foldlayout = new FoldLayout(  
35.                         getContext());  
36.                 //<span style="font-family: Arial, Helvetica, sans-serif;">foldlayout</span><span style="font-family: Arial, Helvetica, sans-serif;">.setAnchor(1);</span>  
37.                 removeView(child);  
38.                 foldlayout.addView(child);  
39.                 ViewGroup.LayoutParams layPar = child.getLayoutParams();  
40.                 addView(foldlayout, i, layPar);  
41.             }  
42.   
43.         }  
44.         setDrawerListener(new DrawerListener()  
45.         {  
46.   
47.             @Override  
48.             public void onDrawerStateChanged(int arg0)  
49.             {  
50.                 // TODO Auto-generated method stub  
51.   
52.             }  
53.   
54.             @Override  
55.             public void onDrawerSlide(View drawerView, float slideOffset)  
56.             {  
57.   
58.                 if (drawerView instanceof FoldLayout)  
59.                 {  
60.                     FoldLayout foldLayout = ((FoldLayout) drawerView);  
61.                     Log.e(TAG, "slideOffset = " + slideOffset);  
62.                     foldLayout.setFactor(slideOffset);  
63.                 }  
64.   
65.             }  
66.   
67.             @Override  
68.             public void onDrawerOpened(View arg0)  
69.             {  
70.   
71.             }  
72.   
73.             @Override  
74.             public void onDrawerClosed(View arg0)  
75.             {  
76.   
77.             }  
78.         });  
79.   
80.     }  
81.   
82.     boolean isDrawerView2(View child)  
83.     {  
84.         final int gravity = ((LayoutParams) child.getLayoutParams()).gravity;  
85.         final int absGravity = GravityCompat.getAbsoluteGravity(gravity,  
86.                 ViewCompat.getLayoutDirection(child));  
87.         return (absGravity & (Gravity.LEFT | Gravity.RIGHT)) != 0;  
88.     }  
89.   
90. }  

看到这，大家可能会想，然后就和SlidingPaneLayout一样，写写布局文件就好了？其实不是的，如果你这么做了，你会发现侧滑很难拉出来，因为是这样的：
DraweLayout的侧滑菜单，比如我们拉出来50%，那么正常来说显示的时侧滑布局右侧的50%，但是这个0.5如果设置给我们的factor，它会把布局缩小到50%且在左边。

导致，你拉了50%其实还是上面都看不到，因为折叠到左侧的50%去了。这里依然有两种解决方案：

1、结合属性动画，做偏移，具体可参考：Android DrawerLayout 高仿QQ5.2双向侧滑菜单

2、让我们的折叠，收缩到最终的位置可以控制，我们现在统统往最坐标收缩，如果可以设置为最右边，那么本例就没有问题了。

2、引入anchor

我们引入一个mAnchor变量，值范围[0，1]，控制FoldLayout最终折叠到的位置。其实修改的代码比较少，我贴一下修改的代码：

[java]  view plain  copy

 

1. private void updateFold()  
2.     {  
3.           
4.         //...  
5.         float anchorPoint = mAnchor * w;  
6.         float midFold = (anchorPoint / mFlodWidth);  
7.   
8.         for (int i = 0; i < mNumOfFolds; i++)  
9.         {  
10.             //引入anchor  
11.             dst[0] = (anchorPoint > i * mFlodWidth) ? anchorPoint  
12.                     + (i - midFold) * mTranslateDisPerFlod : anchorPoint  
13.                     - (midFold - i) * mTranslateDisPerFlod;  
14.             dst[2] = (anchorPoint > (i + 1) * mFlodWidth) ? anchorPoint  
15.                     + (i + 1 - midFold) * mTranslateDisPerFlod : anchorPoint  
16.                     - (midFold - i - 1) * mTranslateDisPerFlod;                                                             }                                                                                                                       }  
17.               

唯一改变的就是dst[0]和dst[2]的坐标，当然了，anchor引入以后，你需要判断原始的坐标是否小于anchorPoint，如果小于需要加一些偏移量，大于则反之。

记得：

[java]  view plain  copy

 

1. public void setAnchor(float anchor)  
2.     {  
3.         this.mAnchor = anchor;  
4.         updateFold();  
5.         invalidate();  
6.     }  

打开上述的FoldDrawerLayout的这行代码：foldlayout.setAnchor(1);让其最后合并位置为右侧。

使用方式，现在就是写好布局文件，大家直接使用SlidingPaneLayout那个布局文件，改一个根布局类就行。

3、效果图

到此，我们完成了折叠式菜单从原理到实战的整个过程。当然了，可以完善还有优化的地方很多，大家可以自己去find and fix 。

源码：下载