Invalidar la memoria caché de Picasso

Question

Puedo cargar una imagen desde el disco con Picasso, por ejemplo, Picasso.with(ctx).load(new File("/path/to/image")).into(imageView), pero siempre que puedo guardar una imagen nueva en el archivo, y la actualización de mi ImageView, Picasso todavía tiene el mapa de bits en caché.

Es posible invalidar la caché de Picasso?

Answer 1

En las versiones recientes de Picasso, hay un nuevo método para invalidar, sin ninguna solución, por lo que creo que la clase de encargo de PicassoTools mencionada anteriormente, ahora está obsoleta en este caso

Picasso.with(getActivity()).invalidate(file);

Answer 2

En realidad, basado en su propia respuesta, hay una forma más fácil de hacerlo sin bifurcación de la biblioteca.Agregue esta clase al paquete com.squareup.picasso.

package com.squareup.picasso;

public class PicassoTools {

    public static void clearCache (Picasso p) {
        p.cache.clear();
    }
}

Debido a que el caché tiene la visibilidad del paquete, esta clase UTIL puede eliminar el caché para usted.Solo tienes que llamarlo:

PicassoTools.clearCache(Picasso.with(context));

Answer 3

CHECK DE MEMORIA DE ABORTAMENTO Y CHECK DE CAGE DE DISH INDICADA POLÍTICA DE MEMORIA POR LA INDICA: EMORYPOLICY.NO_CACHE y NETILYPOLICY.NO_CACHE COMO ABAJO CÓDIGO SNIPPET:

   mPicasso.with(mContext)
            .load(url)
            .memoryPolicy(MemoryPolicy.NO_CACHE )
            .networkPolicy(NetworkPolicy.NO_CACHE)
            .resize(512, 512)
            .error(R.drawable.login)
            .noFade()
            .into(imageView);

Answer 4

Intenta usar:

Picasso.with(ctx).load(new File("/path/to/image")).skipMemoryCache().into(imageView)

Answer 5

Otra opción es eliminar el propio directorio de caché, por ejemplo, en la puesta en marcha de la aplicación:

deleteDirectoryTree(context.getCacheDir());

donde:

/**
 * Deletes a directory tree recursively.
 */
public static void deleteDirectoryTree(File fileOrDirectory) {
    if (fileOrDirectory.isDirectory()) {
        for (File child : fileOrDirectory.listFiles()) {
            deleteDirectoryTree(child);
        }
    }

    fileOrDirectory.delete();
}

que elimina el directorio completo de caché, que está bien si desea simular el primer uso de su aplicación.Si solo desea eliminar el caché Picasso, agregue "Picasso-caché" a la ruta.

Answer 6

Lo que puede hacer si desea borrar todo el cache a la vez, es crear una personalizada Picasso.LruCache, y , a continuación, utilizar la clear método.

He aquí un ejemplo:

Picasso.Builder builder = new Picasso.Builder(this);
LruCache picassoCache = new LruCache(this);
builder.memoryCache(picassoCache);
Picasso.setSingletonInstance(builder.build());

Para borrar la caché:

picassoCache.clear();

Answer 7

El orden de la imagen de búsqueda en Picasso es: Caché de memoria -> caché de disco -> red

Así que hay pocos escenarios que necesitamos para invalidar caché en Picasso:

1.invalidate de memoria caché:

• USERCASE: cuando la imagen ya está actualizada en el caché de disco o en el host remoto

• Solución: Clear caché de URL, archivo, URI si existe

  mPicasso.with(appContext).invalidate(File);
  mPicasso.with(appContext).invalidate(Url);
  mPicasso.with(appContext).invalidate(Uri);
  

.

2.Invalidate de memoria caché de memoria y caché de disco en línea

※ Nota: online la actualización media directamente a ImageView

• Funda de usuario: Imagen actualizada en el host remoto

• Solución: abortar la imagen en la memoria caché de memoria y la caché de disco, solicite una imagen en el host remoto

  mPicasso.with(appContext)
      .load(url)
      .memoryPolicy(MemoryPolicy.NO_CACHE )
      .networkPolicy(NetworkPolicy.NO_CACHE)
      .into(imageView);
  

  -> cancelar el caché de memoria y el caché de disco

.

3.Invalidate de memoria caché de memoria y caché de disco fuera de línea

※ Nota: offline offline la actualización media no actualizada a ImageView, solo Fondo Fetch para usar más tarde

• Funda de usuario: usted conoce la imagen en el host remoto actualizado, pero solo desea actualizar caché solo para usar después (no actualizar en la vista de imagen)

• Solución: SOLO FLEX

   mPicasso.with(appContext)
      .load(url)
      .memoryPolicy(MemoryPolicy.NO_CACHE)
      .networkPolicy(NetworkPolicy.NO_CACHE)
      .fetch();
  

※ Nota: el uso de Fetch () es bueno, pero también consume un recurso de red, por lo que considere cuidadosamente, compruebe el escenario 4 a continuación para una mejor solución

4.Invalidate de memoria caché de memoria y caché de disco fuera de línea Si existe caché de disco

• caso de usuario: solo invalida la caché si ya existe en el caché de disco

• Solución: debe verificar el disco usando el parámetro: NetworkPolicy.Offline cache antes de Fetch

   mPicasso.with(appContext)
      .load(url)
      .memoryPolicy(MemoryPolicy.NO_CACHE)
      .networkPolicy(NetworkPolicy.OFFLINE)
      .fetch(new Callback() {
          @Override
          public void onSuccess() {
              //Success: mean disk cache exist -> should do actual fetch
              picasso.load(url).fetch();
          }
  
          @Override
          public void onError() {
          //Failed: mean disk cache not exist
      }
  });
  

Picasso es una licor increíble, espero que SquareUp agregue más comodidad API para administrar el caché en el próximo futuro.

Answer 8

Puede borrar la memoria caché de Picasso al configurar su propia memoria caché y borrar eso. Este código fue probado en Picasso 2.5.0

private Picasso picasso;
private LruCache picassoLruCache;

picassoLruCache = new LruCache(context);

// Set cache
picasso = new Picasso.Builder(context) //
        .memoryCache(picassoLruCache) //
        .build();

// Clear cache
picassoLruCache.clear();

Answer 9

no se bucle bonita, pero este enfoque fijó mi problema con caché y picasso.Solo use esto cuando desee invalidar el caché para una URL específica, este enfoque es lento y, probablemente, no es la forma correcta de hacer, pero funciona para mí.

    String url = "http://www.blablabla.com/Raiders.jpg";
    Picasso.with(this).invalidate(url);
    Picasso.with(this)
            .load(url)
            .networkPolicy(
                    NetworkUtils.isConnected(this) ?
                            NetworkPolicy.NO_CACHE : NetworkPolicy.OFFLINE)
            .resize(200, 200)
            .centerCrop()
            .placeholder(R.mipmap.ic_avatar)
            .error(R.mipmap.ic_avatar)
            .into(imageView);

Answer 10

Falta una parte muy importante en la respuesta aceptada aquí.Encontré el truco desde aquí: http://blogs.candoerz.com/question/124660/Adroid-Image-cache-is-Not-Clearing-in-picasso.aspx

Solo llamando a la siguiente línea, no eliminaría el caché de una foto cuando use opciones personalizadas como el tamaño de tamaño, el recorte central, etc. cuando se muestra la imagen original.

Picasso.with(getContext()).invalidate(file);

La solución:

Al visualizar la imagen, use el método stableKey().

Picasso.with(getContext()).load(new File(fileUri))
                         .skipMemoryCache()
                         .placeholder(R.drawable.placeholder)
                         .stableKey(fileUri)
                         .into(imageview);

Luego, puede borrar el caché de este archivo más tarde llamando a esto:

Picasso.with(getContext()).invalidate(fileUri);

Espero que esto ayude.

Answer 11

You can skip memory cache by skipMemoryCache()

see the following

        Picasso.with(this)
            .load(IMAGE_URL)
            .skipMemoryCache()
            .placeholder(R.drawable.placeholder)
            .error(R.drawable.no_image)
            .into(mImageViewPicasso);

gradle compile "com.squareup.picasso:picasso:2.4.0"

Answer 12

Another option is to save the new image into a different file than the original. Since the Picasso bitmap cache is keyed off of the file path, loading the new image from a different file will result in a cache miss. This also has the side benefit of not having to clear the entire cache.

Answer 13

use shutdown() instead As per source code; shutdown will stop accepting further request as well as clear all cache

 /** Stops this instance from accepting further requests. */
  public void shutdown() {
    if (this == singleton) {
      throw new UnsupportedOperationException("Default singleton instance cannot be shutdown.");
    }
    if (shutdown) {
      return;
    }
    cache.clear();
    cleanupThread.shutdown();
    stats.shutdown();
    dispatcher.shutdown();
    for (DeferredRequestCreator deferredRequestCreator : targetToDeferredRequestCreator.values()) {
      deferredRequestCreator.cancel();
    }
    targetToDeferredRequestCreator.clear();
    shutdown = true;
  }

Also you can not shutdown singleton instance. So you need to have instance variable for Picasso. Do not forget to reinitialize picasso instance everytime you shutdown() it in order to reuse it

Answer 14

File f = new File(path, name);
Picasso.with(this).invalidate(Uri.fromFile(f));