Picasso源码分析

Picasso是一个由Square公司开源的强大的Android图片下载缓存库，仅仅只需要一行代码就可以实现图片的异步加载。

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

Picasso还解决了Android加载图片时需要解决的一些常见问题：

在adapter中取消不在屏幕范围内的ImageView图片的加载
使用复杂的图片转换来尽可能减少内存消耗
自带内存和硬盘的二级缓存

使用样例：

Adapter中下载： Adapter的重用会被自动检测到，Picasso会取消上次的加载

@Override public void getView(int position, View convertView, ViewGroup parent) {  SquaredImageView view = (SquaredImageView) convertView;  if (view == null) {    view = new SquaredImageView(context);  }  String url = getItem(position);  Picasso.with(context).load(url).into(view);}

2.图片转换：转换图片以适应布局大小并减少内存占用

Picasso.with(context)  .load(url)  .resize(50, 50)  .centerCrop()  .into(imageView)

3.自定义转换

public class CropSquareTransformation implements Transformation {  @Override public Bitmap transform(Bitmap source) {    int size = Math.min(source.getWidth(), source.getHeight());    int x = (source.getWidth() - size) / 2;    int y = (source.getHeight() - size) / 2;    Bitmap result = Bitmap.createBitmap(source, x, y, size, size);    if (result != source) {      source.recycle();    }    return result;  }  @Override public String key() { return "square()"; }}

4.PlaceHolders: 空白或者错误占位图片：picasso提供了两种占位图片，未加载完成或者加载发生错误的时需要一张图片作为提示

Picasso.with(context)    .load(url)    .placeholder(R.drawable.user_placeholder)    .error(R.drawable.user_placeholder_error)    .into(imageView);

5.资源文件加载：除了加载网络图片picasso还支持加载Resources, assets, files, content providers中的资源文件

Picasso.with(context).load(R.drawable.landing_screen).into(imageView1);Picasso.with(context).load("file:///android_asset/DvpvklR.png").into(imageView2);Picasso.with(context).load(new File(...)).into(imageView3);

6.调试指示：对开发者来说，在Picasso实例中调用setIndicatorsEnabled(true) 方法，会显示红、绿、蓝三种颜色的色带来表示分别从网络、内存、硬盘中加载的资源

picasso.PNG

Picasso中几个重要的类介绍：

LruCache

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

LrcCache内存占用了应用可以使用的最大内存的 1/7（约为15%）。

static File createDefaultCacheDir(Context context) {    File cache = new File(context.getApplicationContext().getCacheDir(), PICASSO_CACHE);    if (!cache.exists()) {      //noinspection ResultOfMethodCallIgnored      cache.mkdirs();    }    return cache;  }

在初始化OkHttp3Downloader时，picasso会创建磁盘缓存的文件夹，在 /data/data/应用包名/cache/picasso-cache 目录下。

@TargetApi(JELLY_BEAN_MR2)  static long calculateDiskCacheSize(File dir) {    long size = MIN_DISK_CACHE_SIZE;    try {      StatFs statFs = new StatFs(dir.getAbsolutePath());      //noinspection deprecation      long blockCount =          SDK_INT < JELLY_BEAN_MR2 ? (long) statFs.getBlockCount() : statFs.getBlockCountLong();      //noinspection deprecation      long blockSize =          SDK_INT < JELLY_BEAN_MR2 ? (long) statFs.getBlockSize() : statFs.getBlockSizeLong();      long available = blockCount * blockSize;      // Target 2% of the total space.      size = available / 50;    } catch (IllegalArgumentException ignored) {    }    // Bound inside min/max size for disk cache.    return Math.max(Math.min(size, MAX_DISK_CACHE_SIZE), MIN_DISK_CACHE_SIZE);  }

Picasso会控制占用磁盘缓存的大小控制在5M~50M之间

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

LinkedHashMap<>(int initialCapacity,float loadFactor,boolean accessOrder) 构造方法参数含义：
initialCapacity：初始容量大小，使用无参构造方法时，此值默认是16
loadFactor：加载因子，使用无参构造方法时，此值默认是 0.75f
accessOrder false：基于插入顺序 true：基于访问顺序（使用了LRU 最近最少被使用的调度算法）

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

PicassoExecutorService是Picasso自己封装的线程池，可以看到Wify和以太网情况下设置的线程数量是4，4G网络条件下设置的线程数量是3，3G网络条件下设置的线程数量是2，2G网络条件下设置的线程数量是1，默认情况下设置的线程数量是3。

Request
封装了一系列的对图片的操作，例如改变图片大小、旋转图片、自定义变换等。

RequestCreator
使用Request.Builder创建了Request对象，后续对RequestCreator的设置都作用在Request对象中。

RequestHandler
抽象类，由不同的子类来实现不同来源的图片的获取与加载
实现类有：
AssetRequestHandler：加载asset里的图片
FileRequestHandler：加载硬盘里的图片
ResourceRequestHandler：加载资源图片
NetworkRequestHandler：加载网络图片

Action
Action代表了一个具体的加载任务，主要用于图片加载后的结果回调，有两个抽象方法，complete和error，也就是当图片解析为bitmap后用户希望做什么。最简单的就是将bitmap设置给imageview，失败了就将错误通过回调通知到上层。
具体实现类有：
1.GetAction:同步执行请求时使用。
2.FetchAction:当不需要ImageView来安置bitmap时的异步请求，通常用来预热缓存
3.RemoteViewsAction：用来更新远程图片（notification等）的抽象类。
4.TargetAction：一般在View（不只是ImageView）或者ViewHolder中用来加载图片,需要实现Target接口
5.ImageViewAction：最常用的Action，主要用来给ImageView加载图片

BitmapHunter
BitmapHunter实现了Runnable，将通过线程池下载和解析图片（hunt and decodeStream）。

Dispatcher
在Bitmaphunter成功得到bitmap后，dispatcher利用Handler机制负责对各种事件进行分发。

Stats
专门用于统计的类，负责将统计的数据发给Dispatcher处理

Picasso代码流程分析：

Picasso源码下载地址：https://github.com/square/picasso

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

我们来分析一下Picasso是如何将一张网络图片下载并加载到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类中找到 with() 方法，发现Picasso使用Builder().build() 来创建单例的Picasso对象，真正初始化Picasso的操作在 build() 方法中。

public Picasso build() {      Context context = this.context;      //Picasso依赖了OKHttp3，使用OkHttp来进行网络操作      if (downloader == null) {        downloader = new OkHttp3Downloader(context);      }      //使用LruChche缓存      if (cache == null) {        cache = new LruCache(context);      }      //自定义线程池      if (service == null) {        service = new PicassoExecutorService();      }      //初始化自定义的Transformer对象（用户对图片的自定义转换）      if (transformer == null) {        transformer = RequestTransformer.IDENTITY;      }      //状态控制类，用来发送各种消息，例如查找图片缓存的结果（击中/未击中），下载完成等      Stats stats = new Stats(cache);      //内部使用handler传递消息      Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats);      return new Picasso(context, dispatcher, cache, listener, transformer, requestHandlers, stats,          defaultBitmapConfig, indicatorsEnabled, loggingEnabled);    }  }

在 build() 中我们可以看到Picasso实例化了 OkHttp3Downloader、LruCache、PicassoExecutorService、Stats、Dispatcher，最后返回Picasso对象。

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

执行完with() ，我们再来看 load() ，发现Picasso将图片地址传入返回了一个RequestCreator 对象。

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

private Request createRequest(long started) {    int id = nextId.getAndIncrement();    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());    }    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;  }

RequestCreator中的 createRequest() 同样的使用 Builder().build() 创建了 Request 类对象。

public Request build() {      if (centerInside && centerCrop) {        throw new IllegalStateException("Center crop and center inside can not be used together.");      }      if (centerCrop && (targetWidth == 0 && targetHeight == 0)) {        throw new IllegalStateException(            "Center crop requires calling resize with positive width and height.");      }      if (centerInside && (targetWidth == 0 && targetHeight == 0)) {        throw new IllegalStateException(            "Center inside requires calling resize with positive width and height.");      }      if (priority == null) {        priority = Priority.NORMAL;      }      return new Request(uri, resourceId, stableKey, transformations, targetWidth, targetHeight,          centerCrop, centerInside, centerCropGravity, onlyScaleDown, rotationDegrees,          rotationPivotX, rotationPivotY, hasRotationPivot, purgeable, config, priority);    }

到 Request 类中查看 build() 方法。

public RequestCreator placeholder(@DrawableRes int placeholderResId) {    if (!setPlaceholder) {      throw new IllegalStateException("Already explicitly declared as no placeholder.");    }    if (placeholderResId == 0) {      throw new IllegalArgumentException("Placeholder image resource invalid.");    }    if (placeholderDrawable != null) {      throw new IllegalStateException("Placeholder image already set.");    }    this.placeholderResId = placeholderResId;    return this;  }

使用 placeholder 来设置默认图片

public RequestCreator error(@NonNull Drawable errorDrawable) {    if (errorDrawable == null) {      throw new IllegalArgumentException("Error image may not be null.");    }    if (errorResId != 0) {      throw new IllegalStateException("Error image already set.");    }    this.errorDrawable = errorDrawable;    return this;  }

使用 error 来设置出错时的图片

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 || 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;      }    }    if (setPlaceholder) {      setPlaceholder(target, getPlaceholderDrawable());    }    Action action =        new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId,            errorDrawable, requestKey, tag, callback, noFade);    picasso.enqueueAndSubmit(action);  }

接下来看看最后的 into() 方法，这个方法就是向ImageView中设置图片资源了，所以首先检查是否在主线程，不在主线程抛异常。再检测 imageview 是否为空，为空抛异常。再看是否有设置图片资源的uri和resourceId，如果没有则取消请求，如果设置了placeholder,则将plackholder中的资源设置到 imageView 中。当尝试调整图片的大小让其正好适合ImageView时，也就是调用了 fit() 方法时(deferred为true)，就调用 resize() 调整图片的大小。然后创建Request，根据Request创建 requestKey。如果需要从缓存中取数据，就在Cache缓存中根据requestKey来查询缓存的bitmap，如果查询到的bitmap不为空，则在imageView中设置查到的 bitmap，然后调用CallBack的onSuccess()回调方法。如果不是从缓存中取数据，就先设置placeholder中的图片，然后创建ImageViewAction对象，去执行picasso类的 enqueueAndSubmit() 方法。

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

然后是submit() 方法

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

后面就是 Dispatcher类中的 dispatchSubmit() 方法

void dispatchSubmit(Action action) {    handler.sendMessage(handler.obtainMessage(REQUEST_SUBMIT, action));  }

DispatcherHandler 类的 handleMessage() 方法

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

最后调到 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());    }  }

BitmapHunter的 forRequest()

static BitmapHunter forRequest(Picasso picasso, Dispatcher dispatcher, Cache cache, Stats stats,      Action action) {    Request request = action.getRequest();    List requestHandlers = picasso.getRequestHandlers();    // Index-based loop to avoid allocating an iterator.    //noinspection ForLoopReplaceableByForEach    for (int i = 0, count = requestHandlers.size(); i < count; i++) {      RequestHandler requestHandler = requestHandlers.get(i);      if (requestHandler.canHandleRequest(request)) {        return new BitmapHunter(picasso, dispatcher, cache, stats, action, requestHandler);      }    }    return new BitmapHunter(picasso, dispatcher, cache, stats, action, ERRORING_HANDLER);  }

根据不同的加载路径，选择合适的RequestHandler来创建BitmapHunter

再来看 BitmapHunter 类，实现了 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);    } 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);    }  }

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

Bitmap最终是由BitmapHunter的requestHandler.load()方法获取的，Picasso默认提供了ResourceRequestHandler、ContactsPhotoRequestHandler、MediaStoreRequestHandler、ContentStreamRequestHandler、 AssetRequestHandler、FileRequestHandler、NetworkRequestHandler等7中RequestHandler，用来从不同的来源获取Bitmap，下面重点分析NetworkRequestHandler的实现。

@Override public Result load(Request request, int networkPolicy) throws IOException {    okhttp3.Request downloaderRequest = createRequest(request, networkPolicy);    Response response = downloader.load(downloaderRequest);    ResponseBody body = response.body();    if (!response.isSuccessful()) {      body.close();      throw new ResponseException(response.code(), request.networkPolicy);    }    // Cache response is only null when the response comes fully from the network. Both completely    // cached and conditionally cached responses will have a non-null cache response.    Picasso.LoadedFrom loadedFrom = response.cacheResponse() == null ? NETWORK : DISK;    // Sometimes response content length is zero when requests are being replayed. Haven't found    // root cause to this but retrying the request seems safe to do so.    if (loadedFrom == DISK && body.contentLength() == 0) {      body.close();      throw new ContentLengthException("Received response with 0 content-length header.");    }    if (loadedFrom == NETWORK && body.contentLength() > 0) {      stats.dispatchDownloadFinished(body.contentLength());    }    return new Result(body.source(), loadedFrom);  }

Hunter得到后再通过ExecutorService.submit() 提交到线程池中

成功后dispatcher.dispatchComplete();

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

最后走到Picasso类中的 complete()

void complete(BitmapHunter hunter) {    Action single = hunter.getAction();    List joined = hunter.getActions();    boolean hasMultiple = joined != null && !joined.isEmpty();    boolean shouldDeliver = single != null || hasMultiple;    if (!shouldDeliver) {      return;    }    Uri uri = hunter.getData().uri;    Exception exception = hunter.getException();    Bitmap result = hunter.getResult();    LoadedFrom from = hunter.getLoadedFrom();    if (single != null) {      deliverAction(result, from, single, exception);    }    if (hasMultiple) {      //noinspection ForLoopReplaceableByForEach      for (int i = 0, n = joined.size(); i < n; i++) {        Action join = joined.get(i);        deliverAction(result, from, join, exception);      }    }    if (listener != null && exception != null) {      listener.onImageLoadFailed(this, uri, exception);    }  }

private void deliverAction(Bitmap result, LoadedFrom from, Action action, Exception e) {    if (action.isCancelled()) {      return;    }    if (!action.willReplay()) {      targetToAction.remove(action.getTarget());    }    if (result != null) {      if (from == null) {        throw new AssertionError("LoadedFrom cannot be null.");      }      action.complete(result, from);      if (loggingEnabled) {        log(OWNER_MAIN, VERB_COMPLETED, action.request.logId(), "from " + from);      }    } else {      action.error(e);      if (loggingEnabled) {        log(OWNER_MAIN, VERB_ERRORED, action.request.logId(), e.getMessage());      }    }  }

action.complete() ，看下实现类ImageViewAction中的 complete()

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

最后将得到的bitmap设置到 ImageView 中。

代码方法调用的总体的流程图如下：

Picasso方法调用总体流程图.png

Picasso是一个由Square公司开源的强大的Android图片下载缓存库，仅仅只需要一行代码就可以实现图片的异步加载。

Picasso中几个重要的类介绍：

Picasso代码流程分析：

代码方法调用的总体的流程图如下：

更多相关文章

随机推荐