做了一个关于android游戏下载模块的功能。

界面的东西就不说了，这里着重记录一下下载的逻辑实现。

需求上是要实现最多五个游戏可以同时下载。

首先我就会想到启动一个service来专门管理下载这一块，然后通过activity启动service并传入要下载的应用的包名，版本，url等，这里可以做一个对应用信息做一个封装实体然后传入。因为我们知道当Service第一次启动的时候才会去走onCreate这个方法，而多次启动的时候就不会走onCreate方法，转而直接进入onStart，onStartCommand等等。

所以，我们可以在onCreate里面做一些初始化操作，或者是一些硬性的规定。就我这个模块来说，需求规定最多只有五个APK同时在下载，所以我会想到开启五个线程来进行相应的下载任务。同时会在Service里面注册广播、

下面的代码主要都是在Service里面：

初始化Service
···
@Override
public void onCreate() {
super.onCreate();
Log.i("syso", "oncreate");
registerBrocast();
//用于管理正在下载的应用
downLoadMap = new HashMap<Long, DownLoadApi>();
//封装应用信息
downLoadApi = new DownLoadApi();
// downLoadLists = new ArrayList<Map<String, DownLoadApi>>();
//用于管理正在下载的线程
mSubThreadList = new HashMap<Long, ApkListService.SubThread>();
}
···
接下来每次启动service都会经过一下这个方法：
···
public int onStartCommand(Intent intent, int flags, int startId) {

    Log.i(TAG+"syso", "onStartCommand");

    long appID = 0;
    String appVersion = null;
    if (intent != null) {
        appID = intent.getExtras().getLong("FromDetailAppID");
        appPkgUrl = intent.getExtras().getString("FromDetailPkgUrl");
        appVersion = intent.getExtras().getString("FromDetailVersion");
        appName = intent.getExtras().getString("FromDetailAppName");
        if (downLoadMap.containsKey(appID)) {
            downLoadMap.remove(appID);
        }
        if (downLoadMap.size() < 5) {
            Log.i(TAG+"syso", "appid:" + appID);
            downLoadApi.setRetryCount(3);
            // CommenUtil.setSharePrefrence(getApplicationContext(), appID
            // + "count", 2, "config");
            if (!downLoadMap.containsKey(appID)) {
                downLoadApi = new DownLoadApi(appID, appPkgUrl, appVersion,
                        0, appName);
                downLoadApi.setAppVersion(appVersion);
                Log.i(TAG, "包名-downLoadApi:"+downLoadApi.getName()+",version:"+downLoadApi.getAppVersion());
                downLoadMap.put(appID, downLoadApi);
                // new SubThread(context, downLoadApi, appID)
                // .setPriority(Thread.NORM_PRIORITY - 3);
                // new SubThread(context, downLoadApi, appID).start();
                mSubThread = new SubThread(context, downLoadApi, appID);
                mSubThread.setPriority(Thread.NORM_PRIORITY - 3);
                mSubThread.stopBorad = false;
                mSubThread.start();
                Log.i(TAG+"syso", "mSubThread:" + mSubThread+",appID"+appID);
                mSubThreadList.put(appID, mSubThread);
            } else {
                downLoadApi = downLoadMap.get(appID);
            }
        } else {
            Toast.makeText(ApkListService.this, "当前下载数量超过5个，请稍后下载...",
                    Toast.LENGTH_SHORT).show();
        }
    }
    _asyncInstall();
    Log.i(TAG, "findProgressComplete ApkList OnStartComment");
    return super.onStartCommand(intent, flags, startId);
}

···
针对上面的代码我大体说一下逻辑吧。FromDetailAppID这些都是从activity中传递过来的具体要下载的应用信息，接下来我会检查downLoadMap这个应用管理Map，根据APPID查找，如果里面包含即将要下载的应用，说明有是有一种情况的，那就是之前下载过这个APK但是由于某种原因，暂停也好，导致下载没有完成，但是他还残留在Map中，所以这时就会要remove掉里面残余的value，再重新添加。同时规定下载map的size要小于5，因为最多只有五个APK在同时下载。接下来就是启动下载线程进行下载了。
注意：mSubThreadList.put(appID, mSubThread);这个也是对下载的线程做了限制，也就是最多只有五个下载线程存在。

这里注意还有一个细节就是_asyncInstall();这个方法，这个里面实现了一个轮询的逻辑，也就是在这里面开启了一个线程，这是一个自定义的BaseThread，规定了多少毫秒执行一次，我这里设置大概是两秒执行一次。也就是说对于指定的正在下载的APK进行，每隔两秒的轮询，查询当前正在下载的APK是否下载完成？？如果下载完成了就会启动静默安装。因为根据android的特性，当系统成功安装一个应用的时候就会发出一条广播
···
if (action.equals(Intent.ACTION_PACKAGE_ADDED))
···
所以在Service我们就可以再注册一个广播接受者来进行相应的安装成功的处理，这样，整个从下载到安装成功再反馈的逻辑就出来了。
如果出现下载失败，那么就可以把原先下载一部分的文件删除再重新下载，如果静默安装失败，那么就会再次尝试安装。

注意在安装成功的时候一定要及时的更新downLoadMap，因为他表示的是正在下载的应用集合。

关于下载我也提供一种方案吧，我这里采用的是HttpClient来实现下载，代码可以当作工具类来使用:
···
public static int doDownloadFile(String down_url, String filePath,
String filename, long appId, DownloadListener downloadListener) {
long size = 0;
File fileforsize = new File(filePath + "/" + filename);
mFilePath = fileforsize.getAbsolutePath();
Log.i(TAG, "文件的路径：filePath" + filePath + ",文件名：filename：" + filename);
if (fileforsize.exists()) {
// 已经下载的size
Log.i(TAG, "文件存在，文件的大小：size：" + size);
size = fileforsize.length() - 1;
}
// 下载路径
String url = down_url;
// url = url.replace("gameapk.is.ysten.com", "223.82.250.5");
Log.i(TAG, "不存在对应文件名则下载地址为url = " + url);

    // 设置代理
    Header header = null;
    HttpResponse response = null;
    // 用来获取下载文件的大小
    HttpResponse response_test = null;
    try {
        HttpParams httpParameters = new BasicHttpParams();
        HttpConnectionParams.setStaleCheckingEnabled(httpParameters, false);
        HttpConnectionParams
                .setConnectionTimeout(httpParameters, 10 * 1000);// 设置请求超时10秒
        HttpConnectionParams.setSoTimeout(httpParameters, 10 * 1000); // 设置等待数据超时10秒
        HttpConnectionParams.setSocketBufferSize(httpParameters, 32 * 1024);

        HttpClient client = new DefaultHttpClient(httpParameters);
        HttpClient client_test = new DefaultHttpClient();
        HttpGet request = new HttpGet(url);
        HttpGet request_test = new HttpGet(url);
        if (header != null) {
            request.addHeader(header);
            Log.v(TAG, "header != null:-header:" + header.toString());
        }

        response_test = client_test.execute(request_test);
        Log.v(TAG, "response_test:" + response_test.toString());
        // 获取需要下载文件的大小
        long fileSize = response_test.getEntity().getContentLength();
        Log.i(TAG, "fileSize:" + fileSize);
        if (fileSize < 500) {
            Log.i(TAG, "fileSize < 500返回-1 ");
            return -1;
        }

        // 验证下载文件的完整性
        if (fileSize != 0 && fileSize == size) {
            // downloadListener.appDownloading(100, appId);
            Log.i(TAG, "fileSize == size: return 1");
            return 1;
        }

        // 设置下载的数据位置XX字节到XX字节
        Header header_size = new BasicHeader("Range", "bytes=" + size + "-"
                + fileSize);
        request.addHeader(header_size);

        response = client.execute(request);
        InputStream is = response.getEntity().getContent();
        if (is == null) {
            Log.i(TAG, "is == null: ----stream is null");
            throw new RuntimeException("stream is null");
        }

        // 获取文件对象，开始往文件里面写内容
        File myTempFile = new File(filePath + "/" + filename);
        RandomAccessFile fos = new RandomAccessFile(myTempFile, "rw");

        // 从文件的size以后的位置开始写入，其实也不用，直接往后写就可以。有时候多线程下载需要用
        fos.seek(size);
        byte buf[] = new byte[32 * 1024];
        long downloadfilesize = 0;
        Log.v(TAG, "isPause:" + isPause);
        do {
            Thread.sleep(10);
            // 这个方法是先规定一个数组长度，将这个流中的字节缓冲到数组b中，返回的这个数组中的字节个数，这个缓冲区没有满的话，则返回真实的字节个数，到未尾时都返回-1
            int numread = is.read(buf);
            if (numread <= 0) {
                break;
            }
            fos.write(buf, 0, numread);
            if (downloadListener != null) {
                downloadfilesize += numread;
                int percent = (int) ((downloadfilesize + size) * 100 / fileSize);
                downloadListener.appDownloading(percent, appId);
                Log.v(TAG, "percent:" + percent + "------appId:" + appId
                        + "---listener");
            }
        } while (!isPause);
        is.close();
    } catch (Exception ex) {
        Log.i(TAG, "-异常返回-1 ，ex:" + ex.getMessage());
        ex.printStackTrace();
        return -1;
    }
    return 1;
}

···
前面的从网络读取下载流并解析没啥好说的，主要说一下下载细节，RandomAccessFile fos = new RandomAccessFile(myTempFile, "rw");我是使用这个类来实现文件的读写，首先声明了byte buf[] = new byte[32 * 1024];数组，规定了每次写入目录文件的流的大小，int numread = is.read(buf);
这个方法是先规定一个数组长度，将这个流中的字节缓冲到数组b中，返回的这个数组中的字节个数，这个缓冲区没有满的话，则返回真实的字节个数，到未尾时都返回-1
可以看出我再最后其实对网络上读取的Inptstream做了一个do while死循环，其实并不然，在循环中做了一个线程休眠，差不多10MS，也就是每个10ms我就会从网络上读取的IS中取出上面规定的byte数组大小的流，相当于缓冲区吧，再通过fos.write(buf, 0, numread);写入相应的文件中，当读取到Inptstream的最后的时候， is.read(buf);就会返回-1，所以也就表示读取网络下载流读取完成，就会跳出当前的循环。下面的downloadListener我其实是为了实现了实时监听下载情况的这个逻辑，以便可以做些更新进度条的操作。所以当全部下载完成的时候此方法也就回返回1表示，下载完成，可以进行以后的逻辑处理。

关于静默安装我也提供一种方案吧，我这里采用的是PackageManager.installPackage来实现安装，不过这个方法由于是早期android的下载方式，貌似以后的版本都已经隐藏掉了，看见网上最常用的就是用PM命令来实现静默安装，不过两者都需要root权限，方案：
···
public void Install(String fileName, String packageName,
InstallCallBack callback, Context context)//
{
if (callback != null) {
CommenUtil.installBack = callback;
}
Uri uri = Uri.fromFile(new File(fileName));

    int installFlags = 0;
    PackageManager pm = context.getPackageManager();
    try {
        PackageInfo pi = pm.getPackageInfo(packageName,
                PackageManager.GET_UNINSTALLED_PACKAGES);//
        if (pi != null) {
            installFlags |= PackageManager.INSTALL_REPLACE_EXISTING;
        }
    } catch (NameNotFoundException e) {

    }
    PackageInstallObserver observer = new PackageInstallObserver();
    pm.installPackage(uri, observer, installFlags, packageName);
}

// 用于显示结果
class PackageInstallObserver extends IPackageInstallObserver.Stub {
    public void packageInstalled(String packageName, int returnCode) {
        Log.i("syso", "returnCode:" + returnCode);
        if (returnCode == 1) {
            Log.i("syso", "静默安装成功");
        } else {
            Log.i("syso", "静默安装失败");
            if (installBack != null) {
                installBack.SliceInstallFail();
            }
        }
    }
};

···
但是如果需要这种方法，可能需要用反射把，原先隐藏的类搞出来，在独立打出一个jar包才能使用吧。好在我已经做好了jar包直接下载导入即可使用
jar包地址:http://download.csdn.net/detail/zhuxiaoxuand/9485199

导入即可使用。

好了，主要思路和逻辑就说这么多吧，关于代码嘛。公司项目，还是不上传了。见谅哈，主要理解了这一种下载方式的实现逻辑就好。楼主也是为了记录，如果有不足之处希望大家提出，互相交流学习，我们共同进步。