RequestBuilder getGlide(Object o, ImageView iv) {
    RequestManager manager = Glide.with(getImageContext(iv));
    if (o instanceof String) {
        try {
            int t = Integer.parseInt(String.valueOf(o));
            return getGlideInteger(manager, t, iv);
        } catch (Exception e) {
            return getGlideString(manager, (String) o, iv);
        }
    } else if (o instanceof Integer) {
        return getGlideInteger(manager, (Integer) o, iv);
    } else if (o instanceof Uri) {
        return getGlideUri(manager, (Uri) o, iv);
    } else if (o instanceof File) {
        return getGlideFile(manager, (File) o, iv);
    }
    return getGlideString(manager, "", iv);
}
 

private static void getGlideRequest(Context context,
                                    String url,
                                    RequestOptions options,
                                    ImageView imageView) {

    RequestBuilder<Drawable> requestBuilder;

    List<Cookie> cookies = PersistentCookieStore.getInstance().getCookies();
    if (TextUtils.isEmpty(url)) {
        requestBuilder = Glide.with(context).load(url);
    } else if (cookies == null || cookies.size() <= 0) {
        requestBuilder = Glide.with(context).load(url);
    } else {
        LazyHeaders.Builder builder = new LazyHeaders.Builder();
        for (int i = 0; i < cookies.size(); i++) {
            Cookie cookie = cookies.get(i);
            String value = cookie.name() + "=" + cookie.value();
            builder.setHeader("Cookie", value);
        }

        GlideUrl glideUrl = new GlideUrl(url, builder.build());

        requestBuilder = Glide.with(context).load(glideUrl);
    }

    if (options != null) {
        requestBuilder.apply(options);
    }

    requestBuilder.into(imageView);

}
 

@Nullable
private RequestBuilder<Drawable> loadPage() {
    RequestBuilder<Drawable> request;
    RequestManager glide=GlideX.with(photoView);
    if(glide==null)return null;
    File file=LocalGallery.getPage(galleryFolder,page+1);
    if(file!=null){
        request=glide.load(file);
    }else {
        if (url==null) request = glide.load(R.mipmap.ic_launcher);
        else {
            LogUtility.d("Requested url glide: "+ url);
            request = glide.load(url);
        }
    }
    return request;
}
 

@Override
public Drawable getDrawable(String url) {
    final UrlDrawable urlDrawable = new UrlDrawable();
    RequestBuilder load;
    final Target target;
    if (isGif(url)) {
        load = Glide.with(mContext).asGif().load(url);
        target = new GifTarget(urlDrawable);
    } else {
        load = Glide.with(mContext).asBitmap().load(url);
        target = new BitmapTarget(urlDrawable);
    }
    targets.add(target);
    load.into(target);
    return urlDrawable;
}
 

@NonNull
public static GlideImagesPlugin create(@NonNull final Context context) {
    return create(new GlideStore() {
        @NonNull
        @Override
        public RequestBuilder<Drawable> load(@NonNull AsyncDrawable drawable) {
            return Glide.with(context)
                    .load(drawable.getDestination());
        }

        @Override
        public void cancel(@NonNull Target<?> target) {
            Glide.with(context)
                    .clear(target);
        }
    });
}
 

/**
 * 加载不一定是本地图片资源
 * (即也可以是网络资源)
 * 并且也可以不是gif图片
 * @param context
 * @param model
 * @param iv
 * @param playTimes
 */
public void loadMaybeGifDrawable(Context context,Object model,ImageView iv,int playTimes) {
    if (context == null || iv == null) {
        return;
    }
    iv.setVisibility(View.VISIBLE);
    theDisPlayImageView = new WeakReference<>(iv);
    this.playTimes = playTimes;
    RequestBuilder builder = Glide.with(context.getApplicationContext())
            .asGif()
            ;
    if (loadCallback != null || playTimes >=1) {//指定了播放次数，则需要监听动画执行的结束
        builder.listener(this);
    }
    RequestOptions options = new RequestOptions();
    options.diskCacheStrategy(DiskCacheStrategy.RESOURCE);
    builder.apply(options)
            .load(model)
            .into(iv)
    ;
}
 

private void setAlbumArt(@Nullable final String artUri) {
    if (!mTransitionPostponed && (hasCoverTransition || hasListViewTransition)) {
        mTransitionPostponed = true;
        supportPostponeEnterTransition();
    }
    if (TextUtils.isEmpty(artUri)) {
        mRequestManager.clear(albumArt);
        albumArt.setImageResource(R.drawable.album_art_placeholder);
        onArtProcessed();
    } else {
        RequestBuilder<Drawable> b = mRequestManager
                .asDrawable()
                .load(artUri);

        if (hasCoverTransition || hasListViewTransition) {
            b = b.apply(requestOptionsDontAnimate);
        } else {
            b = b.apply(requestOptions);
        }

        b.listener(new AlbumArtRequestListener()).into(albumArt);
    }
}
 

public void loadAsPath(final String path, final int width, final int height, final int maskId, final String ext) {
    if (TextUtils.isEmpty(path)) {
        loadAsResource(R.drawable.nim_image_default, maskId);
        return;
    }

    setBlendDrawable(maskId);

    RequestBuilder builder;
    if (ImageUtil.isGif(ext)) {
        builder = Glide.with(getContext().getApplicationContext()).asGif().load(new File(path));
    } else {
        RequestOptions options = new RequestOptions()
                .override(width, height)
                .fitCenter()
                .placeholder(R.drawable.nim_image_default)
                .error(R.drawable.nim_image_default);

        builder = Glide.with(getContext().getApplicationContext())
                .asBitmap()
                .apply(options)
                .load(new File(path))
        ;
    }
    builder.into(this);
}
 

public static void loadFlickrThumb(Photo photo, ImageView image) {
    final RequestOptions options = new RequestOptions()
            .diskCacheStrategy(DiskCacheStrategy.DATA)
            .override(Target.SIZE_ORIGINAL, Target.SIZE_ORIGINAL)
            .dontTransform();

    final RequestBuilder<Drawable> thumbRequest = Glide.with(image)
            .load(photo.getThumbnailUrl())
            .apply(options)
            .transition(DrawableTransitionOptions.with(TRANSITION_FACTORY));

    Glide.with(image).load(photo.getMediumUrl())
            .apply(options)
            .thumbnail(thumbRequest)
            .into(image);
}
 

public static void loadFlickrFull(Photo photo, ImageView image, LoadingListener listener) {
    final String photoUrl = photo.getLargeSize() == null
            ? photo.getMediumUrl() : photo.getLargeUrl();

    final RequestOptions options = new RequestOptions()
            .diskCacheStrategy(DiskCacheStrategy.DATA)
            .override(Target.SIZE_ORIGINAL, Target.SIZE_ORIGINAL)
            .dontTransform();

    final RequestBuilder<Drawable> thumbRequest = Glide.with(image)
            .load(photo.getMediumUrl())
            .apply(options);

    Glide.with(image)
            .load(photoUrl)
            .apply(new RequestOptions().apply(options).placeholder(image.getDrawable()))
            .thumbnail(thumbRequest)
            .listener(new RequestListenerWrapper<>(listener))
            .into(image);
}
 

/**
 * Loads thumbnail and then replaces it with full image.
 */
public static void loadFull(ImageView image, int imageId, int thumbId) {
    // We don't want Glide to crop or resize our image
    final RequestOptions options = new RequestOptions()
            .diskCacheStrategy(DiskCacheStrategy.NONE)
            .override(Target.SIZE_ORIGINAL)
            .dontTransform();

    final RequestBuilder<Drawable> thumbRequest = Glide.with(image)
            .load(thumbId)
            .apply(options);

    Glide.with(image)
            .load(imageId)
            .apply(options)
            .thumbnail(thumbRequest)
            .into(image);
}
 

@Override
public void onBindViewHolder(@NonNull GiphyViewHolder holder, int position) {
  GiphyImage image = images.get(position);

  holder.modelReady = false;
  holder.image      = image;
  holder.thumbnail.setAspectRatio(image.getGifAspectRatio());
  holder.gifProgress.setVisibility(View.GONE);

  RequestBuilder<Drawable> thumbnailRequest = GlideApp.with(context)
                                                      .load(new ChunkedImageUrl(image.getStillUrl(), image.getStillSize()))
                                                      .diskCacheStrategy(DiskCacheStrategy.ALL);

  if (Util.isLowMemory(context)) {
    glideRequests.load(new ChunkedImageUrl(image.getStillUrl(), image.getStillSize()))
                 .placeholder(new ColorDrawable(Util.getRandomElement(MaterialColor.values()).toConversationColor(context)))
                 .diskCacheStrategy(DiskCacheStrategy.ALL)
                 .transition(DrawableTransitionOptions.withCrossFade())
                 .listener(holder)
                 .into(holder.thumbnail);

    holder.setModelReady();
  } else {
    glideRequests.load(new ChunkedImageUrl(image.getGifUrl(), image.getGifSize()))
                 .thumbnail(thumbnailRequest)
                 .placeholder(new ColorDrawable(Util.getRandomElement(MaterialColor.values()).toConversationColor(context)))
                 .diskCacheStrategy(DiskCacheStrategy.ALL)
                 .transition(DrawableTransitionOptions.withCrossFade())
                 .listener(holder)
                 .into(holder.thumbnail);
  }
}
 

private RequestBuilder buildPlaceholderGlideRequest(@NonNull GlideRequests glideRequests, @NonNull Slide slide) {
  GlideRequest<Bitmap> bitmap          = glideRequests.asBitmap();
  BlurHash             placeholderBlur = slide.getPlaceholderBlur();

  if (placeholderBlur != null) {
    bitmap = bitmap.load(placeholderBlur);
  } else {
    bitmap = bitmap.load(slide.getPlaceholderRes(getContext().getTheme()));
  }

  return applySizing(bitmap.diskCacheStrategy(DiskCacheStrategy.NONE), new CenterCrop());
}
 

/**
 * 初始化监听器
 */
private void initData() {
    img.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            ImageDialog.this.dismiss();
        }
    });

    // 对于resourceId类型，暂时只能走直接设置
    if (id != null) {
        img.setImageResource(id);
        return;
    }

    RequestManager manager = GlideApp.with(img.getContext());

    RequestBuilder<?> request;
    if (file != null) {
        request = manager.load(file);
    } else if (path != null) {
        request = manager.load(path);
    } else if (uri != null) {
        request = manager.load(uri);
    } else if (bitmap != null){
        request = manager.load(bitmap);
    } else if (data != null){
        request = manager.load(data);
    } else {
        return;
    }

    request.apply(RequestOptions.fitCenterTransform()).into(img);
}
 

private void loadImage(){
    cancelRequest();
    RequestBuilder<Drawable>dra=loadPage();
    if(dra==null)return;
    dra
            .transform(new Rotate(degree))
            .placeholder(R.drawable.ic_launcher_foreground)
            .error(R.drawable.ic_refresh)
            .into(target);
}
 

@NonNull
@Override
public Resource<Bitmap> transform(@NonNull Context context, @NonNull Resource<Bitmap> resource, int outWidth, int outHeight) {
    try {
        if (mWrap != null) {
            resource = mWrap.transform(context, resource, outWidth, outHeight);
        }

        if (PerformanceSpInfoConfig.isLargeImgOpen()) {
            String url = "";
            if (mRequestBuilder instanceof RequestBuilder) {
                if (ReflectUtils.reflect(mRequestBuilder).field("model").get() instanceof String) {
                    url = ReflectUtils.reflect(mRequestBuilder).field("model").get();
                } else if (ReflectUtils.reflect(mRequestBuilder).field("model").get() instanceof Integer) {
                    url = "" + ReflectUtils.reflect(mRequestBuilder).field("model").get();
                }
            }
            Bitmap bitmap = resource.get();
            double imgSize = ConvertUtils.byte2MemorySize(bitmap.getByteCount(), MemoryConstants.MB);
            LargePictureManager.getInstance().saveImageInfo(url, imgSize, bitmap.getWidth(), bitmap.getHeight(), "Glide");
        }
    } catch (Exception e) {
        if (mWrap != null) {
            resource = mWrap.transform(context, resource, outWidth, outHeight);
        }
    }

    return resource;
}
 

public void loadAsPath(final String path, final int width, final int height, final int maskId, final String ext) {
    if (TextUtils.isEmpty(path)) {

        return;
    }
    setBlendDrawable(maskId);
    RequestBuilder builder;
    RequestOptions options = new RequestOptions()
            .override(width, height)
            .fitCenter();

    builder = Glide.with(getContext().getApplicationContext()).asBitmap().apply(options).load(new File(path));

    builder.into(this);
}
 

@Nullable
@Override
public RequestBuilder<Drawable> getPreloadRequestBuilder(@NonNull VideoInfo item) {
    return requestBuilder
            .clone()
            .load(item.getVideoPath());
}
 

public RequestBuilder<Bitmap> build() {
    //noinspection unchecked
    return createBaseRequest(requestManager, song, ignoreMediaStore)
            .diskCacheStrategy(DEFAULT_DISK_CACHE_STRATEGY)
            .error(DEFAULT_ERROR_IMAGE)
            .transition(GenericTransitionOptions.with(DEFAULT_ANIMATION))
            .signature(createSignature(song));
}
 

public RequestBuilder<Bitmap> build() {
    //noinspection unchecked
    return createBaseRequest(builder.requestManager, builder.song, builder.ignoreMediaStore)
            .diskCacheStrategy(DEFAULT_DISK_CACHE_STRATEGY)
            .error(DEFAULT_ERROR_IMAGE)
            .transition(GenericTransitionOptions.with(DEFAULT_ANIMATION))
            .signature(createSignature(builder.song));
}
 

public RequestBuilder<Bitmap> build() {
    //noinspection unchecked
    return createBaseRequest(builder.requestManager, builder.song, builder.ignoreMediaStore)

      //     .transcode(new BitmapPaletteTranscoder(context), BitmapPaletteWrapper.class)
            .diskCacheStrategy(DEFAULT_DISK_CACHE_STRATEGY)
            .error(DEFAULT_ERROR_IMAGE)
            .transition(GenericTransitionOptions.with(DEFAULT_ANIMATION))
            .signature(createSignature(builder.song));
}
 

public static RequestBuilder<Bitmap> createBaseRequest(RequestManager requestManager, Song song, boolean ignoreMediaStore) {
    if (ignoreMediaStore) {
        return requestManager.asBitmap().load(new AudioFileCover(song.data));
    } else {
        return requestManager.asBitmap().load(MusicUtil.getMediaStoreAlbumCoverUri(song.albumId));
    }
}
 

public RequestBuilder<Bitmap> build() {
    return createBaseRequest(requestManager, artist, noCustomImage, forceDownload, mLoadOriginalImage, mImageNumber)
            .diskCacheStrategy(DEFAULT_DISK_CACHE_STRATEGY)

            .transition(GenericTransitionOptions.with(DEFAULT_ANIMATION))
            .priority(Priority.LOW)
            //.override(Target.SIZE_ORIGINAL, Target.SIZE_ORIGINAL)
            .signature(createSignature(artist,mLoadOriginalImage, mImageNumber));
}
 

public RequestBuilder<Bitmap> build() {
    //noinspection unchecked
    return createBaseRequest(builder.requestManager, builder.artist, builder.noCustomImage, builder.forceDownload, builder.mLoadOriginalImage, builder.mImageNumber)
            .diskCacheStrategy(DEFAULT_DISK_CACHE_STRATEGY)
            .priority(Priority.LOW)
            .override(Target.SIZE_ORIGINAL, Target.SIZE_ORIGINAL)
            .signature(createSignature(builder.artist,builder.mLoadOriginalImage, builder.mImageNumber));
}
 

public RequestBuilder<Drawable> buildRequestDrawable() {
    //noinspection unchecked
    return createBaseRequestForDrawable(builder.requestManager, builder.artist, builder.noCustomImage, builder.forceDownload, builder.mLoadOriginalImage, builder.mImageNumber)
            .diskCacheStrategy(DEFAULT_DISK_CACHE_STRATEGY)
            .priority(Priority.LOW)
            .override(Target.SIZE_ORIGINAL, Target.SIZE_ORIGINAL)
            .signature(createSignature(builder.artist,builder.mLoadOriginalImage, builder.mImageNumber));
}
 

public RequestBuilder<Bitmap> build() {
    //noinspection unchecked
    return createBaseRequest(builder.requestManager, builder.artist, builder.noCustomImage, builder.forceDownload, builder.mLoadOriginalImage, builder.mImageNumber)
            //.transcode(new BitmapPaletteTranscoder(context), BitmapPaletteWrapper.class)
            .diskCacheStrategy(DEFAULT_DISK_CACHE_STRATEGY)

            .transition(GenericTransitionOptions.with(DEFAULT_ANIMATION))
            .priority(Priority.LOW)
            .override(Target.SIZE_ORIGINAL, Target.SIZE_ORIGINAL)
            .signature(createSignature(builder.artist,builder.mLoadOriginalImage, builder.mImageNumber));
}
 

public RequestBuilder<Drawable> buildRequestDrawable() {
    //noinspection unchecked
    return createBaseRequestForDrawable(builder.requestManager, builder.artist, builder.noCustomImage, builder.forceDownload, builder.mLoadOriginalImage, builder.mImageNumber)
            .diskCacheStrategy(DEFAULT_DISK_CACHE_STRATEGY)
            .priority(Priority.LOW)
            .override(Target.SIZE_ORIGINAL, Target.SIZE_ORIGINAL)
            .signature(createSignature(builder.artist,builder.mLoadOriginalImage, builder.mImageNumber));
}
 

public static RequestBuilder<Drawable> createBaseRequestForDrawable( RequestManager requestManager, Artist artist, boolean noCustomImage, boolean forceDownload, boolean loadOriginal, int imageNumber) {
    RequestBuilder<Drawable> builder;
    boolean hasCustomImage = CustomArtistImageUtil.getInstance(App.getInstance()).hasCustomArtistImage(artist);
    if (noCustomImage || !hasCustomImage) {
        builder = requestManager.load(new ArtistImage(artist.getName(), forceDownload, loadOriginal, imageNumber));
    } else {
        builder =  requestManager.load(CustomArtistImageUtil.getFile(artist));
    }
    return builder;
}
 

public static RequestBuilder<Bitmap> createBaseRequest( RequestManager requestManager, Artist artist, boolean noCustomImage, boolean forceDownload, boolean loadOriginal, int imageNumber) {
     RequestBuilder<Bitmap> builder;
    boolean hasCustomImage = CustomArtistImageUtil.getInstance(App.getInstance()).hasCustomArtistImage(artist);
    if (noCustomImage || !hasCustomImage) {
        builder = requestManager.asBitmap().load(new ArtistImage(artist.getName(), forceDownload, loadOriginal, imageNumber));
    } else {
        builder =  requestManager.asBitmap().load(CustomArtistImageUtil.getFile(artist));
    }
    return builder;
}
 

@NonNull
public static GlideImagesPlugin create(@NonNull final RequestManager requestManager) {
    return create(new GlideStore() {
        @NonNull
        @Override
        public RequestBuilder<Drawable> load(@NonNull AsyncDrawable drawable) {
            return requestManager.load(drawable.getDestination());
        }

        @Override
        public void cancel(@NonNull Target<?> target) {
            requestManager.clear(target);
        }
    });
}