android 视频断点下载,android——文件断点续传下载(二)

GIF.gif

上篇博客写的是单个文件单个线程的断点续传下载(文件断点续传下载(一))，这里是在之前的基础上进行了扩展，变成了多文件，多线程同时下载/暂停，同时添加了通知栏下载状态显示，虽然代码是基于之前的，还是做了不少改动。

1、activity中显示的是一个列表，点击事件的触发是在列表的条目中，就需要在点击开始时，将点击事件通过接口回调到activity中，进行权限的申请

2、当多任务、多线程同时操作时，利用BroadcastReceiver进行通信会导致界面不有点卡，就改用了Messenger+Handler进行通信

3、需要对Notification做8.0的适配

4、利用TimerTask、Timer进行消息的轮询

5、改用线程池对线程的管理

先看下列表适配器中的逻辑，很简单，

public class FileListAdapter extends BaseAdapter {

private Context mContext;

private List list;

public FileListAdapter(Context context, List list) {

this.mContext = context;

this.list = list;

}

@Override

public int getCount() {

return list == null ? 0 : list.size();

}

@Override

public Object getItem(int position) {

return list.get(position);

}

@Override

public long getItemId(int position) {

return position;

}

@Override

public View getView(final int position, View convertView, ViewGroup parent) {

ViewHolder viewHolder;

final FileInfo fileInfo = list.get(position);

if (convertView == null) {

viewHolder = new ViewHolder();

convertView = LayoutInflater.from(mContext).inflate(R.layout.file_list_adapter_item, parent, false);

viewHolder.tvFileName = convertView.findViewById(R.id.tv_file_name);

viewHolder.progressBar = convertView.findViewById(R.id.progress_bar);

viewHolder.btnStop = convertView.findViewById(R.id.btn_stop);

viewHolder.btnStart = convertView.findViewById(R.id.btn_start);

viewHolder.progressBar.setMax(100);

viewHolder.tvFileName.setText(fileInfo.fileName);

viewHolder.btnStart.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View v) {

if (listener != null) {

listener.doStart(position, fileInfo);

}

}

});

viewHolder.btnStop.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View v) {

if (listener != null) {

listener.doStop(position, fileInfo);

}

}

});

convertView.setTag(viewHolder);

} else {

viewHolder = (ViewHolder) convertView.getTag();

}

viewHolder.progressBar.setProgress(fileInfo.finished);

return convertView;

}

/**

* 更新列表项中条目下载进度

*/

public void updateProgress(List fileInfos) {

this.list = fileInfos;

notifyDataSetChanged();

}

class ViewHolder {

TextView tvFileName;

ProgressBarView progressBar;

Button btnStop, btnStart;

}

private onItemClick listener;

public void setOnItemClick(onItemClick listener) {

this.listener = listener;

}

public interface onItemClick {

/**

* 开始下载

*

* @param position

*/

void doStart(int position, FileInfo fileInfo);

/**

* 暂停下载

*

* @param position

*/

void doStop(int position, FileInfo fileInfo);

}

}

不过有点细节需要注意的，赋值一次后不需要变动的数据，就不需要数据复用了，这样会提高一些性能，这里文件名称的赋值、ProgressBar的初始化、开始/暂停的点击事件就没有进行复用，然后在回调事件中去做权限的申请、开启下载/暂停下载的逻辑处理。

之前是通过startService的方式开启一个Service的，这里没有采用该方式，用的是绑定服务的方式，在onCreate()方法中绑定一个Service；

//绑定service

Intent intent = new Intent(this, DownLoadService.class);

bindService(intent, serviceConnection, Service.BIND_AUTO_CREATE);

Service绑定后，就会回调ServiceConnection中的onServiceConnected()方法，在该方法中利用Messenger同时在Service的onBind()方法中也利用Messenger进行activity和Service数据通信双向绑定；

ServiceConnection serviceConnection = new ServiceConnection() {

@Override

public void onServiceConnected(ComponentName name, IBinder service) {

//绑定回调

//获得service中的Messenger

mServiceMessenger = new Messenger(service);

//创建activity中的Messenger

Messenger messenger = new Messenger(mHandler);

//创建一个消息

Message message = new Message();

message.what = DownLoadService.MSG_BIND;

message.replyTo = messenger;

//使用service的messenger发送activity中的Messenger

try {

mServiceMessenger.send(message);

} catch (RemoteException e) {

e.printStackTrace();

}

}

@Override

public void onServiceDisconnected(ComponentName name) {

//解绑回调

}

};

@Override

public IBinder onBind(Intent intent) {

//创建一个Messenger对象

Messenger messenger = new Messenger(mHandler);

//返回Messenger的binder

return messenger.getBinder();

}

Handler mHandler = new Handler() {

@Override

public void handleMessage(Message msg) {

super.handleMessage(msg);

switch (msg.what) {

case MSG_INIT:

mSGINIT(msg);

break;

case MSG_BIND:

//处理绑定的Messenger

mActivityMessenger = msg.replyTo;

break;

case MSG_START:

mSGSTART(msg);

break;

case MSG_STOP:

mSGSTOP(msg);

break;

}

}

};

实现了activity和service的通信绑定，在点击开始或者暂停时就可以Messenger给service发送消息了；

private void doStart(FileInfo fileInfo) {

//将开始下载的文件id存储在集合中

if (fileIds.contains(fileInfo.id)) {

//正在下载提示用户 并返回

Toast.makeText(this, "该文件正在下载中...", Toast.LENGTH_LONG).show();

return;

}

//将文件id添加到集合中

fileIds.add(fileInfo.id);

Message message = new Message();

message.what = DownLoadService.MSG_START;

message.obj = fileInfo;

try {

mServiceMessenger.send(message);

} catch (RemoteException e) {

e.printStackTrace();

}

Log.e("doStart-->", "doStart");

}

private void doStop(FileInfo fileInfo) {

//暂停下载时将存储的下载文件id移除

for (int i = 0; i < fileIds.size(); i++) {

Integer integer = fileIds.get(i);

if (integer == fileInfo.id) {

fileIds.remove(integer);

break;

}

}

Log.e("doStop-->", "doStop");

Message message = new Message();

message.what = DownLoadService.MSG_STOP;

message.obj = fileInfo;

try {

mServiceMessenger.send(message);

} catch (RemoteException e) {

e.printStackTrace();

}

}

在开始下载时需要将下载文件的id缓存的集合中，用于管理用户多次点击同一个正在下载的文件，在暂停下载或下载完成后在从集合中移除对应的文件id，消息发送后，在Service中Handler的handerMessage()方法中根据msg.whate进行处理。

开始下载时还是和之前一样，在子线程中获取文件的大小，在本地创建文件夹，然后通过handler通知进行下载，只是改成了利用线程池进行线程的管理；

/**

* 开始下载

*

* @param msg

*/

private void mSGSTART(Message msg) {

FileInfo fileInfo = (FileInfo) msg.obj;

Log.e(TAG, ACTION_START);

//开启线程

InitThread thread = new InitThread(fileInfo);

DownLoadTask.sExecutorService.execute(thread);

}

在下载的时候需要对多线程、多任务进行管理，同时开始时通过消息告诉activity去开启消息通知栏，显示下载进度；

/**

* 初始化处理

*

* @param msg

*/

private void mSGINIT(Message msg) {

FileInfo fileInfo = (FileInfo) msg.obj;

Log.e(TAG, MSG_INIT + "");

//启动下载任务

DownLoadTask task = new DownLoadTask(DownLoadService.this, fileInfo, 1, mActivityMessenger);

task.downLoad();

//把下载任务添加到集合中

mTasks.put(fileInfo.id, task);

//给Activity发送消息

Message message = new Message();

message.what = MSG_START;

message.obj = fileInfo;

try {

mActivityMessenger.send(message);

} catch (RemoteException e) {

e.printStackTrace();

}

}

在activity的handler中就可以通知开启通知状态栏，

/**

* 开始下载通知通知栏

*

* @param msg

*/

private void mSGSTART(Message msg) {

//显示一个通知

FileInfo info = (FileInfo) msg.obj;

if (info != null) {

mNotificationUtil.showNotification(info);

}

}

/**

* 通知的工具类

*/

public class NotificationUtil {

//实例化Notification通知管理类

private NotificationManager mNotificationManager;

//管理Notification的集合

private Map mNotification;

private Context mContext;

public NotificationUtil(Context context) {

mContext = context;

mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);

mNotification = new HashMap<>();

}

/**

* 显示notification

*/

public void showNotification(FileInfo fileInfo) {

//是否存在该文件下载通知

if (!mNotification.containsKey(fileInfo.id)) {

//android8.0 notification适配

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

NotificationChannel channel = new NotificationChannel("channel_id", "channel_name", NotificationManager.IMPORTANCE_DEFAULT);

channel.canBypassDnd();//可否绕过请勿打扰模式

channel.enableLights(true);//有新消息时手机有闪光

channel.setLockscreenVisibility(Notification.VISIBILITY_SECRET);//锁屏显示通知

channel.setLightColor(Color.argb(100, 100, 100, 100));//指定闪光时的灯光颜色

channel.canShowBadge();//有新消息时桌面角标显示

channel.enableVibration(true);//振动

AudioAttributes audioAttributes = channel.getAudioAttributes();//获取系统响铃

channel.getGroup();//获取通知渠道组

channel.setBypassDnd(true);//设置可以绕过请勿打扰模式

channel.setVibrationPattern(new long[]{100, 100, 200});//振动模式

channel.shouldShowLights();//是否会闪灯

mNotificationManager.createNotificationChannel(channel);

}

//不存在就新增

//创建通知的对象

Notification.Builder notification;

if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {

//android8.0 notification适配

notification = new Notification.Builder(mContext)

.setChannelId("channel_id");

} else {

notification = new Notification.Builder(mContext);

}

//设置滚动文字

notification.setTicker(fileInfo.fileName + "开始下载")

.setWhen(System.currentTimeMillis())//设置通知显示的时间

.setSmallIcon(R.mipmap.ic_launcher_round)//设置图标

.setContentTitle(fileInfo.fileName)

.setContentText(fileInfo.fileName + "下载中...")

.setAutoCancel(true);//设置通知的特性 FLAG_AUTO_CANCEL点击通知栏自动消失

//设置点击通知栏的操作

Intent intent = new Intent(mContext, MainActivity.class);

PendingIntent pendingIntent = PendingIntent.getActivity(mContext, 0, intent, 0);

notification.setContentIntent(pendingIntent);

//发出通知广播

mNotificationManager.notify(fileInfo.id, notification.build());

//把通知加到集合中

mNotification.put(fileInfo.id, notification);

}

}

/**

* 取消通知

*

* @param id

*/

public void cancleNotification(int id) {

//取消通知

mNotificationManager.cancel(id);

//同时删除集合中的通知

mNotification.remove(id);

}

/**

* 更新通知进度

*

* @param id

* @param progress

*/

public void updateNotification(int id, int progress) {

Notification.Builder notification = mNotification.get(id);

if (notification != null) {

//更新进度条

notification.setProgress(100, progress, false);

//重新发送通知

mNotificationManager.notify(id, notification.build());

}

}

}

消息通知栏是通过NotificationUtil工具类来管理的，调用showNotification()方法创建并显示一个通知状态栏，在进度更新时调用updateNotification()方法，下载完成或者取消通知状态栏调用cancleNotification()就可以了，NotificationUtil类中已经对Notification做了8.0的适配处理，关于Notification的8.0适配网上很多资料，不过需要注意在调用setChannelId()时设置的id要和NotificationChannel创建时传入的id一致；

NotificationChannel channel = new NotificationChannel("channel_id", "channel_name", NotificationManager.IMPORTANCE_DEFAULT);

在DownLoadTask中的downLoad()中还是要根据数据库查询的结果进行下载，数据库中如果有下载记录，直接将查询到的下载记录传入到下载线程中，如果没有就需要新增一个下载任务实例，在新增的时候需要注意，要根据传入的单个任务的下载线程个数来弄，要处理好每个线程的开始下载位置和结束下载位置；

public void downLoad() {

//读取数据库的线程信息

List threadInfos = dao.queryThread(mFileInfo.url);

if (threadInfos.size() == 0) {

//获得每个线程下载的长度 分线程下载，多个线程下载一个文件

int length = mFileInfo.length / mThreadCount;

for (int i = 0; i < mThreadCount; i++) {

ThreadInfo threadInfo = new ThreadInfo();

threadInfo.id = i;

threadInfo.url = mFileInfo.url;

threadInfo.thread_start = length * i;

threadInfo.thread_end = (i + 1) * length - 1;

threadInfo.finished = 0;

if (i == mThreadCount - 1) {

//最后一个线程下载的结束位置

threadInfo.thread_end = mFileInfo.length;

}

//添加到线程集合信息

threadInfos.add(threadInfo);

//向数据库中插入一条信息

if (!dao.isExists(threadInfo.url, threadInfo.id)) {

dao.insertThread(threadInfo);

}

}

}

threadList = new ArrayList<>();

//启动多个线程进行下载

for (ThreadInfo threadInfo : threadInfos) {

DownLoadThread downLoadThread = new DownLoadThread(threadInfo);

DownLoadTask.sExecutorService.execute(downLoadThread);

threadList.add(downLoadThread);

}

//启动定时任务

mTimer.schedule(timerTask, 1000, 1000);

}

在开始的同时开启一个Timer进行轮询；

TimerTask timerTask = new TimerTask() {

@Override

public void run() {

if (isPause) {

//暂停时要将定时器清除掉

cancelTimer();

}

//发送消息修改activity进度

Message message = new Message();

message.what = DownLoadService.MSG_UPDATE;

message.arg1 = mFinished * 100 / mFileInfo.length;

message.arg2 = mFileInfo.id;

Log.e("DownLoadService", mFinished + "");

try {

messenger.send(message);

} catch (RemoteException e) {

e.printStackTrace();

}

}

};

/**

* 清除定时器

*/

private void cancelTimer(){

//取消定时器

timerTask.cancel();

timerTask = null;

mTimer.cancel();

mTimer = null;

}

在下载任务进行的同时会每隔一段时间回调TimerTask中的run方法，通过Messenger向activity传递下载的进度，在暂停下载是需要将Timer移除并置为null。

在DownLoadThread线程中下载完毕后做法和之前一样，多了要将Timer移除并置为null；

/**

* 下载线程

*/

class DownLoadThread extends Thread {

private ThreadInfo mThreadInfo;

//线程是否执行完毕

public boolean isFinished = false;

public DownLoadThread(ThreadInfo threadInfo) {

mThreadInfo = threadInfo;

}

@Override

public void run() {

super.run();

HttpURLConnection conn = null;

RandomAccessFile raf = null;

InputStream input = null;

try {

URL url = new URL(mThreadInfo.url);

conn = (HttpURLConnection) url.openConnection();

conn.setReadTimeout(6000);

conn.setRequestMethod("GET");

//设置下载位置

int start = mThreadInfo.thread_start + mThreadInfo.finished;

conn.setRequestProperty("Range", "bytes=" + start + "-" + mThreadInfo.thread_end);

//设置一个文件写入位置

File file = new File(DownLoadService.DOWNLOAD_PATH, mFileInfo.fileName);

raf = new RandomAccessFile(file, "rwd");

//设置文件写入位置

raf.seek(start);

mFinished += mThreadInfo.finished;

//开始下载了

if (conn.getResponseCode() == HttpURLConnection.HTTP_PARTIAL) {

//读取数据

input = conn.getInputStream();

byte[] buffer = new byte[1024 * 4];

int len = -1;

while ((len = input.read(buffer)) != -1) {

//写入文件

raf.write(buffer, 0, len);

//下载进度发送广播给activity

//累加整个文件的进度

mFinished += len;

//累加每个线程下载的进度

int currentFinished = mThreadInfo.finished;

mThreadInfo.finished = currentFinished + len;

//下载暂停是要把进度保存在数据库中

if (isPause) {

dao.updateThread(mThreadInfo.url, mThreadInfo.id, mThreadInfo.finished);

return;

}

}

//标识线程执行完毕

isFinished = true;

//检查下载任务是否执行完毕

checkAllThreadsFinished();

}

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

if (conn != null) {

conn.disconnect();

}

if (raf != null) {

raf.close();

}

if (input != null) {

input.close();

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

}

/**

* 判断是否所有线程执行完毕

*/

private synchronized void checkAllThreadsFinished() {

boolean allFinished = true;

//遍历线程集合判断线程是否执行完毕

for (DownLoadThread downLoadThread : threadList) {

if (!downLoadThread.isFinished) {

allFinished = false;

break;

}

}

if (allFinished) {

cancelTimer();

//发送消息告诉activity下载完毕

Message message = new Message();

message.what = DownLoadService.MSG_FINISHED;

message.obj = mFileInfo;

try {

messenger.send(message);

} catch (RemoteException e) {

e.printStackTrace();

}

//删除线程信息

dao.deleteThread(mFileInfo.url);

}

}

在activity更新下载进度时要根据对应的文件id去更新进度；

/**

* 下载进度更新

*

* @param msg

*/

private void mSGUPDATE(Message msg) {

int finished = msg.arg1;

int id = msg.arg2;

updataItem(id, finished);

//更新通知进度

mNotificationUtil.updateNotification(id, finished);

}

/**

* 下载完成后更新

*

* @param msg

*/

private void mSGFINISHED(Message msg) {

//更新进度为0

FileInfo fileInfo = (FileInfo) msg.obj;

//下载完成后移除存储的文件id

for (int i = 0; i < fileIds.size(); i++) {

Integer integer = fileIds.get(i);

if (integer == fileInfo.id) {

fileIds.remove(integer);

break;

}

}

if (fileInfo != null) {

updataItem(fileInfo.id, fileInfo.length);

}

Log.e("fileInfo.length-->", fileInfo.length + "");

Toast.makeText(MainActivity.this, fileInfo.fileName + "下载完毕", Toast.LENGTH_LONG).show();

//下载完毕后取消通知

mNotificationUtil.cancleNotification(fileInfo.id);

}

private void updataItem(int id, int finished) {

for (int i = 0; i < lists.size(); i++) {

FileInfo fileInfo = lists.get(i);

if (fileInfo.id == id) {

lists.remove(i);

fileInfo.finished = finished;

lists.add(i, fileInfo);

break;

}

}

adapter.updateProgress(lists);

}