Android bitmap(五)完整例子ImageLoader

参考《android开发艺术探索》

1.图片压缩功能类ImageResizer

 public class ImageResizer{
 private static final String TAG = "ImageResizer";
 
 
public ImageResizer(){
 }
 
 
public Bitmap decodeSampledBitmapFromResource(Resource res,int resId,int reqWidth,int reqHeight){
 //First decode with inJustDecodeBounds=true to check dimensions
 final BitmapFactory.Options options = new BitmapFactory.Options();
 options.inJustDecodeBounds = true;
 BitmapFactory.decodeResource(res,resId,options);
 //calculate inSampleSize
 options.inSampleSize = calculateInSampleSize(options,reqWidth,reqHeight);
 //decode bitmap with inSampleSize set
 options.inJustDecodeBounds = false;
 return BitmapFactory.decodeResource(res,resId,options);
 }
 
 
public Bitmap decodeSampledBitmapFromFileDescriptor(FileDescriptor fd,int reqWidth, int reqHeight){
 //First decode with inJustDecodeBounds=true to check dimensions
 final BitmapFactory.Options options = new BitmapFactory.Options();
 options.inJustDecodeBounds = true;
 BitmapFactory.decodeFileDescriptor(fd,null,options);
 //calculate inSampleSize
 options.inSampleSize = calculateInSampleSize(options,reqWidth,reqHeight);
 //decode bitmap with inSampleSize set
 options.inJustDecodeBounds = false;
 return BitmapFactory.decodeFileDescriptor(fd,null,options);
 }
 
 
public int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight){
 if(reqWidth == 0 || reqHeight == 0){
 return 1;
 }
 //Raw height and width of image
 final int width = options.outWidth;
 final int height = options.outHeight;
 Log.d(TAG,"origin,w="+width+"h="+height);
 int inSampleSize = 1;
 
 
  if(height > reqHeight || width > reqWidth){
     final int halfHeight = height / 2;
     final int halfWidth = width / 2;
     while((halfHeight / inSampleSize) >= reqHeight && (halfWidth / inSampleSize) >= reqWidth){
        inSampleSize *= 2;
     }
  }
  Log.d(TAG,"sampleSize:"+inSampleSize);
  return inSampleSize;
 
 
}
 }
 

2.ImageLoader完整代码

 public class ImageLoader{
 private static final String TAG = "ImageLoader";
 public static final int MESSAGE_POST_RESULT = 1;
 
 
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
 private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
 private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
 private static final long KEEP_ALIVE = 10L;
 
 
private static final int TAG_KEY_URI = R.id.imageloader_uri;
 private static final long DISK_CACHE_SIZE = 1024 * 1024 * 50;
 private static final int IO_BUFFER_SIZE = 8 * 1024;
 private static final int DISK_CACHE_INDEX = 0;
 private boolean mIsDiskLruCacheCreated = false;
 
 
private static final ThreadFactory sThreadFactory = new ThreadFactory(){
 private final AtomicInteger mCount = new AtomicInteger(1);
 
 
  public Thread newThread(Runnable r){
     return new Thread(r, "ImageLoader#" + mCount.getAndIncrement());
  }
 
 
}
 
 
public static final Executor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(
 CORE_POOL_SIZE,MAXIMUM_POOL_SIZE,KEEP_ALIVE,TimeUnit.SECONDS,
 new LinkedBlockingQueue<>(Runnable),sThreadFactory);
 
 
private Handler mMainHandler = new Handler(Looper.getMainLooper()){
 public void handleMessage(Message msg){
 LoaderResult result = (LoaderResult) msg.obj;
 ImageView imageView = result.imageView;
 String uri= (String) imageView.getTag(TAG_KEY_URI);
 if(uri.equals(result.uri)){
 imageView.setImageBitmap(result.bitmap);
 }else{
 Log.w(TAG,"set image bitmap,but url has changed,ignored!");
 }
 }
 };
 
 
private Context mContext;
 private ImageResizer mImageResizer = new ImageResizer();
 private LruCache mMemoryCache;
 private DiskLruCache mDiskLruCache;
 
 
private ImageLoader(Context context){
 mContext = context.getApplicationContext();
 int maxMemory = (int) (Runtime.getRuntime().maxMemory / 1024);
 int cacheSize = maxMemory / 8;
 mMemoryCache = new LruCache(cacheSize){
 protected int sizeOf(String key,Bitmap bitmap){
 return bitmap.getRowBytes() * bitmap.getHeight() / 1024;
 }
 };
 File diskCacheDir = getDiskCacheDir(mContext, "bitmap");
 if(!diskCacheDir.exists()){
 diskCacheDir.mkdirs();
 }
 if(getUsableSpace(diskCacheDir) > DISK_CACHE_SIZE){
 try{
 mDiskLruCache = DiskLruCache.open(diskCacheDir,1,1,DISK_CACHE_SIZE);
 mIsDiskLruCacheCreated = true;
 }catch(IOException e){
 e.printStackTrace();
 }
 }
 }
 
 
public static ImageLoader build(Context context){
 return new ImageLoader(context);
 }
 
 
private void addBitmapToMemoryCache(String key,Bitmap bitmap){
 if(getBitmapFromMemCache(key) == null){
 mMemoryCache.put(key, bitmap);
 }
 }
 
 
private Bitmap getBitmapFromMemCache(String key){
 return mMemoryCache.get(key);
 }
 
 
public void bindBitmap(final String uri, final ImageView imageView){
 bindBitmap(uri,imageView,0,0);
 }
 
 
/**
 * load bitmap from memory cache or disk or network async,then bind imageview and bitmap
 * NOTE THAT: should run in UI thread
 */
 public void bindBitmap(final String uri, final ImageView imageView, final int reqWidth,final int reqHeight){
 imageView.setTag(TAG_KEY_URI,uri);
 Bitmap bitmap = loadBitmapFromMemCache(uri);
 if(bitmap != null){
 imageView.setImageBitmap(bitmap);
 return;
 }
 
 
  Runnable loadBitmapTask = new Runnable(){
     public void run(){
       Bitmap bitmap = loadBitmap(uri, reqWidth, reqHeight);
       if(bitmap != null){
          LoaderResult result = new LoaderResult(imageView,uri,bitmap);
          mMainHandler.obtainMessage(MESSAGE_POST_RESULT,result).sendToTarget();
       }
     }
  }
  THREAD_POOL_EXECUTOR.execute(loadBitmapTask);
 
 
}
 
 
public Bitmap loadBitmap(String uri,int reqWidth,int reqHeight){
 Bitmap bitmap = loadBitmapFromMemCache(uri);
 if(bitmap != null){
 Log.d(TAG,"loadBitmapFromMemCache,url:"+uri);
 return bitmap;
 }
 
 
  try{
     bitmap = loadBitmapFromDiskCache(uri,reqWidth,reqHeight);
     if(bitmap != null){
        Log.d(TAG,"loadBitmapFromDiskCache,url:"+uri);
        return bitmap;
     }
     bitmap = loadBitmapFromHttp(uri,reqWidth,reqHeight);
     Log.d(TAG,"loadBitmapFromHttp,url:"+uri);
  }catch(IOException e){
     e.printStackTrace();
  }
  
  if(bitmap == null && !mIsDiskLruCacheCreated){
     Log.w(TAG, "encounter error,DiskLruCache is not created.");
     bitmap = downloadBitmapFromUrl(uri);
  }
  return bitmap;
 
 
}
 
 
private Bitmap loadBitmapFromMemCache(String url){
 final String key = hashKeyFromUrl(url);
 Bitmap bitmap = getBitmapFromMemCache(key);
 return bitmap;
 }
 
 
private Bitmap loadBitmapFromHttp(String url,int reqWidth, int reqHeight) throws IOException{
 if(Looper.myLooper() == Looper.getMainLooper()){
 throw new RuntimeException("can not visit network from UI Thread.");
 }
 if(mDiskLruCache == null){
 return null;
 }
 String key = hashKeyFromUrl(url);
 DiskLruCache.Editor editor = mDiskLruCache.edit(key);
 if(editor != null){
 OutputStream outputStream = editor.newOutputStream(DISK_CACHE_INDEX);
 if(downloadUrlToStream(url,outputStream)){
 editor.commit();
 }else{
 editor.abort();
 }
 mDiskLruCache.flush();
 }
 return loadBitmapFromDiskCache(url,reqWidth,reqHeight);
 }
 
 
private Bitmap loadBitmapFromDiskCache(String url,int reqWidth,int reqHeight){
 if(Looper.myLooper() == Looper.getMainLooper()){
 Log.w(TAG,"load bitmap from UI Thread,it is not recommended!");
 }
 if(mDiskLruCache == null){
 return null;
 }
 
 
  Bitmap bitmap = null;
  String key = hashKeyFromUrl(url);
  DiskLruCache.SnapShot snapShot = mDiskLruCache.get(key);
  if(snapShot != null){
     FileInputStream fileInputStream = (FileInputStream)snapShot.getInputStream(DISK_CACHE_INDEX);
     FileDescriptor fileDescriptor = fileInputStream.getFD();
     bitmap = mImageResizer.decodeSampledBitmapFromFileDescriptor(fileDescriptor,reqWidth,reqHeight);
     if(bitmap != null){
        addBitmapToMemoryCache(key,bitmap);
     }
  }
  return bitmap;
 
 
}
 
 
public boolean downloadUrlToStream(String urlString,OutputStream outputStream){
 HttpURLConnection urlConnection = null;
 BufferedOutputStream out = null;
 BufferedInputStream in = null;
 try{
 final URL url = new URL(urlString);
 urlConnection = (HttpURLConnection) url.openConnection();
 in = new BufferedInputStream(urlConnection.getInputStream(),IO_BUFFER_SIZE);
 out = new BufferedOutputStream(outputStream,IO_BUFFER_SIZE);
 int b;
 while((b = in.read()) != -1){
 out.write(b);
 }
 return true;
 }catch(IOException e){
 Log.e(TAG,"downloadBitmap failed."+e);
 }finally{
 if(urlConnection != null){
 urlConnection.disconnect();
 }
 MyUtils.close(out);
 MyUtils.close(in);
 }
 return false;
 }
 
 
private Bitmap downloadBitmapFromUrl(String urlString){
 Bitmap bitmap = null;
 HttpURLConnection urlConnection = null;
 BufferedInputStream in = null;
 try{
 final URL url = new URL(urlString);
 urlConnection = (HttpURLConnection) url.openConnection();
 in = new BufferedInputStream(urlConnection.getInputStream(),IO_BUFFER_SIZE);
 bitmap = BitmapFactory.decodeStream(in);
 }catch(IOException e){
 Log.e(TAG,"Error in downloadBitmap:"+e);
 }finally{
 if(urlConnection != null){
 urlConnection.disconnect();
 }
 MyUtils.close(in);
 }
 return bitmap;
 }
 
 
private String hashKeyFromUrl(String url){
 String cacheKey;
 try{
 final MessageDigest mDigest = MessageDigest.getInstance("MD5");
 mDigest.update(url.getBytes());
 cacheKey = bytesToHexString(mDigest.digest());
 }catch(NoSuchAlgorithmException e){
 cacheKey = String.valueOf(url.hasCode());
 }
 return cacheKey;
 }
 
 
private String bytesToHexString(byte[] bytes){
 StringBuilder sb = new StringBuilder();
 for(int i = 0; i < bytes.length; i ++){
 String hex = Integer.toHexString(0xFF & byte[i]);
 if(hex.length() == 1){
 sb.append('0');
 }
 sb.append(hex);
 }
 return sb.toString();
 }
 
 
public File getDiskCacheDir(Context context,String uniqueName){
 boolean externalStorageAvailable = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
 final String cachePath;
 if(externalStorageAvailable){
 cachePath = context.getExternalCacheDir().getPath();
 }else{
 cachePath = context.getCacheDir().getPath();
 }
 return new File(cachePath + File.separator + uniqueName);
 }
 
 
private long getUsableSpace(File path){
 if(Build.VERSION.SDK_INT >= VERSION_CODES.GINGERBREAD){
 return path.getUsableSpace();
 }
 final StatFs stats = new StatFs(path.getPath());
 return (long) stats.getBloackSize() * (long)stats.getAvailableBlocks();
 }
 
 
private static class LoaderResult{
 public ImageView imageView;
 public String uri;
 public Bitmap bitmap;
 
 
  public LoaderResult(ImageView imageView,String uri,Bitmap bitmap){
     this.imageView = imageView;
     this.uri = uri;
     this.bitmap = bitmap;
  }
 
 
}
 }