Release memory of Image Loader on android

Question

I use ImageLoader to get images and show progress bar till image is been downloaded. This class is used by the ArrayAdapter to load images on to a GridView.

I want to know how to release image memory when the fragment that loads this gridview has been detached from the activity. Also, is it expensive to store it in memory (i.e backstack) if several fragment transitions happen after loading this this view.

Here is my code

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Collections;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Log;
import android.view.View;
import android.widget.ImageView;
import android.widget.ProgressBar;

public class ImageLoader {

    MemoryCache memoryCache = new MemoryCache();
    FileCache fileCache;

    private Map<ImageView, String> imageViews = Collections
            .synchronizedMap(new WeakHashMap<ImageView, String>());
    ExecutorService executorService;
    Activity activity = null;

    public ImageLoader(Context context) {
        fileCache = new FileCache(context);
        executorService = Executors.newFixedThreadPool(5);
    }

    public void DisplayImage(String url, Activity activity,
            ImageView imageView, ProgressBar p) {
        imageViews.put(imageView, url);
        this.activity = activity;
        Bitmap bitmap = memoryCache.get(url);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
            imageView.setTag("loaded");
            imageView.setVisibility(View.VISIBLE);
            p.setVisibility(View.GONE);
        } else {
            queuePhoto(url, imageView, p);
            imageView.setImageResource(Utils.stub_id);
        }
    }



    private void queuePhoto(String url, ImageView imageView, ProgressBar pb) {
        PhotoToLoad p = new PhotoToLoad(url, imageView, activity, pb);
        executorService.submit(new PhotosLoader(p));
    }

    private Bitmap getBitmap(String url) {
        File f = fileCache.getFile(url);

        // from SD cache
        Bitmap b = decodeFile(f);
        if (b != null)
            return b;

        // from web
        try {
            Bitmap bitmap = null;
            URL imageUrl = new URL(url);
            HttpURLConnection conn = (HttpURLConnection) imageUrl
                    .openConnection();
            conn.setConnectTimeout(Utils.timeout);
            conn.setReadTimeout(Utils.timeout);
            conn.setInstanceFollowRedirects(true);
            InputStream is = conn.getInputStream();
            OutputStream os = new FileOutputStream(f);
            Utils.CopyStream(is, os);
            os.close();
            bitmap = decodeFile(f);
            return bitmap;
        } catch (Exception ex) {

            return null;
        }
    }

    // decodes image and scales it to reduce memory consumption
    private Bitmap decodeFile(File f) {
        try {
            // decode image size
            BitmapFactory.Options o = new BitmapFactory.Options();
            o.inJustDecodeBounds = true;
            BitmapFactory.decodeStream(new FileInputStream(f), null, o);

            // Find the correct scale value. It should be the power of 2.
            final int REQUIRED_SIZE = 70;
            int width_tmp = o.outWidth, height_tmp = o.outHeight;
            int scale = 1;
            while (true) {
                if (width_tmp / 2 < REQUIRED_SIZE
                        || height_tmp / 2 < REQUIRED_SIZE)
                    break;
                width_tmp /= 2;
                height_tmp /= 2;
                scale *= 2;
            }

            // decode with inSampleSize
            BitmapFactory.Options o2 = new BitmapFactory.Options();
            o2.inSampleSize = scale;
            return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);
        } catch (FileNotFoundException e) {
        }
        return null;
    }

    // Task for the queue
    private class PhotoToLoad {
        public String url;
        public ImageView imageView;
        Activity activity;
        public ProgressBar progressBar;

        public PhotoToLoad(String u, ImageView i, Activity a, ProgressBar p) {
            url = u;
            imageView = i;
            activity = a;
            progressBar = p;
        }
    }

    class PhotosLoader implements Runnable {
        PhotoToLoad photoToLoad;

        PhotosLoader(PhotoToLoad photoToLoad) {
            this.photoToLoad = photoToLoad;
        }

        @Override
        public void run() {
            if (imageViewReused(photoToLoad))
                return;
            try {
                Bitmap bmp = getBitmap(photoToLoad.url);
                memoryCache.put(photoToLoad.url, bmp);
                if (imageViewReused(photoToLoad))
                    return;
                BitmapDisplayer bd = new BitmapDisplayer(bmp, photoToLoad);
                // Activity a = (Activity) photoToLoad.imageView.getContext();
                photoToLoad.activity.runOnUiThread(bd);
            } catch (Exception e) {
                String s = e.getMessage();
            }
        }
    }

    boolean imageViewReused(PhotoToLoad photoToLoad) {
        String tag = imageViews.get(photoToLoad.imageView);
        if (tag == null || !tag.equals(photoToLoad.url))
            return true;
        return false;
    }

    // Used to display bitmap in the UI thread
    class BitmapDisplayer implements Runnable {
        Bitmap bitmap;
        PhotoToLoad photoToLoad;

        public BitmapDisplayer(Bitmap b, PhotoToLoad p) {
            bitmap = b;
            photoToLoad = p;
        }

        public void run() {
            if (imageViewReused(photoToLoad))
                return;

            if (bitmap != null)
            {
                photoToLoad.imageView.setImageBitmap(bitmap);
                photoToLoad.imageView.setTag("loaded");
            }
            else
                photoToLoad.imageView.setImageResource(Utils.stub_id);

            photoToLoad.imageView.setVisibility(View.VISIBLE);
            photoToLoad.progressBar.setVisibility(View.GONE);
        }

    }

    public void clearCache() {
        memoryCache.clear();
        fileCache.clear();
    }

   }

public class MemoryCache {
    private Map<String, SoftReference<Bitmap>> cache=Collections.synchronizedMap(new HashMap<String, SoftReference<Bitmap>>());

    public Bitmap get(String id){
        if(!cache.containsKey(id))
            return null;
        SoftReference<Bitmap> ref=cache.get(id);
        return ref.get();
    }

    public void put(String id, Bitmap bitmap){
        cache.put(id, new SoftReference<Bitmap>(bitmap));
    }

    public void clear() {
        cache.clear();
    }
}

Answer 1

You can use this method

  MemoryCacheUtils.removeFromCache(url,ImageLoader.getInstance().getMemoryCache());
  DiscCacheUtils.removeFromCache(url, ImageLoader.getInstance().getDiscCache());

or you can done it directly by

imageLoader.clearMemoryCache();

`