android结合异步任务，动态加载图片，Json解析数据展示在ListView，并且实现按日期分类展示，借口回调

需求分析：通过异步任务下载JSON数据，解析json数据，其中的日期数据要求按照日期将信息进行分类展示，还有图片的地址信息，每次得到一个图片地址，又开启一个下载图片的异步任务下载图片，并加载到相应的Item布局中。

1 创建一个借口，用于回调结果

public interface INetResourceCallback {

    void getNetResource(String netResource);
    
}

2 封装一个网络请求的工具类，通过接口回调返回数据

public class AsyncTaskTool{

    /**
     * @param urlPath
     * @return
     */
    public static DownloadNetResourceTask getDownloadNetResourceTask(String urlPath){
        return new DownloadNetResourceTask(urlPath);
    }

    

/**
     * 下载网络资源的字节数据的异步任务，使用构建者模式，默认为get请求，如果是post请求则调用post请求方法
     * 使用接口INetResouceCallback 的getNetResource()方法回调将得到的数据返回到调用者中
     * @author jola
     *
     */
    public static class DownloadNetResourceTask extends AsyncTask<String, Integer, String>{
        /**
         *请求的网络地址 
         */
        private String urlPath;
        /**
         * 如果是POST请求，则需要传入此参数
         */
        private String requestParam;
        /**
         * 向异步任务注册的接口，用于返回得到的结果
         */
        @SuppressWarnings("unused")
        private INetResourceCallback mINetResourceCallback;
        
        public DownloadNetResourceTask(String urlPath){
            this.urlPath = urlPath;
        }
        public DownloadNetResourceTask doPostRequestMethod(String requestParam){
            this.requestParam = requestParam;
            return this;
        }
        public void execute(INetResourceCallback mINetResourceCallback){
            this.mINetResourceCallback = mINetResourceCallback;
            super.execute(requestParam);
        }
        @Override
        protected String doInBackground(String... params) {
            try {
                HttpURLConnection conn = (HttpURLConnection)((new URL(urlPath)).openConnection());
                conn.setConnectTimeout(5000);
                //如果有请求方式的参数传递进来，则将请求方式设置为POST
                if(null != requestParam){
                    conn.setRequestMethod("POST");
                    conn.setDoOutput(true);
                    conn.getOutputStream().write(requestParam.getBytes());
                    conn.getOutputStream().flush();
                }
                if(conn.getResponseCode() == HttpURLConnection.HTTP_OK){
                    InputStream in = conn.getInputStream();
                    int hasRead = 0;
                    byte[] buffer = new byte[1024];
                    StringBuilder stringBuilder = new StringBuilder();
                    String strData = null;
                    while(-1 != (hasRead = in.read(buffer))){
                        strData = new String(buffer,0,hasRead);
                        stringBuilder.append(strData);
                    }
                    return stringBuilder.toString();
                }
                
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
        
        @Override
        protected void onPostExecute(String result) {
            //将数据通过接口回调方式传过去
            mINetResourceCallback.getNetResource(result);
        }
    }
}

<strong>3  定义好两个布局文件（日期分类的TextView,展示属于日<span style="font-family:Arial, Helvetica, sans-serif;"><span style="font-size: 18px; background-color: rgb(255, 255, 255);">期</span></span></strong>

TextView展示日期

 <TextView 
        android:id="@+id/time_group_item_txt"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="2016-09-23 今日开服"
        android:background="#F5F5DC"
        android:textColor="#FF4040"
        android:textSize="16sp"
        android:layout_margin="6dp"
        />

在当前日期下内容的item布局

<ImageView 
        android:id="@+id/image_name_item_list"
        android:layout_marginTop="10dp"
        android:layout_width="60dp"
        android:layout_height="60dp"
        android:scaleType="centerCrop"
        />
    <TextView 
        android:id="@+id/title_name_item_list"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="皇图"
        android:textSize="20sp"
        android:layout_margin="6dp"
        android:layout_toRightOf="@id/image_name_item_list"
        />
    <TextView 
        android:id="@+id/start_time_name_item_list"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="09-23 10:00    384我的服服"
        android:singleLine="true"
        android:layout_below="@+id/title_name_item_list"
        android:layout_toRightOf="@+id/image_name_item_list"
        android:layout_alignLeft="@+id/title_name_item_list"
        android:drawableLeft="@drawable/clock_tag"
        />
    <TextView 
        android:id="@+id/operator_name_item_list"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="运营商：馆长当时的就卡机读卡公司"
        android:layout_toRightOf="@+id/image_name_item_list"
        android:layout_below="@+id/start_time_name_item_list"
        android:layout_alignLeft="@+id/title_name_item_list"
        />
    <Button 
        android:id="@+id/btn_name_item_list_view_main"
        android:layout_width="wrap_content"
        android:layout_height="40dp"
        android:layout_alignParentRight="true"
        android:text="查看"
        android:textColor="#FFFFFF"
        android:layout_marginRight="6dp"
        android:layout_marginTop="18dp"
        android:background="@drawable/shape"
        
        />

4 准备好基本的类，用于封装item中的信息

public class Giftbean implements Serializable{

    private String addtime;
    private String area;
    private String gid;
    private String gift;
    private String gname;
    private String iconurl;
    private String id;
    private String linkurl;
    private String openflagname;
    private String operators;
    private String platform;
    private String score;
    private String teststarttime;
    private String uid;
    
省略get,set方法
}

5  主活动中代码如下：

/**
 * GiftBagElves
 * @author jola
 *
 */
public class MainActivity extends Activity implements INetResourceCallback {

    private final static String URLPATH = "http://www.1688wan.com/majax.action?method=getJtkaifu";
    
    /**
     * 默认申请的是第一页的数据
     */
    private int pageno = 1;
    
    /**
     * mListView展示锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟较�
     */
    private ListView mListView;
    
    /**
     * 存放解析到的json对象
     */
    private List<Giftbean> mListData;
    
    /**
     * 根据日趋对开服信息进行分类存储
     */
    private Map<String,List<Giftbean>> mTypeListData = new HashMap<String,List<Giftbean>>();
    
    /**
     * 存放所有展示在ListView中的数据
     */
    private List<Object> allDatas = new ArrayList<Object>();
    /**
     * 自定义适配器
     */
    private KaifuAdapter mAdapter;
    /**
     * item类型是时间，就返回1
     */
    private static final int ITEM_TYPE_DATA = 1;
    /**
     * item类型是开服对象数据，则返回2，加载相应的布局
     */
    private static final int ITEM_TYEP_KAIFU = 2;
    private static final int ITEM_TYPE_SUM = 2;
    
    /**
     * 锟斤拷锟截诧拷锟斤拷
     */
    private void initView(){
        mListView = (ListView) findViewById(R.id.list_view_main_kaifu);
         mAdapter = new KaifuAdapter();
         mListView.setAdapter(mAdapter);
    }
    /**
     * 实用工具类完成异步任务下载指定页面的网络资源,得到的结果在接口回调中
     */
    private void getNetResource(){
        AsyncTaskTool.getDownloadNetResourceTask(URLPATH).execute(this);
    }
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        getNetResource();
    }
    
    /* (non-Javadoc)
     * @see InvokeInterface.INetResourceCallback#getNetResource(java.lang.String)
     * 接口回调，用于获取异步任务下载的得到的数据，通过JSON解析数据
     */
    @Override
    public void getNetResource(String netResource) {
        //JSON解析数据
        Log.i(">>>>", netResource);
        parseKaiFuJSONData(netResource);
    }
    //JSON解析数据
    private void parseKaiFuJSONData(String netResource){
        try {
            JSONObject jsonObject = new JSONObject(netResource);
            JSONArray jsonArray = jsonObject.getJSONArray("info");
            Giftbean kaifu = null;
            for(int i = 0 , len = jsonArray.length(); i < len ; i++){
                kaifu = new Giftbean();
                JSONObject object = jsonArray.getJSONObject(i);
                String gname = object.getString("gname");
                kaifu.setGname(gname == null ? "" : gname);
                kaifu.setGid(object.getString("gid"));
                String addtime = object.getString("addtime");
                kaifu.setAddtime(addtime == null ? "" : addtime);
                String linkurl = object.getString("linkurl");
                kaifu.setLinkurl(linkurl == null ? "" : linkurl);
                String iconurl = object.getString("iconurl");
                kaifu.setIconurl(iconurl == null ? "" : iconurl);
                String area = object.getString("area");
                kaifu.setArea(area == null ? "" : area);
                kaifu.setOperators(object.getString("operators"));
                //分类操作，如果mTypeListData中还没有该类型，就创建一个List
                if(!mTypeListData.containsKey(addtime)){
                    mListData = new ArrayList<Giftbean>();
                    mListData.add(kaifu);
                    mTypeListData.put(addtime, mListData);
                }else{
                    //如果已经包含了该时间的类型，则从Map中取出list,放入解析到的对象
                    mListData = mTypeListData.get(addtime);
                    mListData.add(kaifu);
                }
            }
            //最后遍历mTeypListData，全部的类型，所有解析到的对象按顺序放入到放到allDatas中
            for(Map.Entry<String,List<Giftbean>> entry : mTypeListData.entrySet()){
                allDatas.add(entry.getKey());
//                mAdapter.notifyDataSetChanged();
                List<Giftbean> typeList = entry.getValue();
                for(Giftbean bean : typeList){
                    allDatas.add(bean);
//                    mAdapter.notifyDataSetChanged();
                }
//                allDatas.addAll(entry.getValue());
            }
            mAdapter.notifyDataSetChanged();
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }
    
    class KaifuAdapter extends BaseAdapter{
        private LayoutInflater layoutInflater = LayoutInflater.from(MainActivity.this);
        @Override
        public int getCount() {
            return mListData == null ? 0 : allDatas.size();
        }
        @Override
        public Object getItem(int position) {
            return null;
        }

        @Override
        public long getItemId(int position) {
            return 0;
        }

        /* (non-Javadoc)
         * @see android.widget.BaseAdapter#getItemViewType(int)
         * 根据当前item的值类型，返回不同的item布局类型
         */
        @Override
        public int getItemViewType(int position) {
            Object object = allDatas.get(position);
            //如果当前的类型是String类型的，说明是日期
            if(!(object instanceof Giftbean)){
                return ITEM_TYPE_DATA;
            }else{
                //如果是开服数据对象，则返回2
                return ITEM_TYEP_KAIFU;
            }
        }
        @Override
        public int getViewTypeCount() {
            return ITEM_TYPE_SUM + 1;
        }
        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            View view = convertView;
            int type = getItemViewType(position);
            Giftbean kaiFuBean = new Giftbean();
            TypeViewHolder typeViewHolder = null;
            KaiFuViewHolder kaiFuViewHolder = null;
            if(null == view){
                switch (type) {
                case ITEM_TYPE_DATA:
                    view = layoutInflater.inflate(R.layout.time_group_item_list_kaifu, parent,false);
                    typeViewHolder = new TypeViewHolder(view);
                    view.setTag(typeViewHolder);
                    break;
                case ITEM_TYEP_KAIFU:
                    view = layoutInflater.inflate(R.layout.name_item_list_kaifu, parent,false);
                    kaiFuViewHolder = new KaiFuViewHolder(view);
                    view.setTag(kaiFuViewHolder);
                    break;
                default:
                    break;
                }
            }else{
                switch (type) {
                case ITEM_TYPE_DATA:
                    typeViewHolder = (TypeViewHolder) view.getTag();
                    break;
                case ITEM_TYEP_KAIFU:
                    kaiFuViewHolder = (KaiFuViewHolder) view.getTag();
                default:
                    break;
                }
            }
            switch (type) {
            case ITEM_TYPE_DATA:
                Object object = allDatas.get(position);
                if(object instanceof String){
                    typeViewHolder.typeTextView.setText((String)object);
                }
                break;
            case ITEM_TYEP_KAIFU:
                Object obj = allDatas.get(position);
                if(obj instanceof Giftbean){
                    kaiFuBean = ((Giftbean)obj);
                kaiFuViewHolder.gNameTextView.setText(kaiFuBean.getGname());
                String linkurl = kaiFuBean.getLinkurl();
                String area = kaiFuBean.getArea();
                kaiFuViewHolder.timeAndAreaTextView.setText(linkurl +"    "+ area);
                kaiFuViewHolder.operatorTextView.setText(kaiFuBean.getOperators());
                
                kaiFuViewHolder.checkBtn.setOnClickListener(new OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        
                    }
                });
                ImageDownloadTask task = new ImageDownloadTask(kaiFuViewHolder.imageView);
                task.execute("http://www.1688wan.com"+kaiFuBean.getIconurl());
//                Log.i(">>>>", "http://www.1688wan.com"+kaiFuBean.getIconurl());
                }
                break;
            default:
                break;
            }
            return view;
        }
        
        class ImageDownloadTask extends AsyncTask<String, Integer, Bitmap>{
            private ImageView mImageView;
            public ImageDownloadTask(ImageView mImageView){
                this.mImageView = mImageView; 
            }
            @Override
            protected Bitmap doInBackground(String... params) {
                InputStream inputStream = null;
//                ByteArrayOutputStream byteArrayOutputStream = null;
                try {
                    HttpURLConnection conn = (HttpURLConnection) (new URL(params[0])).openConnection();
//                    conn.setConnectTimeout(5000);
                    if(conn.getResponseCode() == HttpURLConnection.HTTP_OK){
                        inputStream = conn.getInputStream();
//                        byteArrayOutputStream = new ByteArrayOutputStream();
//                        int hasRead = 0;
//                        byte[] buffer = new byte[1024];
//                        while(-1 != inputStream.read(buffer)){
//                            byteArrayOutputStream.write(buffer, 0, hasRead);
//                        }
//                        byteArrayOutputStream.flush();
//                        byte[] imageByte = byteArrayOutputStream.toByteArray();
//                        return BitmapFactory.decodeByteArray(imageByte, 0, imageByte.length);
                        return BitmapFactory.decodeStream(inputStream);
                    }
                } catch (MalformedURLException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally{
                    streamClose(inputStream);
//                    streamClose(byteArrayOutputStream);
                }
                return null;
            }
            
            public  void streamClose(Closeable closeable){
                if(closeable != null){
                    try {
                        closeable.close();
                        } catch (Exception e) {
                    }
                }
            }
            @Override
            protected void onPostExecute(Bitmap result) {
                if(null != result){
                    mImageView.setImageBitmap(result);
                }
            }
            
        }
        
        class TypeViewHolder{
            TextView typeTextView;
            public TypeViewHolder(View view){
                typeTextView = (TextView) view.findViewById(R.id.time_group_item_txt);
            }
        }
        
        class KaiFuViewHolder{
            ImageView imageView;
            TextView gNameTextView;
            TextView timeAndAreaTextView;
            TextView operatorTextView;
            Button checkBtn;
            public KaiFuViewHolder(View view){
                imageView = (ImageView) view.findViewById(R.id.image_name_item_list);
                gNameTextView = (TextView) view.findViewById(R.id.title_name_item_list);
                timeAndAreaTextView = (TextView) view.findViewById(R.id.start_time_name_item_list);
                operatorTextView = (TextView) view.findViewById(R.id.operator_name_item_list);
                checkBtn = (Button) view.findViewById(R.id.btn_name_item_list_view_main);
            }
        }
    }
}