Précharger des images multiples avec Glide

Nous essayons de précharger les images dans la mémoire cache pour les charger plus tard (les images se trouvent dans le Actifs dossier de l'application)

Ce que nous avons essayé:

Glide.with(this)
    .load(pictureUri)
    .diskCacheStrategy(DiskCacheStrategy.ALL);

Glide.with(this)
    .load(picture_uri)
    .diskCacheStrategy(DiskCacheStrategy.ALL)
    .preload();

La question: les Images sont mises en cache uniquement lorsque nous essayons de charge/afficher:
Elles doivent être chargées dans la mémoire avant de sorte qu'ils apparaissent plus rapidement.

Glide.with(this)
    .load(picture_uri)
    .into(imageView);

Nous avons également essayé d'utiliser un GlideModule pour augmenter la CacheMemory taille:

public class GlideModule implements com.bumptech.glide.module.GlideModule {
    @Override
    public void applyOptions(Context context, GlideBuilder
        builder.setMemoryCache(new LruResourceCache(100000));
    }

    @Override
    public void registerComponents(Context context, Glide glide) {
    }
}

Dans le manifeste:

 <meta-data android:name=".GlideModule" android:value="GlideModule"/>

Rien n'est travaillé jusqu'à présent. Une idée?

Nous d'essayer d'utiliser un invisible 1 dp imageView, mais le résultat est le même:

for(Drawing drawing: getDrawingsForTab(tab)){

    Glide.with(this)
            .load(drawing.getImage().toUri())
            .dontAnimate()
            .diskCacheStrategy(DiskCacheStrategy.ALL)
            .into(mPreloadCacheIv);

    for(Picture picture : getPictures()){

        Glide.with(this)
                .load(picture.getPicture().toUri())
                .dontAnimate()
                .diskCacheStrategy(DiskCacheStrategy.ALL)
                .into(mPreloadCacheIv);
    }
}

Peut-être que vous pourriez déjà charger puis dans un invisible imageView lorsque cela est approprié.
J'ai mis à jour la question avec votre avis. Ça ne marche toujours pas. Glisser la documentation n'est pas très clair sur ce sujet :/
Je n'ai pas utilisé de Glisse. Si vos images sont actifs, je ne suis pas certain pourquoi vous configurez diskCacheStrategy(), car les images sont déjà sur le disque. Êtes-vous sûr que votre mémoire cache est d'être reconnue par les Glisse?
De l'actif les images prennent trop de temps à charger dans l'ImageView. Une fois qu'ils ont été une fois chargé en mémoire, c'est immédiat. Ce que je suis en train de réaliser est le deuxième comportement pour la première fois l'image chargée. Ai-je un moyen de savoir dans quel état est la mémoire cache ?

InformationsquelleAutor An-droid | 2016-06-22

17

La meilleure option est de gérer le cache-même, il vous donne plus de contrôle & devrait être facile comme vous le savez déjà ce sont des bitmaps à être chargé.

Première: Installation d'un LruCache
```
LruCache<String, Bitmap> memCache = new LruCache<>(size) {
    @Override
    protected int sizeOf(String key, Bitmap image) {
        return image.getByteCount()/1024;
    }
};
```
Deuxième: Chargement d'une image bitmap dans le LruCache
```
Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
int width = size.x; //width of screen in pixels
int height = size.y;//height of screen in pixels
Glide.with(context)
    .load(Uri.parse("file:///android_asset/imagefile"))
    .asBitmap()
    .fitCenter() //fits given dimensions maintaining ratio
    .into(new SimpleTarget(width,height) {
        //the constructor SimpleTarget() without (width, height) can also be used.
        //as suggested by, An-droid in the comments
        @Override
        public void onResourceReady(Bitmap resource, GlideAnimation glideAnimation) {
            memCache.put("imagefile", resource);
        }
    });
```
Troisième: Utiliser la mise en cache des bitmaps
```
Bitmap image = memCache.get("imagefile");
if (image != null) {
    //Bitmap exists in cache.
    imageView.setImageBitmap(image); 
} else {
    //Bitmap not found in cache reload it 
    Glide.with(context)
         .load(Uri.parse("file:///android_asset/imagefile"))
         .into(imageView);
}
```
- Comment voulez-vous calculer la taille de la cache Lru ? Sachant que je vais le cache plusieurs images ?
- Ce n'est pas une bonne pratique pour inonder toute votre mémoire avec les bitmaps, idéalement, vous ne devriez pas dépasser plus d'un quart de la mémoire allouée à votre demande (int) (Runtime.getRuntime().maxMemory() / (1024 * 4)) si vous avez besoin d'un cache plus grand que cela, vous devriez essayer une autre approche architecturale.
- Une autre chose, la sizeOf(String key, image Bitmap) la méthode est inconnue de la glisse. Elle n'ont getSize(Object item) ?
- le LruCache que j'utilise est android.util.LruCache<K, V>
- J'ai utilisé com.bumptech.glisse.util.LruCache et il semble fonctionner. La seule chose qui manque est d'obtenir la largeur et la hauteur de la taille de l'image correctement. L'image doit être en plein écran mais en gardant son ratio
- Votre réponse est bonne, pour plus d'informations, il est également possible d'utiliser de nouveaux SimpleTarget() sans spécification de valeurs qui permettent de garder la taille d'origine. C'est ce que j'ai fait:)
- Je veux juste mentionner que c'est probablement inutile pour la plupart des cas, de mettre en œuvre votre propre LruCache lors de l'utilisation de la dernière version de Glisse, comme il a sa propre disque, cache LRU. Voir ici: bumptech.github.io/glisse/doc/configuration.html#disque-cache il est également possible de configurer de sorte que vous pouvez gérer la quantité de mémoire à allouer à la Glisse cache.
InformationsquelleAutor Sakchham
21

Utiliser le code suivant pour mettre en cache les images sans les afficher
1. à l'aide de la downloadOnly méthode si vous êtes à la recherche pour télécharger des images à partir du web et de les stocker dans le diskCache:
```
FutureTarget<File> future = Glide.with(applicationContext)
    .load(yourUrl)
    .downloadOnly(500, 500);
```
2. à l'aide de preload méthode si vous souhaitez charger dans la Mémoire Cache.
```
Glide.with(context)
        .load(url)
        .preload(500, 500);
```
Vous pouvez par la suite utiliser la mise en cache des images à l'aide
```
Glide.with(yourFragment)
    .load(yourUrl)
    .into(yourView);
```
- Notez que les images se trouvent dans le dossier de l'application, sera-il encore ?
- J'ai deviné que vous souhaitez télécharger les images à partir du web. L'API semble être pour "downloadOnly" donc je suppose que la réponse est non. Peu importe, ce que je comprends, vous êtes à la recherche de charger des images à partir d'éléments d'actif dans la MemoryCache?
- Oui c'est le cas, je n'ai pas spécify dans la question (je vais la modifier). J'ai juste besoin que les images soient disponibles dans la mémoire pour un chargement plus rapide et éviter 1, 2 secondes entre le clic et leur apparence. Voulez-vous savoir quelque truc pour le faire ? Avec glisse ou pas ?
- Mise à jour de la réponse
- Pourriez-vous détailler un peu plus la réponse pour exemple, la construction de l'url/uri/chemin d'accès pour obtenir de l'actif. J'ai déjà essayé de précontrainte comme décrit dans la question et il ne fonctionne pas
- comment savez-vous cela ne fonctionne pas? Comment pouvez-vous dire que l'image chargée à partir de la mémoire cache ou de disque?
- Quand je dis que ça ne marche pas, je veux dire l'image prend la même quantité de temps à charger. Oui j'ai essayé d'utiliser un plan de module avec certains LruResourceCache comme décrit dans la question
- Vous devez utiliser GlideApp.with(yourFragment).load(yourUrl).fitCenter().asBitmap().preload(); pour fixer le cache de missies.
- où puis-je trouver des images téléchargées?
InformationsquelleAutor Vinay Wadhwa

Glide version 4.6.1

RequestOptions requestOptions = RequestOptions
        .diskCacheStrategy(DiskCacheStrategy.ALL);

Glide.with(appContext)
        .asBitmap()
        .load(model)
        .apply(requestOptions)
        .submit();

Pourriez-vous donner quelques explications?
L'officiel doc - bumptech.github.io/glisse/doc/..., d'essais et d'erreurs et débogage conçu ce morceau de code

InformationsquelleAutor yoAlex5

-1

//i can give you a solution
/**
* 1.reflect some objects inside Glide
*/
fun prepareGlideObjects() {
if (!enableFunctions || atomicPrepare.getAndSet(true)) {
return
}
var t = LogTime.getLogTime()
glide = Glide.get(BasicConfig.getInstance().appContext)
if (diskCache == null) {
val engine = getObject(glide, "engine")
val diskCacheProvider = getObject(engine, "diskCacheProvider")
val method = diskCacheProvider!!::class.java.getDeclaredMethod("getDiskCache")
method.isAccessible = true
diskCache = method.invoke(diskCacheProvider) as DiskCache
}
if (arrayPool == null) {
arrayPool = getObject(glide, "arrayPool") as ArrayPool
}
if (decoder == null) {
val registry = getObject(glide, "registry") as Registry
val decoderRegistry = getObject(registry, "decoderRegistry") as ResourceDecoderRegistry
val map = getObject(decoderRegistry, "decoders") as HashMap<*, *>
val list = map["Bitmap"] as List<*>
val o = list[0]
decoder = getObject(o, "decoder") as ByteBufferBitmapDecoder
}
Log.debug(TAG, "prepareGlideObjects:" + LogTime.getElapsedMillis(t))
try {
t = LogTime.getLogTime()
//首次打开diskCache 耗时较大，此处是提前打开文件索引
val url = GlideUrl("http://xx.cdn.yy.com/fake_pic.jpg")
val dataCacheKey = DataCacheKey(url, EmptySignature.obtain())
diskCache?.get(dataCacheKey)
Log.debug(TAG, "_load_fake_pic:" + LogTime.getElapsedMillis(t))
} catch (e: Throwable) {
Log.error(TAG, "cold load failed:$e")
}
}
/**
*2.load bitmap-file from diskCache
*/
fun loadBitmap(url: String) {
val gUrl = GlideUrl(url:String)
val dataCacheKey = DataCacheKey(gUrl, EmptySignature.obtain())
val file = diskCache?.get(dataCacheKey)
}
//3.decode bitmap from file
private fun extractBitmapFromFile(url: String, file: File) {
try {
val dimen = getDimensionFromUrl(url)
val result = decoder?.decode(ByteBufferUtil.fromFile(file), dimen[0], dimen[1],
Options()) as BitmapResource?
result!!.initialize()
//simple bitmap cache
bitmapMap[url] = result.get()
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
Log.debug(TAG, "allocationByteCount:" +
bitmapMap[url]!!.allocationByteCount / 1024.0)
}
} catch (e: Throwable) {
Log.error(TAG, "init result failed:$e")
}
}
//4.decode file from http-stream
private fun decodeHttpStream() {
val uri = GlideUrl(call?.request()?.url().toString())
val contentLength = Preconditions.checkNotNull(responseBody).contentLength()
val stream = ContentLengthInputStream.obtain(responseBody.byteStream(),
contentLength)
if (arrayPool == null) {
//re prepare
arrayPool = glide?.arrayPool
}
val encoder = StreamEncoder(arrayPool)
val writer = DataCacheWriter(encoder, stream, Options())
val originalKey = DataCacheKey(uri, EmptySignature.obtain())
//ready,此处可以用来监控文件字节流写入本地文件的时间
diskCache?.put(originalKey, writer)
val file = diskCache?.get(uri)
}

//5.après ces travaux, charger une image à partir de diskCache,il suffit de 10ms。

InformationsquelleAutor dong sheng

Vous devez vous connecter pour publier un commentaire.

Première: Installation d'un LruCache

Deuxième: Chargement d'une image bitmap dans le LruCache

Troisième: Utiliser la mise en cache des bitmaps