在Picasso图片加载框架 —— 源码解析（一）中，我们从头到尾梳理了一遍Picasso网络加载图片的过程，但对于其中很多细节并没有展开介绍。本篇将深入细节，以实际情景为出发点，带领大家看看Picasso中丰富的图片功能及其代码实现，进而学习下Picasso框架的设计思想。
一、在不同目标View上显示图片
在实际开发中，我们不一定每次都用ImageView来显示下载的图片。有些时候，我们需要把图片显示到自定义View或RemoteViews上。要想实现这点，一个最朴素的想法就是先获取图片，然后在调用自定义View或RemoteViews的API。想法虽糙，但很实用。Picasso框架也是这么处理的，只不过作为一个图片加载框架，它对这一过程又做了进一步的抽象。
仔细看RequestCreator类的源码，我们可以发现，into()方法共有五种重载：
1）into(ImageView)和into(ImageView, Callback)用于ImageView；
2）into(RemoteViews, int, int, Notification)用于状态栏通知；
3）into(RemoteViews, int, int[])用于桌面小部件；
4）into(Target)用于继承Target接口的类。
1.into(RemoteViews, int, int, Notification)
/**
* 异步方法
*/
public void into(RemoteViews remoteViews, int viewId, int notificationId,
Notification notification) {
long started = System.nanoTime();
if (remoteViews == null) {
throw new IllegalArgumentException("RemoteViews must not be null.");
}
if (notification == null) {
throw new IllegalArgumentException("Notification must not be null.");
}
//不支持图片变换
if (deferred) {
throw new IllegalStateException("Fit cannot be used with RemoteViews.");
}
if (placeholderDrawable != null || placeholderResId != 0 || errorDrawable != null) {
throw new IllegalArgumentException(
"Cannot use placeholder or error drawables with remote views.");
}
//创建真实请求
Request request = createRequest(started);
String key = createKey(request, new StringBuilder());
//处理Notification图片加载的action
RemoteViewsAction action =
new NotificationAction(picasso, request, remoteViews, viewId, notificationId, notification,
memoryPolicy, networkPolicy, key, tag, errorResId);
performRemoteViewInto(action);
}
private void performRemoteViewInto(RemoteViewsAction action) {
//是否从缓存获取图片
if (shouldReadFromMemoryCache(memoryPolicy)) {
Bitmap bitmap = picasso.quickMemoryCacheCheck(action.getKey());
if (bitmap != null) {
action.complete(bitmap, MEMORY);
return;
}
}
if (placeholderResId != 0) {
action.setImageResource(placeholderResId);
}
//入队并提交
picasso.enqueueAndSubmit(action);
}
与ImageView的into()方法类似，创建Request和Action，并调用Picasso.enqueueAndSubmit()入队和提交，后续过程和ImageView的流程一样，就不在此赘述了，不清楚的小伙伴可以去看Picasso图片加载框架 —— 源码解析（一）。
值得注意的一点是，该into()方法并没有做主线程检查，即不强制要求由主线程进行调用。但我们记得，在Picasso.enqueueAndSubmit()中有一个cancelExistingRequest()的动作，该动作会做主线程检查。那么，如果从非主线程调用into()方法，不就直接抛出异常了嘛，感觉像是源码的bug......
在获取到图片后，会回调Action.complete()方法，此处就是回调NotificationAction.complete()方法。
abstract class RemoteViewsAction extends Action<RemoteViewsAction.RemoteViewsTarget> {
@Override
void complete(Bitmap result, Picasso.LoadedFrom from) {
//为remoteViews设置图片
remoteViews.setImageViewBitmap(viewId, result);
update();
}
abstract void update();
static class NotificationAction extends RemoteViewsAction {
@Override
void update() {
//刷新Notification
NotificationManager manager = getService(picasso.context, NOTIFICATION_SERVICE);
manager.notify(notificationId, notification);
}
}
}
从源码可以看到，NotificationAction是RemoteViewsAction的子类，并且没有重写RemoteViewsAction的complete()方法。这里是通过在RemoteViewsAction.complete()方法中提供抽象的update()方法实现了Notification自身的特殊需求。这样做的好处显而易见：将共性的RemoteViews图片设置工作放在基类中予以实现，而子类只需关注自身的特殊逻辑即可。这一点将会在接下来的into(RemoteViews, int, int[])方法中得到进一步的实践。
2.into(RemoteViews, int, int[])
/**
* 异步方法
*/
public void into(RemoteViews remoteViews, int viewId, int[] appWidgetIds) {
long started = System.nanoTime();
if (remoteViews == null) {
throw new IllegalArgumentException("remoteViews must not be null.");
}
if (appWidgetIds == null) {
throw new IllegalArgumentException("appWidgetIds must not be null.");
}
if (deferred) {
throw new IllegalStateException("Fit cannot be used with remote views.");
}
if (placeholderDrawable != null || placeholderResId != 0 || errorDrawable != null) {
throw new IllegalArgumentException(
"Cannot use placeholder or error drawables with remote views.");
}
Request request = createRequest(started);
String key = createKey(request, new StringBuilder()); // Non-main thread needs own builder.
RemoteViewsAction action =
new AppWidgetAction(picasso, request, remoteViews, viewId, appWidgetIds, memoryPolicy,
networkPolicy, key, tag, errorResId);
performRemoteViewInto(action);
}
与Notification的into()方法十分相似，主要不同是Action对象不一样，这里的Action是AppWidgetAction，并且这个AppWidgetAction也是RemoteViewsAction的子类。
abstract class RemoteViewsAction extends Action<RemoteViewsAction.RemoteViewsTarget> {
static class AppWidgetAction extends RemoteViewsAction {
@Override
void update() {
AppWidgetManager manager = AppWidgetManager.getInstance(picasso.context);
manager.updateAppWidget(appWidgetIds, remoteViews);
}
}
}
AppWidgetAction与NotificationAction如出一辙，基类为RemoteViews更新图片，子类实现自身逻辑。
3.into(Target)
接下来，我们来看into()的最后一个重载：into(Target)。从方法参数就可以看出，这个重载与之前两个明显不同，这里不是对RemoteViews进行设置，而是在处理Target，那这个Target是什么呢？
public interface Target {
/**
* 在图片获取成功时触发
* 注意：不能在此方法中回收Bitmap，否则会抛异常
*/
void onBitmapLoaded(Bitmap bitmap, LoadedFrom from);
/**
* 在图片获取失败时触发
*/
void onBitmapFailed(Drawable errorDrawable);
/**
* 在图片请求提交之前触发
*/
void onPrepareLoad(Drawable placeHolderDrawable);
}
Target是Picasso框架提供的接口，任何实现了该接口的类都会在图片获取成功、图片获取失败和提交图片请求之前收到相应的方法回调，进而可以在回调中完成图片处理逻辑。接下来，我们看看into(Target)的实现。
/**
* 异步方法
*/
public void into(Target target) {
long started = System.nanoTime();
//主线程检查
checkMain();
if (target == null) {
throw new IllegalArgumentException("Target must not be null.");
}
if (deferred) {
throw new IllegalStateException("Fit cannot be used with a Target.");
}
//若请求中没有设置uri和resourceId，则视其为无效请求，取消这次request，并回调target.onPrepareLoad()
if (!data.hasImage()) {
picasso.cancelRequest(target);
target.onPrepareLoad(setPlaceholder ? getPlaceholderDrawable() : null);
return;
}
Request request = createRequest(started);
String requestKey = createKey(request);
if (shouldReadFromMemoryCache(memoryPolicy)) {
Bitmap bitmap = picasso.quickMemoryCacheCheck(requestKey);
//若从cache中获取到了图片，则回调target.onBitmapLoaded()
if (bitmap != null) {
picasso.cancelRequest(target);
target.onBitmapLoaded(bitmap, MEMORY);
return;
}
}
//在提交请求之前，回调target.onPrepareLoad()
target.onPrepareLoad(setPlaceholder ? getPlaceholderDrawable() : null);
Action action =
new TargetAction(picasso, target, request, memoryPolicy, networkPolicy, errorDrawable,
requestKey, tag, errorResId);
picasso.enqueueAndSubmit(action);
}
主线程检查 ---> request有效性检查 ---> 从cache获取图片 ---> 创建TargetAction并提交入列。整体流程没有太大变化，只是在相应位置增加了Target的回调。同样的，我们继续看TargetAction的实现。
final class TargetAction extends Action<Target> {
@Override
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 target = getTarget();
if (target != null) {
target.onBitmapLoaded(result, from);
if (result.isRecycled()) {
throw new IllegalStateException("Target callback must not recycle bitmap!");
}
}
}
@Override
void error() {
Target target = getTarget();
if (target != null) {
if (errorResId != 0) {
target.onBitmapFailed(picasso.context.getResources().getDrawable(errorResId));
} else {
target.onBitmapFailed(errorDrawable);
}
}
}
}
当获取图片成功后，TargetAction.complete()会取出Target对象，回调Target.onBitmapLoaded()方法，并且还会对Bitmap的状态进行检查。若Bitmap已被回收掉，则抛出IllegalStateException异常。当获取图片失败时，TargetAction.error()则会回调Target.onBitmapFailed()方法。
看完into(Target)方法的源码，那么into(Target)具体要怎么使用呢？请看源码中的例子：
//在自定义View中使用Target接口
public class ProfileView extends FrameLayout implements Target {
@Override
public void onBitmapLoaded(Bitmap bitmap, LoadedFrom from) {
setBackgroundDrawable(new BitmapDrawable(bitmap));
}
@Override
public void onBitmapFailed() {
setBackgroundResource(R.drawable.profile_error);
}
@Override
public void onPrepareLoad(Drawable placeHolderDrawable) {
setBackgroundDrawable(placeHolderDrawable);
}
}
//在其他类中使用Target接口
public class ViewHolder implements Target {
public FrameLayout frame;
@Override
public void onBitmapLoaded(Bitmap bitmap, LoadedFrom from) {
frame.setBackgroundDrawable(new BitmapDrawable(bitmap));
}
@Override
public void onBitmapFailed() {
frame.setBackgroundResource(R.drawable.profile_error);
}
@Override
public void onPrepareLoad(Drawable placeHolderDrawable) {
frame.setBackgroundDrawable(placeHolderDrawable);
}
}
Target就是Picasso暴露给外部的接口，任何想要图片的地方，都需要继承Target接口，并在相应的回调中处理图片。至于图片是如何被下载的，我们无需关心，Picasso框架会自动帮我们搞定。
使用Target接口时有一点需要格外注意：在Picasso.enqueueAndSubmit()方法中，Target对象会被存储到WeakHashMap中，因此继承Target接口的类最好也重写下equals()和hashCode()方法。
二、直接获取图片
既然into()方法可以将图片显示到指定View上，那么是不是也有个方法可以让开发者直接拿到图片，然后自己决定如何使用呢？当然有的，Picasso框架提供了RequestCreator.get()方法，该方法可以返回一个Bitmap供开发者使用。
public class RequestCreator {
/**
* 同步方法，不能在主线程调用
*/
public Bitmap get() throws IOException {
long started = System.nanoTime();
//线程检查。如果是主线程调用，则会抛IllegalStateException
checkNotMain();
if (deferred) {
throw new IllegalStateException("Fit cannot be used with get.");
}
if (!data.hasImage()) {
return null;
}
Request finalData = createRequest(started);
String key = createKey(finalData, new StringBuilder());
//创建Action
Action action = new GetAction(picasso, finalData, memoryPolicy, networkPolicy, tag, key);
//创建BitmapHunter，并调用BitmapHunter.hunt()方法获取图片
return forRequest(picasso, picasso.dispatcher, picasso.cache, picasso.stats, action).hunt();
}
}
//空实现
class GetAction extends Action<Void> {
GetAction(Picasso picasso, Request data, int memoryPolicy, int networkPolicy, Object tag,
String key) {
super(picasso, null, data, memoryPolicy, networkPolicy, 0, null, key, tag, false);
}
@Override void complete(Bitmap result, Picasso.LoadedFrom from) {
}
@Override public void error() {
}
}
get()方法不同于into()方法将Action提交并入队，而是直接通过BitmapHunter.forRequest()创建BitmapHunter对象，并调用BitmapHunter.hunt()直接从外部资源(网络、磁盘等)获取图片并返回结果。由于GetAction全程没有参与其中，源码中也是给予了空实现。
基于上述代码和分析，可以看出：
1）get()为同步方法，其直接调用了BitmapHunter.hunt()从外部资源获取图片，属于耗时操作，因此不能从主线程调用；
2）get()方法直接将获取到的图片返回，并没有将其保存到cache中。因此，即使多次用get()方法获取相同的图片，每次调用还是都会从外部资源获取一遍，没办法享受cache的好处。
三、预加载
预加载，顾名思义就是提前从网络或磁盘将图片加载至内存中，然后在需要的时候直接从内存中获取图片。这样便可将图片加载的耗时过程隐藏起来，避免了用户长时间的等待，可大大提升用户体验。Picasso框架通过RequestCreator.fetch()方法提供对预加载的支持，废话不多说，直接上源码。
public class RequestCreator {
/**
* 异步方法
*/
public void fetch() {
fetch(null);
}
/**
* 异步方法
*/
public void fetch(Callback callback) {
long started = System.nanoTime();
if (deferred) {
throw new IllegalStateException("Fit cannot be used with fetch.");
}
//检查请求有效性
if (data.hasImage()) {
//fetch操作默认为低优先级
if (!data.hasPriority()) {
data.priority(Priority.LOW);
}
Request request = createRequest(started);
String key = createKey(request, new StringBuilder());
Bitmap bitmap = picasso.quickMemoryCacheCheck(key);
if (bitmap != null) { //如果从cache中找到图片，则回调callback.onSuccess()
if (picasso.loggingEnabled) {
log(OWNER_MAIN, VERB_COMPLETED, request.plainId(), "from " + MEMORY);
}
if (callback != null) {
callback.onSuccess();
}
} else { //如果cache没有目标图片，则创建Action并提交
Action action =
new FetchAction(picasso, request, memoryPolicy, networkPolicy, tag, key, callback);
picasso.submit(action);
}
}
}
}
public class Picasso {
void submit(Action action) {
dispatcher.dispatchSubmit(action);
}
}
是不是很眼熟，其实fetch()和into()的实现很相似，都是异步方法，创建Action并提交给线程池处理。根据前面的分析，在Picasso获取到图片后会回调到FetchAction.complete()方法，那我们直接看FetchAction.complete()。
class FetchAction extends Action<Object> {
@Override
void complete(Bitmap result, Picasso.LoadedFrom from) {
if (callback != null) {
callback.onSuccess();
}
}
}
咦，FetchAction.complete()好像也没做什么，只是回调了Callback的onSuccess()方法，如果Callback为null，那fetch()岂不白做了？并且有无Callback和这预加载又有什么关系呢？
非也非也，其实fetch()方法的核心步骤隐藏在Dispatcher.performComplete()方法中。我们在Picasso图片加载框架 —— 源码解析（一）的7. 分发Response中讲过，当图片获取成功后，会调用Dispatcher.dispatchComplete()进行分发，进而调用Dispatcher.performComplete()。在Dispatcher.performComplete()中有一个将图片保存到cache的过程，这便是我们要找到预加载代码。
void performComplete(BitmapHunter hunter) {
//是否将目标图片缓存起来
if (shouldWriteToMemoryCache(hunter.getMemoryPolicy())) {
cache.set(hunter.getKey(), hunter.getResult());
}
//省略其他代码
}
而Dispatcher持有的这个cache对象便是Picasso中的cache对象。一旦fetch()方法将图片保存到cache中，那么以后再调用Picasso.quickMemoryCacheCheck()的时候，就可以轻松从cache中找目标图片，无需再走网络请求。
public class Picasso {
public static class Builder {
public Picasso build() {
//省略其他代码
//Dispatcher持有的cache对象，便是Picasso中的cache对象
Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats);
//省略其他代码
}
}
//任何从cache获取图片的地方，都会走到quickMemoryCacheCheck()方法
Bitmap quickMemoryCacheCheck(String key) {
Bitmap cached = cache.get(key);
if (cached != null) {
stats.dispatchCacheHit();
} else {
stats.dispatchCacheMiss();
}
return cached;
}
}
另外多提一点，fetch()方法没有做主线程检查，没有调Picasso.enqueueAndSubmit()，也没有做任何UI相关的工作，因此可以大胆从子线程调用。
四、图片变换
图片变换是Android里一个老生常谈的话题，图片的缩放、裁剪和旋转等都可以视为图片变换。Picasso框架对图片变换提供了强大的支持，根据使用方式，本文将其分为基本图片变换和自定义图片变换。
1.基本图片变换
基本图片变换即Picasso内置的图片变换API，无需用户继承或实现，只需简单调用即可，主要包括：
1）RequestCreator.resize()/RequestCreator.resizeDimen()：改变图片尺寸
2）RequestCreator.rotate()：图片旋转
3）RequestCreator.centerCrop()/RequestCreator.centerInside()：图片裁剪
public class RequestCreator {
//data为真实请求
private final Request.Builder data;
//targetWidthResId和targetHeightResId为资源Id
public RequestCreator resizeDimen(int targetWidthResId, int targetHeightResId) {
Resources resources = picasso.context.getResources();
//转换为以像素为单位的值
int targetWidth = resources.getDimensionPixelSize(targetWidthResId);
int targetHeight = resources.getDimensionPixelSize(targetHeightResId);
return resize(targetWidth, targetHeight);
}
//targetWidth和targetHeight的单位是像素
public RequestCreator resize(int targetWidth, int targetHeight) {
data.resize(targetWidth, targetHeight);
return this;
}
//degrees的单位是角度
public RequestCreator rotate(float degrees) {
data.rotate(degrees);
return this;
}
//pivotX和pivotX为旋转中心点
public RequestCreator rotate(float degrees, float pivotX, float pivotY) {
data.rotate(degrees, pivotX, pivotY);
return this;
}
//按比例裁减，使图片居中显示，需配合resize()使用
public RequestCreator centerCrop() {
data.centerCrop();
return this;
}
//按比例裁减，使图片完全显示，需配合resize()使用
public RequestCreator centerInside() {
data.centerInside();
return this;
}
}
public final class Request {
public static final class Builder {
public Builder resize(int targetWidth, int targetHeight) {
if (targetWidth < 0) {
throw new IllegalArgumentException("Width must be positive number or 0.");
}
if (targetHeight < 0) {
throw new IllegalArgumentException("Height must be positive number or 0.");
}
if (targetHeight == 0 && targetWidth == 0) {
throw new IllegalArgumentException("At least one dimension has to be positive number.");
}
this.targetWidth = targetWidth;
this.targetHeight = targetHeight;
return this;
}
public Builder rotate(float degrees) {
rotationDegrees = degrees;
return this;
}
public Builder rotate(float degrees, float pivotX, float pivotY) {
rotationDegrees = degrees;
rotationPivotX = pivotX;
rotationPivotY = pivotY;
hasRotationPivot = true;
return this;
}
//与centerInside为互斥操作
public Builder centerCrop() {
if (centerInside) {
throw new IllegalStateException("Center crop can not be used after calling centerInside");
}
centerCrop = true;
return this;
}
//与centerCrop为互斥操作
public Builder centerInside() {
if (centerCrop) {
throw new IllegalStateException("Center inside can not be used after calling centerCrop");
}
centerInside = true;
return this;
}
}
}
从源码可以看到，上述API只是对Request中相关变量进行赋值，没有做实际的图片变换工作。而真正进行图片变换的时机是在BitmapHunter获取到图片后，Dispatcher分发图片前，即BitmapHunter.hunt()方法中。
class BitmapHunter implements Runnable {
//运行在子线程中
Bitmap hunt() throws IOException {
//省略部分代码
RequestHandler.Result result = requestHandler.load(data, networkPolicy);
if (result != null) {
//省略部分代码
exifRotation = result.getExifOrientation();
bitmap = result.getBitmap();
}
//省略部分代码
//重点
if (bitmap != null) {
//检查是否需要对图片进行变换
if (data.needsTransformation() || exifRotation != 0) {
synchronized (DECODE_LOCK) {
//基本图片变换
if (data.needsMatrixTransform() || exifRotation != 0) {
//在transformResult()方法中对图片进行变换
bitmap = transformResult(data, bitmap, exifRotation);
if (picasso.loggingEnabled) {
log(OWNER_HUNTER, VERB_TRANSFORMED, data.logId());
}
}
//自定义图片变换
if (data.hasCustomTransformations()) {
//此处暂时略过，下面会细讲
}
}
}
}
return bitmap;
}
}
public final class Request {
//needsMatrixTransform()返回true，表示需要基本图片变换
//hasCustomTransformations()返回true，表示需要自定义图片变换
boolean needsTransformation() {
return needsMatrixTransform() || hasCustomTransformations();
}
//若调用过resize()或rotate()，则返回true
boolean needsMatrixTransform() {
return hasSize() || rotationDegrees != 0;
}
public boolean hasSize() {
return targetWidth != 0 || targetHeight != 0;
}
boolean hasCustomTransformations() {
return transformations != null;
}
}
hunt()方法获取到图片后，针对图片变换，做了以下几件事：
1）检查Request.needsTransformation()和exifRotation，看看是否需要进行图片变换。其中，exifOrientation为EXIF图片的旋转信息；
2）若需要变换，则先检查是否要做基本图片变换；
3）在基本图片变换之后，再检查是否要做自定义图片变换。
具体的基本图片变换工作，是由BitmapHunter.transformResult()方法完成的：
static Bitmap transformResult(Request data, Bitmap result, int exifRotation) {
int inWidth = result.getWidth();
int inHeight = result.getHeight();
boolean onlyScaleDown = data.onlyScaleDown;
int drawX = 0;
int drawY = 0;
int drawWidth = inWidth;
int drawHeight = inHeight;
Matrix matrix = new Matrix();
if (data.needsMatrixTransform()) {
int targetWidth = data.targetWidth;
int targetHeight = data.targetHeight;
//图片旋转
float targetRotation = data.rotationDegrees;
if (targetRotation != 0) {
if (data.hasRotationPivot) {
matrix.setRotate(targetRotation, data.rotationPivotX, data.rotationPivotY);
} else {
matrix.setRotate(targetRotation);
}
}
//图片裁剪
if (data.centerCrop) {
float widthRatio = targetWidth / (float) inWidth;
float heightRatio = targetHeight / (float) inHeight;
float scaleX, scaleY;
if (widthRatio > heightRatio) {
int newSize = (int) Math.ceil(inHeight * (heightRatio / widthRatio));
drawY = (inHeight - newSize) / 2;
drawHeight = newSize;
scaleX = widthRatio;
scaleY = targetHeight / (float) drawHeight;
} else {
int newSize = (int) Math.ceil(inWidth * (widthRatio / heightRatio));
drawX = (inWidth - newSize) / 2;
drawWidth = newSize;
scaleX = targetWidth / (float) drawWidth;
scaleY = heightRatio;
}
if (shouldResize(onlyScaleDown, inWidth, inHeight, targetWidth, targetHeight)) {
matrix.preScale(scaleX, scaleY);
}
} else if (data.centerInside) {
float widthRatio = targetWidth / (float) inWidth;
float heightRatio = targetHeight / (float) inHeight;
float scale = widthRatio < heightRatio ? widthRatio : heightRatio;
if (shouldResize(onlyScaleDown, inWidth, inHeight, targetWidth, targetHeight)) {
matrix.preScale(scale, scale);
}
} else if ((targetWidth != 0 || targetHeight != 0)
&& (targetWidth != inWidth || targetHeight != inHeight)) {
float sx =
targetWidth != 0 ? targetWidth / (float) inWidth : targetHeight / (float) inHeight;
float sy =
targetHeight != 0 ? targetHeight / (float) inHeight : targetWidth / (float) inWidth;
if (shouldResize(onlyScaleDown, inWidth, inHeight, targetWidth, targetHeight)) {
matrix.preScale(sx, sy);
}
}
}
if (exifRotation != 0) {
matrix.preRotate(exifRotation);
}
Bitmap newResult =
Bitmap.createBitmap(result, drawX, drawY, drawWidth, drawHeight, matrix, true);
if (newResult != result) {
result.recycle();
result = newResult;
}
return result;
}
可以看到，基本图片变换就是利用Android的Matrix类，对Bitmap进行处理的过程。
2.自定义图片变换
利用基本图片变换可完成图片旋转、裁剪和缩放等，但若想实现更复杂的图片变换，例如：高斯模糊、圆角裁剪或度灰处理等，则就要依赖于自定义图片变换功能了。Picasso框架通过Transformation接口对自定义图片变换功能进行支持。
public interface Transformation {
//对原图片进行自定义变换
//如果在该方法中创建了新的Bitmap实例，则必须对source进行手动recycle
Bitmap transform(Bitmap source);
//返回标识该变换的唯一key
String key();
}
Transformation接口提供了两个方法：
1）transform()：用于对原图片进行自定义变换，图片的变换逻辑应写在该方法中。但要注意，如果在该方法中创建了新的Bitmap实例，则必须对原Bitmap手动回收；
2）key()：返回标识该变换的唯一key。
在使用自定义图片变换功能时，开发者需先编写实现Transformation接口的类，然后在调用RequestCreator.transform()方法将自定义的Transformation添加到Request中。当BitmapHunter获取到图片后，会在hunt()方法中先进行基本图片变换，然后在处理自定义图片变换。
Bitmap hunt() throws IOException {
//省略部分代码
RequestHandler.Result result = requestHandler.load(data, networkPolicy);
if (result != null) {
//省略部分代码
exifRotation = result.getExifOrientation();
bitmap = result.getBitmap();
}
//省略部分代码
//重点
if (bitmap != null) {
//检查是否需要对图片进行变换
if (data.needsTransformation() || exifRotation != 0) {
//基本图片变换
if (data.needsMatrixTransform() || exifRotation != 0) {
//省略部分代码
}
//自定义图片变换
if (data.hasCustomTransformations()) {
bitmap = applyCustomTransformations(data.transformations, bitmap);
if (picasso.loggingEnabled) {
log(OWNER_HUNTER, VERB_TRANSFORMED, data.logId(), "from custom transformations");
}
}
//省略部分代码
}
}
return bitmap;
}
static Bitmap applyCustomTransformations(List<Transformation> transformations, Bitmap result) {
for (int i = 0, count = transformations.size(); i < count; i++) {
final Transformation transformation = transformations.get(i);
Bitmap newResult;
try {
//执行自定义的图片变换逻辑
newResult = transformation.transform(result);
} catch (final RuntimeException e) {
Picasso.HANDLER.post(new Runnable() {
@Override public void run() {
throw new RuntimeException(
"Transformation " + transformation.key() + " crashed with exception.", e);
}
});
return null;
}
//若transformation.transform()返回null，则抛异常
if (newResult == null) {
final StringBuilder builder = new StringBuilder() //
.append("Transformation ")
.append(transformation.key())
.append(" returned null after ")
.append(i)
.append(" previous transformation(s).\n\nTransformation list:\n");
for (Transformation t : transformations) {
builder.append(t.key()).append('\n');
}
Picasso.HANDLER.post(new Runnable() {
@Override public void run() {
throw new NullPointerException(builder.toString());
}
});
return null;
}
//若transformation.transform()返回原Bitmap，且原Bitmap已被回收，则抛异常
if (newResult == result && result.isRecycled()) {
Picasso.HANDLER.post(new Runnable() {
@Override public void run() {
throw new IllegalStateException("Transformation "
+ transformation.key()
+ " returned input Bitmap but recycled it.");
}
});
return null;
}
//若transformation.transform()返回新Bitmap，且原Bitmap未被回收，则抛异常
if (newResult != result && !result.isRecycled()) {
Picasso.HANDLER.post(new Runnable() {
@Override public void run() {
throw new IllegalStateException("Transformation "
+ transformation.key()
+ " mutated input Bitmap but failed to recycle the original.");
}
});
return null;
}
result = newResult;
}
return result;
}
applyCustomTransformations()方法的实现很简单，就是调用Transformation.transform()进行处理，之后再进行一系列的状态检查。
总结
Picasso作为图片加载框架，不只是简单的封装了图片下载和加载的过程，而是在更高的层面上对整个流程进行了抽象：将共性部分封装成框架主线，将易变部分封装成抽象接口/抽象类（Target接口、Transformation接口、Action及其子类）。在保证主体代码稳定的同时，又提高了框架的可扩展性。这种抽象和封装的思想非常值得我们学习。
如对Picasso框架感兴趣，欢迎关注本系列文章。如对本文有疑问，欢迎留言交流。如需要转载，则请注明出处。
