Android 编程技巧之 ----- 断点续传原理以及实现

原文出处 ： Android开发——断点续传原理以及实现

原文作者 ： SEU_Calvin

感谢原文作者无私的分享 !

1.  断点续传原理

在本地下载过程中要使用数据库实时存储到底存储到文件的哪个位置了，这样点击开始继续传递时，才能通过HTTP的GET请求中的setRequestProperty()方法可以告诉服务器，数据从哪里开始，到哪里结束。同时在本地的文件写入时，RandomAccessFile的seek()方法也支持在文件中的任意位置进行写入操作。同时通过广播将子线程的进度告诉Activity的ProcessBar。

 

2.  Activity的按钮响应

当点击开始按钮时，将url写在了FileInfo类的对象info中并通过Intent从Activity传递到了Service中。这里使用setAction()来区分是开始按钮还是暂停按钮。

[java]  view plain  copy

 

1. public class FileInfo implements Serializable{  
2.     private String url; //URL  
3.     private int length; //长度或结束位置  
4.     private int start; //开始位置  
5.     private int now;//当前进度  
6. //构造方法，set/get略  
7. }  
8. //开始按钮逻辑，停止逻辑大致相同  
9. strat.setOnClickListener(new View.OnClickListener() {  
10.      @Override  
11.      public void onClick(View view) {  
12.         Intent intent = new Intent(MainActivity.this,DownLoadService.class);  
13.         intent.setAction(DownLoadService.ACTION_START);  
14.         intent.putExtra("fileUrl",info);  
15.         startService(intent);  
16.    }  
17. });  

3.  在Service中的子线程中获取文件大小

在Service中的onStartCommand()中，将FileInfo对象从Intent中取出，如果是开始命令，则开启一个线程，根据该url去获得要下载文件的大小，将该大小写入对象并通过Handler传回Service，同时在本地创建一个相同大小的本地文件。暂停命令最后会讲到。

[java]  view plain  copy

 

1. public void run() {  
2.            HttpURLConnection urlConnection = null;  
3.            RandomAccessFile randomFile = null;  
4.            try {  
5.                URL url = new URL(fileInfo.getUrl());  
6.                urlConnection = (HttpURLConnection) url.openConnection();  
7.                urlConnection.setConnectTimeout(3000);  
8.                urlConnection.setRequestMethod("GET");  
9.                int length = -1;  
10.                if (urlConnection.getResponseCode() == HttpStatus.SC_OK) {  
11.                    //获得文件长度  
12.                    length = urlConnection.getContentLength();  
13.                }  
14.                if (length <= 0) {  
15.                    return;  
16.                }  
17.                //创建相同大小的本地文件  
18.                File dir = new File(DOWNLOAD_PATH);  
19.                if (!dir.exists()) {  
20.                    dir.mkdir();  
21.                }  
22.                File file = new File(dir, FILE_NAME);  
23.                randomFile = new RandomAccessFile(file, "rwd");  
24.                randomFile.setLength(length);  
25.                //长度给fileInfo对象  
26.                fileInfo.setLength(length);  
27.                //通过Handler将对象传递给Service  
28.                mHandle.obtainMessage(0, fileInfo).sendToTarget();  
29.            } catch (Exception e) {  
30.                e.printStackTrace();  
31.            } finally {  //流的回收逻辑略  
32.            }  
33.        }  
34.    }  

4.  数据库操作封装

在Service的handleMessage()方法中拿到有length属性的FileInfo对象，并使用自定义的DownLoadUtil类进行具体的文件下载逻辑。这里传入上下文，因为数据库处理操作需要用到。

[java]  view plain  copy

 

1. downLoadUtil = new DownLoadUtil(DownLoadService.this,info);  
2. downLoadUtil.download();  

这里有一个数据库操作的接口ThreadDAO，内部有增删改查等逻辑，用于记录下载任务的信息。自定义一个ThreadDAOImpl类将这里的逻辑实现，内部数据库创建关于继承SQLiteOpenHelper的自定义类的逻辑就不贴了，比较简单，该类会在ThreadDAOImpl类的构造方法中创建实例。完成底层数据库操作的封装。

[java]  view plain  copy

 

1. public interface ThreadDAO {  
2.     //插入一条数据  
3.     public void insert(FileInfo info);  
4.     //根据URL删除一条数据  
5.     public void delete(String url);  
6.     //根据URL更新一条进度  
7.     public void update(String url,int finished);  
8.     //根据URL找到一条数据  
9.     public List<FileInfo> get(String url);  
10.     //是否存在  
11.     public boolean isExits(String url);  
12. }  

5.  具体的文件下载逻辑

[java]  view plain  copy

 

1. public class DownLoadUtil {  
2.     //构造方法略  
3.     public void download(){  
4.         List<FileInfo> lists = threadDAO.get(fileInfo.getUrl());  
5.         FileInfo info = null;  
6.         if(lists.size() == 0){  
7.             //第一次下载，创建子线程下载  
8.             new MyThread(fileInfo).start();  
9.         }else{  
10.             //中间开始的  
11.             info = lists.get(0);  
12.             new MyThread(info).start();  
13.         }  
14.     }  
15.   
16.     class MyThread extends Thread{  
17.         private FileInfo info = null;  
18.         public MyThread(FileInfo threadInfo) {  
19.             this.info = threadInfo;  
20.         }  
21.         @Override  
22.         public void run() {  
23.             //向数据库添加线程信息  
24.             if(!threadDAO.isExits(info.getUrl())){  
25.                 threadDAO.insert(info);  
26.             }  
27.             HttpURLConnection urlConnection = null;  
28.             RandomAccessFile randomFile =null;  
29.             InputStream inputStream = null;  
30.             try {  
31.                 URL url = new URL(info.getUrl());  
32.                 urlConnection = (HttpURLConnection) url.openConnection();  
33.                 urlConnection.setConnectTimeout(3000);  
34.                 urlConnection.setRequestMethod("GET");  
35.                 //设置下载位置  
36.                 int start = info.getStart() + info.getNow();  
37.                 urlConnection.setRequestProperty("Range","bytes=" + start + "-" + info.getLength());  
38.   
39.                 //设置文件写入位置  
40.                 File file = new File(DOWNLOAD_PATH,FILE_NAME);  
41.                 randomFile = new RandomAccessFile(file, "rwd");  
42.                 randomFile.seek(start);  
43.   
44.                 //向Activity发广播  
45.                 Intent intent = new Intent(ACTION_UPDATE);  
46.                 finished += info.getNow();  
47.   
48.                 if (urlConnection.getResponseCode() == HttpStatus.SC_PARTIAL_CONTENT) {  
49.                     //获得文件流  
50.                     inputStream = urlConnection.getInputStream();  
51.                     byte[] buffer = new byte[512];  
52.                     int len = -1;  
53.                     long time = System.currentTimeMillis();  
54.                     while ((len = inputStream.read(buffer))!= -1){  
55.                         //写入文件  
56.                         randomFile.write(buffer,0,len);  
57.                         //把进度发送给Activity  
58.                         finished += len;  
59.                         //看时间间隔，时间间隔大于500ms再发  
60.                         if(System.currentTimeMillis() - time >500){  
61.                             time = System.currentTimeMillis();  
62.                             intent.putExtra("now",finished *100 /fileInfo.getLength());  
63.                             context.sendBroadcast(intent);  
64.                         }  
65.                         //判断是否是暂停状态  
66.                         if(isPause){  
67.                             threadDAO.update(info.getUrl(),finished);  
68.                             return; //结束循环  
69.                         }  
70.                     }  
71.                     //删除线程信息  
72.                     threadDAO.delete(info.getUrl());  
73.                 }  
74.             }catch (Exception e){  
75.                 e.printStackTrace();  
76.             }finally {//回收工作略  
77.             }  
78.         }  
79.     }  
80. }  

上面也讲到使用自定义的DownLoadUtil类进行具体的文件下载逻辑，这也是最关键的部分了，在该类的构造方法中进行ThreadDAOImpl实例的创建。并在download()中通过数据库查询的操作，判断是否是第一次开始下载任务，如果是，则开启一个子线程MyThread进行下载任务，否则将进度信息从数据库中取出，并将该信息传递给MyThread。

在MyThread中，通过info.getStart() + info.getNow()设置开始下载的位置，如果是第一次下载两个数将都是0，如果是暂停后再下载，则info.getNow()会取出非0值，该值来自数据库存储。使用setRequestProperty告知服务器从哪里开始传递数据，传递到哪里结束，本地使用RandomAccessFile的seek()方法进行数据的本地存储。使用广播将进度的百分比传递给Activity，Activity再改变ProcessBar进行UI调整。

这里很关键的一点是在用户点击暂停后会在Service中调用downLoadUtil.isPause = true，因此上面while循环会结束，停止下载并通过数据库的update()保存进度值。从而在续传时取出该值，重新对服务器发起文件起始点的下载任务请求，同时也在本地文件的相应位置继续写入操作。

6.  效果如下所示