Android 自定义 ImageLoader

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Hashtable;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.LinkedBlockingQueue;

import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;


import android.app.ProgressDialog;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.MessageQueue;
import android.support.v4.util.LruCache;
import android.test.UiThreadTest;
import android.text.TextUtils;
import android.widget.ImageView;

/**
 * 网络图片加载
 * 
 * @author 
 *
 */
public class ImageNetLoader {

	private static final int TIMEOUT = 30 * 1000;
	// protected final HashMap<String, SoftReference<Bitmap>> bitmapMap;
	Context mContext;
	BitmapFactory.Options opts = null;
	@SuppressWarnings("rawtypes")
	LruCache mMemoryCache = null;
	private static ImageNetLoader imageNetLoader;
	
	private BlockingQueue<FutureTask<Bitmap>> blockingqeque = new LinkedBlockingQueue<FutureTask<Bitmap>>();
	private Thread loadThread = new Thread(){
		public void run() {
			while(true){
				FutureTask<Bitmap> task;
				try {
					task = blockingqeque.take();
					if(task.isCancelled() ||task.isDone() )
						continue;
					task.run();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
				
					
			}
		};
	};
	
	public interface LocalFileNameBuilder {
		public String getName(String url, String localDir);
	}

	private ImageNetLoader(Context mContext) {
		this.mContext = mContext;
		int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
		// 使用最大可用内存值的1/8作为缓存的大小。
		int cacheSize = maxMemory / 8;
		mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
			@Override
			protected int sizeOf(String key, Bitmap bitmap) {
				// 重写此方法来衡量每张图片的大小，默认返回图片数量。
				return bitmap.getByteCount() / 1024;
			}
		};
		
	}

	public static ImageNetLoader instance(Context context) {
		if (imageNetLoader == null) {
			synchronized (ImageNetLoader.class) {
				if (imageNetLoader == null) {
					imageNetLoader = new ImageNetLoader(context);
					imageNetLoader.loadThread.setPriority(Thread.MIN_PRIORITY);
					imageNetLoader.loadThread.start();
				}
			}
		}

		return imageNetLoader;
	}
	@SuppressWarnings("unchecked")
	public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
		if (getBitmapFromMemCache(key) == null) {
			mMemoryCache.put(key, bitmap);
		}
	}

	@SuppressWarnings("unchecked")
	public Bitmap getBitmapFromMemCache(String key) {
		return (Bitmap) mMemoryCache.get(key);
	}

	@SuppressWarnings("unchecked")
	public void removeFromCache(String key) {
		if (mMemoryCache.get(key) != null) {
			mMemoryCache.remove(key);
		}
	}

	/**
	 * 获取URL 并且保存到本地
	 * 
	 * @param urlString
	 * @param localDir
	 * @return
	 * @throws ClientProtocolException
	 * @throws IOException
	 */
	public InputStream getInputStream(String urlString, String localDir,
			LocalFileNameBuilder builder) throws ClientProtocolException,
			IOException {

		HttpParams params = new BasicHttpParams();
		// add the timeout
		HttpConnectionParams.setConnectionTimeout(params, TIMEOUT);
		HttpConnectionParams.setSoTimeout(params, TIMEOUT);

		DefaultHttpClient httpClient = new DefaultHttpClient(params);
		HttpGet request = new HttpGet(urlString);
		HttpResponse response = httpClient.execute(request);

		if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
			request.abort();
			return null;
		}
		InputStream in = response.getEntity().getContent();

		String localPath = getLocalPath(urlString, localDir, builder);
		// 保存到本地

		File f = new File(localPath);
		if (f.createNewFile()) {
			FileOutputStream fo = new FileOutputStream(f);

			BufferedInputStream bi = new BufferedInputStream(in);
			byte[] buffer = new byte[1024 * 10];
			int len = 0;
			while ((len = bi.read(buffer)) > 0) {
				fo.write(buffer, 0, len);
				fo.flush();
			}

			bi.close();
			fo.close();
			return new FileInputStream(f);
		}
		return in;

	}

	/**
	 * 初始化 Bitmap参数
	 */
	private void initOptions() {
		if (opts == null) {
			opts = new BitmapFactory.Options();
			opts.inPreferredConfig = Bitmap.Config.RGB_565;
			opts.inSampleSize = 1;
		}
	}

	/**
	 * 
	 * @param urlString
	 *            网路路径
	 * @param localDir
	 *            本地存储路径 如果不为null就保存到相应目录 否则保存到 temp目录
	 * 
	 * @return
	 */
	public Bitmap getBitmapByUrl(String urlString, String localDir,
			LocalFileNameBuilder builder) {
		if (TextUtils.isEmpty(urlString)) {
			return null;
		}

		Log.v("ImageLoader", "ImageLoader load for:"+ urlString );
		try {
			return getBitmapFromUrl(urlString, localDir, builder);
		} catch (OutOfMemoryError e) {
			e.printStackTrace();
		} catch (Exception e) {
			Log.v(this.getClass().getSimpleName(),
					"Network Exception fetchDrawable failed 1st time" + e);
			try {
				return getBitmapFromUrl(urlString, localDir, builder);
			} catch (OutOfMemoryError es) {
				es.printStackTrace();
			} catch (Exception ex) {
				ex.printStackTrace();
				Log.v(this.getClass().getSimpleName(),
						"Network Exception fetchDrawable failed 2nd time" + ex);
			}
		}
		return null;
	}

	/**
	 * 保存网络文件到本地
	 * 
	 * @param urlString
	 * @param localDir
	 * @param builder
	 */
	public void loadUrlTolocal(String urlString, String localDir,
			LocalFileNameBuilder builder) {
		String localfile = getLocalPath(urlString, localDir, builder);
		File f = new File(localfile);
		if (f.exists() && f.canRead()) {
			return;
		}

		try {
			InputStream in = getInputStream(urlString, localDir, builder);
			in.close();
		} catch (ClientProtocolException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * 获取本地保存路径
	 * 
	 * @param urlString
	 * @param localDir
	 * @return
	 */
	private String getLocalPath(String urlString, String localDir,
			LocalFileNameBuilder builder) {
		String localPath;
		// 获取本地路径
		if (localDir != null) {
			

			if (builder == null) {
				String fileName = MD5.md5Lower(urlString.substring(
						urlString.lastIndexOf('/'), urlString.length())
						+ "."
						+ urlString.substring(urlString.lastIndexOf('.'),
								urlString.length()));
				localPath = localDir + "/" + fileName;
			} else {
				localPath = localDir + "/"
						+ builder.getName(urlString, localDir);
			}

		} else {
			localPath = Config.EXTERNAL_PATH + "/temp/" + MD5.md5Lower(urlString);
		}
		return localPath;

	}

	/**
	 * 从IN中获取bitmap
	 * 
	 * @param in
	 * @return
	 */
	private Bitmap getBitmapFromInputStream(InputStream in) {
		Bitmap bitmap = null;
		try {
			initOptions();
			bitmap = BitmapFactory.decodeStream(in, null, opts);
			try {
				in.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (OutOfMemoryError e) {
			return null;
		}
		return bitmap;
	}

	/**
	 * get Bitmap from the input stream
	 * 
	 * @throws IOException
	 * @throws ClientProtocolException
	 */
	private Bitmap getBitmapFromUrl(String urlString, String localDir,
			LocalFileNameBuilder builder) throws ClientProtocolException,
			IOException {
		return getBitmapFromInputStream(getInputStream(urlString, localDir,
				builder));
	}

	/**
	 * 获取网络图片 不永久保存图片
	 * 
	 * @param urlString
	 * @param defaultres
	 * @param progressDialog
	 * @param imageView1
	 */
	public void loadBitmapOnThread(final String urlString,
			final int defaultres, final ProgressDialog progressDialog,
			final ImageView imageView1) {
		loadBitmapOnThread(urlString, defaultres, progressDialog, imageView1,
				null);

	}

	/**
	 * 加载图片 文件名使用默认规则 默认加入到缓存中
	 * 
	 * @param urlString
	 * @param defaultres
	 * @param progressDialog
	 * @param imageView1
	 * @param localDir
	 */
	public void loadBitmapOnThread(final String urlString,
			final int defaultres, final ProgressDialog progressDialog,
			final ImageView imageView1, final String localDir) {

		loadBitmapOnThread(urlString, defaultres, progressDialog, imageView1,
				localDir, null);
	}

	/**
	 * 加载图片 默认加入到缓存中
	 * 
	 * @param urlString
	 * @param defaultres
	 * @param progressDialog
	 * @param imageView1
	 * @param localDir
	 * @param builder
	 *            本地文件名生成规则
	 */

	public void loadBitmapOnThread(final String urlString,
			final int defaultres, final ProgressDialog progressDialog,
			final ImageView imageView1, final String localDir,
			final LocalFileNameBuilder builder) {

		loadBitmapOnThread(urlString, defaultres, progressDialog, imageView1,
				localDir, builder, true);
	}

	/**
	 * 
	 * @author popo
	 */

	class IRunnable implements Callable<Bitmap> {

		String url;
		String localDir;
		LocalFileNameBuilder localFileNameBuilder;
		boolean saveToCache;
		ImageView imageView;
		ProgressDialog progressDialog;
		int defaultres;

		public IRunnable(String url, String localDir,
				LocalFileNameBuilder localFileNameBuilder, boolean saveToCache,
				ImageView imageView, ProgressDialog progressDialog,
				int defaultres) {
			this.url = url;
			this.localDir = localDir;
			this.localFileNameBuilder = localFileNameBuilder;
			this.saveToCache = saveToCache;
			this.imageView = imageView;
			this.progressDialog = progressDialog;
			this.defaultres = defaultres;
		}

		@Override
		public Bitmap call() throws Exception {
			Bitmap drawable = null;
			drawable = getBitmapByUrl(url, localDir, localFileNameBuilder);

			if (drawable != null) {
				Object[] obj = new Object[] { drawable, imageView, url,
						defaultres, saveToCache, progressDialog };
				Message message = handler.obtainMessage(1, obj);
				handler.sendMessage(message);
			}
			if (progressDialog != null) {
				progressDialog.dismiss();
			}
			taskMaps.remove(url);
			return drawable;

		}

	}

	class Node {
		public IRunnable runnable;
		public FutureTask<Bitmap> task;
	}

	/**
	 * ConcurrentHashMap or HashTable
	 */
	Hashtable<String, Node> taskMaps = new Hashtable<String, Node>();

	/**
	 * 加载图片
	 * 
	 * @param urlString
	 * @param defaultres
	 * @param progressDialog
	 * @param imageView1
	 * @param localDir
	 *            本地缓存目录
	 * @param builder
	 *            本地文件名生成规则
	 * @param saveToCache
	 *            是否 加入到缓存
	 */
	public void loadBitmapOnThread(final String urlString,
			final int defaultres, final ProgressDialog progressDialog,
			final ImageView imageView1, final String localDir,
			final LocalFileNameBuilder builder, final boolean saveToCache) {
		if(imageView1 == null)
			return ;
		Log.v("ImageLoader"," image load for:"+urlString);
		
		// 获取以前的Tag
		String tag = (String) imageView1.getTag(R.id.img_tag);

		imageView1.setTag(R.id.img_tag, urlString);
		if (urlString == null || urlString.trim().equals("")) {
			if (imageView1.getTag(R.id.img_tag).equals(urlString))
				imageView1.setImageResource(defaultres);

			if (progressDialog != null) {
				progressDialog.dismiss();
			}
			
			//取消图片之前的任务
			cancelTask(tag);

			return;
		}

		// 从缓存读取
		try {
			Bitmap bm = getBitmapFromMemCache(urlString);
			if (bm != null && !bm.isRecycled()
					&& imageView1.getTag(R.id.img_tag).equals(urlString)) {
				Log.v("from cache", "url:" + urlString + ",imageView:"
						+ imageView1.toString());
				imageView1.setImageBitmap(bm);
				if (progressDialog != null) {
					progressDialog.dismiss();
				}
				//取消图片之前的任务
				cancelTask(tag);
				return;
			} else {
				removeFromCache(urlString);
				if (defaultres > 0)
					imageView1.setImageResource(defaultres);
				
			}
		} catch (OutOfMemoryError e) {
			e.printStackTrace();
		}
		final String localPath = getLocalPath(urlString, localDir, builder);
		if (localPath != null) {
			imageView1.setTag(R.id.localimg_tag, localPath);
		}
		File f = new File(localPath);
		if (f.exists() && f.canRead()) {
			try {
				FileInputStream fi = new FileInputStream(f);
				Bitmap b = getBitmapFromInputStream(fi);
				if (b != null
						&& imageView1.getTag(R.id.localimg_tag).equals(
								localPath)) {
					Log.v("from file", "url:" + urlString + ",localPath"
							+ localPath);
					if (saveToCache) {
						if (!b.isRecycled())
							addBitmapToMemoryCache(urlString, b);
					}
					imageView1.setImageBitmap(b);
					//取消图片之前的任务
					cancelTask(tag);
					return;
				}
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (OutOfMemoryError e) {
				e.printStackTrace();
			}

		}

		if (progressDialog != null)
			progressDialog.show();

		//那连个地址一样怎么办捏
		//同一个变相同地址 就不做任何处理了等着吧
		
		if(tag != null && tag.equals(urlString)){
			
		}else{
			//不一样取消之前的任务
			cancelTask(tag);
			final Node node = taskMaps.get(urlString);
			//之前已经有图片在下载
			if(node != null ){
				
				
				FutureTask<Bitmap> task = new FutureTask<Bitmap>(new Callable<Bitmap>() {

					@Override
					public Bitmap call() throws Exception {
						try {
							Bitmap drawable = node.task.get();
							if (drawable != null) {
								Object[] obj = new Object[] { drawable, imageView1, urlString,
										defaultres, saveToCache, progressDialog };
								Message message = handler.obtainMessage(1, obj);
								handler.sendMessage(message);
							}

						} catch (InterruptedException e) {
							e.printStackTrace();
						} catch (ExecutionException e) {
							e.printStackTrace();
						}
						return null;
					}
				});
				
				blockingqeque.offer(task);
				
			}else{
				IRunnable runnable = new IRunnable(urlString, localDir, builder, saveToCache, imageView1, progressDialog, defaultres);
				FutureTask<Bitmap> task =  new FutureTask<Bitmap>(runnable);
				blockingqeque.offer(task);
				Node n = new Node();
				n.runnable = runnable;
				n.task = task;
				taskMaps.put(urlString, n);
			}
		}
	}
	
	/**
	 * 取消图片任务
	 * @param tag
	 */
	private void cancelTask(String tag) {
		// 现在图片已经不需要新下载的图片了 那么取消掉吧
		if(tag == null)
			return;
		Node node = taskMaps.get(tag);
		if (node != null) {
			boolean canceled = node.task.cancel(false);
			if (canceled && node.task.isCancelled()) {
				taskMaps.remove(tag);
			}

		}
	}

	final Handler handler = new Handler(Looper.getMainLooper()) {
		@Override
		public void handleMessage(Message message) {

			ImageView imageView = (ImageView) ((Object[]) message.obj)[1];
			String imgpath = (String) ((Object[]) message.obj)[2];
			int defaultres = (Integer) ((Object[]) message.obj)[3];
			boolean saveToCache = (Boolean) ((Object[]) message.obj)[4];
			if (((Object[]) message.obj)[5] != null) {
				ProgressDialog pd = (ProgressDialog) ((Object[]) message.obj)[5];
				if (pd != null) {
					pd.dismiss();
				}
			}

			Log.v("NETIMAGE", "url:" + imgpath + ",imageView:" + imageView);
			switch (message.what) {
			case 1:
				try {
					Bitmap bm = null;
					if (null == message.obj) {
						if (defaultres > 0)
							imageView.setImageResource(defaultres);
					} else {
						bm = (Bitmap) ((Object[]) message.obj)[0];

						if (!bm.isRecycled()) {
							if (imageView != null
									&& imageView.getTag(R.id.img_tag) != null
									&& imageView.getTag(R.id.img_tag).equals(
											imgpath))

								imageView.setImageBitmap(bm);
							removeFromCache(imgpath);
							addBitmapToMemoryCache(imgpath, bm);
						} else {
							if (imageView != null && defaultres > 0)
								imageView.setImageResource(defaultres);
						}
					}
				} catch (OutOfMemoryError e) {
					e.printStackTrace();
				} catch (Exception e) {
					e.printStackTrace();
				}

				break;
			}
		}

	};

}