【前言】
关于Picasso的使用教程,网上资料有很多。本文主要是对Picasso源码进行解析,关于Picasso的详细使用方法,可访问http://square.github.io/picasso/。
Picasso实现了一行代码加载图片的功能(可加载本地图片、网络图片),使用它可以自动处理Android中加载图片涉及到的以下几个问题:
① Adapter中对ImageView的回收和下载任务的自动取消
② 以最小的内存,完成复杂的图片格式转换
③ 自动处理内存缓存和硬盘缓存
【Picasso.with(Context) 介绍】
public static
Picasso with(@NonNull
Context context) {
if
(context == null) {
throw new
IllegalArgumentException("context == null");
}
if
(singleton
== null) {
synchronized
(Picasso.class) {
if
(singleton
== null) {
singleton
= new
Builder(context).build();
}
}
}
return
singleton;
}
通过调用with来获取Picasso的实例,由于使用了构建者模式,在build中构建了许多下载和缓存相关的对象
public
Picasso build() {
Context context = this.context;
if (downloader
== null) {
/**
* 构建默认的下载器(默认使用OkHttp请求网络图片)
*/
downloader
= Utils.createDefaultDownloader(context);
}
if
(cache
== null) {
/**
* 默认缓存机制(Lru内存缓存)
*/
cache
= new
LruCache(context);
}
if
(service
== null) {
/**
* 默认线程池管理器(默认3个线程数)
*/
service
= new
PicassoExecutorService();
}
if
(transformer
== null) {
/**
* 请求转换器
*/
transformer
= RequestTransformer.IDENTITY;
}
/**
* 缓存处理器
*/
Stats stats =
new Stats(cache);
/**
* 事件分发器
*/
Dispatcher dispatcher =
new Dispatcher(context,
service,
HANDLER,
downloader,
cache,
stats);
return new Picasso(context,
dispatcher,
cache,
listener,
transformer,
requestHandlers,
stats,
defaultBitmapConfig,
indicatorsEnabled,
loggingEnabled);
}
}
如果用户不想使用默认的构建对象,可通过new Picasso.Builder来创建Picasso实例。
【Picasso.load(...) 介绍】
load是一个重载的函数,有四种类型的形参
① File 通过转换,调用了load(Uri)
② Uri
③ String 通过转换,调用了load(Uri)
④ int 加载drawable资源图片
public
RequestCreator load(@Nullable
Uri uri) {
return new
RequestCreator(this,
uri,
0);
}
public
RequestCreator load(@DrawableRes
int resourceId) {
if
(resourceId == 0) {
throw new
IllegalArgumentException("Resource ID must not be zero.");
}
return new
RequestCreator(this, null,
resourceId);
}
【RequestCreator 介绍】
封装了图片加载请求,一次请求对应一个RequestCreator实例。该类包含了几个常见的函数:
① placeholder 设置加载过程中显示的图片
② error 设置加载异常后显示的图片
③ resize 重置图片尺寸
④ centerCrop 对图片进行裁剪
⑤ transform 对图片做置换操作(如变形、圆角处理等)
⑥ into 实现异步请求图片到指定的 View组件
【RequestCreator.into(...) 介绍】
into是个重载的函数。支持把图片“绑定”到指定的View控制,其中View控件可以是普通的ImageView,也可以是跨进程的RemoteViews。
public void
into(ImageView target,
Callback callback) {
long
started = System.nanoTime();
/**
* 注意,into方法必须在主线程中调用
*/
checkMain();
...
/**
*
如果之前通过uri或resourceId加载过改图片,则取消请求
*/
if
(!data.hasImage()) {
picasso.cancelRequest(target);
...
return;
}
...
Request request = createRequest(started);
String requestKey =
createKey(request);
/**
*
读取内存中对应的图片,如果有则取消请求
*/
if (shouldReadFromMemoryCache(memoryPolicy))
{
Bitmap bitmap = picasso.quickMemoryCacheCheck(requestKey);
if (bitmap !=
null) {
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;
}
}
...
/**
*
把请求封装成Action
*/
Action action =
new
ImageViewAction(picasso,
target,
request,
memoryPolicy,
networkPolicy,
errorResId,
errorDrawable,
requestKey,
tag,
callback,
noFade);
/**
*
Action进入请求队列
*/
picasso.enqueueAndSubmit(action);
}
【Picasso.enqueueAndSubmit 介绍】
void
enqueueAndSubmit(Action action) {
Object target = action.getTarget();
if (target !=
null &&
targetToAction.get(target) != action) {
/**
* 取消View对应的历史Action请求(保证同一时刻,View只对应一个Action请求)
* 注:该方法要求在主线程调用
*/
cancelExistingRequest(target);
targetToAction.put(target,
action);
}
submit(action);
}
【Picasso.submint 介绍】
Picasso的submint很简单,逻辑的处理交给了事件分发器Dispatcher,接下来看看Dispatcher的dispatchSubmit
void
submit(Action action) {
dispatcher.dispatchSubmit(action);
}
【Dispatcher.dispatchSubmit 介绍】
void
dispatchSubmit(Action action) {
handler.sendMessage(handler.obtainMessage(REQUEST_SUBMIT,
action));
}
dispatchSubmit里面的逻辑也很明了,交给了handler处理。其实这个handler使用的looper是HandlerThread传进来的,而这个HandlerThread又是在Picasso的build中初始化的,也就是说handler属于主线程。
Dispatcher(Context context,
ExecutorService service,
Handler mainThreadHandler,
Downloader downloader,
Cache cache,
Stats stats) {
this.dispatcherThread
= new
DispatcherThread();
...
this.handler
= new
DispatcherHandler(dispatcherThread.getLooper(), this);
...
}
public
Picasso build() {
...
/**
* 事件分发器
*/
Dispatcher dispatcher =
new Dispatcher(context,
service,
HANDLER,
downloader,
cache,
stats);
...
}
}
根据REQUEST_SUBMIT可知,调用了 dispatcher.performSubmit(action);
【Dispatcher.performSubmit(Action, boolean) 介绍】
performSubmit中通过forRequest创建了BitmapHunter实例,它其实是Runnable的子类,之后交给线程池去执行。可知图片的加载请求是在BitmapHunter的run方法中执行的。
void
performSubmit(Action action, boolean
dismissFailed) {
/**
* 如果action被贴上暂停的标签,则加入pausedActions集合,且不对请求做处理
*/
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;
}
/**
* BitmapHunter其实是一个Runnable
*/
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;
}
/**
* 构建请求Runnable
*/
hunter =
forRequest(action.getPicasso(), this,
cache,
stats,
action);
hunter.future
= service.submit(hunter);
hunterMap.put(action.getKey(),
hunter);
if (dismissFailed) {
failedActions.remove(action.getTarget());
}
if
(action.getPicasso().loggingEnabled) {
log(OWNER_DISPATCHER,
VERB_ENQUEUED,
action.request.logId());
}
}
【Dispatcher.forRequest 介绍】
在创建BitmapHunter实例前,会遍历请求处理器集合,该集合的初始化是在Picasso的构造函数中。至少有7个处理器——对不同来源的图片请求进行处理。当然,用户也可以自定义处理器。如果都没有匹配到,将使用默认的ERRORING_HANDLER 并抛出异常。
static
BitmapHunter forRequest(Picasso picasso,
Dispatcher dispatcher,
Cache cache,
Stats stats,
Action action) {
Request request = action.getRequest();
List<RequestHandler> requestHandlers = picasso.getRequestHandlers();
// Index-based loop to avoid allocating an iterator.
//noinspection ForLoopReplaceableByForEach
/**
* 遍历集合,找到适合处理该请求的处理器
* 至少有7个处理器对不同来源的请求进行匹配:
* ResourceRequestHandler、ContactsPhotoRequestHandler、
* MediaStoreRequestHandler、ContentStreamRequestHandler、
*
AssetRequestHandler、FileRequestHandler、NetworkRequestHandler
* 如果都不匹配,也没有自定义的处理器,则使用 ERRORING_HANDLER 抛出异常
*/
for
(int
i = 0,
count = requestHandlers.size();
i < count;
i++) {
RequestHandler requestHandler = requestHandlers.get(i);
if (requestHandler.canHandleRequest(request)) {
return new
BitmapHunter(picasso,
dispatcher,
cache,
stats,
action,
requestHandler);
}
}
return new
BitmapHunter(picasso,
dispatcher,
cache,
stats,
action,
ERRORING_HANDLER);
}
【BitmapHunter.run 介绍】
BitmapHunter.run是请求图片的主要入口,里面又调用了hunt行数,由它完成图片的请求和返回请求结果。
@Override
public void run() {
try
{
updateThreadName(data);
if (picasso.loggingEnabled)
{
log(OWNER_HUNTER,
VERB_EXECUTING,
getLogIdsForHunter(this));
}
/**
* 开始请求图片,并切返回请求结果
*/
result
= hunt();
...
}
【BitmapHunter.hunt介绍】
该方法首先会读取内存中是否有缓存图片,如果没有才会调用requestHandler.load真正加载图片,这个requestHandler就是前面说到的7个请求处理器中的一个,这里以NetworkRequestHandler 为例讲解获取网络图片的过程。
Bitmap
hunt()
throws IOException {
Bitmap bitmap = null;
/**
* 先从内存中读取是否有缓存的图片
*/
if
(shouldReadFromMemoryCache(memoryPolicy))
{
bitmap = cache.get(key);
if (bitmap !=
null) {
stats.dispatchCacheHit();
loadedFrom
= MEMORY;
if (picasso.loggingEnabled)
{
log(OWNER_HUNTER,
VERB_DECODED,
data.logId(),
"from cache");
}
return
bitmap;
}
}
/**
* 除了网络请求处理器返回默认的重试次数为2,其他请求处理器都返回0
*/
data.networkPolicy
= retryCount
== 0
? NetworkPolicy.OFFLINE.index
: networkPolicy;
/**
* 处理器开始加载图片(这里以 NetworkRequestHandler 为例讲解)
*/
RequestHandler.Result result =
requestHandler.load(data,
networkPolicy);
...
if
(bitmap != null) {
if
(picasso.loggingEnabled) {
log(OWNER_HUNTER,
VERB_DECODED,
data.logId());
}
stats.dispatchBitmapDecoded(bitmap);
if (data.needsTransformation() ||
exifOrientation !=
0) {
synchronized
(DECODE_LOCK) {
/**
* 如果设置了图片转换器(变形,旋转等处理),则进行置换处理
*/
if
(data.needsMatrixTransform() ||
exifOrientation !=
0) {
bitmap = transformResult(data,
bitmap,
exifOrientation);
...
}
if
(data.hasCustomTransformations()) {
bitmap = applyCustomTransformations(data.transformations,
bitmap);
...
}
}
...
}
}
return
bitmap;
}
【NetworkRequestHandler.load
介绍】
load里面使用了默认下载器来加载网络数据。该下载器的实例化在Picasso的build里(Utils.createDefaultDownloader),默认实现是OkHttp3Downloader。所以需要跳转到OkHttp3Downloader的load里去看个究竟。
@Override @Nullable
public Result
load(Request request, int
networkPolicy) throws
IOException {
/**
* 使用默认下载器加载网络数据(下载器初始化在Picasso.build里,默认是OkHttp3Downloader)
* 可见Picasso 网络请求部分,使用了第三方开源工具 OkHttp
*/
Response response =
downloader.load(request.uri,
request.networkPolicy);
if (response ==
null) {
return null;
}
Picasso.LoadedFrom loadedFrom = response.cached
? DISK
: NETWORK;
Bitmap bitmap = response.getBitmap();
...
return new
Result(is,
loadedFrom);
}
【OkHttp3Downloader.load 介绍】
最终通过调用OkHttp的网络请求接口获取图片数据,把返回的数据封装到Response后返回。
@Override
public Response
load(@NonNull
Uri uri, int
networkPolicy) throws
IOException {
Request.Builder builder =
new okhttp3.Request.Builder().url(uri.toString());
...
/**
* 直接调用了 OkHttp 框架的网络请求接口,然后把返回的输入流封装到Response返回
*/
okhttp3.Response response =
client.newCall(builder.build()).execute();
int responseCode = response.code();
if (responseCode >=
300) {
response.body().close();
throw new ResponseException(responseCode +
" " + response.message(),
networkPolicy,
responseCode);
}
boolean
fromCache = response.cacheResponse() !=
null;
ResponseBody responseBody = response.body();
return new Response(responseBody.byteStream(),
fromCache,
responseBody.contentLength());
}
【总结】
至此Picasso的源码分析就暂告一段落,让我们回头总结下。Picasso作为一款出色的图片获取、处理框架,离不开服务框架OkHttp、缓存框架LruCache的功劳。还加入了线程池管理器,支持请求优先级设置,支持图片压缩和置换处理,有效避免了OOM异常。