前言

断点续传是一个很传统的话题;现在但凡包含下载功能的软件,大部分都会有断点续传的功能;因此对于断点续传的实现,已经 有很多成熟的解决方案;对于Android开发来说更是这样,github上有大量基于Java语言的断点续传框架;有很多库结合Android Application 生命周期及Sqlite的实现,已经接近完美,使用起来几行代码,两三个回调方法就可以很方便的实现文件断点下载的功能。

因此,这里仅就断点下载最基础的知识做一个简单的总结。

基本原理

断点续传,顾名思义就是下载文件时不必每次都重新开始,可以从之前已经下载好的地方接着下载,这样既可以省流量还能省时间。那么怎么样才能做到呢?这就要靠RandomAccessFile 这个类了。

/**
 * Allows reading from and writing to a file in a random-access manner. This is
 * different from the uni-directional sequential access that a
 * {@link FileInputStream} or {@link FileOutputStream} provides. If the file is
 * opened in read/write mode, write operations are available as well. The
 * position of the next read or write operation can be moved forwards and
 * backwards after every operation.
 */
public class RandomAccessFile implements DataInput, DataOutput, Closeable {
   .......
}复制代码

这是RandomAccessFile 这个类的定义。

那么怎么使用这个类呢?下面来看一个简单的demo

public class RandomIoDemo {

    private static int len;

    public static void main(String[] args) throws Exception {
        // 在磁盘中预先创建一个文件,分配预定的空间
        RandomAccessFile raf = new RandomAccessFile("result.txt", "rwd");
        raf.setLength(1024); // 预分配 1kb 的文件空间
        raf.close();

        // 所要写入的文件内容
        String s1 = "第一个字符串的内容";
        String s2 = "第二个字符串的内容";
        String s3 = "第三个字符串的内容";
        String s4 = "第四个字符串的内容";
        String s5 = "第五个字符串的内容";

        len = s1.getBytes().length;


        // 利用多线程同时写入一个文件

        new FileWriteThread(0, s1.getBytes()).start();
        new FileWriteThread(len, s2.getBytes()).start();
        new FileWriteThread(len * 2, s3.getBytes()).start();
        new FileWriteThread(len * 3, s4.getBytes()).start();
        new FileWriteThread(len * 4, s5.getBytes()).start();
    }

    // 利用线程在文件的指定位置写入指定数据
    private static class FileWriteThread extends Thread {
        private int skip;
        private byte[] content;

        /**
         *
         * @param skip 写入文件需要跳过的字节数
         * @param content 写入到文件的内容
         */
        private FileWriteThread(int skip, byte[] content) {
            this.skip = skip;
            this.content = content;
        }

        public void run() {
            try {
                FileChannel channel = new RandomAccessFile("result.txt", "rwd").getChannel();
                MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_WRITE, skip, len);
                buffer.put(content);
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}复制代码

这个一个简单的Java 实现,功能很简单,就是把s1~s5,这几个字符串的内容写入到result.txt 这个文本文件中去;为了方便起见这几个s1~s5这几个字符串的大小都是相同的;你可能会说这样一个功能很简单呀,用StringBuffer就可以实现,是可以;但是如果s1~s5 这几个字符串的长度很长,或者说要写入到最终文件的内容不是字符串,而是音频、图片流之类的,那么使用RandomAccessFile就可以展现出他的优势了。一句话概括来说,RandomAccessFile 可以实现文件从特定的位置进行读写。

基于OKHttp的断点下载简单实现

好了,RandomAccessFile只是提供了一种文件类型,方便我们进行断点续传,那么如果要实现断点下载的功能,我们需要思考以下两个问题。

首先,所有服务器上的文件都支持断点下载吗?怎么判断一个文件是否支持断点下载?
其次,如果一个文件支持断点下载,那么怎么告知服务器端,我要从哪个字节开始下载?

好了,这两个疑问可以通过下面的代码得到答案:

public class DownloadHelper {


    public static OkHttpClient mClient = new OkHttpClient();

    private static Call mCall;

    public static void startDownload(int startPoint, int endPoint, Handler mHandler) {
        Request request = new Request.Builder()
                .url(Constants.PACKAGE_URL)
                .header("RANGE", "bytes=" + startPoint + "-" + endPoint)
                .build();
        mCall = mClient.newCall(request);
        mCall.enqueue(new OkHttpCallback(startPoint, mHandler));
    }

    public static void startDownload(int startPoint, Handler mHandler) {
        Request request = new Request.Builder()
                .url(Constants.PACKAGE_URL)
                .header("RANGE", "bytes=" + startPoint + "-")
                .build();
        mCall = mClient.newCall(request);
        mCall.enqueue(new OkHttpCallback(startPoint, mHandler));
    }

    public static void cancelDownload() {
        if (mCall != null) {
            mCall.cancel();
        }
    }

}复制代码

可以看到,通过设置Request对象的header方法的RANGE就可以告知服务器端开始下载的节点;我们再看OkHttpCallback的实现

public class OkHttpCallback implements Callback {

    private Handler mHandler;

    private int startPoint;

    public OkHttpCallback(int startPoint, Handler mHandler) {
        this.startPoint = startPoint;
        this.mHandler = mHandler;
    }


    @Override
    public void onFailure(Call call, IOException e) {
        mHandler.sendEmptyMessage(100);
    }

    @Override
    public void onResponse(Call call, Response response) {

        if (response.code() != HttpURLConnection.HTTP_PARTIAL) {
            //返回code非206 ,不支持断点续传
            mHandler.sendEmptyMessage(400);
            return;
        }


        FileChannel fileChannel = null;
        ResponseBody body = response.body();
        int total = (int) body.contentLength();
        int currentLength = 0;
        InputStream inputStream = body.byteStream();

        try {
            RandomAccessFile randomAccessFile = new RandomAccessFile(Constants.FILE_PATH, "rws");
            fileChannel = randomAccessFile.getChannel();
            Log.e(TAG, "onResponse: startPoint=" + startPoint + " ,total=" + total);
            MappedByteBuffer mappedByteBuffer = fileChannel.map(FileChannel.MapMode.READ_WRITE, startPoint, total);
            int len;
            byte[] buffer = new byte[1024];
            while ((len = inputStream.read(buffer)) != -1) {

                currentLength = currentLength + len;
                mappedByteBuffer.put(buffer, 0, len);

                Message msg = Message.obtain();
                msg.arg1 = total;
                msg.arg2 = currentLength;
                msg.what = 300;
                mHandler.sendMessage(msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                inputStream.close();
                if (fileChannel != null) {
                    fileChannel.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}复制代码

在onResponse 回调方法中我们可以看到,当我们在之前的head中添加了RANGE字段,但是如果返回的http code不是206是,我们就可以确定所请求的文件是不支持断点下载的。

现在就可以非常方便的实现一个简单的断点续传功能了。


class MyHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case 400:
                    Toast.makeText(mContext, "不支持断点续传", Toast.LENGTH_SHORT).show();
                    break;
                case 100:
                    Toast.makeText(mContext, "fail", Toast.LENGTH_SHORT).show();
                    break;
                case 300:
                    int total = msg.arg1;
                    int current = msg.arg2;
                    if (!isPause && !isStop) {
                        totalValue = current + breakPointValue;

                        int percent = (int) (totalValue * 100f / (total + breakPointValue));
                        if (percent < 100) {
                            mProgressBar.setProgress(percent);
                            progressValue.setText(String.valueOf(percent));
                        } else {
                            Intent intent = new Intent(Intent.ACTION_VIEW);
                            intent.setDataAndType(Uri.parse("file://" + Constants.FILE_PATH),
                                    "application/vnd.android.package-archive");
                            mContext.startActivity(intent);
                            resetStatus();
                        }
                    }


                    break;
                default:
                    break;
            }
        }
    }

            isPause=true;
            pause.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (isPause) {
                    pause.setImageResource(R.drawable.ic_pause_circle_outline_black_24dp);
                    DownloadHelper.startDownload(breakPointValue, mMyHandler);
                } else {
                    pause.setImageResource(R.drawable.ic_play_circle_outline_black_24dp);
                    DownloadHelper.cancelDownload();
                    breakPointValue = totalValue;
                }
                isPause = !isPause;

            }
        });复制代码

breakPointValue 这个变量记录了每次暂停下载时,断点位置已完成的下载量,第一次开始下载时他的初始值为0,因此便开始从头下载这个文件,并通过Handler依次累加已经完成的下载量totalValue, 同时更新下载进度;当暂停时,停止下载任务;breakPointValue的值就是此刻的总下载量,再次点击继续下载,此时breakPointValue就会从上次断掉的位置开始新一次的下载任务;依次类推直到下载完成。这样,就简单的完成了一个文件的断点下载任务。

这个实现很简单,这里再总结一下需要注意的地方:

使用APK 类型的文件,作为断点下载的测试非常有针对性,如果断点续传的过程中数据错误或丢失,将导致最终下载的完成的APK 文件破损,无法安装。
在Http的ResponseBody中,contentLength 的值不是一成不变的,他每次返回的值,并不是当前所请求文件实际的大小,而是此次请求能够传输的大小,也就是从文件总大小-RANGE 所包含的大小。因此,需要每次把上一次暂停时breakPointValue的值作为下一次累加值的基数。


好了,这就是关于断点下载的简单总结。另附Github 源码地址,有需要的可以查看。

Logo

开放原子开发者工作坊旨在鼓励更多人参与开源活动,与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动,如meetup、训练营等,主打技术交流,干货满满,真诚地邀请各位开发者共同参与!

更多推荐