studio - Caché claro de Picasso en Android

para que sirve la libreria picasso en android studio

Question

Estoy usando Picasso para mostrar el retrato, cuando se modifica el protrait, quiero borrar el caché de este usuario (o el caché de retrato de todos los usuarios), aquí está mi código, y no funciona, ¿alguien puede ayudarme?

LruCache lruCache = new LruCache(context);
lruCache.clear();
Picasso picasso = new Picasso.Builder(context).memoryCache(lruCache).build();
picasso.load(portraitUrl).resize(50, 50).centerCrop().error(R.drawable.user_portrait).into(portaitView);

Answer 1

En las versiones recientes de Picasso, hay un nuevo método para invalidar, sin ningún tipo de solución, así que creo que la clase personalizada de PicassoTools mencionada anteriormente, ahora está obsoleta.

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

Answer 2

Estaba enfrentando el mismo problema y ninguna de las soluciones era aceptable para mí ... Así que al menos hice una solución con reflexión. No utilizo crop, resize, etc., así que mi función clear solo funciona si solo usas load(url) con cambio de tamaño, recorte, transformaciones ... Pero he personalizado la función getKey completa, así que esto debería ser al menos un gran ayuda para extender la función de borrar. O simplemente haga pública la función getKey y cambie la función clear(uri) para clear(key) ...

Acabo de copiar la función clave del código fuente y lo adopté.

Solo obtenga la instancia de picasso de mi clase de herramientas y todo debería funcionar (en lugar de tener un proveedor de contexto como yo, puede, por ejemplo, agregar una función init para inicializar la clase PicassoTools, por ejemplo, con el contexto de la aplicación).

Solo usa la siguiente clase de herramientas:

public class PicassoTools
{
private static Picasso picasso = null;
private static CustomLruCache lruCache = null;

private static CustomLruCache getCache()
{
    if (lruCache == null)
        lruCache = new CustomLruCache(MainApp.getAppContext());
    return lruCache;
}

public static Picasso getPicasso()
{
    if (picasso == null)
        picasso = new Picasso.Builder(MainApp.getAppContext()).memoryCache(getCache()).build();
    return picasso;
}

public static void clear(Uri uri)
{
    getCache().remove(getKey(uri));
}

public static void clearCache()
{
    getCache().clear();
    // Picasso.with(MainApp.getAppContext()).cache.clear();
}

public static void clearCache(Context c)
{
    getCache().clear();
    // Picasso.with(c).cache.clear();
}

private static final int KEY_PADDING = 50; // Determined by exact science.

private static String getKey(Uri uri)
{
    return getKey(uri, null, 0, 0, false, false, null);
}

private static String getKey(Uri uri, Integer resourceId, int targetWidth, int targetHeight, boolean centerCrop, boolean centerInside, List<Transformation> transformations)
{
    StringBuilder builder = new StringBuilder();
    if (uri != null)
    {
        String path = uri.toString();
        builder.ensureCapacity(path.length() + KEY_PADDING);
        builder.append(path);
    }
    else
    {
        builder.ensureCapacity(KEY_PADDING);
        builder.append(resourceId);
    }
    builder.append(''/n'');

    if (targetWidth != 0)
    {
        builder.append("resize:").append(targetWidth).append(''x'').append(targetHeight);
        builder.append(''/n'');
    }
    if (centerCrop)
    {
        builder.append("centerCrop/n");
    }
    else if (centerInside)
    {
        builder.append("centerInside/n");
    }

    if (transformations != null)
    {
        // noinspection ForLoopReplaceableByForEach
        for (int i = 0, count = transformations.size(); i < count; i++)
        {
            builder.append(transformations.get(i).key());
            builder.append(''/n'');
        }
    }

    return builder.toString();
}
}

Y la clase de caché extendida:

public class CustomLruCache extends LruCache
{
public CustomLruCache(Context context)
{
    super(context);
}

public CustomLruCache(int value)
{
    super(value);
}

@Override
public Bitmap get(String key)
{
    L.d(this, key);
    return super.get(key);
}

public void remove(String key)
{
    try
    {
        Bitmap value = map.remove(key);

        Field fieldSize = LruCache.class.getDeclaredField("size");
        fieldSize.setAccessible(true);
        Integer size = (Integer) fieldSize.get(this);
        size -= Utils.getBitmapBytes(value);
        fieldSize.set(this, size);

        Field fieldEvictionCount = LruCache.class.getDeclaredField("evictionCount");
        fieldEvictionCount.setAccessible(true);
        Integer evictionCount = (Integer) fieldEvictionCount.get(this);
        evictionCount++;
        fieldEvictionCount.set(this, evictionCount);

    }
    catch (IllegalArgumentException e)
    {
        L.e(this, e);
    }
    catch (IllegalAccessException e)
    {
        L.e(this, e);
    }
    catch (NoSuchFieldException e)
    {
        L.e(this, e);
    }
}
}

PD: inspirado por Invalidar el caché en Picasso