做了一个关于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
导入即可使用。
好了，主要思路和逻辑就说这么多吧，关于代码嘛。公司项目，还是不上传了。见谅哈，主要理解了这一种下载方式的实现逻辑就好。楼主也是为了记录，如果有不足之处希望大家提出，互相交流学习，我们共同进步。
网友评论