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

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

1、概述

无意中翻到的FoldingLayout的介绍的博客，以及github地址。感觉很nice呀，于是花了点时间研究以及编写，本篇博客将带大家从最基本的原理分析，一步一步的实现我们的FoldingLayout，当然了，如果你能力过硬，可以直接下载github上的代码进行学习。

博客基本分为以下几个部分：

1、Matrix的setPolyToPoly使用

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

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

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

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

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

ok，贴下部分的效果图：

改图对应上述3，妹子不错吧~

ok，对应上述4.

对应上述5。

ok，挑选了部分图，不然太占篇幅了。

那么接下来，我们就按照顺序往下学习了~~~

2、Matrix的setPolyToPoly使用

想要实现折叠，最重要的就是其核心的原理了，那么第一步我们要了解的就是，如何能把一张正常显示的图片，让它能够进行偏移显示。

其实精髓就在于Matrix的setPolyToPoly的方法。

[java]  view plain copy

1. public boolean setPolyToPoly(float[] src, int srcIndex,  float[] dst, int dstIndex,int pointCount)   

简单看一下该方法的参数，src代表变换前的坐标；dst代表变换后的坐标；从src到dst的变换，可以通过srcIndex和dstIndex来制定第一个变换的点，一般可能都设置位0。pointCount代表支持的转换坐标的点数，最多支持4个。

如果不明白没事，下面通过一个简单的例子，带大家了解：

[java]  view plain copy

1. package com.zhy.sample.folderlayout;  
2.   
3. import android.app.Activity;  
4. import android.content.Context;  
5. import android.graphics.Bitmap;  
6. import android.graphics.BitmapFactory;  
7. import android.graphics.Canvas;  
8. import android.graphics.Matrix;  
9. import android.os.Bundle;  
10. import android.view.View;  
11.   
12. public class MatrixPolyToPolyActivity extends Activity  
13. {  
14.   
15.     @Override  
16.     protected void onCreate(Bundle savedInstanceState)  
17.     {  
18.         super.onCreate(savedInstanceState);  
19.         setContentView(new PolyToPolyView(this));  
20.     }  
21.   
22.     class PolyToPolyView extends View  
23.     {  
24.   
25.         private Bitmap mBitmap;  
26.         private Matrix mMatrix;  
27.   
28.         public PolyToPolyView(Context context)  
29.         {  
30.             super(context);  
31.             mBitmap = BitmapFactory.decodeResource(getResources(),  
32.                     R.drawable.tanyan);  
33.             mMatrix = new Matrix();  
34.             float[] src = { 0, 0,//  
35.                     mBitmap.getWidth(), 0,//  
36.                     mBitmap.getWidth(), mBitmap.getHeight(),//  
37.                     0, mBitmap.getHeight() };  
38.             float[] dst = { 0, 0,//  
39.                     mBitmap.getWidth(), 100,//  
40.                     mBitmap.getWidth(), mBitmap.getHeight() - 100,//  
41.                     0, mBitmap.getHeight() };  
42.             mMatrix.setPolyToPoly(src, 0, dst, 0, src.length >> 1);  
43.         }  
44.   
45.         @Override  
46.         protected void onDraw(Canvas canvas)  
47.         {  
48.             super.onDraw(canvas);  
49.             canvas.drawBitmap(mBitmap, mMatrix, null);  
50.         }  
51.   
52.     }  
53.   
54. }  

我们编写了一个PolyToPolyView作为我们的Activity的主视图。

在PolyToPolyView中，我们加载了一张图片，初始化我们的Matrix，注意src和dst两个数组，src就是正常情况下图片的4个顶点。dst将图片右侧两个点的y坐标做了些许的修改。

大家可以在纸上稍微标一下src和dst的四个点的位置。

最后我们在onDraw的时候进行图像的绘制，效果为：

如果你已经在纸上稍微的画了dst的四个点，那么这个结果你一定不陌生。

可以看到我们通过matrix.setPolyToPoly实现了图片的倾斜，那么引入到折叠的情况，假设折叠两次，大家有思路么，考虑一下，没有的话，继续往下看。

3、引入阴影

其实阴影应该在实现初步的折叠以后来说，这样演示其实比较方便，但是为了降低其理解的简单性，我们先把阴影抽取出来说。

假设我们现在要给上图加上阴影，希望的效果图是这样的：

可以看到我们左侧加入了一点阴影，怎么实现呢？

主要还是利用LinearGradient，我们从左到右添加一层从黑色到透明的渐变即可。

[java]  view plain copy

1. public class MatrixPolyToPolyWithShadowActivity extends Activity  
2. {  
3.   
4.     @Override  
5.     protected void onCreate(Bundle savedInstanceState)  
6.     {  
7.         super.onCreate(savedInstanceState);  
8.         setContentView(new PolyToPolyView(this));  
9.   
10.     }  
11.   
12.     class PolyToPolyView extends View  
13.     {  
14.   
15.         private Bitmap mBitmap;  
16.         private Matrix mMatrix;  
17.           
18.         private Paint mShadowPaint;  
19.         private Matrix mShadowGradientMatrix;  
20.         private LinearGradient mShadowGradientShader;  
21.   
22.         public PolyToPolyView(Context context)  
23.         {  
24.             super(context);  
25.             mBitmap = BitmapFactory.decodeResource(getResources(),  
26.                     R.drawable.tanyan);  
27.             mMatrix = new Matrix();  
28.   
29.             mShadowPaint = new Paint();  
30.             mShadowPaint.setStyle(Style.FILL);  
31.             mShadowGradientShader = new LinearGradient(0, 0, 0.5f, 0,  
32.                     Color.BLACK, Color.TRANSPARENT, TileMode.CLAMP);  
33.             mShadowPaint.setShader(mShadowGradientShader);  
34.   
35.             mShadowGradientMatrix = new Matrix();  
36.             mShadowGradientMatrix.setScale(mBitmap.getWidth(), 1);  
37.             mShadowGradientShader.setLocalMatrix(mShadowGradientMatrix);  
38.             mShadowPaint.setAlpha((int) (0.9*255));  
39.   
40.         }  
41.   
42.         @Override  
43.         protected void onDraw(Canvas canvas)  
44.         {  
45.             super.onDraw(canvas);  
46.             canvas.save();  
47.             float[] src = //...;  
48.             float[] dst = //...;  
49.             mMatrix.setPolyToPoly(src, 0, dst, 0, src.length >> 1);  
50.   
51.             canvas.concat(mMatrix);  
52.             canvas.drawBitmap(mBitmap, 0, 0, null);  
53.             //绘制阴影                                                                                                                        canvas.drawRect(0, 0, mBitmap.getWidth(), mBitmap.getHeight(),  
54.                     mShadowPaint);  
55.             canvas.restore();  
56.   
57.         }  
58.   
59.     }  
60.   
61. }  

重点看mShadowPaint，mShadowGradientShader，mShadowGradientMatrix一个是画笔，我们为画笔设置了一个渐变的Shader，这个Shader的参数为

new LinearGradient(0, 0, 0.5f, 0,Color.BLACK, Color.TRANSPARENT, TileMode.CLAMP);

起点（0，0）、终点（0.5f，0）；颜色从和BLACK到透明；模式为CLAMP，也就是拉伸最后一个像素。

这里你可能会问，这才为0.5个像素的区域设置了渐变，不对呀，恩，是的，继续看接下来我们使用了setLocalMatrix(mShadowGradientMatrix);，而这个

mShadowGradientMatrix将和坐标扩大了mBitmap.getWidth()倍，也就是说现在设置渐变的区域为（0.5f*mBitmap.getWidth()，0）半张图的大小，那么后半张图呢？

后半张应用CLAMP模式，拉伸的透明。

关于Shader、setLocalMatrix等用法也可以参考：Android BitmapShader 实战 实现圆形、圆角图片

4、初步实现折叠

了解了原理以及阴影的绘制以后，接下来要开始学习真正的去折叠了，我们的目标效果为：

妹子折叠成了8份，且阴影的范围为：每个沉下去夹缝的左右两侧，左侧黑色半透明遮盖，右侧短距离的黑色到透明阴影（大家可以仔细看）。

现在其实大家以及会将图片简单倾斜和添加阴影了，那么唯一的难点就是怎么将一张图分成很多快，我相信每块的折叠大家都会。

其实我们可以通过绘制该图多次，比如第一次绘制往下倾斜；第二次绘制网上倾斜；这样就和我们标题2的实现类似了，只需要利用setPolyToPoly。

那么绘制多次，每次显示肯定不是一整张图，比如第一次，我只想显示第一块，所以我们还需要clipRect的配合，说到这，应该以及揭秘了~~~

[java]  view plain copy

1. package com.zhy.sample.folderlayout;  
2.   
3. import android.app.Activity;  
4. import android.content.Context;  
5. import android.graphics.Bitmap;  
6. import android.graphics.BitmapFactory;  
7. import android.graphics.Canvas;  
8. import android.graphics.Color;  
9. import android.graphics.LinearGradient;  
10. import android.graphics.Matrix;  
11. import android.graphics.Paint;  
12. import android.graphics.Paint.Style;  
13. import android.graphics.Shader.TileMode;  
14. import android.os.Bundle;  
15. import android.view.View;  
16.   
17. public class SimpleUseActivity extends Activity  
18. {  
19.   
20.     @Override  
21.     protected void onCreate(Bundle savedInstanceState)  
22.     {  
23.         super.onCreate(savedInstanceState);  
24.         setContentView(new PolyToPolyView(this));  
25.   
26.     }  
27.   
28.     class PolyToPolyView extends View  
29.     {  
30.   
31.         private static final int NUM_OF_POINT = 8;  
32.         /** 
33.          * 图片的折叠后的总宽度 
34.          */  
35.         private int mTranslateDis;  
36.   
37.         /** 
38.          * 折叠后的总宽度与原图宽度的比例 
39.          */  
40.         private float mFactor = 0.8f;  
41.         /** 
42.          * 折叠块的个数 
43.          */  
44.         private int mNumOfFolds = 8;  
45.   
46.         private Matrix[] mMatrices = new Matrix[mNumOfFolds];  
47.           
48.         private Bitmap mBitmap;  
49.   
50.         /** 
51.          * 绘制黑色透明区域 
52.          */  
53.         private Paint mSolidPaint;  
54.   
55.         /** 
56.          * 绘制阴影 
57.          */  
58.         private Paint mShadowPaint;  
59.         private Matrix mShadowGradientMatrix;  
60.         private LinearGradient mShadowGradientShader;  
61.   
62.         /*** 
63.          * 原图每块的宽度 
64.          */  
65.         private int mFlodWidth;  
66.         /** 
67.          * 折叠时，每块的宽度 
68.          */  
69.         private int mTranslateDisPerFlod;  
70.   
71.         public PolyToPolyView(Context context)  
72.         {  
73.             super(context);  
74.             mBitmap = BitmapFactory.decodeResource(getResources(),  
75.                     R.drawable.tanyan);  
76.               
77.             //折叠后的总宽度  
78.             mTranslateDis = (int) (mBitmap.getWidth() * mFactor);  
79.             //原图每块的宽度  
80.             mFlodWidth = mBitmap.getWidth() / mNumOfFolds;  
81.             //折叠时，每块的宽度  
82.             mTranslateDisPerFlod = mTranslateDis / mNumOfFolds;  
83.               
84.             //初始化matrix  
85.             for (int i = 0; i < mNumOfFolds; i++)  
86.             {  
87.                 mMatrices[i] = new Matrix();  
88.             }  
89.   
90.             mSolidPaint = new Paint();  
91.             int alpha = (int) (255 * mFactor * 0.8f) ;  
92.             mSolidPaint  
93.                     .setColor(Color.argb((int) (alpha*0.8F), 0, 0, 0));  
94.   
95.             mShadowPaint = new Paint();  
96.             mShadowPaint.setStyle(Style.FILL);  
97.             mShadowGradientShader = new LinearGradient(0, 0, 0.5f, 0,  
98.                     Color.BLACK, Color.TRANSPARENT, TileMode.CLAMP);  
99.             mShadowPaint.setShader(mShadowGradientShader);  
100.             mShadowGradientMatrix = new Matrix();  
101.             mShadowGradientMatrix.setScale(mFlodWidth, 1);  
102.             mShadowGradientShader.setLocalMatrix(mShadowGradientMatrix);  
103.             mShadowPaint.setAlpha(alpha);  
104.   
105.             //纵轴减小的那个高度，用勾股定理计算下  
106.             int depth = (int) Math.sqrt(mFlodWidth * mFlodWidth  
107.                     - mTranslateDisPerFlod * mTranslateDisPerFlod)/2;  
108.   
109.             //转换点  
110.             float[] src = new float[NUM_OF_POINT];  
111.             float[] dst = new float[NUM_OF_POINT];  
112.   
113.             /** 
114.              * 原图的每一块，对应折叠后的每一块，方向为左上、右上、右下、左下，大家在纸上自己画下 
115.              */  
116.             for (int i = 0; i < mNumOfFolds; i++)  
117.             {  
118.                 src[0] = i * mFlodWidth;  
119.                 src[1] = 0;  
120.                 src[2] = src[0] + mFlodWidth;  
121.                 src[3] = 0;  
122.                 src[4] = src[2];  
123.                 src[5] = mBitmap.getHeight();  
124.                 src[6] = src[0];  
125.                 src[7] = src[5];  
126.   
127.                 boolean isEven = i % 2 == 0;  
128.   
129.                 dst[0] = i * mTranslateDisPerFlod;  
130.                 dst[1] = isEven ? 0 : depth;  
131.                 dst[2] = dst[0] + mTranslateDisPerFlod;  
132.                 dst[3] = isEven ? depth : 0;  
133.                 dst[4] = dst[2];  
134.                 dst[5] = isEven ? mBitmap.getHeight() - depth : mBitmap  
135.                         .getHeight();  
136.                 dst[6] = dst[0];  
137.                 dst[7] = isEven ? mBitmap.getHeight() : mBitmap.getHeight()  
138.                         - depth;  
139.   
140.                 //setPolyToPoly  
141.                 mMatrices[i].setPolyToPoly(src, 0, dst, 0, src.length >> 1);  
142.             }  
143.   
144.         }  
145.   
146.         @Override  
147.         protected void onDraw(Canvas canvas)  
148.         {  
149.             super.onDraw(canvas);  
150.             //绘制mNumOfFolds次  
151.             for (int i = 0; i < mNumOfFolds; i++)  
152.             {  
153.                   
154.                 canvas.save();  
155.                 //将matrix应用到canvas  
156.                 canvas.concat(mMatrices[i]);  
157.                 //控制显示的大小  
158.                 canvas.clipRect(mFlodWidth * i, 0, mFlodWidth * i + mFlodWidth,  
159.                         mBitmap.getHeight());  
160.                 //绘制图片  
161.                 canvas.drawBitmap(mBitmap, 0, 0, null);  
162.                 //移动绘制阴影  
163.                 canvas.translate(mFlodWidth * i, 0);  
164.                 if (i % 2 == 0)  
165.                 {  
166.                     //绘制黑色遮盖  
167.                     canvas.drawRect(0, 0, mFlodWidth, mBitmap.getHeight(),  
168.                             mSolidPaint);  
169.                 }else  
170.                 {  
171.                     //绘制阴影  
172.                     canvas.drawRect(0, 0, mFlodWidth, mBitmap.getHeight(),  
173.                             mShadowPaint);  
174.                 }  
175.                 canvas.restore();  
176.             }  
177.   
178.         }  
179.   
180.     }  
181.   
182. }  

简单讲解下，不去管绘制阴影的部分，其实折叠就是：

1、初始化转换点，这里注释说的很清楚，大家最好在纸上绘制下，标一下每个变量。

2、为matrix.setPolyToPoly

3、绘制时使用该matrix，且clipRect控制显示区域（这个区域也很简单，原图的第一块到最后一块），最好就是绘制bitmap了。

阴影这里大家可以换个明亮点的图片去看看~~

好了，由于篇幅原因，剩下的内容将在下一篇继续完成，下一篇将展示如何将简单的图片的折叠，转化为对一个布局内所有控件的折叠效果，以及引入手势、

和DrawerLayout等结合应用到侧滑中去。

对于类似这种效果的，一定要拿出稿纸笔去画一画，否则很难弄明白。