android 下载管理器

android 自带了下载管理器，我们可以获取到下载的进度大小以及下载完成等等的状态，但是android自带的DownLoadManager却没有实现比如暂停，继续等功能也就是不能断点续传，这几天在总下载管理器，写了以后总是 感觉还是不是太好，因为下载要考虑的情况是比较多的

1、我们要考虑下载的时候要有下载情况的回调，

2、下载的文件是否已经下载

3、是否已经下载完成

4、下载速度

5、下载的进度

6、下载的过程中暂停，继续，取消等操作

7、可能有些人还要把下载的列表分为a 已经下载完成 b 正在下载

8、还有要加下载完成的通知，或是提示

9、还有listView经常遇到的进度条显示错乱

等等。。。。上网查找了很多的资料，网上有现成的第三方DownloadProvider这个，功能相当的齐全，但是我还是希望自己能写一个

下边是我自己的实现思路

首先 1 、要有一个service 来进行后台下载

2、需要有一个存放下载信息的一个实体类downLoadInfo 包含下载的文件大小，每次下载的大小，下载的速度等

private long id;

@Transient

private HttpHandler<File> handler;

private HttpHandler.State state
private String downloadUrl;
private String fileName;
private String fileSavePath;
private long progress;
private long fileLength;
private boolean autoResume;
private boolean autoRename;
private float speed;

3、一个下载管理器；进行下载的管理，已经下载进度的回调

下载我使用的是第三方的xutils

4 、一个DownLoadAdapter用来给listView填充数据

整体来讲就是这么多。

下载管理器代码如下

package cn.com.huahuawifi.android.guest.download;

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

import cn.com.huahuawifi.android.guest.util.Utils;
import cn.com.huahuawifi.android.guest.util.XUtilsHttpUtil;

import com.lidroid.xutils.DbUtils;
import com.lidroid.xutils.HttpUtils;
import com.lidroid.xutils.db.converter.ColumnConverter;
import com.lidroid.xutils.db.converter.ColumnConverterFactory;
import com.lidroid.xutils.db.sqlite.ColumnDbType;
import com.lidroid.xutils.db.sqlite.Selector;
import com.lidroid.xutils.exception.DbException;
import com.lidroid.xutils.exception.HttpException;
import com.lidroid.xutils.http.HttpHandler;
import com.lidroid.xutils.http.HttpHandler.State;
import com.lidroid.xutils.http.ResponseInfo;
import com.lidroid.xutils.http.callback.RequestCallBack;
import com.lidroid.xutils.util.LogUtils;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

/**
 * 下载管理器
 */
public class DownloadManager {

    private List<DownloadInfo> downloadInfoList; // 下载列表
    private List<DownloadInfo> alreadyDownLoadList; // 已经下载完成的
    private List<DownloadInfo> downLoadingList; // 正在下载
    private int maxDownloadThread = 3; // 最大下载线程数

    private Context mContext;
    private DbUtils db;

    private long mLastTime;
    private long mLastFileSize;

    /* package */DownloadManager(Context appContext) {
        ColumnConverterFactory.registerColumnConverter(HttpHandler.State.class,
                new HttpHandlerStateConverter());
        mContext = appContext;
        db = DbUtils.create(mContext);
        alreadyDownLoadList = new ArrayList<DownloadInfo>();
        downLoadingList = new ArrayList<DownloadInfo>();
        try {
            downloadInfoList = db.findAll(Selector.from(DownloadInfo.class)); // 查询所有的下载
        } catch (DbException e) {
            LogUtils.e(e.getMessage(), e);
        }
        if (downloadInfoList == null) {
            downloadInfoList = new ArrayList<DownloadInfo>();

        } else {
            for (int i = 0; i < downloadInfoList.size(); i++) {
                if (downloadInfoList
                        .get(i)
                        .getState()
                        .equals(com.lidroid.xutils.http.HttpHandler.State.SUCCESS)) {
                    alreadyDownLoadList.add(downloadInfoList.get(i));
                } else {
                    downLoadingList.add(downloadInfoList.get(i));
                }
            }
        }

    }

    public int getDownloadInfoListCount() {
        return downloadInfoList.size();
    }

    public DownloadInfo getDownloadInfo(int index) {
        return downloadInfoList.get(index);
    }

    public int getDownloadInfoLoadingCount() {
        return downLoadingList.size();

    }

    public List<DownloadInfo> getDownLoadingList() {

        return downLoadingList;
    }

    public DownloadInfo getDownLoadinginfo(int index) {
        downLoadingList.get(index);
        return downLoadingList.get(index);
    }

    public int getAlreadyDownLoadCount() {
        return alreadyDownLoadList.size();

    }

    public List<DownloadInfo> getAlreadyDownLoadList() {

        return alreadyDownLoadList;
    }
    public DownloadInfo getAlreadyDownLoadInfo(int index) {
        alreadyDownLoadList.get(index);
        return alreadyDownLoadList.get(index);
    }
/**
 * 获取当前url的文件是否在下载列表里，或去的时候想确保把改下载添加到了下载列表中
 * @param downloadUrl
 * @return
 */
    public DownloadInfo  getDownLoadInfo(String  downloadUrl){
    DownloadInfo downloadInfo =null;
        for (DownloadInfo doInfo : downloadInfoList) {
            if (doInfo.getDownloadUrl().equals(downloadUrl)) {
                downloadInfo  =doInfo;
                return downloadInfo;
            }
        }
        return downloadInfo;
    }
    /**
     * 添加下载任务
     * 
     * @param url
     *            下载链接
     * @param fileName
     *            文件名
     * @param target
     *            文件存放路径
     * @param autoResume
     * @param autoRename
     * @param callback
     *            回调
     * @throws DbException
     */
    public void addNewDownload(String url, String fileName, String target,
            boolean autoResume, boolean autoRename,
            final RequestCallBack<File> callback) throws DbException {
        if (Utils.fileIsExists(target)) {// 下载文件已经存在不在添加下载任务

        } else {

            final DownloadInfo downloadInfo = new DownloadInfo();
            downloadInfo.setDownloadUrl(url);
            downloadInfo.setAutoRename(autoRename);
            downloadInfo.setAutoResume(autoResume);
            downloadInfo.setFileName(fileName);
            downloadInfo.setFileSavePath(target);
            HttpUtils http = new HttpUtils();
            http.configRequestThreadPoolSize(maxDownloadThread);
            HttpHandler<File> handler = http.download(url, target, autoResume,
                    autoRename, new ManagerCallBack(downloadInfo, callback));
            downloadInfo.setHandler(handler);
            downloadInfo.setState(handler.getState());
            downloadInfoList.add(downloadInfo);
            db.saveBindingId(downloadInfo);
        }
    }

    public void resumeDownload(int index, final RequestCallBack<File> callback)
            throws DbException {
        final DownloadInfo downloadInfo = downloadInfoList.get(index);
        resumeDownload(downloadInfo, callback);
    }

    /**
     * 重新下载
     * 
     * @param downloadInfo
     *            downLoadinfo信息
     * @param callback
     *            回调
     * @throws DbException
     */
    public void resumeDownload(DownloadInfo downloadInfo,
            final RequestCallBack<File> callback) throws DbException {
        HttpUtils http = new HttpUtils();
        http.configRequestThreadPoolSize(maxDownloadThread);
        HttpHandler<File> handler = http.download(
                downloadInfo.getDownloadUrl(), downloadInfo.getFileSavePath(),
                downloadInfo.isAutoResume(), downloadInfo.isAutoRename(),
                new ManagerCallBack(downloadInfo, callback));
        downloadInfo.setHandler(handler);
        downloadInfo.setState(handler.getState());
        db.saveOrUpdate(downloadInfo);
    }

    /**
     * 移除下载任务
     * 
     * @param index
     *            要移除的下表
     * @throws DbException
     */
    public void removeDownload(int index) throws DbException {
        DownloadInfo downloadInfo = downloadInfoList.get(index);
        removeDownload(downloadInfo);
    }

    /**
     * 移除下载任务
     * 
     * @param downloadInfo
     *            下载的downloadInfo对象
     * @throws DbException
     */
    public void removeDownload(DownloadInfo downloadInfo) throws DbException {
        HttpHandler<File> handler = downloadInfo.getHandler();
        if (handler != null && !handler.isCancelled()) {
            handler.cancel();
        }
        downloadInfoList.remove(downloadInfo);
        downLoadingList.remove(downloadInfo);
        alreadyDownLoadList.remove(downloadInfo);
        db.delete(downloadInfo);
    }

    public void removeAlreadyDownLoad(DownloadInfo downloadInfo) throws DbException{
        HttpHandler<File> handler = downloadInfo.getHandler();
        if (handler != null && !handler.isCancelled()) {
            handler.cancel();
        }

        alreadyDownLoadList.remove(downloadInfo);
        Utils.deleteFile(downloadInfo.getFileSavePath());
        db.delete(downloadInfo);
    }
    /**
     * 停止下载
     * 
     * @param index
     *            下载的下表
     * @throws DbException
     */
    public void stopDownload(int index) throws DbException {
        DownloadInfo downloadInfo = downloadInfoList.get(index);
        stopDownload(downloadInfo);
    }

    /**
     * 停止下载
     * 
     * @param downloadInfo
     *            下载的downloadInfo对象
     * @throws DbException
     */
    public void stopDownload(DownloadInfo downloadInfo) throws DbException {
        HttpHandler<File> handler = downloadInfo.getHandler();
        if (handler != null && !handler.isCancelled()) {
            handler.cancel();
        } else {
            downloadInfo.setState(HttpHandler.State.CANCELLED);
        }
        db.saveOrUpdate(downloadInfo);
    }

    /**
     * 停止所有的下载任务
     * 
     * @throws DbException
     */
    public void stopAllDownload() throws DbException {
        for (DownloadInfo downloadInfo : downloadInfoList) {
            HttpHandler<File> handler = downloadInfo.getHandler();
            if (handler != null && !handler.isCancelled()) {
                handler.cancel();
            } else {
                downloadInfo.setState(HttpHandler.State.CANCELLED);
            }
        }
        db.saveOrUpdateAll(downloadInfoList);
    }

    /**
     * 改变数据库中下载状态
     * 
     * @throws DbException
     */
    public void backupDownloadInfoList() throws DbException {
        for (DownloadInfo downloadInfo : downloadInfoList) {
            HttpHandler<File> handler = downloadInfo.getHandler();
            if (handler != null) {
                switch (handler.getState()) {
                case WAITING:
                    downloadInfo.setState(State.CANCELLED);
                    break;
                case SUCCESS:

                    break;
                case FAILURE:
                    break;
                case LOADING:
                    downloadInfo.setState(State.CANCELLED);
                    break;
                case CANCELLED:
                    downloadInfo.setState(State.CANCELLED);
                    break;
                case STARTED:
                    downloadInfo.setState(State.CANCELLED);
                    break;
                default:
                    break;
                }

            }
        }
        db.saveOrUpdateAll(downloadInfoList);
    }

    public int getMaxDownloadThread() {
        return maxDownloadThread;
    }

    /**
     * 设置最大下载线程
     * 
     * @param maxDownloadThread
     */
    public void setMaxDownloadThread(int maxDownloadThread) {
        this.maxDownloadThread = maxDownloadThread;
    }

    public class ManagerCallBack extends RequestCallBack<File> {
        private DownloadInfo downloadInfo;
        private RequestCallBack<File> baseCallBack;

        public RequestCallBack<File> getBaseCallBack() {
            return baseCallBack;
        }

        public void setBaseCallBack(RequestCallBack<File> baseCallBack) {
            this.baseCallBack = baseCallBack;
        }

        private ManagerCallBack(DownloadInfo downloadInfo,
                RequestCallBack<File> baseCallBack) {
            this.baseCallBack = baseCallBack;
            this.downloadInfo = downloadInfo;
        }

        @Override
        public Object getUserTag() {
            if (baseCallBack == null)
                return null;
            return baseCallBack.getUserTag();
        }

        @Override
        public void setUserTag(Object userTag) {
            if (baseCallBack == null)
                return;
            baseCallBack.setUserTag(userTag);
        }

        @Override
        public void onStart() {
            HttpHandler<File> handler = downloadInfo.getHandler();
            if (handler != null) {
                downloadInfo.setState(handler.getState());
            }
            try {
                db.saveOrUpdate(downloadInfo);
                if (downLoadingList.size() == 0) {
                    downLoadingList.add(downloadInfo);
                }
            } catch (DbException e) {
                LogUtils.e(e.getMessage(), e);
            }
            if (baseCallBack != null) {
                baseCallBack.onStart();
            }
        }

        @Override
        public void onCancelled() {
            HttpHandler<File> handler = downloadInfo.getHandler();
            if (handler != null) {
                downloadInfo.setState(handler.getState());
            }
            try {
                db.saveOrUpdate(downloadInfo);
            } catch (DbException e) {
                LogUtils.e(e.getMessage(), e);
            }
            if (baseCallBack != null) {
                baseCallBack.onCancelled();
            }
        }

        @Override
        public void onLoading(long total, long current, boolean isUploading) {
            HttpHandler<File> handler = downloadInfo.getHandler();
            if (handler != null) {
                downloadInfo.setState(handler.getState());
            }
            long nowTime = System.currentTimeMillis();
            Log.e("SPEED1", nowTime + "");
            Log.e("SPEED2", mLastTime + "");
            Log.e("SPEED1_file", current + "");
            Log.e("SPEED2_file", mLastFileSize + "");
            float speed = 0;
            float speedContent = current - mLastFileSize;
            float speedTimer = nowTime - mLastTime;
            if (mLastTime > 0 && current != 0) {

                if (speedContent >= 1024) {
                    speedContent = (float) ((speedContent) / (1024 + 0.0));
                    speedContent = (float) (((int) (speedContent * 10) % 10 + 0.0) / 10 + (int) speedContent);
                    speedTimer = (float) ((speedTimer) / (1000 + 0.0));
                    speed = speedContent / speedTimer;
                }
                Log.e("SPEED", speed + "");
            }

            mLastTime = nowTime;
            mLastFileSize = current;
            downloadInfo.setSpeed(speed);
            downloadInfo.setFileLength(total);

            downloadInfo.setFileAllSize(((float) total) / ((float) 1048576));
            ;
            downloadInfo.setProgress(current);
            try {
                db.saveOrUpdate(downloadInfo);
            } catch (DbException e) {
                LogUtils.e(e.getMessage(), e);
            }
            if (baseCallBack != null) {
                baseCallBack.onLoading(total, current, isUploading);
            }
        }

        @Override
        public void onSuccess(ResponseInfo<File> responseInfo) {
            HttpHandler<File> handler = downloadInfo.getHandler();
            if (handler != null) {
                downloadInfo.setState(handler.getState());
                downLoadingList.remove(downloadInfo);
                alreadyDownLoadList.add(downloadInfo);
            }
            try {
                db.saveOrUpdate(downloadInfo);
            } catch (DbException e) {
                LogUtils.e(e.getMessage(), e);
            }
            if (baseCallBack != null) {
                baseCallBack.onSuccess(responseInfo);
            }
        }

        @Override
        public void onFailure(HttpException error, String msg) {
            HttpHandler<File> handler = downloadInfo.getHandler();
            if (handler != null) {
                downloadInfo.setState(handler.getState());
            }
            try {
                db.saveOrUpdate(downloadInfo);
            } catch (DbException e) {
                LogUtils.e(e.getMessage(), e);
            }
            if (baseCallBack != null) {
                baseCallBack.onFailure(error, msg);
            }
        }
    }

    private class HttpHandlerStateConverter implements
            ColumnConverter<HttpHandler.State> {

        @Override
        public HttpHandler.State getFieldValue(Cursor cursor, int index) {
            return HttpHandler.State.valueOf(cursor.getInt(index));
        }

        @Override
        public HttpHandler.State getFieldValue(String fieldStringValue) {
            if (fieldStringValue == null)
                return null;
            return HttpHandler.State.valueOf(fieldStringValue);
        }

        @Override
        public Object fieldValue2ColumnValue(HttpHandler.State fieldValue) {
            return fieldValue.value();
        }

        @Override
        public ColumnDbType getColumnDbType() {
            return ColumnDbType.INTEGER;
        }
    }
}

DownLoadInfo

<span style="font-size:10px;">package cn.com.huahuawifi.android.guest.download;

import com.lidroid.xutils.db.annotation.Transient;
import com.lidroid.xutils.http.HttpHandler;

import java.io.File;

public class DownloadInfo {

    public DownloadInfo() {
    }

    private long id;

    @Transient
    private HttpHandler<File> handler;

    private HttpHandler.State state;

    private String downloadUrl;

    private String fileName;

    private String fileSavePath;

    private long progress;      //下载的长度

    private long fileLength;   //文件的总长度

    private boolean autoResume;

    private boolean autoRename;     

    private float speed;

    private float fileAllSize;

    public float getFileAllSize() {
        return fileAllSize;
    }

    public void setFileAllSize(float fileAllSize) {
        this.fileAllSize = fileAllSize;
    }

    public float getSpeed() {
        return speed;
    }

    public void setSpeed(float speed) {
        this.speed = speed;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public HttpHandler<File> getHandler() {
        return handler;
    }

    public void setHandler(HttpHandler<File> handler) {
        this.handler = handler;
    }

    public HttpHandler.State getState() {
        return state;
    }

    public void setState(HttpHandler.State state) {
        this.state = state;
    }

    public String getDownloadUrl() {
        return downloadUrl;
    }

    public void setDownloadUrl(String downloadUrl) {
        this.downloadUrl = downloadUrl;
    }

    public String getFileName() {
        return fileName;
    }

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    public String getFileSavePath() {
        return fileSavePath;
    }

    public void setFileSavePath(String fileSavePath) {
        this.fileSavePath = fileSavePath;
    }

    public long getProgress() {
        return progress;
    }

    public void setProgress(long progress) {
        this.progress = progress;
    }

    public long getFileLength() {
        return fileLength;
    }

    public void setFileLength(long fileLength) {
        this.fileLength = fileLength;
    }

    public boolean isAutoResume() {
        return autoResume;
    }

    public void setAutoResume(boolean autoResume) {
        this.autoResume = autoResume;
    }

    public boolean isAutoRename() {
        return autoRename;
    }

    public void setAutoRename(boolean autoRename) {
        this.autoRename = autoRename;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof DownloadInfo)) return false;

        DownloadInfo that = (DownloadInfo) o;

        if (id != that.id) return false;

        return true;
    }

    @Override
    public int hashCode() {
        return (int) (id ^ (id >>> 32));
    }
}</span><span style="font-size:18px;font-weight: bold;">
</span>

下载的service

<span style="font-size:10px;">package cn.com.huahuawifi.android.guest.download;

import android.app.ActivityManager;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.IBinder;
import com.lidroid.xutils.exception.DbException;
import com.lidroid.xutils.util.LogUtils;

import java.util.List;

public class DownloadService extends Service {

    private static DownloadManager DOWNLOAD_MANAGER;

    public static DownloadManager getDownloadManager(Context appContext) {
        if (!DownloadService.isServiceRunning(appContext)) {
            Intent downloadSvr = new Intent("download.service.action");
            appContext.startService(downloadSvr);
        }
        if (DownloadService.DOWNLOAD_MANAGER == null) {
            DownloadService.DOWNLOAD_MANAGER = new DownloadManager(appContext);
        }
        return DOWNLOAD_MANAGER;
    }

    public DownloadService() {
        super();
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

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

    @Override
    public void onStart(Intent intent, int startId) {
        super.onStart(intent, startId);
    }

    @Override
    public void onDestroy() {
        if (DOWNLOAD_MANAGER != null) {
            try {
                DOWNLOAD_MANAGER.stopAllDownload();
                DOWNLOAD_MANAGER.backupDownloadInfoList();
            } catch (DbException e) {
                LogUtils.e(e.getMessage(), e);
            }
        }
        super.onDestroy();
    }

    public static boolean isServiceRunning(Context context) {
        boolean isRunning = false;

        ActivityManager activityManager =
                (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningServiceInfo> serviceList
                = activityManager.getRunningServices(Integer.MAX_VALUE);

        if (serviceList == null || serviceList.size() == 0) {
            return false;
        }

        for (int i = 0; i < serviceList.size(); i++) {
            if (serviceList.get(i).service.getClassName().equals(DownloadService.class.getName())) {
                isRunning = true;
                break;
            }
        }
        return isRunning;
    }
}</span><span style="font-size:18px;font-weight: bold;">
</span>