Android SimpleAdapter源码解析

SimpleAdapter：

public class SimpleAdapter extends BaseAdapter implements Filterable {
    private int[] mTo; // 指向布局里面控件的id 比如：R.id.btn
    private String[] mFrom; // 数据来源，来自Map里面的key
    private ViewBinder mViewBinder;// 接口类型，里面有个setViewValue方法，用于出现特殊类型控件比如：drawable的时候在外部初始化接口，实现具体方法  

    private List<? extends Map<String, ?>> mData;// 用List打包的Map数据源  

    private int mResource;// 布局
    private int mDropDownResource;// 资源文件
    private LayoutInflater mInflater;//LayoutInflater用来载入界面  

    private SimpleFilter mFilter;// 过滤器
    private ArrayList<Map<String, ?>> mUnfilteredData;  

    // SimpleAdapter初始化，将传进了的参数都赋给本地的对应变量
    public SimpleAdapter(Context context, List<? extends Map<String, ?>> data,
        int resource, String[] from, int[] to) {
        mData = data;
        mResource = mDropDownResource = resource;
        mFrom = from;
        mTo = to;
        mInflater = (LayoutInflater) context
        .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    }  

    /*
     * ListView 针对每个item，要求 adapter “返回一个视图” (getView)，
     * 也就是说ListView在开始绘制的时候，系统首先调用getCount（）函数，根据他的返回值得到ListView的长度，
     * 然后根据这个长度，调用getView（）一行一行的绘制ListView的每一项。如果你的getCount（）返回值是0的话，
     * 列表一行都不会显示，如果返回1，就只显示一行。返回几则显示几行。如果我们有几千几万甚至更多的item要显示怎么办？
     * 为每个Item创建一个新的View？不可能！！！实际上Android早已经缓存了这些视图，大家可以看下下面这个截图来理解下，
     * 其实Android中有个叫做Recycler的构件
     */
    public int getCount() {
        return mData.size();
    }  

    public Object getItem(int position) {
        return mData.get(position);
    }  

    public long getItemId(int position) {
        return position;
    }  

    public View getView(int position, View convertView, ViewGroup parent) {
        // 调用createViewFromResource来优化内存
        return createViewFromResource(position, convertView, parent, mResource);
    }  

    /*
     * ListView的机制在这里再说一下，当第一个数据来getView的时候convertView肯定是null，
     * 那么就用mInflater.inflate(resource, parent,
     * false)给它初始化一个View，但是当一屏滑到底了，第一个item，滑出了屏幕，那么它将
     * 从底部出来，那时候convertView就不为null，这个方法的好处就是当convertView不为null
     * 的时候不用加载布局，直接使用convertView， 节省了一步，这也是所说的优化ListView的第一个步骤。
     */
    private View createViewFromResource(int position, View convertView,
        ViewGroup parent, int resource) {
        View v;
        if (convertView == null) {
            v = mInflater.inflate(resource, parent, false);
        } else {
            v = convertView;
        }
        // 这个方法是核心
        bindView(position, v);  

        return v;
    }  

    public void setDropDownViewResource(int resource) {
        this.mDropDownResource = resource;
    }  

    @Override
    public View getDropDownView(int position, View convertView, ViewGroup parent) {
        return createViewFromResource(position, convertView, parent,
            mDropDownResource);
    }  

    // 这个方法的主要功能就是按照 to数组里面控件的顺序挨个赋值，比如new int[]{R.id.tv_name,R.id.tv_pwd}。
    private void bindView(int position, View view) {
        final Map dataSet = mData.get(position);// 找到对应的position位置的map数据
        // 如果没找到跳出
        if (dataSet == null) {
            return;
        }
        /*
         * 将外部实现的ViewBinder，赋值给本地，SimpleAdapter能够实现：
         * checkBox,CheckedTextView,TextView
         * ,ImageView,数据类型也就是Boolean，Integer，Stirng， 所以特殊数据类型的时候才用到ViewBinder
         * ,如果没用到就不需要外部实现ViewBinder接口和里面的方法
         */
        final ViewBinder binder = mViewBinder;
        final String[] from = mFrom;
        final int[] to = mTo;
        final int count = to.length;
//view.findViewById(to[i])，循环找控件
        for (int i = 0; i < count; i++) {
            final View v = view.findViewById(to[i]);
            //如果v不为空的话，找到对应的数据，Object类型的data转换为String，因为boolean在map里面纯的也是true或者false
            if (v != null) {
                final Object data = dataSet.get(from[i]);
                String text = data == null ? "" : data.toString();
                if (text == null) {
                    text = "";
                }
//标志变量bound，判断外部有没有实现ViewBinder，如果实现了，就执行binder.setViewValue(v, data, text)，如果符合特殊条件，就返回true
                boolean bound = false;
                if (binder != null) {
                    bound = binder.setViewValue(v, data, text);
                }
//如果满足if (!bound)那么bound就还是false,说明是普通数据
                if (!bound) {
                    //查看v是不是Checkable的实例化类型，满足的情况可能是CheckBox，CheckedTextView
                    if (v instanceof Checkable) {
                        //如果数据类型是boolean，那么就是CheckBox
                        if (data instanceof Boolean) {
                            ((Checkable) v).setChecked((Boolean) data);
                            //如果不是CheckBox，那么判断是不是继承TextView的CheckedTextView，是的话赋值，不是就抛出异常
                        } else if (v instanceof TextView) {
                            setViewText((TextView) v, text);
                        } else {
                            throw new IllegalStateException(v.getClass()
                                .getName()
                                + " should be bound to a Boolean, not a "
                                + (data == null ? "<unknown type>"
                                    : data.getClass()));
                        }
                        //如果不是Checkable的实例化类型，判断是不是TextView的实例化类型
                    } else if (v instanceof TextView) {
                        setViewText((TextView) v, text);
                        //都不是以上情况，就判断一下是不是ImageView的实例化类型
                    } else if (v instanceof ImageView) {
                        //这里只满足数据类型为int也就是R.drawable.ic，和String类型的url，如果想实现直接用drawbale，就要实现ViewBinder
                        if (data instanceof Integer) {
                            setViewImage((ImageView) v, (Integer) data);
                        } else {
                            setViewImage((ImageView) v, text);
                        }
                    } else {
                        throw new IllegalStateException(
                            v.getClass().getName()
                            + " is not a "
                            + " view that can be bounds by this SimpleAdapter");
                    }
                }
            }
        }
    }  

    public ViewBinder getViewBinder() {
        return mViewBinder;
    }  

    public void setViewBinder(ViewBinder viewBinder) {
        mViewBinder = viewBinder;
    }  

    public void setViewImage(ImageView v, int value) {
        v.setImageResource(value);
    }  

    public void setViewImage(ImageView v, String value) {
        try {
            v.setImageResource(Integer.parseInt(value));
        } catch (NumberFormatException nfe) {
            v.setImageURI(Uri.parse(value));
        }
    }  

    public void setViewText(TextView v, String text) {
        v.setText(text);
    }  

    public Filter getFilter() {
        if (mFilter == null) {
            mFilter = new SimpleFilter();
        }
        return mFilter;
    }  

    public static interface ViewBinder {
        boolean setViewValue(View view, Object data, String textRepresentation);
    }  

//这里是数据过滤器，根据前缀过滤
    private class SimpleFilter extends Filter {  

        @Override
        protected FilterResults performFiltering(CharSequence prefix) {
            FilterResults results = new FilterResults();  

            if (mUnfilteredData == null) {
                mUnfilteredData = new ArrayList<Map<String, ?>>(mData);
            }  

            if (prefix == null || prefix.length() == 0) {
                ArrayList<Map<String, ?>> list = mUnfilteredData;
                results.values = list;
                results.count = list.size();
            } else {
                String prefixString = prefix.toString().toLowerCase();  

                ArrayList<Map<String, ?>> unfilteredValues = mUnfilteredData;
                int count = unfilteredValues.size();  

                ArrayList<Map<String, ?>> newValues = new ArrayList<Map<String, ?>>(
                    count);  

                for (int i = 0; i < count; i++) {
                    Map<String, ?> h = unfilteredValues.get(i);
                    if (h != null) {  

                        int len = mTo.length;  

                        for (int j = 0; j < len; j++) {
                            String str = (String) h.get(mFrom[j]);  

                            String[] words = str.split(" ");
                            int wordCount = words.length;  

                            for (int k = 0; k < wordCount; k++) {
                                String word = words[k];  

                                if (word.toLowerCase().startsWith(prefixString)) {
                                    newValues.add(h);
                                    break;
                                }
                            }
                        }
                    }
                }  

                results.values = newValues;
                results.count = newValues.size();
            }  

            return results;
        }  

  //最后这里是对过滤结果通过notifyDataSetChanged()更新UI
        @Override
        protected void publishResults(CharSequence constraint, FilterResults results) {
            // noinspection unchecked
            mData = (List<Map<String, ?>>) results.values;
            if (results.count > 0) {
                notifyDataSetChanged();
            } else {
                notifyDataSetInvalidated();
            }
        }
    }
}
} 

版权声明：本文为博主原创文章，未经博主允许不得转载。