首页 > 代码库 > [Android实例] Android之断点续传下载

[Android实例] Android之断点续传下载

2024-08-09 20:47:21   220人阅读

在我们做开发的时候经常遇到的就是下载了，现在下载的方法有很多很多，那么怎么做到断点续传下载呢！很多人都头疼这个问题，如果我们没有很好的逻辑真不是很容易解决啊。我参考了一下前辈们的资料了整理了一个项目，能实现多个文件的同时下载。
断点续传下载，顾名思义，那就是我们在一次下载未结束时，退出下载，第二次下载时会接着第一次下载的进度继续下载。那么怎么记录第一次下载的数据呢，这里肯定就要用到数据库了。下面就是我创建数据库的一个SQLiteOpenHelper类。用来首次运行时创建数据库。
DBHelper.java

  1. package com.icss.DBHelper;
  3. import android.content.Context;
  4. import android.database.sqlite.SQLiteDatabase;
  5. import android.database.sqlite.SQLiteOpenHelper;
  7. /**
  8. * 建立一个数据库帮助类
  9. */
  10. public class DBHelper extends SQLiteOpenHelper {
  11.         // download.db-->数据库名
  12.         public DBHelper(Context context) {
  13.                 super(context, "download.db", null, 1);
  14.         }
  16.         /**
  17.          * 在download.db数据库下创建一个download_info表存储下载信息
  18.          */
  19.         @Override
  20.         public void onCreate(SQLiteDatabase db) {
  21.                 db.execSQL("create table download_info(_id integer PRIMARY KEY AUTOINCREMENT, thread_id integer, "
  22.                                 + "start_pos integer, end_pos integer, compelete_size integer,url char)");
  23.         }
  25.         @Override
  26.         public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  28.         }
  30. }
复制代码

下面看主界面的布局,在这里，我只设计了一个ListView来显示下载的音乐的名称，和一个开始下载按钮和一个暂停按钮。
布局文件如下：
main.xml：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.         android:orientation="vertical" android:layout_width="fill_parent"
  4.         android:layout_height="fill_parent" android:weightSum="1">
  5.         <ListView android:id="@android:id/list" android:layout_height="wrap_content"
  6.                 android:layout_width="match_parent" android:layout_weight="0.70"></ListView>
  7. </LinearLayout>
复制代码

list_item.xml：

  1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  2.         android:layout_height="fill_parent" android:id="@+id/linearLayout1"
  3.         android:layout_width="fill_parent" android:orientation="vertical">
  4.         <LinearLayout android:layout_width="fill_parent"
  5.                 android:id="@+id/linearLayout2" android:layout_height="wrap_content"
  6.                 android:orientation="horizontal" android:layout_marginBottom="5dip">
  7.                 <TextView android:layout_width="fill_parent"
  8.                         android:layout_height="wrap_content" android:layout_weight="1"
  9.                         android:id="@+id/tv_resouce_name" />
  10.                 <Button android:layout_width="fill_parent"
  11.                         android:layout_height="wrap_content" android:layout_weight="1"
  12.                         android:text="下载" android:id="@+id/btn_start" android:onClick="startDownload" />
  13.                 <Button android:layout_width="fill_parent"
  14.                         android:layout_height="wrap_content" android:layout_weight="1"
  15.                         android:text="暂停" android:id="@+id/btn_pause" android:onClick="pauseDownload" />
  16.         </LinearLayout>
  17. </LinearLayout>
复制代码

我们要定义一个记录在下载时各个时期的数据的类，这里我创建了一个DownloadInfo类来记录。代码如下：
DownloadInfo：

  1. package com.icss.entity;
  3. public class DownloadInfo {
  5.         private int threadId;// 下载器id
  6.         private int startPos;// 开始点
  7.         private int endPos;// 结束点
  8.         private int compeleteSize;// 完成度
  9.         private String url;// 下载器网络标识
  10.         
  11.         
  12.         
  13.         public DownloadInfo(int threadId, int startPos, int endPos,
  14.                         int compeleteSize, String url) {
  15.                 super();
  16.                 this.threadId = threadId;
  17.                 this.startPos = startPos;
  18.                 this.endPos = endPos;
  19.                 this.compeleteSize = compeleteSize;
  20.                 this.url = url;
  21.         }
  22.         public int getThreadId() {
  23.                 return threadId;
  24.         }
  25.         public void setThreadId(int threadId) {
  26.                 this.threadId = threadId;
  27.         }
  28.         public int getStartPos() {
  29.                 return startPos;
  30.         }
  31.         public void setStartPos(int startPos) {
  32.                 this.startPos = startPos;
  33.         }
  34.         public int getEndPos() {
  35.                 return endPos;
  36.         }
  37.         public void setEndPos(int endPos) {
  38.                 this.endPos = endPos;
  39.         }
  40.         public int getCompeleteSize() {
  41.                 return compeleteSize;
  42.         }
  43.         public void setCompeleteSize(int compeleteSize) {
  44.                 this.compeleteSize = compeleteSize;
  45.         }
  46.         public String getUrl() {
  47.                 return url;
  48.         }
  49.         public void setUrl(String url) {
  50.                 this.url = url;
  51.         }
  52.         
  53.         @Override
  54.              public String toString() {
  55.                  return "DownloadInfo [threadId=" + threadId
  56.                          + ", startPos=" + startPos + ", endPos=" + endPos
  57.                          + ", compeleteSize=" + compeleteSize +"]";
  58.      }
  61. }
复制代码

在下载时，我们有进度条来显示进度，怎么确定进度条的进度，大小和起始位置呢？这里我定义了一个LoadInfo类来记录下载器详细信息。代码如下：
LoadInfo：

  1. package com.icss.entity;
  3. public class LoadInfo {
  5.         public int fileSize;// 文件大小
  6.         private int complete;// 完成度
  7.         private String urlstring;// 下载器标识
  8.         public LoadInfo() {
  9.                 super();
  10.                 // TODO Auto-generated constructor stub
  11.         }
  12.         public LoadInfo(int fileSize, int complete, String urlstring) {
  13.                 super();
  14.                 this.fileSize = fileSize;
  15.                 this.complete = complete;
  16.                 this.urlstring = urlstring;
  17.         }
  18.         public int getFileSize() {
  19.                 return fileSize;
  20.         }
  21.         public void setFileSize(int fileSize) {
  22.                 this.fileSize = fileSize;
  23.         }
  24.         public int getComplete() {
  25.                 return complete;
  26.         }
  27.         public void setComplete(int complete) {
  28.                 this.complete = complete;
  29.         }
  30.         public String getUrlstring() {
  31.                 return urlstring;
  32.         }
  33.         public void setUrlstring(String urlstring) {
  34.                 this.urlstring = urlstring;
  35.         }
  36.         @Override
  37.             public String toString() {
  38.          return "LoadInfo [fileSize=" + fileSize + ", complete=" + complete
  39.                          + ", urlstring=" + urlstring + "]";
  40.      }
  43. }
复制代码

下面是最最重要的一步，那就是定义一个下载器来进行下载了，这里我就不多说，具体解释在代码中都有注解，供大家研究参考。
Downloader:

  1. package com.icss.service;
  3. import java.io.File;
  4. import java.io.InputStream;
  5. import java.io.RandomAccessFile;
  6. import java.net.HttpURLConnection;
  7. import java.net.URL;
  8. import java.util.ArrayList;
  9. import java.util.List;
  11. import com.icss.dao.Dao;
  12. import com.icss.entity.DownloadInfo;
  13. import com.icss.entity.LoadInfo;
  15. import android.content.Context;
  16. import android.os.Handler;
  17. import android.os.Message;
  18. import android.util.Log;
  20. public class Downloader {
  21.         private String urlstr;// 下载的地址
  22.         private String localfile;// 保存路径
  23.         private int threadcount;// 线程数
  24.         private Handler mHandler;// 消息处理器
  25.         private Dao dao;// 工具类
  26.         private int fileSize;// 所要下载的文件的大小
  27.         private List<DownloadInfo> infos;// 存放下载信息类的集合
  28.         private static final int INIT = 1;// 定义三种下载的状态：初始化状态，正在下载状态，暂停状态
  29.         private static final int DOWNLOADING = 2;
  30.         private static final int PAUSE = 3;
  31.         private int state = INIT;
  33.         public Downloader(String urlstr, String localfile, int threadcount,
  34.                         Context context, Handler mHandler) {
  35.                 this.urlstr = urlstr;
  36.                 this.localfile = localfile;
  37.                 this.threadcount = threadcount;
  38.                 this.mHandler = mHandler;
  39.                 dao = new Dao(context);
  40.         }
  42.         /**
  43.          * 判断是否正在下载
  44.          */
  45.         public boolean isdownloading() {
  46.                 return state == DOWNLOADING;
  47.         }
  49.         /**
  50.          * 得到downloader里的信息 首先进行判断是否是第一次下载，如果是第一次就要进行初始化，并将下载器的信息保存到数据库中
  51.          * 如果不是第一次下载，那就要从数据库中读出之前下载的信息（起始位置，结束为止，文件大小等），并将下载信息返回给下载器
  52.          */
  53.         public LoadInfo getDownloaderInfors() {
  54.                 if (isFirst(urlstr)) {
  55.                         init();
  56.                         int range = fileSize / threadcount;
  57.                         infos = new ArrayList<DownloadInfo>();
  58.                         for (int i = 0; i < threadcount - 1; i++) {
  59.                                 DownloadInfo info = new DownloadInfo(i, i * range, (i + 1)
  60.                                                 * range - 1, 0, urlstr);
  61.                                 infos.add(info);
  62.                         }
  63.                         DownloadInfo info = new DownloadInfo(threadcount - 1,
  64.                                         (threadcount - 1) * range, fileSize - 1, 0, urlstr);
  65.                         infos.add(info);
  66.                         // 保存infos中的数据到数据库
  67.                         dao.saveInfos(infos);
  68.                         // 创建一个LoadInfo对象记载下载器的具体信息
  69.                         LoadInfo loadInfo = new LoadInfo(fileSize, 0, urlstr);
  70.                         return loadInfo;
  71.                 } else {
  72.                         // 得到数据库中已有的urlstr的下载器的具体信息
  73.                         infos = dao.getInfos(urlstr);
  74.                         Log.v("TAG", "not isFirst size=" + infos.size());
  75.                         int size = 0;
  76.                         int compeleteSize = 0;
  77.                         for (DownloadInfo info : infos) {
  78.                                 compeleteSize += info.getCompeleteSize();
  79.                                 size += info.getEndPos() - info.getStartPos() + 1;
  80.                         }
  81.                         return new LoadInfo(size, compeleteSize, urlstr);
  82.                 }
  83.         }
  85.         /**
  86.       */
  87.         private void init() {
  88.                 try {
  89.                         URL url = new URL(urlstr);
  90.                         HttpURLConnection connection = (HttpURLConnection) url
  91.                                         .openConnection();
  92.                         connection.setConnectTimeout(5000);
  93.                         connection.setRequestMethod("GET");
  94.                         fileSize = connection.getContentLength();
  95.                         File file = new File(localfile);
  96.                         if (!file.exists()) {
  97.                                 file.createNewFile();
  98.                         }
  99.                         // 本地访问文件
  100.                         RandomAccessFile accessFile = new RandomAccessFile(file, "rwd");
  101.                         accessFile.setLength(fileSize);
  102.                         accessFile.close();
  103.                         connection.disconnect();
  104.                 } catch (Exception e) {
  105.                         e.printStackTrace();
  106.                 }
  107.         }
  109.         /**
  110.          * 判断是否是第一次 下载
  111.          */
  112.         private boolean isFirst(String urlstr) {
  113.                 return dao.isHasInfors(urlstr);
  114.         }
  116.         /**
  117.          * 114 * 利用线程开始下载数据 115
  118.          */
  119.         public void download() {
  120.                 if (infos != null) {
  121.                         if (state == DOWNLOADING)
  122.                                 return;
  123.                         state = DOWNLOADING;
  124.                         for (DownloadInfo info : infos) {
  125.                                 new MyThread(info.getThreadId(), info.getStartPos(),
  126.                                                 info.getEndPos(), info.getCompeleteSize(),
  127.                                                 info.getUrl()).start();
  128.                         }
  129.                 }
  130.         }
  132.         public class MyThread extends Thread {
  133.                 private int threadId;
  134.                 private int startPos;
  135.                 private int endPos;
  136.                 private int compeleteSize;
  137.                 private String urlstr;
  139.                 public MyThread(int threadId, int startPos, int endPos,
  140.                                 int compeleteSize, String urlstr) {
  141.                         this.threadId = threadId;
  142.                         this.startPos = startPos;
  143.                         this.endPos = endPos;
  144.                         this.compeleteSize = compeleteSize;
  145.                         this.urlstr = urlstr;
  146.                 }
  148.                 @Override
  149.                 public void run() {
  150.                         HttpURLConnection connection = null;
  151.                         RandomAccessFile randomAccessFile = null;
  152.                         InputStream is = null;
  153.                         try {
  154.                                 URL url = new URL(urlstr);
  155.                                 connection = (HttpURLConnection) url.openConnection();
  156.                                 connection.setConnectTimeout(5000);
  157.                                 connection.setRequestMethod("GET");
  158.                                 // 设置范围，格式为Range：bytes x-y;
  159.                                 connection.setRequestProperty("Range", "bytes="
  160.                                                 + (startPos + compeleteSize) + "-" + endPos);
  162.                                 randomAccessFile = new RandomAccessFile(localfile, "rwd");
  163.                                 randomAccessFile.seek(startPos + compeleteSize);
  164.                                 // 将要下载的文件写到保存在保存路径下的文件中
  165.                                 is = connection.getInputStream();
  166.                                 byte[] buffer = new byte[4096];
  167.                                 int length = -1;
  168.                                 while ((length = is.read(buffer)) != -1) {
  169.                                         randomAccessFile.write(buffer, 0, length);
  170.                                         compeleteSize += length;
  171.                                         // 更新数据库中的下载信息
  172.                                         dao.updataInfos(threadId, compeleteSize, urlstr);
  173.                                         // 用消息将下载信息传给进度条，对进度条进行更新
  174.                                         Message message = Message.obtain();
  175.                                         message.what = 1;
  176.                                         message.obj = urlstr;
  177.                                         message.arg1 = length;
  178.                                         mHandler.sendMessage(message);
  179.                                         if (state == PAUSE) {
  180.                                                 return;
  181.                                         }
  182.                                 }
  183.                         } catch (Exception e) {
  184.                                 e.printStackTrace();
  185.                         } finally {
  186.                                 try {
  187.                                         is.close();
  188.                                         randomAccessFile.close();
  189.                                         connection.disconnect();
  190.                                         dao.closeDb();
  191.                                 } catch (Exception e) {
  192.                                         e.printStackTrace();
  193.                                 }
  194.                         }
  196.                 }
  197.         }
  199.         // 删除数据库中urlstr对应的下载器信息
  200.         public void delete(String urlstr) {
  201.                 dao.delete(urlstr);
  202.         }
  204.         // 设置暂停
  205.         public void pause() {
  206.                 state = PAUSE;
  207.         }
  209.         // 重置下载状态
  210.         public void reset() {
  211.                 state = INIT;
  212.         }
  213. }
复制代码

在这边下载器类的定义中，我们用到了许多关于进行数据库操作的方法，这里我定义了一个数据库工具类，来提供这些方法，代码如下：
Dao：

  1. package com.icss.dao;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import javax.crypto.spec.DESKeySpec;
  7. import com.icss.DBHelper.DBHelper;
  8. import com.icss.entity.DownloadInfo;
  10. import android.content.Context;
  11. import android.database.Cursor;
  12. import android.database.sqlite.SQLiteDatabase;
  15. /**
  16.   *
  17.   * 一个业务类
  18.   */
  19. public class Dao {
  20.      private DBHelper dbHelper;
  22.      public Dao(Context context) {
  23.          dbHelper = new DBHelper(context);
  24.          
  25.      }
  27.      /**
  28.       * 查看数据库中是否有数据
  29.       */
  30.      public boolean isHasInfors(String urlstr) {
  31.          SQLiteDatabase database = dbHelper.getReadableDatabase();
  32.         String sql = "select count(*)  from download_info where url=?";
  33.          Cursor cursor = database.rawQuery(sql, new String[] { urlstr });
  34.          cursor.moveToFirst();
  35.          int count = cursor.getInt(0);
  36.         cursor.close();
  37.          return count == 0;
  38.      }
  40.      /**
  41.       * 保存 下载的具体信息
  42.       */
  43.      public void saveInfos(List<DownloadInfo> infos) {
  44.          SQLiteDatabase database = dbHelper.getWritableDatabase();
  45.          for (DownloadInfo info : infos) {
  46.              String sql = "insert into download_info(thread_id,start_pos, end_pos,compelete_size,url) values (?,?,?,?,?)";
  47.            Object[] bindArgs = { info.getThreadId(), info.getStartPos(),
  48.                      info.getEndPos(), info.getCompeleteSize(), info.getUrl() };
  49.              database.execSQL(sql, bindArgs);
  50.          }
  51.      }
  53.      /**
  54.       * 得到下载具体信息
  55.       */
  56.      public List<DownloadInfo> getInfos(String urlstr) {
  57.          List<DownloadInfo> list = new ArrayList<DownloadInfo>();
  58.          SQLiteDatabase database = dbHelper.getReadableDatabase();
  59.          String sql = "select thread_id, start_pos, end_pos,compelete_size,url from download_info where url=?";
  60.          Cursor cursor = database.rawQuery(sql, new String[] { urlstr });
  61.          while (cursor.moveToNext()) {
  62.              DownloadInfo info = new DownloadInfo(cursor.getInt(0),
  63.                      cursor.getInt(1), cursor.getInt(2), cursor.getInt(3),
  64.                     cursor.getString(4));
  65.              list.add(info);
  66.          }
  67.          cursor.close();
  68.          return list;
  69.      }
  71.      /**
  72.      * 更新数据库中的下载信息
  73.       */
  74.      public void updataInfos(int threadId, int compeleteSize, String urlstr) {
  75.          SQLiteDatabase database = dbHelper.getReadableDatabase();
  76.          String sql = "update download_info set compelete_size=? where thread_id=? and url=?";
  77.          Object[] bindArgs = { compeleteSize, threadId, urlstr };
  78.         database.execSQL(sql, bindArgs);
  79.      }
  80.      /**
  81.       * 关闭数据库
  82.       */
  83.      public void closeDb() {
  84.          dbHelper.close();
  85.     }
  87.      /**
  88.      * 下载完成后删除数据库中的数据
  89.       */
  90.      public void delete(String url) {
  91.         SQLiteDatabase database = dbHelper.getReadableDatabase();
  92.          database.delete("download_info", "url=?", new String[] { url });
  93.          database.close();
  94.      }
  95. }
复制代码

下面的是程序的主程序，其他的不说了，直接上代码：

  1. package com.icss;
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.List;
  6. import java.util.Map;
  8. import android.app.ListActivity;
  9. import android.os.Bundle;
  10. import android.os.Handler;
  11. import android.os.Message;
  12. import android.view.View;
  13. import android.widget.LinearLayout;
  14. import android.widget.LinearLayout.LayoutParams;
  15. import android.widget.ProgressBar;
  16. import android.widget.SimpleAdapter;
  17. import android.widget.TextView;
  18. import android.widget.Toast;
  20. import com.icss.entity.LoadInfo;
  21. import com.icss.service.Downloader;
  23. public class MainActivity extends ListActivity {
  24.         // 固定下载的资源路径，这里可以设置网络上的地址
  25.         private static final String URL = "http://10.0.0.80:8080/xiangce/";
  26.         // 固定存放下载的音乐的路径：SD卡目录下
  27.         private static final String SD_PATH = "/mnt/sdcard/";
  28.         // 存放各个下载器
  29.         private Map<String, Downloader> downloaders = new HashMap<String, Downloader>();
  30.         // 存放与下载器对应的进度条
  31.         private Map<String, ProgressBar> ProgressBars = new HashMap<String, ProgressBar>();
  32.         /**
  33.          * 31 * 利用消息处理机制适时更新进度条 32
  34.          */
  35.         private Handler mHandler = new Handler() {
  36.                 public void handleMessage(Message msg) {
  37.                         if (msg.what == 1) {
  38.                                 String url = (String) msg.obj;
  39.                                 int length = msg.arg1;
  40.                                 ProgressBar bar = ProgressBars.get(url);
  41.                                 if (bar != null) {
  42.                                         // 设置进度条按读取的length长度更新
  43.                                         bar.incrementProgressBy(length);
  44.                                         if (bar.getProgress() == bar.getMax()) {
  45.                                                 Toast.makeText(MainActivity.this, "下载完成！", 0).show();
  46.                                                 // 下载完成后清除进度条并将map中的数据清空
  47.                                                 LinearLayout layout = (LinearLayout) bar.getParent();
  48.                                                 layout.removeView(bar);
  49.                                                 ProgressBars.remove(url);
  50.                                                 downloaders.get(url).delete(url);
  51.                                                 downloaders.get(url).reset();
  52.                                                 downloaders.remove(url);
  54.                                         }
  55.                                 }
  56.                         }
  57.                 }
  58.         };
  60.         @Override
  61.         public void onCreate(Bundle savedInstanceState) {
  62.                 super.onCreate(savedInstanceState);
  63.                 setContentView(R.layout.main);
  64.                 showListView();
  65.         }
  67.         // 显示listView，这里可以随便添加音乐
  68.         private void showListView() {
  69.                 List<Map<String, String>> data = http://www.mamicode.com/new ArrayList>();
  70.                 Map<String, String> map = new HashMap<String, String>();
  71.                 map.put("name", "mm.mp3");
  72.                 data.add(map);
  73.                 map = new HashMap<String, String>();
  74.                 map.put("name", "pp.mp3");
  75.                 data.add(map);
  76.                 map = new HashMap<String, String>();
  77.                 map.put("name", "tt.mp3");
  78.                 data.add(map);
  79.                 map = new HashMap<String, String>();
  80.                 map.put("name", "You.mp3");
  81.                 data.add(map);
  82.                 SimpleAdapter adapter = new SimpleAdapter(this, data,
  83.                                 R.layout.list_item, new String[] { "name" },
  84.                                 new int[] { R.id.tv_resouce_name });
  85.                 setListAdapter(adapter);
  86.         }
  88.         /**
  89.          * 83 * 响应开始下载按钮的点击事件 84
  90.          */
  91.         public void startDownload(View v) {
  92.                 // 得到textView的内容
  93.                 LinearLayout layout = (LinearLayout) v.getParent();
  94.                 String musicName = ((TextView) layout
  95.                                 .findViewById(R.id.tv_resouce_name)).getText().toString();
  96.                 String urlstr = URL + musicName;
  97.                 String localfile = SD_PATH + musicName;
  98.                 // 设置下载线程数为4，这里是我为了方便随便固定的
  99.                 int threadcount = 4;
  100.                 // 初始化一个downloader下载器
  101.                 Downloader downloader = downloaders.get(urlstr);
  102.                 if (downloader == null) {
  103.                         downloader = new Downloader(urlstr, localfile, threadcount, this,
  104.                                         mHandler);
  105.                         downloaders.put(urlstr, downloader);
  106.                 }
  107.                 if (downloader.isdownloading())
  108.                         return;
  109.                 // 得到下载信息类的个数组成集合
  110.                 LoadInfo loadInfo = downloader.getDownloaderInfors();
  111.                 // 显示进度条
  112.                 showProgress(loadInfo, urlstr, v);
  113.                 // 调用方法开始下载
  114.                 downloader.download();
  115.         }
  117.         /**
  118.          * 显示进度条
  119.          */
  120.         private void showProgress(LoadInfo loadInfo, String url, View v) {
  121.                 ProgressBar bar = ProgressBars.get(url);
  122.                 if (bar == null) {
  123.                         bar = new ProgressBar(this, null,
  124.                                         android.R.attr.progressBarStyleHorizontal);
  125.                         bar.setMax(loadInfo.getFileSize());
  126.                         bar.setProgress(loadInfo.getComplete());
  127.                         System.out.println(loadInfo.getFileSize()+"--"+loadInfo.getComplete());
  128.                         ProgressBars.put(url, bar);
  129.                         LinearLayout.LayoutParams params = new LayoutParams(
  130.                                         LayoutParams.FILL_PARENT, 5);
  131.                         ((LinearLayout) ((LinearLayout) v.getParent()).getParent())
  132.                                         .addView(bar, params);
  133.                 }
  134.         }
  136.         /**
  137.          * 响应暂停下载按钮的点击事件
  138.          */
  139.         public void pauseDownload(View v) {
  140.                 LinearLayout layout = (LinearLayout) v.getParent();
  141.                 String musicName = ((TextView) layout
  142.                                 .findViewById(R.id.tv_resouce_name)).getText().toString();
  143.                 String urlstr = URL + musicName;
  144.                 downloaders.get(urlstr).pause();
  145.         }
  146. }
复制代码

最后我们需要在android Manifest.xml中添加这两个权限一个是访问internet的权限，另一个是写外存的权限。

  1. <uses-permission android:name="android.permission.INTERNET"></uses-permission>
  2.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>
复制代码

最后运行的效果图：


万事俱备只欠东风啦！哈哈，我需要在我的web工程里放几个音乐文件。

下载后得到的文件可在sdcard下面找到！

[Android实例] Android之断点续传下载


联系
我们