ScrollLayout的学习【仿launcher滑动】

实现view滑动的功能在自定义的ScrollLayout类中实现。该类是一个自定义view,它本身和LinearLayout、ScrollView等等view有异曲同工之妙，就像LinearLayout它能帮助我们把我们包装在里面的控件排列成线性布局，我们自己编写的ScrollLayout能够帮助我们实现屏幕滑屏的效果。

 ScrollLayout extendsGroupView

步骤：先把所有的子view的大小都找好，然后为他们分配好位置

之后根据手指的手势判断手势的速度还有移动距离来确定将要移动到哪个curScreen，最后把界面显示成我们的destScreen就OK了。

源码：

main.xml

[html]  view plain copy print ?

1. <?xml version="1.0" encoding="utf-8"?>  
2. <com.crte.scrolllayout.ScrollLyout xmlns:android="http://schemas.android.com/apk/res/android"  
3.     android:layout_width="fill_parent"  
4.     android:layout_height="fill_parent"  
5.     android:orientation="vertical" >  
6.   
7.     <LinearLayout  
8.         android:layout_width="fill_parent"  
9.         android:layout_height="fill_parent"  
10.         android:background="#ffedfa" >  
11.     </LinearLayout>  
12.   
13.     <LinearLayout  
14.         android:layout_width="fill_parent"  
15.         android:layout_height="fill_parent"  
16.         android:background="#ceb452" >  
17.     </LinearLayout>  
18.   
19. </com.crte.scrolllayout.ScrollLyout>  

ScrollLayout类：

[java]  view plain copy print ?

1. package com.crte.scrolllayout;  
2.   
3. import android.app.Activity;  
4.   
5. public class ScrollLyout extends ViewGroup {// Terase_ScrollLyoutDemoActivity  
6.     private static final String TAG = "terase_ScrollLayout";  
7.     private Scroller mScroller;  
8.     private VelocityTracker mVelocityTracker;  
9.   
10.     private int mCurScreen;  
11.     private int mDefaultScreen = 0;  
12.   
13.     private static final int TOUCH_STATE_REST = 0; // 表示触摸状态为空闲  
14.                                                     // 即没有触摸或者手指离开了  
15.     private static final int TOUCH_STATE_SCROLLING = 1; // 表示手指正在移动  
16.   
17.     private static final int SNAP_VELOCITY = 600; // 默认的滚动速度  
18.                                                     // 之后用于和手指滑动产生的速度比较  
19.                                                     // 获取屏幕滚动的速度  
20.   
21.     private int mTouchState = TOUCH_STATE_REST; // 当前手指的事件状态  
22.     private int mTouchSlop; // 手指移动的最小距离的判断标准  
23.                             // =ViewConfiguration.get(getContext()).getScaledTouchSlop();  
24.                             // 在viewpapper中就是依赖于这个值来判断用户  
25.                             // 手指滑动的距离是否达到界面滑动的标准  
26.     private float mLastMotionX; // 手指移动的时候，或者手指离开屏幕的时候记录下的手指的横坐标  
27.     private float mLastMotionY; // 手指移动的时候，或者手指离开屏幕的时候记录下的手指的纵坐标  
28.   
29.     public ScrollLyout(Context context) {  
30.         super(context);  
31.         Logger.e(TAG, "----ScrollLyout1---");  
32.     }  
33.   
34.     public ScrollLyout(Context context, AttributeSet attrs, int defStyle) {  
35.         super(context, attrs, defStyle);  
36.         Logger.e(TAG, "----ScrollLyout2---");  
37.   
38.         // 初始化基本数据  
39.         mScroller = new Scroller(context);  
40.         mCurScreen = mDefaultScreen;  
41.         mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop(); // 使用系统默认的值  
42.     }  
43.   
44.     public ScrollLyout(Context context, AttributeSet attrs) {  
45.         this(context,attrs,0);  
46.         Logger.e(TAG, "----ScrollLyout3---");  
47.     }  
48.   
49.     @Override  
50.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
51.         super.onMeasure(widthMeasureSpec, heightMeasureSpec);  
52.         Logger.e(TAG, "----onMeasure----");  
53.         // 在onlayout之前执行，获取View申请的大小，把它们保存下来，方面后面使用  
54.         final int width = MeasureSpec.getSize(widthMeasureSpec);  
55.         final int widthMode = MeasureSpec.getMode(widthMeasureSpec);  
56.         if (widthMode != MeasureSpec.EXACTLY) {  
57.             throw new IllegalStateException(  
58.                     "ScrollLayout only can run at EXACTLY mode!");  
59.         }  
60.   
61.         final int hightModed = MeasureSpec.getMode(heightMeasureSpec);  
62.         if (hightModed != MeasureSpec.EXACTLY) {  
63.             throw new IllegalStateException(  
64.                     "ScrollLayout only can run at EXACTLY mode!");  
65.         }  
66.         final int count = getChildCount();  
67.         // 为每一个孩子设置它们的大小为ScrollLayout的大小  
68.         for (int i = 0; i < count; i++) {  
69.             getChildAt(i).measure(widthMeasureSpec, heightMeasureSpec);  
70.         }  
71.         scrollTo(mCurScreen * width, 0);  
72.   
73.     }  
74.   
75.     @Override  
76.     protected void onLayout(boolean changed, int l, int t, int r, int b) {  
77.         Logger.e(TAG, "----onLayout----");  
78.         // 为每一个孩子设置它们的位置  
79.         if (changed) {  
80.             int childLeft = 0;  
81.             int childCount = getChildCount();  
82.             for (int i = 0; i < childCount; i++) {  
83.                 final View childView = getChildAt(i);  
84.                 if (childView.getVisibility() != View.GONE) {  
85.                     // 此处获取到的宽度就是在onMeasure中设置的值  
86.                     final int childWidth = childView.getMeasuredWidth();  
87.                     // 为每一个子View布局  
88.                     childView.layout(childLeft, 0, childLeft + childWidth,  
89.                             childView.getMeasuredHeight());  
90.                     childLeft = childLeft + childWidth;  
91.                 }  
92.             }  
93.         }  
94.     }  
95.   
96.     /** 
97.      * 让界面跟着手指移动到手指移动的地点 
98.      */  
99.     public void snapToDestination() {  
100.   
101.         Logger.e(TAG, "----snapToDestination---");  
102.         final int screenWidth = getWidth(); // 子view的宽度，此例中为他适配的父view的宽度  
103.         Logger.e(TAG, "screenWidth = "+screenWidth);  
104.         final int destScreen = (getScrollX() + screenWidth / 2) / screenWidth; // 某个算法吧，  
105.         Logger.e(TAG, "[destScreen] : "+destScreen);                                                                        // 我计算了一下的确是能够准确算出目标view  
106.                                                                                 // getScroolX()值为  
107.         snap2DestScreen(destScreen);  
108.     }  
109.   
110.     /** 
111.      * 滚动到指定screen 
112.      *  
113.      * @param destScreen 
114.      */  
115.     private void snap2DestScreen(int destScreen) {  
116.         Logger.e(TAG, "----snap2DestScreen----");  
117.         Logger.e(TAG, "Math.min(destScreen, getChildCount() - 1) = "+(Math.min(destScreen, getChildCount() - 1)));  
118.         destScreen = Math.max(0, Math.min(destScreen, getChildCount() - 1));// 获取要滚动到的目标screen  
119.         Logger.e(TAG, "whichScreen = "+destScreen);  
120.         if (getScrollX() != (getWidth() * destScreen)) {  
121.             final int delta = destScreen * getWidth() - getScrollX(); // 获取屏幕移到目的view还需要移动多少距离  
122.             Logger.e(TAG, "[getScrollX()] : "+getScrollX() );  
123.             Logger.e(TAG, "[delta] : "+delta);  
124.             Logger.e(TAG, "[getScrollX要走到的位置为] : "+(getScrollX()+delta));  
125.             mScroller.startScroll(getScrollX(), 0, delta, 0,  
126.                     Math.abs(delta) * 2);// 使用Scroller辅助滚动，让滚动变得更平滑  
127.             mCurScreen = destScreen;  
128.             invalidate();// 重绘界面  
129.         }  
130.     }  
131.   
132.     @Override  
133.     public void computeScroll() {  
134.         Logger.e(TAG, "----computeScroll----");  
135.         if(mScroller.computeScrollOffset()){  
136.             scrollTo(mScroller.getCurrX(), mScroller.getCurrY());  
137.             invalidate();  
138.         }  
139.     }  
140.   
141.     @Override  
142.     public boolean onTouchEvent(MotionEvent event) {  
143.         Logger.e(TAG, "----onTouchEvent----");  
144.         if (mVelocityTracker == null) {  
145.             mVelocityTracker = VelocityTracker.obtain();  
146.         }  
147.         mVelocityTracker.addMovement(event);  
148.   
149.         final int action = event.getAction();  
150.         final float x = event.getX();  
151.         final float y = event.getY();  
152.   
153.         switch (action) {  
154.         case MotionEvent.ACTION_DOWN://1,终止滚动2,获取最后一次事件的x值  
155.             Logger.e(TAG, "----ACTION_DOWN----");  
156.             if(!mScroller.isFinished()){  
157.                 mScroller.abortAnimation();  
158.             }  
159.             mLastMotionX = x;  
160.             break;  
161.         case MotionEvent.ACTION_MOVE://1,获取最后一次事件的x值2,滚动到指定位置  
162.             Logger.e(TAG, "----ACTION_MOVE----");  
163.             int deltaX = (int) (mLastMotionX - x );  
164.             mLastMotionX = x;  
165.             scrollBy(deltaX, 0);  
166.             break;  
167.         case MotionEvent.ACTION_UP://1,计算手指移动的速度并得出我们需要的速度2,选择不同情况下滚动到哪个 screen  
168.             Logger.e(TAG, "----ACTION_UP----");  
169.             final VelocityTracker velocityTracker = mVelocityTracker;  
170.             velocityTracker.computeCurrentVelocity(1000);   // 设置属性为计算1秒运行多少个像素  
171.                                     // computeCurrentVelocity(int  
172.                                     // units, float  
173.                                     // maxVelocity)上面的1000即为此处的units。  
174.                                     // maxVelocity必须为正，表示当计算出的速率大于maxVelocity时为maxVelocity  
175.                                     //小于maxVelocity就为计算出的速率  
176.             int velocityX = (int) velocityTracker.getXVelocity();  
177.             Logger.e(TAG, "[velocityX] : "+velocityX);  
178.             if(velocityX > SNAP_VELOCITY && mCurScreen > 0){//如果速度为正，则表示向右滑动。需要指定mCurScreen大于0，才能滑，不然就不准确啦  
179.                 Logger.e(TAG, "速度为正且-->：当前mCurScreen = "+mCurScreen);  
180.                 Logger.e(TAG, "要走到的：mCurScreen = "+(mCurScreen-1));  
181.                 snap2DestScreen(mCurScreen - 1);  
182.                   
183.             }else if(velocityX < -SNAP_VELOCITY && mCurScreen < (getChildCount() - 1)){//如果速度为负，则表示手指向左滑动。需要指定mCurScreen小于最后一个子view的id，才能滑，不然就不准确啦  
184.                 Logger.e(TAG, "速度为fu且《--：当前mCurScreen = "+mCurScreen);  
185.                 Logger.e(TAG, "要走到的：mCurScreen = "+(mCurScreen+1));  
186.                 snap2DestScreen(mCurScreen + 1);  
187.             }else{  //速度小于我们规定的达标速度，那么就让界面跟着手指滑动显示。最后显示哪个screen再做计算（方法中有计算）  
188.                 Logger.e(TAG, "速度的绝对值小于规定速度,走snapToDestination方法");  
189.                 snapToDestination();  
190.             }  
191.             if(mVelocityTracker != null){  
192.                 mVelocityTracker.recycle();  
193.                 mVelocityTracker = null;  
194.             }  
195.             mTouchState = TOUCH_STATE_REST;     //为什么这里要设置？？？  
196.             break;  
197.         case MotionEvent.ACTION_CANCEL://1,设置触摸事件状态为空闲  
198.             Logger.e(TAG, "----ACTION_CANCEL----");  
199.             mTouchState = TOUCH_STATE_REST;  
200.             break;  
201.         }  
202.         return true;  
203.     }  
204.   
205.     @Override  
206.     public boolean onInterceptTouchEvent(MotionEvent ev) {  
207.         Logger.e(TAG, "----onInterceptTouchEvent----");  
208.         final int action = ev.getAction();  
209.         // 如果  
210.         if ((action == MotionEvent.ACTION_MOVE)  
211.                 && mTouchState != TOUCH_STATE_REST) {  
212.             return true;  
213.         }  
214.   
215.         final float x = ev.getX();  
216.         final float y = ev.getY();  
217.   
218.         switch (action) {  
219.         case MotionEvent.ACTION_DOWN:// 判断滚动是否停止  
220.             Logger.e(TAG, "----ACTION_DOWN----");  
221.             mLastMotionX = x;  
222.             mLastMotionY = y;  
223.             mTouchState = mScroller.isFinished() ? TOUCH_STATE_REST  
224.                     : TOUCH_STATE_SCROLLING;  
225.   
226.             break;  
227.         case MotionEvent.ACTION_MOVE:// 判断是否达成滚动条件  
228.             Logger.e(TAG, "----ACTION_MOVE----");  
229.             final int xDiff = (int) Math.abs(mLastMotionX - x);  
230.             if (xDiff > mTouchSlop) {// 如果该值大于我们规定的最小移动距离则表示界面在滚动  
231.                 mTouchState = TOUCH_STATE_SCROLLING;  
232.             }  
233.             break;  
234.         case MotionEvent.ACTION_UP:// 把状态调整为空闲  
235.             Logger.e(TAG, "----ACTION_UP----");  
236.             mTouchState = TOUCH_STATE_REST;  
237.             break;  
238.   
239.         }  
240.         // 如果屏幕没有在滚动那么就不消耗这个touch事件  
241.         return mTouchState != TOUCH_STATE_REST;  
242.     }  
243. }  

Logger是封装了Log的类，负责打印log。

ScrollLayout类中方法运行的流程：

getScrollX()这个方法的值：

有需要的筒子戳下面的连接下载源码。

下载链接：http://download.csdn.net/detail/xueyingpiaoran/4882067