音频驱动/设备
","paddingLeft":2,"paddingRight":2,"paddingBottom":2,"paddingTop":2}},"children":null}],"linkMap":[]},{"x":264,"y":580,"rotation":0,"id":9,"uid":"com.gliffy.shape.network.network_v3.home.tv_flatscreen","width":76,"height":100,"lockAspectRatio":true,"lockShape":false,"order":35,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.tv_flatscreen_3d.network_v3","strokeWidth":2,"strokeColor":"#000000","fillColor":"#003366","gradient":false,"dropShadow":false,"state":0,"shadowX":0,"shadowY":0,"opacity":1}},"children":[{"x":2,"y":0,"rotation":0,"id":70,"uid":null,"width":75,"height":14,"lockAspectRatio":false,"lockShape":false,"order":"auto","graphic":{"type":"Text","Text":{"tid":null,"valign":"middle","overflow":"both","vposition":"below","hposition":"none","html":"视频驱动/设备
","paddingLeft":2,"paddingRight":2,"paddingBottom":2,"paddingTop":2}},"children":null}],"linkMap":[]},{"x":245,"y":580,"rotation":0,"id":60,"uid":"com.gliffy.shape.basic.basic_v1.default.line","width":100,"height":100,"lockAspectRatio":false,"lockShape":false,"order":34,"graphic":{"type":"Line","Line":{"strokeWidth":2,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","ortho":true,"interpolationType":"linear","cornerRadius":null,"controlPath":[[-65,0],[-65,50],[57,50]],"lockSegments":{}}},"children":null,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":45,"px":0.5,"py":1}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":9,"px":0.5,"py":0.5}}},"linkMap":[]},{"x":114,"y":584,"rotation":0,"id":59,"uid":"com.gliffy.shape.basic.basic_v1.default.line","width":100,"height":100,"lockAspectRatio":false,"lockShape":false,"order":33,"graphic":{"type":"Line","Line":{"strokeWidth":2,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","ortho":true,"interpolationType":"linear","cornerRadius":null,"controlPath":[[66,-4],[66,46],[-57,46]],"lockSegments":{}}},"children":null,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":45,"px":0.5,"py":1}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":3,"px":0.5,"py":0.5}}},"linkMap":[]},{"x":270,"y":502,"rotation":0,"id":58,"uid":"com.gliffy.shape.basic.basic_v1.default.line","width":100,"height":100,"lockAspectRatio":false,"lockShape":false,"order":32,"graphic":{"type":"Line","Line":{"strokeWidth":2,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","ortho":true,"interpolationType":"linear","cornerRadius":null,"controlPath":[[10,-2],[10,18],[-90,18],[-90,38]],"lockSegments":{}}},"children":null,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":40,"px":0.5,"py":1}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":45,"px":0.5,"py":0}}},"linkMap":[]},{"x":92,"y":497,"rotation":0,"id":56,"uid":"com.gliffy.shape.basic.basic_v1.default.line","width":100,"height":100,"lockAspectRatio":false,"lockShape":false,"order":31,"graphic":{"type":"Line","Line":{"strokeWidth":2,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","ortho":true,"interpolationType":"linear","cornerRadius":null,"controlPath":[[-12,3],[-12,23],[88,23],[88,43]],"lockSegments":{}}},"children":null,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":38,"px":0.5,"py":1}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":45,"px":0.5,"py":0}}},"linkMap":[]},{"x":267,"y":433,"rotation":0,"id":54,"uid":"com.gliffy.shape.basic.basic_v1.default.line","width":100,"height":100,"lockAspectRatio":false,"lockShape":false,"order":30,"graphic":{"type":"Line","Line":{"strokeWidth":2,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","ortho":true,"interpolationType":"linear","cornerRadius":10,"controlPath":[[13,-3],[13,7],[13,17],[13,27]],"lockSegments":{}}},"children":null,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":36,"px":0.5,"py":1}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":40,"px":0.5,"py":0}}},"linkMap":[]},{"x":87,"y":431,"rotation":0,"id":53,"uid":"com.gliffy.shape.basic.basic_v1.default.line","width":100,"height":100,"lockAspectRatio":false,"lockShape":false,"order":29,"graphic":{"type":"Line","Line":{"strokeWidth":2,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","ortho":true,"interpolationType":"linear","cornerRadius":10,"controlPath":[[-7,-1],[-7,9],[-7,19],[-7,29]],"lockSegments":{}}},"children":null,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":34,"px":0.5,"py":1}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":38,"px":0.5,"py":0}}},"linkMap":[]},{"x":271,"y":362,"rotation":0,"id":52,"uid":"com.gliffy.shape.basic.basic_v1.default.line","width":100,"height":100,"lockAspectRatio":false,"lockShape":false,"order":28,"graphic":{"type":"Line","Line":{"strokeWidth":2,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","ortho":true,"interpolationType":"linear","cornerRadius":10,"controlPath":[[9,-2],[9,8],[9,18],[9,28]],"lockSegments":{}}},"children":null,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":32,"px":0.5,"py":1}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":36,"px":0.5,"py":0}}},"linkMap":[]},{"x":92,"y":356,"rotation":0,"id":51,"uid":"com.gliffy.shape.basic.basic_v1.default.line","width":100,"height":100,"lockAspectRatio":false,"lockShape":false,"order":27,"graphic":{"type":"Line","Line":{"strokeWidth":2,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","ortho":true,"interpolationType":"linear","cornerRadius":10,"controlPath":[[-12,4],[-12,14],[-12,24],[-12,34]],"lockSegments":{}}},"children":null,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":29,"px":0.5,"py":1}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":34,"px":0.5,"py":0}}},"linkMap":[]},{"x":243,"y":271,"rotation":0,"id":50,"uid":"com.gliffy.shape.basic.basic_v1.default.line","width":100,"height":100,"lockAspectRatio":false,"lockShape":false,"order":26,"graphic":{"type":"Line","Line":{"strokeWidth":2,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","ortho":true,"interpolationType":"linear","cornerRadius":null,"controlPath":[[-63,-1],[-63,24],[37,24],[37,49]],"lockSegments":{}}},"children":null,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":27,"px":0.5,"py":1}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":32,"px":0.5,"py":0}}},"linkMap":[]},{"x":106,"y":268,"rotation":0,"id":49,"uid":"com.gliffy.shape.basic.basic_v1.default.line","width":100,"height":100,"lockAspectRatio":false,"lockShape":false,"order":25,"graphic":{"type":"Line","Line":{"strokeWidth":2,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","ortho":true,"interpolationType":"linear","cornerRadius":null,"controlPath":[[74,2],[74,27],[-26,27],[-26,52]],"lockSegments":{}}},"children":null,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":27,"px":0.5,"py":1}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":29,"px":0.5,"py":0}}},"linkMap":[]},{"x":181,"y":201,"rotation":0,"id":48,"uid":"com.gliffy.shape.basic.basic_v1.default.line","width":100,"height":100,"lockAspectRatio":false,"lockShape":false,"order":24,"graphic":{"type":"Line","Line":{"strokeWidth":2,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","ortho":true,"interpolationType":"linear","cornerRadius":10,"controlPath":[[-1,-1],[-1,9],[-1,19],[-1,29]],"lockSegments":{}}},"children":null,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":25,"px":0.5,"py":1}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":27,"px":0.5,"py":0}}},"linkMap":[]},{"x":179,"y":134,"rotation":0,"id":47,"uid":"com.gliffy.shape.basic.basic_v1.default.line","width":100,"height":100,"lockAspectRatio":false,"lockShape":false,"order":23,"graphic":{"type":"Line","Line":{"strokeWidth":2,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","ortho":true,"interpolationType":"linear","cornerRadius":10,"controlPath":[[1,-4],[1,6],[1,16],[1,26]],"lockSegments":{}}},"children":null,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":23,"px":0.5,"py":1}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":25,"px":0.5,"py":0}}},"linkMap":[]},{"x":120,"y":540,"rotation":0,"id":45,"uid":"com.gliffy.shape.flowchart.flowchart_v1.default.process","width":120,"height":40,"lockAspectRatio":false,"lockShape":false,"order":21,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dropShadow":false,"state":0,"shadowX":0,"shadowY":0,"opacity":1}},"children":[{"x":2.4000000000000004,"y":0,"rotation":0,"id":46,"uid":null,"width":115.2,"height":14,"lockAspectRatio":false,"lockShape":false,"order":"auto","graphic":{"type":"Text","Text":{"tid":null,"valign":"middle","overflow":"none","vposition":"none","hposition":"none","html":"音视频同步
","paddingLeft":2,"paddingRight":2,"paddingBottom":2,"paddingTop":2}},"children":null}],"linkMap":[]},{"x":182,"y":62,"rotation":0,"id":42,"uid":"com.gliffy.shape.basic.basic_v1.default.line","width":100,"height":100,"lockAspectRatio":false,"lockShape":false,"order":20,"graphic":{"type":"Line","Line":{"strokeWidth":2,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","ortho":true,"interpolationType":"linear","cornerRadius":10,"controlPath":[[-2,-2],[-2,8],[-2,18],[-2,28]],"lockSegments":{}}},"children":null,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":19,"px":0.5,"py":1}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":23,"px":0.5,"py":0}}},"linkMap":[]},{"x":220,"y":460,"rotation":0,"id":40,"uid":"com.gliffy.shape.flowchart.flowchart_v1.default.process","width":120,"height":40,"lockAspectRatio":false,"lockShape":false,"order":18,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2,"strokeColor":"#333333","fillColor":"#d0e0e3","gradient":false,"dropShadow":false,"state":0,"shadowX":0,"shadowY":0,"opacity":1}},"children":[{"x":2.4,"y":0,"rotation":0,"id":41,"uid":null,"width":115.2,"height":14,"lockAspectRatio":false,"lockShape":false,"order":"auto","graphic":{"type":"Text","Text":{"tid":null,"valign":"middle","overflow":"none","vposition":"none","hposition":"none","html":"视频原始数据
","paddingLeft":2,"paddingRight":2,"paddingBottom":2,"paddingTop":2}},"children":null}],"linkMap":[]},{"x":20,"y":460,"rotation":0,"id":38,"uid":"com.gliffy.shape.flowchart.flowchart_v1.default.process","width":120,"height":40,"lockAspectRatio":false,"lockShape":false,"order":16,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2,"strokeColor":"#333333","fillColor":"#d0e0e3","gradient":false,"dropShadow":false,"state":0,"shadowX":0,"shadowY":0,"opacity":1}},"children":[{"x":2.4,"y":0,"rotation":0,"id":39,"uid":null,"width":115.2,"height":14,"lockAspectRatio":false,"lockShape":false,"order":"auto","graphic":{"type":"Text","Text":{"tid":null,"valign":"middle","overflow":"none","vposition":"none","hposition":"none","html":"音频原始数据
","paddingLeft":2,"paddingRight":2,"paddingBottom":2,"paddingTop":2}},"children":null}],"linkMap":[]},{"x":220,"y":390,"rotation":0,"id":36,"uid":"com.gliffy.shape.flowchart.flowchart_v1.default.process","width":120,"height":40,"lockAspectRatio":false,"lockShape":false,"order":14,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2,"strokeColor":"#333333","fillColor":"#f9cb9c","gradient":false,"dropShadow":false,"state":0,"shadowX":0,"shadowY":0,"opacity":1}},"children":[{"x":2.4,"y":0,"rotation":0,"id":37,"uid":null,"width":115.2,"height":14,"lockAspectRatio":false,"lockShape":false,"order":"auto","graphic":{"type":"Text","Text":{"tid":null,"valign":"middle","overflow":"none","vposition":"none","hposition":"none","html":"视频解码
","paddingLeft":2,"paddingRight":2,"paddingBottom":2,"paddingTop":2}},"children":null}],"linkMap":[]},{"x":20,"y":390,"rotation":0,"id":34,"uid":"com.gliffy.shape.flowchart.flowchart_v1.default.process","width":120,"height":40,"lockAspectRatio":false,"lockShape":false,"order":12,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2,"strokeColor":"#333333","fillColor":"#f9cb9c","gradient":false,"dropShadow":false,"state":0,"shadowX":0,"shadowY":0,"opacity":1}},"children":[{"x":2.4,"y":0,"rotation":0,"id":35,"uid":null,"width":115.2,"height":14,"lockAspectRatio":false,"lockShape":false,"order":"auto","graphic":{"type":"Text","Text":{"tid":null,"valign":"middle","overflow":"none","vposition":"none","hposition":"none","html":"音频解码
","paddingLeft":2,"paddingRight":2,"paddingBottom":2,"paddingTop":2}},"children":null}],"linkMap":[]},{"x":220,"y":320,"rotation":0,"id":32,"uid":"com.gliffy.shape.flowchart.flowchart_v1.default.process","width":120,"height":40,"lockAspectRatio":false,"lockShape":false,"order":10,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2,"strokeColor":"#333333","fillColor":"#a2c4c9","gradient":false,"dropShadow":false,"state":0,"shadowX":0,"shadowY":0,"opacity":1}},"children":[{"x":2.4,"y":0,"rotation":0,"id":33,"uid":null,"width":115.2,"height":14,"lockAspectRatio":false,"lockShape":false,"order":"auto","graphic":{"type":"Text","Text":{"tid":null,"valign":"middle","overflow":"none","vposition":"none","hposition":"none","html":"视频压缩数据
","paddingLeft":2,"paddingRight":2,"paddingBottom":2,"paddingTop":2}},"children":null}],"linkMap":[]},{"x":20,"y":320,"rotation":0,"id":29,"uid":"com.gliffy.shape.flowchart.flowchart_v1.default.process","width":120,"height":40,"lockAspectRatio":false,"lockShape":false,"order":8,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2,"strokeColor":"#333333","fillColor":"#a2c4c9","gradient":false,"dropShadow":false,"state":0,"shadowX":0,"shadowY":0,"opacity":1}},"children":[{"x":2.4,"y":0,"rotation":0,"id":30,"uid":null,"width":115.2,"height":14,"lockAspectRatio":false,"lockShape":false,"order":"auto","graphic":{"type":"Text","Text":{"tid":null,"valign":"middle","overflow":"none","vposition":"none","hposition":"none","html":"音频压缩数据
","paddingLeft":2,"paddingRight":2,"paddingBottom":2,"paddingTop":2}},"children":null}],"linkMap":[]},{"x":120,"y":230,"rotation":0,"id":27,"uid":"com.gliffy.shape.flowchart.flowchart_v1.default.process","width":120,"height":40,"lockAspectRatio":false,"lockShape":false,"order":6,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dropShadow":false,"state":0,"shadowX":0,"shadowY":0,"opacity":1}},"children":[{"x":2.3999999999999995,"y":0,"rotation":0,"id":28,"uid":null,"width":115.19999999999999,"height":14,"lockAspectRatio":false,"lockShape":false,"order":"auto","graphic":{"type":"Text","Text":{"tid":null,"valign":"middle","overflow":"none","vposition":"none","hposition":"none","html":"解封装
","paddingLeft":2,"paddingRight":2,"paddingBottom":2,"paddingTop":2}},"children":null}],"linkMap":[]},{"x":120,"y":160,"rotation":0,"id":25,"uid":"com.gliffy.shape.flowchart.flowchart_v1.default.process","width":120,"height":40,"lockAspectRatio":false,"lockShape":false,"order":4,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2,"strokeColor":"#333333","fillColor":"#76a5af","gradient":false,"dropShadow":false,"state":0,"shadowX":0,"shadowY":0,"opacity":1}},"children":[{"x":2.3999999999999995,"y":0,"rotation":0,"id":26,"uid":null,"width":115.19999999999999,"height":14,"lockAspectRatio":false,"lockShape":false,"order":"auto","graphic":{"type":"Text","Text":{"tid":null,"valign":"middle","overflow":"none","vposition":"none","hposition":"none","html":"封装格式数据
","paddingLeft":2,"paddingRight":2,"paddingBottom":2,"paddingTop":2}},"children":null}],"linkMap":[]},{"x":120,"y":90,"rotation":0,"id":23,"uid":"com.gliffy.shape.flowchart.flowchart_v1.default.process","width":120,"height":40,"lockAspectRatio":false,"lockShape":false,"order":2,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dropShadow":false,"state":0,"shadowX":0,"shadowY":0,"opacity":1}},"children":[{"x":2.4000000000000004,"y":0,"rotation":0,"id":24,"uid":null,"width":115.19999999999999,"height":14,"lockAspectRatio":false,"lockShape":false,"order":"auto","graphic":{"type":"Text","Text":{"tid":null,"valign":"middle","overflow":"none","vposition":"none","hposition":"none","html":"解协议
","paddingLeft":2,"paddingRight":2,"paddingBottom":2,"paddingTop":2}},"children":null}],"linkMap":[]},{"x":120,"y":20,"rotation":0,"id":19,"uid":"com.gliffy.shape.flowchart.flowchart_v1.default.process","width":120,"height":40,"lockAspectRatio":false,"lockShape":false,"order":0,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2,"strokeColor":"#333333","fillColor":"#45818e","gradient":false,"dropShadow":false,"state":0,"shadowX":0,"shadowY":0,"opacity":1}},"children":[{"x":2.3999999999999995,"y":0,"rotation":0,"id":21,"uid":null,"width":115.19999999999993,"height":14,"lockAspectRatio":false,"lockShape":false,"order":"auto","graphic":{"type":"Text","Text":{"tid":null,"valign":"middle","overflow":"none","vposition":"none","hposition":"none","html":"网络数据
","paddingLeft":2,"paddingRight":2,"paddingBottom":2,"paddingTop":2}},"children":null}],"linkMap":[]}],"background":"#FFFFFF","width":340.5,"height":698,"maxWidth":5000,"maxHeight":5000,"nodeIndex":72,"autoFit":true,"exportBorder":false,"gridOn":true,"snapToGrid":true,"drawingGuidesOn":true,"pageBreaksOn":false,"printGridOn":false,"printPaper":"LETTER","printShrinkToFit":false,"printPortrait":true,"shapeStyles":{"com.gliffy.shape.network.network_v3.home":{"fill":"#003366"},"com.gliffy.shape.flowchart.flowchart_v1.default":{"fill":"#f9cb9c","stroke":"#333333","strokeWidth":2}},"lineStyles":{"global":{"endArrow":2,"orthoMode":0}},"textStyles":{},"themeData":null}} \ No newline at end of file diff --git "a/AudioVideo/image/\350\247\206\351\242\221\350\247\243\347\240\201\346\222\255\346\224\276\346\265\201\347\250\213.jpg" "b/AudioVideo/image/\350\247\206\351\242\221\350\247\243\347\240\201\346\222\255\346\224\276\346\265\201\347\250\213.jpg" new file mode 100644 index 00000000..25f9b820 Binary files /dev/null and "b/AudioVideo/image/\350\247\206\351\242\221\350\247\243\347\240\201\346\222\255\346\224\276\346\265\201\347\250\213.jpg" differ diff --git "a/AudioVideo/\345\270\270\350\247\201\345\260\201\350\243\205\346\240\274\345\274\217.md" "b/AudioVideo/\345\270\270\350\247\201\345\260\201\350\243\205\346\240\274\345\274\217.md" new file mode 100644 index 00000000..5dcf80b8 --- /dev/null +++ "b/AudioVideo/\345\270\270\350\247\201\345\260\201\350\243\205\346\240\274\345\274\217.md" @@ -0,0 +1,28 @@ +## 常见封装格式 + +封装格式的主要作用是把视频码流和音频码流按照一定的格式存储在一个文件中。现如今流行的封装格式如下表所示： + +主要封装格式一览 + +| 名称 | 推出机构 | 流媒体 | 支持的视频编码 | 支持的音频编码 | 目前使用领域 | +| ---- | ------------------ | ---- | ----------------------------- | ------------------------------------ | --------- | +| AVI | Microsoft Inc. | 不支持 | 几乎所有格式 | 几乎所有格式 | BT下载影视 | +| MP4 | MPEG | 支持 | MPEG-2, MPEG-4, H.264, H.263等 | AAC, MPEG-1 Layers I, II, III, AC-3等 | 互联网视频网站 | +| TS | MPEG | 支持 | MPEG-1, MPEG-2, MPEG-4, H.264 | MPEG-1 Layers I, II, III, AAC, | IPTV，数字电视 | +| FLV | Adobe Inc. | 支持 | Sorenson, VP6, H.264 | MP3, ADPCM, Linear PCM, AAC等 | 互联网视频网站 | +| MKV | CoreCodec Inc. | 支持 | 几乎所有格式 | 几乎所有格式 | 互联网视频网站 | +| RMVB | Real Networks Inc. | 支持 | RealVideo 8, 9, 10 | AAC, Cook Codec, RealAudio Lossless | BT下载影视 | + +由表可见，除了AVI之外，其他封装格式都支持流媒体，即可以“边下边播”。有些格式更“万能”一些，支持的视音频编码标准多一些，比如MKV。而有些格式则支持的相对比较少，比如说RMVB。 + +这些封装格式都有相关的文档，在这里就不一一例举了。 + +我自己也做过辅助学习的小项目： + +[TS封装格式分析器](http://blog.csdn.net/leixiaohua1020/article/details/17973587) + +[FLV封装格式分析器](http://blog.csdn.net/leixiaohua1020/article/details/17934487) + +### 参考资料： + +[视音频编解码技术零基础学习方法](http://blog.csdn.net/leixiaohua1020/article/details/18893769) \ No newline at end of file diff --git "a/AudioVideo/\345\270\270\350\247\201\345\260\201\350\243\205\346\240\274\345\274\217\346\246\202\350\247\210.md" "b/AudioVideo/\345\270\270\350\247\201\345\260\201\350\243\205\346\240\274\345\274\217\346\246\202\350\247\210.md" new file mode 100644 index 00000000..98f1e818 --- /dev/null +++ "b/AudioVideo/\345\270\270\350\247\201\345\260\201\350\243\205\346\240\274\345\274\217\346\246\202\350\247\210.md" @@ -0,0 +1,14 @@ +## 常见封装格式概览 + +| 名称 | 推出机构 | 流媒体 | 支持的视频编码 | 支持的音频编码 | 目前使用领域 | +| ---- | ------------------ | ---- | ----------------------------- | ------------------------------------ | --------- | +| AVI | Microsoft Inc. | 不支持 | 几乎所有格式 | 几乎所有格式 | BT下载影视 | +| MP4 | MPEG | 支持 | MPEG-2, MPEG-4, H.264, H.263等 | AAC, MPEG-1 Layers I, II, III, AC-3等 | 互联网视频网站 | +| TS | MPEG | 支持 | MPEG-1, MPEG-2, MPEG-4, H.264 | MPEG-1 Layers I, II, III, AAC, | IPTV，数字电视 | +| FLV | Adobe Inc. | 支持 | Sorenson, VP6, H.264 | MP3, ADPCM, Linear PCM, AAC等 | 互联网视频网站 | +| MKV | CoreCodec Inc. | 支持 | 几乎所有格式 | 几乎所有格式 | 互联网视频网站 | +| RMVB | Real Networks Inc. | 支持 | RealVideo 8, 9, 10 | AAC, Cook Codec, RealAudio Lossless | BT下载影视 | + +### 参考资料： + +[视音频编解码技术零基础学习方法](http://blog.csdn.net/leixiaohua1020/article/details/18893769) \ No newline at end of file diff --git "a/AudioVideo/\345\270\270\350\247\201\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256.md" "b/AudioVideo/\345\270\270\350\247\201\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256.md" new file mode 100644 index 00000000..7cb5b7a2 --- /dev/null +++ "b/AudioVideo/\345\270\270\350\247\201\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256.md" @@ -0,0 +1,33 @@ +## 常见流媒体协议 + +流媒体协议是服务器与客户端之间通信遵循的规定。当前网络上主要的流媒体协议如表所示。 + +| 名称 | 推出机构 | 传输层协议 | 客户端 | 目前使用领域 | +| -------- | -------------- | ------- | -------- | -------- | +| RTSP+RTP | IETF | TCP+UDP | VLC, WMP | IPTV | +| RTMP | Adobe Inc. | TCP | Flash | 互联网直播 | +| RTMFP | Adobe Inc. | UDP | Flash | 互联网直播 | +| MMS | Microsoft Inc. | TCP/UDP | WMP | 互联网直播+点播 | +| HTTP | WWW+IETF | TCP | Flash | 互联网点播 | + +RTSP+RTP经常用于IPTV领域。因为其采用UDP传输视音频，支持组播，效率较高。但其缺点是网络不好的情况下可能会丢包，影响视频观看质量。因而围绕IPTV的视频质量的研究还是挺多的。 + +RTSP规范可参考：[RTSP协议学习笔记](http://blog.csdn.net/leixiaohua1020/article/details/11955341) + +RTSP+RTP系统中衡量服务质量可参考：[网络视频传输的服务质量（QoS）](http://blog.csdn.net/leixiaohua1020/article/details/11883393) + +上海IPTV码流分析结果可参考：[IPTV视频码流分析](http://blog.csdn.net/leixiaohua1020/article/details/11846761) + +因为互联网网络环境的不稳定性，RTSP+RTP较少用于互联网视音频传输。互联网视频服务通常采用TCP作为其流媒体的传输层协议，因而像RTMP，MMS，HTTP这类的协议广泛用于互联网视音频服务之中。这类协议不会发生丢包，因而保证了视频的质量，但是传输的效率会相对低一些。 + +此外RTMFP是一种比较新的流媒体协议，特点是支持P2P。 + +RTMP我做的研究相对多一些：比如[RTMP规范简单分析](http://blog.csdn.net/leixiaohua1020/article/details/11694129)，或者[RTMP流媒体播放过程](http://blog.csdn.net/leixiaohua1020/article/details/11704355) + +相关工具的源代码分析：[RTMPdump源代码分析 1： main()函数[系列文章\]](http://blog.csdn.net/leixiaohua1020/article/details/12952977) + +RTMP协议学习：[RTMP流媒体技术零基础学习方法](http://blog.csdn.net/leixiaohua1020/article/details/15814587) + +### 参考资料： + +[视音频编解码技术零基础学习方法](http://blog.csdn.net/leixiaohua1020/article/details/18893769) \ No newline at end of file diff --git "a/AudioVideo/\345\270\270\350\247\201\351\237\263\350\247\206\351\242\221\347\274\226\347\240\201.md" "b/AudioVideo/\345\270\270\350\247\201\351\237\263\350\247\206\351\242\221\347\274\226\347\240\201.md" new file mode 100644 index 00000000..524415e3 --- /dev/null +++ "b/AudioVideo/\345\270\270\350\247\201\351\237\263\350\247\206\351\242\221\347\274\226\347\240\201.md" @@ -0,0 +1,110 @@ +## 常见音视频编码 + +### 1. 视频编码 + +视频编码的主要作用是将视频像素数据（RGB，YUV等）压缩成为视频码流，从而降低视频的数据量。如果视频不经过压缩编码的话，体积通常是非常大的，一部电影可能就要上百G的空间。视频编码是视音频技术中最重要的技术之一。视频码流的数据量占了视音频总数据量的绝大部分。高效率的视频编码在同等的码率下，可以获得更高的视频质量。 + +视频编码的简单原理可以参考：[视频压缩编码和音频压缩编码的基本原理](http://blog.csdn.net/leixiaohua1020/article/details/28114081) + +注：视频编码技术在整个视音频技术中应该是最复杂的技术。如果没有基础的话，可以先买一些书看一下原理，比如说《现代电视原理》《数字电视广播原理与应用》（本科的课本）中的部分章节。 + +主要视频编码一览 + +| 名称 | 推出机构 | 推出时间 | 目前使用领域 | +| ----------- | -------------- | ---- | ------ | +| HEVC(H.265) | MPEG/ITU-T | 2013 | 研发中 | +| H.264 | MPEG/ITU-T | 2003 | 各个领域 | +| MPEG4 | MPEG | 2001 | 不温不火 | +| MPEG2 | MPEG | 1994 | 数字电视 | +| VP9 | Google | 2013 | 研发中 | +| VP8 | Google | 2008 | 不普及 | +| VC-1 | Microsoft Inc. | 2006 | 微软平台 | + +由表可见，有两种视频编码方案是最新推出的：VP9和HEVC。目前这两种方案都处于研发阶段，还没有到达实用的程度。当前使用最多的视频编码方案就是H.264。 + +#### **1.1 主流编码标准** + +H.264仅仅是一个编码标准，而不是一个具体的编码器，H.264只是给编码器的实现提供参照用的。 + +基于H.264标准的编码器还是很多的，究竟孰优孰劣？可参考：[MSU出品的 H.264编码器比较（2011.5）](http://blog.csdn.net/leixiaohua1020/article/details/12373947) + +在学习视频编码的时候，可能会用到各种编码器（实际上就是一个exe文件），他们常用的编码命令可以参考：[各种视频编码器的命令行格式](http://blog.csdn.net/leixiaohua1020/article/details/11705495) + +学习H.264最标准的源代码，就是其官方标准JM了。但是要注意，JM速度非常的慢，是无法用于实际的：[H.264参考软件JM12.2RC代码详细流程](http://blog.csdn.net/leixiaohua1020/article/details/11980219) + +实际中使用最多的就是x264了，性能强悍（超过了很多商业编码器），而且开源。其基本教程网上极多，不再赘述。编码时候可参考：[x264编码指南——码率控制](http://blog.csdn.net/leixiaohua1020/article/details/12720135)。编码后统计值的含义：[X264输出的统计值的含义（X264 Stats Output）](http://blog.csdn.net/leixiaohua1020/article/details/11884559) + +Google推出的VP8属于和H.264同一时代的标准。总体而言，VP8比H.264要稍微差一点。有一篇写的很好的VP8的介绍文章：[深入了解 VP8](http://blog.csdn.net/leixiaohua1020/article/details/12760173)。除了在技术领域，VP8和H.264在专利等方面也是打的不可开交，可参考文章：[WebM(VP8) vs H.264](http://blog.csdn.net/leixiaohua1020/article/details/12720237) + +此外，我国还推出了自己的国产标准AVS，性能也不错，但目前比H.264还是要稍微逊色一点。不过感觉我国在视频编解码领域还算比较先进的，可参考：[视频编码国家标准AVS与H.264的比较（节选）](http://blog.csdn.net/leixiaohua1020/article/details/12851745) + +近期又推出了AVS新一代的版本AVS+，具体的性能测试还没看过。不过据说AVS+得到了国家政策上非常强力的支持。 + +#### **1.2 下一代编码标准** + +下一代的编解码标准就要数HEVC和VP9了。VP9是Google继VP8之后推出的新一代标准。VP9和HEVC相比，要稍微逊色一些。它们的对比可参考：（1）[HEVC与VP9编码效率对比](http://blog.csdn.net/leixiaohua1020/article/details/11713041) （2）[HEVC，VP9，x264性能对比](http://blog.csdn.net/leixiaohua1020/article/details/19014955) + +HEVC在未来拥有很多大的优势，可参考：[HEVC将会取代H.264的原因](http://blog.csdn.net/leixiaohua1020/article/details/11844949) + +学习HEVC最标准的源代码，就是其官方标准HM了。其速度比H.264的官方标准代码又慢了一大截，使用可参考：[HEVC学习—— HM的使用](http://blog.csdn.net/leixiaohua1020/article/details/12759297) + +未来实际使用的HEVC开源编码器很有可能是x265，目前该项目还处于发展阶段，可参考：[x265(HEVC编码器，基于x264)](http://blog.csdn.net/leixiaohua1020/article/details/13991351)[介绍](http://blog.csdn.net/leixiaohua1020/article/details/13991351)。x265的使用可以参考：[HEVC（H.265）标准的编码器（x265，DivX265）试用](http://blog.csdn.net/leixiaohua1020/article/details/18861635) + +主流以及下一代编码标准之间的比较可以参考文章：[视频编码方案之间的比较（HEVC，H.264，MPEG2等）](http://blog.csdn.net/leixiaohua1020/article/details/12237177) + +此外，在码率一定的情况下，几种编码标准的比较可参考：[限制码率的视频编码标准比较（包括MPEG-2，H.263，MPEG-4，以及 H.264）](http://blog.csdn.net/leixiaohua1020/article/details/12851975) + +结果大致是这样的： + +HEVC > VP9 > H.264> VP8 > MPEG4 > H.263 > MPEG2。 + +截了一些图，可以比较直观的了解各种编码标准： + +HEVC码流简析：[HEVC码流简单分析](http://blog.csdn.net/leixiaohua1020/article/details/11845069) + +H.264码流简析：[H.264简单码流分析](http://blog.csdn.net/leixiaohua1020/article/details/11845625) + +MPEG2码流简析：[MPEG2简单码流分析](http://blog.csdn.net/leixiaohua1020/article/details/11846185) + +以上简析使用的工具：[视频码流分析工具](http://blog.csdn.net/leixiaohua1020/article/details/11845435) + +我自己做的小工具： [H.264码流分析器](http://blog.csdn.net/leixiaohua1020/article/details/17933821) + +### 2. 音频编码 + +音频编码的主要作用是将音频采样数据（PCM等）压缩成为音频码流，从而降低音频的数据量。音频编码也是互联网视音频技术中一个重要的技术。但是一般情况下音频的数据量要远小于视频的数据量，因而即使使用稍微落后的音频编码标准，而导致音频数据量有所增加，也不会对视音频的总数据量产生太大的影响。高效率的音频编码在同等的码率下，可以获得更高的音质。 + +音频编码的简单原理可以参考：[视频压缩编码和音频压缩编码的基本原理](http://blog.csdn.net/leixiaohua1020/article/details/28114081) + +主要音频编码一览 + +| 名称 | 推出机构 | 推出时间 | 目前使用领域 | +| ---- | -------------- | ---- | ------- | +| AAC | MPEG | 1997 | 各个领域（新） | +| AC-3 | Dolby Inc. | 1992 | 电影 | +| MP3 | MPEG | 1993 | 各个领域（旧） | +| WMA | Microsoft Inc. | 1999 | 微软平台 | + +由表可见，近年来并未推出全新的音频编码方案，可见音频编码技术已经基本可以满足人们的需要。音频编码技术近期绝大部分的改动都是在MP3的继任者——AAC的基础上完成的。 + +这些编码标准之间的比较可以参考文章：[音频编码方案之间音质比较（AAC，MP3，WMA等）](http://blog.csdn.net/leixiaohua1020/article/details/11730661) + +结果大致是这样的： + +AAC+ > MP3PRO > AAC> RealAudio > WMA > MP3 + +AAC格式的介绍：[AAC格式简介](http://blog.csdn.net/leixiaohua1020/article/details/11822537) + +AAC几种不同版本之间的对比：[AAC规格（LC，HE，HEv2）及性能对比](http://blog.csdn.net/leixiaohua1020/article/details/11971419) + +AAC专利方面的介绍：[AAC专利介绍](http://blog.csdn.net/leixiaohua1020/article/details/11854587) + +此外杜比数字的编码标准也比较流行，但是貌似比最新的AAC稍为逊色：[AC-3技术综述](http://blog.csdn.net/leixiaohua1020/article/details/11822737) + +我自己做的小工具：[ AAC格式分析器](http://blog.csdn.net/leixiaohua1020/article/details/18155549) + + + +### 参考资料： + +[视音频编解码技术零基础学习方法](http://blog.csdn.net/leixiaohua1020/article/details/18893769) \ No newline at end of file diff --git "a/AudioVideo/\351\200\232\347\224\250\350\247\206\351\242\221\350\247\243\347\240\201\346\222\255\346\224\276\346\265\201\347\250\213.md" "b/AudioVideo/\351\200\232\347\224\250\350\247\206\351\242\221\350\247\243\347\240\201\346\222\255\346\224\276\346\265\201\347\250\213.md" new file mode 100644 index 00000000..6f35f5d3 --- /dev/null +++ "b/AudioVideo/\351\200\232\347\224\250\350\247\206\351\242\221\350\247\243\347\240\201\346\222\255\346\224\276\346\265\201\347\250\213.md" @@ -0,0 +1,18 @@ +--- +typora-copy-images-to: ./image +--- + +## 通用视频解码播放流程 + +**通用的网络视频播放流程:** + +1. 从网络数据流中获得视频数据流。 +2. 将视频数据流解析成压缩音频数据和压缩视频数据。 +3. 分别对音频和视频解码获取原始(采样)数据。 +4. 经过同步策略后，有序的将原始(采样)数据输出到指定设备播放。 + + + +### 参考资料： + +[视音频编解码技术零基础学习方法](http://blog.csdn.net/leixiaohua1020/article/details/18893769) \ No newline at end of file diff --git "a/ChaosCrystal/ADB\345\270\270\347\224\250\345\221\275\344\273\244.md" "b/ChaosCrystal/ADB\345\270\270\347\224\250\345\221\275\344\273\244.md" new file mode 100644 index 00000000..bdab36c6 --- /dev/null +++ "b/ChaosCrystal/ADB\345\270\270\347\224\250\345\221\275\344\273\244.md" @@ -0,0 +1,18 @@ +# ADB常用命令 + +命令 | 说明 +--------------------------------|----------------------------------------------------- +adb start-server | 启动服务 +adb kill-server | 关闭服务 +adb devices | 显示当前连接的所有设备（如果服务没有开启会自动开启） +adb install xxx.apk | 将应用安装进设备中 +adb uninstall <包名> | 卸载应用 +adb -s <设备名> <命令> | 如果有多个设备，指定某一个设备进行操作 +adb pull <手机文件> <电脑文件> | 将手机内文件导入到电脑上(文件名均为全称) +adb push <电脑文件> <手机文件> | 将电脑中文件推送到手机上(文件名均为全称) +adb shell | 进入手机命令行终端 + ┗ ls | 查看目录列表 + ┗ ls -l | 显示详细信息(权限 用户名 组名 时间 包名) + ┗ ps | 当前正在运行的进程 + ┗ ping | 手机的网络连通性 + diff --git "a/ChaosCrystal/AndroidStudio\345\270\270\347\224\250\345\277\253\346\215\267\351\224\256(Mac).md" "b/ChaosCrystal/AndroidStudio\345\270\270\347\224\250\345\277\253\346\215\267\351\224\256(Mac).md" new file mode 100644 index 00000000..61910c5f --- /dev/null +++ "b/ChaosCrystal/AndroidStudio\345\270\270\347\224\250\345\277\253\346\215\267\351\224\256(Mac).md" @@ -0,0 +1,31 @@ +# AndroidStudio常用快捷键(Mac) + +这里的快捷键是基于OSX个人定制版本的，具体请到 setting -> keymap 设置 + +快捷键 | 作用 +----------------------------|----------------------------------------------- +Option + Enter | 自动修正 +Command + N | 自动生成代码(Getter Setter) +Command ＋ Alt ＋ L | 格式化代码 +Contral ＋ Shift + F | 格式化代码(定制) +Command ＋ Alt ＋ T | 把选中的代码放在 try{} 、if{} 、 else{} 里 +Command ＋ / | 注释 // +Command ＋ Shift ＋ / | 注释 /* */ +Command ＋ Shift ＋ Up/Down | 语句上下移动 +Option ＋ Shift ＋ Up/Down | 内容上下移动 +Option + Command + M | 将选中代码块封装成一个方法 +Command + D | 复制当前一行(或选择区域)，并粘贴到下面 +Command + Z | 后退 +Command + Shift + Z | 前进 +Control + Alt + O | 优化导入的包 +Ctrl(Command)+ - / + | 折叠/展开代码 +Ctrl(Command)+Shift+ - / + | 折叠/展开全部代码 +Ctrl(Command)+Shift+. | 折叠/展开当前花括号中的代码 +Command + Y | 快速查看代码实现 +Contral + H | 查看继承关系 +Contral + Alt + H | 查看调用关系 +Command + [ | 返回上一次查看的位置 +Command + ] | 前进到返回之前查看的位置 +Command + J | 自动生成代码 +Command + E | 查看最近打开的文件 + diff --git "a/ChaosCrystal/Android\344\270\255dip\343\200\201dp\343\200\201sp\343\200\201pt\345\222\214px.md" "b/ChaosCrystal/Android\344\270\255dip\343\200\201dp\343\200\201sp\343\200\201pt\345\222\214px.md" new file mode 100644 index 00000000..67f1ff94 --- /dev/null +++ "b/ChaosCrystal/Android\344\270\255dip\343\200\201dp\343\200\201sp\343\200\201pt\345\222\214px.md" @@ -0,0 +1,81 @@ +# Android中dip、dp、sp、pt和px + +概念区别： + +单位 | 含义 +--- | --- +dip | device independent pixels(设备独立像素). 不同设备有不同的显示效果,这个和设备硬件有关，一般我们为了支持WVGA、HVGA和QVGA **推荐使用这个，不依赖像素**。 +dp | 同上，和dip一样。 +px | pixels(像素). 不同设备显示效果相同，一般我们HVGA代表320x480像素。 +sp | scaled pixels(放大像素). 主要用于字体显示best for textsize。 +pt | point，是一个标准的长度单位，1pt＝1/72英寸，用于印刷业，非常简单易用。 +in | （英寸）：长度单位。 +mm | （毫米）：长度单位。 + +## 工具包 + +在 [ViewSupport](https://github.com/GcsSloop/ViewSupport) 支持包中可以找到该工具。 + +## 单位转换代码： +``` java +/** + * dp、sp 转换为 px 的工具类 + * + * @author fxsky 2012.11.12 + * + */ +public class DisplayUtil { + /** + * 将px值转换为dip或dp值，保证尺寸大小不变 + * + * @param pxValue + * @param scale + * （DisplayMetrics类中属性density） + * @return + */ + public static int px2dip(Context context, float pxValue) { + final float scale = context.getResources().getDisplayMetrics().density; + return (int) (pxValue / scale + 0.5f); + } + + /** + * 将dip或dp值转换为px值，保证尺寸大小不变 + * + * @param dipValue + * @param scale + * （DisplayMetrics类中属性density） + * @return + */ + public static int dip2px(Context context, float dipValue) { + final float scale = context.getResources().getDisplayMetrics().density; + return (int) (dipValue * scale + 0.5f); + } + + /** + * 将px值转换为sp值，保证文字大小不变 + * + * @param pxValue + * @param fontScale + * （DisplayMetrics类中属性scaledDensity） + * @return + */ + public static int px2sp(Context context, float pxValue) { + final float fontScale = context.getResources().getDisplayMetrics().scaledDensity; + return (int) (pxValue / fontScale + 0.5f); + } + + /** + * 将sp值转换为px值，保证文字大小不变 + * + * @param spValue + * @param fontScale + * （DisplayMetrics类中属性scaledDensity） + * @return + */ + public static int sp2px(Context context, float spValue) { + final float fontScale = context.getResources().getDisplayMetrics().scaledDensity; + return (int) (spValue * fontScale + 0.5f); + } +} +``` + diff --git a/ChaosCrystal/HowToViewAPISourceOnline.md b/ChaosCrystal/HowToViewAPISourceOnline.md new file mode 100644 index 00000000..b0e07bc7 --- /dev/null +++ b/ChaosCrystal/HowToViewAPISourceOnline.md @@ -0,0 +1,12 @@ +# 在线查看Android API源码的方法 + + +方法 | 推荐程度| 链接 | 备注 +---|---|---|--- +官方GitHub仓库 | ★☆☆☆☆ | [GitHub-Android](https://github.com/android) | 搜索不方便 +通过GrepCode | ★★★☆☆ | [GrepCode-Android](http://grepcode.com/project/repository.grepcode.com/java/ext/com.google.android/android/) | 有搜索功能,可以在线查看到各个版本的源码，也可以下载 +通过Chrome插件 | ★★★★★ | [插件:SDKSearch](https://chrome.google.com/webstore/detail/android-sdk-search/hgcbffeicehlpmgmnhnkjbjoldkfhoin)
+
+
+
diff --git a/Course/HowToUsePlantUMLInAS[Mac].md b/Course/HowToUsePlantUMLInAS[Mac].md
new file mode 100644
index 00000000..946389d3
--- /dev/null
+++ b/Course/HowToUsePlantUMLInAS[Mac].md
@@ -0,0 +1,78 @@
+# 在AndroidStudio中使用PlantUML(Mac)
+
+### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
+
+## 前言
+
+### 这是Mac平台设置教程，Windows平台戳这里：[在AndroidStudio中使用PlantUML(Windows)](https://github.com/GcsSloop/AndroidNote/blob/master/Course/HowToUsePlantUMLInAS.md)
+
+**Unified Modeling Language (UML)又称统一建模语言或标准建模语言，用来描述 类（对象的）、对象、关联、职责、行为、接口、用例、包、顺序、协作，以及状态。是用来帮助自己理清众多类之间复杂关系的不二利器，也能帮助别人快速理解你的设计思路。**
+
+那么，我们怎么在AndroidStudio中创建自己的UML类图呢？接下来我就教大家如何用正确的姿势创建UML类图。
+
+## 一.用正确的姿势安装panltUML插件
+### 1.File->Settings->Plugins->Browse repositories
+
+### 2.在搜索框输入plantUML
+
+### 3.导入插件
+#### (ps：由于我已经安装过了，所以没有Install plugin 按钮，未安装的都有这样一个按钮，如下，点击安装即可。)
+
+
+#### 如果以上步骤正确的完成，重启AndroidStudio 右键->new 的时候你会发现多了这么一堆东西，如果出现了这些说明plantUML已经正确的安装了。
+
+
+#### 当然了，所有事情都不会是一帆风顺的，当你迫不及待的想创建一个文件试试的时候你会发现下面的情况。
+
+#### 想必此时你的内心一定和我当时一样，一万头草泥马奔腾而过，这都是什么东西！！！
+#### 一切事情都是有原因的，而这个因为你还缺少一个必要的东西，就是大名鼎鼎的贝尔实验室开发的一个工具包：Graphviz。
+## 二，用正确的姿势安装Graphviz
+
+此处建议使用Homebrew自动下载安装，如果你还没有用过Homebrew来帮助你管理软件，参考这里: [Homebrew&HomebrewCask](https://github.com/GcsSloop/MacDeveloper/blob/master/Tools/Homebrew.md)
+
+安装好homebrew后直接输入如下命令，按下回车后等待片刻即可安装成功:
+
+```
+brew install graphviz
+```
+
+安装完成后，Homebrew会告诉你安装位置，请记好这个位置，你也可以用info命名查看安装位置:
+
+```
+brew info graphviz
+```
+
+我的安装位置在 `/usr/local/Cellar/graphviz/2.38.0`
+
+
+
+
+## 三.用正确的姿势设置plantUML
+
+### 1.点击右上角的设置按钮或进入File->Settings->Other Settings ->PlantUML或者在预览页面点击右上角的设置图标,如下:
+
+### 2.将文件路径填写为刚刚Graphviz的目录下bin目录中dot文件。
+
+#### (我的为：/usr/local/Cellar/graphviz/2.38.0/bin/dot)
+
+
+
+
+### 3.点击OK 刷新一下界面就能看到结果了。
+
+#### 讲到这里，就已经安装完成了，可以愉快的用代码来书写UML图了。
+
+#### 什么？你说你还不会书写的语法？没关系，其实我也不会，不过我有一个好的教程推荐给你，相信你看完就明白啦。
+
+## 四.用正确的姿势学习使用UML
+### 1.[【PlantUML快速指南戳这里】](http://archive.3zso.com/archives/plantuml-quickstart.html)
+### 2.注意，这个教程中的语法和AndroidStudio中基本一致，区别就是开始和结束标志不同。
+
+####好了，到这里该教程正式结束，祝各位小伙伴能愉快的使用plantUML玩耍。
+
+## About Me
+### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
+
+
+
+
diff --git a/Course/Markdown/README.md b/Course/Markdown/README.md
new file mode 100644
index 00000000..a35826e3
--- /dev/null
+++ b/Course/Markdown/README.md
@@ -0,0 +1,6 @@
+# Markdown 实用技巧
+
+* [Markdown 快速入门](https://github.com/GcsSloop/AndroidNote/blob/master/Course/Markdown/markdown-start.md)
+* [Markdown 基础语法](https://github.com/GcsSloop/AndroidNote/blob/master/Course/Markdown/markdown-grammar.md)
+* [Markdown 链接图片](https://github.com/GcsSloop/AndroidNote/blob/master/Course/Markdown/markdown-link.md)
+* [Markdown 编辑器](https://github.com/GcsSloop/AndroidNote/blob/master/Course/Markdown/markdown-editor.md)
diff --git a/Course/Markdown/markdown-editor.md b/Course/Markdown/markdown-editor.md
new file mode 100644
index 00000000..85eb6aae
--- /dev/null
+++ b/Course/Markdown/markdown-editor.md
@@ -0,0 +1,120 @@
+# Markdown实用技巧－编辑器(Typora)
+
+本次的安利对象是一个 Markdown 编辑器，是会长见过的最简单，最优雅的编辑器，先来看一下它的界面吧：
+
+
+
+
+
+它的界面非常简单，有多种主题可选，更重要的是**它的预览界面和编辑界面是一体的，而不像其他编辑器那样是左右分开的。**
+
+
+
+从上面的示例中可以看出，其输入模式支持多种，不论是手动输入语法还是使用快捷键，都非常的流畅，实时看到效果变化，除此之外 Typora 还有很多优点。
+
+## Typora 的优点
+
+* 预览和编辑界面一体。
+* 强大的快捷键。
+* 兼容常见扩展语法。
+* 兼容 HTML (新版进行了完善)。
+* 支持 YAML 格式。
+* 支持公式编辑(LaTeX公式)。
+* 表格和代码块编辑起来非常方便。
+* 支持本地图片相对链接。
+* 支持将本地图片拖进编辑页面。
+* 支持多种导出格式(PDF，HTML，Word，LaTeX 等)。
+* 有多种主题可选。
+
+虽然上面的内容在其他编辑器上也可以见到，但做到这么完善的并不多，想要尝试的小伙伴赶紧来试试吧，相信你也会爱上它的。
+
+#### [点击这里进入 Typora 官网](http://www.typora.io/)
+
+既然 Typora 这么好，为什么不在一开始就推荐呢，这是因为在 Markdown 系列文章第一篇发布的时候，Typora 还有一些小瑕疵(HTML语法兼容部分)让会长不满意，所以只是放在了推荐首位，在最近更新了新版本之后，这一部分已经修复完善了，基本算是完美了，所以会长我才特地写一篇文章来推荐。
+
+**Typora 支持在 WIndows，Linux，和 Mac 上使用，如果你正在使用的是 Mac 的话，那么恭喜你，除了上述的优点，你可以用到一些 Mac 系统才有的福利。**
+
+## 版本回溯功能
+
+这是 Mac 系统提供的一个小功能，使用 Mac 的时候你可能会注意到一个小细节，**使用系统文本编辑器进行编辑文本的时候，从来不会提示你保存文本，即便编辑后不点保存立即退出里面的内容也不会丢失。**你可能会觉得这不就是一个自动保存功能么，有啥稀奇的？
+
+那么你是否遇到过这一种情况，编辑了半天的内容觉得不太好想放弃保存，继续使用之前的内容，这在Windows上很容易实现，只要编辑的时候没有手动保存，直接点击关闭不保存，再打开的时候就是编辑之前的内容。
+
+然而在 Mac 上自动保存了，如果关闭后再打开，点 `Command + Z` 也没用了，这不就尴尬了，难道说遇到这种情况只能关闭前狂点 `Command + Z` 回退？
+
+作为一个有情怀的操作系统，自然不会意识不到这个问题，它提供了更强大的方法，那就是版本回溯，相当于一个自动的 Git 系统，这就厉害了。
+
+Trpora 也用到了这一特性，点击 `File > Revert To > Browse All Versions` 就能看到了。以我之前发布的一篇文章为例：
+
+
+
+ **上图中左边为当前版本，右边为选中版本，最右侧是时间线，使用这一功能可以将文章回溯到任意时间点，妈妈再也不怕我的文章内容丢失啦，也成功避免了以下这种情况 ▼**
+
+
+
+由于这一功能是 Mac 系统提供的，所以不仅对纯文本有效，对 iWork 也是有效的，iWork 上面也有版本回溯功能，像 key，numbers，pages 都支持版本回溯，中文版点 `文件 > 复原 > 浏览所有版本` 即可看到过去保存的数据。
+
+当然了，这只是福利之一。
+
+## 更便捷的图片插入和上传方式
+
+众所周知，Markdown 插入图片是一个大问题，尤其是在本地编辑的时候，但是这些在遇到 Typora 后就变的越来越简单了。
+
+**对于本地图片，我们可以直接拖进来，再也不用记复杂的语法和查图片地址了，没错，只要拖进来就行，Typora 会自动识别图片并进行插入。**
+
+不过还有一个问题，我们的很多文章都是要发布的，直接拖进来这种方式在本地看起来没问题，但上传到网站上是读取不到本地图片的，通常解决方案就是先上传到图床上，之后再将链接插入到 Markdown 中，这样发布就没问题了。
+
+但是，当一篇文章需要插入很多图片的时候，一次次的上传，一次次的复制链接，一次次的粘贴，也是很麻烦的，虽然有一些脚本可以通过快捷键进行上传，但终归还是多了一些步骤，很不方便，而且对新手很不友好，更何况很多新手根本不知道图床所谓何物。
+
+这时候就要祭出 Mac 上另一个神器了: iPic [(点击此处进行下载)](https://itunes.apple.com/cn/app/ipic-tu-chuang-shen-qi-zhong/id1101244278?mt=12)，它是一个专业图床管理工具，貌似出来还没多久，目前免费版只能上传到微博图床，专业版支持大部分图床，专业版一年 30RMB，如果经常使用的话，倒也不算贵。
+
+**话说不还是要用图床么？**
+
+**但 Typora 的方便之处就在于可以和 iPic 无缝结合，纯傻瓜式一键操作，能一次性的将文章中所有本地图片上传到图床上。**
+
+**首先安装 iPic，运行 iPic，之后点击 `Edit > Image Tools > Upload Local Images via iPic` 就像下面这样就行了。**
+
+QQ20161202-8](http://ww1.sinaimg.cn/large/006y8lVajw1facuf1yjjkj30fo0dmq4v.jpg)
+
+**如果你觉得这样还是很麻烦的话，还有另外的选项，可以选择插入本地图片的时候自动上传到服务器，当然了，为了保护个人隐私，这一个选项默认是关闭的，首先你要找到首选项，点击 `Typora > Preferences` 或者快捷键 `Command + ,` 都行，之后打开以下两个选项，其中一个选项是后面用到的。**
+
+
+
+**打开之后继续选择 `Edit > Image Tools > When Insert Local Images > Upload Image via iPic` 它的意思是当插入本地图片时自动通过 iPic 上传到服务器上。**
+
+
+
+这种方案虽然方便，但是会长并不推荐大家这么做，主要还是不安全，误操作的话可能会将一些包含个人隐私的照片上传上去。
+
+会长推荐另一种方案，就是 `Copy Image File to Folder`，操作步骤和上面类似，它的意思是插入本地图片时自动归档到某一个文件夹，在文章编辑完成后在点击上传按钮统一上传，这样有以下几点好处：
+
+* 安全，不会因为误操作将涉及隐私照片传到服务器上。
+* 相当于自动建立了一个本地图片档案，方便备份保存。
+* 如果图床上的图片丢失，可以从快速从本地备份中找到并恢复。
+
+
+关于 Typora 的推荐内容暂时就到这里结束啦，更多关于 Typora 的多详情请参阅 [Support](http://support.typora.io/)。关于 Markdown 的更多内容请参见之前的文章:
+
+[Markdown实用技巧－快速入门](https://www.gcssloop.com/markdown/markdown-start)
+[Markdown实用技巧－基础语法](https://www.gcssloop.com/markdown/markdown-grammar)
+[Markdown实用技巧－链接和图片](https://www.gcssloop.com/markdown/markdown-links)
+
+## 结语
+
+最后稍微夹带一点个人建议，个人觉得 Typora 除了界面简洁之外，最大的优点就是快捷键方便了，然而，快捷键那么多，要不要专一去记呢？
+
+个人的建议是不要专一去记忆这些快捷键，用到的时候打开菜单看一眼快捷键是什么，之后用快捷键按出来，这样用过几次之后自然就会记住常用的快捷键，而且会记得很牢固，不然每个应用都有快捷键，一个一个的记多麻烦。
+
+本文中涉及到的两个软件下载地址：
+
+[**Typora**](http://www.typora.io/)
+[**iPic**](https://itunes.apple.com/cn/app/id1101244278?ls=1&mt=12)
+
+**最后留一个课后作业，关注会长的 [新浪微博](http://weibo.com/GcsSloop) 。**
+
+## About Me
+
+### 作者微博: @GcsSloop
+
+
+
diff --git a/Course/Markdown/markdown-grammar.md b/Course/Markdown/markdown-grammar.md
new file mode 100644
index 00000000..a84c9f40
--- /dev/null
+++ b/Course/Markdown/markdown-grammar.md
@@ -0,0 +1,331 @@
+# Markdown 基础语法
+
+为保证语法兼容性，本文只介绍基础语法，扩展语法等其它内容，会在后续的文章中单独介绍。
+**注意：所有的标记符号均使用英文，中文无效。**
+
+****
+
+## 标题
+
+Markdown 支持多种标题格式。
+
+利用 `=` (等号)和 `-`(减号)可以定义一级标题和二级标题，(任何数量的 `=` 和 `-` 都有效果) ：
+
+| Markdown | +预览 | +
|---|---|
| 一级标题 ==== |
+ 一级标题 |
+
| 二级标题 ---- |
+ 二级标题 |
+
| Markdown | +预览 | +
|---|---|
| # 一级标题 | +一级标题 |
+
| ## 二级标题 | +二级标题 |
+
| ### 三级标题 | +三级标题 |
+
| #### 四级标题 | +四级标题 |
+
| ##### 五级标题 | +五级标题 |
+
| ###### 六级标题 | +六级标题 |
+
| Markdown | +预览 | +
|---|---|
|
+ 第一行 + 相邻被视为同一段落。 + |
+
+ + 第一行 相邻被视为同一段落。 + + |
+
|
+ 第一行[空格][空格] + 上一行结尾存在两个空格，段内换行 + |
+
+
+ 第一行 |
+
|
+ 第一行 + + 两行之间存在空行，视为不同段落。 + |
+
+ + 第一行 + ++ 两行之间存在空行，视为不同段落。 + + |
+
| Markdown | +预览 | +
|---|---|
| *倾斜* | ++ 倾斜 + | +
| **粗体** | +粗体 | +
| ~~删除线~~ | +|
| + > 引用 + | +
+ 引用+ |
+
| Markdown | +预览 | +
|---|---|
| [GcsSloop](http://www.gcssloop.com) | +GcsSloop | +
|  | + |
+
| Markdown | +预览 | +
|---|---|
|
+ * 项目 + * 项目 + * 项目 + * 子项目 + * 子项目 + * 项目 + |
+
+
|
+
+
|
+ 1. 项目 + 2. 项目 + 3. 项目 + 1. 子项目 + 2. 子项目 + 4. 项目 + |
+
+
|
+
| Markdown | +预览 | +
|---|---|
|
+ 在一行中用三个以上的星号、减号、下划线来建立一个分隔线 + --- + |
+
+ + |
+
| 可以利用反斜杠(转义字符)来插入一些在语法中有特殊意义的符号 + \*Hi\* + |
+ *Hi* | +
diff --git a/Course/Markdown/markdown-html.md b/Course/Markdown/markdown-html.md
new file mode 100644
index 00000000..ec82fc0f
--- /dev/null
+++ b/Course/Markdown/markdown-html.md
@@ -0,0 +1,3 @@
+# Markdown 网页格式兼容
+
+Markdown 作为一种标记型语言，在大多数情况下都是需要转换为 HTML 格式的，所以 Markdown 理论上是兼容 HTML 语法的，在 Markdown 所提供的标记无法满足我们需要的时候，可以尝试使用 HTML 相关语法来实现。
\ No newline at end of file
diff --git a/Course/Markdown/markdown-link.md b/Course/Markdown/markdown-link.md
new file mode 100644
index 00000000..5c3d40cc
--- /dev/null
+++ b/Course/Markdown/markdown-link.md
@@ -0,0 +1,194 @@
+# Markdown实用技巧－链接和图片
+
+博客地址： http://www.gcssloop.com/markdown/markdown-links
+
+Sloop 喝过半杯咖啡，涨红的脸色渐渐复了原，旁人便又问道，“ Sloop，你当真会写文章么？” Sloop 看着问他的人，显出不屑置辩的神气。他们便接着说道，“你怎的连半个赞也捞不到呢？” Sloop 立刻显出颓唐不安模样，脸上笼上了一层灰色，嘴里说些话；这回可是全是技术名词之类，一些不懂了。在这时候，众人也都哄笑起来：办公室内外充满了快活的空气。
+
+在这些时候，我可以附和着笑，老板是决不责备的。而且老板见了 Sloop，也每每这样问他，引人发笑。Sloop 自己知道不能和他们谈天，便只好向实习生说话。有一回对我说道，“你会用 Markdown 么？” 我略略点一点头。他说，“会用 Markdown，……我便考你一考。Markdown 的链接，你是怎样写的？” 我想，码农一样的人，也配考我么？便回过脸去，不再理会。Sloop 等了许久，很恳切的说道，“不能写罢？……我教给你，记着！这些写法应该记着。将来做程序员的时候，写文档要用。”我暗想我和程序员的等级还很远呢，而且我们这里的程序员也从不写文档；又好笑，又不耐烦，懒懒的答他道，“谁要你教，不是一对方括号后面跟一对圆括号么？” Sloop 显出极高兴的样子，将两个指头的长指甲敲着电脑，点头说，“对呀对呀！……链接有4样基本写法，你知道么？” 我愈不耐烦了，努着嘴走远。Sloop 刚想打开编辑器，给我演示，见我毫不热心，便又叹一口气，显出极惋惜的样子。
+
+*****
+
+## 前言
+
+**本文是适用于对 Markdown 有一定了解的魔法师，以帮助他们挖掘更多关于 Markdown 的可能性，例如：链接的不同类型以及使用方式，如何在新标签页打开链接，如何控制图片大小等，对 Markdown 还不了解的魔法师请参考 [Markdown快速入门][markdown-start] 和 [Markdown基础语法][markdown-grammar] 。**
+
+**注意：以下的部分语法不属于标准语法，存在不兼容的问题，不能保证所有平台都能够使用。对于非标准语法(拓展语法)我会进行标注说明。**
+
+*****
+
+## 行内式链接:
+
+```markdown
+博客地址: [GcsSloop](http://www.gcssloop.com)
+博客地址: [GcsSloop](http://www.gcssloop.com "GcsSloop的博客")
+```
+
+博客地址: [GcsSloop](http://www.gcssloop.com)
+博客地址: [GcsSloop](http://www.gcssloop.com "GcsSloop的博客")
+
+*****
+
+## 参考式链接:
+
+```markdown
+[GcsSloop的博客][gcssloop]
+
+[gcssloop]: http://www.gcssloop.com
+// 或者
+[gcssloop]: http://www.gcssloop.com "点击访问GcsSloop的博客"
+```
+
+[GcsSloop的博客][gcssloop]
+
+**为什么要使用参考式呢？**
+在写文章的时候很可能会在文章不同的地方引用同一篇文章，使用参考式可以少写一点字符。
+更重要的是，参考文章的链接可能会改变，如果将参考链接统一写在文末的话，改起来会更容易。
+
+*****
+
+## 自动链接:
+
+```markdown
+
+```
+
+{:width="300"}
+
+右键，新标签页打开图片，你会发现原图其实挺大的。
+注意: 部分平台可能不识别 `{:width="300" height="100"}` 标签，你正在看的这个 GitHub 依旧不识别。
+
+*****
+
+## 总结:
+
+Markdown 存在很多的变种，对其语法进行了不同程度的拓展，使其更加的强大，但是使用拓展语法之前请三思。个人建议如下：
+
+* 如果文章(文档)只在单一平台发布，使用任何该平台支持的拓展语法都没问题。
+* 如果文章(文档)需要在多个平台发布，尽量使用标准语法，使用拓展语法之前请注意测试平台兼容性。
+* 图片尽量使用图床管理，而且要进行本地备份。
+
+
+*****
+
+## About Me
+
+### 作者微博: @GcsSloop
+
+
+
+## 参考链接：
+
+[Markdown－基础语法](http://www.markdown.cn/)
+[Markdown语法:在新窗口新标签页中打开](http://yinping4256.github.io/cn/Markdown%E8%AF%AD%E6%B3%95%E5%9C%A8%E6%96%B0%E7%AA%97%E5%8F%A3%E6%96%B0%E6%A0%87%E7%AD%BE%E9%A1%B5%E4%B8%AD%E6%89%93%E5%BC%80/)
+
+
+### 注释:
+
+[^1]: GcsSloop：非著名程序员。
+[^2]: 魔法师：会魔法的人类
+
+
+
+
+[markdown-start]: http://www.gcssloop.com/markdown/markdown-star "Markdown实用技巧－快速入门"
+
+[markdown-grammar]: http://www.gcssloop.com/markdown/markdown-grammar "Markdown实用技巧－基础语法"
+
+[gcssloop]: http://www.gcssloop.com "点击访问GcsSloop的博客"
diff --git a/Course/Markdown/markdown-start.md b/Course/Markdown/markdown-start.md
new file mode 100644
index 00000000..ffca84e8
--- /dev/null
+++ b/Course/Markdown/markdown-start.md
@@ -0,0 +1,176 @@
+# Markdown 快速入门
+
+自从接触了 Markdown 之后，就一直用 Markdown 作为自己的主要书写工具，不论是平时做一些简单的纪录，还是用来写博客，写文档都是非常方便。你现在看到的这篇文章就是用 Markdown 进行书写的。
+
+> 我最早因为 GitHub 而了解到 Markdown，当是支持 Markdown 的平台并不多，现在发现很多平台都已经开始支持 Markdown了，不论是老牌的 CSDN 还是比较新的 简书、掘金、DiyCode 等都支持使用Markdown进行写作，借此趋势，赶紧向还不了解 Markdown 的魔法师强势安利一波。
+>
+> **如果你已经开始使用 Markdown了，那么本文作用对你可以能并不大，请看后续文章。**
+
+
+
+****
+
+## 什么是 Markdown ?
+
+**Markdown 是一种轻量级标记语言，创始人为約翰·格魯伯（John Gruber）。 它允许人们“使用易读易写的纯文本格式编写文档，然后转换成有效的XHTML(或者HTML)文档”。**
+
+相比于 HTML (~~How To Make Love~~ 大雾)， **Markdown 更加精简，更加注重内容，其主要宗旨是「易读易写」** 一般 Markdown 最终都是要转换为 HTML 的，可用于书写博客或者网页，但借助某些工具，可以讲 Markdown 转换为 pdf，word，Latex 等其他常见的文件格式。
+
+
+
+****
+
+## 为什么选择 Markdown ?
+
+**选择 Markdown 但理由只有一个：方便，节省时间!**
+
+至于为什么这样说，请看下面内容：
+
+* **语法简洁**，没有任何编程基础的人十几分钟语言即可入门。
+* **注重内容**，专注于内容编写，不再因为格式拍版而苦恼 (word格式刷工具哭晕在厕所)。
+* **易阅读性**，即便是没有经过转换的 Markdown 文件，大部分文字内容仍可阅读。
+* **易编辑性**，任何文本编辑器都能编辑 Markdown 文件。
+* **跨平台性**，任何平台均能打开 Markdown 文件，由于是纯文本文件，不存在格式兼容的问题。
+* **导出方便**，支持导出为 HTML，PDF，Word(.docx)，LaTex 等常见格式(需要工具支持)。
+
+在 Windows 上编写的文档，非常方便的就能在 Mac 上继续编辑，方便数据迁移，降低沟通成本。
+
+
+
+****
+
+## Markdown 存在的问题
+
+前面吹嘘了 Markdown 的那么多优点，下面就说一下其中的不足：
+
+* **图片问题**，很多人都觉得 Markdown 文件插入图片麻烦，还要自己上传找链接。
+* **语法兼容**，基础语法是兼容的，但不同工具(平台)的扩展语法不兼容(由于没有统一标准)。
+* **细节控制**，Markdown只提供最基础的格式，其显示样式主要由CSS控制，很难针对性的控制部分内容。
+
+以上应该是 Markdown 最常见的一些麻烦，不过不必担心，**后续文章会教大家来如何解决这些问题，取其精华，去其糟粕，让 Markdown 运用得心应手**。
+
+****
+
+## Markdown 编辑器推荐
+
+俗话说，工欲善其事，必先利其器，虽然 Markdown 用任何文本编辑器都能打开编辑，但仍需要专业工具进行转化，常见 Markdown 编辑器我基本上都尝试用过，在此简单推荐几种，大家找适合自己的就行。
+
+**仅推荐本地编辑器，在线编辑器根据需要自己选择，很多平台都已经支持直接用 Markdown 进行编辑了。**
+
+| 编辑器 | 支持平台 | 支持导出格式 |
+| ---------------------------------------- | --------------------------- | ---------------------------------------- |
+| [**Typora**](http://www.typora.io/) | Markdown | +预览 | +
|---|---|
| # 一级标题 | +一级标题 |
+
| ## 二级标题 | +二级标题 |
+
| ### 三级标题 | +三级标题 |
+
| Markdown | +预览 | +
|---|---|
|
+ 第一行 + 相邻被视为同一段落。 + |
+
+ + 第一行 相邻被视为同一段落。 + + |
+
|
+ 第一行 + + 两行之间存在空行，视为不同段落。 + |
+
+ + 第一行 + ++ 两行之间存在空行，视为不同段落。 + + |
+
| Markdown | +预览 | +
|---|---|
| [GcsSloop](http://www.gcssloop.com) | +GcsSloop | +
|  | + |
+
+
+[markdown-grammar]: /markdown/markdown-grammar "Markdown实用技巧－语法"
+
+
+
diff --git a/Course/README.md b/Course/README.md
new file mode 100644
index 00000000..d2e3d8c9
--- /dev/null
+++ b/Course/README.md
@@ -0,0 +1,8 @@
+# 教程类
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Course/jitpack-javadoc.md b/Course/jitpack-javadoc.md
new file mode 100644
index 00000000..bf7176dd
--- /dev/null
+++ b/Course/jitpack-javadoc.md
@@ -0,0 +1,103 @@
+# 用JitPack发布时附加文档和源码
+
+很早之前写过一篇[用JitPack发布Android开源库](http://www.gcssloop.com/course/PublishLibraryByJitPack/)的文章，有小伙伴反馈说**发布到JitPack上的开源库没有文档注释，使用起来很不方便**，这是我的失误，上一篇文章只是讲解了如何使用JitPack发布开源库，最终发布的只有arr(即编译好的动态链接库)，不仅没有文档注释(Javadoc)，也没有源码(sources)，本次就教大家如何在发布同时添加上注释和源码。
+
+**由于JitPack本身就是一个自定义Maven仓库，所以配置方式与Maven基本一样。**
+
+
+
+### 配置项目的 build.gradle
+
+项目的 build.gradle 配置和上一篇一样，没有变化。
+
+```java
+buildscript {
+ dependencies {
+ // 重点就是下面这一行(上面两行是为了定位这一行的添加位置)
+ classpath 'com.github.dcendents:android-maven-gradle-plugin:1.3'
+```
+
+
+
+### 配置 Library 的 build.gradle
+
+完整示例(重点内容已经用注释标出):
+
+```java
+apply plugin: 'com.android.library'
+apply plugin: 'com.github.dcendents.android-maven' // 添加这个
+
+group='com.github.GcsSloop' // 指定group，com.github.<用户名>
+
+android {
+ compileSdkVersion 23
+ buildToolsVersion "23.0.3"
+
+ defaultConfig {
+ minSdkVersion 7
+ targetSdkVersion 23
+ versionCode 1
+ versionName "1.0"
+ }
+ buildTypes {
+ release {
+ minifyEnabled false
+ proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+ }
+ }
+}
+
+dependencies {
+ compile fileTree(dir: 'libs', include: ['*.jar'])
+ testCompile 'junit:junit:4.12'
+ compile 'com.android.support:appcompat-v7:23.4.0'
+}
+
+//---------------------------------------------
+
+// 指定编码
+tasks.withType(JavaCompile) {
+ options.encoding = "UTF-8"
+}
+
+// 打包源码
+task sourcesJar(type: Jar) {
+ from android.sourceSets.main.java.srcDirs
+ classifier = 'sources'
+}
+
+task javadoc(type: Javadoc) {
+ failOnError false
+ source = android.sourceSets.main.java.sourceFiles
+ classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
+ classpath += configurations.compile
+}
+
+// 制作文档(Javadoc)
+task javadocJar(type: Jar, dependsOn: javadoc) {
+ classifier = 'javadoc'
+ from javadoc.destinationDir
+}
+
+artifacts {
+ archives sourcesJar
+ archives javadocJar
+}
+```
+
+
+
+### 发布参照上一篇文章： [使用JitPack发布开源库](http://www.gcssloop.com/course/PublishLibraryByJitPack/)
+
+
+
+### 查看在线文档
+
+如果你在JitPack配置了文档和源码支持，在引用同时就能看到源码的文档，不仅如此，你也可以在线查看。
+
+查看地址是 `https://jitpack.io/com/github/USER/REPO/VERSION/javadoc/`
+
+例如我的一个开源库： https://jitpack.io/com/github/GcsSloop/ViewSupport/v1.2.2/javadoc/
+
+在线API文档样式：
+
\ No newline at end of file
diff --git a/CustomView/Advance/Code/CheckView.java b/CustomView/Advance/Code/CheckView.java
new file mode 100644
index 00000000..be82e5d9
--- /dev/null
+++ b/CustomView/Advance/Code/CheckView.java
@@ -0,0 +1,182 @@
+package com.sloop.canvas;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.os.Handler;
+import android.os.Message;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.View;
+
+/**
+ * + * Created Date: 16/5/31 + *
+ * Copyright (C) 2016 GcsSloop. + *
+ * GitHub: https://github.com/GcsSloop + */ +public class SearchView extends View { + + // 画笔 + private Paint mPaint; + + // View 宽高 + private int mViewWidth; + private int mViewHeight; + + public SearchView(Context context) { + this(context,null); + } + + public SearchView(Context context, AttributeSet attrs) { + super(context, attrs); + initAll(); + } + + public void initAll() { + + initPaint(); + + initPath(); + + initListener(); + + initHandler(); + + initAnimator(); + + // 进入开始动画 + mCurrentState = State.STARTING; + mStartingAnimator.start(); + + } + + // 这个视图拥有的状态 + public static enum State { + NONE, + STARTING, + SEARCHING, + ENDING + } + + // 当前的状态(非常重要) + private State mCurrentState = State.NONE; + + // 放大镜与外部圆环 + private Path path_srarch; + private Path path_circle; + + // 测量Path 并截取部分的工具 + private PathMeasure mMeasure; + + // 默认的动效周期 2s + private int defaultDuration = 2000; + + // 控制各个过程的动画 + private ValueAnimator mStartingAnimator; + private ValueAnimator mSearchingAnimator; + private ValueAnimator mEndingAnimator; + + // 动画数值(用于控制动画状态,因为同一时间内只允许有一种状态出现,具体数值处理取决于当前状态) + private float mAnimatorValue = 0; + + // 动效过程监听器 + private ValueAnimator.AnimatorUpdateListener mUpdateListener; + private Animator.AnimatorListener mAnimatorListener; + + // 用于控制动画状态转换 + private Handler mAnimatorHandler; + + // 判断是否已经搜索结束 + private boolean isOver = false; + + private int count = 0; + + + + private void initPaint() { + mPaint = new Paint(); + mPaint.setStyle(Paint.Style.STROKE); + mPaint.setColor(Color.WHITE); + mPaint.setStrokeWidth(15); + mPaint.setStrokeCap(Paint.Cap.ROUND); + mPaint.setAntiAlias(true); + } + + private void initPath() { + path_srarch = new Path(); + path_circle = new Path(); + + mMeasure = new PathMeasure(); + + // 注意,不要到360度,否则内部会自动优化,测量不能取到需要的数值 + RectF oval1 = new RectF(-50, -50, 50, 50); // 放大镜圆环 + path_srarch.addArc(oval1, 45, 359.9f); + + RectF oval2 = new RectF(-100, -100, 100, 100); // 外部圆环 + path_circle.addArc(oval2, 45, -359.9f); + + float[] pos = new float[2]; + + mMeasure.setPath(path_circle, false); // 放大镜把手的位置 + mMeasure.getPosTan(0, pos, null); + + path_srarch.lineTo(pos[0], pos[1]); // 放大镜把手 + + Log.i("TAG", "pos=" + pos[0] + ":" + pos[1]); + } + + private void initListener() { + mUpdateListener = new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(ValueAnimator animation) { + mAnimatorValue = (float) animation.getAnimatedValue(); + invalidate(); + } + }; + + mAnimatorListener = new Animator.AnimatorListener() { + @Override + public void onAnimationStart(Animator animation) { + + } + + @Override + public void onAnimationEnd(Animator animation) { + // getHandle发消息通知动画状态更新 + mAnimatorHandler.sendEmptyMessage(0); + } + + @Override + public void onAnimationCancel(Animator animation) { + + } + + @Override + public void onAnimationRepeat(Animator animation) { + + } + }; + } + + private void initHandler() { + mAnimatorHandler = new Handler() { + @Override + public void handleMessage(Message msg) { + super.handleMessage(msg); + switch (mCurrentState) { + case STARTING: + // 从开始动画转换好搜索动画 + isOver = false; + mCurrentState = State.SEARCHING; + mStartingAnimator.removeAllListeners(); + mSearchingAnimator.start(); + break; + case SEARCHING: + if (!isOver) { // 如果搜索未结束 则继续执行搜索动画 + mSearchingAnimator.start(); + Log.e("Update", "RESTART"); + + count++; + if (count>2){ // count大于2则进入结束状态 + isOver = true; + } + } else { // 如果搜索已经结束 则进入结束动画 + mCurrentState = State.ENDING; + mEndingAnimator.start(); + } + break; + case ENDING: + // 从结束动画转变为无状态 + mCurrentState = State.NONE; + break; + } + } + }; + } + + private void initAnimator() { + mStartingAnimator = ValueAnimator.ofFloat(0, 1).setDuration(defaultDuration); + mSearchingAnimator = ValueAnimator.ofFloat(0, 1).setDuration(defaultDuration); + mEndingAnimator = ValueAnimator.ofFloat(1, 0).setDuration(defaultDuration); + + mStartingAnimator.addUpdateListener(mUpdateListener); + mSearchingAnimator.addUpdateListener(mUpdateListener); + mEndingAnimator.addUpdateListener(mUpdateListener); + + mStartingAnimator.addListener(mAnimatorListener); + mSearchingAnimator.addListener(mAnimatorListener); + mEndingAnimator.addListener(mAnimatorListener); + } + + + @Override + protected void onSizeChanged(int w, int h, int oldw, int oldh) { + super.onSizeChanged(w, h, oldw, oldh); + mViewWidth = w; + mViewHeight = h; + } + + @Override + protected void onDraw(Canvas canvas) { + super.onDraw(canvas); + + drawSearch(canvas); + } + + private void drawSearch(Canvas canvas) { + + mPaint.setColor(Color.WHITE); + + + canvas.translate(mViewWidth / 2, mViewHeight / 2); + + canvas.drawColor(Color.parseColor("#0082D7")); + + switch (mCurrentState) { + case NONE: + canvas.drawPath(path_srarch, mPaint); + break; + case STARTING: + mMeasure.setPath(path_srarch, false); + Path dst = new Path(); + mMeasure.getSegment(mMeasure.getLength() * mAnimatorValue, mMeasure.getLength(), dst, true); + canvas.drawPath(dst, mPaint); + break; + case SEARCHING: + mMeasure.setPath(path_circle, false); + Path dst2 = new Path(); + float stop = mMeasure.getLength() * mAnimatorValue; + float start = (float) (stop - ((0.5 - Math.abs(mAnimatorValue - 0.5)) * 200f)); + mMeasure.getSegment(start, stop, dst2, true); + canvas.drawPath(dst2, mPaint); + break; + case ENDING: + mMeasure.setPath(path_srarch, false); + Path dst3 = new Path(); + mMeasure.getSegment(mMeasure.getLength() * mAnimatorValue, mMeasure.getLength(), dst3, true); + canvas.drawPath(dst3, mPaint); + break; + } + } +} diff --git a/CustomView/Advance/Code/SearchView.md b/CustomView/Advance/Code/SearchView.md new file mode 100644 index 00000000..311df8e3 --- /dev/null +++ b/CustomView/Advance/Code/SearchView.md @@ -0,0 +1,261 @@ +## SearchView 源代码 + +[下载代码 (右键 -> 另存为)](https://raw.githubusercontent.com/GcsSloop/AndroidNote/master/CustomView/Advance/Code/SearchView.java) + +``` java +/** + * Author: GcsSloop + *
+ * Created Date: 16/5/31 + *
+ * Copyright (C) 2016 GcsSloop. + *
+ * GitHub: https://github.com/GcsSloop + */ +public class SearchView extends View { + + // 画笔 + private Paint mPaint; + + // View 宽高 + private int mViewWidth; + private int mViewHeight; + + public SearchView(Context context) { + this(context,null); + } + + public SearchView(Context context, AttributeSet attrs) { + super(context, attrs); + initAll(); + } + + public void initAll() { + + initPaint(); + + initPath(); + + initListener(); + + initHandler(); + + initAnimator(); + + // 进入开始动画 + mCurrentState = State.STARTING; + mStartingAnimator.start(); + + } + + // 这个视图拥有的状态 + public static enum State { + NONE, + STARTING, + SEARCHING, + ENDING + } + + // 当前的状态(非常重要) + private State mCurrentState = State.NONE; + + // 放大镜与外部圆环 + private Path path_srarch; + private Path path_circle; + + // 测量Path 并截取部分的工具 + private PathMeasure mMeasure; + + // 默认的动效周期 2s + private int defaultDuration = 2000; + + // 控制各个过程的动画 + private ValueAnimator mStartingAnimator; + private ValueAnimator mSearchingAnimator; + private ValueAnimator mEndingAnimator; + + // 动画数值(用于控制动画状态,因为同一时间内只允许有一种状态出现,具体数值处理取决于当前状态) + private float mAnimatorValue = 0; + + // 动效过程监听器 + private ValueAnimator.AnimatorUpdateListener mUpdateListener; + private Animator.AnimatorListener mAnimatorListener; + + // 用于控制动画状态转换 + private Handler mAnimatorHandler; + + // 判断是否已经搜索结束 + private boolean isOver = false; + + private int count = 0; + + + + private void initPaint() { + mPaint = new Paint(); + mPaint.setStyle(Paint.Style.STROKE); + mPaint.setColor(Color.WHITE); + mPaint.setStrokeWidth(15); + mPaint.setStrokeCap(Paint.Cap.ROUND); + mPaint.setAntiAlias(true); + } + + private void initPath() { + path_srarch = new Path(); + path_circle = new Path(); + + mMeasure = new PathMeasure(); + + // 注意,不要到360度,否则内部会自动优化,测量不能取到需要的数值 + RectF oval1 = new RectF(-50, -50, 50, 50); // 放大镜圆环 + path_srarch.addArc(oval1, 45, 359.9f); + + RectF oval2 = new RectF(-100, -100, 100, 100); // 外部圆环 + path_circle.addArc(oval2, 45, -359.9f); + + float[] pos = new float[2]; + + mMeasure.setPath(path_circle, false); // 放大镜把手的位置 + mMeasure.getPosTan(0, pos, null); + + path_srarch.lineTo(pos[0], pos[1]); // 放大镜把手 + + Log.i("TAG", "pos=" + pos[0] + ":" + pos[1]); + } + + private void initListener() { + mUpdateListener = new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(ValueAnimator animation) { + mAnimatorValue = (float) animation.getAnimatedValue(); + invalidate(); + } + }; + + mAnimatorListener = new Animator.AnimatorListener() { + @Override + public void onAnimationStart(Animator animation) { + + } + + @Override + public void onAnimationEnd(Animator animation) { + // getHandle发消息通知动画状态更新 + mAnimatorHandler.sendEmptyMessage(0); + } + + @Override + public void onAnimationCancel(Animator animation) { + + } + + @Override + public void onAnimationRepeat(Animator animation) { + + } + }; + } + + private void initHandler() { + mAnimatorHandler = new Handler() { + @Override + public void handleMessage(Message msg) { + super.handleMessage(msg); + switch (mCurrentState) { + case STARTING: + // 从开始动画转换好搜索动画 + isOver = false; + mCurrentState = State.SEARCHING; + mStartingAnimator.removeAllListeners(); + mSearchingAnimator.start(); + break; + case SEARCHING: + if (!isOver) { // 如果搜索未结束 则继续执行搜索动画 + mSearchingAnimator.start(); + Log.e("Update", "RESTART"); + + count++; + if (count>2){ // count大于2则进入结束状态 + isOver = true; + } + } else { // 如果搜索已经结束 则进入结束动画 + mCurrentState = State.ENDING; + mEndingAnimator.start(); + } + break; + case ENDING: + // 从结束动画转变为无状态 + mCurrentState = State.NONE; + break; + } + } + }; + } + + private void initAnimator() { + mStartingAnimator = ValueAnimator.ofFloat(0, 1).setDuration(defaultDuration); + mSearchingAnimator = ValueAnimator.ofFloat(0, 1).setDuration(defaultDuration); + mEndingAnimator = ValueAnimator.ofFloat(1, 0).setDuration(defaultDuration); + + mStartingAnimator.addUpdateListener(mUpdateListener); + mSearchingAnimator.addUpdateListener(mUpdateListener); + mEndingAnimator.addUpdateListener(mUpdateListener); + + mStartingAnimator.addListener(mAnimatorListener); + mSearchingAnimator.addListener(mAnimatorListener); + mEndingAnimator.addListener(mAnimatorListener); + } + + + @Override + protected void onSizeChanged(int w, int h, int oldw, int oldh) { + super.onSizeChanged(w, h, oldw, oldh); + mViewWidth = w; + mViewHeight = h; + } + + @Override + protected void onDraw(Canvas canvas) { + super.onDraw(canvas); + + drawSearch(canvas); + } + + private void drawSearch(Canvas canvas) { + + mPaint.setColor(Color.WHITE); + + + canvas.translate(mViewWidth / 2, mViewHeight / 2); + + canvas.drawColor(Color.parseColor("#0082D7")); + + switch (mCurrentState) { + case NONE: + canvas.drawPath(path_srarch, mPaint); + break; + case STARTING: + mMeasure.setPath(path_srarch, false); + Path dst = new Path(); + mMeasure.getSegment(mMeasure.getLength() * mAnimatorValue, mMeasure.getLength(), dst, true); + canvas.drawPath(dst, mPaint); + break; + case SEARCHING: + mMeasure.setPath(path_circle, false); + Path dst2 = new Path(); + float stop = mMeasure.getLength() * mAnimatorValue; + float start = (float) (stop - ((0.5 - Math.abs(mAnimatorValue - 0.5)) * 200f)); + mMeasure.getSegment(start, stop, dst2, true); + canvas.drawPath(dst2, mPaint); + break; + case ENDING: + mMeasure.setPath(path_srarch, false); + Path dst3 = new Path(); + mMeasure.getSegment(mMeasure.getLength() * mAnimatorValue, mMeasure.getLength(), dst3, true); + canvas.drawPath(dst3, mPaint); + break; + } + } +} + +``` diff --git a/CustomView/Advance/Code/SetPolyToPoly.java b/CustomView/Advance/Code/SetPolyToPoly.java new file mode 100644 index 00000000..d905ae91 --- /dev/null +++ b/CustomView/Advance/Code/SetPolyToPoly.java @@ -0,0 +1,129 @@ +package com.gcssloop.canvas; + +import android.content.Context; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.graphics.Canvas; +import android.graphics.Matrix; +import android.graphics.Paint; +import android.util.AttributeSet; +import android.view.MotionEvent; +import android.view.View; + +import com.gcssloop.view.utils.CanvasAidUtils; + +/** + * Author: GcsSloop + *
+ * Created Date: 16/8/26 + *
+ * Copyright (C) 2016 GcsSloop. + *
+ * GitHub: https://github.com/GcsSloop
+ */
+public class SetPolyToPoly extends View{
+ private static final String TAG = "SetPolyToPoly";
+
+ private int testPoint = 0;
+ private int triggerRadius = 180; // 触发半径为180px
+
+ private Bitmap mBitmap; // 要绘制的图片
+ private Matrix mPolyMatrix; // 测试setPolyToPoly用的Matrix
+
+ private float[] src = new float[8];
+ private float[] dst = new float[8];
+
+ private Paint pointPaint;
+
+ public SetPolyToPoly(Context context) {
+ this(context, null);
+ }
+
+ public SetPolyToPoly(Context context, AttributeSet attrs) {
+ this(context, attrs, 0);
+ }
+
+ public SetPolyToPoly(Context context, AttributeSet attrs, int defStyleAttr) {
+ super(context, attrs, defStyleAttr);
+ initBitmapAndMatrix();
+ }
+
+ private void initBitmapAndMatrix() {
+ mBitmap = BitmapFactory.decodeResource(getResources(),
+ R.drawable.poly_test2);
+
+ float[] temp = {0, 0, // 左上
+ mBitmap.getWidth(), 0, // 右上
+ mBitmap.getWidth(), mBitmap.getHeight(), // 右下
+ 0, mBitmap.getHeight()}; // 左下
+ src = temp.clone();
+ dst = temp.clone();
+
+ pointPaint = new Paint();
+ pointPaint.setAntiAlias(true);
+ pointPaint.setStrokeWidth(50);
+ pointPaint.setColor(0xffd19165);
+ pointPaint.setStrokeCap(Paint.Cap.ROUND);
+
+ mPolyMatrix = new Matrix();
+ mPolyMatrix.setPolyToPoly(src, 0, src, 0, 4);
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+
+ switch (event.getAction()){
+ case MotionEvent.ACTION_MOVE:
+ float tempX = event.getX();
+ float tempY = event.getY();
+
+ // 根据触控位置改变dst
+ for (int i=0; i
+
+
+
+
+
+
+
+
+
+## 参考资料：
+[View](http://developer.android.com/reference/android/view/View.html)
+[ViewGroup](http://developer.android.com/reference/android/view/ViewGroup.html)
+[View.MeasureSpec](http://developer.android.com/reference/android/view/View.MeasureSpec.html)
+[onMeasure，MeasureSpec源码 流程 思路详解](http://blog.csdn.net/a396901990/article/details/36475213)
+
+[Android中自定义样式与View的构造函数中的第三个参数defStyle的意义](http://www.cnblogs.com/angeldevil/p/3479431.html)
+[android view构造函数研究](http://blog.csdn.net/z103594643/article/details/6755017)
+[Android View构造方法第三参数使用方法详解](http://blog.csdn.net/mybeta/article/details/39993449)
+
+[Android 自定义View onMeasure方法的实现](http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2014/1102/1891.html)
+[Android API指南(二)自定义控件02之 onMeasure](http://wangkuiwu.github.io/2014/06/20/View-OnMeasure/)
+[Android中View的绘制过程 onMeasure方法简述](http://www.cnblogs.com/mengdd/p/3332882.html)
+
+
+
diff --git a/CustomView/Advance/[02]Canvas_BasicGraphics.md b/CustomView/Advance/[02]Canvas_BasicGraphics.md
new file mode 100644
index 00000000..60143dc4
--- /dev/null
+++ b/CustomView/Advance/[02]Canvas_BasicGraphics.md
@@ -0,0 +1,538 @@
+# Canvas之绘制基本形状
+
+### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
+### [【本系列相关文章】](https://github.com/GcsSloop/AndroidNote/tree/master/CustomView/README.md)
+
+在上一篇[自定义View分类与流程](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B01%5DCustomViewProcess.md)中我们了解自定义View相关的基本知识，不过，这些东西依旧还是理论，并不能**拿来(zhuang)用(B)**, 这一次我们就了解一些**能(zhaung)用(B)**的东西。
+
+在本篇文章中，我们先了解Canvas的基本用法，最后用一个小示例来结束本次教程。
+
+## 一.Canvas简介
+
+Canvas我们可以称之为画布，能够在上面绘制各种东西，是安卓平台2D图形绘制的基础，非常强大。
+
+**一般来说，比较基础的东西有两大特点:
+ 1.可操作性强：由于这些是构成上层的基础，所以可操作性必然十分强大。
+ 2.比较难用：各种方法太过基础，想要完美的将这些操作组合起来有一定难度。**
+
+不过不必担心，本系列文章不仅会介绍到Canvas的操作方法，还会简单介绍一些设计思路和技巧。
+
+## 二.Canvas的常用操作速查表
+
+| 操作类型 | 相关API | 备注 |
+| ---------- | ---------------------------------------- | ---------------------------------------- |
+| 绘制颜色 | drawColor, drawRGB, drawARGB | 使用单一颜色填充整个画布 |
+| 绘制基本形状 | drawPoint, drawPoints, drawLine, drawLines, drawRect, drawRoundRect, drawOval, drawCircle, drawArc | 依次为 点、线、矩形、圆角矩形、椭圆、圆、圆弧 |
+| 绘制图片 | drawBitmap, drawPicture | 绘制位图和图片 |
+| 绘制文本 | drawText, drawPosText, drawTextOnPath | 依次为 绘制文字、绘制文字时指定每个文字位置、根据路径绘制文字 |
+| 绘制路径 | drawPath | 绘制路径，绘制贝塞尔曲线时也需要用到该函数 |
+| 顶点操作 | drawVertices, drawBitmapMesh | 通过对顶点操作可以使图像形变，drawVertices直接对画布作用、 drawBitmapMesh只对绘制的Bitmap作用 |
+| 画布剪裁 | clipPath, clipRect | 设置画布的显示区域 |
+| 画布快照 | save, restore, saveLayerXxx, restoreToCount, getSaveCount | 依次为 保存当前状态、 回滚到上一次保存的状态、 保存图层状态、 回滚到指定状态、 获取保存次数 |
+| 画布变换 | translate, scale, rotate, skew | 依次为 位移、缩放、 旋转、错切 |
+| Matrix(矩阵) | getMatrix, setMatrix, concat | 实际画布的位移，缩放等操作的都是图像矩阵Matrix，只不过Matrix比较难以理解和使用，故封装了一些常用的方法。 |
+
+> PS： Canvas常用方法在上面表格中已经全部列出了，当然还存在一些其他的方法未列出，具体可以参考官方文档 [Canvas](http://developer.android.com/reference/android/graphics/Canvas.html)
+
+******
+
+## 三.Canvas详解
+
+本篇内容主要讲解如何利用Canvas绘制基本图形。
+
+
+### 绘制颜色：
+
+绘制颜色是填充整个画布，常用于绘制底色。
+``` java
+ canvas.drawColor(Color.BLUE); //绘制蓝色
+```
+
+
+
+> 关于颜色的更多资料请参考[基础篇_颜色](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView%2FBase%2F%5B03%5DColor.md)
+
+******
+
+### 创建画笔：
+要想绘制内容，首先需要先创建一个画笔，如下：
+``` java
+ // 1.创建一个画笔
+ private Paint mPaint = new Paint();
+
+ // 2.初始化画笔
+ private void initPaint() {
+ mPaint.setColor(Color.BLACK); //设置画笔颜色
+ mPaint.setStyle(Paint.Style.FILL); //设置画笔模式为填充
+ mPaint.setStrokeWidth(10f); //设置画笔宽度为10px
+ }
+
+ // 3.在构造函数中初始化
+ public SloopView(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ initPaint();
+ }
+```
+在创建完画笔之后，就可以在Canvas中绘制各种内容了。
+
+******
+
+### 绘制点：
+
+可以绘制一个点，也可以绘制一组点，如下：
+``` java
+ canvas.drawPoint(200, 200, mPaint); //在坐标(200,200)位置绘制一个点
+ canvas.drawPoints(new float[]{ //绘制一组点，坐标位置由float数组指定
+ 500,500,
+ 500,600,
+ 500,700
+ },mPaint);
+```
+关于坐标原点默认在左上角，水平向右为x轴增大方向，竖直向下为y轴增大方向。
+
+> 更多参考这里 [基础篇_坐标系](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView%2FBase%2F%5B01%5DCoordinateSystem.md)
+
+
+
+******
+
+### 绘制直线：
+绘制直线需要两个点，初始点和结束点，同样绘制直线也可以绘制一条或者绘制一组：
+``` java
+ canvas.drawLine(300,300,500,600,mPaint); // 在坐标(300,300)(500,600)之间绘制一条直线
+ canvas.drawLines(new float[]{ // 绘制一组线 每四数字(两个点的坐标)确定一条线
+ 100,200,200,200,
+ 100,300,200,300
+ },mPaint);
+```
+
+
+
+******
+
+### 绘制矩形：
+我们都知道，确定一个矩形最少需要四个数据，就是**对角线的两个点**的坐标值，这里一般采用**左上角和右下角**的两个点的坐标。
+
+关于绘制矩形，Canvas提供了三种重载方法，第一种就是提供**四个数值(矩形左上角和右下角两个点的坐标)来确定一个矩形**进行绘制。
+其余两种是先将矩形封装为**Rect或RectF**(实际上仍然是用两个坐标点来确定的矩形)，然后传递给Canvas绘制，如下：
+
+``` java
+// 第一种
+canvas.drawRect(100,100,800,400,mPaint);
+
+// 第二种
+Rect rect = new Rect(100,100,800,400);
+canvas.drawRect(rect,mPaint);
+
+// 第三种
+RectF rectF = new RectF(100,100,800,400);
+canvas.drawRect(rectF,mPaint);
+```
+以上三种方法所绘制出来的结果是完全一样的。
+
+
+
+看到这里,相信很多观众会产生一个疑问，为什么会有Rect和RectF两种？两者有什么区别吗？
+
+答案当然是存在区别的，**两者最大的区别就是精度不同，Rect是int(整形)的，而RectF是float(单精度浮点型)的**。除了精度不同，两种提供的方法也稍微存在差别，在这里我们暂时无需关注，想了解更多参见官方文档 [Rect](http://developer.android.com/reference/android/graphics/Rect.html) 和 [RectF](http://developer.android.com/reference/android/graphics/RectF.html)
+
+******
+
+### 绘制圆角矩形：
+绘制圆角矩形也提供了两种重载方式，如下：
+``` java
+ // 第一种
+ RectF rectF = new RectF(100,100,800,400);
+ canvas.drawRoundRect(rectF,30,30,mPaint);
+
+ // 第二种
+ canvas.drawRoundRect(100,100,800,400,30,30,mPaint);
+```
+上面两种方法绘制效果也是一样的，但鉴于第二种方法在API21的时候才添加上，所以我们一般使用的都是第一种。
+
+
+
+下面简单解析一下圆角矩形的几个必要的参数的意思。
+
+很明显可以看出，第二种方法前四个参数和第一种方法的RectF作用是一样的，都是为了确定一个矩形，最后一个参数Paint是画笔，无需多说，**与矩形相比，圆角矩形多出来了两个参数rx 和 ry**，这两个参数是干什么的呢？
+
+稍微分析一下，既然是圆角矩形，他的角肯定是圆弧(圆形的一部分)，**我们一般用什么确定一个圆形呢？**
+
+答案是**圆心 和 半径，其中圆心用于确定位置，而半径用于确定大小**。
+
+由于矩形位置已经确定，所以其边角位置也是确定的，那么确定位置的参数就可以省略，只需要用半径就能描述一个圆弧了。
+
+但是，**半径只需要一个参数，但这里怎么会有两个呢？**
+
+好吧，让你发现了，**这里圆角矩形的角实际上不是一个正圆的圆弧，而是椭圆的圆弧，这里的两个参数实际上是椭圆的两个半径**，他们看起来个如下图：
+
+
+
+**红线标注的 rx 与 ry 就是两个半径，也就是相比绘制矩形多出来的那两个参数。**
+
+我们了解到原理后，就可以为所欲为了，通过计算可知我们上次绘制的矩形宽度为700，高度为300，当你让 rx大于350(宽度的一半)， ry大于150(高度的一半) 时奇迹就出现了， 你会发现圆角矩形变成了一个椭圆， 他们画出来是这样的 ( 为了方便确认我更改了画笔颜色， 同时绘制出了矩形和圆角矩形 )：
+
+``` java
+ // 矩形
+ RectF rectF = new RectF(100,100,800,400);
+
+ // 绘制背景矩形
+ mPaint.setColor(Color.GRAY);
+ canvas.drawRect(rectF,mPaint);
+
+ // 绘制圆角矩形
+ mPaint.setColor(Color.BLUE);
+ canvas.drawRoundRect(rectF,700,400,mPaint);
+```
+
+
+
+其中灰色部分是我们所选定的矩形，而里面的圆角矩形则变成了一个椭圆，实际上在rx为宽度的一半，ry为高度的一半时，刚好是一个椭圆，通过上面我们分析的原理推算一下就能得到，而当rx大于宽度的一半，ry大于高度的一半时，实际上是无法计算出圆弧的，所以drawRoundRect对大于该数值的参数进行了限制(修正)，凡是大于一半的参数均按照一半来处理。
+
+******
+
+### 绘制椭圆：
+相对于绘制圆角矩形，绘制椭圆就简单的多了，因为他只需要一个矩形作为参数:
+
+``` java
+ // 第一种
+ RectF rectF = new RectF(100,100,800,400);
+ canvas.drawOval(rectF,mPaint);
+
+ // 第二种
+ canvas.drawOval(100,100,800,400,mPaint);
+```
+同样，以上两种方法效果完全一样，但一般使用第一种。
+
+
+
+绘制椭圆实际上就是绘制一个矩形的内切图形，原理如下，就不多说了：
+
+
+
+PS： 如果你传递进来的是一个长宽相等的矩形(即正方形)，那么绘制出来的实际上就是一个圆。
+
+******
+### 绘制圆：
+
+绘制圆形也比较简单, 如下：
+
+```
+ canvas.drawCircle(500,500,400,mPaint); // 绘制一个圆心坐标在(500,500)，半径为400 的圆。
+```
+绘制圆形有四个参数，前两个是圆心坐标，第三个是半径，最后一个是画笔。
+
+
+
+******
+### 绘制圆弧：
+
+绘制圆弧就比较神奇一点了，为了理解这个比较神奇的东西，我们先看一下它需要的几个参数：
+
+``` java
+// 第一种
+public void drawArc(@NonNull RectF oval, float startAngle, float sweepAngle, boolean useCenter, @NonNull Paint paint){}
+
+// 第二种
+public void drawArc(float left, float top, float right, float bottom, float startAngle,
+ float sweepAngle, boolean useCenter, @NonNull Paint paint) {}
+```
+
+从上面可以看出，相比于绘制椭圆，绘制圆弧还多了三个参数：
+
+``` java
+startAngle // 开始角度
+sweepAngle // 扫过角度
+useCenter // 是否使用中心
+```
+
+通过字面意思我们基本能猜测出来前两个参数(startAngle， sweepAngel)的作用，就是确定角度的起始位置和扫过角度， 不过第三个参数是干嘛的？试一下就知道了,上代码：
+
+```
+ RectF rectF = new RectF(100,100,800,400);
+ // 绘制背景矩形
+ mPaint.setColor(Color.GRAY);
+ canvas.drawRect(rectF,mPaint);
+
+ // 绘制圆弧
+ mPaint.setColor(Color.BLUE);
+ canvas.drawArc(rectF,0,90,false,mPaint);
+
+ //-------------------------------------
+
+ RectF rectF2 = new RectF(100,600,800,900);
+ // 绘制背景矩形
+ mPaint.setColor(Color.GRAY);
+ canvas.drawRect(rectF2,mPaint);
+
+ // 绘制圆弧
+ mPaint.setColor(Color.BLUE);
+ canvas.drawArc(rectF2,0,90,true,mPaint);
+```
+
+上述代码实际上是绘制了一个起始角度为0度，扫过90度的圆弧，两者的区别就是是否使用了中心点，结果如下：
+
+
+
+可以发现使用了中心点之后绘制出来类似于一个扇形，而不使用中心点则是圆弧起始点和结束点之间的连线加上圆弧围成的图形。这样中心点这个参数的作用就很明显了，不必多说想必大家试一下就明白了。 另外可以关于角度可以参考一下这篇文章： [角度与弧度](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView%2FBase%2F%5B02%5DAngleAndRadian.md)
+
+相比于使用椭圆，我们还是使用正圆比较多的，使用正圆展示一下效果：
+
+```
+ RectF rectF = new RectF(100,100,600,600);
+ // 绘制背景矩形
+ mPaint.setColor(Color.GRAY);
+ canvas.drawRect(rectF,mPaint);
+
+ // 绘制圆弧
+ mPaint.setColor(Color.BLUE);
+ canvas.drawArc(rectF,0,90,false,mPaint);
+
+ //-------------------------------------
+
+ RectF rectF2 = new RectF(100,700,600,1200);
+ // 绘制背景矩形
+ mPaint.setColor(Color.GRAY);
+ canvas.drawRect(rectF2,mPaint);
+
+ // 绘制圆弧
+ mPaint.setColor(Color.BLUE);
+ canvas.drawArc(rectF2,0,90,true,mPaint);
+```
+
+
+******
+### 简要介绍Paint
+
+看了上面这么多，相信有一部分人会产生一个疑问，如果我想绘制一个圆，只要边不要里面的颜色怎么办？
+
+很简单，绘制的**基本形状由Canvas确定**，但绘制出来的**颜色,具体效果则由Paint确定**。
+
+如果你注意到了的话，在一开始我们设置画笔样式的时候是这样的：
+
+``` java
+ mPaint.setStyle(Paint.Style.FILL); //设置画笔模式为填充
+```
+
+为了展示方便，容易看出效果，之前使用的模式一直为填充模式，实际上画笔有三种模式，如下：
+
+``` java
+STROKE //描边
+FILL //填充
+FILL_AND_STROKE //描边加填充
+```
+
+为了区分三者效果我们做如下实验：
+
+```
+ Paint paint = new Paint();
+ paint.setColor(Color.BLUE);
+ paint.setStrokeWidth(40); //为了实验效果明显，特地设置描边宽度非常大
+
+ // 描边
+ paint.setStyle(Paint.Style.STROKE);
+ canvas.drawCircle(200,200,100,paint);
+
+ // 填充
+ paint.setStyle(Paint.Style.FILL);
+ canvas.drawCircle(200,500,100,paint);
+
+ // 描边加填充
+ paint.setStyle(Paint.Style.FILL_AND_STROKE);
+ canvas.drawCircle(200, 800, 100, paint);
+```
+
+
+
+一图胜千言，通过以上实验我们可以比较明显的看出三种模式的区别，如果只需要边缘不需要填充内容的话只需要设置模式为描边(STROKE)即可。
+
+其实关于Paint的内容也是有不少的，这些只是冰山一角，在后续内容中会详细的讲解Paint。
+
+******
+## 小示例
+
+### 简要介绍画布的操作:
+
+> 画布操作详细内容会在下一篇文章中讲解, 不是本文重点，但以下示例中可能会用到，所以此处简要介绍一下。
+
+| 相关操作 | 简要介绍 |
+| --------- | ----------- |
+| save | 保存当前画布状态 |
+| restore | 回滚到上一次保存的状态 |
+| translate | 相对于当前位置位移 |
+| rotate | 旋转 |
+
+### 制作一个饼状图
+
+在展示百分比数据的时候经常会用到饼状图，像这样：
+
+
+
+### 简单分析
+
+其实根据我们上面的知识已经能自己制作一个饼状图了。不过制作东西最重要的不是制作结果，而是制作思路。
+相信我贴上代码大家一看就立刻明白了，非常简单的东西。不过嘛，咱们还是想了解一下制作思路：
+
+先分析饼状图的构成，非常明显，饼状图就是一个又一个的扇形构成的，每个扇形都有不同的颜色，对应的有名字，数据和百分比。
+
+经以上信息可以得出饼状图的最基本数据应包括：名字 数据值 百分比 对应的角度 颜色。
+
+
+用户关心的数据 ： 名字 数据值 百分比
+需要程序计算的数据： 百分比 对应的角度
+其中颜色这一项可以用户指定也可以用程序指定(我们这里采用程序指定)。
+
+
+### 封装数据：
+``` java
+public class PieData {
+ // 用户关心数据
+ private String name; // 名字
+ private float value; // 数值
+ private float percentage; // 百分比
+
+ // 非用户关心数据
+ private int color = 0; // 颜色
+ private float angle = 0; // 角度
+
+ public PieData(@NonNull String name, @NonNull float value) {
+ this.name = name;
+ this.value = value;
+ }
+}
+```
+PS: 以上省略了get set方法
+
+### 自定义View：
+先按照自定义View流程梳理一遍(确定各个步骤应该做的事情)：
+
+| 步骤 | 关键字 | 作用 |
+| :--: | ------------- | --------------------- |
+| 1 | 构造函数 | 初始化(初始化画笔Paint) |
+| 2 | onMeasure | 测量View的大小(暂时不用关心) |
+| 3 | onSizeChanged | 确定View大小(记录当前View的宽高) |
+| 4 | onLayout | 确定子View布局(无子View，不关心) |
+| 5 | onDraw | 实际绘制内容(绘制饼状图) |
+| 6 | 提供接口 | 提供接口(提供设置数据的接口) |
+
+代码如下：
+
+``` java
+public class PieView extends View {
+ // 颜色表(注意: 此处定义颜色使用的是ARGB，带Alpha通道的)
+ private int[] mColors = {0xFFCCFF00, 0xFF6495ED, 0xFFE32636, 0xFF800000, 0xFF808000, 0xFFFF8C69, 0xFF808080,
+ 0xFFE6B800, 0xFF7CFC00};
+ // 饼状图初始绘制角度
+ private float mStartAngle = 0;
+ // 数据
+ private ArrayList
+
+> **PS: 这个饼状图并没有添加百分比等数据，仅作为示例使用。**
+
+## 总结：
+
+ 其实自定义View只要按照流程一步步的走，也是比较容易的。不过里面也有不少坑，这些坑还是自己踩过印象比较深，建议大家不要直接copy源码，自己手打体验一下。
+
+## About Me
+### 作者微博: @GcsSloop
+
+
+
+## 参考资料：
+
+[View](http://developer.android.com/reference/android/view/View.html)
+[Canvas](http://developer.android.com/reference/android/graphics/Canvas.html)
+[Android Canvas绘图详解](http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2012/1212/703.html)
+
+
diff --git "a/\351\227\256\351\242\230/Canvas/Canvas(2).md" b/CustomView/Advance/[03]Canvas_Convert.md
similarity index 61%
rename from "\351\227\256\351\242\230/Canvas/Canvas(2).md"
rename to CustomView/Advance/[03]Canvas_Convert.md
index 8cf7b96f..4ad9f63f 100644
--- "a/\351\227\256\351\242\230/Canvas/Canvas(2).md"
+++ b/CustomView/Advance/[03]Canvas_Convert.md
@@ -1,53 +1,52 @@
-# Canvas基础二
-### 讲解安卓中的Canvas基础内容。
-### 作者微博: [@攻城师sloop](http://weibo.com/5459430586)
-
-上一次我们了解了一些Canvas的基础知识，这次依旧是Canvas相关的一些内容。
-
-相比于上一次绘制简单的图形，这次的内容会稍微有趣一点点，相信大家看完之后会对Canvas更加了解,能够制作一些更(geng)加(neng)炫(zhuang)酷(B)的东西出来。
-
-## 一.Canvas常用操作
-为了方便，我把上次的表格搬过来了。
-
-操作类型 | 相关API | 备注
---- | --- | ---
-绘制颜色 | drawColor, drawRGB, drawARGB | 使用单一颜色填充整个画布
相关 : [安卓自定义View基础-颜色](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/%E9%A2%9C%E8%89%B2/%E9%A2%9C%E8%89%B2.md)
-绘制基本形状 | drawPoint, drawPoints, drawLine, drawLines, drawRect, drawRoundRect, drawOval, drawCircle, drawArc | 依次为 点、线、矩形、圆角矩形、椭圆、圆、圆弧
-绘制图片 | drawBitmap, drawPicture | 绘制位图和图片
-绘制文本 | drawText, drawPosText, drawTextOnPath | 依次为 绘制文字、绘制文字时指定每个文字位置、根据路径绘制文字
-绘制路径 | drawPath | 绘制路径，绘制贝塞尔曲线时也需要用到该函数
-顶点操作 | drawVertices, drawBitmapMesh | 通过对顶点操作可以使图像形变，drawVertices直接对画布作用、 drawBitmapMesh只对绘制的Bitmap作用
-画布剪裁 | clipPath, clipRect | 设置画布的显示区域
-画布快照 | save, restore, saveLayerXxx, restoreToCount, getSaveCount | 依次为 保存当前状态、 回滚到上一次保存的状态、 保存图层状态、 会滚到指定状态、 获取保存次数
-画布变换 | translate, scale, rotate, skew | 依次为 位移、缩放、 旋转、倾斜
相关： [坐标系](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/%E5%9D%90%E6%A0%87%E7%B3%BB/%E5%9D%90%E6%A0%87%E7%B3%BB.md) [角度与弧度](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/%E8%A7%92%E5%BA%A6%E4%B8%8E%E5%BC%A7%E5%BA%A6/%E8%A7%92%E5%BA%A6%E4%B8%8E%E5%BC%A7%E5%BA%A6.md)
-Matrix(矩阵) | getMatrix, setMatrix, concat | 实际画布的位移，缩放等操作的都是图像矩阵Matrix，只不过Matrix比较难以理解和使用，故封装了一些常用的方法。
+# Canvas之画布操作
+
+### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
+### [【本系列相关文章】](https://github.com/GcsSloop/AndroidNote/tree/master/CustomView/README.md)
+
+上一篇[Canvas之绘制基本形状](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B02%5DCanvas_BasicGraphics.md)中我们了解了如何使用Canvas绘制基本图形，本次了解一些基本的画布操作。
+
+本来想把画布操作放到后面部分的，但是发现很多图形绘制都离不开画布操作，于是先讲解一下画布的基本操作方法。
+
+## 一.Canvas的常用操作速查表
+
+| 操作类型 | 相关API | 备注 |
+| ---------- | ---------------------------------------- | ---------------------------------------- |
+| 绘制颜色 | drawColor, drawRGB, drawARGB | 使用单一颜色填充整个画布 |
+| 绘制基本形状 | drawPoint, drawPoints, drawLine, drawLines, drawRect, drawRoundRect, drawOval, drawCircle, drawArc | 依次为 点、线、矩形、圆角矩形、椭圆、圆、圆弧 |
+| 绘制图片 | drawBitmap, drawPicture | 绘制位图和图片 |
+| 绘制文本 | drawText, drawPosText, drawTextOnPath | 依次为 绘制文字、绘制文字时指定每个文字位置、根据路径绘制文字 |
+| 绘制路径 | drawPath | 绘制路径，绘制贝塞尔曲线时也需要用到该函数 |
+| 顶点操作 | drawVertices, drawBitmapMesh | 通过对顶点操作可以使图像形变，drawVertices直接对画布作用、 drawBitmapMesh只对绘制的Bitmap作用 |
+| 画布剪裁 | clipPath, clipRect | 设置画布的显示区域 |
+| 画布快照 | save, restore, saveLayerXxx, restoreToCount, getSaveCount | 依次为 保存当前状态、 回滚到上一次保存的状态、 保存图层状态、 回滚到指定状态、 获取保存次数 |
+| 画布变换 | translate, scale, rotate, skew | 依次为 位移、缩放、 旋转、错切 |
+| Matrix(矩阵) | getMatrix, setMatrix, concat | 实际上画布的位移，缩放等操作的都是图像矩阵Matrix， 只不过Matrix比较难以理解和使用，故封装了一些常用的方法。 |
******
## 二.Canvas基本操作
-上次呢我们了解了绘制颜色和绘制基本形状，这次会了解画布变换相关操作。
-*****
### 1.画布操作
#### 为什么要有画布操作？
-画布操作可以帮助我们用更加容易理解的方式制作图形，如果你之前看过绘制太极和Canvas(1)最后的实例，你就会发现其中就有对translate的运用。
-translate 是干什么用的呢？
+画布操作可以帮助我们用更加容易理解的方式制作图形。
-上面表格中写的是"位移"，但"位移"的词义很是模糊，到底位移的是什么？那换种说法，translate是坐标系的移动，为图形绘制选择一个合适的坐标系，看下图：
+例如： 从坐标原点为起点，绘制一个长度为20dp，与水平线夹角为30度的线段怎么做？
-PS:请不要在意坐标系数值和图像的倾斜，制作软件出了一点问题，如果你有比较好的制作数学图形的软件可以推荐一下。
+按照我们通常的想法(*被常年训练出来的数学思维*)，就是先使用三角函数计算出线段结束点的坐标，然后调用drawLine即可。
-
+然而这是否是被固有思维禁锢了？
-不同的坐标系对于描述一个图形的难度实际上是不同的，就拿上图来说，假设蓝色矩形为屏幕，左侧状态为默认的坐标系，右侧为将坐标原点移动到屏幕中心的坐标系，要在屏幕中心绘制一个圆形，在左侧的坐标系中，你需要计算出圆心的位置和半径，而右侧只需知道半径即可。
+假设我们先绘制一个长度为20dp的水平线，然后将这条水平线旋转30度，则最终看起来效果是相同的，而且不用进行三角函数计算，这样是否更加简单了一点呢？
-合理的使用画布操作可以帮助你用更容易理解的方式创作你想要的效果，这也是画布操作存在的原因。
+**合理的使用画布操作可以帮助你用更容易理解的方式创作你想要的效果，这也是画布操作存在的原因。**
-下面对几种画布操作详细讲解。
+**PS: 所有的画布操作都只影响后续的绘制，对之前已经绘制过的内容没有影响。**
*****
#### ⑴位移(translate)
- 请注意，位移是基于当前位置移动，而不是每次基于屏幕左上角的(0,0)点移动，如下：
+
+ translate是坐标系的移动，可以为图形绘制选择一个合适的坐标系。
+ **请注意，位移是基于当前位置移动，而不是每次基于屏幕左上角的(0,0)点移动**，如下：
``` java
// 省略了创建画笔的代码
@@ -62,9 +61,9 @@ translate 是干什么用的呢？
canvas.drawCircle(0,0,100,mPaint);
```
-
+
-我们首先将坐标系移动一段距离绘制一个圆形，之后再移动一段距离绘制一个圆形，两次移动是叠加的。
+我们首先将坐标系移动一段距离绘制一个圆形，之后再移动一段距离绘制一个圆形，两次移动是可叠加的。
*****
#### ⑵缩放(scale)
@@ -78,19 +77,18 @@ translate 是干什么用的呢？
缩放比例(sx,sy)取值范围详解：
-取值范围(n)| 说明
---------- | ------
-[-∞, -1) | 先根据缩放中心放大n倍，再根据中心轴进行翻转
--1 | 根据缩放中心轴进行翻转
-(-1, 0) | 先根据缩放中心缩小到n，再根据中心轴进行翻转
-0 | 不会显示，若sx为0，则宽度为0，不会显示，sy同理
-(0, 1) | 根据缩放中心缩小到n
-1 | 没有变化
-(1, +∞) | 根据缩放中心放大n倍
-
-> **PS： 当取值为负数时，你也可以认为坐标系进行了翻转，不过对之前的操作不会产生影响。**
+| 取值范围(n) | 说明 |
+| ----------- | ---------------------------------------------- |
+| (-∞, -1) | 先根据缩放中心放大n倍，再根据中心轴进行翻转 |
+| -1 | 根据缩放中心轴进行翻转 |
+| (-1, 0) | 先根据缩放中心缩小到n，再根据中心轴进行翻转 |
+| 0 | 不会显示，若sx为0，则宽度为0，不会显示，sy同理 |
+| (0, 1) | 根据缩放中心缩小到n |
+| 1 | 没有变化 |
+| (1, +∞) | 根据缩放中心放大n倍 |
如果在缩放时稍微注意一下就会发现缩放的中心默认为坐标原点,而缩放中心轴就是坐标轴，如下：
+
``` java
// 将坐标系原点移动到画布正中心
canvas.translate(mWidth / 2, mHeight / 2);
@@ -107,7 +105,7 @@ translate 是干什么用的呢？
```
(为了更加直观，我添加了一个坐标系，可以比较明显的看出，缩放中心就是坐标原点)
-
+
接下来我们使用第二种方法让缩放中心位置稍微改变一下，如下：
``` java
@@ -126,7 +124,7 @@ translate 是干什么用的呢？
```
(图中用箭头指示的就是缩放中心。)
-
+
前面两个示例缩放的数值都是正数，按照表格中的说明，**当缩放比例为负数的时候会根据缩放中心轴进行翻转**，下面我们就来实验一下：
@@ -134,7 +132,7 @@ translate 是干什么用的呢？
// 将坐标系原点移动到画布正中心
canvas.translate(mWidth / 2, mHeight / 2);
- RectF rect = new RectF(0,0,400,-400); // 矩形区域
+ RectF rect = new RectF(0,-400,400,0); // 矩形区域
mPaint.setColor(Color.BLACK); // 绘制黑色矩形
canvas.drawRect(rect,mPaint);
@@ -145,7 +143,7 @@ translate 是干什么用的呢？
mPaint.setColor(Color.BLUE); // 绘制蓝色矩形
canvas.drawRect(rect,mPaint);
```
-
+
> 为了效果明显，这次我不仅添加了坐标系而且对矩形中几个重要的点进行了标注，具有相同字母标注的点是一一对应的。
@@ -157,7 +155,7 @@ translate 是干什么用的呢？
// 将坐标系原点移动到画布正中心
canvas.translate(mWidth / 2, mHeight / 2);
- RectF rect = new RectF(0,0,400,-400); // 矩形区域
+ RectF rect = new RectF(0,-400,400,0); // 矩形区域
mPaint.setColor(Color.BLACK); // 绘制黑色矩形
canvas.drawRect(rect,mPaint);
@@ -168,7 +166,7 @@ translate 是干什么用的呢？
mPaint.setColor(Color.BLUE); // 绘制蓝色矩形
canvas.drawRect(rect,mPaint);
```
-
+
> 添加了这么多的辅助内容，希望大家能够看懂。
@@ -183,6 +181,9 @@ translate 是干什么用的呢？
调用两次缩放则 x轴实际缩放为0.5x0.5=0.25 y轴实际缩放为0.5x0.1=0.05
下面我们利用这一特性制作一个有趣的图形。
+
+> 注意设置画笔模式为描边(STROKE)
+
``` java
// 将坐标系原点移动到画布正中心
canvas.translate(mWidth / 2, mHeight / 2);
@@ -196,7 +197,7 @@ translate 是干什么用的呢？
}
```
-
+
*****
#### ⑶旋转(rotate)
@@ -224,7 +225,7 @@ translate 是干什么用的呢？
canvas.drawRect(rect,mPaint);
```
-
+
改变旋转中心位置：
``` java
@@ -242,7 +243,7 @@ translate 是干什么用的呢？
canvas.drawRect(rect,mPaint);
```
-
+
好吧，旋转也是可叠加的
``` java
@@ -264,20 +265,28 @@ translate 是干什么用的呢？
canvas.rotate(10);
}
```
-
+
*****
-#### ⑷倾斜(skew)
-skew这里翻译为倾斜，有的地方也叫错切。
+#### ⑷错切(skew)
+
+skew这里翻译为错切，错切是特殊类型的线性变换。
-倾斜只提供了一种方法：
+错切只提供了一种方法：
``` java
public void skew (float sx, float sy)
```
+
参数含义：
float sx:将画布在x方向上倾斜相应的角度，sx倾斜角度的tan值，
float sy:将画布在y轴方向上倾斜相应的角度，sy为倾斜角度的tan值.
+变换后:
+```
+X = x + sx * y
+Y = sy * x + y
+```
+
示例：
``` java
// 将坐标系原点移动到画布正中心
@@ -288,14 +297,14 @@ float sy:将画布在y轴方向上倾斜相应的角度，sy为倾斜角度的ta
mPaint.setColor(Color.BLACK); // 绘制黑色矩形
canvas.drawRect(rect,mPaint);
- canvas.skew(1,0); // 在x轴倾斜45度 <-- tan45 = 1
+ canvas.skew(1,0); // 水平错切 <- 45度
mPaint.setColor(Color.BLUE); // 绘制蓝色矩形
canvas.drawRect(rect,mPaint);
```
-
+
-如你所想，倾斜也是可叠加的，不过请注意，调用次序不同绘制结果也会不同
+如你所想，错切也是可叠加的，不过请注意，调用次序不同绘制结果也会不同
``` java
// 将坐标系原点移动到画布正中心
canvas.translate(mWidth / 2, mHeight / 2);
@@ -305,45 +314,47 @@ float sy:将画布在y轴方向上倾斜相应的角度，sy为倾斜角度的ta
mPaint.setColor(Color.BLACK); // 绘制黑色矩形
canvas.drawRect(rect,mPaint);
- canvas.skew(1,0); // 在x轴倾斜45度 <-- tan45 = 1
- canvas.skew(0,1); // 在y轴倾斜45度 <-- tan45 = 1
+ canvas.skew(1,0); // 水平错切
+ canvas.skew(0,1); // 垂直错切
mPaint.setColor(Color.BLUE); // 绘制蓝色矩形
canvas.drawRect(rect,mPaint);
```
-
+
*****
#### ⑸快照(save)和回滚(restore)
-Q: 为什存在快照与回滚
+Q: 为什么存在快照与回滚
A：画布的操作是不可逆的，而且很多画布操作会影响后续的步骤，例如第一个例子，两个圆形都是在坐标原点绘制的，而因为坐标系的移动绘制出来的实际位置不同。所以会对画布的一些状态进行保存和回滚。
与之相关的API:
-相关API | 简介
---- | ---
-save | 把当前的画布的状态进行保存，然后放入特定的栈中
-saveLayerXxx | 新建一个图层，并放入特定的栈中
-restore | 把栈中最顶层的画布状态取出来，并按照这个状态恢复当前的画布
-restoreToCount| 弹出指定位置及其以上所有的状态，并按照指定位置的状态进行恢复
-getSaveCount | 获取栈中内容的数量(即保存次数)
+| 相关API | 简介 |
+| -------------- | ------------------------------ |
+| save | 把当前的画布的状态进行保存，然后放入特定的栈中 |
+| saveLayerXxx | 新建一个图层，并放入特定的栈中 |
+| restore | 把栈中最顶层的画布状态取出来，并按照这个状态恢复当前的画布 |
+| restoreToCount | 弹出指定位置及其以上所有的状态，并按照指定位置的状态进行恢复 |
+| getSaveCount | 获取栈中内容的数量(即保存次数) |
下面对其中的一些概念和方法进行分析：
##### 状态栈：
其实这个栈我也不知道叫什么名字，暂时叫做状态栈吧，它看起来像下面这样：
-
+
这个栈可以存储画布状态和图层状态。
Q：什么是画布和图层？
A：实际上我们看到的画布是由多个图层构成的，如下图(图片来自网络)：
-
+
+
+
实际上我们之前讲解的绘制操作和画布操作都是在默认图层上进行的。
在通常情况下，使用默认图层就可满足需求，但是如果需要绘制比较复杂的内容，如地图(地图可以有多个地图层叠加而成，比如：政区层，道路层，兴趣点层)等，则分图层绘制比较好一些。
你可以把这些图层看做是一层一层的玻璃板，你在每层的玻璃板上绘制内容，然后把这些玻璃板叠在一起看就是最终效果。
@@ -351,14 +362,14 @@ A：实际上我们看到的画布是由多个图层构成的，如下图(图片
##### SaveFlags
-数据类型 | 名称 | 简介
---- | --- | ---
-int | ALL_SAVE_FLAG | 默认，保存全部状态
-int | CLIP_SAVE_FLAG | 保存剪辑区
-int | CLIP_TO_LAYER_SAVE_FLAG | 剪裁区作为图层保存
-int | FULL_COLOR_LAYER_SAVE_FLAG | 保存图层的全部色彩通道
-int | HAS_ALPHA_LAYER_SAVE_FLAG | 保存图层的alpha(不透明度)通道
-int | MATRIX_SAVE_FLAG | 保存Matrix信息(translate, rotate, scale, skew)
+| 数据类型 | 名称 | 简介 |
+| ---- | -------------------------- | ---------------------------------------- |
+| int | ALL_SAVE_FLAG | 默认，保存全部状态 |
+| int | CLIP_SAVE_FLAG | 保存剪辑区 |
+| int | CLIP_TO_LAYER_SAVE_FLAG | 剪裁区作为图层保存 |
+| int | FULL_COLOR_LAYER_SAVE_FLAG | 保存图层的全部色彩通道 |
+| int | HAS_ALPHA_LAYER_SAVE_FLAG | 保存图层的alpha(不透明度)通道 |
+| int | MATRIX_SAVE_FLAG | 保存Matrix信息(translate, rotate, scale, skew) |
##### save
save 有两种方法：
@@ -425,14 +436,15 @@ public int saveLayerAlpha (float left, float top, float right, float bottom, int
如本文一开始所说，合理的使用画布操作可以帮助你用更容易理解的方式创作你想要的效果。
-其实之前准备在画布操作后再讲一些图片 文字 路径相关内容的， 但是没想到画布操作居然有这么多东西，这还是在没讲解Matrix的情况下。
-
(,,• ₃ •,,)
-这次就先讲这么多吧。
-
PS: 由于本人英文水平有限，某些地方可能存在误解或词语翻译不准确，如果你对此有疑问可以提交Issues进行反馈。
+## About Me
+### 作者微博: @GcsSloop
+
+
+
******
## 四.参考资料
@@ -441,7 +453,6 @@ public int saveLayerAlpha (float left, float top, float right, float bottom, int
[Canvas之translate、scale、rotate、skew方法讲解](http://blog.csdn.net/tianjian4592/article/details/45234419)
[Canvas的save(),saveLayer()和restore()浅谈](http://www.cnblogs.com/liangstudyhome/p/4143498.html)
[Graphics->Layers](http://www.programgo.com/article/72302404062/;jsessionid=8E62016408BFFB21D46F9C878A49D8EE)
-[AndroidのCanvasを使いこなす](http://tech.recruit-mp.co.jp/mobile/remember_canvas1/)
[]()
[]()
diff --git "a/\351\227\256\351\242\230/Canvas/Canvas(3).md" b/CustomView/Advance/[04]Canvas_PictureText.md
similarity index 59%
rename from "\351\227\256\351\242\230/Canvas/Canvas(3).md"
rename to CustomView/Advance/[04]Canvas_PictureText.md
index 945b1f7b..06bffcd5 100644
--- "a/\351\227\256\351\242\230/Canvas/Canvas(3).md"
+++ b/CustomView/Advance/[04]Canvas_PictureText.md
@@ -1,487 +1,508 @@
-# Canvas基础三
-### 讲解安卓中的Canvas基础内容。
-### 作者微博: [@攻城师sloop](http://weibo.com/5459430586)
-
-Canvas的内容确实有点多，这次接着了解其他相关内容。
-
-# 一.Canvas常用操作表
-
-操作类型 | 相关API | 备注
---- | --- | ---
-绘制颜色 | drawColor, drawRGB, drawARGB | 使用单一颜色填充整个画布
相关 : [安卓自定义View基础-颜色](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/%E9%A2%9C%E8%89%B2/%E9%A2%9C%E8%89%B2.md)
-绘制基本形状 | drawPoint, drawPoints, drawLine, drawLines, drawRect, drawRoundRect, drawOval, drawCircle, drawArc | 依次为 点、线、矩形、圆角矩形、椭圆、圆、圆弧
-绘制图片 | drawBitmap, drawPicture | 绘制位图和图片
-绘制文本 | drawText, drawPosText, drawTextOnPath | 依次为 绘制文字、绘制文字时指定每个文字位置、根据路径绘制文字
-绘制路径 | drawPath | 绘制路径，绘制贝塞尔曲线时也需要用到该函数
-顶点操作 | drawVertices, drawBitmapMesh | 通过对顶点操作可以使图像形变，drawVertices直接对画布作用、 drawBitmapMesh只对绘制的Bitmap作用
-画布剪裁 | clipPath, clipRect | 设置画布的显示区域
-画布快照 | save, restore, saveLayerXxx, restoreToCount, getSaveCount | 依次为 保存当前状态、 回滚到上一次保存的状态、 保存图层状态、 会滚到指定状态、 获取保存次数
-画布变换 | translate, scale, rotate, skew | 依次为 位移、缩放、 旋转、倾斜
相关： [坐标系](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/%E5%9D%90%E6%A0%87%E7%B3%BB/%E5%9D%90%E6%A0%87%E7%B3%BB.md) [角度与弧度](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/%E8%A7%92%E5%BA%A6%E4%B8%8E%E5%BC%A7%E5%BA%A6/%E8%A7%92%E5%BA%A6%E4%B8%8E%E5%BC%A7%E5%BA%A6.md)
-Matrix(矩阵) | getMatrix, setMatrix, concat | 实际画布的位移，缩放等操作的都是图像矩阵Matrix，只不过Matrix比较难以理解和使用，故封装了一些常用的方法。
-
-******
-# 二.Canvas基本操作详解
-
-上次讲解了画布相关的一些操作，这次讲解绘制图片 文字 等一些基本操作。
-
-## 1.绘制图片
-
-绘制有两种方法，drawPicture 和 drawBitmap,接下来我们一一了解。
-
-### (1)drawPicture
-
-**使用Picture前请关闭硬件加速，以免引起不必要的问题！
使用Picture前请关闭硬件加速，以免引起不必要的问题！
使用Picture前请关闭硬件加速，以免引起不必要的问题！**
-
-**重要的话说三遍！
如何关闭请参考这里：[Android的硬件加速及可能导致的问题](https://github.com/GcsSloop/AndroidNote/issues/7)**
-
-关于drawPicture一开始还是挺让人费解的，不过嘛，我们接下来慢慢研究一下它的用途。
-
-既然是drawPicture就要了解一下什么是**Picture**。 顾名思义，Picture的意思是图片。
-
-不过嘛，我觉得这么用图片这个名词解释Picture是不合适的，为何这么说？请看其官方文档对[Picture](http://developer.android.com/reference/android/graphics/Picture.html)的解释：
-
-
-A Picture records drawing calls (via the canvas returned by beginRecording) and can then play them back into Canvas (via draw(Canvas) or drawPicture(Picture)).For most content (e.g. text, lines, rectangles), drawing a sequence from a picture can be faster than the equivalent API calls, since the picture performs its playback without incurring any method-call overhead.
-
-
-好吧，我知道很多人对这段鸟语是看不懂的，至于为什么要放在这里，仅仅是为了显得更加专业(偷笑)。
-
-下面我就对这段不明觉厉的鸟语用通俗的话翻译一下:
-
-某一天小萌想在朋友面前显摆一下，于是在单杠上来了一个后空翻,动作姿势请参照下图：
-
-
-
-朋友都说 恩，很不错。 想再看一遍 (〃ω〃)。ヽ(〃∀〃)ﾉ。⁄(⁄ ⁄•⁄ω⁄•⁄ ⁄)⁄
-
-于是小萌又来了一遍，如是几次之后，小萌累的吐血三升。
-
-于是小萌机智的想，我何不用手机录下来呢，直接保存成为后空翻.avi 下次想显摆的时候直接拿出手机，点一下播放就行了，省时省力。
-
-小萌被自己的机智深深的折服了，然后Picture就诞生啦。(╯‵□′)╯︵┻━┻掀桌，坑爹呢，这剧情跳跃也忒大了吧。
-
-
-好吧，言归正传，这次我们了解的Picture和上文中的录像功能是类似的，只不过我们Picture录的是Canvas中绘制的内容。
-我们把Canvas绘制点，线，矩形等诸多操作用Picture录制下来，下次需要的时候拿来就能用，使用Picture相比于再次调用绘图API，开销是比较小的，也就是说对于重复的操作可以更加省时省力。
-
-
-PS：你可以把Picture看作是一个录制Canvas操作的录像机。
-
-了解了Picture的概念之后，我们再了解一下Picture的相关方法。
-
-相关方法 | 简介
---- | ---
-public int getWidth () | 获取宽度
-public int getHeight () | 获取高度
-public Canvas beginRecording (int width, int height) | 开始录制 (返回一个Canvas，在Canvas中所有的绘制都会存储在Picture中)
-public void endRecording () | 结束录制
-public void draw (Canvas canvas) | 将Picture中内容绘制到Canvas中
-public static Picture createFromStream (InputStream stream) | (已废弃)通过输入流创建一个Picture
-public void writeToStream (OutputStream stream) | (已废弃)将Picture中内容写出到输出流中
-
-上面表格中基本上已经列出了Picture的所有方法，其中getWidth和getHeight没什么好说的，最后两个已经废弃也自然就不用关注了，排除了这些方法之后，只剩三个方法了，接下来我们就比较详细的了解一下：
-
-**很明显，beginRecording 和 endRecording 是成对使用的，一个开始录制，一个是结束录制，两者之间的操作将会存储在Picture中。**
-
-#### 使用示例：
-
-**准备工作:**
-``` java
- // 1.创建Picture
- private Picture mPicture = new Picture();
-
----------------------------------------------------------------
-
- // 2.录制内容方法
- private void recording() {
- // 开始录制 (接收返回值Canvas)
- Canvas canvas = mPicture.beginRecording(500, 500);
- // 创建一个画笔
- Paint paint = new Paint();
- paint.setColor(Color.BLUE);
- paint.setStyle(Paint.Style.FILL);
-
- // 在Canvas中具体操作
- // 位移
- canvas.translate(250,250);
- // 绘制一个圆
- canvas.drawCircle(0,0,100,paint);
-
- mPicture.endRecording();
- }
-
----------------------------------------------------------------
-
- // 3.在使用前调用(我在构造函数中调用了)
- public Canvas3(Context context, AttributeSet attrs) {
- super(context, attrs);
-
- recording(); // 调用录制
- }
-
-```
-
-**具体使用:**
-
-Picture虽然方法就那么几个，但是具体使用起来还是分很多情况的，总体上可以分为以下几种：
-
-序号 | 简介
---- | ---
-1 | 使用Picture提供的draw方法绘制。
-2 | 使用Canvas提供的drawPicture方法绘制。
-3 | 将Picture包装成为PictureDrawable，使用PictureDrawable的draw方法绘制。
-
-
-以上几种方法主要区别：
-
-主要区别 | 分类 | 简介
---- | --- | ---
-是否对Canvas有影响 | 1有影响
2,3不影响 | 此处指绘制完成后是否会影响Canvas的状态(Matrix clip等)
-可操作性强弱 | 1可操作性较弱
2,3可操作性较强 | 此处的可操作性可以简单理解为对绘制结果可控程度。
-
-几种方法简介和主要区别我知道的就这么多了，接下来对于各种使用方法一一详细介绍：
-
-**1.使用Picture提供的draw方法绘制:**
-``` java
- // 将Picture中的内容绘制在Canvas上
- mPicture.draw(canvas);
-```
-
-
-
-**PS：这种方法在比较低版本的系统上绘制后可能会影响Canvas状态，所以这种方法一般不会使用。**
-
-**2.使用Canvas提供的drawPicture方法绘制**
-
-drawPicture有三种方法：
-``` java
-public void drawPicture (Picture picture)
-
-public void drawPicture (Picture picture, Rect dst)
-
-public void drawPicture (Picture picture, RectF dst)
-```
-和使用Picture的draw方法不同，Canvas的drawPicture不会影响Canvas状态。
-
-**简单示例:**
-``` java
- canvas.drawPicture(mPicture,new RectF(0,0,mPicture.getWidth(),200));
-```
-
-
-
- **PS:对照上一张图片，可以比较明显的看出，绘制的内容根据选区进行了缩放。 **
-
-**3.将Picture包装成为PictureDrawable，使用PictureDrawable的draw方法绘制。**
-```
- // 包装成为Drawable
- PictureDrawable drawable = new PictureDrawable(mPicture);
- // 设置绘制区域 -- 注意此处所绘制的实际内容不会缩放，而是相当于剪裁
- drawable.setBounds(0,0,250,mPicture.getHeight());
- // 绘制
- drawable.draw(canvas);
-```
-
-
-
-**PS:此处setBounds相当于剪裁显示区域，并非根据该区域进行缩放。**
-
-> **注意：在使用Picture之前请关闭硬件加速，以免引起不必要的问题，如何关闭请参考这里： [Android的硬件加速及可能导致的问题](https://github.com/GcsSloop/AndroidNote/issues/7)**
-
-### (2)drawBitmap
-
- > 其实一开始知道要讲Bitmap我是拒绝的，为什么呢？因为Bitmap就是很多问题的根源啊有木有，Bitmap可能导致内存不足，内存泄露，ListView中的复用混乱等诸多问题。想完美的掌控Bitmap还真不是一件容易的事情。限于篇幅**本文对于Bitmap不会过多的展开，只讲解一些常用的功能**，关于Bitmap详细内容，以后开专题讲解QAQ。
-
- 既然要绘制Bitmap，就要先获取一个Bitmap，那么如何获取呢？
-
- **获取Bitmap方式:**
-
- 序号 | 获取方式 | 备注
- --- | --- | ---
- 1 | 通过Bitmap创建 | 复制一个已有的Bitmap(_新Bitmap状态和原有的一致_) 或者 创建一个空白的Bitmap(_内容可改变_)
- 2 | 通过BitmapDrawable获取 | 从资源文件 内存卡 网络等地方获取一张图片并转换为内容不可变的Bitmap
- 3 | 通过BitmapFactory获取 | 从资源文件 内存卡 网络等地方获取一张图片并转换为内容不可变的Bitmap
-
-**通常来说，我们绘制Bitmap都是读取已有的图片转换为Bitmap绘制到Canvas上。**
-很明显，第1种方式不能满足我们的要求，暂时排除。
-第2种方式虽然也可满足我们的要求，但是我不推荐使用这种方式，至于为什么在后续详细讲解Drawable的时候会说明,暂时排除。
-第3种方法我们会比较详细的说明一下如何从各个位置获取图片。
-
-#### 通过BitmapFactory从不同位置获取Bitmap:
-
-**资源文件(drawable/mipmap/raw):**
-``` java
- Bitmap bitmap = BitmapFactory.decodeResource(mContext.getResources(),R.raw.bitmap);
-```
-**资源文件(assets):**
-``` java
- Bitmap bitmap=null;
- try {
- InputStream is = mContext.getAssets().open("bitmap.png");
- bitmap = BitmapFactory.decodeStream(is);
- is.close();
- } catch (IOException e) {
- e.printStackTrace();
- }
-```
-
-**内存卡文件:**
-``` java
- Bitmap bitmap = BitmapFactory.decodeFile("/sdcard/bitmap.png");
-```
-
-**网络文件:**
-``` java
- // 此处省略了获取网络输入流的代码
- Bitmap bitmap = BitmapFactory.decodeStream(is);
- is.close();
-```
-
-既然已经获得到了Bitmap，那么就开始本文的重点了，将Bitmap绘制到画布上。
-#### 绘制Bitmap：
-依照惯例先预览一下drawBitmap的常用方法：
-``` java
- // 第一种
- public void drawBitmap (Bitmap bitmap, Matrix matrix, Paint paint)
-
- // 第二种
- public void drawBitmap (Bitmap bitmap, float left, float top, Paint paint)
-
- // 第三种
- public void drawBitmap (Bitmap bitmap, Rect src, Rect dst, Paint paint)
- public void drawBitmap (Bitmap bitmap, Rect src, RectF dst, Paint paint)
-```
-
-第一种方法中后两个参数(matrix, paint)是在绘制的时候对图片进行一些改变，如果只是需要将图片内容绘制出来只需要如下操作就可以了：
-
-PS:图片左上角位置默认为坐标原点。
-``` java
- canvas.drawBitmap(bitmap,new Matrix(),new Paint());
-```
-> 关于Matrix和Paint暂时略过吧，一展开又是啰啰嗦嗦一大段，反正挖坑已经是常态了，大家应该也习惯了(PAP).
-
-
-
-第二种方法就是在绘制时指定了图片左上角的坐标(距离坐标原点的距离)：
-
-> **注意：此处指定的是与坐标原点的距离，并非是与屏幕顶部和左侧的距离, 虽然默认状态下两者是重合的，但是也请注意分别两者的不同。**
-``` java
- canvas.drawBitmap(bitmap,200,500,new Paint());
-```
-
-
-第三种方法比较有意思，上面多了两个矩形区域(src,dst),这两个矩形选区是干什么用的？
-
-名称 | 作用
---- | ---
-Rect src | 指定绘制图片的区域
-Rect dst
或RectF dst | 指定图片在屏幕上显示(绘制)的区域
-
-示例：
-``` java
- // 将画布坐标系移动到画布中央
- canvas.translate(mWidth/2,mHeight/2);
-
- // 指定图片绘制区域(左上角的四分之一)
- Rect src = new Rect(0,0,bitmap.getWidth()/2,bitmap.getHeight()/2);
-
- // 指定图片在屏幕上显示的区域
- Rect dst = new Rect(0,0,200,400);
-
- // 绘制图片
- canvas.drawBitmap(bitmap,src,dst,null);
-```
-
-
-**详解：**
-
-上面是以绘制该图为例，用src指定了图片绘制部分的区域，即下图中红色方框标注的区域。
-
-
-
-然后用dst指定了绘制在屏幕上的绘制，即下图中蓝色方框标注的区域，图片宽高会根据指定的区域自动进行缩放。
-
-
-从上面可知，第三种方法可以绘制图片的一部分到画布上，这有什么用呢？
-
-如果你看过某些游戏的资源文件，你可能会看到如下的图片(图片来自网络)：
-
-
-
-用一张图片包含了大量的素材，在绘制的时候每次只截取一部分进行绘制，这样可以大大的减少素材数量，而且素材管理起来也很方便。
-
-然而这和我们有什么关系呢？我们又不做游戏开发。
-
-确实，我们不做游戏开发，但是在某些时候我们需要制作一些炫酷的效果，这些效果因为太复杂了用代码很难实现或者渲染效率不高。这时候很多人就会想起帧动画，将动画分解成一张一张的图片然后使用帧动画制作出来，这种实现方式的确比较简单，但是一个动画效果的图片有十几到几十张，一个应用里面来几个这样炫酷的动画效果就会导致资源文件出现一大堆，想找其中的某一张资源图片简直就是灾难啊有木有。但是把同一个动画效果的所有资源图片整理到一张图片上，会大大的减少资源文件数量，方便管理，妈妈再也不怕我找不到资源文件了。
-
-**下面是利用drawBitmap第三种方法制作的一个简单示例：**
-
-资源文件如下：
-
-
-
-最终效果如下：
-
-
-
-源码如下：
-
-> PS:由于是示例代码，做的很粗糙，仅作为学习示例，不建议在任何实际项目中使用。
-
-[_点击此处查看源码_](https://github.com/GcsSloop/AndroidNote/issues/10)
-
-## 2.绘制文字
-依旧预览一下相关常用方法：
-``` java
- // 第一类
- public void drawText (String text, float x, float y, Paint paint)
- public void drawText (String text, int start, int end, float x, float y, Paint paint)
- public void drawText (CharSequence text, int start, int end, float x, float y, Paint paint)
- public void drawText (char[] text, int index, int count, float x, float y, Paint paint)
-
- // 第二类
- public void drawPosText (String text, float[] pos, Paint paint)
- public void drawPosText (char[] text, int index, int count, float[] pos, Paint paint)
-
- // 第三类
- public void drawTextOnPath (String text, Path path, float hOffset, float vOffset, Paint paint)
- public void drawTextOnPath (char[] text, int index, int count, Path path, float hOffset, float vOffset, Paint paint)
-```
-> PS 其中的CharSequence和String的区别可以到这里看看. [->戳这里<-](https://github.com/GcsSloop/AndroidNote/issues/16)
-
-绘制文字部分大致可以分为三类：
-
-第一类只能指定文本左上角位置。
-第二类可以分别指定每个文字的位置。
-第三类是指定一个路径，根据路径绘制文字。
-
-通过上面常用方法的参数也可看出，绘制文字也是需要画笔的，而且文字的大小,颜色,字体,对齐方式都是由画笔控制的。
-
-不过嘛这里仅简单介绍几种常用方法(反正挖坑多了也不怕)，具体在讲解Paint时再详细讲解。
-
-**Paint文本相关常用方法表**
-
-标题 | 相关方法 | 备注
---- | --- | ---
-色彩 | setColor setARGB setAlpha | 设置颜色，透明度
-大小 | setTextSize | 设置文本字体大小
-字体 | setTypeface | 设置或清除字体样式
-样式 | setStyle | 填充(FILL),描边(STROKE),填充加描边(FILL_AND_STROKE)
-对齐 | setTextAlign | 左对齐(LEFT),居中对齐(CENTER),右对齐(RIGHT)
-测量 | measureText | 测量文本大小(注意，请在设置完文本各项参数后调用)
-
-为了绘制文本，我们先创建一个文本画笔：
-``` java
- Paint textPaint = new Paint(); // 创建画笔
- textPaint.setColor(Color.BLACK); // 设置颜色
- textPaint.setStyle(Paint.Style.FILL); // 设置样式
- textPaint.setTextSize(50); // 设置字体大小
-```
-
-### 第一类(drawText)
-第一类可以指定文本开始的位置，可以截取文本中部分内容进行绘制。
-
-很明显，其中x，y两个参数是指定文本绘制的起始位置,示例：
-``` java
-
- // 文本(要绘制的内容)
- String str = "ABCDEFGHIJK";
-
- // 参数分别为 (文本 x轴坐标 y轴坐标 画笔)
- canvas.drawText(str,200,500,textPaint);
-```
-
-
-当然啦，除了能指定绘制文本的起始位置，还能只取出文本中的一部分内容进行绘制。
-
-截取文本中的一部分，对于String和CharSequence来说只指定字符串下标start和end位置(**注意：0<= start < end < str.length()**)
-
-以上一个例子使用的字符串为例，它的下标是这样的(wait，我为啥要说这个，算了，不管了，就这样吧(๑•́ ₃ •̀๑)):
-
-字符 | A | B | C | D | E | F | G | H | I | J | K
- ---|---|---|---|---|---|---|---|---|---|---|---
-下标 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10
-
-假设我我们指定star为1，end为3，那么最终截取的字符串就是"BC"。
-
-一般来说，**使用start和end指定的区间是前闭后开的，即包含start指定的下标，而不包含end指定的下标**，故[1,3)最后获取到的下标只有 下标1 和 下标2 的字符，就是"BC".
-
-示例：
-``` java
- // 文本(要绘制的内容)
- String str = "ABCDEFGHIJK";
- // 参数分别为 (字符串 开始截取位置 结束截取位置 x轴坐标 y轴坐标 画笔)
- canvas.drawText(str,1,3,200,500,textPaint);
-```
-
-
-另外，对于字符数组char[]我们截取字符串使用起始位置(index)和长度(count)来确定。
-
-同样，我们指定index为1，count为3，那么最终截取到的字符串是"BCD".
-
-其实就是从下标位置为1处向后数3位就是截取到的字符串，示例：
-``` java
- // 字符数组(要绘制的内容)
- char[] chars = "ABCDEFGHIJK".toCharArray();
-
- // 参数为 (字符数组 起始坐标 截取长度 x轴坐标 y轴坐标 画笔)
- canvas.drawText(chars,1,3,200,500,textPaint);
-```
-
-
-### 第二类(drawPosText)
-
-通过和第一类比较，我们可以发现，第二类中没有指定x，y坐标的参数，而是出现了这样一个参数**float[] pos**。
-
-好吧，这个名为pos的浮点型数组就是指定坐标的，至于为啥要用数组嘛，因为这家伙野心比较大，想给每个字符都指定一个位置。
-
-示例：
-``` java
- String str = "SLOOP";
-
- canvas.drawPosText(str,new float[]{
- 100,100, // 第一个字符位置
- 200,200, // 第二个字符位置
- 300,300, // ...
- 400,400,
- 500,500
- },textPaint);
-```
-
-
-不过嘛，虽然虽然这个方法也比较容易理解，但是关于这个方法我个人是不推荐使用的，因为坑比较的，主要有一下几点：
-
-序号 | 反对理由
---- | ---
-1 | 必须指定所有字符位置，否则直接crash掉，反人类设计
-2 | 性能不佳，在大量使用的时候可能导致卡顿
-3 | 不支持emoji等特殊字符，不支持字形组合与分解
-
-关于第二类的第二种方法：
-``` java
-public void drawPosText (char[] text, int index, int count, float[] pos, Paint paint)
-```
-和上面一样，就是从字符数组中切出来一段进行绘制，相信以诸位看官的聪明才智一眼就看出来了，我这里就不多说了，真的不是我偷懒啊(ˉ▽￣～) ~~
-
-### 第三类(drawTextOnPath)
-
-第三类要用到path这个大杀器，作为一个厉害角色怎么能这么轻易露脸呢，先保持一下神秘感，也就是说，下回再和大家见面喽。
-
-# 三.总结
-
-学会了图片和文字绘制，对于大部分自定义View都能制作了，可以去看看这位大神制作的作品，尝试模仿一下[一个绚丽的loading动效分析与实现！](http://blog.csdn.net/tianjian4592/article/details/44538605)
-
-
-
-(,,• ₃ •,,)
-
-PS: 由于本人英文水平有限，某些地方可能存在误解或词语翻译不准确，如果你对此有疑问可以提交Issues进行反馈。
-
-# 四.参考资料
-
-[Canvas](http://developer.android.com/reference/android/graphics/Canvas.html)
-[Bitmap](http://developer.android.com/reference/android/graphics/Bitmap.html)
-[Paint](http://developer.android.com/reference/android/graphics/Paint.html)
-[Android ApiDemo 笔记（一）Content与Graphics](http://blog.csdn.net/wufenglong/article/details/5596402)
-
-
+# Canvas之图片文字
+
+### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
+### [【本系列相关文章】](https://github.com/GcsSloop/AndroidNote/tree/master/CustomView/README.md)
+
+在上一篇文章[Canvas之画布操作](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B03%5DCanvas_Convert.md)中我们了解了画布的一些基本操作方法，本次了解一些绘制图片文字相关的内容。如果你对前几篇文章讲述的内容熟练掌握的话，那么恭喜你，本篇结束之后，大部分的自定义View已经难不倒你了，当然了，这并不是终点，接下来还会有更加炫酷的技能。
+
+## 一.Canvas的常用操作速查表
+
+| 操作类型 | 相关API | 备注 |
+| ---------- | ---------------------------------------- | ---------------------------------------- |
+| 绘制颜色 | drawColor, drawRGB, drawARGB | 使用单一颜色填充整个画布 |
+| 绘制基本形状 | drawPoint, drawPoints, drawLine, drawLines, drawRect, drawRoundRect, drawOval, drawCircle, drawArc | 依次为 点、线、矩形、圆角矩形、椭圆、圆、圆弧 |
+| 绘制图片 | drawBitmap, drawPicture | 绘制位图和图片 |
+| 绘制文本 | drawText, drawPosText, drawTextOnPath | 依次为 绘制文字、绘制文字时指定每个文字位置、根据路径绘制文字 |
+| 绘制路径 | drawPath | 绘制路径，绘制贝塞尔曲线时也需要用到该函数 |
+| 顶点操作 | drawVertices, drawBitmapMesh | 通过对顶点操作可以使图像形变，drawVertices直接对画布作用、 drawBitmapMesh只对绘制的Bitmap作用 |
+| 画布剪裁 | clipPath, clipRect | 设置画布的显示区域 |
+| 画布快照 | save, restore, saveLayerXxx, restoreToCount, getSaveCount | 依次为 保存当前状态、 回滚到上一次保存的状态、 保存图层状态、 回滚到指定状态、 获取保存次数 |
+| 画布变换 | translate, scale, rotate, skew | 依次为 位移、缩放、 旋转、错切 |
+| Matrix(矩阵) | getMatrix, setMatrix, concat | 实际上画布的位移，缩放等操作的都是图像矩阵Matrix， 只不过Matrix比较难以理解和使用，故封装了一些常用的方法。 |
+
+******
+# 二.Canvas基本操作详解
+
+## 1.绘制图片
+
+绘制有两种方法，drawPicture(矢量图) 和 drawBitmap(位图),接下来我们一一了解。
+
+### (1)drawPicture
+
+**使用Picture前请关闭硬件加速，以免引起不必要的问题！
使用Picture前请关闭硬件加速，以免引起不必要的问题！
使用Picture前请关闭硬件加速，以免引起不必要的问题！**
+
+**在AndroidMenifest文件中application节点下添上 android:hardwareAccelerated="false"以关闭整个应用的硬件加速。
更多请参考这里：[Android的硬件加速及可能导致的问题](https://github.com/GcsSloop/AndroidNote/issues/7)**
+
+关于drawPicture一开始还是挺让人费解的，不过嘛，我们接下来慢慢研究一下它的用途。
+
+既然是drawPicture就要了解一下什么是Picture。 顾名思义，Picture的意思是图片。
+
+不过嘛，我觉得这么用图片这个名词解释Picture是不合适的，为何这么说？请看其官方文档对[Picture](http://developer.android.com/reference/android/graphics/Picture.html)的解释：
+
+
+A Picture records drawing calls (via the canvas returned by beginRecording) and can then play them back into Canvas (via draw(Canvas) or drawPicture(Picture)).For most content (e.g. text, lines, rectangles), drawing a sequence from a picture can be faster than the equivalent API calls, since the picture performs its playback without incurring any method-call overhead.
+
+
+好吧，我知道很多人对这段鸟语是看不懂的，至于为什么要放在这里，仅仅是为了显得更加专业(偷笑)。
+
+**下面我就对这段不明觉厉的鸟语用通俗的话翻译一下:**
+
+某一天小萌想在朋友面前显摆一下，于是在单杠上来了一个后空翻,动作姿势请参照下图：
+
+
+
+朋友都说 恩，很不错。 想再看一遍 (〃ω〃)。ヽ(〃∀〃)ﾉ。⁄(⁄ ⁄•⁄ω⁄•⁄ ⁄)⁄
+
+于是小萌又来了一遍，如是几次之后，小萌累的吐血三升。
+
+于是小萌机智的想，我何不能用手机将我是飒爽英姿录下来呢，直接保存成为**后空翻.avi** 下次想显摆的时候直接拿出手机，点一下播放就行了，省时省力。
+
+小萌被自己的机智深深的折服了，然后Picture就诞生啦。(╯‵□′)╯︵┻━┻掀桌，坑爹呢，这剧情跳跃也忒大了吧。
+
+
+**好吧，言归正传，这次我们了解的Picture和上文中的录像功能是类似的，只不过我们Picture录的是Canvas中绘制的内容。**
+
+我们把Canvas绘制点，线，矩形等诸多操作用Picture录制下来，下次需要的时候拿来就能用，使用Picture相比于再次调用绘图API，开销是比较小的，也就是说对于重复的操作可以更加省时省力。
+
+**PS：你可以把Picture看作是一个录制Canvas操作的录像机。**
+
+了解了Picture的概念之后，我们再了解一下Picture的相关方法。
+
+| 相关方法 | 简介 |
+| ---------------------------------------- | ---------------------------------------- |
+| public int getWidth () | 获取宽度 |
+| public int getHeight () | 获取高度 |
+| public Canvas beginRecording (int width, int height) | 开始录制 (返回一个Canvas，在Canvas中所有的绘制都会存储在Picture中) |
+| public void endRecording () | 结束录制 |
+| public void draw (Canvas canvas) | 将Picture中内容绘制到Canvas中 |
+| public static Picture createFromStream (InputStream stream) | (已废弃)通过输入流创建一个Picture |
+| public void writeToStream (OutputStream stream) | (已废弃)将Picture中内容写出到输出流中 |
+
+上面表格中基本上已经列出了Picture的所有方法，其中getWidth和getHeight没什么好说的，最后两个已经废弃也自然就不用关注了，排除了这些方法之后，只剩三个方法了，接下来我们就比较详细的了解一下：
+
+**很明显，beginRecording 和 endRecording 是成对使用的，一个开始录制，一个是结束录制，两者之间的操作将会存储在Picture中。**
+
+#### 使用示例：
+
+**准备工作:**
+
+录制内容，即将一些Canvas操作用Picture存储起来，录制的内容是不会直接显示在屏幕上的，只是存储起来了而已。
+
+``` java
+ // 1.创建Picture
+ private Picture mPicture = new Picture();
+
+---------------------------------------------------------------
+
+ // 2.录制内容方法
+ private void recording() {
+ // 开始录制 (接收返回值Canvas)
+ Canvas canvas = mPicture.beginRecording(500, 500);
+ // 创建一个画笔
+ Paint paint = new Paint();
+ paint.setColor(Color.BLUE);
+ paint.setStyle(Paint.Style.FILL);
+
+ // 在Canvas中具体操作
+ // 位移
+ canvas.translate(250,250);
+ // 绘制一个圆
+ canvas.drawCircle(0,0,100,paint);
+
+ mPicture.endRecording();
+ }
+
+---------------------------------------------------------------
+
+ // 3.在使用前调用(我在构造函数中调用了)
+ public Canvas3(Context context, AttributeSet attrs) {
+ super(context, attrs);
+
+ recording(); // 调用录制
+ }
+
+```
+
+**具体使用:**
+
+Picture虽然方法就那么几个，但是具体使用起来还是分很多情况的，由于录制的内容不会直接显示，就像存储的视频不点击播放不会自动播放一样，同样，想要将Picture中的内容显示出来就需要手动调用播放(绘制)，将Picture中的内容绘制出来可以有以下几种方法：
+
+| 序号 | 简介 |
+| ---- | ---------------------------------------- |
+| 1 | 使用Picture提供的draw方法绘制。 |
+| 2 | 使用Canvas提供的drawPicture方法绘制。 |
+| 3 | 将Picture包装成为PictureDrawable，使用PictureDrawable的draw方法绘制。 |
+
+
+以上几种方法主要区别：
+
+| 主要区别 | 分类 | 简介 |
+| ------------ | --------------------- | ------------------------------------ |
+| 是否对Canvas有影响 | 1有影响
2,3不影响 | 此处指绘制完成后是否会影响Canvas的状态(Matrix clip等) |
+| 可操作性强弱 | 1可操作性较弱
2,3可操作性较强 | 此处的可操作性可以简单理解为对绘制结果可控程度。 |
+
+几种方法简介和主要区别基本就这么多了，接下来对于各种使用方法一一详细介绍：
+
+**1.使用Picture提供的draw方法绘制:**
+``` java
+ // 将Picture中的内容绘制在Canvas上
+ mPicture.draw(canvas);
+```
+
+
+
+**PS：这种方法在比较低版本的系统上绘制后可能会影响Canvas状态，所以这种方法一般不会使用。**
+
+**2.使用Canvas提供的drawPicture方法绘制**
+
+drawPicture有三种方法：
+``` java
+public void drawPicture (Picture picture)
+
+public void drawPicture (Picture picture, Rect dst)
+
+public void drawPicture (Picture picture, RectF dst)
+```
+和使用Picture的draw方法不同，Canvas的drawPicture不会影响Canvas状态。
+
+**简单示例:**
+
+``` java
+ canvas.drawPicture(mPicture,new RectF(0,0,mPicture.getWidth(),200));
+```
+
+
+
+ **PS:对照上一张图片，可以比较明显的看出，绘制的内容根据选区进行了缩放。 **
+
+**3.将Picture包装成为PictureDrawable，使用PictureDrawable的draw方法绘制。**
+
+```
+ // 包装成为Drawable
+ PictureDrawable drawable = new PictureDrawable(mPicture);
+ // 设置绘制区域 -- 注意此处所绘制的实际内容不会缩放
+ drawable.setBounds(0,0,250,mPicture.getHeight());
+ // 绘制
+ drawable.draw(canvas);
+```
+
+
+
+**PS:此处setBounds是设置在画布上的绘制区域，并非根据该区域进行缩放，也不是剪裁Picture，每次都从Picture的左上角开始绘制。**
+
+> **注意：在使用Picture之前请关闭硬件加速，以免引起不必要的问题，如何关闭请参考这里： [Android的硬件加速及可能导致的问题](https://github.com/GcsSloop/AndroidNote/issues/7)**
+
+### (2)drawBitmap
+
+ > 其实一开始知道要讲Bitmap我是拒绝的，为什么呢？因为Bitmap就是很多问题的根源啊有木有，Bitmap可能导致内存不足，内存泄露，ListView中的复用混乱等诸多问题。想完美的掌控Bitmap还真不是一件容易的事情。限于篇幅**本文对于Bitmap不会过多的展开，只讲解一些常用的功能**，关于Bitmap详细内容，以后开专题讲解QAQ。
+
+ 既然要绘制Bitmap，就要先获取一个Bitmap，那么如何获取呢？
+
+ **获取Bitmap方式:**
+
+| 序号 | 获取方式 | 备注 |
+| ---- | ------------------ | ---------------------------------------- |
+| 1 | 通过Bitmap创建 | 复制一个已有的Bitmap(_新Bitmap状态和原有的一致_) 或者 创建一个空白的Bitmap(_内容可改变_) |
+| 2 | 通过BitmapDrawable获取 | 从资源文件 内存卡 网络等地方获取一张图片并转换为内容不可变的Bitmap |
+| 3 | 通过BitmapFactory获取 | 从资源文件 内存卡 网络等地方获取一张图片并转换为内容不可变的Bitmap |
+
+**通常来说，我们绘制Bitmap都是读取已有的图片转换为Bitmap绘制到Canvas上。**
+很明显，第1种方式不能满足我们的要求，暂时排除。
+第2种方式虽然也可满足我们的要求，但是我不推荐使用这种方式，至于为什么在后续详细讲解Drawable的时候会说明,暂时排除。
+第3种方法我们会比较详细的说明一下如何从各个位置获取图片。
+
+#### 通过BitmapFactory从不同位置获取Bitmap:
+
+**资源文件(drawable/mipmap/raw):**
+``` java
+ Bitmap bitmap = BitmapFactory.decodeResource(mContext.getResources(),R.raw.bitmap);
+```
+**资源文件(assets):**
+``` java
+ Bitmap bitmap=null;
+ try {
+ InputStream is = mContext.getAssets().open("bitmap.png");
+ bitmap = BitmapFactory.decodeStream(is);
+ is.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+```
+
+**内存卡文件:**
+``` java
+ Bitmap bitmap = BitmapFactory.decodeFile("/sdcard/bitmap.png");
+```
+
+**网络文件:**
+``` java
+ // 此处省略了获取网络输入流的代码
+ Bitmap bitmap = BitmapFactory.decodeStream(is);
+ is.close();
+```
+
+既然已经获得到了Bitmap，那么就开始本文的重点了，将Bitmap绘制到画布上。
+
+#### 绘制Bitmap：
+
+依照惯例先预览一下drawBitmap的常用方法：
+``` java
+ // 第一种
+ public void drawBitmap (Bitmap bitmap, Matrix matrix, Paint paint)
+
+ // 第二种
+ public void drawBitmap (Bitmap bitmap, float left, float top, Paint paint)
+
+ // 第三种
+ public void drawBitmap (Bitmap bitmap, Rect src, Rect dst, Paint paint)
+ public void drawBitmap (Bitmap bitmap, Rect src, RectF dst, Paint paint)
+```
+
+第一种方法中后两个参数(matrix, paint)是在绘制的时候对图片进行一些改变，如果只是需要将图片内容绘制出来只需要如下操作就可以了：
+
+PS:图片左上角位置默认为坐标原点。
+
+``` java
+ canvas.drawBitmap(bitmap,new Matrix(),new Paint());
+```
+
+> 关于Matrix和Paint暂时略过吧，一展开又是啰啰嗦嗦一大段，反正挖坑已经是常态了，大家应该也习惯了(PAP).
+
+
+
+第二种方法就是在绘制时指定了图片左上角的坐标(距离坐标原点的距离)：
+
+> **注意：此处指定的是与坐标原点的距离，并非是与屏幕顶部和左侧的距离, 虽然默认状态下两者是重合的，但是也请注意分别两者的不同。**
+
+``` java
+ canvas.drawBitmap(bitmap,200,500,new Paint());
+```
+
+
+
+第三种方法比较有意思，上面多了两个矩形区域(src,dst),这两个矩形选区是干什么用的？
+
+| 名称 | 作用 |
+| ------------------- | ----------------- |
+| Rect src | 指定绘制图片的区域 |
+| Rect dst 或RectF dst | 指定图片在屏幕上显示(绘制)的区域 |
+
+示例：
+``` java
+ // 将画布坐标系移动到画布中央
+ canvas.translate(mWidth/2,mHeight/2);
+
+ // 指定图片绘制区域(左上角的四分之一)
+ Rect src = new Rect(0,0,bitmap.getWidth()/2,bitmap.getHeight()/2);
+
+ // 指定图片在屏幕上显示的区域
+ Rect dst = new Rect(0,0,200,400);
+
+ // 绘制图片
+ canvas.drawBitmap(bitmap,src,dst,null);
+```
+
+
+**详解：**
+
+上面是以绘制该图为例，用src指定了图片绘制部分的区域，即下图中红色方框标注的区域。
+
+
+
+然后用dst指定了绘制在屏幕上的绘制，即下图中蓝色方框标注的区域，图片宽高会根据指定的区域自动进行缩放。
+
+
+
+从上面可知，第三种方法可以绘制图片的一部分到画布上，这有什么用呢？
+
+如果你看过某些游戏的资源文件，你可能会看到如下的图片(图片来自网络)：
+
+
+
+用一张图片包含了大量的素材，在绘制的时候每次只截取一部分进行绘制，这样可以大大的减少素材数量，而且素材管理起来也很方便。
+
+然而这和我们有什么关系呢？我们又不做游戏开发。
+
+确实，我们不做游戏开发，但是在某些时候我们需要制作一些炫酷的效果，这些效果因为太复杂了用代码很难实现或者渲染效率不高。这时候很多人就会想起帧动画，将动画分解成一张一张的图片然后使用帧动画制作出来，这种实现方式的确比较简单，但是一个动画效果的图片有十几到几十张，一个应用里面来几个这样炫酷的动画效果就会导致资源文件出现一大堆，想找其中的某一张资源图片简直就是灾难啊有木有。但是把同一个动画效果的所有资源图片整理到一张图片上，会大大的**减少资源文件数量，方便管理**，妈妈再也不怕我找不到资源文件了，**同时也节省了图片文件头、文件结束块以及调色板等占用的空间。**
+
+**下面是利用drawBitmap第三种方法制作的一个简单示例：**
+
+资源文件如下：
+
+
+
+最终效果如下：
+
+
+
+源码如下：
+
+> PS:由于是示例代码，做的很粗糙，仅作为学习示例，不建议在任何实际项目中使用。
+
+[_点击此处查看源码_](https://github.com/GcsSloop/AndroidNote/issues/10)
+
+## 2.绘制文字
+依旧预览一下相关常用方法：
+``` java
+ // 第一类
+ public void drawText (String text, float x, float y, Paint paint)
+ public void drawText (String text, int start, int end, float x, float y, Paint paint)
+ public void drawText (CharSequence text, int start, int end, float x, float y, Paint paint)
+ public void drawText (char[] text, int index, int count, float x, float y, Paint paint)
+
+ // 第二类
+ public void drawPosText (String text, float[] pos, Paint paint)
+ public void drawPosText (char[] text, int index, int count, float[] pos, Paint paint)
+
+ // 第三类
+ public void drawTextOnPath (String text, Path path, float hOffset, float vOffset, Paint paint)
+ public void drawTextOnPath (char[] text, int index, int count, Path path, float hOffset, float vOffset, Paint paint)
+```
+> PS 其中的CharSequence和String的区别可以到这里看看. [->戳这里<-](https://github.com/GcsSloop/AndroidNote/issues/16)
+
+绘制文字部分大致可以分为三类：
+
+第一类只能指定文本基线位置(基线x默认在字符串左侧，基线y默认在字符串下方)。
+第二类可以分别指定每个文字的位置。
+第三类是指定一个路径，根据路径绘制文字。
+
+通过上面常用方法的参数也可看出，绘制文字也是需要画笔的，而且文字的大小,颜色,字体,对齐方式都是由画笔控制的。
+
+不过嘛这里仅简单介绍几种常用方法(反正挖坑多了也不怕)，具体在讲解Paint时再详细讲解。
+
+**Paint文本相关常用方法表**
+
+| 标题 | 相关方法 | 备注 |
+| ---- | ------------------------- | ---------------------------------------- |
+| 色彩 | setColor setARGB setAlpha | 设置颜色，透明度 |
+| 大小 | setTextSize | 设置文本字体大小 |
+| 字体 | setTypeface | 设置或清除字体样式 |
+| 样式 | setStyle | 填充(FILL),描边(STROKE),填充加描边(FILL_AND_STROKE) |
+| 对齐 | setTextAlign | 左对齐(LEFT),居中对齐(CENTER),右对齐(RIGHT) |
+| 测量 | measureText | 测量文本大小(注意，请在设置完文本各项参数后调用) |
+
+为了绘制文本，我们先创建一个文本画笔：
+``` java
+ Paint textPaint = new Paint(); // 创建画笔
+ textPaint.setColor(Color.BLACK); // 设置颜色
+ textPaint.setStyle(Paint.Style.FILL); // 设置样式
+ textPaint.setTextSize(50); // 设置字体大小
+```
+
+### 第一类(drawText)
+第一类可以指定文本开始的位置，可以截取文本中部分内容进行绘制。
+
+其中x，y两个参数是指定文本绘制两个基线,示例：
+``` java
+
+ // 文本(要绘制的内容)
+ String str = "ABCDEFGHIJK";
+
+ // 参数分别为 (文本 基线x 基线y 画笔)
+ canvas.drawText(str,200,500,textPaint);
+```
+
+
+> PS: 图中字符串下方的红线是基线y，基线x未在图中画出。
+
+当然啦，除了能指定绘制文本的起始位置，还能只取出文本中的一部分内容进行绘制。
+
+截取文本中的一部分，对于String和CharSequence来说只指定字符串下标start和end位置(**注意：0<= start < end < str.length()**)
+
+以上一个例子使用的字符串为例，它的下标是这样的(wait，我为啥要说这个，算了，不管了，就这样吧(๑•́ ₃ •̀๑)):
+
+| 字符 | A | B | C | D | E | F | G | H | I | J | K |
+| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |
+| 下标 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
+
+假设我们指定start为1，end为3，那么最终截取的字符串就是"BC"。
+
+一般来说，**使用start和end指定的区间是前闭后开的，即包含start指定的下标，而不包含end指定的下标**，故[1,3)最后获取到的下标只有 下标1 和 下标2 的字符，就是"BC"。
+
+示例：
+``` java
+ // 文本(要绘制的内容)
+ String str = "ABCDEFGHIJK";
+ // 参数分别为 (字符串 开始截取位置 结束截取位置 基线x 基线y 画笔)
+ canvas.drawText(str,1,3,200,500,textPaint);
+```
+
+
+另外，对于字符数组char[]我们截取字符串使用起始位置(index)和长度(count)来确定。
+
+同样，我们指定index为1，count为3，那么最终截取到的字符串是"BCD"。
+
+其实就是从下标位置为1处向后数3位就是截取到的字符串，示例：
+``` java
+ // 字符数组(要绘制的内容)
+ char[] chars = "ABCDEFGHIJK".toCharArray();
+
+ // 参数为 (字符数组 起始坐标 截取长度 基线x 基线y 画笔)
+ canvas.drawText(chars,1,3,200,500,textPaint);
+```
+
+
+### 第二类(drawPosText)
+
+通过和第一类比较，我们可以发现，第二类中没有指定x，y坐标的参数，而是出现了这样一个参数**float[] pos**。
+
+好吧，这个名为pos的浮点型数组就是指定坐标的，至于为啥要用数组嘛，因为这家伙野心比较大，想给每个字符都指定一个位置。
+
+示例：
+``` java
+ String str = "SLOOP";
+
+ canvas.drawPosText(str,new float[]{
+ 100,100, // 第一个字符位置
+ 200,200, // 第二个字符位置
+ 300,300, // ...
+ 400,400,
+ 500,500
+ },textPaint);
+```
+
+
+
+不过嘛，虽然虽然这个方法也比较容易理解，但是关于这个方法我个人是不推荐使用的，因为坑比较多，主要有一下几点：
+
+| 序号 | 反对理由 |
+| ---- | --------------------------- |
+| 1 | 必须指定所有字符位置，否则直接crash掉，反人类设计 |
+| 2 | 性能不佳，在大量使用的时候可能导致卡顿 |
+| 3 | 不支持emoji等特殊字符，不支持字形组合与分解 |
+
+关于第二类的第二种方法：
+
+``` java
+public void drawPosText (char[] text, int index, int count, float[] pos, Paint paint)
+```
+
+和上面一样，就是从字符数组中切出来一段进行绘制，相信以诸位看官的聪明才智一眼就看出来了，我这里就不多说了，真的不是我偷懒啊(ˉ▽￣～) ~~
+
+### 第三类(drawTextOnPath)
+
+第三类要用到path这个大杀器，作为一个厉害角色怎么能这么轻易露脸呢，先保持一下神秘感，也就是说，下回再和大家见面喽。
+
+# 三.总结
+
+学会了图片和文字绘制，对于大部分自定义View都能制作了，可以去看看这位大神制作的作品，尝试模仿一下[一个绚丽的loading动效分析与实现！](http://blog.csdn.net/tianjian4592/article/details/44538605)
+
+
+
+(,,• ₃ •,,)
+
+PS: 由于本人英文水平有限，某些地方可能存在误解或词语翻译不准确，如果你对此有疑问可以提交Issues进行反馈。
+
+## About Me
+
+### 作者微博: @GcsSloop
+
+
+
+## 参考资料
+
+[Canvas](http://developer.android.com/reference/android/graphics/Canvas.html)
+[Bitmap](http://developer.android.com/reference/android/graphics/Bitmap.html)
+[Paint](http://developer.android.com/reference/android/graphics/Paint.html)
+[Android ApiDemo 笔记（一）Content与Graphics](http://blog.csdn.net/wufenglong/article/details/5596402)
+
diff --git "a/\351\227\256\351\242\230/Canvas/Path/Path(1).md" b/CustomView/Advance/[05]Path_Basic.md
similarity index 69%
rename from "\351\227\256\351\242\230/Canvas/Path/Path(1).md"
rename to CustomView/Advance/[05]Path_Basic.md
index c04bb148..58e9c2d2 100644
--- "a/\351\227\256\351\242\230/Canvas/Path/Path(1).md"
+++ b/CustomView/Advance/[05]Path_Basic.md
@@ -1,37 +1,43 @@
-# Canvas基础四
-### 讲解安卓中的Canvas基础内容。
-### 作者微博: [@攻城师sloop](http://weibo.com/5459430586)
+# Path之基本操作
-本次会了解到path(路径)这个神器，有了这个神器，就能创造出更多**炫(zhuang)酷(B)**的东东了。
+### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
+
+### [【本系列相关文章】](https://github.com/GcsSloop/AndroidNote/tree/master/CustomView/README.md)
+
+在上一篇[Canvas之图片文字](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B04%5DCanvas_PictureText.md)中我们了解了如何使用Canvas中绘制图片文字，结合前几篇文章，Canvas的基本操作已经差不多完结了，然而Canvas不仅仅具有这些基本的操作，还可以更加炫酷，本次会了解到path(路径)这个Canvas中的神器，有了这个神器，就能创造出更多**炫(zhuang)酷(B)**的东东了。
******
# 一.Path常用方法表
-> 为了兼容性(_偷懒_) 本表格中去除了在API21(即安卓版本5.0)以上才添加的方法。忍不住吐槽一下，为啥看起来有些顺手就能写的重载方法要等到API21才添加上啊。宝宝此刻内心也是崩溃的。
-
-作用 | 相关方法 | 备注
---- | --- | ---
-移动起点 | moveTo | 移动下一次操作的起点位置
-设置终点 | setLastPoint | 重置当前path中最后一个点位置，如果在绘制之前调用，效果和moveTo相同
-连接直线 | lineTo | 添加上一个点到当前点之间的直线到Path
-闭合路径 | close | 连接第一个点连接到最后一个点，形成一个闭合区域
-添加内容 | addRect, addRoundRect, addOval, addCircle, addPath, addArc, arcTo | 添加(矩形， 圆角矩形， 椭圆， 圆， 路径， 圆弧) 到当前Path (注意addArc和arcTo的区别)
-是否为空 | isEmpty | 判断Path是否为空
-是否为矩形 | isRect | 判断path是否是一个矩形
-替换路径 | set | 用新的路径替换到当前路径所有内容
-偏移路径 | offset | 对当前路径之前的操作进行偏移(不会影响之后的操作)
-贝塞尔曲线 | quadTo, cubicTo | 分别为二次和三次贝塞尔曲线的方法
-rXxx方法 | rMoveTo, rLineTo, rQuadTo, rCubicTo | **不带r的方法是基于原点的坐标系(偏移量)，rXxx方法是基于当前点坐标系(偏移量)**
-填充模式 | setFillType, getFillType, isInverseFillType, toggleInverseFillType| 设置,获取,判断和切换填充模式
-提示方法 | incReserve | 提示Path还有多少个点等待加入**(这个方法貌似会让Path优化存储结构)**
-布尔操作(API19) | op | 对两个Path进行布尔运算(即取交集、并集等操作)
-计算边界 | computeBounds | 计算Path的边界
-重置路径 | reset, rewind | 清除Path中的内容(**reset相当于重置到new Path阶段，rewind会保留Path的数据结构**)
-矩阵操作 | transform | 矩阵变换
+> 为了兼容性(_偷懒_) 本表格中去除了部分API21(即安卓版本5.0)以上才添加的方法。
+
+| 作用 | 相关方法 | 备注 |
+| ----------- | ---------------------------------------- | ---------------------------------------- |
+| 移动起点 | moveTo | 移动下一次操作的起点位置 |
+| 设置终点 | setLastPoint | 重置当前path中最后一个点位置，如果在绘制之前调用，效果和moveTo相同 |
+| 连接直线 | lineTo | 添加上一个点到当前点之间的直线到Path |
+| 闭合路径 | close | 连接第一个点连接到最后一个点，形成一个闭合区域 |
+| 添加内容 | addRect, addRoundRect, addOval, addCircle, addPath, addArc, arcTo | 添加(矩形， 圆角矩形， 椭圆， 圆， 路径， 圆弧) 到当前Path (注意addArc和arcTo的区别) |
+| 是否为空 | isEmpty | 判断Path是否为空 |
+| 是否为矩形 | isRect | 判断path是否是一个矩形 |
+| 替换路径 | set | 用新的路径替换到当前路径所有内容 |
+| 偏移路径 | offset | 对当前路径之前的操作进行偏移(不会影响之后的操作) |
+| 贝塞尔曲线 | quadTo, cubicTo | 分别为二次和三次贝塞尔曲线的方法 |
+| rXxx方法 | rMoveTo, rLineTo, rQuadTo, rCubicTo | **不带r的方法是基于原点的坐标系(偏移量)， rXxx方法是基于当前点坐标系(偏移量)** |
+| 填充模式 | setFillType, getFillType, isInverseFillType, toggleInverseFillType | 设置,获取,判断和切换填充模式 |
+| 提示方法 | incReserve | 提示Path还有多少个点等待加入**(这个方法貌似会让Path优化存储结构)** |
+| 布尔操作(API19) | op | 对两个Path进行布尔运算(即取交集、并集等操作) |
+| 计算边界 | computeBounds | 计算Path的边界 |
+| 重置路径 | reset, rewind | 清除Path中的内容
**reset不保留内部数据结构，但会保留FillType.**
**rewind会保留内部的数据结构，但不保留FillType** |
+| 矩阵操作 | transform | 矩阵变换 |
# 二.Path详解
+**请关闭硬件加速，以免引起不必要的问题！
请关闭硬件加速，以免引起不必要的问题！
请关闭硬件加速，以免引起不必要的问题！**
+
+**在AndroidMainfest文件中application节点下添上 android:hardwareAccelerated="false"以关闭整个应用的硬件加速。
更多请参考这里：[Android的硬件加速及可能导致的问题](https://github.com/GcsSloop/AndroidNote/issues/7)**
+
## Path作用
本次特地开了一篇详细讲解Path，为什么要单独摘出来呢，这是因为Path在2D绘图中是一个很重要的东西。
@@ -49,16 +55,16 @@ _The Path class encapsulates compound (multiple contour) geometric paths consist
**通俗解释(sloop个人版)：**
-**Path是封装了由直线和曲线(二次，三次贝塞尔曲线)构成的几何路径。你能用Canvas中的drawPath来把这条路径画出来(同样支持Paint的不同绘制模式)，也可以用于剪裁画布和根据路径绘制文字。我们有时会用Path来描述一个图像的轮廓，所以也会称为轮廓线(轮廓线仅是Path的一种使用方法，两者并不等价)**
+**Path封装了由直线和曲线(二次，三次贝塞尔曲线)构成的几何路径。你能用Canvas中的drawPath来把这条路径画出来(同样支持Paint的不同绘制模式)，也可以用于剪裁画布和根据路径绘制文字。我们有时会用Path来描述一个图像的轮廓，所以也会称为轮廓线(轮廓线仅是Path的一种使用方法，两者并不等价)**
另外路径有开放和封闭的区别。
-
-图像 | 名称 | 备注
- --- | --- | ---
-  | 封闭路径 | 首尾相接形成了一个封闭区域
-  | 开放路径 | 没有首位相接形成封闭区域
-
+
+| 图像 | 名称 | 备注 |
+| ------------------------------------------------------------ | -------- | -------------------------- |
+|  | 封闭路径 | 首尾相接形成了一个封闭区域 |
+|  | 开放路径 | 没有首尾相接形成封闭区域 |
+
> 这个是我随便画的，仅为展示一下区别，请无视我灵魂画师一般的绘图水准。
**与Path相关的还有一些比较神奇的概念，不过暂且不说，等接下来需要用到的时候再详细说明。**
@@ -70,18 +76,18 @@ _The Path class encapsulates compound (multiple contour) geometric paths consist
### 第1组: moveTo、 setLastPoint、 lineTo 和 close
-
+
由于Path的有些知识点无法单独来讲，所以本次采取了一次讲一组方法。
-
+
按照惯例，先创建画笔：
-
+
``` java
Paint mPaint = new Paint(); // 创建画笔
mPaint.setColor(Color.BLACK); // 画笔颜色 - 黑色
mPaint.setStyle(Paint.Style.STROKE); // 填充模式 - 描边
mPaint.setStrokeWidth(10); // 边框宽度 - 10
```
-
+
#### lineTo：
方法预览：
```
@@ -89,9 +95,9 @@ public void lineTo (float x, float y)
```
首先讲解的的LineTo，为啥先讲解这个呢？
-
+
是因为moveTo、 setLastPoint、 close都无法直接看到效果，借助有具现化效果的lineTo才能让这些方法现出原形。
-
+
lineTo很简单，只有一个方法，作用也很容易理解，line嘛，顾名思义就是一条线。
@@ -137,10 +143,10 @@ lineTo很简单，只有一个方法，作用也很容易理解，line嘛，顾
这两个方法虽然在作用上有相似之处，但实际上却是完全不同的两个东东，具体参照下表：
-方法名 | 简介 | 是否影响之前的操作 | 是否影响之后操作
---- | --- | --- | ---
-moveTo | 移动下一次操作的起点位置 | 否 | 是
-setLastPoint | 设置之前操作的最后一个点位置 | 是 | 是
+| 方法名 | 简介 | 是否影响之前的操作 | 是否影响之后操作 |
+| ------------ | -------------- | --------- | -------- |
+| moveTo | 移动下一次操作的起点位置 | 否 | 是 |
+| setLastPoint | 设置之前操作的最后一个点位置 | 是 | 是 |
废话不多说，直接上代码：
``` java
@@ -207,9 +213,9 @@ close方法用于连接当前最后一个点和最初的一个点(如果两个
```
-很明显，两个lineTo分别代表第1和第2条线，而close在此处的作用就算连接了B(200,0)点和圆的O之间的第3条线，使之形成一个封闭的图形。
+很明显，两个lineTo分别代表第1和第2条线，而close在此处的作用就算连接了B(200,0)点和原点O之间的第3条线，使之形成一个封闭的图形。
-**注意：close的作用是封闭路径，与当前最后一个点和第一个点并不等价。如果连接了最后一个点和第一个点仍然无法形成封闭图形，则close什么 也不做。**
+**注意：close的作用是封闭路径，与连接当前最后一个点和第一个点并不等价。如果连接了最后一个点和第一个点仍然无法形成封闭图形，则close什么 也不做。**
### 第2组: addXxx与arcTo
@@ -233,23 +239,23 @@ close方法用于连接当前最后一个点和最初的一个点(如果两个
**这一类就是在path中添加一个基本形状，基本形状部分和前面所讲的绘制基本形状并无太大差别，详情参考[Canvas(1)颜色与基本形状](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/Canvas/Canvas(1).md), 本次只将其中不同的部分摘出来详细讲解一下。**
-**仔细观察一下第一类是方法，无一例外，在最后都有一个_Path.Direction_，这是一个什么神奇的东东？**
+**仔细观察一下第一类的方法，无一例外，在最后都有一个_Path.Direction_，这是一个什么神奇的东东？**
Direction的意思是 方向，趋势。 点进去看一下会发现Direction是一个枚举(Enum)类型，里面只有两个枚举常量，如下：
-类型 | 解释 | 翻译
---- | --- | ---
-CW | clockwise | 顺时针
-CCW | counter-clockwise | 逆时针
+| 类型 | 解释 | 翻译 |
+| ---- | ----------------- | ---- |
+| CW | clockwise | 顺时针 |
+| CCW | counter-clockwise | 逆时针 |
> **瞬间懵逼，我只是想添加一个基本的形状啊，搞什么顺时针和逆时针, (╯‵□′)╯︵┻━┻**
**稍安勿躁，┬─┬ ノ( ' - 'ノ) {摆好摆好） 既然存在肯定是有用的，先偷偷剧透一下这个顺时针和逆时针的作用。**
-序号 | 作用
---- | ---
- 1 | 在添加图形时确定闭合顺序(各个点的记录顺序)
- 2 | 对自相交图形的渲染结果有影响
+| 序号 | 作用 |
+| ---- | ------------------------- |
+| 1 | 在添加图形时确定闭合顺序(各个点的记录顺序) |
+| 2 | 对图形的渲染结果有影响(是判断图形渲染的重要条件) |
这个先剧透这么多，至于对闭合顺序有啥影响，自相交图形的渲染等问题等请慢慢看下去
@@ -269,13 +275,12 @@ CCW | counter-clockwise | 逆时针
**将上面代码的CW改为CCW再运行一次。接下来就是见证奇迹的时刻，两次运行结果一模一样，有木有很神奇！**
> **(╯°Д°)╯︵ ┻━┻(再TM掀一次)
-坑人也不带这样的啊，一毛一样要它干嘛。**
+> 坑人也不带这样的啊，一毛一样要它干嘛。**
**其实啊，这个东东是自带隐身技能的，想要让它现出原形，就要用到咱们刚刚学到的setLastPoint(重置当前最后一个点的位置)。**
```
canvas.translate(mWidth / 2, mHeight / 2); // 移动坐标系到屏幕中心
- canvas.scale(1,-1); // <-- 注意 scale特殊运用：翻转y坐标轴
Path path = new Path();
@@ -286,12 +291,7 @@ CCW | counter-clockwise | 逆时针
canvas.drawPath(path,mPaint);
```
-
-
-**请注意：为了演示方便，本次将坐标系调整到了和我们常见的数学坐标系相同，请留意代码的变动，否则效果刚好是反着的，会更加难以理解。**
-
-> 如果你对坐标系有疑问，请参考之前文章 [坐标系](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/%E5%9D%90%E6%A0%87%E7%B3%BB/%E5%9D%90%E6%A0%87%E7%B3%BB.md)
->如果你对翻转坐标轴有疑问，请参考之前文章 [Canvas(2)画布操作](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/Canvas/Canvas(2).md)
+
可以明显看到，图形发生了奇怪的变化。为何会如此呢？
@@ -311,7 +311,6 @@ CCW | counter-clockwise | 逆时针
``` java
canvas.translate(mWidth / 2, mHeight / 2); // 移动坐标系到屏幕中心
- canvas.scale(1,-1); // <-- 注意 翻转y坐标轴
Path path = new Path();
@@ -322,19 +321,17 @@ CCW | counter-clockwise | 逆时针
canvas.drawPath(path,mPaint);
```
-
+
-通过验证发现，发现结果和我们猜想的一样，但是还有一个潜藏的问题不晓得大家可否注意到。**为啥A点总是排在第一个呢？长得漂亮还是咋地？**
+通过验证发现，发现结果和我们猜想的一样，但是还有一个潜藏的问题不晓得大家可否注意到。**我们用两个点的坐标确定了一个矩形，矩形起始点(A)就是我们指定的第一个点的坐标。**
-我们前面说过，确定一个矩形只需要知道对角线的两个点就足够了，我们实际上是通过 C(-200,-200) 和 A(200,200) 来确定这个矩形的，A点就是我们参数中的第二个点，经过测试可以发现参数中指定的第二个点始终是记录中的第一个点。至于为啥参数中第二个点作为记录的第一个点，可能就是当时设计这个的工程师一拍脑门决定的，也可能是这样设计算法比较简单。这个我们无需深究。
-
-**不过，需要注意的是，交换坐标点的顺序可能就会影响到某些绘制内容哦，例如上面的例子，你可以尝试交换两个坐标点，或者指定另外两个点来作为参数，虽然指定的是同一个矩形，但实际绘制出来是不同的哦。**
+**需要注意的是，交换坐标点的顺序可能就会影响到某些绘制内容哦，例如上面的例子，你可以尝试交换两个坐标点，或者指定另外两个点来作为参数，虽然指定的是同一个矩形，但实际绘制出来是不同的哦。**
**参数中点的顺序很重要！
参数中点的顺序很重要！
参数中点的顺序很重要！
**
重要的话说三遍，本次是用矩形作为例子的，其他的几个图形基本上都包含了曲线，详情参见后续的贝塞尔曲线部分。
-**关于顺时针和逆时针对自相交图形影响的问题请等待下一篇，虽然只讲了一个Path，但也是内容颇多，放进一篇中就太长了，请见谅。**
+**关于顺时针和逆时针对图形填充结果的影响请等待后续文章，虽然只讲了一个Path，但也是内容颇多，放进一篇中就太长了，请见谅。**
#### 第二类(Path)
方法预览：
@@ -370,9 +367,9 @@ CCW | counter-clockwise | 逆时针
canvas.drawPath(path,mPaint);
```
-
+
-首先我们新建地方两个Path(矩形和圆形)中心都是坐标原点，我们在将包含圆形的path添加到包含矩形的path之前将其进行移动了一段距离，最终绘制出来的效果就如上面所示。
+首先我们新建的两个Path(矩形和圆形)中心都是坐标原点，我们在将包含圆形的path添加到包含矩形的path之前将其进行移动了一段距离，最终绘制出来的效果就如上面所示。
#### 第三类(addArc与arcTo)
方法预览：
@@ -387,10 +384,10 @@ CCW | counter-clockwise | 逆时针
从名字就可以看出，这两个方法都是与圆弧相关的，作用都是添加一个圆弧到path中，但既然存在两个方法，两者之间肯定是有区别的：
-名称 | 作用 | 区别
- --- | --- | ---
- addArc | 添加一个圆弧到path | 直接添加一个圆弧到path中
- arcTo | 添加一个圆弧到path | 添加一个圆弧到path，如果圆弧的起点和上次最后一个坐标点不相同，就连接两个点
+| 名称 | 作用 | 区别 |
+| ------ | ----------- | --------------------------------------- |
+| addArc | 添加一个圆弧到path | 直接添加一个圆弧到path中 |
+| arcTo | 添加一个圆弧到path | 添加一个圆弧到path，如果圆弧的起点和上次最后一个坐标点不相同，就连接两个点 |
可以看到addArc有1个方法(_实际上是两个的，但另一个重载方法是API21添加的_), 而arcTo有2个方法，其中一个最后多了一个布尔类型的变量forceMoveTo。
@@ -398,10 +395,10 @@ CCW | counter-clockwise | 逆时针
这个变量意思为“是否强制使用moveTo”，也就是说，是否使用moveTo将变量移动到圆弧的起点位移，也就意味着：
-forceMoveTo | 含义 | 等价方法
- --- | --- | ---
- true | 将最后一个点移动到圆弧起点，即不连接最后一个点与圆弧起点 | public void addArc (RectF oval, float startAngle, float sweepAngle)
- false | 不移动，而是连接最后一个点与圆弧起点 | public void arcTo (RectF oval, float startAngle, float sweepAngle)
+| forceMoveTo | 含义 | 等价方法 |
+| ----------- | ---------------------------- | ---------------------------------------- |
+| true | 将最后一个点移动到圆弧起点，即不连接最后一个点与圆弧起点 | public void addArc (RectF oval, float startAngle, float sweepAngle) |
+| false | 不移动，而是连接最后一个点与圆弧起点 | public void arcTo (RectF oval, float startAngle, float sweepAngle) |
**示例(addArc)：**
``` java
@@ -441,7 +438,7 @@ forceMoveTo | 含义 | 等价方法
从上面两张运行效果图可以清晰的看出来两者的区别，我就不再废话了。
-### 第3组：isEmpty、 isRect、 set 和 offset
+### 第3组：isEmpty、 isRect、isConvex、 set 和 offset
这一组比较简单，稍微说一下就可以了。
@@ -495,7 +492,7 @@ log 输出结果:
#### set
方法预览：
``` java
- public void reset ()
+ public void set (Path src)
```
将新的path赋值到现有path。
@@ -527,12 +524,12 @@ log 输出结果:
**但是第二个方法最后怎么会有一个path作为参数？**
-其实第二个方法中最后的参数das是存储平移后的path的。
+其实第二个方法中最后的参数dst是存储平移后的path的。
-dst状态 | 效果
- --- | ---
- dst为空(null) | 将当前path平移后的状态存入dst中，不会影响当前path
- dat不为空 | 平移将作用于当前path，相当于第一种方法
+| dst状态 | 效果 |
+| ----------- | ------------------------------ |
+| dst不为空 | 将当前path平移后的状态存入dst中，不会影响当前path |
+| dst为空(null) | 平移将作用于当前path，相当于第一种方法 |
示例：
``` java
@@ -569,9 +566,15 @@ dst状态 | 效果
(,,• ₃ •,,)
-PS: 由于本人英文水平有限，某些地方可能存在误解或词语翻译不准确，如果你对此有疑问可以提交Issues进行反馈。
+PS: 由于本人水平有限，某些地方可能存在误解或不准确，如果你对此有疑问可以提交Issues进行反馈。
+
+## About Me
+
+### 作者微博: @GcsSloop
+
+
-# 四.参考资料
+## 参考资料
[Path](http://developer.android.com/reference/android/graphics/Path.html)
[Canvas](http://developer.android.com/reference/android/graphics/Canvas.html)
diff --git a/CustomView/Advance/[06]Path_Bezier.md b/CustomView/Advance/[06]Path_Bezier.md
new file mode 100644
index 00000000..e98db733
--- /dev/null
+++ b/CustomView/Advance/[06]Path_Bezier.md
@@ -0,0 +1,590 @@
+# Path之贝塞尔曲线
+
+### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
+### [【本系列相关文章】](https://github.com/GcsSloop/AndroidNote/tree/master/CustomView/README.md)
+
+在上一篇文章[Path之基本图形](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B05%5DPath_Basic.md)中我们了解了Path的基本使用方法，本次了解Path中非常非常非常重要的内容-贝塞尔曲线。
+
+******
+
+## 一.Path常用方法表
+> 为了兼容性(_偷懒_) 本表格中去除了在API21(即安卓版本5.0)以上才添加的方法。忍不住吐槽一下，为啥看起来有些顺手就能写的重载方法要等到API21才添加上啊。宝宝此刻内心也是崩溃的。
+
+| 作用 | 相关方法 | 备注 |
+| ----------- | ---------------------------------------- | ---------------------------------------- |
+| 移动起点 | moveTo | 移动下一次操作的起点位置 |
+| 设置终点 | setLastPoint | 重置当前path中最后一个点位置，如果在绘制之前调用，效果和moveTo相同 |
+| 连接直线 | lineTo | 添加上一个点到当前点之间的直线到Path |
+| 闭合路径 | close | 连接第一个点连接到最后一个点，形成一个闭合区域 |
+| 添加内容 | addRect, addRoundRect, addOval, addCircle, addPath, addArc, arcTo | 添加(矩形， 圆角矩形， 椭圆， 圆， 路径， 圆弧) 到当前Path (注意addArc和arcTo的区别) |
+| 是否为空 | isEmpty | 判断Path是否为空 |
+| 是否为矩形 | isRect | 判断path是否是一个矩形 |
+| 替换路径 | set | 用新的路径替换到当前路径所有内容 |
+| 偏移路径 | offset | 对当前路径之前的操作进行偏移(不会影响之后的操作) |
+| 贝塞尔曲线 | quadTo, cubicTo | 分别为二次和三次贝塞尔曲线的方法 |
+| rXxx方法 | rMoveTo, rLineTo, rQuadTo, rCubicTo | **不带r的方法是基于原点的坐标系(偏移量)， rXxx方法是基于当前点坐标系(偏移量)** |
+| 填充模式 | setFillType, getFillType, isInverseFillType, toggleInverseFillType | 设置,获取,判断和切换填充模式 |
+| 提示方法 | incReserve | 提示Path还有多少个点等待加入**(这个方法貌似会让Path优化存储结构)** |
+| 布尔操作(API19) | op | 对两个Path进行布尔运算(即取交集、并集等操作) |
+| 计算边界 | computeBounds | 计算Path的边界 |
+| 重置路径 | reset, rewind | 清除Path中的内容
**reset不保留内部数据结构，但会保留FillType.**
**rewind会保留内部的数据结构，但不保留FillType** |
+| 矩阵操作 | transform | 矩阵变换 |
+
+## 二.Path详解
+
+上一次除了一些常用函数之外，讲解的基本上都是直线，本次需要了解其中的曲线部分,说到曲线，就不得不提大名鼎鼎的贝塞尔曲线。它的发明者是下面这个人(法国数学家PierreBézier)。
+
+
+
+### 贝塞尔曲线能干什么？
+
+贝塞尔曲线的运用是十分广泛的，可以说**贝塞尔曲线奠定了计算机绘图的基础(_因为它可以将任何复杂的图形用精确的数学语言进行描述_)**，在你不经意间就已经使用过它了。
+
+你会使用Photoshop的话，你可能会注意到里面有一个**钢笔工具**，这个钢笔工具核心就是贝塞尔曲线。
+
+你说你不会PS？ 没关系，你如果看过前面的文章或者用过2D绘图，肯定绘制过圆，圆弧，圆角矩形等这些东西。这里面的圆弧部分全部都是贝塞尔曲线的运用。
+
+#### 贝塞尔曲线作用十分广泛，简单举几个的栗子:
+> * QQ小红点拖拽效果
+* 一些炫酷的下拉刷新控件
+* 阅读软件的翻书效果
+* 一些平滑的折线图的制作
+* 很多炫酷的动画效果
+
+
+### 如何轻松入门贝塞尔曲线？
+
+虽然贝塞尔曲线用途非常广泛，然而目前貌似并没有适合的中文教程，能够搜索出来Android关于贝塞尔曲线的中文文章基本可以分为以下几种：
+* 科普型(只是让人了解贝塞尔，并没有实质性的内容)
+* 装逼型(摆出来一大堆公式，引用一堆英文原文)
+* 基础型(仅仅是讲解贝塞尔曲线的两个函数用法)
+* 实战型(根据实例讲解其中贝塞尔曲线的运用)
+
+以上几种类型中比较有用的就是基础型和实战型，但两者各有不足，本文会综合两者内容，从零开始学习贝塞尔曲线。
+
+### 第一步.理解贝塞尔曲线的原理
+
+此处理解贝塞尔曲线并非是学会公式的推导过程(不是推倒(ﾉ*･ω･)ﾉ)，而是要了解贝塞尔曲线是如何生成的。
+贝塞尔曲线是用一系列点来控制曲线状态的，我将这些点简单分为两类：
+
+| 类型 | 作用 |
+| ---- | ------------ |
+| 数据点 | 确定曲线的起始和结束位置 |
+| 控制点 | 确定曲线的弯曲程度 |
+
+> 此处暂时仅作了解概念，接下来就会讲解其中详细的含义。
+
+**一阶曲线原理：**
+
+一阶曲线是没有控制点的，仅有两个数据点(A 和 B)，最终效果一个线段。
+
+
+
+> **上图表示的是一阶曲线生成过程中的某一个阶段，动态过程可以参照下图(本文中贝塞尔曲线相关的动态演示图片来自维基百科)。**
+
+
+
+> **PS：一阶曲线其实就是前面讲解过的lineTo。**
+
+**二阶曲线原理：**
+
+二阶曲线由两个数据点(A 和 C)，一个控制点(B)来描述曲线状态，大致如下：
+
+
+
+上图中红色曲线部分就是传说中的二阶贝塞尔曲线，那么这条红色曲线是如何生成的呢？接下来我们就以其中的一个状态分析一下：
+
+
+
+连接AB BC，并在AB上取点D，BC上取点E，使其满足条件：
+
+
+
+
+连接DE，取点F，使得:
+
+
+这样获取到的点F就是贝塞尔曲线上的一个点，动态过程如下：
+
+
+
+> **PS: 二阶曲线对应的方法是quadTo**
+
+**三阶曲线原理：**
+
+三阶曲线由两个数据点(A 和 D)，两个控制点(B 和 C)来描述曲线状态，如下：
+
+
+
+三阶曲线计算过程与二阶类似，具体可以见下图动态效果：
+
+
+
+> **PS: 三阶曲线对应的方法是cubicTo**
+
+#### [贝塞尔曲线速查表](https://github.com/GcsSloop/AndroidNote/blob/master/QuickChart/Bezier.md)
+
+#### 强烈推荐[点击这里](http://bezier.method.ac/)练习贝塞尔曲线，可以加深对贝塞尔曲线的理解程度。
+
+### 第二步.了解贝塞尔曲线相关函数使用方法
+
+#### 一阶曲线：
+
+一阶曲线是一条线段，非常简单，可以参见上一篇文章[Path之基本操作](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/5%5DPath_Basic.md)，此处就不详细讲解了。
+
+#### 二阶曲线：
+
+通过上面对二阶曲线的简单了解，我们知道二阶曲线是由两个数据点，一个控制点构成，接下来我们就用一个实例来演示二阶曲线是如何运用的。
+
+首先，两个数据点是控制贝塞尔曲线开始和结束的位置，比较容易理解，而控制点则是控制贝塞尔的弯曲状态，相对来说比较难以理解，所以本示例重点在于理解贝塞尔曲线弯曲状态与控制点的关系，废话不多说，先上效果图：
+
+
+
+> 为了更加容易看出控制点与曲线弯曲程度的关系，上图中绘制出了辅助点和辅助线，从上面的动态图可以看出，贝塞尔曲线在动态变化过程中有类似于橡皮筋一样的弹性效果，因此在制作一些弹性效果的时候很常用。
+
+主要代码如下：
+
+``` java
+public class Bezier extends View {
+
+ private Paint mPaint;
+ private int centerX, centerY;
+
+ private PointF start, end, control;
+
+ public Bessel1(Context context) {
+ super(context);
+ mPaint = new Paint();
+ mPaint.setColor(Color.BLACK);
+ mPaint.setStrokeWidth(8);
+ mPaint.setStyle(Paint.Style.STROKE);
+ mPaint.setTextSize(60);
+
+ start = new PointF(0,0);
+ end = new PointF(0,0);
+ control = new PointF(0,0);
+ }
+
+ @Override
+ protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+ super.onSizeChanged(w, h, oldw, oldh);
+ centerX = w/2;
+ centerY = h/2;
+
+ // 初始化数据点和控制点的位置
+ start.x = centerX-200;
+ start.y = centerY;
+ end.x = centerX+200;
+ end.y = centerY;
+ control.x = centerX;
+ control.y = centerY-100;
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ // 根据触摸位置更新控制点，并提示重绘
+ control.x = event.getX();
+ control.y = event.getY();
+ invalidate();
+ return true;
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ super.onDraw(canvas);
+
+ // 绘制数据点和控制点
+ mPaint.setColor(Color.GRAY);
+ mPaint.setStrokeWidth(20);
+ canvas.drawPoint(start.x,start.y,mPaint);
+ canvas.drawPoint(end.x,end.y,mPaint);
+ canvas.drawPoint(control.x,control.y,mPaint);
+
+ // 绘制辅助线
+ mPaint.setStrokeWidth(4);
+ canvas.drawLine(start.x,start.y,control.x,control.y,mPaint);
+ canvas.drawLine(end.x,end.y,control.x,control.y,mPaint);
+
+ // 绘制贝塞尔曲线
+ mPaint.setColor(Color.RED);
+ mPaint.setStrokeWidth(8);
+
+ Path path = new Path();
+
+ path.moveTo(start.x,start.y);
+ path.quadTo(control.x,control.y,end.x,end.y);
+
+ canvas.drawPath(path, mPaint);
+ }
+}
+
+```
+
+#### 三阶曲线：
+三阶曲线由两个数据点和两个控制点来控制曲线状态。
+
+
+
+代码:
+
+``` java
+public class Bezier2 extends View {
+
+ private Paint mPaint;
+ private int centerX, centerY;
+
+ private PointF start, end, control1, control2;
+ private boolean mode = true;
+
+ public Bezier2(Context context) {
+ this(context, null);
+
+ }
+
+ public Bezier2(Context context, AttributeSet attrs) {
+ super(context, attrs);
+
+ mPaint = new Paint();
+ mPaint.setColor(Color.BLACK);
+ mPaint.setStrokeWidth(8);
+ mPaint.setStyle(Paint.Style.STROKE);
+ mPaint.setTextSize(60);
+
+ start = new PointF(0, 0);
+ end = new PointF(0, 0);
+ control1 = new PointF(0, 0);
+ control2 = new PointF(0, 0);
+ }
+
+ public void setMode(boolean mode) {
+ this.mode = mode;
+ }
+
+ @Override
+ protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+ super.onSizeChanged(w, h, oldw, oldh);
+ centerX = w / 2;
+ centerY = h / 2;
+
+ // 初始化数据点和控制点的位置
+ start.x = centerX - 200;
+ start.y = centerY;
+ end.x = centerX + 200;
+ end.y = centerY;
+ control1.x = centerX;
+ control1.y = centerY - 100;
+ control2.x = centerX;
+ control2.y = centerY - 100;
+
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ // 根据触摸位置更新控制点，并提示重绘
+ if (mode) {
+ control1.x = event.getX();
+ control1.y = event.getY();
+ } else {
+ control2.x = event.getX();
+ control2.y = event.getY();
+ }
+ invalidate();
+ return true;
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ super.onDraw(canvas);
+ //drawCoordinateSystem(canvas);
+
+ // 绘制数据点和控制点
+ mPaint.setColor(Color.GRAY);
+ mPaint.setStrokeWidth(20);
+ canvas.drawPoint(start.x, start.y, mPaint);
+ canvas.drawPoint(end.x, end.y, mPaint);
+ canvas.drawPoint(control1.x, control1.y, mPaint);
+ canvas.drawPoint(control2.x, control2.y, mPaint);
+
+ // 绘制辅助线
+ mPaint.setStrokeWidth(4);
+ canvas.drawLine(start.x, start.y, control1.x, control1.y, mPaint);
+ canvas.drawLine(control1.x, control1.y,control2.x, control2.y, mPaint);
+ canvas.drawLine(control2.x, control2.y,end.x, end.y, mPaint);
+
+ // 绘制贝塞尔曲线
+ mPaint.setColor(Color.RED);
+ mPaint.setStrokeWidth(8);
+
+ Path path = new Path();
+
+ path.moveTo(start.x, start.y);
+ path.cubicTo(control1.x, control1.y, control2.x,control2.y, end.x, end.y);
+
+ canvas.drawPath(path, mPaint);
+ }
+}
+
+```
+
+> 三阶曲线相比于二阶曲线可以制作更加复杂的形状，但是对于高阶的曲线，用低阶的曲线组合也可达到相同的效果，就是传说中的**降阶**。因此我们对贝塞尔曲线的封装方法一般最高只到三阶曲线。
+
+#### 降阶与升阶
+
+| 类型 | 释义 | 变化 |
+| ---- | -------------------------------- | -------------------------- |
+| 降阶 | 在保持曲线形状与方向不变的情况下，减少控制点数量，即降低曲线阶数 | 方法变得简单，数据点变多，控制点可能减少，灵活性变弱 |
+| 升阶 | 在保持曲线形状与方向不变的情况下，增加控制点数量，即升高曲线阶数 | 方法更加复杂，数据点不变，控制点增加，灵活性变强 |
+
+### 第三步.贝塞尔曲线使用实例
+
+**在制作这个实例之前，首先要明确一个内容，就是在什么情况下需要使用贝塞尔曲线？**
+
+> 需要绘制不规则图形时？ 当然不是！目前来说，我觉得使用贝塞尔曲线主要有以下几个方面(仅个人拙见，可能存在错误，欢迎指正)
+
+| 序号 | 内容 | 用例 |
+| ---- | ---------------------------- | -------------- |
+| 1 | 事先不知道曲线状态，需要实时计算时 | 天气预报气温变化的平滑折线图 |
+| 2 | 显示状态会根据用户操作改变时 | QQ小红点，仿真翻书效果 |
+| 3 | 一些比较复杂的运动状态(配合PathMeasure使用) | 复杂运动状态的动画效果 |
+
+至于只需要一个静态的曲线图形的情况，用图片岂不是更好，大量的计算会很不划算。
+
+如果是显示SVG矢量图的话，已经有相关的解析工具了(内部依旧运用的有贝塞尔曲线)，不需要手动计算。
+
+**贝塞尔曲线的主要优点是可以实时控制曲线状态，并可以通过改变控制点的状态实时让曲线进行平滑的状态变化。**
+
+### 接下来我们就用一个简单的示例让一个圆渐变成为心形：
+
+#### 效果图：
+
+
+
+#### 思路分析：
+
+我们最终的需要的效果是将一个圆转变成一个心形，通过分析可知，圆可以由四段三阶贝塞尔曲线组合而成，如下：
+
+
+
+心形也可以由四段的三阶的贝塞尔曲线组成，如下：
+
+
+
+两者的差别仅仅在于数据点和控制点位置不同，因此只需要调整数据点和控制点的位置，就能将圆形变为心形。
+
+#### 核心难点：
+
+##### 1.如何得到数据点和控制点的位置？
+
+ 关于使用绘制圆形的数据点与控制点早就已经有人详细的计算好了，可以参考stackoverflow的一个回答[How to create circle with Bézier curves?](http://stackoverflow.com/questions/1734745/how-to-create-circle-with-b%C3%A9zier-curves)其中的数据只需要拿来用即可。
+
+ 而对于心形的数据点和控制点，可以由圆形的部分数据点和控制点平移后得到，具体参数可以自己慢慢调整到一个满意的效果。
+
+##### 2.如何达到渐变效果？
+
+ 渐变其实就是每次对数据点和控制点稍微移动一点，然后重绘界面，在短时间多次的调整数据点与控制点，使其逐渐接近目标值，通过不断的重绘界面达到一种渐变的效果。过程可以参照下图动态效果：
+
+ 
+
+#### 代码：
+
+``` java
+public class Bezier3 extends View {
+ private static final float C = 0.551915024494f; // 一个常量，用来计算绘制圆形贝塞尔曲线控制点的位置
+
+ private Paint mPaint;
+ private int mCenterX, mCenterY;
+
+ private PointF mCenter = new PointF(0,0);
+ private float mCircleRadius = 200; // 圆的半径
+ private float mDifference = mCircleRadius*C; // 圆形的控制点与数据点的差值
+
+ private float[] mData = new float[8]; // 顺时针记录绘制圆形的四个数据点
+ private float[] mCtrl = new float[16]; // 顺时针记录绘制圆形的八个控制点
+
+ private float mDuration = 1000; // 变化总时长
+ private float mCurrent = 0; // 当前已进行时长
+ private float mCount = 100; // 将时长总共划分多少份
+ private float mPiece = mDuration/mCount; // 每一份的时长
+
+
+ public Bezier3(Context context) {
+ this(context, null);
+
+ }
+
+ public Bezier3(Context context, AttributeSet attrs) {
+ super(context, attrs);
+
+ mPaint = new Paint();
+ mPaint.setColor(Color.BLACK);
+ mPaint.setStrokeWidth(8);
+ mPaint.setStyle(Paint.Style.STROKE);
+ mPaint.setTextSize(60);
+
+
+ // 初始化数据点
+
+ mData[0] = 0;
+ mData[1] = mCircleRadius;
+
+ mData[2] = mCircleRadius;
+ mData[3] = 0;
+
+ mData[4] = 0;
+ mData[5] = -mCircleRadius;
+
+ mData[6] = -mCircleRadius;
+ mData[7] = 0;
+
+ // 初始化控制点
+
+ mCtrl[0] = mData[0]+mDifference;
+ mCtrl[1] = mData[1];
+
+ mCtrl[2] = mData[2];
+ mCtrl[3] = mData[3]+mDifference;
+
+ mCtrl[4] = mData[2];
+ mCtrl[5] = mData[3]-mDifference;
+
+ mCtrl[6] = mData[4]+mDifference;
+ mCtrl[7] = mData[5];
+
+ mCtrl[8] = mData[4]-mDifference;
+ mCtrl[9] = mData[5];
+
+ mCtrl[10] = mData[6];
+ mCtrl[11] = mData[7]-mDifference;
+
+ mCtrl[12] = mData[6];
+ mCtrl[13] = mData[7]+mDifference;
+
+ mCtrl[14] = mData[0]-mDifference;
+ mCtrl[15] = mData[1];
+ }
+
+
+ @Override
+ protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+ super.onSizeChanged(w, h, oldw, oldh);
+ mCenterX = w / 2;
+ mCenterY = h / 2;
+ }
+
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ super.onDraw(canvas);
+ drawCoordinateSystem(canvas); // 绘制坐标系
+
+ canvas.translate(mCenterX, mCenterY); // 将坐标系移动到画布中央
+ canvas.scale(1,-1); // 翻转Y轴
+
+ drawAuxiliaryLine(canvas);
+
+
+ // 绘制贝塞尔曲线
+ mPaint.setColor(Color.RED);
+ mPaint.setStrokeWidth(8);
+
+ Path path = new Path();
+ path.moveTo(mData[0],mData[1]);
+
+ path.cubicTo(mCtrl[0], mCtrl[1], mCtrl[2], mCtrl[3], mData[2], mData[3]);
+ path.cubicTo(mCtrl[4], mCtrl[5], mCtrl[6], mCtrl[7], mData[4], mData[5]);
+ path.cubicTo(mCtrl[8], mCtrl[9], mCtrl[10], mCtrl[11], mData[6], mData[7]);
+ path.cubicTo(mCtrl[12], mCtrl[13], mCtrl[14], mCtrl[15], mData[0], mData[1]);
+
+ canvas.drawPath(path, mPaint);
+
+ mCurrent += mPiece;
+ if (mCurrent < mDuration){
+
+ mData[1] -= 120/mCount;
+ mCtrl[7] += 80/mCount;
+ mCtrl[9] += 80/mCount;
+
+ mCtrl[4] -= 20/mCount;
+ mCtrl[10] += 20/mCount;
+
+ postInvalidateDelayed((long) mPiece);
+ }
+ }
+
+ // 绘制辅助线
+ private void drawAuxiliaryLine(Canvas canvas) {
+ // 绘制数据点和控制点
+ mPaint.setColor(Color.GRAY);
+ mPaint.setStrokeWidth(20);
+
+ for (int i=0; i<8; i+=2){
+ canvas.drawPoint(mData[i],mData[i+1], mPaint);
+ }
+
+ for (int i=0; i<16; i+=2){
+ canvas.drawPoint(mCtrl[i], mCtrl[i+1], mPaint);
+ }
+
+
+ // 绘制辅助线
+ mPaint.setStrokeWidth(4);
+
+ for (int i=2, j=2; i<8; i+=2, j+=4){
+ canvas.drawLine(mData[i],mData[i+1],mCtrl[j],mCtrl[j+1],mPaint);
+ canvas.drawLine(mData[i],mData[i+1],mCtrl[j+2],mCtrl[j+3],mPaint);
+ }
+ canvas.drawLine(mData[0],mData[1],mCtrl[0],mCtrl[1],mPaint);
+ canvas.drawLine(mData[0],mData[1],mCtrl[14],mCtrl[15],mPaint);
+ }
+
+ // 绘制坐标系
+ private void drawCoordinateSystem(Canvas canvas) {
+ canvas.save(); // 绘制做坐标系
+
+ canvas.translate(mCenterX, mCenterY); // 将坐标系移动到画布中央
+ canvas.scale(1,-1); // 翻转Y轴
+
+ Paint fuzhuPaint = new Paint();
+ fuzhuPaint.setColor(Color.RED);
+ fuzhuPaint.setStrokeWidth(5);
+ fuzhuPaint.setStyle(Paint.Style.STROKE);
+
+ canvas.drawLine(0, -2000, 0, 2000, fuzhuPaint);
+ canvas.drawLine(-2000, 0, 2000, 0, fuzhuPaint);
+
+ canvas.restore();
+ }
+}
+
+```
+
+## 三.总结
+
+其实关于贝塞尔曲线最重要的是核心理解贝塞尔曲线的生成方式，只有理解了贝塞尔曲线的生成方式，才能更好的运用贝塞尔曲线。在上一篇末尾说本篇要涉及一点自相交图形渲染问题，不幸的是，本篇没有了，请期待下一篇(可能会在下一篇中出现o(*￣︶￣*)o)，下一篇依旧Path相关内容，教给大家一些更好玩的东西。
+
+解锁新的境界之[【绘制一个弹性的圆】](http://www.jianshu.com/p/791d3a791ec2)：
+
+
+
+(,,• ₃ •,,)
+#### PS: 由于本人水平有限，某些地方可能存在误解或不准确，如果你对此有疑问可以提交Issues进行反馈。
+
+## About Me
+
+### 作者微博: @GcsSloop
+
+
+
+## 参考资料
+[Path](http://developer.android.com/reference/android/graphics/Path.html)
+[Canvas](http://developer.android.com/reference/android/graphics/Canvas.html)
+[贝塞尔曲线扫盲](http://www.html-js.com/article/1628)
+[贝塞尔曲线-维基百科](https://zh.wikipedia.org/wiki/%E8%B2%9D%E8%8C%B2%E6%9B%B2%E7%B7%9A)
+[How to create circle with Bézier curves?](http://stackoverflow.com/questions/1734745/how-to-create-circle-with-b%C3%A9zier-curves)
+[三次贝塞尔曲线练习之弹性的圆](http://www.jianshu.com/p/791d3a791ec2)
+
+
+
+
+
+
diff --git a/CustomView/Advance/[07]Path_Over.md b/CustomView/Advance/[07]Path_Over.md
new file mode 100644
index 00000000..dad580ce
--- /dev/null
+++ b/CustomView/Advance/[07]Path_Over.md
@@ -0,0 +1,412 @@
+# Path之完结篇(伪)
+
+### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
+### [【本系列相关文章】](https://github.com/GcsSloop/AndroidNote/tree/master/CustomView/README.md)
+
+经历过前两篇 [Path之基本操作](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B05%5DPath_Basic.md) 和 [Path之贝塞尔曲线](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B06%5DPath_Bezier.md) 的讲解，本篇终于进入Path的收尾篇，本篇结束后Path的大部分相关方法都已经讲解完了，但Path还有一些更有意思的玩法，应该会在后续的文章中出现吧，嗯，应该会的ˊ_>ˋ
+
+******
+
+## 一.Path常用方法表
+> 为了兼容性(_偷懒_) 本表格中去除了在API21(即安卓版本5.0)以上才添加的方法。忍不住吐槽一下，为啥看起来有些顺手就能写的重载方法要等到API21才添加上啊。宝宝此刻内心也是崩溃的。
+
+| 作用 | 相关方法 | 备注 |
+| ----------- | ---------------------------------------- | ---------------------------------------- |
+| 移动起点 | moveTo | 移动下一次操作的起点位置 |
+| 设置终点 | setLastPoint | 重置当前path中最后一个点位置，如果在绘制之前调用，效果和moveTo相同 |
+| 连接直线 | lineTo | 添加上一个点到当前点之间的直线到Path |
+| 闭合路径 | close | 连接第一个点连接到最后一个点，形成一个闭合区域 |
+| 添加内容 | addRect, addRoundRect, addOval, addCircle, addPath, addArc, arcTo | 添加(矩形， 圆角矩形， 椭圆， 圆， 路径， 圆弧) 到当前Path (注意addArc和arcTo的区别) |
+| 是否为空 | isEmpty | 判断Path是否为空 |
+| 是否为矩形 | isRect | 判断path是否是一个矩形 |
+| 替换路径 | set | 用新的路径替换到当前路径所有内容 |
+| 偏移路径 | offset | 对当前路径之前的操作进行偏移(不会影响之后的操作) |
+| 贝塞尔曲线 | quadTo, cubicTo | 分别为二次和三次贝塞尔曲线的方法 |
+| rXxx方法 | rMoveTo, rLineTo, rQuadTo, rCubicTo | **不带r的方法是基于原点的坐标系(偏移量)， rXxx方法是基于当前点坐标系(偏移量)** |
+| 填充模式 | setFillType, getFillType, isInverseFillType, toggleInverseFillType | 设置,获取,判断和切换填充模式 |
+| 提示方法 | incReserve | 提示Path还有多少个点等待加入**(这个方法貌似会让Path优化存储结构)** |
+| 布尔操作(API19) | op | 对两个Path进行布尔运算(即取交集、并集等操作) |
+| 计算边界 | computeBounds | 计算Path的边界 |
+| 重置路径 | reset, rewind | 清除Path中的内容
**reset不保留内部数据结构，但会保留FillType.**
**rewind会保留内部的数据结构，但不保留FillType** |
+| 矩阵操作 | transform | 矩阵变换 |
+
+
+## 二、Path方法详解
+
+### rXxx方法
+
+此类方法可以看到和前面的一些方法看起来很像，只是在前面多了一个r，那么这个rXxx和前面的一些方法有什么区别呢？
+
+> **rXxx方法的坐标使用的是相对位置(基于当前点的位移)，而之前方法的坐标是绝对位置(基于当前坐标系的坐标)。**
+
+**举个例子:**
+
+``` java
+ Path path = new Path();
+
+ path.moveTo(100,100);
+ path.lineTo(100,200);
+
+ canvas.drawPath(path,mDeafultPaint);
+```
+
+
+在这个例子中，先移动点到坐标(100，100)处，之后再连接 _点(100，100)_ 到 _(100，200)_ 之间点直线,非常简单，画出来就是一条竖直的线，那接下来看下一个例子：
+
+``` java
+ Path path = new Path();
+
+ path.moveTo(100,100);
+ path.rLineTo(100,200);
+
+ canvas.drawPath(path,mDeafultPaint);
+```
+
+
+这个例子中，将 lineTo 换成了 rLineTo 可以看到在屏幕上原本是竖直的线变成了倾斜的线。这是因为最终我们连接的是 _(100,100)_ 和 _(200, 300)_ 之间的线段。
+
+在使用rLineTo之前，当前点的位置在 (100,100) ， 使用了 rLineTo(100,200) 之后，下一个点的位置是在当前点的基础上加上偏移量得到的，即 (100+100, 100+200) 这个位置，故最终结果如上所示。
+
+**PS: 此处仅以 rLineTo 为例，只要理解 “绝对坐标” 和 “相对坐标” 的区别，其他方法类比即可。**
+
+### 填充模式
+
+我们在之前的文章中了解到，Paint有三种样式，“描边” “填充” 以及 “描边加填充”，我们这里所了解到就是在Paint设置为后两种样式时**不同的填充模式对图形渲染效果的影响**。
+
+**我们要给一个图形内部填充颜色，首先需要分清哪一部分是外部，哪一部分是内部，机器不像我们人那么聪明，机器是如何判断内外呢？**
+
+机器判断图形内外，一般有以下两种方法：
+
+> PS：此处所有的图形均为封闭图形，不包括图形不封闭这种情况。
+
+| 方法 | 判定条件 | 解释 |
+| ------- | --------------------- | ---------------------------------------- |
+| 奇偶规则 | 奇数表示在图形内，偶数表示在图形外 | 从任意位置p作一条射线， 若与该射线相交的图形边的数目为奇数，则p是图形内部点，否则是外部点。 |
+| 非零环绕数规则 | 若环绕数为0表示在图形外，非零表示在图形内 | 首先使图形的边变为矢量。将环绕数初始化为零。再从任意位置p作一条射线。当从p点沿射线方向移动时，对在每个方向上穿过射线的边计数，每当图形的边从右到左穿过射线时，环绕数加1，从左到右时，环绕数减1。处理完图形的所有相关边之后，若环绕数为非零，则p为内部点，否则，p是外部点。 |
+
+接下来我们先了解一下两种判断方法是如何工作的。
+
+#### 奇偶规则(Even-Odd Rule)
+
+这一个比较简单，也容易理解，直接用一个简单示例来说明。
+
+
+
+在上图中有一个四边形，我们选取了三个点来判断这些点是否在图形内部。
+
+>
+>P1: 从P1发出一条射线，发现图形与该射线相交边数为0，偶数，故P1点在图形外部。
+>P2: 从P2发出一条射线，发现图形与该射线相交边数为1，奇数，故P2点在图形内部。
+>P3: 从P3发出一条射线，发现图形与该射线相交边数为2，偶数，故P3点在图形外部。
+
+
+#### 非零环绕数规则(Non-Zero Winding Number Rule)
+
+非零环绕数规则相对来说比较难以理解一点。
+
+我们在之前的文章 [Path之基本操作](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B05%5DPath_Basic.md) 中我们了解到，在给Path中添加图形时需要指定图形的添加方式，是用顺时针还是逆时针，另外我们不论是使用lineTo，quadTo，cubicTo还是其他连接线的方法，都是从一个点连接到另一个点，换言之，**Path中任何线段都是有方向性的**，这也是使用非零环绕数规则的基础。
+
+我们依旧用一个简单的例子来说明非零环绕数规则的用法:
+
+> **PS: 注意图形中线段的方向性!**
+
+
+
+>
+>P1: 从P1点发出一条射线，沿射线方向移动，并没有与边相交点部分，环绕数为0，故P1在图形外边。
+>P2: 从P2点发出一条射线，沿射线方向移动，与图形点左侧边相交，该边从左到右穿过射线，环绕数－1，最终环绕数为－1，故P2在图形内部。
+>P3: 从P3点发出一条射线，沿射线方向移动，在第一个交点处，底边从右到左穿过射线，环绕数＋1，在第二个交点处，右侧边从左到右穿过射线，环绕数－1，最终环绕数为0，故P3在图形外部。
+
+通常，这两种方法的判断结果是相同的，但也存在两种方法判断结果不同的情况，如下面这种情况：
+
+> 注意图形线段的方向，就不详细解释了，用上面的方法进行判断即可。
+
+
+
+#### 自相交图形
+
+**自相交图形定义：多边形在平面内除顶点外还有其他公共点。**
+
+简单的提一下自相交图形，了解概念即可，下图就是一个简单的自相交图形：
+
+
+
+#### Android中的填充模式
+
+Android中的填充模式有四种，是封装在Path中的一个枚举。
+
+| 模式 | 简介 |
+| ---------------- | -------- |
+| EVEN_ODD | 奇偶规则 |
+| INVERSE_EVEN_ODD | 反奇偶规则 |
+| WINDING | 非零环绕数规则 |
+| INVERSE_WINDING | 反非零环绕数规则 |
+
+我们可以看到上面有四种模式，分成两对，例如 "奇偶规则" 与 "反奇偶规则" 是一对，它们之间有什么关系呢？
+
+Inverse 的含义是“相反，对立”，说明反奇偶规则刚好与奇偶规则相反，例如对于一个矩形而言，使用奇偶规则会填充矩形内部，而使用反奇偶规则会填充矩形外部，这个会在后面示例中代码展示两者的区别。
+
+#### Android与填充模式相关的方法
+
+> 这些都是Path中的方法。
+
+| 方法 | 作用 |
+| --------------------- | ------------------------ |
+| setFillType | 设置填充规则 |
+| getFillType | 获取当前填充规则 |
+| isInverseFillType | 判断是否是反向(INVERSE)规则 |
+| toggleInverseFillType | 切换填充规则(即原有规则与反向规则之间相互切换) |
+
+#### 示例演示：
+
+本演示着重于帮助理解填充模式中的一些难点和易混淆的问题，对于一些比较简单的问题，读者可自行验证，本文中不会过多赘述。
+
+##### 奇偶规则与反奇偶规则
+
+``` java
+ mDeafultPaint.setStyle(Paint.Style.FILL); // 设置画布模式为填充
+
+ canvas.translate(mViewWidth / 2, mViewHeight / 2); // 移动画布(坐标系)
+
+ Path path = new Path(); // 创建Path
+
+ //path.setFillType(Path.FillType.EVEN_ODD); // 设置Path填充模式为 奇偶规则
+ path.setFillType(Path.FillType.INVERSE_EVEN_ODD); // 反奇偶规则
+
+ path.addRect(-200,-200,200,200, Path.Direction.CW); // 给Path中添加一个矩形
+```
+
+下面两张图片分别是在奇偶规则与反奇偶规则的情况下绘制的结果，可以看出其填充的区域刚好相反：
+
+> PS: 白色为背景色，黑色为填充色。
+
+
+
+
+##### 图形边的方向对非零奇偶环绕数规则填充结果的影响
+
+我们之前讨论过给Path添加图形时顺时针与逆时针的作用，除了上次讲述的方便记录外，就是本文所涉及的另外一个重要作用了: **"作为非零环绕数规则的判断依据。"**
+
+通过前面我们已经大致了解了在图形边的方向会如何影响到填充效果，我们这里验证一下:
+
+``` java
+ mDeafultPaint.setStyle(Paint.Style.FILL); // 设置画笔模式为填充
+
+ canvas.translate(mViewWidth / 2, mViewHeight / 2); // 移动画布(坐系)
+
+ Path path = new Path(); // 创建Path
+
+ // 添加小正方形 (通过这两行代码来控制小正方形边的方向,从而演示不同的效果)
+ // path.addRect(-200, -200, 200, 200, Path.Direction.CW);
+ path.addRect(-200, -200, 200, 200, Path.Direction.CCW);
+
+ // 添加大正方形
+ path.addRect(-400, -400, 400, 400, Path.Direction.CCW);
+
+ path.setFillType(Path.FillType.WINDING); // 设置Path填充模式为非零环绕规则
+
+ canvas.drawPath(path, mDeafultPaint); // 绘制Path
+```
+
+
+
+
+
+### 布尔操作(API19)
+
+布尔操作与我们中学所学的集合操作非常像，只要知道集合操作中的交集，并集，差集等操作，那么理解布尔操作也是很容易的。
+
+**布尔操作是两个Path之间的运算，主要作用是用一些简单的图形通过一些规则合成一些相对比较复杂，或难以直接得到的图形**。
+
+如太极中的阴阳鱼，如果用贝塞尔曲线制作的话，可能需要六段贝塞尔曲线才行，而在这里我们可以用四个Path通过布尔运算得到，而且会相对来说更容易理解一点。
+
+
+
+``` java
+ canvas.translate(mViewWidth / 2, mViewHeight / 2);
+
+ Path path1 = new Path();
+ Path path2 = new Path();
+ Path path3 = new Path();
+ Path path4 = new Path();
+
+ path1.addCircle(0, 0, 200, Path.Direction.CW);
+ path2.addRect(0, -200, 200, 200, Path.Direction.CW);
+ path3.addCircle(0, -100, 100, Path.Direction.CW);
+ path4.addCircle(0, 100, 100, Path.Direction.CCW);
+
+
+ path1.op(path2, Path.Op.DIFFERENCE);
+ path1.op(path3, Path.Op.UNION);
+ path1.op(path4, Path.Op.DIFFERENCE);
+
+ canvas.drawPath(path1, mDeafultPaint);
+```
+
+前面演示了布尔运算的作用，接下来我们了解一下布尔运算的核心:布尔逻辑。
+
+Path的布尔运算有五种逻辑，如下:
+
+| 逻辑名称 | 类比 | 说明 | 示意图 |
+| ------------------ | ---- | ------------------------ | ---------------------------------------- |
+| DIFFERENCE | 差集 | Path1中减去Path2后剩下的部分 |  |
+| REVERSE_DIFFERENCE | 差集 | Path2中减去Path1后剩下的部分 |  |
+| INTERSECT | 交集 | Path1与Path2相交的部分 |  |
+| UNION | 并集 | 包含全部Path1和Path2 |  |
+| XOR | 异或 | 包含Path1与Path2但不包括两者相交的部分 |  |
+
+#### 布尔运算方法
+
+通过前面的理论知识铺垫，相信大家对布尔运算已经有了基本的认识和理解，下面我们用代码演示一下布尔运算:
+
+在Path中的布尔运算有两个方法
+
+``` java
+ boolean op (Path path, Path.Op op)
+ boolean op (Path path1, Path path2, Path.Op op)
+```
+
+两个方法中的返回值用于判断布尔运算是否成功，它们使用方法如下:
+
+``` java
+ // 对 path1 和 path2 执行布尔运算，运算方式由第二个参数指定，运算结果存入到path1中。
+ path1.op(path2, Path.Op.DIFFERENCE);
+
+ // 对 path1 和 path2 执行布尔运算，运算方式由第三个参数指定，运算结果存入到path3中。
+ path3.op(path1, path2, Path.Op.DIFFERENCE)
+```
+
+#### 布尔运算示例
+
+
+
+代码：
+
+``` java
+ int x = 80;
+ int r = 100;
+
+ canvas.translate(250,0);
+
+ Path path1 = new Path();
+ Path path2 = new Path();
+ Path pathOpResult = new Path();
+
+ path1.addCircle(-x, 0, r, Path.Direction.CW);
+ path2.addCircle(x, 0, r, Path.Direction.CW);
+
+ pathOpResult.op(path1,path2, Path.Op.DIFFERENCE);
+ canvas.translate(0, 200);
+ canvas.drawText("DIFFERENCE", 240,0,mDeafultPaint);
+ canvas.drawPath(pathOpResult,mDeafultPaint);
+
+ pathOpResult.op(path1,path2, Path.Op.REVERSE_DIFFERENCE);
+ canvas.translate(0, 300);
+ canvas.drawText("REVERSE_DIFFERENCE", 240,0,mDeafultPaint);
+ canvas.drawPath(pathOpResult,mDeafultPaint);
+
+ pathOpResult.op(path1,path2, Path.Op.INTERSECT);
+ canvas.translate(0, 300);
+ canvas.drawText("INTERSECT", 240,0,mDeafultPaint);
+ canvas.drawPath(pathOpResult,mDeafultPaint);
+
+ pathOpResult.op(path1,path2, Path.Op.UNION);
+ canvas.translate(0, 300);
+ canvas.drawText("UNION", 240,0,mDeafultPaint);
+ canvas.drawPath(pathOpResult,mDeafultPaint);
+
+ pathOpResult.op(path1,path2, Path.Op.XOR);
+ canvas.translate(0, 300);
+ canvas.drawText("XOR", 240,0,mDeafultPaint);
+ canvas.drawPath(pathOpResult,mDeafultPaint);
+```
+
+### 计算边界
+
+这个方法主要作用是计算Path所占用的空间以及所在位置,方法如下：
+
+``` java
+ void computeBounds (RectF bounds, boolean exact)
+```
+
+它有两个参数：
+
+| 参数 | 作用 |
+| ------ | ------------------------------- |
+| bounds | 测量结果会放入这个矩形 |
+| exact | 是否精确测量，目前这一个参数作用已经废弃，一般写true即可 |
+
+关于exact如有疑问可参见Google官方的提交记录[Path.computeBounds()](https://code.google.com/p/android/issues/detail?id=4070)
+
+#### 计算边界示例
+
+计算path边界的一个简单示例.
+
+
+
+代码：
+
+``` java
+ // 移动canvas,mViewWidth与mViewHeight在 onSizeChanged 方法中获得
+ canvas.translate(mViewWidth/2,mViewHeight/2);
+
+ RectF rect1 = new RectF(); // 存放测量结果的矩形
+
+ Path path = new Path(); // 创建Path并添加一些内容
+ path.lineTo(100,-50);
+ path.lineTo(100,50);
+ path.close();
+ path.addCircle(-100,0,100, Path.Direction.CW);
+
+ path.computeBounds(rect1,true); // 测量Path
+
+ canvas.drawPath(path,mDeafultPaint); // 绘制Path
+
+ mDeafultPaint.setStyle(Paint.Style.STROKE);
+ mDeafultPaint.setColor(Color.RED);
+ canvas.drawRect(rect1,mDeafultPaint); // 绘制边界
+```
+
+### 重置路径
+
+重置Path有两个方法，分别是reset和rewind，两者区别主要有以下两点：
+
+| 方法 | 是否保留FillType设置 | 是否保留原有数据结构 |
+| ------ | :------------: | :--------: |
+| reset | 是 | 否 |
+| rewind | 否 | 是 |
+
+**这个两个方法应该何时选择呢？**
+
+选择权重: FillType > 数据结构
+
+_因为“FillType”影响的是显示效果，而“数据结构”影响的是重建速度。_
+
+
+## 总结
+
+Path中常用的方法到此已经结束，希望能够帮助大家加深对Path的理解运用，让大家能够用Path愉快的玩耍。(￣▽￣)
+
+(,,• ₃ •,,)
+#### PS: 由于本人水平有限，某些地方可能存在误解或不准确，如果你对此有疑问可以提交Issues进行反馈。
+
+## About Me
+
+### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
+
+
+
+## 参考资料
+[Path](https://developer.android.com/reference/android/graphics/Path.html)
+[维基百科－Nonzero-rule](https://en.wikipedia.org/wiki/Nonzero-rule)
+[android绘图之Path总结](http://ghui.me/post/2015/10/android-graphics-path/)
+[布尔逻辑](https://zh.wikipedia.org/wiki/%E5%B8%83%E5%B0%94%E9%80%BB%E8%BE%91)
+[GoogleCode－Path.computeBounds()](https://code.google.com/p/android/issues/detail?id=4070)
+[Path.reset vs Path.rewind](http://stackoverflow.com/questions/11505617/path-reset-vs-path-rewind)
+[]()
+[]()
+
+
+
+
+
diff --git a/CustomView/Advance/[08]Path_Play.md b/CustomView/Advance/[08]Path_Play.md
new file mode 100644
index 00000000..35387d5f
--- /dev/null
+++ b/CustomView/Advance/[08]Path_Play.md
@@ -0,0 +1,588 @@
+# Path之玩出花样(PathMeasure)
+
+可以看到，在经过
+[Path之基本操作](http://www.gcssloop.com/customview/Path_Basic/)
+[Path之贝塞尔曲线](http://www.gcssloop.com/customview/Path_Bezier/) 和
+[Path之完结篇](http://www.gcssloop.com/customview/Path_Over/) 后， Path中各类方法基本上都讲完了，表格中还没有讲解到到方法就是矩阵变换了，难道本篇终于要讲矩阵了？
+非也，矩阵这一部分仍在后面单独讲解，本篇主要讲解 PathMeasure 这个类与 Path 的一些使用技巧。
+
+> PS：不要问我为什么不讲 PathEffect，因为这个方法在后面的Paint系列中。
+
+先放一个图镇楼，省的下面无聊的内容把你们都吓跑了Σ(￣。￣ﾉ)ﾉ
+
+
+
+------
+
+## Path & PathMeasure
+
+顾名思义，PathMeasure是一个用来测量Path的类，主要有以下方法:
+
+### 构造方法
+
+| 方法名 | 释义 |
+| ---------------------------------------- | ---------------------------------------- |
+| PathMeasure() | 创建一个空的PathMeasure |
+| PathMeasure(Path path, boolean forceClosed) | 创建 PathMeasure 并关联一个指定的Path(Path需要已经创建完成)。 |
+
+### 公共方法
+
+| 返回值 | 方法名 | 释义 |
+| ------- | ---------------------------------------- | -------------------- |
+| void | setPath(Path path, boolean forceClosed) | 关联一个Path |
+| boolean | isClosed() | 是否闭合 |
+| float | getLength() | 获取Path的长度 |
+| boolean | nextContour() | 跳转到下一个轮廓 |
+| boolean | getSegment(float startD, float stopD, Path dst, boolean startWithMoveTo) | 截取片段 |
+| boolean | getPosTan(float distance, float[] pos, float[] tan) | 获取指定长度的位置坐标及该点切线值 |
+| boolean | getMatrix(float distance, Matrix matrix, int flags) | 获取指定长度的位置坐标及该点Matrix |
+
+PathMeasure的方法也不多，接下来我们就逐一的讲解一下。
+
+------
+
+### 1.构造函数
+
+构造函数有两个。
+
+**无参构造函数：**
+
+```java
+ PathMeasure ()
+```
+
+用这个构造函数可创建一个空的 PathMeasure，但是使用之前需要先调用 setPath 方法来与 Path 进行关联。被关联的 Path 必须是已经创建好的，如果关联之后 Path 内容进行了更改，则需要使用 setPath 方法重新关联。
+
+**有参构造函数：**
+
+```java
+ PathMeasure (Path path, boolean forceClosed)
+```
+
+用这个构造函数是创建一个 PathMeasure 并关联一个 Path， 其实和创建一个空的 PathMeasure 后调用 setPath 进行关联效果是一样的，同样，被关联的 Path 也必须是已经创建好的，如果关联之后 Path 内容进行了更改，则需要使用 setPath 方法重新关联。
+
+该方法有两个参数，第一个参数自然就是被关联的 Path 了，第二个参数是用来确保 Path 闭合，如果设置为 true， 则不论之前Path是否闭合，都会自动闭合该 Path(如果Path可以闭合的话)。
+
+**在这里有两点需要明确:**
+
+>
+
+- 1. 不论 forceClosed 设置为何种状态(true 或者 false)， 都不会影响原有Path的状态，**即 Path 与 PathMeasure 关联之后，之前的的 Path 不会有任何改变。**
+- 1. forceClosed 的设置状态可能会影响测量结果，**如果 Path 未闭合但在与 PathMeasure 关联的时候设置 forceClosed 为 true 时，测量结果可能会比 Path 实际长度稍长一点，获取到到是该 Path 闭合时的状态。**
+
+下面我们用一个例子来验证一下：
+
+```java
+canvas.translate(mViewWidth/2,mViewHeight/2);
+
+Path path = new Path();
+
+path.lineTo(0,200);
+path.lineTo(200,200);
+path.lineTo(200,0);
+
+PathMeasure measure1 = new PathMeasure(path,false);
+PathMeasure measure2 = new PathMeasure(path,true);
+
+Log.e("TAG", "forceClosed=false---->"+measure1.getLength());
+Log.e("TAG", "forceClosed=true----->"+measure2.getLength());
+
+canvas.drawPath(path,mDeafultPaint);
+```
+
+log如下:
+
+```shell
+com.gcssloop.canvas E/TAG: forceClosed=false---->600.0
+com.gcssloop.canvas E/TAG: forceClosed=true----->800.0
+```
+
+绘制在界面上的效果如下:
+
+
+
+我们所创建的 Path 实际上是一个边长为 200 的正方形的三条边，通过上面的示例就能验证以上两个问题。
+
+>
+
+- 1.我们将 Path 与两个的 PathMeasure 进行关联，并给 forceClosed 设置了不同的状态，之后绘制再绘制出来的 Path 没有任何变化，所以与 Path 与 PathMeasure进行关联并不会影响 Path 状态。
+- 2.我们可以看到，设置 forceClosed 为 true 的方法比设置为 false 的方法测量出来的长度要长一点，这是由于 Path 没有闭合的缘故，多出来的距离正是 Path 最后一个点与最开始一个点之间点距离。**forceClosed 为 false 测量的是当前 Path 状态的长度， forceClosed 为 true，则不论Path是否闭合测量的都是 Path 的闭合长度。**
+
+
+
+### 2.setPath、 isClosed 和 getLength
+
+这三个方法都如字面意思一样，非常简单，这里就简单是叙述一下，不再过多讲解。
+
+setPath 是 PathMeasure 与 Path 关联的重要方法，效果和 构造函数 中两个参数的作用是一样的。
+
+isClosed 用于判断 Path 是否闭合，但是如果你在关联 Path 的时候设置 forceClosed 为 true 的话，这个方法的返回值则一定为true。
+
+getLength 用于获取 Path 的总长度，在之前的测试中已经用过了。
+
+
+
+### 3.getSegment
+
+getSegment 用于获取Path的一个片段，方法如下：
+
+```java
+boolean getSegment (float startD, float stopD, Path dst, boolean startWithMoveTo)
+```
+
+方法各个参数释义：
+
+| 参数 | 作用 | 备注 |
+| --------------- | -------------------- | ---------------------------------------- |
+| 返回值(boolean) | 判断截取是否成功 | true 表示截取成功，结果存入dst中，false 截取失败，不会改变dst中内容 |
+| startD | 开始截取位置距离 Path 起点的长度 | 取值范围: 0 <= startD < stopD <= Path总长度 |
+| stopD | 结束截取位置距离 Path 起点的长度 | 取值范围: 0 <= startD < stopD <= Path总长度 |
+| dst | 截取的 Path 将会添加到 dst 中 | 注意: 是添加，而不是替换 |
+| startWithMoveTo | 起始点是否使用 moveTo | 用于保证截取的 Path 第一个点位置不变 |
+
+>
+
+- 如果 startD、stopD 的数值不在取值范围 [0, getLength] 内，或者 startD == stopD 则返回值为 false，不会改变 dst 内容。
+- 如果在安卓4.4或者之前的版本，在默认开启硬件加速的情况下，更改 dst 的内容后可能绘制会出现问题，请关闭硬件加速或者给 dst 添加一个单个操作，例如: dst.rLineTo(0, 0)
+
+我们先看看这个方法如何使用：
+
+我们创建了一个 Path， 并在其中添加了一个矩形，现在我们想截取矩形中的一部分，就是下图中红色的部分。
+
+> 矩形边长400dp，起始点在左上角，顺时针
+
+
+
+代码:
+
+```java
+canvas.translate(mViewWidth / 2, mViewHeight / 2); // 平移坐标系
+
+Path path = new Path(); // 创建Path并添加了一个矩形
+path.addRect(-200, -200, 200, 200, Path.Direction.CW);
+
+Path dst = new Path(); // 创建用于存储截取后内容的 Path
+
+PathMeasure measure = new PathMeasure(path, false); // 将 Path 与 PathMeasure 关联
+
+// 截取一部分存入dst中，并使用 moveTo 保持截取得到的 Path 第一个点的位置不变
+measure.getSegment(200, 600, dst, true);
+
+canvas.drawPath(dst, mDeafultPaint); // 绘制 dst
+```
+
+结果如下：
+
+
+
+从上图可以看到我们成功到将需要到片段截取了出来，然而当 dst 中有内容时会怎样呢？
+
+```java
+canvas.translate(mViewWidth / 2, mViewHeight / 2); // 平移坐标系
+
+Path path = new Path(); // 创建Path并添加了一个矩形
+path.addRect(-200, -200, 200, 200, Path.Direction.CW);
+
+Path dst = new Path(); // 创建用于存储截取后内容的 Path
+dst.lineTo(-300, -300); // <--- 在 dst 中添加一条线段
+
+PathMeasure measure = new PathMeasure(path, false); // 将 Path 与 PathMeasure 关联
+
+measure.getSegment(200, 600, dst, true); // 截取一部分 并使用 moveTo 保持截取得到的 Path 第一个点的位置不变
+
+canvas.drawPath(dst, mDeafultPaint); // 绘制 Path
+```
+
+结果如下:
+
+
+
+从上面的示例可以看到 dst 中的线段保留了下来，可以得到结论：**被截取的 Path 片段会添加到 dst 中，而不是替换 dst 中到内容。**
+
+前面两个例子中 startWithMoveTo 均为 true， 如果设置为false会怎样呢?
+
+```java
+canvas.translate(mViewWidth / 2, mViewHeight / 2); // 平移坐标系
+
+Path path = new Path(); // 创建Path并添加了一个矩形
+path.addRect(-200, -200, 200, 200, Path.Direction.CW);
+
+Path dst = new Path(); // 创建用于存储截取后内容的 Path
+dst.lineTo(-300, -300); // 在 dst 中添加一条线段
+
+PathMeasure measure = new PathMeasure(path, false); // 将 Path 与 PathMeasure 关联
+
+measure.getSegment(200, 600, dst, false); // <--- 截取一部分 不使用 startMoveTo, 保持 dst 的连续性
+
+canvas.drawPath(dst, mDeafultPaint); // 绘制 Path
+```
+
+结果如下：
+
+
+
+从该示例我们又可以得到一条结论：**如果 startWithMoveTo 为 true, 则被截取出来到Path片段保持原状，如果 startWithMoveTo 为 false，则会将截取出来的 Path 片段的起始点移动到 dst 的最后一个点，以保证 dst 的连续性。**
+
+从而我们可以用以下规则来判断 startWithMoveTo 的取值：
+
+| 取值 | 主要功用 |
+| ----- | ------------------------ |
+| true | 保证截取得到的 Path 片段不会发生形变 |
+| false | 保证存储截取片段的 Path(dst) 的连续性 |
+
+
+
+### 4.nextContour
+
+我们知道 Path 可以由多条曲线构成，但不论是 getLength , getSegment 或者是其它方法，都只会在其中第一条线段上运行，而这个 `nextContour` 就是用于跳转到下一条曲线到方法，_如果跳转成功，则返回 true， 如果跳转失败，则返回 false。_
+
+如下，我们创建了一个 Path 并使其中包含了两个闭合的曲线，内部的边长是200，外面的边长是400，现在我们使用 PathMeasure 分别测量两条曲线的总长度。
+
+
+
+代码：
+
+```java
+canvas.translate(mViewWidth / 2, mViewHeight / 2); // 平移坐标系
+
+Path path = new Path();
+
+path.addRect(-100, -100, 100, 100, Path.Direction.CW); // 添加小矩形
+path.addRect(-200, -200, 200, 200, Path.Direction.CW); // 添加大矩形
+
+canvas.drawPath(path,mDeafultPaint); // 绘制 Path
+
+PathMeasure measure = new PathMeasure(path, false); // 将Path与PathMeasure关联
+
+float len1 = measure.getLength(); // 获得第一条路径的长度
+
+measure.nextContour(); // 跳转到下一条路径
+
+float len2 = measure.getLength(); // 获得第二条路径的长度
+
+Log.i("LEN","len1="+len1); // 输出两条路径的长度
+Log.i("LEN","len2="+len2);
+```
+
+log输出结果:
+
+```shell
+com.gcssloop.canvas I/LEN: len1=800.0
+com.gcssloop.canvas I/LEN: len2=1600.0
+```
+
+通过测试，我们可以得到以下内容：
+
+- 1.曲线的顺序与 Path 中添加的顺序有关。
+- 2.getLength 获取到到是当前一条曲线分长度，而不是整个 Path 的长度。
+- 3.getLength 等方法是针对当前的曲线(其它方法请自行验证)。
+
+#### 5.getPosTan
+
+这个方法是用于得到路径上某一长度的位置以及该位置的正切值：
+
+```java
+boolean getPosTan (float distance, float[] pos, float[] tan)
+```
+
+方法各个参数释义：
+
+| 参数 | 作用 | 备注 |
+| ------------ | ------------- | ---------------------------------------- |
+| 返回值(boolean) | 判断获取是否成功 | true表示成功，数据会存入 pos 和 tan 中，
false 表示失败，pos 和 tan 不会改变 |
+| distance | 距离 Path 起点的长度 | 取值范围: 0 <= distance <= getLength |
+| pos | 该点的坐标值 | 当前点在画布上的位置，有两个数值，分别为x，y坐标。 |
+| tan | 该点的正切值 | 当前点在曲线上的方向，使用 Math.atan2(tan[1], tan[0]) 获取到正切角的弧度值。 |
+
+这个方法也不难理解，除了其中 `tan` 这个东东，这个东西是干什么的呢？
+
+`tan` 是用来判断 Path 上趋势的，即在这个位置上曲线的走向，请看下图示例，注意箭头的方向:
+
+
+
+**[点击这里下载箭头图片](http://ww1.sinaimg.cn/large/005Xtdi2jw1f4gam21ktoj3069069jre.jpg)**
+
+可以看到 上图中箭头在沿着 Path 运动时，方向始终与 Path 走向保持一致，保持方向主要就是依靠 `tan` 。
+
+下面我们来看看代码是如何实现的，首先我们需要定义几个必要的变量:
+
+```java
+private float currentValue = 0; // 用于纪录当前的位置,取值范围[0,1]映射Path的整个长度
+
+private float[] pos; // 当前点的实际位置
+private float[] tan; // 当前点的tangent值,用于计算图片所需旋转的角度
+private Bitmap mBitmap; // 箭头图片
+private Matrix mMatrix; // 矩阵,用于对图片进行一些操作
+```
+
+初始化这些变量(在构造函数中调用这个方法):
+
+```java
+private void init(Context context) {
+ pos = new float[2];
+ tan = new float[2];
+ BitmapFactory.Options options = new BitmapFactory.Options();
+ options.inSampleSize = 2; // 缩放图片
+ mBitmap = BitmapFactory.decodeResource(context.getResources(), R.drawable.arrow, options);
+ mMatrix = new Matrix();
+}
+```
+
+具体绘制:
+
+```java
+canvas.translate(mViewWidth / 2, mViewHeight / 2); // 平移坐标系
+
+Path path = new Path(); // 创建 Path
+
+path.addCircle(0, 0, 200, Path.Direction.CW); // 添加一个圆形
+
+PathMeasure measure = new PathMeasure(path, false); // 创建 PathMeasure
+
+currentValue += 0.005; // 计算当前的位置在总长度上的比例[0,1]
+if (currentValue >= 1) {
+ currentValue = 0;
+}
+
+measure.getPosTan(measure.getLength() * currentValue, pos, tan); // 获取当前位置的坐标以及趋势
+
+mMatrix.reset(); // 重置Matrix
+float degrees = (float) (Math.atan2(tan[1], tan[0]) * 180.0 / Math.PI); // 计算图片旋转角度
+
+mMatrix.postRotate(degrees, mBitmap.getWidth() / 2, mBitmap.getHeight() / 2); // 旋转图片
+mMatrix.postTranslate(pos[0] - mBitmap.getWidth() / 2, pos[1] - mBitmap.getHeight() / 2); // 将图片绘制中心调整到与当前点重合
+
+canvas.drawPath(path, mDeafultPaint); // 绘制 Path
+canvas.drawBitmap(mBitmap, mMatrix, mDeafultPaint); // 绘制箭头
+
+invalidate(); // 重绘页面
+```
+
+**核心要点:**
+
+>
+
+- 1.**通过 `tan` 得值计算出图片旋转的角度**，tan 是 tangent 的缩写，即中学中常见的正切， 其中tan[0]是邻边边长，tan[1]是对边边长，而Math中 `atan2` 方法是根据正切是数值计算出该角度的大小,得到的单位是弧度(取值范围是 -pi 到 pi)，所以上面又将弧度转为了角度。
+- 2.**通过 `Matrix` 来设置图片对旋转角度和位移**，这里使用的方法与前面讲解过对 canvas操作 有些类似，对于 `Matrix` 会在后面专一进行讲解，敬请期待。
+- 3.**页面刷新**，页面刷新此处是在 onDraw 里面调用了 invalidate 方法来保持界面不断刷新，但并不提倡这么做，正确对做法应该是使用 线程 或者 ValueAnimator 来控制界面的刷新，关于控制页面刷新这一部分会在后续的 动画部分 详细讲解，同样敬请期待。
+
+关于`tan`这个参数有很多魔法师不理解，特此拉出来详述一下，`tan` 在数学中被称为正切，在直角三角形中，一个锐角的**正切**定义为它的对边(Opposite side)与邻边(Adjacent side)的比值(来自维基百科)：
+
+
+
+我们此处用 `tan` 来描述 Path 上某一点的切线方向，**主要用了两个数值 tan[0] 和 tan[1] 来描述这个切线的方向(切线方向与x轴夹角)** ，看上面公式可知 `tan` 既可以用 `对边／邻边` 来表述，也可以用 `sin／cos` 来表述，此处用两种理解方式均可以(**注意下面等价关系**):
+
+> **tan[0] = cos = 邻边(单位圆x坐标)**
+> **tan[1] = sin = 对边(单位圆y坐标)**
+
+
+
+**以 `sin／cos`理解:**
+
+
+
+
+
+在圆上最右侧点的切线方向向下(动图中小飞机朝向和切线朝向一致)，切线角度为90度.
+sin90 = 1，cos90 = 0
+tan[0] = cos = 0
+tan[1] = sin = 1
+
+
+
+**以 `对边／邻边` 理解(单位圆上坐标):**
+
+按照这种理解方式需要借助一个单位圆，单位圆上任意一点到圆心到距离均为 1，以下图30度为例：
+
+
+
+tan30 = 对边／邻边 = AB／OA = B点y坐标／B点x坐标
+
+> **另外根据单位圆性质同样可以证得:**
+> sin30 = 对边／斜边 = AB／OB = AB = B点y坐标 (单位圆边上任意一点距离圆心距离均为1，故OB = 1)
+> cos30 = 邻边／斜边 = OA／OB = OA = B点x坐标
+>
+> **化为通用公式即为:**
+> sin = 该角度在单位圆上对应点的y坐标
+> cos = 该角度在单位圆上对应点的x坐标
+>
+> 即 tan = sin／cos = y／x
+> tan[0] = x
+> tan[1] = y
+>
+> 另外注意，这个单位圆与小飞机路径没有半毛钱关系，例如上一个例子中的90度切线，不要在单位圆上找对应位置，**要找对应角度的位置，90度对应的位置是(0，1)**，所以:
+> tan[0] = x = 0
+> tan[1] = y = 1
+>
+> 其实绕来绕去全是等价的 (╯°Д°)╯︵ ┻━┻
+
+**PS: 使用 Math.atan2(tan[1], tan[0]) 将 `tan` 转化为角(单位为弧度)的时候要注意参数顺序。**
+
+
+
+### 6.getMatrix
+
+这个方法是用于得到路径上某一长度的位置以及该位置的正切值的矩阵：
+
+```java
+boolean getMatrix (float distance, Matrix matrix, int flags)
+```
+
+方法各个参数释义：
+
+| 参数 | 作用 | 备注 |
+| ------------ | ------------------- | ---------------------------------------- |
+| 返回值(boolean) | 判断获取是否成功 | true表示成功，数据会存入matrix中，false 失败，matrix内容不会改变 |
+| distance | 距离 Path 起点的长度 | 取值范围: 0 <= distance <= getLength |
+| matrix | 根据 falgs 封装好的matrix | 会根据 flags 的设置而存入不同的内容 |
+| flags | 规定哪些内容会存入到matrix中 | 可选择
POSITION_MATRIX_FLAG(位置)
ANGENT_MATRIX_FLAG(正切) |
+
+其实这个方法就相当于我们在前一个例子中封装 `matrix` 的过程由 `getMatrix` 替我们做了，我们可以直接得到一个封装好到 `matrix`，岂不快哉。
+
+但是我们看到最后到 `flags` 选项可以选择 `位置` 或者 `正切` ,如果我们两个选项都想选择怎么办？
+
+如果两个选项都想选择，可以将两个选项之间用 `|` 连接起来，如下：
+
+```
+measure.getMatrix(distance, matrix, PathMeasure.TANGENT_MATRIX_FLAG | PathMeasure.POSITION_MATRIX_FLAG);
+```
+
+我们可以将上面都例子中 `getPosTan` 替换为 `getMatrix`， 看看是不是会显得简单很多:
+
+具体绘制:
+
+```java
+Path path = new Path(); // 创建 Path
+
+path.addCircle(0, 0, 200, Path.Direction.CW); // 添加一个圆形
+
+PathMeasure measure = new PathMeasure(path, false); // 创建 PathMeasure
+
+currentValue += 0.005; // 计算当前的位置在总长度上的比例[0,1]
+if (currentValue >= 1) {
+ currentValue = 0;
+}
+
+// 获取当前位置的坐标以及趋势的矩阵
+measure.getMatrix(measure.getLength() * currentValue, mMatrix, PathMeasure.TANGENT_MATRIX_FLAG | PathMeasure.POSITION_MATRIX_FLAG);
+
+mMatrix.preTranslate(-mBitmap.getWidth() / 2, -mBitmap.getHeight() / 2); // <-- 将图片绘制中心调整到与当前点重合(注意:此处是前乘pre)
+
+canvas.drawPath(path, mDeafultPaint); // 绘制 Path
+canvas.drawBitmap(mBitmap, mMatrix, mDeafultPaint); // 绘制箭头
+
+invalidate(); // 重绘页面
+```
+
+> 由于此处代码运行结果与上面一样，便不再贴图片了，请参照上面一个示例的效果图。
+
+可以看到使用 getMatrix 方法的确可以节省一些代码，不过这里依旧需要注意一些内容:
+
+>
+
+- 1.对 `matrix` 的操作必须要在 `getMatrix` 之后进行，否则会被 `getMatrix` 重置而导致无效。
+- 2.矩阵对旋转角度默认为图片的左上角，我们此处需要使用 `preTranslate` 调整为图片中心。
+- 3.pre(矩阵前乘) 与 post(矩阵后乘) 的区别，此处请等待后续的文章或者自行搜索。
+
+------
+
+## Path & SVG
+
+我们知道，用Path可以创建出各种个样的图形，但如果图形过于复杂时，用代码写就不现实了，不仅麻烦，而且容易出错，所以在绘制复杂的图形时我们一般是将 SVG 图像转换为 Path。
+
+**你说什么是 SVG?**
+
+SVG 是一种矢量图，内部用的是 xml 格式化存储方式存储这操作和数据，你完全可以将 SVG 看作是 Path 的各项操作简化书写后的存储格式。
+
+Path 和 SVG 结合通常能诞生出一些奇妙的东西，如下:
+
+
+
+
+> **该图片来自这个开源库 ->[PathView](https://github.com/geftimov/android-pathview)**
+> **SVG 转 Path 的解析可以用这个库 -> [AndroidSVG](https://bigbadaboom.github.io/androidsvg/)**
+
+限于篇幅以及本人精力，这一部分就暂不详解了，感兴趣的可以直接看源码，或者搜索一些相关的解析文章。
+
+------
+
+## Path使用技巧
+
+**话说本篇文章的名字不是叫 玩出花样么？怎么只见前面啰啰嗦嗦的扯了一大堆不明所以的东西，花样在哪里？**
+
+> **前面的内容虽然啰嗦繁杂，但却是重中之重的基础，如果在修仙界，这叫根基，而下面讲述的内容的是招式，有了根基才能演化出千变万化的招式，而没有根基只学招式则是徒有其表，只能学一样会一样，很难适应千变万化的需求。**
+
+先放一个效果图，然后分析一下实现过程:
+
+
+
+这是一个搜索的动效图，通过分析可以得到它应该有四种状态，分别如下:
+
+| 状态 | 概述 |
+| ---- | ------------------------ |
+| 初始状态 | 初始状态，没有任何动效，只显示一个搜索标志 🔍 |
+| 准备搜索 | 放大镜图标逐渐变化为一个点 |
+| 正在搜索 | 围绕这一个圆环运动，并且线段长度会周期性变化 |
+| 准备结束 | 从一个点逐渐变化成为放大镜图标 |
+
+这些状态是有序转换的，转换流程以及转换条件如下：
+
+> 其中 `正在搜索` 这个状态持续时间长度是不确定的，在没有搜索完成前，应该一直处于搜索状态。
+
+
+
+简单的分析了其大致的流程之后，就到了制作的重点:对细节对把握。
+
+### Path 划分
+
+为了制作对方便，此处整个动效用了两个 Path， 一个是中间对放大镜， 另一个则是外侧的圆环,将两者全部画出来是这样子的。
+
+
+
+其中 Path 的走向要把握好，如下(只是一个放大镜，并不是♂):
+
+
+
+其中圆形上面的点可以用 PathMeasure 测量，无需计算。
+
+### 动画状态与时间关联
+
+此处使用的是 ValueAnimator，它可以将一段时间映射到一段数值上，随着时间变化不断的更新数值，并且可以使用插值器开控制数值变化规律(此处使用的是默认插值器)。
+
+> PS: 本来不想提前暴露这个的，准备偷偷留到动画部分(｡-_-｡) 但实在是没有优雅的替代方案了。
+
+### 具体绘制
+
+绘制部分是根据 当前状态以及从 ValueAnimator 获得的数值来截取 Path 中合适的部分绘制出来。
+
+### 最终效果
+
+
+
+### 源码
+
+上面的内容是为了帮助大家从把控全局流程以及理解某些细节的设计思路，而更多的内容都藏在代码中，代码总体也不算长，感兴趣的可以自己敲一遍。
+
+#### [戳这里查看源码](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/Code/SearchView.md)
+
+> PS: 本代码仅作为示例使用，还有诸多不足，如 自定义属性，视图大小， 点击事件， 监听回调 等，并不适合直接使用，有需要的可以自行补足相关内容。
+
+## 总结
+
+**本文中虽然后面的内容看起来比较高大上一点，但前面"啰嗦"的废话才是真正的干货，把前面的东西学会了，后面的各种效果都能信手拈来，如果只研究后面的东西，则是取其形，而难以会其意。**
+
+#### PS: 由于本人水平有限，某些地方可能存在误解或不准确，如果你对此有疑问可以提交Issues进行反馈。
+
+## About
+
+[本系列相关文章](http://www.gcssloop.com/customview/CustomViewIndex/)
+
+作者微博: [GcsSloop](http://weibo.com/GcsSloop)
+
+## 参考资料
+
+[PathMeasure](https://developer.android.com/reference/android/graphics/PathMeasure.html)
+[AndroidSVG](https://bigbadaboom.github.io/androidsvg/)
+[android-pathview](https://github.com/geftimov/android-pathview)
+[android Path 和 PathMeasure 进阶](http://blog.csdn.net/cquwentao/article/details/51436852)
+
diff --git a/CustomView/Advance/[09]Matrix_Basic.md b/CustomView/Advance/[09]Matrix_Basic.md
new file mode 100644
index 00000000..e3985de3
--- /dev/null
+++ b/CustomView/Advance/[09]Matrix_Basic.md
@@ -0,0 +1,503 @@
+本文内容偏向理论，和 [画布操作](http://www.gcssloop.com/customview/Canvas_Convert/) 有重叠的部分，本文会让你更加深入的了解其中的原理。
+
+本篇的主角Matrix，是一个一直在后台默默工作的劳动模范，虽然我们所有看到View背后都有着Matrix的功劳，但我们却很少见到它，本篇我们就看看它是何方神圣吧。
+
+> 由于Google已经对这一部分已经做了很好的封装，所以跳过本部分对实际开发影响并不会太大，不想深究的粗略浏览即可，下一篇中将会详细讲解Matrix的具体用法和技巧。
+>
+> ## ⚠️ 警告：测试本文章示例之前请关闭硬件加速。
+
+## Matrix简介
+
+**Matrix是一个矩阵，主要功能是坐标映射，数值转换。**
+
+它看起来大概是下面这样:
+
+
+
+**Matrix作用就是坐标映射，那么为什么需要Matrix呢? 举一个简单的例子:**
+
+我的的手机屏幕作为物理设备，其物理坐标系是从左上角开始的，但我们在开发的时候通常不会使用这一坐标系，而是使用内容区的坐标系。
+
+以下图为例，我们的内容区和屏幕坐标系还相差一个通知栏加一个标题栏的距离，所以两者是不重合的，我们在内容区的坐标系中的内容最终绘制的时候肯定要转换为实际的物理坐标系来绘制，Matrix在此处的作用就是转换这些数值。
+
+> 假设通知栏高度为20像素，导航栏高度为40像素,那么我们在内容区的(0，0)位置绘制一个点，最终就要转化为在实际坐标系中的(0，60)位置绘制一个点。
+
+
+
+以上是仅作为一个简单的示例，实际上不论2D还是3D，我们要将图形显示在屏幕上，都离不开Matrix，所以说Matrix是一个在背后辛勤工作的劳模。
+
+
+
+### Matrix特点
+
+- 作用范围更广，Matrix在View，图片，动画效果等各个方面均有运用，相比与之前讲解等画布操作应用范围更广。
+- 更加灵活，画布操作是对Matrix的封装，Matrix作为更接近底层的东西，必然要比画布操作更加灵活。
+- 封装很好，Matrix本身对各个方法就做了很好的封装，让开发者可以很方便的操作Matrix。
+- 难以深入理解，很难理解中各个数值的意义，以及操作规律，如果不了解矩阵，也很难理解前乘，后乘。
+
+### 常见误解
+
+**1.认为Matrix最下面的一行的三个参数(MPERSP_0、MPERSP_1、MPERSP_2)没有什么太大的作用，在这里只是为了凑数。**
+
+实际上最后一行参数在3D变换中有着至关重要的作用，这一点会在后面中Camera一文中详细介绍。
+
+**2.最后一个参数MPERSP_2被解释为scale**
+
+的确，更改MPERSP_2的值能够达到类似缩放的效果，但这是因为齐次坐标的缘故，并非这个参数的实际功能。
+
+## Matrix基本原理
+
+Matrix 是一个矩阵，最根本的作用就是坐标转换，下面我们就看看几种常见变换的原理:
+
+> 我们所用到的变换均属于仿射变换，仿射变换是 线性变换(缩放，旋转，错切) 和 平移变换(平移) 的复合，由于这些概念对于我们作用并不大，此处不过多介绍，有兴趣可自行了解。
+
+基本变换有4种: 平移(translate)、缩放(scale)、旋转(rotate) 和 错切(skew)。
+
+下面我们看一下四种变换都是由哪些参数控制的。
+
+
+
+
+**从上图可以看到最后三个参数是控制透视的，这三个参数主要在3D效果中运用，通常为(0, 0, 1)，不在本篇讨论范围内，暂不过多叙述，会在之后对文章中详述其作用。**
+
+由于我们以下大部分的计算都是基于矩阵乘法规则，如果你已经把线性代数还给了老师，请参考一下这里:
+**[维基百科-矩阵乘法](https://zh.wikipedia.org/wiki/%E7%9F%A9%E9%99%A3%E4%B9%98%E6%B3%95)**
+
+### 1.缩放(Scale)
+
+
+
+用矩阵表示:
+
+
+
+> 你可能注意到了，我们坐标多了一个1，这是使用了齐次坐标系的缘故，在数学中我们的点和向量都是这样表示的(x, y)，两者看起来一样，计算机无法区分，为此让计算机也可以区分它们，增加了一个标志位，增加之后看起来是这样:
+>
+> (x, y, 1) - 点
+> (x, y, 0) - 向量
+>
+> 另外，齐次坐标具有等比的性质，(2,3,1)、(4,6,2)...(2N,3N,N)表示的均是(2,3)这一个点。(**将MPERSP_2解释为scale这一误解就源于此**)。
+
+图例：
+
+
+
+### 2.错切(Skew)
+
+错切存在两种特殊错切，水平错切(平行X轴)和垂直错切(平行Y轴)。
+
+#### 水平错切
+
+
+
+用矩阵表示:
+
+
+
+图例:
+
+
+
+#### 垂直错切
+
+
+
+用矩阵表示:
+
+
+
+图例:
+
+
+
+#### 复合错切
+
+> 水平错切和垂直错切的复合。
+
+
+
+用矩阵表示:
+
+
+
+图例:
+
+
+
+### 3.旋转(Rotate)
+
+假定一个点 A(x0, y0) ,距离原点距离为 r, 与水平轴夹角为 α 度, 绕原点旋转 θ 度, 旋转后为点 B(x, y) 如下:
+
+
+
+用矩阵表示:
+
+
+
+图例:
+
+
+
+### 4.平移(Translate)
+
+> 此处也是使用齐次坐标的优点体现之一，实际上前面的三个操作使用 2x2 的矩阵也能满足需求，但是使用 2x2 的矩阵，无法将平移操作加入其中，而将坐标扩展为齐次坐标后，将矩阵扩展为 3x3 就可以将算法统一，四种算法均可以使用矩阵乘法完成。
+
+
+
+用矩阵表示:
+
+
+
+图例:
+
+
+
+## Matrix复合原理
+
+其实Matrix的多种复合操作都是使用矩阵乘法实现的，从原理上理解很简单，但是，使用矩阵乘法也有其弱点，后面的操作可能会影响到前面到操作，所以在构造Matrix时顺序很重要。
+
+我们常用的四大变换操作，每一种操作在Matrix均有三类,前乘(pre)，后乘(post)和设置(set)，可以参见文末对[Matrix方法表](#fangfa)，由于矩阵乘法不满足交换律，所以前乘(pre)，后乘(post)和设置(set)的区别还是很大的。
+
+### 前乘(pre)
+
+前乘相当于矩阵的右乘：
+
+
+
+> 这表示一个矩阵与一个特殊矩阵前乘后构造出结果矩阵。
+
+### 后乘(post)
+
+后乘相当于矩阵的左乘：
+
+
+
+> 这表示一个矩阵与一个特殊矩阵后乘后构造出结果矩阵。
+
+### 设置(set)
+
+设置使用的不是矩阵乘法，而是直接覆盖掉原来的数值，所以，**使用设置可能会导致之前的操作失效**。
+
+## 组合
+
+**关于 Matrix 的文章终有一个问题，就是 pre 和 post 这一部分的理论非常别扭，国内大多数文章都是这样的，看起来貌似是对的但很难理解，部分内容违背直觉。**
+
+**我由于也受到了这些文章的影响，自然而然的继承了这一理论，直到在评论区有一位小伙伴提出了一个问题，才让我重新审视了这一部分的内容，并进行了一定反思。**
+
+经过良久的思考之后，我决定抛弃国内大部分文章的那套理论和结论，只用严谨的数学逻辑和程序逻辑来阐述这一部分的理论，也许仍有疏漏，如有发现请指正。
+
+**首先澄清两个错误结论，记住，是错误结论，错误结论，错误结论。**
+
+### ~~错误结论一：pre 是顺序执行，post 是逆序执行。~~
+
+这个结论很具有迷惑性，因为这个结论并非是完全错误的，你很容易就能证明这个结论，例如下面这样：
+
+```java
+// 第一段 pre 顺序执行，先平移(T)后旋转(R)
+Matrix matrix = new Matrix();
+matrix.preTranslate(pivotX,pivotY);
+matrix.preRotate(angle);
+Log.e("Matrix", matrix.toShortString());
+
+// 第二段 post 逆序执行，先平移(T)后旋转(R)
+Matrix matrix = new Matrix();
+matrix.postRotate(angle);
+matrix.postTranslate(pivotX,pivotY)
+Log.e("Matrix", matrix.toShortString());
+```
+
+**这两段代码最终结果是等价的，于是轻松证得这个结论的正确性，但事实真是这样么？**
+
+首先，从数学角度分析，pre 和 post 就是右乘或者左乘的区别，其次，它们不可能实际影响运算顺序(程序执行顺序)。以上这两段代码等价也仅仅是因为最终化简公式一样而已。
+
+> 设原始矩阵为 M，平移为 T ，旋转为 R ，单位矩阵为 I ，最终结果为 M'
+>
+> - 矩阵乘法不满足交换律，即 A\\*B ≠ B\\*A
+> - 矩阵乘法满足结合律，即 (A\\*B)\\*C = A\\*(B\\*C)
+> - 矩阵与单位矩阵相乘结果不变，即 A * I = A
+
+```
+由于上面例子中原始矩阵(M)是一个单位矩阵(I)，所以可得：
+
+// 第一段 pre
+M' = (M*T)*R = I*T*R = T*R
+
+// 第二段 post
+M' = T*(R*M) = T*R*I = T*R
+```
+
+由于两者最终的化简公式是相同的，所以两者是等价的，但是，这结论不具备普适性。
+
+**即原始矩阵不为单位矩阵的时候，两者无法化简为相同的公式，结果自然也会不同。另外，执行顺序就是程序书写顺序，不存在所谓的正序逆序。**
+
+### ~~错误结论二：pre 是先执行，而 post 是后执行。~~
+
+这一条结论比上一条更离谱。
+
+之所以产生这个错误完全是因为写文章的人懂英语。
+
+```
+pre ：先，和 before 相似。
+post ：后，和 after 相似。
+```
+
+所以就得出了 pre 先执行，而 post 后执行这一说法，但从严谨的数学和程序角度来分析，完全是不可能的，还是上面所说的，**pre 和 post 不能影响程序执行顺序，而程序每执行一条语句都会得出一个确定的结果，所以，它根本不能控制先后执行，属于完全扯淡型。**
+
+**如果非要用这套理论强行解释的话，反而看起来像是 post 先执行，例如：**
+
+```java
+matrix.preRotate(angle);
+matrix.postTranslate(pivotX,pivotY);
+```
+
+同样化简公式：
+
+```
+// 矩阵乘法满足结合律
+M‘ = T*(M*R) = T*M*R = (T*M)*R
+```
+
+**从实际上来说，由于矩阵乘法满足结合律，所以不论你说是靠右先执行还是靠左先执行，从结果上来说都没有错。**
+
+**之前基于这条错误的结论我进行了一次错误的证明：**
+
+> **(这段内容注定要成为我写作历程中不可抹灭的耻辱，既然是公开文章，就应该对读者负责，虽然我在发表每一篇文章之前都竭力的求证其中的问题，各种细节，避免出现这种错误，但终究还是留下了这样一段内容，在此我诚挚的向我所有的读者道歉。)**
+>
+> 关注我的读者请尽量看我在 [个人博客](http://www.gcssloop.com/#blog) 和 [GitHub](https://github.com/GcsSloop/AndroidNote/blob/master/README.md) 发布的版本，这两个平台都在博文修复计划之内，有任何错误或者纰漏，都会首先修复这两个平台的文章。另外，所有进行修复过的文章都会在我的微博 [@GcsSloop](http://weibo.com/GcsSloop) 重新发布说明，关注我的微博可以第一时间得到博文更新或者修复的消息。
+>
+> ------
+>
+> ## 以下是错误证明：
+>
+> ~~在实际操作中，我们每一步操作都会得出准确的计算结果，但是为什么还会用存在先后的说法? 难道真的能够用pre和post影响计算顺序? 实则不然，下面我们用一个例子说明:~~
+>
+> ```java
+> Matrix matrix = new Matrix();
+> matrix.postScale(0.5f, 0.8f);
+> matrix.preTranslate(1000, 1000);
+> Log.e(TAG, "MatrixTest" + matrix.toShortString());
+> ```
+>
+> ~~在上面的操作中，如果按照正常的思路，先缩放，后平移，缩放操作执行在前，不会影响到后续的平移操作，但是执行结果却发现平移距离变成了(500， 800)。~~
+>
+> ~~在上面例子中，计算顺序是没有问题的，先计算的缩放，然后计算的平移，而缩放影响到平移则是因为前一步缩放后的结果矩阵右乘了平移矩阵，这是符合矩阵乘法的运算规律的，也就是说缩放操作虽然在前却影响到了平移操作，**相当于先执行了平移操作，然后执行的缩放操作，因此才有pre操作会先执行，而post操作会后执行这一说法**。~~
+>
+> ------
+
+上面的论证是完全错误的，因为可以轻松举出反例：
+
+```java
+Matrix matrix = new Matrix();
+matrix.preScale(0.5f, 0.8f);
+matrix.preTranslate(1000, 1000);
+Log.e(TAG, "MatrixTest" + matrix.toShortString());
+```
+
+反例中，虽然将 `postScale` 改为了 `preScale` ，但两者结果是完全相同的，所以先后论根本就是错误的。
+
+他们结果相同是因为最终化简公式是相同的，都是 S*T
+
+之所以平移距离是 MTRANS\_X = 500，MTRANS\_Y = 800，那是因为执行 Translate 之前 Matrix 已经具有了一个缩放比例。在右乘的时候影响到了具体的数值计算，可以用矩阵乘法计算一下。
+
+
+
+最终结果为：
+
+
+
+当 T*S 的时候，缩放比例则不会影响到 MTRANS\\_X 和 MTRANS\\_Y ，具体可以使用矩阵乘法自己计算一遍。
+
+## 如何理解和使用 pre 和 post ？
+
+不要去管什么先后论，顺序论，就按照最基本的矩阵乘法理解。
+
+```
+pre : 右乘， M‘ = M*A
+post : 左乘， M’ = A*M
+```
+
+**那么如何使用？**
+
+正确使用方式就是先构造正常的 Matrix 乘法顺序，之后根据情况使用 pre 和 post 来把这个顺序实现。
+
+还是用一个最简单的例子理解，假设需要围绕某一点旋转。
+
+可以用这个方法 `xxxRotate(angle, pivotX, pivotY)` ,由于我们这里需要组合构造一个 Matrix，所以不直接使用这个方法。
+
+首先，有两条基本定理：
+
+- 所有的操作(旋转、平移、缩放、错切)默认都是以坐标原点为基准点的。
+- 之前操作的坐标系状态会保留，并且影响到后续状态。
+
+基于这两条基本定理，我们可以推算出要基于某一个点进行旋转需要如下步骤：
+
+```
+1. 先将坐标系原点移动到指定位置，使用平移 T
+2. 对坐标系进行旋转，使用旋转 S (围绕原点旋转)
+3. 再将坐标系平移回原来位置，使用平移 -T
+```
+
+具体公式如下：
+
+> M 为原始矩阵，是一个单位矩阵， M‘ 为结果矩阵， T 为平移， R为旋转
+
+```
+M' = M*T*R*-T = T*R*-T
+```
+
+按照公式写出来的伪代码如下：
+
+```java
+Matrix matrix = new Matrix();
+matrix.preTranslate(pivotX,pivotY);
+matrix.preRotate(angle);
+matrix.preTranslate(-pivotX, -pivotY);
+```
+
+
+
+
+
+围绕某一点操作可以拓展为通用情况，即：
+
+```java
+Matrix matrix = new Matrix();
+matrix.preTranslate(pivotX,pivotY);
+// 各种操作，旋转，缩放，错切等，可以执行多次。
+matrix.preTranslate(-pivotX, -pivotY);
+```
+
+公式为：
+
+```
+M' = M*T* ... *-T = T* ... *-T
+```
+
+但是这种方式，两个调整中心的平移函数就拉的太开了，所以通常采用这种写法：
+
+```java
+Matrix matrix = new Matrix();
+// 各种操作，旋转，缩放，错切等，可以执行多次。
+matrix.postTranslate(pivotX,pivotY);
+matrix.preTranslate(-pivotX, -pivotY);
+```
+
+这样公式为：
+
+```
+M' = T*M* ... *-T = T* ... *-T
+```
+
+可以看到最终化简结果是相同的。
+
+所以说，pre 和 post 就是用来调整乘法顺序的，正常情况下应当正向进行构建出乘法顺序公式，之后根据实际情况调整书写即可。
+
+**在构造 Matrix 时，个人建议尽量使用一种乘法，前乘或者后乘，这样操作顺序容易确定，出现问题也比较容易排查。当然，由于矩阵乘法不满足交换律，前乘和后乘的结果是不同的，使用时应结合具体情景分析使用。**
+
+
+
+### 下面我们用不同对方式来构造一个相同的矩阵:
+
+注意:
+
+- 1.由于矩阵乘法不满足交换律，请保证使用初始矩阵(Initial Matrix)，否则可能导致运算结果不同。
+- 2.注意构造顺序，顺序是会影响结果的。
+- 3.Initial Matrix是指new出来的新矩阵，或者reset后的矩阵，是一个单位矩阵。
+
+#### 1.仅用pre：
+
+```java
+// 使用pre， M' = M*T*S = T*S
+Matrix m ＝ new Matrix();
+m.reset();
+m.preTranslate(tx, ty);
+m.preScale(sx, sy);
+```
+
+用矩阵表示:
+
+
+#### 2.仅用post:
+
+```java
+// 使用post， M‘ = T*S*M = T*S
+Matrix m ＝ new Matrix();
+m.reset();
+m.postScale(sx, sy); //，越靠前越先执行。
+m.postTranslate(tx, ty);
+```
+
+用矩阵表示:
+
+
+
+#### 3.混合:
+
+```java
+// 混合 M‘ = T*M*S = T*S
+Matrix m ＝ new Matrix();
+m.reset();
+m.preScale(sx, sy);
+m.postTranslate(tx, ty);
+```
+
+或:
+
+```java
+// 混合 M‘ = T*M*S = T*S
+Matrix m ＝ new Matrix();
+m.reset();
+m.postTranslate(tx, ty);
+m.preScale(sx, sy);
+```
+
+> 由于此处只有两步操作，且指定了先后，所以代码上交换并不会影响结果。
+
+用矩阵表示:
+
+
+
+**注意: 由于矩阵乘法不满足交换律，请保证初始矩阵为单位矩阵，如果初始矩阵不为单位矩阵，则导致运算结果不同。**
+
+上面虽然用了很多不同的写法，但最终的化简公式是一样的，这些不同的写法，都是根据同一个公式反向推算出来的。
+
+## Matrix方法表
+
+这个方法表，暂时放到这里让大家看看，方法的使用讲解放在下一篇文章中。
+
+| 方法类别 | 相关API | 摘要 |
+| -------- | ---------------------------------------- | -------------------------- |
+| 基本方法 | equals hashCode toString toShortString | 比较、 获取哈希值、 转换为字符串 |
+| 数值操作 | set reset setValues getValues | 设置、 重置、 设置数值、 获取数值 |
+| 数值计算 | mapPoints mapRadius mapRect mapVectors | 计算变换后的数值 |
+| 设置(set) | setConcat setRotate setScale setSkew setTranslate | 设置变换 |
+| 前乘(pre) | preConcat preRotate preScale preSkew preTranslate | 前乘变换 |
+| 后乘(post) | postConcat postRotate postScale postSkew postTranslate | 后乘变换 |
+| 特殊方法 | setPolyToPoly setRectToRect rectStaysRect setSinCos | 一些特殊操作 |
+| 矩阵相关 | invert isAffine isIdentity | 求逆矩阵、 是否为仿射矩阵、 是否为单位矩阵 ... |
+
+## 总结
+
+对于Matrix重在理解，理解了其中的原理之后用起来将会更加得心应手。
+
+学完了本篇之后，推荐配合鸿洋大大的视频课程 [
+打造个性的图片预览与多点触控](http://www.imooc.com/learn/239) 食用，定然能够让你对Matrix对理解更上一层楼。
+
+由于个人水平有限，文章中可能会出现错误，如果你觉得哪一部分有错误，或者发现了错别字等内容，欢迎在评论区告诉我，另外，据说关注 [作者微博](http://weibo.com/GcsSloop) 不仅能第一时间收到新文章消息，还能变帅哦。
+
+## About
+
+[本系列相关文章](http://www.gcssloop.com/customview/CustomViewIndex/)
+
+作者微博: [GcsSloop](http://weibo.com/GcsSloop)
+
+## 参考资料
+
+[Matrix](https://developer.android.com/reference/android/graphics/Matrix.html)
+[Android中图像变换Matrix的原理、代码验证和应用](http://biandroid.iteye.com/blog/1399462)
+[Android中关于矩阵（Matrix）前乘后乘的一些认识](http://blog.csdn.net/linmiansheng/article/details/18820599)
+[维基百科-仿射变换](https://zh.wikipedia.org/wiki/%E4%BB%BF%E5%B0%84%E5%8F%98%E6%8D%A2)
+[维基百科-齐次坐标](https://zh.wikipedia.org/wiki/%E9%BD%90%E6%AC%A1%E5%9D%90%E6%A0%87)
+[维基百科-线性映射](https://zh.wikipedia.org/wiki/%E7%BA%BF%E6%80%A7%E6%98%A0%E5%B0%84)
+[齐次坐标系入门级思考](https://oncemore2020.github.io/blog/homogeneous/)
+[仿射变换与齐次坐标](https://guangchun.wordpress.com/2011/10/12/affineandhomogeneous/)
diff --git a/CustomView/Advance/[10]Matrix_Method.md b/CustomView/Advance/[10]Matrix_Method.md
new file mode 100644
index 00000000..3254f4bb
--- /dev/null
+++ b/CustomView/Advance/[10]Matrix_Method.md
@@ -0,0 +1,871 @@
+# Matrix详解
+
+### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
+### 相关文章: [自定义View目录](http://www.gcssloop.com/1970/01/CustomViewIndex/)
+
+在上一篇文章中，我们对Matrix做了一个简单的了解，偏向理论，在本文中则会详细的讲解Matrix的具体用法，以及Matrix的一些实用技巧。
+
+## Matrix方法表
+
+按照惯例，先放方法表做概览。
+
+| 方法类别 | 相关API | 摘要 |
+| -------- | ---------------------------------------- | -------------------------- |
+| 基本方法 | equals hashCode toString toShortString | 比较、 获取哈希值、 转换为字符串 |
+| 数值操作 | set reset setValues getValues | 设置、 重置、 设置数值、 获取数值 |
+| 数值计算 | mapPoints mapRadius mapRect mapVectors | 计算变换后的数值 |
+| 设置(set) | setConcat setRotate setScale setSkew setTranslate | 设置变换 |
+| 前乘(pre) | preConcat preRotate preScale preSkew preTranslate | 前乘变换 |
+| 后乘(post) | postConcat postRotate postScale postSkew postTranslate | 后乘变换 |
+| 特殊方法 | setPolyToPoly setRectToRect rectStaysRect setSinCos | 一些特殊操作 |
+| 矩阵相关 | invert isAffine(API21) isIdentity | 求逆矩阵、 是否为仿射矩阵、 是否为单位矩阵 ... |
+
+
+## Matrix方法详解
+
+### 构造方法
+
+构造方法没有在上面表格中列出。
+
+#### 无参构造
+
+``` java
+Matrix ()
+```
+创建一个全新的Matrix，使用格式如下：
+
+``` java
+Matrix matrix = new Matrix();
+```
+
+通过这种方式创建出来的并不是一个数值全部为空的矩阵，而是一个单位矩阵,如下:
+
+
+
+#### 有参构造
+
+``` java
+Matrix (Matrix src)
+```
+
+这种方法则需要一个已经存在的矩阵作为参数，使用格式如下:
+
+``` java
+Matrix matrix = new Matrix(src);
+```
+
+创建一个Matrix，并对src深拷贝(理解为新的matrix和src是两个对象，但内部数值相同即可)。
+
+
+### 基本方法
+
+基本方法内容比较简单，在此处简要介绍一下。
+
+#### 1.equals
+
+比较两个Matrix的数值是否相同。
+
+#### 2.hashCode
+
+获取Matrix的哈希值。
+
+#### 3.toString
+
+将Matrix转换为字符串: `Matrix{[1.0, 0.0, 0.0][0.0, 1.0, 0.0][0.0, 0.0, 1.0]}`
+
+#### 4.toShortString
+
+将Matrix转换为短字符串: `[1.0, 0.0, 0.0][0.0, 1.0, 0.0][0.0, 0.0, 1.0]`
+
+
+### 数值操作
+
+数值操作这一组方法可以帮助我们直接控制Matrix里面的数值。
+
+#### 1.set
+
+``` java
+void set (Matrix src)
+```
+
+没有返回值，有一个参数，作用是将参数Matrix的数值复制到当前Matrix中。如果参数为空，则重置当前Matrix，相当于`reset()`。
+
+#### 2.reset
+
+``` java
+void reset ()
+```
+
+重置当前Matrix(将当前Matrix重置为单位矩阵)。
+
+#### 3.setValues
+
+``` java
+void setValues (float[] values)
+```
+
+setValues的参数是浮点型的一维数组，长度需要大于9，拷贝数组中的前9位数值赋值给当前Matrix。
+
+#### 4.getValues
+
+``` java
+void getValues (float[] values)
+```
+
+很显然，getValues和setValues是一对方法，参数也是浮点型的一维数组，长度需要大于9，将Matrix中的数值拷贝进参数的前9位中。
+
+### 数值计算
+
+#### 1.mapPoints
+
+``` java
+void mapPoints (float[] pts)
+
+void mapPoints (float[] dst, float[] src)
+
+void mapPoints (float[] dst, int dstIndex,float[] src, int srcIndex, int pointCount)
+```
+
+计算一组点基于当前Matrix变换后的位置，(由于是计算点，所以参数中的float数组长度一般都是偶数的,若为奇数，则最后一个数值不参与计算)。
+
+它有三个重载方法:
+
+(1) `void mapPoints (float[] pts)` 方法仅有一个参数，pts数组作为参数传递原始数值，计算结果仍存放在pts中。
+
+示例:
+
+``` java
+// 初始数据为三个点 (0, 0) (80, 100) (400, 300)
+float[] pts = new float[]{0, 0, 80, 100, 400, 300};
+
+// 构造一个matrix，x坐标缩放0.5
+Matrix matrix = new Matrix();
+matrix.setScale(0.5f, 1f);
+
+// 输出pts计算之前数据
+Log.i(TAG, "before: "+ Arrays.toString(pts));
+
+// 调用map方法计算
+matrix.mapPoints(pts);
+
+// 输出pts计算之后数据
+Log.i(TAG, "after : "+ Arrays.toString(pts));
+```
+
+结果:
+
+```
+before: [0.0, 0.0, 80.0, 100.0, 400.0, 300.0]
+after : [0.0, 0.0, 40.0, 100.0, 200.0, 300.0]
+```
+
+(2) `void mapPoints (float[] dst, float[] src)` ，src作为参数传递原始数值，计算结果存放在dst中，src不变。
+
+如果原始数据需要保留则一般使用这种方法。
+
+示例:
+
+``` java
+// 初始数据为三个点 (0, 0) (80, 100) (400, 300)
+float[] src = new float[]{0, 0, 80, 100, 400, 300};
+float[] dst = new float[6];
+
+// 构造一个matrix，x坐标缩放0.5
+Matrix matrix = new Matrix();
+matrix.setScale(0.5f, 1f);
+
+// 输出计算之前数据
+Log.i(TAG, "before: src="+ Arrays.toString(src));
+Log.i(TAG, "before: dst="+ Arrays.toString(dst));
+
+// 调用map方法计算
+matrix.mapPoints(dst,src);
+
+// 输出计算之后数据
+Log.i(TAG, "after : src="+ Arrays.toString(src));
+Log.i(TAG, "after : dst="+ Arrays.toString(dst));
+```
+
+结果:
+
+```
+before: src=[0.0, 0.0, 80.0, 100.0, 400.0, 300.0]
+before: dst=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+after : src=[0.0, 0.0, 80.0, 100.0, 400.0, 300.0]
+after : dst=[0.0, 0.0, 40.0, 100.0, 200.0, 300.0]
+```
+
+(3) `void mapPoints (float[] dst, int dstIndex,float[] src, int srcIndex, int pointCount)` 可以指定只计算一部分数值。
+
+| 参数 | 摘要 |
+| ---------- | ------------ |
+| dst | 目标数据 |
+| dstIndex | 目标数据存储位置起始下标 |
+| src | 源数据 |
+| srcIndex | 源数据存储位置起始下标 |
+| pointCount | 计算的点个数 |
+
+
+示例:
+
+>
+>将第二、三个点计算后存储进dst最开始位置。
+
+``` java
+// 初始数据为三个点 (0, 0) (80, 100) (400, 300)
+float[] src = new float[]{0, 0, 80, 100, 400, 300};
+float[] dst = new float[6];
+
+// 构造一个matrix，x坐标缩放0.5
+Matrix matrix = new Matrix();
+matrix.setScale(0.5f, 1f);
+
+// 输出计算之前数据
+Log.i(TAG, "before: src="+ Arrays.toString(src));
+Log.i(TAG, "before: dst="+ Arrays.toString(dst));
+
+// 调用map方法计算(最后一个2表示两个点，即四个数值,并非两个数值)
+matrix.mapPoints(dst, 0, src, 2, 2);
+
+// 输出计算之后数据
+Log.i(TAG, "after : src="+ Arrays.toString(src));
+Log.i(TAG, "after : dst="+ Arrays.toString(dst));
+```
+
+结果:
+
+```
+before: src=[0.0, 0.0, 80.0, 100.0, 400.0, 300.0]
+before: dst=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+after : src=[0.0, 0.0, 80.0, 100.0, 400.0, 300.0]
+after : dst=[40.0, 100.0, 200.0, 300.0, 0.0, 0.0]
+```
+
+#### 2.mapRadius
+
+``` java
+float mapRadius (float radius)
+```
+
+测量半径，由于圆可能会因为画布变换变成椭圆，所以此处测量的是平均半径。
+
+示例:
+
+``` java
+float radius = 100;
+float result = 0;
+
+// 构造一个matrix，x坐标缩放0.5
+Matrix matrix = new Matrix();
+matrix.setScale(0.5f, 1f);
+
+Log.i(TAG, "mapRadius: "+radius);
+
+result = matrix.mapRadius(radius);
+
+Log.i(TAG, "mapRadius: "+result);
+```
+
+结果:
+
+```
+mapRadius: 100.0
+mapRadius: 70.71068
+```
+
+
+#### 3.mapRect
+
+```
+boolean mapRect (RectF rect)
+
+boolean mapRect (RectF dst, RectF src)
+```
+
+测量矩形变换后位置。
+
+(1) `boolean mapRect (RectF rect)` 测量rect并将测量结果放入rect中，返回值是判断矩形经过变换后是否仍为矩形。
+
+示例：
+
+``` java
+RectF rect = new RectF(400, 400, 1000, 800);
+
+// 构造一个matrix
+Matrix matrix = new Matrix();
+matrix.setScale(0.5f, 1f);
+matrix.postSkew(1,0);
+
+Log.i(TAG, "mapRadius: "+rect.toString());
+
+boolean result = matrix.mapRect(rect);
+
+Log.i(TAG, "mapRadius: "+rect.toString());
+Log.e(TAG, "isRect: "+ result);
+```
+
+结果：
+
+```
+mapRadius: RectF(400.0, 400.0, 1000.0, 800.0)
+mapRadius: RectF(600.0, 400.0, 1300.0, 800.0)
+isRect: false
+```
+
+>
+>由于使用了错切，所以返回结果为false。
+
+(2) `boolean mapRect (RectF dst, RectF src)` 测量src并将测量结果放入dst中，返回值是判断矩形经过变换后是否仍为矩形,和之前没有什么太大区别，此处就不啰嗦了。
+
+#### 4.mapVectors
+
+测量向量。
+
+``` java
+void mapVectors (float[] vecs)
+
+void mapVectors (float[] dst, float[] src)
+
+void mapVectors (float[] dst, int dstIndex, float[] src, int srcIndex, int vectorCount)
+```
+
+`mapVectors` 与 `mapPoints` 基本上是相同的，可以直接参照上面的`mapPoints`使用方法。
+
+而两者唯一的区别就是`mapVectors`不会受到位移的影响，这符合向量的定律，如果你不了解的话，请找到以前教过你的老师然后把学费要回来。
+
+区别:
+
+``` java
+float[] src = new float[]{1000, 800};
+float[] dst = new float[2];
+
+// 构造一个matrix
+Matrix matrix = new Matrix();
+matrix.setScale(0.5f, 1f);
+matrix.postTranslate(100,100);
+
+// 计算向量, 不受位移影响
+matrix.mapVectors(dst, src);
+Log.i(TAG, "mapVectors: "+Arrays.toString(dst));
+
+// 计算点
+matrix.mapPoints(dst, src);
+Log.i(TAG, "mapPoints: "+Arrays.toString(dst));
+```
+
+结果:
+
+```
+mapVectors: [500.0, 800.0]
+mapPoints: [600.0, 900.0]
+```
+
+### set、pre 与 post
+
+对于四种基本变换 平移(translate)、缩放(scale)、旋转(rotate)、 错切(skew) 它们每一种都三种操作方法，分别为 设置(set)、 前乘(pre) 和 后乘 (post)。而它们的基础是Concat，通过先构造出特殊矩阵然后用原始矩阵Concat特殊矩阵，达到变换的结果。
+
+**关于四种基本变换的知识和三种对应操作的区别，详细可以参考 [Canvas之画布操作](http://www.gcssloop.com/2015/02/Canvas_Convert/) 和 [Matrix原理](http://www.gcssloop.com/2015/02/Matrix_Basic/) 这两篇文章的内容。**
+
+由于之前的文章已经详细的讲解过了它们的原理与用法，所以此处就简要的介绍一下:
+
+| 方法 | 简介 |
+| ---- | ------------------------------------ |
+| set | 设置，会覆盖掉之前的数值，导致之前的操作失效。 |
+| pre | 前乘，相当于矩阵的右乘， `M' = M * S` (S指为特殊矩阵) |
+| post | 后乘，相当于矩阵的左乘，`M' = S * M` （S指为特殊矩阵） |
+
+**Matrix 相关的重要知识：**
+
+- 1.一开始从Canvas中获取到到Matrix并不是初始矩阵，而是经过偏移后到矩阵，且偏移距离就是距离屏幕左上角的位置。
+
+- > 这个可以用于判定View在屏幕上的绝对位置，View可以根据所处位置做出调整。
+
+- 2.构造Matrix时使用的是矩阵乘法，前乘(pre)与后乘(post)结果差别很大。
+
+- > 这个直接参见上一篇文章 [Matrix原理](http://www.gcssloop.com/2015/02/Matrix_Basic/) 即可。
+
+- 3.受矩阵乘法影响，后面的执行的操作可能会影响到之前的操作。
+
+- > 使用时需要注意构造顺序。
+
+
+### 特殊方法
+
+这一类方法看似不起眼，但拿来稍微加工一下就可能制作意想不到的效果。
+
+#### 1.setPolyToPoly
+
+```java
+boolean setPolyToPoly (
+ float[] src, // 原始数组 src [x,y]，存储内容为一组点
+ int srcIndex, // 原始数组开始位置
+ float[] dst, // 目标数组 dst [x,y]，存储内容为一组点
+ int dstIndex, // 目标数组开始位置
+ int pointCount) // 测控点的数量 取值范围是: 0到4
+```
+
+Poly全称是Polygon，多边形的意思，了解了意思大致就能知道这个方法是做什么用的了，应该与PS中自由变换中的扭曲有点类似。
+
+
+
+> 从参数我们可以了解到setPolyToPoly最多可以支持4个点，这四个点通常为图形的四个角，可以通过这四个角将视图从矩形变换成其他形状。
+
+简单示例:
+
+```java
+public class MatrixSetPolyToPolyTest extends View {
+
+ private Bitmap mBitmap; // 要绘制的图片
+ private Matrix mPolyMatrix; // 测试setPolyToPoly用的Matrix
+
+ public MatrixSetPolyToPolyTest(Context context) {
+ super(context);
+
+ initBitmapAndMatrix();
+ }
+
+ private void initBitmapAndMatrix() {
+ mBitmap = BitmapFactory.decodeResource(getResources(),
+ R.drawable.poly_test);
+
+ mPolyMatrix = new Matrix();
+
+
+ float[] src = {0, 0, // 左上
+ mBitmap.getWidth(), 0, // 右上
+ mBitmap.getWidth(), mBitmap.getHeight(), // 右下
+ 0, mBitmap.getHeight()}; // 左下
+
+ float[] dst = {0, 0, // 左上
+ mBitmap.getWidth(), 400, // 右上
+ mBitmap.getWidth(), mBitmap.getHeight() - 200, // 右下
+ 0, mBitmap.getHeight()}; // 左下
+
+ // 核心要点
+ mPolyMatrix.setPolyToPoly(src, 0, dst, 0, src.length >> 1); // src.length >> 1 为位移运算 相当于处以2
+
+ // 此处为了更好的显示对图片进行了等比缩放和平移(图片本身有点大)
+ mPolyMatrix.postScale(0.26f, 0.26f);
+ mPolyMatrix.postTranslate(0,200);
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ super.onDraw(canvas);
+
+ // 根据Matrix绘制一个变换后的图片
+ canvas.drawBitmap(mBitmap, mPolyMatrix, null);
+ }
+}
+```
+
+
+
+
+
+文章发出后有小伙伴在GitHub上提出疑问，说此处讲解到并不清楚，尤其是最后的一个参数，所以特此补充一下内容。
+
+我们知道`pointCount`支持点的个数为0到4个，四个一般指图形的四个角，属于最常用的一种情形，但前面几种是什么情况呢？
+
+> 发布此文的时候之所以没有讲解0到3的情况，是因为前面的几种情况在实际开发中很少会出现， ~~才不是因为偷懒呢，哼。~~
+
+
+
+| pointCount | 摘要 |
+| :--------: | ---------------------- |
+| 0 | 相当于`reset` |
+| 1 | 相当于`translate` |
+| 2 | 可以进行 缩放、旋转、平移 变换 |
+| 3 | 可以进行 缩放、旋转、平移、错切 变换 |
+| 4 | 可以进行 缩放、旋转、平移、错切以及任何形变 |
+
+> 从上表我们可以观察出一个规律, 随着`pointCount`数值增大setPolyToPoly的可以操作性也越来越强，这不是废话么，可调整点数多了能干的事情自然也多了。
+>
+> 只列一个表格就算交代完毕了显得诚意不足，为了彰显诚意，接下来详细的讲解一下。
+
+
+
+**为什么说前面几种情况在实际开发中很少出现?**
+
+作为开发人员，写出来的代码出了要让机器"看懂"，没有歧义之外，最重要的还是让人看懂，以方便后期的维护修改，从上边的表格中可以看出，前面的几种种情况都可以有更直观的替代方法，只有四个参数的情况下的特殊形变是没有替代方法的。
+
+**测控点选取位置?**
+
+测控点可以选择任何你认为方便的位置，只要src与dst一一对应即可。不过为了方便，通常会选择一些特殊的点： 图形的四个角，边线的中心点以及图形的中心点等。**不过有一点需要注意，测控点选取都应当是不重复的(src与dst均是如此)，如果选取了重复的点会直接导致测量失效，这也意味着，你不允许将一个方形(四个点)映射为三角形(四个点，但其中两个位置重叠)，但可以接近于三角形。**。
+
+**作用范围?**
+
+作用范围当然是设置了Matrix的全部区域，如果你将这个Matrix赋值给了Canvas，它的作用范围就是整个画布，如果你赋值给了Bitmap，它的作用范围就是整张图片。
+
+*****
+
+**接下来用示例演示一下，所有示例的src均为图片大小，dst根据手势变化。**
+
+**pointCount为0**
+
+pointCount为0和`reset`是等价的，而不是保持matrix不变，在最底层的实现中可以看到这样的代码：
+
+```c++
+if (0 == count) {
+ this->reset();
+ return true;
+}
+```
+
+
+
+**pointCount为1**
+
+pointCount为0和`translate`是等价的，在最底层的实现中可以看到这样的代码：
+
+```c++
+if (1 == count) {
+ this->setTranslate(dst[0].fX - src[0].fX, dst[0].fY - src[0].fY);
+ return true;
+}
+```
+
+> 平移的距离是dst - src.
+
+当测控点为1的时候，由于你只有一个点可以控制，所以你只能拖拽着它在2D平面上滑动。
+
+
+
+**pointCount为2**
+
+当pointCount为2的时候，可以做缩放、平移和旋转。
+
+
+
+**pointCount为3**
+
+当pointCount为3的时候，可以做缩放、平移、旋转和错切。
+
+
+
+**pointCount为4**
+
+当pointCount为4的时候，你可以将图像拉伸为任意四边形。
+
+
+
+上面已经用图例比较详细的展示了不同操控点个数的情况，如果你依旧存在疑问，可以获取代码自己试一下。
+
+#### [点击此处查看setPolyToPoly测试代码](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/Code/SetPolyToPoly.md)
+
+#### 2.setRectToRect
+
+```JAVA
+boolean setRectToRect (RectF src, // 源区域
+ RectF dst, // 目标区域
+ Matrix.ScaleToFit stf) // 缩放适配模式
+```
+
+简单来说就是将源矩形的内容填充到目标矩形中，然而在大多数的情况下，源矩形和目标矩形的长宽比是不一致的，到底该如何填充呢，这个填充的模式就由第三个参数 `stf` 来确定。
+
+ScaleToFit 是一个枚举类型，共包含了四种模式:
+
+| 模式 | 摘要 |
+| ------ | -------------------------- |
+| CENTER | 居中，对src等比例缩放，将其居中放置在dst中。 |
+| START | 顶部，对src等比例缩放，将其放置在dst的左上角。 |
+| END | 底部，对src等比例缩放，将其放置在dst的右下角。 |
+| FILL | 充满，拉伸src的宽和高，使其完全填充满dst。 |
+
+下面我们看一下不同宽高比的src与dst在不同模式下是怎样的。
+
+> 假设灰色部分是dst，橙色部分是src，由于是测试不同宽高比，示例中让dst保持不变，看两种宽高比的src在不同模式下填充的位置。
+
+| src(原始状态) |  |
+| :-------: | :--------------------------------------: |
+| CENTER |  |
+| START |  |
+| END |  |
+| FILL |  |
+
+
+
+下面用代码演示一下居中的示例:
+
+```java
+public class MatrixSetRectToRectTest extends View {
+
+ private static final String TAG = "MatrixSetRectToRectTest";
+
+ private int mViewWidth, mViewHeight;
+
+ private Bitmap mBitmap; // 要绘制的图片
+ private Matrix mRectMatrix; // 测试etRectToRect用的Matrix
+
+ public MatrixSetRectToRectTest(Context context) {
+ super(context);
+
+ mBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.rect_test);
+ mRectMatrix = new Matrix();
+ }
+
+ @Override
+ protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+ super.onSizeChanged(w, h, oldw, oldh);
+ mViewWidth = w;
+ mViewHeight = h;
+
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ super.onDraw(canvas);
+
+ RectF src= new RectF(0, 0, mBitmap.getWidth(), mBitmap.getHeight() );
+ RectF dst = new RectF(0, 0, mViewWidth, mViewHeight );
+
+ // 核心要点
+ mRectMatrix.setRectToRect(src,dst, Matrix.ScaleToFit.CENTER);
+
+ // 根据Matrix绘制一个变换后的图片
+ canvas.drawBitmap(mBitmap, mRectMatrix, new Paint());
+ }
+}
+```
+
+
+
+
+
+#### 3.rectStaysRect
+
+判断矩形经过变换后是否仍为矩形，假如Matrix进行了平移、缩放则画布仅仅是位置和大小改变，矩形变换后仍然为矩形，但Matrix进行了非90度倍数的旋转或者错切，则矩形变换后就不再是矩形了，这个很好理解，不过多赘述，顺便说一下，前面的`mapRect`方法的返回值就是根据`rectStaysRect`来判断的。
+
+
+
+#### 4.setSinCos
+
+设置sinCos值，这个是控制Matrix旋转的，由于Matrix已经封装好了Rotate方法，所以这个并不常用，在此仅作概述。
+
+```java
+// 方法一
+void setSinCos (float sinValue, // 旋转角度的sin值
+ float cosValue) // 旋转角度的cos值
+
+// 方法二
+void setSinCos (float sinValue, // 旋转角度的sin值
+ float cosValue, // 旋转角度的cos值
+ float px, // 中心位置x坐标
+ float py) // 中心位置y坐标
+```
+
+简单测试:
+
+```java
+Matrix matrix = new Matrix();
+// 旋转90度
+// sin90=1
+// cos90=0
+matrix.setSinCos(1f, 0f);
+
+Log.i(TAG, "setSinCos:"+matrix.toShortString());
+
+// 重置
+matrix.reset();
+
+// 旋转90度
+matrix.setRotate(90);
+
+Log.i(TAG, "setRotate:"+matrix.toShortString());
+```
+
+结果:
+
+```shell
+setSinCos:[0.0, -1.0, 0.0][1.0, 0.0, 0.0][0.0, 0.0, 1.0]
+setRotate:[0.0, -1.0, 0.0][1.0, 0.0, 0.0][0.0, 0.0, 1.0]
+```
+
+
+
+### 矩阵相关
+
+矩阵相关的函数就属于哪一种非常靠近底层的东西了，大部分开发者很少直接接触这些东西，想要弄明白这个可以回去请教你们的线性代数老师，这里也仅作概述。
+
+| 方法 | 摘要 |
+| ---------- | ------------------------------- |
+| invert | 求矩阵的逆矩阵 |
+| isAffine | 判断当前矩阵是否为仿射矩阵，API21(5.0)才添加的方法。 |
+| isIdentity | 判断当前矩阵是否为单位矩阵。 |
+
+#### 1.invert
+
+求矩阵的逆矩阵，简而言之就是计算与之前相反的矩阵，如果之前是平移200px，则求的矩阵为反向平移200px，如果之前是缩小到0.5f，则结果是放大到2倍。
+
+```java
+boolean invert (Matrix inverse)
+```
+
+简单测试:
+
+```java
+Matrix matrix = new Matrix();
+Matrix invert = new Matrix();
+matrix.setTranslate(200,500);
+
+Log.e(TAG, "before - matrix "+matrix.toShortString() );
+
+Boolean result = matrix.invert(invert);
+
+Log.e(TAG, "after - result "+result );
+Log.e(TAG, "after - matrix "+matrix.toShortString() );
+Log.e(TAG, "after - invert "+invert.toShortString() );
+```
+
+结果：
+
+```shell
+before - matrix [1.0, 0.0, 200.0][0.0, 1.0, 500.0][0.0, 0.0, 1.0]
+after - result true
+after - matrix [1.0, 0.0, 200.0][0.0, 1.0, 500.0][0.0, 0.0, 1.0]
+after - invert [1.0, 0.0, -200.0][0.0, 1.0, -500.0][0.0, 0.0, 1.0]
+```
+
+
+
+#### 2.isAffine
+
+判断矩阵是否是仿射矩阵, 貌似并没有太大卵用，因为你无论如何操作结果始终都为true。
+
+这是为什么呢？因为迄今为止我们使用的所有变换都是仿射变换，那变换出来的矩阵自然是仿射矩阵喽。
+
+判断是否是仿射矩阵最重要的一点就是，直线是否仍为直线，简单想一下就知道，不论平移，旋转，错切，缩放，直线变换后最终仍为直线，要想让`isAffine`的结果变为false，除非你能把直线掰弯，我目前还没有找到能够掰弯的方法，所以我仍是直男(就算找到了，我依旧是直男)。
+
+简单测试:
+
+```java
+Matrix matrix = new Matrix();
+Log.i(TAG,"isAffine="+matrix.isAffine());
+
+matrix.postTranslate(200,0);
+matrix.postScale(0.5f, 1);
+matrix.postSkew(0,1);
+matrix.postRotate(56);
+
+Log.i(TAG,"isAffine="+matrix.isAffine());
+```
+
+结果:
+
+```shell
+isAffine=true
+isAffine=true
+```
+
+
+
+#### 3.isIdentity
+
+判断是否为单位矩阵，什么是单位矩阵呢，就是文章一开始的那个:
+
+
+
+新创建的Matrix和重置后的Matrix都是单位矩阵，不过，只要随意操作一步，就不在是单位矩阵了。
+
+简单测试：
+
+```java
+Matrix matrix = new Matrix();
+Log.i(TAG,"isIdentity="+matrix.isIdentity());
+
+matrix.postTranslate(200,0);
+
+Log.i(TAG,"isIdentity="+matrix.isIdentity());
+```
+
+结果：
+
+```shell
+isIdentity=true
+isIdentity=false
+```
+
+
+
+## Matrix实用技巧
+
+通过前面的代码和示例，我们已经了解了Matrix大部分方法是如何使用的，这些基本的原理和方法通过组合可能会创造出神奇的东西，网上有很多教程讲Bitmap利用Matrix变换来制作镜像倒影等，这都属于Matrix的基本应用，我就不在赘述了，下面我简要介绍几种然并卵的小技巧，更多的大家可以开启自己的脑洞来发挥。
+
+### 1.获取View在屏幕上的绝对位置
+
+在之前的文章[Matrix原理](http://www.gcssloop.com/2015/02/Matrix_Basic/)中我们提到过Matrix最根本的作用就是坐标映射，将View的相对坐标映射为屏幕的绝对坐标，也提到过我们在onDraw函数的canvas中获取到到Matrix并不是单位矩阵，结合这两点，聪明的你肯定想到了我们可以从canvas的Matrix入手取得View在屏幕上的绝对位置。
+
+不过，这也仅仅是一个然并卵的小技巧而已，使用`getLocationOnScreen`同样可以获取View在屏幕的位置，但如果你是想让下一任接盘侠弄不明白你在做什么或者是被同事打死的话，尽管这么做。
+
+简单示例:
+
+```java
+@Override
+protected void onDraw(Canvas canvas) {
+ float[] values = new float[9];
+ int[] location1 = new int[2];
+
+ Matrix matrix = canvas.getMatrix();
+ matrix.getValues(values);
+
+ location1[0] = (int) values[2];
+ location1[1] = (int) values[5];
+ Log.i(TAG, "location1 = " + Arrays.toString(location1));
+
+ int[] location2 = new int[2];
+ this.getLocationOnScreen(location2);
+ Log.i(TAG, "location2 = " + Arrays.toString(location2));
+}
+```
+
+结果:
+
+```shell
+location1 = [0, 243]
+location2 = [0, 243]
+```
+
+### 2.利用setPolyToPoly制造3D效果
+
+这个全凭大家想象力啦，不过我搜了一下还真搜到了好东西，之前鸿洋大大发过一篇博文详细讲解了利用setPolyToPoly制造的折叠效果布局，大家直接到他的博客去看吧，我就不写了。
+
+> 图片引用自鸿洋大大的博客，稍作了一下处理。
+
+
+
+博文链接:
+
+**[Android FoldingLayout 折叠布局 原理及实现（一）](http://blog.csdn.net/lmj623565791/article/details/44278417)**
+
+**[Android FoldingLayout 折叠布局 原理及实现（二）](http://blog.csdn.net/lmj623565791/article/details/44283093)**
+
+## 总结
+
+本篇基本讲解了Matrix相关的所有方法，应该是目前对Matrix讲解最全面的一篇中文文章了，建议配合上一篇[Matrix原理](http://www.gcssloop.com/2015/02/Matrix_Basic/)食用效果更佳。
+
+由于本人水平有限，可能出于误解或者笔误难免出错，如果发现有问题或者对文中内容存在疑问欢迎在下面评论区告诉我，请对问题描述尽量详细，以帮助我可以快速找到问题根源。
+
+## About Me
+
+### 作者微博: @GcsSloop
+
+
+
+## 参考资料
+
+[Matrix](https://developer.android.com/reference/android/graphics/Matrix.html)
+
+[Matrix.ScaleToFit](https://developer.android.com/reference/android/graphics/Matrix.ScaleToFit.html)
+
+[Android中图像变换Matrix的原理、代码验证和应用](http://biandroid.iteye.com/blog/1399462)
+
+[Understanding Affine Transformations With Matrix Mathematics](http://code.tutsplus.com/tutorials/understanding-affine-transformations-with-matrix-mathematics--active-10884)
+
diff --git a/CustomView/Advance/[11]Matrix_3D_Camera.md b/CustomView/Advance/[11]Matrix_3D_Camera.md
new file mode 100644
index 00000000..e59848c0
--- /dev/null
+++ b/CustomView/Advance/[11]Matrix_3D_Camera.md
@@ -0,0 +1,537 @@
+# Matrix Camera
+
+### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
+### 相关文章: [自定义View目录](http://www.gcssloop.com/customview/CustomViewIndex/)
+
+本篇依旧属于Matrix，主要讲解Camera，Android下有很多相机应用，其中的美颜相机更是不少，不过今天这个Camera可不是我们平时拍照的那个相机，而是graphic包下的Camera，专业给View拍照的相机，不过既然是相机，作用都是类似的，主要是将3D的内容拍扁变成2D的内容。
+
+众所周知，我们的手机屏幕是一个2D的平面，所以也没办法直接显示3D的信息，因此我们看到的所有3D效果都是3D在2D平面的投影而已，而本文中的Camera主要作用就是这个，将3D信息转换为2D平面上的投影，实际上这个类更像是一个操作Matrix的工具类，使用Camera和Matrix可以在不使用OpenGL的情况下制作出简单的3D效果。
+
+
+
+## Camera常用方法表
+
+| 方法类别 | 相关API | 简介 |
+| ---- | ---------------------------------------- | -------------- |
+| 基本方法 | save、restore | 保存、 回滚 |
+| 常用方法 | getMatrix、applyToCanvas | 获取Matrix、应用到画布 |
+| 平移 | translate | 位移 |
+| 旋转 | rotate (API 12)、rotateX、rotateY、rotateZ | 各种旋转 |
+| 相机位置 | setLocation (API 12)、getLocationX (API 16)、getLocationY (API 16)、getLocationZ (API 16) | 设置与获取相机位置 |
+
+> Camera的方法并不是特别多，很多内容与之前的讲解的Canvas和Matrix类似，不过又稍有不同，之前的画布操作和Matrix主要是作用于2D空间，而Camera则主要作用于3D空间。
+
+
+
+## 基础概念
+
+在具体讲解方法之前，先补充几个基础概念，以便于后面理解。
+
+#### 3D坐标系
+
+我们Camera使用的3维坐标系是**左手坐标系，即左手手臂指向x轴正方向，四指弯曲指向y轴正方向，此时展开大拇指指向的方向是z轴正方向**。
+
+
+
+> 至于为什么要用左手坐标系呢？~~大概是因为赶工的时候右手不方便比划吧，大雾。~~实际上不同平台上使用的坐标系也有不同，有的是左手，有的是右手，貌似并没有统一的标准，只需要记住 Android 平台上面使用的是左手坐标系即可。
+
+**2D 和 3D 坐标是通过Matrix关联起来的，所以你可以认为两者是同一个坐标系，但又有差别，重点就是y轴方向不同。**
+
+| 坐标系 | 2D坐标系 | 3D坐标系 |
+| ------- | :---: | :----: |
+| 原点默认位置 | 左上角 | 左上角 |
+| X 轴默认方向 | 右 | 右 |
+| Y 轴默认方向 | 下 | 上 |
+| Z 轴默认方向 | 无 | 垂直屏幕向内 |
+
+3D坐标系在屏幕中各个坐标轴默认方向展示:
+
+> 注意y轴默认方向是向上，而2D则是向下，另外本图不代表3D坐标系实际位置。
+
+
+
+
+
+#### 三维投影
+
+> **三维投影**是将三维空间中的点映射到二维平面上的方法。由于目前绝大多数图形数据的显示方式仍是二维的，因此三维投影的应用相当广泛，尤其是在计算机图形学，工程学和工程制图中。
+
+三维投影一般有两种，**正交投影** 和 **透视投影**。
+
+* 正交投影就是我们数学上学过的 "正视图、正视图、侧视图、俯视图" 这些东西。
+* 透视投影则更像拍照片，符合**近大远小**的关系，有立体感，**我们此处使用的就是透视投影。**
+
+
+
+#### 摄像机
+
+如果你学过Unity，那么你对摄像机这一个概念应该会有比较透彻的理解。在一个虚拟的3D的立体空间中，由于我们无法直接用眼睛去观察这一个空间，所以要借助摄像机采集信息，制成2D影像供我们观察。简单来说，**摄像机就是我们观察虚拟3D空间的眼睛**。
+
+**Android 上面观察View的摄像机默认位置在屏幕左上角，而且是距屏幕有一段距离的，假设灰色部分是手机屏幕，白色是上面的一个View，摄像机位置看起来大致就是下面这样子的(为了更好的展示摄像机的位置，做了一个空间转换效果的动图)。**
+
+
+
+> 摄像机的位置默认是 (0, 0, -576)。其中 -576＝ -8 x 72，虽然官方文档说距离屏幕的距离是 -8, 但经过测试实际距离是 -576 像素，当距离为 -10 的时候，实际距离为 -720 像素。我使用了3款手机测试，屏幕大小和像素密度均不同，但结果都是一样的。
+>
+> 这个魔数可以在 Android 底层的图像引擎 Skia 中找到。在 Skia 中，Camera 的位置单位是英寸，英寸和像素的换算单位在 Skia 中被固定为 72 像素，而 Android 中把这个换算单位照搬了过来。
+
+
+
+## 基本方法
+
+基本方法就有两个`save` 和`restore`，主要作用为`保存当前状态和恢复到上一次保存的状态`，通常成对使用，常用格式如下:
+
+```java
+camera.save(); // 保存状态
+... // 具体操作
+camera.retore(); // 回滚状态
+```
+
+
+
+## 常用方法
+
+这两个方法是Camera中最基础也是最常用的方法。
+
+#### getMatrix
+
+```java
+void getMatrix (Matrix matrix)
+```
+
+计算当前状态下矩阵对应的状态，并将计算后的矩阵赋值给参数matrix。
+
+#### applyToCanvas
+
+```java
+void applyToCanvas (Canvas canvas)
+```
+
+计算当前状态下单矩阵对应的状态，并将计算后的矩阵应用到指定的canvas上。
+
+
+
+## 平移
+
+> **声明：以下示例中 Matrix 的平移均使用 postTranslate 来演示，实际情况中使用set、pre 或 post 需要视情况而定。**
+
+```java
+void translate (float x, float y, float z)
+```
+
+和2D平移类似，只不过是多出来了一个维度，从只能在2D平面上平移到在3D空间内平移，不过，此处仍有几个要点需要重点对待。
+
+
+
+#### 沿x轴平移
+
+
+``` java
+camera.translate(x, 0, 0);
+
+matrix.postTranslate(x, 0);
+```
+
+两者x轴同向，所以 Camera 和 Matrix 在沿x轴平移上是一致的。
+
+**结论:**
+
+一致是指平移方向和平移距离一致，在默认情况下，上面两种均可以让坐标系向右移动x个单位。
+
+
+
+#### 沿y轴平移
+
+这个就有点意思了，两个坐标系相互关联，但是两者的y轴方向是相反的，很容易把人搞迷糊。你可以这么玩:
+
+```java
+Camera camera = new Camera();
+camera.translate(0, 100, 0); // camera - 沿y轴正方向平移100像素
+
+Matrix matrix = new Matrix();
+camera.getMatrix(matrix);
+matrix.postTranslate(0,100); // matrix - 沿y轴正方向平移100像素
+
+Log.i(TAG, "Matrix: "+matrix.toShortString());
+```
+
+在上面这种写法，虽然用了5行代码，但是效果却和 `Matrix matrix = new Matrix();` 一样，结果都是单位矩阵。而且看起来貌似没有啥问题，毕竟两次平移都是正向100。(~~如果遇见不懂技术的领导嫌你写代码量少，你可以这样多写几遍，反正一般人是看不出问题的。~~)
+
+```
+Matrix: [1.0, 0.0, 0.0][0.0, 1.0, 0.0][0.0, 0.0, 1.0]
+```
+
+**结论:**
+
+由于两者y轴相反，所以 `camera.translate(0, -y, 0);` 与 `matrix.postTranslate(0, y);`平移方向和距离一致，在默认情况下，这两种方法均可以让坐标系向下移动y个单位。
+
+
+
+#### 沿z轴平移
+
+这个不仅有趣，还容易蒙逼，上面两种情况再怎么闹腾也只是在2D平面上，而z轴的出现则让其有了空间感。
+
+**当View和摄像机在同一条直线上时:** 此时沿z轴平移相当于缩放的效果，缩放中心为摄像机所在(x, y)坐标，当View接近摄像机时，看起来会变大，远离摄像机时，看起来会变小，**近大远小**。
+
+**当View和摄像机不在同一条直线上时:** 当View远离摄像机的时候，View在缩小的同时也在不断接近摄像机在屏幕投影位置(通常情况下为Z轴，在平面上表现为接近坐标原点)。相反，当View接近摄像机的时候，View在放大的同时会远离摄像机在屏幕投影位置。
+
+
+
+我知道，这样说你们肯定是蒙逼的，话说为啥远离摄像机的时候会接近摄像机在屏幕投影位置(´･_･`)，肯定觉得我在逗你们玩，完全是前后矛盾，逻辑都不通，不过这个在这里的确是不矛盾的，因为远离是在3D空间里的情况，而接近只是在2D空间的投影，看下图。
+
+> 假设大矩形是手机屏幕，白色小矩形是View，摄像机位于屏幕左上角，请注意上面View与摄像机的距离以及下方View的大小以及距离左上角(摄像机在屏幕投影位置)的距离。
+
+
+
+至于为什么会这样，因为我们人眼视觉就是这样的，当我们看向远方的时候，视线最终都会消失在视平线上，如果你站在两条平行线中间，看起来它们会在远方(视平线上)相交，虽然在3D空间上两者距离不变，但在2D投影上却是越来越接近，如下图(图片来自网络):
+
+
+
+**结论:**
+
+关于3D效果的平移说起来比较麻烦，但你可以自己实际的体验一下，毕竟我们是生活在3D空间的，拿一张纸片来模拟View，用眼睛当做摄像机，在眼前来回移动纸片，多试几次大致就明白是怎么回事了。
+
+| 平移 | 重点内容 |
+| :--: | ----------- |
+| x轴 | 2D 和 3D 相同。 |
+| y轴 | 2D 和 3D 相反。 |
+| z轴 | 近大远小、视线相交。 |
+
+
+
+## 旋转
+
+旋转是Camera制作3D效果的核心，不过它制作出来的并不能算是真正的3D，而是伪3D，因为View是没有厚度的。
+
+```java
+// (API 12) 可以控制View同时绕x，y，z轴旋转，可以由下面几种方法复合而来。
+void rotate (float x, float y, float z);
+
+// 控制View绕单个坐标轴旋转
+void rotateX (float deg);
+void rotateY (float deg);
+void rotateZ (float deg);
+```
+
+这个东西瞎扯理论也不好理解，直接上图:
+
+
+
+
+
+
+
+
+## 参考资料
+
+[Camera](https://developer.android.com/reference/android/graphics/Camera.html)
+[FlipShare](https://github.com/JeasonWong/FlipShare)
+[从零开始打造一个Android 3D立体旋转容器](http://blog.csdn.net/mr_immortalz/article/details/51918560)
+
diff --git a/CustomView/Advance/[12]Dispatch-TouchEvent-Theory.md b/CustomView/Advance/[12]Dispatch-TouchEvent-Theory.md
new file mode 100644
index 00000000..47b33077
--- /dev/null
+++ b/CustomView/Advance/[12]Dispatch-TouchEvent-Theory.md
@@ -0,0 +1,314 @@
+# 事件分发机制原理
+
+
+之前讲解了很多与View绘图相关的知识，你可以在 [安卓自定义View教程目录](http://www.gcssloop.com/customview/CustomViewIndex) 中查看到这些文章，如果你理解了这些文章，那么至少2D绘图部分不是难题了，大部分的需求都能满足，但是关于View还有很多知识点，例如: `让绘图更加炫酷的Paint`，`让View动起来的动画`，`与用户交互的触控事件` 等一系列内容。**本次就带大家简单的了解一下与交互息息相关的东西－事件分发原理**。
+
+> 本次魔法小火车的终点站是事件分发，请各位魔法师带好装备，准备登车启程。
+
+**注意：本文中所有源码分析部分均基于 API23(Android 6.0) 版本，由于安卓系统源码改变很多，可能与之前版本有所不同，但基本流程都是一致的。**
+
+
+
+## 为什么要有事件分发机制？
+
+**安卓上面的View是树形结构的，View可能会重叠在一起，当我们点击的地方有多个View都可以响应的时候，这个点击事件应该给谁呢？为了解决这一个问题，就有了事件分发机制。**
+
+如下图，View是一层一层嵌套的，当手指点击 `View1` 的时候，下面的`ViewGroupA`、 `RootView` 等也是能够响应的，为了确定到底应该是哪个View处理这次点击事件，就需要事件分发机制来帮忙。
+
+
+
+
+
+## View的结构:
+
+我们的View是树形结构的，在上一个问题中实例View的结构大致如下:
+
+**layout文件:**
+
+```XML
+
+[PhoneWindow](https://android.googlesource.com/platform/frameworks/base/+/696cba573e651b0e4f18a4718627c8ccecb3bda0/policy/src/com/android/internal/policy/impl/PhoneWindow.java)
+[ViewGroup](https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/view/ViewGroup.java)
+[View](https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/view/View.java)
+[Android事件传递机制分析](http://wuxiaolong.me/2015/12/19/MotionEvent/)
+[Android ViewGroup/View 事件分发机制详解](http://anany.me/2015/11/08/touchevent/)
+[ Android事件分发机制完全解析，带你从源码的角度彻底理解(上)](http://blog.csdn.net/guolin_blog/article/details/9097463)
+[ Android事件分发机制完全解析，带你从源码的角度彻底理解(下)](http://blog.csdn.net/sinyu890807/article/details/9153747)
+[更简单的学习Android事件分发](http://www.idtkm.com/customview/customview11/)
+《安卓开发艺术探索》
+
+
+
+## About Me
+
+### 作者微博: @GcsSloop
+
+
+
diff --git a/CustomView/Advance/[15]Dispatch-TouchEvent-Source.md b/CustomView/Advance/[15]Dispatch-TouchEvent-Source.md
new file mode 100644
index 00000000..b31bb10b
--- /dev/null
+++ b/CustomView/Advance/[15]Dispatch-TouchEvent-Source.md
@@ -0,0 +1,548 @@
+# 事件分发机制详解
+
+在上一篇文章 [事件分发机制原理][dispatch-touchevent-theory] 中简要分析了一下事件分发机制的原理，原理是十分简单的，一句话就能总结：**责任链模式，事件层层传递，直到被消费。** 虽然原理简单，但是随着 Android 不断的发展，实际运用场景也越来越复杂，所以想要彻底玩转事件分发机制还需要一定技巧，本篇事件分发机制详解将带大家了解 ...
+
+> **你以为我接下来要讲源码？**
+> 我就不按套路，所有的源码都是为了适应具体的应用场景而写的，只要能够理解运用场景，理解源码也就十分简单了。所以本篇的核心问题是：**正确理解在实际场景中事件分发机制的作用。** 会涉及到源码，但不是主角。
+
+**注意：本文中所有源码分析部分均基于 API23(Android 6.0) 版本，由于安卓系统源码改变很多，可能与之前版本有所不同，但基本流程都是一致的。**
+
+
+
+## 常见事件
+
+既然是事件分发，总要有事件才能分发吧，所以我们先了解一下常见的几种事件。
+
+根据面向对象思想，事件被封装成 MotionEvent 对象，由于本篇重点不在于此，所以只会涉及到几个与手指触摸相关的常见事件:
+
+| 事件 | 简介 |
+| ------------- | ------------------------- |
+| ACTION_DOWN | 手指 **初次接触到屏幕** 时触发。 |
+| ACTION_MOVE | 手指 **在屏幕上滑动** 时触发，会会多次触发。 |
+| ACTION_UP | 手指 **离开屏幕** 时触发。 |
+| ACTION_CANCEL | 事件 **被上层拦截** 时触发。 |
+
+对于单指触控来说，一次简单的交互流程是这样的:
+
+**手指落下(ACTION_DOWN) －> 移动(ACTION_MOVE) －> 离开(ACTION_UP)**
+
+> * 本次事例中 ACTION_MOVE 有多次触发。
+> * 如果仅仅是单击(手指按下再抬起)，不会触发 ACTION_MOVE。
+
+
+
+## 事件分发、拦截与消费
+
+关于这一部分内容，上一篇文章 [事件分发机制原理][dispatch-touchevent-theory] 已经将流程整理的比较清楚了，本文会深入细节来研究这些内容。之所以分开讲，是为了防止大家被细节所迷惑而忽略了整体逻辑。
+
+> `√` 表示有该方法。
+>
+> `X` 表示没有该方法。
+
+| 类型 | 相关方法 | ViewGroup | View |
+| :--: | :-------------------: | :-------: | :--: |
+| 事件分发 | dispatchTouchEvent | √ | √ |
+| 事件拦截 | onInterceptTouchEvent | √ | X |
+| 事件消费 | onTouchEvent | √ | √ |
+
+
+
+### View 相关
+
+`dispatchTouchEvent` 是事件分发机制中的核心，所有的事件调度都归它管。不过我细看表格， ViewGroup 有 dispatchTouchEvent 也就算了，毕竟人家有一堆 ChildView 需要管理，但为啥 View 也有？这就引出了我们的第一个疑问。
+
+#### Q: 为什么 View 会有 dispatchTouchEvent ?
+
+A: 我们知道 View 可以注册很多事件监听器，例如：单击事件(onClick)、长按事件(onLongClick)、触摸事件(onTouch)，并且View自身也有 onTouchEvent 方法，那么问题来了，这么多与事件相关的方法应该由谁管理？毋庸置疑就是 `dispatchTouchEvent`，所以 View 也会有事件分发。
+
+相信看到这里很多小伙伴会产生第二个疑问，View 有这么多事件监听器，到底哪个先执行？
+
+#### Q: 与 View 事件相关的各个方法调用顺序是怎样的？
+
+A: **如果不去看源码，想一下让自己设计会怎样？**
+
+* 单击事件(onClickListener) 需要两个两个事件(ACTION_DOWN 和 ACTION_UP )才能触发，如果先分配给onClick判断，等它判断完，用户手指已经离开屏幕，黄花菜都凉了，定然造成 View 无法响应其他事件，应该最后调用。(最后)
+* 长按事件(onLongClickListener) 同理，也是需要长时间等待才能出结果，肯定不能排到前面，但因为不需要ACTION_UP，应该排在 onClick 前面。(onLongClickListener > onClickListener)
+* 触摸事件(onTouchListener) 如果用户注册了触摸事件，说明用户要自己处理触摸事件了，这个应该排在最前面。(最前)
+* View自身处理(onTouchEvent) 提供了一种默认的处理方式，如果用户已经处理好了，也就不需要了，所以应该排在 onTouchListener 后面。(onTouchListener > onTouchEvent)
+
+**所以事件的调度顺序应该是 `onTouchListener > onTouchEvent > onLongClickListener > onClickListener`**。
+
+
+
+下面我们来看一下实际测试结果:
+
+> 手指按下，不移动，稍等片刻再抬起。
+
+```shell
+[Listener ]: onTouchListener ACTION_DOWN
+[GcsView ]: onTouchEvent ACTION_DOWN
+[Listener ]: onLongClickListener
+[Listener ]: onTouchListener ACTION_UP
+[GcsView ]: onTouchEvent ACTION_UP
+[Listener ]: onClickListener
+```
+
+可以看到，测试结果也支持我们猜测的结论，因为长按 onLongClickListener 不需要 ACTION_UP 所以会在 ACTION_DOWN 之后就触发。
+
+接下来就看一下源码是怎么设计的(省略了大量无关代码)：
+
+```java
+public boolean dispatchTouchEvent(MotionEvent event) {
+ ...
+ boolean result = false; // result 为返回值，主要作用是告诉调用者事件是否已经被消费。
+ if (onFilterTouchEventForSecurity(event)) {
+ ListenerInfo li = mListenerInfo;
+ /**
+ * 如果设置了OnTouchListener，并且当前 View 可点击，就调用监听器的 onTouch 方法，
+ * 如果 onTouch 方法返回值为 true，就设置 result 为 true。
+ */
+ if (li != null && li.mOnTouchListener != null
+ && (mViewFlags & ENABLED_MASK) == ENABLED
+ && li.mOnTouchListener.onTouch(this, event)) {
+ result = true;
+ }
+
+ /**
+ * 如果 result 为 false，则调用自身的 onTouchEvent。
+ * 如果 onTouchEvent 返回值为 true，则设置 result 为 true。
+ */
+ if (!result && onTouchEvent(event)) {
+ result = true;
+ }
+ }
+ ...
+ return result;
+}
+```
+
+> **如果觉得源码还是太长，那么用伪代码实现应当是这样的(省略若干安全判断)，简单粗暴:**
+>
+> ```java
+> public boolean dispatchTouchEvent(MotionEvent event) {
+> if (mOnTouchListener.onTouch(this, event)) {
+> return true;
+> } else if (onTouchEvent(event)) {
+> return true;
+> }
+> return false;
+> }
+> ```
+
+正当你沉迷在源码的"精妙"逻辑的时候，你可能没发现有两个东西失踪了，等回过神来，定睛一看，哎呦妈呀，**OnClick 和 OnLongClick 去哪里了？**
+
+不要担心，OnClick 和 OnLongClick 的具体调用位置在 **onTouchEvent** 中，看源码(同样省略大量无关代码):
+
+```java
+public boolean onTouchEvent(MotionEvent event) {
+ ...
+ final int action = event.getAction();
+ // 检查各种 clickable
+ if (((viewFlags & CLICKABLE) == CLICKABLE ||
+ (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) ||
+ (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE) {
+ switch (action) {
+ case MotionEvent.ACTION_UP:
+ ...
+ removeLongPressCallback(); // 移除长按
+ ...
+ performClick(); // 检查单击
+ ...
+ break;
+ case MotionEvent.ACTION_DOWN:
+ ...
+ checkForLongClick(0); // 检测长按
+ ...
+ break;
+ ...
+ }
+ return true; // ◀︎表示事件被消费
+ }
+ return false;
+}
+```
+
+> **注意了，第一个重点要出现了(敲黑板)!**
+>
+> 
+>
+> **注意上面代码中存在一个 `return true;` 并且是只要 View 可点击就返回 true，就表示事件被消费了。**
+>
+> 举个栗子: I have a **RelativeLayout**，I have a **View**，Ugh，**RelativeLayout - View**
+>
+> ```xml
+>
+
+
+
+[dispatch-touchevent-theory]: http://www.gcssloop.com/customview/dispatch-touchevent-theory "事件分发机制原理－GcsSloop"
+
diff --git a/CustomView/Advance/[16]MotionEvent.md b/CustomView/Advance/[16]MotionEvent.md
new file mode 100644
index 00000000..94c9c8f1
--- /dev/null
+++ b/CustomView/Advance/[16]MotionEvent.md
@@ -0,0 +1,368 @@
+# MotionEvent 详解
+
+Android MotionEvent 详解，之前用了两篇文章 [事件分发机制原理][customview/dispatch-touchevent-theory] 和 [事件分发机制详解][customview/dispatch-touchevent-source] 来讲解事件分发，而作为事件分发主角之一的 MotionEvent 并没有过多的说明，本文就带大家了解 MotionEvent 的相关内容，简要介绍触摸事件，主要包括 单点触控、多点触控、鼠标事件 以及 getAction() 和 getActionMasked() 的区别。
+
+Android 将所有的输入事件都放在了 MotionEvent 中，随着安卓的不断发展壮大，MotionEvent 也开始变得越来越复杂，下面是我自己整理的 MotionEvent 大事记:
+
+| 版本号 | 更新内容 |
+| :-------------------: | --------------------------- |
+| Android 1.0 (API 1 ) | 支持单点触控和轨迹球的事件。 |
+| Android 1.6 (API 4 ) | 支持手势。 |
+| Android 2.2 (API 8 ) | 支持多点触控。 |
+| Android 3.1 (API 12) | 支持触控笔，鼠标，键盘，操纵杆，游戏控制器等输入工具。 |
+
+以上仅仅是简要的说明几次比较大的变动，细小的修复和更新不计其数，此处就不一一列出了，反正也没人关心这些东西。
+MotionEvent 负责集中处理所有类型设备的输入事件，但是由于某些设备使用的几率较小本文会忽略讲解，或者简要讲解，例如：
+1、轨迹球只出现在最早的设备上，现代的设备上已经见不到了，本文不再叙述。
+2、触控笔和手指处理流程基本相同，不再多说。
+3、鼠标在手机上使用概率也比较小，会在文末简要介绍。
+
+
+
+## 单点触控
+
+单点触控就非常简单啦，入门的工程师都会用，上一篇文章也简要介绍过，主要涉及以下几个事件:
+
+| 事件 | 简介 |
+| -------------- | ------------------------ |
+| ACTION_DOWN | 手指 **初次接触到屏幕** 时触发。 |
+| ACTION_MOVE | 手指 **在屏幕上滑动** 时触发，会多次触发。 |
+| ACTION_UP | 手指 **离开屏幕** 时触发。 |
+| ACTION_CANCEL | 事件 **被上层拦截** 时触发。 |
+| ACTION_OUTSIDE | 手指 **不在控件区域** 时触发。 |
+
+和以下的几个方法:
+
+| 方法 | 简介 |
+| :---------- | ---------------------- |
+| getAction() | 获取事件类型。 |
+| getX() | 获得触摸点在当前 View 的 X 轴坐标。 |
+| getY() | 获得触摸点在当前 View 的 Y 轴坐标。 |
+| getRawX() | 获得触摸点在整个屏幕的 X 轴坐标。 |
+| getRawY() | 获得触摸点在整个屏幕的 Y 轴坐标。 |
+
+> 关于 `get` 和 `getRaw` 的区别可以参考这一篇文章 [安卓自定义View基础-坐标系][customview/CoordinateSystem]
+
+单点触控一次简单的交互流程是这样的:
+
+**手指落下(ACTION_DOWN) －> 多次移动(ACTION_MOVE) －> 离开(ACTION_UP)**
+
+> * 本次事例中 ACTION_MOVE 有多次触发。
+> * 如果仅仅是单击(手指按下再抬起)，不会触发 ACTION_MOVE。
+
+
+
+针对单点触控的事件处理一般是这样写的:
+
+```java
+@Override
+public boolean onTouchEvent(MotionEvent event) {
+ // ▼ 注意这里使用的是 getAction()，先埋一个小尾巴。
+ switch (event.getAction()){
+ case MotionEvent.ACTION_DOWN:
+ // 手指按下
+ break;
+ case MotionEvent.ACTION_MOVE:
+ // 手指移动
+ break;
+ case MotionEvent.ACTION_UP:
+ // 手指抬起
+ break;
+ case MotionEvent.ACTION_CANCEL:
+ // 事件被拦截
+ break;
+ case MotionEvent.ACTION_OUTSIDE:
+ // 超出区域
+ break;
+ }
+ return super.onTouchEvent(event);
+}
+```
+
+相信小伙伴对此已经非常熟悉了，经常使用的东西，我也不啰嗦了。
+
+但其中有两个比较特殊的事件: `ACTION_CANCEL` 和 `ACTION_OUTSIDE` 。
+为什么说特殊呢，因为它们是由程序触发而产生的，而且触发条件也非常特殊，通常情况下即便不处理这两个事件也没有什么问题。接下来我们就扒一扒它们的真面目:
+
+
+
+### ACTION_CANCEL
+
+**`ACTION_CANCEL` 的触发条件是事件被上层拦截**，然而我们在 [事件分发机制原理][customview/dispatch-touchevent-theory] 一文中了解到当事件被上层 View 拦截的时候，ChildView 是收不到任何事件的，ChildView 收不到任何事件，自然也不会收到 `ACTION_CANCEL` 了，所以说这个 `ACTION_CANCEL` 的正确触发条件并不是这样，那么是什么呢？
+
+**事实上，只有上层 View 回收事件处理权的时候，ChildView 才会收到一个 `ACTION_CANCEL` 事件。**
+
+这样说可能不太容易理解，咱举个例子?
+
+
+
+> 例如：上层 View 是一个 RecyclerView，它收到了一个 `ACTION_DOWN` 事件，由于这个可能是点击事件，所以它先传递给对应 ItemView，询问 ItemView 是否需要这个事件，然而接下来又传递过来了一个 `ACTION_MOVE` 事件，且移动的方向和 RecyclerView 的可滑动方向一致，所以 RecyclerView 判断这个事件是滚动事件，于是要收回事件处理权，这时候对应的 ItemView 会收到一个 `ACTION_CANCEL` ，并且不会再收到后续事件。
+>
+> **通俗一点？**
+>
+> RecyclerView：儿砸，这里有一个 `ACTION_DOWN` 你看你要不要。
+> ItemView ：好嘞，我看看。
+> RecyclerView：噫？居然是移动事件`ACTION_MOVE`，我要滚起来了，儿砸，我可能要把你送去你姑父家(缓存区)了，在这之前给你一个 `ACTION_CANCEL`，你要收好啊。
+> ItemView ：…...
+>
+> 这是实际开发中最有可能见到 `ACTION_CANCEL` 的场景了。
+
+
+
+### ACTION_OUTSIDE
+
+`ACTION_OUTSIDE`的触发条件更加奇葩，从字面上看，outside 意思不就是超出区域么？然而不论你如何滑动超出控件区域都不会触发 `ACTION_OUTSIDE` 这个事件。相信很多魔法师都对此很是疑惑，说好的超出区域呢？
+
+实际上这个事件根本就不是在这里用的，看官方解释(装一下逼)：
+
+> A movement has happened outside of the normal bounds of the UI element. This does not provide a full gesture, but only the initial location of the movement/touch.
+>
+> 一个触摸事件已经发生了UI元素的正常范围之外。因此不再提供完整的手势，只提供 运动/触摸 的初始位置。
+
+我们知道，正常情况下，如果初始点击位置在该视图区域之外，该视图根本不可能会收到事件，然而，万事万物都不是绝对的，肯定还有一些特殊情况，你可曾还记得点击 Dialog 区域外关闭吗？Dialog 就是一个特殊的视图(没有占满屏幕大小的窗口)，能够接收到视图区域外的事件(虽然在通常情况下你根本用不到这个事件)，除了 Dialog 之外，你最可能看到这个事件的场景是悬浮窗，当然啦，想要接收到视图之外的事件需要一些特殊的设置。
+
+> 设置视图的 WindowManager 布局参数的 flags为[`FLAG_WATCH_OUTSIDE_TOUCH`](http://developer.android.com/reference/android/view/WindowManager.LayoutParams.html#FLAG_WATCH_OUTSIDE_TOUCH)，这样点击事件发生在这个视图之外时，该视图就可以接收到一个 `ACTION_OUTSIDE` 事件。
+>
+> 参见StackOverflow：[How to dismiss the dialog with click on outside of the dialog?](http://stackoverflow.com/questions/8384067/how-to-dismiss-the-dialog-with-click-on-outside-of-the-dialog)
+
+由于这个事件用到的几率比较小，此处就不展开叙述了，以后用到的时候再详细讲解。
+
+
+
+## 多点触控
+
+Android 在 2.2 版本的时候开始支持多点触控，一旦出现了多点触控，很多东西就突然之间变得麻烦起来了，首先要解决的问题就是 **多个手指同时按在屏幕上，会产生很多的事件，这些事件该如何区分呢？**
+
+为了区分这些事件，工程师们用了一个很简单的办法－－**编号，当手指第一次按下时产生一个唯一的号码，手指抬起或者事件被拦截就回收编号，就这么简单。**
+
+**第一次按下的手指特殊处理作为主指针，之后按下的手指作为辅助指针**，然后随之衍生出来了以下事件(注意增加的事件和事件简介的变化)：
+
+| 事件 | 简介 |
+| --------------------------- | ------------------------------ |
+| ACTION_DOWN | **第一个** 手指 **初次接触到屏幕** 时触发。 |
+| ACTION_MOVE | 手指 **在屏幕上滑动** 时触发，会多次触发。 |
+| ACTION_UP | **最后一个** 手指 **离开屏幕** 时触发。 |
+| **ACTION_POINTER_DOWN** | 有非主要的手指按下(**即按下之前已经有手指在屏幕上**)。 |
+| **ACTION_POINTER_UP** | 有非主要的手指抬起(**即抬起之后仍然有手指在屏幕上**)。 |
+| 以下事件类型不推荐使用 | －－－－－－－－－－－－－－－－－－ |
+| ~~ACTION_POINTER\_1\_DOWN~~ | 第 2 个手指按下，已废弃，不推荐使用。 |
+| ~~ACTION_POINTER\_2\_DOWN~~ | 第 3 个手指按下，已废弃，不推荐使用。 |
+| ~~ACTION_POINTER\_3\_DOWN~~ | 第 4 个手指按下，已废弃，不推荐使用。 |
+| ~~ACTION_POINTER\_1\_UP~~ | 第 2 个手指抬起，已废弃，不推荐使用。 |
+| ~~ACTION_POINTER\_2\_UP~~ | 第 3 个手指抬起，已废弃，不推荐使用。 |
+| ~~ACTION_POINTER\_3\_UP~~ | 第 4 个手指抬起，已废弃，不推荐使用。 |
+
+和以下方法：
+
+| 方法 | 简介 |
+| ------------------------------- | ---------------------------------------- |
+| getActionMasked() | 与 `getAction()` 类似，**多点触控必须使用这个方法获取事件类型**。 |
+| getActionIndex() | 获取该事件是哪个指针(手指)产生的。 |
+| getPointerCount() | 获取在屏幕上手指的个数。 |
+| getPointerId(int pointerIndex) | 获取一个指针(手指)的唯一标识符ID，在手指按下和抬起之间ID始终不变。 |
+| findPointerIndex(int pointerId) | 通过PointerId获取到当前状态下PointIndex，之后通过PointIndex获取其他内容。 |
+| getX(int pointerIndex) | 获取某一个指针(手指)的X坐标 |
+| getY(int pointerIndex) | 获取某一个指针(手指)的Y坐标 |
+
+由于多点触控部分涉及内容比较多，也很复杂，我准备单独用一篇文章进行详细叙述，所以这里只叙述一些基础的内容作为铺垫：
+
+### getAction() 与 getActionMasked()
+
+当多个手指在屏幕上按下的时候，会产生大量的事件，如何在获取事件类型的同时区分这些事件就是一个大问题了。
+
+一般来说我们可以通过为事件添加一个int类型的index属性来区分，但是我们知道谷歌工程师是有洁癖的(在 [自定义View分类与流程][customview/CustomViewProcess] 的onMeasure中已经见识过了)，为了添加一个通常数值不会超过10的index属性就浪费一个int大小的空间简直是不能忍受的，于是工程师们将这个index属性和事件类型直接合并了。
+
+int类型共32位(0x00000000)，他们用最低8位(0x000000**ff**)表示事件类型，再往前的8位(0x0000**ff**00)表示事件编号，以手指按下为例讲解数值是如何合成的:
+
+> ACTION_DOWN 的默认数值为 (0x00000000)
+> ACTION_POINTER_DOWN 的默认数值为 (0x00000005)
+
+| 手指按下 | 触发事件(数值) |
+| :-----: | :--------------------------------------- |
+| 第1个手指按下 | ACTION_DOWN (0x0000**00**00) |
+| 第2个手指按下 | ACTION_POINTER_DOWN (0x0000**01**05) |
+| 第3个手指按下 | ACTION_POINTER_DOWN (0x0000**02**05) |
+| 第4个手指按下 | ACTION_POINTER_DOWN (0x0000**03**05) |
+
+**注意：**
+上面表格中用粗体标示出的数值，可以看到随着按下手指数量的增加，这个数值也是一直变化的，进而导致我们使用 `getAction()` 获取到的数值无法与标准的事件类型进行对比，为了解决这个问题，他们创建了一个 `getActionMasked()` 方法，这个方法可以清除index数值，让其变成一个标准的事件类型。
+**1、多点触控时必须使用 `getActionMasked()` 来获取事件类型。**
+**2、单点触控时由于事件数值不变，使用 `getAction()` 和 `getActionMasked()` 两个方法都可以。**
+**3、使用 getActionIndex() 可以获取到这个index数值。不过请注意，getActionIndex() 只在 down 和 up 时有效，move 时是无效的。**
+
+目前来说获取事件类型使用 `getActionMasked()` 就行了，但是如果一定要编译时兼容古董版本的话，可以考虑使用这样的写法:
+
+```java
+final int action = (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO)
+ ? event.getActionMasked()
+ : event.getAction();
+switch (action){
+ case MotionEvent.ACTION_DOWN:
+ // TODO
+ break;
+}
+```
+
+
+
+### PointId
+
+虽然前面刚刚说了一个 actionIndex，可以使用 getActionIndex() 获得，但通过 actionIndex 字面意思知道，这个只表示事件的序号，而且根据其说明文档解释，这个 ActionIndex 只有在手指按下(down)和抬起(up)时是有用的，在移动(move)时是没有用的，事件追踪非常重要的一环就是移动(move)，然而它却没卵用，这也太不实在了 (￣Д￣)ﾉ
+
+**郑重声明：追踪事件流，请认准 PointId，这是唯一官方指定标准，不要相信 ActionIndex 那个小婊砸。**
+
+PointId 在手指按下时产生，手指抬起或者事件被取消后消失，是一个事件流程中唯一不变的标识，可以在手指按下时 通过 `getPointerId(int pointerIndex)` 获得。 (参数中的 pointerIndex 就是 actionIndex)
+
+关于事件流的追踪等问题在讲解多点触控时再详细讲解。
+
+
+
+## 历史数据(批处理)
+
+由于我们的设备非常灵敏，手指稍微移动一下就会产生一个移动事件，所以移动事件会产生的特别频繁，为了提高效率，系统会将近期的多个移动事件(move)按照事件发生的顺序进行排序打包放在同一个 MotionEvent 中，与之对应的产生了以下方法：
+
+| 事件 | 简介 |
+| --------------------------------- | ---------------------------------------- |
+| getHistorySize() | 获取历史事件集合大小 |
+| getHistoricalX(int pos) | 获取第pos个历史事件x坐标
(pos < getHistorySize()) |
+| getHistoricalY(int pos) | 获取第pos个历史事件y坐标
(pos < getHistorySize()) |
+| getHistoricalX (int pin, int pos) | 获取第pin个手指的第pos个历史事件x坐标
(pin < getPointerCount(), pos < getHistorySize() ) |
+| getHistoricalY (int pin, int pos) | 获取第pin个手指的第pos个历史事件y坐标
(pin < getPointerCount(), pos < getHistorySize() ) |
+
+**注意：**
+
+1. pin 全称是 pointerIndex，表示第几个手指，此处为了节省空间使用了缩写。
+2. 历史数据只有 ACTION_MOVE 事件。
+3. 历史数据单点触控和多点触控均可以用。
+
+下面是官方文档给出的一个简单使用示例：
+
+```java
+void printSamples(MotionEvent ev) {
+ final int historySize = ev.getHistorySize();
+ final int pointerCount = ev.getPointerCount();
+ for (int h = 0; h < historySize; h++) {
+ System.out.printf("At time %d:", ev.getHistoricalEventTime(h));
+ for (int p = 0; p < pointerCount; p++) {
+ System.out.printf(" pointer %d: (%f,%f)",
+ ev.getPointerId(p), ev.getHistoricalX(p, h), ev.getHistoricalY(p, h));
+ }
+ }
+ System.out.printf("At time %d:", ev.getEventTime());
+ for (int p = 0; p < pointerCount; p++) {
+ System.out.printf(" pointer %d: (%f,%f)",
+ ev.getPointerId(p), ev.getX(p), ev.getY(p));
+ }
+}
+```
+
+
+
+## 获取事件发生的时间
+
+获取事件发生的时间。
+
+| 方法 | 简介 |
+| ------------------------------- | ------------ |
+| getDownTime() | 获取手指按下时的时间。 |
+| getEventTime() | 获取当前事件发生的时间。 |
+| getHistoricalEventTime(int pos) | 获取历史事件发生的时间。 |
+
+> 1. pos 表示历史数据中的第几个数据。( pos < getHistorySize() )
+> 2. 返回值类型为 long，单位是毫秒。
+
+## 获取压力(接触面积大小)
+
+MotionEvent支持获取某些输入设备(手指或触控笔)的与屏幕的接触面积和压力大小，主要有以下方法：
+
+> 描述中使用了手指，触控笔也是一样的。
+
+| 方法 | 简介 |
+| ---------------------------------------- | ---------------------------- |
+| getSize () | 获取第1个手指与屏幕接触面积的大小 |
+| getSize (int pin) | 获取第pin个手指与屏幕接触面积的大小 |
+| getHistoricalSize (int pos) | 获取历史数据中第1个手指在第pos次事件中的接触面积 |
+| getHistoricalSize (int pin, int pos) | 获取历史数据中第pin个手指在第pos次事件中的接触面积 |
+| getPressure () | 获取第一个手指的压力大小 |
+| getPressure (int pin) | 获取第pin个手指的压力大小 |
+| getHistoricalPressure (int pos) | 获取历史数据中第1个手指在第pos次事件中的压力大小 |
+| getHistoricalPressure (int pin, int pos) | 获取历史数据中第pin个手指在第pos次事件中的压力大小 |
+
+> 1. pin 全称是 pointerIndex，表示第几个手指。(pin < getPointerCount() )
+> 2. pos 表示历史数据中的第几个数据。( pos < getHistorySize() )
+
+**注意：**
+
+**1、获取接触面积大小和获取压力大小是需要硬件支持的。**
+**2、非常不幸的是大部分设备所使用的电容屏不支持压力检测，但能够大致检测出接触面积。**
+**3、大部分设备的 `getPressure()` 是使用接触面积来模拟的。**
+**4、由于某些未知的原因(可能系统版本和硬件问题)，某些设备不支持该方法。**
+
+我用不同的设备对这两个方法进行了测试，然而不同设备测试出来的结果不相同，之后经过我多方查证，发现是系统问题，有的设备上只有 `getSize()` 能用，有的设备上只有 `getPressure()` 能用，而有的则两个都不能用。
+
+**由于获取接触面积和获取压力大小受系统和硬件影响，使用的时候一定要进行数据检测，以防因为设备问题而导致程序出错。**
+
+
+
+## 鼠标事件
+
+由于触控笔事件和手指事件处理流程大致相同，所以就不讲解了，这里讲解一下与鼠标相关的几个事件：
+
+| 事件 | 简介 |
+| ------------------ | ---------------------------------------- |
+| ACTION_HOVER_ENTER | 指针移入到窗口或者View区域，但没有按下。 |
+| ACTION_HOVER_MOVE | 指针在窗口或者View区域移动，但没有按下。 |
+| ACTION_HOVER_EXIT | 指针移出到窗口或者View区域，但没有按下。 |
+| ACTION_SCROLL | 滚轮滚动，可以触发水平滚动(AXIS_HSCROLL)或者垂直滚动(AXIS_VSCROLL) |
+
+注意：
+
+1、这些事件类型是 安卓4.0 (API 14) 才添加的。
+2、使用 ` getActionMasked()` 获得这些事件类型。
+3、这些事件不会传递到 [onTouchEvent(MotionEvent)](https://developer.android.com/reference/android/view/View.html#onTouchEvent(android.view.MotionEvent)) 而是传递到 [onGenericMotionEvent(MotionEvent)](https://developer.android.com/reference/android/view/View.html#onGenericMotionEvent(android.view.MotionEvent)) 。
+
+
+
+## 输入设备类型判断
+
+输入设备类型判断也是安卓4.0 (API 14) 才添加的，主要包括以下几种设备：
+
+| 设备类型 | 简介 |
+| ----------------- | ---- |
+| TOOL_TYPE_ERASER | 橡皮擦 |
+| TOOL_TYPE_FINGER | 手指 |
+| TOOL_TYPE_MOUSE | 鼠标 |
+| TOOL_TYPE_STYLUS | 手写笔 |
+| TOOL_TYPE_UNKNOWN | 未知类型 |
+
+**使用 `getToolType(int pointerIndex)` 来获取对应的输入设备类型，pointIndex可以为0，但必须小于 `getPointerCount()`。**
+
+
+
+## 总结
+
+虽然本文标题是 MotionEvent 详解，但由于 MotionEvent 实在太庞大了，本文只能涉及一些比较常用的内容，某些不太常用的内容就在以后用到的时候再详细介绍吧，像游戏手柄等输入设备由于我暂时不做游戏开发，也没有过多了解，所以就不介绍给大家啦。
+
+由于个人水平有限，文章中可能会出现错误，如果你觉得哪一部分有错误，或者发现了错别字等内容，欢迎在评论区告诉我，另外，据说关注 [作者微博](http://weibo.com/GcsSloop) 不仅能第一时间收到新文章消息，还能变帅哦。
+
+
+
+## 参考资料
+
+[MotionEvent ](https://developer.android.com/reference/android/view/MotionEvent.html)
+[Android MotionEvent详解](http://www.jianshu.com/p/0c863bbde8eb)
+
+
+
+## About Me
+
+### 作者微博: @GcsSloop
+
+
+
+
+
+[customview/CoordinateSystem]: http://www.gcssloop.com/customview/CoordinateSystem "安卓自定义View基础-坐标系"
+[customview/CustomViewProcess]: http://www.gcssloop.com/customview/CustomViewProcess "安卓自定义View进阶-分类与流程"
+[customview/dispatch-touchevent-theory]: http://www.gcssloop.com/customview/dispatch-touchevent-theory "安卓自定义View进阶-事件分发机制原理"
+[customview/dispatch-touchevent-source]: http://www.gcssloop.com/customview/dispatch-touchevent-source "安卓自定义View进阶-事件分发机制详解"
diff --git a/CustomView/Advance/[17]touch-matrix-region.md b/CustomView/Advance/[17]touch-matrix-region.md
new file mode 100644
index 00000000..cf23d6cb
--- /dev/null
+++ b/CustomView/Advance/[17]touch-matrix-region.md
@@ -0,0 +1,579 @@
+# 特殊控件的事件处理方案
+
+本文带大家了解 Android 特殊形状控件的事件处理方式，主要是利用了 Region 和 Matrix 的一些方法，超级实用的事件处理方案，相信看完本篇之后，任何奇葩控件的事件处理都会变得十分简单。
+
+不得不说，Android 对事件体系封装的非常棒，即便对事件体系不太了解的人，只要简单的调用方法就能使用，而且具有防呆设计，能够保证事件流的完整性和统一性，最大可能性的避免了事件处理的混乱，着实令人佩服。
+**然而世界上并没有绝对完美的东西，当"事件处理"遇上"自定义View"，一场好戏就开演了。**
+
+## 特殊形状控件
+
+在通常的情况下，自定义 View 直接使用系统的事件体系处理就行，我们也不需要特殊处理，然而当一些特殊的控件出现的时候，麻烦就来了，举个栗子：
+
+
+
+这是一个在遥控器上非常常见的按键布局，注意中间上下左右选择的部分，看起来十分简单，然而当你真正准备在手机上实现的时候麻烦就出现了。因为所有的 View 默认都是矩形的，所以事件接收区域也是矩形的，如果直接使用系统提供的 View 来组合出一摸一样的布局也很简单，但点击区域该如何处理？显然有部分点击区域是在控件外面的，并且会产生重叠区域：
+
+> 红色方框表示 View 的可点击区域。
+
+
+
+当我们面对这样比较奇特的控件的时候，有很多处理办法，比较投机的一种就是背景贴一个静态图，按钮做成透明的，设置小一点，放在对应的位置，这样可以保证不会误触，当然了如果想要点击效果可以在按钮按下的时候更新一下背景图，这样虽然也可以，但是这样会导致可点击区域变小，体验效果变差，设计方案变得复杂，而且逻辑也不容易处理，是一种非常糟糕的设计。
+
+当然了，看了我这么多文章的小伙伴应该也猜到接下来要说什么了，没错，就是自定义 View。当我们面对一些奇葩控件的时候，自定义 View 就变成了一种非常好用的处理方案。
+
+相信小伙伴们看过 [前面的文章][CustomViewIndex] 之后，对各种图形的绘制已经不成问题了，所以我们直接处理重点问题。
+
+> #### 注意：
+>
+> 本文中所有的 自定义View 均继承自 CustomView ，这是一个自定义的超类，目的是简化 自定义View 部分常用操作，你可以在 [ViewSupport](https://github.com/GcsSloop/ViewSupport/wiki/CustomView) 中找到它以及关于它的简介。
+> **⚠️ 警告：测试本文章示例之前请关闭硬件加速。**
+
+## 特殊形状控的点击区域判断
+
+要进行特殊形状的点击判断，要用到一个之前没有使用过的类：Region。
+
+Region 直接翻译的意思是 地域，区域。**在此处应该是区域的意思**。它和 Path 有些类似，但 Path 可以是不封闭图形，而 Region 总是封闭的。可以通过 `setPath` 方法将 Path 转换为 Region。
+
+ **本文中我们重点要使用到的是 Region 中的 `contains` 方法，这个方法可以判断一个点是否包含在该区域内。**
+
+接下来是一个简单的示例，**判断手指是否是在圆形区域内按下**:
+
+
+
+代码：
+
+```java
+public class RegionClickView extends CustomView {
+ Region circleRegion;
+ Path circlePath;
+
+ public RegionClickView(Context context) {
+ super(context);
+ mDeafultPaint.setColor(0xFF4E5268);
+ circlePath = new Path();
+ circleRegion = new Region();
+ }
+
+ @Override
+ protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+ super.onSizeChanged(w, h, oldw, oldh);
+ // ▼在屏幕中间添加一个圆
+ circlePath.addCircle(w/2, h/2, 300, Path.Direction.CW);
+ // ▼将剪裁边界设置为视图大小
+ Region globalRegion = new Region(-w, -h, w, h);
+ // ▼将 Path 添加到 Region 中
+ circleRegion.setPath(circlePath, globalRegion);
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ switch (event.getAction()){
+ case MotionEvent.ACTION_DOWN:
+ int x = (int) event.getX();
+ int y = (int) event.getY();
+
+ // ▼点击区域判断
+ if (circleRegion.contains(x,y)){
+ Toast.makeText(this.getContext(),"圆被点击",Toast.LENGTH_SHORT).show();
+ }
+ break;
+ }
+ return true;
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ // ▼注意此处将全局变量转化为局部变量，方便 GC 回收 canvas
+ Path circle = circlePath;
+ // 绘制圆
+ canvas.drawPath(circle,mDeafultPaint);
+ }
+}
+```
+
+> 代码中比较重要的内容都用 ▼ 符号标记出来了。
+
+上述代码非常简单，就是创建了个 Path 并在其中添加圆形，之后将 Path 设置到 Region 中，当手指在屏幕上按下的时候判断手指位置是否在 Region 区域内。
+
+
+
+## 画布变换后坐标转换问题
+
+还是本文一开始的例子，绘制一个上下左右选择按键，这个控件是上下左右对称的，熟悉我代码风格的小伙伴都知道，如果遇上这种问题，我肯定是要将坐标系平移到这个控件中心的，这样数据比较好计算，然而进行画布变换操作会产生一个新问题：**手指触摸的坐标系和画布坐标系不统一，就可能引起手指触摸位置和绘制位置不统一。**
+
+举个栗子：
+
+> 画布移动后在手指按下位置绘制一个圆，可以看到，直接拿手指触摸位置的坐标来绘制会导致绘制位置不正确，**两者坐标是相同的，但是由于坐标系不同，导致实际显示位置不同。**
+
+
+
+代码：
+
+```java
+public class CanvasVonvertTouchTest extends CustomView{
+ float down_x = -1;
+ float down_y = -1;
+
+ public CanvasVonvertTouchTest(Context context) {
+ this(context, null);
+ }
+
+ public CanvasVonvertTouchTest(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ switch (event.getActionMasked()){
+ case MotionEvent.ACTION_DOWN:
+ case MotionEvent.ACTION_MOVE:
+ down_x = event.getX();
+ down_y = event.getY();
+ invalidate();
+ break;
+
+ case MotionEvent.ACTION_CANCEL:
+ case MotionEvent.ACTION_UP:
+ down_x = down_y = -1;
+ invalidate();
+ break;
+ }
+
+ return true;
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ float x = down_x;
+ float y = down_y;
+
+ drawTouchCoordinateSpace(canvas); // 绘制触摸坐标系 灰色
+
+ // ▼注意画布平移
+ canvas.translate(mViewWidth/2, mViewHeight/2);
+
+ drawTranslateCoordinateSpace(canvas); // 绘制平移后的坐标系，红色
+
+ if (x == -1 && y == -1) return; // 如果没有就返回
+
+ canvas.drawCircle(x,y,20,mDeafultPaint); // 在触摸位置绘制一个小圆
+ }
+
+ /**
+ * 绘制触摸坐标系，灰色，为了能够显示出坐标系，将坐标系位置稍微偏移了一点
+ */
+ private void drawTouchCoordinateSpace(Canvas canvas) {
+ canvas.save();
+ canvas.translate(10,10);
+ CanvasAidUtils.set2DAxisLength(1000, 0, 1400, 0);
+ CanvasAidUtils.setLineColor(Color.GRAY);
+ CanvasAidUtils.draw2DCoordinateSpace(canvas);
+ canvas.restore();
+ }
+
+ /**
+ * 绘制平移后的坐标系，红色
+ */
+ private void drawTranslateCoordinateSpace(Canvas canvas) {
+ CanvasAidUtils.set2DAxisLength(500, 500, 700, 700);
+ CanvasAidUtils.setLineColor(Color.RED);
+ CanvasAidUtils.draw2DCoordinateSpace(canvas);
+ CanvasAidUtils.draw2DCoordinateSpace(canvas);
+ }
+}
+```
+
+**那么问题来了，我们在之前的文章中讲过，映射不同坐标系的坐标用 什么来着？**
+**是 Matrix。**
+
+如果看过我之前的文章但没有想起来的说明你们根本没有认真看，全部拖出去糟蹋 5 分钟！
+没看过的点 [Matrix原理][Matrix_Basic] 和 [Matrix详解][Matrix_Method] 。
+
+> **Matrix 是一个矩阵，主要功能是坐标映射，数值转换。**
+
+那么接下来我们就对上面的示例进行简单的改造一下，让触摸位置和实际绘制绘制重合。小白点和黑色的圆没有完全重合是因为系统显示触摸位置的绘制逻辑和我使用的绘制逻辑不太相同导致的。
+
+
+
+代码：
+
+**注意：比较重要的修改位置用▼标记出来了。**
+
+```java
+public class CanvasVonvertTouchTest extends CustomView{
+ float down_x = -1;
+ float down_y = -1;
+
+ public CanvasVonvertTouchTest(Context context) {
+ this(context, null);
+ }
+
+ public CanvasVonvertTouchTest(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ switch (event.getActionMasked()){
+ case MotionEvent.ACTION_DOWN:
+ case MotionEvent.ACTION_MOVE:
+ // ▼ 注意此处使用 getRawX，而不是 getX
+ down_x = event.getRawX();
+ down_y = event.getRawY();
+ invalidate();
+ break;
+
+ case MotionEvent.ACTION_CANCEL:
+ case MotionEvent.ACTION_UP:
+ down_x = down_y = -1;
+ invalidate();
+ break;
+ }
+
+ return true;
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ float[] pts = {down_x, down_y};
+
+ drawTouchCoordinateSpace(canvas); // 绘制触摸坐标系，灰色
+ // ▼注意画布平移
+ canvas.translate(mViewWidth/2, mViewHeight/2);
+
+ drawTranslateCoordinateSpace(canvas); // 绘制平移后的坐标系，红色
+
+ if (pts[0] == -1 && pts[1] == -1) return; // 如果没有就返回
+
+ // ▼ 获得当前矩阵的逆矩阵
+ Matrix invertMatrix = new Matrix();
+ canvas.getMatrix().invert(invertMatrix);
+
+ // ▼ 使用 mapPoints 将触摸位置转换为画布坐标
+ invertMatrix.mapPoints(pts);
+
+ // 在触摸位置绘制一个小圆
+ canvas.drawCircle(pts[0],pts[1],20,mDeafultPaint);
+ }
+
+ /**
+ * 绘制触摸坐标系，颜色为灰色，为了能够显示出坐标系，将坐标系位置稍微偏移了一点
+ */
+ private void drawTouchCoordinateSpace(Canvas canvas) {
+ canvas.save();
+ canvas.translate(10,10);
+ CanvasAidUtils.set2DAxisLength(1000, 0, 1400, 0);
+ CanvasAidUtils.setLineColor(Color.GRAY);
+ CanvasAidUtils.draw2DCoordinateSpace(canvas);
+ canvas.restore();
+ }
+
+ /**
+ * 绘制平移后的坐标系，颜色为红色
+ */
+ private void drawTranslateCoordinateSpace(Canvas canvas) {
+ CanvasAidUtils.set2DAxisLength(500, 500, 700, 700);
+ CanvasAidUtils.setLineColor(Color.RED);
+ CanvasAidUtils.draw2DCoordinateSpace(canvas);
+ CanvasAidUtils.draw2DCoordinateSpace(canvas);
+ }
+}
+```
+
+其实核心部分就这两点：
+
+```java
+// ▼ 注意此处使用 getRawX，而不是 getX
+down_x = event.getRawX();
+down_y = event.getRawY();
+
+// -------------------------------------
+
+// ▼ 获得当前矩阵的逆矩阵
+Matrix invertMatrix = new Matrix();
+canvas.getMatrix().invert(invertMatrix);
+
+// ▼ 使用 mapPoints 将触摸位置转换为画布坐标
+invertMatrix.mapPoints(pts);
+```
+
+1. 使用全局坐标系
+2. 使用逆矩阵的 mapPoints
+
+**原理嘛，其实非常简单，我们在画布上正常的绘制，需要将画布坐标系转换为全局坐标系后才能真正的绘制内容。所以我们反着来，将获得到的全局坐标系坐标使用当前画布的逆矩阵转化一下，就转化为当前画布的坐标系坐标了，如果对 [Matrix原理][Matrix_Basic] 和 [Matrix详解][Matrix_Method] 理解了，即便我不说你们也肯定会想到这个方案的。**
+
+## 仿遥控器按钮代码示例
+
+在解决了上述两大难题之后，相信不论形状如何奇葩的自定义控件，基本上都难不倒大家了，最后用一个简单的示例作为结尾，还是文章开头所举的例子，核心内容就是上面讲的两个东西。
+
+
+
+代码：
+
+```java
+public class RemoteControlMenu extends CustomView {
+ Path up_p, down_p, left_p, right_p, center_p;
+ Region up, down, left, right, center;
+
+ Matrix mMapMatrix = null;
+
+ int CENTER = 0;
+ int UP = 1;
+ int RIGHT = 2;
+ int DOWN = 3;
+ int LEFT = 4;
+ int touchFlag = -1;
+ int currentFlag = -1;
+
+ MenuListener mListener = null;
+
+ int mDefauColor = 0xFF4E5268;
+ int mTouchedColor = 0xFFDF9C81;
+
+
+ public RemoteControlMenu(Context context) {
+ this(context, null);
+ }
+
+ public RemoteControlMenu(Context context, AttributeSet attrs) {
+ super(context, attrs);
+
+ up_p = new Path();
+ down_p = new Path();
+ left_p = new Path();
+ right_p = new Path();
+ center_p = new Path();
+
+ up = new Region();
+ down = new Region();
+ left = new Region();
+ right = new Region();
+ center = new Region();
+
+ mDeafultPaint.setColor(mDefauColor);
+ mDeafultPaint.setAntiAlias(true);
+
+ mMapMatrix = new Matrix();
+
+ }
+
+ @Override
+ protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+ super.onSizeChanged(w, h, oldw, oldh);
+ mMapMatrix.reset();
+
+ // 注意这个区域的大小
+ Region globalRegion = new Region(-w, -h, w, h);
+ int minWidth = w > h ? h : w;
+ minWidth *= 0.8;
+
+ int br = minWidth / 2;
+ RectF bigCircle = new RectF(-br, -br, br, br);
+
+ int sr = minWidth / 4;
+ RectF smallCircle = new RectF(-sr, -sr, sr, sr);
+
+ float bigSweepAngle = 84;
+ float smallSweepAngle = -80;
+
+ // 根据视图大小，初始化 Path 和 Region
+ center_p.addCircle(0, 0, 0.2f * minWidth, Path.Direction.CW);
+ center.setPath(center_p, globalRegion);
+
+ right_p.addArc(bigCircle, -40, bigSweepAngle);
+ right_p.arcTo(smallCircle, 40, smallSweepAngle);
+ right_p.close();
+ right.setPath(right_p, globalRegion);
+
+ down_p.addArc(bigCircle, 50, bigSweepAngle);
+ down_p.arcTo(smallCircle, 130, smallSweepAngle);
+ down_p.close();
+ down.setPath(down_p, globalRegion);
+
+ left_p.addArc(bigCircle, 140, bigSweepAngle);
+ left_p.arcTo(smallCircle, 220, smallSweepAngle);
+ left_p.close();
+ left.setPath(left_p, globalRegion);
+
+ up_p.addArc(bigCircle, 230, bigSweepAngle);
+ up_p.arcTo(smallCircle, 310, smallSweepAngle);
+ up_p.close();
+ up.setPath(up_p, globalRegion);
+
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ float[] pts = new float[2];
+ pts[0] = event.getRawX();
+ pts[1] = event.getRawY();
+ mMapMatrix.mapPoints(pts);
+
+ int x = (int) pts[0];
+ int y = (int) pts[1];
+
+ switch (event.getActionMasked()) {
+ case MotionEvent.ACTION_DOWN:
+ touchFlag = getTouchedPath(x, y);
+ currentFlag = touchFlag;
+ break;
+ case MotionEvent.ACTION_MOVE:
+ currentFlag = getTouchedPath(x, y);
+ break;
+ case MotionEvent.ACTION_UP:
+ currentFlag = getTouchedPath(x, y);
+ // 如果手指按下区域和抬起区域相同且不为空，则判断点击事件
+ if (currentFlag == touchFlag && currentFlag != -1 && mListener != null) {
+ if (currentFlag == CENTER) {
+ mListener.onCenterCliched();
+ } else if (currentFlag == UP) {
+ mListener.onUpCliched();
+ } else if (currentFlag == RIGHT) {
+ mListener.onRightCliched();
+ } else if (currentFlag == DOWN) {
+ mListener.onDownCliched();
+ } else if (currentFlag == LEFT) {
+ mListener.onLeftCliched();
+ }
+ }
+ touchFlag = currentFlag = -1;
+ break;
+ case MotionEvent.ACTION_CANCEL:
+ touchFlag = currentFlag = -1;
+ break;
+ }
+
+ invalidate();
+ return true;
+ }
+
+ // 获取当前触摸点在哪个区域
+ int getTouchedPath(int x, int y) {
+ if (center.contains(x, y)) {
+ return 0;
+ } else if (up.contains(x, y)) {
+ return 1;
+ } else if (right.contains(x, y)) {
+ return 2;
+ } else if (down.contains(x, y)) {
+ return 3;
+ } else if (left.contains(x, y)) {
+ return 4;
+ }
+ return -1;
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ super.onDraw(canvas);
+ canvas.translate(mViewWidth / 2, mViewHeight / 2);
+
+ // 获取测量矩阵(逆矩阵)
+ if (mMapMatrix.isIdentity()) {
+ canvas.getMatrix().invert(mMapMatrix);
+ }
+
+ // 绘制默认颜色
+ canvas.drawPath(center_p, mDeafultPaint);
+ canvas.drawPath(up_p, mDeafultPaint);
+ canvas.drawPath(right_p, mDeafultPaint);
+ canvas.drawPath(down_p, mDeafultPaint);
+ canvas.drawPath(left_p, mDeafultPaint);
+
+ // 绘制触摸区域颜色
+ mDeafultPaint.setColor(mTouchedColor);
+ if (currentFlag == CENTER) {
+ canvas.drawPath(center_p, mDeafultPaint);
+ } else if (currentFlag == UP) {
+ canvas.drawPath(up_p, mDeafultPaint);
+ } else if (currentFlag == RIGHT) {
+ canvas.drawPath(right_p, mDeafultPaint);
+ } else if (currentFlag == DOWN) {
+ canvas.drawPath(down_p, mDeafultPaint);
+ } else if (currentFlag == LEFT) {
+ canvas.drawPath(left_p, mDeafultPaint);
+ }
+ mDeafultPaint.setColor(mDefauColor);
+ }
+
+ public void setListener(MenuListener listener) {
+ mListener = listener;
+ }
+
+ // 点击事件监听器
+ public interface MenuListener {
+ void onCenterCliched();
+
+ void onUpCliched();
+
+ void onRightCliched();
+
+ void onDownCliched();
+
+ void onLeftCliched();
+ }
+}
+```
+
+**运行效果:**
+
+当手指在某一区域活动时，该区域会高亮显示，如果注册了监听器，点击某一区域会触发监听器回调。
+
+
+
+## 关于硬件加速的问题
+
+**硬件加速是个好东西，但是处理不好会引起诸多问题，博主为了怕麻烦我一直关闭硬件加速。**
+
+然而硬件加速在 Android 4.0 以上是默认开启的，这就导致了有好几位魔法师反馈测试结果和我的测试结果不同，我来简单说明一下硬件加速干了什么事情，以及这些文章中的锅是如何产生的，应该由谁来背。
+
+我在 [Matrix 原理][Matrix_Basic] 中说过 Matrix 的作用： **Matrix作用就是坐标映射。**
+其核心功能就是将单个 View 的坐标系转化为屏幕(物理)坐标系，虽然转换一次费不了多少时间，但是当执行动画效果等需要大量快速重绘的情况下，耗费的时间就需要考量一下了，于是乎，硬件加速干了一件非常**精明**的事情，**把所有画布坐标系都设置为屏幕(物理)坐标系**，之后在 View 绘制区域设置一个遮罩，保证绘制内容不会超过 View 自身的大小，**这样就直接跳过坐标转换过程，可以节省坐标系之间数值转换耗费的时间**。因此导致了以下问题：
+
+1. 开启硬件加速情况下 event.getX() 和 不开启情况下 event.getRawX() 等价，获取到的是屏幕(物理)坐标 (本文的锅)。
+2. 开启硬件加速情况下 event.getRawX() 数值是一个错误数值，因为本身就是全局的坐标又叠加了一次 View 的偏移量，所以肯定是不正确的 (本文的锅)。
+3. 从 Canvas 获取到的 Matrix 是全局的，默认情况下 x,y 偏移量始终为0，因此你不能从这里拿到当前 View 的偏移量 ( Matrix系列文章中的锅 )。
+4. 由于其使用的是遮罩来控制绘制区域，所以如果重绘 path 时，如果 path 区域变大，但没有执行单步操作会导致 path 绘制不完整或者看起来比较奇怪 (Path系列文章中的锅)。
+
+很显然，这个硬件加速有点6，制造了各种锅想让我来背，然而智慧的我早已看穿一切，默默的把硬件加速关闭了，因为我不知道它还有多少锅没亮出来。
+
+**这里顺便挖个坑，等我搞明白硬件加速扔锅的逻辑之后，专门写一篇硬件加速的文章，把硬件加速的锅全埋进去，再也不背这口大黑锅了**。
+**(╯°Д°）╯︵ ┻━┻**
+
+
+
+**个人建议：**
+
+1. APP全局关闭硬件加速。
+2. 针对动画较多的 Activity 或者 View 单独开启硬件加速。
+3. 如果应用要兼容到 3.0 以下，不要使用硬件加速的特性，或者进行兼容处理。
+4. 如果 自定义View 出现与绘图相关的异常，请务必检查一下硬件加速。
+5. 如果想关掉硬件加速看这里： [Android如何关闭硬件加速](https://github.com/GcsSloop/AndroidNote/issues/7) 。
+
+
+
+## 总结
+
+本文虽然代码比较多，但核心概念非常简单，主要涉及以下两点：
+
+1. Region 的区域检测。
+2. Matrix 的坐标映射。
+
+**这两个知识点都不是很难，然而灵活运用起来却是非常强大的，如果有对 Matrix 不了解的小伙伴，推荐去看我 [之前的文章][CustomViewIndex]，里面有关于Matrix的详细介绍，**
+
+
+
+## About Me
+
+### 作者微博: @GcsSloop
+
+
+
+
+
+[CustomViewIndex]: http://www.gcssloop.com/customview/CustomViewIndex
+[Matrix_Basic]: http://www.gcssloop.com/customview/Matrix_Basic
+[Matrix_Method]: http://www.gcssloop.com/customview/Matrix_Method
+
+
+
diff --git a/CustomView/Advance/[18]multi-touch.md b/CustomView/Advance/[18]multi-touch.md
new file mode 100644
index 00000000..98efa326
--- /dev/null
+++ b/CustomView/Advance/[18]multi-touch.md
@@ -0,0 +1,613 @@
+# Android 多点触控详解
+
+Android 多点触控详解，在前面的几篇文章中我们大致了解了 Android 中的事件处理流程和一些简单的处理方案，本次带大家了解 Android 多点触控相关的一些知识。
+
+**多点触控** ( **Multitouch**，也称 **Multi-touch** )，即同时接受屏幕上多个点的人机交互操作，多点触控是从 Android 2.0 开始引入的功能，在 Android 2.2 时对这一部分进行了重新设计。
+
+在本文开始之前，先回顾一下 [MotionEvent详解][motionevent] 中提到过的内容：
+
+- Android 将所有的事件都封装进了 `Motionvent` 中。
+- 我们可以通过复写 `onTouchEvent` 或者设置 `OnTouchListener` 来获取 View 的事件。
+- 多点触控获取事件类型请使用 `getActionMasked()` 。
+- 追踪事件流请使用 `PointId`。
+
+**多点触控相关的事件：**
+
+| 事件 | 简介 |
+| --------------------------- | ------------------------------ |
+| ACTION_DOWN | **第一个** 手指 **初次接触到屏幕** 时触发。 |
+| ACTION_MOVE | 手指 **在屏幕上滑动** 时触发，会多次触发。 |
+| ACTION_UP | **最后一个** 手指 **离开屏幕** 时触发。 |
+| **ACTION_POINTER_DOWN** | 有非主要的手指按下(**即按下之前已经有手指在屏幕上**)。 |
+| **ACTION_POINTER_UP** | 有非主要的手指抬起(**即抬起之后仍然有手指在屏幕上**)。 |
+| 以下事件类型不推荐使用 | －－－以下事件在 2.2 版本以上被标记为废弃－－－ |
+| ~~ACTION_POINTER\_1\_DOWN~~ | 第 2 个手指按下，已废弃，不推荐使用。 |
+| ~~ACTION_POINTER\_2\_DOWN~~ | 第 3 个手指按下，已废弃，不推荐使用。 |
+| ~~ACTION_POINTER\_3\_DOWN~~ | 第 4 个手指按下，已废弃，不推荐使用。 |
+| ~~ACTION_POINTER\_1\_UP~~ | 第 2 个手指抬起，已废弃，不推荐使用。 |
+| ~~ACTION_POINTER\_2\_UP~~ | 第 3 个手指抬起，已废弃，不推荐使用。 |
+| ~~ACTION_POINTER\_3\_UP~~ | 第 4 个手指抬起，已废弃，不推荐使用。 |
+
+**多点触控相关的方法：**
+
+| 方法 | 简介 |
+| ------------------------------- | ---------------------------------------- |
+| getActionMasked() | 与 `getAction()` 类似，**多点触控需要使用这个方法获取事件类型**。 |
+| getActionIndex() | 获取该事件是哪个指针(手指)产生的。 |
+| getPointerCount() | 获取在屏幕上手指的个数。 |
+| getPointerId(int pointerIndex) | 获取一个指针(手指)的唯一标识符ID，在手指按下和抬起之间ID始终不变。 |
+| findPointerIndex(int pointerId) | 通过PointerId获取到当前状态下PointIndex，之后通过PointIndex获取其他内容。 |
+| getX(int pointerIndex) | 获取某一个指针(手指)的X坐标 |
+| getY(int pointerIndex) | 获取某一个指针(手指)的Y坐标 |
+
+回顾完毕，开始正文。
+
+
+
+## 一、多点触控相关问题
+
+在引入多点触控之前，事件的类型很少，基本事件类型只有按下(down)、移动(move) 和 抬起(up)，即便加上那些特殊的事件类型也只有几种而已，所以我们可以用几个常量来标记这些事件，在使用的时候使用 `getAction()` 方法来获取具体的事件，之后和这些常量进行对比就行了。
+
+在 Android 2.0 版本的时候，开始引入多点触控技术，由于技术上并不成熟，硬件和驱动也跟不上，多数设备只能支持追踪两三个点而已，因此在设计 API 上采取了一种简单粗暴的方案，添加了几个常量用于多点触控的事件类型的判断。
+
+| 事件 | 简介 |
+| ----------------------- | -------------------- |
+| ACTION_POINTER\_1\_DOWN | 第 2 个手指按下，已废弃，不推荐使用。 |
+| ACTION_POINTER\_2\_DOWN | 第 3 个手指按下，已废弃，不推荐使用。 |
+| ACTION_POINTER\_3\_DOWN | 第 4 个手指按下，已废弃，不推荐使用。 |
+| ACTION_POINTER\_1\_UP | 第 2 个手指抬起，已废弃，不推荐使用。 |
+| ACTION_POINTER\_2\_UP | 第 3 个手指抬起，已废弃，不推荐使用。 |
+| ACTION_POINTER\_3\_UP | 第 4 个手指抬起，已废弃，不推荐使用。 |
+
+这些事件类型是用来判断非主要手指(第一个按下的称为主要手指)的按下和抬起，使用起来大概是这样子：
+
+```java
+switch (event.getAction()) {
+ case MotionEvent.ACTION_DOWN: break;
+ case MotionEvent.ACTION_UP: break;
+ case MotionEvent.ACTION_MOVE: break;
+ case MotionEvent.ACTION_POINTER_1_DOWN: break;
+ case MotionEvent.ACTION_POINTER_2_DOWN: break;
+ case MotionEvent.ACTION_POINTER_3_DOWN: break;
+ case MotionEvent.ACTION_POINTER_1_UP: break;
+ case MotionEvent.ACTION_POINTER_2_UP: break;
+ case MotionEvent.ACTION_POINTER_3_UP: break;
+}
+```
+
+看到这里可能会产生以下的一些疑问？
+
+### 1.为什么没有 ACTION_POINTER_X_MOVE ?
+
+在多指触控中所有的移动事件都是使用 `ACTION_MOVE`， 并没有追踪某一个手指的 move 事件类型，个人猜测主要是因为：**很难无歧义的实现单独追踪每一个手指。**
+
+要理解这个，首先要明白设备是如何识别多点触控的，设备没有眼睛，不能像我们人一样看到有几个手指(或者触控笔)在屏幕上。
+目前大多数 Android 设备都是电容屏，它们感知触摸是利用手指(触控笔)与屏幕接触产生的微小电流变化，之后通过计算这些电流变化来得出具体的触摸位置，在多点触控中，当两个触摸点足够靠近时，设备实际上是无法分清这两个点的。因此当两个触摸点靠近(重合)后再分开，设备很可能就无法正确的追踪两个点了，所以也很难实现无歧义的追踪每一个点。
+
+并且从软件上来说，事件的编号产生和复用也是一个大问题，例如下面的场景：
+
+| 事件 | 手指数量 | 编号变化 |
+| ------------ | :--: | ------------------------- |
+| 一个手指按下(命名为A) | 1 | A手指的编号为0，id为0 |
+| 一个手指按下(命名为B) | 2 | B手指的编号为1，id为1 |
+| A手指抬起 | 1 | B手指编号变更为0，id不变为1 |
+| 一个手指按下(命名为C) | 2 | C手指编号为0，id为0，B手指编号为1，id为1 |
+
+注意观察上面编号和id的变化，有两个问题，**1、B手指的编号变化了。2、A手指和C手指id是相同的(A手指抬起后，C手指按下替代了A手指)。**所以这就引出了一个问题：如果存在 ACTION_POINTER_X_MOVE，那么X应该用什么标志呢？编号会变化，id虽然不会变化，但id会被复用，例如A手指抬起后C手指按下，C手指复用了A手指的id。所以不论使用哪一个都不能保证唯一性。
+
+当然了，解决问题最好的方式就是把问题抛出去，既然从硬件和软件上都不能保证唯一性和不变性，就不做区分了，因此所有的 move 事件都是 `ACTION_MOVE`, 具体是哪个手指产生的 move 用户可以结合其他事件(按下和抬起)来综合判断。
+
+### 2.超过4个手指怎么办？
+
+**2.0 兼容版**，在2.2 之前的设计中，其提供的常量最多能判断四个手指的抬起和落下，当超过四个手指时怎么办呢？
+
+由于在 2.2 版本之前，由于没有 `getActionMasked` 方法，我们可以自己自己手动进行计算，例如下面这样 ：
+
+```java
+String TAG = "Gcs";
+
+int action = event.getAction() & MotionEvent.ACTION_MASK;
+int index = (event.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK)
+ >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
+
+switch (action) {
+ case MotionEvent.ACTION_DOWN:
+ Log.e(TAG,"第1个手指按下");
+ break;
+ case MotionEvent.ACTION_UP:
+ Log.e(TAG,"最后1个手指抬起");
+ break;
+ case MotionEvent.ACTION_POINTER_1_DOWN: // 此时相当于 ACTION_POINTER_DOWN
+ Log.e(TAG,"第"+(index+1)+"个手指按下");
+ break;
+ case MotionEvent.ACTION_POINTER_1_UP: // 此时相当于 ACTION_POINTER_UP
+ Log.e(TAG,"第"+(index+1)+"个手指抬起");
+ break;
+}
+```
+
+在上面的例子中有几点比较关键：
+
+#### 2.1、action 与 Index 的获得
+
+我们在 [MotionEvent详解][motionevent] 中了解过，Android中的事件一般用最后8位来表示事件类型，再往前8位来表示Index。
+
+例如多指触控的按下事件，其事件类型是 0x000000**05**， 其Index标志位是 0x0000**00**05，随着更多的手指按下，其中变化的部分是 Index 标志位，最后两位是始终不变的，所以我们只要能将这两个分离开就行了。
+
+**取得事件类型(action)**
+
+```java
+// 获取事件类型
+int action = event.getAction() & MotionEvent.ACTION_MASK;
+```
+
+这个非常简单，ACTION_MASK=0x000000ff， 与 getAction() 进行按位与操作后保留最后8位内容(十六进制每一个字符转化为二进制是4位)。
+
+例如：
+0x000001**05** & 0x000000ff = 0x000000**05**
+
+**取得事件索引(index)**
+
+```java
+// 获取index编号
+int index = (event.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK)
+ >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
+```
+
+ACTION_POINTER_INDEX_MASK = 0x0000ff00
+ACTION_POINTER_INDEX_SHIFT = 8
+首先让 getAction() 与 ACTION_POINTER_INDEX_MASK 按位与之后，只保留 Index 那8位，之后再右移8位，最终就拿到了 Index 的真实数值。
+
+例如：
+0x0000**01**05 & 0x0000ff00 = 0x0000**01**00
+0x0000**01**00 >> 8 = 0x000000**01**
+
+#### 2.2、用 ACTION\_POINTER\_1\_DOWN 代替 ACTION\_POINTER\_DOWN
+
+这是因为在 2.0 版本的时候还没有 ACTION\_POINTER\_DOWN 的这个常量，但是它们两个点数值是相同的，都是 0x00000005，这个你可以查看官方文档或者源码，甚至你直接写 `case 0x00000005` 也行，抬起也是同理。
+
+#### 2.3、只考虑兼容 2.2 以上的版本
+
+当然了，如果你不需要兼容 2.0 版本，只需要兼容到 2.2 以上的话就很简单了，像下面这样：
+
+```java
+String TAG = "Gcs";
+
+int index = event.getActionIndex();
+
+switch (event.getActionMasked()) {
+ case MotionEvent.ACTION_DOWN:
+ Log.e(TAG,"第1个手指按下");
+ break;
+ case MotionEvent.ACTION_UP:
+ Log.e(TAG,"最后1个手指抬起");
+ break;
+ case MotionEvent.ACTION_POINTER_DOWN:
+ Log.e(TAG,"第"+(index+1)+"个手指按下");
+ break;
+ case MotionEvent.ACTION_POINTER_UP:
+ Log.e(TAG,"第"+(index+1)+"个手指抬起");
+ break;
+}
+```
+
+### 3. index 和 pointId 的变化规则
+
+在 2.2 版本以上，我们可以通过 getActionIndex() 轻松获取到事件的索引(Index)，但是这个事件索引的变化还是有点意思的，Index 变化有以下几个特点：
+
+1、从 0 开始，自动增长。
+2、如果之前落下的手指抬起，后面手指的 Index 会随之减小。
+3、Index 变化趋向于第一次落下的数值(落下手指时，前面有空缺会优先填补空缺)。
+4、对 move 事件无效。
+
+下面我们逐条解释一下具体含义。
+
+#### 3.1、从 0 开始，自动增长。
+
+这一条非常简单，也很容易理解，而且在 [MotionEvent详解][motionevent] 中讲解 getAction() 与 getActionMasked() 也简单说过。
+
+| 手指按下 | 触发事件(数值) |
+| :-----: | :--------------------------------------- |
+| 第1个手指按下 | ACTION_DOWN (0x0000**00**00) |
+| 第2个手指按下 | ACTION_POINTER_DOWN (0x0000**01**05) |
+| 第3个手指按下 | ACTION_POINTER_DOWN (0x0000**02**05) |
+| 第4个手指按下 | ACTION_POINTER_DOWN (0x0000**03**05) |
+
+注意加粗的位置，数值随着手指按下而不断变大。
+
+#### 3.2、如果之前落下的手指抬起，后面手指的 Index 会随之减小。
+
+这个也比较容易理解，像下面这样：
+
+| 手指按下 | 触发事件(数值) |
+| :-----: | :--------------------------------------- |
+| 第1个手指按下 | ACTION_DOWN (0x0000**00**00) |
+| 第2个手指按下 | ACTION_POINTER_DOWN (0x0000**01**05) |
+| 第3个手指按下 | ACTION_POINTER_DOWN (0x0000**02**05) |
+| 第2个手指抬起 | ACTION_POINTER_UP (0x0000**01**06) |
+| 第3个手指抬起 | ACTION_POINTER_UP (0x0000**01**06) |
+
+注意最后两次触发的事件，它的 Index 都是 1，这样也比较容易解释，当原本的第 2 个手指抬起后，屏幕上就只剩下两个手指了，之前的第 3 个手指就变成了第 2 个，于是抬起时触发事件的 Index 为 1，即之前落下的手指抬起，后面手指的 Index 会随之减小。
+
+#### 3.3、Index 变化趋向于第一次落下的数值(落下手指时，前面有空缺会优先填补空缺)。
+
+这个就有点神奇了，通过上一条规则，我们知道，某一个手指的 Index 可能会随着其他手指的抬起而变小，这次我们用 4 个手指测试一下 Index 的变化趋势。
+
+| 手指按下 | 触发事件(数值) |
+| :---------: | :--------------------------------------- |
+| 第1个手指按下 | ACTION_DOWN (0x0000**00**00) |
+| 第2个手指按下 | ACTION_POINTER_DOWN (0x0000**01**05) |
+| **第3个手指按下** | ACTION_POINTER_DOWN (0x0000**02**05) |
+| 第2个手指抬起 | ACTION_POINTER_UP (0x0000**01**06) |
+| ~~第3个手指抬起~~ | ~~ACTION_POINTER_UP~~ ~~(0x0000**01**06)~~ |
+| 第4个手指按下 | ACTION_POINTER_DOWN (0x0000**01**05) |
+| **第3个手指抬起** | ACTION_POINTER_UP (0x0000**02**06) |
+
+这个要和上一个对比这看，**重点观察第 3 个手指所触发事件区别**，在上一个示例中，随着第 2 个手指的抬起，第 3 个手指变化为第 2(01) 个，所以抬起时触发的是第 2 根手指的抬起事件(删除线部分)。
+
+但是，如果第 2 个手指抬起后，落在屏幕上另外一个手指会怎样？经过测试，发现另外**落下的手指会替代之前第 2 个手指的位置，系统判定为 2(01)，而不是顺延下去变成 3(02)，并且原本第3个手指的index变为原来数值(02)**，但是如果继续落下其他的手指，数值则会顺延。
+
+**即手指抬起时的 Index 会趋向于和按下时相同，虽然在手指数量不足时，Index 会变小，但是当手指变多时，Index 会趋向于保持和按下时一样。**
+
+> PS：由于程序是从0开始计数的，所以 0 就是 1， 1 就是 2 ...
+
+#### 3.4、对 move 事件无效。
+
+这个也比较容易理解，我们所取得的 Index 属性实际上是从事件上分离下来的，但是 move 事件始终为 0x0000**00**02，也就是说，在 move 时不论你移动哪个手指，使用 `getActionIndex()` 获取到的始终是数值 0。
+
+既然 move 事件无法用事件索引(Index)区别，那么该如何区分 move 是那个手指发出的呢？这就要用到 pointId 了，**pointId 和 index 最大的区别就是 pointId 是不变的，始终为第一次落下时生成的数值，不会受到其他手指抬起和落下的影响。**
+
+#### 3.5、pointId 与 index 的异同。
+
+相同点：
+
+- 从 0 开始，自动增长。
+- 落下手指时优先填补空缺(填补之前抬起手指的编号)。
+
+不同点：
+
+- Index 会变化，pointId 始终不变。
+
+### 4. Move 相关事件
+
+#### 4.1 actionIndex 与 pointerIndex
+
+在 move 中无法取得 actionIndex 的，我们需要使用 pointerIndex 来获取更多的信息，例如某个手指的坐标：
+
+```java
+getX(int pointerIndex)
+getY(int pointerIndex)
+```
+
+**但是这个 pointerIndex 又是什么呢？和 actionIndex 有区别么？**
+
+实际上这个 pointerIndex 和 actionIndex 区别并不大，两者的数值是相同的，你可以认为 pointerIndex 是特地为 move 事件准备的 actionIndex。
+
+#### 4.2 pointerIndex 与 pointerId
+
+| 类型 | 简介 |
+| ------------ | ----------------------------- |
+| pointerIndex | 用于获取具体事件，可能会随着其他手指的抬起和落下而变化 |
+| pointerId | 用于识别手指，手指按下时产生，手指抬起时回收，期间始终不变 |
+
+这两个数值使用以下两个方法相互转换。
+
+| 方法 | 简介 |
+| ------------------------------- | ---------------------------------------- |
+| getPointerId(int pointerIndex) | 获取一个指针(手指)的唯一标识符ID，在手指按下和抬起之间ID始终不变。 |
+| findPointerIndex(int pointerId) | 通过 pointerId 获取到当前状态下 pointIndex，之后通过 pointIndex 获取其他内容。 |
+
+> 通常情况下，pointerIndex 和 pointerId 是相同的，但也可能会因为某些手指的抬起而变得不同。
+
+#### 4.3 遍历多点触控
+
+先来一个简单的，遍历出多个手指的 move 事件：
+
+```java
+String TAG = "Gcs";
+switch (event.getActionMasked()) {
+ case MotionEvent.ACTION_MOVE:
+ for (int i = 0; i < event.getPointerCount(); i++) {
+ Log.i("TAG", "pointerIndex="+i+", pointerId="+event.getPointerId(i));
+ // TODO
+ }
+}
+```
+
+通过遍历 pointerCount 获取到所有的 pointerIndex，同时通过 pointerIndex 来获取 pointerId，可以通过不同手指抬起和按下后移动来观察 pointerIndex 和 pointerId 的变化。
+
+#### 4.4 在多点触控中追踪单个手指
+
+要实现追踪单个手指还是有些麻烦的，需要同时使用上 actionIndex， pointerId 和 pointerIndex，例如，我们只追踪第2个手指，并画出其位置：
+
+```java
+/**
+ * 绘制出第二个手指第位置
+ */
+public class MultiTouchTest extends CustomView {
+ String TAG = "Gcs";
+
+ // 用于判断第2个手指是否存在
+ boolean haveSecondPoint = false;
+
+ // 记录第2个手指第位置
+ PointF point = new PointF(0, 0);
+
+ public MultiTouchTest(Context context) {
+ this(context, null);
+ }
+
+ public MultiTouchTest(Context context, AttributeSet attrs) {
+ super(context, attrs);
+
+ mDeafultPaint.setAntiAlias(true);
+ mDeafultPaint.setTextAlign(Paint.Align.CENTER);
+ mDeafultPaint.setTextSize(30);
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ int index = event.getActionIndex();
+
+ switch (event.getActionMasked()) {
+ case MotionEvent.ACTION_POINTER_DOWN:
+ // 判断是否是第2个手指按下
+ if (event.getPointerId(index) == 1){
+ haveSecondPoint = true;
+ point.set(event.getY(), event.getX());
+ }
+ break;
+ case MotionEvent.ACTION_POINTER_UP:
+ // 判断抬起的手指是否是第2个
+ if (event.getPointerId(index) == 1){
+ haveSecondPoint = false;
+ point.set(0, 0);
+ }
+ break;
+ case MotionEvent.ACTION_MOVE:
+ if (haveSecondPoint) {
+ // 通过 pointerId 来获取 pointerIndex
+ int pointerIndex = event.findPointerIndex(1);
+ // 通过 pointerIndex 来取出对应的坐标
+ point.set(event.getX(pointerIndex), event.getY(pointerIndex));
+ }
+ break;
+ }
+
+ invalidate(); // 刷新
+
+ return true;
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ canvas.save();
+ canvas.translate(mViewWidth/2, mViewHeight/2);
+ canvas.drawText("追踪第2个按下手指的位置", 0, 0, mDeafultPaint);
+ canvas.restore();
+
+ // 如果屏幕上有第2个手指则绘制出来其位置
+ if (haveSecondPoint) {
+ canvas.drawCircle(point.x, point.y, 50, mDeafultPaint);
+ }
+ }
+}
+```
+
+这段代码也非常短，其核心就是通过判断数值为 1 的 pointerId 是否存在，如果存在就在 move 的时候取出其坐标，并绘制出来。
+
+
+
+> 虽然逻辑简单，但个人感觉写起来还是有些麻烦，如果有更简单的方案欢迎告诉我。
+
+
+
+## 二、如何使用多点触控
+
+多点触控应用还是比较广泛的，至少目前大部分的图片查看都需要用到多点触控技术(用于拖动和缩放图片)。
+
+但是在某些看似不需要多触控的地方也需要对多点触控进行判断，只要是多点触控可能引起错误的地方都应该加上多点触控的判断。例如使用到 move 事件的时候，由于 move 事件可能由多个手指同时触发，所以可能会出现同时被多个手指控制的情况，如果不适当的处理，这个 move 就可能由任何一个手指触发。
+
+举一个简单的例子：
+
+如果我们需要一个**可以用单指拖动的图片**。假如我们不进行多指触控的判断，像下面这样：
+
+**没有针对多指触控处理版本：**
+
+```java
+/**
+ * 一个可以拖图片动的 View
+ */
+public class DragView1 extends CustomView {
+ String TAG = "Gcs";
+
+ Bitmap mBitmap; // 图片
+ RectF mBitmapRectF; // 图片所在区域
+ Matrix mBitmapMatrix; // 控制图片的 matrix
+
+ boolean canDrag = false;
+ PointF lastPoint = new PointF(0, 0);
+
+ public DragView1(Context context) {
+ this(context, null);
+ }
+
+ public DragView1(Context context, AttributeSet attrs) {
+ super(context, attrs);
+
+ // 调整图片大小
+ BitmapFactory.Options options = new BitmapFactory.Options();
+ options.outWidth = 960/2;
+ options.outHeight = 800/2;
+
+ mBitmap = BitmapFactory.decodeResource(this.getResources(), R.drawable.drag_test, options);
+ mBitmapRectF = new RectF(0,0,mBitmap.getWidth(), mBitmap.getHeight());
+ mBitmapMatrix = new Matrix();
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ switch (event.getActionMasked()) {
+ case MotionEvent.ACTION_DOWN:
+ // 判断按下位置是否包含在图片区域内
+ if (mBitmapRectF.contains((int)event.getX(), (int)event.getY())){
+ canDrag = true;
+ lastPoint.set(event.getX(), event.getY());
+ }
+ break;
+ case MotionEvent.ACTION_UP:
+ canDrag = false;
+ case MotionEvent.ACTION_MOVE:
+ if (canDrag) {
+ // 移动图片
+ mBitmapMatrix.postTranslate(event.getX() - lastPoint.x, event.getY() - lastPoint.y);
+ // 更新上一次点位置
+ lastPoint.set(event.getX(), event.getY());
+
+ // 更新图片区域
+ mBitmapRectF = new RectF(0, 0, mBitmap.getWidth(), mBitmap.getHeight());
+ mBitmapMatrix.mapRect(mBitmapRectF);
+
+ invalidate();
+ }
+ break;
+ }
+
+ return true;
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ canvas.drawBitmap(mBitmap, mBitmapMatrix, mDeafultPaint);
+ }
+}
+```
+
+这个版本非常简单，当然了，如果正常使用(只使用一个手指)的话也不会出问题，但是当使用多个手指，且有抬起和按下的时候就可能出问题，下面用一个典型的场景演示一下：
+
+
+
+注意在第二个手指按下，第一个手指抬起时，此时原本的第二个手指会被识别为第一个，所以图片会直接跳动到第二个手指位置。
+
+为了不出现这种情况，我们可以判断一下 pointId 并且只获取第一个手指的数据，这样就能避免这种情况发生了，如下。
+
+**针对多指触控处理后版本：**
+
+```java
+/**
+ * 一个可以拖图片动的 View
+ */
+public class DragView extends CustomView {
+ String TAG = "Gcs";
+
+ Bitmap mBitmap; // 图片
+ RectF mBitmapRectF; // 图片所在区域
+ Matrix mBitmapMatrix; // 控制图片的 matrix
+
+ boolean canDrag = false;
+ PointF lastPoint = new PointF(0, 0);
+
+ public DragView(Context context) {
+ this(context, null);
+ }
+
+ public DragView(Context context, AttributeSet attrs) {
+ super(context, attrs);
+
+ BitmapFactory.Options options = new BitmapFactory.Options();
+ options.outWidth = 960/2;
+ options.outHeight = 800/2;
+
+ mBitmap = BitmapFactory.decodeResource(this.getResources(), R.drawable.drag_test, options);
+ mBitmapRectF = new RectF(0,0,mBitmap.getWidth(), mBitmap.getHeight());
+ mBitmapMatrix = new Matrix();
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ switch (event.getActionMasked()) {
+ case MotionEvent.ACTION_DOWN:
+ case MotionEvent.ACTION_POINTER_DOWN:
+ // ▼ 判断是否是第一个手指 && 是否包含在图片区域内
+ if (event.getPointerId(event.getActionIndex()) == 0 && mBitmapRectF.contains((int)event.getX(), (int)event.getY())){
+ canDrag = true;
+ lastPoint.set(event.getX(), event.getY());
+ }
+ break;
+ case MotionEvent.ACTION_UP:
+ case MotionEvent.ACTION_POINTER_UP:
+ // ▼ 判断是否是第一个手指
+ if (event.getPointerId(event.getActionIndex()) == 0){
+ canDrag = false;
+ }
+ break;
+ case MotionEvent.ACTION_MOVE:
+ // 如果存在第一个手指，且这个手指的落点在图片区域内
+ if (canDrag) {
+ // ▼ 注意 getX 和 getY
+ int index = event.findPointerIndex(0);
+ // Log.i(TAG, "index="+index);
+ mBitmapMatrix.postTranslate(event.getX(index)-lastPoint.x, event.getY(index)-lastPoint.y);
+ lastPoint.set(event.getX(index), event.getY(index));
+
+ mBitmapRectF = new RectF(0,0,mBitmap.getWidth(), mBitmap.getHeight());
+ mBitmapMatrix.mapRect(mBitmapRectF);
+
+ invalidate();
+ }
+ break;
+ }
+
+ return true;
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ canvas.drawBitmap(mBitmap, mBitmapMatrix, mDeafultPaint);
+ }
+}
+```
+
+可以看到，比起上一个版本，只添加了少量代码，就变得更加“智能”了，可以准确识别某一个手指，不会因为手指抬起而认错手指。
+
+
+
+**重点注意最后，第一个手指抬起之后，图片并没有跳跃到第二个手指的位置。**
+
+上面的两个对比示例都精简到了极致，其核心依旧是正确的追踪某一个手指，建议大家自己写一遍体会一下。
+
+------
+
+我感觉很多人看到这里依旧是不明所以的，一些简单的东西还好弄，但是复杂一些，如同时处理多个手指的数值就有些困难了，**假如说你之前没有接触过多点触控的处理，此时让你实现用两个手指来缩放图片还是有些困难的。**
+
+因为这不仅要追踪两个手指的位置，还要根据位置变化来计算缩放比例和缩放中心，单单这两个非常简单的数学问题就能难倒一大批人。
+
+
+
+当然了，很多麻烦问题都有简单的解决方案，假如说我们真的要实现一个可以用两个或者多个手指缩放的控件，何必要自己算呢，可以尝试一下 Android 自带的解决方案：**手势检测(GestureDetector)**，不仅能自动帮你计算好缩放比例和缩放中心，而且还可以检测出 单击、长按、滑屏 等不同的手势，不过这就不是本篇的事情了，以后有时间会写一下有关手势检测的用法(继续挖坑)。
+
+## 三、总结
+
+前段时间因为各种事情比较忙，这篇文章也没时间去写，所以就一直拖到了现在，期间收到不少读者催更，实在是抱歉了。今后在会尽量保证稳定更新的，争取尽快把自定义View系列这一个大坑填完。 ˊ_>ˋ
+
+关于多点触控，个人认为还算一个比较重要的知识点。尤其是随着 Android 的发展，很多炫酷的交互操作可能会需要用户进行拖拽操作。在进行这类操作的时候进行一下手指的判断还是相当重要的。
+
+本文中需要注意的几个知识点：
+
+- 如何兼容 2.0 版本的多点触控(目前大部分都不需要兼容 2.0 了吧)。
+- actionIndex、pointIndex 与 pointId 的区别和用法。
+- 如何在多点触控中正确的追踪一个手指。
+
+## About Me
+
+### 作者微博: @GcsSloop
+
+
+
+## 参考资料
+
+[MotionEvent ](https://developer.android.com/reference/android/view/MotionEvent.html)
+
+
+
+[motionevent]: http://www.gcssloop.com/customview/motionevent
\ No newline at end of file
diff --git a/CustomView/Advance/[19]gesture-detector.md b/CustomView/Advance/[19]gesture-detector.md
new file mode 100644
index 00000000..94e60e18
--- /dev/null
+++ b/CustomView/Advance/[19]gesture-detector.md
@@ -0,0 +1,386 @@
+# Android 手势检测(GestureDetector)
+
+Android 手势检测，主要是 GestureDetector 相关内容的用法和注意事项，本文依旧属于事件处理这一体系，部分内容会涉及到之前文章提及过的知识点，如果你没看过之前的文章，可以到 [自定义 View 系列](http://www.gcssloop.com/customview/CustomViewIndex) 来查看这些内容。
+
+在开发 Android 手机应用过程中，可能需要对一些手势作出响应，如：单击、双击、长按、滑动、缩放等。这些都是很常用的手势。就拿最简单的双击来说吧，假如我们需要判断一个控件是否被双击(即在较短的时间内快速的点击两次)，似乎是一个很容易的任务，但仔细考虑起来，要处理的细节问题也有不少，例如：
+
+1. **记录点击次数**，为了判断是否被点击超过 1 次，所以必须记录点击次数。
+2. **记录点击时间**，由于双击事件是较快速的点击两次，像点击一次后，过来几分钟再点击一次肯定不能算是双击事件，所以在记录点击次数的同时也要记录上一次的点击时间，我们可以设置本次点击距离上一次时间超过一定时间(例如：超过100ms)就不识别为双击事件。
+3. **点击状态重置**，在响应双击事件，或者判断不是双击事件的时候要重置计数器和上一次点击时间。重置既可以在点击的时候判断并进行重新设置，也可以使用定时器等超过一定时间后重置状态。
+
+这样看起来，判断一个双击事件就有这么多麻烦事情，更别其他的手势了，虽然这些看起来都很简单，但设计起来需要考虑的细节情况实在是太多了。
+
+那么有没有一种更好的方法来方便的检测手势呢？当然有啦，因为这些手势很常用，系统早就封装了一些方法给我们用，接下来我们就看看它们是如何使用的。
+
+## GestureDetector
+
+> GestureDetector 可以使用 MotionEvents 检测各种手势和事件。GestureDetector.OnGestureListener 是一个回调方法，在发生特定的事件时会调用 Listener 中对应的方法回调。这个类只能用于检测触摸事件的 MotionEvent，不能用于轨迹球事件。
+> (话说轨迹球已经消失多长时间了，估计很多人都没见过轨迹球这种东西)。
+>
+> 如何使用：
+>
+> - 创建一个 GestureDetector 实例。
+> - 在onTouchEvent（MotionEvent）方法中，确保调用 GestureDetector 实例的 onTouchEvent（MotionEvent）。回调中定义的方法将在事件发生时执行。
+> - 如果侦听 onContextClick（MotionEvent），则必须在 View 的 onGenericMotionEvent（MotionEvent）中调用 GestureDetector OnGenericMotionEvent（MotionEvent）。
+
+ GestureDetector 本身的方法比较少，使用起来也非常简单，下面让我们先看一下它的简单使用示例，分解开来大概需要三个步骤。
+
+```java
+// 1.创建一个监听回调
+SimpleOnGestureListener listener = new SimpleOnGestureListener() {
+ @Override public boolean onDoubleTap(MotionEvent e) {
+ Toast.makeText(MainActivity.this, "双击666", Toast.LENGTH_SHORT).show();
+ return super.onDoubleTap(e);
+ }
+};
+
+// 2.创建一个检测器
+final GestureDetector detector = new GestureDetector(this, listener);
+
+// 3.给监听器设置数据源
+view.setOnTouchListener(new View.OnTouchListener() {
+ @Override public boolean onTouch(View v, MotionEvent event) {
+ return detector.onTouchEvent(event);
+ }
+});
+```
+
+接下来我们先了解一下 GestureDetector 里面都有哪些内容。
+
+### 1. 构造函数
+
+GestureDetector 一共有 5 种构造函数，但有 2 种被废弃了，1 种是重复的，所以我们只需要关注其中的 2 种构造函数即可，如下：
+
+| 构造函数 |
+| ---------------------------------------- |
+| GestureDetector(Context context, GestureDetector.OnGestureListener listener) |
+| GestureDetector(Context context, GestureDetector.OnGestureListener listener, Handler handler) |
+
+第 1 种构造函数里面需要传递两个参数，上下文(Context) 和 手势监听器(OnGestureListener)，这个很容易理解，就不再过多叙述，上面的例子中使用的就是这一种。
+
+第 2 种构造函数则需要多传递一个 Handler 作为参数，这个有什么作用呢？其实作用也非常简单，这个 Handler 主要是为了给 GestureDetector 提供一个 Looper。
+
+在通常情况下是不需这个 Handler 的，因为它会在内部自动创建一个 Handler 用于处理数据，如果你在主线程中创建 GestureDetector，那么它内部创建的 Handler 会自动获得主线程的 Looper，然而如果你在一个没有创建 Looper 的子线程中创建 GestureDetector 则需要传递一个带有 Looper 的 Handler 给它，否则就会因为无法获取到 Looper 导致创建失败。
+
+第 2 种构造函数使用方式如下(下面是两种在子线程中创建 GestureDetector 的方法)：
+
+```java
+// 方式一、在主线程创建 Handler
+final Handler handler = new Handler();
+new Thread(new Runnable() {
+ @Override public void run() {
+ final GestureDetector detector = new GestureDetector(MainActivity.this, new
+ GestureDetector.SimpleOnGestureListener() , handler);
+ // ... 省略其它代码 ...
+ }
+}).start();
+
+// 方式二、在子线程创建 Handler，并且指定 Looper
+new Thread(new Runnable() {
+ @Override public void run() {
+ final Handler handler = new Handler(Looper.getMainLooper());
+ final GestureDetector detector = new GestureDetector(MainActivity.this, new
+ GestureDetector.SimpleOnGestureListener() , handler);
+ // ... 省略其它代码 ...
+ }
+}).start();
+```
+
+当然了，使用其它创建 Handler 的方式也是可以的，重点传递的 Handler 一定要有 Looper，敲黑板，重点是 Handler 中的 Looper。假如子线程准备了 Looper 那么可以直接使用第 1 种构造函数进行创建，如下：
+
+```java
+new Thread(new Runnable() {
+ @Override public void run() {
+ Looper.prepare(); // <- 重点在这里
+ final GestureDetector detector = new GestureDetector(MainActivity.this, new
+ GestureDetector.SimpleOnGestureListener());
+ // ... 省略其它代码 ...
+ }
+}).start();
+```
+
+### 2.手势监听器
+
+既然是手势检测，自然要在对应的手势出现的时候通知调用者，最合适的自然是事件监听器模式。目前 GestureDetecotr 有四种监听器。
+
+| 监听器 | 简介 |
+| ---------------------------------------- | ---------------------------------------- |
+| [OnContextClickListener](https://developer.android.com/reference/android/view/GestureDetector.OnContextClickListener.html) | 这个很容易让人联想到ContextMenu，然而它和ContextMenu并没有什么关系，它是在Android6.0(API 23)才添加的一个选项，是用于检测外部设备上的按钮是否按下的，例如蓝牙触控笔上的按钮，一般情况下，忽略即可。 |
+| [OnDoubleTapListener](https://developer.android.com/reference/android/view/GestureDetector.OnDoubleTapListener.html) | 双击事件，有三个回调类型：双击(DoubleTap)、单击确认(SingleTapConfirmed) 和 双击事件回调(DoubleTapEvent) |
+| [OnGestureListener](https://developer.android.com/reference/android/view/GestureDetector.OnGestureListener.html) | 手势检测，主要有以下类型事件：按下(Down)、 一扔(Fling)、长按(LongPress)、滚动(Scroll)、触摸反馈(ShowPress) 和 单击抬起(SingleTapUp) |
+| [SimpleOnGestureListener](https://developer.android.com/reference/android/view/GestureDetector.SimpleOnGestureListener.html) | 这个是上述三个接口的空实现，一般情况下使用这个比较多，也比较方便。 |
+
+#### 2.1 OnContextClickListener
+
+由于 OnContextClickListener 主要是用于检测外部设备按钮的，关于它需要注意一点，如果侦听 onContextClick(MotionEvent)，则必须在 View 的 onGenericMotionEvent(MotionEvent)中调用 GestureDetector 的 OnGenericMotionEvent(MotionEvent)。
+
+由于目前我们用到这个监听器的场景并不多，所以也就不展开介绍了，重点关注后面几个监听器。
+
+#### 2.2 OnDoubleTapListener
+
+这个很明显就是用于检测双击事件的，它有三个回调接口，分别是 onDoubleTap、onDoubleTapEvent 和 onSingleTapConfirmed。
+
+##### **2.2.1 onDoubleTap 与 onSingleTapConfirmed**
+
+**如果你只想监听双击事件，那么只用关注 onDoubleTap 就行了，如果你同时要监听单击事件则需要关注 onSingleTapConfirmed 这个回调函数**。
+
+有人可能会有疑问，监听单击事件为什么要使用 onSingleTapConfirmed，使用 OnClickListener 不行吗？从理论上是可行的，但是我并不推荐这样使用，主要有两个原因：
+1.它们两个是存在一定冲突的，如果你看过 [事件分发机制详解](http://www.gcssloop.com/customview/dispatch-touchevent-source) 就会知道，如果想要两者同时被触发，则 setOnTouchListener 不能消费事件，如果 onTouchListener 消费了事件，就可能导致 OnClick 无法正常触发。
+2.需要同时监听单击和双击，则说明单击和双击后响应逻辑不同，然而使用 OnClickListener 会在双击事件发生时触发两次，这显然不是我们想要的结果。而使用 onSingleTapConfirmed 就不用考虑那么多了，你完全可以把它当成单击事件来看待，而且在双击事件发生时，onSingleTapConfirmed 不会被调用，这样就不会引发冲突。
+
+如果你需要同时监听两种点击事件可以这样写：
+
+```java
+GestureDetector detector = new GestureDetector(this, new GestureDetector
+ .SimpleOnGestureListener() {
+ @Override public boolean onSingleTapConfirmed(MotionEvent e) {
+ Toast.makeText(MainActivity.this, "单击", Toast.LENGTH_SHORT).show();
+ return false;
+ }
+ @Override public boolean onDoubleTap(MotionEvent e) {
+ Toast.makeText(MainActivity.this, "双击", Toast.LENGTH_SHORT).show();
+ return false;
+ }
+});
+```
+
+关于 onSingleTapConfirmed 原理也非常简单，这一个回调函数在单击事件发生后300ms后触发(注意，不是立即触发的)，只有在确定不会有后续的事件后，既当前事件肯定是单击事件才触发 onSingleTapConfirmed，所以在进行点击操作时，onDoubleTap 和 onSingleTapConfirmed 只会有一个被触发，也就不存在冲突了。
+
+当然，如果你对事件分发机制非常了解的话，随便怎么用都行，条条大路通罗马，我这里只是推荐一种最简单而且不容易出错的实现方案。
+
+##### **2.2.2 onDoubleTapEvent**
+
+**有些细心的小伙伴可能注意到还有一个 onDoubleTapEvent 回调函数，它是干什么的呢？它在双击事件确定发生时会对第二次按下产生的 MotionEvent 信息进行回调。**
+
+至于为什么要存在这样的回调，就要涉及到另一个比较细致的问题了，那就是 onDoubleTap 的触发时间，如果你在这些函数被调用时打印一条日志，那么你会看到这样的信息：
+
+```
+GCS-LOG: onDoubleTap
+GCS-LOG: onDoubleTapEvent - down
+GCS-LOG: onDoubleTapEvent - move
+GCS-LOG: onDoubleTapEvent - move
+GCS-LOG: onDoubleTapEvent - up
+```
+
+通过观察这些信息你会发现它们的调用顺序非常有趣，首先是 onDoubleTap 被触发，之后依次触发 onDoubleTapEvent 的 down、move、up 等信息，为什么说它们有趣呢？是因为这样的调用顺序会引发两种猜想，第一种猜想是 onDoubleTap 是在第二次手指抬起(up)后触发的，而 onDoubleTapEvent 是一种延时回调。第二种猜想则是 onDoubleTap 在第二次手指按下(dowm)时触发，onDoubleTapEvent 是一种实时回调。
+
+通过测试和观察源码发现第二种猜想是正确的，因为第二次按下手指时，即便不抬起也会触发 onDoubleTap 和 onDoubleTapEvent 的 down，而且源码中逻辑也表明 onDoubleTapEvent 是一种实时回调。
+
+这就引发了另一个问题，双击的触发时间，虽然这是一个细微到很难让人注意到的问题，假如说我们想要在第二次按下抬起后才判定这是一个双击操作，触发后续的内容，则不能使用 onDoubleTap 了，需要使用 onDoubleTapEvent 来进行更细微的控制，如下：
+
+```java
+final GestureDetector detector = new GestureDetector(MainActivity.this, new GestureDetector.SimpleOnGestureListener() {
+ @Override public boolean onDoubleTap(MotionEvent e) {
+ Logger.e("第二次按下时触发");
+ return super.onDoubleTap(e);
+ }
+
+ @Override public boolean onDoubleTapEvent(MotionEvent e) {
+ switch (e.getActionMasked()) {
+ case MotionEvent.ACTION_UP:
+ Logger.e("第二次抬起时触发");
+ break;
+ }
+ return super.onDoubleTapEvent(e);
+ }
+});
+```
+
+如果你不需要控制这么细微的话，忽略即可(Logger 是我自己封装的日志库，忽略即可)。
+
+#### 2.3 OnGestureListener
+
+这个是手势检测中较为核心的一个部分了，主要检测以下类型事件：按下(Down)、 一扔(Fling)、长按(LongPress)、滚动(Scroll)、触摸反馈(ShowPress) 和 单击抬起(SingleTapUp)。
+
+##### 2.3.1 onDown
+
+```java
+@Override public boolean onDown(MotionEvent e) {
+ return true;
+}
+```
+
+看过前面的文章应该知道，down 在事件分发体系中是一个较为特殊的事件，为了保证事件被唯一的 View 消费，哪个 View 消费了 down 事件，后续的内容就会传递给该 View。如果我们想让一个 View 能够接收到事件，有两种做法：
+
+1、让该 View 可以点击，因为可点击状态会默认消费 down 事件。
+
+2、手动消费掉 down 事件。
+
+由于图片、文本等一些控件默认是不可点击的，所以我们要么声明它们的 clickable 为 true，要么在发生 down 事件是返回 true。所以 onDown 在这里的作用就很明显了，就是为了保证让该控件能拥有消费事件的能力，以接受后续的事件。
+
+##### 2.3.2 onFling
+
+Failing 中文直接翻译过来就是一扔、抛、甩，最常见的场景就是在 ListView 或者 RecyclerView 上快速滑动时手指抬起后它还会滚动一段时间才会停止。onFling 就是检测这种手势的。
+
+```java
+@Override
+public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float
+ velocityY) {
+ return super.onFling(e1, e2, velocityX, velocityY);
+}
+```
+
+在 onFling 的回调中共有四个参数，分别是：
+
+| 参数 | 简介 |
+| --------- | ------------------ |
+| e1 | 手指按下时的 Event。 |
+| e2 | 手指抬起时的 Event。 |
+| velocityX | 在 X 轴上的运动速度(像素／秒)。 |
+| velocityY | 在 Y 轴上的运动速度(像素／秒)。 |
+
+我们可以通过 e1 和 e2 获取到手指按下和抬起时的坐标、时间等相关信息，通过 velocityX 和 velocityY 获取到在这段时间内的运动速度，单位是像素／秒(即 1 秒内滑动的像素距离)。
+
+这个我们自己用到的地方比较少，但是也可以帮助我们简单的做出一些有趣的效果，例如下面的这种弹球效果，会根据滑动的力度和方向产生不同的弹跳效果。
+
+
+
+其实这种原理非常简单，简化之后如下：
+
+1. 记录 velocityX 和 velocityY 作为初始速度，之后不断让速度衰减，直至为零。
+2. 根据速度和当前小球的位置计算一段时间后的位置，并在该位置重新绘制小球。
+3. 判断小球边缘是否碰触控件边界，如果碰触了边界则让速度反向。
+
+根据这三条基本的逻辑就可以做出比较像的弹球效果，[具体的Demo可以看这里](https://raw.githubusercontent.com/GcsSloop/AndroidNote/master/CustomView/Demo/FailingBall.zip)。
+
+##### 2.3.3 onLongPress
+
+这个是检测长按事件的，即手指按下后不抬起，在一段时间后会触发该事件。
+
+```java
+@Override
+public void onLongPress(MotionEvent e) {
+}
+```
+
+##### 2.3.4 onScroll
+
+onScroll 就是监听滚动事件的，它看起来和 onFaling 比较像，不同的是，onSrcoll 后两个参数不是速度，而是滚动的距离。
+
+```java
+@Override
+public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float
+ distanceY) {
+ return super.onScroll(e1, e2, distanceX, distanceY);
+}
+```
+
+| 参数 | |
+| --------- | ----------- |
+| e1 | 手指按下时的Event |
+| e2 | 手指抬起时的Event |
+| distanceX | 在 X 轴上划过的距离 |
+| distanceY | 在 Y 轴上划过的距离 |
+
+##### 2.3.5 onShowPress
+
+它是用户按下时的一种回调，主要作用是给用户提供一种视觉反馈，可以在监听到这种事件时可以让控件换一种颜色，或者产生一些变化，告诉用户他的动作已经被识别。
+
+不过这个消息和 onSingleTapConfirmed 类似，也是一种延时回调，延迟时间是 180 ms，假如用户手指按下后立即抬起或者事件立即被拦截，时间没有超过 180 ms的话，这条消息会被 remove 掉，也就不会触发这个回调。
+
+```java
+@Override
+public void onShowPress(MotionEvent e) {
+}
+```
+
+##### 2.3.6 onSingleTapUp
+
+```java
+@Override
+public boolean onSingleTapUp(MotionEvent e) {
+ return super.onSingleTapUp(e);
+}
+```
+
+这个也很容易理解，就是用户单击抬起时的回调，但是它和上面的 `onSingleTapConfirmed` 之间有何不同呢？和 `onClick` 又有何不同呢？
+
+单击事件触发：
+
+```java
+GCS: onSingleTapUp
+GCS: onClick
+GCS: onSingleTapConfirmed
+```
+
+| 类型 | 触发次数 | 摘要 |
+| -------------------- | ---- | ---- |
+| onSingleTapUp | 1 | 单击抬起 |
+| onSingleTapConfirmed | 1 | 单击确认 |
+| onClick | 1 | 单击事件 |
+
+双击事件触发：
+
+```java
+GCS: onSingleTapUp
+GCS: onClick
+GCS: onDoubleTap // <- 双击
+GCS: onClick
+```
+
+| 类型 | 触发次数 | 摘要 |
+| -------------------- | ---- | ------------ |
+| onSingleTapUp | 1 | 在双击的第一次抬起时触发 |
+| onSingleTapConfirmed | 0 | 双击发生时不会触发。 |
+| onClick | 2 | 在双击事件时触发两次。 |
+
+可以看出来这三个事件还是有所不同的，根据自己实际需要进行使用即可
+
+#### 2.4 SimpleOnGestureListener
+
+这个里面并没有什么内容，只是对上面三种 Listener 的空实现，在上面的例子中使用的基本都是这监听器。因为它用起来更方便一点。
+
+这主要是 GestureDetector 构造函数的设计问题，以只监听 OnDoubleTapListener 为例，如果想要使用 OnDoubleTapListener 接口则需要这样进行设置：
+
+```java
+GestureDetector detector = new GestureDetector(this, new GestureDetector
+ .SimpleOnGestureListener());
+detector.setOnDoubleTapListener(new GestureDetector.OnDoubleTapListener() {
+ @Override public boolean onSingleTapConfirmed(MotionEvent e) {
+ Toast.makeText(MainActivity.this, "单击确认", Toast.LENGTH_SHORT).show();
+ return false;
+ }
+
+ @Override public boolean onDoubleTap(MotionEvent e) {
+ Toast.makeText(MainActivity.this, "双击", Toast.LENGTH_SHORT).show();
+ return false;
+ }
+
+ @Override public boolean onDoubleTapEvent(MotionEvent e) {
+ // Toast.makeText(MainActivity.this,"",Toast.LENGTH_SHORT).show();
+ return false;
+ }
+});
+```
+
+既然都已经创建 SimpleOnGestureListener 了，再创建一个 OnDoubleTapListener 显然十分浪费，如果构造函数不使用 SimpleOnGestureListener，而是使用 OnGestureListener 的话，会多出几个无用的空实现，显然很浪费，所以在一般情况下，老老实实的使用 SimpleOnGestureListener 就好了。
+
+### 3. 相关方法
+
+除了各类监听器之外，与 GestureDetector 相关的方法其实并不多，只有几个，下面来简单介绍一下。
+
+| 方法 | 摘要 |
+| ----------------------- | ---------------------------------------- |
+| setIsLongpressEnabled | 通过布尔值设置是否允许触发长按事件，true 表示允许，false 表示不允许。 |
+| isLongpressEnabled | 判断当前是否允许触发长按事件，true 表示允许，false 表示不允许。 |
+| onTouchEvent | 这个是其中一个重要的方法，在最开始已经演示过使用方式了。 |
+| onGenericMotionEvent | 这个是在 API 23 之后才添加的内容，主要是为 OnContextClickListener 服务的，暂时不用关注。 |
+| setContextClickListener | 设置 ContextClickListener 。 |
+| setOnDoubleTapListener | 设置 OnDoubleTapListener 。 |
+
+### 结语
+
+关于手势检测部分的 GestureDetector 相关内容基本就这么多了，其实手势检测还有一个 ScaleGestureDetector 也是为手势检测服务的，限于篇幅，本次就讲这么多吧。
+
+其实手势检测辅助类 GestureDetector 本身并不是很复杂，带上注释等内容才不到1000行，感兴趣的可以自己研究一下实现方式。
+
+## About Me
+
+### 作者微博: @GcsSloop
+
+
+
+## 参考资料
+
+[文档 · GestureDetector ](https://developer.android.com/reference/android/view/GestureDetector.html)
+[源码 · GestureDetector](https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/core/java/android/view/GestureDetector.java)
\ No newline at end of file
diff --git a/CustomView/Advance/[99]DrawText.md b/CustomView/Advance/[99]DrawText.md
new file mode 100644
index 00000000..fe9982a1
--- /dev/null
+++ b/CustomView/Advance/[99]DrawText.md
@@ -0,0 +1,279 @@
+# drawText之坐标、居中、绘制多行
+
+本文用于讲解Canvas中关于DrawText相关的一些常见问题，如坐标，居中，和绘制多行。
+
+之前由于个人的疏忽以及对问题的想当然，没有进行验证，在 [【安卓自定义View进阶 - 图片文字】](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B4%5DCanvas_PictureText.md) 这篇文章中出现了一个错误，有不少眼睛雪亮的网友都发现了该错误并给予了反馈，非常感谢这些网友的帮助。
+
+
+
+## 错误原因
+
+这个错误是drawText方法中坐标的一个问题，就一般的绘图而言，坐标一般都是指定左上角，然而drawText默认并不是左上角，甚至不是大家测试后认为的左下角，而是一个**由Paint中Align决定的对齐基准线**，该API注释原文如下：
+
+> Draw the text, with origin at (x,y), using the specified paint. **The origin is interpreted based on the Align setting in the paint.**
+
+在默认情况下基线如下图所示：
+
+> PS：基线(BaseLine)有两条，是用户指定的坐标确定的，在默认情况下，基线X在字符串左侧，基线y在字符串下方(但并不是最低的部分)。
+
+
+
+## 分析这样设计的原因
+
+**Q: 为何基线y要放到文字下面，而不是上面？**
+
+> A : 既然采用这种对齐方式，必然有其缘由，至少不是为了坑我这种小白。据本人猜测可能有以下原因：
+* 1.符合人类书写习惯，不论是汉字还是英文或是其他语言，我们在书写对齐的时候都是以下面为基准线的，而不是上面，（**我们默认的基准线类似于四线格中的第三条线**）。
+
+* 2.字的特点，字的显示不仅有有中文汉字，还有一些特殊字符，并且大部分是根据下面对齐的，如果把对齐的基线放到上面并使其显示整齐，设计太麻烦，如下：
+
+* 3.字体的特点，我们都知道，字有很多的字体风格，不同字体风格的大小是不同的，如果以以上面为基准线而让其底部对齐，这设计难度简直不敢想象：
+
+**综上所述，基线y放到下面不仅符合人的书写习惯，而且更加便于设计。**
+
+## drawText从入门到懵逼
+
+虽然之前在 [图片文字](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B4%5DCanvas_PictureText.md) 这篇文章中已经简单的了解部分关于文字的方法，但Paint中关于文字的方法还有很多，本文会了解一些我们比较关心的一些内容，例如绘制居中的文本，多行文本等，在此之前我们先了解一下Paint中与文本相关的内部类或者枚举：
+
+名称 | 类型 | 主要作用
+---------------|:------:|------------------------------------------------------
+Align | 枚举 | 指定基准线与文本的相对关系(包含 左对齐 右对齐 居中)
+Style | 枚举 | 设置样式，但不仅仅是为文本服务(包含 描边 填充 描边加填充)
+FontMetrics | 内部类 | 描述给定的文本大小，字体，间距等各种度量值(度量结果类型为float)
+FontMetricsInt | 内部类 | 作用同上，但度量结果返回值是int型的
+
+### Align
+
+Align中文意思是对齐，其作用正式如此，我们使用过 Word 的人都知道文本有 *左对齐、居中、右对齐、两端对齐、分散对齐* 五种模式，Align作用就是设置文本的对齐模式，但是并没有这么多，仅有 **左对齐、居中、右对齐** 三种模式，如下：
+
+> 吐槽：就因为没有两端对齐和分散对齐，导致长文本，尤其是中英混合的长文本在手机上显示效果奇差，相信做阅读类软件的程序员深有体会，最终还要自定义View解决。
+
+枚举类型 | 作用
+---------|-------------------------------------------------------------
+LEFT | 左对齐 基线X在文本左侧，基线y在文本下方，文本出现在给定坐标的右侧，是默认的对齐方式
+RIGHT | 右对齐 基线x在文本右侧，基线y在文本下方，文本出现在给定坐标的左侧
+CENTER | 居中对齐 基线x在文本中间，基线y在文本下方，文本出现在给定坐标的两侧
+
+Align对应的方法如下：
+
+``` java
+ public Paint.Align getTextAlign () // 获取对齐方式
+
+ public void setTextAlign (Paint.Align align) // 设置对齐方式
+```
+
+在实际运用中基线与模式之间的关系则如下图所示：
+
+
+
+> PS 该图片是截屏加工所得，其中红色的先是各自的基准线。注意汉字有一部分是在基准线下面的。
+
+其核心代码如下：
+
+``` java
+ // 平移画布 - 如有疑问请参考画布操作这篇文章
+ canvas.translate(mCenterX,0); // mCenterX 是屏幕宽度的一半，在onSizeChanged中获取
+
+ // 设置字体颜色
+ mPaint.setColor(Color.rgb(0x06,0xaf,0xcd));
+
+ // 在不同模式下绘制文字
+ mPaint.setTextAlign(Paint.Align.LEFT);
+ canvas.drawText("左对齐", 0, 200, mPaint);
+
+ mPaint.setTextAlign(Paint.Align.CENTER);
+ canvas.drawText("居中对齐", 0, 400, mPaint);
+
+ mPaint.setTextAlign(Paint.Align.RIGHT);
+ canvas.drawText("右对齐", 0, 600, mPaint);
+```
+
+### Style
+
+Style的意思是样式，这个在 [Canvas之绘制基本形状](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B2%5DCanvas_BasicGraphics.md) 这篇文章中讲过，它有三种状态：
+
+枚举类型 | 作用
+----------------|----------------
+FILL | 填充
+STROKE | 描边
+FILL_AND_STROKE | 填充加描边
+
+Style 对应的方法如下：
+
+``` java
+public Paint.Style getStyle () // 获取当然样式
+
+public void setStyle (Paint.Style style) // 设置样式
+```
+
+效果如下：
+
+
+
+核心代码：
+
+``` java
+ // 平移画布 - 如有疑问请参考画布操作这篇文章
+ canvas.translate(mCenterX,0); // mCenterX 是屏幕宽度的一半，在onSizeChanged中获取
+
+ mPaint.setTextAlign(Paint.Align.CENTER);
+ mPaint.setColor(Color.rgb(0x06,0xaf,0xcd));
+
+ // 设置不同的样式
+
+ // 填充
+ mPaint.setStyle(Paint.Style.FILL);
+ canvas.drawText("GcsSloop 中文", 0, 200, mPaint);
+
+ // 描边
+ mPaint.setStyle(Paint.Style.STROKE);
+ canvas.drawText("GcsSloop 中文", 0, 400, mPaint);
+
+ // 描边加填充
+ mPaint.setStyle(Paint.Style.FILL_AND_STROKE);
+ canvas.drawText("GcsSloop 中文", 0, 600, mPaint);
+```
+
+### FontMetrics
+
+FontMetrics 是 Paint 的一个内部类，根据名字我们可以大致知道这是一个描述**字体规格**相关的类，关于这个类的描述原文是这样的：
+
+> Class that describes the various metrics for a font at a given text size. Remember, Y values increase going down, so those values will be positive, and values that measure distances going up will be negative. This class is returned by getFontMetrics().
+
+翻译一下：
+
+> 简单来说，FontMetrics包含了当前文本相关的各项参数，你可以通过 Paint中 _getFontMetrics()_ 这个方法来获取到这个类。
+(另外，原文中还特地强调了一下关于坐标正负的问题。）
+
+##### FontMetrics包含了以下几个数值：
+
+> 如果没有特殊说明，一下文章中“基线”默认代表“基线Y”。
+
+名称 | 正负| 释义
+--------|:---:|--------------------------------------------------------
+top | - | 在指定字形和大小的情况下，字符最高点与基线之间的距离
+ascent | - | 单个字符的最高点与基线距离的推荐值(不包括字母上面的符号)
+descent | + | 单个字符的最低点与基线距离的推荐值
+bottom | + | 在指定字形和大小的情况下，字符最低点与基线之间的距离
+leading | + | 行间距,当前行bottom与下一行top之间的距离的推荐值 (通常为0，因为top与ascent，bottom与leading之间的距离足够作为行间距了)
+
+
+
+看了上面啰啰嗦嗦讲了一堆，你可能会产生一些疑问，这里我简单解释一下：
+
+0、 FontMetrics到底有什么用？
+
+> FontMetrics 是字体规格，比较精确的测量出文字相关的各种数据，在很多地方都是用得到的，比较常见的就是我们的音乐播放器中的歌词显示，需要实时的变字体位置，这里就需要比较精确是数值来进行计算以确保不会出现两行文字重叠等问题。
+
+1、为什么表格中最高点距离基线的值是负值，而最低点反而是正值？
+
+> 这是因为手机屏幕坐标系的特殊性，在数学中常见的坐标系y轴是向上的，而对于手机而言，y轴默认是向下的，所以数值越小越靠近屏幕顶端，即最高点的数值比基线小，最高点减去基线结果自然为负数。 更多参考 [坐标系](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Base/%5B1%5DCoordinateSystem.md) 这篇文章。
+
+2、为什么表格中很多都是推荐值？
+
+> 这是因为字的规格不仅受字大小的影响，而且受字体风格的影响，不同的字体风格差别很大，其结果可能会有偏差，故大部分都是推荐值。
+
+3、 具体绘制的文本不同会影响 FontMetrics 中的数值吗？
+
+> 不会， **FontMetrics中的数值受字体大小(FontSize) 和 字体风格(Typeface) 影响**， 而不会因为具体绘制的内容不同而改变，给Paint设置完字体大小和字体风格后就能获取到正确的FontMetrics。
+
+**获取FontMetrics的方法**
+``` java
+ Paint.FontMetrics mMetrics = mPaint.getFontMetrics();
+
+ Log.e("TAG", "top=" + mMetrics.top);
+ Log.e("TAG", "ascent=" + mMetrics.ascent);
+ Log.e("TAG", "descent=" + mMetrics.descent);
+ Log.e("TAG", "bottom=" + mMetrics.bottom);
+ Log.e("TAG", "leading=" + mMetrics.leading);
+```
+结果：
+```
+05-15 21:18:13.315 13112-13112/com.gcssloop.canvas E/TAG: top=-152.98828
+05-15 21:18:13.315 13112-13112/com.gcssloop.canvas E/TAG: ascent=-129.88281
+05-15 21:18:13.315 13112-13112/com.gcssloop.canvas E/TAG: descent=34.179688
+05-15 21:18:13.315 13112-13112/com.gcssloop.canvas E/TAG: bottom=37.939453
+05-15 21:18:13.315 13112-13112/com.gcssloop.canvas E/TAG: leading=0.0
+```
+
+**由于FontMetrics中的 ascent 与 descent 比较常用，所以可以直接通过Paint获取：**
+``` java
+ Log.e("TAG", "P.ascent=" + mPaint.ascent());
+ Log.e("TAG", "P.descent=" + mPaint.descent());
+```
+结果，可以看到与通过FontMetrics获得的结果相同。
+```
+05-15 21:24:18.950 13112-13112/com.gcssloop.canvas E/TAG: P.ascent=-129.88281
+05-15 21:24:18.955 13112-13112/com.gcssloop.canvas E/TAG: P.descent=34.179688
+```
+
+
+## 文字居中
+
+对于绘制居中的文本来说，我们可以封装一个方法用中心点作为绘制坐标，在绘制的时候转换为实际坐标。
+
+根据前面的知识可知，想让文字水平居中很容易，只需要设置 TextAlign 为 CENTER，那么基线X(BaseLineX)自然就是这个字符串的中心了。
+
+而让文字垂直居中则有些麻烦了，因为基线Y(BaseLineY)既不是顶部，底部，也不是中心，所以文本居中最难的内容就是计算BaseLineY的位置。
+
+我们已知：
+
+> 1. 中心位置坐标，centerX, centerY
+2. 文本高度：height ＝ descent－ascent
+3. descent的坐标：descentY ＝ centerY ＋ 1/2height
+4. baseLineY坐标：baseLineY ＝ descentY－descent
+
+通过上面内容可以推算出如下公式：
+
+> baseLineY ＝ centerY － 1/2(ascent + descent)
+
+**根据公式我们可以封装一个方法：**
+
+``` java
+ /**
+ * 居中绘制文本
+ *
+ * @param text
+ * @param canvas
+ * @param paint
+ */
+ public void drawTextByCenter(String text, float x, float y, Canvas canvas, Paint paint) {
+ Paint tempPaint = new Paint(paint); // 创建一个临时画笔,防止影响原来画笔的状态
+ tempPaint.setTextAlign(Paint.Align.CENTER); // 设置文本对齐方式为居中
+
+ // 通过y计算出baseline的位置
+ float baseline = y - (tempPaint.descent() + tempPaint.ascent()) / 2;
+
+ canvas.drawText(text, x, baseline, tempPaint); //绘制文本
+ }
+```
+
+**测试方法是否正确**
+
+``` java
+ canvas.translate(mCenterX, mCenterY);
+
+ String text = "ASSA";
+ mPaint.setColor(Color.BLACK);
+
+ drawTextByCenter(text, 0, 0, canvas, mPaint);
+```
+
+结果：
+
+
+
+## 绘制多行
+
+前面讲的所有绘制文本都是绘制单行文本，而对于长文本就束手无策了，但是我们偶尔也需要绘制一些长文本，例如绘制一段文本，这样前面的就无法满足需求了。
+
+我们先思考一下如何才能绘制一段长文本让其可以自动换行，如自动测量文本长度，然后根据测量的内容截开成n行，然后一行一行的绘制。
+
+
+
+
+
+
+
+
+
diff --git a/CustomView/Base/[1]CoordinateSystem.md b/CustomView/Base/[01]CoordinateSystem.md
similarity index 85%
rename from CustomView/Base/[1]CoordinateSystem.md
rename to CustomView/Base/[01]CoordinateSystem.md
index 1571ce47..9db00f30 100644
--- a/CustomView/Base/[1]CoordinateSystem.md
+++ b/CustomView/Base/[01]CoordinateSystem.md
@@ -1,5 +1,8 @@
# 安卓中的坐标系
+
### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
+### [【本系列相关文章】](http://www.gcssloop.com/1970/01/CustomViewIndex/)
+
## 一.屏幕坐标系和数学坐标系的区别
由于移动设备一般定义屏幕左上角为坐标原点，向右为x轴增大方向，向下为y轴增大方向，
@@ -26,11 +29,13 @@
getBottom(); //获取子View右下角距父View顶部的距离
getRight(); //获取子View右下角距父View左侧的距离
```
+
**如下图所示：**
## 三.MotionEvent中 get 和 getRaw 的区别
+
```
event.getX(); //触摸点相对于其所在组件坐标系的坐标
event.getY();
@@ -39,6 +44,7 @@
event.getRawY();
```
+
**如下图所示：**
> PS:其中相同颜色的内容是对应的，其中为了显示方便，蓝色箭头向左稍微偏移了一点.
@@ -54,9 +60,12 @@
3 | MotionEvent中get和getRaw的区别
## 五.参考文章：
+
[Android 屏幕（View）坐标系统](http://blog.csdn.net/wangjinyu501/article/details/21827341)
## About Me
-
+### 作者微博: @GcsSloop
+
+
diff --git a/CustomView/Base/[02]AngleAndRadian.md b/CustomView/Base/[02]AngleAndRadian.md
new file mode 100644
index 00000000..07235471
--- /dev/null
+++ b/CustomView/Base/[02]AngleAndRadian.md
@@ -0,0 +1,79 @@
+# 角度与弧度
+
+### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
+### [【本系列相关文章】](http://www.gcssloop.com/1970/01/CustomViewIndex/)
+
+安卓中角度(angle)与弧度(radian)的有关问题。
+
+## 一.前言
+
+### 1.为什么讲这个？
+
+ 在我们自定义View，尤其是制作一些复杂炫酷的效果的时候，实际上是将一些简单的东西通过数学上精密的计算组合到一起形成的效果。
+
+这其中可能会涉及到画布的相关操作(旋转)，以及一些正余弦函数的计算等，这些内容就会用到一些角度、弧度相关的知识。
+
+### 2.为什么对角的描述存在角度与弧度两种单位？
+
+简单来说就是为了方便，为了精确描述一个角的大小引入了角度与弧度的概念。
+
+由于两者进制是不同的(**角度是60进制，弧度是10进制**),在合适的地方使用合适的单位来描述会更加方便。
+
+> **例如：**
+> 角度是60进位制，遇到30°6′这样的角，应该转化为10进制的30.1°。但弧度就不需要，因为弧度本身就是十进制的实数。
+
+
+## 二.角度与弧度的定义
+
+角度和弧度一样都是描述角的一种度量单位，下面是它们的定义：
+
+| 名称 | 定义 |
+| :--: | ---------------------------------------- |
+| 角度 | 两条射线从圆心向圆周射出，形成一个夹角和夹角正对的一段弧。**当这段弧长正好等于圆周长的360分之一时，两条射线的夹角的大小为1度.** |
+| 弧度 | 两条射线从圆心向圆周射出，形成一个夹角和夹角正对的一段弧。**当这段弧长正好等于圆的半径时，两条射线的夹角大小为1弧度.** |
+
+**如图:**
+
+
+
+
+
+## 三.角度和弧度的换算关系
+**圆一周对应的角度为360度(角度)，对应的弧度为2π弧度。**
+
+**故得等价关系:360(角度) = 2π(弧度) ==> 180(角度) = π(弧度)**
+
+由等价关系可得如下换算公式:
+
+> rad 是弧度， deg 是角度
+
+| 公式 | 例子 |
+| ----------------------- | ------------------ |
+| **rad = deg x π / 180** | 2π ＝ 360 x π / 180 |
+| **deg = rad x 180 / π** | 360 ＝ 2π x 180 / π |
+
+维基百科的公式：
+
+> rad 是弧度， deg 是角度
+
+
+
+
+## 四.一些细节问题
+
+由于默认屏幕坐标系和常见数学坐标系的小差别([坐标系问题点这里](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Base/%5B1%5DCoordinateSystem.md))，所以在角上必然也会存在一些区别，例如：
+
+**在常见的数学坐标系中角度增大方向为逆时针，**
+
+**在默认的屏幕坐标系中角度增大方向为顺时针。**
+
+
+
+## About Me
+
+### 作者微博: @GcsSloop
+
+
+
+
+
diff --git a/CustomView/Base/[03]Color.md b/CustomView/Base/[03]Color.md
new file mode 100644
index 00000000..300b9cc5
--- /dev/null
+++ b/CustomView/Base/[03]Color.md
@@ -0,0 +1,179 @@
+# 颜色
+
+### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
+
+### [【本系列相关文章】](http://www.gcssloop.com/1970/01/CustomViewIndex/)
+
+简要介绍安卓中的颜色相关内容，包括颜色的定义，创建颜色的几种方式，以及颜色的混合模式等。
+
+## 一.简单介绍颜色
+
+安卓支持的颜色模式：
+
+颜色模式 | 备注
+:--- | ---
+ARGB8888 | 四通道高精度(32位)
+ARGB4444 | 四通道低精度(16位)
+RGB565 | **屏幕默认模式**(16位)
+Alpha8 | 仅有透明通道(8位)
+
+*PS：其中字母表示通道类型，数值表示该类型用多少位二进制来描述。如ARGB8888则表示有四个通道(ARGB),每个对应的通道均用8位来描述。*
+
+*注意：我们常用的是ARGB8888和ARGB4444，而在所有的安卓设备屏幕上默认的模式都是RGB565,请留意这一点。*
+
+**以ARGB8888为例介绍颜色定义:**
+
+类型 | 解释 | 0(0x00) | 255(0xff)
+:-------- |:------ | :------ | :--------
+A(Alpha) | 透明度 | 透明 | 不透明
+R(Red) | 红色 | 无色 | 红色
+G(Green) | 绿色 | 无色 | 绿色
+B(Blue) | 蓝色 | 无色 | 蓝色
+
+*其中 A R G B 的取值范围均为0~255(即16进制的0x00~0xff)*
+
+A 从0x00到0xff表示从透明到不透明。
+
+RGB 从0x00到0xff表示颜色从浅到深。
+
+**当RGB全取最小值(0或0x000000)时颜色为黑色，全取最大值(255或0xffffff)时颜色为白色**
+
+## 二.几种创建或使用颜色的方式
+
+### 1.java中定义颜色
+
+``` java
+ int color = Color.GRAY; //灰色
+```
+
+ 由于Color类提供的颜色仅为有限的几个，通常还是用ARGB值进行表示。
+
+``` java
+ int color = Color.argb(127, 255, 0, 0); //半透明红色
+
+ int color = 0xaaff0000; //带有透明度的红色
+```
+
+### 2.在xml文件中定义颜色
+
+在/res/values/color.xml 文件中如下定义：
+
+``` xml
+
+
+
+
diff --git a/CustomView/Base/[2]AngleAndRadian.md b/CustomView/Base/[2]AngleAndRadian.md
deleted file mode 100644
index 655a6857..00000000
--- a/CustomView/Base/[2]AngleAndRadian.md
+++ /dev/null
@@ -1,70 +0,0 @@
-# 角度与弧度
-
-安卓中角度(angle)与弧度(radian)的有关问题。
-
-## 一.前言
-
-### 1.为什么讲这个？
-
- 在我们自定义View，尤其是制作一些复杂炫酷的效果的时候，实际上是将一些简单的东西通过数学上精密的计算组合到一起形成的效果。
-
-这其中可能会涉及到画布的相关操作(旋转)，以及一些正余弦函数的计算等，这些内容就会用到一些角度、弧度相关的知识。
-
-### 2.为什么对角的描述存在角度与弧度两种单位？
-
-简单来说就是为了方便，为了精确描述一个角的大小引入了角度与弧度的概念。
-
-由于两者进制也是不同的(**角度是60进制，弧度是10进制**),在合适的地方使用合适的单位来描述会更加方便。
-
-> **例如：**
-角度是60进位制，遇到30°6′这样的角，应该转化为10进制的30.1°。但弧度就不需要，因为弧度本身就是十进制的实数。
-
-
-## 二.角度与弧度的定义
-
-角度和弧度一样都是描述角的一种度量单位，下面是它们的定义：
-
-名称 | 定义
-:---:| ---
-角度 | 两条射线从圆心向圆周射出，形成一个夹角和夹角正对的一段弧。**当这段弧长正好等于圆周长的360分之一时，两条射线的夹角的大小为1度.**
-弧度 | 两条射线从圆心向圆周射出，形成一个夹角和夹角正对的一段弧。**当这段弧长正好等于圆的半径时，两条射线的夹角大小为1弧度.**
-
-**如图:**
-
-
-
-
-
-## 三.角度和弧度的换算关系
-根据角度和弧度的的定义和圆的相关知识非常容易就能得出两者的换算公式：
-
-先设圆的周长为C. 半径为r
-
-C = 2πr;
-
-一周对应的角度为360度(角度)，对应的弧度为2π弧度。
-
-故: **180度 = π弧度.**
-
-可得:
-
-**弧度 = 角度xπ/180**
-
-**角度 = 弧度x180/π**
-
-
-## 四.一些细节问题
-由于默认屏幕坐标系和常见数学坐标系的小差别([坐标系问题点这里](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Base/%5B1%5DCoordinateSystem.md)，所以在角度上必然也会存在一些区别，例如：
-
-**在常见的数学坐标系中角度增大方向为逆时针，**
-
-**在默认的屏幕坐标系中角度增大方向为顺时针。**
-
-
-
-## About Me
-### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
-
-
-
-
diff --git a/CustomView/CustomViewRule.md b/CustomView/CustomViewRule.md
new file mode 100644
index 00000000..766fcaa0
--- /dev/null
+++ b/CustomView/CustomViewRule.md
@@ -0,0 +1,48 @@
+# 自定义View基本法
+
+我们使用手机，是想要获取某些信息，而 View 是这些信息的直接展示界面，因为信息种类繁多，为了更好的展示这些信息， View 也必须有多种多样，Android 系统本身就给我们提供了不少类型的 View，但有时仍不能满足我们的需要，所以有时可能需要自定义 View 来完成任务。
+
+自定义 View 有许多需要注意的地方，关于这些需要注意的内容，我都会整理在这里，其名为《自定义 View 基本法》。
+
+#### 第一条：尽量避免自定义 View。
+
+由于 View 直接承载了与用户交互的重任，所以必须要考虑到各种情况，例如：
+
+* 当没有设置宽高属性时，View 默认应该多大。
+* 横竖屏转换时 View 可能重新设定大小，此时应如何处理。
+* View 因为特殊情况被销毁后重建，应如何保存和恢复数据。
+
+由于某些情况很特殊，触发条件也特殊，我们简单的实现了一个自定义了一个 View，可能在 99% 的情况下都是正常的，但在某些特殊情况下就会出问题。
+
+而系统提供给我们的组件都是经过千锤百炼的，基本上考虑到了各种特殊情况的处理，所以通常情况下，系统提供给我们的组件稳定性要好一些。所以我的建议是，能使用系统提供的组件的尽量使用系统的。
+
+除此之外，使用系统提供的组件也方便于其他人快速读懂项目，便于交流。
+
+#### 第二条：尽量避免从头开始。
+
+如果一定要使用自定义 View，那么尽量去继承系统已有的组件，并重写其中的部分方法，不要自己从头开始写。例如：图像相关的 View 可以考虑继承 ImageView，容器类 View 可以考虑继承 LinerLayout，RelativeLayout 等，原因同上。
+
+#### 第三条：处理特殊情况。
+
+针对能想到的一些特殊情况进行处理并且测试，尽量保证自定义 View 能适应各种特殊场景。
+
+#### 第四条：留下文档。
+
+**程序员有两大痛苦，1、别人写的项目居然没有文档。2、自己写的项目居然要写文档。**
+
+虽然有时候文档写起来确实挺麻烦，但是个人建议要留下一份文档，至少要为自己写的程序添加**有效的注释**，这不仅是方便他人，更重要的是方便自己以后修改项目。
+
+* 于自定义View而言，首先要标明这个自定义View是解决什么问题，有怎样的效果，使用的场景如何。
+* 其次要在关键部位标注实现原理。(例如：显示圆形的ImageView，要标明圆形是如何实现的，使用的是遮罩还是剪裁。)
+* 避免无效注释 (例如：在onDraw上面标注绘图)，大家都知道这个是绘图，但绘制逻辑才是重点，要去标注绘制逻辑。
+
+#### 第五条：面向结果编程。
+
+我们既然使用自定义View，自然是想要实现一些系统组件无法实现的效果，所以要时刻谨记自己所需要的内容，让其中的所有逻辑都为这个结果服务，我自己实现自定义 View 一般有如下步骤：
+
+1. 原型，用我能想到的逻辑实现原型(demo)，不管其代码复杂度，首先要得到结果，通常情况下，第一份代码可得性和整洁性都比较差。
+2. 优化，在原型的基础上对代码进行优化，剔除不必要的内容，例如尝试优化逻辑，对与一些重复性的内容抽取函数进行封装，想办法消灭一些中间变量。同时添加上必要注释，让其逻辑更加清晰易懂。
+3. 测试，对其进行场景测试，尽量保证其正常运行。
+
+
+
diff --git a/CustomView/Demo/FailingBall.zip b/CustomView/Demo/FailingBall.zip
new file mode 100644
index 00000000..92f0b8f5
Binary files /dev/null and b/CustomView/Demo/FailingBall.zip differ
diff --git a/CustomView/Demo/PieView.zip b/CustomView/Demo/PieView.zip
new file mode 100644
index 00000000..f88db430
Binary files /dev/null and b/CustomView/Demo/PieView.zip differ
diff --git a/CustomView/Demo/dispatchTouchEventDemo.zip b/CustomView/Demo/dispatchTouchEventDemo.zip
new file mode 100644
index 00000000..665b5d4c
Binary files /dev/null and b/CustomView/Demo/dispatchTouchEventDemo.zip differ
diff --git a/CustomView/README.md b/CustomView/README.md
new file mode 100644
index 00000000..cf5a50ac
--- /dev/null
+++ b/CustomView/README.md
@@ -0,0 +1,56 @@
+# 自定义View系列
+
+从零起步，从入门到懵逼的自定义View教程。
+
+## 基础篇
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/LICENSE b/LICENSE
deleted file mode 100644
index 8f71f43f..00000000
--- a/LICENSE
+++ /dev/null
@@ -1,202 +0,0 @@
- Apache License
- Version 2.0, January 2004
- http://www.apache.org/licenses/
-
- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
- 1. Definitions.
-
- "License" shall mean the terms and conditions for use, reproduction,
- and distribution as defined by Sections 1 through 9 of this document.
-
- "Licensor" shall mean the copyright owner or entity authorized by
- the copyright owner that is granting the License.
-
- "Legal Entity" shall mean the union of the acting entity and all
- other entities that control, are controlled by, or are under common
- control with that entity. For the purposes of this definition,
- "control" means (i) the power, direct or indirect, to cause the
- direction or management of such entity, whether by contract or
- otherwise, or (ii) ownership of fifty percent (50%) or more of the
- outstanding shares, or (iii) beneficial ownership of such entity.
-
- "You" (or "Your") shall mean an individual or Legal Entity
- exercising permissions granted by this License.
-
- "Source" form shall mean the preferred form for making modifications,
- including but not limited to software source code, documentation
- source, and configuration files.
-
- "Object" form shall mean any form resulting from mechanical
- transformation or translation of a Source form, including but
- not limited to compiled object code, generated documentation,
- and conversions to other media types.
-
- "Work" shall mean the work of authorship, whether in Source or
- Object form, made available under the License, as indicated by a
- copyright notice that is included in or attached to the work
- (an example is provided in the Appendix below).
-
- "Derivative Works" shall mean any work, whether in Source or Object
- form, that is based on (or derived from) the Work and for which the
- editorial revisions, annotations, elaborations, or other modifications
- represent, as a whole, an original work of authorship. For the purposes
- of this License, Derivative Works shall not include works that remain
- separable from, or merely link (or bind by name) to the interfaces of,
- the Work and Derivative Works thereof.
-
- "Contribution" shall mean any work of authorship, including
- the original version of the Work and any modifications or additions
- to that Work or Derivative Works thereof, that is intentionally
- submitted to Licensor for inclusion in the Work by the copyright owner
- or by an individual or Legal Entity authorized to submit on behalf of
- the copyright owner. For the purposes of this definition, "submitted"
- means any form of electronic, verbal, or written communication sent
- to the Licensor or its representatives, including but not limited to
- communication on electronic mailing lists, source code control systems,
- and issue tracking systems that are managed by, or on behalf of, the
- Licensor for the purpose of discussing and improving the Work, but
- excluding communication that is conspicuously marked or otherwise
- designated in writing by the copyright owner as "Not a Contribution."
-
- "Contributor" shall mean Licensor and any individual or Legal Entity
- on behalf of whom a Contribution has been received by Licensor and
- subsequently incorporated within the Work.
-
- 2. Grant of Copyright License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- copyright license to reproduce, prepare Derivative Works of,
- publicly display, publicly perform, sublicense, and distribute the
- Work and such Derivative Works in Source or Object form.
-
- 3. Grant of Patent License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- (except as stated in this section) patent license to make, have made,
- use, offer to sell, sell, import, and otherwise transfer the Work,
- where such license applies only to those patent claims licensable
- by such Contributor that are necessarily infringed by their
- Contribution(s) alone or by combination of their Contribution(s)
- with the Work to which such Contribution(s) was submitted. If You
- institute patent litigation against any entity (including a
- cross-claim or counterclaim in a lawsuit) alleging that the Work
- or a Contribution incorporated within the Work constitutes direct
- or contributory patent infringement, then any patent licenses
- granted to You under this License for that Work shall terminate
- as of the date such litigation is filed.
-
- 4. Redistribution. You may reproduce and distribute copies of the
- Work or Derivative Works thereof in any medium, with or without
- modifications, and in Source or Object form, provided that You
- meet the following conditions:
-
- (a) You must give any other recipients of the Work or
- Derivative Works a copy of this License; and
-
- (b) You must cause any modified files to carry prominent notices
- stating that You changed the files; and
-
- (c) You must retain, in the Source form of any Derivative Works
- that You distribute, all copyright, patent, trademark, and
- attribution notices from the Source form of the Work,
- excluding those notices that do not pertain to any part of
- the Derivative Works; and
-
- (d) If the Work includes a "NOTICE" text file as part of its
- distribution, then any Derivative Works that You distribute must
- include a readable copy of the attribution notices contained
- within such NOTICE file, excluding those notices that do not
- pertain to any part of the Derivative Works, in at least one
- of the following places: within a NOTICE text file distributed
- as part of the Derivative Works; within the Source form or
- documentation, if provided along with the Derivative Works; or,
- within a display generated by the Derivative Works, if and
- wherever such third-party notices normally appear. The contents
- of the NOTICE file are for informational purposes only and
- do not modify the License. You may add Your own attribution
- notices within Derivative Works that You distribute, alongside
- or as an addendum to the NOTICE text from the Work, provided
- that such additional attribution notices cannot be construed
- as modifying the License.
-
- You may add Your own copyright statement to Your modifications and
- may provide additional or different license terms and conditions
- for use, reproduction, or distribution of Your modifications, or
- for any such Derivative Works as a whole, provided Your use,
- reproduction, and distribution of the Work otherwise complies with
- the conditions stated in this License.
-
- 5. Submission of Contributions. Unless You explicitly state otherwise,
- any Contribution intentionally submitted for inclusion in the Work
- by You to the Licensor shall be under the terms and conditions of
- this License, without any additional terms or conditions.
- Notwithstanding the above, nothing herein shall supersede or modify
- the terms of any separate license agreement you may have executed
- with Licensor regarding such Contributions.
-
- 6. Trademarks. This License does not grant permission to use the trade
- names, trademarks, service marks, or product names of the Licensor,
- except as required for reasonable and customary use in describing the
- origin of the Work and reproducing the content of the NOTICE file.
-
- 7. Disclaimer of Warranty. Unless required by applicable law or
- agreed to in writing, Licensor provides the Work (and each
- Contributor provides its Contributions) on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- implied, including, without limitation, any warranties or conditions
- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
- PARTICULAR PURPOSE. You are solely responsible for determining the
- appropriateness of using or redistributing the Work and assume any
- risks associated with Your exercise of permissions under this License.
-
- 8. Limitation of Liability. In no event and under no legal theory,
- whether in tort (including negligence), contract, or otherwise,
- unless required by applicable law (such as deliberate and grossly
- negligent acts) or agreed to in writing, shall any Contributor be
- liable to You for damages, including any direct, indirect, special,
- incidental, or consequential damages of any character arising as a
- result of this License or out of the use or inability to use the
- Work (including but not limited to damages for loss of goodwill,
- work stoppage, computer failure or malfunction, or any and all
- other commercial damages or losses), even if such Contributor
- has been advised of the possibility of such damages.
-
- 9. Accepting Warranty or Additional Liability. While redistributing
- the Work or Derivative Works thereof, You may choose to offer,
- and charge a fee for, acceptance of support, warranty, indemnity,
- or other liability obligations and/or rights consistent with this
- License. However, in accepting such obligations, You may act only
- on Your own behalf and on Your sole responsibility, not on behalf
- of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability
- incurred by, or claims asserted against, such Contributor by reason
- of your accepting any such warranty or additional liability.
-
- END OF TERMS AND CONDITIONS
-
- APPENDIX: How to apply the Apache License to your work.
-
- To apply the Apache License to your work, attach the following
- boilerplate notice, with the fields enclosed by brackets "{}"
- replaced with your own identifying information. (Don't include
- the brackets!) The text should be enclosed in the appropriate
- comment syntax for the file format. We also recommend that a
- file or class name and description of purpose be included on the
- same "printed page" as the copyright notice for easier
- identification within third-party archives.
-
- Copyright {yyyy} {name of copyright owner}
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
-
diff --git a/Lecture/README.md b/Lecture/README.md
new file mode 100644
index 00000000..959ec327
--- /dev/null
+++ b/Lecture/README.md
@@ -0,0 +1,4 @@
+# 演讲稿
+
+* [程序员练级指北(郑州GDG-2016DevFest)](https://github.com/GcsSloop/AndroidNote/blob/master/Lecture/gdg-developer-growth-guide.md)
+
diff --git a/Lecture/gdg-developer-growth-guide.md b/Lecture/gdg-developer-growth-guide.md
new file mode 100755
index 00000000..0a383423
--- /dev/null
+++ b/Lecture/gdg-developer-growth-guide.md
@@ -0,0 +1,165 @@
+# 程序员练级指北
+
+
+
+之前非常有幸收到 [脉脉不得语](https://github.com/inferjay) 的邀请参加 郑州GDG[^1] 举办的 DevFest[^2] 活动，并上台分享了一下自己的拙见，回来之后我将自己演讲的内容整理了一下，并分享给大家，希望对一些人有帮助，关于 郑州GDG 更多的活动内容，大家可以到 [GDGZhengzou](https://github.com/GDGZhengzhou/Events) 查看。另外，欢迎关注我的 [GitHub](https://github.com/GcsSloop) 和 [微博](http://weibo.com/GcsSloop) 。
+
+**我在本次活动中的演讲主题是《程序员练级指北》，主要内容如何从零开始，并逐渐成长为一名合格的程序员，里面的内容是基于自身的经历和见解所书写的，并不一定适合所有人，建议选择性采纳。**
+
+**为了演讲不那么枯燥乏味，我用了很多口语化的描述，并将程序员分了等级，从零装备的新手到钻石级别套装的大佬，其实各个等级之间并没有严格的分界点，只是大致的划分，大家理解便好。另外本文和现场演讲可能稍有差别，下面开始正文。**
+
+Hello，大家好，我是 GcsSloop，今天是我第一次在这么多陌生人面前装逼，啊不，演讲，心里很是忐忑，现在我还能感受到自己的心扑通扑通的跳。
+
+我呢，主要学习 Android，爱好装逼，喜欢钱，目前正在向段子手的方向上越走越远。
+
+非常高兴今天能站在这里向大家分享我自己的观点，因为在坐的的技术牛人太多了，作为一个没什么技术实力的新人，不敢在这里班门弄斧讲技术，要不然正讲着哪位大牛突然站起来说我讲的不对，这不就尴尬了么。
+
+由于本人爱好装逼，自然也研究了一些心得，所以我今天分享一下程序员如何在不同阶段正确的装逼。
+
+## 第一阶段 - 新手村
+
+
+
+作为编程的新手，自然是不能在大佬面前装逼的，否则分分钟被吊打。这一阶段我们要先给自己定一个小目标，什么是小目标呢？例如挣他个一百万？这对于我们来说当然是不现实的，作为编程菜鸟，小目标当然是稍微努力一下就能完成的，例如：看完几个新手教程，时间不要太长，两三天能完成的任务量就够了。当然了，光看还不行的，要发在朋友圈，让大家觉得你是一个非常有上进心的人。
+
+**为什么要发在朋友圈呢？装逼是一方面，除此之外，过了两天你就会发现，这两天光顾着打游戏了，新手教程居然忘记看了，这时候去看看朋友圈，再看看上面的赞，心里想如果这要是不弄完以后还如何在朋友面前装逼，自己装的逼跪着也要学完。**
+
+这一阶段注意两点：
+
+1. **任务周期要短，任务量要小**，如果周期太长，例如一个月，到月底发现弄不完了，就会想反正也弄不完了，就这样吧，容易破罐子破摔。
+2. **要形成周围的监督机制**，如果没人看着，反正也没人知道，那就随便学喽，过不了几天自己就放弃了。
+
+如果按照计划执行了第一阶段的任务，那么经过大约一两个月的时间，新手教程基本上就看完了，相当于集齐了一套新手装备，顺利进入下一阶段。
+
+## 第二阶段 - 初级套装
+
+
+
+初级套装虽然攻击和防御力都很弱，但至少能单挑一些野怪了，有了一定的装逼资本，这时候就要在新手村附近刷一些野怪练级。
+
+既然是刷怪升级，自然要选一个怪物比较集中的地方，最好还要有不同等级的怪物，这样方便刷经验，这个地方是哪里呢？个人觉得最适合的地方就是学校OJ题库，不一定要是自己学校的，大部分学校的OJ题库都是开放的，这里面的题目比较多，难度也分了很多等级，是非常适合新手练习的场所。不熟悉OJ系统的建议搜索了解一下。
+
+**这一阶段非常容易卡关，经常发现自己有两点不会，就是这也不会，那也不会。**
+
+然而作为编程界的新手，我们遇到的大部分问题肯定已经有大神踩过坑了，在99%的情况下，用百度或者Google搜索题目描述就能得到攻略方式，但不要偷懒直接复制，要自己亲自写一遍代码，这样有助于自己了解不同类型题目的模式。
+
+如果你发现了一道题的答案搜索不到，但是自己解决了，那么恭喜你捡到宝了，说明你遇到了一个稀有的或者新增的怪物，赶紧整理一下攻略过程发博客吧，又能装逼了。
+
+这样过了一段时间你就会发现，这些野怪大部分都很弱，只会几种常见的套路而已，除了最基础的题型外，归纳起来就是：堆、栈、树、表、图。
+
+每一类野怪都有特定的攻略方法，常用的有：枚举，遍历，分治，贪婪，动态，线性，暴力打表 以及 抖机灵。
+
+我在大一的时候加入了学校的打野攻略组，就是传说中的ACM，在里面待了大约有一年的时间，虽然没拿过大奖项，但好在通过刷题把自己的基础巩固了。
+
+这一阶段反映自己进步的最好标准就是 做题量 和 排行榜，我最高在校内排到前5，两年没有更新的情况下目前依旧在前50之内，不要问我哪个学校的，是我学校的，看一下OJ排行榜自然能认出我，我在排行榜上也叫GcsSloop。
+
+装逼完毕，进入下一阶段。
+
+## 第三阶段 - 青铜套装
+
+
+
+刷野怪时间长了就会发现其实也挺没意思的，不过好在能够练装备，把数据结构知识和一些常见的算法弄明白，熟悉敌人的攻击套路，这样经过一段时间后，装备基本也升级到青铜了，这时候就应该尝试去挑战一下区域小boss了。
+
+什么是挑战区域小boss呢，就是尝试制作一个完整的项目并发布出去，有人使用即可。
+
+挑战小boss可以组团或者单挑，个人虽然喜欢组团，但无奈我们学校这个服务器太弱了，基本找不到合适的队友，尝试了几次组队最终都以失败而告终，无奈只能去单挑。
+
+单挑boss要量力而行，不能找太强的boss，根据我自己的经验，单挑太强的boss会死的很难看，自己曾经有无数个项目胎死腹中或者半路夭折。
+
+选择一个比较弱的boss，例如：发布一个简单的 app 到应用市场，获取到一定的下载量，或者写一个开源库，获得一点 star。
+
+**这一阶段锻炼的是项目构建能力，能够完整的构建一个项目并发布出去，有人使用就算成功了。**
+
+这样既能带来成就感，又能装逼，发完之后记得告诉身边的人自己有内容发布了，再次装一波。
+
+## 第四阶段 - 白银套装
+
+
+
+单挑完一些区域小boss后，将套装升级为白银，有了一定的装逼资本，此时发现总在朋友圈装逼成就感太差了，这时候可以去论坛、贴吧、社区、微博等地方好好的装一把，让那些装备还没有升级起来的小白看看这套锃亮的白银套装是多么耀眼，不过仍要注意不能太过火，在出来帮助新手解决问题的时候顺便展示一下白银套装的威力就行了，装的太狠容易被大佬发现抓起来吊打，这不就尴尬了么。
+
+顺便说一下，如果从培训机构出来的，正常应该是白银初级，自身有基础加上比较努力可能会达到白银中级，能拿到白银套装说明已经达到了职业程序员最基本的标准。
+
+**很多人打到白银就开始迷茫了，去挑战小boss吧太没成就感，那些看起来就很肥美的中级和高级boss基本已经被大公司瓜分了，自己根本无从插手。所以这时候就要考虑加入公司的问题了。**
+
+那些比较好的公司，例如：网易、阿里、腾讯 等肯定有一堆人挤破头都想进，作为一个刚刚拿到白银套装的人想挤进去不能说没有机会，但肯定很难。但作为拥有白银套装的人，想加入一些小公司倒还算比较容易。
+
+个人建议初期有条件优先选择比较大的公司，因为这些公司资源多，有成熟的体系，可以帮助我们快速的在某一方向上获得长足的发展。
+
+后期则优先选择发展型的小公司，如果是从大公司跳向一个小公司，一般都会担任不错的职位，这可以帮助我们锻炼技术之外的能力，另外一个原因是随着公司成长可以分得一些红利。
+
+加入公司自然要考虑自身和公司的关系。
+
+个人觉得最核心的一点就是不要依附于公司，也不要抱有敌意，最好的办法就是和公司成为**利益共同体**，在自己为公司创造价值的同时利用公司强大的资源提升自己的能力。
+
+如果太过于依附公司，认为自己努力工作一定能得到相应回报的，根据经济学的假设，人都是自私而理性的，老板亦是如此，所以这类人大部分情况下都不会得到预期的结果。
+
+对公司抱有敌意，认为自己就是打工赚钱的，想偷懒干最少的活，拿最多的钱，因为在偷懒的同时错失了很多发展机会，所以这类人大部分会随着技术的升级而被淘汰掉。
+
+**如何与公司成为利益共同体呢？首先要明确自己的目标，自己加入公司是为了提升自己的能力，而不仅仅是来打工赚钱的，想要实现这一目标则是想办法干更多的活，这样老板肯定乐意，而我们通过干更多的活来接触更多的信息，并且把接触到的信息沉淀成为自己的经验积累，对自身发展也是有益的。**
+
+当然了，我们也不是傻子，当我们自身产生的价值远远超过公司给我们的薪资并且公司资源已经无法支撑我们继续提升的时候，就该抛弃这家公司跳槽了，这一次跳槽势必能进入一个更好的公司深造，可以利用更庞大的资源来辅助我们发展，接触到更多的信息。在信息时代，信息就是金钱，将信息沉淀成为个人经验并不能第一时间转化为金钱，但是总能在未来的某一时刻爆发出惊人的力量。
+
+## 第五阶段 - 黄金套装
+
+
+
+在白银阶段，就具备了职业程序员的基本素养，但是离出任CTO，迎娶白富美，走上人生巅峰还差的很远呢，想要实现这些目标，首先要拿到黄金套装。
+
+一般来说技术发现有两个方向可走：**深度 和 广度。**
+
+我自己使用的是树形型结构，大树的树，**一到两门追求深度，做树木主干，其余的最求广度，做树木枝叶**。
+
+> 有些人也称为T型知识结构，不过我觉得树形更佳贴切，因为我的所有周边技能都是围绕主干展开的，并且是可生长(拓展)的。
+
+我的主方向 Android，自学了 C、Java、Python、Web、Photoshop 等相关知识，除了主方向Android之外，其他方向作为辅助方向，仅仅了解了最基础的内容，也就是能够靠着搜索引擎写一些简单小程序的程度。
+
+树型知识架构有很多好处：
+
+1. **不被单一语言束缚，在实际场景中可以选择最合适的语言**。
+2. **可以跨领域突破，我在研究 Android 2D 绘图逻辑的时候就借鉴了很多 PS 的知识**。
+3. **预留发展空间大，假设某一天，Android市场饱和了或者前景变差了，我可以快速的从树枝中选择一支比较擅长的发展成为主干，而不用每次都从零开始**。
+
+其实我们大部分人都是俗人，是不是黄金套装都无所谓，能赚钱才行，很多人来做技术也是为了赚钱，所以接下来我说的是如何想办法用最小的代价产生最大的价值。想要赚钱首先要明白最基本的商业逻辑，如果我们通过正常的方式从别人那里赚到钱了，说明我们为别人提供了价值，这样别人才愿意付费给我们。
+
+所以我们要想办法用最小的代价为别人提供最大的价值，我写代码之前会多思考，没错，就是学生时代老师经常说的多思考。不过那时候没有人告诉我们该思考什么，因此我自己摸索出来了一套东西。
+
+1. **思考核心目标**，我们是为了某一件事情而写程序，并不是因为写程序了所以要完成这件事情。**核心目标是完成这件事情，而不是写程序。**
+2. **思考是否可以偷懒**，我是否可以用更简单的方式完成目标，例如**不写代码，少写代码**。
+3. **如果写代码了，是否可以产生附加价值**，例如我写这一段代码是否可以抽取成为一个开源库，是否可以将其中的设计思想整理成文共享出去。
+4. **如何产生更大的价值**，我的开源库或者文章如何才能服务更多人，让更多人了解到我的东西。因为只有服务更多人，才能产生更大的价值，我们也才可能从中拿走一部分利润。
+
+经历过这几步的思考，基本上就已经能将所写的每一段代码的价值潜力都发掘出来，进而用最小的力气服务最多的人。当然了，为了别人服务，只是产生了价值，在通常情况下，这部分价值是无法直接提现的，也就是说仅仅产生了价值但自身并没有收益。
+
+不过非常值得庆幸的是，今年很有可能成为内容付费元年，今年已经出来了很多内容变现工具，我知道的就有，微博长文打赏，简书打赏，知乎live，diycode原创打赏 和 掘金原创打赏。
+
+另外，最重要的是，**随着社会的快速发展，很多人有钱了，开始愿意为自己喜欢的事物打赏，这是一切的基础。**
+
+
+## 第六阶段 - 钻石套装
+
+
+
+能拿到钻石套装的人在全球范围内都是屈指可数的，这一类人通常是某一领域的开拓者，就是我们所说的 XXX之父。这些开拓者已经将自己的影响力渗透进了社会的各行各业，说他们推动了社会的进步也是可以的，我有生之年不说集齐套装，仅仅能拿一件钻石武器便足以令我心满意足了。
+
+## 结语
+
+前面啰嗦了这么多，最后告诉大家一个小秘密，如果你想要研究一个人发展的根本，不要直接去问他，因为别人很少会告诉你自己赖以生存的核心技能，他们只会告诉你看起来很光鲜的皮毛，就是所谓的心灵鸡汤，这些听起来很励志，但落实在自己身上通常没什么用，大多数情况下只会给你带来两三天的激情而已。
+
+正确的方法是观察他在做什么事情，以及分析他做这些事情的背后逻辑。如果你能把这些逻辑想清楚了，就把别人真正的核心技能偷过来了。之后根据自身情况一步一步的学着做就行了。
+
+**所以说，你们如果你们想了解我在做什么，为什么不考虑关注一下我的 [新浪微博](http://weibo.com/GcsSloop) 呢？关注一下又不会吃亏！**
+
+### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
+
+
+
+[^1]: GDG 全称 Google Developer Group，中文意思是 **谷歌开发者社区** 。
+
+[^2]: DevFest 开发者节，今年(2016)的举办时间是 9月1日 到 11月30日 之间，全球大部分谷歌开发者社区都会举办该活动，一年一次。
+
+
+
+
+
diff --git a/OpenGL/README.md b/OpenGL/README.md
new file mode 100644
index 00000000..3f834828
--- /dev/null
+++ b/OpenGL/README.md
@@ -0,0 +1,3 @@
+# OpenGL
+
+OpenGL 全称 Open Graphics Library,是用于渲染2D、3D矢量图形的跨语言、跨平台的应用程序编程接口(API)。OpenGL 常用于CAD、虚拟实境、科学可视化程序和电子游戏开发。
diff --git a/QuickChart/Bezier.md b/QuickChart/Bezier.md
new file mode 100644
index 00000000..e4adf995
--- /dev/null
+++ b/QuickChart/Bezier.md
@@ -0,0 +1,12 @@
+# 贝塞尔曲线常用操作速查表
+
+> ### 贝塞尔曲线的操作方法均包含在Path中，详情可参考[Path之贝塞尔曲线](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B6%5DPath_Bessel.md)
+
+> **表格中演示动画均来自维基百科**
+
+贝塞尔曲线 | 对应的方法 | 演示动画
+:-----------------------:|------------|------------------------------------------------------------------------------
+ 一阶曲线
(线性曲线) | lineTo | 
+ 二阶曲线 | quadTo | 
+三阶曲线 | cubicTo | 
+四阶曲线 | 无 | 
diff --git a/QuickChart/Canvas.md b/QuickChart/Canvas.md
new file mode 100644
index 00000000..5b5f269c
--- /dev/null
+++ b/QuickChart/Canvas.md
@@ -0,0 +1,28 @@
+# Canvas常用操作速查表
+
+| 操作分类 | 相关API | 备注 |
+| ---------- | ---------------------------------------- | ---------------------------------------- |
+| 绘制颜色 | drawColor, drawRGB, drawARGB | 使用单一颜色填充整个画布
**相关链接:**
[【基础－颜色】](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Base/%5B3%5DColor.md)
[【Canvas－颜色与基本形状】](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B2%5DCanvas_BasicGraphics.md) |
+| 绘制基本形状 | drawPoint, drawPoints, drawLine, drawLines, drawRect, drawRoundRect, drawOval, drawCircle, drawArc | 依次为 点、线、矩形、圆角矩形、椭圆、圆、圆弧
**相关链接 :**
[【Canvas－颜色与基本形状】](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B2%5DCanvas_BasicGraphics.md) |
+| 绘制图片 | drawBitmap, drawPicture | 绘制位图和图片
**相关链接:**
[【Canvas－图片文字】](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B4%5DCanvas_PictureText.md) |
+| 绘制文本 | drawText, drawPosText, drawTextOnPath | 依次为 绘制文字、绘制文字时指定每个文字位置、根据路径绘制文字
**相关链接:**
[【Canvas－图片文字】](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B4%5DCanvas_PictureText.md) |
+| 绘制路径 | drawPath | 绘制路径，绘制贝塞尔曲线时也需要用到该函数
**相关链接:**
[【Path－基本操作】](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B5%5DPath_Basic.md)
[【Path－贝塞尔曲线】](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B6%5DPath_Bezier.md)
[【Path－完结篇(伪)】](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B7%5DPath_Over.md)
[【Path－Path玩出花样(PathMeasure)】](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B08%5DPath_Play.md) |
+| 顶点操作 | drawVertices, drawBitmapMesh | 通过对顶点操作可以使图像形变，drawVertices直接对画布作用、 drawBitmapMesh只对绘制的Bitmap作用 |
+| 画布剪裁 | clipPath, clipRect | 设置画布的显示区域 |
+| 画布快照 | save, restore, saveLayerXxx, restoreToCount, getSaveCount | 依次为 保存当前状态、 回滚到上一次保存的状态、 保存图层状态、 会滚到指定状态、 获取保存次数
**相关链接:**
[【Canvas－画布操作】](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B3%5DCanvas_Convert.md) |
+| 画布变换 | translate, scale, rotate, skew | 依次为 位移、缩放、 旋转、错切
**相关链接:**
[【基础－坐标系】](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Base/%5B1%5DCoordinateSystem.md)
[【基础－角度弧度】](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Base/%5B2%5DAngleAndRadian.md)
[【Canvas－画布操作】](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B3%5DCanvas_Convert.md) |
+| Matrix(矩阵) | getMatrix, setMatrix, concat | 实际画布的位移，缩放等操作的都是图像矩阵Matrix，只不过Matrix比较难以理解和使用，故封装了一些常用的方法。
[【Matrix－原理】](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B09%5DMatrix_Basic.md) |
+
+| 操作类型 | 相关API | 备注 |
+| ---------- | ---------------------------------------- | ---------------------------------------- |
+| 基础方法 | getDensity, getWidth, getHeight，getDrawFilter，isHardwareAccelerated(API 11)，getMaximumBitmapWidth，getMaximumBitmapHeight，getDensity，quickReject，isOpaque，setBitmap，setDrawFilter | 使用单一颜色填充画布 |
+| 绘制颜色 | drawColor, drawRGB, drawARGB，drawPaint | 使用单一颜色填充画布 |
+| 绘制基本形状 | drawPoint, drawPoints, drawLine, drawLines, drawRect, drawRoundRect, drawOval, drawCircle, drawArc | 依次为 点、线、矩形、圆角矩形、椭圆、圆、圆弧 |
+| 绘制图片 | drawBitmap, drawPicture | 绘制位图和图片 |
+| 绘制文本 | drawText, drawPosText, drawTextOnPath | 依次为 绘制文字、绘制文字时指定每个文字位置、根据路径绘制文字 |
+| 绘制路径 | drawPath | 绘制路径，绘制贝塞尔曲线时也需要用到该函数 |
+| 顶点操作 | drawVertices, drawBitmapMesh | 通过对顶点操作可以使图像形变，drawVertices直接对画布作用、 drawBitmapMesh只对绘制的Bitmap作用 |
+| 画布剪裁 | clipPath, clipRect， clipRegion，getClipBounds | 画布剪裁相关方法 |
+| 画布快照 | save, restore, saveLayer, saveLayerXxx, restoreToCount, getSaveCount | 依次为 保存当前状态、 回滚到上一次保存的状态、 保存图层状态、 回滚到指定状态、 获取保存次数 |
+| 画布变换 | translate, scale, rotate, skew | 依次为 位移、缩放、 旋转、错切 |
+| Matrix(矩阵) | getMatrix, setMatrix, concat | 实际画布的位移，缩放等操作的都是图像矩阵Matrix，只不过Matrix比较难以理解和使用，故封装了一些常用的方法。 |
diff --git a/QuickChart/Matrix.md b/QuickChart/Matrix.md
new file mode 100644
index 00000000..6aaead2c
--- /dev/null
+++ b/QuickChart/Matrix.md
@@ -0,0 +1,19 @@
+# Matrix常用操作速查表
+
+| 方法类别 | 相关API | 摘要 |
+| -------- | ---------------------------------------- | -------------------------- |
+| 基本方法 | equals hashCode toString toShortString | 比较、 获取哈希值、 转换为字符串 |
+| 数值操作 | set reset setValues getValues | 设置、 重置、 设置数值、 获取数值 |
+| 数值计算 | mapPoints mapRadius mapRect mapVectors | 计算变换后的数值 |
+| 设置(set) | setConcat setRotate setScale setSkew setTranslate | 设置变换 |
+| 前乘(pre) | preConcat preRotate preScale preSkew preTranslate | 前乘变换 |
+| 后乘(post) | postConcat postRotate postScale postSkew postTranslate | 后乘变换 |
+| 特殊方法 | setPolyToPoly setRectToRect rectStaysRect setSinCos | 一些特殊操作 |
+| 矩阵相关 | invert isAffine(API21) isIdentity | 求逆矩阵、 是否为仿射矩阵、 是否为单位矩阵 ... |
+
+## 相关文章
+
+* [安卓自定义View进阶 - Matrix原理](http://www.gcssloop.com/customview/Matrix_Basic/)
+* [安卓自定义View进阶 - Matrix详解](http://www.gcssloop.com/customview/Matrix_Method/)
+* [安卓自定义View进阶 - Matrix Camera](http://www.gcssloop.com/customview/matrix-3d-camera)
+
diff --git a/QuickChart/Path.md b/QuickChart/Path.md
new file mode 100644
index 00000000..6ed41739
--- /dev/null
+++ b/QuickChart/Path.md
@@ -0,0 +1,31 @@
+# Path常用操作速查表
+
+> 为了兼容性(_偷懒_) 本表格中去除了在API21(即安卓版本5.0)以上才添加的方法。忍不住吐槽一下，为啥看起来有些顺手就能写的重载方法要等到API21才添加上啊。宝宝此刻内心也是崩溃的。
+
+作用 | 相关方法 | 备注
+----------------|-----------------|------------------------------------------
+移动起点 | moveTo | 移动下一次操作的起点位置
+设置终点 | setLastPoint | 重置当前path中最后一个点位置，如果在绘制之前调用，效果和moveTo相同
+连接直线 | lineTo | 添加上一个点到当前点之间的直线到Path
+闭合路径 | close | 连接第一个点连接到最后一个点，形成一个闭合区域
+添加内容 | addRect, addRoundRect, addOval, addCircle, addPath, addArc, arcTo | 添加(矩形， 圆角矩形， 椭圆， 圆， 路径， 圆弧) 到当前Path (注意addArc和arcTo的区别)
+是否为空 | isEmpty | 判断Path是否为空
+是否为矩形 | isRect | 判断path是否是一个矩形
+替换路径 | set | 用新的路径替换到当前路径所有内容
+偏移路径 | offset | 对当前路径之前的操作进行偏移(不会影响之后的操作)
+贝塞尔曲线 | quadTo, cubicTo | 分别为二次和三次贝塞尔曲线的方法
+rXxx方法 | rMoveTo, rLineTo, rQuadTo, rCubicTo | **不带r的方法是基于原点的坐标系(偏移量)， rXxx方法是基于当前点坐标系(偏移量)**
+填充模式 | setFillType, getFillType, isInverseFillType, toggleInverseFillType | 设置,获取,判断和切换填充模式
+提示方法 | incReserve | 提示Path还有多少个点等待加入**(这个方法貌似会让Path优化存储结构)**
+布尔操作(API19) | op | 对两个Path进行布尔运算(即取交集、并集等操作)
+计算边界 | computeBounds | 计算Path的边界
+重置路径 | reset, rewind | 清除Path中的内容
**reset不保留内部数据结构，但会保留FillType.**
**rewind会保留内部的数据结构，但不保留FillType**
+矩阵操作 | transform | 矩阵变换
+
+## 相关文章
+
+* [Path基本操作](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B5%5DPath_Basic.md)
+* [贝塞尔曲线](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B6%5DPath_Bezier.md)
+* [Path完结篇(伪)](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B7%5DPath_Over.md)
+* [Path玩出花样](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B8%5DPath_Play.md)
+
diff --git a/QuickChart/README.md b/QuickChart/README.md
new file mode 100644
index 00000000..50800265
--- /dev/null
+++ b/QuickChart/README.md
@@ -0,0 +1,7 @@
+# 速查表
+
+
+* [Canvas常用操作速查表](https://github.com/GcsSloop/AndroidNote/blob/master/QuickChart/Canvas.md)
+* [Path常用操作速查表](https://github.com/GcsSloop/AndroidNote/blob/master/QuickChart/Path.md)
+* [Matrix常用操作速查表](https://github.com/GcsSloop/AndroidNote/blob/master/QuickChart/Matrix.md)
+* [贝塞尔曲线常用操作速查表](https://github.com/GcsSloop/AndroidNote/blob/master/QuickChart/Bezier.md)
diff --git a/README.md b/README.md
index 823ecb7b..1e8b8821 100644
--- a/README.md
+++ b/README.md
@@ -1,30 +1,181 @@
-# AndroidNote
+
+
### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
-我的安卓学习笔记，记录学习过程中遇到的问题,以及我发布的安卓相关文章。
+我的安卓学习笔记，记录学习过程中遇到的问题,以及我的一些经验总结。如果出现链接失效等情况可以提交 Issues 提醒我修改相关内容。
+
+> #### PS:点击分类标题可以查看该分类的详细信息。
+
+## [博客](http://www.gcssloop.com/#blog "GcsSloop的博客")
+
+我的个人博客，在博客中可以获得更好的阅读体验，同时在博客的评论区可以更及时的向我反馈文章中的问题。
+
+ 
+
+******
+
+
+
+## [自定义View](https://github.com/GcsSloop/AndroidNote/tree/master/CustomView/README.md)
+
+* 基础篇
+ * [安卓自定义View基础 - 坐标系](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Base/%5B01%5DCoordinateSystem.md)
+ * [安卓自定义View基础 - 角度弧度](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Base/%5B02%5DAngleAndRadian.md)
+ * [安卓自定义View基础 - 颜色](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Base/%5B03%5DColor.md)
+* 进阶篇
+ * [安卓自定义View进阶 - 分类和流程](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B01%5DCustomViewProcess.md)
+ * [安卓自定义View进阶 - 绘制基本图形](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B02%5DCanvas_BasicGraphics.md)
+ * [安卓自定义View进阶 - 画布操作](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B03%5DCanvas_Convert.md)
+ * [安卓自定义View进阶 - 图片文字](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B04%5DCanvas_PictureText.md)
+ * [安卓自定义View进阶 - Path基本操作](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B05%5DPath_Basic.md)
+ * [安卓自定义View进阶 - 贝塞尔曲线](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B06%5DPath_Bezier.md)
+ * [安卓自定义View进阶 - Path完结篇(伪)](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B07%5DPath_Over.md)
+ * [安卓自定义View进阶 - Path玩出花样(PathMeasure)](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B08%5DPath_Play.md)
+ * [安卓自定义View进阶 - Matrix原理](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B09%5DMatrix_Basic.md)
+ * [安卓自定义View进阶 - Matrix详解](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B10%5DMatrix_Method.md)
+ * [安卓自定义View进阶 - Matrix Camera](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B11%5DMatrix_3D_Camera.md)
+ * [安卓自定义View进阶 - 事件分发机制原理](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B12%5DDispatch-TouchEvent-Theory.md)
+ * [安卓自定义View进阶 - 事件分发机制详解](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B15%5DDispatch-TouchEvent-Source.md)
+ * [安卓自定义View进阶 - MotionEvent详解](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B16%5DMotionEvent.md)
+ * [安卓自定义View进阶 - 特殊形状控件事件处理方案](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B17%5Dtouch-matrix-region.md)
+ * [安卓自定义View进阶 - 多点触控详解](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B18%5Dmulti-touch.md)
+ * [安卓自定义View进阶 - 手势检测(GestureDetector)](https://github.com/GcsSloop/AndroidNote/blob/master/CustomView/Advance/%5B19%5Dgesture-detector.md)
+ * [安卓自定义View进阶 - 缩放手势检测(ScaleGestureDetector)](http://www.gcssloop.com/customview/scalegesturedetector)
+ * [安卓自定义View进阶 - 画笔基础(Paint)](http://www.gcssloop.com/customview/paint-base)
+
+
+* [ViewSupport - 自定义View工具包](https://github.com/GcsSloop/ViewSupport)
+
+******
+
+## 雕虫晓技
+
+* [雕虫晓技(一) 组件化](http://www.gcssloop.com/gebug/componentr)
+* [雕虫晓技(二) 编码](http://www.gcssloop.com/gebug/coding)
+* [雕虫晓技(三) 通用圆角布局全解析](http://www.gcssloop.com/gebug/rclayout)
+* [雕虫晓技(四) 搭建私有Maven仓库(带容灾备份)](http://www.gcssloop.com/gebug/maven-private)
+* [雕虫晓技(五) 网格分页布局源码解析(上) (付费)](https://xiaozhuanlan.com/topic/5841730926)
+* [雕虫晓技(六) 网格分页布局源码解析(下) (付费)](https://xiaozhuanlan.com/topic/1456397082)
+* [雕虫晓技(七) 用旧Android手机做远程摄像头](http://www.gcssloop.com/gebug/internet-ip-webcam)
+* [雕虫晓技(八) Android与数据流的斗争](http://www.gcssloop.com/gebug/android-stream)
+* [雕虫晓技(九) Netty与私有协议框架](http://www.gcssloop.com/gebug/netty-private-protocol)
+* [雕虫晓技(十) Android超简单气泡效果](http://www.gcssloop.com/gebug/bubble-sample)
+
+******
+
+## [教程类](https://github.com/GcsSloop/AndroidNote/tree/master/Course/README.md)
+
+* [在AndroidStudio中使用PlantUML(Win)](https://github.com/GcsSloop/AndroidNote/blob/master/Course/HowToUsePlantUMLInAS.md)
+* [在AndroidStudio中使用PlantUML(Mac)](https://github.com/GcsSloop/AndroidNote/blob/master/Course/HowToUsePlantUMLInAS%5BMac%5D.md)
+* [优雅的发布Android开源库(论JitPack的优越性)](https://github.com/GcsSloop/AndroidNote/blob/master/Course/ReleaseLibraryByJitPack.md)
+* [用JitPack发布时附加文档和源码](https://github.com/GcsSloop/AndroidNote/blob/master/Course/jitpack-javadoc.md)
+
+******
+
+## [Markdown](https://github.com/GcsSloop/AndroidNote/tree/master/Course/Markdown)
+
+* [Markdown 快速入门](https://github.com/GcsSloop/AndroidNote/blob/master/Course/Markdown/markdown-start.md)
+* [Markdown 基础语法](https://github.com/GcsSloop/AndroidNote/blob/master/Course/Markdown/markdown-grammar.md)
+* [Markdown 链接图片](https://github.com/GcsSloop/AndroidNote/blob/master/Course/Markdown/markdown-link.md)
+* [Markdown 编辑器](https://github.com/GcsSloop/AndroidNote/blob/master/Course/Markdown/markdown-editor.md)
+
+******
+
+## Tips
+
+* [ArrayList与LinkedList遍历性能比较](https://github.com/GcsSloop/AndroidNote/blob/magic-world/ChaosCrystal/List%E9%81%8D%E5%8E%86%E6%80%A7%E8%83%BD.md)
+* [程序员不可不知的版权协议](https://github.com/GcsSloop/AndroidNote/blob/magic-world/ChaosCrystal/%E5%BC%80%E6%BA%90%E5%85%B1%E4%BA%AB%E5%8D%8F%E8%AE%AE.md)
+
+******
+
+## [速查表](https://github.com/GcsSloop/AndroidNote/tree/master/QuickChart/README.md)
-如果出现链接失效等情况可以提交Issues提醒我修改相关内容。
+* [Canvas常用操作速查表](https://github.com/GcsSloop/AndroidNote/blob/master/QuickChart/Canvas.md)
+* [Path常用操作速查表](https://github.com/GcsSloop/AndroidNote/blob/master/QuickChart/Path.md)
+* [Matrix常用操作速查表](https://github.com/GcsSloop/AndroidNote/blob/master/QuickChart/Matrix.md)
+* [贝塞尔曲线常用操作速查表](https://github.com/GcsSloop/AndroidNote/blob/master/QuickChart/Bezier.md)
+******
-## 自定义View系列
+## [混沌水晶](https://github.com/GcsSloop/AndroidNote/tree/master/ChaosCrystal/README.md)
-**基础篇** |
-:---: |
- |
- |
+混沌水晶本身并没有太大功效，但与其他物品合成之后可能产生质的变化。
+* [Android中dip、dp、sp、pt和px](https://github.com/GcsSloop/AndroidNote/blob/master/ChaosCrystal/Android%E4%B8%ADdip%E3%80%81dp%E3%80%81sp%E3%80%81pt%E5%92%8Cpx.md)
+* [AndroidStudio常用快捷键(Mac)](https://github.com/GcsSloop/AndroidNote/blob/master/ChaosCrystal/AndroidStudio%E5%B8%B8%E7%94%A8%E5%BF%AB%E6%8D%B7%E9%94%AE(Mac).md)
+* [在线查看Android API源码](https://github.com/GcsSloop/AndroidNote/blob/master/ChaosCrystal/HowToViewAPISourceOnline.md)
+* [录屏与GIF制作](https://github.com/GcsSloop/AndroidNote/blob/master/ChaosCrystal/%E5%BD%95%E5%B1%8F%E4%B8%8EGIF%E5%88%B6%E4%BD%9C.md)
+* [ADB常用命令](https://github.com/GcsSloop/AndroidNote/blob/master/ChaosCrystal/ADB%E5%B8%B8%E7%94%A8%E5%91%BD%E4%BB%A4.md)
- 问题 | 描述
- --- | ---
- [Canvas(4)](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/Canvas/Path/Path(1).md) | Path1~直线
- [Canvas(3)](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/Canvas/Canvas(3).md) | 图片与文字
- [Canvas(2)](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/Canvas/Canvas(2).md) | 画布操作
- [Canvas(1)](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/Canvas/Canvas(1).md) | 颜色与基本图形
- [View几个重要的函数](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/View/%E8%87%AA%E5%AE%9A%E4%B9%89View%E5%87%A0%E4%B8%AA%E9%87%8D%E8%A6%81%E7%9A%84%E5%87%BD%E6%95%B0.md) | 自定义View流程与重要的函数
-[颜色](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/%E9%A2%9C%E8%89%B2/%E9%A2%9C%E8%89%B2.md) | 介绍安卓中颜色相关问题
+******
+## 开源库
-## About Me
+* [arc-seekbar - 弧形SeekBar](https://github.com/GcsSloop/arc-seekbar)
+* [encrypt - 加密工具包](https://github.com/GcsSloop/encrypt)
+* [rclayout - 通用圆角布局](https://github.com/GcsSloop/rclayout)
+* [FontsManager - 快速替换字体](https://github.com/GcsSloop/FontsManager)
+* [Rocker － 自定义摇杆](https://github.com/GcsSloop/Rocker)
+* [LeafLoading － 进度条](https://github.com/GcsSloop/LeafLoading)
+* [Rotate3dAnimation - 3D旋转动画(修正版)](https://github.com/GcsSloop/Rotate3dAnimation)
+
+------
+
+## 源码解析
+
+- [AtomicFile 源码解析](https://github.com/GcsSloop/AndroidNote/blob/master/SourceAnalysis/AtomicFile.md)
+
+## 传送门
+
+通往异世界的传送门，请谨慎使用。
+
+时空折跃准备完毕，[点击开始传送](https://github.com/GcsSloop/AndroidNote/tree/magic-world)。
+
+*****
+
+## 博文修复计划
+
+由于自己的知识水平有限，书写的文章难免会出现一些问题。
+
+随着知识增长和知识面的扩大，发现了一些之前未曾注意到的问题，故有此博文修复计划，本次修复不仅会修复之前文章中的瑕疵和纰漏，甚至会对文章的知识结构稍作调整，所有修复的文章和调整后的内容都会在微博重新发布声明，点击下面关注我的微博可以第一时间了解到相关信息，另外据说关注我的微博会变帅哦。
+
+**本次博文修复计划主要针对 [个人博客](http://www.gcssloop.com/#blog) 和 [GitHub](https://github.com/GcsSloop)，由于博主精力有限以及某些平台自身限制，对于其他平台仅能修复部分内容。**
+
+******
+
+## 版权声明
+
+* 所有原创文章(未进行特殊标识的均属于原创) 的著作权属于 **GcsSloop**。
+* 所有转载文章(标题注明`[转]`的所有文章) 的著作权属于原作者。
+* 所有译文文章(标题注明`[译]`的所有文章) 的原文著作权属于原作者，译文著作权属于 **GcsSloop**。
+
+#### 转载注意事项
+
+除注明外，所有文章均采用 [Creative Commons BY-NC-ND 4.0（自由转载-保持署名-非商用-禁止演绎）](http://creativecommons.org/licenses/by-nc-nd/4.0/deed.zh)协议发布。
+
+你可以在非商业的前提下免费转载，但同时你必须：
+
+* 保持文章原文，不作修改。
+* 明确署名，即至少注明 `作者：GcsSloop` 字样以及文章的原始链接，且不得使用 `rel="nofollow"` 标记。
+* 商业用途请点击最下面图片联系本人。
+* 微信公众号转载一律不授权 `原创` 标志。
+
+## 捐赠
+
+#### 如果你觉得我的文章有帮助的话，捐赠一些晶石，鼓励我继续研究! 🐾
+
+| | |
+| ---------------------------------------- | ---------------------------------------- |
+|  |  |
+
+## 交流群
+
+QQ群：612310796
+微信群：加我个人微信 GcsSloop，备注加群。
+
+
+### 作者微博: [@GcsSloop](http://weibo.com/GcsSloop)
-
+
+[▲ 回到顶部](#top)
diff --git a/SourceAnalysis/AtomicFile.md b/SourceAnalysis/AtomicFile.md
new file mode 100644
index 00000000..78e669c2
--- /dev/null
+++ b/SourceAnalysis/AtomicFile.md
@@ -0,0 +1,276 @@
+# AtomicFile 源码解析
+
+
+
+## 什么是 AtomicFile ?
+
+AtomicFile 在 `android.support.v4.util` 包下，**是一个与文件相关的工具类，其作用是保证文件读写的原子性。** 即文件读写的时候全部成功才会更新文件，如果失败则不会影响文件内容。
+
+看官方对其说明：
+
+> Static library support version of the framework's `AtomicFile`, a helper class for performing atomic operations on a file by creating a backup file until a write has successfully completed.
+>
+> 静态支持库版本的AtomicFile，一个帮助类，用于通过创建备份文件对文件执行原子操作，直到写入成功完成。
+>
+> Atomic file guarantees file integrity by ensuring that a file has been completely written and sync'd to disk before removing its backup. As long as the backup file exists, the original file is considered to be invalid (left over from a previous attempt to write the file).
+>
+> 原子文件通过确保文件在删除其备份之前已经完全写入并同步到磁盘，从而保证文件的完整性。只要备份文件存在，原始文件将被视为无效（会尝试写入备份文件中）。
+>
+> Atomic file does not confer any file locking semantics. Do not use this class when the file may be accessed or modified concurrently by multiple threads or processes. The caller is responsible for ensuring appropriate mutual exclusion invariants whenever it accesses the file.
+>
+> 原子文件不提供任何文件锁定语义。当文件可能被多个线程或进程并发访问或修改时，不要使用此类。每当访问文件时，调用者都负责确保适当的互斥变量。
+
+## 主要方法
+
+| 返回值 | 方法名称和简介 |
+| :------------------: | ---------------------------------------- |
+| | **AtomicFile(File baseName)**
构造方法，通过File创建AtomicFile |
+| **FileOutputStream** | **startWrite()**
准备写文件，获得一个向文件写入的字节流(FileOutputStream)。 |
+| **void** | **finishWrite(FileOutputStream str)**
写入完毕时调用。 |
+| **void** | **failWrite(FileOutputStream str)**
写入失败时调用。 |
+| **FileInputStream** | **openRead()**
准备读取文件，获得一个从文件读取的字节流(FileInputStream)。 |
+| **byte[]** | **readFully()**
将文件中所有内容读取出来用 byte 数组返回，相当于更方便的 openRead 方法。 |
+| **File** | **getBaseFile()**
获得原文件地址。 |
+| **void** | **delete()**
删除 AtomicFile，包括原文件和备份文件。 |
+
+## AtomicFile 原理
+
+AtomicFile 原理其实非常简单，下面用一张图简单展示一下其原理：
+
+
+
+## AtomicFile 源码解析
+
+源码解析非常简单，根据上面表格中的内容按顺序一个一个看吧。
+
+
+
+#### 构造函数：
+
+根据传进来的文件创建 AtomicFile 类，同时创建辅助备份文件(空文件)。
+
+```java
+private final File mBaseName;
+private final File mBackupName;
+
+public AtomicFile(File baseName) {
+ mBaseName = baseName; // 记录原始文件
+ mBackupName = new File(baseName.getPath() + ".bak"); // 创建备份文件
+}
+```
+
+
+
+#### 开始写入(startWrite)
+
+在获取向文件写入的输出流之前，它会对原文件进行备份，同时清除原文件内容。
+
+同时根据其原理可知，它并不是线程安全的，如果需要多线程操作等，最好自己加锁，如果一个线程未写完，直接开启了另一个线程进行写入可能会导致文件内容丢失。
+
+**另外使用这种方法获得到的 FileOutputStream 不要直接关闭，写入完成的时候需要调用 `finishWrite` 或者`failWrite` 进行关闭，否则下次读取的时候会因为备份文件存在而使本次写入失效。**
+
+```java
+public FileOutputStream startWrite() throws IOException {
+ // 当原文件存在，备份文件不存在的时候，原文件更名为备份文件
+ if (mBaseName.exists()) {
+ if (!mBackupName.exists()) {
+ // 如果原文件存在且备份文件不存在，直接将原文件重命名为备份文件
+ if (!mBaseName.renameTo(mBackupName)) {
+ Log.w("AtomicFile", "Couldn't rename file " + mBaseName
+ + " to backup file " + mBackupName);
+ }
+ } else {
+ mBaseName.delete(); // 删除原文件
+ }
+ }
+ // 保证原文件存在，并根据原文件创建一个输出流。
+ FileOutputStream str = null;
+ try {
+ str = new FileOutputStream(mBaseName);
+ } catch (FileNotFoundException e) {
+ File parent = mBaseName.getParentFile();
+ if (!parent.mkdirs()) {
+ throw new IOException("Couldn't create directory " + mBaseName);
+ }
+ FileUtils.setPermissions(
+ parent.getPath(),
+ FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IXOTH,
+ -1, -1);
+ try {
+ str = new FileOutputStream(mBaseName);
+ } catch (FileNotFoundException e2) {
+ throw new IOException("Couldn't create " + mBaseName);
+ }
+ }
+ return str; // 返回输出流。
+}
+```
+
+
+
+#### 写入完成(finishWrite)
+
+写入完成的时候需要用户调用该方法，该方法会关闭 FileOutputStream ，并且会删除备份文件以保证文件的唯一性。
+
+```java
+public void finishWrite(FileOutputStream str) {
+ if (str != null) {
+ FileUtils.sync(str);
+ try {
+ str.close();
+ mBackupName.delete();
+ } catch (IOException e) {
+ Log.w("AtomicFile", "finishWrite: Got exception:", e);
+ }
+ }
+}
+```
+
+
+
+#### 写入失败(failWrite)
+
+写入失败时会调用该方法，该方法会关闭 FileOutputStream，并且从备份文件恢复文件内容。
+
+```java
+public void failWrite(FileOutputStream str) {
+ if (str != null) {
+ FileUtils.sync(str);
+ try {
+ str.close();
+ mBaseName.delete();
+ mBackupName.renameTo(mBaseName);
+ } catch (IOException e) {
+ Log.w("AtomicFile", "failWrite: Got exception:", e);
+ }
+ }
+}
+```
+
+
+
+#### 准备读取(openRead)
+
+该方法会获取到一个读取文件的输入流(FileInputStream)，并且在备份文件存在时，会简单粗暴的删除原文件，并从备份文件恢复内容。
+
+```java
+public FileInputStream openRead() throws FileNotFoundException {
+ if (mBackupName.exists()) {
+ mBaseName.delete();
+ mBackupName.renameTo(mBaseName);
+ }
+ return new FileInputStream(mBaseName);
+}
+```
+
+
+
+#### 读取全部(readFully)
+
+该方法会将文件中的所有内容转化为一个 byte 数组并且返回，所以不建议使用该方法读取大文件。
+
+```java
+public byte[] readFully() throws IOException {
+ FileInputStream stream = openRead();
+ try {
+ int pos = 0;
+ int avail = stream.available();
+ byte[] data = new byte[avail];
+ // 通过循环读取的方式将文件所有内容都装入 byte 数组中。
+ while (true) {
+ int amt = stream.read(data, pos, data.length-pos);
+ //Log.i("foo", "Read " + amt + " bytes at " + pos
+ // + " of avail " + data.length);
+ if (amt <= 0) {
+ //Log.i("foo", "**** FINISHED READING: pos=" + pos
+ // + " len=" + data.length);
+ return data;
+ }
+ pos += amt;
+ avail = stream.available();
+ if (avail > data.length-pos) {
+ byte[] newData = new byte[pos+avail];
+ System.arraycopy(data, 0, newData, 0, pos);
+ data = newData;
+ }
+ }
+ } finally {
+ stream.close();
+ }
+}
+```
+
+
+
+#### 获取原文件(getBaseFile)
+
+该方法用于获取原文件路径，但通常情况下并不推荐使用，因为获取到的原文件可能是损坏的或者无效的。
+
+```java
+public File getBaseFile() {
+ return mBaseName;
+}
+```
+
+
+
+#### 删除(delete)
+
+该方法会直接删除原文件和备份文件。
+
+```java
+public void delete() {
+ mBaseName.delete();
+ mBackupName.delete();
+}
+```
+
+
+
+## 简单示例
+
+
+
+## FAQ
+
+**Q：AtmoicFile 适用于哪些文件？**
+
+> A：**AtomicFile 适用一次性写入的文件**。根据 AtomicFile 原理可知，每一次获取写入文件的输出流的时候都会清空原文件的内容，所以是无法给文件追加内容的。
+
+**Q：AtmoicFile 是否是线程安全的？**
+
+> A：根据其原理就可知它没有带线程锁，所以**AtomicFile并不能保证线程安全**。
+
+**Q：文件写入完毕后可以直接关闭输出字节流(FileOutputStream)么？**
+
+> A：AtomicFile写入完毕后是不允许直接关闭字节流的，因为直接关闭字节流会导致备份文件没有删除，因而下次读取的时候会导致读取到的是原文件，而不是更新后的文件。
+> **写入完毕后应调用 finishWrite(正常写入完成) 或者 failWrite(写入失败)。**
+
+**Q：文件读取完毕后可以直接关闭输入字节流(FileInputStream)么？**
+
+> A：可以。
+
+
+
+## 结语
+
+AtomicFile 作为一个工具类，有其方便之处，同时也有一些需要注意的地方，例如不能追加内容，另外，AtomicFile 除了上述方法之外，还有另外几个方法没有在本文中说明，这几个方法由于不安全，已经被标注删除和隐藏，故本文就不在赘述了。
+
+事实上 AtomicFile 逻辑非常简单，应用场景也有限，如果需要的话自己徒手写一个也是可以的，个人觉得它的作用并不太大，如果以后大家在源码或者其他地方见到了这个类，知道它是干什么的就行了。
+
+**最后，任何工具都是双刃剑，用好了伤人，用不好伤己，希望大家用之前好好了解一下其利弊，权衡之后再做决定。**
+
+
+
+## 参考资料
+
+[Guide - AtomicFile](https://developer.android.com/reference/android/support/v4/util/AtomicFile.html)
+[源码 - AtomicFile](https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/util/AtomicFile.java)
+
+
+
+## About Me
+
+### 作者微博: @GcsSloop
+
+
\ No newline at end of file
diff --git a/SourceAnalysis/CircularArray.md b/SourceAnalysis/CircularArray.md
new file mode 100644
index 00000000..e69de29b
diff --git a/SourceAnalysis/README.md b/SourceAnalysis/README.md
new file mode 100644
index 00000000..6924a8e2
--- /dev/null
+++ b/SourceAnalysis/README.md
@@ -0,0 +1,3 @@
+# 源码解析
+
+* [AtomicFile 源码解析](https://github.com/GcsSloop/AndroidNote/blob/master/SourceAnalysis/AtomicFile.md)
diff --git "a/\351\227\256\351\242\230/Canvas/Art/Oval.png" "b/\351\227\256\351\242\230/Canvas/Art/Oval.png"
deleted file mode 100644
index 54370fac..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art/Oval.png" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art/RoundRect.png" "b/\351\227\256\351\242\230/Canvas/Art/RoundRect.png"
deleted file mode 100644
index 69ab5df1..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art/RoundRect.png" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art/drawArc1.jpeg" "b/\351\227\256\351\242\230/Canvas/Art/drawArc1.jpeg"
deleted file mode 100644
index 9fe89101..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art/drawArc1.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art/drawArc2.jpeg" "b/\351\227\256\351\242\230/Canvas/Art/drawArc2.jpeg"
deleted file mode 100644
index 35a2300b..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art/drawArc2.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art/drawCircle.jpeg" "b/\351\227\256\351\242\230/Canvas/Art/drawCircle.jpeg"
deleted file mode 100644
index dd6ed255..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art/drawCircle.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art/drawColor.jpeg" "b/\351\227\256\351\242\230/Canvas/Art/drawColor.jpeg"
deleted file mode 100644
index 530a14a5..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art/drawColor.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art/drawLine.jpeg" "b/\351\227\256\351\242\230/Canvas/Art/drawLine.jpeg"
deleted file mode 100644
index b6ad10ab..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art/drawLine.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art/drawOval.jpeg" "b/\351\227\256\351\242\230/Canvas/Art/drawOval.jpeg"
deleted file mode 100644
index 66354dd8..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art/drawOval.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art/drawPoint.jpeg" "b/\351\227\256\351\242\230/Canvas/Art/drawPoint.jpeg"
deleted file mode 100644
index 10729758..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art/drawPoint.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art/drawRect.jpeg" "b/\351\227\256\351\242\230/Canvas/Art/drawRect.jpeg"
deleted file mode 100644
index 50410260..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art/drawRect.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art/drawRoundRect1.jpeg" "b/\351\227\256\351\242\230/Canvas/Art/drawRoundRect1.jpeg"
deleted file mode 100644
index 20cc954b..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art/drawRoundRect1.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art/drawRoundRect3.jpeg" "b/\351\227\256\351\242\230/Canvas/Art/drawRoundRect3.jpeg"
deleted file mode 100644
index f9d8c5b5..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art/drawRoundRect3.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art/paintStyle.jpeg" "b/\351\227\256\351\242\230/Canvas/Art/paintStyle.jpeg"
deleted file mode 100644
index 242f945a..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art/paintStyle.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art/pie.png" "b/\351\227\256\351\242\230/Canvas/Art/pie.png"
deleted file mode 100644
index f364eed6..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art/pie.png" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art/pieView.jpeg" "b/\351\227\256\351\242\230/Canvas/Art/pieView.jpeg"
deleted file mode 100644
index 9416b7a6..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art/pieView.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art2/layer.png" "b/\351\227\256\351\242\230/Canvas/Art2/layer.png"
deleted file mode 100644
index ff63b415..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art2/layer.png" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art2/rotate1.jpg" "b/\351\227\256\351\242\230/Canvas/Art2/rotate1.jpg"
deleted file mode 100644
index 79fb11cc..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art2/rotate1.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art2/rotate2.jpg" "b/\351\227\256\351\242\230/Canvas/Art2/rotate2.jpg"
deleted file mode 100644
index 07ed907a..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art2/rotate2.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art2/rotate3.jpg" "b/\351\227\256\351\242\230/Canvas/Art2/rotate3.jpg"
deleted file mode 100644
index f135013e..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art2/rotate3.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art2/scale1.jpg" "b/\351\227\256\351\242\230/Canvas/Art2/scale1.jpg"
deleted file mode 100644
index 050049cc..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art2/scale1.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art2/scale2.jpg" "b/\351\227\256\351\242\230/Canvas/Art2/scale2.jpg"
deleted file mode 100644
index 85786c48..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art2/scale2.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art2/scale3.jpg" "b/\351\227\256\351\242\230/Canvas/Art2/scale3.jpg"
deleted file mode 100644
index b6bab08b..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art2/scale3.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art2/scale4.jpg" "b/\351\227\256\351\242\230/Canvas/Art2/scale4.jpg"
deleted file mode 100644
index f14148c4..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art2/scale4.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art2/scale5.jpg" "b/\351\227\256\351\242\230/Canvas/Art2/scale5.jpg"
deleted file mode 100644
index 82630e11..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art2/scale5.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art2/skew1.jpg" "b/\351\227\256\351\242\230/Canvas/Art2/skew1.jpg"
deleted file mode 100644
index 90c583b3..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art2/skew1.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art2/skew2.jpg" "b/\351\227\256\351\242\230/Canvas/Art2/skew2.jpg"
deleted file mode 100644
index df2a0641..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art2/skew2.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art2/stack1.png" "b/\351\227\256\351\242\230/Canvas/Art2/stack1.png"
deleted file mode 100644
index e2d76436..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art2/stack1.png" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art2/translate.jpg" "b/\351\227\256\351\242\230/Canvas/Art2/translate.jpg"
deleted file mode 100644
index 360bf012..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art2/translate.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art2/translate.png" "b/\351\227\256\351\242\230/Canvas/Art2/translate.png"
deleted file mode 100644
index 5eb90580..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art2/translate.png" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/Picture1.jpg" "b/\351\227\256\351\242\230/Canvas/Art3/Picture1.jpg"
deleted file mode 100644
index 4bbb07e9..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/Picture1.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/checkres.png" "b/\351\227\256\351\242\230/Canvas/Art3/checkres.png"
deleted file mode 100644
index d47fc789..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/checkres.png" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/checkview.gif" "b/\351\227\256\351\242\230/Canvas/Art3/checkview.gif"
deleted file mode 100644
index afb000fa..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/checkview.gif" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/drawBitmap1.jpg" "b/\351\227\256\351\242\230/Canvas/Art3/drawBitmap1.jpg"
deleted file mode 100644
index 2a01045e..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/drawBitmap1.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/drawBitmap2.jpg" "b/\351\227\256\351\242\230/Canvas/Art3/drawBitmap2.jpg"
deleted file mode 100644
index 621a595f..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/drawBitmap2.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/drawBitmap3.jpg" "b/\351\227\256\351\242\230/Canvas/Art3/drawBitmap3.jpg"
deleted file mode 100644
index 294b77bb..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/drawBitmap3.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/drawBitmap4.jpg" "b/\351\227\256\351\242\230/Canvas/Art3/drawBitmap4.jpg"
deleted file mode 100644
index 6f36e496..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/drawBitmap4.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/drawBitmap5.jpg" "b/\351\227\256\351\242\230/Canvas/Art3/drawBitmap5.jpg"
deleted file mode 100644
index 59fe96ec..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/drawBitmap5.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/drawBitmap6.png" "b/\351\227\256\351\242\230/Canvas/Art3/drawBitmap6.png"
deleted file mode 100644
index e0cea113..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/drawBitmap6.png" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/drawPicture1.jpg" "b/\351\227\256\351\242\230/Canvas/Art3/drawPicture1.jpg"
deleted file mode 100644
index af15313e..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/drawPicture1.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/drawPicture2.jpg" "b/\351\227\256\351\242\230/Canvas/Art3/drawPicture2.jpg"
deleted file mode 100644
index 2271ad5b..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/drawPicture2.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/drawPicture3.jpg" "b/\351\227\256\351\242\230/Canvas/Art3/drawPicture3.jpg"
deleted file mode 100644
index 61126cc8..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/drawPicture3.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/drawText1.jpg" "b/\351\227\256\351\242\230/Canvas/Art3/drawText1.jpg"
deleted file mode 100644
index 73cef560..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/drawText1.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/drawText2.jpg" "b/\351\227\256\351\242\230/Canvas/Art3/drawText2.jpg"
deleted file mode 100644
index a74b1ddd..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/drawText2.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/drawText3.jpg" "b/\351\227\256\351\242\230/Canvas/Art3/drawText3.jpg"
deleted file mode 100644
index 1084f745..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/drawText3.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art3/drawText4.jpg" "b/\351\227\256\351\242\230/Canvas/Art3/drawText4.jpg"
deleted file mode 100644
index 2efafb85..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art3/drawText4.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art4/CW-CCW1.jpeg" "b/\351\227\256\351\242\230/Canvas/Art4/CW-CCW1.jpeg"
deleted file mode 100644
index c27e5e77..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art4/CW-CCW1.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art4/CW-CCW2.jpeg" "b/\351\227\256\351\242\230/Canvas/Art4/CW-CCW2.jpeg"
deleted file mode 100644
index 4f21e1ec..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art4/CW-CCW2.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art4/CW-CCW3.jpeg" "b/\351\227\256\351\242\230/Canvas/Art4/CW-CCW3.jpeg"
deleted file mode 100644
index 2c9a6a73..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art4/CW-CCW3.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art4/addArc.jpeg" "b/\351\227\256\351\242\230/Canvas/Art4/addArc.jpeg"
deleted file mode 100644
index 913f3021..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art4/addArc.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art4/addPath.jpeg" "b/\351\227\256\351\242\230/Canvas/Art4/addPath.jpeg"
deleted file mode 100644
index ba5ebe9b..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art4/addPath.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art4/arcTo.jpeg" "b/\351\227\256\351\242\230/Canvas/Art4/arcTo.jpeg"
deleted file mode 100644
index 80191eec..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art4/arcTo.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art4/close.jpeg" "b/\351\227\256\351\242\230/Canvas/Art4/close.jpeg"
deleted file mode 100644
index 9762080c..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art4/close.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art4/leida.png" "b/\351\227\256\351\242\230/Canvas/Art4/leida.png"
deleted file mode 100644
index b7cb48fa..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art4/leida.png" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art4/lineTo.jpeg" "b/\351\227\256\351\242\230/Canvas/Art4/lineTo.jpeg"
deleted file mode 100644
index ea8ce87e..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art4/lineTo.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art4/moveTo.jpeg" "b/\351\227\256\351\242\230/Canvas/Art4/moveTo.jpeg"
deleted file mode 100644
index 8f20383a..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art4/moveTo.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art4/offset.jpeg" "b/\351\227\256\351\242\230/Canvas/Art4/offset.jpeg"
deleted file mode 100644
index 9d0434e3..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art4/offset.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art4/set.jpeg" "b/\351\227\256\351\242\230/Canvas/Art4/set.jpeg"
deleted file mode 100644
index 3471f773..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art4/set.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art4/setLastPoint.jpeg" "b/\351\227\256\351\242\230/Canvas/Art4/setLastPoint.jpeg"
deleted file mode 100644
index 16575298..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art4/setLastPoint.jpeg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art5/Pic1.jpg" "b/\351\227\256\351\242\230/Canvas/Art5/Pic1.jpg"
deleted file mode 100644
index 6025e5e5..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art5/Pic1.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art5/Pic2.jpg" "b/\351\227\256\351\242\230/Canvas/Art5/Pic2.jpg"
deleted file mode 100644
index 56c69e8e..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art5/Pic2.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Art5/Pic3.jpg" "b/\351\227\256\351\242\230/Canvas/Art5/Pic3.jpg"
deleted file mode 100644
index 6c0202c1..00000000
Binary files "a/\351\227\256\351\242\230/Canvas/Art5/Pic3.jpg" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/Canvas/Canvas(1).md" "b/\351\227\256\351\242\230/Canvas/Canvas(1).md"
deleted file mode 100644
index 97d8d59f..00000000
--- "a/\351\227\256\351\242\230/Canvas/Canvas(1).md"
+++ /dev/null
@@ -1,498 +0,0 @@
-# Canvas基础一
-### 讲解安卓中的Canvas基础内容。
-### 作者微博: [@攻城师sloop](http://weibo.com/5459430586)
-
-上一次我们了解自定义View的流程，以及几个重要的相关函数，不过，这些东西依旧还是理论，并不能拿来(zhuang)用(B), 这一次我们就了解一些能(zhaung)用(B)的东西。
-关于本文，我们先了解Canvas的基本用法，再学习一个能拿来装逼(就是看起来很牛逼，但是没卵用)的东西。
-
-## 一.Canvas简介
-Canvas可以说是一大利器(在2D绘图方面)，因为涉及到的东西比较基础。
-
-比较基础的东西一般有两大特点:
- 1.可操作性强：由于这些是构成上层的基础，所以可操作性必然十分强大。
- 2.比较难用：各种方法太过基础，想要比较完美的组合起来有一定难度，并非不会这些操作，而是不知如何组织这些操作。
-
-不过不必担心，下面不仅会介绍到Canvas的操作方法，还会简单介绍一些设计思路和技巧。
-
-## 二.Canvas基础
-Canvas我们可以称之为画布，在上面绘制各种东西。
-
-绘制的基本形状由Canvas确定，但绘制出来的颜色,具体效果则由Paint确定。
-
-本次内容仅简单讲解Canvas所能绘制的基本内容，对Paint有一点涉及但不会涉及太多，关于Paint的更多用法会在以后详细想介绍，下面开始正题：
-
-### Canvas的常用操作：
-
-操作类型 | 相关API | 备注
---- | --- | ---
-绘制颜色 | drawColor, drawRGB, drawARGB | 使用单一颜色填充整个画布
相关 : [安卓自定义View基础-颜色](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/%E9%A2%9C%E8%89%B2/%E9%A2%9C%E8%89%B2.md)
-绘制基本形状 | drawPoint, drawPoints, drawLine, drawLines, drawRect, drawRoundRect, drawOval, drawCircle, drawArc | 依次为 点、线、矩形、圆角矩形、椭圆、圆、圆弧
-绘制图片 | drawBitmap, drawPicture | 绘制位图和图片
-绘制文本 | drawText, drawPosText, drawTextOnPath | 依次为 绘制文字、绘制文字时指定每个文字位置、根据路径绘制文字
-绘制路径 | drawPath | 绘制路径，绘制贝塞尔曲线时也需要用到该函数
-顶点操作 | drawVertices, drawBitmapMesh | 通过对顶点操作可以使图像形变，drawVertices直接对画布作用、 drawBitmapMesh只对绘制的Bitmap作用
-画布剪裁 | clipPath, clipRect | 设置画布的显示区域
-画布快照 | save, restore, saveLayerXxx, restoreToCount, getSaveCount | 依次为 保存当前状态、 回滚到上一次保存的状态、 保存图层状态、 会滚到指定状态、 获取保存次数
-画布变换 | translate, scale, rotate, skew | 依次为 位移、缩放、 旋转、倾斜
相关： [坐标系](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/%E5%9D%90%E6%A0%87%E7%B3%BB/%E5%9D%90%E6%A0%87%E7%B3%BB.md) [角度与弧度](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/%E8%A7%92%E5%BA%A6%E4%B8%8E%E5%BC%A7%E5%BA%A6/%E8%A7%92%E5%BA%A6%E4%B8%8E%E5%BC%A7%E5%BA%A6.md)
-Matrix(矩阵) | getMatrix, setMatrix, concat | 实际画布的位移，缩放等操作的都是图像矩阵Matrix，只不过Matrix比较难以理解和使用，故封装了一些常用的方法。
-
-PS： Canvas常用方法在上面表格中基本全部列出了，当然还存在一些其他的方法未列出，具体可以官方文档 [Canvas](http://developer.android.com/reference/android/graphics/Canvas.html)
-
-从上表可以看出，Canvas的可用操作还是有很多的，限于篇幅，本文仅讲解 绘制颜色， 绘制基本形状，简要介绍画布形变操作，最后会利用以上知识做一个小实例用来练(zhaung)手(B)，其余内容会在以后的文章中更加详细的介绍。
-
-******
-### Canvas基础示例：
-
-#### 绘制颜色：
-绘制颜色是填充整个画布，常用于绘制底色。
-``` java
- canvas.drawColor(Color.BLUE); //绘制蓝色
-```
-
-
-
-******
-#### 创建画笔：
-要想绘制内容，首先需要先创建一个画笔，如下：
-``` java
- // 1.创建一个画笔
- private Paint mPaint = new Paint();
-
- // 2.初始化画笔
- private void initPaint() {
- mPaint.setColor(Color.BLACK); //设置画笔颜色
- mPaint.setStyle(Paint.Style.FILL); //设置画笔模式为填充
- mPaint.setStrokeWidth(10f); //设置画笔宽度为10px
- }
-
- // 3.在构造函数中初始化
- public SloopView(Context context, AttributeSet attrs) {
- super(context, attrs);
- initPaint();
- }
-```
-在创建完画笔之后，就可以在Canvas中绘制各种内容了。
-
-******
-#### 绘制点：
-可以绘制一个点，也可以绘制一组点，如下：
-``` java
- canvas.drawPoint(200, 200, mPaint); //在坐标(200,200)位置绘制一个点
- canvas.drawPoints(new float[]{ //绘制一组点，坐标位置由float数组指定
- 500,500,
- 500,600,
- 500,700
- },mPaint);
-```
-关于坐标原点默认在左上角，水平向右为x轴增大方向，竖直向下为y轴增大方向。更多参考这里 [安卓自定义View基础 - 坐标系](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/%E5%9D%90%E6%A0%87%E7%B3%BB/%E5%9D%90%E6%A0%87%E7%B3%BB.md)
-
-
-******
-#### 绘制直线：
-绘制直线需要两个点，初始点和结束点，同样绘制直线也可以绘制一条或者绘制一组：
-``` java
- canvas.drawLine(300,300,500,600,mPaint); // 在坐标(300,300)(500,600)之间绘制一条直线
- canvas.drawLines(new float[]{ // 绘制一组线 每四数字(两个点的坐标)确定一条线
- 100,200,200,200,
- 100,300,200,300
- },mPaint);
-```
-
-
-******
-#### 绘制矩形：
-确定确定一个矩形最少需要四个数据，就是对角线的两个点的坐标值，通常我们会采用左上角和右下角的两个点的坐标(当然了右上和左下也可以)，像这样：
-
-
-
-关于绘制矩形，Canvas提供了三种重载方法，第一种就是提供四个数值(对角线两个点的坐标)来确定一个矩形进行绘制。
-其余两种是先将矩形封装为Rect或RectF(实际上仍然是用两个坐标点来确定的矩形)，然后传递给Canvas绘制，如下：
-``` java
- // 第一种
- canvas.drawRect(100,100,800,400,mPaint);
-
- // 第二种
- Rect rect = new Rect(100,100,800,400);
- canvas.drawRect(rect,mPaint);
-
- // 第三种
- RectF rectF = new RectF(100,100,800,400);
- canvas.drawRect(rectF,mPaint);
-```
-以上三种方法所绘制出来的结果是完全一样的。
-
-
-
-看到这里,相信很多观众会产生一个疑问，为什么会有Rect和RectF两种？两者有什么区别吗？
-
-答案当然是存在区别的，两种最大的区别就是精度不同，Rect是int(整形)的，而RectF则是float(单精度浮点型)的。当然了除了精度不同，两种提供的方法也稍微存在差别，在这里我们暂时无需关注，想了解更多参见官方文档 [Rect](http://developer.android.com/reference/android/graphics/Rect.html) 和 [RectF](http://developer.android.com/reference/android/graphics/RectF.html)
-
-******
-#### 绘制圆角矩形：
-绘制圆角矩形也提供了两种重载方式，如下：
-``` java
- // 第一种
- RectF rectF = new RectF(100,100,800,400);
- canvas.drawRoundRect(rectF,30,30,mPaint);
-
- // 第二种
- canvas.drawRoundRect(100,100,800,400,30,30,mPaint);
-```
-上面两种方法绘制效果也是一样的，但鉴于第二种方法在API21的时候才添加上，所以我们一般使用的都是第一种。
-
-
-
-下面简单解析一下圆角矩形的几个必要的参数的意思。
-
-很明显可以看出，第二种方法前四个参数和第一种方法的RectF作用是一样的，都是为了确定一个矩形，最后一个参数Paint是画笔，无需多说，与矩形相比，圆角矩形多出来了两个参数rx 和 ry，这两个参数是干什么的呢？
-
-稍微分析一下，既然是圆角矩形，他的角肯定是圆弧，我们用什么一般用什么确定一个圆弧呢？
-答案是圆心和半径，其中圆心用于确定位置，而半径用于确定大小。
-由于矩形位置已经确定，所以他的边角位置肯定也是确定的，那么确定位置这个参数就可以省略了，只需要用半径就能描述一个圆弧了。
-呃，你说半径只需要一个参数，这里有两个唉。
-好吧，让你发现了，这里圆角矩形的角实际上不是一个正圆的圆弧，而是椭圆的圆弧，这里的两个参数实际上是椭圆的两个半径(长半径和短半径)，他们看起来个如下图：
-
-
-
-在此图之中，外部灰色的矩形表示我们确定的矩形，而用红色圈住的 A、B 两个点是我们用来确定这个矩形的两个重要参数,而用红线标注的 rx 与 ry 就是两个半径，也就是相比绘制矩形多出来的那两个参数。
-
-我们了解到原理后，就可以为所欲为了，通过计算可知我们上次绘制的矩形宽度为700，高度为300，当你让 rx大于350， ry大于150 时奇迹就出现了，你会发现圆角矩形变成了一个椭圆，他们画出来是这样的(为了方便确认我更改了画笔颜色，同时绘制出了矩形和圆角矩形)：
-``` java
- // 矩形
- RectF rectF = new RectF(100,100,800,400);
-
- // 绘制背景矩形
- mPaint.setColor(Color.GRAY);
- canvas.drawRect(rectF,mPaint);
-
- // 绘制圆角矩形
- mPaint.setColor(Color.BLUE);
- canvas.drawRoundRect(rectF,700,400,mPaint);
-```
-
-
-
-其中灰色部分是我们所选定的矩形，而里面的圆角矩形则变成了一个椭圆，实际上在rx为宽度的一半，ry为高度的一半时，刚好是一个椭圆，通过上面我们分析的原理推算一下就能得到，而当rx大于宽度的一半，ry大于高度的一半时，实际上是无法计算的圆弧的，所以drawRoundRect对大于该数值的参数进行了修正，凡是大于一半的参数均按照一半来处理。
-
-好了圆角矩形就分析这么多吧。
-
-******
-#### 绘制椭圆：
-相对于绘制圆角矩形，绘制椭圆就简单的多了，因为他只需要一个矩形就能绘制出一个与矩形内切的椭圆。
-``` java
- // 第一种
- RectF rectF = new RectF(100,100,800,400);
- canvas.drawOval(rectF,mPaint);
-
- // 第二种
- canvas.drawOval(100,100,800,400,mPaint);
-```
-同样，以上两种方法效果完全一样，但一般使用第一种。
-
-
-
-绘制椭圆实际上就是绘制一个矩形调度内切椭圆，原理如下，就不多说了：
-
-
-
-PS： 如果你传递进来的是一个长宽相等的矩形(即正方形)，那么绘制出来的实际上就是一个圆。
-
-******
-#### 绘制圆：
-绘制圆形比较简单，因为圆形只需要圆心和半径，如下：
-```
- canvas.drawCircle(500,500,400,mPaint); // 绘制一个圆心坐标在(500,500)，半径为400 的圆。
-```
-绘制圆形有四个参数，前两个是圆心，第三个是半径，最后一个是画笔。
-
-
-
-******
-#### 绘制圆弧：
-绘制圆弧相比以上内容就比较神奇一点了，为了理解这个比较神奇的东西，我们先看一下他需要的几个参数：
-``` java
-// 第一种
-public void drawArc(@NonNull RectF oval, float startAngle, float sweepAngle, boolean useCenter, @NonNull Paint paint){}
-
-// 第二种
-public void drawArc(float left, float top, float right, float bottom, float startAngle,
- float sweepAngle, boolean useCenter, @NonNull Paint paint) {}
-```
-从上面可以看出，相比于绘制椭圆，绘制圆弧还多了三个参数：
-``` java
-startAngle // 开始角度
-sweepAngle // 扫过角度
-useCenter // 是否使用中心
-```
-通过字面意思我们基本能猜测出来前两个参数(startAngle， sweepAngel)的作用，就是确定角度的起始位置和角度实际大小， 而角度的结束角度实际上就是起始角度加上角度大小(startAngle, sweepAngle). 不过第三个参数是干嘛的？试一下就知道了,上代码：
-```
- RectF rectF = new RectF(100,100,800,400);
- // 绘制背景矩形
- mPaint.setColor(Color.GRAY);
- canvas.drawRect(rectF,mPaint);
-
- // 绘制圆弧
- mPaint.setColor(Color.BLUE);
- canvas.drawArc(rectF,0,90,false,mPaint);
-
- //-------------------------------------
-
- RectF rectF2 = new RectF(100,600,800,900);
- // 绘制背景矩形
- mPaint.setColor(Color.GRAY);
- canvas.drawRect(rectF2,mPaint);
-
- // 绘制圆弧
- mPaint.setColor(Color.BLUE);
- canvas.drawArc(rectF2,0,90,true,mPaint);
-```
-上述代码实际上是绘制了一个起始角度为0度，扫过90度的圆弧，两者的区别就是是否使用了中心点，结果如下：
-
-
-
-可以发现使用了中心点之后绘制出来类似于一个扇形，而不使用中心点则是圆弧起始点和结束点之间的连线加上圆弧围成的图形。这样中心点这个参数的作用就很明显了，不必多说想必大家试一下就明白了。 另外可以关于角度可以参考一下这篇： [角度与弧度](https://github.com/GcsSloop/AndroidNote/blob/master/%E9%97%AE%E9%A2%98/%E8%A7%92%E5%BA%A6%E4%B8%8E%E5%BC%A7%E5%BA%A6/%E8%A7%92%E5%BA%A6%E4%B8%8E%E5%BC%A7%E5%BA%A6.md)
-
-相比于使用椭圆，我们通常还是使用正圆比较多的，使用正圆展示一下效果：
-```
- RectF rectF = new RectF(100,100,800,400);
- // 绘制背景矩形
- mPaint.setColor(Color.GRAY);
- canvas.drawRect(rectF,mPaint);
-
- // 绘制圆弧
- mPaint.setColor(Color.BLUE);
- canvas.drawArc(rectF,0,90,false,mPaint);
-
- //-------------------------------------
-
- RectF rectF2 = new RectF(100,600,800,900);
- // 绘制背景矩形
- mPaint.setColor(Color.GRAY);
- canvas.drawRect(rectF2,mPaint);
-
- // 绘制圆弧
- mPaint.setColor(Color.BLUE);
- canvas.drawArc(rectF2,0,90,true,mPaint);
-```
-
-
-******
-#### 简要介绍Paint
-看了上面这么多，相信有一部分人会产生一个疑问，如果我想绘制一个圆，只要边不要里面的颜色怎么办？
-
-很简单，在一开始我们就说过，绘制的基本形状由Canvas确定，但绘制出来的颜色,具体效果则由Paint确定。
-
-如果你注意到了的话，在一开始我们设置画笔样式的时候是这样的：
-``` java
- mPaint.setStyle(Paint.Style.FILL); //设置画笔模式为填充
-```
-这也是为了展示方便，容易看出效果，所以设置了模式为填充，实际上画笔有三种模式，如下：
-``` java
-STROKE //描边
-FILL //填充
-FILL_AND_STROKE //描边加填充
-```
-为了区分三者效果我们做如下实验：
-```
- Paint paint = new Paint();
- paint.setColor(Color.BLUE);
- paint.setStrokeWidth(40); //为了实验效果明显特异，特地设置描边宽度非常大
-
- // 描边
- paint.setStyle(Paint.Style.STROKE);
- canvas.drawCircle(200,200,100,paint);
-
- // 填充
- paint.setStyle(Paint.Style.FILL);
- canvas.drawCircle(200,500,100,paint);
-
- // 描边加填充
- paint.setStyle(Paint.Style.FILL_AND_STROKE);
- canvas.drawCircle(200, 800, 100, paint);
-```
-
-
-
-一图胜千言，通过以上实验我们可以比较明显的看出三种模式的区别，如果只需要边缘不需要填充内容的话只需要设置模式为描边(STROKE)即可。
-
-其实关于Paint的内容也是有不少的，这些只是冰山一角，在以后会详细的讲解Paint内容。
-
-******
-## 小示例
-
-### 简要介绍画布的操作：
-
-相关操作 | 简要介绍
---- | ---
-save | 保存当前画布状态
-restore | 回滚到上一次保存的状态
-translate | 相对于当前位置位移
-rotate | 旋转
-
-### 制作一个饼状图
-在展示百分比数据的时候经常会用到饼状图，像这样：
-
-
-
-#### 简单分析
-其实根据我们上面的知识已经能自己制作一个饼状图了。不过制作东西最重要的不是制作结果，而是制作思路。
-相信我贴上代码大家一看就立刻明白了，非常简单的东西。不过嘛，咱们还是想了解一下制作思路：
-
-先分析饼状图的构成，非常明显，饼状图就是一个又一个的扇形构成的，每个扇形都有不同的颜色，对应的有名字，数据和百分比。
-
-经以上信息可以得出饼状图的最基本数据应包括： 名字 数据值 百分比 对应的角度 颜色。
-
-
-用户关心的数据 ： 名字 数据值 百分比
-需要程序计算的数据： 百分比 对应的角度
-其中颜色这一项可以用户指定也可以用程序指定(我们这里采用程序指定)。
-
-
-#### 封装数据：
-``` java
-public class PieData {
- // 用户关心数据
- private String name; // 名字
- private float value; // 数值
- private float percentage; // 百分比
-
- // 非用户关心数据
- private int color = 0; // 颜色
- private float angle = 0; // 角度
-
- public PieData(@NonNull String name, @NonNull float value) {
- this.name = name;
- this.value = value;
- }
-}
-```
-PS: 以上省略了get set方法
-
-#### 自定义View：
-先按照自定义View流程梳理一遍：
-
-步骤 | 关键字 | 作用
---- | --- | ---
-1 | 构造函数 | 初始化(初始化画笔Paint)
-2 | onMeasure | 测量View的大小(暂时不用关心)
-3 | onSizeChanged | 确定View大小(记录当前View的宽高)
-4 | onLayout | 确定子View布局(不关心)
-5 | onDraw | 实际绘制内容(绘制饼状图)
-6 | 提供接口 | 提供接口(提供设置数据的接口)
-
-代码如下：
-``` java
-public class PieView extends View {
- // 颜色表
- private int[] mColors = {0xFFCCFF00, 0xFF6495ED, 0xFFE32636, 0xFF800000, 0xFF808000, 0xFFFF8C69, 0xFF808080,
- 0xFFE6B800, 0xFF7CFC00};
- // 饼状图初始绘制角度
- private float mStartAngle = 0;
- // 数据
- private ArrayList
-
-
-## 总结：
- 本次偷懒了一点，最后的饼状图并没有绘制完整，以后会补上未完成的部分的。
-
- 其实自定义View只要按照流程一步步的走，还是比较容易的。不过里面自然也是有不少坑的，这个坑还是自己踩过印象会比较深，建议大家不要直接copy源码，自己亲手写一遍体验一下。
-
-## 参考资料：
-
-[View](http://developer.android.com/reference/android/view/View.html)
-[Canvas](http://developer.android.com/reference/android/graphics/Canvas.html)
-[Android Canvas绘图详解](http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2012/1212/703.html)
-
-
diff --git "a/\351\227\256\351\242\230/Canvas/Path/Path(2).md" "b/\351\227\256\351\242\230/Canvas/Path/Path(2).md"
deleted file mode 100644
index 9e31a17b..00000000
--- "a/\351\227\256\351\242\230/Canvas/Path/Path(2).md"
+++ /dev/null
@@ -1,106 +0,0 @@
-# Canvas基础五
-### 讲解安卓中的Canvas基础内容。
-### 作者微博: [@攻城师sloop](http://weibo.com/GcsSloop)
-
-本次讲解Path中的贝塞尔曲线部分，创造更多**炫(zhuang)酷(B)**的东东。
-
-******
-
-# 一.Path常用方法表
-> 为了兼容性(_偷懒_) 本表格中去除了在API21(即安卓版本5.0)以上才添加的方法。忍不住吐槽一下，为啥看起来有些顺手就能写的重载方法要等到API21才添加上啊。宝宝此刻内心也是崩溃的。
-
-作用 | 相关方法 | 备注
---- | --- | ---
-移动起点 | moveTo | 移动下一次操作的起点位置
-设置终点 | setLastPoint | 重置当前path中最后一个点位置，如果在绘制之前调用，效果和moveTo相同
-连接直线 | lineTo | 添加上一个点到当前点之间的直线到Path
-闭合路径 | close | 连接第一个点连接到最后一个点，形成一个闭合区域
-添加内容 | addRect, addRoundRect, addOval, addCircle, addPath, addArc, arcTo | 添加(矩形， 圆角矩形， 椭圆， 圆， 路径， 圆弧) 到当前Path (注意addArc和arcTo的区别)
-是否为空 | isEmpty | 判断Path是否为空
-是否为矩形 | isRect | 判断path是否是一个矩形
-替换路径 | set | 用新的路径替换到当前路径所有内容
-偏移路径 | offset | 对当前路径之前的操作进行偏移(不会影响之后的操作)
-贝塞尔曲线 | quadTo, cubicTo | 分别为二次和三次贝塞尔曲线的方法
-rXxx方法 | rMoveTo, rLineTo, rQuadTo, rCubicTo | **不带r的方法是基于原点的坐标系(偏移量)，rXxx方法是基于当前点坐标系(偏移量)**
-填充模式 | setFillType, getFillType, isInverseFillType, toggleInverseFillType| 设置,获取,判断和切换填充模式
-提示方法 | incReserve | 提示Path还有多少个点等待加入**(这个方法貌似会让Path优化存储结构)**
-布尔操作(API19) | op | 对两个Path进行布尔运算(即取交集、并集等操作)
-计算边界 | computeBounds | 计算Path的边界
-重置路径 | reset, rewind | 清除Path中的内容(**reset相当于重置到new Path阶段，rewind会保留Path的数据结构**)
-矩阵操作 | transform | 矩阵变换
-
-# 二.Path详解
-
-上一次除了一些常用函数之外，讲解的基本上都是直线，本次需要了解其中的曲线部分,说到曲线，就不得不提大名鼎鼎的贝塞尔曲线。
-就是下面这个人(法国数学家PierreBézier)所发现的。
-
-
-
-
-**搜索贝塞尔曲线，我们看到的基本就是下面这些不明觉厉的图形：**
-
-贝塞尔曲线 | 结构 | 演示动画
- --- | --- | ---
- 一阶曲线
(线性曲线) |  | 
- 二阶曲线 |  | 
-三阶曲线 |  | 
-四阶曲线 |  | 
-
-**或者类似于这样的不明觉厉的公式：**
-
-
-
-**话说这根本就是数学家干的活吧，让我一个写程序(_差点挂在高数上下不来_)的弄这个？**
-
-
-
-不过嘛，不用担心，本次内容中不会拿这些不明觉厉的公式去忽悠大家，下面正式开始。
-
-## 贝塞尔曲线能干什么？
-
-额，一个比较弱智的问题，人家都说是曲线了，肯定就是画曲线啦，不然还能干什么！
-
-例如绘制一个妹子的小蛮腰。:point_down:
-
-**:warning:前方高能预警，非战斗人员请迅速撤离！！！**
-
->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
-
-
-
-**如果没有贝塞尔曲线，就会变成这样子。:point_down:**
-
-
-
-
-
-贝塞尔曲线的运用是十分广泛的，可以说**贝塞尔曲线奠定了计算机绘图的基础(_因为它可以将任何复杂的图形用精确的数学语言进行描述_)**，在你不经意间就已经使用过它了。
-
-你会使用Photoshop的话，你可能会注意到里面有一个**钢笔工具**。这是一个令人十分费解的东西，我在一开始尝试使用的时候总会制造出一些和我预期不同的曲线，各种歪歪扭扭。这个钢笔工具就是贝塞尔曲线的一种运用。
-
-你说你不会PS？ 没关系，你如果看过前面的文章或者用过2D绘图，肯定绘制过圆，圆弧，圆角矩形等这些东西。这里面的圆弧部分全部都是贝塞尔曲线的运用。
-
-实际上在前面我们所绘制的**圆是用四段贝塞尔曲线拼接出来的**，有木有觉得很不可思议？
-
-相信很多人看到这里都会怀疑，因为上过中学的人都知道圆是有自己的方程式的，而且比贝塞尔曲线简单的多。
-
-如果你们不相信的话，咱们可以做一个实验，**教大家如何用圆分分钟做出一个吃豆人**:
-
-上代码：
-``` java
-```
-
-
-
-
-
-
-## 论如何避免接触公式学好贝塞尔曲线
-
-
-
-
-# 三.总结
-
-# 四.参考资料
-
diff --git "a/\351\227\256\351\242\230/View/\350\207\252\345\256\232\344\271\211View\345\207\240\344\270\252\351\207\215\350\246\201\347\232\204\345\207\275\346\225\260.md" "b/\351\227\256\351\242\230/View/\350\207\252\345\256\232\344\271\211View\345\207\240\344\270\252\351\207\215\350\246\201\347\232\204\345\207\275\346\225\260.md"
deleted file mode 100644
index 45e0994b..00000000
--- "a/\351\227\256\351\242\230/View/\350\207\252\345\256\232\344\271\211View\345\207\240\344\270\252\351\207\215\350\246\201\347\232\204\345\207\275\346\225\260.md"
+++ /dev/null
@@ -1,231 +0,0 @@
-# 自定义View几个重要的函数
-
-简单讲解自定义View相关的几个重要的函数。
-
-### 作者微博: [@攻城师sloop](http://weibo.com/5459430586)
-
-作为一个有(hui)追(zhuang)求(B)的程序员，肯定想做一些让人眼前一亮的程序效果，但是系统提供的那些一般很难满足，为了梦(zhuang)想(B)就必须要学习一些自定义View。下面我们就了解一些自定义View相关的东西。
-
-## 一.自定义View分类
-
-### 我将自定义View分为了两类(只是我自己的分类)：
-
-### 1.自定义ViewGroup
-
- 自定义ViewGroup一般是利用现有的组件根据特定的布局方式来组成新的组件，大多继承自ViewGroup或各种Layout，包含有子View。
-
- 例如：一个应用内的底部导航条中的条目，一般都是上面为图标，下面是文字，那么这两个就可以用自定义ViewGroup组合成为一个Veiw，提供两个属性分别用来设置文字和图片即可，这样使用起来会方便很多。
-
-### 2.自定义View
-
- 在没有现成的View，需要自己实现的时候，就使用自定义View，一般继承自View，SurfaceView或其他的View，不包含子View。
-
- 例如：定义一个支持自动加载网络图片的ImageView，或制作一种特殊的动画效果。
-
- 一般来说，自定义View在大多数情况下都有替代方案，利用图片或者组合动画来实现，但是使用后者可能会面临内存耗费过大，制作麻烦更诸多问题。
-
-*******
-
-## 二.几个重要的函数
-
-### 1.构造函数
- View的构造函数有四种重载分别如下
-``` java
- public void SloopView(Context context) {}
- public void SloopView(Context context, AttributeSet attrs) {}
- public void SloopView(Context context, AttributeSet attrs, int defStyleAttr) {}
- public void SloopView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {}
-```
- 可以看出，关于View构造函数的参数有多有少，先排除几个不常用的，留下常用的再研究。
-
- 有四个参数的构造函数在API21的时候才添加上，我一般不使用，暂不考虑。
-
-有三个参数的构造函数中第三个参数是默认的Style，这里的默认的Style是指它在当前Application或Activity所用的Theme中的默认Style，且只有在明确调用的时候才会生效，以系统中的ImageButton为例说明：
-``` java
- public ImageButton(Context context, AttributeSet attrs) {
- //调用了三个参数的构造函数，明确指定第三个参数
- this(context, attrs, com.android.internal.R.attr.imageButtonStyle);
- }
-
- public ImageButton(Context context, AttributeSet attrs, int defStyleAttr) {
- //此处调了四个参数的构造函数，无视即可
- this(context, attrs, defStyleAttr, 0);
- }
-```
-注意：即使你在View中使用了Style这个属性也不会调用三个参数的构造函数，所调用的依旧是两个参数的构造函数。
-
-由于三个参数的构造函数第三个参数一般不用，暂不考虑，第三个参数的具体用法会在以后用到的时候详细介绍。
-
-排除了两个之后，只剩下一个参数和两个参数的构造函数，他们的详情如下：
-``` java
- //一般在直接New一个View的时候调用。
- public void SloopView(Context context) {}
-
- //一般在layout文件中使用的时候会调用，关于它的所有属性(包括自定义属性)都会包含在attrs中传递进来。
- public void SloopView(Context context, AttributeSet attrs) {}
-```
-以下方法调用的是一个参数的构造函数：
-``` java
- //在Avtivity中
- SloopView view = new SloopView(this);
-```
-以下方法调用的是两个参数的构造函数：
-``` xml
- //在layout文件中 - 格式为： 包名.View名
-
-[ViewGroup](http://developer.android.com/reference/android/view/ViewGroup.html)
-[View.MeasureSpec](http://developer.android.com/reference/android/view/View.MeasureSpec.html)
-[onMeasure，MeasureSpec源码 流程 思路详解](http://blog.csdn.net/a396901990/article/details/36475213)
-
-[Android中自定义样式与View的构造函数中的第三个参数defStyle的意义](http://www.cnblogs.com/angeldevil/p/3479431.html)
-[android view构造函数研究](http://blog.csdn.net/z103594643/article/details/6755017)
-[Android View构造方法第三参数使用方法详解](http://blog.csdn.net/mybeta/article/details/39993449)
-
-[Android 自定义View onMeasure方法的实现](http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2014/1102/1891.html)
-[Android API指南(二)自定义控件02之 onMeasure](http://wangkuiwu.github.io/2014/06/20/View-OnMeasure/)
-[Android中View的绘制过程 onMeasure方法简述](http://www.cnblogs.com/mengdd/p/3332882.html)
-
-
-
-
-
-
diff --git "a/\351\227\256\351\242\230/\351\242\234\350\211\262/Art/\351\242\234\350\211\262.png" "b/\351\227\256\351\242\230/\351\242\234\350\211\262/Art/\351\242\234\350\211\262.png"
deleted file mode 100644
index 16c46b60..00000000
Binary files "a/\351\227\256\351\242\230/\351\242\234\350\211\262/Art/\351\242\234\350\211\262.png" and /dev/null differ
diff --git "a/\351\227\256\351\242\230/\351\242\234\350\211\262/\351\242\234\350\211\262.md" "b/\351\227\256\351\242\230/\351\242\234\350\211\262/\351\242\234\350\211\262.md"
deleted file mode 100644
index 356219c7..00000000
--- "a/\351\227\256\351\242\230/\351\242\234\350\211\262/\351\242\234\350\211\262.md"
+++ /dev/null
@@ -1,195 +0,0 @@
-# 颜色
-### 作者微博: [@攻城师sloop](http://weibo.com/5459430586)
-```
-目录：
-一.简单介绍颜色
-二.几种创建或定义颜色的方式
-三.推荐取色工具
-四.颜色混合模式(Alpha通道相关)
-五.参考资料
-```
-
-## 一.简单介绍颜色
-安卓中颜色是按照ARGB方式定义的。
-
-A(Alpha): 透明度
-
-R(Red): 红色
-
-G(Green): 绿色
-
-B(Blue): 蓝色
-
-其中 A R G B 的取值范围均为0~255(即16进制的0x00~0xff)
-
-A 从ox00到oxff表示从透明到不透明。
-
-RGB 从0x00到0xff表示颜色从浅到深。
-
-## 二.几种创建或使用颜色的方式
-### 1.java中定义颜色
-``` java
- int color = Color.GRAY; //灰色
-```
- 由于Color类提供的颜色仅为有限的几个，通常还是用ARGB值进行表示。
-``` java
- int color = Color.argb(127, 255, 0, 0); //半透明红色
-
- int color = 0xaaff0000; //带有透明度的红色
-```
-### 2.在xml文件中定义颜色
-在/res/values/color.xml 文件中如下定义：
-``` xml
-
-
-
-
-
-用示例图来查看使用不同模式时的混合效果如下（src表示输入的图，dst表示原Canvas上的内容）：
-
-
-
-### 更详细的使用方式会在稍后的Canvas中介绍
-
-## 五.参考资料
-
-[【安卓图形动画】](http://www.cnblogs.com/zhucai/p/android-graphics-animation.html)
-
-
-ADD
-Saturate(S + D)
-
-
-CLEAR
-[0, 0]
-
-
-DARKEN
-[Sa + Da - Sa*Da, Sc*(1 - Da) + Dc*(1 - Sa) + min(Sc, Dc)]
-
-
-DST
-[Da, Dc]
-
-
-DST_ATOP
-[Sa, Sa * Dc + Sc * (1 - Da)]
-
-
-DST_IN
-[Sa * Da, Sa * Dc]
-
-
-DST_OUT
-[Da * (1 - Sa), Dc * (1 - Sa)]
-
-
-DST_OVER
-[Sa + (1 - Sa)*Da, Rc = Dc + (1 - Da)*Sc]
-
-
-LIGHTEN
-[Sa + Da - Sa*Da, Sc*(1 - Da) + Dc*(1 - Sa) + max(Sc, Dc)]
-
-
-MULTIPLY
-[Sa * Da, Sc * Dc]
-
-
-SCREEN
-[Sa + Da - Sa * Da, Sc + Dc - Sc * Dc]
-
-
-SRC
-[Sa, Sc]
-
-
-SRC_ATOP
-[Da, Sc * Da + (1 - Sa) * Dc]
-
-
-SRC_IN
-[Sa * Da, Sc * Da]
-
-
-SRC_OUT
-[Sa * (1 - Da), Sc * (1 - Da)]
-
-
-SRC_OVER
-[Sa + (1 - Sa)*Da, Rc = Sc + (1 - Sa)*Dc]
-
-
-
-XOR
-[Sa + Da - 2 * Sa * Da, Sc * (1 - Da) + (1 - Sa) * Dc]
-