Bitmap Cache (SoftReference, Hard) in Lazy List not working properly - Android

Question

I read several topics on lazy loading a list in stackoverflow, and I'm trying to figure out how to work with different cache levels in android.

As mentioned here:

Lazy loading images in a ListView

I used

Multithreading for performance , by Gill Debunn.

Example. I modified it to just work in the correct way, and also work with 1.6. Here is the code:

/* * Copyright (C) 2010 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ public class ImageDownloader { private static final String TAG = "ImageDownloader"; private static final int HARD_CACHE_CAPACITY = 40; private static final int DELAY_BEFORE_PURGE = 10 * 1000; // in milliseconds private final static ConcurrentHashMap<String, SoftReference<Bitmap>> sSoftBitmapCache = new ConcurrentHashMap<String, SoftReference<Bitmap>>(HARD_CACHE_CAPACITY / 2); /* Download the specified image from the Internet and binds it to the provided ImageView. The * binding is immediate if the image is found in the cache and will be done asynchronously * otherwise. A null bitmap will be associated to the ImageView if an error occurs. * * @param url The URL of the image to download. * @param imageView The ImageView to bind the downloaded image to. */ public void download(String url, ImageView imageView) { Log.d(TAG, "download(String url, ImageView imageView)"); resetPurgeTimer(); Bitmap bitmap = getBitmapFromCache(url); if (bitmap == null) { Log.d(TAG, "(bitmap == null)"); forceDownload(url, imageView); } else { Log.d(TAG, "(bitmap != null) "); cancelPotentialDownload(url, imageView); imageView.setImageBitmap(bitmap); } } /* * Same as download but the image is always downloaded and the cache is not used. * Kept private at the moment as its interest is not clear. private void forceDownload(String url, ImageView view) { forceDownload(url, view, null); } */ /** * Same as download but the image is always downloaded and the cache is not used. * Kept private at the moment as its interest is not clear. */ private void forceDownload(String url, ImageView imageView) { Log.d(TAG, "forceDownload(String url, ImageView imageView)"); // State sanity: url is guaranteed to never be null in DownloadedDrawable and cache keys. if (url == null) { Log.d(TAG, "(url == null)"); imageView.setImageDrawable(null); return; } Bitmap bitmap = null; BitmapDownloaderTask task = null; if (cancelPotentialDownload(url, imageView)) { Log.d(TAG, "(cancelPotentialDownload(url, imageView))"); task = new BitmapDownloaderTask(imageView); DownloadedDrawable downloadedDrawable = new DownloadedDrawable(task); imageView.setImageDrawable(downloadedDrawable); imageView.setMinimumHeight(156); task.execute(url); } } /** * Returns true if the current download has been canceled or if there was no download in * progress on this image view. * Returns false if the download in progress deals with the same url. The download is not * stopped in that case. */ private static boolean cancelPotentialDownload(String url, ImageView imageView) { Log.d(TAG, "---cancelPotentialDownload(String url, ImageView imageView)----)"); BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView); if (bitmapDownloaderTask != null) { Log.d(TAG, "(bitmapDownloaderTask != null)"); String bitmapUrl = bitmapDownloaderTask.url; if ((bitmapUrl == null) || (!bitmapUrl.equals(url))) { Log.d(TAG, "(((bitmapUrl == null) || (!bitmapUrl.equals(url)))"); bitmapDownloaderTask.cancel(true); } else { Log.d(TAG, "The same URL is already being downloaded."); // The same URL is already being downloaded. return false; } } return true; } /** * @param imageView Any imageView * @return Retrieve the currently active download task (if any) associated with this imageView. * null if there is no such task. */ private static BitmapDownloaderTask getBitmapDownloaderTask(ImageView imageView) { Log.d(TAG, "getBitmapDownloaderTask(ImageView imageView)"); if (imageView != null) { Log.d(TAG, "(imageView != null) )"); Drawable drawable = imageView.getDrawable(); if (drawable instanceof DownloadedDrawable) { Log.d(TAG, "(drawable instanceof DownloadedDrawable) "); DownloadedDrawable downloadedDrawable = (DownloadedDrawable)drawable; return downloadedDrawable.getBitmapDownloaderTask(); } } return null; } Bitmap downloadBitmap(String stringUrl) { Log.d(TAG, "(downloadBitmap(String stringUrl)"); URL url = null; HttpURLConnection connection = null; InputStream inputStream = null; try { url = new URL(stringUrl); connection = (HttpURLConnection) url.openConnection(); connection.setUseCaches(true); inputStream = connection.getInputStream(); return BitmapFactory.decodeStream(new FlushedInputStream(inputStream)); /* BitmapFactory.Options bfOptions=new BitmapFactory.Options(); bfOptions.inDither=false; //Disable Dithering mode bfOptions.inPurgeable=true; //Tell to gc that whether it needs free memory, the Bitmap can be cleared bfOptions.inInputShareable=true; //Which kind of reference will be used to recover the Bitmap data after being clear, when it will be used in the future bfOptions.inTempStorage=new byte[32 * 1024]; Bitmap b=BitmapFactory.decodeStream(new FlushedInputStream(inputStream), null,bfOptions ); return b; */ } catch (IOException e) { //getRequest.abort(); Log.w(TAG, "I/O error while retrieving bitmap from " + url, e); } catch (IllegalStateException e) { // getRequest.abort(); Log.w(TAG, "Incorrect URL: " + url); } catch (Exception e) { //getRequest.abort(); Log.w(TAG, "Error while retrieving bitmap from " + url, e); } finally { if (connection != null) { connection.disconnect(); } } return null; } /* * An InputStream that skips the exact number of bytes provided, unless it reaches EOF. */ static class FlushedInputStream extends FilterInputStream { public FlushedInputStream(InputStream inputStream) { super(inputStream); } @Override public long skip(long n) throws IOException { long totalBytesSkipped = 0L; while (totalBytesSkipped < n) { long bytesSkipped = in.skip(n - totalBytesSkipped); if (bytesSkipped == 0L) { int b = read(); if (b < 0) { break; // we reached EOF } else { bytesSkipped = 1; // we read one byte } } totalBytesSkipped += bytesSkipped; } return totalBytesSkipped; } } /** * The actual AsyncTask that will asynchronously download the image. */ class BitmapDownloaderTask extends AsyncTask<String, Void, Bitmap> { private String url; private final WeakReference<ImageView> imageViewReference; public BitmapDownloaderTask(ImageView imageView) { Log.w(TAG, "BitmapDownloaderTask(ImageView imageView)"); imageViewReference = new WeakReference<ImageView>(imageView); } /** * Actual download method. */ @Override protected Bitmap doInBackground(String... params) { Log.w(TAG, "doInBackground"); url = params[0]; return downloadBitmap(url); } /** * Once the image is downloaded, associates it to the imageView */ @Override protected void onPostExecute(Bitmap bitmap) { Log.w(TAG, "onPostExecute"); if (isCancelled()) { bitmap = null; } addBitmapToCache(url, bitmap); if (imageViewReference != null) { Log.w(TAG, "(imageViewReference != null)"); ImageView imageView = imageViewReference.get(); BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView); // Change bitmap only if this process is still associated with it // Or if we don't use any bitmap to task association (NO_DOWNLOADED_DRAWABLE mode) if ((this == bitmapDownloaderTask)) { Log.w(TAG, " if ((this == bitmapDownloaderTask)"); imageView.setImageBitmap(bitmap); } } } } /** * A fake Drawable that will be attached to the imageView while the download is in progress. * * <p>Contains a reference to the actual download task, so that a download task can be stopped * if a new binding is required, and makes sure that only the last started download process can * bind its result, independently of the download finish order.</p> */ static class DownloadedDrawable extends ColorDrawable { private final WeakReference<BitmapDownloaderTask> bitmapDownloaderTaskReference; public DownloadedDrawable(BitmapDownloaderTask bitmapDownloaderTask) { super(Color.BLACK); Log.w(TAG, "DownloadedDrawable(BitmapDownloaderTask bitmapDownloaderTask) "); bitmapDownloaderTaskReference = new WeakReference<BitmapDownloaderTask>(bitmapDownloaderTask); } public BitmapDownloaderTask getBitmapDownloaderTask() { Log.w(TAG, "BitmapDownloaderTask getBitmapDownloaderTask() "); return bitmapDownloaderTaskReference.get(); } } /* public void setMode(Mode mode) { this.mode = mode; clearCache(); } */ /* * Cache-related fields and methods. * * We use a hard and a soft cache. A soft reference cache is too aggressively cleared by the * Garbage Collector. */ // Hard cache, with a fixed maximum capacity and a life duration private final HashMap<String, Bitmap> sHardBitmapCache = new LinkedHashMap<String, Bitmap>(HARD_CACHE_CAPACITY / 2, 0.75f, true) // private final HashMap<String, Bitmap> sHardBitmapCache = new LinkedHashMap<String, Bitmap>() { // private static final long serialVersionUID = -695136752926135717L; @Override protected boolean removeEldestEntry(LinkedHashMap.Entry<String, Bitmap> eldest) { Log.w(TAG, "removeEldestEntry(LinkedHashMap.Entry<String, Bitmap> eldest) "); Log.w(TAG, "size() : " + size()); Log.w(TAG, "HARD_CACHE_CAPACITY : " + HARD_CACHE_CAPACITY); if (size() > HARD_CACHE_CAPACITY) { Log.w(TAG, "(size() > HARD_CACHE_CAPACITY) "); Log.e(TAG, "sSoftBitmapCache --> sSoftBitmapCache.put "); // Entries push-out of hard reference cache are transferred to soft reference cache sSoftBitmapCache.put(eldest.getKey(), new SoftReference<Bitmap>(eldest.getValue())); return true; } else return false; } }; //HARD_CACHE_CAPACITY / 2 // Soft cache for bitmaps kicked out of hard cache // private final static ConcurrentHashMap<String, SoftReference<Bitmap>> sSoftBitmapCache = new ConcurrentHashMap<String, SoftReference<Bitmap>>(); private final Handler purgeHandler = new Handler(); private final Runnable purger = new Runnable() { public void run() { Log.e(TAG, "purger run"); // clearCache(); } }; /** * Adds this bitmap to the cache. * @param bitmap The newly downloaded bitmap. */ private void addBitmapToCache(String url, Bitmap bitmap) { Log.w(TAG, "--------addBitmapToCache-----------"); if (bitmap != null) { Log.w(TAG, "(bitmap != null) "); synchronized (sHardBitmapCache) { //final Bitmap tryData = sHardBitmapCache.get(url); // if (tryData != null) { // sHardBitmapCache.remove(url); // } Log.w(TAG, " sHardBitmapCache.put(url, bitmap);"); sHardBitmapCache.put(url, bitmap); } } } /** * @param url The URL of the image that will be retrieved from the cache. * @return The cached bitmap or null if it was not found. */ private Bitmap getBitmapFromCache(String url) { Log.e(TAG, " --------getBitmapFromCache(String url)----------------"); // First try the hard reference cache synchronized (sHardBitmapCache) { final Bitmap bitmap = sHardBitmapCache.get(url); if (bitmap != null) { Log.e(TAG, " getBitmapFromCache ---> Bitmap found in Hard cache!!!!!"); // Bitmap found in hard cache // Move element to first position, so that it is removed last sHardBitmapCache.remove(url); sHardBitmapCache.put(url, bitmap); return bitmap; }else{ Log.e(TAG, " getBitmapFromCache ---> Bitmap not found in Hard cache"); } } // Then try the soft reference cache SoftReference<Bitmap> bitmapReference = sSoftBitmapCache.get(url); if (bitmapReference != null) { Log.e(TAG, " getBitmapFromCache ---> bitmapReference found in SoftReference cache!"); final Bitmap bitmap = bitmapReference.get(); if (bitmap != null) { Log.e(TAG, "Bitmap found in SoftReference cache!!!!!!!"); // Bitmap found in soft cache return bitmap; } else { Log.e(TAG, "oooooooooooooooooooo --> Soft reference has been Garbage Collected"); // Soft reference has been Garbage Collected sSoftBitmapCache.remove(url); } } return null; } /** * Clears the image cache used internally to improve performance. Note that for memory * efficiency reasons, the cache will automatically be cleared after a certain inactivity delay. */ public void clearCache() { Log.e(TAG, "----------------clearCache() ------------------"); synchronized (sHardBitmapCache) { //sHardBitmapCache.clear(); } //sSoftBitmapCache.clear(); sHardBitmapCache.clear(); sSoftBitmapCache.clear(); } /** * Allow a new delay before the automatic cache clear is done. */ private void resetPurgeTimer() { purgeHandler.removeCallbacks(purger); purgeHandler.postDelayed(purger, DELAY_BEFORE_PURGE); } 

}

I fully understand the logic of this example, however I am confused why this is not working properly.

We have two cache levels: hard cache and SoftReference cache. We save the bitmap images in the hard cache, and then when it is full we save in SoftReference and reorder the hard cache.

Then I close the application, close the Internet and restart it. In the constructor, we call resetPurgeTimer (), which clears the cache and therefore nothing is in the cache. To avoid this, I commented on this line so as not to clear the cache. I am restarting my application and I can see 6-7 images that are present in the SoftReference cache (according to LogCat).

I know that the SoftReference cache may be empty when the GC is called, but it is almost empty even before the application is closed or Wi-Fi is turned off ... There is a known error with SoftReferences that are garbage collected even without memory loss.

Is there something wrong with this widely used example?

Thanks in advance,

Andreas

Answer 1

Yes, in Android 3.0 and higher, you cannot use weak or soft links for bitmap images. The JVM will aggressively collect them. Instead, you should use LRUCache (in the support library) to cache them. I also recommend setting the maximum cache size to a fraction of the maximum heap size (e.g. 1/6).