Picasso是Square公司开源的一个Android平台上的图片加载框架,也是大名鼎鼎的JakeWharton的代表作品之一.对于图片加载和缓存框架,优秀的开源作品有不少。比如:Android-Universal-Image-Loader,Glide,fresco等等.我自己有在项目中使用过的有Picasso,U-I-L,Glide.对于一般的应用上面这些图片加载和缓存框架都是能满足使用的,Trinea有一篇关于这些框架的对比文章Android三大图片缓存原理、特性对比有兴趣了解的可以去看看,本文我们主要讲Picasso的使用方法和源码分析.
使用方法
//加载一张图片 Picasso.with(this).load(“url”).placeholder(R.mipmap.ic_default).into(imageView); //加载一张图片并设置一个回调接口 Picasso.with(this).load(“url”).placeholder(R.mipmap.ic_default).into(imageView, new Callback() { @Override public void onSuccess() { } @Override public void onError() { } }); //预加载一张图片 Picasso.with(this).load(“url”).fetch(); //同步加载一张图片,注意只能在子线程中调用并且Bitmap不会被缓存到内存里. new Thread() { @Override public void run() { try { final Bitmap bitmap = Picasso.with(getApplicationContext()).load(“url”).get(); mHandler.post(new Runnable() { @Override public void run() { imageView.setImageBitmap(bitmap); } }); } catch (IOException e) { e.printStackTrace(); } } }.start(); //加载一张图片并自适应imageView的大小,如果imageView设置了wrap_content,会显示不出来.直到该ImageView的 //LayoutParams被设置而且调用了该View的ViewTreeObserver.OnPreDrawListener回调接口后才会显示. Picasso.with(this).load(“url”).priority(Picasso.Priority.HIGH).fit().into(imageView); //加载一张图片并按照指定尺寸以centerCrop()的形式缩放. Picasso.with(this).load(“url”).resize(200,200).centerCrop().into(imageView); //加载一张图片并按照指定尺寸以centerInside()的形式缩放.并设置加载的优先级为高.注意centerInside()或centerCrop() //只能同时使用一种,而且必须指定resize()或者resizeDimen(); Picasso.with(this).load(“url”).resize(400,400).centerInside().priority(Picasso.Priority.HIGH).into(imageView); //加载一张图片旋转并且添加一个Transformation,可以对图片进行各种变化处理,例如圆形头像. Picasso.with(this).load(“url”).rotate(10).transform(new Transformation() { @Override public Bitmap transform(Bitmap source) { //处理Bitmap return null; } @Override public String key() { return null; } }).into(imageView); //加载一张图片并设置tag,可以通过tag来暂定或者继续加载,可以用于当ListView滚动是暂定加载.停止滚动恢复加载. Picasso.with(this).load(“url”).tag(mContext).into(imageView); Picasso.with(this).pauseTag(mContext); Picasso.with(this).resumeTag(mContxt);
上面我们介绍了Picasso的大部分常用的使用方法.此外Picasso内部还具有监控功能.可以检测内存数据,缓存命中率等等.而且还会根据网络变化优化并发线程.下面我们就来进行Picasso的源码分析。这里说明一下,Picasso的源码分析目前在网络上已经有几篇比较好的分析文章,参考了以下文章
RowandJJ的Picasso源码学习
闭门造车的Picasso源码分析系列
类关系图
从类图上我们可以看出Picasso的核心类主要包括:Picasso,RequestCreator,Action,Dispatcher,Request,RequestHandler,BitmapHunter等等.一张图片加载可以分为以下几步:
创建->入队->执行->解码->变换->批处理->完成->分发->显示(可选)
下面就让我们来通过Picasso的调用流程来具体分析它的具体实现.
源码分析
Picasso.with()方法的实现
按照我们的惯例,我们从Picasso的调用流程开始分析,我们就从加载一张图片开始看起:
Picasso.with(this).load(url).into(imageView);
让我们先来看看Picasso.with()做了什么:
public static Picasso with(Context context) { if (singleton == null) { synchronized (Picasso.class) { if (singleton == null) { singleton = new Builder(context).build(); } } } return singleton; }
维护一个Picasso的单例,如果还未实例化就通过new Builder(context).build()创建一个singleton并返回,我们继续看Builder类的实现:
public static class Builder { public Builder(Context context) { if (context == null) { throw new IllegalArgumentException(“Context must not be null.”); } this.context = context.getApplicationContext(); } /** Create the {@link Picasso} instance. */ public Picasso build() { Context context = this.context; if (downloader == null) { //创建默认下载器 downloader = Utils.createDefaultDownloader(context); } if (cache == null) { //创建Lru内存缓存 cache = new LruCache(context); } if (service == null) { //创建线程池,默认有3个执行线程,会根据网络状况自动切换线程数 service = new PicassoExecutorService(); } if (transformer == null) { //创建默认的transformer,并无实际作用 transformer = RequestTransformer.IDENTITY; } //创建stats用于统计缓存,以及缓存命中率,下载数量等等 Stats stats = new Stats(cache); //创建dispatcher对象用于任务的调度 Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats); return new Picasso(context, dispatcher, cache, listener, transformer, requestHandlers, stats, defaultBitmapConfig, indicatorsEnabled, loggingEnabled); } }
上面的代码里省去了部分配置的方法,当我们使用Picasso默认配置的时候(当然也可以自定义),最后会调用build()方法并配置好我们需要的各种对象,最后实例化一个Picasso对象并返回。最后在Picasso的构造方法里除了对这些对象的赋值以及创建一些新的对象,例如清理线程等等.最重要的是初始化了requestHandlers,下面是代码片段:
List
可以看到除了添加我们可以自定义的extraRequestHandlers,另外添加了7个RequestHandler分别用来处理加载不同来源的资源,可能是Resource里的,也可能是File也可能是来源于网络的资源.这里使用了一个ArrayList来存放这些RequestHandler现在先不用了解这么做是为什么,下面我们会分析,到这我们就了解了Picasso.with()做了什么,接下来我们去看看load()方法.
load(),centerInside(),等方法的实现
在Picasso的load()方法里我们可以传入String,Uri或者File对象,但是其最终都是返回一个RequestCreator对象,如下所示:
public RequestCreator load(Uri uri) { return new RequestCreator(this, uri, 0); }
再来看看RequestCreator的构造方法:
RequestCreator(Picasso picasso, Uri uri, int resourceId) { if (picasso.shutdown) { throw new IllegalStateException( “Picasso instance already shut down. Cannot submit new requests.”); } this.picasso = picasso; this.data = new Request.Builder(uri, resourceId, picasso.defaultBitmapConfig); }
首先是持有一个Picasso的对象,然后构建一个Request的Builder对象,将我们需要加载的图片的信息都保存在data里,在我们通过.centerCrop()或者.transform()等等方法的时候实际上也就是改变data内的对应的变量标识,再到处理的阶段根据这些参数来进行对应的操作,所以在我们调用into()方法之前,所有的操作都是在设定我们需要处理的参数,真正的操作都是有into()方法引起的。
into()方法的实现
从上文中我们知道在我们调用了load()方法之后会返回一个RequestCreator对象,所以.into(imageView)方法必然是在RequestCreator里:
public void into(ImageView target) { //传入空的callback into(target, null); } public void into(ImageView target, Callback callback) { long started = System.nanoTime(); //检查调用是否在主线程 checkMain(); if (target == null) { throw new IllegalArgumentException(“Target must not be null.”); } //如果没有设置需要加载的uri,或者resourceId if (!data.hasImage()) { picasso.cancelRequest(target); //如果设置占位图片,直接加载并返回 if (setPlaceholder) { setPlaceholder(target, getPlaceholderDrawable()); } return; } //如果是延时加载,也就是选择了fit()模式 if (deferred) { //fit()模式是适应target的宽高加载,所以并不能手动设置resize,如果设置就抛出异常 if (data.hasSize()) { throw new IllegalStateException(“Fit cannot be used with resize.”); } int width = target.getWidth(); int height = target.getHeight(); //如果目标ImageView的宽或高现在为0 if (width == 0 || height == 0) { //先设置占位符 if (setPlaceholder) { setPlaceholder(target, getPlaceholderDrawable()); } //监听ImageView的ViewTreeObserver.OnPreDrawListener接口,一旦ImageView //的宽高被赋值,就按照ImageView的宽高继续加载. picasso.defer(target, new DeferredRequestCreator(this, target, callback)); return; } //如果ImageView有宽高就设置设置 data.resize(width, height); } //构建Request Request request = createRequest(started); //构建requestKey String requestKey = createKey(request); //根据memoryPolicy来决定是否可以从内存里读取 if (shouldReadFromMemoryCache(memoryPolicy)) { //通过LruCache来读取内存里的缓存图片 Bitmap bitmap = picasso.quickMemoryCacheCheck(requestKey); //如果读取到 if (bitmap != null) { //取消target的request picasso.cancelRequest(target); //设置图片 setBitmap(target, picasso.context, bitmap, MEMORY, noFade, picasso.indicatorsEnabled); if (picasso.loggingEnabled) { log(OWNER_MAIN, VERB_COMPLETED, request.plainId(), “from ” + MEMORY); } //如果设置了回调接口就回调接口的方法. if (callback != null) { callback.onSuccess(); } return; } } //如果缓存里没读到,先根据是否设置了占位图并设置占位 if (setPlaceholder) { setPlaceholder(target, getPlaceholderDrawable()); } //构建一个Action对象,由于我们是往ImageView里加载图片,所以这里创建的是一个ImageViewAction对象. Action action = new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId, errorDrawable, requestKey, tag, callback, noFade); //将Action对象入列提交 picasso.enqueueAndSubmit(action); }
整个流程看下来应该是比较清晰的,最后是创建了一个ImageViewAction对象并通过picasso提交,这里简要说明一下ImageViewAction,实际上Picasso会根据我们调用的不同方式来实例化不同的Action对象,当我们需要往ImageView里加载图片的时候会创建ImageViewAction对象,如果是往实现了Target接口的对象里加载图片是则会创建TargetAction对象,这些Action类的实现类不仅保存了这次加载需要的所有信息,还提供了加载完成后的回调方法.也是由子类实现并用来完成不同的调用的。然后让我们继续去看picasso.enqueueAndSubmit(action)方法:
void enqueueAndSubmit(Action action) { Object target = action.getTarget(); //取消这个target已经有的action. if (target != null && targetToAction.get(target) != action) { // This will also check we are on the main thread. cancelExistingRequest(target); targetToAction.put(target, action); } //提交action submit(action); } //调用dispatcher来派发action void submit(Action action) { dispatcher.dispatchSubmit(action); }
很简单,最后是转到了dispatcher类来处理,那我们就来看看dispatcher.dispatchSubmit(action)方法:
void dispatchSubmit(Action action) { handler.sendMessage(handler.obtainMessage(REQUEST_SUBMIT, action)); }
看到通过一个handler对象发送了一个REQUEST_SUBMIT的消息,那么这个handler是存在与哪个线程的呢?
Dispatcher(Context context, ExecutorService service, Handler mainThreadHandler, Downloader downloader, Cache cache, Stats stats) { this.dispatcherThread = new DispatcherThread(); this.dispatcherThread.start(); this.handler = new DispatcherHandler(dispatcherThread.getLooper(), this); this.mainThreadHandler = mainThreadHandler; } static class DispatcherThread extends HandlerThread { DispatcherThread() { super(Utils.THREAD_PREFIX + DISPATCHER_THREAD_NAME, THREAD_PRIORITY_BACKGROUND); } }
上面是Dispatcher的构造方法(省略了部分代码),可以看到先是创建了一个HandlerThread对象,然后创建了一个DispatcherHandler对象,这个handler就是刚刚用来发送REQUEST_SUBMIT消息的handler,这里我们就明白了原来是通过Dispatcher类里的一个子线程里的handler不断的派发我们的消息,这里是用来派发我们的REQUEST_SUBMIT消息,而且最终是调用了 dispatcher.performSubmit(action);方法:
void performSubmit(Action action) { performSubmit(action, true); } void performSubmit(Action action, boolean dismissFailed) { //是否该tag的请求被暂停 if (pausedTags.contains(action.getTag())) { pausedActions.put(action.getTarget(), action); if (action.getPicasso().loggingEnabled) { log(OWNER_DISPATCHER, VERB_PAUSED, action.request.logId(), “because tag ‘” + action.getTag() + “‘ is paused”); } return; } //通过action的key来在hunterMap查找是否有相同的hunter,这个key里保存的是我们 //的uri或者resourceId和一些参数,如果都是一样就将这些action合并到一个 //BitmapHunter里去. BitmapHunter hunter = hunterMap.get(action.getKey()); if (hunter != null) { hunter.attach(action); return; } if (service.isShutdown()) { if (action.getPicasso().loggingEnabled) { log(OWNER_DISPATCHER, VERB_IGNORED, action.request.logId(), “because shut down”); } return; } //创建BitmapHunter对象 hunter = forRequest(action.getPicasso(), this, cache, stats, action); //通过service执行hunter并返回一个future对象 hunter.future = service.submit(hunter); //将hunter添加到hunterMap中 hunterMap.put(action.getKey(), hunter); if (dismissFailed) { failedActions.remove(action.getTarget()); } if (action.getPicasso().loggingEnabled) { log(OWNER_DISPATCHER, VERB_ENQUEUED, action.request.logId()); } }
注释很详细,这里我们再分析一下forRequest()是如何实现的:
static BitmapHunter forRequest(Picasso picasso, Dispatcher dispatcher, Cache cache, Stats stats, Action action) { Request request = action.getRequest(); List
首先是添加到内存缓存中去,然后在发送一个HUNTER_DELAY_NEXT_BATCH消息,实际上这个消息最后会触发performBatchComplete()方法,performBatchComplete()里则是通过mainThreadHandler将BitmapHunter的List发送到主线程处理,所以我们去看看mainThreadHandler的handleMessage()方法:
static final Handler HANDLER = new Handler(Looper.getMainLooper()) { @Override public void handleMessage(Message msg) { switch (msg.what) { case HUNTER_BATCH_COMPLETE: { @SuppressWarnings(“unchecked”) List
