【0090】【项目实战】-【谷歌电子市场】-【02】【ListView封装】【listview增加加载更多布局】【加载更多功能添加】【导入http工具包&相关工具类】【BaseProtocol创建&拼接网络链接】【读写缓存&解析数据】【HomeProtocol实现&Json解析】【加载首页数据】

 1. 回顾说明

【说明】Application一定需要在清单配置文件中配置一下，否则无法初始化变量GooglePlayApplication.java中的变量；

2.ListView第一层封装

【说明】首页中的布局是listView显示；

2.1 最简单的listView的书写

【new 一个listView】

【适配器数据】

【添加假数据】添加假数据，在集合中添加测试数据；

【listView的item的布局】

【ListView的convertView的复用】

【设置适配器】

 

【效果】

2.2 ListView的简单封装

【说明】

【封转的原因】在每次书写listView的时候总是需要写前面的三个方法，并且内容都基本一致；封装是为了简化代码的书写；

【第一层封装的思路】生成一个类，继承与BaseAdapter，该类实现了前面三个方法；

【类中的泛型的使用】【技巧】在类的定义的时候直接增加泛型；

【简单封装adpter】

【封装之后的使用】需要添加泛型的类型和实现构造方法；

 

【效果】跟之前的效果一模一样，大大简化了代码，只需要书写adapter中的getView方法即可；

 3.ListView第二层封装

【说明】主要是对getView方法的封装；

【说明】getView分解为主要做下面的四件事情；需要ViewHolder的配合；父类完成不了事情让子类完成；

3.1BaseHolder的封装

【说明】BaseHolder主要完成对应的getView中的一些功能；

【BaseHolder的使用】

【说明】因为BaseHolder不能直接new，需要子类实现未实现的方法initView（只有子类才知道自己本身需要初始化哪些布局和控件），因此在此再次书写一个抽象方法，让子类实现；

3.2 【getView使用BaseHolder】

 

【注销原来的getView方法】

【子类实现加载布局和刷新的方法】

【HomeFragment调用Holder】很简洁，代码量很少；

 

【bug】返回值有问题，应该返回Holder中的RootView布局；

 【效果】跟之前的效果一致；

【说明】listView在项目中使用个情况较多，则需要搭建此此框架，如果仅仅使用一个则不需要搭建框架；

【源码】/GooglePlay74/src/com/itheima/googleplay74/ui/holder/BaseHolder.java

package com.itheima.googleplay74.ui.holder;

import android.view.View;

public abstract class BaseHolder<T> {

    private View mRootView;// 一个item的根布局

    private T data;

    //当new这个对象时, 就会加载布局, 初始化控件,设置tag
    public BaseHolder() {
        mRootView = initView();
        // 3. 打一个标记tag
        mRootView.setTag(this);
    }

    // 1. 加载布局文件
    // 2. 初始化控件 findViewById
    public abstract View initView();

    // 返回item的布局对象
    public View getRootView() {
        return mRootView;
    }

    // 设置当前item的数据
    public void setData(T data) {
        this.data = data;
        refreshView(data);
    }

    // 获取当前item的数据
    public T getData() {
        return data;
    }

    // 4. 根据数据来刷新界面
    public abstract void refreshView(T data);

}

  【源码】/GooglePlay74/src/com/itheima/googleplay74/ui/holder/HomeHolder.java

package com.itheima.googleplay74.ui.holder;

import android.view.View;
import android.widget.TextView;

import com.itheima.googleplay74.R;
import com.itheima.googleplay74.domain.AppInfo;
import com.itheima.googleplay74.utils.UIUtils;
/**
 * 首页holder
 * @author Kevin
 * @date 2015-10-28
 */
public class HomeHolder extends BaseHolder<AppInfo> {

    private TextView tvContent;

    @Override
    public View initView() {
        // 1. 加载布局
        View view = UIUtils.inflate(R.layout.list_item_home);
        // 2. 初始化控件
        tvContent = (TextView) view.findViewById(R.id.tv_content);
        return view;
    }

    @Override
    public void refreshView(AppInfo data) {
        tvContent.setText(data.name);
    }

}

4.listview增加加载更多布局

4.1 效果及思路

【效果】如下，将下拉加载更多封装到listView中；

【说明】之前使用的增加一个脚布局，现在使用的另外一种思路实现，使用listView加载多种布局（安全卫士当中使用过）；

 

4.2 源码实现

【说明】需要重写这两个方法

【增加了一个布局，因此数量增加1】

【定义两种类型】

【局限性】有的页面的布局类型超过了两种，但是下面的写法只支持两种，因此具有局限性；

[此页面具有三种类型]使用的是listView开发的；

[改进]多一个方法，默认值写为TYPE_NORMAL，但是子类可以复写该方法，增加类型，变得灵活了；

【增加加载更多布局】

 【加载更多的布局】

【加载布局】

【效果】

5.加载更多布局根据状态刷新页面

5.1 存在的三种状态

【存在的三种状态】

5.2 没有更多数据

【说明】在某些页面是天生没有更多数据的，比如分类，在构造法中直接表明该页面是否具有更多数据

【灵活变通】子类重写方法修改是否可以具有加载更多的属性；

【根据data值refreshView框架】

【将多种布局放在一个xml中】根据情况进行显示或者隐藏；

[源码]/GooglePlay74/res/layout/list_item_more.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:gravity="center"
    android:orientation="vertical" >

    <LinearLayout
        android:id="@+id/ll_load_more"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:orientation="horizontal" >

        <ProgressBar
            android:id="@+id/progressBar1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:indeterminateDrawable="@drawable/custom_progress" />

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginLeft="5dp"
            android:text="加载中..."
            android:textColor="#000"
            android:textSize="20sp" />
    </LinearLayout>

    <TextView
        android:id="@+id/tv_load_error"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:paddingTop="10dp"
        android:paddingBottom="10dp"
        android:layout_marginLeft="5dp"
        android:text="加载失败,点击重试"
        android:textColor="#000"
        android:textSize="20sp" />

</LinearLayout>

【根据data值refreshView更改显示隐藏布局】

 

【效果】隐藏布局

[隐藏布局的调用关系]页面子类重写hasMore()方法，返回值为false；将返回值false传递给父类，然后设置data，然后刷新页面；

6.加载更多数据逻辑

6.1 加载更多数据的逻辑

【框架】请求加载更多的数据框架，需要开辟子线程，请求数据；

【对数据的判断】

[没有更多数据了]

 [有更多数据]

[标记的添加]

【将数据追加到当前的listView后面，然后刷新页面】

6.2 加载更多数据的方法的调用时机

【说明】调用加载更多数据的逻辑可以有两种，一种是了listView进行监听，但是比较繁琐，每一个listView可能都需要设置listener事件；

 另外一种就是根据搭建的框架，直接在适配器的父类中进行设置，如下面的，根据数据来刷新页面，选择这种方式；

6.3 子类实现加载更多数据的方法

【说明】此方法运行在子线程中，因为被调用是子线程中；

【加载成功效果】测试加载成功的状态

【加载失败的效果】

 【没有更多数据的效果】

6.4 注意

【说明】没有整明白为什么需要从0开始；

7.导入http工具包&相关工具类

7.1 【LogUtils工具类的作用】

打印分等级的日志信息，可以在上线之前进行关闭，避免性能的浪费和敏感信息的被捕获；

/GooglePlay74/src/com/itheima/googleplay74/utils//GooglePlay74/src/com/itheima/googleplay74/utils/LogUtils.java

【源码】

package com.itheima.googleplay74.utils;
import android.util.Log;


public class LogUtils {
    /** 日志输出级别NONE */
    public static final int LEVEL_NONE = 0;
    /** 日志输出级别E */
    public static final int LEVEL_ERROR =1;
    /** 日志输出级别W */
    public static final int LEVEL_WARN = 2;
    /** 日志输出级别I */
    public static final int LEVEL_INFO = 3;
    /** 日志输出级别D */
    public static final int LEVEL_DEBUG = 4;
    /** 日志输出级别V */
    public static final int LEVEL_VERBOSE = 5;

    /** 日志输出时的TAG */
    private static String mTag = "LogUtils";
    /** 是否允许输出log */
    private static int mDebuggable = LEVEL_VERBOSE;  //在上线之前将此处改为：LEVEL_NONE,则可以屏蔽掉所有的打印信息；

    /** 以级别为 d 的形式输出LOG */
    public static void v(String msg) {
        if (mDebuggable >= LEVEL_VERBOSE) {
            Log.v(mTag, msg);
        }
    }

    /** 以级别为 d 的形式输出LOG */
    public static void d(String msg) {
        if (mDebuggable >= LEVEL_DEBUG) {
            Log.d(mTag, msg);
        }
    }

    /** 以级别为 i 的形式输出LOG */
    public static void i(String msg) {
        if (mDebuggable >= LEVEL_INFO) {
            Log.i(mTag, msg);
        }
    }

    /** 以级别为 w 的形式输出LOG */
    public static void w(String msg) {
        if (mDebuggable >= LEVEL_WARN) {
            Log.w(mTag, msg);
        }
    }

    /** 以级别为 w 的形式输出Throwable */
    public static void w(Throwable tr) {
        if (mDebuggable >= LEVEL_WARN) {
            Log.w(mTag, "", tr);
        }
    }

    /** 以级别为 w 的形式输出LOG信息和Throwable */
    public static void w(String msg, Throwable tr) {
        if (mDebuggable >= LEVEL_WARN && null != msg) {
            Log.w(mTag, msg, tr);
        }
    }

    /** 以级别为 e 的形式输出LOG */
    public static void e(String msg) {
        if (mDebuggable >= LEVEL_ERROR) {
            Log.e(mTag, msg);
        }
    }

    /** 以级别为 e 的形式输出Throwable */
    public static void e(Throwable tr) {
        if (mDebuggable >= LEVEL_ERROR) {
            Log.e(mTag, "", tr);
        }
    }

    /** 以级别为 e 的形式输出LOG信息和Throwable */
    public static void e(String msg, Throwable tr) {
        if (mDebuggable >= LEVEL_ERROR && null != msg) {
            Log.e(mTag, msg, tr);
        }
    }
}

 7.2 【/StringUtils.java类使用的作用】

/GooglePlay74/src/com/itheima/googleplay74/utils/StringUtils.java

【说明】类比于TextUtils.isempty，但是此处判断的更严谨：包括为值不为null，去除了空格之后的大小写和不论大小写的null。都会进入到判断；

package com.itheima.googleplay74.utils;


public class StringUtils {
    /** 判断字符串是否有值，如果为null或者是空字符串或者只有空格或者为"null"字符串，则返回true，否则则返回false */
    public static boolean isEmpty(String value) {
        if (value != null && !"".equalsIgnoreCase(value.trim())
                && !"null".equalsIgnoreCase(value.trim())) {
            return false;
        } else {
            return true;
        }
    }
}

 7.3 【IOUtils.java类的作用】

 /GooglePlay74/src/com/itheima/googleplay74/utils/IOUtils.java

【说明】Closeable指的是可以关闭的一些类，除了stream，还有其他的类型；

              包含了异常的捕获；

package com.itheima.googleplay74.utils;

import java.io.Closeable;
import java.io.IOException;

public class IOUtils {
    /** 关闭流 */
    public static boolean close(Closeable io) {
        if (io != null) {
            try {
                io.close();
            } catch (IOException e) {
                LogUtils.e(e);
            }
        }
        return true;
    }
}

 7.4 http工具包

【包含的文件】两个HttpHelper.java和HttpClientFactory.java；

【源码】/GooglePlay74/src/com/itheima/googleplay74/http/HttpHelper.java

package com.itheima.googleplay74.http;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.StatusLine;
import org.apache.http.client.HttpClient;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.impl.client.AbstractHttpClient;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.protocol.SyncBasicHttpContext;

import android.util.Log;

import com.itheima.googleplay74.utils.IOUtils;
import com.itheima.googleplay74.utils.LogUtils;
import com.itheima.googleplay74.utils.StringUtils;

public class HttpHelper {

    public static final String URL = "http://127.0.0.1:8090/";

    /** get请求，获取返回字符串内容 */
    public static HttpResult get(String url) {
        HttpGet httpGet = new HttpGet(url);
        return execute(url, httpGet);
    }

    /** post请求，获取返回字符串内容 */
    public static HttpResult post(String url, byte[] bytes) {
        HttpPost httpPost = new HttpPost(url);
        ByteArrayEntity byteArrayEntity = new ByteArrayEntity(bytes);
        httpPost.setEntity(byteArrayEntity);
        return execute(url, httpPost);
    }

    /** 下载 */
    public static HttpResult download(String url) {
        HttpGet httpGet = new HttpGet(url);
        return execute(url, httpGet);
    }

    /** 执行网络访问 */
    private static HttpResult execute(String url, HttpRequestBase requestBase) {
        boolean isHttps = url.startsWith("https://");//判断是否需要采用https
        AbstractHttpClient httpClient = HttpClientFactory.create(isHttps);
        HttpContext httpContext = new SyncBasicHttpContext(new BasicHttpContext());
        HttpRequestRetryHandler retryHandler = httpClient.getHttpRequestRetryHandler();//获取重试机制
        int retryCount = 0;
        boolean retry = true;
        while (retry) {
            try {
                HttpResponse response = httpClient.execute(requestBase, httpContext);//访问网络
                if (response != null) {
                    return new HttpResult(response, httpClient, requestBase);
                }
            } catch (Exception e) {
                IOException ioException = new IOException(e.getMessage());
                retry = retryHandler.retryRequest(ioException, ++retryCount, httpContext);//把错误异常交给重试机制，以判断是否需要采取从事
                LogUtils.e(e);
            }
        }
        return null;
    }

    /** http的返回结果的封装，可以直接从中获取返回的字符串或者流 */
    public static class HttpResult {
        private HttpResponse mResponse;
        private InputStream mIn;
        private String mStr;
        private HttpClient mHttpClient;
        private HttpRequestBase mRequestBase;

        public HttpResult(HttpResponse response, HttpClient httpClient, HttpRequestBase requestBase) {
            mResponse = response;
            mHttpClient = httpClient;
            mRequestBase = requestBase;
        }

        public int getCode() {
            StatusLine status = mResponse.getStatusLine();
            return status.getStatusCode();
        }

        /** 从结果中获取字符串，一旦获取，会自动关流，并且把字符串保存，方便下次获取 */
        public String getString() {
            if (!StringUtils.isEmpty(mStr)) {
                return mStr;
            }
            InputStream inputStream = getInputStream();
            ByteArrayOutputStream out = null;
            if (inputStream != null) {
                try {
                    out = new ByteArrayOutputStream();
                    byte[] buffer = new byte[1024 * 4];
                    int len = -1;
                    while ((len = inputStream.read(buffer)) != -1) {
                        out.write(buffer, 0, len);
                    }
                    byte[] data = out.toByteArray();
                    mStr = new String(data, "utf-8");
                } catch (Exception e) {
                    LogUtils.e(e);
                } finally {
                    IOUtils.close(out);
                    close();
                }
            }
            return mStr;
        }

        /** 获取流，需要使用完毕后调用close方法关闭网络连接 */
        public InputStream getInputStream() {
            if (mIn == null && getCode() < 300) {
                HttpEntity entity = mResponse.getEntity();
                try {
                    mIn = entity.getContent();
                } catch (Exception e) {
                    LogUtils.e(e);
                }
            }
            return mIn;
        }

        /** 关闭网络连接 */
        public void close() {
            if (mRequestBase != null) {
                mRequestBase.abort();
            }
            IOUtils.close(mIn);
            if (mHttpClient != null) {
                mHttpClient.getConnectionManager().closeExpiredConnections();
            }
        }
    }
}

 【源码】/GooglePlay74/src/com/itheima/googleplay74/http/HttpClientFactory.java

package com.itheima.googleplay74.http;

import org.apache.http.HttpVersion;
import org.apache.http.client.params.HttpClientParams;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.conn.params.ConnPerRouteBean;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;

public class HttpClientFactory {
    /** http请求最大并发连接数 */
    private static final int MAX_CONNECTIONS = 10;
    /** 超时时间 */
    private static final int TIMEOUT = 10 * 1000;
    /** 缓存大小 */
    private static final int SOCKET_BUFFER_SIZE = 8 * 1024; // 8KB

    public static DefaultHttpClient create(boolean isHttps) {
        HttpParams params = createHttpParams();
        DefaultHttpClient httpClient = null;
        if (isHttps) {
            // 支持http与https
            SchemeRegistry schemeRegistry = new SchemeRegistry();
            schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
            schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
            // ThreadSafeClientConnManager线程安全管理类
            ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);
            httpClient = new DefaultHttpClient(cm, params);
        } else {
            httpClient = new DefaultHttpClient(params);
        }
        return httpClient;
    }

    private static HttpParams createHttpParams() {
        final HttpParams params = new BasicHttpParams();
        // 设置是否启用旧连接检查，默认是开启的。关闭这个旧连接检查可以提高一点点性能，但是增加了I/O错误的风险（当服务端关闭连接时）。
        // 开启这个选项则在每次使用老的连接之前都会检查连接是否可用，这个耗时大概在15-30ms之间
        HttpConnectionParams.setStaleCheckingEnabled(params, false);
        HttpConnectionParams.setConnectionTimeout(params, TIMEOUT);// 设置链接超时时间
        HttpConnectionParams.setSoTimeout(params, TIMEOUT);// 设置socket超时时间
        HttpConnectionParams.setSocketBufferSize(params, SOCKET_BUFFER_SIZE);// 设置缓存大小
        HttpConnectionParams.setTcpNoDelay(params, true);// 是否不使用延迟发送(true为不延迟)
        HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); // 设置协议版本
        HttpProtocolParams.setUseExpectContinue(params, true);// 设置异常处理机制
        HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);// 设置编码
        HttpClientParams.setRedirecting(params, false);// 设置是否采用重定向

        ConnManagerParams.setTimeout(params, TIMEOUT);// 设置超时
        ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(MAX_CONNECTIONS));// 多线程最大连接数
        ConnManagerParams.setMaxTotalConnections(params, 10); // 多线程总连接数
        return params;
    }

}

8.BaseProtocol创建&拼接网络链接

【网络封装】主要完成三件事：请求网络获取数据、缓存机制（写缓存和读缓存）、解析数据；

 

【网络访问地址的拼接】

【实际网址的拼接】实际的网址的拼接比较复杂；其中存在index分页返回的数据页面；

    // 从网络获取数据
    // index表示的是从哪个位置开始返回20条数据, 用于分页
    private String getDataFromServer(int index) {
        // http://www.itheima.com/home?index=0&name=zhangsan&age=18
        HttpResult httpResult = HttpHelper.get(HttpHelper.URL + getKey()
                + "?index=" + index + getParams());

        if (httpResult != null) {
            String result = httpResult.getString();
            System.out.println("访问结果:" + result);
            // 写缓存
            if (!StringUtils.isEmpty(result)) {
                setCache(index, result);
            }

            return result;
        }

        return null;
    }

9.读写缓存&解析数据

9.1【写缓存】

【增加缓存的有效期】缓存中的数据需要定期刷新；打上时间戳就好；

【写缓存的调用】将取到的数据放入到缓存中；

9.2 读缓存数据

    // 读缓存
    public String getCache(int index) {
        // 以url为文件名, 以json为文件内容,保存在本地
        File cacheDir = UIUtils.getContext().getCacheDir();// 本应用的缓存文件夹
        // 生成缓存文件
        File cacheFile = new File(cacheDir, getKey() + "?index=" + index
                + getParams());

        // 判断缓存是否存在
        if (cacheFile.exists()) {
            // 判断缓存是否有效
            BufferedReader reader = null;
            try {
                reader = new BufferedReader(new FileReader(cacheFile));
                String deadline = reader.readLine();// 读取第一行的有效期
                long deadtime = Long.parseLong(deadline);

                if (System.currentTimeMillis() < deadtime) {// 当前时间小于截止时间,
                                                            // 说明缓存有效
                    // 缓存有效
                    StringBuffer sb = new StringBuffer();
                    String line;
                    while ((line = reader.readLine()) != null) {  //此处已经去掉了原来的时间的数据；
                        sb.append(line);
                    }

                    return sb.toString();
                }

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                IOUtils.close(reader);
            }

        }

        return null;
    }

 9.3 缓存数据的使用

    // index表示的是从哪个位置开始返回20条数据, 用于分页
    public T getData(int index) {
        // 先判断是否有缓存, 有的话就加载缓存
        String result = getCache(index);

        if (StringUtils.isEmpty(result)) {// 如果没有缓存,或者缓存失效
            // 请求服务器
            result = getDataFromServer(index);
        }

        // 开始解析
        if (result != null) {
            T data = parseData(result);
            return data;
        }

        return null;
    }

 9.4 解析数据的接口

【说明】因为子类的对数据的解析各不同，因此需要放到子类中去实现该方法；

10.HomeProtocol实现&Json解析

10.1.HomeProtocol 子类的建立

【新建子类，继承与父类BaseProtocol】

【泛型的确定】

10.2.json的解析

【json解析可以使用两种方法】一种是使用Gson（比较严格，遇到中括号就是数组，遇到大括号就是对象），另外一种是使用jsonObject（比较随意）；

【参考json网址】http://www.json.org/json-zh.html

 

【泛型的替代使用的是ArrayList<AppInfo>泛型】此处的构造方法的泛型是个集合；

【源码】/GooglePlay74/src/com/itheima/googleplay74/http/protocol/HomeProtocol.java

【解析起来比较繁琐】

package com.itheima.googleplay74.http.protocol;

import java.util.ArrayList;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import com.itheima.googleplay74.domain.AppInfo;

/**
 * 首页网络数据解析
 * 
 * @author Kevin
 * @date 2015-10-28
 */
public class HomeProtocol extends BaseProtocol<ArrayList<AppInfo>> {

    @Override
    public String getKey() {
        return "home";
    }

    @Override
    public String getParams() {
        return "";// 如果没有参数,就传空串,不要传null
    }

    @Override
    public ArrayList<AppInfo> parseData(String result) {
        // Gson, JsonObject
        // 使用JsonObject解析方式: 如果遇到{},就是JsonObject;如果遇到[], 就是JsonArray
        try {
            JSONObject jo = new JSONObject(result);

            // 解析应用列表数据
            JSONArray ja = jo.getJSONArray("list");
            ArrayList<AppInfo> appInfoList = new ArrayList<AppInfo>();
            for (int i = 0; i < ja.length(); i++) {
                JSONObject jo1 = ja.getJSONObject(i);

                AppInfo info = new AppInfo();
                info.des = jo1.getString("des");
                info.downloadUrl = jo1.getString("downloadUrl");
                info.iconUrl = jo1.getString("iconUrl");
                info.id = jo1.getString("id");
                info.name = jo1.getString("name");
                info.packageName = jo1.getString("packageName");
                info.size = jo1.getLong("size");
                info.stars = (float) jo1.getDouble("stars");

                appInfoList.add(info);
            }

            // 初始化轮播条的数据
            JSONArray ja1 = jo.getJSONArray("picture");
            ArrayList<String> pictures = new ArrayList<String>();
            for (int i = 0; i < ja1.length(); i++) {
                String pic = ja1.getString(i);
                pictures.add(pic);
            }

            return appInfoList;

        } catch (JSONException e) {
            e.printStackTrace();
        }

        return null;
    }

}

11.加载首页数据

11.1 泛型和首页数据的加载

【泛型替换】

【加载数据】

11.2 加载的校验

【说明】网络请求回来的数据有可能是空值或者是异常的值；

【说明】对于每一个网络数据加载的页面都可以进行数据的校验，因此将校验放在父类当中；

【增加网络权限】

【效果】首页加载了第一页的数据，缺点是没有加载第二页的数据；

【加载第二页的数据】获取页面的数据的大小的时候需要将index放入，index的大小正好是加载到当前集合中数据的多少；

【将获取的数据返回】

【效果】

 【查看缓存是否起到了作用】