Invalidar caché en Picasso

En realidad, basado en su propia respuesta, hay una manera más fácil de hacerlo sin bifurcar la biblioteca. Añadir esta clase a la com.squareup.paquete picasso.

package com.squareup.picasso;

public class PicassoTools {

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

Debido a que la caché tiene visibilidad del paquete, esta clase util puede borrar la caché por usted. Solo tienes que llamarlo:

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

Abortar la caché de memoria y la comprobación de la caché de disco indicando la política de memoria por el indicador: emoryPolicy.NO_CACHE y NetworkPolicy.NO_CACHE como se muestra a continuación fragmento de código:

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

Intenta usar:

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

Otra opción es eliminar el directorio de caché en sí, por ejemplo al iniciar 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 todo el directorio de caché, lo cual está bien si desea simular el primer uso de su aplicación. Si solo desea eliminar la caché de Picasso, agregue "picasso-cache" a la ruta.

Lo que puede hacer si desea eliminar toda la caché a la vez, es crear un Picasso.LruCache personalizado y luego usar el método clear en él.

Aquí hay una muestra:

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

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

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

1.Invalidar la memoria caché:

• Usercase: Cuando la imagen ya se actualiza en caché de disco o host remoto

• Solución: Borrar caché de Url, Archivo, Uri si existe

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

.

2.Invalidar caché de memoria y caché de disco En línea

※nota: En línea significa actualizar directamente a ImageView

• Caso de usuario: Imagen actualizada en host remoto

• Solución: Abortar imagen en caché de memoria y caché de disco y luego solicitar imagen en host remoto

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

  - > Abortar caché de memoria y caché de disco

.

3.Invalidar caché de memoria y caché de disco Sin conexión

※ nota: Offline significa actualizar no actualizar a ImageView, solo buscar en segundo plano usando más tarde

• Caso de usuario: Conoce la imagen en el host remoto actualizada, pero solo desea actualizar la caché solo para usarla después (no actualizar a la vista de imagen)

• Solución: obtener solo

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

※Nota: Usar fetch() es bueno, pero también consume recursos de red, así que considere cuidadosamente, verifique el escenario 4 a continuación para una mejor solución

4.Invalidar caché de memoria y caché de disco si la caché de disco es exist

• Caso de usuario: Solo invalida la caché si ya existe en la caché de disco

• Solución: Debe comprobar el disco utilizando el parámetro: NetworkPolicy.Caché sin conexión 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 increíble libs, espero que squareup agregará más conveniencia API para administrar caché en el futuro próximo.

Puede borrar la caché de imágenes de Picasso configurando su propia caché y borrarla. 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();

No hace un bucle bonito, pero este enfoque solucionó mi problema con caché y Picasso. Solo use esto cuando quiera invalidar la caché para una URL específica, este enfoque es lento y probablemente no es la forma correcta de hacerlo, 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);

Falta una parte muy importante de la respuesta aceptada aquí. Encontré el truco desde aquí: http://blogs.candoerz.com/question/124660/android-image-cache-is-not-clearing-in-picasso.aspx

Simplemente llamando a la siguiente línea, no borraría la caché de una foto cuando usa opciones personalizadas como redimensionar, recortar el centro, etc. al mostrar la imagen original.

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

La solución:

Al mostrar la imagen, utilice el método stableKey().

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

Entonces, usted puede borre la caché de este archivo más tarde llamando a esto:

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

Espero que esto ayude.

Puede omitir la caché de memoria mediante skipMemoryCache()

Véase lo siguiente

        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"

Otra opción es guardar la nueva imagen en un archivo diferente al original. Dado que la caché de mapa de bits de Picasso está desactivada de la ruta del archivo, cargar la nueva imagen desde un archivo diferente resultará en un error de caché. Esto también tiene el beneficio secundario de no tener que borrar toda la caché.

Use shutdown() en su lugar Según el código fuente; el apagado dejará de aceptar más solicitudes, así como borrar toda la caché

 /** 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;
  }

Tampoco puede apagar la instancia de singleton. Así que necesita tener variable de instancia para Picasso. No se olvide de reiniciar picasso instancia cada vez que shutdown() con el fin de reutilizarlo

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