devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android中多线程下载列表实现_android 下载列表

作者：小丑西瓜9 | 2024-03-22 00:07:13

赞

踩

android 下载列表

       实现了一下Android中的文件多线程下载模块，支持自定义线程数、断点续传、下载任务的删除，添加等功能，这里封装了一下，功能已全部实现。不过由于使用的是最简单的手动线程数组及消息通知实现，可能还存在某些小问题。笔者会在后面的使用过程中再进行优化完善。先看一下程序测试效果，这里指定了5个下载任务，以及2个下载线程，具体如下：

        要运行以上Demo需要自己搭建服务器，和简单，只需要把所需的文件拷贝到Tomcat中的../webapps/ROOT文件夹下即可，以下是笔者的电脑：

       其中的0.mp3,1.mp3....11.mp3及本Demo的测试数据。

       除此之外还需要引入Afinal类库，已包含在工程下载中了(下载地址在本文最后)

       主要类介绍

       主界面MainActivity，负责初始化任务参数，用户可以单击列表中的按钮来删除、暂停、继续任务。可以看到有一个refreshHandler负责根据不同的Message来对列表进行不同的刷新操作。

  1. package com.wly.filedownloader;
  2. import java.util.List;
  3. import com.wly.filedownloader.dao.BeanHelper;
  4. import net.tsz.afinal.FinalDb;
  5. import net.tsz.afinal.exception.AfinalException;
  6. import android.os.Bundle;
  7. import android.os.Handler;
  8. import android.os.Message;
  9. import android.app.Activity;
  10. import android.app.AlertDialog;
  11. import android.content.DialogInterface;
  12. import android.graphics.Bitmap.Config;
  13. import android.view.LayoutInflater;
  14. import android.view.Menu;
  15. import android.view.View;
  16. import android.view.View.OnClickListener;
  17. import android.view.ViewGroup;
  18. import android.widget.BaseAdapter;
  19. import android.widget.Button;
  20. import android.widget.ListAdapter;
  21. import android.widget.ListView;
  22. import android.widget.ProgressBar;
  23. import android.widget.RelativeLayout;
  24. import android.widget.TextView;
  25.  
  26. public class MainActivity extends Activity{
  27.  
  28. 	DownloadHelper downHelper;
  29. 	private LayoutInflater inflater;
  30. 	private ListView lv;
  31. 	
  32. 	//最大支持同时进行的线程数
  33. 	private int maxThread = 2;
  34. 	
  35. 	//测试下载任务数量
  36. 	private int taskSize = 5;
  37. 		
  38. 	private DynamicArray<Bean> waitArray; //等待列表
  39. 	private DynamicArray<Bean> workArray; //用来存放已完成及下载中的任务
  40. 	List<Bean> list;
  41. 	
  42. 	//专门负责刷新界面的Handler
  43. 	private Handler refreshHandler = new Handler() {
  44.  
  45. 		@Override
  46. 		public void handleMessage(Message msg) {
  47. 			super.handleMessage(msg);
  48. 			switch(msg.what) {
  49. 			case Conf.State_FINISH:
  50. 				myAdapter.notifyDataSetChanged();
  51. 				break;
  52. 			case Conf.State_CANCEL:
  53. 				for(int i=0;i<workArray.size();i++) {
  54. 					if(workArray.getObjectAt(i).getGuid().equals(msg.obj)) {
  55. 						workArray.delete(i);
  56. 					}
  57. 				}
  58. 				downHelper.refreshDownloaderArray();
  59. 				myAdapter.notifyDataSetChanged();
  60. 				break;
  61. 			case Conf.MSG_STATECHANGED:
  62. 				myAdapter.notifyDataSetChanged();
  63. 				break;
  64. 			case Conf.State_DOWNLOAD:
  65. 				//刷新可见区域列表进度值
  66. 				int firstV = lv.getFirstVisiblePosition();
  67. 				int lastV = lv.getLastVisiblePosition();
  68. 				for (int i = firstV; i <= lastV; i++)  {
  69. 					
  70. 					View cell = lv.findViewById(i);
  71. 					cell.getId();
  72. 					if(cell != null) {
  73. 						Bean bean = workArray.getObjectAt(i);
  74. 						if(bean != null) {
  75. 							((ProgressBar)cell
  76. 									.findViewById(R.id.download_progress))
  77. 									.setProgress(bean.getPercent());
  78. 						}
  79. 					}
  80. 				}
  81. 				break;
  82. 			case Conf.State_FILEERROR:
  83. 				//文件版本异常
  84. 				break;
  85. 			}
  86. 		}
  87. 	};
  88. 	@Override
  89. 	protected void onCreate(Bundle savedInstanceState) {
  90. 		super.onCreate(savedInstanceState);
  91. 		setContentView(R.layout.activity_main);
  92. 		
  93. 		lv = (ListView) findViewById(R.id.listView1);
  94. 		Bean[] beanArray = new Bean[taskSize];
  95. 		workArray = new DynamicArray<Bean>();
  96. 		waitArray = new DynamicArray<Bean>();
  97.  
  98. 		
  99. 		for(int i=0;i<beanArray.length;i++) {
  100. 			beanArray[i] = new Bean("AA_" + i,"http://10.0.2.2:8080/" + i + ".mp3", i + ".mp3"
  101. 					,Conf.State_WAITTASK,0);
  102. 		}
  103. 	
  104. 		//1.添加测试数据到本地数据库
  105. 		List<Bean> list = FinalDb.create(this).findAll(Bean.class);
  106. 		if(list.size() == 0) {
  107. 			for(int i=0;i<beanArray.length;i++) {
  108. 				FinalDb.create(this).save(beanArray[i]);
  109. 			}
  110.  
  111. 			list = FinalDb.create(this).findAll(Bean.class);	
  112. 		}
  113. 		
  114. 		
  115. 		for(Bean bean:list) {
  116. 			System.out.println("id:" + bean.getId() + "," + "title:" + bean.getTitle() 
  117. 					+ "," + "url:" + bean.getUrl()  + "," + "isEnabled:" + bean.getIsEnabled() 
  118. 					+ ",isFinished:" + bean.getIsFinished() 
  119. 					+ "," + "cZise:" + bean.getCompleteSize() + ",percent:" + bean.getPercent());
  120. 		}
  121. 		for(Bean bean:list) {
  122. 			waitArray.insert(bean);
  123. 		}
  124. 		
  125. 		downHelper = new DownloadHelper(this,maxThread,waitArray,workArray,refreshHandler);
  126.  
  127. 		downHelper.assignTaskToDownloaders();
  128.  
  129. 		inflater = LayoutInflater.from(this);
  130. 		
  131. 		lv.setAdapter(myAdapter);
  132.  
  133. 	}
  134. 	
  135. 	@Override
  136. 	protected void onDestroy() {
  137. 		super.onDestroy();
  138. 		//停止所有下载器任务
  139. 		downHelper.kill();
  140. 	}
  141. 	
  142. 	class ViewHolder {
  143. 		ProgressBar progressBar;
  144. 		Button pauseBtn,cancelBtn,watingBtn,resumeBtn;
  145. 		RelativeLayout level_1,level_2,level_3;
  146. 		TextView title;
  147. 	}
  148. 	
  149. 	
  150. 	ViewHolder holder;
  151.  
  152. 	BaseAdapter myAdapter = new BaseAdapter() {
  153. 		
  154. 		@Override
  155. 		public View getView(final int position, View convertView, ViewGroup parent) {
  156. 			
  157. 			final Bean bean;
  158. 			//先显示"完成列表",再显示"下载中及等待列表"
  159. 			if(position < workArray.size()) {
  160. 				bean = workArray.getObjectAt(position);
  161. 			} else {
  162. 				bean = waitArray.getObjectAt(position-workArray.size());
  163. 			}
  164. 			final Downloader downloader = downHelper.getDownloaderByGuid(bean.getGuid());
  165. 			
  166. 			convertView = inflater.inflate(R.layout.download_list_item, null);
  167. 			ProgressBar progressBar = (ProgressBar) convertView.findViewById(R.id.download_progress);
  168. 			final Button pauseBtn = (Button)convertView.findViewById(R.id.download_btn_pause);
  169. 			Button cancelBtn = (Button)convertView.findViewById(R.id.download_btn_cancel);
  170. 			Button resumeBtn = (Button)convertView.findViewById(R.id.download_btn_resume);
  171. 			Button waitCancelBtn = (Button)convertView.findViewById(R.id.wait_btn_cancel);
  172. 			RelativeLayout download_level = (RelativeLayout)convertView.findViewById(R.id.download_level);
  173. 			RelativeLayout waiting_level = (RelativeLayout)convertView.findViewById(R.id.waiting_level);
  174. 			RelativeLayout finish_level = (RelativeLayout)convertView.findViewById(R.id.finish_level);
  175. 			TextView title = (TextView)convertView.findViewById(R.id.download_title);
  176.  
  177. 			//根据Bean的状态来决定暂停、继续、取消等按钮的显示状态
  178. 			progressBar.setProgress((int)bean.getPercent());
  179. 			title.setText(bean.getTitle());
  180. 			final String guid = bean.getGuid();
  181. 			
  182. 			if(bean.getIsEnabled() == Conf.TRUE) { //对应下载进度(0,100) => 暂停/继续
  183. 				download_level.setVisibility(View.VISIBLE);
  184. 				waiting_level.setVisibility(View.INVISIBLE);
  185. 				finish_level.setVisibility(View.INVISIBLE);
  186. 				if(downloader.getstate() == Conf.State_DOWNLOAD) { //下载中
  187. 					resumeBtn.setVisibility(View.INVISIBLE); 
  188. 					pauseBtn.setVisibility(View.VISIBLE); 
  189. 				} else { //暂停中
  190. 					resumeBtn.setVisibility(View.VISIBLE); 
  191. 					pauseBtn.setVisibility(View.INVISIBLE); 
  192. 					resumeBtn.setText("继续");
  193. 				}
  194. 			} else if(bean.getIsFinished() == Conf.TRUE) { //对应下载进度100 => 完成
  195. 				download_level.setVisibility(View.INVISIBLE);
  196. 				waiting_level.setVisibility(View.INVISIBLE);
  197. 				finish_level.setVisibility(View.VISIBLE);
  198. 			} else { //对应下载进度0 => 开始/等待
  199. 				//检查是否处于等待状态
  200. 				System.out.println("--开始/等待--");
  201. 				if(downloader != null) {
  202. 					download_level.setVisibility(View.VISIBLE);
  203. 					waiting_level.setVisibility(View.INVISIBLE);
  204. 					finish_level.setVisibility(View.INVISIBLE);
  205. 					
  206. 					resumeBtn.setText("开始");
  207. 				} else {
  208. 					download_level.setVisibility(View.INVISIBLE);
  209. 					waiting_level.setVisibility(View.VISIBLE);
  210. 					finish_level.setVisibility(View.INVISIBLE);
  211. 				}
  212. 			}
  213. 			
  214. 			pauseBtn.setOnClickListener(new View.OnClickListener() {
  215. 				
  216. 				@Override
  217. 				public void onClick(View v) {
  218. 					downloader.pause();
  219. 				}
  220. 			});
  221. 			
  222. 			resumeBtn.setOnClickListener(new View.OnClickListener() {
  223. 				
  224. 				@Override
  225. 				public void onClick(View v) {
  226. 					if(downloader != null && downloader.isActive()) {
  227. 						downloader.recovery();
  228. 						System.out.println("--recovery--");
  229. 					} else {
  230. 						downloader.start();
  231. 						System.out.println("--start--");
  232. 					}
  233. 				}
  234. 			});
  235. 			
  236. 			//下载中"取消"按钮
  237. 			cancelBtn.setOnClickListener(new View.OnClickListener() {
  238. 				
  239. 				@Override
  240. 				public void onClick(View v) {
  241. 					downloader.cancel();
  242. 				}
  243. 			});
  244. 			
  245. 			//等待中"取消"按钮
  246. 			waitCancelBtn.setOnClickListener(new View.OnClickListener() {
  247. 				
  248. 				@Override
  249. 				public void onClick(View v) {
  250. 					if(position < workArray.size()) {
  251. 						downloader.cancel();
  252. 					} else {
  253. 						waitArray.delete(position-workArray.size());
  254. 						BeanHelper.delete(MainActivity.this,bean);
  255. 						myAdapter.notifyDataSetChanged();
  256. 					}
  257. 				}
  258. 			});
  259. 			
  260. 			convertView.setId(position);
  261. 			return convertView;
  262. 		}
  263. 		
  264. 		@Override
  265. 		public long getItemId(int position) {
  266. 			return 0;
  267. 		}
  268. 		
  269. 		@Override
  270. 		public Object getItem(int position) {
  271. 			if(position < workArray.size()) {
  272. 				return workArray.getObjectAt(position);
  273. 			} else {
  274. 				return waitArray.getObjectAt(position-workArray.size());
  275. 			}
  276. 		}
  277. 		
  278. 		@Override
  279. 		public int getCount() {
  280. 			return waitArray.size() + workArray.size();
  281. 		}
  282. 	};
  283. }

       下载器调度类DownloaderHelper，负责检查任务队列和下载器数组，并将下载任务分配给空闲的下载器。

  1. package com.wly.filedownloader;
  2.  
  3. import com.wly.filedownloader.Downloader.MyDownloadListener;
  4.  
  5. import android.app.AlertDialog;
  6. import android.content.Context;
  7. import android.content.DialogInterface;
  8. import android.os.Handler;
  9. import android.os.Message;
  10.  
  11. /**
  12.  * 本类中包含两个队列一个是等待中的实体Bean，另一个是下载中的任务队列， 当添加一个任务实体Bean时，会先检查是否有空余的下载器没有使用，如果有，就
  13.  * 使用refreshDownloaderArray将该任务Bean从"等待下载队列"移动到"下载中队列"
  14.  * 同样的，当一个任务下载成功后，先从"下载中队列"移除，然后得到一个空闲的下载器，最后调用插入流程，将一个新的任务Bean 添加到到"下载中队列"中去
  15.  * 最后是删除(取消),如果发生在"等待"队列则删除数据即可，如果发生在"下载中"队列则复用下载完成逻辑即可。
  16.  * 
  17.  * @author wly
  18.  * 
  19.  */
  20. public class DownloadHelper {
  21.  
  22. 	private DynamicArray<Bean> waitArray;
  23. 	private DynamicArray<Bean> workArray;
  24. 	private int maxThread; // 最大同时进行任务数量,默认是1
  25. 	private Context mContext;
  26.  
  27. 	/**
  28. 	 * 下载器队列
  29. 	 */
  30. 	private Downloader[] downladerArray;
  31.  
  32. 	private Handler mHandler; // Activity中的Handler
  33.  
  34. 	private long lastRefreshTime = 0;
  35.  
  36. 	private int refresh_time = 0; // 每次刷新进度的最少间隔时间
  37.  
  38. 	// 做一层过滤，控制界面刷新频率
  39. 	private Handler handler = new Handler() {
  40.  
  41. 		@Override
  42. 		public void handleMessage(Message msg) {
  43. 			super.handleMessage(msg);
  44. 			if (msg.what == Conf.State_FILEERROR) {
  45. 				System.out.println("--文件异常，发送重置对应下载任务界面显示信息!!!--");
  46. 			} else {
  47. 				// 每隔refresh_time时间发送一次刷新界面信息
  48. 				if ((System.currentTimeMillis() - lastRefreshTime) > refresh_time) {
  49. 					mHandler.sendEmptyMessage(Conf.State_DOWNLOAD);
  50. 					lastRefreshTime = System.currentTimeMillis();
  51. 				}
  52. 			}
  53. 		}
  54. 	};
  55.  
  56. 	private MyDownloadListener myDownloadListener = new MyDownloadListener() {
  57.  
  58. 		@Override
  59. 		public void finished(Bean bean) {
  60.  
  61. 			// 1.尝试新的任务给空闲的下载器
  62. 			refreshDownloaderArray();
  63. 			// 2.刷新界面
  64. 			Message msg = new Message();
  65. 			msg.what = Conf.State_FINISH;
  66. 			mHandler.sendMessage(msg);
  67.  
  68. 			System.out.println("--finished");
  69. 		}
  70.  
  71. 		@Override
  72. 		public void started() {
  73. 			Message msg = new Message();
  74. 			msg.what = Conf.MSG_STATECHANGED;
  75. 			mHandler.sendMessage(msg);
  76. 		}
  77.  
  78. 		@Override
  79. 		public void paused() {
  80. 			Message msg = new Message();
  81. 			msg.what = Conf.MSG_STATECHANGED;
  82. 			mHandler.sendMessage(msg);
  83. 		}
  84.  
  85. 		@Override
  86. 		public void resumed() {
  87. 			Message msg = new Message();
  88. 			msg.what = Conf.MSG_STATECHANGED;
  89. 			mHandler.sendMessage(msg);
  90. 		}
  91.  
  92. 		@Override
  93. 		public void canceled(String guid) {
  94.  
  95. 			// 发送消息给Activity
  96. 			Message msg = new Message();
  97. 			msg.what = Conf.State_CANCEL;
  98. 			msg.obj = guid;
  99. 			mHandler.sendMessage(msg);
  100. 		}
  101.  
  102. 		/**
  103. 		 * 准备就绪(主要是文件校验过程)，可以开始下载了，
  104. 		 */
  105. 		@Override
  106. 		public void ready(String guid) {
  107. 			System.out.println("--准备就绪，可以开始下载了--");
  108. 		}
  109. 	};
  110.  
  111. 	/**
  112. 	 * 创建实体Bean的队列
  113. 	 * 
  114. 	 * @param context
  115. 	 * @param maxThread
  116. 	 * @param beans
  117. 	 * @param handler
  118. 	 */
  119. 	public DownloadHelper(Context context, int maxThread,
  120. 			DynamicArray<Bean> dArray, DynamicArray<Bean> workArray,
  121. 			Handler handler) {
  122. 		this.maxThread = maxThread;
  123. 		this.mContext = context;
  124. 		this.waitArray = dArray;
  125. 		this.workArray = workArray;
  126. 		this.mHandler = handler;
  127.  
  128. 		downladerArray = new Downloader[maxThread];
  129. 	}
  130.  
  131. 	/**
  132. 	 * 添加任务到队列
  133. 	 * 
  134. 	 * @param bean
  135. 	 */
  136. 	public void insert(Bean bean) {
  137. 		waitArray.insert(bean);
  138. 		refreshDownloaderArray();
  139. 	}
  140. 	
  141. 	/**
  142. 	 * 初始启动Activity时，为下载器数组中的下载器分配下载任务
  143. 	 */
  144. 	public void assignTaskToDownloaders() {
  145. 		int i = 0;
  146. 		while (i < maxThread && !waitArray.isEmpty()) {
  147. 			// 为下载器分配下载任务
  148. 			Bean bean = waitArray.poll();
  149. 			workArray.insert(bean); // 不管任务完成与否都插入到"工作队列"中去
  150.  
  151. 			if (bean.getIsFinished() == Conf.FALSE) { // 只为未完成的任务分配下载器
  152. 				downladerArray[i] = new Downloader(mContext);
  153. 				downladerArray[i].assignTask(bean, myDownloadListener, handler);
  154. 				i++;
  155. 			}
  156. 		}
  157. 	}
  158.  
  159. 	/**
  160. 	 * 取消整个队列任务
  161. 	 */
  162. 	public void kill() {
  163. 		for (Downloader d : downladerArray) {
  164. 			if (d != null) {
  165. 				d.kill();
  166. 			}
  167. 		}
  168. 	}
  169.  
  170. 	/**
  171. 	 * 检查下载器队列的状态，负责刷新下载器中的任务。通常在新增、更新、删除任务后调用
  172. 	 */
  173. 	public void refreshDownloaderArray() {
  174. 		for (int i = 0; i < maxThread; i++) {
  175. 			if (downladerArray[i] != null && downladerArray[i].isIdle()) {
  176. 				if (!waitArray.isEmpty()) {
  177. 					Bean bean = waitArray.poll();
  178. 					workArray.insert(bean);
  179. 					// 为下载器分配下载任务
  180. 					downladerArray[i].assignTask(bean, myDownloadListener,
  181. 							handler);
  182. 					// 开始下载
  183. 					downladerArray[i].recovery();
  184. 				} else {
  185. 					downladerArray[i].kill();
  186. 				}
  187. 			}
  188. 		}
  189. 	}
  190.  
  191. 	/**
  192. 	 * 根据guid查询得到其对应的实体bean对象
  193. 	 * 
  194. 	 * @param guid
  195. 	 * @return
  196. 	 */
  197. 	public Downloader getDownloaderByGuid(String guid) {
  198. 		for (Downloader d : downladerArray) {
  199. 			if (d != null && d.getBean().getGuid().equals(guid)) {
  200. 				return d;
  201. 			}
  202. 		}
  203. 		return null;
  204. 	}
  205.  
  206. 	// /**
  207. 	// * 检查网络环境
  208. 	// */
  209. 	// public boolean isNetAvailable() {
  210. 	// return true;
  211. 	// }
  212. }

        下载器类Downloader，负责下载数据，将下载状态进行持久化。需要特别说明一下的是，这里的下载器在启动后会进入一个下载循环，即使当前任务断开服务器连接，进入暂停状态，本下载器不会停止，只是进入了wait状态。除此之外，下载器中还包含自定义接口MyDownloadListener，用于向Activity反馈当前的下载状态，以更新界面。

  1. package com.wly.filedownloader;
  2.  
  3. import java.io.File;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. import java.io.RandomAccessFile;
  8. import java.net.HttpURLConnection;
  9. import java.net.MalformedURLException;
  10. import java.net.ProtocolException;
  11. import java.net.URL;
  12.  
  13. import com.wly.filedownloader.dao.BeanHelper;
  14.  
  15. import android.app.AlertDialog;
  16. import android.content.Context;
  17. import android.content.DialogInterface;
  18. import android.os.Handler;
  19. import android.os.Message;
  20.  
  21. /**
  22.  * 下载器
  23.  * @author wly
  24.  *
  25.  */
  26. public class Downloader extends Thread {
  27.  
  28. 	private Bean mBean;
  29. 	private MyDownloadListener mListener;
  30. 	
  31. 	//用于表征当前下载器是否处于空闲状态，如果是的话，可以为其分配新的下载任务,进入空闲状态只有两种方法:"下载完成"和"取消下载"
  32. 	private boolean isIdle; 
  33. 	
  34. 	private boolean isAlive = false; //表示当前下载器是否已经激活,默认未激活
  35. 	
  36. 	private Handler handler;
  37. 	
  38. 	private Context mContext;
  39. 	
  40. 	private int beanPercent;	
  41. 	
  42. 	private int state;
  43. 	/**
  44. 	 * 创建对象
  45. 	 * @param context
  46. 	 */
  47. 	public Downloader(Context context) {
  48. 		isIdle = true;
  49. 		this.mContext = context;
  50. 		state = Conf.State_WAITTASK;
  51. 	}
  52.  
  53. 	public boolean isPause() {
  54. 		return (state == Conf.State_PAUSE);
  55. 	}
  56. 	
  57. 	public boolean isRun() {
  58. 		return (state == Conf.State_DOWNLOAD);
  59. 	}
  60. 	
  61. 	/**
  62. 	 * 返回当前下载器的激活状态
  63. 	 * @return
  64. 	 */
  65. 	public boolean isActive() {
  66. 		return isAlive;
  67. 	}
  68.  
  69. 	/**
  70. 	 * 等到当前下载器状态
  71. 	 * @return
  72. 	 */
  73. 	public int getstate() {
  74. 		return state;
  75. 	}
  76. 	
  77. 	/**
  78. 	 * 分配任务
  79. 	 * @param id
  80. 	 * @param bean
  81. 	 * @param listener
  82. 	 * @param handler
  83. 	 */
  84. 	public void assignTask(Bean bean,MyDownloadListener listener,Handler handler) {
  85.  
  86. 		this.mBean = bean;
  87. 		this.mListener = listener;
  88. 		this.handler = handler;
  89. 		isIdle = false;
  90. 	}
  91. 	
  92. 	public Bean getBean() {
  93. 		return this.mBean;
  94. 	}
  95.  
  96. 	/**
  97. 	 * 取消下载任务
  98. 	 */
  99. 	public void cancel() {
  100. 		
  101. 			//先暂停当前任务
  102. 			if(!isPause()) { 
  103. 				pause();
  104. 			}
  105. 			AlertDialog.Builder dialog = new AlertDialog.Builder(mContext);
  106. 			dialog.setTitle("提示")
  107. 				.setMessage("确定要取消当前选中的任务吗?")
  108. 				.setPositiveButton("是的", new DialogInterface.OnClickListener() {
  109. 					
  110. 					@Override
  111. 					public void onClick(DialogInterface dialog, int which) {
  112. 						if(state == Conf.State_WAITTASK || state == Conf.State_PAUSE) {
  113. 							isIdle = true;
  114. 							BeanHelper.delete(mContext, mBean);
  115. 							mListener.canceled(mBean.getGuid());
  116. 							mBean.setPercent(0);
  117. 							state = Conf.State_WAITTASK;
  118. 						} else {
  119. 							state = Conf.State_CANCELING;
  120. 						}
  121. 					}
  122. 				}).setNegativeButton("取消", new DialogInterface.OnClickListener() {
  123. 					
  124. 					@Override
  125. 					public void onClick(DialogInterface dialog, int which) {
  126. 						recovery(); //恢复下载
  127. 					}
  128. 				}).show();
  129. 	}
  130. 	
  131. 	/**
  132. 	 * 暂停任务
  133. 	 */
  134. 	public void pause() {
  135. 		state = Conf.State_PAUSE;
  136. 		mListener.paused();
  137. 	}
  138. 	
  139. 	public void recovery() {
  140. 		state = Conf.State_DOWNLOAD;
  141. 		mListener.resumed();
  142. 		interrupt();
  143. 	}
  144. 	
  145. 	public boolean isPaused() {
  146. 		return state == Conf.State_PAUSE;
  147. 	}
  148. 	
  149. 	/**
  150. 	 * 取消当前任务
  151. 	 */
  152. 	public void kill() {
  153. 		System.out.println("Kill the downloader with guid:" + mBean.getGuid());
  154. 		state = Conf.State_WAITTASK;
  155. 		isAlive = false;
  156. 	}
  157. 	
  158. 	public boolean isIdle() {
  159. 		return isIdle;
  160. 	}
  161. 	
  162. 	@Override
  163. 	public void run() {
  164. 		synchronized (this){
  165. 			long fileSize = 0;
  166. 			RandomAccessFile randomAccessFile = null;
  167. 			long completedSize = 0;
  168. 			isAlive = true;
  169. 			isIdle = false;
  170. 			state = Conf.State_DOWNLOAD;
  171. 			InputStream is = null;
  172. 			HttpURLConnection conn = null;
  173. 			File file = null;
  174. 			mBean.setIsEnabled(Conf.TRUE);
  175. 			while(isAlive) {
  176. 				//如果有可下载任务，就进行下载
  177. 				if(state == Conf.State_DOWNLOAD) {
  178. 					//1.读取当前下载任务信息，如果是断点继续下载，则进行文件连续性判断				
  179. 					beanPercent = mBean.getPercent();
  180. 					completedSize = mBean.getCompleteSize();
  181. 					//检查本地文件是否存在
  182. 					File pathFile = new File(Conf.getSaveDir(mContext));
  183. 					if (!pathFile.exists()) {
  184. 						pathFile.mkdirs();
  185. 					}
  186. 					file = new File(Conf.getSaveDir(mContext) 
  187. 							+ File.separator  + mBean.getTitle());
  188. 					System.out.println("新任务:" + mBean.getTitle());
  189. 					if(!file.exists()) {
  190. 						if(mBean.getCompleteSize() == 0) {//新任务
  191. 							try {
  192. 								file.createNewFile();
  193. 							} catch (IOException e) {
  194. 								e.printStackTrace();
  195. 							}
  196. 						} else { //暂停任务,但是文件不存在，则重置下载任务
  197. 							mBean = new Bean(mBean.getGuid(), mBean.getUrl(), mBean.getTitle(), Conf.State_WAITTASK, 0);
  198. 							BeanHelper.update(mContext, mBean);
  199. 							beanPercent = mBean.getPercent();
  200. 							completedSize = mBean.getCompleteSize();
  201. 							
  202. 							Message msg = new Message();
  203. 							msg.what = Conf.State_FILEERROR;
  204. 							handler.sendMessage(msg);
  205. 						}
  206. 					}
  207. 					
  208. 					
  209. 					//2.与服务器检验文件的统一性
  210. 					//verifyFileWithServer();
  211. 					
  212. 					//从当前进度点开始数据下载
  213. 					URL url;
  214. 					try {
  215. 						url = new URL(mBean.getUrl());
  216. 						conn = (HttpURLConnection) url.openConnection();
  217. 						conn.setDoInput(true);
  218. 						conn.setDoOutput(true);
  219. 						conn.setConnectTimeout(Conf.NET_TIMEOUT_CONNECT);
  220. 						conn.setReadTimeout(Conf.NET_TIMEOUT_READ);
  221. 						conn.setRequestMethod("GET");
  222. 						
  223. 						fileSize = conn.getContentLength(); //得到文件尺寸
  224. 						
  225. 						try {
  226. 							randomAccessFile = new RandomAccessFile(file, "rwd");
  227. 							randomAccessFile.setLength(mBean.getCompleteSize());
  228. 							beanPercent = (int)((double)(completedSize) / fileSize * 100);
  229. 							randomAccessFile.seek((long)beanPercent);
  230. 						} catch (FileNotFoundException e) {
  231. 							e.printStackTrace();
  232. 							//重置下载任务
  233. 							
  234. 						} catch (IOException e) {
  235. 							e.printStackTrace();
  236. 							//重置下载任务
  237. 						}
  238. 						
  239. 						//准备就绪
  240. 						mListener.started();
  241. 						mBean.setIsEnabled(Conf.TRUE);
  242. 						mListener.ready(mBean.getGuid());	
  243. 					} catch (MalformedURLException e1) {
  244. 						e1.printStackTrace();
  245. 					} catch (ProtocolException e) {
  246. 						e.printStackTrace();
  247. 					} catch (IOException e) {
  248. 						e.printStackTrace();
  249. 					}
  250. 					
  251. 					//开始下载
  252. 					try {
  253. 						is = conn.getInputStream();
  254. 						int length = -1;
  255. 						byte[] buffer = new byte[2048];
  256. 						while(state == Conf.State_DOWNLOAD &&
  257. 									(length=is.read(buffer)) != -1) {
  258. 							randomAccessFile.write(buffer, 0, length);
  259. 							completedSize += length;
  260. 							beanPercent = (int)((double)(completedSize) / fileSize * 100);
  261. 							mBean.setPercent(beanPercent);
  262. 							
  263. 							Message msg = new Message();
  264. 							handler.sendMessage(msg);
  265. 							
  266. 							System.out.println("percent:" + beanPercent);
  267. 							//当前任务已完成，进入"空闲"状态
  268. 							if(beanPercent == 100) {
  269. 								System.out.println("--一个下载任务完成--");
  270.  
  271. 								mBean.setIsFinished(Conf.TRUE);
  272. 								mBean.setIsEnabled(Conf.FALSE);
  273. 								//1.数据持久化动作
  274. 								mBean.setPercent(beanPercent);
  275. 								mBean.setCompleteSize(completedSize);
  276. 								BeanHelper.update(mContext, mBean);
  277. 								System.out.println("---更新状态完毕---");
  278. 							
  279. 								//2.下载完毕,发送通知,刷新界面,等待新任务
  280. 								//告知下载队列，请求新任务
  281. 								isIdle = true;
  282. 								state = Conf.State_WAITTASK;
  283. 								mListener.finished(mBean);
  284. 								beanPercent = 0;
  285. 								completedSize = 0;
  286. //								try {
  287. //									sleep(1000);
  288. //									System.out.println("--等待分配新的任务--");
  289. //								} catch (InterruptedException e) {
  290. //									e.printStackTrace();
  291. //								}
  292. 								break;
  293. 							}
  294. 						}
  295. 					} catch (IOException e1) {
  296. 						e1.printStackTrace();
  297. 					}
  298. 				}
  299. 				
  300. 				if(state == Conf.State_PAUSE) {
  301. 					//1.断开连接
  302. 					if(conn != null) {
  303. 						try {
  304. 							is.close();
  305. 							conn.disconnect();
  306. 						} catch (IOException e) {
  307. 							e.printStackTrace();
  308. 						}
  309. 						System.out.println("---断开连接----");
  310. 						//2.进行数据持久化
  311. 						mBean.setIsEnabled(Conf.TRUE);
  312. 						mBean.setPercent(beanPercent);
  313. 						mBean.setCompleteSize(completedSize);
  314. 						BeanHelper.update(mContext, mBean);
  315. 						System.out.println("---更新状态---");
  316. 					}
  317. 				}
  318. 				
  319. 				if(state == Conf.State_CANCELING) {
  320. 					//1.删除数据库数据
  321. 					BeanHelper.delete(mContext, mBean);
  322. 					//2.刷新界面
  323. 					isIdle = true;
  324. 					mListener.canceled(mBean.getGuid());
  325. 					state = Conf.State_WAITTASK;
  326. 				}
  327. //				try {
  328. //					System.out.println("下载器" + mBean.getGuid() + "正处于暂停/空闲状态");
  329. //					sleep(1000);
  330. //				} catch (InterruptedException e) {
  331. //					e.printStackTrace();
  332. //				}
  333. 				try {
  334. 					wait();
  335. 				} catch (InterruptedException e) {
  336. 					e.printStackTrace();
  337. 				}
  338. 			}
  339. 			System.out.println("This Downloader" + mBean.getGuid() + " has been killed!!!");
  340. 		}
  341. 		
  342.  
  343. 	}
  344. 	
  345. 	/**
  346. 	 * 从文件/网路路径中解析出文件名
  347. 	 * @param filePath
  348. 	 * @return
  349. 	 */
  350. 	public String getFileNameFromPath(String filePath) {
  351. 		String[] ss = filePath.split("//");
  352. 		return ss[ss.length-1];
  353. 	}
  354. 	
  355. 	/**
  356. 	 * 下载过程的生命周期回调接口，用于刷新界面。注意：界面刷新是在数据更改之后的
  357. 	 * @author wly
  358. 	 *
  359. 	 */
  360. 	public interface MyDownloadListener {
  361. 		/**
  362. 		 * 下载完成，发送通知Helper,Helper再通过Handler通知Activity
  363. 		 * @param downloaderID 下载器在下载器数组中的位置索引
  364. 		 */
  365. 		public void finished(Bean bean);
  366. 		/**
  367. 		 * 已经开始下载，下载中，本方法的调用在ready()之后
  368. 		 * @param id
  369. 		 */
  370. 		public void started();
  371. 		/**
  372. 		 * 已经暂停下载
  373. 		 * @param id
  374. 		 */
  375. 		public void paused();
  376. 		/**
  377. 		 * 已经恢复下载
  378. 		 * @param id
  379. 		 */
  380. 		public void resumed();
  381. 		/**
  382. 		 * 已经取消下载
  383. 		 * @param guid
  384. 		 */
  385. 		public void canceled(String guid);
  386. 		/**
  387. 		 * 已经准备就绪(文件校验,断点读取等)，可以开始下载
  388. 		 * @param guid
  389. 		 */
  390. 		public void ready(String guid);
  391. 	}
  392. }

        自定义动态数组类DynamicArray，是下载任务容器，集合了队列和数组的特性。这是由模块的需求决定的，下载任务应该用优先队列(FIFO特性)来做，但是由于下载队列又需要支持用户的删除某个指定任务的功能(数组访问指定索引特性)。

  1. package com.wly.filedownloader;
  2.  
  3. /**
  4.  * 动态数组,结合队列(FIFO)和数组(根据索引进行删除元素)的特性
  5.  * 
  6.  * @author wly
  7.  * 
  8.  */
  9. public class DynamicArray<T> {
  10.  
  11. 	private T[] elems;
  12. 	private int mRight; // 右侧有内容索引值，即队列尾
  13.  
  14. 	private int mLeft; // 左侧有内容索引值，即队列首
  15.  
  16. 	private int INCREATE_STEP = 12;
  17.  
  18. 	// public static void main(String[] args) {
  19. 	// DynamicArray<Student> array = new DynamicArray<Student>();
  20. 	// array.insert(new Student("A"));
  21. 	// array.insert(new Student("B"));
  22. 	// array.insert(new Student("C"));
  23. 	// array.insert(new Student("D"));
  24. 	// array.insert(new Student("E"));
  25. 	// array.insert(new Student("F"));
  26. 	//
  27. 	// array.poll();
  28. 	// array.peek();
  29. 	// array.delete(2);
  30. 	// array.getObjectAt(2);
  31. 	// System.out.println(array.size());
  32. 	//
  33. 	// }
  34.  
  35. 	static class Student {
  36. 		String name;
  37.  
  38. 		public Student(String name) {
  39. 			this.name = name;
  40. 		}
  41. 	}
  42.  
  43. 	public DynamicArray() {
  44. 		elems = (T[]) new Object[INCREATE_STEP];
  45. 		mLeft = 0;
  46. 		mRight = 0;
  47. 	}
  48.  
  49. 	/**
  50. 	 * 插入一个元素到数组
  51. 	 * 
  52. 	 * @param t
  53. 	 */
  54. 	public void insert(T t) {
  55. 		// 扩展数组
  56. 		if (mRight >= elems.length) {
  57. 			T[] temp = (T[]) new Object[elems.length + INCREATE_STEP];
  58. 			for (int i = 0; i < elems.length; i++) {
  59. 				temp[i] = elems[i];
  60. 			}
  61. 			elems = temp;
  62. 			temp = null;
  63. 		}
  64.  
  65. 		if (elems[mRight] == null) {
  66. 			elems[mRight++] = t;
  67. 		} else {
  68. 			elems[mRight++] = t;
  69. 		}
  70. 	}
  71.  
  72. 	public T peek() {
  73. 		if (!isEmpty()) {
  74. 			return elems[mLeft];
  75. 		}
  76. 		return null;
  77. 	}
  78.  
  79. 	/**
  80. 	 * 弹出一个元素，将数组起点到p之间的元素都往右移动一位
  81. 	 * 
  82. 	 * @return
  83. 	 */
  84. 	public T poll() {
  85. 		if (mLeft == mRight) {
  86. 			System.out.println("数组为空，无法移除");
  87. 			return null;
  88. 		} else {
  89. 			T t = elems[mLeft];
  90. 			elems[mLeft++] = null;
  91. 			return t;
  92. 		}
  93. 	}
  94.  
  95. 	/**
  96. 	 * 删除mLeft和mRight之间的元素，从0开始
  97. 	 * 
  98. 	 * @param p
  99. 	 */
  100. 	public void delete(int p) {
  101. 		p = p + mLeft;
  102. 		if (p >= mRight) {
  103. 			System.out.println("无效的索引值,无法进行删除");
  104. 		} else {
  105. 			for (int i = p; i > mLeft; i--) {
  106. 				elems[i] = elems[i - 1];
  107. 			}
  108. 			elems[mLeft] = null;
  109. 		}
  110. 		mLeft++;
  111. 	}
  112.  
  113. 	/**
  114. 	 * 返回数组实际保存的有效个数
  115. 	 * 
  116. 	 * @return
  117. 	 */
  118. 	public int size() {
  119.  
  120. 		return (mRight - mLeft);
  121. 	}
  122.  
  123. 	/**
  124. 	 * 得到mLeft和mRight之间第p个元素，从0开始
  125. 	 * 
  126. 	 * @param p
  127. 	 * @return
  128. 	 */
  129. 	public T getObjectAt(int p) {
  130. 		p = p + mLeft;
  131. 		if (p >= mRight) {
  132. 			System.out.println("无效的索引值,无法进行查找");
  133. 			return null;
  134. 		} else {
  135. 			return elems[p];
  136. 		}
  137. 	}
  138.  
  139. 	/**
  140. 	 * 数组是否为空
  141. 	 * 
  142. 	 * @return
  143. 	 */
  144. 	public boolean isEmpty() {
  145. 		return (mRight <= mLeft);
  146. 	}
  147. }

        实体Bean类

  1. package com.wly.filedownloader;
  2.  
  3. import net.tsz.afinal.annotation.sqlite.Id;
  4. import net.tsz.afinal.annotation.sqlite.Table;
  5.  
  6. /**
  7.  * 下载任务实体类
  8.  * @author wly
  9.  *
  10.  */
  11. @Table(name="Bean")
  12. public class Bean {
  13. 	@Id
  14. 	private int id; //数据表查询主键
  15. 	private String url;
  16. 	private String title;
  17. 	
  18. 	private int isEnabled; //对应percent=(0,100),0表示false,1表示true
  19. 	private int isFinished; //对应percent=100,0表示false,1表示true
  20. 	
  21. 	private int percent; //表示当前下载任务的进度，需要持久化
  22. 	
  23. 	private long completeSize;
  24. 	
  25. 	private String guid; //下载实体类唯一性标识id
  26. 	
  27. 	/**
  28. 	 * 默认构造函数，必须有
  29. 	 */
  30. 	public Bean() {
  31. 		
  32. 	}
  33. 	
  34. 	/**
  35. 	 * 新建任务，没有状态和进度,默认isEnabled、isFinished都为false
  36. 	 */
  37. 	public Bean(String url,String title) {
  38. 		this.url = url;
  39. 		this.title = title;
  40. 		this.percent = 0;
  41. 		this.completeSize = 0;
  42. 		this.isEnabled = Conf.FALSE;
  43. 		this.isFinished = Conf.FALSE;
  44. 	}
  45.  
  46. 	/**
  47. 	 * 从本地持久化处新建对象，包含状态和进度
  48. 	 * @param url
  49. 	 * @param title
  50. 	 * @param state 0初始状态，1下载中，2暂停中
  51. 	 * @param percent
  52. 	 */
  53. 	public Bean(String guid,String url, String title, int state, int percent) {
  54. 		super();
  55. 		this.guid = guid;
  56. 		this.url = url;
  57. 		this.title = title;
  58. 		this.percent = percent;
  59. 	}
  60.  
  61. 	public String getUrl() {
  62. 		return url;
  63. 	}
  64.  
  65. 	public void setUrl(String url) {
  66. 		this.url = url;
  67. 	}
  68.  
  69. 	public String getTitle() {
  70. 		return title;
  71. 	}
  72.  
  73. 	public void setTitle(String title) {
  74. 		this.title = title;
  75. 	}
  76.  
  77. 	public int getPercent() {
  78. 		return percent;
  79. 	}
  80.  
  81. 	public void setPercent(int percent) {
  82. 		this.percent = percent;
  83. 	}
  84.  
  85. 	public int getId() {
  86. 		return id;
  87. 	}
  88.  
  89. 	public void setId(int id) {
  90. 		this.id = id;
  91. 	}
  92.  
  93. 	public long getCompleteSize() {
  94. 		return completeSize;
  95. 	}
  96.  
  97. 	public void setCompleteSize(long completeSize) {
  98. 		this.completeSize = completeSize;
  99. 	}
  100.  
  101. 	public String getGuid() {
  102. 		return guid;
  103. 	}
  104.  
  105. 	public void setGuid(String guid) {
  106. 		this.guid = guid;
  107. 	}
  108.  
  109. 	public int getIsEnabled() {
  110. 		return isEnabled;
  111. 	}
  112.  
  113. 	public void setIsEnabled(int isEnabled) {
  114. 		this.isEnabled = isEnabled;
  115. 	}
  116.  
  117. 	public int getIsFinished() {
  118. 		return isFinished;
  119. 	}
  120.  
  121. 	public void setIsFinished(int isFinished) {
  122. 		this.isFinished = isFinished;
  123. 	}
  124. }

      最后，配置参数类Conf

  1. package com.wly.filedownloader;
  2.  
  3. import java.io.File;
  4.  
  5. import android.content.Context;
  6. import android.os.Environment;
  7.  
  8. /**
  9.  * 看出配置类
  10.  * @author wly
  11.  *
  12.  */
  13. public class Conf {
  14.  
  15. 	public final static int NET_TIMEOUT_READ  = 5000; //读取超时
  16. 	public final static int NET_TIMEOUT_CONNECT = 20000; //连接超时
  17. 	
  18. 	public final static int State_DOWNLOAD = 1; //下载中状态
  19. 	public final static int State_PAUSE = 2; //暂停状态
  20. 	public final static int State_FINISH = 3;//完成状态
  21. 	public final static int State_CANCEL = 4; //DownloadBean被取消
  22. 	public final static int State_WAITTASK = 5; //等待下载任务状态，可能刚下载完一个任务，可能还没还是下载任务
  23. 	
  24. 	public final static int State_CANCELING = 7; //任务取消中
  25. 	
  26. 	public final static int State_FILEERROR = 6; //文件异常，文件版本不连续
  27. 	
  28. 	public final static int MSG_STATECHANGED = 9;//表示列表状态发生概念，通知Adapter刷新界面
  29. 	
  30. 	public final static int RETRY_TIMES = 3; //网络请求重试次数
  31. 	
  32. 	public final static int FALSE = 0;
  33. 	public final static int TRUE = 1;
  34. 	
  35. 	/**
  36. 	 * 得到本地文件保存路径
  37. 	 * @return
  38. 	 */
  39. 	public static String getSaveDir(Context context) {
  40. 		
  41. 		String fileDir;
  42. 		
  43. 		if (android.os.Environment.getExternalStorageState().equals(
  44. 				android.os.Environment.MEDIA_MOUNTED)) { //判断SD卡是否存在
  45. 			File f = context.getExternalCacheDir();
  46. 			if (null == f) {
  47. 				fileDir = Environment.getExternalStorageDirectory().getPath()
  48. 						+ File.separator + context.getPackageName()
  49. 						+ File.separator + "cache";
  50. 			} else {
  51. 				fileDir = f.getPath();
  52. 			}
  53. 		} else {
  54. 			File f = context.getCacheDir();
  55. 			fileDir = f.getPath();
  56. 		}
  57. 		return fileDir;
  58. 	}
  59. }

       几个实现过程中需要注意的地方

       1、列表的进度反馈，因为列表需要支持拖动的同时刷新进度，但是如果简单的使用BaseAdapter.notifyDataSetChanged()来刷新的话，会出现两个问题： 一、列表拖动过程中有卡顿现象；二、列表上的按钮将变得难以响应单击事件。那么怎么解决这个问题呢？可以这么思考，如果不使用notifyDataSetChanged来刷新整张列表，而是直接取得列表项上的组件的引用，然后直接修改组件属性的话，就不会出现上述两个问题了。

       解决：Google了很多，讲的多少使用ListView.getFirstVisiablePosition和getChildAt()配合使用，我也试了下，发现在拖动列表时会出现显示错乱的情况(主要问题是getChildAt得到的View并不是期望的View)。于是只能再自己想办法了，还好咱够聪明，难不倒咱。这里在getView中使用当前的为每个contentView分配一个id:

  1. 	public View getView(final int position, View convertView, ViewGroup parent) {
  2. 			.......
  3.                      .......		
  4. 			convertView.setId(position);
  5. 			return convertView;
  6. 		}

       然后在需要刷新时根据id得到对应的列表项convertView对象，在取得其中的ProgressBar并为其设置进度即可。

  1. //刷新可见区域列表进度值
  2. 				int firstV = lv.getFirstVisiblePosition();
  3. 				int lastV = lv.getLastVisiblePosition();
  4. 				for (int i = firstV; i <= lastV; i++)  {
  5. 					
  6. 					View cell = lv.findViewById(i);
  7. 					cell.getId();
  8. 					if(cell != null) {
  9. 						Bean bean = workArray.getObjectAt(i);
  10. 						if(bean != null) {
  11. 							((ProgressBar)cell
  12. 									.findViewById(R.id.download_progress))
  13. 									.setProgress(bean.getPercent());
  14. 						}
  15. 					}
  16. 				}

       2、下载器队列的安排，因为有这样特定的需求，所以需要手动管理"等待中"队列和"下载中"队列。

       3、下载模块的实现，可能不是很难，不过还是有一些需要注意的地方的。

 

       工程下载地址: http://download.csdn.net/detail/u011638883/6803369

       O啦~~~

       虽然东西不是很难，但还是花了笔者不少时间，希望能给有需要的朋友一点参考。

       谢谢!!

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/283753
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号