Picasso粗糙分析

Picasso

1.在第一步可以设置BitmapConfig（图片配置），Downloader（下载器，如果网络库引用了okHttp，则使用okhttp进行下载）,Executor（线程池）,MemoryCache（缓存）, Listener(回调),Transformer（对请求进行转换）,RequestHandler（对请求进行处理）,Debugging,Log,Indicator.

  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;

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

    /**
     * Specify the default {@link Bitmap.Config} used when decoding images. This can be overridden
     * on a per-request basis using {@link RequestCreator#config(Bitmap.Config) config(..)}.
     */
    public Builder defaultBitmapConfig(@NonNull Bitmap.Config bitmapConfig) {
      if (bitmapConfig == null) {
        throw new IllegalArgumentException("Bitmap config must not be null.");
      }
      this.defaultBitmapConfig = bitmapConfig;
      return this;
    }

    /** Specify the {@link Downloader} that will be used for downloading images. */
    public Builder downloader(@NonNull Downloader downloader) {
      if (downloader == null) {
        throw new IllegalArgumentException("Downloader must not be null.");
      }
      if (this.downloader != null) {
        throw new IllegalStateException("Downloader already set.");
      }
      this.downloader = downloader;
      return this;
    }

    /**
     * Specify the executor service for loading images in the background.
     * <p>
     * Note: Calling {@link Picasso#shutdown() shutdown()} will not shutdown supplied executors.
     */
    public Builder executor(@NonNull ExecutorService executorService) {
      if (executorService == null) {
        throw new IllegalArgumentException("Executor service must not be null.");
      }
      if (this.service != null) {
        throw new IllegalStateException("Executor service already set.");
      }
      this.service = executorService;
      return this;
    }

    /** Specify the memory cache used for the most recent images. */
    public Builder memoryCache(@NonNull Cache memoryCache) {
      if (memoryCache == null) {
        throw new IllegalArgumentException("Memory cache must not be null.");
      }
      if (this.cache != null) {
        throw new IllegalStateException("Memory cache already set.");
      }
      this.cache = memoryCache;
      return this;
    }

    /** Specify a listener for interesting events. */
    public Builder listener(@NonNull Listener listener) {
      if (listener == null) {
        throw new IllegalArgumentException("Listener must not be null.");
      }
      if (this.listener != null) {
        throw new IllegalStateException("Listener already set.");
      }
      this.listener = listener;
      return this;
    }

    /**
     * Specify a transformer for all incoming requests.
     * <p>
     * <b>NOTE:</b> This is a beta feature. The API is subject to change in a backwards incompatible
     * way at any time.
     */
    public Builder requestTransformer(@NonNull RequestTransformer transformer) {
      if (transformer == null) {
        throw new IllegalArgumentException("Transformer must not be null.");
      }
      if (this.transformer != null) {
        throw new IllegalStateException("Transformer already set.");
      }
      this.transformer = transformer;
      return this;
    }

    /** Register a {@link RequestHandler}. */
    public Builder addRequestHandler(@NonNull RequestHandler requestHandler) {
      if (requestHandler == null) {
        throw new IllegalArgumentException("RequestHandler must not be null.");
      }
      if (requestHandlers == null) {
        requestHandlers = new ArrayList<RequestHandler>();
      }
      if (requestHandlers.contains(requestHandler)) {
        throw new IllegalStateException("RequestHandler already registered.");
      }
      requestHandlers.add(requestHandler);
      return this;
    }

    /**
     * @deprecated Use {@link #indicatorsEnabled(boolean)} instead.
     * Whether debugging is enabled or not.
     */
    @Deprecated public Builder debugging(boolean debugging) {
      return indicatorsEnabled(debugging);
    }

    /** Toggle whether to display debug indicators on images. */
    public Builder indicatorsEnabled(boolean enabled) {
      this.indicatorsEnabled = enabled;
      return this;
    }

    /**
     * Toggle whether debug logging is enabled.
     * <p>
     * <b>WARNING:</b> 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;

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

在build的过程中，默认的实现了downloader、cache、executor、transformer。并且在其之中还调用了一个调度器dispatcher，这个接着就会提到他。

2.调用load()方法生成RequestCreator,RequestCteator包含了对本次请求的处理，包括对图片的处理、设置占位图、网络策略、缓存策略等。
load()可加载Uri、Path、File、ResourceId等图片资源，除了ResourceId外，其余最后都会调用Uri的方法

/**
   * Start an image request using the specified URI.
   * <p>
   * Passing {@code null} as a {@code uri} will not trigger any request but will set a placeholder,
   * if one is specified.
   *
   * @see #load(File)
   * @see #load(String)
   * @see #load(int)
   */
  public RequestCreator load(@Nullable Uri uri) {
    return new RequestCreator(this, uri, 0);
  }

---

我们可以把RequestCreator视为对这个请求的一系列操作，它能够设置占位图、加载失败图、对本次请求添加tag（以便对本次请求进行暂停、恢复、甚至取消操作）、fit（按照ImageView的大小设置图片，所以仅能当Target为ImageView时才能进行）、unfit、resize（设置图片大小，与fit冲突，不可同时设置）、centerCrop、centerInside、onlyScaleDown（只有当原图的尺寸比target大时才进行resize）、rotate、config（再解码图片时使用自己的配置）、stableKey（取代地址或者是Uri当缓存的key，这个可以避免重名）、priority（可以对request的级别进行提升以便尽快执行，但是这个并不完全保证能够按照级别进行执行）、transform（自定义一个对图片的处理）、memoryPolicy（缓存策略）、networkPolicy（网络请求策略）、purgeable（在decode 图片的时候开启 inPurgeable 和 inInputShareable）、noFade、get（同步获取图片并且不能缓存在内存中，不可再main thread使用）、fetch（预先下载图片但并不需要填充到控件，起到预热缓存的作用）、into（需要在主线程调用）

  /**
   * Asynchronously fulfills the request into the specified {@link Target}. In most cases, you
   * should use this when you are dealing with a custom {@link android.view.View View} or view
   * holder which should implement the {@link Target} interface.
   * <p>
   * Implementing on a {@link android.view.View View}:
   * public class ProfileView extends FrameLayout implements Target {
   *   {@literal @}Override public void onBitmapLoaded(Bitmap bitmap, LoadedFrom from) {
   *     setBackgroundDrawable(new BitmapDrawable(bitmap));
   *   }
   *
   *   {@literal @}Override public void onBitmapFailed() {
setBackgroundResource(R.drawable.profile_error);
   *   }
   *   {@literal @}Override public void onPrepareLoad(Drawable placeHolderDrawable) {
   *     frame.setBackgroundDrawable(placeHolderDrawable);
   *   }
   * }
   * Implementing on a view holder object for use inside of an adapter:
   * public class ViewHolder implements Target {
   *   public FrameLayout frame;
   *   public TextView name;
   *   {@literal @}Override public void onBitmapLoaded(Bitmap bitmap, LoadedFrom from) {
   *     frame.setBackgroundDrawable(new BitmapDrawable(bitmap));
   *   }
   *   {@literal @}Override public void onBitmapFailed() {
   *     frame.setBackgroundResource(R.drawable.profile_error);
   *   }
   *
   *   {@literal @}Override public void onPrepareLoad(Drawable placeHolderDrawable) {
   *     frame.setBackgroundDrawable(placeHolderDrawable);
   *   }
   * }
   * </pre></blockquote>
   * <p>
   * <em>Note:</em> This method keeps a weak reference to the {@link Target} instance and will be
   * garbage collected if you do not keep a strong reference to it. To receive callbacks when an
   * image is loaded use {@link #into(android.widget.ImageView, Callback)}.
   */
  public void into(@NonNull 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);
  }

在into这个方法中，显示判断一下是否在主线程，在判断是否设置图片资源，再看看是否调用了fit()方法设置脱险大小，如果设置了fit 则不能再使用热死则方法调整大小。在检查一下内存缓存看是否有匹配，成功则设置图片，不成功则设置占位图，在组织action，调用picasso的enqueueAndSubmit执行这个action。

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

在picasso里面维护了一个即将执行的map，先会判断一下这个action是否之前添加过，如果添加过，则将之前添加的取消，再将这个Action添加进这个map，然后调用submit方法执行action。

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

在dispatcher中通过handler最终调用了performsubmit方法

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

    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());
    }
  }
  ```
在这个方法中，先判断了这个action是否在暂停列表中，在判断huntermap是否有对应的BitmapHunter，这个BitmapHunter是继承了Runnable接口、执行下载并进行图片转换的地方。然后添加进线程池执行，我们看一下BitmapHunter的run方法

@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 (Downloader.ResponseException e) {
  if (!e.localCacheOnly || e.responseCode != 504) {
    exception = e;
  }
  dispatcher.dispatchFailed(this);
} catch (NetworkRequestHandler.ContentLengthException e) {
  exception = e;
  dispatcher.dispatchRetry(this);
} catch (IOException e) {
  exception = e;
  dispatcher.dispatchRetry(this);
} catch (OutOfMemoryError e) {
  StringWriter writer = new StringWriter();
  stats.createSnapshot().dump(new PrintWriter(writer));
  exception = new RuntimeException(writer.toString(), e);
  dispatcher.dispatchFailed(this);
} catch (Exception e) {
  exception = e;
  dispatcher.dispatchFailed(this);
} finally {
  Thread.currentThread().setName(Utils.THREAD_IDLE_NAME);
}

}

  整个run方法中只有一句关键的就是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;
}
}
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);
  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; }


在requestHandler.load(data, networkPolicy)这个方法中，RequestHandler通过Downloader下载了图片，然后对bitmap的处理过程添加了线程锁，大概是为了避免同时处理图片出现问题。
在回到run方法当我们下载成功后，在用dispatcher通知dispatchComplete
然后通过handler不断调用，最终调用performComplete方法之中

void performComplete(BitmapHunter hunter) {
if (shouldWriteToMemoryCache(hunter.getMemoryPolicy())) {
cache.set(hunter.getKey(), hunter.getResult());
}
hunterMap.remove(hunter.getKey());
batch(hunter);
if (hunter.getPicasso().loggingEnabled) {
log(OWNER_DISPATCHER, VERB_BATCHED, getLogIdsForHunter(hunter), “for completion”);
}
}
“`
在这个方法中，添加进缓存，再将hunter移出huntermap
在调用batch方法，将hunter添加进列表里。
这个batch的作用是将200ms内完成的请求一次性的交给主线程去执行。
batch最终会调用mainHandlerde complete方法，complete将图片设置给target，调用listener 完成。

在dispatcher中完成了各项请求从mainThread到dispaTcherthread再到downloadThread的跳转。
下面是几个有意思的点
1.picasso只提供了内存缓存，并没有提供硬盘缓存，那为什么说有两级缓存呢，因为picasso将硬盘缓存使用了下载器的硬盘缓存。并且如果项目中引进了okhttp，就会优先使用okhttp，我们看一下picasso的build方法中，默认实现了一个downloader

        downloader = Utils.createDefaultDownloader(context);
      }

---

在Utils中
“` static Downloader createDefaultDownloader(Context context) {
if (SDK_INT >= GINGERBREAD) {
try {
Class.forName(“okhttp3.OkHttpClient”);
return OkHttp3DownloaderCreator.create(context);
} catch (ClassNotFoundException ignored) {
}
try {
Class.forName(“com.squareup.okhttp.OkHttpClient”);
return OkHttpDownloaderCreator.create(context);
} catch (ClassNotFoundException ignored) {
}
}
return new UrlConnectionDownloader(context);
}

2.在picasso 的build方法中，线程池的建立
```if (service == null) {
        service = new PicassoExecutorService();
      }

  在这个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);
}

}
“`
针对各种网络环境下实现了不同的线程池数量。很贴心有木有

3.picasso可以为所有实现target接口的view设置图片，
4.picasso不断判断是否之前加入过此view可以修正在滚动列表中图片错乱的毛病。