[Android实例] Android之断点续传下载

在我们做开发的时候经常遇到的就是下载了，现在下载的方法有很多很多，那么怎么做到断点续传下载呢！很多人都头疼这个问题，如果我们没有很好的逻辑真不是很容易解决啊。我参考了一下前辈们的资料了整理了一个项目，能实现多个文件的同时下载。
断点续传下载，顾名思义，那就是我们在一次下载未结束时，退出下载，第二次下载时会接着第一次下载的进度继续下载。那么怎么记录第一次下载的数据呢，这里肯定就要用到数据库了。下面就是我创建数据库的一个SQLiteOpenHelper类。用来首次运行时创建数据库。
DBHelper.java

1. package com.icss.DBHelper;
3. import android.content.Context;
4. import android.database.sqlite.SQLiteDatabase;
5. import android.database.sqlite.SQLiteOpenHelper;
7. /**
8. * 建立一个数据库帮助类
9. */
10. public class DBHelper extends SQLiteOpenHelper {
11.         // download.db-->数据库名
12.         public DBHelper(Context context) {
13.                 super(context, "download.db", null, 1);
14.         }
16.         /**
17.          * 在download.db数据库下创建一个download_info表存储下载信息
18.          */
19.         @Override
20.         public void onCreate(SQLiteDatabase db) {
21.                 db.execSQL("create table download_info(_id integer PRIMARY KEY AUTOINCREMENT, thread_id integer, "
22.                                 + "start_pos integer, end_pos integer, compelete_size integer,url char)");
23.         }
25.         @Override
26.         public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
28.         }
30. }

复制代码

下面看主界面的布局,在这里，我只设计了一个ListView来显示下载的音乐的名称，和一个开始下载按钮和一个暂停按钮。
布局文件如下：
main.xml：

1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3.         android:orientation="vertical" android:layout_width="fill_parent"
4.         android:layout_height="fill_parent" android:weightSum="1">
5.         <ListView android:id="@android:id/list" android:layout_height="wrap_content"
6.                 android:layout_width="match_parent" android:layout_weight="0.70"></ListView>
7. </LinearLayout>

复制代码

list_item.xml：

1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
2.         android:layout_height="fill_parent" android:id="@+id/linearLayout1"
3.         android:layout_width="fill_parent" android:orientation="vertical">
4.         <LinearLayout android:layout_width="fill_parent"
5.                 android:id="@+id/linearLayout2" android:layout_height="wrap_content"
6.                 android:orientation="horizontal" android:layout_marginBottom="5dip">
7.                 <TextView android:layout_width="fill_parent"
8.                         android:layout_height="wrap_content" android:layout_weight="1"
9.                         android:id="@+id/tv_resouce_name" />
10.                 <Button android:layout_width="fill_parent"
11.                         android:layout_height="wrap_content" android:layout_weight="1"
12.                         android:text="下载" android:id="@+id/btn_start" android:onClick="startDownload" />
13.                 <Button android:layout_width="fill_parent"
14.                         android:layout_height="wrap_content" android:layout_weight="1"
15.                         android:text="暂停" android:id="@+id/btn_pause" android:onClick="pauseDownload" />
16.         </LinearLayout>
17. </LinearLayout>

复制代码

我们要定义一个记录在下载时各个时期的数据的类，这里我创建了一个DownloadInfo类来记录。代码如下：
DownloadInfo：

1. package com.icss.entity;
3. public class DownloadInfo {
5.         private int threadId;// 下载器id
6.         private int startPos;// 开始点
7.         private int endPos;// 结束点
8.         private int compeleteSize;// 完成度
9.         private String url;// 下载器网络标识
10.         
11.         
12.         
13.         public DownloadInfo(int threadId, int startPos, int endPos,
14.                         int compeleteSize, String url) {
15.                 super();
16.                 this.threadId = threadId;
17.                 this.startPos = startPos;
18.                 this.endPos = endPos;
19.                 this.compeleteSize = compeleteSize;
20.                 this.url = url;
21.         }
22.         public int getThreadId() {
23.                 return threadId;
24.         }
25.         public void setThreadId(int threadId) {
26.                 this.threadId = threadId;
27.         }
28.         public int getStartPos() {
29.                 return startPos;
30.         }
31.         public void setStartPos(int startPos) {
32.                 this.startPos = startPos;
33.         }
34.         public int getEndPos() {
35.                 return endPos;
36.         }
37.         public void setEndPos(int endPos) {
38.                 this.endPos = endPos;
39.         }
40.         public int getCompeleteSize() {
41.                 return compeleteSize;
42.         }
43.         public void setCompeleteSize(int compeleteSize) {
44.                 this.compeleteSize = compeleteSize;
45.         }
46.         public String getUrl() {
47.                 return url;
48.         }
49.         public void setUrl(String url) {
50.                 this.url = url;
51.         }
52.         
53.         @Override
54.              public String toString() {
55.                  return "DownloadInfo [threadId=" + threadId
56.                          + ", startPos=" + startPos + ", endPos=" + endPos
57.                          + ", compeleteSize=" + compeleteSize +"]";
58.      }
61. }

复制代码

在下载时，我们有进度条来显示进度，怎么确定进度条的进度，大小和起始位置呢？这里我定义了一个LoadInfo类来记录下载器详细信息。代码如下：
LoadInfo：

1. package com.icss.entity;
3. public class LoadInfo {
5.         public int fileSize;// 文件大小
6.         private int complete;// 完成度
7.         private String urlstring;// 下载器标识
8.         public LoadInfo() {
9.                 super();
10.                 // TODO Auto-generated constructor stub
11.         }
12.         public LoadInfo(int fileSize, int complete, String urlstring) {
13.                 super();
14.                 this.fileSize = fileSize;
15.                 this.complete = complete;
16.                 this.urlstring = urlstring;
17.         }
18.         public int getFileSize() {
19.                 return fileSize;
20.         }
21.         public void setFileSize(int fileSize) {
22.                 this.fileSize = fileSize;
23.         }
24.         public int getComplete() {
25.                 return complete;
26.         }
27.         public void setComplete(int complete) {
28.                 this.complete = complete;
29.         }
30.         public String getUrlstring() {
31.                 return urlstring;
32.         }
33.         public void setUrlstring(String urlstring) {
34.                 this.urlstring = urlstring;
35.         }
36.         @Override
37.             public String toString() {
38.          return "LoadInfo [fileSize=" + fileSize + ", complete=" + complete
39.                          + ", urlstring=" + urlstring + "]";
40.      }
43. }

复制代码

下面是最最重要的一步，那就是定义一个下载器来进行下载了，这里我就不多说，具体解释在代码中都有注解，供大家研究参考。
Downloader:

1. package com.icss.service;
3. import java.io.File;
4. import java.io.InputStream;
5. import java.io.RandomAccessFile;
6. import java.net.HttpURLConnection;
7. import java.net.URL;
8. import java.util.ArrayList;
9. import java.util.List;
11. import com.icss.dao.Dao;
12. import com.icss.entity.DownloadInfo;
13. import com.icss.entity.LoadInfo;
15. import android.content.Context;
16. import android.os.Handler;
17. import android.os.Message;
18. import android.util.Log;
20. public class Downloader {
21.         private String urlstr;// 下载的地址
22.         private String localfile;// 保存路径
23.         private int threadcount;// 线程数
24.         private Handler mHandler;// 消息处理器
25.         private Dao dao;// 工具类
26.         private int fileSize;// 所要下载的文件的大小
27.         private List<DownloadInfo> infos;// 存放下载信息类的集合
28.         private static final int INIT = 1;// 定义三种下载的状态：初始化状态，正在下载状态，暂停状态
29.         private static final int DOWNLOADING = 2;
30.         private static final int PAUSE = 3;
31.         private int state = INIT;
33.         public Downloader(String urlstr, String localfile, int threadcount,
34.                         Context context, Handler mHandler) {
35.                 this.urlstr = urlstr;
36.                 this.localfile = localfile;
37.                 this.threadcount = threadcount;
38.                 this.mHandler = mHandler;
39.                 dao = new Dao(context);
40.         }
42.         /**
43.          * 判断是否正在下载
44.          */
45.         public boolean isdownloading() {
46.                 return state == DOWNLOADING;
47.         }
49.         /**
50.          * 得到downloader里的信息 首先进行判断是否是第一次下载，如果是第一次就要进行初始化，并将下载器的信息保存到数据库中
51.          * 如果不是第一次下载，那就要从数据库中读出之前下载的信息（起始位置，结束为止，文件大小等），并将下载信息返回给下载器
52.          */
53.         public LoadInfo getDownloaderInfors() {
54.                 if (isFirst(urlstr)) {
55.                         init();
56.                         int range = fileSize / threadcount;
57.                         infos = new ArrayList<DownloadInfo>();
58.                         for (int i = 0; i < threadcount - 1; i++) {
59.                                 DownloadInfo info = new DownloadInfo(i, i * range, (i + 1)
60.                                                 * range - 1, 0, urlstr);
61.                                 infos.add(info);
62.                         }
63.                         DownloadInfo info = new DownloadInfo(threadcount - 1,
64.                                         (threadcount - 1) * range, fileSize - 1, 0, urlstr);
65.                         infos.add(info);
66.                         // 保存infos中的数据到数据库
67.                         dao.saveInfos(infos);
68.                         // 创建一个LoadInfo对象记载下载器的具体信息
69.                         LoadInfo loadInfo = new LoadInfo(fileSize, 0, urlstr);
70.                         return loadInfo;
71.                 } else {
72.                         // 得到数据库中已有的urlstr的下载器的具体信息
73.                         infos = dao.getInfos(urlstr);
74.                         Log.v("TAG", "not isFirst size=" + infos.size());
75.                         int size = 0;
76.                         int compeleteSize = 0;
77.                         for (DownloadInfo info : infos) {
78.                                 compeleteSize += info.getCompeleteSize();
79.                                 size += info.getEndPos() - info.getStartPos() + 1;
80.                         }
81.                         return new LoadInfo(size, compeleteSize, urlstr);
82.                 }
83.         }
85.         /**
86.       */
87.         private void init() {
88.                 try {
89.                         URL url = new URL(urlstr);
90.                         HttpURLConnection connection = (HttpURLConnection) url
91.                                         .openConnection();
92.                         connection.setConnectTimeout(5000);
93.                         connection.setRequestMethod("GET");
94.                         fileSize = connection.getContentLength();
95.                         File file = new File(localfile);
96.                         if (!file.exists()) {
97.                                 file.createNewFile();
98.                         }
99.                         // 本地访问文件
100.                         RandomAccessFile accessFile = new RandomAccessFile(file, "rwd");
101.                         accessFile.setLength(fileSize);
102.                         accessFile.close();
103.                         connection.disconnect();
104.                 } catch (Exception e) {
105.                         e.printStackTrace();
106.                 }
107.         }
109.         /**
110.          * 判断是否是第一次 下载
111.          */
112.         private boolean isFirst(String urlstr) {
113.                 return dao.isHasInfors(urlstr);
114.         }
116.         /**
117.          * 114 * 利用线程开始下载数据 115
118.          */
119.         public void download() {
120.                 if (infos != null) {
121.                         if (state == DOWNLOADING)
122.                                 return;
123.                         state = DOWNLOADING;
124.                         for (DownloadInfo info : infos) {
125.                                 new MyThread(info.getThreadId(), info.getStartPos(),
126.                                                 info.getEndPos(), info.getCompeleteSize(),
127.                                                 info.getUrl()).start();
128.                         }
129.                 }
130.         }
132.         public class MyThread extends Thread {
133.                 private int threadId;
134.                 private int startPos;
135.                 private int endPos;
136.                 private int compeleteSize;
137.                 private String urlstr;
139.                 public MyThread(int threadId, int startPos, int endPos,
140.                                 int compeleteSize, String urlstr) {
141.                         this.threadId = threadId;
142.                         this.startPos = startPos;
143.                         this.endPos = endPos;
144.                         this.compeleteSize = compeleteSize;
145.                         this.urlstr = urlstr;
146.                 }
148.                 @Override
149.                 public void run() {
150.                         HttpURLConnection connection = null;
151.                         RandomAccessFile randomAccessFile = null;
152.                         InputStream is = null;
153.                         try {
154.                                 URL url = new URL(urlstr);
155.                                 connection = (HttpURLConnection) url.openConnection();
156.                                 connection.setConnectTimeout(5000);
157.                                 connection.setRequestMethod("GET");
158.                                 // 设置范围，格式为Range：bytes x-y;
159.                                 connection.setRequestProperty("Range", "bytes="
160.                                                 + (startPos + compeleteSize) + "-" + endPos);
162.                                 randomAccessFile = new RandomAccessFile(localfile, "rwd");
163.                                 randomAccessFile.seek(startPos + compeleteSize);
164.                                 // 将要下载的文件写到保存在保存路径下的文件中
165.                                 is = connection.getInputStream();
166.                                 byte[] buffer = new byte[4096];
167.                                 int length = -1;
168.                                 while ((length = is.read(buffer)) != -1) {
169.                                         randomAccessFile.write(buffer, 0, length);
170.                                         compeleteSize += length;
171.                                         // 更新数据库中的下载信息
172.                                         dao.updataInfos(threadId, compeleteSize, urlstr);
173.                                         // 用消息将下载信息传给进度条，对进度条进行更新
174.                                         Message message = Message.obtain();
175.                                         message.what = 1;
176.                                         message.obj = urlstr;
177.                                         message.arg1 = length;
178.                                         mHandler.sendMessage(message);
179.                                         if (state == PAUSE) {
180.                                                 return;
181.                                         }
182.                                 }
183.                         } catch (Exception e) {
184.                                 e.printStackTrace();
185.                         } finally {
186.                                 try {
187.                                         is.close();
188.                                         randomAccessFile.close();
189.                                         connection.disconnect();
190.                                         dao.closeDb();
191.                                 } catch (Exception e) {
192.                                         e.printStackTrace();
193.                                 }
194.                         }
196.                 }
197.         }
199.         // 删除数据库中urlstr对应的下载器信息
200.         public void delete(String urlstr) {
201.                 dao.delete(urlstr);
202.         }
204.         // 设置暂停
205.         public void pause() {
206.                 state = PAUSE;
207.         }
209.         // 重置下载状态
210.         public void reset() {
211.                 state = INIT;
212.         }
213. }

复制代码

在这边下载器类的定义中，我们用到了许多关于进行数据库操作的方法，这里我定义了一个数据库工具类，来提供这些方法，代码如下：
Dao：

1. package com.icss.dao;
3. import java.util.ArrayList;
4. import java.util.List;
5. import javax.crypto.spec.DESKeySpec;
7. import com.icss.DBHelper.DBHelper;
8. import com.icss.entity.DownloadInfo;
10. import android.content.Context;
11. import android.database.Cursor;
12. import android.database.sqlite.SQLiteDatabase;
15. /**
16.   *
17.   * 一个业务类
18.   */
19. public class Dao {
20.      private DBHelper dbHelper;
22.      public Dao(Context context) {
23.          dbHelper = new DBHelper(context);
24.          
25.      }
27.      /**
28.       * 查看数据库中是否有数据
29.       */
30.      public boolean isHasInfors(String urlstr) {
31.          SQLiteDatabase database = dbHelper.getReadableDatabase();
32.         String sql = "select count(*)  from download_info where url=?";
33.          Cursor cursor = database.rawQuery(sql, new String[] { urlstr });
34.          cursor.moveToFirst();
35.          int count = cursor.getInt(0);
36.         cursor.close();
37.          return count == 0;
38.      }
40.      /**
41.       * 保存 下载的具体信息
42.       */
43.      public void saveInfos(List<DownloadInfo> infos) {
44.          SQLiteDatabase database = dbHelper.getWritableDatabase();
45.          for (DownloadInfo info : infos) {
46.              String sql = "insert into download_info(thread_id,start_pos, end_pos,compelete_size,url) values (?,?,?,?,?)";
47.            Object[] bindArgs = { info.getThreadId(), info.getStartPos(),
48.                      info.getEndPos(), info.getCompeleteSize(), info.getUrl() };
49.              database.execSQL(sql, bindArgs);
50.          }
51.      }
53.      /**
54.       * 得到下载具体信息
55.       */
56.      public List<DownloadInfo> getInfos(String urlstr) {
57.          List<DownloadInfo> list = new ArrayList<DownloadInfo>();
58.          SQLiteDatabase database = dbHelper.getReadableDatabase();
59.          String sql = "select thread_id, start_pos, end_pos,compelete_size,url from download_info where url=?";
60.          Cursor cursor = database.rawQuery(sql, new String[] { urlstr });
61.          while (cursor.moveToNext()) {
62.              DownloadInfo info = new DownloadInfo(cursor.getInt(0),
63.                      cursor.getInt(1), cursor.getInt(2), cursor.getInt(3),
64.                     cursor.getString(4));
65.              list.add(info);
66.          }
67.          cursor.close();
68.          return list;
69.      }
71.      /**
72.      * 更新数据库中的下载信息
73.       */
74.      public void updataInfos(int threadId, int compeleteSize, String urlstr) {
75.          SQLiteDatabase database = dbHelper.getReadableDatabase();
76.          String sql = "update download_info set compelete_size=? where thread_id=? and url=?";
77.          Object[] bindArgs = { compeleteSize, threadId, urlstr };
78.         database.execSQL(sql, bindArgs);
79.      }
80.      /**
81.       * 关闭数据库
82.       */
83.      public void closeDb() {
84.          dbHelper.close();
85.     }
87.      /**
88.      * 下载完成后删除数据库中的数据
89.       */
90.      public void delete(String url) {
91.         SQLiteDatabase database = dbHelper.getReadableDatabase();
92.          database.delete("download_info", "url=?", new String[] { url });
93.          database.close();
94.      }
95. }

复制代码

下面的是程序的主程序，其他的不说了，直接上代码：

1. package com.icss;
3. import java.util.ArrayList;
4. import java.util.HashMap;
5. import java.util.List;
6. import java.util.Map;
8. import android.app.ListActivity;
9. import android.os.Bundle;
10. import android.os.Handler;
11. import android.os.Message;
12. import android.view.View;
13. import android.widget.LinearLayout;
14. import android.widget.LinearLayout.LayoutParams;
15. import android.widget.ProgressBar;
16. import android.widget.SimpleAdapter;
17. import android.widget.TextView;
18. import android.widget.Toast;
20. import com.icss.entity.LoadInfo;
21. import com.icss.service.Downloader;
23. public class MainActivity extends ListActivity {
24.         // 固定下载的资源路径，这里可以设置网络上的地址
25.         private static final String URL = "http://10.0.0.80:8080/xiangce/";
26.         // 固定存放下载的音乐的路径：SD卡目录下
27.         private static final String SD_PATH = "/mnt/sdcard/";
28.         // 存放各个下载器
29.         private Map<String, Downloader> downloaders = new HashMap<String, Downloader>();
30.         // 存放与下载器对应的进度条
31.         private Map<String, ProgressBar> ProgressBars = new HashMap<String, ProgressBar>();
32.         /**
33.          * 31 * 利用消息处理机制适时更新进度条 32
34.          */
35.         private Handler mHandler = new Handler() {
36.                 public void handleMessage(Message msg) {
37.                         if (msg.what == 1) {
38.                                 String url = (String) msg.obj;
39.                                 int length = msg.arg1;
40.                                 ProgressBar bar = ProgressBars.get(url);
41.                                 if (bar != null) {
42.                                         // 设置进度条按读取的length长度更新
43.                                         bar.incrementProgressBy(length);
44.                                         if (bar.getProgress() == bar.getMax()) {
45.                                                 Toast.makeText(MainActivity.this, "下载完成！", 0).show();
46.                                                 // 下载完成后清除进度条并将map中的数据清空
47.                                                 LinearLayout layout = (LinearLayout) bar.getParent();
48.                                                 layout.removeView(bar);
49.                                                 ProgressBars.remove(url);
50.                                                 downloaders.get(url).delete(url);
51.                                                 downloaders.get(url).reset();
52.                                                 downloaders.remove(url);
54.                                         }
55.                                 }
56.                         }
57.                 }
58.         };
60.         @Override
61.         public void onCreate(Bundle savedInstanceState) {
62.                 super.onCreate(savedInstanceState);
63.                 setContentView(R.layout.main);
64.                 showListView();
65.         }
67.         // 显示listView，这里可以随便添加音乐
68.         private void showListView() {
69.                 List<Map<String, String>> data = new ArrayList<Map<String, String>>();
70.                 Map<String, String> map = new HashMap<String, String>();
71.                 map.put("name", "mm.mp3");
72.                 data.add(map);
73.                 map = new HashMap<String, String>();
74.                 map.put("name", "pp.mp3");
75.                 data.add(map);
76.                 map = new HashMap<String, String>();
77.                 map.put("name", "tt.mp3");
78.                 data.add(map);
79.                 map = new HashMap<String, String>();
80.                 map.put("name", "You.mp3");
81.                 data.add(map);
82.                 SimpleAdapter adapter = new SimpleAdapter(this, data,
83.                                 R.layout.list_item, new String[] { "name" },
84.                                 new int[] { R.id.tv_resouce_name });
85.                 setListAdapter(adapter);
86.         }
88.         /**
89.          * 83 * 响应开始下载按钮的点击事件 84
90.          */
91.         public void startDownload(View v) {
92.                 // 得到textView的内容
93.                 LinearLayout layout = (LinearLayout) v.getParent();
94.                 String musicName = ((TextView) layout
95.                                 .findViewById(R.id.tv_resouce_name)).getText().toString();
96.                 String urlstr = URL + musicName;
97.                 String localfile = SD_PATH + musicName;
98.                 // 设置下载线程数为4，这里是我为了方便随便固定的
99.                 int threadcount = 4;
100.                 // 初始化一个downloader下载器
101.                 Downloader downloader = downloaders.get(urlstr);
102.                 if (downloader == null) {
103.                         downloader = new Downloader(urlstr, localfile, threadcount, this,
104.                                         mHandler);
105.                         downloaders.put(urlstr, downloader);
106.                 }
107.                 if (downloader.isdownloading())
108.                         return;
109.                 // 得到下载信息类的个数组成集合
110.                 LoadInfo loadInfo = downloader.getDownloaderInfors();
111.                 // 显示进度条
112.                 showProgress(loadInfo, urlstr, v);
113.                 // 调用方法开始下载
114.                 downloader.download();
115.         }
117.         /**
118.          * 显示进度条
119.          */
120.         private void showProgress(LoadInfo loadInfo, String url, View v) {
121.                 ProgressBar bar = ProgressBars.get(url);
122.                 if (bar == null) {
123.                         bar = new ProgressBar(this, null,
124.                                         android.R.attr.progressBarStyleHorizontal);
125.                         bar.setMax(loadInfo.getFileSize());
126.                         bar.setProgress(loadInfo.getComplete());
127.                         System.out.println(loadInfo.getFileSize()+"--"+loadInfo.getComplete());
128.                         ProgressBars.put(url, bar);
129.                         LinearLayout.LayoutParams params = new LayoutParams(
130.                                         LayoutParams.FILL_PARENT, 5);
131.                         ((LinearLayout) ((LinearLayout) v.getParent()).getParent())
132.                                         .addView(bar, params);
133.                 }
134.         }
136.         /**
137.          * 响应暂停下载按钮的点击事件
138.          */
139.         public void pauseDownload(View v) {
140.                 LinearLayout layout = (LinearLayout) v.getParent();
141.                 String musicName = ((TextView) layout
142.                                 .findViewById(R.id.tv_resouce_name)).getText().toString();
143.                 String urlstr = URL + musicName;
144.                 downloaders.get(urlstr).pause();
145.         }
146. }

复制代码

最后我们需要在android Manifest.xml中添加这两个权限一个是访问internet的权限，另一个是写外存的权限。

1. <uses-permission android:name="android.permission.INTERNET"></uses-permission>
2.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>

复制代码

最后运行的效果图：


万事俱备只欠东风啦！哈哈，我需要在我的web工程里放几个音乐文件。

下载后得到的文件可在sdcard下面找到！