Android 基于OkHttp的下载,支持https,断点下载,优化下载速度

package com.lenovo.smarthcc.http.okhttp;

import android.text.TextUtils;

import com.lenovo.smarthcc.http.Listenner;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import okhttp3.Call;
import okhttp3.Headers;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okio.Buffer;
import okio.Okio;
import okio.Sink;
import okio.Source;

/**
* <p>Author:    shijiale</p>
* <p>Date:      2017/3/14.<p>

* <p>Describe:
*/

public class BRDownloadThread extends Thread {

private static OkHttpClient mClient;                 //okhttp client
private Builder mBuilder;                            //配置
private boolean isExit = false;                      //是否退出下载
private long mStartTime = 0;                         //当前这次下载起始时间
private long mDownloadLength;                        //当前这次下载的长度
private final int MAX_BUFF_SIZE = 4 * 1024;          //每次发送的字节(这个数值可能没有什么作用,因为大部分http流都会做缓存)
private Call mCall;                                  //当前请求
private DaemonThead mDaemonMsgThread;                //用于进度回调的线程

/***
* 退出当前下载线程
*/
public synchronized void exit() {
isExit = true;
}

private BRDownloadThread() {
mClient = OkHttpProxy.getClient();
if (mDaemonMsgThread == null) {
mDaemonMsgThread = new DaemonThead();
mDaemonMsgThread.isRunning = true;
}
}

@Override
public void run() {
super.run();
try {
downloadFile();
} catch (Exception e) {
mBuilder.mErrorListenner.onChanged(Listenner.STATUS_ERROR, mBuilder.mSavePath, e.getMessage());
} finally {
if (mDaemonMsgThread != null) {
mDaemonMsgThread.isRunning = false;
mDaemonMsgThread = null;
}
}
}

/***
* 自动修改下载的文件名称
* @param fileLength 文件在服务器的大小
*/
private void autoChangeFileName(long fileLength) {
File file = new File(mBuilder.mSavePath);
if(file != null && file.exists() && file.length() == fileLength) {
String path = mBuilder.mSavePath;
path = path.substring(0,path.lastIndexOf(".") + 1);

String expresion = mBuilder.mSavePath.substring(path.lastIndexOf(".") + 1,mBuilder.mSavePath.length());
path += "(" + new Date(System.currentTimeMillis()).toLocaleString() + ")" + expresion;
mBuilder.mSavePath = path;
}
}

private boolean chekDirectory() {
String path = mBuilder.mSavePath;
path = path.substring(0,path.lastIndexOf(File.separator) + 1);
File file = new File(path);
if(file != null && file.exists()) {
return true;
}
if(file == null || !file.exists()) {
boolean mkdirs = file.mkdirs();
if(!mkdirs) {
return false;
}
}
return true;
}

/***
* 下载文件
* @throws IOException
*/
private void downloadFile() throws IOException {

if(!chekDirectory()) {
mBuilder.mErrorListenner.onChanged(Listenner.STATUS_ERROR,mBuilder.mSavePath,"directory create failed!");
return;
}
//获取文件长度
mBuilder.mFileAllLength = getNetFileSize();
//如果允许重复下载,则对文件进行重命名,修改后的文件名会会在 onStop onSuccess中体现
if(mBuilder.isAutoRename) {
autoChangeFileName(mBuilder.mFileAllLength);
}
RandomAccessFile file = new RandomAccessFile(mBuilder.mSavePath, "rw");
//如果本地已经存在该文件,并且大小和服务器相同则返回下载成功
if (file != null && file.length() == mBuilder.mFileAllLength && mBuilder.mFileAllLength != 0) {
mBuilder.mSuccessListenner.onChanged(Listenner.STATUS_SUCCESS, mBuilder.mSavePath,mBuilder.mFileAllLength + "");
return;
}
//设置文件起始指针
if (file != null && file.length() != 0) {
if (mBuilder.mStartOffset > 0 && mBuilder.mStartOffset < file.length()) {
file.seek(mBuilder.mStartOffset);
} else {
file.seek(file.length() - 1);
mBuilder.mStartOffset = file.length() - 1;
}
}
//设置请求参数
callRequest(mBuilder.mStartOffset);
if (mCall == null) {
mBuilder.mErrorListenner.onChanged(Listenner.STATUS_ERROR, mBuilder.mSavePath, "CONNECTION ERROR!");
return;
}
//建立连接
Response res = mCall.execute();
if (!res.isSuccessful()) {
mBuilder.mErrorListenner.onChanged(Listenner.STATUS_ERROR, mBuilder.mSavePath, "CONNECTION ERROR!");
return;
}
//更新文件长度
mBuilder.mLengthChangeListenner.onChanged(Listenner.STATUS_LENGTH_CHANGE, mBuilder.mFileAllLength + "", (mBuilder.mStartOffset + mDownloadLength) + "");
//开启进度刷新线程
mDaemonMsgThread.start();
//保存文件
boolean ret = saveData(res.body().byteStream(), new FileOutputStream(file.getFD()));
if (ret) {
mBuilder.mSuccessListenner.onChanged(Listenner.STATUS_SUCCESS, mBuilder.mSavePath,mBuilder.mFileAllLength + "");
} else {
mBuilder.mStopListenner.onChanged(Listenner.STATUS_STOP, mBuilder.mSavePath, mBuilder.mFileAllLength + "", (mBuilder.mStartOffset + mDownloadLength) + "");
}
mBuilder.mLengthChangeListenner.onChanged(Listenner.STATUS_LENGTH_CHANGE, mBuilder.mFileAllLength + "", (mBuilder.mStartOffset + mDownloadLength) + "");
}

/***
* 获取文件在服务器的长度,head请求
* @return
* @throws IOException
*/
private long getNetFileSize() throws IOException {
Request request = getRequestBuilder(0)
.head()
.build();
Call call = mClient.newCall(request);
if (call == null) {
mBuilder.mErrorListenner.onChanged(Listenner.STATUS_ERROR, mBuilder.mSavePath, "CONNECTION ERROR,Get File Size!");
return -1;
}

Response response = call.execute();
if (!response.isSuccessful()) {
mBuilder.mErrorListenner.onChanged(Listenner.STATUS_ERROR, mBuilder.mSavePath, "CONNECTION ERROR,Get File Size!");
return -1;
}

Headers headers = response.headers();
long fileSize = 0;
try {
fileSize = Long.parseLong(headers.get("Content-Length"));
} catch (Exception e) {
fileSize = -1;
}
return fileSize;
}

/***
* 执行请求
* @param offset 起始下载偏移量,该偏移量以当前已经下载的文件长度为准
*/
private void callRequest(long offset) {
Request request = getRequestBuilder(offset)
.build();
mCall = mClient.newCall(request);
}

/***
* 初始化请求参数
* @param offset 起始下载偏移量
* @return
*/
private Request.Builder getRequestBuilder(long offset) {
Headers.Builder builder = new Headers.Builder();
//header
if (mBuilder.mHeaders != null) {
for (String k : mBuilder.mHeaders.keySet()) {
builder.set(k, mBuilder.mHeaders.get(k));
}
}
if (builder.get("Range") == null) {
builder.set("Range", "bytes=" + offset + "-");
}
Headers headers = builder.build();
//urlparams url后面的参数
if (mBuilder.mUrlParams != null && !mBuilder.mUrlParams.isEmpty()) {
if (!mBuilder.mUrl.contains("?")) {
mBuilder.mUrl += "?";
}
for (String k : mBuilder.mUrlParams.keySet()) {
mBuilder.mUrl += k + "=" + mBuilder.mUrlParams.get(k);
mBuilder.mUrl += "&";
}
}
Request.Builder reBuilder = new Request.Builder()
.url(mBuilder.mUrl)
.headers(headers);
return reBuilder;
}

/***
* 保存文件
* @param is 源输入流
* @param os 目标输出流
* @return 如果是下载完成返回true,如果停止导致返回false
* @throws IOException
*/
private boolean saveData(InputStream is, OutputStream os) throws IOException {
Source source = Okio.source(is);
Sink sink = Okio.sink(os);
Buffer buf = new Buffer();
long len = 0;

while ((len = source.read(buf, MAX_BUFF_SIZE)) != -1 && !isExit) {
sink.write(buf, len);
mDownloadLength += len;
}

sink.flush();
sink.close();
source.close();
return !isExit;
}

/***
* 刷新当前下载进度
*/
private synchronized void changeSpeed() {
long endTime = System.currentTimeMillis();
mBuilder.mSpeedChangeListenner.onChanged(Listenner.STATUS_SPEED_CHANGE, mBuilder.mFileAllLength + "", (mBuilder.mStartOffset + mDownloadLength) + "",(endTime - mStartTime) + "", mDownloadLength + "");
}

/**
* 用于在一个新的线程中刷新下载进度,防止回调中有耗时操作阻塞下载线程影响下载速度
*/
private final class DaemonThead extends Thread {
//是否开启
private boolean isRunning = true;

@Override
public void run() {
while (isRunning) {
//防止下载完成以及其他状态回调时,进度还在刷新
synchronized (mBuilder) {
changeSpeed();
try {
Thread.sleep(mBuilder.mSpeedRefreshHZ);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}

/***
* Listtenner 的简单封装,可以简单的得到状态回调中的数值
*/
public static abstract class SimpleDownLoadListenner implements Listenner {

@Override
public void onChanged(int code, String... value) {
switch (code) {
case Listenner.STATUS_ERROR: {
onDownloadError(value[0], value[1]);
}
break;
case Listenner.STATUS_SUCCESS: {
onDownloadSuccessful(value[0],getLongValue(value[1]));
}
break;
case Listenner.STATUS_SPEED_CHANGE: {
onDownloadSpeedChanged(getLongValue(value[0]), getLongValue(value[1]), getLongValue(value[2]),getLongValue(value[3]));
}
break;
case Listenner.STATUS_STOP: {
onDownloadStoped(value[0], getLongValue(value[1]), getLongValue(value[2]));
}
break;
case Listenner.STATUS_LENGTH_CHANGE: {
onDownloadLengthChanged(getLongValue(value[0]), getLongValue(value[1]));
}
break;
}
}

private long getLongValue(String value) {
try {
return Long.parseLong(value);
} catch (Exception e) {
return 0;
}
}

public void onDownloadSuccessful(String path,long allFileLength) {

}

public void onDownloadStoped(String path, long allLength, long allDownloadlength) {

}

public void onDownloadError(String path, String msg) {

}

public void onDownloadLengthChanged(long allLength, long allDownloadLength) {

}

public synchronized void onDownloadSpeedChanged(long allLength,long allDownloadLenght , long times, long nowDownloadLength) {

}
}

/***
* BRDownloadThread以Builder模式创建,不允许new
*/
public static class Builder implements Listenner {
private Map<String, String> mUrlParams;        //url后的参数
private Map<String, String> mHeaders;          //请求头
private long mFileAllLength;                   //文件总长度
private long mStartOffset = 0;                 //起始下载偏移量
private String mUrl;                           //请求地址
private String mSavePath;                      //保存路径(全路径)
private String mBasePath;                      //保存文件夹名称
private String mSaveName;                      //文件名称
private Listenner mSuccessListenner;           //成功回调
private Listenner mErrorListenner;             //失败回调
private Listenner mLengthChangeListenner;      //文件长度变化回调(只在获取到服务器文件大小时回调,以及线程终止后回调(包括完成和停止))
private Listenner mSpeedChangeListenner;       //进度刷新 刷新频率为(1/mSpeedRefreshHZ)
private Listenner mStopListenner;              //停止回调,只在下载手动终止时回调
private long mSpeedRefreshHZ = 500;            //进度刷新间隔 毫秒
private boolean isAutoRename = false;          //是否支持文件重命名,如果本地已存在 false 不再重复下载 true 重命名后继续下载

public Builder setAutoRename(boolean auto) {
isAutoRename = auto;
return this;
}

/***
* 设置进度刷新间隔
* @param times 间隔时间 ms
* @return
*/
public Builder setDaemonRefreshDelayTime(long times) {
mSpeedRefreshHZ = times;
return this;
}

/***
* 设置保存的的全路径
* @param path
* @return
*/
public Builder setSavePath(String path) {
mSavePath = path;
return this;
}

/**
* 设置保存文件夹名称
* @param basePath 文件夹名称
* @return
*/
public Builder setBasePath(String basePath) {
mBasePath = basePath;
return this;
}

/***
* 保存文件名
* @param name 文件名
* @return
*/
public Builder setSaveName(String name) {
mSaveName = name;
return this;
}

/***
* 请求地址
* @param url
*/
public Builder(String url) {
mUrl = url;
}

public Builder() {

}

/***
* 设置状态监听回调
* @param l
* @return
*/
public Builder setListenners(Listenner l) {
mSuccessListenner = l;
mErrorListenner = l;
mLengthChangeListenner = l;
mSpeedChangeListenner = l;
mStopListenner = l;
return this;
}

/***
* 成功监听
* @param l
* @return
*/
public Builder setSuccessListenner(Listenner l) {
mSuccessListenner = l;
return this;
}

/***
* 失败监听
* @param l
* @return
*/
public Builder setErrorListenner(Listenner l) {
mErrorListenner = l;
return this;
}

public Builder setStopListenner(Listenner l) {
mStopListenner = l;
return this;
}

/***
* 长度变化监听
* @param l
* @return
*/
public Builder setLengthChangeListenner(Listenner l) {
mLengthChangeListenner = l;
return this;
}

/***
* 进度刷新监听
* @param l
* @return
*/
public Builder setOnSpeedListenner(Listenner l) {
mSpeedChangeListenner = l;
return this;
}

/***
* 设置起始下载偏移量和文件长度
* @param offset 偏移量 首次下载为 0,该值只作为参考实际已文件长度为准
* @param fileAllLength 文件长度,可有可无
* @return
*/
public Builder setOffset(long offset, long fileAllLength) {
mStartOffset = offset;
mFileAllLength = fileAllLength;
return this;
}

public Builder setUrl(String url) {
mUrl = url;
return this;
}

/***
* 请求头(如果header头中包含Range 则会替换默认的Range属性,建议不要包含)
* @param headers
* @return
*/
public Builder setHeaders(Map<String, String> headers) {
mHeaders = headers;
return this;
}

/***
* 请求头
* @param headers
* @return
*/
public synchronized Builder addHeaders(Map<String, String> headers) {
if (mHeaders == null) {
mHeaders = headers;
} else {
mHeaders.putAll(headers);
}
return this;
}

/***
* 请求头
* @param k
* @param v
* @return
*/
public synchronized Builder addHeader(String k, String v) {
if (mHeaders == null) {
mHeaders = new HashMap<>();
}
return this;
}

/***
* 如果url后面包含参数,可以使用该方法为url添加参数
* @param params
* @return
*/
public synchronized Builder setUrlParams(Map<String, String> params) {
mUrlParams = params;
return this;
}

/***
* url参数
* @param params
* @return
*/
public synchronized Builder addUrlParams(Map<String, String> params) {
if (mUrlParams == null) {
mUrlParams = params;
} else {
mUrlParams.putAll(mUrlParams);
}
return this;
}

/**
* url 参数
* @param k
* @param v
* @return
*/
public synchronized Builder addUrlParams(String k, String v) {
if (mUrlParams == null) {
mUrlParams = new HashMap<>();
}
mUrlParams.put(k, v);
return this;
}

public BRDownloadThread build() throws RuntimeException {

if (mErrorListenner == null) {
mErrorListenner = this;
}

if (mSpeedChangeListenner == null) {
mSpeedChangeListenner = this;
}

if (mSuccessListenner == null) {
mSuccessListenner = this;
}

if (mStopListenner == null) {
mStopListenner = this;
}

if (mLengthChangeListenner == null) {
mLengthChangeListenner = this;
}

//文件保存路径错误
if (TextUtils.isEmpty(mSavePath) && (TextUtils.isEmpty(mBasePath)
|| TextUtils.isEmpty(mSaveName))) {
throw new RuntimeException("can not build BRDownloadthread,because savepath or (saveBasePasth and saveName is null)!");
}

//起始下载偏移量大于文件长度
if (mStartOffset > mFileAllLength) {
throw new RuntimeException("can not continue to download form startOffset,Because file length is null!");
}

if (TextUtils.isEmpty(mSavePath) && !TextUtils.isEmpty(mBasePath) && !TextUtils.isEmpty(mSaveName)) {
mSavePath = mBasePath + File.separator + mSaveName;
}

BRDownloadThread thread = new BRDownloadThread();
thread.mBuilder = this;
return thread;
}

@Override
public void onChanged(int code, String... value) {

}
}
}

mDownloadThread = new BRDownloadThread.Builder(downloadPath)
.setSavePath(savePasth)
.setOffset(0,0)
.setListenners(new BRDownloadThread.SimpleDownLoadListenner() {
@Override
public void onChanged(int code, String... value) {
switch (code) {
case Listenner.STATUS_ERROR: {
LogUtil.i("ERROR == > " + getString(value));
}break;
case Listenner.STATUS_LENGTH_CHANGE: {
LogUtil.i("LENGTH == >" + getString(value));
}break;
case Listenner.STATUS_SPEED_CHANGE: {
LogUtil.i("SPEED == >" + getString(value));
}break;
case Listenner.STATUS_STOP: {
LogUtil.i("STOP == >" + getString(value));
}break;
case Listenner.STATUS_SUCCESS: {
LogUtil.i("SUCCESSFUL == >" + getString(value));
}break;
}
}
})
.build();
mDownloadThread.start();