Android使用OKHttp3实现下载(断点续传、显示进度)

OKHttp3是如今非常流行的Android网络请求框架,那么如何利用Android实现断点续传呢,今天写了个Demo尝试了一下,感觉还是有点意思

准备阶段

我们会用到OKHttp3来做网络请求,使用RxJava来实现线程的切换,并且开启Java8来启用Lambda表达式,毕竟RxJava实现线程切换非常方便,而且数据流的形式也非常舒服,同时Lambda和RxJava配合食用味道更佳

打开我们的app Module下的build.gradle,代码如下

[plain]  view plain  copy

1. apply plugin: 'com.android.application'  
2.   
3. android {  
4.     compileSdkVersion 24  
5.     buildToolsVersion "24.0.3"  
6.   
7.     defaultConfig {  
8.         applicationId "com.lanou3g.downdemo"  
9.         minSdkVersion 15  
10.         targetSdkVersion 24  
11.         versionCode 1  
12.         versionName "1.0"  
13.         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"  
14.         //为了开启Java8  
15.         jackOptions{  
16.             enabled true;  
17.         }  
18.     }  
19.     buildTypes {  
20.         release {  
21.             minifyEnabled false  
22.             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'  
23.         }  
24.     }  
25.   
26.     //开启Java1.8 能够使用lambda表达式  
27.     compileOptions{  
28.         sourceCompatibility JavaVersion.VERSION_1_8  
29.         targetCompatibility JavaVersion.VERSION_1_8  
30.     }  
31. }  
32.   
33. dependencies {  
34.     compile fileTree(dir: 'libs', include: ['*.jar'])  
35.     androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {  
36.         exclude group: 'com.android.support', module: 'support-annotations'  
37.     })  
38.     compile 'com.android.support:appcompat-v7:24.1.1'  
39.     testCompile 'junit:junit:4.12'  
40.   
41.     //OKHttp  
42.     compile 'com.squareup.okhttp3:okhttp:3.6.0'  
43.     //RxJava和RxAndroid 用来做线程切换的  
44.     compile 'io.reactivex.rxjava2:rxandroid:2.0.1'  
45.     compile 'io.reactivex.rxjava2:rxjava:2.0.1'  
46. }  

OKHttp和RxJava,RxAndroid使用的都是最新的版本,并且配置开启了Java8

布局文件

接着开始书写布局文件

[html]  view plain  copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
3.     xmlns:tools="http://schemas.android.com/tools"  
4.     android:id="@+id/activity_main"  
5.     android:layout_width="match_parent"  
6.     android:layout_height="match_parent"  
7.     android:paddingBottom="@dimen/activity_vertical_margin"  
8.     android:paddingLeft="@dimen/activity_horizontal_margin"  
9.     android:paddingRight="@dimen/activity_horizontal_margin"  
10.     android:paddingTop="@dimen/activity_vertical_margin"  
11.     android:orientation="vertical"  
12.     tools:context="com.lanou3g.downdemo.MainActivity">  
13.   
14.     <LinearLayout  
15.         android:layout_width="match_parent"  
16.         android:layout_height="wrap_content"  
17.         android:orientation="horizontal">  
18.         <ProgressBar  
19.             android:id="@+id/main_progress1"  
20.             android:layout_width="0dp"  
21.             android:layout_weight="1"  
22.             android:layout_height="match_parent"  
23.             style="@style/Widget.AppCompat.ProgressBar.Horizontal" />  
24.         <Button  
25.             android:id="@+id/main_btn_down1"  
26.             android:layout_width="wrap_content"  
27.             android:layout_height="wrap_content"  
28.             android:text="下载1"/>  
29.         <Button  
30.             android:id="@+id/main_btn_cancel1"  
31.             android:layout_width="wrap_content"  
32.             android:layout_height="wrap_content"  
33.             android:text="取消1"/>  
34.     </LinearLayout>  
35.     <LinearLayout  
36.         android:layout_width="match_parent"  
37.         android:layout_height="wrap_content"  
38.         android:orientation="horizontal">  
39.         <ProgressBar  
40.             android:id="@+id/main_progress2"  
41.             android:layout_width="0dp"  
42.             android:layout_weight="1"  
43.             android:layout_height="match_parent"  
44.             style="@style/Widget.AppCompat.ProgressBar.Horizontal" />  
45.         <Button  
46.             android:id="@+id/main_btn_down2"  
47.             android:layout_width="wrap_content"  
48.             android:layout_height="wrap_content"  
49.             android:text="下载2"/>  
50.         <Button  
51.             android:id="@+id/main_btn_cancel2"  
52.             android:layout_width="wrap_content"  
53.             android:layout_height="wrap_content"  
54.             android:text="取消2"/>  
55.     </LinearLayout>  
56.     <LinearLayout  
57.         android:layout_width="match_parent"  
58.         android:layout_height="wrap_content"  
59.         android:orientation="horizontal">  
60.         <ProgressBar  
61.             android:id="@+id/main_progress3"  
62.             android:layout_width="0dp"  
63.             android:layout_weight="1"  
64.             android:layout_height="match_parent"  
65.             style="@style/Widget.AppCompat.ProgressBar.Horizontal" />  
66.         <Button  
67.             android:id="@+id/main_btn_down3"  
68.             android:layout_width="wrap_content"  
69.             android:layout_height="wrap_content"  
70.             android:text="下载3"/>  
71.         <Button  
72.             android:id="@+id/main_btn_cancel3"  
73.             android:layout_width="wrap_content"  
74.             android:layout_height="wrap_content"  
75.             android:text="取消3"/>  
76.     </LinearLayout>  
77. </LinearLayout>  

大概是这个样子的

3个ProgressBar就是为了显示进度的,每个ProgressBar对应2个Button,一个是开始下载,一个是暂停(取消)下载,这里需要说明的是,对下载来说暂停和取消没有什么区别,除非当取消的时候,会顺带把临时文件都删除了,在本例里是不区分他俩的.

扫描二维码关注公众号，回复： 383418 查看本文章

Application

我们这里需要用到一些文件路径,有一个全局Context会比较方便, 而Application也是Context的子类,使用它的是最方便的,所以我们写一个类来继承Application

[java]  view plain  copy

1. package com.lanou3g.downdemo;  
2.   
3. import android.app.Application;  
4. import android.content.Context;  
5.   
6. /** 
7.  * Created by 陈丰尧 on 2017/2/2. 
8.  */  
9.   
10. public class MyApp extends Application {  
11.     public static Context sContext;//全局的Context对象  
12.   
13.     @Override  
14.     public void onCreate() {  
15.         super.onCreate();  
16.         sContext = this;  
17.     }  
18. }  

可以看到,我们就是要获得一个全局的Context对象的

我们在AndroidManifest中注册一下我们的Application,同时再把我们所需要的权限给上

[html]  view plain  copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
3.     package="com.lanou3g.downdemo">  
4.       
5.     <!--网络权限-->  
6.     <uses-permission android:name="android.permission.INTERNET"/>  
7.   
8.     <application  
9.         android:allowBackup="true"  
10.         android:icon="@mipmap/ic_launcher"  
11.         android:label="@string/app_name"  
12.         android:supportsRtl="true"  
13.         android:name=".MyApp"  
14.         android:theme="@style/AppTheme">  
15.         <activity android:name=".MainActivity">  
16.             <intent-filter>  
17.                 <action android:name="android.intent.action.MAIN" />  
18.   
19.                 <category android:name="android.intent.category.LAUNCHER" />  
20.             </intent-filter>  
21.         </activity>  
22.     </application>  
23.   
24. </manifest>  

我们只需要一个网络权限,在application标签下,添加name属性,来指向我们的Application

DownloadManager

接下来是核心代码了,就是我们的DownloadManager,先上代码

[java]  view plain  copy

1. package com.lanou3g.downdemo;  
2.   
3. import java.io.File;  
4. import java.io.FileOutputStream;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.util.HashMap;  
8. import java.util.concurrent.atomic.AtomicReference;  
9.   
10. import io.reactivex.Observable;  
11. import io.reactivex.ObservableEmitter;  
12. import io.reactivex.ObservableOnSubscribe;  
13. import io.reactivex.android.schedulers.AndroidSchedulers;  
14. import io.reactivex.schedulers.Schedulers;  
15. import okhttp3.Call;  
16. import okhttp3.OkHttpClient;  
17. import okhttp3.Request;  
18. import okhttp3.Response;  
19.   
20. /** 
21.  * Created by 陈丰尧 on 2017/2/2. 
22.  */  
23.   
24. public class DownloadManager {  
25.   
26.     private static final AtomicReference<DownloadManager> INSTANCE = new AtomicReference<>();  
27.     private HashMap<String, Call> downCalls;//用来存放各个下载的请求  
28.     private OkHttpClient mClient;//OKHttpClient;  
29.   
30.     //获得一个单例类  
31.     public static DownloadManager getInstance() {  
32.         for (; ; ) {  
33.             DownloadManager current = INSTANCE.get();  
34.             if (current != null) {  
35.                 return current;  
36.             }  
37.             current = new DownloadManager();  
38.             if (INSTANCE.compareAndSet(null, current)) {  
39.                 return current;  
40.             }  
41.         }  
42.     }  
43.   
44.     private DownloadManager() {  
45.         downCalls = new HashMap<>();  
46.         mClient = new OkHttpClient.Builder().build();  
47.     }  
48.   
49.     /** 
50.      * 开始下载 
51.      * 
52.      * @param url              下载请求的网址 
53.      * @param downLoadObserver 用来回调的接口 
54.      */  
55.     public void download(String url, DownLoadObserver downLoadObserver) {  
56.         Observable.just(url)  
57.                 .filter(s -> !downCalls.containsKey(s))//call的map已经有了,就证明正在下载,则这次不下载  
58.                 .flatMap(s -> Observable.just(createDownInfo(s)))  
59.                 .map(this::getRealFileName)//检测本地文件夹,生成新的文件名  
60.                 .flatMap(downloadInfo -> Observable.create(new DownloadSubscribe(downloadInfo)))//下载  
61.                 .observeOn(AndroidSchedulers.mainThread())//在主线程回调  
62.                 .subscribeOn(Schedulers.io())//在子线程执行  
63.                 .subscribe(downLoadObserver);//添加观察者  
64.   
65.     }  
66.   
67.     public void cancel(String url) {  
68.         Call call = downCalls.get(url);  
69.         if (call != null) {  
70.             call.cancel();//取消  
71.         }  
72.         downCalls.remove(url);  
73.     }  
74.   
75.     /** 
76.      * 创建DownInfo 
77.      * 
78.      * @param url 请求网址 
79.      * @return DownInfo 
80.      */  
81.     private DownloadInfo createDownInfo(String url) {  
82.         DownloadInfo downloadInfo = new DownloadInfo(url);  
83.         long contentLength = getContentLength(url);//获得文件大小  
84.         downloadInfo.setTotal(contentLength);  
85.         String fileName = url.substring(url.lastIndexOf("/"));  
86.         downloadInfo.setFileName(fileName);  
87.         return downloadInfo;  
88.     }  
89.   
90.     private DownloadInfo getRealFileName(DownloadInfo downloadInfo) {  
91.         String fileName = downloadInfo.getFileName();  
92.         long downloadLength = 0, contentLength = downloadInfo.getTotal();  
93.         File file = new File(MyApp.sContext.getFilesDir(), fileName);  
94.         if (file.exists()) {  
95.             //找到了文件,代表已经下载过,则获取其长度  
96.             downloadLength = file.length();  
97.         }  
98.         //之前下载过,需要重新来一个文件  
99.         int i = 1;  
100.         while (downloadLength >= contentLength) {  
101.             int dotIndex = fileName.lastIndexOf(".");  
102.             String fileNameOther;  
103.             if (dotIndex == -1) {  
104.                 fileNameOther = fileName + "(" + i + ")";  
105.             } else {  
106.                 fileNameOther = fileName.substring(0, dotIndex)  
107.                         + "(" + i + ")" + fileName.substring(dotIndex);  
108.             }  
109.             File newFile = new File(MyApp.sContext.getFilesDir(), fileNameOther);  
110.             file = newFile;  
111.             downloadLength = newFile.length();  
112.             i++;  
113.         }  
114.         //设置改变过的文件名/大小  
115.         downloadInfo.setProgress(downloadLength);  
116.         downloadInfo.setFileName(file.getName());  
117.         return downloadInfo;  
118.     }  
119.   
120.     private class DownloadSubscribe implements ObservableOnSubscribe<DownloadInfo> {  
121.         private DownloadInfo downloadInfo;  
122.   
123.         public DownloadSubscribe(DownloadInfo downloadInfo) {  
124.             this.downloadInfo = downloadInfo;  
125.         }  
126.   
127.         @Override  
128.         public void subscribe(ObservableEmitter<DownloadInfo> e) throws Exception {  
129.             String url = downloadInfo.getUrl();  
130.             long downloadLength = downloadInfo.getProgress();//已经下载好的长度  
131.             long contentLength = downloadInfo.getTotal();//文件的总长度  
132.             //初始进度信息  
133.             e.onNext(downloadInfo);  
134.   
135.             Request request = new Request.Builder()  
136.                     //确定下载的范围,添加此头,则服务器就可以跳过已经下载好的部分  
137.                     .addHeader("RANGE", "bytes=" + downloadLength + "-" + contentLength)  
138.                     .url(url)  
139.                     .build();  
140.             Call call = mClient.newCall(request);  
141.             downCalls.put(url, call);//把这个添加到call里,方便取消  
142.             Response response = call.execute();  
143.   
144.             File file = new File(MyApp.sContext.getFilesDir(), downloadInfo.getFileName());  
145.             InputStream is = null;  
146.             FileOutputStream fileOutputStream = null;  
147.             try {  
148.                 is = response.body().byteStream();  
149.                 fileOutputStream = new FileOutputStream(file, true);  
150.                 byte[] buffer = new byte[2048];//缓冲数组2kB  
151.                 int len;  
152.                 while ((len = is.read(buffer)) != -1) {  
153.                     fileOutputStream.write(buffer, 0, len);  
154.                     downloadLength += len;  
155.                     downloadInfo.setProgress(downloadLength);  
156.                     e.onNext(downloadInfo);  
157.                 }  
158.                 fileOutputStream.flush();  
159.                 downCalls.remove(url);  
160.             } finally {  
161.                 //关闭IO流  
162.                 IOUtil.closeAll(is, fileOutputStream);  
163.   
164.             }  
165.             e.onComplete();//完成  
166.         }  
167.     }  
168.   
169.     /** 
170.      * 获取下载长度 
171.      * 
172.      * @param downloadUrl 
173.      * @return 
174.      */  
175.     private long getContentLength(String downloadUrl) {  
176.         Request request = new Request.Builder()  
177.                 .url(downloadUrl)  
178.                 .build();  
179.         try {  
180.             Response response = mClient.newCall(request).execute();  
181.             if (response != null && response.isSuccessful()) {  
182.                 long contentLength = response.body().contentLength();  
183.                 response.close();  
184.                 return contentLength == 0 ? DownloadInfo.TOTAL_ERROR : contentLength;  
185.             }  
186.         } catch (IOException e) {  
187.             e.printStackTrace();  
188.         }  
189.         return DownloadInfo.TOTAL_ERROR;  
190.     }  
191.   
192.   
193. }  

代码稍微有点长,关键部位我都加了注释了,我们挑关键地方看看

首先我们这个类是单例类,我们下载只需要一个OKHttpClient就足够了,所以我们让构造方法私有,而单例类的获取实例方法就是这个getInstance();当然大家用别的方式实现单例也可以的,然后我们在构造方法里初始化我们的HttpClient,并且初始化一个HashMap,用来放所有的网络请求的,这样当我们取消下载的时候,就可以找到url对应的网络请求然后把它取消掉就可以了

接下来就是核心的download方法了,首先是参数,第一个参数url不用多说,就是请求的网址,第二个参数是一个Observer对象,因为我们使用的是RxJava,并且没有特别多复杂的方法,所以就没单独写接口,而是谢了一个Observer对象来作为回调,接下来是DownLoadObserver的代码

[java]  view plain  copy

1. package com.lanou3g.downdemo;  
2.   
3. import io.reactivex.Observer;  
4. import io.reactivex.disposables.Disposable;  
5.   
6. /** 
7.  * Created by 陈丰尧 on 2017/2/2. 
8.  */  
9.   
10. public  abstract class DownLoadObserver implements Observer<DownloadInfo> {  
11.     protected Disposable d;//可以用于取消注册的监听者  
12.     protected DownloadInfo downloadInfo;  
13.     @Override  
14.     public void onSubscribe(Disposable d) {  
15.         this.d = d;  
16.     }  
17.   
18.     @Override  
19.     public void onNext(DownloadInfo downloadInfo) {  
20.         this.downloadInfo = downloadInfo;  
21.     }  
22.   
23.     @Override  
24.     public void onError(Throwable e) {  
25.         e.printStackTrace();  
26.     }  
27.   
28.   
29. }  

在RxJava2中 这个Observer有点变化,当注册观察者的时候,会调用onSubscribe方法,而该方法参数就是用来取消注册的,这样的改动可以更灵活的有监听者来取消监听了,我们的进度信息会一直的传送的onNext方法里,这里将下载所需要的内容封了一个类叫DownloadInfo

[java]  view plain  copy

1. package com.lanou3g.downdemo;  
2.   
3. /** 
4.  * Created by 陈丰尧 on 2017/2/2. 
5.  * 下载信息 
6.  */  
7.   
8. public class DownloadInfo {  
9.     public static final long TOTAL_ERROR = -1;//获取进度失败  
10.     private String url;  
11.     private long total;  
12.     private long progress;  
13.     private String fileName;  
14.       
15.     public DownloadInfo(String url) {  
16.         this.url = url;  
17.     }  
18.   
19.     public String getUrl() {  
20.         return url;  
21.     }  
22.   
23.     public String getFileName() {  
24.         return fileName;  
25.     }  
26.   
27.     public void setFileName(String fileName) {  
28.         this.fileName = fileName;  
29.     }  
30.   
31.     public long getTotal() {  
32.         return total;  
33.     }  
34.   
35.     public void setTotal(long total) {  
36.         this.total = total;  
37.     }  
38.   
39.     public long getProgress() {  
40.         return progress;  
41.     }  
42.   
43.     public void setProgress(long progress) {  
44.         this.progress = progress;  
45.     }  
46. }  

这个类就是一些基本信息,total就是需要下载的文件的总大小,而progress就是当前下载的进度了,这样就可以计算出下载的进度信息了

接着看DownloadManager的download方法,首先通过url生成一个Observable对象,然后通过filter操作符过滤一下,如果当前正在下载这个url对应的内容,那么就不下载它,

接下来调用createDownInfo重新生成Observable对象,这里应该用map也是可以的,createDownInfo这个方法里会调用getContentLength来获取服务器上的文件大小,可以看一下这个方法的代码,

[java]  view plain  copy

1. /** 
2.     * 获取下载长度 
3.     * 
4.     * @param downloadUrl 
5.     * @return 
6.     */  
7.    private long getContentLength(String downloadUrl) {  
8.        Request request = new Request.Builder()  
9.                .url(downloadUrl)  
10.                .build();  
11.        try {  
12.            Response response = mClient.newCall(request).execute();  
13.            if (response != null && response.isSuccessful()) {  
14.                long contentLength = response.body().contentLength();  
15.                response.close();  
16.                return contentLength == 0 ? DownloadInfo.TOTAL_ERROR : contentLength;  
17.            }  
18.        } catch (IOException e) {  
19.            e.printStackTrace();  
20.        }  
21.        return DownloadInfo.TOTAL_ERROR;  
22.    }  

可以看到,其实就是在通过OK进行了一次网络请求,并且从返回的头信息里拿到文件的大小信息,一般这个信息都是可以拿到的,除非下载网址不是直接指向资源文件的,而是自己手写的Servlet,那就得跟后台人员沟通好了. 注意,这次网络请求并没有真正的去下载文件,而是请求个大小就结束了,具体原因会在后面真正请求数据的时候解释

接着download方法

获取完文件大小后,就可以去硬盘里找文件了,这里调用了getRealFileName方法

[java]  view plain  copy

1. private DownloadInfo getRealFileName(DownloadInfo downloadInfo) {  
2.         String fileName = downloadInfo.getFileName();  
3.         long downloadLength = 0, contentLength = downloadInfo.getTotal();  
4.         File file = new File(MyApp.sContext.getFilesDir(), fileName);  
5.         if (file.exists()) {  
6.             //找到了文件,代表已经下载过,则获取其长度  
7.             downloadLength = file.length();  
8.         }  
9.         //之前下载过,需要重新来一个文件  
10.         int i = 1;  
11.         while (downloadLength >= contentLength) {  
12.             int dotIndex = fileName.lastIndexOf(".");  
13.             String fileNameOther;  
14.             if (dotIndex == -1) {  
15.                 fileNameOther = fileName + "(" + i + ")";  
16.             } else {  
17.                 fileNameOther = fileName.substring(0, dotIndex)  
18.                         + "(" + i + ")" + fileName.substring(dotIndex);  
19.             }  
20.             File newFile = new File(MyApp.sContext.getFilesDir(), fileNameOther);  
21.             file = newFile;  
22.             downloadLength = newFile.length();  
23.             i++;  
24.         }  
25.         //设置改变过的文件名/大小  
26.         downloadInfo.setProgress(downloadLength);  
27.         downloadInfo.setFileName(file.getName());  
28.         return downloadInfo;  
29.     }  

这个方法就是看本地是否有已经下载过的文件,如果有,再判断一次本地文件的大小和服务器上数据的大小,如果是一样的,证明之前下载全了,就再成一个带(1)这样的文件,而如果本地文件大小比服务器上的小的话,那么证明之前下载了一半断掉了,那么就把进度信息保存上,并把文件名也存上,看完了再回到download方法

之后就开始真正的网络请求了,这里写了一个内部类来实现ObservableOnSubscribe接口,这个接口也是RxJava2的,东西和之前一样,好像只改了名字,看一下代码

[java]  view plain  copy

1. private class DownloadSubscribe implements ObservableOnSubscribe<DownloadInfo> {  
2.         private DownloadInfo downloadInfo;  
3.   
4.         public DownloadSubscribe(DownloadInfo downloadInfo) {  
5.             this.downloadInfo = downloadInfo;  
6.         }  
7.   
8.         @Override  
9.         public void subscribe(ObservableEmitter<DownloadInfo> e) throws Exception {  
10.             String url = downloadInfo.getUrl();  
11.             long downloadLength = downloadInfo.getProgress();//已经下载好的长度  
12.             long contentLength = downloadInfo.getTotal();//文件的总长度  
13.             //初始进度信息  
14.             e.onNext(downloadInfo);  
15.   
16.             Request request = new Request.Builder()  
17.                     //确定下载的范围,添加此头,则服务器就可以跳过已经下载好的部分  
18.                     .addHeader("RANGE", "bytes=" + downloadLength + "-" + contentLength)  
19.                     .url(url)  
20.                     .build();  
21.             Call call = mClient.newCall(request);  
22.             downCalls.put(url, call);//把这个添加到call里,方便取消  
23.             Response response = call.execute();  
24.   
25.             File file = new File(MyApp.sContext.getFilesDir(), downloadInfo.getFileName());  
26.             InputStream is = null;  
27.             FileOutputStream fileOutputStream = null;  
28.             try {  
29.                 is = response.body().byteStream();  
30.                 fileOutputStream = new FileOutputStream(file, true);  
31.                 byte[] buffer = new byte[2048];//缓冲数组2kB  
32.                 int len;  
33.                 while ((len = is.read(buffer)) != -1) {  
34.                     fileOutputStream.write(buffer, 0, len);  
35.                     downloadLength += len;  
36.                     downloadInfo.setProgress(downloadLength);  
37.                     e.onNext(downloadInfo);  
38.                 }  
39.                 fileOutputStream.flush();  
40.                 downCalls.remove(url);  
41.             } finally {  
42.                 //关闭IO流  
43.                 IOUtil.closeAll(is, fileOutputStream);  
44.   
45.             }  
46.             e.onComplete();//完成  
47.         }  
48.     }  

主要看subscribe方法

首先拿到url,当前进度信息和文件的总大小,然后开始网络请求,注意这次网络请求的时候需要添加一条头信息

[java]  view plain  copy

1. .addHeader("RANGE", "bytes=" + downloadLength + "-" + contentLength)  

这条头信息的意思是下载的范围是多少,downloadLength是从哪开始下载,contentLength是下载到哪,当要断点续传的话必须添加这个头,让输入流跳过多少字节的形式是不行的,所以我们要想能成功的添加这条信息那么就必须对这个url请求2次,一次拿到总长度,来方便判断本地是否有下载一半的数据,第二次才开始真正的读流进行网络请求,我还想了一种思路,当文件没有下载完成的时候添加一个自定义的后缀,当下载完成再把这个后缀取消了,应该就不需要请求两次了.

接下来就是正常的网络请求,向本地写文件了,而写文件到本地这,网上大多用的是RandomAccessFile这个类,但是如果不涉及到多个部分拼接的话是没必要的,直接使用输出流就好了,在输出流的构造方法上添加一个true的参数,代表是在原文件的后面添加数据即可,而在循环里,不断的调用onNext方法发送进度信息,当写完了之后别忘了关流,同时把call对象从hashMap中移除了.这里写了一个IOUtil来关流

[java]  view plain  copy

1. package com.lanou3g.downdemo;  
2.   
3. import java.io.Closeable;  
4. import java.io.IOException;  
5.   
6. /** 
7.  * Created by 陈丰尧 on 2017/2/2. 
8.  */  
9.   
10. public class IOUtil {  
11.     public static void closeAll(Closeable... closeables){  
12.         if(closeables == null){  
13.             return;  
14.         }  
15.         for (Closeable closeable : closeables) {  
16.             if(closeable!=null){  
17.                 try {  
18.                     closeable.close();  
19.                 } catch (IOException e) {  
20.                     e.printStackTrace();  
21.                 }  
22.             }  
23.         }  
24.     }  
25. }  

其实就是挨一个判断是否为空,并关闭罢了

这样download方法就完成了,剩下的就是切换线程,注册观察者了

MainActivity

最后是aty的代码

[java]  view plain  copy

1. package com.lanou3g.downdemo;  
2.   
3. import android.net.Uri;  
4. import android.support.annotation.IdRes;  
5. import android.support.v7.app.AppCompatActivity;  
6. import android.os.Bundle;  
7. import android.view.View;  
8. import android.widget.Button;  
9. import android.widget.ProgressBar;  
10. import android.widget.Toast;  
11.   
12. public class MainActivity extends AppCompatActivity implements View.OnClickListener {  
13.     private Button downloadBtn1, downloadBtn2, downloadBtn3;  
14.     private Button cancelBtn1, cancelBtn2, cancelBtn3;  
15.     private ProgressBar progress1, progress2, progress3;  
16.     private String url1 = "http://192.168.31.169:8080/out/dream.flac";  
17.     private String url2 = "http://192.168.31.169:8080/out/music.mp3";  
18.     private String url3 = "http://192.168.31.169:8080/out/code.zip";  
19.     @Override  
20.     protected void onCreate(Bundle savedInstanceState) {  
21.         super.onCreate(savedInstanceState);  
22.         setContentView(R.layout.activity_main);  
23.   
24.         downloadBtn1 = bindView(R.id.main_btn_down1);  
25.         downloadBtn2 = bindView(R.id.main_btn_down2);  
26.         downloadBtn3 = bindView(R.id.main_btn_down3);  
27.   
28.         cancelBtn1 = bindView(R.id.main_btn_cancel1);  
29.         cancelBtn2 = bindView(R.id.main_btn_cancel2);  
30.         cancelBtn3 = bindView(R.id.main_btn_cancel3);  
31.   
32.         progress1 = bindView(R.id.main_progress1);  
33.         progress2 = bindView(R.id.main_progress2);  
34.         progress3 = bindView(R.id.main_progress3);  
35.   
36.         downloadBtn1.setOnClickListener(this);  
37.         downloadBtn2.setOnClickListener(this);  
38.         downloadBtn3.setOnClickListener(this);  
39.   
40.         cancelBtn1.setOnClickListener(this);  
41.         cancelBtn2.setOnClickListener(this);  
42.         cancelBtn3.setOnClickListener(this);  
43.     }  
44.   
45.     @Override  
46.     public void onClick(View v) {  
47.         switch (v.getId()) {  
48.             case R.id.main_btn_down1:  
49.                 DownloadManager.getInstance().download(url1, new DownLoadObserver() {  
50.                     @Override  
51.                     public void onNext(DownloadInfo value) {  
52.                         super.onNext(value);  
53.                         progress1.setMax((int) value.getTotal());  
54.                         progress1.setProgress((int) value.getProgress());  
55.                     }  
56.   
57.                     @Override  
58.                     public void onComplete() {  
59.                         if(downloadInfo != null){  
60.                             Toast.makeText(MainActivity.this,  
61.                                     downloadInfo.getFileName() + "-DownloadComplete",  
62.                                     Toast.LENGTH_SHORT).show();  
63.                         }  
64.                     }  
65.                 });  
66.                 break;  
67.             case R.id.main_btn_down2:  
68.                 DownloadManager.getInstance().download(url2, new DownLoadObserver() {  
69.                     @Override  
70.                     public void onNext(DownloadInfo value) {  
71.                         super.onNext(value);  
72.                         progress2.setMax((int) value.getTotal());  
73.                         progress2.setProgress((int) value.getProgress());  
74.                     }  
75.   
76.                     @Override  
77.                     public void onComplete() {  
78.                         if(downloadInfo != null){  
79.                             Toast.makeText(MainActivity.this,  
80.                                     downloadInfo.getFileName() + Uri.encode("下载完成"),  
81.                                     Toast.LENGTH_SHORT).show();  
82.                         }  
83.                     }  
84.                 });  
85.                 break;  
86.             case R.id.main_btn_down3:  
87.                 DownloadManager.getInstance().download(url3, new DownLoadObserver() {  
88.                     @Override  
89.                     public void onNext(DownloadInfo value) {  
90.                         super.onNext(value);  
91.                         progress3.setMax((int) value.getTotal());  
92.                         progress3.setProgress((int) value.getProgress());  
93.                     }  
94.   
95.                     @Override  
96.                     public void onComplete() {  
97.                         if(downloadInfo != null){  
98.                             Toast.makeText(MainActivity.this,  
99.                                     downloadInfo.getFileName() + "下载完成",  
100.                                     Toast.LENGTH_SHORT).show();  
101.                         }  
102.                     }  
103.                 });  
104.                 break;  
105.             case R.id.main_btn_cancel1:  
106.                 DownloadManager.getInstance().cancel(url1);  
107.                 break;  
108.             case R.id.main_btn_cancel2:  
109.                 DownloadManager.getInstance().cancel(url2);  
110.                 break;  
111.             case R.id.main_btn_cancel3:  
112.                 DownloadManager.getInstance().cancel(url3);  
113.                 break;  
114.         }  
115.     }  
116.       
117.     private <T extends View> T bindView(@IdRes int id){  
118.         View viewById = findViewById(id);  
119.         return (T) viewById;  
120.     }  
121. }  

Activity里没什么了,就是注册监听,开始下载,取消下载这些了,下面我们来看看效果吧

运行效果

可以看到 多个下载,断点续传什么的都已经成功了,最后我的文件网址是我自己的局域网,大家写的时候别忘了换了..

代码

http://download.csdn.net/detail/cfy137000/9746583