源码阅读系列:Picasso源码阅读

96
JackMeGo
2017.03.06 19:47* 字数 2118

Android开发中,我们经常用到各种开源框架,很多优秀的框架不仅提供了功能丰富的功能接口,其高超的代码编写和组织水平也值得我们学习。通过学习这些框架的源码,有助于快速提高我们的编程质量。在接下来的博客中,我将对一系列优秀的开源框架源码进行阅读分析,目的有两个,一是理解框架的实现机制,从源码的角度去分析怎样更好的使用这些框架。二是从这些优秀的源码中学习如何组织代码,如何实现高质量的编程。本文我们将分析Android图片加载工具Picasso源码。

我们从Picasso使用方式上入手,Picasso的使用通常分为两步,第一步初始化Picasso单例,第二步获取Picasso单例,创建RequestCreator,加载图片。代码示例如下:

Picasso初始化

private void initPicasso() {
    Picasso picasso = new Picasso.Builder(this)
            .defaultBitmapConfig(Bitmap.Config.RGB_565) // 设置全局的图片样式
            .downloader(new OkHttpDownloader(FileUtility.getPicassoCacheDir())) // 设置Downloader
            .requestTransformer(new Picasso.RequestTransformer() { // 设置RequestTransformer
                @Override
                public Request transformRequest(Request request) {
                    if (request.uri != null) {
                        return request.buildUpon().setUri(NetworkConfig.processUri(request.uri)).build();
                    }
                    return request;
                }
            })
            .build();
    Picasso.setSingletonInstance(picasso); // 设置Picasso单例
}

加载图片

Picasso.with(this) // 获取Picasso单例
        .load(url) // 返回一个新建的RequestCreator对象
        .resize(width, height) // 设置尺寸
        .onlyScaleDown() // 设置缩放
        .centerInside() // 设置裁剪方式
        .placeholder(R.drawable.transparent)  // 设置占位图片
        .error(R.drawable.group_chat_error_image)  // 设置出错展示的图片
        .memoryPolicy(MemoryPolicy.NO_CACHE) // 设置内存缓存策略
        .networkPolicy(NetworkPolicy.NO_CACHE) // 设置网络缓存策略
        .into(mScaleSampleImage, null);  // 设置图片加载的目标控件

Picasso初始化用到了单例模式和构造者模式。关于构造者模式的讲解可以查看这篇文章,此处不再赘述。在Picasso初始化用到Picasso.Builder静态内部类,有以下设置项:

public static class Builder {
    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;

    private boolean indicatorsEnabled;
    private boolean loggingEnabled;

    // 设置图片格式
    public Builder defaultBitmapConfig(@NonNull Bitmap.Config bitmapConfig) {
        ...
    }
    // 设置Downloader
    public Builder downloader(@NonNull Downloader downloader) {
        ...
    }
    // 设置线程池
    public Builder executor(@NonNull ExecutorService executorService) {
        ...
    }
    // 设置内存缓存
    public Builder memoryCache(@NonNull Cache memoryCache) {
        ...
    }
    // 设置Picasso Listener,里面有响应函数onImageLoadFailed
    public Builder listener(@NonNull Listener listener) {
        ...
    }
    // 设置RequestTransformer,可以对网络请求添加统一处理
    public Builder requestTransformer(@NonNull RequestTransformer transformer) {
        ...
    }
    // 添加针对不同类型请求的Hander,请求类型如
    // 网络图片请求 http://example.com/1.png
    // 文件请求 file:///android_asset/foo/bar.png
    // 媒体库文件 content://media/external/images/media/1
    public Builder addRequestHandler(@NonNull RequestHandler requestHandler) {
        ...
    }
    // 设置是否展示调试指示器
    public Builder indicatorsEnabled(boolean enabled) {
        ...
    }
    // 设置是否启用日志
    public Builder loggingEnabled(boolean enabled) {
        ...
    }
    // 最终生成Picasso实例的build函数
    public Picasso build() {
        Context context = this.context;

        if (downloader == null) {
            downloader = new OkHttp3Downloader(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);
    }

通过这个Builder类完成Picasso实例的构造,然后通过setSingletonInstance函数设置Picasso全局单例:

public class Picasso {
    static volatile Picasso singleton = null;
    ...
    public static void setSingletonInstance(@NonNull Picasso picasso) {
        if (picasso == null) {
          throw new IllegalArgumentException("Picasso must not be null.");
        }
        synchronized (Picasso.class) {
          if (singleton != null) {
          throw new IllegalStateException("Singleton instance already exists.");
        }
        singleton = picasso;
      }
    }
    ...
}

这样就完成了Picasso单例的初始化,并完成了一些全局的设置。接下来可以通过这个单例加载图片并展示了。

Picasso.with(this) // 获取Picasso单例
        .load(url) // 返回一个新建的RequestCreator对象
        .resize(width, height) // 设置尺寸
        .onlyScaleDown() // 设置缩放
        .centerInside() // 设置裁剪方式
        .placeholder(R.drawable.transparent)  // 设置占位图片
        .error(R.drawable.group_chat_error_image)  // 设置出错展示的图片
        .memoryPolicy(MemoryPolicy.NO_CACHE) // 设置内存缓存策略
        .networkPolicy(NetworkPolicy.NO_CACHE) // 设置网络缓存策略
        .into(mScaleSampleImage, null);  // 设置图片加载的目标控件

通过Picasso.with获取单例对象:

public class Picasso {
    static volatile Picasso singleton = null;
    ...
    public static Picasso with(@NonNull Context context) {
        if (context == null) {
          throw new IllegalArgumentException("context == null");
        }
        if (singleton == null) {
          synchronized (Picasso.class) {
            // 如果还没初始化,采用默认配置进行初始化
            if (singleton == null) {
              singleton = new Builder(context).build();
            }
          }
        }
        return singleton;
      }
    ...
}

获取到Picasso单例对象后,调用picasso.load函数,返回一个RequestCreator对象,该对象用于构造一个具体的加载图片请求Request。

public class Picasso {
    ...
    public RequestCreator load(@Nullable Uri uri) {
        return new RequestCreator(this, uri, 0);
    }

    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(@NonNull File file) {
        if (file == null) {
          return new RequestCreator(this, null, 0);
        }
        return load(Uri.fromFile(file));
    }

    public RequestCreator load(@DrawableRes int resourceId) {
        if (resourceId == 0) {
          throw new IllegalArgumentException("Resource ID must not be zero.");
        }
        return new RequestCreator(this, null, resourceId);
    }
    ...
}

可以看出,load可以加载不同类型的资源,包括Uri,文件路径,文件,资源ID等。

RequestCreator采用了构造者模式,提供了一系列设置函数,可以设置本次要加载图片的裁剪方式,缩放方式,旋转角度等。

public class RequestCreator {
    ...
    private final Picasso picasso;
    private final Request.Builder data;

    ...
    private int placeholderResId;
    private int errorResId;
    private int memoryPolicy;
    private int networkPolicy;
    ...

    public RequestCreator placeholder(@DrawableRes int placeholderResId) {
        ...
    }

    public RequestCreator error(@DrawableRes int errorResId) {
    public RequestCreator tag(@NonNull Object tag) {
    public RequestCreator resize(int targetWidth, int targetHeight) {
    
    public RequestCreator centerCrop() {
        data.centerCrop(Gravity.CENTER);
        return this;
    }

    public RequestCreator centerInside() {
        data.centerInside();
        return this;
    }

    public RequestCreator onlyScaleDown() {
        data.onlyScaleDown();
        return this;
    }

    public RequestCreator rotate(float degrees) {
        data.rotate(degrees);
        return this;
    }

    public RequestCreator config(@NonNull Bitmap.Config config) {
        data.config(config);
        return this;
    }

    public RequestCreator priority(@NonNull Priority priority) {
        data.priority(priority);
        return this;
    }

    public RequestCreator transform(@NonNull Transformation transformation) {
        data.transform(transformation);
        return this;
    }

    public RequestCreator memoryPolicy(@NonNull MemoryPolicy policy,
      @NonNull MemoryPolicy... additional) {
        ...
    }
    public RequestCreator networkPolicy(@NonNull NetworkPolicy policy,
      @NonNull NetworkPolicy... additional) {
        ...
    }
    ...
}

RequestCreator对外提供了一系列设置函数,返回的都是同一个RequestCreator对象,标准的构造者模式。完成所有设置后,调用into函数实现Request对象的最终构造。

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;
    }
    // 第一个分支:延迟加载
    // deferred=true表明调用了fit()方法,根据ImageView的宽高适配图片
    // 所以需要在ImageView完成layout以后才能获得确切的尺寸
    // 所以需要延迟加载图片
    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 || target.isLayoutRequested()) {
        if (setPlaceholder) {
          setPlaceholder(target, getPlaceholderDrawable());
        }
        picasso.defer(target, new DeferredRequestCreator(this, target, callback));
        return;
      }
      data.resize(width, height);
    }

    // createRequest调用data.build()生成一个Request,
    // 并调用picasso.transformRequest对这个请求进行转换(如果设置了requestTransformer)
    Request request = createRequest(started);
    // 根据请求的图片和各个请求参数,如Uri,rotationDegrees,resize,centerCorp,centerInside等
    // 生成一个用于标识的字符串,作为缓存中的key
    String requestKey = createKey(request);

    // 第二个分支:从缓存中获取
    // 如果设置了缓存(通过memoryPolicy方法设置),先试图从缓存获取,获取成功直接返回
    if (shouldReadFromMemoryCache(memoryPolicy)) {
      Bitmap bitmap = picasso.quickMemoryCacheCheck(requestKey);
      if (bitmap != null) {
        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来加载该图片。
    // 一个Action包含了complete/error/cancel等回调函数
    // 对应了图片加载成功,失败,取消加载的操作
    Action action =
        new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId,
            errorDrawable, requestKey, tag, callback, noFade);

    // 通过picasso对象将该action加入执行队列,里面的任务通过ThreadPoolExecutor线程池执行
    picasso.enqueueAndSubmit(action);
  }

这个函数是个很关键的函数,我们可以将它作为理解Picasso加载过程的一条主线。该函数首先通过checkMain检查是不是在主线程发起调用,由于加载图片需要对UI进行操作,所以必须在主线程进行函数的调用。

static void checkMain() {
    if (!isMain()) {
      throw new IllegalStateException("Method call should happen from the main thread.");
    }
}

static boolean isMain() {
    return Looper.getMainLooper().getThread() == Thread.currentThread();
}

checkMain的实现是通过比较当前线程和MainLooper线程是否是同一个线程进行的。
完成主线程检查后,判断有没有设置图片来源,包括Uri或Resource ID等,如果没设置不进行加载。

// 如果没有要加载的图片Uri或ResourceID,取消
    if (!data.hasImage()) {
      picasso.cancelRequest(target);
      if (setPlaceholder) {
        setPlaceholder(target, getPlaceholderDrawable());
      }
      return;
    }

接下来判断可以立即加载,还是需要延迟加载。延迟加载的场景是使用fit()方法进行图片尺寸自适应调整的时候。如果设置图片根据需要展示的View的尺寸进行自动调整,而且这个View的宽度或高度设置为0(比如通过weight进行相对宽高的设置),那么代码执行到这里的时候View可能还没完成测量的过程,还没有计算出实际的宽高,就需要等测量完成后才进行加载,也就是延迟加载,这里作为into函数三个分支的第一个分支。

延迟加载时通过DeferredRequestCreator类实现的:

class DeferredRequestCreator implements OnPreDrawListener, OnAttachStateChangeListener {
    private final RequestCreator creator;
    @VisibleForTesting final WeakReference<ImageView> target;
    @VisibleForTesting Callback callback;

    DeferredRequestCreator(RequestCreator creator, ImageView target, Callback callback) {
        this.creator = creator;
        this.target = new WeakReference<>(target);
        this.callback = callback;

        // 给目标View注册onAttachStateChangeListener
        target.addOnAttachStateChangeListener(this);

        // Only add the pre-draw listener if the view is already attached.
        // See: https://github.com/square/picasso/issues/1321
        if (target.getWindowToken() != null) {
          onViewAttachedToWindow(target);
        }
    }

    // 添加onAttachStateChangeListener的两个方法
    @Override public void onViewAttachedToWindow(View view) {
        view.getViewTreeObserver().addOnPreDrawListener(this);
    }
    // 添加onAttachStateChangeListener的两个方法
    @Override public void onViewDetachedFromWindow(View view) {
        view.getViewTreeObserver().removeOnPreDrawListener(this);
    }

    @Override public boolean onPreDraw() {
        ImageView target = this.target.get();
        if (target == null) {
          return true;
        }

        ViewTreeObserver vto = target.getViewTreeObserver();
        if (!vto.isAlive()) {
          return true;
        }

        int width = target.getWidth();
        int height = target.getHeight();

        if (width <= 0 || height <= 0 || target.isLayoutRequested()) {
            return true;
        }

        target.removeOnAttachStateChangeListener(this);
        vto.removeOnPreDrawListener(this);
        this.target.clear();

        // 通过unfit函数取消延迟加载的标识,通过resize设置尺寸,最后通过into函
        // 数生成最终的Request并提交到线程池去执行
        this.creator.unfit().resize(width, height).into(target, callback);
        return true;
    }
    ...
}

DeferredRequestCreator实现延迟加载,是通过给目标View注册onAttachStateChangeListener监听器实现的,监听器的两个接口函数onViewAttachedToWindow,onViewDetachedFromWindow分别对应了一个View被放置到界面上,和从界面上收回两个时间节点。在onViewAttachedToWindow中,给view的ViewTreeObserver添加onPreDrawListener监听器,并在onViewDetachedFromWindow中删除该监听器。onPreDrawListener监听器的onPreDraw接口函数会在界面完成测量后将要被展示出来前调用,此时可以获取到view的宽高,从而知道需要将加载的图片缩放到的具体尺寸。获取到具体尺寸后就可以通过unfit函数取消延迟加载的标识,通过resize设置尺寸,最后通过into函数生成最终的Request并提交到线程池去执行。

这是into函数里面需要延迟执行的情形的处理。如果没有通过fit进行自适应,而是一开始就指定了需要加载图片的宽高,就走第二个分支的逻辑,尝试从缓存获取。

    Request request = createRequest(started);
    // 根据请求的图片和各个请求参数,如Uri,rotationDegrees,resize,centerCorp,centerInside等
    // 生成一个用于标识的字符串,作为缓存中的key
    String requestKey = createKey(request);

    // 第二个分支:从缓存中获取
    // 如果设置了缓存(通过memoryPolicy方法设置),先试图从缓存获取,获取成功直接返回
    if (shouldReadFromMemoryCache(memoryPolicy)) {
      Bitmap bitmap = picasso.quickMemoryCacheCheck(requestKey);
      if (bitmap != null) {
        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;
      }
    }

createRequest会根据RequestCreator的各个设置项生成一个request,然后通过createKey生成一个key值:

private Request createRequest(long started) {
    int id = nextId.getAndIncrement();
    // data.build构造者模式
    Request request = data.build();
    request.id = id;
    request.started = started;

    boolean loggingEnabled = picasso.loggingEnabled;
    if (loggingEnabled) {
      log(OWNER_MAIN, VERB_CREATED, request.plainId(), request.toString());
    }
    // 如果设置了RequestTransformer则先transform一下request
    Request transformed = picasso.transformRequest(request);
    if (transformed != request) {
      // If the request was changed, copy over the id and timestamp from the original.
      transformed.id = id;
      transformed.started = started;

      if (loggingEnabled) {
        log(OWNER_MAIN, VERB_CHANGED, transformed.logId(), "into " + transformed);
      }
    }

    return transformed;
  }
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) {
      //noinspection ForLoopReplaceableByForEach
      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();
  }

从createKey的实现可以看出,同一个来源的图片,如果加载参数不同,会生成不同的key,并分别存储到缓存中。接下来判断是否设置了内存缓存,如果设置的话通过picasso.quickMemoryCacheCheck根据key查找缓存内容,找到的话返回这个bitmap,并设置给view。

public class Picasso {
    ...
    final Cache cache;
    ...
    Bitmap quickMemoryCacheCheck(String key) {
        // 从Cache中查找
        Bitmap cached = cache.get(key);
        if (cached != null) {
          stats.dispatchCacheHit();
        } else {
          stats.dispatchCacheMiss();
        }
        return cached;
        }
        ...
}

我们看看Cache类具体是怎样实现的:

public interface Cache {
    /** Retrieve an image for the specified {@code key} or {@code null}. */
    Bitmap get(String key);

    /** Store an image in the cache for the specified {@code key}. */
    void set(String key, Bitmap bitmap);

    /** Returns the current size of the cache in bytes. */
    int size();

    /** Returns the maximum size in bytes that the cache can hold. */
    int maxSize();

    /** Clears the cache. */
    void clear();

    /** Remove items whose key is prefixed with {@code keyPrefix}. */
    void clearKeyUri(String keyPrefix);

    /** A cache which does not store any values. */
    Cache NONE = new Cache() {
            @Override public Bitmap get(String key) {
            return null;
        }

        @Override public void set(String key, Bitmap bitmap) {
            // Ignore.
        }

        @Override public int size() {
            return 0;
        }

        @Override public int maxSize() {
            return 0;
        }

        @Override public void clear() {
        }

        @Override public void clearKeyUri(String keyPrefix) {
        }
    };
}

可以看到,Cache是一个接口类,规范了一系列对缓存的操作接口,包括get/set/size/clear等,还包含一个空实现。Picasso提供了一个实现了Cache接口的类LruCache,用户也可以提供自己的实现。

public class LruCache implements Cache {
    final LinkedHashMap<String, Bitmap> map;
    private final int maxSize;

    private int size;
    private int putCount;
    private int evictionCount;
  
    ...
    public LruCache(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("Max size must be positive.");
        }
        this.maxSize = maxSize;
        this.map = new LinkedHashMap<>(0, 0.75f, true);
    }

    @Override public Bitmap get(@NonNull String key) {
        if (key == null) {
            throw new NullPointerException("key == null");
        }

        Bitmap mapValue;
        synchronized (this) {
            mapValue = map.get(key);
            if (mapValue != null) {
                hitCount++;
                return mapValue;
            }
            missCount++;
        }

        return null;
    }

    @Override public void set(@NonNull String key, @NonNull Bitmap bitmap) {
        if (key == null || bitmap == null) {
            throw new NullPointerException("key == null || bitmap == null");
        }

        int addedSize = Utils.getBitmapBytes(bitmap);
        if (addedSize > maxSize) {
            return;
        }

        synchronized (this) {
            putCount++;
            size += addedSize;
            Bitmap previous = map.put(key, bitmap);
            if (previous != null) {
                size -= Utils.getBitmapBytes(previous);
            }
        }

        trimToSize(maxSize);
      }
    }

    private void trimToSize(int maxSize) {
        while (true) {
            String key;
            Bitmap value;
            synchronized (this) {
                if (size < 0 || (map.isEmpty() && size != 0)) {
                      throw new IllegalStateException(
                          getClass().getName() + ".sizeOf() is reporting inconsistent results!");
        }

        if (size <= maxSize || map.isEmpty()) {
            break;
        }

        // LinkedHashMap遍历输出的顺序跟元素插入的顺序相同,所以缓存的换出机制是FIFO
        Map.Entry<String, Bitmap> toEvict = map.entrySet().iterator().next();
        key = toEvict.getKey();
        value = toEvict.getValue();
        map.remove(key);
        size -= Utils.getBitmapBytes(value);
        evictionCount++;
      }
    }
  }
    ...
}

LruCache通过一个LinkedHashMap来存储图片键值对,LinkedHashMap结合了链表的FIFO特性以及HashMap的键值对存取特性,通过iterator遍历的时候保证先加入的先遍历到,当缓存的大小达到设定值的时候,通过trimToSize函数进行缓存的换出,借助LinkedHashMap实现FIFO的换出策略。同时注意由于多个线程可以同时存取缓存,需要进行线程同步机制,这里是通过synchronized加锁实现的。

如果缓存没有命中,进入into函数第三个分支,通过网络或文件系统加载。

    // 第三个分支:从网络或文件系统加载
    // 如果从缓存获取失败,则生成一个Action来加载该图片。
    // 一个Action包含了complete/error/cancel等回调函数
    // 对应了图片加载成功,失败,取消加载的操作
    Action action =
        new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId,
            errorDrawable, requestKey, tag, callback, noFade);

    // 通过picasso对象将该action加入执行队列,里面的任务通过ThreadPoolExecutor线程池执行
    picasso.enqueueAndSubmit(action);

这里一次图片加载的操作是通过一个Action来表示的,Action是一个接口类,提供了跟一次图片加载相关的操作,比如请求的Request,网络缓存策略,内存缓存策略,加载成功的回调函数,失败的回调,取消的回调等。

abstract class Action<T> {
    static class RequestWeakReference<M> extends WeakReference<M> {
        final Action action;
        public RequestWeakReference(Action action, M referent, ReferenceQueue<? super M> q) {
        super(referent, q);
        this.action = action;
      }
    }

    final Picasso picasso;
    final Request request;
    final WeakReference<T> target;

    abstract void complete(Bitmap result, Picasso.LoadedFrom from);
    abstract void error(Exception e);
    void cancel() {
        cancelled = true;
    }
    ...
}

Picasso提供了几种Action的实现,包括ImageViewAction(图片加载并展示到ImageView),NotificationAction(图片加载并展示到Notification),GetAction(图片同步加载不展示),FetchAction(图片异步加载并设置回调函数)等,下面给出ImageViewAction的代码:

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) {
        if (result == null) {
            throw new AssertionError(
            String.format("Attempted to complete action with no result!\n%s", this));
        }

        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();
        }
    }

    @Override public void error(Exception e) {
        ImageView target = this.target.get();
        if (target == null) {
            return;
        }
        Drawable placeholder = target.getDrawable();
        if (placeholder instanceof AnimationDrawable) {
            ((AnimationDrawable) 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;
        }
    }
}

构造完Action通过picasso对象加入线程池执行:

    // 通过picasso对象将该action加入执行队列,里面的任务通过ThreadPoolExecutor线程池执行
    picasso.enqueueAndSubmit(action);
public class Picasso {
    ...
    final Dispatcher dispatcher;
    ...
    void enqueueAndSubmit(Action action) {
        Object target = action.getTarget();
        if (target != null && targetToAction.get(target) != action) {
            // This will also check we are on the main thread.
            cancelExistingRequest(target);
            targetToAction.put(target, action);
        }
        submit(action);
    }

    void submit(Action action) {
        dispatcher.dispatchSubmit(action);
    }
    ...
}

Picasso调用Dispatcher类进行消息的分发:

class Dispatcher {
    ...
    final Handler handler;
    ...
    Dispatcher(Context context, ExecutorService service, Handler mainThreadHandler,
          Downloader downloader, Cache cache, Stats stats) {
        ...
        this.handler = new DispatcherHandler(dispatcherThread.getLooper(), this);
        ...
    }
    void dispatchSubmit(Action action) {
        handler.sendMessage(handler.obtainMessage(REQUEST_SUBMIT, action));
    }
    ...
}

DispatcherHandler提供对各种动作的响应,包括提交一个Action,取消Action,暂停等等。

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);
            }
          });
      }
    }
  }

我们看一下提交一个Action最终是怎样得到执行的:

void performSubmit(Action action, boolean dismissFailed) {
    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;
    }
    
    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;
    }
    // 根据每个Action创建一个Hunter对象,并通过ExecutorService提交到线程池执行
    hunter = forRequest(action.getPicasso(), this, cache, stats, action);
    hunter.future = service.submit(hunter);
    hunterMap.put(action.getKey(), hunter);
    if (dismissFailed) {
      failedActions.remove(action.getTarget());
    }

    if (action.getPicasso().loggingEnabled) {
      log(OWNER_DISPATCHER, VERB_ENQUEUED, action.request.logId());
    }
  }

可以看到performSubmit函数会根据每个Action创建一个BitmapHunter对象,并通过ExecutorService提交到线程池执行。BitmapHunter是一个多线程类,提供了加载图片的操作:

class BitmapHunter implements Runnable {
    @Override public void run() {
        try {
          updateThreadName(data);

          if (picasso.loggingEnabled) {
              log(OWNER_HUNTER, VERB_EXECUTING, getLogIdsForHunter(this));
          }

          result = hunt();

          if (result == null) {
            dispatcher.dispatchFailed(this);
          } else {
            dispatcher.dispatchComplete(this);
          }
        } catch (NetworkRequestHandler.ResponseException e) {
          if (!NetworkPolicy.isOfflineOnly(e.networkPolicy) || e.code != 504) {
            exception = e;
          }
          dispatcher.dispatchFailed(this);
        }  
        ...
    }
    ...
}

看一下hunt()函数的实现:

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.OFFLINE.index : networkPolicy;
    // 通过requestHandler.load进行加载
    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) {
        Source source = result.getSource();
        try {
          // 获取加载成功的bitmap
          bitmap = decodeStream(source, data);
        } finally {
          try {
            //noinspection ConstantConditions If bitmap is null then source is guranteed non-null.
            source.close();
          } catch (IOException ignored) {
          }
        }
      }
    }

    if (bitmap != null) {
      if (picasso.loggingEnabled) {
        log(OWNER_HUNTER, VERB_DECODED, data.logId());
      }
      stats.dispatchBitmapDecoded(bitmap);
      // 如果设置了对bitmap的transform函数,执行transform操作
      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;
  }

再次尝试从内存缓存获取,之前没再内存缓存中,说不定这时候已经在了。如果获取不到,调用RequestHandler的load函数进行真正的加载操作。

RequestHandler是个虚基类,提供了统一的加载接口:

public abstract class RequestHandler {
    ...
    @Nullable public Bitmap getBitmap() {
      return bitmap;
    }
    @Nullable public abstract Result load(Request request, int networkPolicy) throws IOException;
    ...
}

NetworkRequestHandler,ContactsPhotoRequestHandler,AssetRequestHandler,ContentStreamRequestHandler,ResourceRequestHandler等都实现了RequestHandler基类,分别提供了网络加载,联系人图片加载,Asset资源加载,文件加载,Resource资源图片加载等不同的加载方式。

这样,就完成了Picasso加载图片的整个流程分析。代码量适中,结构也比较清晰,适合阅读学习。

日记本
Web note ad 1