Android 断点续传基础之单线程下载

推荐资源站：https://zhimalier.com/

前天去驾校刷课时，不曾想出来的时候下起了雪，真的好冷啊。恰巧我是走着去的，回来的路上本以为只有雪才是那么的美，那么的纯洁。可是那都是表面，当雪落在地面，终究是一滩污水，就像人！唉，一场雪下不尽冬天的冷漠，映不尽人心的浑浊！

Android 断点续传进阶之多线程下载：http://blog.csdn.net/qq_27489007/article/details/53912722

断点续传，从慕课网学习之后在此写文章记录一下！ 讲真，下载这种东西凡是一个APP基本都用到，所以学习下断点续传提升自己！说的再多 不如一张效果图来的实在！

这只是基本的实现 所以会有很多未曾考虑的问题 比如多次点击创建多个线程等，请根据个人情况进行编写。

首先来说说原理，文件的下载过程其实就是字节的读取和写入的过程，而断点续传，就是在字节读取过程中停止之后，又能接着上次的进度继续读取字节。那我们要实现这个共功能，就需要在每个读取字节时记录读取的字节，然后在继续下载的时候继续上次的字节读取。

整体所需知识点内容

• 数据库的操作
• Service的启动
• activity给service传递参数
• 使用广播回传数据到activity
• 线程和handler
• 网络操作

遇到的问题：在这因为返回值的问题烦躁了一下，有可能出现空指针的异常，已经提出成文章了

请参考http://blog.csdn.net/qq_27489007/article/details/53523378

文件关系图

断点续传流程图

开始撸代码(主要代码)

/**
 * 普通断点续传
 */
public class DuandianActivity extends AppCompatActivity {
    @BindView(R.id.tv)
    TextView tv;
    @BindView(R.id.probar)
    ProgressBar probar;
    @BindView(R.id.btstar)
    Button btstar;
    @BindView(R.id.btstop)
    Button btstop;
    String url = "http://dldir1.qq.com/weixin/android/weixin6316android780.apk";
    private FileInfo fileInfo;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_duandian);
        ButterKnife.bind(this);
        probar.setMax(100);
        //创建文件信息对象
        fileInfo = new FileInfo(0, url, "文件名-下载进度", 0, 0);
        tv.setText(fileInfo.getFileName());  //设置显示下载的文件名
        //注册广播接收器
        IntentFilter filter = new IntentFilter();
        filter.addAction(DownloadService.ACTION_UPDATE);
        registerReceiver(mReceiver, filter);
    }

    //更新ui的广播接收器
    BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (DownloadService.ACTION_UPDATE.equals(intent.getAction())) {
                int finished = intent.getIntExtra("finished", 0);
                probar.setProgress(finished);
                if (probar.getProgress()==100){
                    Toast.makeText(DuandianActivity.this,"下载完成！",Toast.LENGTH_SHORT).show();
                }
            }
        }
    };

    //按钮事件监听
    @OnClick({R.id.btstar, R.id.btstop})
    public void onClick(View view) {
        Intent intent = new Intent(DuandianActivity.this, DownloadService.class);
        switch (view.getId()) {
            case R.id.btstar:
                //通过intent传递参数给service
                intent.setAction(DownloadService.ACTION_START);
                intent.putExtra("fileInfo", fileInfo);
                Log.i("TAG",intent.getAction().toString());
                startService(intent);
                break;
            case R.id.btstop:
                intent.setAction(DownloadService.ACTION_STOP);
                intent.putExtra("fileInfo", fileInfo);
                startService(intent);
                break;
        }
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mReceiver != null) {
            unregisterReceiver(mReceiver);
        }
    }
}

DownloadService.java

/**
 * 下载的服务类
 */
public class DownloadService extends Service {
    public static final String ACTION_START = "ACTION_START";
    public static final String ACTION_STOP = "ACTION_STOP";
    public static final String ACTION_UPDATE = "ACTION_UPDATE";
    public static final String DOWNLOAD_PATH = Environment.getExternalStorageDirectory().getAbsolutePath() + "/download";//sd卡路径
    private DownloadTask mDownloadTask = null;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
//        Log.i("TAG", intent.getAction().toString());
//        Log.i("action", intent.getAction().toString());
        //获得activity传来的参数
        if (ACTION_START.equals(intent.getAction())) {
            FileInfo fileInfo = (FileInfo) intent.getSerializableExtra("fileInfo");
            Log.i("test", "start" + fileInfo.toString());
            //启动初始化线程
            new InitThread(fileInfo).start();
        } else if (ACTION_STOP.equals(intent.getAction())) {
            FileInfo fileInfo = (FileInfo) intent.getSerializableExtra("fileInfo");
            Log.i("test", "stop" + fileInfo.toString());
            if (mDownloadTask != null) {
                mDownloadTask.isPause = true;
                Toast.makeText(getApplicationContext(),"暂停成功",Toast.LENGTH_SHORT).show();
            }else {
                Toast.makeText(getApplicationContext(),"还未开始下载",Toast.LENGTH_SHORT).show();
            }
        }

        return super.onStartCommand(intent, Service.START_REDELIVER_INTENT, startId);
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    private static final int MSG_INIT = 0;
    Handler mhandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case MSG_INIT:
                    FileInfo fileInfo = (FileInfo) msg.obj;
                    Log.i("test", "Init:" + fileInfo);
                    //启动下载任务
                    mDownloadTask = new DownloadTask(DownloadService.this, fileInfo);
                    mDownloadTask.download();
                    break;
            }
        }
    };

    /**
     * 子线程进行下载保存工作
     * 初始化子线程
     */
    class InitThread extends Thread {
        private FileInfo thread_fileInfo = null;
        private RandomAccessFile raf;

        public InitThread(FileInfo fileInfo) {
            this.thread_fileInfo = fileInfo;
        }

        @Override
        public void run() {
            //连接网络文件
            HttpURLConnection conn = null;
            try {
                URL url = new URL(thread_fileInfo.getUrl());
                conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                conn.setConnectTimeout(3000);
                int length = -1;
                if (conn.getResponseCode() == 200) {
                    //获得文件长度
                    length = conn.getContentLength();
                }
                if (length <= 0) {
                    return;
                }
                File dir = new File(DOWNLOAD_PATH);
                if (!dir.exists()) {   //判断如果不存在则创建一个文件
                    dir.mkdir();
                }
                //在本地创建文件
                File file = new File(dir, thread_fileInfo.getFileName());
                //随机访问的文件 可以在文件的任意一个位置进行写入操作
                //rwd可读可写可操作
                raf = new RandomAccessFile(file, "rwd");
                //设置文件长度
                raf.setLength(length);
                thread_fileInfo.setLength(length);
                mhandler.obtainMessage(MSG_INIT, thread_fileInfo).sendToTarget();
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (conn != null && raf != null) {
                        raf.close();  //关闭文件操作
                        conn.disconnect();  //断掉链接
                    }

                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            super.run();
        }
    }
}

DownloadTask.java

/**
 * 下载的任务类   对文件的下载
 * Created by lung on 2016-12-07.
 */
public class DownloadTask {
    private Context mContext = null;
    private FileInfo mFileInfo = null;
    private ThreadDAOImpl mThreadDAO = null;
    private long mFinished = 0;   //总的完成进度
    public boolean isPause = false;   //暂停下载的开关

    public DownloadTask(Context mContext, FileInfo mFileInfo) {
        this.mContext = mContext;
        this.mFileInfo = mFileInfo;
        mThreadDAO = new ThreadDAOImpl(mContext);
    }

    //下载的方法
    public void download() {
        //读取数据库的线程信息
        List<TheardInfo> threaddInfos = mThreadDAO.getThreads(mFileInfo.getUrl());
        TheardInfo info;
        if (threaddInfos.size() == 0) {  //如果数据库无线程信息
            info = new TheardInfo(0, mFileInfo.getUrl(), 0, mFileInfo.getLength(), 0);
        } else {
            info = threaddInfos.get(0);//单线程的下载 所以使用get(0)
        }
        //创建子线程进行下载
        new DownloadThread(info).start();
    }

    class DownloadThread extends Thread {
        private TheardInfo threadInfo;

        public DownloadThread(TheardInfo threadInfo) {
            this.threadInfo = threadInfo;
        }

        @Override
        public void run() {
            //向数据库插入线程信息
            if (!mThreadDAO.isExists(threadInfo.getUrl(), threadInfo.getId())) {
                mThreadDAO.insertThread(threadInfo);
            }
            //设置下载位置
            try {
                URL url = new URL(threadInfo.getUrl());
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                conn.setConnectTimeout(3000);
                //开始的字节数 为开始加上完成的长度
                long start = threadInfo.getStart() + threadInfo.getFinished();
                //下载的范围  开始的字节数 到结束的字节数
                conn.setRequestProperty("Range", "bytes=" + start + "-" + threadInfo.getEnd());
                //设置文件写入位置   路径 文件名
                File file = new File(DownloadService.DOWNLOAD_PATH, mFileInfo.getFileName());
                //
                RandomAccessFile raf = new RandomAccessFile(file, "rwd");
                raf.seek(start);  //文件的写入位置
                Intent intent = new Intent(DownloadService.ACTION_UPDATE);//把进度广播发送给activity 所以需要intent
                mFinished += threadInfo.getFinished();//从线程中拿到完成的进度
                //开始下载
                if (conn.getResponseCode() == 206) {
                    //读取数据
                    InputStream input = conn.getInputStream();
                    byte[] buffer = new byte[1024 * 4];
                    int len = -1;
                    long time = System.currentTimeMillis();  //拿到当前时间
                    while ((len = input.read(buffer)) != -1) {
                        //写入文件
                        raf.write(buffer, 0, len);
                        //把下载进度发送广播给activity
                        mFinished += len; //把现在下载的进度累加进去
                        if (System.currentTimeMillis() - time > 1000) {   //减少ni负载 大于10秒发送更新
                            time = System.currentTimeMillis();
                            //以百分比的形式发送给广播
                            intent.putExtra("finished", (int) (mFinished * 100 / mFileInfo.getLength()));
                            mContext.sendBroadcast(intent);
                        }
                        //在下载暂停时，保存下载进度
                        if (isPause) {     //如果暂停   把线程信息进行保存
                            mThreadDAO.updateThread(mFileInfo.getUrl(), mFileInfo.getId(), mFinished);
                            return;
                        }
                    }
                    intent.putExtra("finished",100);
                    mContext.sendBroadcast(intent);  //发送广播
                    //下载完成后  删除线程信息
                    mThreadDAO.deleteThread(threadInfo.getUrl(), threadInfo.getId());
                    input.close();
                }
                raf.close();
                conn.disconnect();
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {   //关闭各种链接

            }
            super.run();
        }
    }
}

总结
文件下载是如何实现的
1 设置下载位置      若有暂停 从暂停处开始
2 设置文件写入位置  即保存在哪里
3 正常的文件读写  最后别完了删除线程信息
4 断点续传怎么实现
在下载进程的时候，把进度保存到数据库中了；再次开始下载的时候，从数据库中访问线程信息，若存在则传到子线程，把Finish完成的进度累加起来
5 Service起到了什么作用？
为了保证能够在后台下载不被退出程序所打断！

附上Demo：http://download.csdn.net/detail/qq_27489007/9722868