Android----腾讯微博（下拉刷新+点击更多）listview的实现 （android）
 

Lance老师UI系列教程第二课->腾讯微博（下拉刷新+点击更多）listview的实现 （android）

分类： android UI教程 android2012-07-23 21:00 982人阅读 评论(1) 收藏 举报
                                                    UI系列教程第二课：腾讯微博下拉刷新listview

 

今天蓝老师要讲的是关于腾讯微博下拉刷新listview的实现。如上图所示，这是一个用户体验非常好的操作方式，在腾讯微博，新浪微博等等应用中相当常见，相信很多童鞋以后做应用也都会碰到。关于其实现原理，其实网上已有很多demo，鼻祖要数GitHub的J兄了，J兄的做法主要是重写 OnScroll，根据各种状态修改headview的size；还有种则是在OnTouchEvent里做文章，同样是对headview设置padding改变其大小；可能对于多数人后者比较容易理解，蓝老师就第二种实现方式展开本节课程，示例demo是蓝老师重构代码后同时加以扩展添加底部点击获取更多的操作方式，完成腾讯微博的listview实现效果，废话不多说，先上效果图：

 

大致跟童鞋们说下思路，实现原理是给listview加上一个headview，然后headview有四种状态

[java] view plaincopy
  1. public interface IListViewState  
  2. {  
  3.     int LVS_NORMAL = 0;                 //  普通状态  
  4.     int LVS_PULL_REFRESH = 1;           //  下拉刷新状态  
  5.     int LVS_RELEASE_REFRESH = 2;        //  松开刷新状态  
  6.     int LVS_LOADING = 3;                //  加载状态  
  7. }  

 

所以关键在于MotionEvent.ACTION_MOVE时根据手势情况切换各种headview状态

MotionEvent.ACTION_UP时根据当前状态确定是该进入加载状态还是普通状态

OK，先贴上touchevent代码：

[java] view plaincopy
  1. @Override  
  2.     public boolean onTouchEvent(MotionEvent ev) {  
  3.         // TODO Auto-generated method stub  
  4.                   
  5.         if (mOnRefreshListener != null)  
  6.         {  
  7.             switch (ev.getAction()) {  
  8.             case MotionEvent.ACTION_DOWN:         
  9.                 doActionDown(ev);  
  10.                 break;  
  11.             case MotionEvent.ACTION_MOVE:  
  12.                 doActionMove(ev);  
  13.                 break;  
  14.             case MotionEvent.ACTION_UP:  
  15.                 doActionUp(ev);  
  16.                 break;  
  17.             default:  
  18.                 break;  
  19.             }     
  20.         }  
  21.           
  22.                   
  23.         return super.onTouchEvent(ev);  
  24.     }  
  25.       
  26.     private void doActionDown(MotionEvent ev)  
  27.     {  
  28.         if(mIsRecord == false && mFirstItemIndex == 0)  
  29.         {  
  30.             mStartY = (int) ev.getY();  
  31.             mIsRecord = true;  
  32.         }  
  33.     }  
  34.       
  35.     private void doActionMove(MotionEvent ev)  
  36.     {  
  37.         mMoveY = (int) ev.getY();  
  38.           
  39.         if(mIsRecord == false && mFirstItemIndex == 0)  
  40.         {  
  41.             mStartY = (int) ev.getY();  
  42.             mIsRecord = true;  
  43.         }  
  44.           
  45.         if (mIsRecord == false || mViewState == IListViewState.LVS_LOADING)  
  46.         {  
  47.             return ;  
  48.         }     
  49.           
  50.         int offset = (mMoveY - mStartY) / RATIO;      
  51.           
  52.         switch(mViewState)  
  53.         {  
  54.             case IListViewState.LVS_NORMAL:  
  55.             {  
  56.                 if (offset > 0)  
  57.                 {         
  58.                     mHeadView.setPadding(0, offset - mHeadContentHeight, 0, 0);  
  59.                     switchViewState(IListViewState.LVS_PULL_REFRESH);  
  60.                 }  
  61.             }  
  62.                 break;  
  63.             case IListViewState.LVS_PULL_REFRESH:  
  64.             {  
  65.                 setSelection(0);  
  66.                 mHeadView.setPadding(0, offset - mHeadContentHeight, 0, 0);  
  67.                 if (offset < 0)  
  68.                 {  
  69.                     switchViewState(IListViewState.LVS_NORMAL);  
  70.                 }else if (offset > mHeadContentHeight)  
  71.                 {  
  72.                     switchViewState(IListViewState.LVS_RELEASE_REFRESH);  
  73.                 }  
  74.             }  
  75.                 break;  
  76.             case IListViewState.LVS_RELEASE_REFRESH:  
  77.             {  
  78.                 setSelection(0);  
  79.                 mHeadView.setPadding(0, offset - mHeadContentHeight, 0, 0);  
  80.                 if (offset >= 0 && offset <= mHeadContentHeight)  
  81.                 {  
  82.                     mBack = true;  
  83.                     switchViewState(IListViewState.LVS_PULL_REFRESH);  
  84.                 }else if (offset < 0)  
  85.                 {  
  86.                     switchViewState(IListViewState.LVS_NORMAL);  
  87.                 }else{  
  88.                   
  89.                 }  
  90.                   
  91.             }  
  92.                 break;  
  93.             default:  
  94.                 return;  
  95.         };        
  96.           
  97.     }  
  98.       
  99.     private void doActionUp(MotionEvent ev)  
  100.     {  
  101.         mIsRecord = false;  
  102.         mBack = false;  
  103.           
  104.         if (mViewState == IListViewState.LVS_LOADING)  
  105.         {  
  106.             return ;  
  107.         }  
  108.           
  109.         switch(mViewState)  
  110.         {  
  111.         case IListViewState.LVS_NORMAL:  
  112.           
  113.             break;  
  114.         case IListViewState.LVS_PULL_REFRESH:  
  115.             mHeadView.setPadding(0, -1 * mHeadContentHeight, 0, 0);  
  116.             switchViewState(IListViewState.LVS_NORMAL);  
  117.             break;  
  118.         case IListViewState.LVS_RELEASE_REFRESH:  
  119.             mHeadView.setPadding(0, 0, 0, 0);  
  120.             switchViewState(IListViewState.LVS_LOADING);  
  121.             onRefresh();  
  122.             break;  
  123.         }     
  124.           
  125.     }  

 

看下面这个代码段

[java] view plaincopy
  1. if(mIsRecord == false && mFirstItemIndex == 0)  
  2.     {  
  3.         mStartY = (int) ev.getY();  
  4.         mIsRecord = true;  
  5.     }  

其实就是在一次完整的手势过程中，当headview第一次出现时，记录当前触摸点Y坐标值，而在之后的MotionEvent.ACTION_MOVE过程中，我们当前的触摸点与原始记录值会有一个偏移量offset

int offset = (mMoveY - mStartY) / RATIO;

这个RATIO值姑且不管它，把它当成一先，假设headview原始高度为size，那么offset与size就有以下三种关系：

Offset < 0                                   headview不可见                                    NORMAL状态

Offset > 0 && offset < size         headview可见且不超过原始高度                      PULL_REFRESH状态

Offset > size                              headview可见且超过原始高度                         RELEASE_REFRESH

 

我们要做的就是根据当前状态再结合offset值来改变headview的尺寸以及确定是否需要切换headview状态

Switch的这段代码已经描述的很明朗了

 

[java] view plaincopy
  1. switch(mViewState)  
  2.         {  
  3.             case IListViewState.LVS_NORMAL:  
  4.             {  
  5.                 if (offset > 0)  
  6.                 {         
  7.                     mHeadView.setPadding(0, offset - mHeadContentHeight, 0, 0);  
  8.                     switchViewState(IListViewState.LVS_PULL_REFRESH);  
  9.                 }  
  10.             }  
  11.                 break;  
  12.             case IListViewState.LVS_PULL_REFRESH:  
  13.             {  
  14.                 setSelection(0);  
  15.                 mHeadView.setPadding(0, offset - mHeadContentHeight, 0, 0);  
  16.                 if (offset < 0)  
  17.                 {  
  18.                     switchViewState(IListViewState.LVS_NORMAL);  
  19.                 }else if (offset > mHeadContentHeight)  
  20.                 {  
  21.                     switchViewState(IListViewState.LVS_RELEASE_REFRESH);  
  22.                 }  
  23.             }  
  24.                 break;  
  25.             case IListViewState.LVS_RELEASE_REFRESH:  
  26.             {  
  27.                 setSelection(0);  
  28.                 mHeadView.setPadding(0, offset - mHeadContentHeight, 0, 0);  
  29.                 if (offset >= 0 && offset <= mHeadContentHeight)  
  30.                 {  
  31.                     mBack = true;  
  32.                     switchViewState(IListViewState.LVS_PULL_REFRESH);  
  33.                 }else if (offset < 0)  
  34.                 {  
  35.                     switchViewState(IListViewState.LVS_NORMAL);  
  36.                 }else{  
  37.                   
  38.                 }  
  39.                   
  40.             }  
  41.                 break;  
  42.             default:  
  43.                 return;  
  44.         };        

 

部分童鞋可能会好奇，为神马在PULL_REFRESH以及RELEASE_REFRESH状态为何要设置setselection(0)

主要是因为当列表长度超过屏幕时候，在往上推动时候会感觉好像是推动速度比下拉速度快，实际上是因为，当列表高度超过屏幕时候，我们在往上推动时候，除了执行我们自己的方法之外，列表也在向下滑动，这样就产生了“推动比下拉速度快”的错觉，也导致了headview部分视图被滚出屏外而不会被完全显示，所以需要在 PULL_REFRESH和RELEASE_REFRESH状态setSelection(0)让headview按当前尺寸完全显示，不信大家把它注释掉试一试就知道了。

那么在switchViewState里就只是更改一些显示元素而已了

[java] view plaincopy
  1. private void switchViewState(int state)  
  2.     {     
  3.           
  4.           
  5.         switch(state)  
  6.         {  
  7.             case IListViewState.LVS_NORMAL:  
  8.             {  
  9.                 Log.e("!!!!!!!!!!!", "convert to IListViewState.LVS_NORMAL");  
  10.                 mArrowImageView.clearAnimation();  
  11.                 mArrowImageView.setImageResource(R.drawable.arrow);  
  12.             }  
  13.                 break;  
  14.             case IListViewState.LVS_PULL_REFRESH:  
  15.             {  
  16.                 Log.e("!!!!!!!!!!!", "convert to IListViewState.LVS_PULL_REFRESH");  
  17.                 mHeadProgressBar.setVisibility(View.GONE);  
  18.                 mArrowImageView.setVisibility(View.VISIBLE);  
  19.                 mRefreshTextview.setText("下拉可以刷新");  
  20.                 mArrowImageView.clearAnimation();  
  21.   
  22.                 // 是由RELEASE_To_REFRESH状态转变来的  
  23.                 if (mBack)  
  24.                 {  
  25.                     mBack = false;  
  26.                     mArrowImageView.clearAnimation();  
  27.                     mArrowImageView.startAnimation(reverseAnimation);  
  28.                 }  
  29.             }  
  30.                 break;  
  31.             case IListViewState.LVS_RELEASE_REFRESH:  
  32.             {  
  33.                 Log.e("!!!!!!!!!!!", "convert to IListViewState.LVS_RELEASE_REFRESH");  
  34.                 mHeadProgressBar.setVisibility(View.GONE);  
  35.                 mArrowImageView.setVisibility(View.VISIBLE);  
  36.                 mRefreshTextview.setText("松开获取更多");  
  37.                 mArrowImageView.clearAnimation();  
  38.                 mArrowImageView.startAnimation(animation);  
  39.             }  
  40.                 break;  
  41.             case IListViewState.LVS_LOADING:  
  42.             {  
  43.                 Log.e("!!!!!!!!!!!", "convert to IListViewState.LVS_LOADING");  
  44.                 mHeadProgressBar.setVisibility(View.VISIBLE);  
  45.                 mArrowImageView.clearAnimation();  
  46.                 mArrowImageView.setVisibility(View.GONE);  
  47.                 mRefreshTextview.setText("载入中...");  
  48.             }  
  49.                 break;  
  50.                 default:  
  51.                     return;  
  52.         }     
  53.           
  54.         mViewState = state;  
  55.           
  56.     }  

再回到刚刚RATIO值的问题，其实就是为了更良好的用户体验，本例设置该值为2，也就意味着虽然移动了100距离，但实际headview尺寸值只改变了50，这样就有一种橡皮筋的感觉

下面再看看activity里面的使用

[java] view plaincopy
  1. public void initData()  
  2.    {  
  3.   
  4.     data = new LinkedList<String>();  
  5.     String string = "";  
  6.     for(int i = 0; i < 6; i++)  
  7.     {  
  8.         string = "genius" + i;  
  9.         data.addFirst(string);  
  10.     }  
  11.       
  12.     adapter = new MyListViewAdapter(this, data);  
  13.   
  14.       
  15.       
  16.     mListView.setAdapter(adapter);  
  17.     mListView.setOnRefreshListener(this);  
  18.     mListView.setOnLoadMoreListener(this);  
  19.   
  20.    }  
[java] view plaincopy
  1. public void OnRefresh() {  
  2.         // TODO Auto-generated method stub  
  3.       
  4.         mRefreshAsynTask = new RefreshDataAsynTask();  
  5.         mRefreshAsynTask.execute(null);  
  6.     }  
[java] view plaincopy
  1. class RefreshDataAsynTask extends AsyncTask<Void , Void, Void>  
  2.     {  
  3.   
  4.         @Override  
  5.         protected Void doInBackground(Void... arg0) {  
  6.               
  7.               
  8.               
  9.             try {  
  10.                 Thread.sleep(2000);  
  11.             } catch (InterruptedException e) {  
  12.                 // TODO Auto-generated catch block  
  13.                 e.printStackTrace();  
  14.             }  
  15.               
  16.             index++;  
  17.             data.addFirst("genius" + index);  
  18.               
  19.               
  20.             return null;  
  21.         }  
  22.   
  23.         @Override  
  24.         protected void onPostExecute(Void result) {  
  25.             // TODO Auto-generated method stub  
  26.           
  27.             adapter.refreshData(data);  
  28.             mListView.onRefreshComplete();  
  29.         }  
  30.           
  31.           
  32.           
  33.     }  

加载完数据后更新adapter并刷新listview状态就可以了

 

如果不需要下拉效果就把 mListView.setOnRefreshListener(this);屏蔽掉

如果不需要footview，就调用listview.removeFootView移除掉它

很智能有木有~

其它就没啥好说的了，footview的处理比较简单，童鞋们自个儿下代码看吧

下面附上代码工程链接：

http://download.csdn.net/detail/geniuseoe2012/4446532

 

温馨提示：学而不思则罔，思而不学则殆，拿来主义固然要发挥，不过童鞋们也要有自己的思考，不然很难进步的哦

欲知更多Android-UI技巧，请关注窝的下一堂课,更多精彩尽在http://blog.csdn.net/geniuseoe2012

posted on 2013-01-18 00:08  zhengbeibei  阅读(5417)  评论(0)  编辑  收藏  举报
Copyright © 2024 zhengbeibei
Powered by .NET 9.0 on Kubernetes Powered By: 博客园