Android 实现文件的单线程断点续传下载

1.实际效果：

2.代码实现

完成这个小项目需要：

基础网络知识（Http）

了解android界面处理机制

Service的绑定与解绑

BroadCastReceiver的注册与消息的处理

本地文件的I/O处理

数据库基础

事件回调原理

在这里我采用了数据库框架GreenDao，方便实现想要的效果，自己独立写几个类来操作SQLite数据库也是可以的。关于怎么使用GreenDao，这里不做叙述了，网上一大堆教程，这里给个教程链接http://m.blog.csdn.net/article/details?id=51893092。

下面是项目框架



主要有服务类DownloadService，广播类ProgressReceiver，下载类DownloadTask，线程信息类ThreadInfo,和MainActivity与App（继承Application,用于初始化数据库）。

首先来看看我的布局文件acitivty_main.xml：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/activity_main"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context="com.chen.capton.filedownload.MainActivity">

<TextView
android:id="@+id/info"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="文件信息："
android:layout_alignEnd="@+id/pause" />

<ProgressBar
style="?android:attr/progressBarStyleHorizontal"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_below="@+id/info"
android:layout_alignParentStart="true"
android:id="@+id/progressBar" />

<Button
android:text="开始"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/progressBar"
android:layout_alignParentStart="true"
android:id="@+id/start" />

<Button
android:text="暂停"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:enabled="false"
android:id="@+id/pause"
android:layout_below="@+id/progressBar"
android:layout_toEndOf="@+id/start" />

<TextView
android:text="进度"
android:gravity="right"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:id="@+id/progressText"
android:layout_alignParentEnd="true"
android:layout_toEndOf="@+id/info" />
</RelativeLayout>

配置文件menifests.xml：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.chen.capton.filedownload">
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<application
android:name=".App"
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>

<service
android:name=".DownloadService"
android:enabled="true"
android:exported="true">
</service>
</application>

</manifest>

最主要的MainActivity：

洋洋洒洒100多行

package com.chen.capton.filedownload;

import android.content.ComponentName;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

private TextView fileInfoText,progressText;
private Button startBtn,pauseBtn;
private ProgressBar mProgressBar;
private ProgressReceiver mReceiver;
private final String REFRESH_PROGRESS="REFRESH_PROGRESS"; //设置Action，与ProgressReceiver,DownloadService中的Action都一致
private final String url="http://192.168.1.103/app.zip";  //设置url
private final int maxProgress=100;                        //设置进度条最大进度
private boolean isContinue;                               //是否暂停的标识
private Handler handler=new Handler(){
public void handleMessage(Message msg){
mProgressBar.setProgress(msg.what);//由于发送的是空消息，直接用What作为进度参数使用
progressText.setText("完成度:"+msg.what+"%");
}
}; //用于界面更新的handler。将它作为参数传递至ProgressReceiver，供其发送Message，然后根据Message更新进度
private DownloadService mService;
private ServiceConnection conn=new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
//获取绑定好的DownloadService对象
mService= ((DownloadService.MyBinder)service).getService();
}
@Override
public void onServiceDisconnected(ComponentName name) {}
};

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

initComponent(); //初始化ProgressReceiver，DownloadService

setContentView(R.layout.activity_main);

initView(); //初始化视图控件
setListener(); //设置点击事件
}

private void initView() {
fileInfoText= (TextView) findViewById(R.id.info);
progressText= (TextView) findViewById(R.id.progressText);
startBtn= (Button) findViewById(R.id.start);
pauseBtn= (Button) findViewById(R.id.pause);
mProgressBar= (ProgressBar) findViewById(R.id.progressBar);
mProgressBar.setMax(maxProgress);
}

/*
* 初始化ProgressReceiver，DownloadService
* 绑定DownloadService，注册ProgressReceiver
* */
private void initComponent() {
Intent intent=new Intent(this,DownloadService.class);
bindService(intent,conn,BIND_AUTO_CREATE);

mReceiver=new ProgressReceiver(handler);
IntentFilter filter=new IntentFilter();
filter.addAction(REFRESH_PROGRESS);
registerReceiver(mReceiver,filter);
}

private void setListener() {
startBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if(!isContinue) {
mService.startMission(url,maxProgress);
v.setEnabled(false);
pauseBtn.setEnabled(true);
fileInfoText.setText(getFileName(url));
}else {
mService.continueMission();
v.setEnabled(false);
pauseBtn.setEnabled(true);
}
}
});
pauseBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mService.pauseMission();
v.setEnabled(false);
startBtn.setEnabled(true);
isContinue=true;
startBtn.setText("继续");
}
});
}

/*
* 获取文件名
* */
private String getFileName(String url){
int start=url.lastIndexOf("/")+1;
int end=url.length();
return url.substring(start,end);
}

@Override
protected void onDestroy() {
/*
* 解绑定DownloadService，注销ProgressReceiver
* */
unregisterReceiver(mReceiver);
unbindService(conn);
super.onDestroy();
}

}

用于初始化数据库的App类：

当然也可以在MainActivity中初始化数据库，为了代码简洁和更快地初始化数据库，就写着这里了。

package com.chen.capton.filedownload;

import android.app.Application;
import android.database.sqlite.SQLiteDatabase;

/**
* Created by CAPTON on 2017/1/9.
*/

public class App extends Application {

public static App instances;
@Override
public void onCreate() {
super.onCreate();
setDatabase();
instances = this;
}
public static App getInstances(){
return instances;
}
/**
* 设置greenDao
*/
private DaoMaster.DevOpenHelper mHelper;
private SQLiteDatabase db;
private DaoMaster mDaoMaster;
private DaoSession mDaoSession;
private void setDatabase() {
mHelper = new DaoMaster.DevOpenHelper(this, "Dishes-db", null);
db = mHelper.getWritableDatabase();
mDaoMaster = new DaoMaster(db);
mDaoSession = mDaoMaster.newSession();
}
public DaoSession getDaoSession() {
return mDaoSession;
}
public SQLiteDatabase getDb() {
return db;
}

}

接下来就是贴各个类的代码了

服务类DownloadService：

package com.chen.capton.filedownload;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;

/*
* 实现DownloadTask.RefreshProgressListener接口
* */
public class DownloadService extends Service implements DownloadTask.RefreshProgressListener{
private final String REFRESH_PROGRESS="REFRESH_PROGRESS"; //设置Action
private DownloadTask task;
private Intent intent;
@Override
public IBinder onBind(Intent intent) {
return new MyBinder();
}

class MyBinder extends Binder {
public DownloadService getService(){
intent=new Intent();
intent.setAction(REFRESH_PROGRESS);
return DownloadService.this;
}
}

/*
* 供DownloadTask回调的方法，用于发送刷新进度的广播
* */
@Override
public void refressProgress(int progress) {
intent.putExtra("progress",progress); //将进度值写入intent
sendBroadcast(intent);  //发送广播
}

public void startMission(String url,int maxProgress){
task=new DownloadTask(url,maxProgress);
task.setRefreshProgressListener(this);
task.startMission();
};
public void pauseMission(){
task.pauseMission();
}
public void continueMission(){
task.continueMission();
}
}

广播类ProgressReceiver：

package com.chen.capton.filedownload;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Handler;

/**
* Created by CAPTON on 2017/1/9.
*/

public class ProgressReceiver extends BroadcastReceiver {
private Handler handler;  //保存从MainActivity传来的handler；
private final String REFRESH_PROGRESS="REFRESH_PROGRESS";//设置Action
public ProgressReceiver(Handler handler) {
this.handler=handler;
}

@Override
public void onReceive(Context context, Intent intent) {
//判断Action是否一致
if(intent.getAction().equals(REFRESH_PROGRESS)){
//从传来的intent中获取进度值
int progress=intent.getIntExtra("progress",0);
//将带有进度值的intent发送出去，交与MainActivity中的handler处理
handler.sendEmptyMessage(progress);
}
}
}

下载类（重点）DownloadTask：

package com.chen.capton.filedownload;

import android.os.Environment;
import android.util.Log;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;

/**
* Created by CAPTON on 2017/1/9.
*/

public class DownloadTask {

private String url;           //下载地址
private ThreadInfo threadInfo;//线程信息
private ThreadInfoDao dao; //数据库入口对象
private DownloadThread thread; //下载线程
public boolean isPause;//是否断开连接的标志位，很关键，呵呵
private int maxProgress; //最大进度
public int filedLength;  //文件长度
public int finishedLength; //完成的文件长度（待保存的文件进度）
private RefreshProgressListener listener;//进度刷新的监听器用于调用Service的更新方法

public DownloadTask(String url,int maxProgress) {
this.url = url;
this.maxProgress=maxProgress;
threadInfo=new ThreadInfo();
DaoSession session=App.getInstances().getDaoSession();  //从App中获取初始化好的DaoSession对象
dao=session.getThreadInfoDao();
thread=new DownloadThread(url,threadInfo,maxProgress);
}

/*
* 开始下载线程
* */
public void startMission(){
thread.start();
}

/*
* 暂停任务，即跳出while循环，将线程信息保存到数据库
* */
public void pauseMission(){
isPause=true;
ThreadInfo info=dao.queryBuilder().where(ThreadInfoDao.Properties.Id.eq(1)).build().unique();
//第一次保存进度时插入纪录,之后更新纪录即可
if(info==null) {
info=new ThreadInfo(null, filedLength, finishedLength);
dao.insert(info);
}else {
info.setFileLength(filedLength);
info.setFinishedLength(finishedLength);
dao.update(info);
}
}
/*
*  从数据库读取上次保存的线程信息，新建线程从指定位置下载剩下的部分
* */
public void continueMission(){
isPause=false;
ThreadInfo info=dao.queryBuilder().where(ThreadInfoDao.Properties.Id.eq(1)).build().unique();
if(info!=null){
thread=new DownloadThread(url,info,maxProgress);
thread.start();
}
}

/*
* 下载线程，核心
* */
class DownloadThread extends Thread{
private String url;
private ThreadInfo threadInfo;
private HttpURLConnection conn; //httpUrl连接
private InputStream is;   //输入流
private File fileDir; //建立一个文件夹存放文件
private File file;
private RandomAccessFile raFile;  //可随机读写的File类，实际又不是继承File，呵呵，断点续传必用。
private int maxProgress;

public DownloadThread(String url, ThreadInfo threadInfo, int maxProgress) {
this.url = url;
this.threadInfo=threadInfo;
this.maxProgress=maxProgress;
fileDir=new File(Environment.getExternalStorageDirectory(),"test");
if(!fileDir.exists()){
fileDir.mkdir(); //第一次下载时，应该没有text目录，新建一个
}
file=new File(fileDir,getFileName(url));
try {
raFile=new RandomAccessFile(file,"rw"); //设置文件读写模式，"rw"为可读可写
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}

public void run(){
/*
* 第一次连接，先获取文件长度，供后续设置文件的传输范围（byte）
* */
try {
URL Url = new URL(url);
HttpURLConnection conn= (HttpURLConnection) Url.openConnection();
conn.setRequestMethod("GET");
conn.setReadTimeout(3000);
filedLength=conn.getContentLength();
threadInfo.setFileLength(filedLength);
conn.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
/*
* 第二次连接，根据文件长度，上次保存的进度，设置传输范围，建立连接开始下载
* */
try {
URL Url=new URL(url);
conn= (HttpURLConnection) Url.openConnection();
conn.setRequestMethod("GET");  //设置连接方式
conn.setReadTimeout(5000);  //设置连接超时
//设置传输的范围，例如"bytes=0-1231540",‘-’后面没写说明结束端为传输文件的最后一字节
conn.setRequestProperty("Range","bytes="+threadInfo.getFinishedLength()+"-"+threadInfo.getFileLength());
conn.connect();
is=conn.getInputStream();  //从连接对象中获取输入流
//数据输入流，也可以用BufferedInputStream;
DataInputStream dis=new DataInputStream(is);
try {
//设置一定的延时，等待服务器响应报文
Thread.sleep(1800);
} catch (InterruptedException e) {
e.printStackTrace();
}

/*
* 根据响应码判断是否成功连接服务器
* */
if(conn.getResponseCode()==HttpURLConnection.HTTP_OK||
conn.getResponseCode()==HttpURLConnection.HTTP_PARTIAL) {
raFile.seek(threadInfo.getFinishedLength());//跳转至上一次暂停时保存的位置
byte[] b = new byte[1024];  //设置byte数组,大小适度即可;
int len;    //每次写入b中的实际字节数
long now=System.currentTimeMillis(); //设置循环初始时间
while ((len = dis.read(b)) != -1) {
raFile.write(b, 0, len); //将保存在b中的数据写入文件
finishedLength += len;   //累加下载长度
/*
* 判断文件（下载）写入消耗的时间是否大于100ms，若是才跟新进度，不设置的话,
* 刷新频率=文件长度(很大的数)/1kb，会明显地限制传输速度
* */
if(System.currentTimeMillis()-now>=100) {
now=System.currentTimeMillis();
//根据公式算出实际进度大小，然后调用DownloadService的实现方法refressProgress(int progress);
listener.refressProgress((int) ((long) finishedLength * maxProgress / threadInfo.getFileLength()));
}else {
/*当文件（下载）写入消耗的时间小于100ms时，判断是否下载完成，若是则把进度设置为最大这个判断存在的意义在于，当文件下载完全时，消耗时间又小于100ms,进度显示为100%, 若不设置，则进度显示会卡在90%-100%之间,文件越小,显示误差越大*/
if (finishedLength>=threadInfo.getFileLength()){
listener.refressProgress(maxProgress);
}
}
if (isPause) {
break;
}
}
threadInfo.setFinishedLength(finishedLength); //保存下载信息
//写入完毕或者暂停则断开连接
is.close();
conn.disconnect();
}
} catch (IOException e) {
e.printStackTrace();
}
}
};

/*
* 设置回调方法，和回调接口，让DownloadService实现接口用于刷新进度。
* */
public void setRefreshProgressListener(RefreshProgressListener listener){
this.listener=listener;
}
public interface RefreshProgressListener{
void refressProgress(int progress);
}
private String getFileName(String url){
int start=url.lastIndexOf("/")+1;
int end=url.length();
return url.substring(start,end);
}
}

线程信息类ThreadInfo:

package com.chen.capton.filedownload;

import org.greenrobot.greendao.annotation.Entity;
import org.greenrobot.greendao.annotation.Id;
import org.greenrobot.greendao.annotation.Generated;

/**
* Created by CAPTON on 2017/1/9.
*/

//声明此类是GreenDao框架的Entity实体类
@Entity
public class ThreadInfo {
//声明这是自增的唯一键
@Id
private Long id;
private int fileLength;
private int finishedLength;

/*
*用Android Studio 点击Build选项下的"Make Project"，后面的代码会自动生成
*/
@Generated(hash = 956576157)
public ThreadInfo(Long id, int fileLength, int finishedLength) {
this.id = id;
this.fileLength = fileLength;
this.finishedLength = finishedLength;
}
@Generated(hash = 930225280)
public ThreadInfo() {
}
public Long getId() {
return this.id;
}
public void setId(Long id) {
this.id = id;
}
public int getFileLength() {
return this.fileLength;
}
public void setFileLength(int fileLength) {
this.fileLength = fileLength;
}
public int getFinishedLength() {
return this.finishedLength;
}
public void setFinishedLength(int finishedLength) {
this.finishedLength = finishedLength;
}
}

代码就全部贴完了，至于思路是怎么屡清楚的，主要看你对各个知识点掌握的熟练程度。

3.设计思路

写这个小demo,我的思路是：

❶，先要明确目标：文件的单线程断点续传,首先单线程先不管，后面还有多线程呢，断点续传是重点，说道断点续传你就应该明白要保存暂停时的进度了，保存进度需要用什么途径？SharePreference,SQLite(这里采用的途径)，文件保存？如果是单线程，只需要保存一个进度信息，SharePreference是最方便了，把文件长度，已下载长度两个参数写进xml文件里就行了，需要续传文件时从xml里读就行了，当然这只是最简单的情况；如果是多线程下载时，比如10个线程，你就需要至少20个命名空间来保存参数，这样很麻烦，读写信息都很麻烦，不如数据库来的方便了。至于用文件存储信息就不要去想了，更麻烦，可以自行琢磨。

❷，信息的保存方式确定了，接下来是考虑如何下载文件了，当然不要去用什么框架来下载了，自己手写，从http连接开始写，到文件写入，关闭http连接为止，都自己写。这里Http连接用到的是HttpUrlConnection,也可以用HttpClient。文件的来源弄懂了，然后是文件输出，断点续传要用到RandomAccessFile这个类，可以实现文件的随机位置的读写，当然这个类并不是继承File类,而是实现 DataOutput, DataInput, Closeable这几个接口，所以我们在导入数据的时候用DataInputStream比较好，BufferdInputStream也是可以的。

❸文件如何下载写入和保存搞定了，接下来是进度刷新的问题，这个就涉及到Service,BroadCastReceiver,Handler这三大块的知识了，把这些基础知识先掌握好。其实我刚开始学的时候没用Service,BroadCastReceiver，直接在MainActivity里写，当然代码量就吓人了，结构也看起来很复杂，不过感觉下载速度确实最快（估计是Service不用一直发送消息给BroadCastReceiver，发送一个消息虽然很快，但是进度是不断刷新的，积少成多，我们的设备要处理的消息就多了，效率就下降了，从而影响文件传输速度了）。

❹各大类的调用关系：

(1)MainActivity（点击”开始”,”暂停”按钮）调用DownloadService内的方法

(2)DownloadService继续调用DownloadTask的相应方法

(3)DownloadTask开始其中的下载线程，线程下载一定字节的后,回调DownloadService的refressProgress（int progress）方法

(4)refressProgress方法发送广播给ProgressReceiver，ProgressReceiver根据发来的信息通过Handler转发到MainActivity的Handler中

(5)MainActivity中的Handler收到最终消息，更新UI。

若是点击”暂停”按钮,“开始”按钮变为“继续”按钮，->(3)中跳出文件读取的循环，并把进度写入数据库，再次点击“继续”按钮续传文件，DownloadTask读取数据库数据，重新开始(3)(4)(5)。

前面的是大致思路，具体细节要深入到代码里去剖析，如果你是大神，余光一瞥就能理解每一行代码的用意；如果你对各个知识掌握的还不够熟练，可能就卡在某处了。几乎所有重要的方法和类我都一一注释了其用意了，剩下一些繁文缛节就没有叙述了，希望大家都能明白。

建议：

❶最好在个人电脑上构建一个局域网服务器，通过局域网来测试下载任务（不用流量），我用的是WAMP，简单粗暴，把文件丢进根目录下的“www”目录即可通过类似“http://192.168.1.10x/xxx.xxx“的url找到你的文件。建好服务器启动后发现手机无法访问地址，可以试试关闭电脑的防火墙（百试不厌），当然用完最好恢复回去。

❷文件最好选择一些设备需要检查其完整性的格式，如zip,rar,apk, 尝试打开文件来检验是否下载完整

❸手机最好已经root,方便查看数据库的信息（注意：GreenDao输出的数据库格式可能不是以db结尾（受初始化时的命名决定），手动改成”.db”结尾就可以打开了）。这里推荐“RE文件管理器”这款软件来查看root后的手机文件夹。当然不root的话，如果是数据出错，就手动写代码检查数据库喽。

4.相关文件

单线程断点续传 demo apk 链接：http://pan.baidu.com/s/1sltoHrB 密码：v4tj

完整项目demo 链接：http://pan.baidu.com/s/1kVBbTcj 密码：qcb7