1.相关简介
Picasso是Square公司开源的一个Android平台上的图片加载框架,也是大名鼎鼎的JakeWharton的代表作品之一,公司项目也是采用了Picasso,为了更好的了解和使用Picasso,因此对它的源码做一个简单的分析.
2.基本使用方法
//加载一张图片
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").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);
3.源码分析
我们从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) {
//维护一个Picasso的单例,如果还未实例化就通过new Builder(context).build()创建一个singleton并返回
singleton = (new Picasso.Builder(context)).build();
}
}
}
return 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,下面是代码片段:
Picasso(Context context, Dispatcher dispatcher, Cache cache, Picasso.Listener listener, Picasso.RequestTransformer requestTransformer, List extraRequestHandlers, Stats stats, Config defaultBitmapConfig, boolean indicatorsEnabled, boolean loggingEnabled) {
this.context = context;
this.dispatcher = dispatcher;
this.cache = cache;
this.listener = listener;
this.requestTransformer = requestTransformer;
this.defaultBitmapConfig = defaultBitmapConfig;
byte builtInHandlers = 7;
int extraCount = extraRequestHandlers != null?extraRequestHandlers.size():0;
ArrayList allRequestHandlers = new ArrayList(builtInHandlers + extraCount);
allRequestHandlers.add(new ResourceRequestHandler(context));
if(extraRequestHandlers != null) {
allRequestHandlers.addAll(extraRequestHandlers);
}
allRequestHandlers.add(new ContactsPhotoRequestHandler(context));
allRequestHandlers.add(new MediaStoreRequestHandler(context));
allRequestHandlers.add(new ContentStreamRequestHandler(context));
allRequestHandlers.add(new AssetRequestHandler(context));
allRequestHandlers.add(new FileRequestHandler(context));
allRequestHandlers.add(new NetworkRequestHandler(dispatcher.downloader, stats));
this.requestHandlers = Collections.unmodifiableList(allRequestHandlers);
this.stats = stats;
this.targetToAction = new WeakHashMap();
this.targetToDeferredRequestCreator = new WeakHashMap();
this.indicatorsEnabled = indicatorsEnabled;
this.loggingEnabled = loggingEnabled;
this.referenceQueue = new ReferenceQueue();
this.cleanupThread = new Picasso.CleanupThread(this.referenceQueue, HANDLER);
this.cleanupThread.start();
}
可以看到除了添加我们可以自定义的extraRequestHandlers,另外添加了7个RequestHandler分别用来处理加载不同来源的资源,可能是Resource里的,也可能是File也可能是来源于网络的资源.这里使用了一个ArrayList来存放这些RequestHandler,执行完build之后,我们接下来该做的就是调用load方法,接下来我们去看看load()方法.
load()方法的实现
在Picasso的load()方法里我们可以传入String,Uri或者File对象,但是其最终都是返回一个RequestCreator对象,如下所示:
public RequestCreator load(String path) {
if(path == null) {
return new RequestCreator(this, (Uri)null, 0);
} else if(path.trim().length() == 0) {
throw new IllegalArgumentException("Path must not be empty.");
} else {
return this.load(Uri.parse(path));
}
}
RequestCreator(Picasso picasso, Uri uri, int resourceId) {
if(picasso.shutdown) {
throw new IllegalStateException("Picasso instance already shut down. Cannot submit new requests.");
} else {
this.picasso = picasso;
this.data = new Request.Builder(uri, resourceId, picasso.defaultBitmapConfig);
}
}
首先是持有一个Picasso的对象,根据shutdown属性是判断Picasso实例是否已经停止运行,如果已经shutdown则抛异常,否则构建一个Request的Builder对象,将我们即将要加载的图片信息保存在data中,data是一个Request.Builder对象,里边保存了我们所有的图片加载的配置信息,在我们通过.centerCrop()或者.transform()等方法的时候实际上也就是改变data内的对应的变量标识,再到处理的阶段根据这些参数来进行对应的操作,比如调用了centerCrop方法
public RequestCreator centerCrop() {
data.centerCrop();
return this;
}
所以在我们调用into()方法之前,所有的操作都是在修改data里面的变量,设定我们需要处理的参数,当所有的配置信息都完成之后,真正的操作都是由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类来处理,dispatch就是在build方法中被初始化的,那我们就来看看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);
}
}
private static class DispatcherHandler extends Handler {
private final Dispatcher dispatcher;
public DispatcherHandler(Looper looper, Dispatcher dispatcher) {
super(looper);
this.dispatcher = dispatcher;
}
@Override public void handleMessage(final Message msg) {
switch (msg.what) {
case REQUEST_SUBMIT: {
Action action = (Action) msg.obj;
dispatcher.performSubmit(action);
break;
}
case REQUEST_CANCEL: {
Action action = (Action) msg.obj;
dispatcher.performCancel(action);
break;
}
case TAG_PAUSE: {
Object tag = msg.obj;
dispatcher.performPauseTag(tag);
break;
}
case TAG_RESUME: {
Object tag = msg.obj;
dispatcher.performResumeTag(tag);
break;
}
case HUNTER_COMPLETE: {
BitmapHunter hunter = (BitmapHunter) msg.obj;
dispatcher.performComplete(hunter);
break;
}
case HUNTER_RETRY: {
BitmapHunter hunter = (BitmapHunter) msg.obj;
dispatcher.performRetry(hunter);
break;
}
case HUNTER_DECODE_FAILED: {
BitmapHunter hunter = (BitmapHunter) msg.obj;
dispatcher.performError(hunter, false);
break;
}
case HUNTER_DELAY_NEXT_BATCH: {
dispatcher.performBatchComplete();
break;
}
case NETWORK_STATE_CHANGE: {
NetworkInfo info = (NetworkInfo) msg.obj;
dispatcher.performNetworkStateChange(info);
break;
}
case AIRPLANE_MODE_CHANGE: {
dispatcher.performAirplaneModeChange(msg.arg1 == AIRPLANE_MODE_ON);
break;
}
default:
Picasso.HANDLER.post(new Runnable() {
@Override public void run() {
throw new AssertionError("Unknown handler message received: " + msg.what);
}
});
}
}
}
上面是Dispatcher的构造方法(省略了部分代码),可以看到先是创建了一个HandlerThread对象,然后创建了一个DispatcherHandler对象,这个handler就是刚刚用来发送REQUEST_SUBMIT消息的handler,这里我们就明白了原来是通过Dispatcher类里的一个子线程里的handler不断的派发我们的消息,这里是用来派发我们的REQUEST_SUBMIT消息,找到这个case,发现最终是调用了 dispatcher.performSubmit(action);方法:
case REQUEST_SUBMIT: {
Action action = (Action) msg.obj;
dispatcher.performSubmit(action);
break;
}
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 requestHandlers = picasso.getRequestHandlers();
//从requestHandlers中检测哪个RequestHandler可以处理这个request,如果找到就创建
//BitmapHunter并返回.
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);
}
这里就体现出来了责任链模式,通过依次调用requestHandlers里RequestHandler的canHandleRequest()方法来确定这个request能被哪个RequestHandler执行,找到对应的RequestHandler后就创建BitmapHunter对象并返回.再回到performSubmit()方法里,通过service.submit(hunter);执行了hunter,hunter实现了Runnable接口,所以run()方法就会被执行,所以我们继续看看BitmapHunter里run()方法的实现:
@Override public void run() {
try {
//更新当前线程的名字
updateThreadName(data);
if (picasso.loggingEnabled) {
log(OWNER_HUNTER, VERB_EXECUTING, getLogIdsForHunter(this));
}
//调用hunt()方法并返回Bitmap类型的result对象.
result = hunt();
//如果为空,调用dispatcher发送失败的消息,
//如果不为空则发送完成的消息
if (result == null) {
dispatcher.dispatchFailed(this);
} else {
dispatcher.dispatchComplete(this);
}
//通过不同的异常来进行对应的处理
} catch (Downloader.ResponseException e) {
if (!e.localCacheOnly || e.responseCode != 504) {
exception = e;
}
dispatcher.dispatchFailed(this);
} catch (NetworkRequestHandler.ContentLengthException e) {
exception = e;
dispatcher.dispatchRetry(this);
} catch (IOException e) {
exception = e;
dispatcher.dispatchRetry(this);
} catch (OutOfMemoryError e) {
StringWriter writer = new StringWriter();
stats.createSnapshot().dump(new PrintWriter(writer));
exception = new RuntimeException(writer.toString(), e);
dispatcher.dispatchFailed(this);
} catch (Exception e) {
exception = e;
dispatcher.dispatchFailed(this);
} finally {
Thread.currentThread().setName(Utils.THREAD_IDLE_NAME);
}
}
先更新线程名称,然后调用了hunt方法,获取到一个result,这个result是一个Bitmap,如果获取到了Bitmap则调用dispatcher.dispatchComplete方法,否则调用dispatcher.dispatchFailed方法,这两个实际上都是调用了Handler的sendMessage方法,来发送不同的消息做不同处理,我们这里就来看看hunt()方法,看看这个Bitmap到底是怎么获取的:
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;
}
}
//如果未设置networkPolicy并且retryCount为0,则将networkPolicy设置为
//NetworkPolicy.OFFLINE
data.networkPolicy = retryCount == 0 ? NetworkPolicy.OFFLINE.index : networkPolicy;
//通过对应的requestHandler来获取result
RequestHandler.Result result = requestHandler.load(data, networkPolicy);
if (result != null) {
loadedFrom = result.getLoadedFrom();
exifOrientation = result.getExifOrientation();
bitmap = result.getBitmap();
// If there was no Bitmap then we need to decode it from the stream.
if (bitmap == null) {
InputStream is = result.getStream();
try {
bitmap = decodeStream(is, data);
} finally {
Utils.closeQuietly(is);
}
}
}
if (bitmap != null) {
if (picasso.loggingEnabled) {
log(OWNER_HUNTER, VERB_DECODED, data.logId());
}
stats.dispatchBitmapDecoded(bitmap);
//处理Transformation
if (data.needsTransformation() || exifOrientation != 0) {
synchronized (DECODE_LOCK) {
if (data.needsMatrixTransform() || exifOrientation != 0) {
bitmap = transformResult(data, bitmap, exifOrientation);
if (picasso.loggingEnabled) {
log(OWNER_HUNTER, VERB_TRANSFORMED, data.logId());
}
}
if (data.hasCustomTransformations()) {
bitmap = applyCustomTransformations(data.transformations, bitmap);
if (picasso.loggingEnabled) {
log(OWNER_HUNTER, VERB_TRANSFORMED, data.logId(), "from custom transformations");
}
}
}
if (bitmap != null) {
stats.dispatchBitmapTransformed(bitmap);
}
}
}
//返回bitmap
return bitmap;
}
首先是判断是否可以从内存中获取这张图片,如果可以,将图片加载出来并返回,并更新stats中相关变量,否则就从一个RequestHandler中读取,那么RequestHandler是我们在new一个Picasso的时候传入了多个RequestHandler,这里到底是使用哪一个RequestHandler呢?这就和我们上文说的匹配RequestHandler有关了,毫无疑问,我们下载网络图片,当然是匹配NetworkRequestHandler,那我们看看NetworkRequestHandler里边的load方法:
@Override public Result load(Request request, int networkPolicy) throws IOException {
Response response = downloader.load(request.uri, request.networkPolicy);
if (response == null) {
return null;
}
Picasso.LoadedFrom loadedFrom = response.cached ? DISK : NETWORK;
Bitmap bitmap = response.getBitmap();
if (bitmap != null) {
return new Result(bitmap, loadedFrom);
}
InputStream is = response.getInputStream();
if (is == null) {
return null;
}
// Sometimes response content length is zero when requests are being replayed. Haven't found
// root cause to this but retrying the request seems safe to do so.
if (loadedFrom == DISK && response.getContentLength() == 0) {
Utils.closeQuietly(is);
throw new ContentLengthException("Received response with 0 content-length header.");
}
if (loadedFrom == NETWORK && response.getContentLength() > 0) {
stats.dispatchDownloadFinished(response.getContentLength());
}
return new Result(is, loadedFrom);
}
这个方法里首先调用了downloader里边的load方法,获取一个Response对象,然后再拿到这个response对象里边的Bitmap返回,downloader就是我们在上文说的那个downloader,这里选取OkHttpDownloader,看看它里边的load方法
//build方法中被调用,给Picasso构造方法提供下载器
static Downloader createDefaultDownloader(Context context) {
try {
Class.forName("com.squareup.okhttp.OkHttpClient");
return OkHttpLoaderCreator.create(context);
} catch (ClassNotFoundException ignored) {
}
return new UrlConnectionDownloader(context);
}
private static class OkHttpLoaderCreator {
static Downloader create(Context context) {
return new OkHttpDownloader(context);
}
}
@Override public Response load(Uri uri, int networkPolicy) throws IOException {
CacheControl cacheControl = null;
if (networkPolicy != 0) {
if (NetworkPolicy.isOfflineOnly(networkPolicy)) {
cacheControl = CacheControl.FORCE_CACHE;
} else {
CacheControl.Builder builder = new CacheControl.Builder();
if (!NetworkPolicy.shouldReadFromDiskCache(networkPolicy)) {
builder.noCache();
}
if (!NetworkPolicy.shouldWriteToDiskCache(networkPolicy)) {
builder.noStore();
}
cacheControl = builder.build();
}
}
Request.Builder builder = new Request.Builder().url(uri.toString());
if (cacheControl != null) {
builder.cacheControl(cacheControl);
}
com.squareup.okhttp.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());
}
在这里我们总算看到了网络访问的代码了,就是大家熟悉的OkHttp网络请求了,下载到数据之后,再重新new一个Response对象返回,现在我们再回到BitmapHunter的run方法中,当成功获取到bitmap之后,接下来调用dispatcher.dispatchComplete(this); 发送一条消息,最终也是通过handler调用了dispatcher.performComplete()方法:
void dispatchComplete(BitmapHunter hunter) {
handler.sendMessage(handler.obtainMessage(HUNTER_COMPLETE, hunter));
}
又是Handler,再找到这个case
case HUNTER_COMPLETE: {
BitmapHunter hunter = (BitmapHunter) msg.obj;
dispatcher.performComplete(hunter);
break;
}
这里又调用了dispatcher.performComplete方法,点击去看看:
void performComplete(BitmapHunter hunter) {
//是否可以放入内存缓存里
if (shouldWriteToMemoryCache(hunter.getMemoryPolicy())) {
cache.set(hunter.getKey(), hunter.getResult());
}
//从hunterMap移除
hunterMap.remove(hunter.getKey());
//处理hunter
batch(hunter);
if (hunter.getPicasso().loggingEnabled) {
log(OWNER_DISPATCHER, VERB_BATCHED, getLogIdsForHunter(hunter), "for completion");
}
}
首先判断了是否该将Bitmap写入到内存缓存中,需要的话就写入,然后是batch方法:
private void batch(BitmapHunter hunter) {
if (hunter.isCancelled()) {
return;
}
batch.add(hunter);
if (!handler.hasMessages(HUNTER_DELAY_NEXT_BATCH)) {
handler.sendEmptyMessageDelayed(HUNTER_DELAY_NEXT_BATCH, BATCH_DELAY);
}
}
首先判断如果hunter已经被取消,则直接返回,否则将hunter加入到batch中,然后判断Handler中是否有一条HUNTER_DELAY_NEXT_BATCH消息,没有的话就发一条,OK,发一条之后,我们来找到相关的case:
case HUNTER_DELAY_NEXT_BATCH: {
dispatcher.performBatchComplete();
break;
}
void performBatchComplete() {
List copy = new ArrayList(batch);
batch.clear();
mainThreadHandler.sendMessage(mainThreadHandler.obtainMessage(HUNTER_BATCH_COMPLETE, copy));
logBatch(copy);
}
}
在这里将batch存入到一个新的List集合中,然后mainThreadHandler又发送一条消息,这个mainThreadHandler是什么鬼?不知道大家是否还记得在build方法中我们创建Dispatch实例的时候传入了一个Handler,就是那个在主线程中创建的Handler,在Picasso那个类里边,我们找到了HUNTER_BATCH_COMPLETE这个case:
case HUNTER_BATCH_COMPLETE: {
@SuppressWarnings("unchecked") List batch = (List) msg.obj;
//noinspection ForLoopReplaceableByForEach
for (int i = 0, n = batch.size(); i < n; i++) {
BitmapHunter hunter = batch.get(i);
hunter.picasso.complete(hunter);
}
break;
}
这个case中我们来一条一条的处理batch中的消息,交给picasso的complete方法去处理:
void complete(BitmapHunter hunter) {
//获取单个Action
Action single = hunter.getAction();
//获取被添加进来的Action
List joined = hunter.getActions();
//是否有合并的Action
boolean hasMultiple = joined != null && !joined.isEmpty();
//是否需要派发
boolean shouldDeliver = single != null || hasMultiple;
if (!shouldDeliver) {
return;
}
Uri uri = hunter.getData().uri;
Exception exception = hunter.getException();
Bitmap result = hunter.getResult();
LoadedFrom from = hunter.getLoadedFrom();
//派发Action
if (single != null) {
deliverAction(result, from, single);
}
//派发合并的Action
if (hasMultiple) {
//noinspection ForLoopReplaceableByForEach
for (int i = 0, n = joined.size(); i < n; i++) {
Action join = joined.get(i);
deliverAction(result, from, join);
}
}
if (listener != null && exception != null) {
listener.onImageLoadFailed(this, uri, exception);
}
}
派发合并的action
private void deliverAction(Bitmap result, LoadedFrom from, Action action) {
if (action.isCancelled()) {
return;
}
if (!action.willReplay()) {
targetToAction.remove(action.getTarget());
}
if (result != null) {
if (from == null) {
throw new AssertionError("LoadedFrom cannot be null.");
}
action.complete(result, from);
if (loggingEnabled) {
log(OWNER_MAIN, VERB_COMPLETED, action.request.logId(), "from " + from);
}
} else {
action.error();
if (loggingEnabled) {
log(OWNER_MAIN, VERB_ERRORED, action.request.logId());
}
}
}
如果Bitmap不为空,则会执行 action.complete(result, from),调用action的complete方法,Action是我们在into方法中创建的,当时new了一个ImageViewAction,所以我们去找ImageViewAction的complete方法:
@Override public void complete(Bitmap result, Picasso.LoadedFrom from) {
if (result == null) {
throw new AssertionError(
String.format("Attempted to complete action with no result!\n%s", this));
}
//得到target也就是ImageView
ImageView target = this.target.get();
if (target == null) {
return;
}
Context context = picasso.context;
boolean indicatorsEnabled = picasso.indicatorsEnabled;
//通过PicassoDrawable来将bitmap设置到ImageView上
PicassoDrawable.setBitmap(target, context, result, from, noFade, indicatorsEnabled);
//回调callback接口
if (callback != null) {
callback.onSuccess();
}
}
获取到所有信息之后,然后调用PicassoDrawable的setBitmap方法:
static void setBitmap(ImageView target, Context context, Bitmap bitmap,
Picasso.LoadedFrom loadedFrom, boolean noFade, boolean debugging) {
Drawable placeholder = target.getDrawable();
if (placeholder instanceof AnimationDrawable) {
((AnimationDrawable) placeholder).stop();
}
PicassoDrawable drawable =
new PicassoDrawable(context, bitmap, placeholder, loadedFrom, noFade, debugging);
target.setImageDrawable(drawable);
}