一、Picasso源码解析
（1）get()：一个单例模式，为了保证线程安全，使用的是双重校验锁。创建的过程中又使用了Builder模式，实现链式调用。
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;
}
//Picasso是针对应用级别的使用，不会是随着Activity或是Fragment的生命周期而产生变化，只有当前的应用退出或是销毁时Picasso才会停止它的行为。
public Builder(@NonNull Context context) {
if (context == null) {
throw new IllegalArgumentException("Context must not be null.");
}
this.context = context.getApplicationContext();
}
//初始化并返回Picasso实例对象
public Picasso build() {
Context context = this.context;
//downloader下载器
if (downloader == null) {
downloader = new OkHttp3Downloader(context);
}
//LruCache缓存
if (cache == null) {
cache = new LruCache(context);
}
//PicassoExecutorService线程池
if (service == null) {
service = new PicassoExecutorService();
}
//请求的前置处理，在请求发出去之前执行，类似于拦截器
if (transformer == null) {
transformer = RequestTransformer.IDENTITY;
}
//Stats图片的状态
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);
}
}
- OkHttp3Downloader(context)下载器
public OkHttp3Downloader(final Context context) {
this(Utils.createDefaultCacheDir(context));
}
public OkHttp3Downloader(final File cacheDir) {
this(cacheDir, Utils.calculateDiskCacheSize(cacheDir));
}
public OkHttp3Downloader(final Context context, final long maxSize) {
this(Utils.createDefaultCacheDir(context), maxSize);
}
//缓存目录，缓存大小限制
public OkHttp3Downloader(final File cacheDir, final long maxSize) {
this(new OkHttpClient.Builder().cache(new Cache(cacheDir, maxSize)).build());
sharedClient = false;
}
//设置OkHttpClient与缓存文件
public OkHttp3Downloader(OkHttpClient client) {
this.client = client;
this.cache = client.cache();
}
- LruCache(context)缓存
public LruCache(@NonNull Context context) {
this(Utils.calculateMemoryCacheSize(context));
}
public LruCache(int maxByteCount) {
cache = new android.util.LruCache<String, LruCache.BitmapAndSize>(maxByteCount) {
@Override protected int sizeOf(String key, BitmapAndSize value) {
return value.byteCount;
}
};
}
//采用的LinkedHashMap，来保存缓存图片
public LruCache(int maxSize) {
if (maxSize <= 0) {
throw new IllegalArgumentException("maxSize <= 0");
}
this.maxSize = maxSize;
this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
}
- PicassoExecutorService()线程池
- 重用线程池中的线程， 避免因为线程的创建和销毁所带来的性能开销.
- 有效控制线程池中的最大并发数，避免大量线程之间因为相互抢占系统资源而导致的阻塞现象.
- 能够对线程进行简单的管理，可提供定时执行和按照指定时间间隔循环执行等功能
PicassoExecutorService() {
super(DEFAULT_THREAD_COUNT, DEFAULT_THREAD_COUNT, 0, TimeUnit.MILLISECONDS,
new PriorityBlockingQueue<Runnable>(), new Utils.PicassoThreadFactory());
}
//corePoolSize: 线程池的核心线程数
//maximumPoolSize: 最大的线程数
//keepAliveTime: 超时的时间
//unit：超时时间的时间单位.
//workQueue：线程池的任务队列
//threadFactory: 线程工厂
//handler: 任务无法执行时，回调handler的rejectedExecution方法来通知调用者
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, defaultHandler);
}
- Stats(cache)图片的状态
//状态信息
Stats(Cache cache) {
this.cache = cache;
this.statsThread = new HandlerThread(STATS_THREAD_NAME, THREAD_PRIORITY_BACKGROUND);
this.statsThread.start();
Utils.flushStackLocalLeaks(statsThread.getLooper());
this.handler = new StatsHandler(statsThread.getLooper(), this);
}
- Dispatcher调度器控制线程的加载和取消、网络监听、消息处理等。
Dispatcher(Context context, ExecutorService service, Handler mainThreadHandler,
Downloader downloader, Cache cache, Stats stats) {
this.dispatcherThread = new DispatcherThread();//DispatcherThread继承HandlerThread
this.dispatcherThread.start();
Utils.flushStackLocalLeaks(dispatcherThread.getLooper());
this.context = context;
this.service = service;
this.hunterMap = new LinkedHashMap<>();
this.failedActions = new WeakHashMap<>();
this.pausedActions = new WeakHashMap<>();
this.pausedTags = new LinkedHashSet<>();
this.handler = new DispatcherHandler(dispatcherThread.getLooper(), this);//在子线程运行的handler，自定义消息分发
this.downloader = downloader;
this.mainThreadHandler = mainThreadHandler;
this.cache = cache;
this.stats = stats;
this.batch = new ArrayList<>(4);
this.airplaneMode = Utils.isAirplaneModeOn(this.context);
this.scansNetworkChanges = hasPermission(context, Manifest.permission.ACCESS_NETWORK_STATE);
this.receiver = new NetworkBroadcastReceiver(this);
receiver.register();
}
- DispatcherHandler.handleMessage
//消息并没有被直接进行处理而是转移到了dispatcher中，在dispatcher中进行相应的处理
private static class DispatcherHandler extends Handler {
//code..
@Override
public void handleMessage(final Message msg) {
switch (msg.what) {
case REQUEST_SUBMIT: {
Action action = (Action) msg.obj;
dispatcher.performSubmit(action);
break;
}
//code...
case HUNTER_COMPLETE: {
BitmapHunter hunter = (BitmapHunter) msg.obj;
dispatcher.performComplete(hunter);
break;
}
//code...
case HUNTER_DELAY_NEXT_BATCH: {
dispatcher.performBatchComplete();
break;
}
//code...
}
}
}
void performSubmit(Action action) {
performSubmit(action, true);
}
void performSubmit(Action action, boolean dismissFailed) {
if (pausedTags.contains(action.getTag())) {
pausedActions.put(action.getTarget(), action);
return;
}
//查看是否有对应url的缓存的hunter
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;
}
hunter = forRequest(action.getPicasso(), this, cache, stats, action);
//提交任务到线程池
hunter.future = service.submit(hunter);
//将runnable缓存在map集合中
hunterMap.put(action.getKey(), hunter);
if (dismissFailed) {
failedActions.remove(action.getTarget());
}
}
- 创建BitmapHunter执行run方法
@Override
public void run() {
try {
updateThreadName(data);
//获取bitmap图片
result = hunt();
//判断bitmap是否为空
if (result == null) {
//失败回调
dispatcher.dispatchFailed(this);
} else {
//失败回调
dispatcher.dispatchComplete(this);
}
}
//code...
}
- 成功回调方法dispatchComplete
void dispatchComplete(BitmapHunter hunter) {
handler.sendMessage(handler.obtainMessage(HUNTER_COMPLETE, hunter));
}
//通过handleMessage调用
void performComplete(BitmapHunter hunter) {
//将图片添加到临时缓存
if (shouldWriteToMemoryCache(hunter.getMemoryPolicy())) {
cache.set(hunter.getKey(), hunter.getResult());
}
//删除下载任务
hunterMap.remove(hunter.getKey());
batch(hunter);
}
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
handler.sendEmptyMessageDelayed(HUNTER_DELAY_NEXT_BATCH, BATCH_DELAY);
}
}
- 通过handleMessage接收延迟任务调用performBatchComplete()
void performBatchComplete() {
List<BitmapHunter> copy = new ArrayList<>(batch);
batch.clear();
//发送任务到Picasso的HANDLER主线程的handler中
mainThreadHandler.sendMessage(mainThreadHandler.obtainMessage(HUNTER_BATCH_COMPLETE, copy));
logBatch(copy);
}
- 查看Picasso.HANDLER中的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<BitmapHunter> batch = (List<BitmapHunter>) msg.obj;
for (int i = 0, n = batch.size(); i < n; i++) {
BitmapHunter hunter = batch.get(i);
//通过调用complete最终调用ImageViewAction中complete方法
hunter.picasso.complete(hunter);
}
break;
}
//code...
}
}
};
//ImageViewAction.java
@Override
public void complete(Bitmap result, Picasso.LoadedFrom from) {
//code...
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();
}
}
//PicassoDrawable.java
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);
}
（2）load(imageUrl)：加载url，创建并返回一个图片下载请求的构建器RequestCreator
public RequestCreator load(@Nullable String path) {
if (path == null) {
return new RequestCreator(this, null, 0);
}
if (path.trim().length() == 0) {
throw new IllegalArgumentException("Path must not be empty.");
}
return load(Uri.parse(path));
}
public RequestCreator load(@Nullable Uri uri) {
return new RequestCreator(this, uri, 0);
}
//RequestCreator.java
//请求构建器，用来存储该图片加载任务的一切信息
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);
}
（3）into(imageView)：请求图片并返回
public void into(ImageView target) {
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.");
}
if (!data.hasImage()) {
picasso.cancelRequest(target);
if (setPlaceholder) {
setPlaceholder(target, getPlaceholderDrawable());
}
return;
}
if (deferred) {
if (data.hasSize()) {
throw new IllegalStateException("Fit cannot be used with resize.");
}
int width = target.getWidth();
int height = target.getHeight();
if (width == 0 || height == 0) {
//设置默认图
if (setPlaceholder) {
setPlaceholder(target, getPlaceholderDrawable());
}
picasso.defer(target, new DeferredRequestCreator(this, target, callback));
return;
}
data.resize(width, height);
}
//Request的拦截器
Request request = createRequest(started);
//根据请求的URL，图片的处理等参数创建一个字符串Key
String requestKey = createKey(request);
//缓存策略，是否应该从内存中读取
if (shouldReadFromMemoryCache(memoryPolicy)) {
//内存的快速检查
Bitmap bitmap = picasso.quickMemoryCacheCheck(requestKey);
if (bitmap != null) {
//如果缓存中已存在则取消请求并直接设置给ImageView
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());
}
//创建ImageViewAction对象
Action action =
new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId,
errorDrawable, requestKey, tag, callback, noFade);
//提交请求
picasso.enqueueAndSubmit(action);
}
