private static GenericRequestBuilder<GifDecoder, GifDecoder, Bitmap, Bitmap> getRequestBuilder(Context context,
        GifDecoder gifDecoder, int width, int height, BitmapPool bitmapPool) {
    GifFrameResourceDecoder frameResourceDecoder = new GifFrameResourceDecoder(bitmapPool);
    GifFrameModelLoader frameLoader = new GifFrameModelLoader();
    Encoder<GifDecoder> sourceEncoder = NullEncoder.get();
    return Glide.with(context)
            .using(frameLoader, GifDecoder.class)
            .load(gifDecoder)
            .as(Bitmap.class)
            .sourceEncoder(sourceEncoder)
            .decoder(frameResourceDecoder)
            .skipMemoryCache(true)
            .diskCacheStrategy(DiskCacheStrategy.NONE)
            .override(width, height);

}
 

/**
 * Create a small thumbnail sized image that has the same bounds as the
 * media store thumbnail images.
 * <p>
 * If the Uri points at an animated gif, the gif will not play.
 */
public GenericRequestBuilder<Uri, ?, ?, GlideDrawable> loadMediaStoreThumb(Uri uri, Key key)
{
    Size size = clampSize(MEDIASTORE_THUMB_SIZE, MAXIMUM_SMOOTH_PIXELS, getMaxImageDisplaySize());
    return mTinyImageBuilder
            .clone()
            .load(uri)
            .signature(key)
            // This attempts to ensure we load the cached media store version.
            .override(size.width(), size.height());
}
 

/**
 * Create very tiny thumbnail request that should complete as fast
 * as possible.
 * <p>
 * If the Uri points at an animated gif, the gif will not play.
 */
public GenericRequestBuilder<Uri, ?, ?, GlideDrawable> loadTinyThumb(Uri uri, Key key)
{
    Size size = clampSize(TINY_THUMB_SIZE, MAXIMUM_SMOOTH_PIXELS, getMaxImageDisplaySize());
    return mTinyImageBuilder
            .clone()
            .load(uri)
            .signature(key)
            .override(size.width(), size.height());
}
 

public static GenericRequestBuilder applyDimens(@NonNull GenericRequestBuilder requestBuilder,
                                                @NonNull GlideTaskParams payload) {
    final Media media = payload.getMedia();
    if (media != null) {
        requestBuilder.override(media.getWidth(), media.getHeight());
    }
    return requestBuilder;
}
 

public static <T extends ImageView> void load(@NonNull final GenericRequestBuilder requestBuilder,
                                              @NonNull final GlideTaskParams<T> payload) {

    if (payload.isThumbnail()) {
        requestBuilder.thumbnail(payload.getThumbnailMultiplier());
    }

    requestBuilder.placeholder(payload.getPlaceholder())
            .into(new GlideDrawableImageViewTarget(payload.getTarget()) {
                @Override
                public void onLoadFailed(Exception e, Drawable errorDrawable) {
                    if (payload.getCurrentRetry() < payload.getMaxRetry()) {
                        payload.incrementCurrentRetry();
                        load(requestBuilder, payload);
                    } else {
                        super.onLoadFailed(e, errorDrawable);
                        payload.getListener().failure(payload.getTarget(), errorDrawable);
                    }
                }

                @Override
                public void onResourceReady(GlideDrawable resource, GlideAnimation<? super GlideDrawable> animation) {
                    super.onResourceReady(resource, animation);
                    payload.getListener().success(payload.getTarget(), resource);
                }
            });
}
 

@Override public Drawable getDrawable(@NonNull String url) {
    final UrlDrawable urlDrawable = new UrlDrawable();
    if (container != null && container.get() != null) {
        Context context = container.get().getContext();
        final GenericRequestBuilder load = Glide.with(context)
                .load(url)
                .dontAnimate();
        final GlideDrawableTarget target = new GlideDrawableTarget(urlDrawable, container, width);
        load.into(target);
        cachedTargets.add(target);
    }
    return urlDrawable;
}
 

private GenericRequestBuilder buildThumbnailGlideRequest(@NonNull Slide slide, @NonNull MasterSecret masterSecret) {
  @SuppressWarnings("ConstantConditions")
  DrawableRequestBuilder<DecryptableUri> builder = Glide.with(getContext()).load(new DecryptableUri(masterSecret, slide.getThumbnailUri()))
                                                                           .crossFade()
                                                                           .transform(new RoundedCorners(getContext(), true, radius, backgroundColorHint));

  if (slide.isInProgress()) return builder;
  else                      return builder.error(R.drawable.ic_missing_thumbnail_picture);
}
 

@Singleton
@Provides
GenericRequestBuilder<GlideUrl, InputStream, byte[], GifDrawable> provideGifRequestBuilder(
        RequestManager requestManager, OkHttpClient okHttpClient) {

    return requestManager.using(new OkHttpUrlLoader(okHttpClient), InputStream.class)
            .from(GlideUrl.class)
            .as(byte[].class)
            .transcode(new GifDrawableBytesTranscoder(), GifDrawable.class)
            .diskCacheStrategy(DiskCacheStrategy.SOURCE)
            .decoder(new StreamByteArrayResourceDecoder())
            .sourceEncoder(new StreamEncoder())
            .cacheDecoder(new FileToStreamDecoder<>(new StreamByteArrayResourceDecoder()));
}
 

@Bindable
public GenericRequestBuilder getHeroImage() {
    if (mLfmReference != null) {
        Image hero = mLfmReference.getImageBySize(Image.Size.MEGA);

        if (hero != null) {
            return Glide.with(getContext())
                    .load(hero.getUrl())
                    .diskCacheStrategy(DiskCacheStrategy.SOURCE)
                    .centerCrop()
                    .animate(android.R.anim.fade_in);
        }
    }
    return null;
}
 

private GenericRequestBuilder<Uri, ?, ?, GlideDrawable> renderTinySize(Uri uri)
{
    return mGlideManager.loadTinyThumb(uri, generateSignature(mData));
}
 

public LoadCycler(GenericRequestBuilder<M, ?, ?, T> request, ImageView imageView) {
	this(request, new DrawableImageViewTarget(imageView));
}
 

public LoadCycler(GenericRequestBuilder<M, ?, ?, T> request, Target<? super T> target) {
	this.target = target;
	prev = copy(request);
	curr = copy(request);
	next = copy(request);
}
 

private GenericRequestBuilder<M, ?, ?, T> copy(GenericRequestBuilder<M, ?, ?, T> request) {
	return request.clone().dontAnimate().thumbnail(null).listener(null).load(null);
}
 

private void rotate() {
	GenericRequestBuilder<M, ?, ?, T> temp = prev;
	prev = curr;
	curr = next;
	next = temp;
}
 

private GenericRequestBuilder buildPlaceholderGlideRequest(Slide slide) {
  return Glide.with(getContext()).load(slide.getPlaceholderRes(getContext().getTheme()))
                                 .asBitmap()
                                 .fitCenter();
}
 

@BindingAdapter("android:src")
public static void bindImage(ImageView imageView, GenericRequestBuilder request) {
    if (request != null) {
        request.into(imageView);
    }
}
 

@Bindable
public GenericRequestBuilder getHeroImage() {
    return Glide.with(getContext()).load(mAlbum.getArtUri()).centerCrop();
}
 

@Override
public Drawable getDrawable(ImageHolder holder, final RichTextConfig config, TextView textView) {
    final ImageTarget target;
    final GenericRequestBuilder load;
    DrawableTypeRequest dtr;
    DrawableWrapper drawableWrapper = new DrawableWrapper();
    byte[] src = Base64.decode(holder.getSource());
    if (src != null) {
        dtr = Glide.with(textView.getContext()).load(src);
    } else {
        dtr = Glide.with(textView.getContext()).load(holder.getSource());
    }
    Rect rect = null;
    if (config.cacheType >= CacheType.LAYOUT) {
        rect = loadCache(holder.getSource());
        if (rect != null) {
            drawableWrapper.setBounds(rect);
        }
    } else {
        drawableWrapper.setBounds(0, 0, holder.getWidth(), holder.getHeight());
    }
    if (holder.isGif()) {
        target = new ImageTargetGif(textView, drawableWrapper, holder, config, this, rect);
        load = dtr.asGif();
    } else {
        target = new ImageTargetBitmap(textView, drawableWrapper, holder, config, this, rect);
        load = dtr.asBitmap().atMost();
    }
    checkTag(textView);
    targets.add(target);
    if (!config.resetSize && holder.isInvalidateSize()) {
        load.override(holder.getWidth(), holder.getHeight());
    }
    if (holder.getScaleType() == ImageHolder.ScaleType.CENTER_CROP) {
        if (holder.isGif()) {
            //noinspection ConstantConditions
            ((GifTypeRequest) load).centerCrop();
        } else {
            //noinspection ConstantConditions
            ((BitmapTypeRequest) load).centerCrop();
        }
    } else if (holder.getScaleType() == ImageHolder.ScaleType.FIT_CENTER) {
        if (holder.isGif()) {
            //noinspection ConstantConditions
            ((GifTypeRequest) load).fitCenter();
        } else {
            //noinspection ConstantConditions
            ((BitmapTypeRequest) load).fitCenter();
        }
    }
    textView.post(new Runnable() {
        @Override
        public void run() {
            load.placeholder(config.placeHolder).error(config.errorImage).into(target);
        }
    });
    drawableWrapper.setCallback(textView);
    return drawableWrapper;
}