Android翻页效果原理实现之引入折线

炮兵镇楼

PS：写得太嗨忘了说明一点，下面文章中提到的“长边”（也就是代码部分中出现的sizeLong）指的是折叠区域直角三角形中与控件右边相连的边，而“短边”（也就是代码部分中出现的sizeShort）则指的是折叠区域直角三角形中与控件底边相连的边。两者术语并非指的是较长的边和较短的边，这点要注意。其命名来源于My参考图…………囧……

上一节中我们讲了翻页的原理实现，说白了就是Canvas中clip方法的使用，而现实生活中的翻页必然不是像我们上节demo那样左右切换的，我们总是会在看书翻页的时候掀起纸张的一角拉向书的另一侧实现翻页，翻页的过程对纸张来说是一个曲度和形状改变的过程，这一节我们先不讲曲度的实现，我们先假设翻页的过程是一个折页的过程，类似下图：

先以折页的方式对翻页过程进行一个细致的分析，然后再在下一节将折线变为曲线。折页的实现可分为两种方式，一种是纯计算，我们利用已知的条件根据各类公式定理计算出未知的值，第二种呢则是通过图形的组合巧妙地去获取图形的交并集来实现，第二种方式需要很好的空间想象力这里就先不说了，而第一种纯计算的方式呢又可以分为使用高等数学和解三角形两种方法，前者对于数学不好的童鞋来说不易理解，这里我们选择后者使用解三角形来计算，首先我们先来搞个简单的辅助图：

图很简单，一看就懂，大家可以拿个本子或者书尝试折页，不管你如何折，折叠区域AOB和下一页显示的区域APB必定是完全相等的对吧，那么我们就可以得到一个惊人的事实：角AOB恒为直角，这时我们来添加一些辅助线便于理解：

我们设折叠后的三角形AOB的短边长度为x而长边长度为y，由图可以得出以下运算：

我们可以使用相同的方法去解得y的值，这里我使用的是等面积法，由图可知梯形MOBP的面积是三角形MOA、AOB、APB面积之和：

这样我们可以根据任意一点得出两边边长，我们来代码中实践一下看看是不是这样的呢？为了便于理解，这里我重新使用了一个新的FoldView：

[java]  view plain copy print ?

1. public class FoldView extends View {  
2.     public FoldView(Context context, AttributeSet attrs) {  
3.         super(context, attrs);  
4.     }  
5. }  

那么尝试根据我们以上分析的原理来绘制这么一个折页的效果，获取事件点、获取控件宽高就不说了，我们重点来看看onDraw中的计算：

[java]  view plain copy print ?

1. @Override  
2. protected void onDraw(Canvas canvas) {  
3.     // 重绘时重置路径  
4.     mPath.reset();  
5.   
6.     // 绘制底色  
7.     canvas.drawColor(Color.WHITE);  
8.   
9.     /* 
10.      * 如果坐标点在右下角则不执行绘制 
11.      */  
12.     if (pointX == 0 && pointY == 0) {  
13.         return;  
14.     }  
15.   
16.     /* 
17.      * 额，这个该怎么注释好呢……根据图来 
18.      */  
19.     float mK = mViewWidth - pointX;  
20.     float mL = mViewHeight - pointY;  
21.   
22.     // 需要重复使用的参数存值避免重复计算  
23.     float temp = (float) (Math.pow(mL, 2) + Math.pow(mK, 2));  
24.   
25.     /* 
26.      * 计算短边长边长度 
27.      */  
28.     float sizeShort = temp / (2F * mK);  
29.     float sizeLong = temp / (2F * mL);  
30.   
31.     /* 
32.      * 生成路径 
33.      */  
34.     mPath.moveTo(pointX, pointY);  
35.     mPath.lineTo(mViewWidth, mViewHeight - sizeLong);  
36.     mPath.lineTo(mViewWidth - sizeShort, mViewHeight);  
37.     mPath.close();  
38.   
39.     // 绘制路径  
40.     canvas.drawPath(mPath, mPaint);  
41. }  

每次绘制的时候我们需要重置Path不然上一次的Path就会跟这一次叠加在一起，效果如下：

效果是大致出来了，但是我们发现有一处不对的地方，当我们非常靠左或非常靠下地折叠时：

如果再往下折

如果再往左折

此时我们的Path就会消失掉，其实这跟我们我们现实中的折页是一样的，折页的过程是有限制的，如下图：

右下角点P因为受装订线的制约，其半径最大只能为纸张的宽度，如果我们始终以该宽度为半径折页，那么点P的轨迹就可以形成曲线Q，图中半透明红色区域为一个半圆形，也就是说，我们的点P只能在该范围内才应当有效对吧，那么该如何做限制呢？很简单，我们只需在计算长短边长之前判断触摸点是否在该区域即可：

[java]  view plain copy print ?

1. /** 
2.  * 计算短边的有效区域 
3.  */  
4. private void computeShortSizeRegion() {  
5.     // 短边圆形路径对象  
6.     Path pathShortSize = new Path();  
7.   
8.     // 用来装载Path边界值的RectF对象  
9.     RectF rectShortSize = new RectF();  
10.   
11.     // 添加圆形到Path  
12.     pathShortSize.addCircle(0, mViewHeight, mViewWidth, Path.Direction.CCW);  
13.   
14.     // 计算边界  
15.     pathShortSize.computeBounds(rectShortSize, true);  
16.   
17.     // 将Path转化为Region  
18.     mRegionShortSize.setPath(pathShortSize, new Region((int) rectShortSize.left, (int) rectShortSize.top, (int) rectShortSize.right, (int) rectShortSize.bottom));  
19. }  

同样计算有效区域这个过程是在onSizeChanged中进行，我们说过尽量不要在一些重复调用的方法内执行没必要的计算，在onDraw里我们只需在绘制钱判断下当前触摸点是否在该区域内，如果不在，那么我们通过坐标x轴重新计算坐标y轴：

[java]  view plain copy print ?

1. /* 
2.  * 判断触摸点是否在短边的有效区域内 
3.  */  
4. if (!mRegionShortSize.contains((int) mPointX, (int) mPointY)) {  
5.     // 如果不在则通过x坐标强行重算y坐标  
6.     mPointY = (float) (Math.sqrt((Math.pow(mViewWidth, 2) - Math.pow(mPointX, 2))) - mViewHeight);  
7.   
8.     // 精度附加值避免精度损失  
9.     mPointY = Math.abs(mPointY) + mValueAdded;  
10. }  

那么如何来计算y坐标呢？很简单，我们只需根据圆的方程求解即可，因为P的轨迹是个圆~在得到新的y坐标mPointY后我们还应该为其加上一点点的精度值mValueAdded来挽回因浮点计算而损失的精度。而对于过分往下折出现的问题我们使用限制下折最大值的方法来避免：

[java]  view plain copy print ?

1. /* 
2.  * 缓冲区域判断 
3.  */  
4. float area = mViewHeight - mBuffArea;  
5. if (mPointY >= area) {  
6.     mPointY = area;  
7. }  

在控件下方接近底部的地方我们设定一个缓冲区域，触摸点永远不能到达该区域，因为没有必要也没有意义，再往下就要划出控件了，别浪费多余的计算，运行效果大致如下：

大致的效果出来了，我们还需要做一些补充工作，当触摸点在右下角某个区域时如果我们抬起手指，那么就让“纸张”自动滑下去，同理当触摸点在左边某个区域时我们让“纸张”自动翻过去，这里我们约定这两个区域分别是控件右下角宽高四分之一的区域和控件左侧八分之一的区域（当然你可以约定你自己的控件行为，这里我就哪简单往哪走了~）：

那么在上一节中我们也有类似的效果，这里我们依葫芦画瓢，当手指抬起时判断当前事件点是否位于右下角自滑区域内，如果在那么以当前事件点为坐标点A右下角为坐标点B根据两点式我们可以获得一条直线方程：

此后根据不断自加递增的x坐标不断计算对应的y坐标直至点滑至右下角为止，既然涉及到事件，So我们在onTouchEvent处理：

[java]  view plain copy print ?

1. case MotionEvent.ACTION_UP:// 手指抬起时候  
2.     /* 
3.      * 获取当前事件点 
4.      */  
5.     float x = event.getX();  
6.     float y = event.getY();  
7.   
8.     /* 
9.      * 如果当前事件点位于右下自滑区域 
10.      */  
11.     if (x > mAutoAreaRight && y > mAutoAreaButtom) {  
12.         // 获取当前点为直线方程坐标之一  
13.         float startX = x, startY = y;  
14.   
15.         /* 
16.          * 当x坐标小于控件宽度时 
17.          */  
18.         while (x < mViewWidth) {  
19.             // 不断让x自加  
20.             x++;  
21.   
22.             // 重置当前点的值  
23.             mPointX = x;  
24.             mPointY = startY + ((x - startX) * (mViewHeight - startY)) / (mViewWidth - startX);  
25.   
26.             // 重绘视图  
27.             invalidate();  
28.         }  
29.     }  
30.     break;  

OK，我们来看看效果：

大家看到当手指弹起时如果触摸点在右下角的自滑区域内的话就会自动“滑动”到右下角去，可是大家细心的话会发现效果好像不太对啊！怎么一下子就到右下角了？说好的“滑动”呢？好像毫无滑动效果啊！！！！为什么会这样？其实如果你细心就会发现上一节我们在讲图片左右两侧自滑的时候也是一样的效果！根本就没有什么滑动！为什么？难道在我们的while循环中没有执行invalidate吗？大家可以尝试在View中重写invalidate()方法Log一些信息看看invalidate()是否没有没执行。这里鉴于篇幅我就直接简单地说一下了，具体的我们会在《自定义控件其实很简单》系列文章讲到View绘制流程的时候详细阐述。这里我先可以告诉大家的是invalidate()方法即便你调用了也不会马上执行，invalidate()的作用更准确地说是将我们的View标记为无效，当View被标记为无效后Android就会尝试去调用onDraw()对其重绘，如果大家曾翻阅过API 文档就会看到在invalidate()方法中Google给出了这么一句话：

我们知道UI的刷新需要在UI Thread也就是主线程中进行，这里会涉及到一个叫做message和message queue的东西，message你可以见文知意地称其为消息而message queue则为消息队列，我们将一个message压入message queue后UI Thread会处理它，而我们刷新UI也需要有message作为载体去告诉UI Thread诶需要更新UI了哦，而当我们在UI Thread中去做一个loop不断地往message queue中压入消息时，我们的UI Thread是不会去处理这些message的，直到loop结束为止，这就是为什么我们在while中不断调用invalidate()的时候你只会看到最后的结果而不会得到中间过程的变化。这里我只阐述了一个很浅显能懂的原因，更深入的原因涉及到View中各种标识位的运算如上所说篇幅过长就不多说了。那么知道了原因该如何去处理呢？message和message queue如果大家对Handler有一定的了解一定不陌生，没错，这里我们也将使用Handler来实现我们的滑动，首先，在我们的View中创建一个内部类，该内部类是Handler的一个子类，我们将使用它来更新View实现滑动效果：

[java]  view plain copy print ?

1. /** 
2.  * 处理滑动的Handler 
3.  */  
4. @SuppressLint("HandlerLeak")  
5. private class SlideHandler extends Handler {  
6.     @Override  
7.     public void handleMessage(Message msg) {  
8.         // 循环调用滑动计算  
9.         FoldView.this.slide();  
10.   
11.         // 重绘视图  
12.         FoldView.this.invalidate();  
13.     }  
14.   
15.     /** 
16.      * 延迟向Handler发送消息实现时间间隔 
17.      *  
18.      * @param delayMillis 
19.      *            间隔时间 
20.      */  
21.     public void sleep(long delayMillis) {  
22.         this.removeMessages(0);  
23.         sendMessageDelayed(obtainMessage(0), delayMillis);  
24.     }  
25. }  

我们额外提供一个slide()方法来对参数值进行更新：

[java]  view plain copy print ?

1. /** 
2.  * 计算滑动参数变化 
3.  */  
4. private void slide() {  
5.     /* 
6.      * 如果x坐标恒小于控件宽度 
7.      */  
8.     if (isSlide && mPointX < mViewWidth) {  
9.         // 则让x坐标自加  
10.         mPointX++;  
11.   
12.         // 并根据x坐标的值重新计算y坐标的值  
13.         mPointY = mStart_BR_Y + ((mPointX - mStart_BR_X) * (mViewHeight - mStart_BR_Y)) / (mViewWidth - mStart_BR_X);  
14.   
15.         // 让SlideHandler处理重绘  
16.         mSlideHandler.sleep(1);  
17.     }  
18. }  

而在onTouchEvent中我们则不在处理参数的计算和重绘，仅需简单调用slide()方法即可：

[java]  view plain copy print ?

1. case MotionEvent.ACTION_UP:// 手指抬起时候  
2.     /* 
3.      * 获取当前事件点 
4.      */  
5.     float x = event.getX();  
6.     float y = event.getY();  
7.   
8.     /* 
9.      * 如果当前事件点位于右下自滑区域 
10.      */  
11.     if (x > mAutoAreaRight && y > mAutoAreaButtom) {  
12.         // 获取并设置直线方程的起点  
13.         mStart_BR_X = x;  
14.         mStart_BR_Y = y;  
15.   
16.         // OK要开始滑动了哦~  
17.         isSlide = true;  
18.   
19.         // 滑动  
20.         slide();  
21.     }  
22.     break;  

注：mStart_BR_X和mStart_BR_Y为直线方程的一点，这里我单独使用两个引用存值便于大家理解，如果各位数学基础好完全可以将其并入到slide()方法中一并计算并省去这两个引用的声明。

这里我们定义了一个boolean类型的isSlide标识值，目的是方便控制动画，我们对外提供一个slideStop方法便于其他组件对动画的控制（当然你可以提供更多方法来控制slide，这里就不多说了），例如当Activity的onDestroy被调用时让动画停止：

[java]  view plain copy print ?

1. /** 
2.  * 为isSlide提供对外的停止方法便于必要时释放滑动动画 
3.  */  
4. public void slideStop() {  
5.     isSlide = false;  
6. }  

在这一过程中，我们在事件手指抬起时判断点的所在，如果在滑动区域我们则触发slide()方法的执行，在slide()方法中我们重新计算坐标值并调用SlideHandler的sleep(long delayMillis)方法，sleep(long delayMillis)的处理逻辑也很简单，根据delayMillis延时向SlideHandler发送obtainMessage，在SlideHandler的handleMessage方法中再次调用slide()方法重新计算参数值并刷新界面。看到这里你可能会问为什么slide()和sleep()没有死循环而？Don't worry！我们来细致分析一下我们到底干了什么，首先我们创建了一个Handler的子类SlideHandler与当前Thread绑定在一起由此我们才可以直接给Thread发送并处理message。因为Handler对message的处理都是异步的，所以在我们自定的SlideHandler中sleep()方法也是个异步方法，所以slide()和sleep()之间的相互调用才没有构成死循环。

好了，分析归分析，我们还是要看实际效果的对吧，执行一下看看：

是不是有“滑动”的效果了？之前我们在处理MOVE的时候在onDraw中定义了一个底部的缓冲区：

[java]  view plain copy print ?

1. float area = mViewHeight - mBuffArea;  
2. if (mPointY >= area) {  
3.     mPointY = area;  
4. }  

而在自滑的时候我们是不需要去判断它的，So~我们改改：

[java]  view plain copy print ?

1. /* 
2.  * 缓冲区域判断 
3.  */  
4. float area = mViewHeight - mBuffArea;  
5. if (!isSlide && mPointY >= area) {  
6.     mPointY = area;  
7. }  

只有当没有产生滑动动画时才去判断缓冲区~

至此，从《自定义控件其实很简单》系列开始我们已经学会三种对View进行刷新的方式：第一种是在刚开始讲《自定义控件其实很简单1/12》让View作为Runnable的实现类，在run方法中更新，另一种是我们后来用的比较多的直接在onDraw方法中invalidate()，最后一种呢则是上面我们讲的Handler来处理绘制逻辑，这三种方法虽说本质一样但是实现方式各不相同且应用场景也不尽相同~第一种更倾向于多种状态进行同时重绘，第二种局限性很大虽说常见但能实现的功能很弱，第三种可以应用到绝大多数的重绘情景且不受不同状态的影响自由度更大。

好了，我们继续修改下代码让左侧也实现自滑的功能：

如图所示，当我们的触摸点x坐标落于控件左侧1/8处弹起手指时，我们让该点与“上一页”的左下角相连构成一条直线，让点沿着该直线不断下滑直至“上一页”的左下角，鉴于我们要分开对左下和右下滑动进行处理，这里我定义一个枚举内部类：

[java]  view plain copy print ?

1. /** 
2.  * 枚举类定义滑动方向 
3.  */  
4. private enum Slide {  
5.     LEFT_BOTTOM, RIGHT_BOTTOM  
6. }  

对应地我们就需要一个成员变量来存值咯：

[java]  view plain copy print ?

1. private Slide mSlide;// 定义当前滑动是往左下滑还是右下滑  

重新整理onTouchEvent处理逻辑：

[java]  view plain copy print ?

1. case MotionEvent.ACTION_UP:// 手指抬起时候  
2.     /* 
3.      * 获取当前事件点 
4.      */  
5.     float x = event.getX();  
6.     float y = event.getY();  
7.   
8.     /* 
9.      * 如果当前事件点位于右下自滑区域 
10.      */  
11.     if (x > mAutoAreaRight && y > mAutoAreaButtom) {  
12.         // 当前为往右下滑  
13.         mSlide = Slide.RIGHT_BOTTOM;  
14.   
15.         // 摩擦吧骚年！  
16.         justSlide(x, y);  
17.     }  
18.   
19.     /* 
20.      * 如果当前事件点位于左侧自滑区域 
21.      */  
22.     if (x < mAutoAreaLeft) {  
23.         // 当前为往左下滑  
24.         mSlide = Slide.LEFT_BOTTOM;  
25.   
26.         // 摩擦吧骚年！  
27.         justSlide(x, y);  
28.     }  
29.     break;  

我们将一些相同的方法封装在justSlide中：

[java]  view plain copy print ?

1. /** 
2.  * 在这光滑的地板上~ 
3.  *  
4.  * @param x 
5.  *            当前触摸点x 
6.  * @param y 
7.  *            当前触摸点y 
8.  */  
9. private void justSlide(float x, float y) {  
10.     // 获取并设置直线方程的起点  
11.     mStart_X = x;  
12.     mStart_Y = y;  
13.   
14.     // OK要开始滑动了哦~  
15.     isSlide = true;  
16.   
17.     // 滑动  
18.     slide();  
19. }  

slide()中的处理则会根据滑动方向来计算参数值：

[java]  view plain copy print ?

1. /** 
2.  * 计算滑动参数变化 
3.  */  
4. private void slide() {  
5.     /* 
6.      * 如果滑动标识值为false则返回 
7.      */  
8.     if (!isSlide) {  
9.         return;  
10.     }  
11.   
12.     /* 
13.      * 如果当前滑动标识为向右下滑动x坐标恒小于控件宽度 
14.      */  
15.     if (mSlide == Slide.RIGHT_BOTTOM && mPointX < mViewWidth) {  
16.         // 则让x坐标自加  
17.         mPointX += 10;  
18.   
19.         // 并根据x坐标的值重新计算y坐标的值  
20.         mPointY = mStart_Y + ((mPointX - mStart_X) * (mViewHeight - mStart_Y)) / (mViewWidth - mStart_X);  
21.   
22.         // 让SlideHandler处理重绘  
23.         mSlideHandler.sleep(25);  
24.     }  
25.   
26.     /* 
27.      * 如果当前滑动标识为向左下滑动x坐标恒大于控件宽度的负值 
28.      */  
29.     if (mSlide == Slide.LEFT_BOTTOM && mPointX > -mViewWidth) {  
30.         // 则让x坐标自减  
31.         mPointX -= 20;  
32.   
33.         // 并根据x坐标的值重新计算y坐标的值  
34.         mPointY = mStart_Y + ((mPointX - mStart_X) * (mViewHeight - mStart_Y)) / (-mViewWidth - mStart_X);  
35.   
36.         // 让SlideHandler处理重绘  
37.         mSlideHandler.sleep(25);  
38.     }  
39. }  

看看效果：

好像一切都很完美，但是我们发现当Path绘制到快结束时卡了两下，同时我们的LogCat也出现了如下警告：

说是我们的Path太大了已经超出了texture的渲染范围，什么是texture这要涉及到GL等Android底层对图形绘制的过程，我们不需要理解，但是要知道的是，从API 11开始Android开始支持HW硬件加速绘制视图，硬件加速对texture是有限制的，这个限制值因机而异，如上面我们在警告信息的最后看到的max = 16384 x 16384，如何解决呢？最简单的方法当然是直接关闭硬件加速咯，关于关闭硬件加速的两种方法在《自定义控件其实很简单》中我们已经说过：

[java]  view plain copy print ?

1. setLayerType(LAYER_TYPE_SOFTWARE, null);  

这样我们再次运行：

诶~Good，很顺畅也没出现警告了对吧，但是Path的大小依然是没有改变的，依然是灰常灰常大，超出控件上方的部分依旧被绘制而且很大很大，其实这部分绘制是完全没必要的，而且为此我们还关闭了HW更可怕的是还将APP的最低支持版本升到了11……我们可不可以通过其他方式来避免呢？答案是肯定的，方法很多，但是最简明扼要的还是Calculation~~~~~我们尝试去判断折叠后长边的的长度，如果长边的长度大于控件的高度则我们折叠的分部就不是一个三角形而是一个四边形了：

如上图中的四边形OBQM，那么如何来生成这个四边形的区域呢？我们曾约定在手指MOVE的过程中控件下方有一个“缓冲区域”，也就是说我们的触摸点Y坐标永远不可能在MOVE的过程中与控件底部重合，这个约定给我们在计算四边形区域的时候带来一个好处：如上图所示OA边总会与PN的延长线有交点，那样计算就非常简单了，我们过点O作一条垂直于PN边的垂线与PN边相交于点D：

那么我么就会有：

由此很容易得出

[java]  view plain copy print ?

1. MN = largerTrianShortSize = an / (sizeLong - (mViewHeight - mPointY)) * (mViewWidth - mPointX);  
2. QN = smallTrianShortSize = an / sizeLong * sizeShort;  

在onDraw中我们在计算出sizeLong和sizeShort后加一步判断：

[java]  view plain copy print ?

1. /* 
2.  * 计算短边长边长度 
3.  */  
4. float sizeShort = temp / (2F * mK);  
5. float sizeLong = temp / (2F * mL);  
6.   
7. // 移动路径起点至触摸点  
8. mPath.moveTo(mPointX, mPointY);  
9.   
10. if (sizeLong > mViewHeight) {  
11.     // 计算……额……按图来AN边~  
12.     float an = sizeLong - mViewHeight;  
13.   
14.     // 三角形AMN的MN边  
15.     float largerTrianShortSize = an / (sizeLong - (mViewHeight - mPointY)) * (mViewWidth - mPointX);  
16.   
17.     // 三角形AQN的QN边  
18.     float smallTrianShortSize = an / sizeLong * sizeShort;  
19.   
20.     /* 
21.      * 生成四边形路径 
22.      */  
23.     mPath.lineTo(mViewWidth - largerTrianShortSize, 0);  
24.     mPath.lineTo(mViewWidth - smallTrianShortSize, 0);  
25.     mPath.lineTo(mViewWidth - sizeShort, mViewHeight);  
26.     mPath.close();  
27. } else {  
28.     /* 
29.      * 生成三角形路径 
30.      */  
31.     mPath.lineTo(mViewWidth, mViewHeight - sizeLong);  
32.     mPath.lineTo(mViewWidth - sizeShort, mViewHeight);  
33.     mPath.close();  
34. }  
35.   
36. // 绘制路径  
37. canvas.drawPath(mPath, mPaint);  

来看看具体效果：

挺不错的感觉，好，继续！

折线是OK了，剩下的问题是如何将我们的图片显示，也就是上一节的内容融合进来呢？在此之前，我们要知道的是折叠区域、当前页和下一页这三部分显示的是不同的内容，如文章开头的示图：

那么如何显示不同的图片就必须要先将这三部分表达出来对吧，我们之前曾学过Region区域对象，在这里就可以派上用场。首先，我们可以考虑将整个控件分为三个区域：显示当前页的区域、显示折叠的区域（也就是当前页的背面）、显示下一页的区域。与上图类似，我们可以利用图层的功能使用三个图层来模拟。第一步我们声明一个Region类型的引用来定义当前页的区域：

[java]  view plain copy print ?

1. private Region mRegionCurrent;// 当前页区域，其实就是控件的大小  

因为当前页的区域其实就是控件大小（置于最底层无所谓了~），我们直接就可以在onSizeChanged中完成对象的生成：

[java]  view plain copy print ?

1. // 计算当前页区域  
2. mRegionCurrent.set(0, 0, mViewWidth, mViewHeight);  

尔后我们需要计算折叠区域和下一页的路径：

如图红色线条所示路径，我们需要这部分区域来计算下一页的区域，即：下一页区域=线条部分区域-折叠区域对吧，同样我们声明一个Path类型的引用来定义该部分Path：

[java]  view plain copy print ?

1. private Path mPathFoldAndNext;// 一个包含折叠和下一页区域的Path  

在onDraw中在计算折叠区域的同时计算该部分区域：

[java]  view plain copy print ?

1. /* 
2.  * 计算短边长边长度 
3.  */  
4. float sizeShort = temp / (2F * mK);  
5. float sizeLong = temp / (2F * mL);  
6.   
7. // 移动路径起点至触摸点  
8. mPath.moveTo(mPointX, mPointY);  
9. mPathFoldAndNext.moveTo(mPointX, mPointY);  
10.   
11. if (sizeLong > mViewHeight) {  
12.     // 计算……额……按图来AN边~  
13.     float an = sizeLong - mViewHeight;  
14.   
15.     // 三角形AMN的MN边  
16.     float largerTrianShortSize = an / (sizeLong - (mViewHeight - mPointY)) * (mViewWidth - mPointX);  
17.   
18.     // 三角形AQN的QN边  
19.     float smallTrianShortSize = an / sizeLong * sizeShort;  
20.   
21.     /* 
22.      * 计算参数 
23.      */  
24.     float topX1 = mViewWidth - largerTrianShortSize;  
25.     float topX2 = mViewWidth - smallTrianShortSize;  
26.     float btmX2 = mViewWidth - sizeShort;  
27.   
28.     /* 
29.      * 生成四边形路径 
30.      */  
31.     mPath.lineTo(topX1, 0);  
32.     mPath.lineTo(topX2, 0);  
33.     mPath.lineTo(btmX2, mViewHeight);  
34.     mPath.close();  
35.   
36.     /* 
37.      * 生成包含折叠和下一页的路径 
38.      */  
39.     mPathFoldAndNext.lineTo(topX1, 0);  
40.     mPathFoldAndNext.lineTo(mViewWidth, 0);  
41.     mPathFoldAndNext.lineTo(mViewWidth, mViewHeight);  
42.     mPathFoldAndNext.lineTo(btmX2, mViewHeight);  
43.     mPathFoldAndNext.close();  
44. } else {  
45.     /* 
46.      * 计算参数 
47.      */  
48.     float leftY = mViewHeight - sizeLong;  
49.     float btmX = mViewWidth - sizeShort;  
50.   
51.     /* 
52.      * 生成三角形路径 
53.      */  
54.     mPath.lineTo(mViewWidth, leftY);  
55.     mPath.lineTo(btmX, mViewHeight);  
56.     mPath.close();  
57.   
58.     /* 
59.      * 生成包含折叠和下一页的路径 
60.      */  
61.     mPathFoldAndNext.lineTo(mViewWidth, leftY);  
62.     mPathFoldAndNext.lineTo(mViewWidth, mViewHeight);  
63.     mPathFoldAndNext.lineTo(btmX, mViewHeight);  
64.     mPathFoldAndNext.close();  
65. }  

将路径转换为Region我们独立一个方法来调用：

[java]  view plain copy print ?

1. /** 
2.  * 通过路径计算区域 
3.  *  
4.  * @param path 
5.  *            路径对象 
6.  * @return 路径的Region 
7.  */  
8. private Region computeRegion(Path path) {  
9.     Region region = new Region();  
10.     RectF f = new RectF();  
11.     path.computeBounds(f, true);  
12.     region.setPath(path, new Region((int) f.left, (int) f.top, (int) f.right, (int) f.bottom));  
13.     return region;  
14. }  

之后我们就可以计算并绘制这三部分区域：

[java]  view plain copy print ?

1. /* 
2.  * 定义区域 
3.  */  
4. Region regionFold = null;  
5. Region regionNext = null;  
6.   
7. /* 
8.  * 通过路径成成区域 
9.  */  
10. regionFold = computeRegion(mPath);  
11. regionNext = computeRegion(mPathFoldAndNext);  
12.   
13. /* 
14.  * 计算当前页的区域 
15.  */  
16. canvas.save();  
17. canvas.clipRegion(mRegionCurrent);  
18. canvas.clipRegion(regionNext, Region.Op.DIFFERENCE);  
19. canvas.drawColor(0xFFF4D8B7);  
20. canvas.restore();  
21.   
22. /* 
23.  * 计算折叠页的区域 
24.  */  
25. canvas.save();  
26. canvas.clipRegion(regionFold);  
27. canvas.drawColor(0xFF663C21);  
28. canvas.restore();  
29.   
30. /* 
31.  * 计算下一页的区域 
32.  */  
33. canvas.save();  
34. canvas.clipRegion(regionNext);  
35. canvas.clipRegion(regionFold, Region.Op.DIFFERENCE);  
36. canvas.drawColor(0xFF9596C4);  
37. canvas.restore();  

我们看看效果是否与我们期待的一致：

差不多对吧，只是有点小问题，我们在没触摸之前显示的是空白这很好解决，下面我们结合上一节的内容把图片的效果也整合进来，该部分全部的代码如下，我就直接贴出来了：

[java]  view plain copy print ?

1. package com.aigestudio.pagecurl.views;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. import android.annotation.SuppressLint;  
7. import android.content.Context;  
8. import android.graphics.Bitmap;  
9. import android.graphics.Canvas;  
10. import android.graphics.Color;  
11. import android.graphics.Paint;  
12. import android.graphics.Path;  
13. import android.graphics.RectF;  
14. import android.graphics.Region;  
15. import android.os.Handler;  
16. import android.os.Message;  
17. import android.text.TextPaint;  
18. import android.util.AttributeSet;  
19. import android.view.MotionEvent;  
20. import android.view.View;  
21. import android.widget.Toast;  
22.   
23. /** 
24.  * 折叠View 
25.  *  
26.  * @author AigeStudio {@link http://blog.csdn.net/aigestudio} 
27.  * @version 1.0.0 
28.  * @since 2014/12/27 
29.  */  
30. public class FoldView extends View {  
31.     private static final float VALUE_ADDED = 1 / 500F;// 精度附加值占比  
32.     private static final float BUFF_AREA = 1 / 50F;// 底部缓冲区域占比  
33.     private static final float AUTO_AREA_BUTTOM_RIGHT = 3 / 4F, AUTO_AREA_BUTTOM_LEFT = 1 / 8F;// 右下角和左侧自滑区域占比  
34.     private static final float AUTO_SLIDE_BL_V = 1 / 25F, AUTO_SLIDE_BR_V = 1 / 100F;// 滑动速度占比  
35.     private static final float TEXT_SIZE_NORMAL = 1 / 40F, TEXT_SIZE_LARGER = 1 / 20F;// 标准文字尺寸和大号文字尺寸的占比  
36.   
37.     private List<Bitmap> mBitmaps;// 位图数据列表  
38.   
39.     private SlideHandler mSlideHandler;// 滑动处理Handler  
40.     private Paint mPaint;// 画笔  
41.     private TextPaint mTextPaint;// 文本画笔  
42.     private Context mContext;// 上下文环境引用  
43.   
44.     private Path mPath;// 折叠路径  
45.     private Path mPathFoldAndNext;// 一个包含折叠和下一页区域的Path  
46.   
47.     private Region mRegionShortSize;// 短边的有效区域  
48.     private Region mRegionCurrent;// 当前页区域，其实就是控件的大小  
49.   
50.     private int mViewWidth, mViewHeight;// 控件宽高  
51.     private int mPageIndex;// 当前显示mBitmaps数据的下标  
52.   
53.     private float mPointX, mPointY;// 手指触摸点的坐标  
54.     private float mValueAdded;// 精度附减值  
55.     private float mBuffArea;// 底部缓冲区域  
56.     private float mAutoAreaButtom, mAutoAreaRight, mAutoAreaLeft;// 右下角和左侧自滑区域  
57.     private float mStart_X, mStart_Y;// 直线起点坐标  
58.     private float mAutoSlideV_BL, mAutoSlideV_BR;// 滑动速度  
59.     private float mTextSizeNormal, mTextSizeLarger;// 标准文字尺寸和大号文字尺寸  
60.     private float mDegrees;// 当前Y边长与Y轴的夹角  
61.   
62.     private boolean isSlide, isLastPage, isNextPage;// 是否执行滑动、是否已到最后一页、是否可显示下一页的标识值  
63.   
64.     private Slide mSlide;// 定义当前滑动是往左下滑还是右下滑  
65.   
66.     /** 
67.      * 枚举类定义滑动方向 
68.      */  
69.     private enum Slide {  
70.         LEFT_BOTTOM, RIGHT_BOTTOM  
71.     }  
72.   
73.     private Ratio mRatio;// 定义当前折叠边长  
74.   
75.     /** 
76.      * 枚举类定义长边短边 
77.      */  
78.     private enum Ratio {  
79.         LONG, SHORT  
80.     }  
81.   
82.     public FoldView(Context context, AttributeSet attrs) {  
83.         super(context, attrs);  
84.         mContext = context;  
85.   
86.         /* 
87.          * 实例化文本画笔并设置参数 
88.          */  
89.         mTextPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG | Paint.LINEAR_TEXT_FLAG);  
90.         mTextPaint.setTextAlign(Paint.Align.CENTER);  
91.   
92.         /* 
93.          * 实例化画笔对象并设置参数 
94.          */  
95.         mPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG);  
96.         mPaint.setStyle(Paint.Style.STROKE);  
97.         mPaint.setStrokeWidth(2);  
98.   
99.         /* 
100.          * 实例化路径对象 
101.          */  
102.         mPath = new Path();  
103.         mPathFoldAndNext = new Path();  
104.   
105.         /* 
106.          * 实例化区域对象 
107.          */  
108.         mRegionShortSize = new Region();  
109.         mRegionCurrent = new Region();  
110.   
111.         // 实例化滑动Handler处理器  
112.         mSlideHandler = new SlideHandler();  
113.     }  
114.   
115.     @Override  
116.     protected void onSizeChanged(int w, int h, int oldw, int oldh) {  
117.         /* 
118.          * 获取控件宽高 
119.          */  
120.         mViewWidth = w;  
121.         mViewHeight = h;  
122.   
123.         // 初始化位图数据  
124.         if (null != mBitmaps) {  
125.             initBitmaps();  
126.         }  
127.   
128.         // 计算文字尺寸  
129.         mTextSizeNormal = TEXT_SIZE_NORMAL * mViewHeight;  
130.         mTextSizeLarger = TEXT_SIZE_LARGER * mViewHeight;  
131.   
132.         // 计算精度附加值  
133.         mValueAdded = mViewHeight * VALUE_ADDED;  
134.   
135.         // 计算底部缓冲区域  
136.         mBuffArea = mViewHeight * BUFF_AREA;  
137.   
138.         /* 
139.          * 计算自滑位置 
140.          */  
141.         mAutoAreaButtom = mViewHeight * AUTO_AREA_BUTTOM_RIGHT;  
142.         mAutoAreaRight = mViewWidth * AUTO_AREA_BUTTOM_RIGHT;  
143.         mAutoAreaLeft = mViewWidth * AUTO_AREA_BUTTOM_LEFT;  
144.   
145.         // 计算短边的有效区域  
146.         computeShortSizeRegion();  
147.   
148.         /* 
149.          * 计算滑动速度 
150.          */  
151.         mAutoSlideV_BL = mViewWidth * AUTO_SLIDE_BL_V;  
152.         mAutoSlideV_BR = mViewWidth * AUTO_SLIDE_BR_V;  
153.   
154.         // 计算当前页区域  
155.         mRegionCurrent.set(0, 0, mViewWidth, mViewHeight);  
156.     }  
157.   
158.     /** 
159.      * 初始化位图数据 
160.      * 缩放位图尺寸与屏幕匹配 
161.      */  
162.     private void initBitmaps() {  
163.         List<Bitmap> temp = new ArrayList<Bitmap>();  
164.         for (int i = mBitmaps.size() - 1; i >= 0; i--) {  
165.             Bitmap bitmap = Bitmap.createScaledBitmap(mBitmaps.get(i), mViewWidth, mViewHeight, true);  
166.             temp.add(bitmap);  
167.         }  
168.         mBitmaps = temp;  
169.     }  
170.   
171.     /** 
172.      * 计算短边的有效区域 
173.      */  
174.     private void computeShortSizeRegion() {  
175.         // 短边圆形路径对象  
176.         Path pathShortSize = new Path();  
177.   
178.         // 用来装载Path边界值的RectF对象  
179.         RectF rectShortSize = new RectF();  
180.   
181.         // 添加圆形到Path  
182.         pathShortSize.addCircle(0, mViewHeight, mViewWidth, Path.Direction.CCW);  
183.   
184.         // 计算边界  
185.         pathShortSize.computeBounds(rectShortSize, true);  
186.   
187.         // 将Path转化为Region  
188.         mRegionShortSize.setPath(pathShortSize, new Region((int) rectShortSize.left, (int) rectShortSize.top, (int) rectShortSize.right, (int) rectShortSize.bottom));  
189.     }  
190.   
191.     @Override  
192.     protected void onDraw(Canvas canvas) {  
193.         /* 
194.          * 如果数据为空则显示默认提示文本 
195.          */  
196.         if (null == mBitmaps || mBitmaps.size() == 0) {  
197.             defaultDisplay(canvas);  
198.             return;  
199.         }  
200.   
201.         // 重绘时重置路径  
202.         mPath.reset();  
203.         mPathFoldAndNext.reset();  
204.   
205.         // 绘制底色  
206.         canvas.drawColor(Color.WHITE);  
207.   
208.         /* 
209.          * 如果坐标点在原点（即还没发生触碰时）则绘制第一页 
210.          */  
211.         if (mPointX == 0 && mPointY == 0) {  
212.             canvas.drawBitmap(mBitmaps.get(mBitmaps.size() - 1), 0, 0, null);  
213.             return;  
214.         }  
215.   
216.         /* 
217.          * 判断触摸点是否在短边的有效区域内 
218.          */  
219.         if (!mRegionShortSize.contains((int) mPointX, (int) mPointY)) {  
220.             // 如果不在则通过x坐标强行重算y坐标  
221.             mPointY = (float) (Math.sqrt((Math.pow(mViewWidth, 2) - Math.pow(mPointX, 2))) - mViewHeight);  
222.   
223.             // 精度附加值避免精度损失  
224.             mPointY = Math.abs(mPointY) + mValueAdded;  
225.         }  
226.   
227.         /* 
228.          * 缓冲区域判断 
229.          */  
230.         float area = mViewHeight - mBuffArea;  
231.         if (!isSlide && mPointY >= area) {  
232.             mPointY = area;  
233.         }  
234.   
235.         /* 
236.          * 额，这个该怎么注释好呢……根据图来 
237.          */  
238.         float mK = mViewWidth - mPointX;  
239.         float mL = mViewHeight - mPointY;  
240.   
241.         // 需要重复使用的参数存值避免重复计算  
242.         float temp = (float) (Math.pow(mL, 2) + Math.pow(mK, 2));  
243.   
244.         /* 
245.          * 计算短边长边长度 
246.          */  
247.         float sizeShort = temp / (2F * mK);  
248.         float sizeLong = temp / (2F * mL);  
249.   
250.         /* 
251.          * 根据长短边边长计算旋转角度并确定mRatio的值 
252.          */  
253.         if (sizeShort < sizeLong) {  
254.             mRatio = Ratio.SHORT;  
255.             float sin = (mK - sizeShort) / sizeShort;  
256.             mDegrees = (float) (Math.asin(sin) / Math.PI * 180);  
257.         } else {  
258.             mRatio = Ratio.LONG;  
259.             float cos = mK / sizeLong;  
260.             mDegrees = (float) (Math.acos(cos) / Math.PI * 180);  
261.         }  
262.   
263.         // 移动路径起点至触摸点  
264.         mPath.moveTo(mPointX, mPointY);  
265.         mPathFoldAndNext.moveTo(mPointX, mPointY);  
266.   
267.         if (sizeLong > mViewHeight) {  
268.             // 计算……额……按图来AN边~  
269.             float an = sizeLong - mViewHeight;  
270.   
271.             // 三角形AMN的MN边  
272.             float largerTrianShortSize = an / (sizeLong - (mViewHeight - mPointY)) * (mViewWidth - mPointX);  
273.   
274.             // 三角形AQN的QN边  
275.             float smallTrianShortSize = an / sizeLong * sizeShort;  
276.   
277.             /* 
278.              * 计算参数 
279.              */  
280.             float topX1 = mViewWidth - largerTrianShortSize;  
281.             float topX2 = mViewWidth - smallTrianShortSize;  
282.             float btmX2 = mViewWidth - sizeShort;  
283.   
284.             /* 
285.              * 生成四边形路径 
286.              */  
287.             mPath.lineTo(topX1, 0);  
288.             mPath.lineTo(topX2, 0);  
289.             mPath.lineTo(btmX2, mViewHeight);  
290.             mPath.close();  
291.   
292.             /* 
293.              * 生成包含折叠和下一页的路径 
294.              */  
295.             mPathFoldAndNext.lineTo(topX1, 0);  
296.             mPathFoldAndNext.lineTo(mViewWidth, 0);  
297.             mPathFoldAndNext.lineTo(mViewWidth, mViewHeight);  
298.             mPathFoldAndNext.lineTo(btmX2, mViewHeight);  
299.             mPathFoldAndNext.close();  
300.         } else {  
301.             /* 
302.              * 计算参数 
303.              */  
304.             float leftY = mViewHeight - sizeLong;  
305.             float btmX = mViewWidth - sizeShort;  
306.   
307.             /* 
308.              * 生成三角形路径 
309.              */  
310.             mPath.lineTo(mViewWidth, leftY);  
311.             mPath.lineTo(btmX, mViewHeight);  
312.             mPath.close();  
313.   
314.             /* 
315.              * 生成包含折叠和下一页的路径 
316.              */  
317.             mPathFoldAndNext.lineTo(mViewWidth, leftY);  
318.             mPathFoldAndNext.lineTo(mViewWidth, mViewHeight);  
319.             mPathFoldAndNext.lineTo(btmX, mViewHeight);  
320.             mPathFoldAndNext.close();  
321.         }  
322.   
323.         drawBitmaps(canvas);  
324.     }  
325.   
326.     /** 
327.      * 绘制位图数据 
328.      *  
329.      * @param canvas 
330.      *            画布对象 
331.      */  
332.     private void drawBitmaps(Canvas canvas) {  
333.         // 绘制位图前重置isLastPage为false  
334.         isLastPage = false;  
335.   
336.         // 限制pageIndex的值范围  
337.         mPageIndex = mPageIndex < 0 ? 0 : mPageIndex;  
338.         mPageIndex = mPageIndex > mBitmaps.size() ? mBitmaps.size() : mPageIndex;  
339.   
340.         // 计算数据起始位置  
341.         int start = mBitmaps.size() - 2 - mPageIndex;  
342.         int end = mBitmaps.size() - mPageIndex;  
343.   
344.         /* 
345.          * 如果数据起点位置小于0则表示当前已经到了最后一张图片 
346.          */  
347.         if (start < 0) {  
348.             // 此时设置isLastPage为true  
349.             isLastPage = true;  
350.   
351.             // 并显示提示信息  
352.             showToast("This is fucking lastest page");  
353.   
354.             // 强制重置起始位置  
355.             start = 0;  
356.             end = 1;  
357.         }  
358.   
359.         /* 
360.          * 定义区域 
361.          */  
362.         Region regionFold = null;  
363.         Region regionNext = null;  
364.   
365.         /* 
366.          * 通过路径成成区域 
367.          */  
368.         regionFold = computeRegion(mPath);  
369.         regionNext = computeRegion(mPathFoldAndNext);  
370.   
371.         /* 
372.          * 计算当前页的区域 
373.          */  
374.         canvas.save();  
375.         canvas.clipRegion(mRegionCurrent);  
376.         canvas.clipRegion(regionNext, Region.Op.DIFFERENCE);  
377.         canvas.drawBitmap(mBitmaps.get(end - 1), 0, 0, null);  
378.         canvas.restore();  
379.   
380.         /* 
381.          * 计算折叠页的区域 
382.          */  
383.         canvas.save();  
384.         canvas.clipRegion(regionFold);  
385.   
386.         canvas.translate(mPointX, mPointY);  
387.   
388.         /* 
389.          * 根据长短边标识计算折叠区域图像 
390.          */  
391.         if (mRatio == Ratio.SHORT) {  
392.             canvas.rotate(90 - mDegrees);  
393.             canvas.translate(0, -mViewHeight);  
394.             canvas.scale(-1, 1);  
395.             canvas.translate(-mViewWidth, 0);  
396.         } else {  
397.             canvas.rotate(-(90 - mDegrees));  
398.             canvas.translate(-mViewWidth, 0);  
399.             canvas.scale(1, -1);  
400.             canvas.translate(0, -mViewHeight);  
401.         }  
402.   
403.         canvas.drawBitmap(mBitmaps.get(end - 1), 0, 0, null);  
404.         canvas.restore();  
405.   
406.         /* 
407.          * 计算下一页的区域 
408.          */  
409.         canvas.save();  
410.         canvas.clipRegion(regionNext);  
411.         canvas.clipRegion(regionFold, Region.Op.DIFFERENCE);  
412.         canvas.drawBitmap(mBitmaps.get(start), 0, 0, null);  
413.         canvas.restore();  
414.     }  
415.   
416.     /** 
417.      * 默认显示 
418.      *  
419.      * @param canvas 
420.      *            Canvas对象 
421.      */  
422.     private void defaultDisplay(Canvas canvas) {  
423.         // 绘制底色  
424.         canvas.drawColor(Color.WHITE);  
425.   
426.         // 绘制标题文本  
427.         mTextPaint.setTextSize(mTextSizeLarger);  
428.         mTextPaint.setColor(Color.RED);  
429.         canvas.drawText("FBI WARNING", mViewWidth / 2, mViewHeight / 4, mTextPaint);  
430.   
431.         // 绘制提示文本  
432.         mTextPaint.setTextSize(mTextSizeNormal);  
433.         mTextPaint.setColor(Color.BLACK);  
434.         canvas.drawText("Please set data use setBitmaps method", mViewWidth / 2, mViewHeight / 3, mTextPaint);  
435.     }  
436.   
437.     /** 
438.      * 通过路径计算区域 
439.      *  
440.      * @param path 
441.      *            路径对象 
442.      * @return 路径的Region 
443.      */  
444.     private Region computeRegion(Path path) {  
445.         Region region = new Region();  
446.         RectF f = new RectF();  
447.         path.computeBounds(f, true);  
448.         region.setPath(path, new Region((int) f.left, (int) f.top, (int) f.right, (int) f.bottom));  
449.         return region;  
450.     }  
451.   
452.     /** 
453.      * 计算滑动参数变化 
454.      */  
455.     private void slide() {  
456.         /* 
457.          * 如果滑动标识值为false则返回 
458.          */  
459.         if (!isSlide) {  
460.             return;  
461.         }  
462.   
463.         /* 
464.          * 如果当前页不是最后一页 
465.          * 如果是需要翻下一页 
466.          * 并且上一页已被做掉 
467.          */  
468.         if (!isLastPage && isNextPage && (mPointX - mAutoSlideV_BL <= -mViewWidth)) {  
469.             mPointX = -mViewWidth;  
470.             mPointY = mViewHeight;  
471.             mPageIndex++;  
472.             invalidate();  
473.         }  
474.   
475.         /* 
476.          * 如果当前滑动标识为向右下滑动x坐标恒小于控件宽度 
477.          */  
478.         else if (mSlide == Slide.RIGHT_BOTTOM && mPointX < mViewWidth) {  
479.             // 则让x坐标自加  
480.             mPointX += mAutoSlideV_BR;  
481.   
482.             // 并根据x坐标的值重新计算y坐标的值  
483.             mPointY = mStart_Y + ((mPointX - mStart_X) * (mViewHeight - mStart_Y)) / (mViewWidth - mStart_X);  
484.   
485.             // 让SlideHandler处理重绘  
486.             mSlideHandler.sleep(25);  
487.         }  
488.   
489.         /* 
490.          * 如果当前滑动标识为向左下滑动x坐标恒大于控件宽度的负值 
491.          */  
492.         else if (mSlide == Slide.LEFT_BOTTOM && mPointX > -mViewWidth) {  
493.             // 则让x坐标自减  
494.             mPointX -= mAutoSlideV_BL;  
495.   
496.             // 并根据x坐标的值重新计算y坐标的值  
497.             mPointY = mStart_Y + ((mPointX - mStart_X) * (mViewHeight - mStart_Y)) / (-mViewWidth - mStart_X);  
498.   
499.             // 让SlideHandler处理重绘  
500.             mSlideHandler.sleep(25);  
501.         }  
502.     }  
503.   
504.     /** 
505.      * 为isSlide提供对外的停止方法便于必要时释放滑动动画 
506.      */  
507.     public void slideStop() {  
508.         isSlide = false;  
509.     }  
510.   
511.     /** 
512.      * 提供对外的方法获取View内Handler 
513.      *  
514.      * @return mSlideHandler 
515.      */  
516.     public SlideHandler getSlideHandler() {  
517.         return mSlideHandler;  
518.     }  
519.   
520.     @Override  
521.     public boolean onTouchEvent(MotionEvent event) {  
522.         isNextPage = true;  
523.   
524.         /* 
525.          * 获取当前事件点 
526.          */  
527.         float x = event.getX();  
528.         float y = event.getY();  
529.   
530.         switch (event.getAction() & MotionEvent.ACTION_MASK) {  
531.         case MotionEvent.ACTION_UP:// 手指抬起时候  
532.             if (isNextPage) {  
533.                 /* 
534.                  * 如果当前事件点位于右下自滑区域 
535.                  */  
536.                 if (x > mAutoAreaRight && y > mAutoAreaButtom) {  
537.                     // 当前为往右下滑  
538.                     mSlide = Slide.RIGHT_BOTTOM;  
539.   
540.                     // 摩擦吧骚年！  
541.                     justSlide(x, y);  
542.                 }  
543.   
544.                 /* 
545.                  * 如果当前事件点位于左侧自滑区域 
546.                  */  
547.                 if (x < mAutoAreaLeft) {  
548.                     // 当前为往左下滑  
549.                     mSlide = Slide.LEFT_BOTTOM;  
550.   
551.                     // 摩擦吧骚年！  
552.                     justSlide(x, y);  
553.                 }  
554.             }  
555.             break;  
556.         case MotionEvent.ACTION_DOWN:  
557.             isSlide = false;  
558.             /* 
559.              * 如果事件点位于回滚区域 
560.              */  
561.             if (x < mAutoAreaLeft) {  
562.                 // 那就不翻下一页了而是上一页  
563.                 isNextPage = false;  
564.                 mPageIndex--;  
565.                 mPointX = x;  
566.                 mPointY = y;  
567.                 invalidate();  
568.             }  
569.             downAndMove(event);  
570.             break;  
571.         case MotionEvent.ACTION_MOVE:  
572.             downAndMove(event);  
573.             break;  
574.         }  
575.         return true;  
576.     }  
577.   
578.     /** 
579.      * 处理DOWN和MOVE事件 
580.      *  
581.      * @param event 
582.      *            事件对象 
583.      */  
584.     private void downAndMove(MotionEvent event) {  
585.         if (!isLastPage) {  
586.             mPointX = event.getX();  
587.             mPointY = event.getY();  
588.   
589.             invalidate();  
590.         }  
591.     }  
592.   
593.     /** 
594.      * 在这光滑的地板上~ 
595.      *  
596.      * @param x 
597.      *            当前触摸点x 
598.      * @param y 
599.      *            当前触摸点y 
600.      */  
601.     private void justSlide(float x, float y) {  
602.         // 获取并设置直线方程的起点  
603.         mStart_X = x;  
604.         mStart_Y = y;  
605.   
606.         // OK要开始滑动了哦~  
607.         isSlide = true;  
608.   
609.         // 滑动  
610.         slide();  
611.     }  
612.   
613.     /** 
614.      * 设置位图数据 
615.      *  
616.      * @param bitmaps 
617.      *            位图数据列表 
618.      */  
619.     public synchronized void setBitmaps(List<Bitmap> bitmaps) {  
620.         /* 
621.          * 如果数据为空则抛出异常 
622.          */  
623.         if (null == bitmaps || bitmaps.size() == 0)  
624.             throw new IllegalArgumentException("no bitmap to display");  
625.   
626.         /* 
627.          * 如果数据长度小于2则GG思密达 
628.          */  
629.         if (bitmaps.size() < 2)  
630.             throw new IllegalArgumentException("fuck you and fuck to use imageview");  
631.   
632.         mBitmaps = bitmaps;  
633.         invalidate();  
634.     }  
635.   
636.     /** 
637.      * Toast显示 
638.      *  
639.      * @param msg 
640.      *            Toast显示文本 
641.      */  
642.     private void showToast(Object msg) {  
643.         Toast.makeText(mContext, msg.toString(), Toast.LENGTH_SHORT).show();  
644.     }  
645.   
646.     /** 
647.      * 处理滑动的Handler 
648.      */  
649.     @SuppressLint("HandlerLeak")  
650.     public class SlideHandler extends Handler {  
651.         @Override  
652.         public void handleMessage(Message msg) {  
653.             // 循环调用滑动计算  
654.             FoldView.this.slide();  
655.   
656.             // 重绘视图  
657.             FoldView.this.invalidate();  
658.         }  
659.   
660.         /** 
661.          * 延迟向Handler发送消息实现时间间隔 
662.          *  
663.          * @param delayMillis 
664.          *            间隔时间 
665.          */  
666.         public void sleep(long delayMillis) {  
667.             this.removeMessages(0);  
668.             sendMessageDelayed(obtainMessage(0), delayMillis);  
669.         }  
670.     }  
671. }  

以上代码就是本节的全部内容，运行的效果如下：

代码部分除了折叠区域图像的生成外都是直接从上一节COPY过来，而折叠区域图像的生成为了便于大家的理解我分为了两种情况计算（如果你的图形学屌可以将其并入一个计算方式）即当长边大于短边和短边大于长边两种情况（注意文章开头我们的长短边声明），而相等的情况我们并入其中一种一并计算即可。具体的计算过程很简单，首先我们必定要移动Canvas使其原点与我们的触摸点对应：

[java]  view plain copy print ?

1. canvas.translate(mPointX, mPointY);//386行  

然后就是分情况了，第一种情况短边小于长边：

[java]  view plain copy print ?

1. //392-395行  
2. canvas.rotate(90 - mDegrees);  
3. canvas.translate(0, -mViewHeight);  
4. canvas.scale(-1, 1);  
5. canvas.translate(-mViewWidth, 0);  

这个过程图解的话就是：

而另一种情况短边大于长边：

[java]  view plain copy print ?

1. //397-400行  
2. canvas.rotate(-(90 - mDegrees));  
3. canvas.translate(-mViewWidth, 0);  
4. canvas.scale(1, -1);  
5. canvas.translate(0, -mViewHeight);  

该过程其实与上面类似、就不在画图了，图解很累的……

其他的跟上一节我们所讲的没有太大的出入。

OK，这一节到此为止，下一节我们将去尝试曲线的生成，如何将折线变为曲线并简单地实现扭曲的效果，thx all 谢谢大家、

本文转自 http://blog.csdn.net/aigestudio/article/details/42686907