Android 之 Picasso使用

Picasso使用

简介：

Picasso是Square公司出品的一款强大的Android图片缓存库，可以实现图片的加载与缓存功能。

功能：

Picasso采用链式调用的方式实现了加载图片和自动缓存功能，同时，在图片的处理上也做的相当好，可以自己根据相应的需求来对图片进行变换大小和进行旋转，还提供了Transformation接口，可以自行处理Bitmap相关的操作，在Adapter中的使用也相当流畅。

使用：

Picasso 主要采用链式的方法，让图片从加载到设置到相关的View中串联起来，主要使用Picasso.with(context).load(url).into(imageView)，同时，可以在链式操作中，load(url)和into(imageView)之间设置相关的参数来实现一些基础要求，例如：设置加载时的图片，或者加载失败的图片等等。同时还可以调用resize()等方法将图片转化并且占用较少内存。Picasso在加载时也提供了很多cancelTag(Object tag),pauseTag(Object tag),resumeTag(Object tag)等相关对Picasso进行暂停，resume相关的操作，可以控制Picasso更好的处理图片。

缓存：

Picasso是采用了OkHttp下载，那么Picasso一定使用了

client.setCache(new com.squareup.okhttp.Cache(cacheDir, maxSize));
public OkHttpDownloader(final Context context) {  this(Utils.createDefaultCacheDir(context)); 
}
static File createDefaultCacheDir(Context context) {
    File cache = new File(context.getApplicationContext().getCacheDir(), PICASSO_CACHE);
    if (!cache.exists()) {
      //noinspection ResultOfMethodCallIgnored
      cache.mkdirs();
    }
    return cache;
  }

而context.getApplicationContext().getCacheDir() ;获得缓存目录
getCacheDir()方法用于获取/data/data/(application package)/cache目录
getFilesDir()方法用于获取/data/data/(application package)/files目录
Context.getExternalFilesDir()方法可以获取到 SDCard/Android/data/你的应用的包名/files/ 目录，一般放一些长时间保存的数据
Context.getExternalCacheDir()方法可以获取到 SDCard/Android/data/你的应用包名/cache/目录，一般存放临时缓存数据
private static final String PICASSO_CACHE = “picasso-cache”;
ok,那么缓存目录就在 /data/data/(application package)/cache/picasso-cache/下边

需求：

很多时候，我们不可能每次都要去设置placeholderResId，errorResId等，这样不仅增加代码的数量，还会使Picasso的链式变得很长，如果有可能的话，可以对Picasso进行一些基础的封装。
Picasso.with(context) 源码中显示的context.getApplicationContext(),所以在初始化的时候，我们可以在Application类中直接实现，然后在Application中对placeholderResId，errorResId等进行相应的设置。

public class MyPicasso {

    private static MyPicasso instance;

    private static Picasso picasso;

    //记载一些Picasso参数的对象
    private static PicassoBean bean;

    public MyPicasso(Context context) {
        picasso = Picasso.with(context);
        bean = new PicassoBean();
    }

    /***
     * 在Application中初始化，在之后的调用中可以直接使用Util进行使用
     *
     * @param context 上下文
     *                <p>根据Picasso的源码{@link Picasso.Builder#Builder(android.content.Context)}可知，
     *                Picasso初始化即为with(Context context)这里的Context就是去获取相关的Application
     *                级的Context，同时，初始化为单例模式，及时以后再去调用with(Context context)，
     *                也不会再去{@link Picasso.Builder#build()}</p>
     */
    public static void init(Context context) {
        if (instance == null) {
            synchronized (MyPicasso.class) {
                if (instance == null) {
                    instance = new MyPicasso(context);
                }
            }
        }
    }

    /**
     * 获得定义的PicassoBean,便于设置一些参数
     **/
    public static PicassoBean getBean() {
        if (bean != null) {
            return bean;
        } else {
            throw new NullPointerException("PicassonBean is null");
        }
    }

    /**
     * 加载默认数据，对图像不做处理
     *
     * @param object
     * @param iv
     */
    public static void inject(Object object, ImageView iv) {
        inject(object, iv, null);
    }

    /**
     * 加载圆角图像，
     *
     * @param object
     * @param iv
     * @param rangle 圆角角度，单位px
     */
    public static void inject(Object object, ImageView iv, int rangle) {
        inject(object, iv, new RangleTransForm(rangle));
    }

    /**
     *  加载圆形图片
     * @param object
     * @param iv
     * @param isCircle 是否为圆形图片
     */
    public static void inject(Object object, ImageView iv, boolean isCircle) {
        if (isCircle) {
            inject(object, iv, new CircleTransForm());
        } else {
            inject(object,iv);
        }
    }

    /**
     * 加载数据
     *
     * @param object 需传入相关的数据，根据类型来执行不同操作
     * @param iv     需要注入的相关的ImageView
     */
    private static void inject(Object object, ImageView iv, Transformation transformation) {
        if (object instanceof Integer) {
            initArg(picasso.load((Integer) object), transformation).into(iv);
        } else if (object instanceof String) {
            initArg(picasso.load((String) object), transformation).into(iv);
        } else if (object instanceof Uri) {
            initArg(picasso.load((Uri) object), transformation).into(iv);
        } else if (object instanceof File) {
            initArg(picasso.load((File) object), transformation).into(iv);
        } else {
            throw new IllegalArgumentException("Please input correct object arg ");
        }
    }

    /**
     * 加载一些配置
     *
     * @param creator
     * @param transformation 方便自定义一些有特点的图像
     * @return
     */
    private static RequestCreator initArg(RequestCreator creator, Transformation transformation) {
        if (bean.placeholderResId != 0) {
            creator.placeholder(bean.placeholderResId);
        }
        if (bean.errorResId != 0) {
            creator.error(bean.errorResId);
        }
        if (transformation != null) {
            creator.transform(transformation);
        } else {
            if (bean.transformation != null) {
                creator.transform(bean.transformation);
            }
        }
        if (bean.policy != null) {
            creator.memoryPolicy(bean.policy);
        }
        if (bean.networkPolicy != null) {
            creator.networkPolicy(bean.networkPolicy);
        }
        return creator;
    }

    /**
     * 清除缓存
     *
     * @param object 需传入相关的数据，根据类型来执行不同操作
     */
    public static void invalidate(Object object) {
        if (object instanceof String) {
            picasso.invalidate((String) object);
        } else if (object instanceof Uri) {
            picasso.invalidate((Uri) object);
        } else if (object instanceof File) {
            picasso.invalidate((File) object);
        } else {
            throw new IllegalArgumentException("Please input correct arg");
        }
    }

    /**
     * 设置是否指示标志
     *
     * @param indicatorsEnabled
     */
    public static void setIndicatorsEnabled(boolean indicatorsEnabled) {
        picasso.setIndicatorsEnabled(indicatorsEnabled);
    }

    /**
     * 设置是否需要打印日志
     *
     * @param loggingEnabled
     */
    public static void setLoggingEnabled(boolean loggingEnabled) {
        picasso.setLoggingEnabled(loggingEnabled);
    }

    /**
     * 设置cancel的标志
     *
     * @param tag
     */
    public static void cancelTag(Object tag) {
        picasso.cancelTag(tag);
    }

    /**
     * 设置pause的标志
     *
     * @param tag
     */
    public static void pauseTag(Object tag) {
        picasso.pauseTag(tag);
    }

    /**
     * 设置Resume的标志
     *
     * @param tag
     */
    public static void resumeTag(Object tag) {
        picasso.resumeTag(tag);
    }

    /**
     * 停止使用当前Picasso
     * {@link Picasso#shutdown}
     */
    public static void shutdown() {
        picasso.shutdown();
    }

    /**
     * @Description: 方便MyPicasso设置一些参数的Bean
     * <p>主要设置加载中图片，失败图片，自定义修改图片样式</p>
     */
    public class PicassoBean {

        /**
         * 加载时的图像的ID
         **/
        private int placeholderResId = 0;

        /**
         * 加载失败的图像的ID
         **/
        private int errorResId = 0;

        /**
         * 针对一些自定义的图像改变
         **/
        private Transformation transformation = null;

        /**
         * 缓存方式，系统默认有缓存，如果不设置为系统默认
         **/
        private MemoryPolicy policy = null;

        /**
         * 如果在内存缓存中找不到相应的Bitmap,则使用此NetworkPolicy，系统默认，如不设置为默认
         **/
        private NetworkPolicy networkPolicy = null;

        /************************  链式结构，可以更好的设置参数*******************************/

        /**
         * 设置加载中的图片
         **/
        public PicassoBean placeholder(int placeholderResId) {
            this.placeholderResId = placeholderResId;
            return this;
        }

        /**
         * 设置失败时的图片
         **/
        public PicassoBean error(int errorResId) {
            this.errorResId = errorResId;
            return this;
        }

        /**
         * 设置图片转换的transformation
         *
         * @param transformation {@link Transformation}
         * @return
         */
        public PicassoBean transform(Transformation transformation) {
            this.transformation = transformation;
            return this;
        }

        /**
         * 设置缓存样式
         *
         * @param policy
         * @return
         */
        public PicassoBean memoryPolicy(MemoryPolicy policy) {
            this.policy = policy;
            return this;
        }

        /**
         * 设置在内存缓存中读取不到Bitmap对象，则继续实现的方式
         *
         * @param policy
         * @return
         */
        public PicassoBean networkPolicy(NetworkPolicy policy) {
            this.networkPolicy = policy;
            return this;
        }

    }


}

其中主要对经常使用的placeholderResId，errorResId等进行了封装，并且在其中实现了两个Transformation类，CircleTransForm类为裁剪为圆形图片，RangleTransForm为圆角矩形，可以在使用的时候直接传入相关参数设置即可。

CircleTransForm类如下：

public class CircleTransForm implements Transformation {
    @Override
    public Bitmap transform(Bitmap source) {
        int width = source.getWidth();
        int height = source.getHeight();
        int min = Math.min(width, height);

        int width_min = (width - min) / 2;
        int height_min = (height - min) / 2;

        Bitmap bitmap = Bitmap.createBitmap(source, width_min, height_min, min, min);
        if (bitmap != source) {
            source.recycle();
        }
        Bitmap circleBit = Bitmap.createBitmap(min, min, source.getConfig());
        Canvas canvas = new Canvas(circleBit);
        Paint paint = new Paint();
        BitmapShader shader = new BitmapShader(bitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
        paint.setShader(shader);
        paint.setAntiAlias(true);
        float radius = min / (float) 2;
        canvas.drawCircle(radius, radius, radius, paint);
        bitmap.recycle();
        return circleBit;
    }

    @Override
    public String key() {
        return "circle";
    }
}

RangleTransForm类如下：

public class RangleTransForm implements Transformation {

    //设置圆角的角度
    private int rangle = 0;

    public RangleTransForm(int rangle) {
        this.rangle = rangle;
    }

    @Override
    public Bitmap transform(Bitmap source) {
        Bitmap bitmap = Bitmap.createBitmap(source.getWidth(),source.getHeight(),source.getConfig());
        Canvas canvas = new Canvas(bitmap);
        Paint paint = new Paint();
        BitmapShader shader = new BitmapShader(source, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
        paint.setShader(shader);
        paint.setAntiAlias(true);
        RectF rectF = new RectF(0,0,source.getWidth(),source.getHeight());
        canvas.drawRoundRect(rectF,rangle,rangle,paint);
        source.recycle();
        return bitmap;
    }

    @Override
    public String key() {
        return "rangle";
    }
}

代码下载：http://download.csdn.net/detail/u012238268/9590159