[Android组件解读] Picasso详解

前言

昨天讲解了square公司的leakcanary，现在来讲解下他的图片库－Picasso。

Picasso在前期是比较好的一个图片加载库，相对于Universal-Image-Loader(应该已经被弃用了，想了解可以点击这个Android-Universal-Image-Loader 图片异步加载类库的使用（超详细配置）)

但是技术的革新是很快的，没过几个月就有其他的产品出现，如Google推荐的图片加载库Glide,FaceBook的Fresco

其实目前更多App使用的是Fresco，因为其支持Gif,支持图片渐进展示，内存合理的管理

本文先讲解Picasso的使用及原理（或许再过几个月就被抛弃了，写篇文章纪念下吧）,后续在讲解其他的图片库

Picasso介绍

Picasso

picasso是Square公司开源的一个Android图形缓存库，地址http://square.github.io/picasso/，可以实现图片下载和缓存功能。仅仅只需要一行代码就能完全实现图片的异步加载：

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

如何使用Picasso

1. 在build.gradle中添加引用

    // 加载Picasso
    compile 'com.squareup.picasso:picasso:2.5.2'
   

2. 代码调用，此处需要将一个imageView传到Picasso中

    在xml中添加
     
    
    在Activity中添加
    Picasso.with(this).load("http://7xrn7f.com1.z0.glb.clouddn.com/16-6-12/59488576.jpg").into(imageView);
   

   除了URL还可以load其他的资源:

   
   
   

   Picasso加载链接方式

3. [重要]Picasso的Debug模式

    Picasso.with(this).setLoggingEnabled(true);
    可以在控制台显示Picasso运行的日志
    
    Picasso.with(this).setIndicatorsEnabled(true);
    在最后生成的PicassoDrawable类的ondraw里绘制了个左上角小三角，根据
    public enum LoadedFrom {
        MEMORY(Color.GREEN),
        DISK(Color.BLUE),
        NETWORK(Color.RED);
    }
    
    在ImageView的左上角显示。
    绿色－从内存中加载的图片
    蓝色－从磁盘中加载的图片
    红色－从网络中加载的图片
   

其他相关资料

picasso-强大的Android图片下载缓存库--picasso相关的介绍

使用Picasso加载图片的内存优化实践 --探索图片内存使用优化

---

使用方式讲到这里，现在开始研究下代码
先抛几个问题

1. Picasso如何加载图片，并展示图片
2. Picasso中的图片内存是怎么优化的
3. 怎么实现在Adapter中的回收不在视野的ImageView

OK，那我们带着问题看他的源码

代码讲解

首先看他的代码目录结构

代码目录结构

.
├── Action.java
├── AssetRequestHandler.java
├── BitmapHunter.java --加载图片线程池
├── Cache.java
├── Callback.java
├── ContactsPhotoRequestHandler.java
├── ContentStreamRequestHandler.java
├── DeferredRequestCreator.java
├── Dispatcher.java --事件处理机，调度者
├── Downloader.java
├── FetchAction.java
├── FileRequestHandler.java
├── GetAction.java
├── ImageViewAction.java
├── LruCache.java --Picasso默认缓存，自己开辟空间
├── MarkableInputStream.java
├── MediaStoreRequestHandler.java
├── MemoryPolicy.java
├── NetworkPolicy.java
├── NetworkRequestHandler.java
├── OkHttp3Downloader.java --Picasso默认下载器，实现了Downloader.java的方法
├── Picasso.java  --主入口，对外提供的方法：with(context),load()
├── PicassoDrawable.java
├── PicassoExecutorService.java --Picasso默认线程池,根据网络情况创建线程池的大小，Wifi(4),4G(3),3G(2),2G(1)
├── RemoteViewsAction.java
├── Request.java
├── RequestCreator.java
├── RequestHandler.java --实现各种资源请求方式的抽象类，像ResourceRequestHandler，FileRequestHandler，NetworkRequestHandler都是请求资源方式
├── ResourceRequestHandler.java
├── Stats.java  -- 数据统计
├── StatsSnapshot.java －－数据统计内存快照，将数据输出在控制台
├── Target.java
├── TargetAction.java
├── Transformation.java  --Image转换的接口，用在RequestCreateor.transform方法,可以实现圆角图片
└── Utils.java  --工具类

其中对外的的两个类是Picasso和RequestCreator

Picasso提供了如下的方法

Markdown

RequestCreator提供了如下的方法

Markdown

分析Picasso.with(context).load(XXX).into(imageView)

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的对象，通过Builder模式进行构建

 public static class Builder {
    // 上下文对象
    private final Context context;
    // 下载器对象
    private Downloader downloader;
    // 线程池对象
    private ExecutorService service;
    // 缓存对象
    private Cache cache;
    // 监听器，图片Load失败监听器
    private Listener listener;
    private RequestTransformer transformer;
    private List requestHandlers;
    // 默认图片控制
    private Bitmap.Config defaultBitmapConfig;
    
    // Debug模式
    // 显示加载方式角标
    private boolean indicatorsEnabled;
    // 显示Debug日志
    private boolean loggingEnabled;

    /** Start building a new {@link Picasso} instance. */
    public Builder(@NonNull Context context) {
      if (context == null) {
        throw new IllegalArgumentException("Context must not be null.");
      }
      this.context = context.getApplicationContext();
    }
    
    ....
    
    /**
     * Toggle whether debug logging is enabled.
     * 

     * WARNING: Enabling this will result in excessive object allocation. This should be only
     * be used for debugging purposes. Do NOT pass {@code BuildConfig.DEBUG}.
     */
    public Builder loggingEnabled(boolean enabled) {
      this.loggingEnabled = enabled;
      return this;
    }

   /** Create the {@link Picasso} instance. */
    public Picasso build() {
      Context context = this.context;

      // 默认使用OkHttp3Downloader，okhttp3下载
      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 = new Stats(cache);

      // Picasso调度器
      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构造器中添加各种Load编译器

 // 本地资源请求器，支持Res文件
    allRequestHandlers.add(new ResourceRequestHandler(context));
    if (extraRequestHandlers != null) {
      allRequestHandlers.addAll(extraRequestHandlers);
    }
    // 相册资源请求器，支持这种格式'contacts/#/photo'
    allRequestHandlers.add(new ContactsPhotoRequestHandler(context));
    // 多媒体资源请求器，获取Video获取缩略图
    allRequestHandlers.add(new MediaStoreRequestHandler(context));
    // content资源请求，支持'content://'
    allRequestHandlers.add(new ContentStreamRequestHandler(context));
    // assets资源请求，支持'file:///android_asset/'
    allRequestHandlers.add(new AssetRequestHandler(context));
    // 文件资源请求，支持'file://'
    allRequestHandlers.add(new FileRequestHandler(context));
    // 网络资源请求，使用OKttp去加载
    allRequestHandlers.add(new NetworkRequestHandler(dispatcher.downloader, stats));
    // 将其设置为不可变List
    requestHandlers = Collections.unmodifiableList(allRequestHandlers);

调用load方法进入

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

获取到RequestCreator的对象，RequestCreator中存在各种配置。

对图片的配置：

图片配置

对内存的配置：

内存配置

可以配置不写缓存/不写磁盘
public enum MemoryPolicy {
  /** Skips memory cache lookup when processing a request. */
  NO_CACHE(1 << 0),
  /**
   * Skips storing the final result into memory cache. Useful for one-off requests
   * to avoid evicting other bitmaps from the cache.
   */
  NO_STORE(1 << 1);
  }

对网络的配置:

网络配置

可以配置离线/请求数据不记录缓存/请求数据不记录磁盘
public enum NetworkPolicy {

  /** Skips checking the disk cache and forces loading through the network. */
  NO_CACHE(1 << 0),

  /**
   * Skips storing the result into the disk cache.
   * 

   * Note: At this time this is only supported if you are using OkHttp.
   */
  NO_STORE(1 << 1),

  /** Forces the request through the disk cache only, skipping network. */
  OFFLINE(1 << 2);
}

最后调用RequestCreator.into()方法

 /**
   * Asynchronously fulfills the request into the specified {@link ImageView} and invokes the
   * target {@link Callback} if it's not {@code null}.
   * 

   * Note: The {@link Callback} param is a strong reference and will prevent your
   * {@link android.app.Activity} or {@link android.app.Fragment} from being garbage collected. If
   * you use this method, it is strongly recommended you invoke an adjacent
   * {@link Picasso#cancelRequest(android.widget.ImageView)} call to prevent temporary leaking.
   */
  public void into(ImageView target, Callback callback) {
    long started = System.nanoTime();
    // 检查是否在主线程
    checkMain();

    // 判断ImageView不允许为空
    if (target == null) {
      throw new IllegalArgumentException("Target must not be null.");
    }

    // 判断请求的url是否为空
    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 || target.isLayoutRequested()) {
        if (setPlaceholder) {
          setPlaceholder(target, getPlaceholderDrawable());
        }
        picasso.defer(target, new DeferredRequestCreator(this, target, callback));
        return;
      }
      data.resize(width, height);
    }

    Request request = createRequest(started);
    String requestKey = createKey(request);

    // 从缓存中读取图片
    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;
      }
    }

    // 设置Loading图片
    if (setPlaceholder) {
      setPlaceholder(target, getPlaceholderDrawable());
    }


    // 创建Action, 这个Action发送给Dispatcher进行分发处理
    Action action =
        new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId,
            errorDrawable, requestKey, tag, callback, noFade);

    picasso.enqueueAndSubmit(action);
  }

该方法调用之后会创建Action，然后这个Action会发送给Dispatcher处理，然后根据发送的Action中的Request中的uri选择哪个图片加载器，找到之后生成一个BitmapHunter对象，BitmapHunter是一个runnable,会执行加载图片的功能，最后加载完成之后，通过Dispatcher进行回调

Picasso的线程池

此处需要介绍下Picasso的线程池，是 根据网络情况进行创建

private static final int DEFAULT_THREAD_COUNT = 3;

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

OK,Picasso的图片加载方式讲到这儿了

Picasso中的图片内存

通过自定义的内存大小进行管理

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

怎么实现在Adapter中的回收不在视野的ImageView

通过Picasso.pauseTag(tag),Picasso.resumeTag(tag)进行暂停/恢复加载，其实质是向Dispater发送Message删除缓存中的事件队列