Glide v4 源码解析（四）

public class ImageViewTargetFactory {
  @NonNull
  @SuppressWarnings("unchecked")
  public <Z> ViewTarget<ImageView, Z> buildTarget(@NonNull ImageView view,
      @NonNull Class<Z> clazz) {
    if (Bitmap.class.equals(clazz)) {
      return (ViewTarget<ImageView, Z>) new BitmapImageViewTarget(view);
    } else if (Drawable.class.isAssignableFrom(clazz)) {
      return (ViewTarget<ImageView, Z>) new DrawableImageViewTarget(view);
    } else {
      throw new IllegalArgumentException(
          "Unhandled class: " + clazz + ", try .as*(Class).transcode(ResourceTranscoder)");
    }
  }
}

Glide.with(this)
    .asBitmap()
    .load(file)
    .into(object : CustomTarget<Bitmap>() {
        override fun onResourceReady(
            resource: Bitmap,
            transition: Transition<in Bitmap>?
        ) {
            ivFace.setImageBitmap(resource)
        }

        override fun onLoadCleared(placeholder: Drawable?) {
            ivFace.setImageDrawable(placeholder)
        }
    })

/**
  * Preloads the resource into the cache using the given width and height.
  *
  * <p> Pre-loading is useful for making sure that resources you are going to to want in the near
  * future are available quickly. </p>
  *
  * @param width  The desired width in pixels, or {@link Target#SIZE_ORIGINAL}. This will be
  *               overridden by
  *               {@link com.bumptech.glide.request.RequestOptions#override(int, int)} if
  *               previously called.
  * @param height The desired height in pixels, or {@link Target#SIZE_ORIGINAL}. This will be
  *               overridden by
  *               {@link com.bumptech.glide.request.RequestOptions#override(int, int)}} if
  *               previously called).
  * @return A {@link Target} that can be used to cancel the load via
  * {@link RequestManager#clear(Target)}.
  * @see com.bumptech.glide.ListPreloader
  */
@NonNull
public Target<TranscodeType> preload(int width, int height) {
  final PreloadTarget<TranscodeType> target = PreloadTarget.obtain(requestManager, width, height);
  return into(target);
}

/**
  * Preloads the resource into the cache using {@link Target#SIZE_ORIGINAL} as the target width and
  * height. Equivalent to calling {@link #preload(int, int)} with {@link Target#SIZE_ORIGINAL} as
  * the width and height.
  *
  * @return A {@link Target} that can be used to cancel the load via
  * {@link RequestManager#clear(Target)}
  * @see #preload(int, int)
  */
@NonNull
public Target<TranscodeType> preload() {
  return preload(Target.SIZE_ORIGINAL, Target.SIZE_ORIGINAL);
}

/**
 * A one time use {@link com.bumptech.glide.request.target.Target} class that loads a resource into
 * memory and then clears itself.
 *
 * @param <Z> The type of resource that will be loaded into memory.
 */
public final class PreloadTarget<Z> extends SimpleTarget<Z> {
  private static final int MESSAGE_CLEAR = 1;
  private static final Handler HANDLER = new Handler(Looper.getMainLooper(), new Callback() {
    @Override
    public boolean handleMessage(Message message) {
      if (message.what == MESSAGE_CLEAR) {
        ((PreloadTarget<?>) message.obj).clear();
        return true;
      }
      return false;
    }
  });

  private final RequestManager requestManager;

  /**
   * Returns a PreloadTarget.
   *
   * @param width  The width in pixels of the desired resource.
   * @param height The height in pixels of the desired resource.
   * @param <Z>    The type of the desired resource.
   */
  public static <Z> PreloadTarget<Z> obtain(RequestManager requestManager, int width, int height) {
    return new PreloadTarget<>(requestManager, width, height);
  }

  private PreloadTarget(RequestManager requestManager, int width, int height) {
    super(width, height);
    this.requestManager = requestManager;
  }

  @Override
  public void onResourceReady(@NonNull Z resource, @Nullable Transition<? super Z> transition) {
    HANDLER.obtainMessage(MESSAGE_CLEAR, this).sendToTarget();
  }

  @SuppressWarnings("WeakerAccess")
  @Synthetic void clear() {
    requestManager.clear(this);
  }
}

/**
  * Returns a future that can be used to do a blocking get on a background thread.
  *
  * <p>This method defaults to {@link Target#SIZE_ORIGINAL} for the width and the height. However,
  * since the width and height will be overridden by values passed to {@link
  * RequestOptions#override(int, int)}, this method can be used whenever {@link RequestOptions}
  * with override values are applied, or whenever you want to retrieve the image in its original
  * size.
  *
  * @see #submit(int, int)
  * @see #into(Target)
  */
@NonNull
public FutureTarget<TranscodeType> submit() {
  return submit(Target.SIZE_ORIGINAL, Target.SIZE_ORIGINAL);
}

/**
  * Returns a future that can be used to do a blocking get on a background thread.
  *
  * @param width  The desired width in pixels, or {@link Target#SIZE_ORIGINAL}. This will be
  *               overridden by
  *               {@link com.bumptech.glide.request.RequestOptions#override(int, int)} if
  *               previously called.
  * @param height The desired height in pixels, or {@link Target#SIZE_ORIGINAL}. This will be
  *               overridden by
  *               {@link com.bumptech.glide.request.RequestOptions#override(int, int)}} if
  *               previously called).
  */
@NonNull
public FutureTarget<TranscodeType> submit(int width, int height) {
  final RequestFutureTarget<TranscodeType> target = new RequestFutureTarget<>(width, height);
  return into(target, target, Executors.directExecutor());
}

FutureTarget<File> target = null;
RequestManager requestManager = Glide.with(context);
try {
  target = requestManager
     .downloadOnly()
     .load(model)
     .submit();
  File downloadedFile = target.get();
  // ... do something with the file (usually throws IOException)
} catch (ExecutionException | InterruptedException | IOException e) {
  // ... bug reporting or recovery
} finally {
  // make sure to cancel pending operations and free resources
  if (target != null) {
    target.cancel(true); // mayInterruptIfRunning
  }
}

@Deprecated
@CheckResult
public <Y extends Target<File>> Y downloadOnly(@NonNull Y target) {
  return getDownloadOnlyRequest().into(target);
}

@Deprecated
@CheckResult
public FutureTarget<File> downloadOnly(int width, int height) {
  return getDownloadOnlyRequest().submit(width, height);
}

@NonNull
@CheckResult
protected RequestBuilder<File> getDownloadOnlyRequest() {
  return new RequestBuilder<>(File.class, this).apply(DOWNLOAD_ONLY_OPTIONS);
}

@NonNull
public <Y extends Target<TranscodeType>> Y into(@NonNull Y target) {
  return into(target, /*targetListener=*/ null, Executors.mainThreadExecutor());
}

public FutureTarget<TranscodeType> submit(int width, int height) {
  final RequestFutureTarget<TranscodeType> target = new RequestFutureTarget<>(width, height);
  return into(target, target, Executors.directExecutor());
}

@NonNull
@CheckResult
public RequestBuilder<File> downloadOnly() {
  return as(File.class).apply(DOWNLOAD_ONLY_OPTIONS);
}

protected static final RequestOptions DOWNLOAD_ONLY_OPTIONS =
    new RequestOptions().diskCacheStrategy(DiskCacheStrategy.DATA).priority(Priority.LOW)
        .skipMemoryCache(true);

@NonNull
@CheckResult
@SuppressWarnings("unchecked")
public RequestBuilder<TranscodeType> listener(
    @Nullable RequestListener<TranscodeType> requestListener) {
  this.requestListeners = null;
  return addListener(requestListener);
}

@NonNull
@CheckResult
public RequestBuilder<TranscodeType> addListener(
    @Nullable RequestListener<TranscodeType> requestListener) {
  if (requestListener != null) {
    if (this.requestListeners == null) {
      this.requestListeners = new ArrayList<>();
    }
    this.requestListeners.add(requestListener);
  }
  return this;
}

private synchronized void onResourceReady(Resource<R> resource, R result, DataSource dataSource) {
  // We must call isFirstReadyResource before setting status.
  boolean isFirstResource = isFirstReadyResource();
  status = Status.COMPLETE;
  this.resource = resource;

  isCallingCallbacks = true;
  try {
    boolean anyListenerHandledUpdatingTarget = false;
    if (requestListeners != null) {
      for (RequestListener<R> listener : requestListeners) {
        anyListenerHandledUpdatingTarget |=
            listener.onResourceReady(result, model, target, dataSource, isFirstResource);
      }
    }
    anyListenerHandledUpdatingTarget |=
        targetListener != null
            && targetListener.onResourceReady(result, model, target, dataSource, isFirstResource);

    if (!anyListenerHandledUpdatingTarget) {
      Transition<? super R> animation =
          animationFactory.build(dataSource, isFirstResource);
      target.onResourceReady(result, animation);
    }
  } finally {
    isCallingCallbacks = false;
  }

  notifyLoadSuccess();
}

private synchronized void onLoadFailed(GlideException e, int maxLogLevel) {
  stateVerifier.throwIfRecycled();
  e.setOrigin(requestOrigin);

  loadStatus = null;
  status = Status.FAILED;

  isCallingCallbacks = true;
  try {
    //TODO: what if this is a thumbnail request?
    boolean anyListenerHandledUpdatingTarget = false;
    if (requestListeners != null) {
      for (RequestListener<R> listener : requestListeners) {
        anyListenerHandledUpdatingTarget |=
            listener.onLoadFailed(e, model, target, isFirstReadyResource());
      }
    }
    anyListenerHandledUpdatingTarget |=
        targetListener != null
            && targetListener.onLoadFailed(e, model, target, isFirstReadyResource());

    if (!anyListenerHandledUpdatingTarget) {
      setErrorPlaceholder();
    }
  } finally {
    isCallingCallbacks = false;
  }

  notifyLoadFailed();
}