Android網絡編程 --斷點續傳下載文件

Android網絡編程 --斷點續傳下載文件

2014年2月28日 2月最後一天

前言：關於斷點續傳下載文件，這個我好幾個月之前面試的時候就遇到過，那時我確實迷惑了一下，Android開發分兩種，一種是界面開發，一種是研發應用型，面試官問過我屬於哪一種，我記得那次面試對我打擊很大，因爲它證明了我對Android還不夠熟悉，水平還不到家，反正感覺被面試官鄙視了。不過到現在我已經不那麼想了，不管是界面開發還是研發應用，靠的都是動手能力，能做出東西人才是有用之人，面試主要看你對技術有沒有概念，實際開發中誰管你會不會那個技術，反正你給我把效果做出來就行了，做不出東西就給我滾蛋，所以經驗對應屆生來說是一大詬病，所以建議在大學的雛鳥們多動手做點東西出來，而不是死磕大學那些無用的課程。

廢話多了一點，下面我就來介紹本篇博客的技術要點：

HTTP協議，我想上過計算機網絡課程的童鞋肯定不陌生，但是誰又能說自己能把它實際運用上了，只有在實際項目開發的時候纔會用到。Http算是Android網絡中最常用到的網絡協議了，客戶端通過http通信與服務器進行數據交互，GET方法和POST方法想必是再熟悉不過了，本篇博客介紹一個比較實用的技術，斷點續傳下載，光看這個名字就感覺挺高大上，確實是，想實現它需要對http協議有一定的瞭解，並且對多線程機制比較熟悉，還有就是Android中異步更新UI的原理不能讓程序出現卡頓的現象。

在說http斷點續傳之前需要重點了解http協議頭部的Range字段

Range 

　　 用於請求頭中，指定第一個字節的位置和最後一個字節的位置，一般格式：

　　 Range:(unit=first byte pos)-[last byte pos] 

比如你要請求下載一個MP3文件，url爲：http://abv.cn/music/光輝歲月.mp3

你需要通過http發送get請求，請求頭字段可能如下

GET /music/%E5%85%89%E8%BE%89%E5%B2%81%E6%9C%88.mp3 HTTP/1.1
Host: abv.cn
Connection: keep-alive
Accept-Encoding: identity;q=1, *;q=0
User-Agent: Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.16 50.63 Safari/537.36
Accept: */*
Referer: http://abv.cn/music/%E5%85%89%E8%BE%89%E5%B2%81%E6%9C%88.mp3
Accept-Language: zh-CN,zh;q=0.8,en;q=0.6
Range: bytes=0-// 請求內容字節範圍

如果直接請求的話，自然字節從0開始了。

響應頭部字段：

HTTP/1.1 206 Partial Content
Date: Tue, 25 Feb 2014 06:05:26 GMT
Server: Apache/2.4.3 (Unix) OpenSSL/1.0.1c PHP/5.4.7
Last-Modified: Sun, 23 Feb 2014 12:53:00 GMT
ETag: "49aa24-4f31255b92300"
Accept-Ranges: bytes
Content-Length: 4827684// 這個表示文件大小
Content-Range: bytes 0-4827683/4827684// 文件字節範圍
Keep-Alive: timeout=5, max=100
Connection: Keep-Alive
Content-Type: audio/mpeg

關於其他字段的含義，我在這裏就不解釋了，自己動手查去，哪個不懂就查哪個。上面很直觀的展示了請求很響應的內容。

那麼斷點續傳的原理就是通過http請求你想下載內容的字節範圍，假如之前已經下載了一部分，但你有事需要暫停下載，那麼下次下載的時候你接着後面繼續下載就可以了。

但再實際開發中，可能需要下載比較大的文件，並且不能下載太久，這時候我們需要利用多線程來分段下載我們需要的內容。下面是在Android平臺下實現的多線程斷點續傳下載：

http://download.csdn.net/detail/wwj_748/6975041,源碼已經給你們準備好了。

代碼中註釋已經很清楚，小巫在這裏就多說了。

/MultiThreadDownload/src/com/wwj/download/db/DBOpenHelper.java

數據庫幫助類，用於創建保存下載進度的表

package com.wwj.download.db;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

public class DBOpenHelper extends SQLiteOpenHelper {
    private static final String DBNAME = "eric.db";
    private static final int VERSION = 1;

    public DBOpenHelper(Context context) {
        super(context, DBNAME, null, VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        // 創建filedownlog表
        db.execSQL("CREATE TABLE IF NOT EXISTS filedownlog (id integer primary key autoincrement, downpath varchar(100), threadid INTEGER, downlength INTEGER)");
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        db.execSQL("DROP TABLE IF EXISTS filedownlog");
        onCreate(db);
    }
}

/MultiThreadDownload/src/com/wwj/net/download/FileDownloader.java

文件下載器

package com.wwj.net.download;

import java.io.File;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import android.content.Context;
import android.util.Log;

/**
 * 文件下載器
 *
 */
public class FileDownloader {
    private static final String TAG = "FileDownloader";
    private Context context;
    private FileService fileService;
    /* 停止下載 */
    private boolean exit;
    /* 已下載文件長度 */
    private int downloadSize = 0;
    /* 原始文件長度 */
    private int fileSize = 0;
    /* 線程數 */
    private DownloadThread[] threads;
    /* 本地保存文件 */
    private File saveFile;
    /* 緩存各線程下載的長度 */
    private Map<Integer, Integer> data = new ConcurrentHashMap<Integer, Integer>();
    /* 每條線程下載的長度 */
    private int block;
    /* 下載路徑 */
    private String downloadUrl;

    /**
     * 獲取線程數
     */
    public int getThreadSize() {
        return threads.length;
    }

    /**
     * 退出下載
     */
    public void exit() {
        this.exit = true;
    }

    public boolean getExit() {
        return this.exit;
    }

    /**
     * 獲取文件大小
     *
     * @return
     */
    public int getFileSize() {
        return fileSize;
    }

    /**
     * 累計已下載大小
     *
     * @param size
     */
    protected synchronized void append(int size) {
        downloadSize += size;
    }

    /**
     * 更新指定線程最後下載的位置
     *
     * @param threadId
     *            線程id
     * @param pos
     *            最後下載的位置
     */
    protected synchronized void update(int threadId, int pos) {
        this.data.put(threadId, pos);
        this.fileService.update(this.downloadUrl, threadId, pos);
    }

    /**
     * 構建文件下載器
     *
     * @param downloadUrl
     *            下載路徑
     * @param fileSaveDir
     *            文件保存目錄
     * @param threadNum
     *            下載線程數
     */
    public FileDownloader(Context context, String downloadUrl,
            File fileSaveDir, int threadNum) {
        try {
            this.context = context;
            this.downloadUrl = downloadUrl;
            fileService = new FileService(this.context);
            URL url = new URL(this.downloadUrl);
            if (!fileSaveDir.exists()) // 判斷目錄是否存在，如果不存在，創建目錄
                fileSaveDir.mkdirs();
            this.threads = new DownloadThread[threadNum];// 實例化線程數組
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setConnectTimeout(5 * 1000);
            conn.setRequestMethod("GET");
            conn.setRequestProperty(
                    "Accept",
                    "image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, application/xaml+xml, application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*");
            conn.setRequestProperty("Accept-Language", "zh-CN");
            conn.setRequestProperty("Referer", downloadUrl);
            conn.setRequestProperty("Charset", "UTF-8");
            conn.setRequestProperty(
                    "User-Agent",
                    "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)");
            conn.setRequestProperty("Connection", "Keep-Alive");
            conn.connect(); // 連接
            printResponseHeader(conn);
            if (conn.getResponseCode() == 200) { // 響應成功
                this.fileSize = conn.getContentLength();// 根據響應獲取文件大小
                if (this.fileSize <= 0)
                    throw new RuntimeException("Unkown file size ");

                String filename = getFileName(conn);// 獲取文件名稱
                this.saveFile = new File(fileSaveDir, filename);// 構建保存文件
                Map<Integer, Integer> logdata = fileService
                        .getData(downloadUrl);// 獲取下載記錄
                if (logdata.size() > 0) {// 如果存在下載記錄
                    for (Map.Entry<Integer, Integer> entry : logdata.entrySet())
                        data.put(entry.getKey(), entry.getValue());// 把各條線程已經下載的數據長度放入data中
                }
                if (this.data.size() == this.threads.length) {// 下面計算所有線程已經下載的數據總長度
                    for (int i = 0; i < this.threads.length; i++) {
                        this.downloadSize += this.data.get(i + 1);
                    }
                    print("已經下載的長度" + this.downloadSize);
                }
                // 計算每條線程下載的數據長度
                this.block = (this.fileSize % this.threads.length) == 0 ? this.fileSize
                        / this.threads.length
                        : this.fileSize / this.threads.length + 1;
            } else {
                throw new RuntimeException("server no response ");
            }
        } catch (Exception e) {
            print(e.toString());
            throw new RuntimeException("don't connection this url");
        }
    }

    /**
     * 獲取文件名
     */
    private String getFileName(HttpURLConnection conn) {
        String filename = this.downloadUrl.substring(this.downloadUrl
                .lastIndexOf('/') + 1);
        if (filename == null || "".equals(filename.trim())) {// 如果獲取不到文件名稱
            for (int i = 0;; i++) {
                String mine = conn.getHeaderField(i);
                if (mine == null)
                    break;
                if ("content-disposition".equals(conn.getHeaderFieldKey(i)
                        .toLowerCase())) {
                    Matcher m = Pattern.compile(".*filename=(.*)").matcher(
                            mine.toLowerCase());
                    if (m.find())
                        return m.group(1);
                }
            }
            filename = UUID.randomUUID() + ".tmp";// 默認取一個文件名
        }
        return filename;
    }

    /**
     * 開始下載文件
     *
     * @param listener
     *            監聽下載數量的變化,如果不需要了解實時下載的數量,可以設置爲null
     * @return 已下載文件大小
     * @throws Exception
     */
    public int download(DownloadProgressListener listener) throws Exception {
        try {
            RandomAccessFile randOut = new RandomAccessFile(this.saveFile, "rw");
            if (this.fileSize > 0)
                randOut.setLength(this.fileSize); // 預分配fileSize大小
            randOut.close();
            URL url = new URL(this.downloadUrl);
            if (this.data.size() != this.threads.length) {// 如果原先未曾下載或者原先的下載線程數與現在的線程數不一致
                this.data.clear();
                for (int i = 0; i < this.threads.length; i++) {
                    this.data.put(i + 1, 0);// 初始化每條線程已經下載的數據長度爲0
                }
                this.downloadSize = 0;
            }
            for (int i = 0; i < this.threads.length; i++) {// 開啓線程進行下載
                int downLength = this.data.get(i + 1);
                if (downLength < this.block
                        && this.downloadSize < this.fileSize) {// 判斷線程是否已經完成下載,否則繼續下載
                    this.threads[i] = new DownloadThread(this, url,
                            this.saveFile, this.block, this.data.get(i + 1),
                            i + 1);
                    this.threads[i].setPriority(7); // 設置線程優先級
                    this.threads[i].start();
                } else {
                    this.threads[i] = null;
                }
            }
            fileService.delete(this.downloadUrl);// 如果存在下載記錄，刪除它們，然後重新添加
            fileService.save(this.downloadUrl, this.data);
            boolean notFinish = true;// 下載未完成
            while (notFinish) {// 循環判斷所有線程是否完成下載
                Thread.sleep(900);
                notFinish = false;// 假定全部線程下載完成
                for (int i = 0; i < this.threads.length; i++) {
                    if (this.threads[i] != null && !this.threads[i].isFinish()) {// 如果發現線程未完成下載
                        notFinish = true;// 設置標誌爲下載沒有完成
                        if (this.threads[i].getDownLength() == -1) {// 如果下載失敗,再重新下載
                            this.threads[i] = new DownloadThread(this, url,
                                    this.saveFile, this.block,
                                    this.data.get(i + 1), i + 1);
                            this.threads[i].setPriority(7);
                            this.threads[i].start();
                        }
                    }
                }
                if (listener != null)
                    listener.onDownloadSize(this.downloadSize);// 通知目前已經下載完成的數據長度
            }
            if (downloadSize == this.fileSize)
                fileService.delete(this.downloadUrl);// 下載完成刪除記錄
        } catch (Exception e) {
            print(e.toString());
            throw new Exception("file download error");
        }
        return this.downloadSize;
    }

    /**
     * 獲取Http響應頭字段
     *
     * @param http
     * @return
     */
    public static Map<String, String> getHttpResponseHeader(
            HttpURLConnection http) {
        Map<String, String> header = new LinkedHashMap<String, String>();
        for (int i = 0;; i++) {
            String mine = http.getHeaderField(i);
            if (mine == null)
                break;
            header.put(http.getHeaderFieldKey(i), mine);
        }
        return header;
    }

    /**
     * 打印Http頭字段
     *
     * @param http
     */
    public static void printResponseHeader(HttpURLConnection http) {
        Map<String, String> header = getHttpResponseHeader(http);
        for (Map.Entry<String, String> entry : header.entrySet()) {
            String key = entry.getKey() != null ? entry.getKey() + ":" : "";
            print(key + entry.getValue());
        }
    }

    private static void print(String msg) {
        Log.i(TAG, msg);
    }
}

/MultiThreadDownload/src/com/wwj/net/download/FileService.java

package com.wwj.net.download;

import java.util.HashMap;
import java.util.Map;

import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;

import com.wwj.download.db.DBOpenHelper;

/**
 * 業務bean
 *
 */
public class FileService {
    private DBOpenHelper openHelper;

    public FileService(Context context) {
        openHelper = new DBOpenHelper(context);
    }

    /**
     * 獲取每條線程已經下載的文件長度
     *
     * @param path
     * @return
     */
    public Map<Integer, Integer> getData(String path) {
        SQLiteDatabase db = openHelper.getReadableDatabase();
        Cursor cursor = db
                .rawQuery(
                        "select threadid, downlength from filedownlog where downpath=?",
                        new String[] { path });
        Map<Integer, Integer> data = new HashMap<Integer, Integer>();
        while (cursor.moveToNext()) {
            data.put(cursor.getInt(0), cursor.getInt(1));
        }
        cursor.close();
        db.close();
        return data;
    }

    /**
     * 保存每條線程已經下載的文件長度
     *
     * @param path
     * @param map
     */
    public void save(String path, Map<Integer, Integer> map) {// int threadid,
                                                                // int position
        SQLiteDatabase db = openHelper.getWritableDatabase();
        db.beginTransaction();
        try {
            for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
                db.execSQL(
                        "insert into filedownlog(downpath, threadid, downlength) values(?,?,?)",
                        new Object[] { path, entry.getKey(), entry.getValue() });
            }
            db.setTransactionSuccessful();
        } finally {
            db.endTransaction();
        }
        db.close();
    }

    /**
     * 實時更新每條線程已經下載的文件長度
     *
     * @param path
     * @param map
     */
    public void update(String path, int threadId, int pos) {
        SQLiteDatabase db = openHelper.getWritableDatabase();
        db.execSQL(
                "update filedownlog set downlength=? where downpath=? and threadid=?",
                new Object[] { pos, path, threadId });
        db.close();
    }

    /**
     * 當文件下載完成後，刪除對應的下載記錄
     *
     * @param path
     */
    public void delete(String path) {
        SQLiteDatabase db = openHelper.getWritableDatabase();
        db.execSQL("delete from filedownlog where downpath=?",
                new Object[] { path });
        db.close();
    }

}

/MultiThreadDownload/src/com/wwj/net/download/DownloadThread.java

下載線程類

package com.wwj.net.download;

import java.io.File;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;

import android.util.Log;

public class DownloadThread extends Thread {
    private static final String TAG = "DownloadThread";
    private File saveFile;
    private URL downUrl;
    private int block;
    /* 下載開始位置 */
    private int threadId = -1;
    private int downLength;
    private boolean finish = false;
    private FileDownloader downloader;

    public DownloadThread(FileDownloader downloader, URL downUrl,
            File saveFile, int block, int downLength, int threadId) {
        this.downUrl = downUrl;
        this.saveFile = saveFile;
        this.block = block;
        this.downloader = downloader;
        this.threadId = threadId;
        this.downLength = downLength;
    }

    @Override
    public void run() {
        if (downLength < block) {// 未下載完成
            try {
                HttpURLConnection http = (HttpURLConnection) downUrl
                        .openConnection();
                http.setConnectTimeout(5 * 1000); // 設置連接超時
                http.setRequestMethod("GET"); // 設置請求方法，這裏是“GET”
                // 瀏覽器可接受的MIME類型
                http.setRequestProperty(
                        "Accept",
                        "image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, application/xaml+xml, application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*");
                http.setRequestProperty("Accept-Language", "zh-CN"); // 瀏覽器所希望的語言種類，當服務器能夠提供一種以上的語言版本時要用到
                http.setRequestProperty("Referer", downUrl.toString());// 包含一個URL，用戶從該URL代表的頁面出發訪問當前請求的頁面。
                http.setRequestProperty("Charset", "UTF-8"); // 字符集
                int startPos = block * (threadId - 1) + downLength;// 開始位置
                int endPos = block * threadId - 1;// 結束位置
                http.setRequestProperty("Range", "bytes=" + startPos + "-"
                        + endPos);// 設置獲取實體數據的範圍
                // 瀏覽器類型，如果Servlet返回的內容與瀏覽器類型有關則該值非常有用。
                http.setRequestProperty(
                        "User-Agent",
                        "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)");
                http.setRequestProperty("Connection", "Keep-Alive"); // 設置爲持久連接

                // 得到輸入流
                InputStream inStream = http.getInputStream();
                byte[] buffer = new byte[1024];
                int offset = 0;
                print("Thread " + this.threadId
                        + " start download from position " + startPos);
                // 隨機訪問文件
                RandomAccessFile threadfile = new RandomAccessFile(
                        this.saveFile, "rwd");
                // 定位到pos位置
                threadfile.seek(startPos);
                while (!downloader.getExit()
                        && (offset = inStream.read(buffer, 0, 1024)) != -1) {
                    // 寫入文件
                    threadfile.write(buffer, 0, offset);
                    downLength += offset; // 累加下載的大小
                    downloader.update(this.threadId, downLength); // 更新指定線程下載最後的位置
                    downloader.append(offset); // 累加已下載大小
                }
                threadfile.close();
                inStream.close();
                print("Thread " + this.threadId + " download finish");
                this.finish = true;
            } catch (Exception e) {
                this.downLength = -1;
                print("Thread " + this.threadId + ":" + e);
            }
        }
    }

    private static void print(String msg) {
        Log.i(TAG, msg);
    }

    /**
     * 下載是否完成
     *
     * @return
     */
    public boolean isFinish() {
        return finish;
    }

    /**
     * 已經下載的內容大小
     *
     * @return 如果返回值爲-1,代表下載失敗
     */
    public long getDownLength() {
        return downLength;
    }
}

/MultiThreadDownload/src/com/wwj/net/download/DownloadProgressListener.java

下載進度接口

package com.wwj.net.download;


public interface DownloadProgressListener {
    public void onDownloadSize(int size);
}

/MultiThreadDownload/src/com/wwj/download/MainActivity.java

界面

package com.wwj.download;

import java.io.File;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

import android.app.Activity;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;

import com.wwj.net.download.DownloadProgressListener;
import com.wwj.net.download.FileDownloader;

public class MainActivity extends Activity {
    private static final int PROCESSING = 1;
    private static final int FAILURE = -1;

    private EditText pathText; // url地址
    private TextView resultView;
    private Button downloadButton;
    private Button stopButton;
    private ProgressBar progressBar;

    private Handler handler = new UIHandler();

    private final class UIHandler extends Handler {
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case PROCESSING: // 更新進度
                progressBar.setProgress(msg.getData().getInt("size"));
                float num = (float) progressBar.getProgress()
                        / (float) progressBar.getMax();
                int result = (int) (num * 100); // 計算進度
                resultView.setText(result + "%");
                if (progressBar.getProgress() == progressBar.getMax()) { // 下載完成
                    Toast.makeText(getApplicationContext(), R.string.success,
                            Toast.LENGTH_LONG).show();
                }
                break;
            case FAILURE: // 下載失敗
                Toast.makeText(getApplicationContext(), R.string.error,
                        Toast.LENGTH_LONG).show();
                break;
            }
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        pathText = (EditText) findViewById(R.id.path);
        resultView = (TextView) findViewById(R.id.resultView);
        downloadButton = (Button) findViewById(R.id.downloadbutton);
        stopButton = (Button) findViewById(R.id.stopbutton);
        progressBar = (ProgressBar) findViewById(R.id.progressBar);
        ButtonClickListener listener = new ButtonClickListener();
        downloadButton.setOnClickListener(listener);
        stopButton.setOnClickListener(listener);
    }

    private final class ButtonClickListener implements View.OnClickListener {
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
            case R.id.downloadbutton: // 開始下載
                // http://abv.cn/music/光輝歲月.mp3，可以換成其他文件下載的鏈接
                String path = pathText.getText().toString();
                String filename = path.substring(path.lastIndexOf('/') + 1);

                try {
                    // URL編碼（這裏是爲了將中文進行URL編碼）
                    filename = URLEncoder.encode(filename, "UTF-8");
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }

                path = path.substring(0, path.lastIndexOf("/") + 1) + filename;
                if (Environment.getExternalStorageState().equals(
                        Environment.MEDIA_MOUNTED)) {
                    // File savDir =
                    // Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MOVIES);
                    // 保存路徑
                    File savDir = Environment.getExternalStorageDirectory();
                    download(path, savDir);
                } else {
                    Toast.makeText(getApplicationContext(),
                            R.string.sdcarderror, Toast.LENGTH_LONG).show();
                }
                downloadButton.setEnabled(false);
                stopButton.setEnabled(true);
                break;
            case R.id.stopbutton: // 暫停下載
                exit();
                Toast.makeText(getApplicationContext(),
                        "Now thread is Stopping!!", Toast.LENGTH_LONG).show();
                downloadButton.setEnabled(true);
                stopButton.setEnabled(false);
                break;
            }
        }

        /*
         * 由於用戶的輸入事件(點擊button, 觸摸屏幕....)是由主線程負責處理的，如果主線程處於工作狀態，
         * 此時用戶產生的輸入事件如果沒能在5秒內得到處理，系統就會報“應用無響應”錯誤。
         * 所以在主線程裏不能執行一件比較耗時的工作，否則會因主線程阻塞而無法處理用戶的輸入事件，
         * 導致“應用無響應”錯誤的出現。耗時的工作應該在子線程裏執行。
         */
        private DownloadTask task;

        private void exit() {
            if (task != null)
                task.exit();
        }

        private void download(String path, File savDir) {
            task = new DownloadTask(path, savDir);
            new Thread(task).start();
        }

        /**
         *
         * UI控件畫面的重繪(更新)是由主線程負責處理的，如果在子線程中更新UI控件的值，更新後的值不會重繪到屏幕上
         * 一定要在主線程裏更新UI控件的值，這樣才能在屏幕上顯示出來，不能在子線程中更新UI控件的值
         *
         */
        private final class DownloadTask implements Runnable {
            private String path;
            private File saveDir;
            private FileDownloader loader;

            public DownloadTask(String path, File saveDir) {
                this.path = path;
                this.saveDir = saveDir;
            }

            /**
             * 退出下載
             */
            public void exit() {
                if (loader != null)
                    loader.exit();
            }

            DownloadProgressListener downloadProgressListener = new DownloadProgressListener() {
                @Override
                public void onDownloadSize(int size) {
                    Message msg = new Message();
                    msg.what = PROCESSING;
                    msg.getData().putInt("size", size);
                    handler.sendMessage(msg);
                }
            };

            public void run() {
                try {
                    // 實例化一個文件下載器
                    loader = new FileDownloader(getApplicationContext(), path,
                            saveDir, 3);
                    // 設置進度條最大值
                    progressBar.setMax(loader.getFileSize());
                    loader.download(downloadProgressListener);
                } catch (Exception e) {
                    e.printStackTrace();
                    handler.sendMessage(handler.obtainMessage(FAILURE)); // 發送一條空消息對象
                }
            }
        }
    }

}

以上就是所有核心代碼了，權限和佈局文件我就不貼了，自己可以下我提供的demo來看。