Android QQ小红点的实现（附完整注释）

请尊重原创，转载请注明出处：http://blog.csdn.net/mabeijianxi/article/details/50560361

最近抽了些时间找了些资料，做了一个相对成熟的类似QQ小红点的拖拽控件。

先看下最后的效果：

simple与lib下载地址：https://github.com/mabeijianxi/stickyDots

一、分析：

1、首先分析这个控件的组成部分：

通过观察可以很明显的得出这个控件由三部分组成，一个固定不动的圆，一个连接部分，一个可能是圆的拖拽部分，由于不确定暂时把它看作圆

2、分析三个部分需要如何绘制。

（1）两个圆：这个比较简单，直接在复写view的onDraw方法，在里面执行canvas.drawCircle(），当然还需要传入圆心坐标和半径大小。

（2）连接部分：这个用过ps的矢量工具的应该知道。这里的是两条二阶贝塞尔曲线加两条直线。如图，二阶贝塞尔曲线是由起始点（P0，P2）和一个控制点（P1）组成。

二阶贝塞尔曲线在Android中的绘制方法可以调用Path类：

Path mPath=new Path();

mPath.moveTo(P0.x,P0.y);

mPath.quadTo(P1..x, P1.y, P2.x, P2.y);

直线就比较简单了：

mPath.lineTo(L0.x,L0.y);

（3）如何把每个部分结合起来，并且绘制在屏幕上：

有一个圆的圆心是固定的，可以先绘制。完成以后需要绘制连接部分，这个连接部分有两条曲线，两条直线，所以需要5个点才能绘制出来，

其中1个贝塞尔曲线的控制点，因为对称，所以控制点两条曲线公用一个控制点，。至于剩下的四个点，这里选取两个圆的外切点，如图：

接下来就是计算了，首先拖拽圆的圆心、半径可以知道，圆心坐标就是你手指触摸的位置，可以重写onTouchEvent()得到，固定圆圆心是不会变的，至于半径暂时给个确定值。

第一步：计算外切点：

根据两圆心所连接成的执行计算斜率:

公式是k=dy/dy; 

dy=O1.y-O2.y;

dx=O1.x-O2.x;

有了斜率、半径与圆心计算切点就没有问题了，都是三角函数的一些换算，就不多说，具体的可以下载或者查看这个工具类GeometryUtil的计算过程。

第二步：计算控制点，其实就是O1与O2的中心点，x=(O1.x+O2.x)/2    y=(O1.y+O2.y)/2

第三步：根据计算出来的五个点开始绘制闭合图形

这里我选择B点开始绘制：

移动到B点：mPath.moveTo(B.x,B.y）

从B点向A点作二阶贝塞尔曲线：mPath.quadTo(M.x,M.y,A.x,A.y）

从A向C绘制直线：mPath.lineTo(C.x,C.y)

从C向D绘制二阶贝塞尔曲线：mPath.quadTo(M.x,M.y,D.x,D.y)

直接封闭图形就行了：mPath.close()

二、静态图像绘制：

下面的静态绘制的代码：

[java]  view plain  copy

1. package com.mabeijianxi.myapplication;  
2.   
3. import android.content.Context;  
4. import android.graphics.Canvas;  
5. import android.graphics.Color;  
6. import android.graphics.Paint;  
7. import android.graphics.Path;  
8. import android.graphics.PointF;  
9. import android.graphics.Rect;  
10. import android.view.View;  
11.   
12. /** 
13.  * Created by mabeijianxi on 2016/1/25. 
14.  */  
15.     public class StickyView extends View {  
16.     /** 
17.      * 拖拽圆的圆心 
18.      */  
19.     PointF mDragCanterPoint = new PointF(250, 450);  
20.     /** 
21.      * 固定圆的圆心 
22.      */  
23.     PointF mFixCanterPoint = new PointF(250, 250);  
24.     /** 
25.      * 控制点 
26.      */  
27.     PointF mCanterPoint = new PointF(250, 400);  
28.   
29.     /** 
30.      * 固定圆的切点 
31.      */  
32.     PointF[] mFixTangentPointes = new PointF[] { new PointF(235, 250),  
33.             new PointF(265, 250) };  
34.     /** 
35.      * 拖拽圆的切点 
36.      */  
37.     PointF[] mDragTangentPoint = new PointF[] { new PointF(230, 450),  
38.             new PointF(270, 450) };  
39.     /** 
40.      * 拖拽圆半径 
41.      */  
42.     float mDragRadius = 20;  
43.     /** 
44.      * 固定圆半径 
45.      */  
46.     float mFixRadius = 15;  
47.     private int statusBarHeight;  
48.     private Paint mPaint;  
49.     private Path mPath;  
50.   
51.     public StickyView(Context context) {  
52.         super(context);  
53.         mPaint = new Paint();  
54.         mPaint.setColor(Color.RED);  
55.         mPaint.setAntiAlias(true);  
56.         mPath = new Path();  
57.     }  
58.   
59.     @Override  
60.     protected void onDraw(Canvas canvas) {  
61.         super.onDraw(canvas);  
62.         canvas.save();  
63.         canvas.translate(0, -statusBarHeight);  
64.             canvas.drawCircle(mFixCanterPoint.x, mFixCanterPoint.y, mFixRadius,  
65.                     mPaint);  
66.   
67.             float dy = mDragCanterPoint.y - mFixCanterPoint.y;  
68.             float dx = mDragCanterPoint.x - mFixCanterPoint.x;  
69.   
70.             mCanterPoint.set((mDragCanterPoint.x + mFixCanterPoint.x) / 2,  
71.                     (mDragCanterPoint.y + mFixCanterPoint.y) / 2);  
72.   
73.             if (dx != 0) {  
74.                 float k1 = dy / dx;  
75.                 float k2 = -1 / k1;  
76.                 mDragTangentPoint = getIntersectionPoints(  
77.                         mDragCanterPoint, mDragRadius, (double) k2);  
78.                 mFixTangentPointes = getIntersectionPoints(  
79.                         mFixCanterPoint, mFixRadius, (double) k2);  
80.             } else {  
81.                 mDragTangentPoint = getIntersectionPoints(  
82.                         mDragCanterPoint, mDragRadius, (double) 0);  
83.                 mFixTangentPointes = getIntersectionPoints(  
84.                         mFixCanterPoint, mFixRadius, (double) 0);  
85.             }  
86.   
87.             mPath.reset();  
88.             mPath.moveTo(mFixTangentPointes[0].x, mFixTangentPointes[0].y);  
89.             mPath.quadTo(mCanterPoint.x, mCanterPoint.y,  
90.                     mDragTangentPoint[0].x, mDragTangentPoint[0].y);  
91.             mPath.lineTo(mDragTangentPoint[1].x, mDragTangentPoint[1].y);  
92.             mPath.quadTo(mCanterPoint.x, mCanterPoint.y,  
93.                     mFixTangentPointes[1].x, mFixTangentPointes[1].y);  
94.             mPath.close();  
95.             canvas.drawPath(mPath, mPaint);  
96.   
97.             canvas.drawCircle(mDragCanterPoint.x, mDragCanterPoint.y,  
98.                     mDragRadius, mPaint);  
99.   
100.         canvas.restore();  
101.     }  
102.   
103.     /** 获取状态栏高度 
104.      * @param v 
105.      * @return 
106.      */  
107.     public static int getStatusBarHeight(View v) {  
108.         if (v == null) {  
109.             return 0;  
110.         }  
111.         Rect frame = new Rect();  
112.         v.getWindowVisibleDisplayFrame(frame);  
113.         return frame.top;  
114.     }  
115.     @Override  
116.     protected void onSizeChanged(int w, int h, int oldw, int oldh) {  
117.         super.onSizeChanged(w, h, oldw, oldh);  
118.         statusBarHeight=getStatusBarHeight(this);  
119.     }  
120.   
121.     /** 
122.      * Get the point of intersection between circle and line. 
123.      * 获取 通过指定圆心，斜率为lineK的直线与圆的交点。 
124.      * 
125.      * @param pMiddle The circle center point. 
126.      * @param radius The circle radius. 
127.      * @param lineK The slope of line which cross the pMiddle. 
128.      * @return 
129.      */  
130.     public static PointF[] getIntersectionPoints(PointF pMiddle, float radius, Double lineK) {  
131.         PointF[] points = new PointF[2];  
132.   
133.         float radian, xOffset = 0, yOffset = 0;  
134.         if(lineK != null){  
135.   
136.             radian= (float) Math.atan(lineK);  
137.             xOffset = (float) (Math.cos(radian) * radius);  
138.             yOffset = (float) (Math.sin(radian) * radius);  
139.         }else {  
140.             xOffset = radius;  
141.             yOffset = 0;  
142.         }  
143.         points[0] = new PointF(pMiddle.x + xOffset, pMiddle.y + yOffset);  
144.         points[1] = new PointF(pMiddle.x - xOffset, pMiddle.y - yOffset);  
145.   
146.         return points;  
147.     }  
148. }  

Activity:

[java]  view plain  copy

1. package com.mabeijianxi.myapplication;  
2.   
3. import android.app.Activity;  
4. import android.os.Bundle;  
5.   
6. public class MainActivity extends Activity {  
7.   
8.     @Override  
9.     protected void onCreate(Bundle savedInstanceState) {  
10.         super.onCreate(savedInstanceState);  
11.         setContentView(new StickyView(this));  
12.     }  
13. }  

运行结果：

是不是觉得挺简单的，下面开始动态绘制。

三、动态图形绘制：

有了绘制静态图的经验，绘制动态图将变得很简单，无非就是根据手指触摸的位置计算拖拽圆的圆心坐标、控制点的坐标与控制点的坐标，很明显

拖拽圆的坐标就是我们手指触摸的位置，固定圆坐标不变，那么其他的坐标的计算方法我们已经在二中已经知道了，比如控制点就是两圆心的中点。

切点可根据三角函数求出。公式全都有了，现在只需要动态绘制就可以了。

获取手指触摸的坐标，大家应该都会，直接上代码了：

[java]  view plain  copy

1. public boolean onTouchEvent(MotionEvent event) {  
2.         switch (event.getAction()) {  
3.             case MotionEvent.ACTION_DOWN:  
4.   
5.                 float startX = event.getRawX();  
6.                 float startY = event.getRawY();  
7.                 updateDragCenterPoint(startX, startY);  
8.                 break;  
9.             case MotionEvent.ACTION_MOVE:  
10.                 float endX = event.getRawX();  
11.                 float endY = event.getRawY();  
12. //                更加手的移动位置绘制拖拽圆的位置  
13.                 updateDragCenterPoint(endX, endY);  
14. //  
15.                 break;  
16.         }  
17.         return true;  
18.     }  
19.     /** 
20.      * 更新拖拽圆圆心 
21.      */  
22.     private void updateDragCenterPoint(float x, float y) {  
23.         mDragCanterPoint.set(x, y);  
24.         invalidate();  
25.     }  

运行示意图：

四、根据业务增加功能与动画。

1、观察分析：

a.固定圆虽然圆心不变，但是半径在变化，并且与两圆的圆心距成正比。

b.拖拽过程中有一个范围。

c.拖拽过程中根据拖拽范围有几个状态：①只在范围内移动，正常全部绘制。

       ②只范围内移动，最后在范围内松手，作回弹动画。

       ③范围外移动过，只要超出过一次将不再绘制固定圆与连接杆。

④ 范围外移动过，最后在范围外松手，直接让所有图像消失。

⑤范围外移动过，最后在范围内松手，图形重设到初始状态。

2、实现：

a.固定圆半径动态变化，这个可以更具拖拽圆与固定圆之间的距离来变化：

[java]  view plain  copy

1. /** 
2.      * 计算拖动过程中固定圆的半径 
3.      */  
4.     private float updateStickRadius() {  
5.         float distance = (float) Math.sqrt(Math.pow(mDragCanterPoint.y - mFixCanterPoint.y, 2)   
6.                 + Math.pow(mDragCanterPoint.x - mFixCanterPoint.x, 2));  
7.         distance = Math.min(distance, mFarthestDistance);  
8.         float percent = distance * 1.0f / mFarthestDistance;  
9.         return mFixRadius + (mMinFixRadius - mFixRadius) * percent;  
10.     }  

b. 配置回弹动画，通过值动画来模拟数据，其实就是以拖拽圆为起点固定圆为终点不停的直线移动拖拽圆的坐标：

[java]  view plain  copy

1. /** 
2.     * 移动的时候一直在范围内，最后在范围内松手 
3.     */  
4.    private void inUp() {  
5.        final PointF startPoint = new PointF(mDragCanterPoint.x,  
6.                mDragCanterPoint.y);  
7.        final PointF endPoint = new PointF(mFixCanterPoint.x,  
8.                mFixCanterPoint.y);  
9.        ValueAnimator animator = ValueAnimator.ofFloat(1.0f);  
10.        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {  
11.   
12.            @Override  
13.            public void onAnimationUpdate(ValueAnimator animation) {  
14.                float fraction = animation.getAnimatedFraction();  
15.                PointF byPercent = GeometryUtil.getPointByPercent(  
16.                        startPoint, endPoint, fraction);  
17.                updateDragCenterPoint(byPercent.x, byPercent.y);  
18.            }  
19.        });  
20.        animator.setInterpolator(new OvershootInterpolator(4.0f));  
21.        animator.setDuration(500);  
22.        animator.start();  
23.    }  

c. 增加状态标识，这里只需要两个就够了，一个代表是否超出过范围，一个代表现在是在范围外还是范围内。

[java]  view plain  copy

1. /** 
2.      * 超出范围 
3.      */  
4.     private boolean isOut;  
5.     /** 
6.      * 在超出范围的地方松手 
7.      */  
8.     private boolean isOutUp;  

只需要在触摸与绘制过程中动态改变或者判断它们就可以了。

以上分析得出code:

[java]  view plain  copy

1. package com.mabeijianxi.myapplication;  
2.   
3. import android.animation.ValueAnimator;  
4. import android.content.Context;  
5. import android.graphics.Canvas;  
6. import android.graphics.Color;  
7. import android.graphics.Paint;  
8. import android.graphics.Path;  
9. import android.graphics.PointF;  
10. import android.graphics.Rect;  
11. import android.view.MotionEvent;  
12. import android.view.View;  
13. import android.view.animation.OvershootInterpolator;  
14.   
15. /** 
16.  * Created by mabeijianxi on 2016/1/25. 
17.  */  
18. public class StickyView extends View {  
19.     /** 
20.      * 最大拖拽范围 
21.      */  
22.     private float mFarthestDistance = 200;  
23.     /** 
24.      * 动画中固定员的最小半径 
25.      */  
26.     private float mMinFixRadius = 8;  
27.     /** 
28.      * 拖拽圆的圆心 
29.      */  
30.     PointF mDragCanterPoint = new PointF(250, 250);  
31.     /** 
32.      * 固定圆的圆心 
33.      */  
34.     PointF mFixCanterPoint = new PointF(250, 250);  
35.     /** 
36.      * 控制点 
37.      */  
38.     PointF mCanterPoint = new PointF(250, 250);  
39.   
40.     /** 
41.      * 固定圆的切点 
42.      */  
43.     PointF[] mFixTangentPointes = new PointF[]{new PointF(235, 250),  
44.             new PointF(265, 250)};  
45.     /** 
46.      * 拖拽圆的切点 
47.      */  
48.     PointF[] mDragTangentPoint = new PointF[]{new PointF(230, 250),  
49.             new PointF(270, 250)};  
50.     /** 
51.      * 拖拽圆半径 
52.      */  
53.     float mDragRadius = 20;  
54.     /** 
55.      * 固定圆半径 
56.      */  
57.     float mFixRadius = 15;  
58.     /** 
59.      * 超出范围 
60.      */  
61.     private boolean isOut;  
62.     /** 
63.      * 在超出范围的地方松手 
64.      */  
65.     private boolean isOutUp;  
66.     private int mStatusBarHeight;  
67.     private Paint mPaint;  
68.     private Path mPath;  
69.     private float rangeMove;  
70.   
71.     public StickyView(Context context) {  
72.         super(context);  
73.         mPaint = new Paint();  
74.         mPaint.setColor(Color.RED);  
75.         mPaint.setAntiAlias(true);  
76.         mPath = new Path();  
77.     }  
78.   
79.     @Override  
80.     protected void onDraw(Canvas canvas) {  
81.         super.onDraw(canvas);  
82.         canvas.save();  
83. //      需要去除状态栏高度偏差  
84.         canvas.translate(0, -mStatusBarHeight);  
85. //      移出了范围后将不再绘制链接部分和固定圆  
86.         if (!isOut) {  
87. //            根据圆心距动态绘制固定圆大小  
88.             float mFixRadius = updateStickRadius();  
89.             canvas.drawCircle(mFixCanterPoint.x, mFixCanterPoint.y, mFixRadius,  
90.                     mPaint);  
91. //      设置控制点，这里的控制点选择的是两圆心连接成的直线的中心位置  
92.             mCanterPoint.set((mDragCanterPoint.x + mFixCanterPoint.x) / 2,  
93.                     (mDragCanterPoint.y + mFixCanterPoint.y) / 2);  
94. //            接下来是计算两个圆的外切点，会用到一点几何知识，忘了的回去找高中老师  
95.             float dy = mDragCanterPoint.y - mFixCanterPoint.y;  
96.             float dx = mDragCanterPoint.x - mFixCanterPoint.x;  
97.   
98.             if (dx != 0) {  
99.                 float k1 = dy / dx;  
100.                 float k2 = -1 / k1;  
101.                 mDragTangentPoint = getIntersectionPoints(  
102.                         mDragCanterPoint, mDragRadius, (double) k2);  
103.                 mFixTangentPointes = getIntersectionPoints(  
104.                         mFixCanterPoint, mFixRadius, (double) k2);  
105.             } else {  
106.                 mDragTangentPoint = getIntersectionPoints(  
107.                         mDragCanterPoint, mDragRadius, (double) 0);  
108.                 mFixTangentPointes = getIntersectionPoints(  
109.                         mFixCanterPoint, mFixRadius, (double) 0);  
110.             }  
111. //           必须重设上一次的路径  
112.             mPath.reset();  
113. //            moveTo顾名思义就是移动到某个位置，这里移动到固定圆的第一个外切点  
114.             mPath.moveTo(mFixTangentPointes[0].x, mFixTangentPointes[0].y);  
115. //           quadTo是绘制二阶贝塞尔曲线，这种曲线很想ps里面画矢量路径的那种。二阶的话需要一个控制点，一个起点一个终点  
116.             mPath.quadTo(mCanterPoint.x, mCanterPoint.y,  
117.                     mDragTangentPoint[0].x, mDragTangentPoint[0].y);  
118. //            从上一个点绘制一条直线到下面这个位置  
119.             mPath.lineTo(mDragTangentPoint[1].x, mDragTangentPoint[1].y);  
120. //            再绘制一条二阶贝塞尔曲线  
121.             mPath.quadTo(mCanterPoint.x, mCanterPoint.y,  
122.                     mFixTangentPointes[1].x, mFixTangentPointes[1].y);  
123. //            执行close，表示形成闭合路径  
124.             mPath.close();  
125. //            绘制到界面上  
126.             canvas.drawPath(mPath, mPaint);  
127.   
128.         }  
129. //        当在范围外松手的时候是不再绘制拖拽圆的  
130.         if (!isOutUp) {  
131.             canvas.drawCircle(mDragCanterPoint.x, mDragCanterPoint.y,  
132.                     mDragRadius, mPaint);  
133.         }  
134. //        参考范围，没实际作用  
135.         mPaint.setStyle(Paint.Style.STROKE);  
136.         canvas.drawCircle(mFixCanterPoint.x, mFixCanterPoint.y, mFarthestDistance, mPaint);  
137.         mPaint.setStyle(Paint.Style.FILL);  
138.   
139.         canvas.restore();  
140.     }  
141.   
142.     @Override  
143.     public boolean onTouchEvent(MotionEvent event) {  
144.         switch (event.getAction()) {  
145.             case MotionEvent.ACTION_DOWN:  
146.                 isOut = false;  
147.                 float startX = event.getRawX();  
148.                 float startY = event.getRawY();  
149.                 updateDragCenterPoint(startX, startY);  
150.                 break;  
151.             case MotionEvent.ACTION_MOVE:  
152.                 float endX = event.getRawX();  
153.                 float endY = event.getRawY();  
154. //                更加手的移动位置绘制拖拽圆的位置  
155.                 updateDragCenterPoint(endX, endY);  
156.                 distance();  
157. //                当移出了规定的范围的时候  
158.                 if (rangeMove > mFarthestDistance) {  
159.                     isOut = true;  
160.                 } else {  
161. //                    不能把isOut改为false,因为移出一次后就算它移出过了  
162. //              isOut=false;  
163.                     isOutUp = false;  
164.                 }  
165.                 break;  
166.             case MotionEvent.ACTION_UP:  
167. //                防止误操作  
168.                 distance();  
169.                 if (isOut) {  
170.                     outUp();  
171.                 }  
172.                 // 没有超出，做动画  
173.                 else {  
174.                     inUp();  
175.                 }  
176.                 invalidate();  
177.                 break;  
178.         }  
179.         return true;  
180.     }  
181.     /** 
182.      * 移动出规定范围 
183.      */  
184.     private void outUp() {  
185.         // 外面松手  
186.         if (rangeMove > mFarthestDistance) {  
187.             isOutUp = true;  
188.         }  
189.         // 里面松手  
190.         else {  
191.             isOutUp = false;  
192.         }  
193.         updateDragCenterPoint(mFixCanterPoint.x, mFixCanterPoint.y);  
194.     }  
195.     /** 
196.      * 计算此时拖拽圆心到固定圆心的距离 
197.      */  
198.     private void distance() {  
199.         rangeMove = getDistanceBetween2Points(  
200.                 mFixCanterPoint, mDragCanterPoint);  
201.     }  
202.   
203.     /** 
204.      * 移动的时候一直在范围内，最后在范围内松手 
205.      */  
206.     private void inUp() {  
207.         final PointF startPoint = new PointF(mDragCanterPoint.x,  
208.                 mDragCanterPoint.y);  
209.         final PointF endPoint = new PointF(mFixCanterPoint.x,  
210.                 mFixCanterPoint.y);  
211.         ValueAnimator animator = ValueAnimator.ofFloat(1.0f);  
212.         animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {  
213.   
214.             @Override  
215.             public void onAnimationUpdate(ValueAnimator animation) {  
216.                 float fraction = animation.getAnimatedFraction();  
217.                 PointF byPercent = getPointByPercent(  
218.                         startPoint, endPoint, fraction);  
219.                 updateDragCenterPoint(byPercent.x, byPercent.y);  
220.             }  
221.         });  
222.         animator.setInterpolator(new OvershootInterpolator(4.0f));  
223.         animator.setDuration(500);  
224.         animator.start();  
225.     }  
226.   
227.     /** 
228.      * 计算拖动过程中固定圆的半径 
229.      */  
230.     private float updateStickRadius() {  
231.         float distance = (float) Math.sqrt(Math.pow(mDragCanterPoint.y - mFixCanterPoint.y, 2)  
232.                 + Math.pow(mDragCanterPoint.x - mFixCanterPoint.x, 2));  
233.         distance = Math.min(distance, mFarthestDistance);  
234.         float percent = distance * 1.0f / mFarthestDistance;  
235.         return mFixRadius + (mMinFixRadius - mFixRadius) * percent;  
236.     }  
237.   
238.     /** 
239.      * 更新拖拽圆圆心 
240.      */  
241.     private void updateDragCenterPoint(float x, float y) {  
242.         mDragCanterPoint.set(x, y);  
243.         invalidate();  
244.     }  
245.   
246.     /** 
247.      * 获取状态栏高度 
248.      * 
249.      * @param v 
250.      * @return 
251.      */  
252.     public static int getStatusBarHeight(View v) {  
253.         if (v == null) {  
254.             return 0;  
255.         }  
256.         Rect frame = new Rect();  
257.         v.getWindowVisibleDisplayFrame(frame);  
258.         return frame.top;  
259.     }  
260.   
261.     @Override  
262.     protected void onSizeChanged(int w, int h, int oldw, int oldh) {  
263.         super.onSizeChanged(w, h, oldw, oldh);  
264.         mStatusBarHeight = getStatusBarHeight(this);  
265.     }  
266.     /** 
267.      * Get point between p1 and p2 by percent. 
268.      * 根据百分比获取两点之间的某个点坐标 
269.      * @param p1 
270.      * @param p2 
271.      * @param percent 
272.      * @return 
273.      */  
274.     public static PointF getPointByPercent(PointF p1, PointF p2, float percent) {  
275.         return new PointF(evaluateValue(percent, p1.x , p2.x), evaluateValue(percent, p1.y , p2.y));  
276.     }  
277.     /** 
278.      * 根据分度值，计算从start到end中，fraction位置的值。fraction范围为0 -> 1 
279.      * @param fraction 
280.      * @param start 
281.      * @param end 
282.      * @return 
283.      */  
284.     public static float evaluateValue(float fraction, Number start, Number end){  
285.         return start.floatValue() + (end.floatValue() - start.floatValue()) * fraction;  
286.     }  
287.     /** 
288.      * As meaning of method name. 
289.      * 获得两点之间的距离 
290.      * @param p0 
291.      * @param p1 
292.      * @return 
293.      */  
294.     public static float getDistanceBetween2Points(PointF p0, PointF p1) {  
295.         float distance = (float) Math.sqrt(Math.pow(p0.y - p1.y, 2) + Math.pow(p0.x - p1.x, 2));  
296.         return distance;  
297.     }  
298.     /** 
299.      * Get the point of intersection between circle and line. 
300.      * 获取 通过指定圆心，斜率为lineK的直线与圆的交点。 
301.      * 
302.      * @param pMiddle The circle center point. 
303.      * @param radius  The circle radius. 
304.      * @param lineK   The slope of line which cross the pMiddle. 
305.      * @return 
306.      */  
307.     public static PointF[] getIntersectionPoints(PointF pMiddle, float radius, Double lineK) {  
308.         PointF[] points = new PointF[2];  
309.   
310.         float radian, xOffset = 0, yOffset = 0;  
311.         if (lineK != null) {  
312.   
313.             radian = (float) Math.atan(lineK);  
314.             xOffset = (float) (Math.cos(radian) * radius);  
315.             yOffset = (float) (Math.sin(radian) * radius);  
316.         } else {  
317.             xOffset = radius;  
318.             yOffset = 0;  
319.         }  
320.         points[0] = new PointF(pMiddle.x + xOffset, pMiddle.y + yOffset);  
321.         points[1] = new PointF(pMiddle.x - xOffset, pMiddle.y - yOffset);  
322.   
323.         return points;  
324.     }  
325.   
326. }  

Activity:

[java]  view plain  copy

1. package com.mabeijianxi.myapplication;  
2.   
3. import android.app.Activity;  
4. import android.os.Bundle;  
5.   
6. public class MainActivity extends Activity {  
7.   
8.     @Override  
9.     protected void onCreate(Bundle savedInstanceState) {  
10.         super.onCreate(savedInstanceState);  
11.         setContentView(new StickyView(this));  
12.     }  
13. }  

以上代码运行示意图：

五、添加到合适的项目中：

也许你觉得应该结束了，然而其实才刚刚开始，下面会涉及到WindowManager与event的一些操作。

1、分析：比如要像QQ一样添加到listview中应该怎么做？一个listview里面有很多条目，我们这个拖拽控件是在条目中的，也就是说如果要像一般控件一样

直接添加到条目中，那么他将不能做出这一系列的拖拽，因为只能在父控件的区域内绘制，也就只能在一个条目的范围内移动，那么怎么可以实现

全屏移动呢？除非它的parent大小充满整个屏幕，这时应该想到WindowManager。只要在需要的时候把它添加到WindowManager就可以了，那么

什么时候需要呢？很明显是当手指触摸到需要被拖拽的控件的时候，所以肯定需要给需要拖拽的控件设置触摸监听。那么问题又来了，我们写的自定

拖拽控件的拖拽部分是一个圆，我们需要被拖拽的控件可能是一坨狗屎也可能是一朵鲜花，怎么办呢？其实很简单，让我们需要拖拽的狗屎也添加到

WindowManager中，狗屎的中心坐标恒等于拖拽圆的圆心就可以。一个View如果需要加到一个父控件中，那么添加之前这个View坑定不能有parent，

没有哪个孩子是两个爹的，所以需要先view.getParent(),如果其parent instanceof viewGroup那么就可以remove掉这个view，当然remove之前还需要

先得到view的LayoutParams,因为你动画做完了还需要把这个view还给原来的listview的条目。这个方法是不错，但是在一个view被remove了以后再添加

回去，这时将会有些得不到，具体的代码里面有注释，其实就是得不到，view在屏幕上的绝对坐标，我能想到的就是这个view被移除后坑定也在这个当前

窗体里面被移除，将再添加回去的时候，可能没有再次绑定到窗体，所提得不到坐标，具体详解请参考如何取得View的位置之View.getLocationInWindow()的

小秘密，我尝试了很多次依然有bug，如果大家有解决办法一定要吝啬和我分享一下呗。于是我采取了另外一个办法，每隔需要被拖拽的狗屎在被触摸时将

被隐藏，然后会新建一个一模一样的狗屎用来做动画，这样的话不管新建的狗屎解决如何都不重要，当然这样对内容会有那么多一点点的消耗。

2、实践：这里添加了一个辅助类当作桥梁作用，请点击StickyViewHelper，具体操作方法请点击simple。

3、使用lib依赖说明:麻烦一点就是需要被拖拽的控件在布局文件中要单独指定，然后在需要使用的地方用include.像这样：

includeview:

[java]  view plain  copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <TextView xmlns:android="http://schemas.android.com/apk/res/android"  
3.     android:id="@+id/mDragView"  
4.     android:layout_width="wrap_content"  
5.     android:layout_height="20dp"  
6.     android:background="@drawable/red_bg"  
7.     android:gravity="center"  
8.     android:layout_gravity="center"  
9.     android:singleLine="true"  
10.     android:text="1"  
11.     android:textSize="13sp"  
12.     android:textColor="@android:color/white"  
13.     />  

item:

[java]  view plain  copy

1. <include  
2.         android:layout_height="wrap_content"  
3.         android:layout_width="wrap_content"  
4.         android:layout_centerVertical="true"  
5.         android:layout_alignParentRight="true"  
6.         android:layout_marginRight="15dp"  
7.         layout="@layout/includeview"  
8.         />  

具体的请参照sample,内附详细注释。

sample与lib下载地址：https://github.com/mabeijianxi/stickyDots