DownloadManagerAsync.java

package com.sogouchat.os;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.http.protocol.HTTP;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import com.sogouchat.bean.DownNode;
import com.sogouchat.bean.MsgNode;
import com.sogouchat.ui.ChatMsgViewAdapter.IMsgContentType;

import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

// 以一个实例，即异步下载，来演示 Android 的异步消息处理（用 Handler 的方式）
public class DownloadManagerAsync {
	private static final String TAG = "DownloadManagerAsync";
	public DownloadManagerAsync() {
	}

	// 实例化自定义的 Handler
	EventHandler mHandler = new EventHandler(this);
	private String mFilePath;
	public boolean mRunning;

	// 按指定 url 地址下载文件到指定路径
	public void download(final String url, final String savePath) {
		Log.i(TAG, "download"+url+savePath) ;
		mRunning = true;
		new Thread(new Runnable() {
			public void run() {
				try {
					// Fetch long url
					String longUrl = null;
					Document doc = Jsoup.connect(url).get();
//					Log.i(TAG, doc.toString());
					String title = doc.title();
					Elements links = doc.select("a[href]");

					for (Element link : links) {
//						Log.i(TAG + "links",
//								link.attr("abs:href") + link.text());
						if (link.text().equals("查看原图")) {
							longUrl = link.attr("abs:href");
						}
						else if (link.text().equals("下载语音")){
							longUrl = link.attr("abs:href");
						}
					}
					if (longUrl == null) {
						Log.i(TAG, "download Not Long Url") ;
						return;
					}
					Log.i(TAG, "download Start+++++++++++") ;
					mFilePath = savePath;
					sendMessage(FILE_DOWNLOAD_CONNECT);
					URL sourceUrl = new URL(longUrl);
					URLConnection conn = sourceUrl.openConnection();
					conn.setDoInput(true);
					conn.setConnectTimeout(5 * 1000);
					InputStream inputStream = conn.getInputStream();

					String filePath = Environment.getExternalStorageDirectory() +ChatAppConstant.SAVE_PATH
							+ savePath;
					Log.i(TAG, "rul = " + longUrl + " " + filePath);
					int urlLen = longUrl.length();
					String imageType = longUrl.substring(urlLen-9, urlLen-6);
					Log.i(TAG, "----imageType = " + imageType);
					if (imageType.compareTo("png")==0){
						filePath = filePath.substring(0, filePath.length()-4);
						filePath = filePath + ".png";
						Log.i(TAG, "filePath = " + filePath);
					}
					File savefile = new File(filePath);
					savefile.createNewFile();
					FileOutputStream outputStream = new FileOutputStream(
							filePath, true);
					
					int readCount = 0; 
					int readNum = 0;
					int prevPercent = 0;
					byte[] buffer = new byte[1024];
					int fileSize = conn.getContentLength();
					Log.i(TAG, "fileSize = " +  fileSize);
					while (readCount < fileSize && 
								((readNum = inputStream.read(buffer)) != -1)) {
						
						outputStream.write(buffer, 0, readNum);
						readCount = readCount + readNum;
						int percent = (int) (readCount * 100 / fileSize);
						if (percent > prevPercent) {
							// 发送下载进度信息
							sendMessage(FILE_DOWNLOAD_UPDATE, percent,
									readCount);
							Log.i(TAG, "percent = " +  percent +"readCount = "+ readCount);
							prevPercent = percent;
						}
					}

					outputStream.flush();
					outputStream.close();
					sendMessage(FILE_DOWNLOAD_COMPLETE, savePath);
					Log.i(TAG, "download End+++++++++++") ;
				} catch (Exception e) {
					sendMessage(FILE_DOWNLOAD_ERROR, e);
					Log.e("MyError", e.toString());
				}
				mHandler.sendEmptyMessage(-100); 
			}
		}).start();
	}
	
	public void download(DownNode msg) {
		mRunning = true;
		String path="";
		if (msg.mType == IMsgContentType.MSG_IMAGE) {
			path = msg.mDate + ".png";
		} else if (msg.mType == IMsgContentType.MSG_AUDIO) {
			path = msg.mDate + ".mp3";
		}
		download(msg.mShortUrl, path);
	}

	// 读取指定 url 地址的响应内容
	public void download(final String url) {
		new Thread(new Runnable() {
			public void run() {
				try {
					sendMessage(FILE_DOWNLOAD_CONNECT);
					URL sourceUrl = new URL(url);
					URLConnection conn = sourceUrl.openConnection();
					conn.setConnectTimeout(3000);
					BufferedReader reader = new BufferedReader(
							new InputStreamReader(conn.getInputStream(),
									HTTP.UTF_8));

					String line = null;
					StringBuffer content = new StringBuffer();
					while ((line = reader.readLine()) != null) {
						content.append(line);
					}

					reader.close();

					sendMessage(FILE_DOWNLOAD_COMPLETE, content.toString());

				} catch (Exception e) {
					sendMessage(FILE_DOWNLOAD_ERROR, e);
					Log.e("MyError", e.toString());
				}
			}
		}).start();
	}

	// 向 Handler 发送消息
	private void sendMessage(int what, Object obj) {
		// 构造需要向 Handler 发送的消息
		Message msg = mHandler.obtainMessage(what, obj);
		// 发送消息
		mHandler.sendMessage(msg);
	}

	private void sendMessage(int what) {
		Message msg = mHandler.obtainMessage(what);
		mHandler.sendMessage(msg);
	}

	private void sendMessage(int what, int arg1, int arg2) {
		Message msg = mHandler.obtainMessage(what, arg1, arg2);
		mHandler.sendMessage(msg);
	}

	private static final int FILE_DOWNLOAD_CONNECT = 0;
	private static final int FILE_DOWNLOAD_UPDATE = 1;
	private static final int FILE_DOWNLOAD_COMPLETE = 2;
	private static final int FILE_DOWNLOAD_ERROR = -1;

	// 自定义的 Handler
	private class EventHandler extends Handler {
		private DownloadManagerAsync mManager;

		public EventHandler(DownloadManagerAsync manager) {
			mManager = manager;
		}

		// 处理接收到的消息
		@Override
		public void handleMessage(Message msg) {

//			if (msg.what == FILE_DOWNLOAD_COMPLETE ||
//				msg.what == FILE_DOWNLOAD_ERROR	){
//				mRunning = false;
//			}
//			else{
//				mRunning = true;
//			}
			switch (msg.what) {
			case FILE_DOWNLOAD_CONNECT:
				if (mOnDownloadConnectListener != null)
					mOnDownloadConnectListener.onDownloadConnect(mManager);
				break;
			case FILE_DOWNLOAD_UPDATE:
				if (mOnDownloadUpdateListener != null)
					mOnDownloadUpdateListener.onDownloadUpdate(mManager,
							msg.arg1);
				break;
			case FILE_DOWNLOAD_COMPLETE:
				if (mOnDownloadCompleteListener != null)
					mOnDownloadCompleteListener.onDownloadComplete(mManager,
							msg.obj, mFilePath);
				mRunning = false;
				break;
			case FILE_DOWNLOAD_ERROR:
				if (mOnDownloadErrorListener != null)
					mOnDownloadErrorListener.onDownloadError(mManager,
							(Exception) msg.obj);
				mRunning = false;
				break;
			default:
//				super.handleMessage(msg); 
				break;
			}
		}
	}

	// 定义连接事件
	private OnDownloadConnectListener mOnDownloadConnectListener;

	public interface OnDownloadConnectListener {
		void onDownloadConnect(DownloadManagerAsync manager);
	}

	public void setOnDownloadConnectListener(OnDownloadConnectListener listener) {
		mOnDownloadConnectListener = listener;
	}

	// 定义下载进度更新事件
	private OnDownloadUpdateListener mOnDownloadUpdateListener;

	public interface OnDownloadUpdateListener {
		void onDownloadUpdate(DownloadManagerAsync manager, int percent);
	}

	public void setOnDownloadUpdateListener(OnDownloadUpdateListener listener) {
		mOnDownloadUpdateListener = listener;
	}

	// 定义下载完成事件
	private OnDownloadCompleteListener mOnDownloadCompleteListener;

	public interface OnDownloadCompleteListener {
		void onDownloadComplete(DownloadManagerAsync manager, Object result, String file);
	}

	public void setOnDownloadCompleteListener(
			OnDownloadCompleteListener listener) {
		mOnDownloadCompleteListener = listener;
	}

	// 定义下载异常事件
	private OnDownloadErrorListener mOnDownloadErrorListener;

	public interface OnDownloadErrorListener {
		void onDownloadError(DownloadManagerAsync manager, Exception e);
	}

	public void setOnDownloadErrorListener(OnDownloadErrorListener listener) {
		mOnDownloadErrorListener = listener;
	}
}