Ich lade ein Bild mit Picasso von der Festplatte , z. B. Picasso.with(ctx).load(new File("/path/to/image")).into(imageView)
aber wenn ich ein neues Bild in dieser Datei speichere und mein Bild aktualisiere ImageView
, hat Picasso immer noch die Bitmap zwischengespeichert.
Ist es möglich, den Cache in Picasso ungültig zu machen?
android
caching
image-loading
picasso
Maarten
quelle
quelle
Picasso.with(getActivity()).invalidate(file);
wie kann ich wieder zwischenspeichern?Antworten:
In den neueren Versionen von Picasso gibt es eine neue Methode zum Ungültigmachen ohne Problemumgehungen. Daher denke ich, dass die zuvor erwähnte benutzerdefinierte PicassoTools-Klasse in diesem Fall veraltet ist
Picasso.with(getActivity()).invalidate(file);
quelle
IllegalStateException
. github.com/square/picasso/commit/…Picasso.with(imageView.getContext()).load(imageUrl).networkPolicy(NetworkPolicy.NO_CACHE).into(imageView);
da invalidate () den Netzwerkcache nicht löschtBasierend auf Ihrer eigenen Antwort gibt es einen einfacheren Weg, dies zu tun, ohne die Bibliothek zu verzweigen. Fügen Sie diese Klasse dem Paket com.squareup.picasso hinzu.
package com.squareup.picasso; public class PicassoTools { public static void clearCache (Picasso p) { p.cache.clear(); } }
Da der Cache Paketsichtbarkeit hat, kann diese util-Klasse den Cache für Sie leeren. Sie müssen es nur nennen:
PicassoTools.clearCache(Picasso.with(context));
quelle
Picasso.with(getApplication()).cache.clear();
das nicht funktioniert. Es wäre viel sauberer.Brechen Sie die Überprüfung des Speichercaches und des Festplattencaches ab, indem Sie die Speicherrichtlinie anhand des Flags angeben: emoryPolicy.NO_CACHE und NetworkPolicy.NO_CACHE wie folgt: Codefragment:
mPicasso.with(mContext) .load(url) .memoryPolicy(MemoryPolicy.NO_CACHE ) .networkPolicy(NetworkPolicy.NO_CACHE) .resize(512, 512) .error(R.drawable.login) .noFade() .into(imageView);
quelle
Versuchen zu benutzen:
Picasso.with(ctx).load(new File("/path/to/image")).skipMemoryCache().into(imageView)
quelle
Wenn Sie den gesamten Cache auf einmal löschen möchten, können Sie eine benutzerdefinierte Datei erstellen
Picasso.LruCache
und anschließend dieclear
Methode verwenden.Hier ist ein Beispiel:
Picasso.Builder builder = new Picasso.Builder(this); LruCache picassoCache = new LruCache(this); builder.memoryCache(picassoCache); Picasso.setSingletonInstance(builder.build());
So leeren Sie den Cache:
picassoCache.clear();
quelle
Die Reihenfolge der Suchbilder in Picasso lautet: Speichercache -> Festplattencache -> Netzwerk
Es gibt also nur wenige Szenarien, in denen der Cache in Picasso ungültig gemacht werden muss:
1. Ungültigen Speichercache:
Lösung: Löschen Sie den Cache von URL, Datei und Uri, falls vorhanden
mPicasso.with(appContext).invalidate(File); mPicasso.with(appContext).invalidate(Url); mPicasso.with(appContext).invalidate(Uri);
.
2. Ungültiger Speichercache und Festplattencache online
※ Hinweis: Online- Mittelaktualisierung direkt auf ImageView
Benutzerfall: Image auf Remote-Host aktualisiert
Lösung: Brechen Sie das Image im Speicher- und Festplatten-Cache ab und fordern Sie das Image auf dem Remote-Host an
mPicasso.with(appContext) .load(url) .memoryPolicy(MemoryPolicy.NO_CACHE ) .networkPolicy(NetworkPolicy.NO_CACHE) .into(imageView);
-> Speicher- und Festplatten-Cache abbrechen
.
3. Ungültigen Speicher-Cache und Festplatten-Cache offline
※ Hinweis: Offline bedeutet Update nicht auf ImageView aktualisieren, sondern nur Hintergrundabruf zur späteren Verwendung
Lösung: Nur abrufen
mPicasso.with(appContext) .load(url) .memoryPolicy(MemoryPolicy.NO_CACHE) .networkPolicy(NetworkPolicy.NO_CACHE) .fetch();
※ Hinweis: Die Verwendung von fetch () ist gut, verbraucht aber auch Netzwerkressourcen. Überlegen Sie daher sorgfältig, ob Sie Szenario 4 unten auf eine bessere Lösung überprüfen
4. Ungültigen Speichercache und Festplattencache Offline, wenn Festplattencache vorhanden ist
Lösung: Sollte die Festplatte vor dem Abrufen mit dem Parameter: NetworkPolicy.OFFLINE-Cache überprüfen
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 ist eine erstaunliche Bibliothek. Ich hoffe, Squareup wird in der kommenden Zukunft mehr Komfort-API für die Verwaltung des Cache hinzufügen.
quelle
Eine andere Möglichkeit besteht darin, das Cache-Verzeichnis selbst zu löschen, beispielsweise beim Start der App:
deleteDirectoryTree(context.getCacheDir());
wo:
/** * Deletes a directory tree recursively. */ public static void deleteDirectoryTree(File fileOrDirectory) { if (fileOrDirectory.isDirectory()) { for (File child : fileOrDirectory.listFiles()) { deleteDirectoryTree(child); } } fileOrDirectory.delete(); }
Dadurch wird das gesamte Cache-Verzeichnis gelöscht. Dies ist in Ordnung, wenn Sie die erste Verwendung Ihrer App simulieren möchten. Wenn Sie nur den Picasso-Cache löschen möchten, fügen Sie dem Pfad "Picasso-Cache" hinzu.
quelle
Sie können den Bildcache von Picasso löschen, indem Sie Ihren eigenen Cache festlegen und diesen löschen. Dieser Code wurde auf Picasso 2.5.0 getestet
private Picasso picasso; private LruCache picassoLruCache; picassoLruCache = new LruCache(context); // Set cache picasso = new Picasso.Builder(context) // .memoryCache(picassoLruCache) // .build(); // Clear cache picassoLruCache.clear();
quelle
Schleife nicht schön, aber dieser Ansatz hat mein Problem mit Cache und Picasso behoben. Verwenden Sie diese Option nur, wenn Sie den Cache für eine bestimmte URL ungültig machen möchten. Dieser Ansatz ist langsam und wahrscheinlich nicht die richtige Vorgehensweise, funktioniert aber für mich.
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);
quelle
Ein sehr wichtiger Teil fehlt in der hier akzeptierten Antwort. Ich habe den Trick von hier gefunden: http://blogs.candoerz.com/question/124660/android-image-cache-is-not-clearing-in-picasso.aspx
Wenn Sie nur die folgende Zeile aufrufen, wird der Cache eines Fotos nicht gelöscht, wenn Sie beim Anzeigen des Originalbilds benutzerdefinierte Optionen wie Größenänderung, Zuschneiden in der Mitte usw. verwenden.
Picasso.with(getContext()).invalidate(file);
Die Lösung:
Verwenden Sie beim Anzeigen des Bildes die
stableKey()
Methode.Picasso.with(getContext()).load(new File(fileUri)) .skipMemoryCache() .placeholder(R.drawable.placeholder) .stableKey(fileUri) .into(imageview);
Anschließend können Sie den Cache dieser Datei später löschen, indem Sie Folgendes aufrufen:
Picasso.with(getContext()).invalidate(fileUri);
Hoffe das wird helfen.
quelle
Sie können den Speichercache überspringen
skipMemoryCache()
siehe folgendes
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"
quelle
Eine andere Möglichkeit besteht darin, das neue Bild in einer anderen Datei als das Original zu speichern. Da der Picasso-Bitmap-Cache vom Dateipfad getrennt ist, führt das Laden des neuen Bildes aus einer anderen Datei zu einem Cache-Fehler. Dies hat auch den Nebeneffekt, dass nicht der gesamte Cache geleert werden muss.
quelle
Verwenden Sie
shutdown()
stattdessen gemäß Quellcode. Durch das Herunterfahren werden keine weiteren Anforderungen mehr akzeptiert und der gesamte Cache geleert/** 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; }
Außerdem können Sie die Singleton-Instanz nicht herunterfahren. Sie benötigen also eine Instanzvariable für
Picasso
. Vergessen Sie nicht, die Picasso-Instanz jedes Mal neu zu initialisieren,shutdown()
um sie wiederzuverwendenquelle
File f = new File(path, name); Picasso.with(this).invalidate(Uri.fromFile(f));
quelle