Picasso 是 Android 开发中最受欢迎的图片请求加载框架之一 ,它诞生于 2013 年,距今已有六年的生命。在这六年间 Picasso 发布过 21 个版本更新,而最近的一次更新为18年的 3 月 8 日,更新的版本号为 2.71828(文中统称为新版),该版本离上一次发布更新相隔了三年。本文主要分析新版 Picasso 的源码实现和它的一些 API 变化。
本文过长,推荐关注我之后再慢慢品尝~
1. 新版 Picasso 的使用
新版 Picasso 最直观的变化就是在 App 中的调用方式为:
Picasso.get().load(url).into(imageView);
该调用跟原来版本的调用区别是,没有了需要传 Context 的 with 方法,取而代之是一个不需要传参的 get 方法来获取全局唯一 Picasso 实例。
本文也主要通过分析 Picasso.get().load(url).into(imageView)
该句调用的来龙去脉来理清新版 Picasso 框架的实现原理。
2. Picasso 实例的获取
Picasso 实例是通过调用 Picasso 类中的静态方法 get 获取的,该方法也是新版 Picasso 的入口,我们从该方法开始看起:
static volatile Picasso singleton = null;
public static Picasso get() {
if (singleton == null) {
synchronized (Picasso.class) {
if (singleton == null) {
if (PicassoProvider.context == null) {
throw new IllegalStateException("context == null");
}
singleton = new Builder(PicassoProvider.context).build();
}
}
}
return singleton;
}
上面这段代码是一个非常经典的双重检查锁模式 (Double Checked Locking Pattern)。
首先进入 get 方法即检查一次 Picasso 实例 singleton 是否为 null,不为 null 就可以直接返回该实例。
接着进入到同步块,因为可能会一个线程进入同步块后创建完对象后退出,另一个线程又紧接着进入同步块,因此进入同步块后需要再检查一次 singleton 是否为 null,如果还为 null,这时候可以开始初始化该实例。
最后静态变量 singleton 需要用 volatile 关键字来修饰,目的是为了防止重排序。
2.1 使用 ContentProvider 获取 Context
新版 Picasso 提供给我们的入口方法 get 不需要传 Context,因为它使用的是 PicassoProvider 类中的 context,我们看一下 PicassoProvider 类:
public final class PicassoProvider extends ContentProvider {
@SuppressLint("StaticFieldLeak") static Context context;
@Override public boolean onCreate() {
context = getContext();
return true;
}
}
PicassoProvider 类继承自 ContentProvider,除了 onCreate 方法,其他方法都是默认实现 (为了节省篇幅,省略了该部分代码),而 onCreate 方法也只是调用 getContext 方法并赋值给静态变量 context,然后返回 true 表示成功加载了该 ContentProvider。
Picasso 这么做的理由是,只要将 PicassoProvider 在 AndroidManifest 文件中注册,那么 App 在启动的时候,系统就会自动回调 PicassoProvider 的 onCreate 方法,因此也就自动获取到了 Context。
2.2 Picasso 实例的创建
接着回到 Picasso.get 方法中,Picasso 实例通过该句代码创建:
singleton = new Builder(PicassoProvider.context).build();
这里使用到了常用的 Builder 设计模式。当一个类的属性过多,通过构造函数构造一个对象过于复杂时,可以选择使用 Builder 设计模式来简化对象的构造过程。
看下 Picasso 类中静态内部类 Builder 的构造函数:
public Builder(@NonNull Context context) {
if (context == null) {
throw new IllegalArgumentException("Context must not be null.");
}
this.context = context.getApplicationContext();
}
该构造函数确保传进来的 Context 实例不为 null,然后获取全局的 Application Context。
接着是 Picasso.Builder 类中的 build 方法:
private final Context context;
private Downloader downloader;
private ExecutorService service;
private Cache cache;
private Listener listener;
private RequestTransformer transformer;
private List<RequestHandler> requestHandlers;
private Bitmap.Config defaultBitmapConfig;
public Picasso build() {
Context context = this.context;
// 配置下载器 Downloader,用于从网络下载图片资源,默认为 OkHttp3Downloader
if (downloader == null) {
downloader = new OkHttp3Downloader(context);
}
// 配置缓存 Cache,用来保存最近查看使用的图片,默认为 LruCache
if (cache == null) {
cache = new LruCache(context);
}
// 配置 ExecutorService,默认为 PicassoExecutorService
// 后面 Bitmap 的获取任务就在该线程池中完成
if (service == null) {
service = new PicassoExecutorService();
}
// 配置 RequestTransformer 实例
if (transformer == null) {
transformer = RequestTransformer.IDENTITY;
}
// 创建 Stats 实例,Stats 类用来进行一些统计,如缓存命中数,图片下载数等
Stats stats = new Stats(cache);
// 创建 Dispatcher 实例,Dispatcher 类顾名思义,它的作用就是用来分发处理
// 各种图片操作事件的如提交图片请求事件,图片获取完成事件等;
// 传入前面配置好的对象和 HANDLER 实例给 Dispatcher 类构造函数
// 该 HANDLER 在主线程接收处理事件,后面获取到 Bitmap 后需要回调到
// 该 HANDLER 的 handleMessage 方法中以便将 Bitmap 切换回主线程显示
Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats);
// 传入前面配置好的一系列参数,创建 Picasso 实例
return new Picasso(context, dispatcher, cache, listener, transformer, requestHandlers, stats,
defaultBitmapConfig, indicatorsEnabled, loggingEnabled);
}
该方法的逻辑与相关类作用已在注释中进行了说明。
接下来看 Picasso 类的构造函数:
private final Listener listener;
private final RequestTransformer requestTransformer;
private final CleanupThread cleanupThread;
private final List<RequestHandler> requestHandlers;
final Context context;
final Dispatcher dispatcher;
final Cache cache;
final Stats stats;
final Map<Object, Action> targetToAction;
final Map<ImageView, DeferredRequestCreator> targetToDeferredRequestCreator;
final ReferenceQueue<Object> referenceQueue;
final Bitmap.Config defaultBitmapConfig;
boolean indicatorsEnabled;
volatile boolean loggingEnabled;
boolean shutdown;
Picasso(Context context, Dispatcher dispatcher, Cache cache, Listener listener, RequestTransformer requestTransformer, List<RequestHandler> extraRequestHandlers, Stats stats,Bitmap.Config defaultBitmapConfig, boolean indicatorsEnabled, boolean loggingEnabled) {
// 一些赋值操作
this.context = context;
this.dispatcher = dispatcher;
this.cache = cache;
this.listener = listener;
this.requestTransformer = requestTransformer;
this.defaultBitmapConfig = defaultBitmapConfig;
// Picasso 默认包含七个内置 RequestHandler 分别用来处理七种不同类型的请求
// 你也可以自己继承 RequestHandler 类来处理你的自定义请求
// 自定义请求放在 extraRequestHandlers 中
int builtInHandlers = 7;
int extraCount = (extraRequestHandlers != null ? extraRequestHandlers.size() : 0);
List<RequestHandler> allRequestHandlers = new ArrayList<>(builtInHandlers + extraCount);
// 添加 ResourceRequestHandler,用于处理加载图片资源 id 的情况
// ResourceRequestHandler 需要第一个进行添加
// 避免其他的 RequestHandler 检查 (request.resourceId != 0) 的情况
allRequestHandlers.add(new ResourceRequestHandler(context));
// 然后添加自定义的 RequestHandler (如果有的话)
if (extraRequestHandlers != null) {
allRequestHandlers.addAll(extraRequestHandlers);
}
// 添加 ContactsPhotoRequestHandler,用于处理手机联系人图片
allRequestHandlers.add(new ContactsPhotoRequestHandler(context));
// 添加 MediaStoreRequestHandler,用于处理 content://media/ 开头的 URI
allRequestHandlers.add(new MediaStoreRequestHandler(context));
// 添加 ContentStreamRequestHandler,用于处理 scheme 为 content 的 URI
allRequestHandlers.add(new ContentStreamRequestHandler(context));
// 添加 AssetRequestHandler,用于处理 file:///android_asset/ 开头的 URI
allRequestHandlers.add(new AssetRequestHandler(context));
// 添加 FileRequestHandler,用于处理 scheme 为 file 的 URI
allRequestHandlers.add(new FileRequestHandler(context));
// 添加 NetworkRequestHandler,用于处理 http 或 https 图片 url
allRequestHandlers.add(new NetworkRequestHandler(dispatcher.downloader, stats));
// 调用 Collections 的静态方法 unmodifiableList
// 返回一个不能进行修改操作的 List 实例,防止 requestHandlers 被修改
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 CleanupThread(referenceQueue, HANDLER);
this.cleanupThread.start();
}
到这里 Picasso 实例就创建完毕了。
2.3 Dispatcher 实例的创建
Picasso.Builder 类的 build 方法在创建 Picasso 实例前先创建了 Dispatcher 类的实例,Dispatcher 类对后面分发处理图片事件至关重要,这里先看一下它的构造函数:
final DispatcherThread dispatcherThread;
final Context context;
final ExecutorService service;
final Downloader downloader;
final Map<String, BitmapHunter> hunterMap;
final Map<Object, Action> failedActions;
final Map<Object, Action> pausedActions;
final Set<Object> pausedTags;
final Handler handler;
final Handler mainThreadHandler;
final Cache cache;
final Stats stats;
final List<BitmapHunter> batch;
final NetworkBroadcastReceiver receiver;
final boolean scansNetworkChanges;
boolean airplaneMode;
Dispatcher(Context context, ExecutorService service, Handler mainThreadHandler,
Downloader downloader, Cache cache, Stats stats) {
// 创建静态内部类 DispatcherThread 的实例并启动
this.dispatcherThread = new DispatcherThread();
this.dispatcherThread.start();
this.context = context;
this.service = service;
this.hunterMap = new LinkedHashMap<>();
this.failedActions = new WeakHashMap<>();
this.pausedActions = new WeakHashMap<>();
this.pausedTags = new LinkedHashSet<>();
// 创建静态内部类 DispatcherHandler 的实例
this.handler = new DispatcherHandler(dispatcherThread.getLooper(), this);
this.downloader = downloader;
// 保存前面 Picasso 类传进来的主线程 HANDLER
this.mainThreadHandler = mainThreadHandler;
this.cache = cache;
this.stats = stats;
this.batch = new ArrayList<>(4);
}
该构造函数首先创建了 DispatcherThread 实例,而后面 DispatcherHandler 实例的创建用到了 DispatcherThread 中的 Looper。
DispatcherThread 和 DispatcherHandler 都是 Dispatcher 中的静态内部类:
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;
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 HUNTER_COMPLETE: {
BitmapHunter hunter = (BitmapHunter) msg.obj;
dispatcher.performComplete(hunter);
break;
}
default:
Picasso.HANDLER.post(new Runnable() {
@Override public void run() {
throw new AssertionError("Unknown handler message received: " + msg.what);
}
});
}
}
}
可以看到,DispatcherThread 继承自 HandlerThread,而 DispatcherHandler 实例是通过 DispatcherThread 的 Looper 创建的,因此 DispatcherHandler 发送的消息将切换到工作线程 (即 DispatcherThread) 中处理,即 DispatcherHandler 的 handleMessage 方法会在工作线程中执行。
3. Picasso 类中的 load 方法
获取到 Picasso 实例后,紧接着调用 Picasso 类的 load 方法,该方法主要作用就是创建并返回一个 RequestCreator 实例。
RequestCreator 类的主要作用就是创建 Request 对象,并提供了一系列的 into 方法来开始图片请求。
先来看一下 Picasso 类中的 load 方法:
public RequestCreator load(@Nullable String path) {
// 如果传进来的 path 为 null,创建并返回一个
// Uri 为 null 的 RequestCreator 对象。
if (path == null) {
return new RequestCreator(this, null, 0);
}
// 如果 path 为空字符串,抛出异常。
if (path.trim().length() == 0) {
throw new IllegalArgumentException("Path must not be empty.");
}
return load(Uri.parse(path));
}
最后 path 不为 null 也不为空字符串,则调用 Uri.parse(path) 方法对 path 进行解析并返回 一个 Uri 对象传给 load(@Nullable Uri uri) 方法。
public RequestCreator load(@Nullable Uri uri) {
return new RequestCreator(this, uri, 0);
}
该方法创建并返回一个 RequestCreator 实例,看一下 RequestCreator 类的构造函数:
private final Picasso picasso;
private final Request.Builder data;
RequestCreator(Picasso picasso, Uri uri, int resourceId) {
this.picasso = picasso;
this.data = new Request.Builder(uri, resourceId, picasso.defaultBitmapConfig);
}
可以看到 RequestCreator 对象持有了 Picasso 的一份引用,然后创建了 Request.Builder 类的实例 data,这里又用到了 Builder 设计模式。
Request.Builder 的构造函数为:
Builder(Uri uri, int resourceId, Bitmap.Config bitmapConfig) {
this.uri = uri;
this.resourceId = resourceId;
this.config = bitmapConfig;
}
到这里 RequestCreator 就创建完成了,接下来就可以调用 RequestCreator 类中的许多方法,如 placeholder 方法,centerCrop 方法等,我们这里直接前往 into 方法。
4. RequestCreator 类的 into 方法
经过 load 方法后,紧接着就来到了 into 方法,该方法是整个 API 调用流程的最后一步,可以说是整个调用流程的重头戏,因此篇幅也比较大。
我们往 into 方法传的是 ImageView 实例,看一下该方法源码:
public void into(ImageView target) {
into(target, null);
}
public void into(ImageView target, Callback callback) {
// 记录开始处理的时间戳
long started = System.nanoTime();
// 检查当前方法是否在主线程进行调用,如果不是抛出异常
checkMain();
// ImageView 实例 target 不能为 null,否则抛异常
if (target == null) {
throw new IllegalArgumentException("Target must not be null.");
}
// data 即前面的 Request.Builder 实例
// 如果 data 中没有图片(例如传入的 path 为 null)
// 直接对该 target 取消请求,并设置占位图如果有设置 placeholder
if (!data.hasImage()) {
picasso.cancelRequest(target);
if (setPlaceholder) {
setPlaceholder(target, getPlaceholderDrawable());
}
return;
}
// 创建 Request 实例
Request request = createRequest(started);
// 为当前 Request 生成一个 requestKey,用来标记 Request
String requestKey = createKey(request);
// 如果当前的 memoryPolicy 允许从缓存中读取图片
// 从 Cache 中获取 requestKey 对应的 Bitmap,如果该 Bitmap 存在
// 则取消当前请求,直接为 target 设置该 Bitmap
if (shouldReadFromMemoryCache(memoryPolicy)) {
Bitmap bitmap = picasso.quickMemoryCacheCheck(requestKey);
if (bitmap != null) {
picasso.cancelRequest(target);
setBitmap(target, picasso.context, bitmap, MEMORY, noFade, picasso.indicatorsEnabled);
if (callback != null) {
callback.onSuccess();
}
return;
}
}
// 前面缓存中没有查找到图片,从这里开始请求
// 先设置 placeholder 如果有配置的话
if (setPlaceholder) {
setPlaceholder(target, getPlaceholderDrawable());
}
// 创建一个 ImageViewAction 的实例
Action action = new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId,
errorDrawable, requestKey, tag, callback, noFade);
// 向 picasso 提交该 Action 实例
picasso.enqueueAndSubmit(action);
}
这里省略了部分与 Picasso.get().load(uri).into(imageView)
调用不相关的代码,代码中的注释只是大致逻辑流程,接下来按 into 方法的代码逻辑对一些细节进行分析。
4.1 设置占位图 (placeholder) 的实现
从 into 方法中可以看到,有两处需要设置占位图,设置占位图的逻辑是:
if (setPlaceholder) {
setPlaceholder(target, getPlaceholderDrawable());
}
看一下 getPlaceholderDrawable 方法:
private Drawable getPlaceholderDrawable() {
if (placeholderResId != 0) {
if (Build.VERSION.SDK_INT >= 21) {
return picasso.context.getDrawable(placeholderResId);
} else if (Build.VERSION.SDK_INT >= 16) {
return picasso.context.getResources().getDrawable(placeholderResId);
} else {
TypedValue value = new TypedValue();
picasso.context.getResources().getValue(placeholderResId, value, true);
return picasso.context.getResources().getDrawable(value.resourceId);
}
} else {
return placeholderDrawable;
}
}
该方法根据当前运行的 Android SDK 版本进行不同的方法调用来通过 placeholderResId 获取到一个 Drawable 实例。
获取到占位图 Drawable 后接下来就可以进行设置了,setPlaceholder 方法为 PicassoDrawable 类中的静态方法,调用该方法后 ImageView 就可以显示占位图了。
static void setPlaceholder(ImageView target, Drawable placeholderDrawable) {
target.setImageDrawable(placeholderDrawable);
if (target.getDrawable() instanceof Animatable) {
((Animatable) target.getDrawable()).start();
}
}
4.2 Request 实例的创建
Request 对象是通过 createRequest 方法创建的:
private static final AtomicInteger nextId = new AtomicInteger();
private Request createRequest(long started) {
// 为 Request 实例分配下一个 id
int id = nextId.getAndIncrement();
// 创建 Request 实例
Request request = data.build();
request.id = id;
request.started = started;
return request;
}
Request 实例通过调用 Request.Builder 类的 build 方法创建:
public Request build() {
// 先验证当前的配置参数是否合法
// centerInside 和 centerCrop 方法不能同时用
if (centerInside && centerCrop) {
throw new IllegalStateException("Center crop and center inside can not be used together.");
}
// centerCrop 方法需要与 resize 方法同用
if (centerCrop && (targetWidth == 0 && targetHeight == 0)) {
throw new IllegalStateException(
"Center crop requires calling resize with positive width and height.");
}
// centerInside 方法需要与 resize 方法同用
if (centerInside && (targetWidth == 0 && targetHeight == 0)) {
throw new IllegalStateException(
"Center inside requires calling resize with positive width and height.");
}
// 设置 priority
if (priority == null) {
priority = Priority.NORMAL;
}
// 创建 Request 实例
return new Request(uri, resourceId, stableKey, transformations, targetWidth, targetHeight,
centerCrop, centerInside, centerCropGravity, onlyScaleDown, rotationDegrees,
rotationPivotX, rotationPivotY, hasRotationPivot, purgeable, config, priority);
}
该方法在最后一步创建了 Request 实例,看一下 Request 类的构造函数:
public final Uri uri;
public final int resourceId;
public final String stableKey;
public final List<Transformation> transformations;
public final int targetWidth;
public final int targetHeight;
public final boolean centerCrop;
public final int centerCropGravity;
public final boolean centerInside;
public final boolean onlyScaleDown;
public final float rotationDegrees;
public final float rotationPivotX;
public final float rotationPivotY;
public final boolean hasRotationPivot;
public final boolean purgeable;
public final Bitmap.Config config;
public final Priority priority;
private Request(Uri uri, int resourceId, String stableKey, List<Transformation> transformations,
int targetWidth, int targetHeight, boolean centerCrop, boolean centerInside,
int centerCropGravity, boolean onlyScaleDown, float rotationDegrees,
float rotationPivotX, float rotationPivotY, boolean hasRotationPivot,
boolean purgeable, Bitmap.Config config, Priority priority) {
// 图片的 Uri,与 resourceId 不能共存
this.uri = uri;
// 图片的 resourceId,与 Uri 不能共存
this.resourceId = resourceId;
this.stableKey = stableKey;
// 用来对 Bitmap 进行转换的一系列 Transformation
if (transformations == null) {
this.transformations = null;
} else {
this.transformations = unmodifiableList(transformations);
}
// resize 方法设置的图片宽度和高度
this.targetWidth = targetWidth;
this.targetHeight = targetHeight;
// 图片 scaleType 是否为 centerCrop,与 centerInside 不共存
this.centerCrop = centerCrop;
// 图片 scaleType 是否为 centerInside,与 centerCrop 不共存
this.centerInside = centerInside;
// 如果设置了 centerCrop,centerCropGravity 用来设置中心的偏移量
this.centerCropGravity = centerCropGravity;
this.onlyScaleDown = onlyScaleDown;
// 图片旋转的度数
this.rotationDegrees = rotationDegrees;
this.rotationPivotX = rotationPivotX;
this.rotationPivotY = rotationPivotY;
this.hasRotationPivot = hasRotationPivot;
this.purgeable = purgeable;
this.config = config;
// 当前请求的优先级
this.priority = priority;
}
Request 实例创建完毕。
4.3 requestKey 的创建
requestKey 用来标识一个 Request,requestKey 通过调用 createKey 方法实现:
static final StringBuilder MAIN_THREAD_KEY_BUILDER = new StringBuilder();
static String createKey(Request data) {
String result = createKey(data, MAIN_THREAD_KEY_BUILDER);
MAIN_THREAD_KEY_BUILDER.setLength(0);
return result;
}
static String createKey(Request data, StringBuilder builder) {
if (data.stableKey != null) {
builder.ensureCapacity(data.stableKey.length() + KEY_PADDING);
builder.append(data.stableKey);
} else if (data.uri != null) {
String path = data.uri.toString();
builder.ensureCapacity(path.length() + KEY_PADDING);
builder.append(path);
} else {
builder.ensureCapacity(KEY_PADDING);
builder.append(data.resourceId);
}
builder.append(KEY_SEPARATOR);
if (data.rotationDegrees != 0) {
builder.append("rotation:").append(data.rotationDegrees);
if (data.hasRotationPivot) {
builder.append('@').append(data.rotationPivotX).append('x').append(data.rotationPivotY);
}
builder.append(KEY_SEPARATOR);
}
if (data.hasSize()) {
builder.append("resize:").append(data.targetWidth).append('x').append(data.targetHeight);
builder.append(KEY_SEPARATOR);
}
if (data.centerCrop) {
builder.append("centerCrop:").append(data.centerCropGravity).append(KEY_SEPARATOR);
} else if (data.centerInside) {
builder.append("centerInside").append(KEY_SEPARATOR);
}
if (data.transformations != null) {
for (int i = 0, count = data.transformations.size(); i < count; i++) {
builder.append(data.transformations.get(i).key());
builder.append(KEY_SEPARATOR);
}
}
return builder.toString();
}
该方法根据当前 Request 配置的参数来生成对应的 requestKey。
4.4 MemoryPolicy 的实现
into 方法通过调用 shouldReadFromMemoryCache 方法来判断是否应该从 Cache 中读取当前 requestKey 对应的 Bitmap。
shouldReadFromMemoryCache 方法是枚举类型 MemoryPolicy 中的一个静态方法,MemoryPolicy 源码如下:
public enum MemoryPolicy {
NO_CACHE(1 << 0),
NO_STORE(1 << 1);
static boolean shouldReadFromMemoryCache(int memoryPolicy) {
return (memoryPolicy & MemoryPolicy.NO_CACHE.index) == 0;
}
static boolean shouldWriteToMemoryCache(int memoryPolicy) {
return (memoryPolicy & MemoryPolicy.NO_STORE.index) == 0;
}
final int index;
MemoryPolicy(int index) {
this.index = index;
}
}
可以看到 MemoryPolicy 用到了一些位操作。
MemoryPolicy 共两种枚举类型,NO_CACHE 和 NO_STORE,NO_CACHE 的 index 为 1 (二进制为 1),NO_STORE 的 index 为 2 (二进制为 10)。
shouldReadFromMemoryCache 方法返回 true 如果 (memoryPolicy & MemoryPolicy.NO_CACHE.index) == 0
,即 memoryPolicy 为 0 。返回 true 表示当前 memoryPolicy 允许从 Cache 中读取图片。
shouldWriteToMemoryCache 方法在满足 (memoryPolicy & MemoryPolicy.NO_STORE.index) == 0
的条件下返回 true,即 memoryPolicy 为 0。返回 true 表示当前 memoryPolicy 允许向 Cache 中写入图片。
而在没有配置 memoryPolicy 的情况下,memoryPolicy 默认为 0,因此这两个方法这里都会返回 true。
4.5 Action 实例的创建
Picasso 将一次图片获取活动封装成一个 Action 实例。
Action 为抽象类,包含两个必须实现的抽象方法,complete 方法和 error 方法,分别表示该次图片获取活动完成或出错。
abstract void complete(Bitmap result, Picasso.LoadedFrom from);
abstract void error(Exception e);
Picasso 提供了不同的 Action 子类来对应不同的图片获取活动。
我们这里用到的是 ImageViewAction,ImageViewAction 用于将获取到的 Bitmap 加载到 ImageView 中:
class ImageViewAction extends Action<ImageView> {
Callback callback;
ImageViewAction(Picasso picasso, ImageView imageView, Request data, int memoryPolicy,
int networkPolicy, int errorResId, Drawable errorDrawable, String key, Object tag,
Callback callback, boolean noFade) {
super(picasso, imageView, data, memoryPolicy, networkPolicy, errorResId, errorDrawable, key,
tag, noFade);
this.callback = callback;
}
@Override public void complete(Bitmap result, Picasso.LoadedFrom from) {
// 获取要加载图片进去的 ImageView
ImageView target = this.target.get();
if (target == null) return;
Context context = picasso.context;
boolean indicatorsEnabled = picasso.indicatorsEnabled;
// 为 target 设置 Bitmap
PicassoDrawable.setBitmap(target, context, result, from, noFade, indicatorsEnabled);
// 回调 callback
if (callback != null) callback.onSuccess();
}
@Override public void error(Exception e) {
ImageView target = this.target.get();
if (target == null) return;
// 获取占位图 Drawable 实例,如果该 Drawable 实现了 Animatable 接口
// 这时候就应该停止该 Animatable
Drawable placeholder = target.getDrawable();
if (placeholder instanceof Animatable) ((Animatable) placeholder).stop();
// 设置错误情况下的图片
if (errorResId != 0) {
target.setImageResource(errorResId);
} else if (errorDrawable != null) {
target.setImageDrawable(errorDrawable);
}
if (callback != null) callback.onError(e);
}
@Override void cancel() {
super.cancel();
if (callback != null) callback = null;
}
}
可以看到 ImageViewAction 类继承自 Action,泛型参数为 ImageView 作为该 Action 的 target。
ImageViewAction 实现了 complete 方法和 error 方法并重写了 cancel 方法。
4.6 Action 实例的提交
Action 实例创建完毕后,就可以调用 Picasso 类中的 enqueueAndSubmit 方法提交该 Action 实例了,然后从这里开始一次图片获取活动,由于这部分代码过于庞大,从 enqueueAndSubmit 方法开始放在下一节分析。
5. Picasso 处理 Action 的实现
Picasso 处理 Action 从 Picasso 类的 enqueueAndSubmit 方法开始:
void enqueueAndSubmit(Action action) {
// 省略部分代码...
// 调用 submit 方法提交该 Action
submit(action);
}
void submit(Action action) {
dispatcher.dispatchSubmit(action);
}
submit 方法又调用了 Dispatcher 类的 dispatchSubmit 方法,Picasso 类这时候就将此 Action 交接给 Dispatcher 类进行处理。
5.1 Dispatcher 类提交 Action 的实现
Picasso 通过调用 Dispatcher 类的 dispatchSubmit 方法开始提交该 Action 实例:
void dispatchSubmit(Action action) {
handler.sendMessage(handler.obtainMessage(REQUEST_SUBMIT, action));
}
该方法使用 handler 发送了一条 REQUEST_SUBMIT 信息,我们在 2.3 小节中可以看到,该 handler 即 DispatcherHandler 实例,发送该消息后会在工作线程回调到 DispatcherHandler 中的 handleMessage 方法,然后从该方法接着会调用 Dispatcher 类的 performSubmit 方法:
void performSubmit(Action action) {
performSubmit(action, true);
}
void performSubmit(Action action, boolean dismissFailed) {
// 创建 BitmapHunter 实例
BitmapHunter hunter = forRequest(action.getPicasso(), this, cache, stats, action);
// 使用配置好的 PicassoExecutorService 提交该 BitmapHunter 实例
hunter.future = service.submit(hunter);
}
上面的代码做了一些简化,删除了与当前逻辑无关的代码。
该方法通过调用 forRequest 方法来创建 BitmapHunter 实例,而 forRequest 方法是 BitmapHunter 类中的静态方法。
从上面的代码可以看到,接下来的工作就交给 BitmapHunter 来完成了。
5.2 BitmapHunter 类的实现
BitmapHunter 类的主要职责是结合 Action 和 RequestHandler 来获取 Bitmap 实例。
BitmapHunter 提供了静态方法 forRequest 来创建实例:
static BitmapHunter forRequest(Picasso picasso, Dispatcher dispatcher, Cache cache, Stats stats,
Action action) {
// 获取 Action 中的 Request 对象
Request request = action.getRequest();
// 获取 Picasso 配置的全部 RequestHandler
List<RequestHandler> requestHandlers = picasso.getRequestHandlers();
// 从下标 0 开始迭代全部 RequestHandler,如果该 RequestHandler 能
// 处理该 Request,则用该 RequestHandler 创建 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);
}
}
// 没有 RequestHandler 能处理该 Request,传入 ERRORING_HANDLER
return new BitmapHunter(picasso, dispatcher, cache, stats, action, ERRORING_HANDLER);
}
这里的 requestHandlers 部分用到了责任链模式 (Chains of Responsibility)。
接着看下 BitmapHunter 的构造函数:
final int sequence;
final Picasso picasso;
final Dispatcher dispatcher;
final Cache cache;
final Stats stats;
final String key;
final Request data;
final int memoryPolicy;
int networkPolicy;
final RequestHandler requestHandler;
Action action;
List<Action> actions;
Bitmap result;
Future<?> future;
Picasso.LoadedFrom loadedFrom;
Exception exception;
int exifOrientation;
int retryCount;
Priority priority;
BitmapHunter(Picasso picasso, Dispatcher dispatcher, Cache cache, Stats stats, Action action,
RequestHandler requestHandler) {
this.sequence = SEQUENCE_GENERATOR.incrementAndGet();
this.picasso = picasso;
this.dispatcher = dispatcher;
this.cache = cache;
this.stats = stats;
this.action = action;
this.key = action.getKey();
this.data = action.getRequest();
this.priority = action.getPriority();
this.memoryPolicy = action.getMemoryPolicy();
this.networkPolicy = action.getNetworkPolicy();
this.requestHandler = requestHandler;
this.retryCount = requestHandler.getRetryCount();
}
BitmapHunter 类实现了 Runnable 接口,因此当前面调用 service.submit(hunter) ,BitmapHunter 类中的 run 方法会在线程池中运行:
@Override public void run() {
try {
result = hunt();
if (result == null) {
dispatcher.dispatchFailed(this);
} else {
dispatcher.dispatchComplete(this);
}
} catch (Exception e) {
// 处理一堆异常...
}
}
run 方法主要通过调用 hunt 方法获取返回的 Bitmap 并赋值给 result,如果 result 不为 null,则调用 Dispatcher 类的 dispatchComplete 方法,否则调用 dispatchFailed 方法。
因此获取 Bitmap 的具体逻辑就在 hunt 方法中完成:
Bitmap hunt() throws IOException {
Bitmap bitmap = null;
// 先从缓存中查找 key 对应的 Bitmap,该 key 即之前创建的 requestKey
if (shouldReadFromMemoryCache(memoryPolicy)) {
bitmap = cache.get(key);
if (bitmap != null) {
stats.dispatchCacheHit();
loadedFrom = MEMORY;
return bitmap;
}
}
// 调用 RequestHandler 的 load 方法获取 RequestHandler.Result 实例
// Picasso 将 RequestHandler 加载的结果封装成一个 Result 对象
// 我们这里调用的是 NetworkRequestHandler 类中的 load 方法
RequestHandler.Result result = requestHandler.load(data, networkPolicy);
if (result != null) {
loadedFrom = result.getLoadedFrom();
exifOrientation = result.getExifOrientation();
bitmap = result.getBitmap();
// result 中的 bitmap 为 null,将 source 中的字节流编码成 Bitmap
if (bitmap == null) {
Source source = result.getSource();
try {
bitmap = decodeStream(source, data);
} finally {
try {
source.close();
} catch (IOException ignored) {
}
}
}
}
return bitmap;
}
hunt 方法结束,返回获取到的 Bitmap 实例,回到 BitmapHunter 的 run 方法,这时候如果返回的 Bitmap 实例不为null,就调用 Dispatcher 类中的 dispatchComplete 方法,这样剩下的工作又交接给了 Dispatcher。
5.3 Dispatcher 类请求完成的实现
BitmapHunter 获取到不为 null 的 Bitmap 实例后,调用 Dispatcher 类中的 dispatchComplete 方法分发其完成事件:
void dispatchComplete(BitmapHunter hunter) {
handler.sendMessage(handler.obtainMessage(HUNTER_COMPLETE, hunter));
}
handler 发送该消息后,接着又在工作线程中回调到了 Dispatcher 类的 performComplete 方法:
void performComplete(BitmapHunter hunter) {
if (shouldWriteToMemoryCache(hunter.getMemoryPolicy())) {
cache.set(hunter.getKey(), hunter.getResult());
}
batch(hunter);
}
这时候 Picasso 将 Bitmap 存入到了缓存中,然后调用 batch 方法:
private void batch(BitmapHunter hunter) {
if (hunter.isCancelled()) {
return;
}
if (hunter.result != null) {
hunter.result.prepareToDraw();
}
batch.add(hunter);
if (!handler.hasMessages(HUNTER_DELAY_NEXT_BATCH)) {
handler.sendEmptyMessageDelayed(HUNTER_DELAY_NEXT_BATCH, BATCH_DELAY);
}
}
handler 最后发送了 HUNTER_DELAY_NEXT_BATCH 消息,发送该消息后又回调到了 Dispatcher 类的 performBatchComplete 方法:
void performBatchComplete() {
batch.clear(); mainThreadHandler.sendMessage(mainThreadHandler.obtainMessage(HUNTER_BATCH_COMPLETE, copy));
}
这时候发送消息的是 mainThreadHandler,切换到主线程来了,发送的消息为 HUNTER_BATCH_COMPLETE,该消息回调到了 Picasso 类中的 HANDLER 实例中:
static final Handler HANDLER = new Handler(Looper.getMainLooper()) {
@Override public void handleMessage(Message msg) {
switch (msg.what) {
case HUNTER_BATCH_COMPLETE: {
List<BitmapHunter> batch = (List<BitmapHunter>) msg.obj;
for (int i = 0, n = batch.size(); i < n; i++) {
BitmapHunter hunter = batch.get(i);
hunter.picasso.complete(hunter);
}
break;
}
default:
throw new AssertionError("Unknown handler message received: " + msg.what);
}
}
};
对每个 BitmapHunter 实例调用 Picasso 类中的 complete 方法:
void complete(BitmapHunter hunter) {
Action single = hunter.getAction();
if (single == null) return;
Uri uri = hunter.getData().uri;
Exception exception = hunter.getException();
Bitmap result = hunter.getResult();
LoadedFrom from = hunter.getLoadedFrom();
deliverAction(result, from, single, exception);
if (listener != null && exception != null) {
listener.onImageLoadFailed(this, uri, exception);
}
}
private void deliverAction(Bitmap result, LoadedFrom from, Action action, Exception e) {
if (action.isCancelled()) {
return;
}
if (result != null) {
if (from == null) {
throw new AssertionError("LoadedFrom cannot be null.");
}
action.complete(result, from);
}
} else {
action.error(e);
}
}
我们之前提交的是 ImageViewAction 实例,因此这时候会回调到 ImageViewAction 类的 complete 方法:
@Override public void complete(Bitmap result, Picasso.LoadedFrom from) {
ImageView target = this.target.get();
if (target == null) return;
Context context = picasso.context;
boolean indicatorsEnabled = picasso.indicatorsEnabled;
PicassoDrawable.setBitmap(target, context, result, from, noFade, indicatorsEnabled);
if (callback != null) {
callback.onSuccess();
}
}
最后 setBitmap:
static void setBitmap(ImageView target, Context context, Bitmap bitmap,
Picasso.LoadedFrom loadedFrom, boolean noFade, boolean debugging) {
Drawable placeholder = target.getDrawable();
if (placeholder instanceof Animatable) {
((Animatable) placeholder).stop();
}
PicassoDrawable drawable =
new PicassoDrawable(context, bitmap, placeholder, loadedFrom, noFade, debugging);
target.setImageDrawable(drawable);
}
结束该方法后,这时候图片终于成功在界面显示了,整个调用流程到此也终于结束。
6. 参考
- Picasso: A powerful image downloading and caching library for Android
- 如何正确地写出单例模式
- ContentProvider | Android Developers
最后
如果你看到了这里,觉得文章写得不错就给个赞呗?如果你觉得那里值得改进的,请给我留言。一定会认真查询,修正不足。谢谢。
希望读到这的您能转发分享和关注一下我,以后还会更新技术干货,谢谢您的支持!
转发+点赞+关注,第一时间获取最新知识点
Android架构师之路很漫长,一起共勉吧!
——————分割线——————
简书点赞可以有好几种赞,长按点赞按钮就会有选项,大家点赞的时候,麻烦点个超赞,让我感受下这个功能……
网友评论