android使用OkHttp实现下载的进度监听和断点续传

1. 导入依赖包

// retrofit, 基于Okhttp，考虑到项目中经常会用到retrofit，就导入这个了。
 compile 'com.squareup.retrofit2:retrofit:2.1.0'
// ButterKnife
 compile 'com.jakewharton:butterknife:7.0.1'
// rxjava 本例中线程切换要用到，代替handler
 compile 'io.reactivex:rxjava:1.1.6'
 compile 'io.reactivex:rxandroid:1.2.1'

2. 继承ResponseBody，生成带进度监听的ProgressResponseBody

// 参考okhttp的官方demo，此类当中我们主要把注意力放在ProgressListener和read方法中。在这里获取文件总长我写在了构造方法里，这样免得在source的read方法中重复调用或判断。读者也可以根据个人需要定制自己的 * 。
public class ProgressResponseBody extends ResponseBody {

public interface ProgressListener {
   void onPreExecute(long contentLength);
   void update(long totalBytes, boolean done);
 }

private final ResponseBody responseBody;
 private final ProgressListener progressListener;
 private BufferedSource bufferedSource;

public ProgressResponseBody(ResponseBody responseBody,
               ProgressListener progressListener) {
   this.responseBody = responseBody;
   this.progressListener = progressListener;
   if(progressListener!=null){
     progressListener.onPreExecute(contentLength());
   }
 }

@Override
 public MediaType contentType() {
   return responseBody.contentType();
 }

@Override
 public long contentLength() {
   return responseBody.contentLength();
 }

@Override
 public BufferedSource source() {
   if (bufferedSource == null) {
     bufferedSource = Okio.buffer(source(responseBody.source()));
   }
   return bufferedSource;
 }

private Source source(Source source) {
   return new ForwardingSource(source) {
     long totalBytes = 0L;
     @Override
     public long read(Buffer sink, long byteCount) throws IOException {
       long bytesRead = super.read(sink, byteCount);
       // read() returns the number of bytes read, or -1 if this source is exhausted.
       totalBytes += bytesRead != -1 ? bytesRead : 0;
       if (null != progressListener) {
         progressListener.update(totalBytes, bytesRead == -1);
       }
       return bytesRead;
     }
   };
 }
}

3.创建ProgressDownloader

//带进度监听功能的辅助类
public class ProgressDownloader {

public static final String TAG = "ProgressDownloader";

private ProgressListener progressListener;
 private String url;
 private OkHttpClient client;
 private File destination;
 private Call call;

public ProgressDownloader(String url, File destination, ProgressListener progressListener) {
   this.url = url;
   this.destination = destination;
   this.progressListener = progressListener;
   //在下载、暂停后的继续下载中可复用同一个client对象
   client = getProgressClient();
 }
 //每次下载需要新建新的Call对象
 private Call newCall(long startPoints) {
   Request request = new Request.Builder()
       .url(url)
       .header("RANGE", "bytes=" + startPoints + "-")//断点续传要用到的，指示下载的区间
       .build();
   return client.newCall(request);
 }

public OkHttpClient getProgressClient() {
 // * ，用上ProgressResponseBody
   Interceptor interceptor = new Interceptor() {
     @Override
     public Response intercept(Chain chain) throws IOException {
       Response originalResponse = chain.proceed(chain.request());
       return originalResponse.newBuilder()
           .body(new ProgressResponseBody(originalResponse.body(), progressListener))
           .build();
     }
   };

return new OkHttpClient.Builder()
       .addNetworkInterceptor(interceptor)
       .build();
 }

// startsPoint指定开始下载的点
 public void download(final long startsPoint) {
   call = newCall(startsPoint);
   call.enqueue(new Callback() {
         @Override
         public void onFailure(Call call, IOException e) {

}

@Override
         public void onResponse(Call call, Response response) throws IOException {
           save(response, startsPoint);
         }
       });
 }

public void pause() {
   if(call!=null){
     call.cancel();
   }
 }

private void save(Response response, long startsPoint) {
   ResponseBody body = response.body();
   InputStream in = body.byteStream();
   FileChannel channelOut = null;
   // 随机访问文件，可以指定断点续传的起始位置
   RandomAccessFile randomAccessFile = null;
   try {
     randomAccessFile = new RandomAccessFile(destination, "rwd");
     //Chanel NIO中的用法，由于RandomAccessFile没有使用缓存策略，直接使用会使得下载速度变慢，亲测缓存下载3.3秒的文件，用普通的RandomAccessFile需要20多秒。
     channelOut = randomAccessFile.getChannel();
     // 内存映射，直接使用RandomAccessFile，是用其seek方法指定下载的起始位置，使用缓存下载，在这里指定下载位置。
     MappedByteBuffer mappedBuffer = channelOut.map(FileChannel.MapMode.READ_WRITE, startsPoint, body.contentLength());
     byte[] buffer = new byte[1024];
     int len;
     while ((len = in.read(buffer)) != -1) {
       mappedBuffer.put(buffer, 0, len);
     }
   } catch (IOException e) {
     e.printStackTrace();
   }finally {
     try {
       in.close();
       if (channelOut != null) {
         channelOut.close();
       }
       if (randomAccessFile != null) {
         randomAccessFile.close();
       }
     } catch (IOException e) {
       e.printStackTrace();
     }
   }
 }
}

4. 测试demo

清单文件中添加网络权限和文件访问权限

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

MainActivity

public class MainActivity extends AppCompatActivity implements ProgressResponseBody.ProgressListener {

public static final String TAG = "MainActivity";
 public static final String PACKAGE_URL = "http://gdown.baidu.com/data/wisegame/df65a597122796a4/weixin_821.apk";
 @Bind(R.id.progressBar)
 ProgressBar progressBar;
 private long breakPoints;
 private ProgressDownloader downloader;
 private File file;
 private long totalBytes;
 private long contentLength;

@Override
 protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   setContentView(R.layout.activity_main);
   ButterKnife.bind(this);
 }

@OnClick({R.id.downloadButton, R.id.cancel_button, R.id.continue_button})
 public void onClick(View view) {
   switch (view.getId()) {
     case R.id.downloadButton:
     // 新下载前清空断点信息
       breakPoints = 0L;
       file = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS), "sample.apk");
       downloader = new ProgressDownloader(PACKAGE_URL, file, this);
       downloader.download(0L);
       break;
     case R.id.pause_button:
       downloader.pause();
       Toast.makeText(this, "下载暂停", Toast.LENGTH_SHORT).show();
       // 存储此时的totalBytes，即断点位置。
       breakPoints = totalBytes;
       break;
     case R.id.continue_button:
       downloader.download(breakPoints);
       break;
   }
 }

@Override
 public void onPreExecute(long contentLength) {
   // 文件总长只需记录一次，要注意断点续传后的contentLength只是剩余部分的长度
   if (this.contentLength == 0L) {
     this.contentLength = contentLength;
     progressBar.setMax((int) (contentLength / 1024));
   }
 }

@Override
 public void update(long totalBytes, boolean done) {
   // 注意加上断点的长度
   this.totalBytes = totalBytes + breakPoints;
   progressBar.setProgress((int) (totalBytes + breakPoints) / 1024);
   if (done) {
   // 切换到主线程
     Observable
         .empty()
         .observeOn(AndroidSchedulers.mainThread())
         .doOnCompleted(new Action0() {
           @Override
           public void call() {
             Toast.makeText(MainActivity.this, "下载完成", Toast.LENGTH_SHORT).show();
           }
         })
         .subscribe();
   }
 }
}

最后是动态效果图

来源：http://blog.csdn.net/kevinscsdn/article/details/51934274