Android Picasso图片加载库源码剖析

Picasso是一个优秀的轻量级网络图片加载缓存库。花了两天时间研读了下的阅读了下他的源码。做一下的剖析：

Picasso的优点：

• 足够轻量级:maven打包出来的jar只有130kb左右
• 二级缓存策略，分别缓存内存和磁盘空间
• 自动监控内存大小数据
• 很好的线程控制，根据网络状态控制线程数量、具有优先级调度策略。
• 图片适应、压缩处理策略
• 预加载功能
• 代码质量高、易拓展。

1 Picasso整体画像

1 流程图

2 Picasso 基本使用和概括流程

Picasso.with(context).load("http://i.imgur.com/DvpvklR.png").into(imageView);

看下初始化的方法。with()获的Picasso的全局单例。

public static Picasso with(Context context) {    if (singleton == null) {      synchronized (Picasso.class) {        if (singleton == null) {          singleton = new Builder(context).build();        }      }    }    return singleton; }

使用Builder模式获得实例，看起来比较清晰明了。

public Picasso build() {      Context context = this.context;      if (downloader == null) {        downloader = Utils.createDefaultDownloader(context);      }      if (cache == null) {        cache = new LruCache(context);      }      if (service == null) {        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);    }

建造者获得实例的时候会初始好Download（网络下载模块）、LruCache（缓存核心）、RequestTransformer（Request运输类）、Stats（检测类）、Dispatch（事务分发中心）。

调用load(uri)开始执行图片加载
load(Uri)
load(String)
load(File)
其中#load(Uri)

public RequestCreator load(Uri uri) {    return new RequestCreator(this, uri, 0);}

RequestCreator提供了图片相关处理相关的所有API，RequestCreator所有的api方法结果return this。可以理解他同样为一个builder模式的建造者。着重看下装载图片的into()方法实现。

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.");    }    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);      if (bitmap != null) {          //取消网络的加载        picasso.cancelRequest(target);        target.onBitmapLoaded(bitmap, MEMORY);        return;      }    }    target.onPrepareLoad(setPlaceholder ? getPlaceholderDrawable() : null);    Action action =        new TargetAction(picasso, target, request, memoryPolicy, networkPolicy, errorDrawable,            requestKey, tag, errorResId);   //提交动作执行下载    picasso.enqueueAndSubmit(action);}

到这里可以大体看到的图片加载的流程代码,Picasso模块初始化之后，初始了各个核心模块，并创建RequestCreator提供出图片相关的所有操作API，在执行启动into下载图片的时机优先使用缓存中的数据。那么他们各个模块是怎么协调工作的呢？下面分块来揭秘。

2 线程控制

BitmapHunter implements Runnable
这是一个单独的图片处理的线程单元。 run()方法中调用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;      }    }//根据网络状况执行图片的加载    data.networkPolicy = retryCount == 0 ? NetworkPolicy.OFFLINE.index : networkPolicy;    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);      //图片适配的处理，由于是多线程所以做了同步加锁的处理DECODE_LOCK      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);        }      }    }    return bitmap;  }

Dispatch类是一个控制的中心，控制线程的加载和取消、网络监听、消息处理等。

Dispatcher(Context context, ExecutorService service, Handler mainThreadHandler,      Downloader downloader, Cache cache, Stats stats) {    this.dispatcherThread = new DispatcherThread();    this.dispatcherThread.start();    Utils.flushStackLocalLeaks(dispatcherThread.getLooper());    this.context = context;    this.service = service;    ···    代码省略  }

其构造中获得service 即为PicassoExecutorService ，而PicassoExecutorService 集成自ThreadPoolExecutor,是一个线程池。
Picasso具有根据网络状况控制线程数量的方法就是有PicassoExecutorService来控制完成的

 void adjustThreadCount(NetworkInfo info) {    if (info == null || !info.isConnectedOrConnecting()) {      setThreadCount(DEFAULT_THREAD_COUNT);      return;    }    switch (info.getType()) {      case ConnectivityManager.TYPE_WIFI:      case ConnectivityManager.TYPE_WIMAX:      case ConnectivityManager.TYPE_ETHERNET:        setThreadCount(4);        break;      case ConnectivityManager.TYPE_MOBILE:        switch (info.getSubtype()) {          case TelephonyManager.NETWORK_TYPE_LTE:  // 4G          case TelephonyManager.NETWORK_TYPE_HSPAP:          case TelephonyManager.NETWORK_TYPE_EHRPD:            setThreadCount(3);            break;          case TelephonyManager.NETWORK_TYPE_UMTS: // 3G          case TelephonyManager.NETWORK_TYPE_CDMA:          case TelephonyManager.NETWORK_TYPE_EVDO_0:          case TelephonyManager.NETWORK_TYPE_EVDO_A:          case TelephonyManager.NETWORK_TYPE_EVDO_B:            setThreadCount(2);            break;          case TelephonyManager.NETWORK_TYPE_GPRS: // 2G          case TelephonyManager.NETWORK_TYPE_EDGE:            setThreadCount(1);            break;          default:            setThreadCount(DEFAULT_THREAD_COUNT);        }        break;      default:        setThreadCount(DEFAULT_THREAD_COUNT);    }  }

上一节我们在into方法中提交执行下载enqueueAndSubmit的过程最终交由控制中心Dispatch中performSubmit来完成

void performSubmit(Action action, boolean dismissFailed) {    if (pausedTags.contains(action.getTag())) {    ···    省略代码    hunter = forRequest(action.getPicasso(), this, cache, stats, action);    hunter.future = service.submit(hunter);    hunterMap.put(action.getKey(), hunter);    ···    代码省略    }  }

叫BitmapHunter的线程放入线程池中控制执行
hunter.future = service.submit(hunter);

@Override  public Future<?> submit(Runnable task) {    PicassoFutureTask ftask = new PicassoFutureTask((BitmapHunter) task);    execute(ftask);    return ftask;  }

3 回收任务

为了避免oom，缓存中Target使用了weakReference弱引用，方便被系统回收。但是有些Target(比如说ImageView)已经被回收，但是所对应的Request请求还在继续任务(Action)，就会浪费资源。Picasso中引入了一个叫CleanupThread的内部线程，CleanupThread是一个daemon线程，它的工作是找到那些Target(比如说ImageView)已经被回收的取消相应的任务Action。

看线程代码

private static class CleanupThread extends Thread {    private final ReferenceQueue<Object> referenceQueue;    private final Handler handler;    CleanupThread(ReferenceQueue<Object> referenceQueue, Handler handler) {      this.referenceQueue = referenceQueue;      this.handler = handler;      setDaemon(true);      setName(THREAD_PREFIX + "refQueue");    }    @Override public void run() {      Process.setThreadPriority(THREAD_PRIORITY_BACKGROUND);      while (true) {        try {          // Prior to Android 5.0, even when there is no local variable, the result from          // remove() & obtainMessage() is kept as a stack local variable.          // We're forcing this reference to be cleared and replaced by looping every second          // when there is nothing to do.          // This behavior has been tested and reproduced with heap dumps.          RequestWeakReference<?> remove =              (RequestWeakReference<?>) referenceQueue.remove(THREAD_LEAK_CLEANING_MS);          Message message = handler.obtainMessage();          if (remove != null) {            message.what = REQUEST_GCED;            message.obj = remove.action;            handler.sendMessage(message);          } else {            message.recycle();          }        } catch (InterruptedException e) {          break;        } catch (final Exception e) {          handler.post(new Runnable() {            @Override public void run() {              throw new RuntimeException(e);            }          });          break;        }      }    }    void shutdown() {      interrupt();    }  }

由此看出此线程一直在遍历ReferenceQueue，从中找到这样的reference,就交给handler,handler会从reference中拿到action.
取消：

private void cancelExistingRequest(Object target) {   checkMain();   Action action = targetToAction.remove(target);   if (action != null) {      action.cancel();      dispatcher.dispatchCancel(action);   }   if (target instanceof ImageView) {      ImageView targetImageView = (ImageView) target;      DeferredRequestCreator deferredRequestCreator =            targetToDeferredRequestCreator.remove(targetImageView);     if (deferredRequestCreator != null) {        deferredRequestCreator.cancel();      }   }}

4 LruCache缓存

Picasso 采用LruCache缓存方式，借鉴了volley。本质是使用LinkedHashMap缓存。使用LinkedHashMap是因为其具有存取快，易遍历的数据结构。

this.map = new LinkedHashMap<String, Bitmap>(0, 0.75f, true);

初始化缓存内存的大小，在LurCache初始化的时候可以传入自定义的大小控件。默认的大小为内存的15%。

static int calculateMemoryCacheSize(Context context) {    ActivityManager am = getService(context, ACTIVITY_SERVICE);    boolean largeHeap = (context.getApplicationInfo().flags & FLAG_LARGE_HEAP) != 0;    int memoryClass = am.getMemoryClass();    if (largeHeap && SDK_INT >= HONEYCOMB) {      memoryClass = ActivityManagerHoneycomb.getLargeMemoryClass(am);    }    // Target ~15% of the available heap.    return (int) (1024L * 1024L * memoryClass / 7);}

存取很简单就是简单的从map中存取缓存对象。

@Override public void set(String key, Bitmap bitmap) {    if (key == null || bitmap == null) {      throw new NullPointerException("key == null || bitmap == null");    }    Bitmap previous;    //set、put可能为并发的操作，需要同步加锁。    synchronized (this) {      putCount++;      size += Utils.getBitmapBytes(bitmap);      previous = map.put(key, bitmap);      if (previous != null) {        size -= Utils.getBitmapBytes(previous);      }    }    //是否超过最大控件    trimToSize(maxSize);  } 

5 图形变化

图片变化由Transformation定义了接口。交由BitmapHunter的hunt核心代码中执行。

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;      }      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;      }      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;      }      // If the transformation returned a new bitmap ensure they recycled the original.      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;  }

Request 维护了一个图形变换的列表。图片加载成功后 BitmapHunter遍历这个集合完成图形的变换。