Android 多线程文件断点下载器实现（造轮子系列）（二）

1.开始

如果对断点续传没有了解的，可以看看我的上一篇博文——断点续传实现

上次完成了断点下载相关的功能，这次开始进行任务并行相关的扩展。

任务并行需要完成的功能：一定数量的任务并行下载，超过额定值的任务暂停等待。有一个很好的方法能完成这种要求，那就是concurrent包下提供的线程池。

2.任务抽象

用到线程池，那么就要用到runnable并进行相关的调用，为了提高抽象等级，把下载任务相关的属性和方法抽象成一个抽象类，供下载任务类实现。可以看到，基类是要求子类实现Runnable接口的。

abstract public class TransferTask implements Runnable
{
protected long taskSize;
protected long completedSize;

protected String url;

protected String fileName;
protected String saveDirPath;
protected OkHttpClient client;
//下载的文件
RandomAccessFile file;
//任务状态
int state = LoadState.PREPARE;

public long getTaskSize()
{
return taskSize;
}

public long getCompletedSize()
{
return completedSize;
}

public String getFileName()
{
return fileName;
}

public void setFileName(String fileName)
{
this.fileName = fileName;
}

public void setSaveDirPath(String saveDirPath)
{
this.saveDirPath = saveDirPath;
}

public int getState()
{
return state;
}

public void setState(int state)
{
this.state = state;
}

public String getUrl()
{
return url;
}

public void setUrl(String url)
{
this.url = url;
}

public String getSaveDirPath()
{
return saveDirPath;
}

@Override
abstract public void run();
}

具体实现类的run()方法，使用上次写下的代码就可以了。

3.DownloadManager

完成了简单的抽象，就有了可供调度的线程。

考虑到使用线程池，那么就需要一个专门的类管理线程池，并对相关的下载任务进行分配和需要的操作。

于是定义一个DownlaodManager，因为线程池无法获取线程的状态和改变线程内的变量，所以Manager出了维护一个线程池外，还要维护一个任务的列表，在线程执行完毕或取消后，将对应的任务移出列表。设置的回调如下

interface CompletedListener
{
void isFinished(String url);
}

除了这些，还要考虑到后台线程和前台交互，用来显示进度或者提示相关信息。于是也需要维护一个UI线程的Handler，并用回调更新界面。

这样的应用，比较适合使用单例模式。具体分析写在注释里

/**
* Created by pxh on 2016/2/15.
* 管理下载任务
*/
public class DownloadManager implements DownloadTask.CompletedListener
{
static DownloadManager mManager;
Context context;

//数据库相关的操作类和实体类
static private DaoMaster daoMaster;
static private DaoSession daoSession;
private DownloadEntityDao downloadDao;

//下载路径
String downLoadPath = "";

//可并行线程数
private int nThread;

//Activity或fragment实现的接口，方法为OnUIUpdate()，是在UI线程运行的方法
DownloadUpdateListener mDownloadUpdate;

private Handler mHandler;

//维护的任务相关队列，保存未完成的任务
LinkedList<TransferTask> taskList;

//用于调度的线程池
ExecutorService executorService;

//私有构造方法
private DownloadManager(Context context, int nThread)
{
this.context = context;
this.nThread = nThread;

//得到UI线程的Handler，用于更新UI
mHandler = new Handler(Looper.getMainLooper());
//初始化nThread大小的线程池，超过nThread的任务挂起
executorService = Executors.newFixedThreadPool(this.nThread);
taskList = new LinkedList<>();
//将数据库中的未完成任务读取出来，并存入到taskList中
getDownloadTask();
downloadDao = getDaoSession(context).getDownloadEntityDao();
}

//获得实例前先进行一次init，因为下载任务在后台执行，为了防止内存泄漏，Context最好为Application的Context而不是Activity的
static public void init(Context context)
{
if (mManager == null)
synchronized (DownloadManager.class) {
if (mManager == null)
mManager = new DownloadManager(context, 3);
}
}

static public void init(Context context, int nThread)
{
if (mManager == null)
synchronized (DownloadManager.class) {
if (mManager == null)
mManager = new DownloadManager(context, nThread);
}
}

static public DownloadManager getInstance()
{
if (mManager == null)
throw new NullPointerException();
return mManager;
}

public void addTask(String url, String fileName)
{
//DownloadTask为TransferTask的实现类
DownloadTask task = new DownloadTask(fileName, url, SDCardUtils.getSDCardPath() + downLoadPath, downloadDao);
//注册完成事件，方便任务完成后将实例移出实例集合
task.setCompletedListener(this);
//将任务加入队列，并在线程池中执行
taskList.add(task);
executorService.execute(task);
}

/**
* 可以获得当前为下载完成的任务列表及其相关信息
*
* @return
*/
public LinkedList<TransferTask> getTaskList()
{
return taskList;
}

//可以根据url获取相应的任务
private DownloadTask getTask(String url)
{
for (TransferTask task : taskList) {
DownloadTask dTask = (DownloadTask) task;
if (dTask.getUrl().equals(url)) {
return dTask;
}
}
return null;
}

//下载完成，将相应的任务移出taskList
@Override
public void isFinished(String url)
{
Log.v("task finished", "task : " + url + " download completed");
DownloadTask task = getTask(url);
if (task != null)
taskList.remove(task);
else
Log.e("isFinished", "task=null");
}

//使用弱引用，防止内存泄漏
public void setUpdateListener(DownloadUpdateListener updateListener)
{
WeakReference<DownloadUpdateListener> reference = new WeakReference<>(updateListener);//prevent memory leak
this.mDownloadUpdate = reference.get();
}

/**
* 获取DaoMaster
*
* @param context
* @return
*/
public static DaoMaster getDaoMaster(Context context)
{
if (daoMaster == null) {
DaoMaster.OpenHelper helper = new DaoMaster.DevOpenHelper(context, "downloadDB", null);
daoMaster = new DaoMaster(helper.getWritableDatabase());
}
return daoMaster;
}

/**
* 获取 DaoSession
*
* @param context
* @return
*/
public static DaoSession getDaoSession(Context context)
{
if (daoSession == null) {
if (daoMaster == null) {
daoMaster = getDaoMaster(context);
}
daoSession = daoMaster.newSession();
}
return daoSession;
}

//将数据库中的未完成任务读取出来，并存入到taskList中
private void getDownloadTask()
{
DownloadEntityDao downloadEntityDao = getDaoSession(context).getDownloadEntityDao();
List<DownloadEntity> entityList = downloadEntityDao.loadAll();
for (DownloadEntity entity : entityList) {
Log.e("dao", entity.toString());
if (entity.getCompletedSize().equals(entity.getTaskSize())) {
//handle already downloaded files
} else
taskList.add(new DownloadTask(downloadEntityDao, entity));
}

}

public interface DownloadUpdateListener
{
void OnUIUpdate();
}
}

4.简单使用

在Activity中，只需要如下代码就可以得到Manager的实例

DownloadManager.init(this.getApplicationContext());
downloadManager = DownloadManager.getInstance();

一般情况下，都是使用ListView或者RecyclerView显示下载的信息，这时候就可以通过

downloadManager.getTaskList()

获得任务列表的引用

并且可以在OnUIUpdate()方法中随任务下载更新列表

@Override
public void OnUIUpdate()
{
adapter.notifyDataSetChanged();
}

这里写了一个例子，Activity如下

public class MainActivity extends AppCompatActivity implements TaskConfirmDialog.InputCompletedListener,
DownloadManager.DownloadUpdateListener
{
private ListView listView;
DownloadManager downloadManager;
protected Adapter adapter;

@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
listView = (ListView) findViewById(R.id.listView);
DownloadManager.init(this.getApplicationContext());
downloadManager = DownloadManager.getInstance();
downloadManager.setUpdateListener(this);
setListViewAdapter();
verifyStoragePermissions(this);
}

private static void deleteFilesByDirectory(File directory)
{
if (directory != null && directory.exists() && directory.isDirectory()) {
for (File item : directory.listFiles()) {
item.delete();
}
}
}

void setListViewAdapter()
{
adapter = new Adapter(this, downloadManager.getTaskList());
listView.setAdapter(adapter);
}

@Override
public boolean onCreateOptionsMenu(Menu menu)
{
getMenuInflater().inflate(R.menu.main_menu, menu);
return super.onCreateOptionsMenu(menu);
}

@Override
public boolean onOptionsItemSelected(MenuItem item)
{
switch (item.getItemId()) {
case R.id.action_add_task:
TaskConfirmDialog dialogFragment = new TaskConfirmDialog();
android.app.FragmentManager manager = getFragmentManager();
dialogFragment.show(manager, "");
break;
}
return super.onOptionsItemSelected(item);
}

@Override
public void inputCompleted(String url, String fileName)
{

url = "http://apk.hiapk.com/web/api.do?qt=8051&id=716";
String url1 = "https://github.com/nebulae-pan/OkHttpDownloadManager/archive/master.zip";
String url2 = "https://github.com/bxiaopeng/AndroidStudio/archive/master.zip";
String url3 = "https://github.com/romannurik/AndroidAssetStudio/archive/master.zip";
String url4 = "https://github.com/facebook/fresco/archive/master.zip";
String url5 = "https://github.com/bacy/volley/archive/master.zip";
downloadManager.addTask(url, "123.apk");
downloadManager.addTask(url1, "1.zip");
downloadManager.addTask(url2, "2.zip");
downloadManager.addTask(url3, "3.zip");
downloadManager.addTask(url4, "4.zip");
downloadManager.addTask(url5, "5.zip");
}

@Override
public void OnUIUpdate()
{
adapter.notifyDataSetChanged();
}

/**
* just sample
*/
static class Adapter extends BaseAdapter
{
LinkedList<TransferTask> data;
Context context;

public Adapter(Context context, LinkedList<TransferTask> data)
{
this.data = data;
this.context = context;
}

@Override
public int getCount()
{
return data.size();
}

@Override
public Object getItem(int position)
{
return data.get(position);
}

@Override
public long getItemId(int position)
{
return 0;
}

@Override
public View getView(final int position, View convertView, ViewGroup parent)
{
if (convertView == null) {
convertView = ((Activity) context).getLayoutInflater().inflate(R.layout.item_download, parent, false);
}
final TransferTask tf = data.get(position);
//if taskSize isn't initial complete,post to getView
((TextView) convertView.findViewById(R.id.title)).setText(tf.getFileName());
((ProgressBar) convertView.findViewById(R.id.progressBar)).setProgress((int) (tf.getTaskSize() > 0 ? 100
* tf.getCompletedSize() / tf.getTaskSize() : 0));
if (tf.getState() == LoadState.PREPARE) {
(convertView.findViewById(R.id.operation)).setEnabled(false);
((Button) convertView.findViewById(R.id.operation)).setText("connecting");
}
if (tf.getState() == LoadState.PAUSE) {
((Button) convertView.findViewById(R.id.operation)).setText("start");
}
if (tf.getState() == LoadState.DOWNLOADING) {
(convertView.findViewById(R.id.operation)).setEnabled(true);
((Button) convertView.findViewById(R.id.operation)).setText("pause");
}
(convertView.findViewById(R.id.operation)).setOnClickListener(new View.OnClickListener()
{
@Override
public void onClick(View v)
{
if (tf.getState() == LoadState.DOWNLOADING)
DownloadManager.getInstance().pauseTask(position);
else if (tf.getState() == LoadState.PAUSE)
DownloadManager.getInstance().restartTask(position);
}
});
return convertView;
}
}
}

5.运行效果与问题解决

具体运行效果如下

第一个截图是同时有三个任务可以下载，其余的任务等待



如果前面的任务暂停，后面的任务开始进行



不过在更新界面的时候发现了一个问题，在每接受一个数据块后更新，导致多任务下更新速率极快，大于了界面刷新速度。

想到的解决办法有两个

接收数据块后挂起一段时间，降低更新速率

格外开启一个更新线程，固定的时间想UI线程发送更新信息

第一种方法实现简单，但会导致加载变慢。

这里放下我想到的第二种方法

//在DownloadManager下加入这两个属性
final Object updateLock = new Object();//更新界面进程的互斥锁
boolean isUpdating = false; //当前是否更新

/**
* 需判断状态，全部暂停后停止更新界面
*/
Runnable updateUIByOneSecond = new Runnable()
{
@Override
public void run()
{
synchronized (updateLock) {
if (isUpdating) {
mHandler.post(new Runnable()
{
@Override
public void run()
{
if (mDownloadUpdate == null) return;
mDownloadUpdate.OnUIUpdate();
}
});
ifNeedStopUpdateUI();
mHandler.postDelayed(this, 1000);
}
}
}
};

protected void startUpdateUI()
{
synchronized (updateLock) {
if (!isUpdating) {
isUpdating = true;
new Thread(updateUIByOneSecond).start();
}
}
}

protected void stopUpdateUI()
{
synchronized (updateLock) {
isUpdating = false;
}
}

//检查是否需要停止更新
protected void ifNeedStopUpdateUI()
{
for (TransferTask task : taskList) {
if (task.getState() == LoadState.DOWNLOADING || task.getState() == LoadState.PREPARE )
return;
}
stopUpdateUI();
}

实现思路就是，在addTask()，reStartTask()这些会需要界面更新的任务中加入startUpdateUI()器界面更新线程。

界面更新线程updateUIByOneSecond()每秒执行一次，会判断当前状态是否需要执行更新，如果需要，向UI线程的Handler发送更新信息，并在发送完毕后，检查所有任务的状态，如果不存在正在下载，或正在连接准备中的任务，就结束更新。这样就能实现统一的列表更新。

6.结束

这次实现了多任务并行下载，之后就要向最后一步：多线程下载，发起挑战了。

如果有大神，希望能看看我的博文或在github上的代码，给我提出一写建议。