Android , React-Native , Kotlin , Android JetBrains Coding Blogs: Display High Resolution Image URL

If you got VM Budget error when display high resolution image so you have to try this example ,to display high resolution image.

create one class name AsyncTask

import android.annotation.TargetApi;
import android.os.Handler;
import android.os.Message;
import android.os.Process;

import java.util.ArrayDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

public abstract class AsyncTask<Params, Progress, Result> {
 private static final String LOG_TAG = "AsyncTask";

 private static final int CORE_POOL_SIZE = 5;
 private static final int MAXIMUM_POOL_SIZE = 128;
 private static final int KEEP_ALIVE = 1;

 private static final ThreadFactory sThreadFactory = new ThreadFactory() {
 private final AtomicInteger mCount = new AtomicInteger(1);

 public Thread newThread(Runnable r) {
 return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
 }
 };

 private static final BlockingQueue<Runnable> sPoolWorkQueue =
 new LinkedBlockingQueue<Runnable>(10);

 /**
 * An {@link Executor} that can be used to execute tasks in parallel.
 */
 public static final Executor THREAD_POOL_EXECUTOR
 = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
 TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory,
 new ThreadPoolExecutor.DiscardOldestPolicy());

 /**
 * An {@link Executor} that executes tasks one at a time in serial
 * order. This serialization is global to a particular process.
 */
 public static final Executor SERIAL_EXECUTOR = Utils.hasHoneycomb() ? new SerialExecutor() :
 Executors.newSingleThreadExecutor(sThreadFactory);

 public static final Executor DUAL_THREAD_EXECUTOR =
 Executors.newFixedThreadPool(2, sThreadFactory);

 private static final int MESSAGE_POST_RESULT = 0x1;
 private static final int MESSAGE_POST_PROGRESS = 0x2;

 private static final InternalHandler sHandler = new InternalHandler();

 private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
 private final WorkerRunnable<Params, Result> mWorker;
 private final FutureTask<Result> mFuture;

 private volatile Status mStatus = Status.PENDING;

 private final AtomicBoolean mCancelled = new AtomicBoolean();
 private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

 @TargetApi(11)
 private static class SerialExecutor implements Executor {
 final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
 Runnable mActive;

 public synchronized void execute(final Runnable r) {
 mTasks.offer(new Runnable() {
 public void run() {
 try {
 r.run();
 } finally {
 scheduleNext();
 }
 }
 });
 if (mActive == null) {
 scheduleNext();
 }
 }

 protected synchronized void scheduleNext() {
 if ((mActive = mTasks.poll()) != null) {
 THREAD_POOL_EXECUTOR.execute(mActive);
 }
 }
 }

 /**
 * Indicates the current status of the task. Each status will be set only once
 * during the lifetime of a task.
 */
 public enum Status {
 /**
 * Indicates that the task has not been executed yet.
 */
 PENDING,
 /**
 * Indicates that the task is running.
 */
 RUNNING,
 /**
 * Indicates that {@link AsyncTask#onPostExecute} has finished.
 */
 FINISHED,
 }

 /** @hide Used to force static handler to be created. */
 public static void init() {
 sHandler.getLooper();
 }

 /** @hide */
 public static void setDefaultExecutor(Executor exec) {
 sDefaultExecutor = exec;
 }

 /**
 * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
 */
 public AsyncTask() {
 mWorker = new WorkerRunnable<Params, Result>() {
 public Result call() throws Exception {
 mTaskInvoked.set(true);

 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
 //noinspection unchecked
 return postResult(doInBackground(mParams));
 }
 };

 mFuture = new FutureTask<Result>(mWorker) {
 @Override
 protected void done() {
 try {
 postResultIfNotInvoked(get());
 } catch (InterruptedException e) {
 android.util.Log.w(LOG_TAG, e);
 } catch (ExecutionException e) {
 throw new RuntimeException("An error occured while executing doInBackground()",
 e.getCause());
 } catch (CancellationException e) {
 postResultIfNotInvoked(null);
 }
 }
 };
 }

 private void postResultIfNotInvoked(Result result) {
 final boolean wasTaskInvoked = mTaskInvoked.get();
 if (!wasTaskInvoked) {
 postResult(result);
 }
 }

 private Result postResult(Result result) {
 @SuppressWarnings("unchecked")
 Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
 new AsyncTaskResult<Result>(this, result));
 message.sendToTarget();
 return result;
 }

 /**
 * Returns the current status of this task.
 *
 * @return The current status.
 */
 public final Status getStatus() {
 return mStatus;
 }

 /**
 * Override this method to perform a computation on a background thread. The
 * specified parameters are the parameters passed to {@link #execute}
 * by the caller of this task.
 *
 * This method can call {@link #publishProgress} to publish updates
 * on the UI thread.
 *
 * @param params The parameters of the task.
 *
 * @return A result, defined by the subclass of this task.
 *
 * @see #onPreExecute()
 * @see #onPostExecute
 * @see #publishProgress
 */
 protected abstract Result doInBackground(Params... params);

 /**
 * Runs on the UI thread before {@link #doInBackground}.
 *
 * @see #onPostExecute
 * @see #doInBackground
 */
 protected void onPreExecute() {
 }

 /**
 * Runs on the UI thread after {@link #doInBackground}. The
 * specified result is the value returned by {@link #doInBackground}.
 *
 * This method won't be invoked if the task was cancelled.
 *
 * @param result The result of the operation computed by {@link #doInBackground}.
 *
 * @see #onPreExecute
 * @see #doInBackground
 * @see #onCancelled(Object)
 */
 @SuppressWarnings({"UnusedDeclaration"})
 protected void onPostExecute(Result result) {
 }

 /**
 * Runs on the UI thread after {@link #publishProgress} is invoked.
 * The specified values are the values passed to {@link #publishProgress}.
 *
 * @param values The values indicating progress.
 *
 * @see #publishProgress
 * @see #doInBackground
 */
 @SuppressWarnings({"UnusedDeclaration"})
 protected void onProgressUpdate(Progress... values) {
 }

 /**
 * Runs on the UI thread after {@link #cancel(boolean)} is invoked and
 * {@link #doInBackground(Object[])} has finished.
 *
 * The default implementation simply invokes {@link #onCancelled()} and
 * ignores the result. If you write your own implementation, do not call
 * <code>super.onCancelled(result)</code>.
 *
 * @param result The result, if any, computed in
 * {@link #doInBackground(Object[])}, can be null
 *
 * @see #cancel(boolean)
 * @see #isCancelled()
 */
 @SuppressWarnings({"UnusedParameters"})
 protected void onCancelled(Result result) {
 onCancelled();
 }

 /**
 * Applications should preferably override {@link #onCancelled(Object)}.
 * This method is invoked by the default implementation of
 * {@link #onCancelled(Object)}.
 *
 * Runs on the UI thread after {@link #cancel(boolean)} is invoked and
 * {@link #doInBackground(Object[])} has finished.
 *
 * @see #onCancelled(Object)
 * @see #cancel(boolean)
 * @see #isCancelled()
 */
 protected void onCancelled() {
 }

 /**
 * Returns <tt>true</tt> if this task was cancelled before it completed
 * normally. If you are calling {@link #cancel(boolean)} on the task,
 * the value returned by this method should be checked periodically from
 * {@link #doInBackground(Object[])} to end the task as soon as possible.
 *
 * @return <tt>true</tt> if task was cancelled before it completed
 *
 * @see #cancel(boolean)
 */
 public final boolean isCancelled() {
 return mCancelled.get();
 }

 /**
 * Attempts to cancel execution of this task. This attempt will
 * fail if the task has already completed, already been cancelled,
 * or could not be cancelled for some other reason. If successful,
 * and this task has not started when <tt>cancel</tt> is called,
 * this task should never run. If the task has already started,
 * then the <tt>mayInterruptIfRunning</tt> parameter determines
 * whether the thread executing this task should be interrupted in
 * an attempt to stop the task.
 *
 * Calling this method will result in {@link #onCancelled(Object)} being
 * invoked on the UI thread after {@link #doInBackground(Object[])}
 * returns. Calling this method guarantees that {@link #onPostExecute(Object)}
 * is never invoked. After invoking this method, you should check the
 * value returned by {@link #isCancelled()} periodically from
 * {@link #doInBackground(Object[])} to finish the task as early as
 * possible.
 *
 * @param mayInterruptIfRunning <tt>true</tt> if the thread executing this
 * task should be interrupted; otherwise, in-progress tasks are allowed
 * to complete.
 *
 * @return <tt>false</tt> if the task could not be cancelled,
 * typically because it has already completed normally;
 * <tt>true</tt> otherwise
 *
 * @see #isCancelled()
 * @see #onCancelled(Object)
 */
 public final boolean cancel(boolean mayInterruptIfRunning) {
 mCancelled.set(true);
 return mFuture.cancel(mayInterruptIfRunning);
 }

 /**
 * Waits if necessary for the computation to complete, and then
 * retrieves its result.
 *
 * @return The computed result.
 *
 * @throws CancellationException If the computation was cancelled.
 * @throws ExecutionException If the computation threw an exception.
 * @throws InterruptedException If the current thread was interrupted
 * while waiting.
 */
 public final Result get() throws InterruptedException, ExecutionException {
 return mFuture.get();
 }

 /**
 * Waits if necessary for at most the given time for the computation
 * to complete, and then retrieves its result.
 *
 * @param timeout Time to wait before cancelling the operation.
 * @param unit The time unit for the timeout.
 *
 * @return The computed result.
 *
 * @throws CancellationException If the computation was cancelled.
 * @throws ExecutionException If the computation threw an exception.
 * @throws InterruptedException If the current thread was interrupted
 * while waiting.
 * @throws TimeoutException If the wait timed out.
 */
 public final Result get(long timeout, TimeUnit unit) throws InterruptedException,
 ExecutionException, TimeoutException {
 return mFuture.get(timeout, unit);
 }

 /**
 * Executes the task with the specified parameters. The task returns
 * itself (this) so that the caller can keep a reference to it.
 *
 * Note: this function schedules the task on a queue for a single background
 * thread or pool of threads depending on the platform version. When first
 * introduced, AsyncTasks were executed serially on a single background thread.
 * Starting with {@link android.os.Build.VERSION_CODES#DONUT}, this was changed
 * to a pool of threads allowing multiple tasks to operate in parallel. Starting
 * {@link android.os.Build.VERSION_CODES#HONEYCOMB}, tasks are back to being
 * executed on a single thread to avoid common application errors caused
 * by parallel execution. If you truly want parallel execution, you can use
 * the {@link #executeOnExecutor} version of this method
 * with {@link #THREAD_POOL_EXECUTOR}; however, see commentary there for warnings
 * on its use.
 *
 * This method must be invoked on the UI thread.
 *
 * @param params The parameters of the task.
 *
 * @return This instance of AsyncTask.
 *
 * @throws IllegalStateException If {@link #getStatus()} returns either
 * {@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}.
 *
 * @see #executeOnExecutor(java.util.concurrent.Executor, Object[])
 * @see #execute(Runnable)
 */
 public final AsyncTask<Params, Progress, Result> execute(Params... params) {
 return executeOnExecutor(sDefaultExecutor, params);
 }

 /**
 * Executes the task with the specified parameters. The task returns
 * itself (this) so that the caller can keep a reference to it.
 *
 * This method is typically used with {@link #THREAD_POOL_EXECUTOR} to
 * allow multiple tasks to run in parallel on a pool of threads managed by
 * AsyncTask, however you can also use your own {@link Executor} for custom
 * behavior.
 *
 * Warning: Allowing multiple tasks to run in parallel from
 * a thread pool is generally not what one wants, because the order
 * of their operation is not defined. For example, if these tasks are used
 * to modify any state in common (such as writing a file due to a button click),
 * there are no guarantees on the order of the modifications.
 * Without careful work it is possible in rare cases for the newer version
 * of the data to be over-written by an older one, leading to obscure data
 * loss and stability issues. Such changes are best
 * executed in serial; to guarantee such work is serialized regardless of
 * platform version you can use this function with {@link #SERIAL_EXECUTOR}.
 *
 * This method must be invoked on the UI thread.
 *
 * @param exec The executor to use. {@link #THREAD_POOL_EXECUTOR} is available as a
 * convenient process-wide thread pool for tasks that are loosely coupled.
 * @param params The parameters of the task.
 *
 * @return This instance of AsyncTask.
 *
 * @throws IllegalStateException If {@link #getStatus()} returns either
 * {@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}.
 *
 * @see #execute(Object[])
 */
 public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
 Params... params) {
 if (mStatus != Status.PENDING) {
 switch (mStatus) {
 case RUNNING:
 throw new IllegalStateException("Cannot execute task:"
 + " the task is already running.");
 case FINISHED:
 throw new IllegalStateException("Cannot execute task:"
 + " the task has already been executed "
 + "(a task can be executed only once)");
 }
 }

 mStatus = Status.RUNNING;

 onPreExecute();

 mWorker.mParams = params;
 exec.execute(mFuture);

 return this;
 }

 /**
 * Convenience version of {@link #execute(Object...)} for use with
 * a simple Runnable object. See {@link #execute(Object[])} for more
 * information on the order of execution.
 *
 * @see #execute(Object[])
 * @see #executeOnExecutor(java.util.concurrent.Executor, Object[])
 */
 public static void execute(Runnable runnable) {
 sDefaultExecutor.execute(runnable);
 }

 /**
 * This method can be invoked from {@link #doInBackground} to
 * publish updates on the UI thread while the background computation is
 * still running. Each call to this method will trigger the execution of
 * {@link #onProgressUpdate} on the UI thread.
 *
 * {@link #onProgressUpdate} will note be called if the task has been
 * canceled.
 *
 * @param values The progress values to update the UI with.
 *
 * @see #onProgressUpdate
 * @see #doInBackground
 */
 protected final void publishProgress(Progress... values) {
 if (!isCancelled()) {
 sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
 new AsyncTaskResult<Progress>(this, values)).sendToTarget();
 }
 }

 private void finish(Result result) {
 if (isCancelled()) {
 onCancelled(result);
 } else {
 onPostExecute(result);
 }
 mStatus = Status.FINISHED;
 }

 private static class InternalHandler extends Handler {
 @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
 @Override
 public void handleMessage(Message msg) {
 AsyncTaskResult result = (AsyncTaskResult) msg.obj;
 switch (msg.what) {
 case MESSAGE_POST_RESULT:
 // There is only one result
 result.mTask.finish(result.mData[0]);
 break;
 case MESSAGE_POST_PROGRESS:
 result.mTask.onProgressUpdate(result.mData);
 break;
 }
 }
 }

 private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
 Params[] mParams;
 }

 @SuppressWarnings({"RawUseOfParameterizedType"})
 private static class AsyncTaskResult<Data> {
 final AsyncTask mTask;
 final Data[] mData;

 AsyncTaskResult(AsyncTask task, Data... data) {
 mTask = task;
 mData = data;
 }
 }
}

now, create second class name DiskLruCache

import java.io.BufferedInputStream;
import java.io.BufferedWriter;
import java.io.Closeable;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.Array;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public final class DiskLruCache implements Closeable {
 static final String JOURNAL_FILE = "journal";
 static final String JOURNAL_FILE_TMP = "journal.tmp";
 static final String MAGIC = "libcore.io.DiskLruCache";
 static final String VERSION_1 = "1";
 static final long ANY_SEQUENCE_NUMBER = -1;
 private static final String CLEAN = "CLEAN";
 private static final String DIRTY = "DIRTY";
 private static final String REMOVE = "REMOVE";
 private static final String READ = "READ";

 private static final Charset UTF_8 = Charset.forName("UTF-8");
 private static final int IO_BUFFER_SIZE = 8 * 1024;

 /*
 * This cache uses a journal file named "journal". A typical journal file
 * looks like this:
 * libcore.io.DiskLruCache
 * 1
 * 100
 * 2
 *
 * CLEAN 3400330d1dfc7f3f7f4b8d4d803dfcf6 832 21054
 * DIRTY 335c4c6028171cfddfbaae1a9c313c52
 * CLEAN 335c4c6028171cfddfbaae1a9c313c52 3934 2342
 * REMOVE 335c4c6028171cfddfbaae1a9c313c52
 * DIRTY 1ab96a171faeeee38496d8b330771a7a
 * CLEAN 1ab96a171faeeee38496d8b330771a7a 1600 234
 * READ 335c4c6028171cfddfbaae1a9c313c52
 * READ 3400330d1dfc7f3f7f4b8d4d803dfcf6
 *
 * The first five lines of the journal form its header. They are the
 * constant string "libcore.io.DiskLruCache", the disk cache's version,
 * the application's version, the value count, and a blank line.
 *
 * Each of the subsequent lines in the file is a record of the state of a
 * cache entry. Each line contains space-separated values: a state, a key,
 * and optional state-specific values.
 * o DIRTY lines track that an entry is actively being created or updated.
 * Every successful DIRTY action should be followed by a CLEAN or REMOVE
 * action. DIRTY lines without a matching CLEAN or REMOVE indicate that
 * temporary files may need to be deleted.
 * o CLEAN lines track a cache entry that has been successfully published
 * and may be read. A publish line is followed by the lengths of each of
 * its values.
 * o READ lines track accesses for LRU.
 * o REMOVE lines track entries that have been deleted.
 *
 * The journal file is appended to as cache operations occur. The journal may
 * occasionally be compacted by dropping redundant lines. A temporary file named
 * "journal.tmp" will be used during compaction; that file should be deleted if
 * it exists when the cache is opened.
 */

 private final File directory;
 private final File journalFile;
 private final File journalFileTmp;
 private final int appVersion;
 private final long maxSize;
 private final int valueCount;
 private long size = 0;
 private Writer journalWriter;
 private final LinkedHashMap<String, Entry> lruEntries
 = new LinkedHashMap<String, Entry>(0, 0.75f, true);
 private int redundantOpCount;

 /**
 * To differentiate between old and current snapshots, each entry is given
 * a sequence number each time an edit is committed. A snapshot is stale if
 * its sequence number is not equal to its entry's sequence number.
 */
 private long nextSequenceNumber = 0;

 /* From java.util.Arrays */
 @SuppressWarnings("unchecked")
 private static <T> T[] copyOfRange(T[] original, int start, int end) {
 final int originalLength = original.length; // For exception priority compatibility.
 if (start > end) {
 throw new IllegalArgumentException();
 }
 if (start < 0 || start > originalLength) {
 throw new ArrayIndexOutOfBoundsException();
 }
 final int resultLength = end - start;
 final int copyLength = Math.min(resultLength, originalLength - start);
 final T[] result = (T[]) Array
 .newInstance(original.getClass().getComponentType(), resultLength);
 System.arraycopy(original, start, result, 0, copyLength);
 return result;
 }

 /**
 * Returns the remainder of 'reader' as a string, closing it when done.
 */
 public static String readFully(Reader reader) throws IOException {
 try {
 StringWriter writer = new StringWriter();
 char[] buffer = new char[1024];
 int count;
 while ((count = reader.read(buffer)) != -1) {
 writer.write(buffer, 0, count);
 }
 return writer.toString();
 } finally {
 reader.close();
 }
 }

 /**
 * Returns the ASCII characters up to but not including the next "\r\n", or
 * "\n".
 *
 * @throws java.io.EOFException if the stream is exhausted before the next newline
 * character.
 */
 public static String readAsciiLine(InputStream in) throws IOException {
 // TODO: support UTF-8 here instead

 StringBuilder result = new StringBuilder(80);
 while (true) {
 int c = in.read();
 if (c == -1) {
 throw new EOFException();
 } else if (c == '\n') {
 break;
 }

 result.append((char) c);
 }
 int length = result.length();
 if (length > 0 && result.charAt(length - 1) == '\r') {
 result.setLength(length - 1);
 }
 return result.toString();
 }

 /**
 * Closes 'closeable', ignoring any checked exceptions. Does nothing if 'closeable' is null.
 */
 public static void closeQuietly(Closeable closeable) {
 if (closeable != null) {
 try {
 closeable.close();
 } catch (RuntimeException rethrown) {
 throw rethrown;
 } catch (Exception ignored) {
 }
 }
 }

 /**
 * Recursively delete everything in {@code dir}.
 */
 // TODO: this should specify paths as Strings rather than as Files
 public static void deleteContents(File dir) throws IOException {
 File[] files = dir.listFiles();
 if (files == null) {
 throw new IllegalArgumentException("not a directory: " + dir);
 }
 for (File file : files) {
 if (file.isDirectory()) {
 deleteContents(file);
 }
 if (!file.delete()) {
 throw new IOException("failed to delete file: " + file);
 }
 }
 }

 /** This cache uses a single background thread to evict entries. */
 private final ExecutorService executorService = new ThreadPoolExecutor(0, 1,
 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
 private final Callable<Void> cleanupCallable = new Callable<Void>() {
 @Override public Void call() throws Exception {
 synchronized (DiskLruCache.this) {
 if (journalWriter == null) {
 return null; // closed
 }
 trimToSize();
 if (journalRebuildRequired()) {
 rebuildJournal();
 redundantOpCount = 0;
 }
 }
 return null;
 }
 };

 private DiskLruCache(File directory, int appVersion, int valueCount, long maxSize) {
 this.directory = directory;
 this.appVersion = appVersion;
 this.journalFile = new File(directory, JOURNAL_FILE);
 this.journalFileTmp = new File(directory, JOURNAL_FILE_TMP);
 this.valueCount = valueCount;
 this.maxSize = maxSize;
 }

 /**
 * Opens the cache in {@code directory}, creating a cache if none exists
 * there.
 *
 * @param directory a writable directory
 * @param appVersion
 * @param valueCount the number of values per cache entry. Must be positive.
 * @param maxSize the maximum number of bytes this cache should use to store
 * @throws IOException if reading or writing the cache directory fails
 */
 public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize)
 throws IOException {
 if (maxSize <= 0) {
 throw new IllegalArgumentException("maxSize <= 0");
 }
 if (valueCount <= 0) {
 throw new IllegalArgumentException("valueCount <= 0");
 }

 // prefer to pick up where we left off
 DiskLruCache cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
 if (cache.journalFile.exists()) {
 try {
 cache.readJournal();
 cache.processJournal();
 cache.journalWriter = new BufferedWriter(new FileWriter(cache.journalFile, true),
 IO_BUFFER_SIZE);
 return cache;
 } catch (IOException journalIsCorrupt) {
// System.logW("DiskLruCache " + directory + " is corrupt: "
// + journalIsCorrupt.getMessage() + ", removing");
 cache.delete();
 }
 }

 // create a new empty cache
 directory.mkdirs();
 cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
 cache.rebuildJournal();
 return cache;
 }

 private void readJournal() throws IOException {
 InputStream in = new BufferedInputStream(new FileInputStream(journalFile), IO_BUFFER_SIZE);
 try {
 String magic = readAsciiLine(in);
 String version = readAsciiLine(in);
 String appVersionString = readAsciiLine(in);
 String valueCountString = readAsciiLine(in);
 String blank = readAsciiLine(in);
 if (!MAGIC.equals(magic)
 || !VERSION_1.equals(version)
 || !Integer.toString(appVersion).equals(appVersionString)
 || !Integer.toString(valueCount).equals(valueCountString)
 || !"".equals(blank)) {
 throw new IOException("unexpected journal header: ["
 + magic + ", " + version + ", " + valueCountString + ", " + blank + "]");
 }

 while (true) {
 try {
 readJournalLine(readAsciiLine(in));
 } catch (EOFException endOfJournal) {
 break;
 }
 }
 } finally {
 closeQuietly(in);
 }
 }

 private void readJournalLine(String line) throws IOException {
 String[] parts = line.split(" ");
 if (parts.length < 2) {
 throw new IOException("unexpected journal line: " + line);
 }

 String key = parts[1];
 if (parts[0].equals(REMOVE) && parts.length == 2) {
 lruEntries.remove(key);
 return;
 }

 Entry entry = lruEntries.get(key);
 if (entry == null) {
 entry = new Entry(key);
 lruEntries.put(key, entry);
 }

 if (parts[0].equals(CLEAN) && parts.length == 2 + valueCount) {
 entry.readable = true;
 entry.currentEditor = null;
 entry.setLengths(copyOfRange(parts, 2, parts.length));
 } else if (parts[0].equals(DIRTY) && parts.length == 2) {
 entry.currentEditor = new Editor(entry);
 } else if (parts[0].equals(READ) && parts.length == 2) {
 // this work was already done by calling lruEntries.get()
 } else {
 throw new IOException("unexpected journal line: " + line);
 }
 }

 /**
 * Computes the initial size and collects garbage as a part of opening the
 * cache. Dirty entries are assumed to be inconsistent and will be deleted.
 */
 private void processJournal() throws IOException {
 deleteIfExists(journalFileTmp);
 for (Iterator<Entry> i = lruEntries.values().iterator(); i.hasNext(); ) {
 Entry entry = i.next();
 if (entry.currentEditor == null) {
 for (int t = 0; t < valueCount; t++) {
 size += entry.lengths[t];
 }
 } else {
 entry.currentEditor = null;
 for (int t = 0; t < valueCount; t++) {
 deleteIfExists(entry.getCleanFile(t));
 deleteIfExists(entry.getDirtyFile(t));
 }
 i.remove();
 }
 }
 }

 /**
 * Creates a new journal that omits redundant information. This replaces the
 * current journal if it exists.
 */
 private synchronized void rebuildJournal() throws IOException {
 if (journalWriter != null) {
 journalWriter.close();
 }

 Writer writer = new BufferedWriter(new FileWriter(journalFileTmp), IO_BUFFER_SIZE);
 writer.write(MAGIC);
 writer.write("\n");
 writer.write(VERSION_1);
 writer.write("\n");
 writer.write(Integer.toString(appVersion));
 writer.write("\n");
 writer.write(Integer.toString(valueCount));
 writer.write("\n");
 writer.write("\n");

 for (Entry entry : lruEntries.values()) {
 if (entry.currentEditor != null) {
 writer.write(DIRTY + ' ' + entry.key + '\n');
 } else {
 writer.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
 }
 }

 writer.close();
 journalFileTmp.renameTo(journalFile);
 journalWriter = new BufferedWriter(new FileWriter(journalFile, true), IO_BUFFER_SIZE);
 }

 private static void deleteIfExists(File file) throws IOException {
// try {
// Libcore.os.remove(file.getPath());
// } catch (ErrnoException errnoException) {
// if (errnoException.errno != OsConstants.ENOENT) {
// throw errnoException.rethrowAsIOException();
// }
// }
 if (file.exists() && !file.delete()) {
 throw new IOException();
 }
 }

 /**
 * Returns a snapshot of the entry named {@code key}, or null if it doesn't
 * exist is not currently readable. If a value is returned, it is moved to
 * the head of the LRU queue.
 */
 public synchronized Snapshot get(String key) throws IOException {
 checkNotClosed();
 validateKey(key);
 Entry entry = lruEntries.get(key);
 if (entry == null) {
 return null;
 }

 if (!entry.readable) {
 return null;
 }

 /*
 * Open all streams eagerly to guarantee that we see a single published
 * snapshot. If we opened streams lazily then the streams could come
 * from different edits.
 */
 InputStream[] ins = new InputStream[valueCount];
 try {
 for (int i = 0; i < valueCount; i++) {
 ins[i] = new FileInputStream(entry.getCleanFile(i));
 }
 } catch (FileNotFoundException e) {
 // a file must have been deleted manually!
 return null;
 }

 redundantOpCount++;
 journalWriter.append(READ + ' ' + key + '\n');
 if (journalRebuildRequired()) {
 executorService.submit(cleanupCallable);
 }

 return new Snapshot(key, entry.sequenceNumber, ins);
 }

 /**
 * Returns an editor for the entry named {@code key}, or null if another
 * edit is in progress.
 */
 public Editor edit(String key) throws IOException {
 return edit(key, ANY_SEQUENCE_NUMBER);
 }

 private synchronized Editor edit(String key, long expectedSequenceNumber) throws IOException {
 checkNotClosed();
 validateKey(key);
 Entry entry = lruEntries.get(key);
 if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER
 && (entry == null || entry.sequenceNumber != expectedSequenceNumber)) {
 return null; // snapshot is stale
 }
 if (entry == null) {
 entry = new Entry(key);
 lruEntries.put(key, entry);
 } else if (entry.currentEditor != null) {
 return null; // another edit is in progress
 }

 Editor editor = new Editor(entry);
 entry.currentEditor = editor;

 // flush the journal before creating files to prevent file leaks
 journalWriter.write(DIRTY + ' ' + key + '\n');
 journalWriter.flush();
 return editor;
 }

 /**
 * Returns the directory where this cache stores its data.
 */
 public File getDirectory() {
 return directory;
 }

 /**
 * Returns the maximum number of bytes that this cache should use to store
 * its data.
 */
 public long maxSize() {
 return maxSize;
 }

 /**
 * Returns the number of bytes currently being used to store the values in
 * this cache. This may be greater than the max size if a background
 * deletion is pending.
 */
 public synchronized long size() {
 return size;
 }

 private synchronized void completeEdit(Editor editor, boolean success) throws IOException {
 Entry entry = editor.entry;
 if (entry.currentEditor != editor) {
 throw new IllegalStateException();
 }

 // if this edit is creating the entry for the first time, every index must have a value
 if (success && !entry.readable) {
 for (int i = 0; i < valueCount; i++) {
 if (!entry.getDirtyFile(i).exists()) {
 editor.abort();
 throw new IllegalStateException("edit didn't create file " + i);
 }
 }
 }

 for (int i = 0; i < valueCount; i++) {
 File dirty = entry.getDirtyFile(i);
 if (success) {
 if (dirty.exists()) {
 File clean = entry.getCleanFile(i);
 dirty.renameTo(clean);
 long oldLength = entry.lengths[i];
 long newLength = clean.length();
 entry.lengths[i] = newLength;
 size = size - oldLength + newLength;
 }
 } else {
 deleteIfExists(dirty);
 }
 }

 redundantOpCount++;
 entry.currentEditor = null;
 if (entry.readable | success) {
 entry.readable = true;
 journalWriter.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
 if (success) {
 entry.sequenceNumber = nextSequenceNumber++;
 }
 } else {
 lruEntries.remove(entry.key);
 journalWriter.write(REMOVE + ' ' + entry.key + '\n');
 }

 if (size > maxSize || journalRebuildRequired()) {
 executorService.submit(cleanupCallable);
 }
 }

 /**
 * We only rebuild the journal when it will halve the size of the journal
 * and eliminate at least 2000 ops.
 */
 private boolean journalRebuildRequired() {
 final int REDUNDANT_OP_COMPACT_THRESHOLD = 2000;
 return redundantOpCount >= REDUNDANT_OP_COMPACT_THRESHOLD
 && redundantOpCount >= lruEntries.size();
 }

 /**
 * Drops the entry for {@code key} if it exists and can be removed. Entries
 * actively being edited cannot be removed.
 *
 * @return true if an entry was removed.
 */
 public synchronized boolean remove(String key) throws IOException {
 checkNotClosed();
 validateKey(key);
 Entry entry = lruEntries.get(key);
 if (entry == null || entry.currentEditor != null) {
 return false;
 }

 for (int i = 0; i < valueCount; i++) {
 File file = entry.getCleanFile(i);
 if (!file.delete()) {
 throw new IOException("failed to delete " + file);
 }
 size -= entry.lengths[i];
 entry.lengths[i] = 0;
 }

 redundantOpCount++;
 journalWriter.append(REMOVE + ' ' + key + '\n');
 lruEntries.remove(key);

 if (journalRebuildRequired()) {
 executorService.submit(cleanupCallable);
 }

 return true;
 }

 /**
 * Returns true if this cache has been closed.
 */
 public boolean isClosed() {
 return journalWriter == null;
 }

 private void checkNotClosed() {
 if (journalWriter == null) {
 throw new IllegalStateException("cache is closed");
 }
 }

 /**
 * Force buffered operations to the filesystem.
 */
 public synchronized void flush() throws IOException {
 checkNotClosed();
 trimToSize();
 journalWriter.flush();
 }

 /**
 * Closes this cache. Stored values will remain on the filesystem.
 */
 public synchronized void close() throws IOException {
 if (journalWriter == null) {
 return; // already closed
 }
 for (Entry entry : new ArrayList<Entry>(lruEntries.values())) {
 if (entry.currentEditor != null) {
 entry.currentEditor.abort();
 }
 }
 trimToSize();
 journalWriter.close();
 journalWriter = null;
 }

 private void trimToSize() throws IOException {
 while (size > maxSize) {
// Map.Entry<String, Entry> toEvict = lruEntries.eldest();
 final Map.Entry<String, Entry> toEvict = lruEntries.entrySet().iterator().next();
 remove(toEvict.getKey());
 }
 }

 /**
 * Closes the cache and deletes all of its stored values. This will delete
 * all files in the cache directory including files that weren't created by
 * the cache.
 */
 public void delete() throws IOException {
 close();
 deleteContents(directory);
 }

 private void validateKey(String key) {
 if (key.contains(" ") || key.contains("\n") || key.contains("\r")) {
 throw new IllegalArgumentException(
 "keys must not contain spaces or newlines: \"" + key + "\"");
 }
 }

 private static String inputStreamToString(InputStream in) throws IOException {
 return readFully(new InputStreamReader(in, UTF_8));
 }

 /**
 * A snapshot of the values for an entry.
 */
 public final class Snapshot implements Closeable {
 private final String key;
 private final long sequenceNumber;
 private final InputStream[] ins;

 private Snapshot(String key, long sequenceNumber, InputStream[] ins) {
 this.key = key;
 this.sequenceNumber = sequenceNumber;
 this.ins = ins;
 }

 /**
 * Returns an editor for this snapshot's entry, or null if either the
 * entry has changed since this snapshot was created or if another edit
 * is in progress.
 */
 public Editor edit() throws IOException {
 return DiskLruCache.this.edit(key, sequenceNumber);
 }

 /**
 * Returns the unbuffered stream with the value for {@code index}.
 */
 public InputStream getInputStream(int index) {
 return ins[index];
 }

 /**
 * Returns the string value for {@code index}.
 */
 public String getString(int index) throws IOException {
 return inputStreamToString(getInputStream(index));
 }

 @Override public void close() {
 for (InputStream in : ins) {
 closeQuietly(in);
 }
 }
 }

 /**
 * Edits the values for an entry.
 */
 public final class Editor {
 private final Entry entry;
 private boolean hasErrors;

 private Editor(Entry entry) {
 this.entry = entry;
 }

 /**
 * Returns an unbuffered input stream to read the last committed value,
 * or null if no value has been committed.
 */
 public InputStream newInputStream(int index) throws IOException {
 synchronized (DiskLruCache.this) {
 if (entry.currentEditor != this) {
 throw new IllegalStateException();
 }
 if (!entry.readable) {
 return null;
 }
 return new FileInputStream(entry.getCleanFile(index));
 }
 }

 /**
 * Returns the last committed value as a string, or null if no value
 * has been committed.
 */
 public String getString(int index) throws IOException {
 InputStream in = newInputStream(index);
 return in != null ? inputStreamToString(in) : null;
 }

 /**
 * Returns a new unbuffered output stream to write the value at
 * {@code index}. If the underlying output stream encounters errors
 * when writing to the filesystem, this edit will be aborted when
 * {@link #commit} is called. The returned output stream does not throw
 * IOExceptions.
 */
 public OutputStream newOutputStream(int index) throws IOException {
 synchronized (DiskLruCache.this) {
 if (entry.currentEditor != this) {
 throw new IllegalStateException();
 }
 return new FaultHidingOutputStream(new FileOutputStream(entry.getDirtyFile(index)));
 }
 }

 /**
 * Sets the value at {@code index} to {@code value}.
 */
 public void set(int index, String value) throws IOException {
 Writer writer = null;
 try {
 writer = new OutputStreamWriter(newOutputStream(index), UTF_8);
 writer.write(value);
 } finally {
 closeQuietly(writer);
 }
 }

 /**
 * Commits this edit so it is visible to readers. This releases the
 * edit lock so another edit may be started on the same key.
 */
 public void commit() throws IOException {
 if (hasErrors) {
 completeEdit(this, false);
 remove(entry.key); // the previous entry is stale
 } else {
 completeEdit(this, true);
 }
 }

 /**
 * Aborts this edit. This releases the edit lock so another edit may be
 * started on the same key.
 */
 public void abort() throws IOException {
 completeEdit(this, false);
 }

 private class FaultHidingOutputStream extends FilterOutputStream {
 private FaultHidingOutputStream(OutputStream out) {
 super(out);
 }

 @Override public void write(int oneByte) {
 try {
 out.write(oneByte);
 } catch (IOException e) {
 hasErrors = true;
 }
 }

 @Override public void write(byte[] buffer, int offset, int length) {
 try {
 out.write(buffer, offset, length);
 } catch (IOException e) {
 hasErrors = true;
 }
 }

 @Override public void close() {
 try {
 out.close();
 } catch (IOException e) {
 hasErrors = true;
 }
 }

 @Override public void flush() {
 try {
 out.flush();
 } catch (IOException e) {
 hasErrors = true;
 }
 }
 }
 }

 private final class Entry {
 private final String key;

 /** Lengths of this entry's files. */
 private final long[] lengths;

 /** True if this entry has ever been published */
 private boolean readable;

 /** The ongoing edit or null if this entry is not being edited. */
 private Editor currentEditor;

 /** The sequence number of the most recently committed edit to this entry. */
 private long sequenceNumber;

 private Entry(String key) {
 this.key = key;
 this.lengths = new long[valueCount];
 }

 public String getLengths() throws IOException {
 StringBuilder result = new StringBuilder();
 for (long size : lengths) {
 result.append(' ').append(size);
 }
 return result.toString();
 }

 /**
 * Set lengths using decimal numbers like "10123".
 */
 private void setLengths(String[] strings) throws IOException {
 if (strings.length != valueCount) {
 throw invalidLengths(strings);
 }

 try {
 for (int i = 0; i < strings.length; i++) {
 lengths[i] = Long.parseLong(strings[i]);
 }
 } catch (NumberFormatException e) {
 throw invalidLengths(strings);
 }
 }

 private IOException invalidLengths(String[] strings) throws IOException {
 throw new IOException("unexpected journal line: " + Arrays.toString(strings));
 }

 public File getCleanFile(int i) {
 return new File(directory, key + "." + i);
 }

 public File getDirtyFile(int i) {
 return new File(directory, key + "." + i + ".tmp");
 }
 }
}

now ,create third class name ImageCache

import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.ref.SoftReference;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HashSet;
import java.util.Iterator;

import android.annotation.TargetApi;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.BitmapFactory;
import android.graphics.drawable.BitmapDrawable;
import android.os.Bundle;
import android.os.Environment;
import android.os.StatFs;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.util.LruCache;
import android.util.Log;

import com.jitega.act.BuildConfig;

/**
* This class handles disk and memory caching of bitmaps in conjunction with the
* {@link ImageWorker} class and its subclasses. Use
* {@link ImageCache#getInstance(FragmentManager, ImageCacheParams)} to get an instance of this
* class, although usually a cache should be added directly to an {@link ImageWorker} by calling
* {@link ImageWorker#addImageCache(FragmentManager, ImageCacheParams)}.
*/
public class ImageCache {
 private static final String TAG = "ImageCache";

 // Default memory cache size in kilobytes
 private static final int DEFAULT_MEM_CACHE_SIZE = 1024 * 5; // 5MB

 // Default disk cache size in bytes
 private static final int DEFAULT_DISK_CACHE_SIZE = 1024 * 1024 * 10; // 10MB

 // Compression settings when writing images to disk cache
 private static final CompressFormat DEFAULT_COMPRESS_FORMAT = CompressFormat.JPEG;
 private static final int DEFAULT_COMPRESS_QUALITY = 70;
 private static final int DISK_CACHE_INDEX = 0;

 // Constants to easily toggle various caches
 private static final boolean DEFAULT_MEM_CACHE_ENABLED = true;
 private static final boolean DEFAULT_DISK_CACHE_ENABLED = true;
 private static final boolean DEFAULT_INIT_DISK_CACHE_ON_CREATE = false;

 private DiskLruCache mDiskLruCache;
 private LruCache<String, BitmapDrawable> mMemoryCache;
 private ImageCacheParams mCacheParams;
 private final Object mDiskCacheLock = new Object();
 private boolean mDiskCacheStarting = true;

 private HashSet<SoftReference<Bitmap>> mReusableBitmaps;

 /**
 * Create a new ImageCache object using the specified parameters. This should not be
 * called directly by other classes, instead use
 * {@link ImageCache#getInstance(FragmentManager, ImageCacheParams)} to fetch an ImageCache
 * instance.
 *
 * @param cacheParams The cache parameters to use to initialize the cache
 */
 private ImageCache(ImageCacheParams cacheParams) {
 init(cacheParams);
 }

 /**
 * Return an {@link ImageCache} instance. A {@link RetainFragment} is used to retain the
 * ImageCache object across configuration changes such as a change in device orientation.
 *
 * @param fragmentManager The fragment manager to use when dealing with the retained fragment.
 * @param cacheParams The cache parameters to use if the ImageCache needs instantiation.
 * @return An existing retained ImageCache object or a new one if one did not exist
 */
 public static ImageCache getInstance(
 FragmentManager fragmentManager, ImageCacheParams cacheParams) {

 // Search for, or create an instance of the non-UI RetainFragment
 final RetainFragment mRetainFragment = findOrCreateRetainFragment(fragmentManager);

 // See if we already have an ImageCache stored in RetainFragment
 ImageCache imageCache = (ImageCache) mRetainFragment.getObject();

 // No existing ImageCache, create one and store it in RetainFragment
 if (imageCache == null) {
 imageCache = new ImageCache(cacheParams);
 mRetainFragment.setObject(imageCache);
 }

 return imageCache;
 }

 /**
 * Initialize the cache, providing all parameters.
 *
 * @param cacheParams The cache parameters to initialize the cache
 */
 private void init(ImageCacheParams cacheParams) {
 mCacheParams = cacheParams;

 // Set up memory cache
 if (mCacheParams.memoryCacheEnabled) {
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "Memory cache created (size = " + mCacheParams.memCacheSize + ")");
 }

 // If we're running on Honeycomb or newer, then
 if (Utils.hasHoneycomb()) {
 mReusableBitmaps = new HashSet<SoftReference<Bitmap>>();
 }

 mMemoryCache = new LruCache<String, BitmapDrawable>(mCacheParams.memCacheSize) {

 /**
 * Notify the removed entry that is no longer being cached
 */
 @Override
 protected void entryRemoved(boolean evicted, String key,
 BitmapDrawable oldValue, BitmapDrawable newValue) {
 if (RecyclingBitmapDrawable.class.isInstance(oldValue)) {
 // The removed entry is a recycling drawable, so notify it
 // that it has been removed from the memory cache
 ((RecyclingBitmapDrawable) oldValue).setIsCached(false);
 } else {
 // The removed entry is a standard BitmapDrawable

 if (Utils.hasHoneycomb()) {
 // We're running on Honeycomb or later, so add the bitmap
 // to a SoftRefrence set for possible use with inBitmap later
 mReusableBitmaps.add(new SoftReference<Bitmap>(oldValue.getBitmap()));
 }
 }
 }

 /**
 * Measure item size in kilobytes rather than units which is more practical
 * for a bitmap cache
 */
 @Override
 protected int sizeOf(String key, BitmapDrawable value) {
 final int bitmapSize = getBitmapSize(value) / 1024;
 return bitmapSize == 0 ? 1 : bitmapSize;
 }
 };
 }

 // By default the disk cache is not initialized here as it should be initialized
 // on a separate thread due to disk access.
 if (cacheParams.initDiskCacheOnCreate) {
 // Set up disk cache
 initDiskCache();
 }
 }

 /**
 * Initializes the disk cache. Note that this includes disk access so this should not be
 * executed on the main/UI thread. By default an ImageCache does not initialize the disk
 * cache when it is created, instead you should call initDiskCache() to initialize it on a
 * background thread.
 */
 public void initDiskCache() {
 // Set up disk cache
 synchronized (mDiskCacheLock) {
 if (mDiskLruCache == null || mDiskLruCache.isClosed()) {
 File diskCacheDir = mCacheParams.diskCacheDir;
 if (mCacheParams.diskCacheEnabled && diskCacheDir != null) {
 if (!diskCacheDir.exists()) {
 diskCacheDir.mkdirs();
 }
 if (getUsableSpace(diskCacheDir) > mCacheParams.diskCacheSize) {
 try {
 mDiskLruCache = DiskLruCache.open(
 diskCacheDir, 1, 1, mCacheParams.diskCacheSize);
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "Disk cache initialized");
 }
 } catch (final IOException e) {
 mCacheParams.diskCacheDir = null;
 Log.e(TAG, "initDiskCache - " + e);
 }
 }
 }
 }
 mDiskCacheStarting = false;
 mDiskCacheLock.notifyAll();
 }
 }

 /**
 * Adds a bitmap to both memory and disk cache.
 * @param data Unique identifier for the bitmap to store
 * @param value The bitmap drawable to store
 */
 public void addBitmapToCache(String data, BitmapDrawable value) {
 if (data == null || value == null) {
 return;
 }

 // Add to memory cache
 if (mMemoryCache != null) {
 if (RecyclingBitmapDrawable.class.isInstance(value)) {
 // The removed entry is a recycling drawable, so notify it
 // that it has been added into the memory cache
 ((RecyclingBitmapDrawable) value).setIsCached(true);
 }
 mMemoryCache.put(data, value);
 }

 synchronized (mDiskCacheLock) {
 // Add to disk cache
 if (mDiskLruCache != null) {
 final String key = hashKeyForDisk(data);
 OutputStream out = null;
 try {
 DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
 if (snapshot == null) {
 final DiskLruCache.Editor editor = mDiskLruCache.edit(key);
 if (editor != null) {
 out = editor.newOutputStream(DISK_CACHE_INDEX);
 value.getBitmap().compress(
 mCacheParams.compressFormat, mCacheParams.compressQuality, out);
 editor.commit();
 out.close();
 }
 } else {
 snapshot.getInputStream(DISK_CACHE_INDEX).close();
 }
 } catch (final IOException e) {
 Log.e(TAG, "addBitmapToCache - " + e);
 } catch (Exception e) {
 Log.e(TAG, "addBitmapToCache - " + e);
 } finally {
 try {
 if (out != null) {
 out.close();
 }
 } catch (IOException e) {}
 }
 }
 }
 }

 /**
 * Get from memory cache.
 *
 * @param data Unique identifier for which item to get
 * @return The bitmap drawable if found in cache, null otherwise
 */
 public BitmapDrawable getBitmapFromMemCache(String data) {
 BitmapDrawable memValue = null;

 if (mMemoryCache != null) {
 memValue = mMemoryCache.get(data);
 }

 if (BuildConfig.DEBUG && memValue != null) {
 Log.d(TAG, "Memory cache hit");
 }

 return memValue;
 }

 /**
 * Get from disk cache.
 *
 * @param data Unique identifier for which item to get
 * @return The bitmap if found in cache, null otherwise
 */
 public Bitmap getBitmapFromDiskCache(String data) {
 final String key = hashKeyForDisk(data);
 Bitmap bitmap = null;

 synchronized (mDiskCacheLock) {
 while (mDiskCacheStarting) {
 try {
 mDiskCacheLock.wait();
 } catch (InterruptedException e) {}
 }
 if (mDiskLruCache != null) {
 InputStream inputStream = null;
 try {
 final DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
 if (snapshot != null) {
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "Disk cache hit");
 }
 inputStream = snapshot.getInputStream(DISK_CACHE_INDEX);
 if (inputStream != null) {
 FileDescriptor fd = ((FileInputStream) inputStream).getFD();

 // Decode bitmap, but we don't want to sample so give
 // MAX_VALUE as the target dimensions
 bitmap = ImageResizer.decodeSampledBitmapFromDescriptor(
 fd, Integer.MAX_VALUE, Integer.MAX_VALUE, this);
 }
 }
 } catch (final IOException e) {
 Log.e(TAG, "getBitmapFromDiskCache - " + e);
 } finally {
 try {
 if (inputStream != null) {
 inputStream.close();
 }
 } catch (IOException e) {}
 }
 }
 return bitmap;
 }
 }

 /**
 * @param options - BitmapFactory.Options with out* options populated
 * @return Bitmap that case be used for inBitmap
 */
 protected Bitmap getBitmapFromReusableSet(BitmapFactory.Options options) {
 Bitmap bitmap = null;

 if (mReusableBitmaps != null && !mReusableBitmaps.isEmpty()) {
 final Iterator<SoftReference<Bitmap>> iterator = mReusableBitmaps.iterator();
 Bitmap item;

 while (iterator.hasNext()) {
 item = iterator.next().get();

 if (null != item && item.isMutable()) {
 // Check to see it the item can be used for inBitmap
 if (canUseForInBitmap(item, options)) {
 bitmap = item;

 // Remove from reusable set so it can't be used again
 iterator.remove();
 break;
 }
 } else {
 // Remove from the set if the reference has been cleared.
 iterator.remove();
 }
 }
 }

 return bitmap;
 }

 /**
 * Clears both the memory and disk cache associated with this ImageCache object. Note that
 * this includes disk access so this should not be executed on the main/UI thread.
 */
 public void clearCache() {
 if (mMemoryCache != null) {
 mMemoryCache.evictAll();
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "Memory cache cleared");
 }
 }

 synchronized (mDiskCacheLock) {
 mDiskCacheStarting = true;
 if (mDiskLruCache != null && !mDiskLruCache.isClosed()) {
 try {
 mDiskLruCache.delete();
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "Disk cache cleared");
 }
 } catch (IOException e) {
 Log.e(TAG, "clearCache - " + e);
 }
 mDiskLruCache = null;
 initDiskCache();
 }
 }
 }

 /**
 * Flushes the disk cache associated with this ImageCache object. Note that this includes
 * disk access so this should not be executed on the main/UI thread.
 */
 public void flush() {
 synchronized (mDiskCacheLock) {
 if (mDiskLruCache != null) {
 try {
 mDiskLruCache.flush();
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "Disk cache flushed");
 }
 } catch (IOException e) {
 Log.e(TAG, "flush - " + e);
 }
 }
 }
 }

 /**
 * Closes the disk cache associated with this ImageCache object. Note that this includes
 * disk access so this should not be executed on the main/UI thread.
 */
 public void close() {
 synchronized (mDiskCacheLock) {
 if (mDiskLruCache != null) {
 try {
 if (!mDiskLruCache.isClosed()) {
 mDiskLruCache.close();
 mDiskLruCache = null;
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "Disk cache closed");
 }
 }
 } catch (IOException e) {
 Log.e(TAG, "close - " + e);
 }
 }
 }
 }

 /**
 * A holder class that contains cache parameters.
 */
 public static class ImageCacheParams {
 public int memCacheSize = DEFAULT_MEM_CACHE_SIZE;
 public int diskCacheSize = DEFAULT_DISK_CACHE_SIZE;
 public File diskCacheDir;
 public CompressFormat compressFormat = DEFAULT_COMPRESS_FORMAT;
 public int compressQuality = DEFAULT_COMPRESS_QUALITY;
 public boolean memoryCacheEnabled = DEFAULT_MEM_CACHE_ENABLED;
 public boolean diskCacheEnabled = DEFAULT_DISK_CACHE_ENABLED;
 public boolean initDiskCacheOnCreate = DEFAULT_INIT_DISK_CACHE_ON_CREATE;

 /**
 * Create a set of image cache parameters that can be provided to
 * {@link ImageCache#getInstance(FragmentManager, ImageCacheParams)} or
 * {@link ImageWorker#addImageCache(FragmentManager, ImageCacheParams)}.
 * @param context A context to use.
 * @param diskCacheDirectoryName A unique subdirectory name that will be appended to the
 * application cache directory. Usually "cache" or "images"
 * is sufficient.
 */
 public ImageCacheParams(Context context, String diskCacheDirectoryName) {
 diskCacheDir = getDiskCacheDir(context, diskCacheDirectoryName);
 }

 /**
 * Sets the memory cache size based on a percentage of the max available VM memory.
 * Eg. setting percent to 0.2 would set the memory cache to one fifth of the available
 * memory. Throws {@link IllegalArgumentException} if percent is < 0.05 or > .8.
 * memCacheSize is stored in kilobytes instead of bytes as this will eventually be passed
 * to construct a LruCache which takes an int in its constructor.
 *
 * This value should be chosen carefully based on a number of factors
 * Refer to the corresponding Android Training class for more discussion:
 * http://developer.android.com/training/displaying-bitmaps/
 *
 * @param percent Percent of available app memory to use to size memory cache
 */
 public void setMemCacheSizePercent(float percent) {
 if (percent < 0.05f || percent > 0.8f) {
 throw new IllegalArgumentException("setMemCacheSizePercent - percent must be "
 + "between 0.05 and 0.8 (inclusive)");
 }
 memCacheSize = Math.round(percent * Runtime.getRuntime().maxMemory() / 1024);
 }
 }

 /**
 * @param candidate - Bitmap to check
 * @param targetOptions - Options that have the out* value populated
 * @return true if <code>candidate</code> can be used for inBitmap re-use with
 * <code>targetOptions</code>
 */
 private static boolean canUseForInBitmap(
 Bitmap candidate, BitmapFactory.Options targetOptions) {
 int width = targetOptions.outWidth / targetOptions.inSampleSize;
 int height = targetOptions.outHeight / targetOptions.inSampleSize;

 return candidate.getWidth() == width && candidate.getHeight() == height;
 }

 /**
 * Get a usable cache directory (external if available, internal otherwise).
 *
 * @param context The context to use
 * @param uniqueName A unique directory name to append to the cache dir
 * @return The cache dir
 */
 public static File getDiskCacheDir(Context context, String uniqueName) {
 // Check if media is mounted or storage is built-in, if so, try and use external cache dir
 // otherwise use internal cache dir
 final String cachePath =
 Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()) ||
 !isExternalStorageRemovable() ? getExternalCacheDir(context).getPath() :
 context.getCacheDir().getPath();

 return new File(cachePath + File.separator + uniqueName);
 }

 /**
 * A hashing method that changes a string (like a URL) into a hash suitable for using as a
 * disk filename.
 */
 public static String hashKeyForDisk(String key) {
 String cacheKey;
 try {
 final MessageDigest mDigest = MessageDigest.getInstance("MD5");
 mDigest.update(key.getBytes());
 cacheKey = bytesToHexString(mDigest.digest());
 } catch (NoSuchAlgorithmException e) {
 cacheKey = String.valueOf(key.hashCode());
 }
 return cacheKey;
 }

 private static String bytesToHexString(byte[] bytes) {
 // http://stackoverflow.com/questions/332079
 StringBuilder sb = new StringBuilder();
 for (int i = 0; i < bytes.length; i++) {
 String hex = Integer.toHexString(0xFF & bytes[i]);
 if (hex.length() == 1) {
 sb.append('0');
 }
 sb.append(hex);
 }
 return sb.toString();
 }

 /**
 * Get the size in bytes of a bitmap in a BitmapDrawable.
 * @param value
 * @return size in bytes
 */
 @TargetApi(12)
 public static int getBitmapSize(BitmapDrawable value) {
 Bitmap bitmap = value.getBitmap();

 if (Utils.hasHoneycombMR1()) {
 return bitmap.getByteCount();
 }
 // Pre HC-MR1
 return bitmap.getRowBytes() * bitmap.getHeight();
 }

 /**
 * Check if external storage is built-in or removable.
 *
 * @return True if external storage is removable (like an SD card), false
 * otherwise.
 */
 @TargetApi(9)
 public static boolean isExternalStorageRemovable() {
 if (Utils.hasGingerbread()) {
 return Environment.isExternalStorageRemovable();
 }
 return true;
 }

 /**
 * Get the external app cache directory.
 *
 * @param context The context to use
 * @return The external cache dir
 */
 @TargetApi(8)
 public static File getExternalCacheDir(Context context) {
 if (Utils.hasFroyo()) {
 return context.getExternalCacheDir();
 }

 // Before Froyo we need to construct the external cache dir ourselves
 final String cacheDir = "/Android/data/" + context.getPackageName() + "/cache/";
 return new File(Environment.getExternalStorageDirectory().getPath() + cacheDir);
 }

 /**
 * Check how much usable space is available at a given path.
 *
 * @param path The path to check
 * @return The space available in bytes
 */
 @TargetApi(9)
 public static long getUsableSpace(File path) {
 if (Utils.hasGingerbread()) {
 return path.getUsableSpace();
 }
 final StatFs stats = new StatFs(path.getPath());
 return (long) stats.getBlockSize() * (long) stats.getAvailableBlocks();
 }

 /**
 * Locate an existing instance of this Fragment or if not found, create and
 * add it using FragmentManager.
 *
 * @param fm The FragmentManager manager to use.
 * @return The existing instance of the Fragment or the new instance if just
 * created.
 */
 private static RetainFragment findOrCreateRetainFragment(FragmentManager fm) {
 // Check to see if we have retained the worker fragment.
 RetainFragment mRetainFragment = (RetainFragment) fm.findFragmentByTag(TAG);

 // If not retained (or first time running), we need to create and add it.
 if (mRetainFragment == null) {
 mRetainFragment = new RetainFragment();
 fm.beginTransaction().add(mRetainFragment, TAG).commitAllowingStateLoss();
 }

 return mRetainFragment;
 }

 /**
 * A simple non-UI Fragment that stores a single Object and is retained over configuration
 * changes. It will be used to retain the ImageCache object.
 */
 public static class RetainFragment extends Fragment {
 private Object mObject;

 /**
 * Empty constructor as per the Fragment documentation
 */
 public RetainFragment() {}

 @Override
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);

 // Make sure this Fragment is retained over a configuration change
 setRetainInstance(true);
 }

 /**
 * Store a single object in this Fragment.
 *
 * @param object The object to store
 */
 public void setObject(Object object) {
 mObject = object;
 }

 /**
 * Get the stored object.
 *
 * @return The stored object
 */
 public Object getObject() {
 return mObject;
 }
 }

}

now, create fourth class name ImageFetcher

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;

import android.content.Context;
import android.graphics.Bitmap;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Build;
import android.util.Log;
import android.widget.Toast;

import com.jitega.act.BuildConfig;
import com.jitega.act.R;
import com.jitega.utility.Utility;

/**
* A simple subclass of {@link ImageResizer} that fetches and resizes images fetched from a URL.
*/
public class ImageFetcher extends ImageResizer {
 private static final String TAG = "ImageFetcher";
 private static final int HTTP_CACHE_SIZE = 10 * 1024 * 1024; // 10MB
 private static final String HTTP_CACHE_DIR = "http";
 private static final int IO_BUFFER_SIZE = 8 * 1024;

 private DiskLruCache mHttpDiskCache;
 private File mHttpCacheDir;
 private boolean mHttpDiskCacheStarting = true;
 private final Object mHttpDiskCacheLock = new Object();
 private static final int DISK_CACHE_INDEX = 0;

 /**
 * Initialize providing a target image width and height for the processing images.
 *
 * @param context
 * @param imageWidth
 * @param imageHeight
 */
 public ImageFetcher(Context context, int imageWidth, int imageHeight) {
 super(context, imageWidth, imageHeight);
 init(context);
 }

 /**
 * Initialize providing a single target image size (used for both width and height);
 *
 * @param context
 * @param imageSize
 */
 public ImageFetcher(Context context, int imageSize) {
 super(context, imageSize);
 init(context);
 }

 private void init(Context context) {
 checkConnection(context);
 mHttpCacheDir = ImageCache.getDiskCacheDir(context, HTTP_CACHE_DIR);
 }

 @Override
 protected void initDiskCacheInternal() {
 super.initDiskCacheInternal();
 initHttpDiskCache();
 }

 private void initHttpDiskCache() {
 if (!mHttpCacheDir.exists()) {
 mHttpCacheDir.mkdirs();
 }
 synchronized (mHttpDiskCacheLock) {
 if (ImageCache.getUsableSpace(mHttpCacheDir) > HTTP_CACHE_SIZE) {
 try {
 mHttpDiskCache = DiskLruCache.open(mHttpCacheDir, 1, 1, HTTP_CACHE_SIZE);
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "HTTP cache initialized");
 }
 } catch (IOException e) {
 mHttpDiskCache = null;
 }
 }
 mHttpDiskCacheStarting = false;
 mHttpDiskCacheLock.notifyAll();
 }
 }

 @Override
 protected void clearCacheInternal() {
 super.clearCacheInternal();
 synchronized (mHttpDiskCacheLock) {
 if (mHttpDiskCache != null && !mHttpDiskCache.isClosed()) {
 try {
 mHttpDiskCache.delete();
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "HTTP cache cleared");
 }
 } catch (IOException e) {
 Log.e(TAG, "clearCacheInternal - " + e);
 }
 mHttpDiskCache = null;
 mHttpDiskCacheStarting = true;
 initHttpDiskCache();
 }
 }
 }

 @Override
 protected void flushCacheInternal() {
 super.flushCacheInternal();
 synchronized (mHttpDiskCacheLock) {
 if (mHttpDiskCache != null) {
 try {
 mHttpDiskCache.flush();
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "HTTP cache flushed");
 }
 } catch (IOException e) {
 Log.e(TAG, "flush - " + e);
 }
 }
 }
 }

 @Override
 protected void closeCacheInternal() {
 super.closeCacheInternal();
 synchronized (mHttpDiskCacheLock) {
 if (mHttpDiskCache != null) {
 try {
 if (!mHttpDiskCache.isClosed()) {
 mHttpDiskCache.close();
 mHttpDiskCache = null;
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "HTTP cache closed");
 }
 }
 } catch (IOException e) {
 Log.e(TAG, "closeCacheInternal - " + e);
 }
 }
 }
 }

 /**
 * Simple network connection check.
 *
 * @param context
 */
 private void checkConnection(Context context) {
 final ConnectivityManager cm =
 (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
 final NetworkInfo networkInfo = cm.getActiveNetworkInfo();
 if (networkInfo == null || !networkInfo.isConnectedOrConnecting()) {
 // Toast.makeText(context, R.string.no_network_connection_toast, Toast.LENGTH_LONG).show();
 Utility.showDialogwithTitle(context, "no_network_connection");
 Log.e(TAG, "checkConnection - no connection found");
 }
 }

 /**
 * The main process method, which will be called by the ImageWorker in the AsyncTask background
 * thread.
 *
 * @param data The data to load the bitmap, in this case, a regular http URL
 * @return The downloaded and resized bitmap
 */
 private Bitmap processBitmap(String data) {
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "processBitmap - " + data);
 }

 final String key = ImageCache.hashKeyForDisk(data);
 FileDescriptor fileDescriptor = null;
 FileInputStream fileInputStream = null;
 DiskLruCache.Snapshot snapshot;
 synchronized (mHttpDiskCacheLock) {
 // Wait for disk cache to initialize
 while (mHttpDiskCacheStarting) {
 try {
 mHttpDiskCacheLock.wait();
 } catch (InterruptedException e) {}
 }

 if (mHttpDiskCache != null) {
 try {
 snapshot = mHttpDiskCache.get(key);
 if (snapshot == null) {
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "processBitmap, not found in http cache, downloading...");
 }
 DiskLruCache.Editor editor = mHttpDiskCache.edit(key);
 if (editor != null) {
 if (downloadUrlToStream(data,
 editor.newOutputStream(DISK_CACHE_INDEX))) {
 editor.commit();
 } else {
 editor.abort();
 }
 }
 snapshot = mHttpDiskCache.get(key);
 }
 if (snapshot != null) {
 fileInputStream =
 (FileInputStream) snapshot.getInputStream(DISK_CACHE_INDEX);
 fileDescriptor = fileInputStream.getFD();
 }
 } catch (IOException e) {
 Log.e(TAG, "processBitmap - " + e);
 } catch (IllegalStateException e) {
 Log.e(TAG, "processBitmap - " + e);
 } finally {
 if (fileDescriptor == null && fileInputStream != null) {
 try {
 fileInputStream.close();
 } catch (IOException e) {}
 }
 }
 }
 }

 Bitmap bitmap = null;
 if (fileDescriptor != null) {
 bitmap = decodeSampledBitmapFromDescriptor(fileDescriptor, mImageWidth,
 mImageHeight, getImageCache());
 }
 if (fileInputStream != null) {
 try {
 fileInputStream.close();
 } catch (IOException e) {}
 }
 return bitmap;
 }

 @Override
 protected Bitmap processBitmap(Object data) {
 return processBitmap(String.valueOf(data));
 }

 /**
 * Download a bitmap from a URL and write the content to an output stream.
 *
 * @param urlString The URL to fetch
 * @return true if successful, false otherwise
 */
 public boolean downloadUrlToStream(String urlString, OutputStream outputStream) {
 disableConnectionReuseIfNecessary();
 HttpURLConnection urlConnection = null;
 BufferedOutputStream out = null;
 BufferedInputStream in = null;

 try {
 final URL url = new URL(urlString);
 urlConnection = (HttpURLConnection) url.openConnection();
 in = new BufferedInputStream(urlConnection.getInputStream(), IO_BUFFER_SIZE);
 out = new BufferedOutputStream(outputStream, IO_BUFFER_SIZE);

 int b;
 while ((b = in.read()) != -1) {
 out.write(b);
 }
 return true;
 } catch (final IOException e) {
 Log.e(TAG, "Error in downloadBitmap - " + e);
 } finally {
 if (urlConnection != null) {
 urlConnection.disconnect();
 }
 try {
 if (out != null) {
 out.close();
 }
 if (in != null) {
 in.close();
 }
 } catch (final IOException e) {}
 }
 return false;
 }

 /**
 * Workaround for bug pre-Froyo, see here for more info:
 * http://android-developers.blogspot.com/2011/09/androids-http-clients.html
 */
 public static void disableConnectionReuseIfNecessary() {
 // HTTP connection reuse which was buggy pre-froyo
 if (Build.VERSION.SDK_INT < Build.VERSION_CODES.FROYO) {
 System.setProperty("http.keepAlive", "false");
 }
 }
}

now, create fifth class name ImageResizer

import java.io.FileDescriptor;
import android.annotation.TargetApi;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Build;
import android.util.Log;

import com.jitega.act.BuildConfig;

/**
* A simple subclass of {@link ImageWorker} that resizes images from resources given a target width
* and height. Useful for when the input images might be too large to simply load directly into
* memory.
*/
public class ImageResizer extends ImageWorker {
 private static final String TAG = "ImageResizer";
 protected int mImageWidth;
 protected int mImageHeight;

 /**
 * Initialize providing a single target image size (used for both width and height);
 *
 * @param context
 * @param imageWidth
 * @param imageHeight
 */
 public ImageResizer(Context context, int imageWidth, int imageHeight) {
 super(context);
 setImageSize(imageWidth, imageHeight);
 }

 /**
 * Initialize providing a single target image size (used for both width and height);
 *
 * @param context
 * @param imageSize
 */
 public ImageResizer(Context context, int imageSize) {
 super(context);
 setImageSize(imageSize);
 }

 /**
 * Set the target image width and height.
 *
 * @param width
 * @param height
 */
 public void setImageSize(int width, int height) {
 mImageWidth = width;
 mImageHeight = height;
 }

 /**
 * Set the target image size (width and height will be the same).
 *
 * @param size
 */
 public void setImageSize(int size) {
 setImageSize(size, size);
 }

 /**
 * The main processing method. This happens in a background task. In this case we are just
 * sampling down the bitmap and returning it from a resource.
 *
 * @param resId
 * @return
 */
 private Bitmap processBitmap(int resId) {
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "processBitmap - " + resId);
 }
 return decodeSampledBitmapFromResource(mResources, resId, mImageWidth,
 mImageHeight, getImageCache());
 }

 @Override
 protected Bitmap processBitmap(Object data) {
 return processBitmap(Integer.parseInt(String.valueOf(data)));
 }

 /**
 * Decode and sample down a bitmap from resources to the requested width and height.
 *
 * @param res The resources object containing the image data
 * @param resId The resource id of the image data
 * @param reqWidth The requested width of the resulting bitmap
 * @param reqHeight The requested height of the resulting bitmap
 * @param cache The ImageCache used to find candidate bitmaps for use with inBitmap
 * @return A bitmap sampled down from the original with the same aspect ratio and dimensions
 * that are equal to or greater than the requested width and height
 */
 public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId,
 int reqWidth, int reqHeight, ImageCache cache) {

 // First decode with inJustDecodeBounds=true to check dimensions
 final BitmapFactory.Options options = new BitmapFactory.Options();
 options.inJustDecodeBounds = true;
 BitmapFactory.decodeResource(res, resId, options);

 // Calculate inSampleSize
 options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

 // If we're running on Honeycomb or newer, try to use inBitmap
 if (Utils.hasHoneycomb()) {
 addInBitmapOptions(options, cache);
 }

 // Decode bitmap with inSampleSize set
 options.inJustDecodeBounds = false;
 return BitmapFactory.decodeResource(res, resId, options);
 }

 /**
 * Decode and sample down a bitmap from a file to the requested width and height.
 *
 * @param filename The full path of the file to decode
 * @param reqWidth The requested width of the resulting bitmap
 * @param reqHeight The requested height of the resulting bitmap
 * @param cache The ImageCache used to find candidate bitmaps for use with inBitmap
 * @return A bitmap sampled down from the original with the same aspect ratio and dimensions
 * that are equal to or greater than the requested width and height
 */
 public static Bitmap decodeSampledBitmapFromFile(String filename,
 int reqWidth, int reqHeight, ImageCache cache) {

 // First decode with inJustDecodeBounds=true to check dimensions
 final BitmapFactory.Options options = new BitmapFactory.Options();
 options.inJustDecodeBounds = true;
 BitmapFactory.decodeFile(filename, options);

 // Calculate inSampleSize
 options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

 // If we're running on Honeycomb or newer, try to use inBitmap
 if (Utils.hasHoneycomb()) {
 addInBitmapOptions(options, cache);
 }

 // Decode bitmap with inSampleSize set
 options.inJustDecodeBounds = false;
 return BitmapFactory.decodeFile(filename, options);
 }

 /**
 * Decode and sample down a bitmap from a file input stream to the requested width and height.
 *
 * @param fileDescriptor The file descriptor to read from
 * @param reqWidth The requested width of the resulting bitmap
 * @param reqHeight The requested height of the resulting bitmap
 * @param cache The ImageCache used to find candidate bitmaps for use with inBitmap
 * @return A bitmap sampled down from the original with the same aspect ratio and dimensions
 * that are equal to or greater than the requested width and height
 */
 public static Bitmap decodeSampledBitmapFromDescriptor(
 FileDescriptor fileDescriptor, int reqWidth, int reqHeight, ImageCache cache) {

 // First decode with inJustDecodeBounds=true to check dimensions
 final BitmapFactory.Options options = new BitmapFactory.Options();
 options.inJustDecodeBounds = true;
 BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options);

 // Calculate inSampleSize
 options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

 // Decode bitmap with inSampleSize set
 options.inJustDecodeBounds = false;

 // If we're running on Honeycomb or newer, try to use inBitmap
 if (Utils.hasHoneycomb()) {
 addInBitmapOptions(options, cache);
 }

 return BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options);
 }

 @TargetApi(Build.VERSION_CODES.HONEYCOMB)
 private static void addInBitmapOptions(BitmapFactory.Options options, ImageCache cache) {
 // inBitmap only works with mutable bitmaps so force the decoder to
 // return mutable bitmaps.
 options.inMutable = true;

 if (cache != null) {
 // Try and find a bitmap to use for inBitmap
 Bitmap inBitmap = cache.getBitmapFromReusableSet(options);

 if (inBitmap != null) {
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "Found bitmap to use for inBitmap");
 }
 options.inBitmap = inBitmap;
 }
 }
 }

 /**
 * Calculate an inSampleSize for use in a {@link BitmapFactory.Options} object when decoding
 * bitmaps using the decode* methods from {@link BitmapFactory}. This implementation calculates
 * the closest inSampleSize that will result in the final decoded bitmap having a width and
 * height equal to or larger than the requested width and height. This implementation does not
 * ensure a power of 2 is returned for inSampleSize which can be faster when decoding but
 * results in a larger bitmap which isn't as useful for caching purposes.
 *
 * @param options An options object with out* params already populated (run through a decode*
 * method with inJustDecodeBounds==true
 * @param reqWidth The requested width of the resulting bitmap
 * @param reqHeight The requested height of the resulting bitmap
 * @return The value to be used for inSampleSize
 */
 public static int calculateInSampleSize(BitmapFactory.Options options,
 int reqWidth, int reqHeight) {
 // Raw height and width of image
 final int height = options.outHeight;
 final int width = options.outWidth;
 int inSampleSize = 1;

 if (height > reqHeight || width > reqWidth) {

 // Calculate ratios of height and width to requested height and width
 final int heightRatio = Math.round((float) height / (float) reqHeight);
 final int widthRatio = Math.round((float) width / (float) reqWidth);

 // Choose the smallest ratio as inSampleSize value, this will guarantee a final image
 // with both dimensions larger than or equal to the requested height and width.
 inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;

 // This offers some additional logic in case the image has a strange
 // aspect ratio. For example, a panorama may have a much larger
 // width than height. In these cases the total pixels might still
 // end up being too large to fit comfortably in memory, so we should
 // be more aggressive with sample down the image (=larger inSampleSize).

 final float totalPixels = width * height;

 // Anything more than 2x the requested pixels we'll sample down further
 final float totalReqPixelsCap = reqWidth * reqHeight * 2;

 while (totalPixels / (inSampleSize * inSampleSize) > totalReqPixelsCap) {
 inSampleSize++;
 }
 }
 return inSampleSize;
 }
}

now, create sixth class name ImageWorker

import java.lang.ref.WeakReference;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.ColorDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.TransitionDrawable;
import android.support.v4.app.FragmentActivity;
import android.support.v4.app.FragmentManager;
import android.util.Log;
import android.widget.ImageView;

import com.jitega.act.BuildConfig;

/**
* This class wraps up completing some arbitrary long running work when loading a bitmap to an
* ImageView. It handles things like using a memory and disk cache, running the work in a background
* thread and setting a placeholder image.
*/
public abstract class ImageWorker {
 private static final String TAG = "ImageWorker";
 private static final int FADE_IN_TIME = 200;

 private ImageCache mImageCache;
 private ImageCache.ImageCacheParams mImageCacheParams;
 private Bitmap mLoadingBitmap;
 private boolean mFadeInBitmap = true;
 private boolean mExitTasksEarly = false;
 protected boolean mPauseWork = false;
 private final Object mPauseWorkLock = new Object();

 protected Resources mResources;

 private static final int MESSAGE_CLEAR = 0;
 private static final int MESSAGE_INIT_DISK_CACHE = 1;
 private static final int MESSAGE_FLUSH = 2;
 private static final int MESSAGE_CLOSE = 3;

 protected ImageWorker(Context context) {
 mResources = context.getResources();
 }

 /**
 * Load an image specified by the data parameter into an ImageView (override
 * {@link ImageWorker#processBitmap(Object)} to define the processing logic). A memory and
 * disk cache will be used if an {@link ImageCache} has been added using
 * {@link ImageWorker#addImageCache(FragmentManager, ImageCache.ImageCacheParams)}. If the
 * image is found in the memory cache, it is set immediately, otherwise an {@link AsyncTask}
 * will be created to asynchronously load the bitmap.
 *
 * @param data The URL of the image to download.
 * @param imageView The ImageView to bind the downloaded image to.
 */
 public void loadImage(Object data, ImageView imageView) {
 if (data == null) {
 return;
 }

 BitmapDrawable value = null;

 if (mImageCache != null) {
 value = mImageCache.getBitmapFromMemCache(String.valueOf(data));
 }

 if (value != null) {
 // Bitmap found in memory cache
 imageView.setImageDrawable(value);
 } else if (cancelPotentialWork(data, imageView)) {
 final BitmapWorkerTask task = new BitmapWorkerTask(imageView);
 final AsyncDrawable asyncDrawable =
 new AsyncDrawable(mResources, mLoadingBitmap, task);
 imageView.setImageDrawable(asyncDrawable);

 // NOTE: This uses a custom version of AsyncTask that has been pulled from the
 // framework and slightly modified. Refer to the docs at the top of the class
 // for more info on what was changed.
 task.executeOnExecutor(AsyncTask.DUAL_THREAD_EXECUTOR, data);
 }
 }

 /**
 * Set placeholder bitmap that shows when the the background thread is running.
 *
 * @param bitmap
 */
 public void setLoadingImage(Bitmap bitmap) {
 mLoadingBitmap = bitmap;
 }

 /**
 * Set placeholder bitmap that shows when the the background thread is running.
 *
 * @param resId
 */
 public void setLoadingImage(int resId) {
 mLoadingBitmap = BitmapFactory.decodeResource(mResources, resId);
 }

 /**
 * Adds an {@link ImageCache} to this {@link ImageWorker} to handle disk and memory bitmap
 * caching.
 * @param fragmentManager
 * @param cacheParams The cache parameters to use for the image cache.
 */
 public void addImageCache(FragmentManager fragmentManager,
 ImageCache.ImageCacheParams cacheParams) {
 mImageCacheParams = cacheParams;
 mImageCache = ImageCache.getInstance(fragmentManager, mImageCacheParams);
 new CacheAsyncTask().execute(MESSAGE_INIT_DISK_CACHE);
 }

 /**
 * Adds an {@link ImageCache} to this {@link ImageWorker} to handle disk and memory bitmap
 * caching.
 * @param activity
 * @param diskCacheDirectoryName See
 * {@link ImageCache.ImageCacheParams#ImageCacheParams(Context, String)}.
 */
 public void addImageCache(FragmentActivity activity, String diskCacheDirectoryName) {
 mImageCacheParams = new ImageCache.ImageCacheParams(activity, diskCacheDirectoryName);
 mImageCache = ImageCache.getInstance(activity.getSupportFragmentManager(), mImageCacheParams);
 new CacheAsyncTask().execute(MESSAGE_INIT_DISK_CACHE);
 }

 /**
 * If set to true, the image will fade-in once it has been loaded by the background thread.
 */
 public void setImageFadeIn(boolean fadeIn) {
 mFadeInBitmap = fadeIn;
 }

 public void setExitTasksEarly(boolean exitTasksEarly) {
 mExitTasksEarly = exitTasksEarly;
 setPauseWork(false);
 }

 /**
 * Subclasses should override this to define any processing or work that must happen to produce
 * the final bitmap. This will be executed in a background thread and be long running. For
 * example, you could resize a large bitmap here, or pull down an image from the network.
 *
 * @param data The data to identify which image to process, as provided by
 * {@link ImageWorker#loadImage(Object, ImageView)}
 * @return The processed bitmap
 */
 protected abstract Bitmap processBitmap(Object data);

 /**
 * @return The {@link ImageCache} object currently being used by this ImageWorker.
 */
 protected ImageCache getImageCache() {
 return mImageCache;
 }

 /**
 * Cancels any pending work attached to the provided ImageView.
 * @param imageView
 */
 public static void cancelWork(ImageView imageView) {
 final BitmapWorkerTask bitmapWorkerTask = getBitmapWorkerTask(imageView);
 if (bitmapWorkerTask != null) {
 bitmapWorkerTask.cancel(true);
 if (BuildConfig.DEBUG) {
 final Object bitmapData = bitmapWorkerTask.data;
 Log.d(TAG, "cancelWork - cancelled work for " + bitmapData);
 }
 }
 }

 /**
 * Returns true if the current work has been canceled or if there was no work in
 * progress on this image view.
 * Returns false if the work in progress deals with the same data. The work is not
 * stopped in that case.
 */
 public static boolean cancelPotentialWork(Object data, ImageView imageView) {
 final BitmapWorkerTask bitmapWorkerTask = getBitmapWorkerTask(imageView);

 if (bitmapWorkerTask != null) {
 final Object bitmapData = bitmapWorkerTask.data;
 if (bitmapData == null || !bitmapData.equals(data)) {
 bitmapWorkerTask.cancel(true);
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "cancelPotentialWork - cancelled work for " + data);
 }
 } else {
 // The same work is already in progress.
 return false;
 }
 }
 return true;
 }

 /**
 * @param imageView Any imageView
 * @return Retrieve the currently active work task (if any) associated with this imageView.
 * null if there is no such task.
 */
 private static BitmapWorkerTask getBitmapWorkerTask(ImageView imageView) {
 if (imageView != null) {
 final Drawable drawable = imageView.getDrawable();
 if (drawable instanceof AsyncDrawable) {
 final AsyncDrawable asyncDrawable = (AsyncDrawable) drawable;
 return asyncDrawable.getBitmapWorkerTask();
 }
 }
 return null;
 }

 /**
 * The actual AsyncTask that will asynchronously process the image.
 */
 private class BitmapWorkerTask extends AsyncTask<Object, Void, BitmapDrawable> {
 private Object data;
 private final WeakReference<ImageView> imageViewReference;

 public BitmapWorkerTask(ImageView imageView) {
 imageViewReference = new WeakReference<ImageView>(imageView);
 }

 /**
 * Background processing.
 */
 @Override
 protected BitmapDrawable doInBackground(Object... params) {
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "doInBackground - starting work");
 }

 data = params[0];
 final String dataString = String.valueOf(data);
 Bitmap bitmap = null;
 BitmapDrawable drawable = null;

 // Wait here if work is paused and the task is not cancelled
 synchronized (mPauseWorkLock) {
 while (mPauseWork && !isCancelled()) {
 try {
 mPauseWorkLock.wait();
 } catch (InterruptedException e) {}
 }
 }

 // If the image cache is available and this task has not been cancelled by another
 // thread and the ImageView that was originally bound to this task is still bound back
 // to this task and our "exit early" flag is not set then try and fetch the bitmap from
 // the cache
 if (mImageCache != null && !isCancelled() && getAttachedImageView() != null
 && !mExitTasksEarly) {
 bitmap = mImageCache.getBitmapFromDiskCache(dataString);
 }

 // If the bitmap was not found in the cache and this task has not been cancelled by
 // another thread and the ImageView that was originally bound to this task is still
 // bound back to this task and our "exit early" flag is not set, then call the main
 // process method (as implemented by a subclass)
 if (bitmap == null && !isCancelled() && getAttachedImageView() != null
 && !mExitTasksEarly) {
 bitmap = processBitmap(params[0]);
 }

 // If the bitmap was processed and the image cache is available, then add the processed
 // bitmap to the cache for future use. Note we don't check if the task was cancelled
 // here, if it was, and the thread is still running, we may as well add the processed
 // bitmap to our cache as it might be used again in the future
 if (bitmap != null) {
 if (Utils.hasHoneycomb()) {
 // Running on Honeycomb or newer, so wrap in a standard BitmapDrawable
 drawable = new BitmapDrawable(mResources, bitmap);
 } else {
 // Running on Gingerbread or older, so wrap in a RecyclingBitmapDrawable
 // which will recycle automagically
 drawable = new RecyclingBitmapDrawable(mResources, bitmap);
 }

 if (mImageCache != null) {
 mImageCache.addBitmapToCache(dataString, drawable);
 }
 }

 if (BuildConfig.DEBUG) {
 Log.d(TAG, "doInBackground - finished work");
 }

 return drawable;
 }

 /**
 * Once the image is processed, associates it to the imageView
 */
 @Override
 protected void onPostExecute(BitmapDrawable value) {
 // if cancel was called on this task or the "exit early" flag is set then we're done
 if (isCancelled() || mExitTasksEarly) {
 value = null;
 }

 final ImageView imageView = getAttachedImageView();
 if (value != null && imageView != null) {
 if (BuildConfig.DEBUG) {
 Log.d(TAG, "onPostExecute - setting bitmap");
 }
 setImageDrawable(imageView, value);
 }
 }

 @Override
 protected void onCancelled(BitmapDrawable value) {
 super.onCancelled(value);
 synchronized (mPauseWorkLock) {
 mPauseWorkLock.notifyAll();
 }
 }

 /**
 * Returns the ImageView associated with this task as long as the ImageView's task still
 * points to this task as well. Returns null otherwise.
 */
 private ImageView getAttachedImageView() {
 final ImageView imageView = imageViewReference.get();
 final BitmapWorkerTask bitmapWorkerTask = getBitmapWorkerTask(imageView);

 if (this == bitmapWorkerTask) {
 return imageView;
 }

 return null;
 }
 }

 /**
 * A custom Drawable that will be attached to the imageView while the work is in progress.
 * Contains a reference to the actual worker task, so that it can be stopped if a new binding is
 * required, and makes sure that only the last started worker process can bind its result,
 * independently of the finish order.
 */
 private static class AsyncDrawable extends BitmapDrawable {
 private final WeakReference<BitmapWorkerTask> bitmapWorkerTaskReference;

 public AsyncDrawable(Resources res, Bitmap bitmap, BitmapWorkerTask bitmapWorkerTask) {
 super(res, bitmap);
 bitmapWorkerTaskReference =
 new WeakReference<BitmapWorkerTask>(bitmapWorkerTask);
 }

 public BitmapWorkerTask getBitmapWorkerTask() {
 return bitmapWorkerTaskReference.get();
 }
 }

 /**
 * Called when the processing is complete and the final drawable should be
 * set on the ImageView.
 *
 * @param imageView
 * @param drawable
 */
 private void setImageDrawable(ImageView imageView, Drawable drawable) {
 if (mFadeInBitmap) {
 // Transition drawable with a transparent drawable and the final drawable
 final TransitionDrawable td =
 new TransitionDrawable(new Drawable[] {
 new ColorDrawable(android.R.color.transparent),
 drawable
 });
 // Set background to loading bitmap
 imageView.setBackgroundDrawable(
 new BitmapDrawable(mResources, mLoadingBitmap));

 imageView.setImageDrawable(td);
 td.startTransition(FADE_IN_TIME);
 } else {
 imageView.setImageDrawable(drawable);
 }
 }

 /**
 * Pause any ongoing background work. This can be used as a temporary
 * measure to improve performance. For example background work could
 * be paused when a ListView or GridView is being scrolled using a
 * {@link android.widget.AbsListView.OnScrollListener} to keep
 * scrolling smooth.
 * 
 * If work is paused, be sure setPauseWork(false) is called again
 * before your fragment or activity is destroyed (for example during
 * {@link android.app.Activity#onPause()}), or there is a risk the
 * background thread will never finish.
 */
 public void setPauseWork(boolean pauseWork) {
 synchronized (mPauseWorkLock) {
 mPauseWork = pauseWork;
 if (!mPauseWork) {
 mPauseWorkLock.notifyAll();
 }
 }
 }

 protected class CacheAsyncTask extends AsyncTask<Object, Void, Void> {

 @Override
 protected Void doInBackground(Object... params) {
 switch ((Integer)params[0]) {
 case MESSAGE_CLEAR:
 clearCacheInternal();
 break;
 case MESSAGE_INIT_DISK_CACHE:
 initDiskCacheInternal();
 break;
 case MESSAGE_FLUSH:
 flushCacheInternal();
 break;
 case MESSAGE_CLOSE:
 closeCacheInternal();
 break;
 }
 return null;
 }
 }

 protected void initDiskCacheInternal() {
 if (mImageCache != null) {
 mImageCache.initDiskCache();
 }
 }

 protected void clearCacheInternal() {
 if (mImageCache != null) {
 mImageCache.clearCache();
 }
 }

 protected void flushCacheInternal() {
 if (mImageCache != null) {
 mImageCache.flush();
 }
 }

 protected void closeCacheInternal() {
 if (mImageCache != null) {
 mImageCache.close();
 mImageCache = null;
 }
 }

 public void clearCache() {
 new CacheAsyncTask().execute(MESSAGE_CLEAR);
 }

 public void flushCache() {
 new CacheAsyncTask().execute(MESSAGE_FLUSH);
 }

 public void closeCache() {
 new CacheAsyncTask().execute(MESSAGE_CLOSE);
 }
}

now, create seventh class name RecyclingBitmapDrawable

import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.drawable.BitmapDrawable;
import android.util.Log;
import com.jitega.act.BuildConfig;

/**
* A BitmapDrawable that keeps track of whether it is being displayed or cached.
* When the drawable is no longer being displayed or cached,
* {@link Bitmap#recycle() recycle()} will be called on this drawable's bitmap.
*/
public class RecyclingBitmapDrawable extends BitmapDrawable {

 static final String LOG_TAG = "CountingBitmapDrawable";

 private int mCacheRefCount = 0;
 private int mDisplayRefCount = 0;

 private boolean mHasBeenDisplayed;

 public RecyclingBitmapDrawable(Resources res, Bitmap bitmap) {
 super(res, bitmap);
 }

 /**
 * Notify the drawable that the displayed state has changed. Internally a
 * count is kept so that the drawable knows when it is no longer being
 * displayed.
 *
 * @param isDisplayed - Whether the drawable is being displayed or not
 */
 public void setIsDisplayed(boolean isDisplayed) {
 synchronized (this) {
 if (isDisplayed) {
 mDisplayRefCount++;
 mHasBeenDisplayed = true;
 } else {
 mDisplayRefCount--;
 }
 }

 // Check to see if recycle() can be called
 checkState();
 }

 /**
 * Notify the drawable that the cache state has changed. Internally a count
 * is kept so that the drawable knows when it is no longer being cached.
 *
 * @param isCached - Whether the drawable is being cached or not
 */
 public void setIsCached(boolean isCached) {
 synchronized (this) {
 if (isCached) {
 mCacheRefCount++;
 } else {
 mCacheRefCount--;
 }
 }

 // Check to see if recycle() can be called
 checkState();
 }

 private synchronized void checkState() {
 // If the drawable cache and display ref counts = 0, and this drawable
 // has been displayed, then recycle
 if (mCacheRefCount <= 0 && mDisplayRefCount <= 0 && mHasBeenDisplayed
 && hasValidBitmap()) {
 if (BuildConfig.DEBUG) {
 Log.d(LOG_TAG, "No longer being used or cached so recycling. "
 + toString());
 }

 getBitmap().recycle();
 }
 }

 private synchronized boolean hasValidBitmap() {
 Bitmap bitmap = getBitmap();
 return bitmap != null && !bitmap.isRecycled();
 }

}

now, create eight class name Utils

import com.jitega.act.JitegaSlider;
import android.annotation.TargetApi;
import android.os.Build;
import android.os.StrictMode;

/**
* Class containing some static utility methods.
*/
public class Utils {
 private Utils() {};

 @TargetApi(11)
 public static void enableStrictMode() {
 if (Utils.hasGingerbread()) {
 StrictMode.ThreadPolicy.Builder threadPolicyBuilder =
 new StrictMode.ThreadPolicy.Builder()
 .detectAll()
 .penaltyLog();
 StrictMode.VmPolicy.Builder vmPolicyBuilder =
 new StrictMode.VmPolicy.Builder()
 .detectAll()
 .penaltyLog();

 if (Utils.hasHoneycomb()) {
 threadPolicyBuilder.penaltyFlashScreen();
 vmPolicyBuilder
 .setClassInstanceLimit(JitegaSlider.class, 1)
 .setClassInstanceLimit(JitegaSlider.class, 1);
 }
 StrictMode.setThreadPolicy(threadPolicyBuilder.build());
 StrictMode.setVmPolicy(vmPolicyBuilder.build());
 }
 }

 public static boolean hasFroyo() {
 // Can use static final constants like FROYO, declared in later versions
 // of the OS since they are inlined at compile time. This is guaranteed behavior.
 return Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO;
 }

 public static boolean hasGingerbread() {
 return Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD;
 }

 public static boolean hasHoneycomb() {
 return Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB;
 }

 public static boolean hasHoneycombMR1() {
 return Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1;
 }

 public static boolean hasJellyBean() {
 return Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN;
 }
}

now ,In Your MainActivity class use below code

public class JitegaSlider extends FragmentActivity implements OnEditorActionListener{

private ImageFetcher mImageFetcher;
ImageView myimg;

protected void onCreate(Bundle savedInstanceState) {
 // TODO Auto-generated method stub
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main);

 myimg = (ImageView)convertView.findViewById(R.id.myimg);

 ImageCacheParams cacheParams = new ImageCacheParams(context, IMAGE_CACHE_DIR);
 cacheParams.setMemCacheSizePercent(0.25f); // Set memory cache to 25% of app memory
 mImageFetcher = new ImageFetcher(context, mImageThumbSize);
 mImageFetcher.setLoadingImage(R.drawable.app_icon);
 mImageFetcher.addImageCache(getSupportFragmentManager(), cacheParams);

 mImageFetcher.loadImage("Your image url",myimg);
}
}

that's it ,enjoy code.

Android , React-Native , Kotlin , Android JetBrains Coding Blogs

Saturday, 27 July 2013

Display High Resolution Image URL

No comments:

Post a Comment

Find Hours Diffrence in Kotlin

Report Abuse