Android cache d'image

Concernant l'élégant connection.setUseCaches solution ci-dessus: malheureusement, il ne fonctionne pas sans quelques efforts supplémentaires. Vous aurez besoin d'installer un ResponseCache à l'aide de ResponseCache.setDefault. Sinon, HttpURLConnection silencieusement ignorer la setUseCaches(true) peu.

Voir le commentaire en haut de FileResponseCache.java pour plus de détails:

http://libs-for-android.googlecode.com/svn/reference/com/google/android/filecache/FileResponseCache.html

(J'aimerais l'afficher dans un commentaire, mais j'ai n'ont apparemment pas assez pour le karma.)

Utilisation LruCache pour mettre en cache les images de manière efficace. Vous pouvez lire à ce sujet LruCache de Développeur Android site

J'ai utilisé ci-dessous une solution pour les Images de téléchargement et de la mise en cache dans android. Vous pouvez suivre les étapes ci-dessous:

ÉTAPE 1:
faire Classe Nommée ImagesCache. J'ai utilisé Singleton object for this class

import android.graphics.Bitmap;
import android.support.v4.util.LruCache;
public class ImagesCache 
{
private  LruCache<String, Bitmap> imagesWarehouse;
private static ImagesCache cache;
public static ImagesCache getInstance()
{
if(cache == null)
{
cache = new ImagesCache();
}
return cache;
}
public void initializeCache()
{
final int maxMemory = (int) (Runtime.getRuntime().maxMemory() /1024);
final int cacheSize = maxMemory / 8;
System.out.println("cache size = "+cacheSize);
imagesWarehouse = new LruCache<String, Bitmap>(cacheSize)
{
protected int sizeOf(String key, Bitmap value) 
{
//The cache size will be measured in kilobytes rather than number of items.
int bitmapByteCount = value.getRowBytes() * value.getHeight();
return bitmapByteCount / 1024;
}
};
}
public void addImageToWarehouse(String key, Bitmap value)
{       
if(imagesWarehouse != null && imagesWarehouse.get(key) == null)
{
imagesWarehouse.put(key, value);
}
}
public Bitmap getImageFromWarehouse(String key)
{
if(key != null)
{
return imagesWarehouse.get(key);
}
else
{
return null;
}
}
public void removeImageFromWarehouse(String key)
{
imagesWarehouse.remove(key);
}
public void clearCache()
{
if(imagesWarehouse != null)
{
imagesWarehouse.evictAll();
}       
}
}

ÉTAPE 2:

faire une autre classe nommée DownloadImageTask qui est utilisé si l'image bitmap n'est pas disponible dans le cache, il va le télécharger ici:

public class DownloadImageTask extends AsyncTask<String, Void, Bitmap>
{   
private int inSampleSize = 0;
private String imageUrl;
private BaseAdapter adapter;
private ImagesCache cache;
private int desiredWidth, desiredHeight;
private Bitmap image = null;
private ImageView ivImageView;
public DownloadImageTask(BaseAdapter adapter, int desiredWidth, int desiredHeight) 
{
this.adapter = adapter;
this.cache = ImagesCache.getInstance();
this.desiredWidth = desiredWidth;
this.desiredHeight = desiredHeight;
}
public DownloadImageTask(ImagesCache cache, ImageView ivImageView, int desireWidth, int desireHeight)
{
this.cache = cache;
this.ivImageView = ivImageView;
this.desiredHeight = desireHeight;
this.desiredWidth = desireWidth;
}
@Override
protected Bitmap doInBackground(String... params) 
{
imageUrl = params[0];
return getImage(imageUrl);
}
@Override
protected void onPostExecute(Bitmap result) 
{
super.onPostExecute(result);
if(result != null)
{
cache.addImageToWarehouse(imageUrl, result);
if(ivImageView != null)
{
ivImageView.setImageBitmap(result);
}
else
{
}
if(adapter != null)
{
adapter.notifyDataSetChanged();
}
}
}
private Bitmap getImage(String imageUrl)
{   
if(cache.getImageFromWarehouse(imageUrl) == null)
{
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
options.inSampleSize = inSampleSize;
try
{
URL url = new URL(imageUrl);
HttpURLConnection connection = (HttpURLConnection)url.openConnection();
InputStream stream = connection.getInputStream();
image = BitmapFactory.decodeStream(stream, null, options);
int imageWidth = options.outWidth;
int imageHeight = options.outHeight;
if(imageWidth > desiredWidth || imageHeight > desiredHeight)
{   
System.out.println("imageWidth:"+imageWidth+", imageHeight:"+imageHeight);
inSampleSize = inSampleSize + 2;
getImage(imageUrl);
}
else
{   
options.inJustDecodeBounds = false;
connection = (HttpURLConnection)url.openConnection();
stream = connection.getInputStream();
image = BitmapFactory.decodeStream(stream, null, options);
return image;
}
}
catch(Exception e)
{
Log.e("getImage", e.toString());
}
}
return image;
}

ÉTAPE 3: Utilisation de votre Activity ou Adapter

Remarque: Si vous voulez charger une image à partir de l'url à partir de Activity Classe. Utiliser le deuxième Constructeur de DownloadImageTask, mais si vous voulez afficher une image à partir Adapter utiliser le premier Constructeur de DownloadImageTask (par exemple vous avez une image dans ListView et vous êtes réglage de l'image à partir de la 'Carte')

L'UTILISATION DE L'ACTIVITÉ:

ImageView imv = (ImageView) findViewById(R.id.imageView);
ImagesCache cache = ImagesCache.getInstance();//Singleton instance handled in ImagesCache class.
cache.initializeCache();
String img = "your_image_url_here";
Bitmap bm = cache.getImageFromWarehouse(img);
if(bm != null)
{
imv.setImageBitmap(bm);
}
else
{
imv.setImageBitmap(null);
DownloadImageTask imgTask = new DownloadImageTask(cache, imv, 300, 300);//Since you are using it from `Activity` call second Constructor.
imgTask.execute(img);
}

UTILISATION DE L'ADAPTATEUR:

ImageView imv = (ImageView) rowView.findViewById(R.id.imageView);
ImagesCache cache = ImagesCache.getInstance();
cache.initializeCache();
String img = "your_image_url_here";
Bitmap bm = cache.getImageFromWarehouse(img);
if(bm != null)
{
imv.setImageBitmap(bm);
}
else
{
imv.setImageBitmap(null);
DownloadImageTask imgTask = new DownloadImageTask(this, 300, 300);//Since you are using it from `Adapter` call first Constructor.
imgTask.execute(img);
}

Remarque:

cache.initializeCache() vous pouvez utiliser cette instruction dans la première Activité de votre application. Une fois que vous avez initialisé la cache vous n'aurez jamais besoin de initialisé à chaque fois si vous utilisez ImagesCache instance.

Je ne suis pas douée pour expliquer les choses, mais espérons que cela aidera les débutants que la façon de mettre en cache en utilisant LruCache et de son utilisation 🙂

EDIT:

Maintenant un jours il y a des très célèbres bibliothèques connu comme Picasso et Glide qui peut être utilisé pour charger des images de manière très efficace dans l'application android. Essayez cette très simple et utile bibliothèque Picasso pour android et De Glisse Pour Android. Vous n'avez pas besoin de s'inquiéter à propos de cache des images.

Picasso permet sans tracas chargement de l'image dans votre application—souvent
en une seule ligne de code!

De la glisse, tout comme Picasso, peut charger et afficher des images à partir de nombreux
sources, tout en prenant également en charge la mise en cache et de garder un peu de mémoire
en manipulations d'images. Il a été utilisé par les officiels
Google apps (comme l'app pour Google I/O 2015) et est tout aussi populaire
comme Picasso. Dans cette série, nous allons explorer les différences et les
les avantages de la Glisse sur Picasso.

Vous pouvez également visiter le blog pour la différence entre la Glisse et Picasso

Je voudrais envisager d'utiliser droidfu de l'image cache. Il met en œuvre à la fois une mémoire et un disque d'images en fonction de cache. Vous bénéficiez également d'un WebImageView qui tire parti de la ImageCache bibliothèque.

Voici la description complète de droidfu et WebImageView:
http://brainflush.wordpress.com/2009/11/23/droid-fu-part-2-webimageview-and-webgalleryadapter/

Comme le Tonnerre Lapin suggéré, ImageDownloader est le meilleur pour le job. J'ai aussi trouvé une légère variation de la classe à:

http://theandroidcoder.com/utilities/android-image-download-and-caching/

La principale différence entre les deux est que la ImageDownloader utilise le Android système de mise en cache, et la modification de l'une des utilisations internes et externes de stockage que la mise en cache, en gardant en mémoire cache des images indéfiniment ou jusqu'à ce que l'utilisateur supprime manuellement. L'auteur mentionne également Android 2.1 compatibilité.

Il y a une entrée spéciale sur la formation officielle de la section d'Android à ce sujet: http://developer.android.com/training/displaying-bitmaps/cache-bitmap.html

La section est tout à fait nouveau, il n'était pas là lorsque la question a été posée.

La solution proposée est d'utiliser un LruCache. Cette catégorie a été introduite en Nid d'abeille, mais il est également inclus dans la bibliothèque de compatibilité.

Vous pouvez initialiser un LruCache en définissant le nombre maximal d'entrées et il sera automatiquement trier votre vous et nettoyez-les moins utilisés lorsque vous dépassez la limite. Autre que cela, il est utilisé comme normal Map.

L'exemple de code à partir de la page officielle:

private LruCache mMemoryCache;
@Override
protected void onCreate(Bundle savedInstanceState) {
...
//Get memory class of this device, exceeding this amount will throw an
//OutOfMemory exception.
final int memClass = ((ActivityManager) context.getSystemService(
Context.ACTIVITY_SERVICE)).getMemoryClass();
//Use 1/8th of the available memory for this memory cache.
final int cacheSize = 1024 * 1024 * memClass / 8;
mMemoryCache = new LruCache(cacheSize) {
@Override
protected int sizeOf(String key, Bitmap bitmap) {
//The cache size will be measured in bytes rather than number of items.
return bitmap.getByteCount();
}
};
...
}
public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
if (getBitmapFromMemCache(key) == null) {
mMemoryCache.put(key, bitmap);
}
}
public Bitmap getBitmapFromMemCache(String key) {
return mMemoryCache.get(key);
}

Précédemment SoftReferences sont une bonne alternative, mais pas plus, en citant la page officielle:

Remarque: Dans le passé, un quartier populaire de la mémoire cache de mise en œuvre a été un
SoftReference ou WeakReference cache bitmap, mais ce n'est pas
recommandé. À partir de Android 2.3 (API de Niveau 9) à la poubelle
collecteur est plus agressif avec la collecte de soft/références faibles
ce qui les rend assez inefficace. En outre, avant d'Android 3.0
API (Niveau 11), la sauvegarde des données d'une image bitmap a été stocké dans la végétation
de mémoire, ce qui n'est pas publié d'une manière prévisible, potentiellement
provoquant une application brièvement dépasser ses limites de mémoire et de crash.

Ce qui a fonctionné pour moi a été mise en ResponseCache sur ma classe Principale:

try {
File httpCacheDir = new File(getApplicationContext().getCacheDir(), "http");
long httpCacheSize = 10 * 1024 * 1024; //10 MiB
HttpResponseCache.install(httpCacheDir, httpCacheSize);
} catch (IOException e) { } 

et

connection.setUseCaches(true);

lors du téléchargement de l'image.

http://practicaldroid.blogspot.com/2013/01/utilizing-http-response-cache.html

J'avais lutté avec pendant un certain temps, et les réponses à l'aide de SoftReferences de perdre leurs données trop rapidement. Les réponses suggèrent que l'instanciation d'un RequestCache étaient trop salissant, en plus je n'ai jamais pu trouver un exemple complet.

Mais ImageDownloader.java fonctionne à merveille pour moi. Il utilise une table de hachage jusqu'à ce que la capacité soit atteint ou jusqu'à ce que la purge du délai d'attente se produit, alors les choses se déplacé à un SoftReference, utilisant ainsi le meilleur des deux mondes.

Même plus tard de réponse, mais j'ai écrit un Android Image Manager qui gère la mise en cache transparente (mémoire et disque). Le code est sur Github https://github.com/felipecsl/Android-ImageManager