来源：http://blog.csdn.net/u011638883/article/details/17347015

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

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

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

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

主要类介绍

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
package com.wly.filedownloader;
import java.util.List;
import com.wly.filedownloader.dao.BeanHelper;
import net.tsz.afinal.FinalDb;
import net.tsz.afinal.exception.AfinalException;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.graphics.Bitmap.Config;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.Button;
import android.widget.ListAdapter;
import android.widget.ListView;
import android.widget.ProgressBar;
import android.widget.RelativeLayout;
import android.widget.TextView;
 
public class MainActivity extends Activity{
 
    DownloadHelper downHelper;
    private LayoutInflater inflater;
    private ListView lv;
     
    //最大支持同时进行的线程数
    private int maxThread = 2;
     
    //测试下载任务数量
    private int taskSize = 5;
         
    private DynamicArray<bean> waitArray; //等待列表
    private DynamicArray<bean> workArray; //用来存放已完成及下载中的任务
    List<bean> list;
     
    //专门负责刷新界面的Handler
    private Handler refreshHandler = new Handler() {
 
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch(msg.what) {
            case Conf.State_FINISH:
                myAdapter.notifyDataSetChanged();
                break;
            case Conf.State_CANCEL:
                for(int i=0;i<workarray.size();i++) bean="" beanarray="new" bundle="" case="" cell="" conf.msg_statechanged:="" conf.state_download:="" conf.state_fileerror:="" firstv="lv.getFirstVisiblePosition();" for="" i="firstV;" int="" lastv="lv.getLastVisiblePosition();" lv="(ListView)" override="" protected="" view="" void="" workarray="new">();
        waitArray = new DynamicArray<bean>();
 
         
        for(int i=0;i<beanarray.length;i++) .mp3="" 10.0.2.2:8080="" aa_="" bean="" http:="" i=""> list = FinalDb.create(this).findAll(Bean.class);
        if(list.size() == 0) {
            for(int i=0;i<beanarray.length;i++) baseadapter="" bean="" button="" cancelbtn="(Button)convertView.findViewById(R.id.download_btn_cancel);" convertview="inflater.inflate(R.layout.download_list_item," czise:="" downhelper="new" download_level="(RelativeLayout)convertView.findViewById(R.id.download_level);" downloader="" else="" final="" finish_level="(RelativeLayout)convertView.findViewById(R.id.finish_level);" guid="bean.getGuid();" id:="" inflater="LayoutInflater.from(this);" int="" isenabled:="" isfinished:="" list="FinalDb.create(this).findAll(Bean.class);" myadapter="new" override="" pausebtn="(Button)convertView.findViewById(R.id.download_btn_pause);" percent:="" position="" progressbar="" protected="" public="" relativelayout="" resumebtn="(Button)convertView.findViewById(R.id.download_btn_resume);" string="" textview="" title="(TextView)convertView.findViewById(R.id.download_title);" title:="" url:="" view="" viewgroup="" viewholder="" void="" waitcancelbtn="(Button)convertView.findViewById(R.id.wait_btn_cancel);" waiting_level="(RelativeLayout)convertView.findViewById(R.id.waiting_level);"> 暂停/继续
                download_level.setVisibility(View.VISIBLE);
                waiting_level.setVisibility(View.INVISIBLE);
                finish_level.setVisibility(View.INVISIBLE);
                if(downloader.getstate() == Conf.State_DOWNLOAD) { //下载中
                    resumeBtn.setVisibility(View.INVISIBLE);
                    pauseBtn.setVisibility(View.VISIBLE);
                } else { //暂停中
                    resumeBtn.setVisibility(View.VISIBLE);
                    pauseBtn.setVisibility(View.INVISIBLE);
                    resumeBtn.setText(继续);
                }
            } else if(bean.getIsFinished() == Conf.TRUE) { //对应下载进度100 => 完成
                download_level.setVisibility(View.INVISIBLE);
                waiting_level.setVisibility(View.INVISIBLE);
                finish_level.setVisibility(View.VISIBLE);
            } else { //对应下载进度0 => 开始/等待
                //检查是否处于等待状态
                System.out.println(--开始/等待--);
                if(downloader != null) {
                    download_level.setVisibility(View.VISIBLE);
                    waiting_level.setVisibility(View.INVISIBLE);
                    finish_level.setVisibility(View.INVISIBLE);
                     
                    resumeBtn.setText(开始);
                } else {
                    download_level.setVisibility(View.INVISIBLE);
                    waiting_level.setVisibility(View.VISIBLE);
                    finish_level.setVisibility(View.INVISIBLE);
                }
            }
             
            pauseBtn.setOnClickListener(new View.OnClickListener() {
                 
                @Override
                public void onClick(View v) {
                    downloader.pause();
                }
            });
             
            resumeBtn.setOnClickListener(new View.OnClickListener() {
                 
                @Override
                public void onClick(View v) {
                    if(downloader != null && downloader.isActive()) {
                        downloader.recovery();
                        System.out.println(--recovery--);
                    } else {
                        downloader.start();
                        System.out.println(--start--);
                    }
                }
            });
             
            //下载中取消按钮
            cancelBtn.setOnClickListener(new View.OnClickListener() {
                 
                @Override
                public void onClick(View v) {
                    downloader.cancel();
                }
            });
             
            //等待中取消按钮
            waitCancelBtn.setOnClickListener(new View.OnClickListener() {
                 
                @Override
                public void onClick(View v) {
                    if(position < workArray.size()) {
                        downloader.cancel();
                    } else {
                        waitArray.delete(position-workArray.size());
                        BeanHelper.delete(MainActivity.this,bean);
                        myAdapter.notifyDataSetChanged();
                    }
                }
            });
             
            convertView.setId(position);
            return convertView;
        }
         
        @Override
        public long getItemId(int position) {
            return 0;
        }
         
        @Override
        public Object getItem(int position) {
            if(position < workArray.size()) {
                return workArray.getObjectAt(position);
            } else {
                return waitArray.getObjectAt(position-workArray.size());
            }
        }
         
        @Override
        public int getCount() {
            return waitArray.size() + workArray.size();
        }
    };
}
      </beanarray.length;i++)></beanarray.length;i++)></bean></workarray.size();i++)></bean></bean></bean>

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

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

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

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

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

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

实体Bean类

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

最后，配置参数类Conf

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

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

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

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

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

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

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

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

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

Android中多线程下载列表的封装实现(含进度反馈)的更多相关文章

  1. 教你如何在 Android 使用多线程下载文件

    # 教你如何在 Android 使用多线程下载文件 前言 在 Android 日常开发中,我们会经常遇到下载文件需求,这里我们也可以用系统自带的 api DownloadManager 来解决这个问题 ...

  2. 如何在苹果电脑下载器Folx中管理下载列表

    Folx是一款Mas OS专用的下载器,提供了便捷的下载管理.灵活的设置.今天小编准备跟大家聊一聊关于Folx中常见的几种下载管理方式. 一.管理任务状态栏 在Folx下载面板上,可以通过类别查看任务 ...

  3. [Android学习笔记]Android中多线程开发的一些概念

    线程安全: 在多线程的情况下,不会因为线程之间的操作而导致数据错误. 线程同步: 同一个资源,可能在同一时间被多个线程操作,这样会导致数据错误.这是一个现象,也是一个问题,而研究如何解决此类问题的相关 ...

  4. Android之——多线程下载演示样例

    转载请注明出处:http://blog.csdn.net/l1028386804/article/details/46883927 一.概述 说到Android中的文件下载.Android API中明 ...

  5. Android版多线程下载器核心代码分享

    首先给大家分享多线程下载核心类: package com.example.urltest; import java.io.IOException; import java.io.InputStream ...

  6. Android中如何下载文件并显示下载进度

    原文地址:http://jcodecraeer.com/a/anzhuokaifa/androidkaifa/2014/1125/2057.html 这里主要讨论三种方式:AsyncTask.Serv ...

  7. Android中多线程编程(三)Handler更新UI的方式

    Handler更新UI的方式和原因以及遇到的问题 1.方式: 仅仅能通过Handler来更新UI. 代码例如以下: package com.chengdong.su.handlerdemo; impo ...

  8. android中RecycleView分页原生代码封装，无任何第三方代

    概述 RecycleView分页加载封装,简单方便,功能齐全 详细 代码下载:http://www.demodashi.com/demo/13283.html 一.场景: 在项目开发中经常使用到列表集 ...

  9. [zt] Android中使用List列表

    原文地址:http://www.vogella.com/tutorials/AndroidListView/article.html 1. Android and Lists 1.1. Using l ...

随机推荐

  1. ASP.NET MVC轻教程 Step By Step 10——模型验证

    在使用表单获取用户输入的数据时,我们必须对数据进行有效性验证,因为来自网络的信息都是不可信的.同时也要给用户即时的反馈,避免让用户感到困惑.这就涉及到数据验证的范畴. 数据验证最直接的做法是在服务器端 ...

  2. 移动端meta标签整理－备

    分类 在介绍移动端特有 meta 标签之前,先简单说一下 HTML meta 标签的一些知识. meta 标签包含了 HTTP 标题信息 (http-equiv) 和 页面描述信息 (name). h ...

  3. Ikki's Story IV - Panda's Trick

    poj3207:http://poj.org/problem?id=3207 题意::平面上有一个圆,圆的边上按顺时针放着0..n-1共n个点.现在要连m条边,比如a,b,那么a到b可以从圆的内部连接 ...

  4. salt-API基本验证命令

    配置SALT-API,网上有很多,作下来也很顺利. 我的参考: 作一下验证的记录: curl -k https://x.x.x.x:8000/login -H "Accept: applic ...

  5. Scarborough Fair 绝美天籁

    很少见的男声唱法,而且还古色古香: https://www.youtube.com/watch?v=sgbo2QWLBzI https://www.youtube.com/watch?v=-BakWV ...

  6. MySQL重置密码与远程连接权限问题

    如果mysql没有密码,或者密码设置为空的时候可以通过在用管理员身份打开cmd,然后在里面输入mysqladmin -u root password 123456  这个地方的密码是明文密码. 如果忘 ...

  7. BZOJ1232: [Usaco2008Nov]安慰奶牛cheer

    1232: [Usaco2008Nov]安慰奶牛cheer Time Limit: 10 Sec  Memory Limit: 162 MBSubmit: 578  Solved: 403[Submi ...

  8. 【转】Android编译系统详解(三)——编译流程详解

    原文网址:http://www.cloudchou.com/android/post-276.html 本文原创作者:Cloud Chou. 欢迎转载,请注明出处和本文链接 1.概述 编译Androi ...

  9. 【转】VC的MFC中重绘函数的使用总结（整理）

    原文网址:http://www.cnblogs.com/x8023z/archive/2008/12/09/mfc33.html 在刷新窗口时经常要调用重绘函数MFC提供了三个函数用于窗口重绘Inva ...

  10. Google Map API学习1

    这一段时间公司一个新产品上线, 做超市代购的 这样,就需要计算每个门店也就是超市,距离小区之间的距离. 我们用的是Google Map 1.批量对地址进行编码,也就是将地址批量转化成对应的Goole ...