com.bumptech.glide.RequestManager Java Examples

public GlideFilmstripManager(Context context)
{
    Glide glide = Glide.get(context);
    BitmapEncoder bitmapEncoder = new BitmapEncoder(Bitmap.CompressFormat.JPEG,
            JPEG_COMPRESS_QUALITY);
    GifBitmapWrapperResourceEncoder drawableEncoder = new GifBitmapWrapperResourceEncoder(
            bitmapEncoder,
            new GifResourceEncoder(glide.getBitmapPool()));
    RequestManager request = Glide.with(context);

    mTinyImageBuilder = request
            .fromMediaStore()
            .asBitmap() // This prevents gifs from animating at tiny sizes.
            .transcode(new BitmapToGlideDrawableTranscoder(context), GlideDrawable.class)
            .fitCenter()
            .placeholder(DEFAULT_PLACEHOLDER_RESOURCE)
            .dontAnimate();

    mLargeImageBuilder = request
            .fromMediaStore()
            .encoder(drawableEncoder)
            .fitCenter()
            .placeholder(DEFAULT_PLACEHOLDER_RESOURCE)
            .dontAnimate();
}
 

public static void loadAvatar(RequestManager glide, ImageView view, String avatarUrl) {
    avatarUrl = Utils.nullToText(avatarUrl);
    String cacheKey = AVATAR_CACHE_KEYS.get(avatarUrl);
    if (cacheKey == null) {
        cacheKey = avatarUrl;
    }
    if (HiSettingsHelper.getInstance().isCircleAvatar()) {
        glide.load(new AvatarModel(avatarUrl))
                .signature(new ObjectKey(cacheKey))
                .diskCacheStrategy(DiskCacheStrategy.NONE)
                .circleCrop()
                .error(DEFAULT_USER_ICON)
                .transition(DrawableTransitionOptions.withCrossFade())
                .into(view);
    } else {
        glide.load(new AvatarModel(avatarUrl))
                .signature(new ObjectKey(cacheKey))
                .diskCacheStrategy(DiskCacheStrategy.NONE)
                .transform(new CenterCrop(), new RoundedCorners(Utils.dpToPx(4)))
                .error(DEFAULT_USER_ICON)
                .transition(DrawableTransitionOptions.withCrossFade())
                .into(view);
    }
}
 

public static Observable<File> get(RequestManager requestManager, String url) {
    return Observable.create(new Observable.OnSubscribe<File>() {
        @Override
        public void call(Subscriber<? super File> subscriber) {
            try {
                subscriber.onNext(requestManager.load(url)
                        .downloadOnly(Target.SIZE_ORIGINAL, Target.SIZE_ORIGINAL)
                        .get());
            } catch (InterruptedException | ExecutionException e) {
                subscriber.onError(e);
            } finally {
                subscriber.onCompleted();
            }
        }
    }).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread());

}
 

private DrawableRequestBuilder load(Object object, RequestManager with){
    DrawableRequestBuilder builder = null;
    if(object instanceof String){
        String imageUrl = (String) object;
        if(!imageUrl.startsWith("http://")){
            imageUrl = Api.IMG_SERVER_URL.concat(imageUrl);
        }
        builder = with.load(imageUrl);
    }else if(object instanceof Integer){
        builder = with.load((Integer) object);
    }else if(object instanceof File){
        builder = with.load((File) object);
    }else if(object instanceof Uri){
        builder = with.load((Uri) object);
    }else if(object instanceof Byte[]){
        builder = with.load((Byte[]) object);
    }
    return builder;
}
 

@Override
public void onViewRecycled(@NonNull ViewHolder holder) {
    final ImageView imgView=holder.master.findViewById(R.id.image);
    toDelete.add(map.remove(imgView));
    for (Iterator<BitmapTarget> iterator = toDelete.iterator(); iterator.hasNext();) {
        BitmapTarget target = iterator.next();
        if(context.isFinishing()||Global.isDestroyed(context))
            break;
        if(!map.containsValue(target)) {
            RequestManager manager = GlideX.with(context);
            if (manager != null) manager.clear(target);
        }
        iterator.remove();
    }
    super.onViewRecycled(holder);
}
 

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

@Nullable
private static DrawableTypeRequest getDrawableTypeRequest(Object obj, View img) {
    if (img == null || obj == null) return null;
    Context context = img.getContext();
    RequestManager manager = Glide.with(context);
    DrawableTypeRequest drawableTypeRequest = null;
    if (obj instanceof String) {
        drawableTypeRequest = manager.load((String) obj);
    } else if (obj instanceof Integer) {
        drawableTypeRequest = manager.load((Integer) obj);
    } else if (obj instanceof Uri) {
        drawableTypeRequest = manager.load((Uri) obj);
    } else if (obj instanceof File) {
        drawableTypeRequest = manager.load((File) obj);
    }
    return drawableTypeRequest;
}
 

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

@VisibleForTesting
UploadViewHolder(@NonNull View itemView, @NonNull ImageView thumbnail,
        @NonNull TextView filename, @NonNull TextView status, @NonNull RequestManager glide) {
    super(itemView);
    this.thumbnail = thumbnail;
    this.filename = filename;
    this.status = status;
    this.glide = glide;
}
 

public static DrawableTypeRequest createBaseRequest(RequestManager requestManager, Song song, boolean ignoreMediaStore) {
    if (ignoreMediaStore) {
        return requestManager.load(new AudioFileCover(song.data));
    } else {
        return requestManager.loadFromMediaStore(MusicUtil.getMediaStoreAlbumCoverUri(song.albumId));
    }
}
 

@Inject
public CatsAdapter(LayoutInflater layoutInflater, RequestManager glideRequestManager,
                   EventBus eventBus) {
    this.layoutInflater = layoutInflater;
    this.glideRequestManager = glideRequestManager;
    this.eventBus = eventBus;
    this.catImages = new ArrayList<>();
}
 

public RequestManager get(FragmentActivity activity) {
    if (Util.isOnBackgroundThread()) {
        return get(activity.getApplicationContext());
    } else {
        assertNotDestroyed(activity);
        FragmentManager fm = activity.getSupportFragmentManager();
        return supportFragmentGet(activity, fm);
    }
}
 

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

public static void loadImage(Activity activity,String url,ImageView imageView){
    LogUtility.d("Requested url glide: "+ url);
    if(activity.isFinishing()||Global.isDestroyed(activity))return;
    if(Global.getDownloadPolicy()== Global.DataUsageType.NONE){loadLogo(imageView);return;}
    RequestManager glide=GlideX.with(activity);
    if(glide==null)return;
    int logo=Global.getLogo();
    glide.load(url)
            .placeholder(logo)
            .error(logo)
            .into(imageView);
}
 

@Override
public Set<RequestManager> getDescendants() {
    Set<RequestManagerFragment> descendantFragments = getDescendantRequestManagerFragments();
    HashSet<RequestManager> descendants =
        new HashSet<RequestManager>(descendantFragments.size());
    for (RequestManagerFragment fragment : descendantFragments) {
        if (fragment.getRequestManager() != null) {
            descendants.add(fragment.getRequestManager());
        }
    }
    return descendants;
}
 

public static DrawableTypeRequest createBaseRequest(RequestManager requestManager, Song song, boolean ignoreMediaStore) {
    if (ignoreMediaStore) {
        return requestManager.load(new AudioFileCover(song.data));
    } else {
        return requestManager.loadFromMediaStore(MusicUtil.getMediaStoreAlbumCoverUri(song.albumId));
    }
}
 

public RequestManager get(Context context) {
    if (context == null) {
        throw new IllegalArgumentException("You cannot start a load on a null Context");
    } else if (Util.isOnMainThread() && !(context instanceof Application)) {
        if (context instanceof FragmentActivity) {
            return get((FragmentActivity) context);
        } else if (context instanceof Activity) {
            return get((Activity) context);
        } else if (context instanceof ContextWrapper) {
            return get(((ContextWrapper) context).getBaseContext());
        }
    }

    return getApplicationManager(context);
}
 

@Override
protected void onResume() {
    super.onResume();
    Global.updateACRAReportStatus(this);
    com.dar.nclientv2.settings.Login.initUseAccountTag(this);

    loadStringLogin();
    onlineFavoriteManager.setVisible(com.dar.nclientv2.settings.Login.isLogged(true));
    if(setting!=null){
        Global.initFromShared(this);//restart all settings
        inspector=inspector.cloneInspector(this,resetDataset);
        inspector.start();//restart inspector
        if(setting.theme!=Global.getTheme()||!setting.locale.equals(Global.initLanguage(this))){
            RequestManager manager= GlideX.with(getApplicationContext());
            if(manager!=null)manager.pauseAllRequestsRecursive();
            recreate();
        }
        adapter.notifyDataSetChanged();//restart adapter
        showPageSwitcher(inspector.getPage(),inspector.getPageCount());//restart page switcher
        changeLayout(getResources().getConfiguration().orientation==Configuration.ORIENTATION_LANDSCAPE);
        setting=null;
    }else if(filteringTag){
        inspector=InspectorV3.basicInspector(this,1,resetDataset);
        inspector.start();
        filteringTag=false;
    }
    invalidateOptionsMenu();
}
 

public FeedEntryViewHolder(View itemView, RequestManager glide) {
	super(itemView);
	this.glide = glide;
	this.image = (ImageView)itemView.findViewById(R.id.github_864_image);
	this.title = (TextView)itemView.findViewById(R.id.github_864_title);
	this.author = (ImageView)itemView.findViewById(R.id.github_864_author_icon);
}
 

@Nullable
public static RequestManager with(Context context) {
    try {
        return Glide.with(context);
    } catch (VerifyError | IllegalStateException ignore) {
        return null;
    }
}
 

@Nullable
public static RequestManager with(Fragment fragment) {
    try {
        return Glide.with(fragment);
    } catch (VerifyError | IllegalStateException ignore) {
        return null;
    }
}
 

@Nullable
public static RequestManager with(FragmentActivity fragmentActivity) {
    try {
        return Glide.with(fragmentActivity);
    } catch (VerifyError | IllegalStateException ignore) {
        return null;
    }
}
 

@Nullable
public static RequestManager with(Activity activity) {
    try {
        return Glide.with(activity);
    } catch (VerifyError | IllegalStateException ignore) {
        return null;
    }
}
 

VideoGridViewAdapter(Context context, ArrayList<VideoInfo> dataList, RequestManager requestManager) {
    this.context = context;
    this.videoListData = dataList;
    this.requestBuilder = requestManager.asDrawable();
    /*this.setItemSelectCallback(new VideoGridViewAdapter.ItemSelectCallback(){
        @Override
        public void onItemSelectCallback(int position) {
            notifyItemChanged(selectedPos);
            selectedPos = position;
            notifyItemChanged(selectedPos);//刷新当前点击item
        }
    });*/
}
 

public MainAdapter(Context context, ObservableList<Image> data, RequestManager requestManager,
                   Listener listener) {
    super(context, data);

    this.requestManager = requestManager;
    this.listener = listener;

    setHasStableIds(true);
}
 

public static DrawableTypeRequest createBaseRequest(RequestManager requestManager, Song song, boolean ignoreMediaStore) {
    if (ignoreMediaStore) {
        return requestManager.load(new AudioFileCover(song.data));
    } else {
        return requestManager.loadFromMediaStore(MusicUtil.getMediaStoreAlbumCoverUri(song.albumId));
    }
}
 

public AppInfoAdapter(Context context, RequestManager requestManager,
                      FilteredSortedList.Filter<AppInfo> filter, OnItemClickListener listener) {
    super(AppInfo.class, filter);
    this.context = context;
    this.inflater = LayoutInflater.from(context);
    this.requestManager = requestManager;
    this.listener = listener;
}
 

@Override
public RequestManager getGlideManager() {
    if (mGlideManager == null) {
        synchronized (this) {
            if (mGlideManager == null) {
                mGlideManager = Glide.with(this);
            }
        }
    }
    return mGlideManager;
}
 

private void loadNetworkDependent() {
    RequestManager requestManager = Glide.with(context);
    DrawableTypeRequest<String> request;

    // if you need transformations or other options specific for the load, chain them here
    if (deviceOnWifi()) {
        request = requestManager.load("http://www.placehold.it/750x750");
    }
    else {
        request = requestManager.load("http://www.placehold.it/100x100");
    }

    request.into(imageView1);
}
 

public static Observable<File> download(RequestManager rm, String url, int width, int height) {
    return Observable.defer(() -> {
        try {
            return Observable.just(rm.load(url).downloadOnly(width, height).get());
        } catch (Exception e) {
            return Observable.error(e);
        }
    });
}