今天要实现一个类似viva上， 可以拉动的gallery

--------------------------------------------------------2012.11.9

       自己是一个什么东西都记不住的人，所以要弄一个东西的时候，就重新查笔记，或者查demo

要实现类似的东西，首先 找了个demo ，发现，只能显示对应的图片，因为在 Adapter中的getView只返回原来初始化了的对应的图片作为每个item来显示

public View getView(int position, View convertView, ViewGroup parent) {
	return mImages[position];
}

只能生成对应大小的item， 如果 要显示， 要么 让数组里面的大小增大到很大， 要么就让显示循环

没有多思考，又找了个demo

发现是这样做的

在getView里面循环下  取余得到对应的图片，

public View getView(int position, View convertView, ViewGroup parent){
	ImageView imageView = new ImageView(mContext);
	imageView.setImageResource(resIds[position % resIds.length]);
	imageView.setScaleType(ImageView.ScaleType.FIT_XY);
	imageView.setLayoutParams(new Gallery.LayoutParams(163, 106));
	imageView.setBackgroundResource(mGalleryItemBackground);
	return imageView;
}

再把getCount 的数值 设置成最大值（很大的一个数）。

public int getCount() {
	return Integer.MAX_VALUE;
}

就可以相当于无限的2边拉了。

当然，在Activity最好设置成gallery.setSelection(Integer.MAX_VALUE/2);，

不然就只能一边无限拉了

问题：

BaseAdapter 下面的实现和构造过程？

本文参考了   ：

http://blog.csdn.net/svrsimon/article/details/6935950

---------------------------------2012.11.13-----------异步加载中重复请求的问题

今天要对这个组件改动，要异步加载图片

于是，在getView中异步加载图片

问题来了，每次拉动，都会请求服务器，如果有5张图片，当拉到后面的时候，原来请求过的图片也会重新请求

于是，按照同事说的方法，把图片放到本地，如果本地有显示本地的；如果本地没有，就请求服务器显示，并且下载到本地。

这样做就不会因为拉动而频繁的请求服务器了。

-------------------------------2012.11.13-----------中间的图片和周围不一样

将  imageView.setBackgroundResource(R.drawable.online_list_item_default_img2);
改成了 imageView.setImageResource(R.drawable.online_list_item_default_img2);

再异步下载判断就可以了，   但是不知道为什么！

---------------------------------2012.11.13------------对BaseAdapter的理解（先简单看一下）

首先看源码

/**
 * Common base class of common implementation for an {@link Adapter} that can be
 * used in both {@link ListView} (by implementing the specialized
 * {@link ListAdapter} interface} and {@link Spinner} (by implementing the
 * specialized {@link SpinnerAdapter} interface.
 */
public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter {
    private final DataSetObservable mDataSetObservable = new DataSetObservable();

    public boolean hasStableIds() {
        return false;
    }
    
    public void registerDataSetObserver(DataSetObserver observer) {
        mDataSetObservable.registerObserver(observer);
    }

    public void unregisterDataSetObserver(DataSetObserver observer) {
        mDataSetObservable.unregisterObserver(observer);
    }
    
    /**
     * Notifies the attached observers that the underlying data has been changed
     * and any View reflecting the data set should refresh itself.
     */
    public void notifyDataSetChanged() {
        mDataSetObservable.notifyChanged();
    }

    /**
     * Notifies the attached observers that the underlying data is no longer valid
     * or available. Once invoked this adapter is no longer valid and should
     * not report further data set changes.
     */
    public void notifyDataSetInvalidated() {
        mDataSetObservable.notifyInvalidated();
    }

    public boolean areAllItemsEnabled() {
        return true;
    }

    public boolean isEnabled(int position) {
        return true;
    }

    public View getDropDownView(int position, View convertView, ViewGroup parent) {
        return getView(position, convertView, parent);
    }

    public int getItemViewType(int position) {
        return 0;
    }

    public int getViewTypeCount() {
        return 1;
    }
    
    public boolean isEmpty() {
        return getCount() == 0;
    }
}

首先是，private final DataSetObservable mDataSetObservable = new DataSetObservable();

DataSetObservable 观察者，观察者模式？？（有时间要具体看下）

参考：http://www.cnblogs.com/jerryxing/archive/2012/04/08/2438085.html（现在还不是很懂）

观察者模式,     参考文档：http://www.blogjava.net/supercrsky/articles/202544.html （先保存）

实现 implements ListAdapter, SpinnerAdapter 2个adapter接口   （o(︶︿︶)o 唉）

-------------------------------------------------11.13  ------观察者模式的理解（感觉还好，有时间看下 Button的监听过程）------

详情见【自己blog】：http://blog.csdn.net/q2390183798/article/details/8178983

-----------------------------------2012.11.13-------理解BaseAdapter-----------

先理解下 Observable<T>  , 先写了  注册，删除，删除所有的方法，对于线程sychronized的  （不懂为什么要是抽象的???怕单独用？）

/**
 * Provides methods for (un)registering arbitrary observers in an ArrayList.
 */
public abstract class Observable<T> {
    /**
     * The list of observers.  An observer can be in the list at most
     * once and will never be null.
     */
    protected final ArrayList<T> mObservers = new ArrayList<T>();

    /**
     * Adds an observer to the list. The observer cannot be null and it must not already
     * be registered.
     * @param observer the observer to register
     * @throws IllegalArgumentException the observer is null
     * @throws IllegalStateException the observer is already registered
     */
    public void registerObserver(T observer) {
        if (observer == null) {
            throw new IllegalArgumentException("The observer is null.");
        }
        synchronized(mObservers) {
            if (mObservers.contains(observer)) {
                throw new IllegalStateException("Observer " + observer + " is already registered.");
            }
            mObservers.add(observer);
        }
    }

    /**
     * Removes a previously registered observer. The observer must not be null and it
     * must already have been registered.
     * @param observer the observer to unregister
     * @throws IllegalArgumentException the observer is null
     * @throws IllegalStateException the observer is not yet registered
     */
    public void unregisterObserver(T observer) {
        if (observer == null) {
            throw new IllegalArgumentException("The observer is null.");
        }
        synchronized(mObservers) {
            int index = mObservers.indexOf(observer);
            if (index == -1) {
                throw new IllegalStateException("Observer " + observer + " was not registered.");
            }
            mObservers.remove(index);
        }
    }
    
    /**
     * Remove all registered observer
     */
    public void unregisterAll() {
        synchronized(mObservers) {
            mObservers.clear();
        }        
    }
}