Adapter数据变化改变现有View的实现

首先说说Adapter具体的类的继承关系，如下图

     Adapte为接口它的实现类的对象作为AdapterView和View的桥梁，Adapter是装载了View(比如ListView和girdView要显示的数据）。相关View要显示的数据完全与View解耦。View要显示的数据从Adapter里面获取并展现出来；Adapter负责把真实的数据是配成一个个View(每一条数据对应一个View)让GirdView等类似的组件来显示这些是配好的一个个View,。也就是说View要显示什么数据取决于Adapter，View的变化（比如ListView删除一个或者增加一个Item)也取决于Adapter里面的数据的变化。这也就说明当Adapter的里面的数据如果发生变化的时候相应的View(如ListView)也得发生对应的变化。当Adapter里面的数据发生变化的时候必须通知View也发生变化，继而重绘View从而展示数据变化过的View.这是典型的观察者模式的应用。

Adapter是被观察的主题，被观察者监视，如果Adapter这个Subject状态发生了变化，主题会告知观察者，观察者通过回调一个函数得到通知，通知关联对象做出相应的更新。

既然是被观察者，用面向对象的思维来说，该主题必须持有观察者的对象用来让观察者观察，所以主题在观察者模式中也具备了注册和销毁观察者对象的责任

 由此可以推出Adapter有以下两个主要的职责：

  1) 把源数据适配成一个个View

  2) 当数据发生变化的时候发送通知（向观察者发送通知，然后由观察者做出相应的响应，观察者模式），让相关组件（GirdView)做出在页面展现上的修改。

  

Adapter的部分代码如下：

[java]  view plain  copy

 

1. public interface Adapter {  
2.     /** 
3.      * 注册观察者observer，当Adapter里面的数据发生变化时通知 
4.      *该观察者，观察者调用onChanged()方法来做出相应的响应 
5.      */  
6.     void registerDataSetObserver(DataSetObserver observer);  
7.   
8.     /** 
9.      * 取消已经注册过的观察者observer对象 
10.      */  
11.     void unregisterDataSetObserver(DataSetObserver observer);  
12.   
13.     /** 
14.      *把adapter里面的数据适配一个个View，每一条数据对应了一个View用来对该条数据做展现 
15.      最终让GirdView等相关组件来显示。具体会产生多少个View由getCount()方法来决定 
16.      */  
17.     View getView(int position, View convertView, ViewGroup parent);  
18.  }  

可以看到adapter这个父接口定义了注册观察者的方法，下面就看看观察者的都做了哪些事情：这里的观察者是DataSetObserver抽象类的扩展类。该抽象类提供了两个方法：

[java]  view plain  copy

 

1. public abstract class DataSetObserver {  
2. //数据源发生变化的时候调用  
3.  public void onChanged() {  
4.         // Do nothing  
5.     }  
6.     public void onInvalidated() {  
7.         // Do nothing  
8.     }  
9. }  

那么，这个观察者是怎么和Adapter进行关联的呢？其实观察者对象是放在一个ArrayList集合里面去的。该集合封装在Observable<T>这个抽象类。看看这个类的源码就可以明白：

[java]  view plain  copy

 

1. public abstract class Observable<T> {  
2. //保存观察者对象的集合  
3.  protected final ArrayList<T> mObservers = new ArrayList<T>();  
4. //注册观察者  
5.  public void registerObserver(T observer) {  
6.         if (observer == null) {  
7.             throw new IllegalArgumentException("The observer is null.");  
8.         }  
9.         synchronized(mObservers) {  
10.             if (mObservers.contains(observer)) {  
11.                 throw new IllegalStateException("Observer " + observer + " is already registered.");  
12.             }  
13.             mObservers.add(observer);  
14.         }  
15.     }  
16. //删除已经注册的观察者  
17.     public void unregisterObserver(T observer) {  
18.         if (observer == null) {  
19.             throw new IllegalArgumentException("The observer is null.");  
20.         }  
21.         synchronized(mObservers) {  
22.             int index = mObservers.indexOf(observer);  
23.             if (index == -1) {  
24.                 throw new IllegalStateException("Observer " + observer + " was not registered.");  
25.             }  
26.             mObservers.remove(index);  
27.         }  
28.     }  
29. //清空所有观察者  
30.  public void unregisterAll() {  
31.         synchronized(mObservers) {  
32.             mObservers.clear();  
33.         }  
34.     }  
35. }  

通过源码可以知道Observervable<T>的主要职责是添加观察者以及删除已经添加过的观察者！该抽象类还有一个子类DataSetObservable：该类在继承父类功能的基础上又提供了两个方法，这两个方法的作用就是向一系列观察者发送通知，以便让该类包含的 所有 观察者执行onChanged()或者onInvalidated（）来执行特定的行为。源码如下：

[java]  view plain  copy

 

1. public class DataSetObservable extends Observable<DataSetObserver> {  
2.     //当数据源发生变化的时候调用此方法来让View进行响应   
3.     public void notifyChanged() {  
4.         synchronized(mObservers) {          
5.             for (int i = mObservers.size() - 1; i >= 0; i--) {  
6.                 mObservers.get(i).onChanged();  
7.             }  
8.         }  
9.     }  
10.     public void notifyInvalidated() {  
11.         synchronized (mObservers) {  
12.             for (int i = mObservers.size() - 1; i >= 0; i--) {  
13.                 mObservers.get(i).onInvalidated();  
14.             }  
15.         }  
16.     }  
17. }  

通过上面的说明我们知道观察者对象的工作是由DataSetObservable来间接发出告知并执行观察者自己的onChange方法的。读到这可以发现，现在观察者还是没有和相应Adapter进行关联以及在数据发生变化的时候Adapter是怎么发送通知的，下面就以BaseAdapter进行说明，其部分源码如下：

[java]  view plain  copy

 

1. public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter {  
2. //该对象用来注册观察者  
3.  private final DataSetObservable mDataSetObservable = new DataSetObservable();  
4.   
5.     public boolean hasStableIds() {  
6.         return false;  
7.     }  
8.     //注册观察者  
9.     public void registerDataSetObserver(DataSetObserver observer) {  
10.         mDataSetObservable.registerObserver(observer);  
11.     }  
12.     //删除已经注册过的观察者  
13.     public void unregisterDataSetObserver(DataSetObserver observer) {  
14.         mDataSetObservable.unregisterObserver(observer);  
15.     }  
16.       
17.    //当数据源发生变化的时候调用此方法  
18.     public void notifyDataSetChanged() {  
19.         mDataSetObservable.notifyChanged();  
20.     }  
21.     public void notifyDataSetInvalidated() {  
22.         mDataSetObservable.notifyInvalidated();  
23.     }  

很显然，BaseAdapter包含了一个DataSetObservable类型的引用mDataSetObservable，通过前面的说明可知该引用所代表的对象里面封装了若干个观察者，具体注册观察者的方法就是BaseAdapter的 registerDataSetObserver方法。通过读该源码发现该类提供了一个notifyDataSetChanged()方法，当数据源或者Adapter里面的数据发生变化的时候要手动调用此方法来发起通知！！！！到此为止就找到了是什么方法来为观察者发送通知的，正是notifyDataSetChanged()方法。

  以上只是沿着程序的脉络来说明当数据发生变化的时候是怎么通知观察者的。具体观察者都做了的onChange方法都做了什么并没有说明，这些由观察者不同的子类来实现的，这里先不做讨论。下面说说怎样让adapter里面的数据在view里面显示出来。

  上面已经说明了Adapter的一个职责之一就是把数据源组织成一个个view并返回一个view的对象，具体怎么组织的是由Adapter的方法getView来实现的,该方法实在onMeasure()方法执行的时候被调用的，再具体的是在obtainView方法中调用。搞Android开发的程序员都少不了和这个方法打交道，这里就不做赘述。

  当把数据放入Adapter之后，通过GirdView（或者ListView这篇文章以GirdView为例)的setAdapter()方法把数据最终展现出来。或许细心的读者会发现在自己开发的过程中并没有在自己的Adapter添加观察者啊？只是简单的setAdapter()之后就什么也不用管了？其实不然，看看setAdapter都做些了什么就会知道

[java]  view plain  copy

 

1. public void setAdapter(ListAdapter adapter) {  
2.         //清空之前绑定的mDataSetObserver对象  
3.         if (mAdapter != null && mDataSetObserver != null) {  
4.             mAdapter.unregisterDataSetObserver(mDataSetObserver);  
5.         }  
6.   
7.         //清空之前的一切数据，初始化一些必要的参数  
8.         resetList();  
9.         mRecycler.clear();    
10.         //重置adapter       
11.         mAdapter = adapter;  
12.   
13.         //初始化上次选中item的位置  
14.         mOldSelectedPosition = INVALID_POSITION;  
15.         //初始化上次选中行的位置，即：当初选中的行的索引  
16.         mOldSelectedRowId = INVALID_ROW_ID;  
17.   
18.         // AbsListView#setAdapter will update choice mode states.  
19.         super.setAdapter(adapter);  
20.   
21.         if (mAdapter != null) {  
22.             //记录之前girdView里面item的数目  
23.             mOldItemCount = mItemCount;  
24.             //当前girdView里面item的数据  
25.             mItemCount = mAdapter.getCount();  
26.             //数据已经变化  
27.             mDataChanged = true;  
28.               
29.             //检测焦点  
30.             checkFocus();  
31.               
32.             //注册观察者  
33.             mDataSetObserver = new AdapterDataSetObserver();  
34.             mAdapter.registerDataSetObserver(mDataSetObserver);  
35.   
36.               
37.             mRecycler.setViewTypeCount(mAdapter.getViewTypeCount());  
38.   
39.               
40.             int position;  
41.             //判断是否从最后来查找Selectable的的位置  
42.             //lookForSelectablePosition从方法实现上来看是第二个参数是没有用到的  
43.             if (mStackFromBottom) {  
44.                 
45.                 position = lookForSelectablePosition(mItemCount - 1, false);  
46.             } else {  
47.                 position = lookForSelectablePosition(0, true);  
48.             }  
49.             //选中第几个，记录了行和当前girdview的id  
50.             setSelectedPositionInt(position);  
51.             //选中下一个  
52.             setNextSelectedPositionInt(position);  
53.             //检测是否选中的位置改变  
54.             checkSelectionChanged();  
55.         } else {  
56.             checkFocus();              
57.             // Nothing selected  
58.             checkSelectionChanged();  
59.         }  
60.         //充值布局  
61.         requestLayout();  
62.     }  

通过上面的源码可以发现，每次调用setAdapter的时候都会注册AdapterDataSetObserver对象（上面代码33行），这样就可以在adapter发生变化的时候进行响应的处理。

那么看看这个具体的观察者到底都做了些什么：

[java]  view plain  copy

 

1. class AdapterDataSetObserver extends AdapterView<ListAdapter>.AdapterDataSetObserver {  
2.         @Override  
3.         public void onChanged() {  
4.             //注意主要的逻辑就在super.onChanged()方法里面  
5.             super.onChanged();  
6.             if (mFastScroller != null) {  
7.                 mFastScroller.onSectionsChanged();  
8.             }  
9.         }  
10.   
11.         @Override  
12.         public void onInvalidated() {  
13.             super.onInvalidated();  
14.             if (mFastScroller != null) {  
15.                 mFastScroller.onSectionsChanged();  
16.             }  
17.         }  
18.     }  

看看onChange()方法里面调用了父类的方法onChange()方法，主要的响应数据变化的逻辑就在父类的onChange()方法里面，先买看看父类的该方法的具体实现：

[java]  view plain  copy

 

1. class AdapterDataSetObserver extends DataSetObserver {  
2.   
3.         private Parcelable mInstanceState = null;  
4.   
5.         @Override  
6.         public void onChanged() {  
7.             mDataChanged = true;  
8.             mOldItemCount = mItemCount;  
9.             mItemCount = getAdapter().getCount();  
10.             if (AdapterView.this.getAdapter().hasStableIds() && mInstanceState != null  
11.                     && mOldItemCount == 0 && mItemCount > 0) {  
12.                 AdapterView.this.onRestoreInstanceState(mInstanceState);  
13.                 mInstanceState = null;  
14.             } else {  
15.                 rememberSyncState();  
16.             }  
17.             checkFocus();  
18.             requestLayout();  
19.         }  
20. }  

最终走到会执行requestLayout()来重新布局页面达到响应数据变化的目的。至此，已经完成了对adapter数据变化来改变当前View的变化的说明。

下面说说使用案例：

有如下效果图

                                                                                      效果图1

注意上图的12个数据时保存在GirdView里面的，当我点击编辑的时候页面变化成如下图所示的情况：

                                                       效果图2

下面具体说说这种效果的具体实现。

1）Adapter的代码如下：

[java]  view plain  copy

 

1. public class CollectionItemAdapter extends BaseAdapter {  
2.    
3.     private Vector<Collection> collections;  
4.     public static final  int EDIT_STATUS = 0;//为零时为编辑状态  
5.     public  static final int UNEDIT_STATUS = -1;//为非编辑状态  
6.      private int delePosition = UNEDIT_STATUS;//删除标志      
7.   
8.     public int getDelePosition() {  
9.         return delePosition;  
10.     }  
11.   
12.     public void setDelePosition(int delePosition) {  
13.         this.delePosition = delePosition;  
14.     }  
15.   
16.     public Vector<Collection> getCollections() {  
17.         return collections;  
18.     }  
19.   
20.     public void setCollections(Vector<Collection> collections) {  
21.         this.collections = collections;  
22.     }  
23.   
24.     @Override  
25.     public int getCount() {  
26.         if(collections != null){  
27.             return collections.size();  
28.         }  
29.         // TODO Auto-generated method stub  
30.         return 0;  
31.     }  
32.   
33.     @Override  
34.     public Collection getItem(int position) {  
35.         if(collections !=null){  
36.            return   collections.get(position);  
37.         }  
38.         // TODO Auto-generated method stub  
39.         return null;  
40.     }  
41.   
42.     @Override  
43.     public long getItemId(int position) {  
44.         // TODO Auto-generated method stub  
45.         return position;  
46.     }  
47.   
48.     @Override  
49.     public View getView(int position, View convertView, ViewGroup parent) {  
50.         ViewItem viewItem = null;  
51.         if(convertView==null){  
52.             viewItem = new ViewItem();        
53.             convertView = App.getLayoutInflater().inflate(R.layout.collection_item, null);            
54.             viewItem.img = (ImageView)convertView.findViewById(R.id.item_img);  
55.             viewItem.name = (TextView)convertView.findViewById(R.id.item_name);  
56.             viewItem.editBg = (ImageView)convertView.findViewById(R.id.collection_edit_bg);  
57.             convertView.setTag(viewItem);         
58.         }else {  
59.             viewItem = (ViewItem) convertView.getTag();  
60.         }  
61.         viewItem.img.setImageResource(R.drawable.no_pic_small);  
62.         Collection collection = this.getItem(position);  
63.         viewItem.name.setText(collection.getName());  
64.         ImageLoader.getInstance().displayImage(collection.getPicUrl(), viewItem.img, App.getOptionsSmall());  
65.         viewItem.img.setVisibility(View.VISIBLE);  
66.         if(delePosition==EDIT_STATUS){//表示为编辑状态  
67.             //显示删除背景图  
68.             viewItem.editBg.setVisibility(View.VISIBLE);      
69.               
70.         }else{  
71.             //隐藏删除背景图  
72.             viewItem.editBg.setVisibility(View.GONE);  
73.         }  
74.         return convertView;  
75.     }  
76.   
77.     private static class ViewItem {  
78.         ImageView img;  
79.         TextView name;  
80.         ImageView editBg;  
81.         public String toString(){  
82.             return name.getText().toString();  
83.         }  
84.     }  
85.   
86. }  

注意该Adapter有一个delePosition 用来标志是否处于编辑状态，同时在getView方法里面对该字段进行了判断：当处于非编辑状态的时候运行结果为效果图1，当点击编辑的时候delePoition为编辑状态，此时的页面效果为效果图2.也就是说如果想是实现这个功能只需要改变Adapter对象的这个字段进行设置然后调用notifyDataSetChanged()方法通知观察者就行了，所以当点击编辑的时候的响应事件为：

[java]  view plain  copy

 

1. //设置删除标志  
2.                     collectionAdapter.setDelePosition(CollectionItemAdapter.UNEDIT_STATUS);  
3.                    //向观察者发生通知  
4. collectionAdapter.notifyDataSetChanged();  

2)collection_item.xml配置文件如下

[html]  view plain  copy

 

1. <?xml version="1.0" encoding="utf-8"?>  
2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
3.     android:layout_width="fill_parent"  
4.     android:layout_height="fill_parent" >  
5.   
6.     <RelativeLayout  
7.         android:layout_width="@dimen/wiki_item_w"  
8.         android:layout_height="@dimen/wiki_item_h" >  
9.         <!-- 海报 -->  
10.         <RelativeLayout  
11.             android:layout_width="match_parent"  
12.             android:layout_height="match_parent"  
13.             android:padding="@dimen/pading_17" >  
14.             <ImageView  
15.                 android:id="@+id/item_img"  
16.                 android:layout_width="fill_parent"  
17.                 android:layout_height="fill_parent"  
18.                 android:focusable="false"  
19.                 android:src="@drawable/test" />  
20.         </RelativeLayout>  
21.   
22.         <!-- 节目名称的背景底图 -->  
23.         <RelativeLayout  
24.             android:layout_width="match_parent"  
25.             android:layout_height="match_parent"  
26.             android:padding="@dimen/pading_15" >  
27.   
28.             <ImageView  
29.                 android:id="@+id/item_bg_img"  
30.                 android:layout_width="fill_parent"  
31.                 android:layout_height="fill_parent"  
32.                 android:focusable="false"  
33.                 android:src="@drawable/item_txt_bg" />  
34.         </RelativeLayout>  
35.        <!--焦点框图片 -->  
36.         <ImageView  
37.             android:id="@+id/collection_focus"  
38.             android:layout_width="match_parent"  
39.             android:layout_height="match_parent"  
40.             android:background="@drawable/item_focus_selecter" />  
41.          
42.         <!-- 处于编辑状态的背景图片，开始visibility为gone,当点击编辑是为visible -->  
43.         <RelativeLayout  
44.             android:layout_width="match_parent"  
45.             android:layout_height="match_parent"  
46.             android:padding="@dimen/pading_19" >  
47.             <ImageView  
48.                 android:id="@+id/collection_edit_bg"  
49.                 android:layout_width="match_parent"  
50.                 android:layout_height="match_parent"  
51.                 android:focusable="false"  
52.                 android:background="@drawable/record_collection_edit_selecter"  
53.                 android:visibility="gone" />  
54.         </RelativeLayout>  
55.          <!-- 节目名称 -->  
56.         <tv.huan.epg.vod.qclt.ui.widget.ScrollForeverTextView  
57.             android:id="@+id/item_name"  
58.             android:layout_width="fill_parent"  
59.             android:layout_height="wrap_content"  
60.             android:layout_alignParentBottom="true"  
61.             android:layout_marginBottom="@dimen/collection_item_name_margin_left"  
62.             android:layout_marginLeft="@dimen/collection_item_name_margin_right"  
63.             android:layout_marginRight="@dimen/collection_item_name_margin_bottom"  
64.             android:ellipsize="marquee"  
65.             android:gravity="center"  
66.             android:marqueeRepeatLimit="marquee_forever"  
67.             android:singleLine="true"  
68.             android:textColor="@drawable/font_color_selector"  
69.             android:textSize="@dimen/font_20" />  
70.     </RelativeLayout>  
71.   
72. </RelativeLayout>  

另外在编辑的时候点击某一个item可以删除，也就是删除Adapter类里面的Vector里面的数据，删除过后同样调用notifyDatasetChanged()方法进行通知即可

略作总结：因为数据都在Adapter里面，所以说Adapter是观察者要观察的主题(SubJect)或者说被观察的对象，Adapter负责注册和销毁观察者，当数据发生变化的时候通知观察者更新ListView.观察者的作用就是当一个对象的状态发生变化的时候，能够自动通知其他对象，以便其他对象做出对应的更新操作。

其中在观察者模式中，Subject是主动变化，而观察者只能根据主题的变化而做出相应的变更。