使用greenDao+HttpurlConnection实现多线程断点下载


//声明数据库

public class MyApp extends Application {
    private DaoMaster.DevOpenHelper mHelper;
    private SQLiteDatabase db;
    private DaoMaster mDaoMaster;
    private DaoSession mDaoSession;

    @Override
    public void onCreate() {
        super.onCreate();
        setDatabase();
    }

    /**
     * 设置greenDao
     */
    private void setDatabase() {
        // 通过 DaoMaster 的内部类 DevOpenHelper,你可以得到一个便利的 SQLiteOpenHelper 对象。
        // 可能你已经注意到了,你并不需要去编写「CREATE TABLE」这样的 SQL 语句,因为 greenDAO 已经帮你做了。
        // 注意:默认的 DaoMaster.DevOpenHelper 会在数据库升级时,删除所有的表,意味着这将导致数据的丢失。
        // 所以,在正式的项目中,你还应该做一层封装,来实现数据库的安全升级。
        mHelper = new DaoMaster.DevOpenHelper(this, "Users.db", null);
        db = mHelper.getWritableDatabase();
        // 注意:该数据库连接属于 DaoMaster,所以多个 Session 指的是相同的数据库连接。
        mDaoMaster = new DaoMaster(db);
        mDaoSession = mDaoMaster.newSession();
    }
    public DaoSession getDaoSession() {
        return mDaoSession;
    }
    public SQLiteDatabase getDb() {
        db = mHelper.getWritableDatabase();
        return db;
    }


创建数据库的操作类

package moyuchen.com.download.download.db;

import android.annotation.SuppressLint;
import android.content.Context;

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

import Green.Bean.FileResult;
import Green.Bean.FileResultDao;
import moyuchen.com.download.MyApp;

/**
 *
 * 该类主要用来保存下载记录
 */
public class FileDBService {
   private String TAG="===============FileDBService================";
// private DBOpenHelper openHelper;
   private final MyApp instances;

   public FileDBService(Context context) {
//    openHelper = new DBOpenHelper(context);
      instances = (MyApp) context.getApplicationContext();
   }

   /**
    * 获取每条线程已经下载的文件长度
    * 
    * @param path
    * @return
    */
   @SuppressLint("LongLogTag")
   public Map<Integer, Integer> getData(String path) {
      Map<Integer, Integer> data = new HashMap<Integer, Integer>();

      List<FileResult> list = instances.getDaoSession().getFileResultDao().queryBuilder().where(FileResultDao.Properties.Downpath.eq(path)).build().list();
      for (FileResult fileResult : list) {
         data.put(fileResult.getThreadid(),fileResult.getDownlength());
      }
//    SQLiteDatabase db = openHelper.getReadableDatabase();
//    Cursor cursor = db.rawQuery("select THREADID, DOWNLENGTH from FILE_RESULT where DOWNPATH=?", new String[] { path });

//    while (cursor.moveToNext()) {
//       data.put(cursor.getInt(0), cursor.getInt(1));
//       Log.i("=====sbhelper======", "getData: " +cursor.getInt(0) + "-->" + cursor.getInt(1));
//    }
//    cursor.close();
//    db.close();
      return data;
   }

   /**
    * 保存每条线程已经下载的文件长度
    * @param path
    * @param map
    */
   @SuppressLint("LongLogTag")
   public void save(String path, Map<Integer, Integer> map) {// int threadid,
      //使用sqlite数据库
//    SQLiteDatabase db = openHelper.getWritableDatabase();
//    db.beginTransaction();
//    try {
//       for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
//          db.execSQL("insert into FILE_RESULT(DOWNPATH, THREADID, DOWNLENGTH) values(?,?,?)",
//                new Object[] { path, entry.getKey(), entry.getValue() });
         //使用greendao数据库
      for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
         instances.getDaoSession().getFileResultDao().insert(new FileResult(null,path,entry.getKey(),entry.getValue()));
      }

//       }
//       db.setTransactionSuccessful();
//    } finally {
//       db.endTransaction();
//    }
//    db.close();
   }

   /**
    * 实时更新每条线程已经下载的文件长度
    * @param path
    */
   @SuppressLint("LongLogTag")
   public void update(String path, int threadId, int pos) {
      
      //使用GreenDAO
      List<FileResult> list = instances.getDaoSession().getFileResultDao().queryBuilder().where(FileResultDao.Properties.Downpath.eq(path), FileResultDao.Properties.Threadid.eq(threadId)).build().list();

      for (FileResult fileResult : list) {
         Long id = fileResult.getId();
         instances.getDaoSession().getFileResultDao().update(new FileResult(id,path,threadId,pos));
      }

      //使用sqlite数据库
//    SQLiteDatabase db = openHelper.getWritableDatabase();
//    db.execSQL("update FILE_RESULT set DOWNLENGTH=? where DOWNPATH=? and THREADID=?",
//          new Object[]{pos, path, threadId});
//    db.close();

   }

   /**
    * 当文件下载完成后,删除对应的下载记录
    * @param path
    */
   @SuppressLint("LongLogTag")
   public void delete(String path) {
      //使用GreenDao数据库
      List<FileResult> list = instances.getDaoSession().getFileResultDao().queryBuilder().where(FileResultDao.Properties.Downpath.eq(path)).build().list();
      for (FileResult fileResult : list) {
         Long id = fileResult.getId();
         instances.getDaoSession().getFileResultDao().deleteByKey(id);
      }


      //使用sqlite数据库
//    SQLiteDatabase db = openHelper.getWritableDatabase();
//    db.execSQL("delete from FILE_RESULT where DOWNPATH=?",
//          new Object[] { path });
//    db.close();
   }

}

创建ProgressBar进度监听接口

package moyuchen.com.download.download;

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

创建下载线程类
package moyuchen.com.download.download;

import android.util.Log;

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

public class DownloadThread extends Thread {
   private static final String TAG = "DownloadThread";
   /**保存文件的位置*/
   private File saveFile;
   /**文件资源路径*/
   private URL downUrl;
   /**当前线程需要下载的长度*/
   private int blockLength;
   /** 当前线程的id */
   private int threadId = -1;
   /**当前线程已经下载的文件大小*/
   private int downLength;
   /**true 下载完成 否则没有下载完成*/
   private boolean finish = false;
   private FileDownloader downloader;

   /**
    * 构造函数
    * @param downloader FileDownloader
    * @param downUrl 资源文件的URL
    * @param saveFile 构造的本地文件
    * @param block  当前线程需要下载的长度
    * @param downLength 当前线程已经下载的文件大小
     * @param threadId 当前线程ID
     */
   public DownloadThread(FileDownloader downloader, URL downUrl,
                    File saveFile, int block, int downLength, int threadId) {
      this.downUrl = downUrl;
      this.saveFile = saveFile;
      this.blockLength = block;
      this.downloader = downloader;
      this.threadId = threadId;
      this.downLength = downLength;
   }

   @Override
   public void run() {
      if (downLength < blockLength) {
         try {
            HttpURLConnection http = (HttpURLConnection) downUrl.openConnection();
            http.setConnectTimeout(5 * 1000);
            http.setRequestMethod("GET");
            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());// 先前网页的地址,当前请求网页紧随其后,即来路
            http.setRequestProperty("Charset", "UTF-8");
            int startPos = blockLength * (threadId - 1) + downLength;
            int endPos = blockLength * threadId - 1;// 结束位置
            http.setRequestProperty("Range", "bytes=" + startPos + "-" + endPos);//设置获取实体数据的范围
            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");
            // 定位下载位置
            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;
   }

   /**
    * 已经下载的文件大小
    */
   public long getDownLength() {
      return downLength;
   }
}


//创建文件下载工具类

package moyuchen.com.download.download;

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

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 moyuchen.com.download.download.db.FileDBService;

/**
 *
 * 文件下载工具类
 *
 */
public class FileDownloader {
   private static final String TAG = "FileDownloader";
   private Context context;
   private FileDBService 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 blockLength;
   /** 下载路径  */
   private String downloadUrl;



   /**
    * 构建文件下载器
    * @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 FileDBService(this.context);
         Log.i(TAG, "FileDownloader: downloadUrl:"+this.downloadUrl);
         URL url = new URL(this.downloadUrl);
         Log.i(TAG, "FileDownloader: url:"+url.getPath());
         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);
         int responseCode = conn.getResponseCode();
         print("============responseCode============"+responseCode);
         if (conn.getResponseCode() == 200) {//连接成功
            this.fileSize = conn.getContentLength();// 获取资源文件的大小
            //打印下载文件长度
            Log.i(TAG, "FileDownloader: fileSize:"+this.fileSize);

            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.blockLength = (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) {
         e.printStackTrace();
//       print(e.toString() );
         throw new RuntimeException("don't connection this url");
      }
   }



   /**
    *  开始下载文件
    * @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); // 设置文件的大小
         }
         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);// 初始化缓存各线程下载的长度
            }
            this.downloadSize = 0;
         }
         for (int i = 0; i < this.threads.length; i++) {
            int downLength = this.data.get(i + 1);
            if (downLength < this.blockLength && this.downloadSize < this.fileSize) {
               this.threads[i] = new DownloadThread(this, url,
                     this.saveFile, this.blockLength, 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.blockLength,
                           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) {
         e.printStackTrace();
         print(e.toString());
         throw new Exception("file download error");
      }
      return this.downloadSize;
   }


   /**
    * 获取文件名
    * @param conn
    * @return
    */
   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;
   }



   /**
    * 获取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());
      }
      print("=====================printResponseHeader===============End==========");
   }



   /**
    * 获取线程数
    */
   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
    */
   public synchronized void append(int size) {
      downloadSize += size;
   }

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


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

创建greendao实体类

package Green.Bean;

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

/**
 * User: Moyuchen
 * Date: 2017-11-16 15:11
 * Description:
 */
@Entity
public class FileResult {
    @Id(autoincrement = true)
    private Long id;
    @Property(nameInDb = "DOWNPATH")
    private String downpath;
    @Property(nameInDb = "THREADID")
    private Integer threadid;
    @Property(nameInDb = "DOWNLENGTH")
    private Integer downlength;
    public Integer getDownlength() {
        return this.downlength;
    }
    public void setDownlength(Integer downlength) {
        this.downlength = downlength;
    }
    public Integer getThreadid() {
        return this.threadid;
    }
    public void setThreadid(Integer threadid) {
        this.threadid = threadid;
    }
    public String getDownpath() {
        return this.downpath;
    }
    public void setDownpath(String downpath) {
        this.downpath = downpath;
    }
    public Long getId() {
        return this.id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    @Generated(hash = 1034016740)
    public FileResult(Long id, String downpath, Integer threadid, Integer downlength) {
        this.id = id;
        this.downpath = downpath;
        this.threadid = threadid;
        this.downlength = downlength;
    }
    @Generated(hash = 1832301249)
    public FileResult() {
    }
}

接下来就是Main类了MainActivity
package moyuchen.com.download;

import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
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 java.io.File;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

import moyuchen.com.download.download.DownloadProgressListener;
import moyuchen.com.download.download.FileDownloader;

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

    private EditText pathText;
    private TextView resultView;
    private Button downloadButton;
    private Button stopButton;
    /**进度条*/
    private ProgressBar progressBar;

    private Handler handler = new UIHandler();
    /**
     * 当Handler被创建会关联到创建它的当前线程的消息队列,该类用于往消息队列发送消息
     * 消息队列中的消息由当前线程内部进行处理
     */
    private final class UIHandler extends Handler {
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case PROCESSING: //
                    progressBar.setProgress(msg.getData().getInt("size"));
                    //已经下载的占总的大小的百分比
                    float fraction = (float) progressBar.getProgress() / (float) progressBar.getMax();
                    //当前已经下载的大小
                    int currentLength = (int) (fraction * 100);
                    resultView.setText(currentLength + "%");
                    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.activity_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);
        pathText.setText("http://mirror.aarnet.edu.au/pub/TED-talks/911Mothers_2010W-480p.mp4");
    }

    private final class ButtonClickListener implements View.OnClickListener {
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.downloadbutton: //开始下载
                    String path = pathText.getText().toString();
                    String filename = path.substring(path.lastIndexOf('/') + 1);
                    try {
                        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.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;
            }
        }


        private DownloadTask task;

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

        /**
         * 下载方法
         * @param path
         * @param savDir
         */
        private void download(String path, File savDir) {
            task = new DownloadTask(path, savDir);
            new Thread(task).start();
        }

        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);
                }
            };

            @Override
            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));
                }
            }
        }
    }

}

MainActivity中的布局文件

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@string/path" />

    <EditText
        android:id="@+id/path"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:inputType="none"
        android:text="@string/fileaddress2"
        android:textSize="12sp" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal" >

        <Button
            android:id="@+id/downloadbutton"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/button" />

        <Button
            android:id="@+id/stopbutton"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:enabled="false"
            android:text="暂停下载" />
    </LinearLayout>

    <ProgressBar
        android:id="@+id/progressBar"
        style="?android:attr/progressBarStyleHorizontal"
        android:layout_width="match_parent"
        android:layout_height="20dip" />

    <TextView
        android:id="@+id/resultView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center" />

</LinearLayout>ss

 然后是String的资源文件,在values文件下的strings.xml

<resources>

    <string name="app_name">多线程断点续传下载</string>
    <string name="action_settings">Settings</string>
    <string name="hello_world">Hello world!</string>
    <string name="path">下载地址:</string>
    <string name="button">开始下载</string>
    <string name="success">下载完成</string>
    <string name="error">下载出错</string>
    <string name="stopbutton">暂停下载</string>
    <string name="sdcarderror">没有SD卡</string>
    <!-- <string name="fileaddress">http://www.winrar.com.cn/download/wrar380sc.exe</string> -->
    <string name="fileaddress2">http://abv.cn/music/光辉岁月.mp3</string>
    <!-- <string name="fileaddress">http://www.winrar.com.cn/download/wrar380sc.exe</string> -->
    <string name="fileaddress">http://nchc.dl.sourceforge.net/project/sevenzip/7-Zip/9.20/7z920.exe</string>

</resources>






  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值