Effacer la mémoire cache de Picasso

Je suis en train de vider le cache mémoire de Picasso via Android de codage.

Quelqu'un peut-il m'aider à ce problème..?

J'ai essayé d'utiliser le code suivant, mais ce n'était pas utile dans mon cas:

Picasso.with(getActivity()).load(data.get(pos).getFeed_thumb_image()).skipMemoryCache().into(image);

source d'informationauteur Parthiban M

Utiliser ce lieu :

 Picasso.with(getContext()).load(data.get(pos).getFeed_thumb_image()).memoryPolicy(MemoryPolicy.NO_CACHE).into(image);

9

Retirer le cache de Picasso comme ça.
```
public class Clear {

    public static void clearCache (Picasso p) {
        p.cache.clear();
    }
}
```
Cette classe util pouvez effacer le cache pour vous. Vous avez juste à appeler:
```
Clear.clearCache(Picasso.with(context));
```
MODIFIER:

La classe de Claire doit être dans le paquet :
```
package com.squareup.picasso;
```
Car le cache n'est pas accessible depuis l'extérieur de cet ensemble.
Comme dans cette réponse: https://stackoverflow.com/a/23544650/4585226

Lorsque l'activité détruire, malheureusement bitmap n'a pas été recyclé si nous sommes à l'aide de Picasso. J'essaie de programmation pour recycler bitmap, ce qui est chargé dans l'image vue. Il y a un moyen de faire référence à chargé image en utilisant Target.

 Target mBackgroundTarget = new Target() {
        Bitmap mBitmap;

        @Override
        public void onBitmapLoaded(Bitmap bitmap, Picasso.LoadedFrom from) {
            if (bitmap == null || bitmap.isRecycled())
                return;

            mBitmap = bitmap;
            mBgImage.setImageBitmap(bitmap);
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    //Do some animation
                }
            });
        }

        @Override
        public void onBitmapFailed(Drawable errorDrawable) {
            recycle();
        }

        @Override
        public void onPrepareLoad(Drawable placeHolderDrawable) {

        }

        /**
         * Recycle bitmap to free memory
         */
        private void recycle() {
            if (mBitmap != null && !mBitmap.isRecycled()) {
                mBitmap.recycle();
                mBitmap = null;
                System.gc();
            }
        }
    };

Et lorsque l'Activité détruire, je l'appelle onBitmapFailed(null) de recycler bitmap chargée.

@Override
protected void onDestroy() {
    super.onDestroy();
    try {
        if (mBackgroundTarget != null) {
            mBackgroundTarget.onBitmapFailed(null);
            Picasso.with(context).cancelRequest(mBackgroundTarget);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Mais rappelez-vous, NE met PAS en CACHE de l'IMAGE DANS la MÉMOIRE en ce cas, Il sera la cause de l'Utilisation recyclé bitmap exception.

Picasso.with(context)
            .load(imageUrl)
            .resize(width, height)
            .memoryPolicy(MemoryPolicy.NO_CACHE)
            .into(mBackgroundTarget);

Espérons que cette aide.

si vous essayez de charger une image à travers Json(db) essayez d'effacer le networkCache pour un meilleur résultat.

Picasso.with(context).load(uri).networkPolicy(NetworkPolicy.NO_CACHE)
        .memoryPolicy(MemoryPolicy.NO_CACHE)
        .placeholder(R.drawable.bv_logo_default).stableKey(id)
        .into(viewImage_imageView);

1

Au lieu d'effacer le cache complet si l'on veut actualiser l'image d'Uri. essayez cette Picasso.with(context).invalidate(uri); en interne supprime la clé de cache géré par Picasso.

Extrait de Picasso.java/** * Invalidate all memory cached images for the specified {@code uri}. * * @see #invalidate(String) * @see #invalidate(File) */ public void invalidate(Uri uri) { if (uri == null) { throw new IllegalArgumentException("uri == null"); } cache.clearKeyUri(uri.toString()); }

Si vous gardez la référence de votre personnalisé Downloader mise en œuvre, vous pouvez effacer le cache.

public class PicassoUtil {
    private static Picasso sInstance;
    private static OkHttp22Downloader sDownloader;
    public  static Picasso getPicasso(Context context){
        if(sInstance == null) {
            sDownloader = new OkHttp22Downloader(context)
            Picasso.Builder builder = new Picasso.Builder(context);
            builder.downloader(sDownloader);
            sInstance = builder.build(sDownloader);
        }
        return sInstance;
    }
   public static void clearCache(){
      if(sDownloader != null){
        sDownloader.clearCache();
      }
   }
}

Il est important d'avoir accès à votre client http et de ses Cache. Dans mon application il ya un accès à la mémoire cache, donc effacer la mémoire cache avec clearCache() méthode.

0

j'ai eu le même problème.
Il a travaillé pour moi.
J'ai utilisé Picasso dans RecycleView à l'intérieur d'une boîte de dialogue. Quand j'ai fermé la boîte de dialogue, picasso ne pas effacer le cache. Mais pendant que vous utilisez la boîte de dialogue, il efface l'image cache. Cependant, il ya certains qui cache n'est pas vidé. Peut-être que le cache n'a pas été effacé est le dernier vous avez vu dans la boîte de dialogue avant de dialogue.rejeter().

utiliser cette
memoryPolicy(MemoryPolicy.NO_CACHE,MemoryPolicy.NO_STORE)
```
Picasso.with(activity).load(file).resize(100,100).centerCrop().memoryPolicy(MemoryPolicy.NO_CACHE,MemoryPolicy.NO_STORE).into(contactImage, new com.squareup.picasso.Callback() {
               @Override
                public void onSuccess() {

                }

                @Override
                public void onError() {

                }
            });
```

 Picasso.with(this.getContext()).load(gamePlayer.getPlayerProfileUrl()).skipMemoryCache().into(iv);

Cela fonctionne aussi

Vous devez vous connecter pour publier un commentaire.