android : SoftReference / WeakReference example

package com.myapp;

import java.io.File;
import java.lang.ref.SoftReference;
import java.util.WeakHashMap;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Log;


public class BitmapSoftRefrences {


      public static String SDPATH = Environment.getExternalStorageDirectory()
        + "/MYAPP";

// 1. create a cache map
public static WeakHashMap<String, SoftReference<Bitmap>> mCache = new WeakHashMap<String, SoftReference<Bitmap>>();
public static String TAG = "BitmapSoftRefrences";

// 2. ask for bitmap
public static Bitmap get(String key) {
    if (key == null) {
        return null;
    }

    try {
        if (mCache.containsKey(key)) {

            SoftReference<Bitmap> reference = mCache.get(key);
            Bitmap bitmap = reference.get();
            if (bitmap != null) {
                return bitmap;
            }
            return decodeFile(key);
        }

    } catch (Exception e) {
        // TODO: handle exception
        Logger.debug(BitmapSoftRefrences.class,
                "EXCEPTION: " + e.getMessage());

    }

    // the key does not exists so it could be that the
    // file is not downloaded or decoded yet...

    File file = new File(SDPATH + "/" + key);

    if (file.exists()) {
        return decodeFile(key);
    } else {
        Logger.debug(BitmapSoftRefrences.class, "RuntimeException");

        throw new RuntimeException("RuntimeException!");
    }
}

// 3. the decode file will return bitmap if bitmap is not cached
public static Bitmap decodeFile(String key) {
    // --- prevent scaling
    BitmapFactory.Options opt = new BitmapFactory.Options();
    opt.inScaled = false;

    Bitmap bitmap = BitmapFactory.decodeFile(SDPATH + "/" + key, opt);

    mCache.put(key, new SoftReference<Bitmap>(bitmap));

    return bitmap;
}

public static void clear() {
    mCache.clear();
}

}

To create a WeakReference, the syntax is WeakReference<SomeType> myWeakReference = new WeakReference<SomeType>(actualObject);. To retrieve the object via that WeakReference, do the check if (weakWidget == null). That way, you will avoid a NullPointerException if it has been garbage-collected already.

This Java.net article by Ethan Nicholas explains why you would want to use a WeakReference instead of a strong one. It provides the example of a final (unextendible) class called Widget that has no defined serial UID, presuming that the developer decides to define a serial UID to track each Widget instance. They do so by creating a new HashMap and doing something like serialNumberMap.put(widget, widgetSerialNumber); which is a strong reference. That means it must be explicitly cleaned up when no longer needed. The developer is responsible for knowing exactly when to manually "garbage-collect" that reference and remove it from the HashMap, which should be done only when they're really sure it's not needed anymore. This may be the problem you ran into in your application.

In this particular case, as the article explains, the developer could use the WeakHashMap class instead (as @NayAneshGupte put in his example), wherein the key is actually a WeakReference. This would allow the JVM nullify the keys to old Widgets as it saw fit, so that the garbage collector could come along and destroy their associated objects.

The article also goes on to talk about SoftReferences and PhantomReferences (which I've never used). You can read more about all of these in this javapapers.com article and this Rally blog.