Android图片加载框架比较

做android的同学肯定都使用过imageloader这款图片加载框架。
图片加载对于中低级的安卓开发人员来说是相当不容易的，因为图片加载时做容易造成安卓内存溢出的原因，而要解决这些问题还需要很多相关知识：
1、多线程下载，线程管理。
2、多级缓存架构设计和策略，内存缓存，磁盘缓存，缓存有效性处理。
3、图片压缩，特效处理，动画处理。
4、复杂网络情况下下载图片策略，例如弱网络等。
5、内存管理，lru 算法、对象引用、GC回收等优化。
等等一些功能都会是新手开发者摸不到头脑，而imageloader刚好把上述问题解决了，所以这款图片框架基本上成为了必备神框架一般存在。


就想Android系统迭代速度一样快，这款框架团队已经到了没有再更新了时候了，取而代之是一些新的更加牛x的框架。
现在主流的是：
Glide：这个谷歌推荐的，肯定要放到第一个来说，相当于谷歌亲儿子，但是不是每个谷歌亲儿子都能够发展的很好，比如停止更新volley不想说了，现在用换成了okhttp成为新宠。
首先项目非常轻巧，源代码体积小，功能齐全，使用api简单方便。还有就是出色图片处理，保存bitmap格式是RGB565，对内存消耗低。


Fresco：刚好公司项目把imageloader转成fresco，名字挺好听壁画。
在图片不显示他的内存会被回收。
有模糊图片现加载，然后高清图片下载后再显示，类似预加载效果。
图片动画处理非常丰富。
但是项目源码体积大，但是现在都是巨型APP时代这个缺点也不算什么，只要功能强大就行。


Picasso：这个框架和Glide的api非常类型，相似度有90%。bitmap保存格式是ARGB8888，所以对内存消耗没有Glide 出色。


现在的主流三款框架都能够完成imageloader的功能而且还能够有更多强大的功能，但是开发就也发现不是功能越多越好，适合项目才是最好的，其实imageloader已经完成了基本上图片加载相关所有功能了。而且平时项目中没有什么特别的需求。


所以还是默默的有点怀念它，只是不更新了，现在代码是自己默认imageloader写的一个阉割版的imageloader留作纪念。
有点偷懒没有加入lrucache 二级缓存，就做了一级磁盘缓存，使用的asytask也是想调用时候少少传递上下文这个参数和线程管理，但是挺好用的呵呵！因为简单可以扩展和学习使用。


使用方法：


// 初始化默认最大宽度和保存文件夹 可以放到 application onCreate 方法中
DisplayMetrics outMetrics=new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(outMetrics);
SimpleImageLoader.getInstance().init(outMetrics.widthPixels, Environment.getExternalStorageDirectory().getAbsolutePath()+"/sijienet_com");






//默认调用
SimpleImageLoader.getInstance().displayImage(imageUrls[position],imageView);






//图片处理圆形图片
SimpleImageLoader.getInstance().displayImage(imageUrls[position],imageView, new OnImageLoaderListener() {
@Override
public void setImageView(ImageView imageView,Bitmap bitmap) {
imageView.setImageBitmap(SimpleImageLoader.getOvalBitmap(bitmap));
}
});


//图片处理圆角图片
SimpleImageLoader.getInstance().displayImage(imageUrls[position],imageView, new OnImageLoaderListener() {
@Override
public void setImageView(ImageView imageView,Bitmap bitmap) {
imageView.setImageBitmap(SimpleImageLoader.getRoundedCornerBitmap(bitmap, 100));
}
});


//设置获取bitmap大小，优先级高于默认最大宽度
SimpleImageLoader.getInstance().displayImage(imageUrls[position],imageView, 250);




//activity退出清除当前现在任务
SimpleImageLoader.getInstance().cancelAllTasks();

Simpleimageloader 代码：

package com.net.sijienet.imageloader;

import java.io.File;
import java.io.FileOutputStream;
import java.lang.ref.WeakReference;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.List;

import android.annotation.SuppressLint;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.RectF;
import android.os.AsyncTask;
import android.os.Environment;
import android.util.Log;
import android.widget.ImageView;

/**
 * Created by json li on 2017/3/24. 
 * sijienet.com
 */
@SuppressLint("NewApi") 
public class SimpleImageLoader {

    public static SimpleImageLoader instance=null;
    
    private final String TAG="SimpleImageLoader";

    private List<LoadTask> loadTasks=new ArrayList<LoadTask>();
    
    private int defaultReqWidth;
    
    private String sdPath;
    
    public static SimpleImageLoader getInstance(){
        if (instance==null){
            synchronized (SimpleImageLoader.class){
                if (instance==null){
                    instance=new SimpleImageLoader();
                }
            }
        }
        return instance;
    }
    
    public void init(int defaultReqWitdth , String sdPath){
    	this.sdPath = sdPath;
    	this.defaultReqWidth = defaultReqWitdth;
    	Log.i(TAG, "max width="+defaultReqWitdth+" filePath="+sdPath);
    }

    private SimpleImageLoader(){
        defaultReqWidth = 750;
        sdPath=Environment.getExternalStorageDirectory().getAbsolutePath()+"/simple_imageloader_dir";
    }

    void setImgBitmap(ImageView imageView, Bitmap bitmap,OnImageLoaderListener imageLoaderListener){
    	if (imageLoaderListener!=null) {
			imageLoaderListener.setImageView(imageView, bitmap);
			return;
		}
        imageView.setImageBitmap(bitmap);
    }
    
    public void displayImage(String url, ImageView imageView){
    	displayImage(url, imageView, defaultReqWidth, null);
    }
    
    public void displayImage(String url, ImageView imageView,OnImageLoaderListener imageLoaderListener){
    	displayImage(url, imageView, defaultReqWidth, imageLoaderListener);
    }
    
    public void displayImage(String url, ImageView imageView,int reqWidth){
    	displayImage(url, imageView, reqWidth, null);
    }

    public void displayImage(String url, ImageView imageView, int reqWidth, OnImageLoaderListener imageLoaderListener){
        if (url==null || imageView==null){
            return;
        }
        Bitmap bitmap=getBitmapFromCache(url, reqWidth);
        if (bitmap !=null){
            setImgBitmap(imageView, bitmap, imageLoaderListener);
        }else {
            LoadTask loadTask=new LoadTask(new WeakReference<ImageView>(imageView), url, reqWidth, imageLoaderListener);
            loadTasks.add(loadTask);
            loadTask.execute(url);
        }
    }

    public void cancelAllTasks() {
        if (loadTasks != null) {
            for (LoadTask task : loadTasks) {
                task.cancel(false);
            }
            Log.i(TAG,"cancel size=="+ loadTasks.size());
            loadTasks.clear();
        }
    }
    
    String getAllPath(String url){
    	File file=new File(sdPath);
    	if (!file.exists()) {
			file.mkdirs();
		}
    	String fileName = getMd5String(url)+".jpg";
        String allPath = sdPath+"/"+fileName;
        return allPath;
    }

    public Bitmap getBitmapFromCache(String key, int reqWidth) {
        Bitmap bitmap=null;
        String allPath = getAllPath(key);
        if (new File(allPath).exists())
        {
            return decodeSampledBitmapFromResource(allPath, reqWidth);
        }
        return bitmap;
    }

    class LoadTask extends AsyncTask<String, Void, Bitmap> {

        WeakReference<ImageView> imageView;
        String url;
        int reqWidth;
        OnImageLoaderListener imageLoaderListener;

        public LoadTask(WeakReference<ImageView> imageView, String url,
				int reqWidth, OnImageLoaderListener imageLoaderListener) {
			super();
			this.imageView = imageView;
			this.url = url;
			this.reqWidth = reqWidth;
			this.imageLoaderListener = imageLoaderListener;
		}

		@Override
        protected Bitmap doInBackground(String... arg0) {
            Bitmap bitmap = downloadBitmap(url);
            return bitmap;
        }

        @Override
        protected void onPostExecute(Bitmap result) {
            super.onPostExecute(result);
            ImageView imageView = this.imageView.get();
            if (imageView != null && result != null) {
                Log.i(TAG,"load imageView url=="+ url);
                setImgBitmap(imageView, result, imageLoaderListener);
            }
            loadTasks.remove(this);
        }

        Bitmap downloadBitmap(String imageUrl) {
            Bitmap bitmap = null;
            HttpURLConnection con = null;
            FileOutputStream fileOutputStream=null;
            try {
                URL url = new URL(imageUrl);
                con = (HttpURLConnection) url.openConnection();
                con.setConnectTimeout(2 * 1000);
                con.setReadTimeout(10 * 1000);
                con.setDoInput(true);
                con.setDoOutput(true);
                String allPath = getAllPath(this.url);
                fileOutputStream=new FileOutputStream(allPath);
                byte[] arr=new byte[1024];
                int len=-1;
                while( (len=con.getInputStream().read(arr))!=-1 ){
                    fileOutputStream.write(arr,0,len);
                }
                bitmap=decodeSampledBitmapFromResource(allPath, reqWidth);
            } catch (Exception e) {
                e.printStackTrace();
                Log.i(TAG,"image load error=="+ e.getMessage());
            } finally {
            	if (fileOutputStream!=null) {
            		try {
            			fileOutputStream.flush();
    					fileOutputStream.close();
					} catch (Exception e2) {
						e2.printStackTrace();
					}
				}
                if (con != null) {
                    con.disconnect();
                }
            }
            return bitmap;
        }

    }
    
    public interface OnImageLoaderListener{
    	void setImageView(ImageView imageView, Bitmap bitmap);
    }


    public static String getMd5String(String str){
        StringBuilder sb = new StringBuilder(40);
        try {
            MessageDigest md5=MessageDigest.getInstance("MD5");
            byte[] bs = md5.digest(str.getBytes());
            for(byte x:bs) {
                if((x & 0xff)>>4 == 0) {
                    sb.append("0").append(Integer.toHexString(x & 0xff));
                } else {
                    sb.append(Integer.toHexString(x & 0xff));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sb.toString();
    }

    public static Bitmap getRoundedCornerBitmap(Bitmap bitmap,float roundPx){
        Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(output);
        final int color = 0xff424242;
        final Paint paint = new Paint();
        final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
        final RectF rectF = new RectF(rect);
        paint.setAntiAlias(true);
        canvas.drawARGB(0, 0, 0, 0);
        paint.setColor(color);
        canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
        canvas.drawBitmap(bitmap, rect, rect, paint);

        return output;
    }

    public static Bitmap getOvalBitmap(Bitmap bitmap){
        Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(output);
        final int color = 0xff424242;
        final Paint paint = new Paint();
        final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
        final RectF rectF = new RectF(rect);
        paint.setAntiAlias(true);
        canvas.drawARGB(0, 0, 0, 0);
        paint.setColor(color);
        canvas.drawOval(rectF, paint);
        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
        canvas.drawBitmap(bitmap, rect, rect, paint);
        return output;
    }
    
    public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth) {
        final int width = options.outWidth;
        int inSampleSize = 1;
        if (width > reqWidth) {
            final int widthRatio = Math.round((float) width / (float) reqWidth);
            inSampleSize = widthRatio;
        }
        return inSampleSize;
    }

    public static Bitmap decodeSampledBitmapFromResource(String pathName, int reqWidth) {
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(pathName, options);
        options.inSampleSize = calculateInSampleSize(options, reqWidth);
        options.inJustDecodeBounds = false;
        return BitmapFactory.decodeFile(pathName, options);
    }


}