想起来之前做视频缓存的工具类,没事记一下,中间用了一个开源的缓存的进度库,其他的都是自己写的
其中网络请求时用的OkHttp3
缓存进度库用的是:
compile 'io.github.lizhangqu:coreprogress:1.0.2'封装的工具类:DownloadUtil.java
import android.text.TextUtils;
import android.util.Log;
import com.hkzr.docopad.minterface.OnDownloadListener;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import io.github.lizhangqu.coreprogress.ProgressHelper;
import io.github.lizhangqu.coreprogress.ProgressUIListener;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.ResponseBody;
/**
* 创 建: lt
* 作 用: 断点下载的类
* 使用方法:
* 注意事项:
*/
public class DownloadUtil {
private Call call;
private static DownloadUtil downloadUtil;
private OkHttpClient okHttpClient;
private List<Object[]> list;//call,url,startBytes,path,OnDownloadListener
private OnDownloadListener onDownloadListener;
private final static int ADD = 0;
private final static int CANCEL = 1;
private final static int SET = 2;
private DownloadUtil() {
okHttpClient = new OkHttpClient.Builder()
.connectTimeout(30, TimeUnit.SECONDS)//设置超时时间之类的
.readTimeout(30, TimeUnit.SECONDS)
.writeTimeout(30, TimeUnit.SECONDS).build();
list = new ArrayList<>();
}
/**
* 单例初始化
*/
public static DownloadUtil init() {
if (downloadUtil == null) {
synchronized (DownloadUtil.class) {
if (downloadUtil == null) {
downloadUtil = new DownloadUtil();
}
}
}
return downloadUtil;
}
/**
* 添加下载请求
*
* @param startBytes 从第几个字节开始
* @param path 保存的路径
* @param url 下载链接
* @param onDownloadListener 回调
*/
public void addDownload(long startBytes, String path, String url, OnDownloadListener onDownloadListener) {
//添加Range头
//传入链接
Call call = okHttpClient.newCall(new Request.Builder().addHeader("RANGE", "bytes=" + startBytes + "-").url(url).get().build());
list.add(new Object[]{call, url, startBytes, path, onDownloadListener});
loop(ADD);
}
/**
* 下载请求
*
* @param startBytes 从第几个字节开始
* @param path 保存的路径
*/
private void download(final long startBytes, final String path) {
Log.i("lllttt", "DownloadUtil : " + startBytes);
//回调
try {
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
//失败了
if (onDownloadListener != null) {
onDownloadListener.onFailure(e);
}
}
@Override
public void onResponse(Call call, Response response) {
ResponseBody body = response.body();
ResponseBody responseBody = ProgressHelper.withProgress(body, new ProgressUIListener() {
@Override
public void onUIProgressChanged(long numBytes, long totalBytes, float percent, float speed) {
if (onDownloadListener != null) {
onDownloadListener.onProgress(numBytes, totalBytes, percent, speed);
}
}
@Override
public void onUIProgressStart(long totalBytes) {
if (onDownloadListener != null) {
onDownloadListener.onStart(totalBytes);
}
}
@Override
public void onUIProgressFinish() {
if (onDownloadListener != null) {
onDownloadListener.onFinish();
}
try {
list.remove(0);
} catch (Exception e) {
e.printStackTrace();
}
DownloadUtil.this.call = null;
onDownloadListener = null;
loop(ADD);
}
});
save(responseBody, startBytes, path);
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
private void save(ResponseBody body, long startsPoint, String path) {
InputStream in = body.byteStream();
FileChannel channelOut = null;
// 随机访问文件，可以指定断点续传的起始位置
RandomAccessFile randomAccessFile = null;
try {
randomAccessFile = new RandomAccessFile(path, "rwd");
//Chanel NIO中的用法，由于RandomAccessFile没有使用缓存策略，直接使用会使得下载速度变慢，亲测缓存下载3.3秒的文件，用普通的RandomAccessFile需要20多秒。
channelOut = randomAccessFile.getChannel();
randomAccessFile.seek(startsPoint);
// 内存映射，直接使用RandomAccessFile，是用其seek方法指定下载的起始位置，使用缓存下载，在这里指定下载位置。
MappedByteBuffer mappedBuffer = channelOut.map(FileChannel.MapMode.READ_WRITE, startsPoint, body.contentLength());
byte[] buffer = new byte[1024];
int len = 0;
while ((len = in.read(buffer)) != -1) {
mappedBuffer.put(buffer, 0, len);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
in.close();
if (channelOut != null) {
channelOut.close();
}
if (randomAccessFile != null) {
randomAccessFile.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 停止下载(暂停)
*
* @param url 下载路径
*/
public void cancelDownload(String url) {
loop(CANCEL, url);
}
/**
* 停止所有
*/
public void cancelAllDownload() {
if (list != null)
list.clear();
if (call != null)
call.cancel();
call = null;
if (onDownloadListener != null)
onDownloadListener.onFailure(null);
this.onDownloadListener = null;
}
/**
* 开始某个下载任务
*
* @param url 链接
*/
public void startDownLoad(long startBytes, String path, String url, OnDownloadListener onDownloadListener) {
if (startBytes < 0) //todo
startBytes = 0;
//查询有没有这个下载链接,有就让他挪到第一位,没有就添加到第一位
if (list != null && list.size() == 1 && !isHave(url)) {
//如果只有几个暂停的,并开启了一个暂停的,并把第二个暂停的打开
//应该把那个下载中的放为等待中,这个为开始下载
Object[] objects = list.get(0);
this.call.cancel();
this.call = null;
this.onDownloadListener = null;
Call call = okHttpClient.newCall(new Request.Builder().addHeader("RANGE", "bytes=" + startBytes + "-").url(url).get().build());
list.add(0, new Object[]{call, url, startBytes, path, onDownloadListener});
loop(ADD);
}
if (isHave(url)) {
//挪到第一位
Object[] objs = null;
for (Object[] objects : list) {
if (objects[1].equals(url)) {
objs = objects;
break;
}
}
if (list == null || list.size() <= 1) {
loop(ADD);
} else {
list.remove(objs);
list.add(1, objs);
loop(CANCEL, String.valueOf(list.get(0)[1]));
}
} else {
//添加到第一位
Call c = okHttpClient.newCall(new Request.Builder().addHeader("RANGE", "bytes=" + startBytes + "-").url(url).get().build());
list.add(0, new Object[]{c, url, startBytes, path, onDownloadListener});
if (call != null)
this.call.cancel();
this.call = null;
loop(ADD);
}
}
/**
* 判断这个任务是否在运行
*
* @param url 链接
*/
public boolean isRun(String url) {
if (list == null || list.size() == 0) {
return false;
}
return list.get(0)[1].equals(url);
}
/**
* 判断这个任务是否存在
*
* @param url 链接
*/
public boolean isHave(String url) {
if (list == null || list.size() == 0) {
return false;
}
for (Object[] obj : list) {
if (TextUtils.equals((String) obj[1], url))
return true;
}
return false;
}
/**
* 判断是否还有任务
*/
public boolean isHave() {
if (list == null)
return false;
return !(list.size() == 0);
}
/**
* 给没有回调的下载请求设置回调
*
* @param url 视频下载链接
* @param onDownloadListener 下载回调
*/
public void setListener(String url, OnDownloadListener onDownloadListener) {
loop(SET, url, onDownloadListener);
}
private void loop(int i) {
loop(i, null);
}
private void loop(int i, String url) {
loop(i, url, null);
}
/**
* 轮询
*/
private void loop(int i, String url, OnDownloadListener onDownloadListener) {
if (list == null || list.size() == 0)
return;
switch (i) {
case ADD:
if (call != null)
return;
Object[] objects = list.get(0);
this.call = (Call) objects[0];
this.onDownloadListener = (OnDownloadListener) objects[4];
download((long) objects[2], (String) objects[3]);
break;
case CANCEL:
for (int j = 0; j < list.size(); j++) {
Object[] objs = list.get(j);
if (objs[1].equals(url)) {
//如果url一样
((Call) objs[0]).cancel();
list.remove(objs);
if (j == 0) {
call = null;
this.onDownloadListener = null;
loop(ADD);
}
}
}
break;
case SET:
for (int j = 0; j < list.size(); j++) {
if (list.get(j)[1].equals(url)) {
//如果url一样
list.get(j)[4] = onDownloadListener;
if (j == 0)
this.onDownloadListener = onDownloadListener;
}
}
break;
}
}
}回调:OnDownloadListener.java
/**
* 创 建: lt
* 作 用: 下载的回调
* 使用方法:
* 注意事项:
*/
public interface OnDownloadListener {
/**
* 下载失败
*/
void onFailure(Exception e);
/**
* 下载开始
*
* @param totalBytes 一共多少字节
*/
void onStart(long totalBytes);
/**
* 下载完成
*/
void onFinish();
/**
* 下载中(不是第一次的话,会使总字节数发生变化,所以要在第一次下载的时候保存总字节数,然后自己计算百分比)
*
* @param numBytes 已经下载了多少字节
* @param totalBytes 总字节
* @param percent 万分比(乘以100为百分比)
* @param speed 下载速度(* 1000 / 1024 / 1024 =M/s?)
*/
void onProgress(long numBytes, long totalBytes, float percent, float speed);
}下载用的服务:VideoCacheService.java
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import com.hkzr.docopad.app.App;
import com.hkzr.docopad.greendao.VideoCacheInfoDao;
import com.hkzr.docopad.minterface.OnDownloadListener;
import com.hkzr.docopad.model.VideoCacheInfo;
import com.hkzr.docopad.utils.DownloadUtil;
import com.hkzr.docopad.utils.NetUtil;
import com.hkzr.docopad.utils.SDCardUtil;
import com.hkzr.docopad.utils.ToastUtil;
import java.util.ArrayList;
import java.util.List;
public class VideoCacheService extends Service {
private DownloadUtil init;
private boolean isCheck = false;//是否在检查网络和存储空间中
public VideoCacheService() {
}
@Override
public IBinder onBind(Intent intent) {
return new BindVideoCache();
}
@Override
public void onCreate() {
super.onCreate();
init = DownloadUtil.init();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
super.onDestroy();
}
public void oneLoad(String videoName, long videoSize, String videoUrl,
int lookProgress, String videoId, long videoDuration
, String videoImg, String savePath) {
//如果sd卡可用,并且大于视频大小就可以走
//如果内部存储大于视频大小就可以走
if (!(SDCardUtil.isSDCardEnabled() && SDCardUtil.getSDCardAllSize() > videoSize || SDCardUtil.getAvailableInternalMemorySize() > videoSize)) {
ToastUtil.showToast("磁盘已满,请清理足够的存储空间");
return;
}
VideoCacheInfo videoCacheInfo = new VideoCacheInfo(null,//id
videoName,//视频名称
videoSize,//视频大小
videoUrl,//视频路径
0,//下载的百分比进度
lookProgress,//播放的百分比进度
videoId,//视频的id
videoDuration,//视频持续时长,毫秒单位?
videoImg,//视频预览图片
savePath,//保存路径
0,//下载字节数
VideoCacheInfo.STAUS_NO_START);//状态,未开始
App.ormDao.getVideoCacheInfoDao().insert(videoCacheInfo);
load(0, savePath, videoUrl, null);
}
public void load(final long startBytes, String path, final String url, final OnDownloadListener onDownloadListener) {
//如果磁盘满了或者无网络,则无需添加到队列中
if (!NetUtil.isNetworkAvailable(getApplicationContext())) {
ToastUtil.showToast("当前无网络,请检查网络链接后重试");
if (onDownloadListener != null)
onDownloadListener.onFailure(null);
return;
}
init.addDownload(startBytes, path, url, onDownloadListener);
if (!isCheck) {
isCheck = true;
handler.sendEmptyMessage(0);
}
}
public void cancel(String url) {
init.cancelDownload(url);
for (VideoCacheInfo info : App.ormDao.getVideoCacheInfoDao().queryBuilder().where(VideoCacheInfoDao.Properties.VideoUrl.eq(url)).list()) {
info.setStatus(VideoCacheInfo.STATUS_PAUSED);
App.ormDao.getVideoCacheInfoDao().update(info);
}
}
public void cancelAll() {
init.cancelAllDownload();
for (VideoCacheInfo info : App.ormDao.loadAll(VideoCacheInfo.class)) {
if (info.getStatus() != VideoCacheInfo.STATUS_FINISH && info.getStatus() != VideoCacheInfo.STATUS_PAUSED) {
info.setStatus(VideoCacheInfo.STAUS_NO_START);
App.ormDao.getVideoCacheInfoDao().update(info);
}
}
}
public boolean isHave(String url) {
return init.isHave(url);
}
public void setListener(String url, OnDownloadListener onDownloadListener) {
if (!NetUtil.isNetworkAvailable(getApplicationContext())) {
ToastUtil.showToast("当前无网络,请检查网络链接后重试");
if (onDownloadListener != null)
onDownloadListener.onFailure(null);
return;
}
init.setListener(url, onDownloadListener);
}
public void startDownLoad(long startBytes, String path, String url, OnDownloadListener onDownloadListener) {
if (!NetUtil.isNetworkAvailable(getApplicationContext())) {
ToastUtil.showToast("当前无网络,请检查网络链接后重试");
if (onDownloadListener != null)
onDownloadListener.onFailure(null);
return;
}
for (VideoCacheInfo info : App.ormDao.getVideoCacheInfoDao().queryBuilder().where(VideoCacheInfoDao.Properties.VideoUrl.eq(url)).list()) {
info.setStatus(VideoCacheInfo.STATUS_STARTED);
App.ormDao.getVideoCacheInfoDao().update(info);
}
init.startDownLoad(startBytes, path, url, onDownloadListener);
if (!isCheck) {
isCheck = true;
handler.sendEmptyMessage(0);
}
}
public void startAll() {
List<VideoCacheInfo> videoCacheInfos = App.ormDao.getVideoCacheInfoDao().loadAll();
if (videoCacheInfos == null || videoCacheInfos.size() == 0)
return;
List<VideoCacheInfo> list = new ArrayList<>();
for (VideoCacheInfo info : videoCacheInfos) {
if ((info.getStatus() == VideoCacheInfo.STAUS_NO_START || info.getStatus() == VideoCacheInfo.STATUS_STARTED) && !isHave(info.getVideoUrl())) {
//表示需要下载,并且没在队列中
list.add(info);
}
}
if (list.size() == 0)
return;
for (VideoCacheInfo info : list) {
load(info.getDownloadSpeed(), info.getLocalPath(), info.getVideoUrl(), null);
}
}
Handler handler = new Handler(Looper.getMainLooper()) {
@Override
public void handleMessage(Message msg) {
if (!init.isHave()) {
//如果没有任务了就不检查了
isCheck = false;
return;
}
//还有任务就检查网络和内部存储
if (!NetUtil.isNetworkAvailable(getApplicationContext())) {
//没有网络就提醒,并暂停所有任务
init.cancelAllDownload();
ToastUtil.showToast("当前无网络,已暂停缓存任务");
isCheck=false;
return;
}
if ((SDCardUtil.isSDCardEnabled() && SDCardUtil.getSDCardAllSize() < 60 * 1024)
|| SDCardUtil.getAvailableInternalMemorySize() < 60 * 1024 * 1024) {
init.cancelAllDownload();
ToastUtil.showToast("存储空间不足,已暂停缓存任务");
isCheck=false;
return;
}
handler.sendEmptyMessageDelayed(0, 6000);
}
};
public boolean isRun(String url) {
return init.isRun(url);
}
public class BindVideoCache extends Binder {
/**
* 第一次添加下载请求
*
* @param videoName 视频名称
* @param videoSize 视频大小
* @param videoUrl 视频路径
* @param lookProgress 播放的百分比进度
* @param videoId 视频的id
* @param videoDuration 视频持续时长,毫秒单位?
* @param videoImg 视频预览图片
* @param savePath 保存路径
*/
public void mOneLoad(String videoName, long videoSize, String videoUrl,
int lookProgress, String videoId, long videoDuration
, String videoImg, String savePath) {//ps:其实这个方法根据设计模式原则应该是直接传一个对象的,懒得改了
oneLoad(videoName, videoSize, videoUrl,
lookProgress, videoId, videoDuration
, videoImg, savePath);
}
/**
* 开始下载(非第一次下载)
*
* @param startBytes 从第几个字节开始
* @param path 保存的路径
* @param url 下载链接
* @param onDownloadListener 回调
*/
public void mLoad(long startBytes, String path, String url, OnDownloadListener onDownloadListener) {
load(startBytes, path, url, onDownloadListener);
}
/**
* 停止下载(暂停)
*
* @param url 下载路径
*/
public void mCancel(String url) {
cancel(url);
}
/**
* 停止所有
*/
public void mCancelAll() {
cancelAll();
}
/**
* 判断缓存队列中是否存在该任务
*
* @param url 任务链接
* @return 是否存在
*/
public boolean mIsHave(String url) {
return isHave(url);
}
/**
* 设置回调
*
* @param url 视频链接
* @param onDownloadListener 下载回调
*/
public void mSetListener(String url, OnDownloadListener onDownloadListener) {
setListener(url, onDownloadListener);
}
/**
* 开始下载(暂停或停止后)
*
* @param startBytes 从第几个字节开始
* @param path 保存的路径
* @param url 下载链接
* @param onDownloadListener 回调
*/
public void mStartDownLoad(long startBytes, String path, String url, OnDownloadListener onDownloadListener) {
startDownLoad(startBytes, path, url, onDownloadListener);
}
/**
* 判断是否正在下载
*
* @param url 视频链接
*/
public boolean mIsRun(String url) {
return isRun(url);
}
/**
* 是否在缓存中或缓存过
*
* @param vid 视频id
*/
public boolean isVideoCacheOrCacheing(String vid) {
List<VideoCacheInfo> list = App.ormDao.getVideoCacheInfoDao().queryBuilder().where(VideoCacheInfoDao.Properties.VideoId.eq(vid)).list();
if (list != null && list.size() > 0) {
//表示缓存过了或在缓存队列中
return true;
}
return false;
}
/**
* 加载并开始所有等待中和缓存中的任务,无监听
* 如果已被加载,则不理会
*/
public void mStartAll() {
startAll();
}
}
}附加一个缓存时使用的Bean类,使用了GreenDao来保存下载的进度和本地磁盘位置等信息:VideoCacheInfo.java
import org.greenrobot.greendao.annotation.Entity;
import org.greenrobot.greendao.annotation.Generated;
import org.greenrobot.greendao.annotation.Id;
import org.greenrobot.greendao.annotation.Keep;
import org.greenrobot.greendao.annotation.Transient;
import java.io.Serializable;
/**
* 作 用: 缓存视频的bean类
*/
@Entity
public class VideoCacheInfo implements Serializable {
/**
* 0: 未开始, 正等待
* 1: 已经开始
* 2： 已停止,未完成
* 3: 已暂停
* 4: 已完成
*/
@Transient
public static final int STAUS_NO_START = 0;
@Transient
public static final int STATUS_STARTED = 1;
@Transient
public static final int STATUS_STOPED = 2;
@Transient
public static final int STATUS_PAUSED = 3;
@Transient
public static final int STATUS_FINISH = 4;
@Id(autoincrement = true)
private Long id;
@Transient
private HistoryBean history;
private String videoName;//视频名称
private long videoSize;//视频大小
private String videoUrl;//视频链接
private int downProgress;//下载进度
private int lookProgress = -1;//观看进度
private String videoId;//服务器id
private long videoDuration;//视频持续时间
private String videoIcon;//图片静态图片
private String localPath;//本地存放路径
private long downloadSpeed = 0;//下载字节数
private int status = STAUS_NO_START;//状态
@Transient
private boolean isCheck;
@Generated(hash = 1303373854)
public VideoCacheInfo(Long id, String videoName, long videoSize,
String videoUrl, int downProgress, int lookProgress, String videoId,
long videoDuration, String videoIcon, String localPath,
long downloadSpeed, int status) {
this.id = id;
this.videoName = videoName;
this.videoSize = videoSize;
this.videoUrl = videoUrl;
this.downProgress = downProgress;
this.lookProgress = lookProgress;
this.videoId = videoId;
this.videoDuration = videoDuration;
this.videoIcon = videoIcon;
this.localPath = localPath;
this.downloadSpeed = downloadSpeed;
this.status = status;
}
@Generated(hash = 843470261)
public VideoCacheInfo() {
}
public int getLookProgress() {
return lookProgress;
}
public void setLookProgress(int lookProgress) {
this.lookProgress = lookProgress;
}
public boolean isCheck() {
return isCheck;
}
public void setCheck(boolean check) {
isCheck = check;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getVideoName() {
return videoName;
}
public void setVideoName(String videoName) {
this.videoName = videoName;
}
public long getVideoSize() {
return videoSize;
}
public void setVideoSize(long videoSize) {
this.videoSize = videoSize;
}
public String getVideoUrl() {
return videoUrl;
}
public void setVideoUrl(String videoUrl) {
this.videoUrl = videoUrl;
}
public int getDownProgress() {
return downProgress;
}
public void setDownProgress(int downProgress) {
this.downProgress = downProgress;
}
public String getVideoId() {
return videoId;
}
public void setVideoId(String videoId) {
this.videoId = videoId;
}
public long getVideoDuration() {
return videoDuration;
}
public void setVideoDuration(long videoDuration) {
this.videoDuration = videoDuration;
}
public String getVideoIcon() {
return videoIcon;
}
public void setVideoIcon(String videoIcon) {
this.videoIcon = videoIcon;
}
public long getDownloadSpeed() {
return downloadSpeed;
}
public void setDownloadSpeed(long downloadSpeed) {
this.downloadSpeed = downloadSpeed;
}
@Keep
public HistoryBean getHistory() {
return history;
}
@Keep
public void setHistory(HistoryBean history) {
this.history = history;
}
public String getLocalPath() {
return localPath;
}
public void setLocalPath(String localPath) {
this.localPath = localPath;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
@Override
public String toString() {
return "VideoCacheInfo{" +
"id=" + id +
", history=" + history +
", videoName='" + videoName + '\'' +
", videoSize='" + videoSize + '\'' +
", videoUrl='" + videoUrl + '\'' +
", downProgress=" + downProgress +
", videoId='" + videoId + '\'' +
", videoDuration=" + videoDuration +
", videoIcon='" + videoIcon + '\'' +
", localPath='" + localPath + '\'' +
", downloadSpeed=" + downloadSpeed +
", status=" + status +
'}';
}
}有帮助或者有问题可以留言
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
