Android基于HTTP协议的多线程断点下载器的实现

一、首先写这篇文章之前,要了解实现该Android多线程断点下载器的几个知识点

1.多线程下载的原理,如下图所示

注意:由于Android移动设备和PC机的处理器还是不能相比,所以开辟的子线程建议不要多于5条。当然现在某些高端机子的处理器能力比较强了,就可以多开辟几条子线程。

2、为了实现断点下载,采用数据库方式记录下载的进度,这样当你将该应用退出后,下次点击下载的时候,程序会去查看该下载链接是否存在下载记录,如果存在下载记录就会判断下载的进度,如何从上次下载的进度继续开始下载。

3、特别注意在主线程里不能执行一件比较耗时的工作,否则会因主线程阻塞而无法处理用户的输入事件,导致“应用无响应”错误的出现。耗时的工作应该在子线程里执行。

4、UI控件画面的重绘(更新)是由主线程负责处理的,不能在子线程中更新UI控件的值。可以采用Handler机制,在主线程创建Handler对象,在子线程发送消息给主线程所绑定的消息队列,从消息中获取UI控件的值,然后在主线程中进行UI控件的重绘(更新)工作。
5、了解HTTP协议各个头字段的含义

 

二、将该下载器的具体实现代码展现出来

step1、首先查看整个Android项目的结构图

                                

 

step2:设计应用的UI界面   /layout/activity_main.xml

 

[html][/html] view plaincopy

  1. <span style=”font-size:18px;”><LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android”
  2.     android:orientation=”vertical” android:layout_width=”fill_parent”
  3.     android:layout_height=”fill_parent”>
  4.     <TextView
  5.         android:layout_width=”fill_parent”
  6.         android:layout_height=”wrap_content”
  7.         android:text=”@string/path” />
  8.     <EditText
  9.         android:id=”@+id/path”
  10.         android:layout_width=”fill_parent”
  11.         android:layout_height=”wrap_content”
  12.         android:text=”http://192.168.1.100:8080/Hello/a.mp4″ />
  13.     <LinearLayout
  14.         android:layout_width=”fill_parent”
  15.         android:layout_height=”wrap_content”
  16.         android:orientation=”horizontal” >
  17.         <Button
  18.             android:id=”@+id/downloadbutton”
  19.             android:layout_width=”wrap_content”
  20.             android:layout_height=”wrap_content”
  21.             android:text=”@string/startbutton” />
  22.         <Button
  23.             android:id=”@+id/stopbutton”
  24.             android:layout_width=”wrap_content”
  25.             android:layout_height=”wrap_content”
  26.             android:enabled=”false”
  27.             android:text=”@string/stopbutton” />
  28.     </LinearLayout>
  29.     <ProgressBar
  30.         android:id=”@+id/progressBar”
  31.         style=”?android:attr/progressBarStyleHorizontal”
  32.         android:layout_width=”fill_parent”
  33.         android:layout_height=”18dp” />
  34.     <TextView
  35.         android:id=”@+id/resultView”
  36.         android:layout_width=”fill_parent”
  37.         android:layout_height=”wrap_content”
  38.         android:gravity=”center” />
  39. </LinearLayout></span>

 

 

/values/string.xml

 

[html][/html] view plaincopy

  1. <span style=”font-size:18px;”><?xml version=”1.0″ encoding=”utf-8″?>
  2. <resources>
  3.     <string name=”action_settings”>Settings</string>
  4.     <string name=”hello_world”>Hello world!</string>
  5.     <string name=”app_name”>多线程断点下载器_欧阳鹏编写</string>
  6.     <string name=”path”>下载路径</string>
  7.     <string name=”startbutton”>开始下载</string>
  8.     <string name=”success”>下载完成</string>
  9.     <string name=”error”>下载失败</string>
  10.     <string name=”stopbutton”>停止下载</string>
  11.     <string name=”sdcarderror”>SDCard不存在或者写保护</string>
  12. </resources></span>

 

 

step3、程序主应用 cn.oyp.download.MainActivity.java文件

 

[java][/java] view plaincopy

  1. <span style=”font-size:18px;”>package cn.oyp.download;
  2. import java.io.File;
  3. import android.app.Activity;
  4. import android.os.Bundle;
  5. import android.os.Environment;
  6. import android.os.Handler;
  7. import android.os.Message;
  8. import android.view.View;
  9. import android.widget.Button;
  10. import android.widget.EditText;
  11. import android.widget.ProgressBar;
  12. import android.widget.TextView;
  13. import android.widget.Toast;
  14. import cn.oyp.download.downloader.DownloadProgressListener;
  15. import cn.oyp.download.downloader.FileDownloader;
  16. public class MainActivity extends Activity {
  17.     /** 下载路径文本框 **/
  18.     private EditText pathText;
  19.     /** 下载按钮 **/
  20.     private Button downloadButton;
  21.     /** 停止下载按钮 **/
  22.     private Button stopbutton;
  23.     /** 下载进度条 **/
  24.     private ProgressBar progressBar;
  25.     /** 下载结果文本框,显示下载的进度值 **/
  26.     private TextView resultView;
  27.     /** Hanlder的作用是用于往创建Hander对象所在的线程所绑定的消息队列发送消息 **/
  28.     private Handler handler = new UIHander();
  29.     @Override
  30.     protected void onCreate(Bundle savedInstanceState) {
  31.         super.onCreate(savedInstanceState);
  32.         setContentView(R.layout.activity_main);
  33.         /** 初始化各控件 **/
  34.         pathText = (EditText) this.findViewById(R.id.path);
  35.         downloadButton = (Button) this.findViewById(R.id.downloadbutton);
  36.         stopbutton = (Button) this.findViewById(R.id.stopbutton);
  37.         progressBar = (ProgressBar) this.findViewById(R.id.progressBar);
  38.         resultView = (TextView) this.findViewById(R.id.resultView);
  39.         /** 设置按钮的监听 **/
  40.         ButtonClickListener listener = new ButtonClickListener();
  41.         downloadButton.setOnClickListener(listener);
  42.         stopbutton.setOnClickListener(listener);
  43.     }
  44.     /**
  45.      * Hanlder的作用是用于往创建Hander对象所在的线程所绑定的消息队列发送消息
  46.      */
  47.     private final class UIHander extends Handler {
  48.         public void handleMessage(Message msg) {
  49.             switch (msg.what) {
  50.             case 1:
  51.                 int size = msg.getData().getInt(“size”); // 获取下载的进度值
  52.                 progressBar.setProgress(size); // 实时更新,设置下载进度值
  53.                 /** 计算下载的进度百分比 */
  54.                 float num = (float) progressBar.getProgress()
  55.                         / (float) progressBar.getMax();
  56.                 int result = (int) (num * 100);
  57.                 resultView.setText(result + “%”); // 设置下载结果文本框显示下载的进度值
  58.                 // 如果进度达到了进度最大值,即下载完毕
  59.                 if (progressBar.getProgress() == progressBar.getMax()) {
  60.                     Toast.makeText(getApplicationContext(), R.string.success, 1)
  61.                             .show();// 下载成功
  62.                 }
  63.                 break;
  64.             case -1:
  65.                 Toast.makeText(getApplicationContext(), R.string.error, 1)
  66.                         .show();// 下载出错
  67.                 break;
  68.             }
  69.         }
  70.     }
  71.     /**
  72.      * 按钮监听类
  73.      */
  74.     private final class ButtonClickListener implements View.OnClickListener {
  75.         public void onClick(View v) {
  76.             switch (v.getId()) {
  77.             /** 如果是下载按钮 */
  78.             case R.id.downloadbutton:
  79.                 String path = pathText.getText().toString();// 获取下载路径
  80.                 // 判断SD卡是否存在并且可写
  81.                 if (Environment.getExternalStorageState().equals(
  82.                         Environment.MEDIA_MOUNTED)) {
  83.                     // 获取SD卡的路径
  84.                     File saveDir = Environment.getExternalStorageDirectory();
  85.                     // 开始下载的相关操作
  86.                     download(path, saveDir);
  87.                 } else {
  88.                     Toast.makeText(getApplicationContext(),
  89.                             R.string.sdcarderror, 1).show();
  90.                 }
  91.                 downloadButton.setEnabled(false);
  92.                 stopbutton.setEnabled(true);
  93.                 break;
  94.             /** 如果是停止下载按钮 */
  95.             case R.id.stopbutton:
  96.                 exit();// 退出下载
  97.                 downloadButton.setEnabled(true);
  98.                 stopbutton.setEnabled(false);
  99.                 break;
  100.             }
  101.         }
  102.         /**
  103.          * UI控件画面的重绘(更新)是由主线程负责处理的,如果在子线程中更新UI控件的值,更新后的值不会重绘到屏幕上
  104.          * 一定要在主线程里更新UI控件的值,这样才能在屏幕上显示出来,不能在子线程中更新UI控件的值
  105.          * 借用Handler来传送UI控件的值到主线程去,在主线程更新UI控件的值
  106.          */
  107.         private final class DownloadTask implements Runnable {
  108.             /** 下载路径 */
  109.             private String path;
  110.             /** 保存路径 */
  111.             private File saveDir;
  112.             /** 文件下载器 */
  113.             private FileDownloader loader;
  114.             /**
  115.              * DownloadTask的构造函数
  116.              *
  117.              * @param path
  118.              *            下载路径
  119.              * @param saveDir
  120.              *            保存路径
  121.              */
  122.             public DownloadTask(String path, File saveDir) {
  123.                 this.path = path;
  124.                 this.saveDir = saveDir;
  125.             }
  126.             /**
  127.              * 线程主方法
  128.              */
  129.             public void run() {
  130.                 try {
  131.                     /**
  132.                      * 构建文件下载器 将下载路径,文件保存目录,下载线程数指定好
  133.                      */
  134.                     loader = new FileDownloader(getApplicationContext(), path,
  135.                             saveDir, 5);
  136.                     progressBar.setMax(loader.getFileSize());// 设置进度条的最大刻度(即文件的总长度)
  137.                     /**
  138.                      * DownloadProgressListener是一个接口,onDownloadSize()为未实现的方法。
  139.                      * onDownloadSize()方法会在download方法内部被动态赋值
  140.                      * 监听下载数量的变化,如果不需要了解实时下载的数量,可以设置为null
  141.                      */
  142.                     loader.download(new DownloadProgressListener() {
  143.                         public void onDownloadSize(int size) {
  144.                             // 借用Handler来传送UI控件的值到主线程去,在主线程更新UI控件的值
  145.                             Message msg = new Message();
  146.                             msg.what = 1; // 对应UIHander 获得的msg.what
  147.                             msg.getData().putInt(“size”, size); // 将获取的值发送给handler,用于动态更新进度
  148.                             handler.sendMessage(msg);
  149.                         }
  150.                     });
  151.                 } catch (Exception e) {
  152.                     e.printStackTrace();
  153.                     // 对应UIHander 获得的msg.what
  154.                     handler.sendMessage(handler.obtainMessage(-1));
  155.                 }
  156.             }
  157.             /**
  158.              * 退出下载
  159.              */
  160.             public void exit() {
  161.                 if (loader != null)
  162.                     loader.exit();
  163.             }
  164.         }
  165.         /** end of DownloadTask */
  166.         /**
  167.          * 由于用户的输入事件(点击button, 触摸屏幕….)是由主线程负责处理的,如果主线程处于工作状态,
  168.          * 此时用户产生的输入事件如果没能在5秒内得到处理,系统就会报“应用无响应”错误。
  169.          * 所以在主线程里不能执行一件比较耗时的工作,否则会因主线程阻塞而无法处理用户的输入事件,
  170.          * 导致“应用无响应”错误的出现。耗时的工作应该在子线程里执行。
  171.          */
  172.         private DownloadTask task;
  173.         /**
  174.          * 退出下载
  175.          */
  176.         public void exit() {
  177.             if (task != null)
  178.                 task.exit();
  179.         }
  180.         /**
  181.          * 下载方法,运行在主线程,负责开辟子线程完成下载操作,这操作耗时不超过1秒
  182.          *
  183.          * @param path
  184.          *            下载路径
  185.          * @param saveDir
  186.          *            保存路径
  187.          */
  188.         private void download(String path, File saveDir) {
  189.             task = new DownloadTask(path, saveDir);
  190.             new Thread(task).start();// 开辟子线程完成下载操作
  191.         }
  192.     }
  193.     /** end of ButtonClickListener **/
  194. }
  195. </span>

文件下载器cn.oyp.download.downloader.FileDownloader.java文件

 

 

[java][/java] view plaincopy

  1. <span style=”font-size:18px;”>package cn.oyp.download.downloader;
  2. import java.io.File;
  3. import java.io.RandomAccessFile;
  4. import java.net.HttpURLConnection;
  5. import java.net.URL;
  6. import java.util.LinkedHashMap;
  7. import java.util.Map;
  8. import java.util.UUID;
  9. import java.util.concurrent.ConcurrentHashMap;
  10. import java.util.regex.Matcher;
  11. import java.util.regex.Pattern;
  12. import cn.oyp.download.service.FileService;
  13. import android.content.Context;
  14. import android.util.Log;
  15. /**
  16.  * 文件下载器
  17.  */
  18. public class FileDownloader {
  19.     private static final String TAG = “FileDownloader”;
  20.     /** 上下文 */
  21.     private Context context;
  22.     /** 文件下载服务类 */
  23.     private FileService fileService;
  24.     /** 是否停止下载 */
  25.     private boolean exit;
  26.     /** 已下载文件长度 */
  27.     private int downloadSize = 0;
  28.     /** 原始文件长度 */
  29.     private int fileSize = 0;
  30.     /** 用于下载的线程数组 */
  31.     private DownloadThread[] threads;
  32.     /** 本地保存文件 */
  33.     private File saveFile;
  34.     /** 缓存各线程下载的长度 */
  35.     private Map<Integer, Integer> data = new ConcurrentHashMap<Integer, Integer>();
  36.     /** 每条线程下载的长度 */
  37.     private int block;
  38.     /** 下载路径 */
  39.     private String downloadUrl;
  40.     /**
  41.      * 获取线程数
  42.      */
  43.     public int getThreadSize() {
  44.         return threads.length;
  45.     }
  46.     /**
  47.      * 退出下载
  48.      */
  49.     public void exit() {
  50.         this.exit = true;
  51.     }
  52.     /**
  53.      * 是否退出下载
  54.      */
  55.     public boolean getExit() {
  56.         return this.exit;
  57.     }
  58.     /**
  59.      * 获取文件大小
  60.      */
  61.     public int getFileSize() {
  62.         return fileSize;
  63.     }
  64.     /**
  65.      * 累计已下载大小
  66.      * 该方法在具体某个线程下载的时候会被调用
  67.      */
  68.     protected synchronized void append(int size) {
  69.         downloadSize += size;
  70.     }
  71.     /**
  72.      * 更新指定线程最后下载的位置
  73.      * 该方法在具体某个线程下载的时候会被调用
  74.      * @param threadId
  75.      *            线程id
  76.      * @param pos
  77.      *            最后下载的位置
  78.      */
  79.     protected synchronized void update(int threadId, int pos) {
  80.         // 缓存各线程下载的长度
  81.         this.data.put(threadId, pos);
  82.         // 更新数据库中的各线程下载的长度
  83.         this.fileService.update(this.downloadUrl, threadId, pos);
  84.     }
  85.     /**
  86.      * 构建文件下载器
  87.      *
  88.      * @param downloadUrl
  89.      *            下载路径
  90.      * @param fileSaveDir
  91.      *            文件保存目录
  92.      * @param threadNum
  93.      *            下载线程数
  94.      */
  95.     public FileDownloader(Context context, String downloadUrl,
  96.             File fileSaveDir, int threadNum) {
  97.         try {
  98.             this.context = context;
  99.             this.downloadUrl = downloadUrl;
  100.             fileService = new FileService(this.context);
  101.             // 根据指定的下载路径,生成URL
  102.             URL url = new URL(this.downloadUrl);
  103.             if (!fileSaveDir.exists())
  104.                 fileSaveDir.mkdirs();// 如果保存路径不存在,则新建一个目录
  105.             // 根据指定的线程数来新建线程数组
  106.             this.threads = new DownloadThread[threadNum];
  107.             // 打开HttpURLConnection
  108.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();
  109.             // 设置 HttpURLConnection的断开时间
  110.             conn.setConnectTimeout(5 * 1000);
  111.             // 设置 HttpURLConnection的请求方式
  112.             conn.setRequestMethod(“GET”);
  113.             // 设置 HttpURLConnection的接收的文件类型
  114.             conn.setRequestProperty(
  115.                     “Accept”,
  116.                     “image/gif, image/jpeg, image/pjpeg, image/pjpeg, “
  117.                             + “application/x-shockwave-flash, application/xaml+xml, “
  118.                             + “application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, “
  119.                             + “application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*”);
  120.             // 设置 HttpURLConnection的接收语音
  121.             conn.setRequestProperty(“Accept-Language”, “zh-CN”);
  122.             // 指定请求uri的源资源地址
  123.             conn.setRequestProperty(“Referer”, downloadUrl);
  124.             // 设置 HttpURLConnection的字符编码
  125.             conn.setRequestProperty(“Charset”, “UTF-8”);
  126.             // 检查浏览页面的访问者在用什么操作系统(包括版本号)浏览器(包括版本号)和用户个人偏好
  127.             conn.setRequestProperty(
  128.                     “User-Agent”,
  129.                     “Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2;”
  130.                             + ” Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.50727; “
  131.                             + “.NET CLR 3.0.04506.30; .NET CLR 3.0.4506.2152;”
  132.                             + ” .NET CLR 3.5.30729)”);
  133.             conn.setRequestProperty(“Connection”, “Keep-Alive”);
  134.             conn.connect();
  135.             // 打印Http协议头
  136.             printResponseHeader(conn);
  137.             // 如果返回的状态码为200表示正常
  138.             if (conn.getResponseCode() == 200) {
  139.                 this.fileSize = conn.getContentLength();// 根据响应获取文件大小
  140.                 if (this.fileSize <= 0)
  141.                     throw new RuntimeException(“Unkown file size “);
  142.                 String filename = getFileName(conn);// 获取文件名称
  143.                 this.saveFile = new File(fileSaveDir, filename);// 构建保存文件
  144.                 Map<Integer, Integer> logdata = fileService
  145.                         .getData(downloadUrl);// 获取下载记录
  146.                 if (logdata.size() > 0) {// 如果存在下载记录
  147.                     for (Map.Entry<Integer, Integer> entry : logdata.entrySet())
  148.                         data.put(entry.getKey(), entry.getValue());// 把各条线程已经下载的数据长度放入data中
  149.                 }
  150.                 if (this.data.size() == this.threads.length) {// 下面计算所有线程已经下载的数据总长度
  151.                     for (int i = 0; i < this.threads.length; i++) {
  152.                         this.downloadSize += this.data.get(i + 1);
  153.                     }
  154.                     print(“已经下载的长度” + this.downloadSize);
  155.                 }
  156.                 // 计算每条线程下载的数据长度
  157.                 this.block = (this.fileSize % this.threads.length) == 0 ? this.fileSize
  158.                         / this.threads.length
  159.                         : this.fileSize / this.threads.length + 1;
  160.             } else {
  161.                 throw new RuntimeException(“server no response “);
  162.             }
  163.         } catch (Exception e) {
  164.             print(e.toString());
  165.             throw new RuntimeException(“don’t connection this url”);
  166.         }
  167.     }
  168.     /**
  169.      * 获取文件名
  170.      *
  171.      * @param conn
  172.      *            Http连接
  173.      */
  174.     private String getFileName(HttpURLConnection conn) {
  175.         String filename = this.downloadUrl.substring(this.downloadUrl
  176.                 .lastIndexOf(‘/’) + 1);// 截取下载路径中的文件名
  177.         // 如果获取不到文件名称
  178.         if (filename == null || “”.equals(filename.trim())) {
  179.             // 通过截取Http协议头分析下载的文件名
  180.             for (int i = 0;; i++) {
  181.                 String mine = conn.getHeaderField(i);
  182.                 if (mine == null)
  183.                     break;
  184.                 /**
  185.                  * Content-disposition 是 MIME 协议的扩展,MIME 协议指示 MIME
  186.                  * 用户代理如何显示附加的文件。
  187.                  * Content-Disposition就是当用户想把请求所得的内容存为一个文件的时候提供一个默认的文件名
  188.                  * 协议头中的Content-Disposition格式如下:
  189.                  * Content-Disposition”,”attachment;filename=FileName.txt”);
  190.                  */
  191.                 if (“content-disposition”.equals(conn.getHeaderFieldKey(i)
  192.                         .toLowerCase())) {
  193.                     // 通过正则表达式匹配出文件名
  194.                     Matcher m = Pattern.compile(“.*filename=(.*)”).matcher(
  195.                             mine.toLowerCase());
  196.                     // 如果匹配到了文件名
  197.                     if (m.find())
  198.                         return m.group(1);// 返回匹配到的文件名
  199.                 }
  200.             }
  201.             // 如果还是匹配不到文件名,则默认取一个随机数文件名
  202.             filename = UUID.randomUUID() + “.tmp”;
  203.         }
  204.         return filename;
  205.     }
  206.     /**
  207.      * 开始下载文件
  208.      *
  209.      * @param listener
  210.      *            监听下载数量的变化,如果不需要了解实时下载的数量,可以设置为null
  211.      * @return 已下载文件大小
  212.      * @throws Exception
  213.      */
  214.     public int download(DownloadProgressListener listener) throws Exception {
  215.         try {
  216.             RandomAccessFile randOut = new RandomAccessFile(this.saveFile, “rw”);
  217.             if (this.fileSize > 0)
  218.                 randOut.setLength(this.fileSize);
  219.             randOut.close();
  220.             URL url = new URL(this.downloadUrl);
  221.             // 如果原先未曾下载或者原先的下载线程数与现在的线程数不一致
  222.             if (this.data.size() != this.threads.length) {
  223.                 this.data.clear();// 清除原来的线程数组
  224.                 for (int i = 0; i < this.threads.length; i++) {
  225.                     this.data.put(i + 1, 0);// 初始化每条线程已经下载的数据长度为0
  226.                 }
  227.                 this.downloadSize = 0;
  228.             }
  229.             //循环遍历线程数组
  230.             for (int i = 0; i < this.threads.length; i++) {
  231.                 int downLength = this.data.get(i + 1); // 获取当前线程下载的文件长度
  232.                 // 判断线程是否已经完成下载,否则继续下载
  233.                 if (downLength < this.block
  234.                         && this.downloadSize < this.fileSize) {
  235.                     //启动线程开始下载
  236.                     this.threads[i] = new DownloadThread(this, url,
  237.                             this.saveFile, this.block, this.data.get(i + 1),
  238.                             i + 1);
  239.                     this.threads[i].setPriority(7);
  240.                     this.threads[i].start();
  241.                 } else {
  242.                     this.threads[i] = null;
  243.                 }
  244.             }
  245.             //如果存在下载记录,从数据库中删除它们
  246.             fileService.delete(this.downloadUrl);
  247.             //重新保存下载的进度到数据库
  248.             fileService.save(this.downloadUrl, this.data);
  249.             boolean notFinish = true;// 下载未完成
  250.             while (notFinish) {// 循环判断所有线程是否完成下载
  251.                 Thread.sleep(900);
  252.                 notFinish = false;// 假定全部线程下载完成
  253.                 for (int i = 0; i < this.threads.length; i++) {
  254.                     if (this.threads[i] != null && !this.threads[i].isFinish()) {// 如果发现线程未完成下载
  255.                         notFinish = true;// 设置标志为下载没有完成
  256.                         // 如果下载失败,再重新下载
  257.                         if (this.threads[i].getDownLength() == -1) {
  258.                             this.threads[i] = new DownloadThread(this, url,
  259.                                     this.saveFile, this.block,
  260.                                     this.data.get(i + 1), i + 1);
  261.                             this.threads[i].setPriority(7);
  262.                             this.threads[i].start();
  263.                         }
  264.                     }
  265.                 }
  266.                 if (listener != null)
  267.                     listener.onDownloadSize(this.downloadSize);// 通知目前已经下载完成的数据长度
  268.             }
  269.             // 如果下载完成
  270.             if (downloadSize == this.fileSize)
  271.                 fileService.delete(this.downloadUrl);// 下载完成删除记录
  272.         } catch (Exception e) {
  273.             print(e.toString());
  274.             throw new Exception(“file download error”);
  275.         }
  276.         return this.downloadSize;
  277.     }
  278.     /**
  279.      * 获取Http响应头字段
  280.      * @param http
  281.      * @return
  282.      */
  283.     public static Map<String, String> getHttpResponseHeader(
  284.             HttpURLConnection http) {
  285.         Map<String, String> header = new LinkedHashMap<String, String>();
  286.         for (int i = 0;; i++) {
  287.             String mine = http.getHeaderField(i);
  288.             if (mine == null)
  289.                 break;
  290.             header.put(http.getHeaderFieldKey(i), mine);
  291.         }
  292.         return header;
  293.     }
  294.     /**
  295.      * 打印Http头字段
  296.      *
  297.      * @param http
  298.      */
  299.     public static void printResponseHeader(HttpURLConnection http) {
  300.         Map<String, String> header = getHttpResponseHeader(http);
  301.         for (Map.Entry<String, String> entry : header.entrySet()) {
  302.             String key = entry.getKey() != null ? entry.getKey() + “:” : “”;
  303.             print(key + entry.getValue());
  304.         }
  305.     }
  306.     /**
  307.      * 打印信息
  308.      * @param msg  信息
  309.      */
  310.     private static void print(String msg) {
  311.         Log.i(TAG, msg);
  312.     }
  313. }
  314. </span>

 

 

文件下载线程 cn.oyp.download.downloader.DownloadThread.java文件

 

[java][/java] view plaincopy

  1. <span style=”font-size:18px;”>package cn.oyp.download.downloader;
  2. import java.io.File;
  3. import java.io.InputStream;
  4. import java.io.RandomAccessFile;
  5. import java.net.HttpURLConnection;
  6. import java.net.URL;
  7. import android.util.Log;
  8. public class DownloadThread extends Thread {
  9.     private static final String TAG = “DownloadThread”;
  10.     /** 本地保存文件 */
  11.     private File saveFile;
  12.     /** 下载路径 */
  13.     private URL downUrl;
  14.     /** 该线程要下载的长度 */
  15.     private int block;
  16.     /** 线程ID */
  17.     private int threadId = -1;
  18.     /** 该线程已经下载的长度 */
  19.     private int downLength;
  20.     /** 是否下载完成*/
  21.     private boolean finish = false;
  22.     /** 文件下载器 */
  23.     private FileDownloader downloader;
  24.     /***
  25.      *  构造方法
  26.      */
  27.     public DownloadThread(FileDownloader downloader, URL downUrl,
  28.             File saveFile, int block, int downLength, int threadId) {
  29.         this.downUrl = downUrl;
  30.         this.saveFile = saveFile;
  31.         this.block = block;
  32.         this.downloader = downloader;
  33.         this.threadId = threadId;
  34.         this.downLength = downLength;
  35.     }
  36.     /**
  37.      * 线程主方法
  38.      */
  39.     @Override
  40.     public void run() {
  41.         if (downLength < block) {// 未下载完成
  42.             try {
  43.                 HttpURLConnection http = (HttpURLConnection) downUrl
  44.                         .openConnection();
  45.                 http.setConnectTimeout(5 * 1000);
  46.                 http.setRequestMethod(“GET”);
  47.                 http.setRequestProperty(
  48.                         “Accept”,
  49.                         “image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash,”
  50.                                 + ” application/xaml+xml, application/vnd.ms-xpsdocument, application/x-ms-xbap, “
  51.                                 + “application/x-ms-application, application/vnd.ms-excel,”
  52.                                 + ” application/vnd.ms-powerpoint, application/msword, */*”);
  53.                 http.setRequestProperty(“Accept-Language”, “zh-CN”);
  54.                 http.setRequestProperty(“Referer”, downUrl.toString());
  55.                 http.setRequestProperty(“Charset”, “UTF-8”);
  56.                 // 该线程开始下载位置
  57.                 int startPos = block * (threadId – 1) + downLength;
  58.                 // 该线程下载结束位置
  59.                 int endPos = block * threadId – 1;
  60.                 // 设置获取实体数据的范围
  61.                 http.setRequestProperty(“Range”, “bytes=” + startPos + “-“
  62.                         + endPos);
  63.                 http.setRequestProperty(
  64.                         “User-Agent”,
  65.                         “Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/4.0;”
  66.                                 + ” .NET CLR 1.1.4322; .NET CLR 2.0.50727; “
  67.                                 + “.NET CLR 3.0.04506.30; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)”);
  68.                 http.setRequestProperty(“Connection”, “Keep-Alive”);
  69.                 //获取输入流
  70.                 InputStream inStream = http.getInputStream();
  71.                 byte[] buffer = new byte[1024];
  72.                 int offset = 0;
  73.                 print(“Thread ” + this.threadId
  74.                         + ” start download from position ” + startPos);
  75.                 /**
  76.                  * rwd: 打开以便读取和写入,对于 “rw”,还要求对文件内容的每个更新都同步写入到基础存储设备。
  77.                  * 对于Android移动设备一定要注意同步,否则当移动设备断电的话会丢失数据
  78.                  */
  79.                 RandomAccessFile threadfile = new RandomAccessFile(
  80.                         this.saveFile, “rwd”);
  81.                 //直接移动到文件开始位置下载的
  82.                 threadfile.seek(startPos);
  83.                 while (!downloader.getExit()
  84.                         && (offset = inStream.read(buffer, 0, 1024)) != -1) {
  85.                     threadfile.write(buffer, 0, offset);//开始写入数据到文件
  86.                     downLength += offset;   //该线程以及下载的长度增加
  87.                     downloader.update(this.threadId, downLength);//修改数据库中该线程已经下载的数据长度
  88.                     downloader.append(offset);//文件下载器已经下载的总长度增加
  89.                 }
  90.                 threadfile.close();
  91.                 inStream.close();
  92.                 print(“Thread ” + this.threadId + ” download finish”);
  93.                 this.finish = true;
  94.             } catch (Exception e) {
  95.                 this.downLength = -1;
  96.                 print(“Thread ” + this.threadId + “:” + e);
  97.             }
  98.         }
  99.     }
  100.     private static void print(String msg) {
  101.         Log.i(TAG, msg);
  102.     }
  103.     /**
  104.      * 下载是否完成
  105.      *
  106.      * @return
  107.      */
  108.     public boolean isFinish() {
  109.         return finish;
  110.     }
  111.     /**
  112.      * 已经下载的内容大小
  113.      *
  114.      * @return 如果返回值为-1,代表下载失败
  115.      */
  116.     public long getDownLength() {
  117.         return downLength;
  118.     }
  119. }
  120. </span>

 

 

下载进度监听接口cn.oyp.download.downloader.DownloadProgressListener.java文件

 

[java][/java] view plaincopy

  1. <span style=”font-size:18px;”>package cn.oyp.download.downloader;
  2. /**
  3.  * 下载进度监听接口
  4.  */
  5. public interface DownloadProgressListener {
  6.     /**
  7.      *下载的进度
  8.      */
  9.     public void onDownloadSize(int size);
  10. }
  11. </span>

数据库操作类 cn.oyp.download.service.DBOpenHelper.java类

 

 

[java][/java] view plaincopy

  1. <span style=”font-size:18px;”>package cn.oyp.download.service;
  2. import android.content.Context;
  3. import android.database.sqlite.SQLiteDatabase;
  4. import android.database.sqlite.SQLiteOpenHelper;
  5. public class DBOpenHelper extends SQLiteOpenHelper {
  6.     // 数据库文件的文件名
  7.     private static final String DBNAME = “download.db”;
  8.     // 数据库的版本号
  9.     private static final int VERSION = 1;
  10.     public DBOpenHelper(Context context) {
  11.         super(context, DBNAME, null, VERSION);
  12.     }
  13.     @Override
  14.     public void onCreate(SQLiteDatabase db) {
  15.         db.execSQL(“CREATE TABLE IF NOT EXISTS filedownlog (id integer primary key autoincrement, downpath varchar(100), threadid INTEGER, downlength INTEGER)”);
  16.     }
  17.     @Override
  18.     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  19.         db.execSQL(“DROP TABLE IF EXISTS filedownlog”);
  20.         onCreate(db);
  21.     }
  22. }
  23. </span>

文件下载服务类cn.oyp.download.service.FileService

 

[java][/java] view plaincopy

  1. <span style=”font-size:18px;”>package cn.oyp.download.service;
  2. import java.util.HashMap;
  3. import java.util.Map;
  4. import android.content.Context;
  5. import android.database.Cursor;
  6. import android.database.sqlite.SQLiteDatabase;
  7. /**
  8.  * 文件下载服务类
  9.  */
  10. public class FileService {
  11.     private DBOpenHelper openHelper;
  12.     public FileService(Context context) {
  13.         openHelper = new DBOpenHelper(context);
  14.     }
  15.     /**
  16.      * 获取每条线程已经下载的文件长度
  17.      *
  18.      * @param path
  19.      * @return
  20.      */
  21.     public Map<Integer, Integer> getData(String path) {
  22.         SQLiteDatabase db = openHelper.getReadableDatabase();
  23.         Cursor cursor = db
  24.                 .rawQuery(
  25.                         “select threadid, downlength from filedownlog where downpath=?”,
  26.                         new String[] { path });
  27.         Map<Integer, Integer> data = new HashMap<Integer, Integer>();
  28.         while (cursor.moveToNext()) {
  29.             data.put(cursor.getInt(0), cursor.getInt(1));
  30.         }
  31.         cursor.close();
  32.         db.close();
  33.         return data;
  34.     }
  35.     /**
  36.      * 保存每条线程已经下载的文件长度
  37.      *
  38.      * @param path
  39.      * @param map
  40.      */
  41.     public void save(String path, Map<Integer, Integer> map) {// int threadid,
  42.                                                                 // int position
  43.         SQLiteDatabase db = openHelper.getWritableDatabase();
  44.         db.beginTransaction();
  45.         try {
  46.             for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
  47.                 db.execSQL(
  48.                         “insert into filedownlog(downpath, threadid, downlength) values(?,?,?)”,
  49.                         new Object[] { path, entry.getKey(), entry.getValue() });
  50.             }
  51.             db.setTransactionSuccessful();
  52.         } finally {
  53.             db.endTransaction();
  54.         }
  55.         db.close();
  56.     }
  57.     /**
  58.      * 实时更新每条线程已经下载的文件长度
  59.      *
  60.      * @param path
  61.      * @param map
  62.      */
  63.     public void update(String path, int threadId, int pos) {
  64.         SQLiteDatabase db = openHelper.getWritableDatabase();
  65.         db.execSQL(
  66.                 “update filedownlog set downlength=? where downpath=? and threadid=?”,
  67.                 new Object[] { pos, path, threadId });
  68.         db.close();
  69.     }
  70.     /**
  71.      * 当文件下载完成后,删除对应的下载记录
  72.      *
  73.      * @param path
  74.      */
  75.     public void delete(String path) {
  76.         SQLiteDatabase db = openHelper.getWritableDatabase();
  77.         db.execSQL(“delete from filedownlog where downpath=?”,
  78.                 new Object[] { path });
  79.         db.close();
  80.     }
  81. }
  82. </span>

step4:AndroidManifest.xml

 

[html][/html] view plaincopy

  1. <span style=”font-size:18px;”><?xml version=”1.0″ encoding=”utf-8″?>
  2. <manifest xmlns:android=”http://schemas.android.com/apk/res/android”
  3.     package=”cn.oyp.download”
  4.     android:versionCode=”1″
  5.     android:versionName=”1.0″ >
  6.     <uses-sdk
  7.         android:minSdkVersion=”8″
  8.         android:targetSdkVersion=”17″ />
  9.     <!– 访问Internet权限 –>
  10.     <uses-permission android:name=”android.permission.INTERNET” />
  11.     <!– 在SDCard中创建与删除文件权限 –>
  12.     <uses-permission android:name=”android.permission.MOUNT_UNMOUNT_FILESYSTEMS” />
  13.     <!– 往SDCard写入数据权限 –>
  14.     <uses-permission android:name=”android.permission.WRITE_EXTERNAL_STORAGE” />
  15.     <application
  16.         android:allowBackup=”true”
  17.         android:icon=”@drawable/icon”
  18.         android:label=”@string/app_name”
  19.         android:theme=”@style/AppTheme” >
  20.         <activity
  21.             android:name=”cn.oyp.download.MainActivity”
  22.             android:label=”@string/app_name” >
  23.             <intent-filter>
  24.                 <action android:name=”android.intent.action.MAIN” />
  25.                 <category android:name=”android.intent.category.LAUNCHER” />
  26.             </intent-filter>
  27.         </activity>
  28.     </application>
  29. </manifest></span>

 

 

step5:由于便于本项目的展示,所以新建一个JSP项目,部署到Tomcat服务器上,以供下载。


step6:部署应用,观看运行效果

1、打开应用

2、点击“开始下载”

3.点击“停止下载”

4.点击“开始下载”   会继续上一次的下载进度继续下载

5.退出应用,再进应用

6、点击“开始下载”,会继续上一次退出应用的时候的下载进度继续下载,完成断点下载

 

7.当下载完成的时候

标签