init uil

+/build
+uil.iml
\ No newline at end of file

+/*
+ *  Copyright (c)  2016.  wugian
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 25
+    buildToolsVersion "25.0.0"
+
+    defaultConfig {
+        minSdkVersion 18
+        targetSdkVersion 25
+        versionCode 1
+        versionName "1.0"
+
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+}

+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in D:\develope-file\android-sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}

+<!--
+  ~  Copyright (c)  2016.  wugian
+  ~  Licensed under the Apache License, Version 2.0 (the "License");
+  ~  you may not use this file except in compliance with the License.
+  ~  You may obtain a copy of the License at
+  ~
+  ~  http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~  Unless required by applicable law or agreed to in writing, software
+  ~  distributed under the License is distributed on an "AS IS" BASIS,
+  ~  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~  See the License for the specific language governing permissions and
+  ~  limitations under the License.
+  ~
+  -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.nostra13.universalimageloader">
+
+    <application android:allowBackup="true"
+                 android:supportsRtl="true"
+    >
+
+    </application>
+
+</manifest>

+/*******************************************************************************
+ * Copyright 2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.disc;
+
+import android.graphics.Bitmap;
+import com.nostra13.universalimageloader.utils.IoUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Interface for disk cache
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.9.2
+ */
+public interface DiskCache {
+	/**
+	 * Returns root directory of disk cache
+	 *
+	 * @return Root directory of disk cache
+	 */
+	File getDirectory();
+
+	/**
+	 * Returns file of cached image
+	 *
+	 * @param imageUri Original image URI
+	 * @return File of cached image or <b>null</b> if image wasn't cached
+	 */
+	File get(String imageUri);
+
+	/**
+	 * Saves image stream in disk cache.
+	 * Incoming image stream shouldn't be closed in this method.
+	 *
+	 * @param imageUri    Original image URI
+	 * @param imageStream Input stream of image (shouldn't be closed in this method)
+	 * @param listener    Listener for saving progress, can be ignored if you don't use
+	 *                    {@linkplain com.nostra13.universalimageloader.core.listener.ImageLoadingProgressListener
+	 *                    progress listener} in ImageLoader calls
+	 * @return <b>true</b> - if image was saved successfully; <b>false</b> - if image wasn't saved in disk cache.
+	 * @throws IOException
+	 */
+	boolean save(String imageUri, InputStream imageStream, IoUtils.CopyListener listener) throws IOException;
+
+	/**
+	 * Saves image bitmap in disk cache.
+	 *
+	 * @param imageUri Original image URI
+	 * @param bitmap   Image bitmap
+	 * @return <b>true</b> - if bitmap was saved successfully; <b>false</b> - if bitmap wasn't saved in disk cache.
+	 * @throws IOException
+	 */
+	boolean save(String imageUri, Bitmap bitmap) throws IOException;
+
+	/**
+	 * Removes image file associated with incoming URI
+	 *
+	 * @param imageUri Image URI
+	 * @return <b>true</b> - if image file is deleted successfully; <b>false</b> - if image file doesn't exist for
+	 * incoming URI or image file can't be deleted.
+	 */
+	boolean remove(String imageUri);
+
+	/** Closes disk cache, releases resources. */
+	void close();
+
+	/** Clears disk cache. */
+	void clear();
+}

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.disc.impl;
+
+import android.graphics.Bitmap;
+import com.nostra13.universalimageloader.cache.disc.DiskCache;
+import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator;
+import com.nostra13.universalimageloader.core.DefaultConfigurationFactory;
+import com.nostra13.universalimageloader.utils.IoUtils;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * Base disk cache.
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @see FileNameGenerator
+ * @since 1.0.0
+ */
+public abstract class BaseDiskCache implements DiskCache {
+	/** {@value */
+	public static final int DEFAULT_BUFFER_SIZE = 32 * 1024; // 32 Kb
+	/** {@value */
+	public static final Bitmap.CompressFormat DEFAULT_COMPRESS_FORMAT = Bitmap.CompressFormat.PNG;
+	/** {@value */
+	public static final int DEFAULT_COMPRESS_QUALITY = 100;
+
+	private static final String ERROR_ARG_NULL = " argument must be not null";
+	private static final String TEMP_IMAGE_POSTFIX = ".tmp";
+
+	protected final File cacheDir;
+	protected final File reserveCacheDir;
+
+	protected final FileNameGenerator fileNameGenerator;
+
+	protected int bufferSize = DEFAULT_BUFFER_SIZE;
+
+	protected Bitmap.CompressFormat compressFormat = DEFAULT_COMPRESS_FORMAT;
+	protected int compressQuality = DEFAULT_COMPRESS_QUALITY;
+
+	/** @param cacheDir Directory for file caching */
+	public BaseDiskCache(File cacheDir) {
+		this(cacheDir, null);
+	}
+
+	/**
+	 * @param cacheDir        Directory for file caching
+	 * @param reserveCacheDir null-ok; Reserve directory for file caching. It's used when the primary directory isn't available.
+	 */
+	public BaseDiskCache(File cacheDir, File reserveCacheDir) {
+		this(cacheDir, reserveCacheDir, DefaultConfigurationFactory.createFileNameGenerator());
+	}
+
+	/**
+	 * @param cacheDir          Directory for file caching
+	 * @param reserveCacheDir   null-ok; Reserve directory for file caching. It's used when the primary directory isn't available.
+	 * @param fileNameGenerator {@linkplain FileNameGenerator
+	 *                          Name generator} for cached files
+	 */
+	public BaseDiskCache(File cacheDir, File reserveCacheDir, FileNameGenerator fileNameGenerator) {
+		if (cacheDir == null) {
+			throw new IllegalArgumentException("cacheDir" + ERROR_ARG_NULL);
+		}
+		if (fileNameGenerator == null) {
+			throw new IllegalArgumentException("fileNameGenerator" + ERROR_ARG_NULL);
+		}
+
+		this.cacheDir = cacheDir;
+		this.reserveCacheDir = reserveCacheDir;
+		this.fileNameGenerator = fileNameGenerator;
+	}
+
+	@Override
+	public File getDirectory() {
+		return cacheDir;
+	}
+
+	@Override
+	public File get(String imageUri) {
+		return getFile(imageUri);
+	}
+
+	@Override
+	public boolean save(String imageUri, InputStream imageStream, IoUtils.CopyListener listener) throws IOException {
+		File imageFile = getFile(imageUri);
+		File tmpFile = new File(imageFile.getAbsolutePath() + TEMP_IMAGE_POSTFIX);
+		boolean loaded = false;
+		try {
+			OutputStream os = new BufferedOutputStream(new FileOutputStream(tmpFile), bufferSize);
+			try {
+				loaded = IoUtils.copyStream(imageStream, os, listener, bufferSize);
+			} finally {
+				IoUtils.closeSilently(os);
+			}
+		} finally {
+			if (loaded && !tmpFile.renameTo(imageFile)) {
+				loaded = false;
+			}
+			if (!loaded) {
+				tmpFile.delete();
+			}
+		}
+		return loaded;
+	}
+
+	@Override
+	public boolean save(String imageUri, Bitmap bitmap) throws IOException {
+		File imageFile = getFile(imageUri);
+		File tmpFile = new File(imageFile.getAbsolutePath() + TEMP_IMAGE_POSTFIX);
+		OutputStream os = new BufferedOutputStream(new FileOutputStream(tmpFile), bufferSize);
+		boolean savedSuccessfully = false;
+		try {
+			savedSuccessfully = bitmap.compress(compressFormat, compressQuality, os);
+		} finally {
+			IoUtils.closeSilently(os);
+			if (savedSuccessfully && !tmpFile.renameTo(imageFile)) {
+				savedSuccessfully = false;
+			}
+			if (!savedSuccessfully) {
+				tmpFile.delete();
+			}
+		}
+		bitmap.recycle();
+		return savedSuccessfully;
+	}
+
+	@Override
+	public boolean remove(String imageUri) {
+		return getFile(imageUri).delete();
+	}
+
+	@Override
+	public void close() {
+		// Nothing to do
+	}
+
+	@Override
+	public void clear() {
+		File[] files = cacheDir.listFiles();
+		if (files != null) {
+			for (File f : files) {
+				f.delete();
+			}
+		}
+	}
+
+	/** Returns file object (not null) for incoming image URI. File object can reference to non-existing file. */
+	protected File getFile(String imageUri) {
+		String fileName = fileNameGenerator.generate(imageUri);
+		File dir = cacheDir;
+		if (!cacheDir.exists() && !cacheDir.mkdirs()) {
+			if (reserveCacheDir != null && (reserveCacheDir.exists() || reserveCacheDir.mkdirs())) {
+				dir = reserveCacheDir;
+			}
+		}
+		return new File(dir, fileName);
+	}
+
+	public void setBufferSize(int bufferSize) {
+		this.bufferSize = bufferSize;
+	}
+
+	public void setCompressFormat(Bitmap.CompressFormat compressFormat) {
+		this.compressFormat = compressFormat;
+	}
+
+	public void setCompressQuality(int compressQuality) {
+		this.compressQuality = compressQuality;
+	}
+}
\ No newline at end of file

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.disc.impl;
+
+import android.graphics.Bitmap;
+import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator;
+import com.nostra13.universalimageloader.core.DefaultConfigurationFactory;
+import com.nostra13.universalimageloader.utils.IoUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Cache which deletes files which were loaded more than defined time. Cache size is unlimited.
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.3.1
+ */
+public class LimitedAgeDiskCache extends BaseDiskCache {
+
+	private final long maxFileAge;
+
+	private final Map<File, Long> loadingDates = Collections.synchronizedMap(new HashMap<File, Long>());
+
+	/**
+	 * @param cacheDir Directory for file caching
+	 * @param maxAge   Max file age (in seconds). If file age will exceed this value then it'll be removed on next
+	 *                 treatment (and therefore be reloaded).
+	 */
+	public LimitedAgeDiskCache(File cacheDir, long maxAge) {
+		this(cacheDir, null, DefaultConfigurationFactory.createFileNameGenerator(), maxAge);
+	}
+
+	/**
+	 * @param cacheDir Directory for file caching
+	 * @param maxAge   Max file age (in seconds). If file age will exceed this value then it'll be removed on next
+	 *                 treatment (and therefore be reloaded).
+	 */
+	public LimitedAgeDiskCache(File cacheDir, File reserveCacheDir, long maxAge) {
+		this(cacheDir, reserveCacheDir, DefaultConfigurationFactory.createFileNameGenerator(), maxAge);
+	}
+
+	/**
+	 * @param cacheDir          Directory for file caching
+	 * @param reserveCacheDir   null-ok; Reserve directory for file caching. It's used when the primary directory isn't available.
+	 * @param fileNameGenerator Name generator for cached files
+	 * @param maxAge            Max file age (in seconds). If file age will exceed this value then it'll be removed on next
+	 *                          treatment (and therefore be reloaded).
+	 */
+	public LimitedAgeDiskCache(File cacheDir, File reserveCacheDir, FileNameGenerator fileNameGenerator, long maxAge) {
+		super(cacheDir, reserveCacheDir, fileNameGenerator);
+		this.maxFileAge = maxAge * 1000; // to milliseconds
+	}
+
+	@Override
+	public File get(String imageUri) {
+		File file = super.get(imageUri);
+		if (file != null && file.exists()) {
+			boolean cached;
+			Long loadingDate = loadingDates.get(file);
+			if (loadingDate == null) {
+				cached = false;
+				loadingDate = file.lastModified();
+			} else {
+				cached = true;
+			}
+
+			if (System.currentTimeMillis() - loadingDate > maxFileAge) {
+				file.delete();
+				loadingDates.remove(file);
+			} else if (!cached) {
+				loadingDates.put(file, loadingDate);
+			}
+		}
+		return file;
+	}
+
+	@Override
+	public boolean save(String imageUri, InputStream imageStream, IoUtils.CopyListener listener) throws IOException {
+		boolean saved = super.save(imageUri, imageStream, listener);
+		rememberUsage(imageUri);
+		return saved;
+	}
+
+	@Override
+	public boolean save(String imageUri, Bitmap bitmap) throws IOException {
+		boolean saved = super.save(imageUri, bitmap);
+		rememberUsage(imageUri);
+		return saved;
+	}
+
+	@Override
+	public boolean remove(String imageUri) {
+		loadingDates.remove(getFile(imageUri));
+		return super.remove(imageUri);
+	}
+
+	@Override
+	public void clear() {
+		super.clear();
+		loadingDates.clear();
+	}
+
+	private void rememberUsage(String imageUri) {
+		File file = getFile(imageUri);
+		long currentTime = System.currentTimeMillis();
+		file.setLastModified(currentTime);
+		loadingDates.put(file, currentTime);
+	}
+}
\ No newline at end of file

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.disc.impl;
+
+import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator;
+
+import java.io.File;
+
+/**
+ * Default implementation of {@linkplain com.nostra13.universalimageloader.cache.disc.DiskCache disk cache}.
+ * Cache size is unlimited.
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.0.0
+ */
+public class UnlimitedDiskCache extends BaseDiskCache {
+	/** @param cacheDir Directory for file caching */
+	public UnlimitedDiskCache(File cacheDir) {
+		super(cacheDir);
+	}
+
+	/**
+	 * @param cacheDir        Directory for file caching
+	 * @param reserveCacheDir null-ok; Reserve directory for file caching. It's used when the primary directory isn't available.
+	 */
+	public UnlimitedDiskCache(File cacheDir, File reserveCacheDir) {
+		super(cacheDir, reserveCacheDir);
+	}
+
+	/**
+	 * @param cacheDir          Directory for file caching
+	 * @param reserveCacheDir   null-ok; Reserve directory for file caching. It's used when the primary directory isn't available.
+	 * @param fileNameGenerator {@linkplain FileNameGenerator
+	 *                          Name generator} for cached files
+	 */
+	public UnlimitedDiskCache(File cacheDir, File reserveCacheDir, FileNameGenerator fileNameGenerator) {
+		super(cacheDir, reserveCacheDir, fileNameGenerator);
+	}
+}

+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.nostra13.universalimageloader.cache.disc.impl.ext;
+
+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.FilterOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * A cache that uses a bounded amount of space on a filesystem. Each cache
+ * entry has a string key and a fixed number of values. Each key must match
+ * the regex <strong>[a-z0-9_-]{1,64}</strong>. Values are byte sequences,
+ * accessible as streams or files. Each value must be between {@code 0} and
+ * {@code Integer.MAX_VALUE} bytes in length.
+ *
+ * <p>The cache stores its data in a directory on the filesystem. This
+ * directory must be exclusive to the cache; the cache may delete or overwrite
+ * files from its directory. It is an error for multiple processes to use the
+ * same cache directory at the same time.
+ *
+ * <p>This cache limits the number of bytes that it will store on the
+ * filesystem. When the number of stored bytes exceeds the limit, the cache will
+ * remove entries in the background until the limit is satisfied. The limit is
+ * not strict: the cache may temporarily exceed it while waiting for files to be
+ * deleted. The limit does not include filesystem overhead or the cache
+ * journal so space-sensitive applications should set a conservative limit.
+ *
+ * <p>Clients call {@link #edit} to create or update the values of an entry. An
+ * entry may have only one editor at one time; if a value is not available to be
+ * edited then {@link #edit} will return null.
+ * <ul>
+ * <li>When an entry is being <strong>created</strong> it is necessary to
+ * supply a full set of values; the empty value should be used as a
+ * placeholder if necessary.
+ * <li>When an entry is being <strong>edited</strong>, it is not necessary
+ * to supply data for every value; values default to their previous
+ * value.
+ * </ul>
+ * Every {@link #edit} call must be matched by a call to {@link Editor#commit}
+ * or {@link Editor#abort}. Committing is atomic: a read observes the full set
+ * of values as they were before or after the commit, but never a mix of values.
+ *
+ * <p>Clients call {@link #get} to read a snapshot of an entry. The read will
+ * observe the value at the time that {@link #get} was called. Updates and
+ * removals after the call do not impact ongoing reads.
+ *
+ * <p>This class is tolerant of some I/O errors. If files are missing from the
+ * filesystem, the corresponding entries will be dropped from the cache. If
+ * an error occurs while writing a cache value, the edit will fail silently.
+ * Callers should handle other problems by catching {@code IOException} and
+ * responding appropriately.
+ */
+final class DiskLruCache implements Closeable {
+	static final String JOURNAL_FILE = "journal";
+	static final String JOURNAL_FILE_TEMP = "journal.tmp";
+	static final String JOURNAL_FILE_BACKUP = "journal.bkp";
+	static final String MAGIC = "libcore.io.DiskLruCache";
+	static final String VERSION_1 = "1";
+	static final long ANY_SEQUENCE_NUMBER = -1;
+	static final Pattern LEGAL_KEY_PATTERN = Pattern.compile("[a-z0-9_-]{1,64}");
+	private static final String CLEAN = "CLEAN";
+	private static final String DIRTY = "DIRTY";
+	private static final String REMOVE = "REMOVE";
+	private static final String READ = "READ";
+
+    /*
+     * 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 File journalFileBackup;
+	private final int appVersion;
+	private long maxSize;
+	private int maxFileCount;
+	private final int valueCount;
+	private long size = 0;
+	private int fileCount = 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;
+
+	/** This cache uses a single background thread to evict entries. */
+	final ThreadPoolExecutor executorService =
+			new ThreadPoolExecutor(0, 1, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
+	private final Callable<Void> cleanupCallable = new Callable<Void>() {
+		public Void call() throws Exception {
+			synchronized (DiskLruCache.this) {
+				if (journalWriter == null) {
+					return null; // Closed.
+				}
+				trimToSize();
+				trimToFileCount();
+				if (journalRebuildRequired()) {
+					rebuildJournal();
+					redundantOpCount = 0;
+				}
+			}
+			return null;
+		}
+	};
+
+	private DiskLruCache(File directory, int appVersion, int valueCount, long maxSize, int maxFileCount) {
+		this.directory = directory;
+		this.appVersion = appVersion;
+		this.journalFile = new File(directory, JOURNAL_FILE);
+		this.journalFileTmp = new File(directory, JOURNAL_FILE_TEMP);
+		this.journalFileBackup = new File(directory, JOURNAL_FILE_BACKUP);
+		this.valueCount = valueCount;
+		this.maxSize = maxSize;
+		this.maxFileCount = maxFileCount;
+	}
+
+	/**
+	 * Opens the cache in {@code directory}, creating a cache if none exists
+	 * there.
+	 *
+	 * @param directory a writable directory
+	 * @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
+	 * @param maxFileCount the maximum file count this cache should store
+	 * @throws IOException if reading or writing the cache directory fails
+	 */
+	public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize, int maxFileCount)
+			throws IOException {
+		if (maxSize <= 0) {
+			throw new IllegalArgumentException("maxSize <= 0");
+		}
+		if (maxFileCount <= 0) {
+			throw new IllegalArgumentException("maxFileCount <= 0");
+		}
+		if (valueCount <= 0) {
+			throw new IllegalArgumentException("valueCount <= 0");
+		}
+
+		// If a bkp file exists, use it instead.
+		File backupFile = new File(directory, JOURNAL_FILE_BACKUP);
+		if (backupFile.exists()) {
+			File journalFile = new File(directory, JOURNAL_FILE);
+			// If journal file also exists just delete backup file.
+			if (journalFile.exists()) {
+				backupFile.delete();
+			} else {
+				renameTo(backupFile, journalFile, false);
+			}
+		}
+
+		// Prefer to pick up where we left off.
+		DiskLruCache cache = new DiskLruCache(directory, appVersion, valueCount, maxSize, maxFileCount);
+		if (cache.journalFile.exists()) {
+			try {
+				cache.readJournal();
+				cache.processJournal();
+				cache.journalWriter = new BufferedWriter(
+						new OutputStreamWriter(new FileOutputStream(cache.journalFile, true), Util.US_ASCII));
+				return cache;
+			} catch (IOException journalIsCorrupt) {
+				System.out
+						.println("DiskLruCache "
+								+ directory
+								+ " is corrupt: "
+								+ journalIsCorrupt.getMessage()
+								+ ", removing");
+				cache.delete();
+			}
+		}
+
+		// Create a new empty cache.
+		directory.mkdirs();
+		cache = new DiskLruCache(directory, appVersion, valueCount, maxSize, maxFileCount);
+		cache.rebuildJournal();
+		return cache;
+	}
+
+	private void readJournal() throws IOException {
+		StrictLineReader reader = new StrictLineReader(new FileInputStream(journalFile), Util.US_ASCII);
+		try {
+			String magic = reader.readLine();
+			String version = reader.readLine();
+			String appVersionString = reader.readLine();
+			String valueCountString = reader.readLine();
+			String blank = reader.readLine();
+			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 + "]");
+			}
+
+			int lineCount = 0;
+			while (true) {
+				try {
+					readJournalLine(reader.readLine());
+					lineCount++;
+				} catch (EOFException endOfJournal) {
+					break;
+				}
+			}
+			redundantOpCount = lineCount - lruEntries.size();
+		} finally {
+			Util.closeQuietly(reader);
+		}
+	}
+
+	private void readJournalLine(String line) throws IOException {
+		int firstSpace = line.indexOf(' ');
+		if (firstSpace == -1) {
+			throw new IOException("unexpected journal line: " + line);
+		}
+
+		int keyBegin = firstSpace + 1;
+		int secondSpace = line.indexOf(' ', keyBegin);
+		final String key;
+		if (secondSpace == -1) {
+			key = line.substring(keyBegin);
+			if (firstSpace == REMOVE.length() && line.startsWith(REMOVE)) {
+				lruEntries.remove(key);
+				return;
+			}
+		} else {
+			key = line.substring(keyBegin, secondSpace);
+		}
+
+		Entry entry = lruEntries.get(key);
+		if (entry == null) {
+			entry = new Entry(key);
+			lruEntries.put(key, entry);
+		}
+
+		if (secondSpace != -1 && firstSpace == CLEAN.length() && line.startsWith(CLEAN)) {
+			String[] parts = line.substring(secondSpace + 1).split(" ");
+			entry.readable = true;
+			entry.currentEditor = null;
+			entry.setLengths(parts);
+		} else if (secondSpace == -1 && firstSpace == DIRTY.length() && line.startsWith(DIRTY)) {
+			entry.currentEditor = new Editor(entry);
+		} else if (secondSpace == -1 && firstSpace == READ.length() && line.startsWith(READ)) {
+			// 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];
+					fileCount++;
+				}
+			} 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 OutputStreamWriter(new FileOutputStream(journalFileTmp), Util.US_ASCII));
+		try {
+			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');
+				}
+			}
+		} finally {
+			writer.close();
+		}
+
+		if (journalFile.exists()) {
+			renameTo(journalFile, journalFileBackup, true);
+		}
+		renameTo(journalFileTmp, journalFile, false);
+		journalFileBackup.delete();
+
+		journalWriter = new BufferedWriter(
+				new OutputStreamWriter(new FileOutputStream(journalFile, true), Util.US_ASCII));
+	}
+
+	private static void deleteIfExists(File file) throws IOException {
+		if (file.exists() && !file.delete()) {
+			throw new IOException();
+		}
+	}
+
+	private static void renameTo(File from, File to, boolean deleteDestination) throws IOException {
+		if (deleteDestination) {
+			deleteIfExists(to);
+		}
+		if (!from.renameTo(to)) {
+			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.
+		File[] files = new File[valueCount];
+		InputStream[] ins = new InputStream[valueCount];
+		try {
+			File file;
+			for (int i = 0; i < valueCount; i++) {
+				file = entry.getCleanFile(i);
+				files[i] = file;
+				ins[i] = new FileInputStream(file);
+			}
+		} catch (FileNotFoundException e) {
+			// A file must have been deleted manually!
+			for (int i = 0; i < valueCount; i++) {
+				if (ins[i] != null) {
+					Util.closeQuietly(ins[i]);
+				} else {
+					break;
+				}
+			}
+			return null;
+		}
+
+		redundantOpCount++;
+		journalWriter.append(READ + ' ' + key + '\n');
+		if (journalRebuildRequired()) {
+			executorService.submit(cleanupCallable);
+		}
+
+		return new Snapshot(key, entry.sequenceNumber, files, ins, entry.lengths);
+	}
+
+	/**
+	 * 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 synchronized long getMaxSize() {
+		return maxSize;
+	}
+
+	/** Returns the maximum number of files that this cache should store */
+	public synchronized int getMaxFileCount() {
+		return maxFileCount;
+	}
+
+	/**
+	 * Changes the maximum number of bytes the cache can store and queues a job
+	 * to trim the existing store, if necessary.
+	 */
+	public synchronized void setMaxSize(long maxSize) {
+		this.maxSize = maxSize;
+		executorService.submit(cleanupCallable);
+	}
+
+	/**
+	 * 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;
+	}
+
+	/**
+	 * Returns the number of files currently being used to store the values in
+	 * this cache. This may be greater than the max file count if a background
+	 * deletion is pending.
+	 */
+	public synchronized long fileCount() {
+		return fileCount;
+	}
+
+	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 (!editor.written[i]) {
+					editor.abort();
+					throw new IllegalStateException("Newly created entry didn't create value for index " + i);
+				}
+				if (!entry.getDirtyFile(i).exists()) {
+					editor.abort();
+					return;
+				}
+			}
+		}
+
+		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;
+					fileCount++;
+				}
+			} 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');
+		}
+		journalWriter.flush();
+
+		if (size > maxSize || fileCount > maxFileCount || 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 redundantOpCompactThreshold = 2000;
+		return redundantOpCount >= redundantOpCompactThreshold //
+				&& 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.exists() && !file.delete()) {
+				throw new IOException("failed to delete " + file);
+			}
+			size -= entry.lengths[i];
+			fileCount--;
+			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 synchronized 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();
+		trimToFileCount();
+		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();
+		trimToFileCount();
+		journalWriter.close();
+		journalWriter = null;
+	}
+
+	private void trimToSize() throws IOException {
+		while (size > maxSize) {
+			Map.Entry<String, Entry> toEvict = lruEntries.entrySet().iterator().next();
+			remove(toEvict.getKey());
+		}
+	}
+
+	private void trimToFileCount() throws IOException {
+		while (fileCount > maxFileCount) {
+			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();
+		Util.deleteContents(directory);
+	}
+
+	private void validateKey(String key) {
+		Matcher matcher = LEGAL_KEY_PATTERN.matcher(key);
+		if (!matcher.matches()) {
+			throw new IllegalArgumentException("keys must match regex [a-z0-9_-]{1,64}: \"" + key + "\"");
+		}
+	}
+
+	private static String inputStreamToString(InputStream in) throws IOException {
+		return Util.readFully(new InputStreamReader(in, Util.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 File[] files;
+		private final InputStream[] ins;
+		private final long[] lengths;
+
+		private Snapshot(String key, long sequenceNumber, File[] files, InputStream[] ins, long[] lengths) {
+			this.key = key;
+			this.sequenceNumber = sequenceNumber;
+			this.files = files;
+			this.ins = ins;
+			this.lengths = lengths;
+		}
+
+		/**
+		 * 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 file with the value for {@code index}. */
+		public File getFile(int index) {
+			return files[index];
+		}
+
+		/** 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));
+		}
+
+		/** Returns the byte length of the value for {@code index}. */
+		public long getLength(int index) {
+			return lengths[index];
+		}
+
+		public void close() {
+			for (InputStream in : ins) {
+				Util.closeQuietly(in);
+			}
+		}
+	}
+
+	private static final OutputStream NULL_OUTPUT_STREAM = new OutputStream() {
+		@Override
+		public void write(int b) throws IOException {
+			// Eat all writes silently. Nom nom.
+		}
+	};
+
+	/** Edits the values for an entry. */
+	public final class Editor {
+		private final Entry entry;
+		private final boolean[] written;
+		private boolean hasErrors;
+		private boolean committed;
+
+		private Editor(Entry entry) {
+			this.entry = entry;
+			this.written = (entry.readable) ? null : new boolean[valueCount];
+		}
+
+		/**
+		 * 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;
+				}
+				try {
+					return new FileInputStream(entry.getCleanFile(index));
+				} catch (FileNotFoundException e) {
+					return null;
+				}
+			}
+		}
+
+		/**
+		 * 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();
+				}
+				if (!entry.readable) {
+					written[index] = true;
+				}
+				File dirtyFile = entry.getDirtyFile(index);
+				FileOutputStream outputStream;
+				try {
+					outputStream = new FileOutputStream(dirtyFile);
+				} catch (FileNotFoundException e) {
+					// Attempt to recreate the cache directory.
+					directory.mkdirs();
+					try {
+						outputStream = new FileOutputStream(dirtyFile);
+					} catch (FileNotFoundException e2) {
+						// We are unable to recover. Silently eat the writes.
+						return NULL_OUTPUT_STREAM;
+					}
+				}
+				return new FaultHidingOutputStream(outputStream);
+			}
+		}
+
+		/** 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), Util.UTF_8);
+				writer.write(value);
+			} finally {
+				Util.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);
+			}
+			committed = 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);
+		}
+
+		public void abortUnlessCommitted() {
+			if (!committed) {
+				try {
+					abort();
+				} catch (IOException ignored) {
+				}
+			}
+		}
+
+		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: " + java.util.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");
+		}
+	}
+}

+/*******************************************************************************
+ * Copyright 2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.disc.impl.ext;
+
+import android.graphics.Bitmap;
+import com.nostra13.universalimageloader.cache.disc.DiskCache;
+import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator;
+import com.nostra13.universalimageloader.utils.IoUtils;
+import com.nostra13.universalimageloader.utils.L;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * Disk cache based on "Least-Recently Used" principle. Adapter pattern, adapts
+ * {@link DiskLruCache DiskLruCache} to
+ * {@link DiskCache DiskCache}
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @see FileNameGenerator
+ * @since 1.9.2
+ */
+public class LruDiskCache implements DiskCache {
+	/** {@value */
+	public static final int DEFAULT_BUFFER_SIZE = 32 * 1024; // 32 Kb
+	/** {@value */
+	public static final Bitmap.CompressFormat DEFAULT_COMPRESS_FORMAT = Bitmap.CompressFormat.PNG;
+	/** {@value */
+	public static final int DEFAULT_COMPRESS_QUALITY = 100;
+
+	private static final String ERROR_ARG_NULL = " argument must be not null";
+	private static final String ERROR_ARG_NEGATIVE = " argument must be positive number";
+
+	protected DiskLruCache cache;
+	private File reserveCacheDir;
+
+	protected final FileNameGenerator fileNameGenerator;
+
+	protected int bufferSize = DEFAULT_BUFFER_SIZE;
+
+	protected Bitmap.CompressFormat compressFormat = DEFAULT_COMPRESS_FORMAT;
+	protected int compressQuality = DEFAULT_COMPRESS_QUALITY;
+
+	/**
+	 * @param cacheDir          Directory for file caching
+	 * @param fileNameGenerator {@linkplain FileNameGenerator
+	 *                          Name generator} for cached files. Generated names must match the regex
+	 *                          <strong>[a-z0-9_-]{1,64}</strong>
+	 * @param cacheMaxSize      Max cache size in bytes. <b>0</b> means cache size is unlimited.
+	 * @throws IOException if cache can't be initialized (e.g. "No space left on device")
+	 */
+	public LruDiskCache(File cacheDir, FileNameGenerator fileNameGenerator, long cacheMaxSize) throws IOException {
+		this(cacheDir, null, fileNameGenerator, cacheMaxSize, 0);
+	}
+
+	/**
+	 * @param cacheDir          Directory for file caching
+	 * @param reserveCacheDir   null-ok; Reserve directory for file caching. It's used when the primary directory isn't available.
+	 * @param fileNameGenerator {@linkplain FileNameGenerator
+	 *                          Name generator} for cached files. Generated names must match the regex
+	 *                          <strong>[a-z0-9_-]{1,64}</strong>
+	 * @param cacheMaxSize      Max cache size in bytes. <b>0</b> means cache size is unlimited.
+	 * @param cacheMaxFileCount Max file count in cache. <b>0</b> means file count is unlimited.
+	 * @throws IOException if cache can't be initialized (e.g. "No space left on device")
+	 */
+	public LruDiskCache(File cacheDir, File reserveCacheDir, FileNameGenerator fileNameGenerator, long cacheMaxSize,
+			int cacheMaxFileCount) throws IOException {
+		if (cacheDir == null) {
+			throw new IllegalArgumentException("cacheDir" + ERROR_ARG_NULL);
+		}
+		if (cacheMaxSize < 0) {
+			throw new IllegalArgumentException("cacheMaxSize" + ERROR_ARG_NEGATIVE);
+		}
+		if (cacheMaxFileCount < 0) {
+			throw new IllegalArgumentException("cacheMaxFileCount" + ERROR_ARG_NEGATIVE);
+		}
+		if (fileNameGenerator == null) {
+			throw new IllegalArgumentException("fileNameGenerator" + ERROR_ARG_NULL);
+		}
+
+		if (cacheMaxSize == 0) {
+			cacheMaxSize = Long.MAX_VALUE;
+		}
+		if (cacheMaxFileCount == 0) {
+			cacheMaxFileCount = Integer.MAX_VALUE;
+		}
+
+		this.reserveCacheDir = reserveCacheDir;
+		this.fileNameGenerator = fileNameGenerator;
+		initCache(cacheDir, reserveCacheDir, cacheMaxSize, cacheMaxFileCount);
+	}
+
+	private void initCache(File cacheDir, File reserveCacheDir, long cacheMaxSize, int cacheMaxFileCount)
+			throws IOException {
+		try {
+			cache = DiskLruCache.open(cacheDir, 1, 1, cacheMaxSize, cacheMaxFileCount);
+		} catch (IOException e) {
+			L.e(e);
+			if (reserveCacheDir != null) {
+				initCache(reserveCacheDir, null, cacheMaxSize, cacheMaxFileCount);
+			}
+			if (cache == null) {
+				throw e; //new RuntimeException("Can't initialize disk cache", e);
+			}
+		}
+	}
+
+	@Override
+	public File getDirectory() {
+		return cache.getDirectory();
+	}
+
+	@Override
+	public File get(String imageUri) {
+		DiskLruCache.Snapshot snapshot = null;
+		try {
+			snapshot = cache.get(getKey(imageUri));
+			return snapshot == null ? null : snapshot.getFile(0);
+		} catch (IOException e) {
+			L.e(e);
+			return null;
+		} finally {
+			if (snapshot != null) {
+				snapshot.close();
+			}
+		}
+	}
+
+	@Override
+	public boolean save(String imageUri, InputStream imageStream, IoUtils.CopyListener listener) throws IOException {
+		DiskLruCache.Editor editor = cache.edit(getKey(imageUri));
+		if (editor == null) {
+			return false;
+		}
+
+		OutputStream os = new BufferedOutputStream(editor.newOutputStream(0), bufferSize);
+		boolean copied = false;
+		try {
+			copied = IoUtils.copyStream(imageStream, os, listener, bufferSize);
+		} finally {
+			IoUtils.closeSilently(os);
+			if (copied) {
+				editor.commit();
+			} else {
+				editor.abort();
+			}
+		}
+		return copied;
+	}
+
+	@Override
+	public boolean save(String imageUri, Bitmap bitmap) throws IOException {
+		DiskLruCache.Editor editor = cache.edit(getKey(imageUri));
+		if (editor == null) {
+			return false;
+		}
+
+		OutputStream os = new BufferedOutputStream(editor.newOutputStream(0), bufferSize);
+		boolean savedSuccessfully = false;
+		try {
+			savedSuccessfully = bitmap.compress(compressFormat, compressQuality, os);
+		} finally {
+			IoUtils.closeSilently(os);
+		}
+		if (savedSuccessfully) {
+			editor.commit();
+		} else {
+			editor.abort();
+		}
+		return savedSuccessfully;
+	}
+
+	@Override
+	public boolean remove(String imageUri) {
+		try {
+			return cache.remove(getKey(imageUri));
+		} catch (IOException e) {
+			L.e(e);
+			return false;
+		}
+	}
+
+	@Override
+	public void close() {
+		try {
+			cache.close();
+		} catch (IOException e) {
+			L.e(e);
+		}
+		cache = null;
+	}
+
+	@Override
+	public void clear() {
+		try {
+			cache.delete();
+		} catch (IOException e) {
+			L.e(e);
+		}
+		try {
+			initCache(cache.getDirectory(), reserveCacheDir, cache.getMaxSize(), cache.getMaxFileCount());
+		} catch (IOException e) {
+			L.e(e);
+		}
+	}
+
+	private String getKey(String imageUri) {
+		return fileNameGenerator.generate(imageUri);
+	}
+
+	public void setBufferSize(int bufferSize) {
+		this.bufferSize = bufferSize;
+	}
+
+	public void setCompressFormat(Bitmap.CompressFormat compressFormat) {
+		this.compressFormat = compressFormat;
+	}
+
+	public void setCompressQuality(int compressQuality) {
+		this.compressQuality = compressQuality;
+	}
+}

+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.nostra13.universalimageloader.cache.disc.impl.ext;
+
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+
+/**
+ * Buffers input from an {@link InputStream} for reading lines.
+ *
+ * <p>This class is used for buffered reading of lines. For purposes of this class, a line ends
+ * with "\n" or "\r\n". End of input is reported by throwing {@code EOFException}. Unterminated
+ * line at end of input is invalid and will be ignored, the caller may use {@code
+ * hasUnterminatedLine()} to detect it after catching the {@code EOFException}.
+ *
+ * <p>This class is intended for reading input that strictly consists of lines, such as line-based
+ * cache entries or cache journal. Unlike the {@link java.io.BufferedReader} which in conjunction
+ * with {@link java.io.InputStreamReader} provides similar functionality, this class uses different
+ * end-of-input reporting and a more restrictive definition of a line.
+ *
+ * <p>This class supports only charsets that encode '\r' and '\n' as a single byte with value 13
+ * and 10, respectively, and the representation of no other character contains these values.
+ * We currently check in constructor that the charset is one of US-ASCII, UTF-8 and ISO-8859-1.
+ * The default charset is US_ASCII.
+ */
+class StrictLineReader implements Closeable {
+	private static final byte CR = (byte) '\r';
+	private static final byte LF = (byte) '\n';
+
+	private final InputStream in;
+	private final Charset charset;
+
+	/*
+	   * Buffered data is stored in {@code buf}. As long as no exception occurs, 0 <= pos <= end
+	   * and the data in the range [pos, end) is buffered for reading. At end of input, if there is
+	   * an unterminated line, we set end == -1, otherwise end == pos. If the underlying
+	   * {@code InputStream} throws an {@code IOException}, end may remain as either pos or -1.
+	   */
+	private byte[] buf;
+	private int pos;
+	private int end;
+
+	/**
+	 * Constructs a new {@code LineReader} with the specified charset and the default capacity.
+	 *
+	 * @param in the {@code InputStream} to read data from.
+	 * @param charset the charset used to decode data. Only US-ASCII, UTF-8 and ISO-8859-1 are
+	 * supported.
+	 * @throws NullPointerException if {@code in} or {@code charset} is null.
+	 * @throws IllegalArgumentException if the specified charset is not supported.
+	 */
+	public StrictLineReader(InputStream in, Charset charset) {
+		this(in, 8192, charset);
+	}
+
+	/**
+	 * Constructs a new {@code LineReader} with the specified capacity and charset.
+	 *
+	 * @param in the {@code InputStream} to read data from.
+	 * @param capacity the capacity of the buffer.
+	 * @param charset the charset used to decode data. Only US-ASCII, UTF-8 and ISO-8859-1 are
+	 * supported.
+	 * @throws NullPointerException if {@code in} or {@code charset} is null.
+	 * @throws IllegalArgumentException if {@code capacity} is negative or zero
+	 * or the specified charset is not supported.
+	 */
+	public StrictLineReader(InputStream in, int capacity, Charset charset) {
+		if (in == null || charset == null) {
+			throw new NullPointerException();
+		}
+		if (capacity < 0) {
+			throw new IllegalArgumentException("capacity <= 0");
+		}
+		if (!(charset.equals(Util.US_ASCII))) {
+			throw new IllegalArgumentException("Unsupported encoding");
+		}
+
+		this.in = in;
+		this.charset = charset;
+		buf = new byte[capacity];
+	}
+
+	/**
+	 * Closes the reader by closing the underlying {@code InputStream} and
+	 * marking this reader as closed.
+	 *
+	 * @throws IOException for errors when closing the underlying {@code InputStream}.
+	 */
+	public void close() throws IOException {
+		synchronized (in) {
+			if (buf != null) {
+				buf = null;
+				in.close();
+			}
+		}
+	}
+
+	/**
+	 * Reads the next line. A line ends with {@code "\n"} or {@code "\r\n"},
+	 * this end of line marker is not included in the result.
+	 *
+	 * @return the next line from the input.
+	 * @throws IOException for underlying {@code InputStream} errors.
+	 * @throws EOFException for the end of source stream.
+	 */
+	public String readLine() throws IOException {
+		synchronized (in) {
+			if (buf == null) {
+				throw new IOException("LineReader is closed");
+			}
+
+			// Read more data if we are at the end of the buffered data.
+			// Though it's an error to read after an exception, we will let {@code fillBuf()}
+			// throw again if that happens; thus we need to handle end == -1 as well as end == pos.
+			if (pos >= end) {
+				fillBuf();
+			}
+			// Try to find LF in the buffered data and return the line if successful.
+			for (int i = pos; i != end; ++i) {
+				if (buf[i] == LF) {
+					int lineEnd = (i != pos && buf[i - 1] == CR) ? i - 1 : i;
+					String res = new String(buf, pos, lineEnd - pos, charset.name());
+					pos = i + 1;
+					return res;
+				}
+			}
+
+			// Let's anticipate up to 80 characters on top of those already read.
+			ByteArrayOutputStream out = new ByteArrayOutputStream(end - pos + 80) {
+				@Override
+				public String toString() {
+					int length = (count > 0 && buf[count - 1] == CR) ? count - 1 : count;
+					try {
+						return new String(buf, 0, length, charset.name());
+					} catch (UnsupportedEncodingException e) {
+						throw new AssertionError(e); // Since we control the charset this will never happen.
+					}
+				}
+			};
+
+			while (true) {
+				out.write(buf, pos, end - pos);
+				// Mark unterminated line in case fillBuf throws EOFException or IOException.
+				end = -1;
+				fillBuf();
+				// Try to find LF in the buffered data and return the line if successful.
+				for (int i = pos; i != end; ++i) {
+					if (buf[i] == LF) {
+						if (i != pos) {
+							out.write(buf, pos, i - pos);
+						}
+						pos = i + 1;
+						return out.toString();
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * Reads new input data into the buffer. Call only with pos == end or end == -1,
+	 * depending on the desired outcome if the function throws.
+	 */
+	private void fillBuf() throws IOException {
+		int result = in.read(buf, 0, buf.length);
+		if (result == -1) {
+			throw new EOFException();
+		}
+		pos = 0;
+		end = result;
+	}
+}
+

+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.nostra13.universalimageloader.cache.disc.impl.ext;
+
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringWriter;
+import java.nio.charset.Charset;
+
+/** Junk drawer of utility methods. */
+final class Util {
+	static final Charset US_ASCII = Charset.forName("US-ASCII");
+	static final Charset UTF_8 = Charset.forName("UTF-8");
+
+	private Util() {
+	}
+
+	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();
+		}
+	}
+
+	/**
+	 * Deletes the contents of {@code dir}. Throws an IOException if any file
+	 * could not be deleted, or if {@code dir} is not a readable directory.
+	 */
+	static void deleteContents(File dir) throws IOException {
+		File[] files = dir.listFiles();
+		if (files == null) {
+			throw new IOException("not a readable directory: " + dir);
+		}
+		for (File file : files) {
+			if (file.isDirectory()) {
+				deleteContents(file);
+			}
+			if (!file.delete()) {
+				throw new IOException("failed to delete file: " + file);
+			}
+		}
+	}
+
+	static void closeQuietly(/*Auto*/Closeable closeable) {
+		if (closeable != null) {
+			try {
+				closeable.close();
+			} catch (RuntimeException rethrown) {
+				throw rethrown;
+			} catch (Exception ignored) {
+			}
+		}
+	}
+}
\ No newline at end of file

+/*******************************************************************************
+ * Copyright 2011-2013 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.disc.naming;
+
+/**
+ * Generates names for files at disk cache
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.3.1
+ */
+public interface FileNameGenerator {
+
+	/** Generates unique file name for image defined by URI */
+	String generate(String imageUri);
+}

+/*******************************************************************************
+ * Copyright 2011-2013 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.disc.naming;
+
+/**
+ * Names image file as image URI {@linkplain String#hashCode() hashcode}
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.3.1
+ */
+public class HashCodeFileNameGenerator implements FileNameGenerator {
+	@Override
+	public String generate(String imageUri) {
+		return String.valueOf(imageUri.hashCode());
+	}
+}

+/*******************************************************************************
+ * Copyright 2011-2013 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.disc.naming;
+
+import com.nostra13.universalimageloader.utils.L;
+
+import java.math.BigInteger;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+/**
+ * Names image file as MD5 hash of image URI
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.4.0
+ */
+public class Md5FileNameGenerator implements FileNameGenerator {
+
+	private static final String HASH_ALGORITHM = "MD5";
+	private static final int RADIX = 10 + 26; // 10 digits + 26 letters
+
+	@Override
+	public String generate(String imageUri) {
+		byte[] md5 = getMD5(imageUri.getBytes());
+		BigInteger bi = new BigInteger(md5).abs();
+		return bi.toString(RADIX);
+	}
+
+	private byte[] getMD5(byte[] data) {
+		byte[] hash = null;
+		try {
+			MessageDigest digest = MessageDigest.getInstance(HASH_ALGORITHM);
+			digest.update(data);
+			hash = digest.digest();
+		} catch (NoSuchAlgorithmException e) {
+			L.e(e);
+		}
+		return hash;
+	}
+}

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.memory;
+
+import android.graphics.Bitmap;
+
+import java.lang.ref.Reference;
+import java.util.*;
+
+/**
+ * Base memory cache. Implements common functionality for memory cache. Provides object references (
+ * {@linkplain Reference not strong}) storing.
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.0.0
+ */
+public abstract class BaseMemoryCache implements MemoryCache {
+
+	/** Stores not strong references to objects */
+	private final Map<String, Reference<Bitmap>> softMap = Collections.synchronizedMap(new HashMap<String, Reference<Bitmap>>());
+
+	@Override
+	public Bitmap get(String key) {
+		Bitmap result = null;
+		Reference<Bitmap> reference = softMap.get(key);
+		if (reference != null) {
+			result = reference.get();
+		}
+		return result;
+	}
+
+	@Override
+	public boolean put(String key, Bitmap value) {
+		softMap.put(key, createReference(value));
+		return true;
+	}
+
+	@Override
+	public Bitmap remove(String key) {
+		Reference<Bitmap> bmpRef = softMap.remove(key);
+		return bmpRef == null ? null : bmpRef.get();
+	}
+
+	@Override
+	public Collection<String> keys() {
+		synchronized (softMap) {
+			return new HashSet<String>(softMap.keySet());
+		}
+	}
+
+	@Override
+	public void clear() {
+		softMap.clear();
+	}
+
+	/** Creates {@linkplain Reference not strong} reference of value */
+	protected abstract Reference<Bitmap> createReference(Bitmap value);
+}

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.memory;
+
+import android.graphics.Bitmap;
+
+import com.nostra13.universalimageloader.utils.L;
+
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Limited cache. Provides object storing. Size of all stored bitmaps will not to exceed size limit (
+ * {@link #getSizeLimit()}).<br />
+ * <br />
+ * <b>NOTE:</b> This cache uses strong and weak references for stored Bitmaps. Strong references - for limited count of
+ * Bitmaps (depends on cache size), weak references - for all other cached Bitmaps.
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @see BaseMemoryCache
+ * @since 1.0.0
+ */
+public abstract class LimitedMemoryCache extends BaseMemoryCache {
+
+	private static final int MAX_NORMAL_CACHE_SIZE_IN_MB = 16;
+	private static final int MAX_NORMAL_CACHE_SIZE = MAX_NORMAL_CACHE_SIZE_IN_MB * 1024 * 1024;
+
+	private final int sizeLimit;
+
+	private final AtomicInteger cacheSize;
+
+	/**
+	 * Contains strong references to stored objects. Each next object is added last. If hard cache size will exceed
+	 * limit then first object is deleted (but it continue exist at {@link #softMap} and can be collected by GC at any
+	 * time)
+	 */
+	private final List<Bitmap> hardCache = Collections.synchronizedList(new LinkedList<Bitmap>());
+
+	/** @param sizeLimit Maximum size for cache (in bytes) */
+	public LimitedMemoryCache(int sizeLimit) {
+		this.sizeLimit = sizeLimit;
+		cacheSize = new AtomicInteger();
+		if (sizeLimit > MAX_NORMAL_CACHE_SIZE) {
+			L.w("You set too large memory cache size (more than %1$d Mb)", MAX_NORMAL_CACHE_SIZE_IN_MB);
+		}
+	}
+
+	@Override
+	public boolean put(String key, Bitmap value) {
+		boolean putSuccessfully = false;
+		// Try to add value to hard cache
+		int valueSize = getSize(value);
+		int sizeLimit = getSizeLimit();
+		int curCacheSize = cacheSize.get();
+		if (valueSize < sizeLimit) {
+			while (curCacheSize + valueSize > sizeLimit) {
+				Bitmap removedValue = removeNext();
+				if (hardCache.remove(removedValue)) {
+					curCacheSize = cacheSize.addAndGet(-getSize(removedValue));
+				}
+			}
+			hardCache.add(value);
+			cacheSize.addAndGet(valueSize);
+
+			putSuccessfully = true;
+		}
+		// Add value to soft cache
+		super.put(key, value);
+		return putSuccessfully;
+	}
+
+	@Override
+	public Bitmap remove(String key) {
+		Bitmap value = super.get(key);
+		if (value != null) {
+			if (hardCache.remove(value)) {
+				cacheSize.addAndGet(-getSize(value));
+			}
+		}
+		return super.remove(key);
+	}
+
+	@Override
+	public void clear() {
+		hardCache.clear();
+		cacheSize.set(0);
+		super.clear();
+	}
+
+	protected int getSizeLimit() {
+		return sizeLimit;
+	}
+
+	protected abstract int getSize(Bitmap value);
+
+	protected abstract Bitmap removeNext();
+}

+/*******************************************************************************
+ * Copyright 2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.memory;
+
+import android.graphics.Bitmap;
+
+import java.util.Collection;
+
+/**
+ * Interface for memory cache
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.9.2
+ */
+public interface MemoryCache {
+	/**
+	 * Puts value into cache by key
+	 *
+	 * @return <b>true</b> - if value was put into cache successfully, <b>false</b> - if value was <b>not</b> put into
+	 * cache
+	 */
+	boolean put(String key, Bitmap value);
+
+	/** Returns value by key. If there is no value for key then null will be returned. */
+	Bitmap get(String key);
+
+	/** Removes item by key */
+	Bitmap remove(String key);
+
+	/** Returns all keys of cache */
+	Collection<String> keys();
+
+	/** Remove all items from cache */
+	void clear();
+}

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.memory.impl;
+
+import android.graphics.Bitmap;
+import com.nostra13.universalimageloader.cache.memory.LimitedMemoryCache;
+
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Limited {@link Bitmap bitmap} cache. Provides {@link Bitmap bitmaps} storing. Size of all stored bitmaps will not to
+ * exceed size limit. When cache reaches limit size then cache clearing is processed by FIFO principle.<br />
+ * <br />
+ * <b>NOTE:</b> This cache uses strong and weak references for stored Bitmaps. Strong references - for limited count of
+ * Bitmaps (depends on cache size), weak references - for all other cached Bitmaps.
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.0.0
+ */
+public class FIFOLimitedMemoryCache extends LimitedMemoryCache {
+
+	private final List<Bitmap> queue = Collections.synchronizedList(new LinkedList<Bitmap>());
+
+	public FIFOLimitedMemoryCache(int sizeLimit) {
+		super(sizeLimit);
+	}
+
+	@Override
+	public boolean put(String key, Bitmap value) {
+		if (super.put(key, value)) {
+			queue.add(value);
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	@Override
+	public Bitmap remove(String key) {
+		Bitmap value = super.get(key);
+		if (value != null) {
+			queue.remove(value);
+		}
+		return super.remove(key);
+	}
+
+	@Override
+	public void clear() {
+		queue.clear();
+		super.clear();
+	}
+
+	@Override
+	protected int getSize(Bitmap value) {
+		return value.getRowBytes() * value.getHeight();
+	}
+
+	@Override
+	protected Bitmap removeNext() {
+		return queue.remove(0);
+	}
+
+	@Override
+	protected Reference<Bitmap> createReference(Bitmap value) {
+		return new WeakReference<Bitmap>(value);
+	}
+}

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.memory.impl;
+
+import android.graphics.Bitmap;
+
+import com.nostra13.universalimageloader.cache.memory.MemoryCache;
+
+import java.util.Collection;
+import java.util.Comparator;
+
+/**
+ * Decorator for {@link MemoryCache}. Provides special feature for cache: some different keys are considered as
+ * equals (using {@link Comparator comparator}). And when you try to put some value into cache by key so entries with
+ * "equals" keys will be removed from cache before.<br />
+ * <b>NOTE:</b> Used for internal needs. Normally you don't need to use this class.
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.0.0
+ */
+public class FuzzyKeyMemoryCache implements MemoryCache {
+
+	private final MemoryCache cache;
+	private final Comparator<String> keyComparator;
+
+	public FuzzyKeyMemoryCache(MemoryCache cache, Comparator<String> keyComparator) {
+		this.cache = cache;
+		this.keyComparator = keyComparator;
+	}
+
+	@Override
+	public boolean put(String key, Bitmap value) {
+		// Search equal key and remove this entry
+		synchronized (cache) {
+			String keyToRemove = null;
+			for (String cacheKey : cache.keys()) {
+				if (keyComparator.compare(key, cacheKey) == 0) {
+					keyToRemove = cacheKey;
+					break;
+				}
+			}
+			if (keyToRemove != null) {
+				cache.remove(keyToRemove);
+			}
+		}
+		return cache.put(key, value);
+	}
+
+	@Override
+	public Bitmap get(String key) {
+		return cache.get(key);
+	}
+
+	@Override
+	public Bitmap remove(String key) {
+		return cache.remove(key);
+	}
+
+	@Override
+	public void clear() {
+		cache.clear();
+	}
+
+	@Override
+	public Collection<String> keys() {
+		return cache.keys();
+	}
+}

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.memory.impl;
+
+import android.graphics.Bitmap;
+import com.nostra13.universalimageloader.cache.memory.LimitedMemoryCache;
+
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+/**
+ * Limited {@link Bitmap bitmap} cache. Provides {@link Bitmap bitmaps} storing. Size of all stored bitmaps will not to
+ * exceed size limit. When cache reaches limit size then the least recently used bitmap is deleted from cache.<br />
+ * <br />
+ * <b>NOTE:</b> This cache uses strong and weak references for stored Bitmaps. Strong references - for limited count of
+ * Bitmaps (depends on cache size), weak references - for all other cached Bitmaps.
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.3.0
+ */
+public class LRULimitedMemoryCache extends LimitedMemoryCache {
+
+	private static final int INITIAL_CAPACITY = 10;
+	private static final float LOAD_FACTOR = 1.1f;
+
+	/** Cache providing Least-Recently-Used logic */
+	private final Map<String, Bitmap> lruCache = Collections.synchronizedMap(new LinkedHashMap<String, Bitmap>(INITIAL_CAPACITY, LOAD_FACTOR, true));
+
+	/** @param maxSize Maximum sum of the sizes of the Bitmaps in this cache */
+	public LRULimitedMemoryCache(int maxSize) {
+		super(maxSize);
+	}
+
+	@Override
+	public boolean put(String key, Bitmap value) {
+		if (super.put(key, value)) {
+			lruCache.put(key, value);
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	@Override
+	public Bitmap get(String key) {
+		lruCache.get(key); // call "get" for LRU logic
+		return super.get(key);
+	}
+
+	@Override
+	public Bitmap remove(String key) {
+		lruCache.remove(key);
+		return super.remove(key);
+	}
+
+	@Override
+	public void clear() {
+		lruCache.clear();
+		super.clear();
+	}
+
+	@Override
+	protected int getSize(Bitmap value) {
+		return value.getRowBytes() * value.getHeight();
+	}
+
+	@Override
+	protected Bitmap removeNext() {
+		Bitmap mostLongUsedValue = null;
+		synchronized (lruCache) {
+			Iterator<Entry<String, Bitmap>> it = lruCache.entrySet().iterator();
+			if (it.hasNext()) {
+				Entry<String, Bitmap> entry = it.next();
+				mostLongUsedValue = entry.getValue();
+				it.remove();
+			}
+		}
+		return mostLongUsedValue;
+	}
+
+	@Override
+	protected Reference<Bitmap> createReference(Bitmap value) {
+		return new WeakReference<Bitmap>(value);
+	}
+}

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.memory.impl;
+
+import android.graphics.Bitmap;
+import com.nostra13.universalimageloader.cache.memory.LimitedMemoryCache;
+
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+/**
+ * Limited {@link Bitmap bitmap} cache. Provides {@link Bitmap bitmaps} storing. Size of all stored bitmaps will not to
+ * exceed size limit. When cache reaches limit size then the bitmap which has the largest size is deleted from
+ * cache.<br />
+ * <br />
+ * <b>NOTE:</b> This cache uses strong and weak references for stored Bitmaps. Strong references - for limited count of
+ * Bitmaps (depends on cache size), weak references - for all other cached Bitmaps.
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.0.0
+ */
+public class LargestLimitedMemoryCache extends LimitedMemoryCache {
+	/**
+	 * Contains strong references to stored objects (keys) and sizes of the objects. If hard cache
+	 * size will exceed limit then object with the largest size is deleted (but it continue exist at
+	 * {@link #softMap} and can be collected by GC at any time)
+	 */
+	private final Map<Bitmap, Integer> valueSizes = Collections.synchronizedMap(new HashMap<Bitmap, Integer>());
+
+	public LargestLimitedMemoryCache(int sizeLimit) {
+		super(sizeLimit);
+	}
+
+	@Override
+	public boolean put(String key, Bitmap value) {
+		if (super.put(key, value)) {
+			valueSizes.put(value, getSize(value));
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	@Override
+	public Bitmap remove(String key) {
+		Bitmap value = super.get(key);
+		if (value != null) {
+			valueSizes.remove(value);
+		}
+		return super.remove(key);
+	}
+
+	@Override
+	public void clear() {
+		valueSizes.clear();
+		super.clear();
+	}
+
+	@Override
+	protected int getSize(Bitmap value) {
+		return value.getRowBytes() * value.getHeight();
+	}
+
+	@Override
+	protected Bitmap removeNext() {
+		Integer maxSize = null;
+		Bitmap largestValue = null;
+		Set<Entry<Bitmap, Integer>> entries = valueSizes.entrySet();
+		synchronized (valueSizes) {
+			for (Entry<Bitmap, Integer> entry : entries) {
+				if (largestValue == null) {
+					largestValue = entry.getKey();
+					maxSize = entry.getValue();
+				} else {
+					Integer size = entry.getValue();
+					if (size > maxSize) {
+						maxSize = size;
+						largestValue = entry.getKey();
+					}
+				}
+			}
+		}
+		valueSizes.remove(largestValue);
+		return largestValue;
+	}
+
+	@Override
+	protected Reference<Bitmap> createReference(Bitmap value) {
+		return new WeakReference<Bitmap>(value);
+	}
+}

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.memory.impl;
+
+import android.graphics.Bitmap;
+
+import com.nostra13.universalimageloader.cache.memory.MemoryCache;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Decorator for {@link MemoryCache}. Provides special feature for cache: if some cached object age exceeds defined
+ * value then this object will be removed from cache.
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @see MemoryCache
+ * @since 1.3.1
+ */
+public class LimitedAgeMemoryCache implements MemoryCache {
+
+	private final MemoryCache cache;
+
+	private final long maxAge;
+	private final Map<String, Long> loadingDates = Collections.synchronizedMap(new HashMap<String, Long>());
+
+	/**
+	 * @param cache  Wrapped memory cache
+	 * @param maxAge Max object age <b>(in seconds)</b>. If object age will exceed this value then it'll be removed from
+	 *               cache on next treatment (and therefore be reloaded).
+	 */
+	public LimitedAgeMemoryCache(MemoryCache cache, long maxAge) {
+		this.cache = cache;
+		this.maxAge = maxAge * 1000; // to milliseconds
+	}
+
+	@Override
+	public boolean put(String key, Bitmap value) {
+		boolean putSuccesfully = cache.put(key, value);
+		if (putSuccesfully) {
+			loadingDates.put(key, System.currentTimeMillis());
+		}
+		return putSuccesfully;
+	}
+
+	@Override
+	public Bitmap get(String key) {
+		Long loadingDate = loadingDates.get(key);
+		if (loadingDate != null && System.currentTimeMillis() - loadingDate > maxAge) {
+			cache.remove(key);
+			loadingDates.remove(key);
+		}
+
+		return cache.get(key);
+	}
+
+	@Override
+	public Bitmap remove(String key) {
+		loadingDates.remove(key);
+		return cache.remove(key);
+	}
+
+	@Override
+	public Collection<String> keys() {
+		return cache.keys();
+	}
+
+	@Override
+	public void clear() {
+		cache.clear();
+		loadingDates.clear();
+	}
+}

+package com.nostra13.universalimageloader.cache.memory.impl;
+
+import android.graphics.Bitmap;
+
+import com.nostra13.universalimageloader.cache.memory.MemoryCache;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * A cache that holds strong references to a limited number of Bitmaps. Each time a Bitmap is accessed, it is moved to
+ * the head of a queue. When a Bitmap is added to a full cache, the Bitmap at the end of that queue is evicted and may
+ * become eligible for garbage collection.<br />
+ * <br />
+ * <b>NOTE:</b> This cache uses only strong references for stored Bitmaps.
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.8.1
+ */
+public class LruMemoryCache implements MemoryCache {
+
+	private final LinkedHashMap<String, Bitmap> map;
+
+	private final int maxSize;
+	/** Size of this cache in bytes */
+	private int size;
+
+	/** @param maxSize Maximum sum of the sizes of the Bitmaps in this cache */
+	public LruMemoryCache(int maxSize) {
+		if (maxSize <= 0) {
+			throw new IllegalArgumentException("maxSize <= 0");
+		}
+		this.maxSize = maxSize;
+		this.map = new LinkedHashMap<String, Bitmap>(0, 0.75f, true);
+	}
+
+	/**
+	 * Returns the Bitmap for {@code key} if it exists in the cache. If a Bitmap was returned, it is moved to the head
+	 * of the queue. This returns null if a Bitmap is not cached.
+	 */
+	@Override
+	public final Bitmap get(String key) {
+		if (key == null) {
+			throw new NullPointerException("key == null");
+		}
+
+		synchronized (this) {
+			return map.get(key);
+		}
+	}
+
+	/** Caches {@code Bitmap} for {@code key}. The Bitmap is moved to the head of the queue. */
+	@Override
+	public final boolean put(String key, Bitmap value) {
+		if (key == null || value == null) {
+			throw new NullPointerException("key == null || value == null");
+		}
+
+		synchronized (this) {
+			size += sizeOf(key, value);
+			Bitmap previous = map.put(key, value);
+			if (previous != null) {
+				size -= sizeOf(key, previous);
+			}
+		}
+
+		trimToSize(maxSize);
+		return true;
+	}
+
+	/**
+	 * Remove the eldest entries until the total of remaining entries is at or below the requested size.
+	 *
+	 * @param maxSize the maximum size of the cache before returning. May be -1 to evict even 0-sized elements.
+	 */
+	private void trimToSize(int maxSize) {
+		while (true) {
+			String key;
+			Bitmap value;
+			synchronized (this) {
+				if (size < 0 || (map.isEmpty() && size != 0)) {
+					throw new IllegalStateException(getClass().getName() + ".sizeOf() is reporting inconsistent results!");
+				}
+
+				if (size <= maxSize || map.isEmpty()) {
+					break;
+				}
+
+				Map.Entry<String, Bitmap> toEvict = map.entrySet().iterator().next();
+				if (toEvict == null) {
+					break;
+				}
+				key = toEvict.getKey();
+				value = toEvict.getValue();
+				map.remove(key);
+				size -= sizeOf(key, value);
+			}
+		}
+	}
+
+	/** Removes the entry for {@code key} if it exists. */
+	@Override
+	public final Bitmap remove(String key) {
+		if (key == null) {
+			throw new NullPointerException("key == null");
+		}
+
+		synchronized (this) {
+			Bitmap previous = map.remove(key);
+			if (previous != null) {
+				size -= sizeOf(key, previous);
+			}
+			return previous;
+		}
+	}
+
+	@Override
+	public Collection<String> keys() {
+		synchronized (this) {
+			return new HashSet<String>(map.keySet());
+		}
+	}
+
+	@Override
+	public void clear() {
+		trimToSize(-1); // -1 will evict 0-sized elements
+	}
+
+	/**
+	 * Returns the size {@code Bitmap} in bytes.
+	 * <p/>
+	 * An entry's size must not change while it is in the cache.
+	 */
+	private int sizeOf(String key, Bitmap value) {
+		return value.getRowBytes() * value.getHeight();
+	}
+
+	@Override
+	public synchronized final String toString() {
+		return String.format("LruCache[maxSize=%d]", maxSize);
+	}
+}
\ No newline at end of file

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.memory.impl;
+
+import android.graphics.Bitmap;
+import com.nostra13.universalimageloader.cache.memory.LimitedMemoryCache;
+
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+/**
+ * Limited {@link Bitmap bitmap} cache. Provides {@link Bitmap bitmaps} storing. Size of all stored bitmaps will not to
+ * exceed size limit. When cache reaches limit size then the bitmap which used the least frequently is deleted from
+ * cache.<br />
+ * <br />
+ * <b>NOTE:</b> This cache uses strong and weak references for stored Bitmaps. Strong references - for limited count of
+ * Bitmaps (depends on cache size), weak references - for all other cached Bitmaps.
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.0.0
+ */
+public class UsingFreqLimitedMemoryCache extends LimitedMemoryCache {
+	/**
+	 * Contains strong references to stored objects (keys) and last object usage date (in milliseconds). If hard cache
+	 * size will exceed limit then object with the least frequently usage is deleted (but it continue exist at
+	 * {@link #softMap} and can be collected by GC at any time)
+	 */
+	private final Map<Bitmap, Integer> usingCounts = Collections.synchronizedMap(new HashMap<Bitmap, Integer>());
+
+	public UsingFreqLimitedMemoryCache(int sizeLimit) {
+		super(sizeLimit);
+	}
+
+	@Override
+	public boolean put(String key, Bitmap value) {
+		if (super.put(key, value)) {
+			usingCounts.put(value, 0);
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	@Override
+	public Bitmap get(String key) {
+		Bitmap value = super.get(key);
+		// Increment usage count for value if value is contained in hardCahe
+		if (value != null) {
+			Integer usageCount = usingCounts.get(value);
+			if (usageCount != null) {
+				usingCounts.put(value, usageCount + 1);
+			}
+		}
+		return value;
+	}
+
+	@Override
+	public Bitmap remove(String key) {
+		Bitmap value = super.get(key);
+		if (value != null) {
+			usingCounts.remove(value);
+		}
+		return super.remove(key);
+	}
+
+	@Override
+	public void clear() {
+		usingCounts.clear();
+		super.clear();
+	}
+
+	@Override
+	protected int getSize(Bitmap value) {
+		return value.getRowBytes() * value.getHeight();
+	}
+
+	@Override
+	protected Bitmap removeNext() {
+		Integer minUsageCount = null;
+		Bitmap leastUsedValue = null;
+		Set<Entry<Bitmap, Integer>> entries = usingCounts.entrySet();
+		synchronized (usingCounts) {
+			for (Entry<Bitmap, Integer> entry : entries) {
+				if (leastUsedValue == null) {
+					leastUsedValue = entry.getKey();
+					minUsageCount = entry.getValue();
+				} else {
+					Integer lastValueUsage = entry.getValue();
+					if (lastValueUsage < minUsageCount) {
+						minUsageCount = lastValueUsage;
+						leastUsedValue = entry.getKey();
+					}
+				}
+			}
+		}
+		usingCounts.remove(leastUsedValue);
+		return leastUsedValue;
+	}
+
+	@Override
+	protected Reference<Bitmap> createReference(Bitmap value) {
+		return new WeakReference<Bitmap>(value);
+	}
+}

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.cache.memory.impl;
+
+import android.graphics.Bitmap;
+import com.nostra13.universalimageloader.cache.memory.BaseMemoryCache;
+
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+
+/**
+ * Memory cache with {@linkplain WeakReference weak references} to {@linkplain Bitmap bitmaps}<br />
+ * <br />
+ * <b>NOTE:</b> This cache uses only weak references for stored Bitmaps.
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.5.3
+ */
+public class WeakMemoryCache extends BaseMemoryCache {
+	@Override
+	protected Reference<Bitmap> createReference(Bitmap value) {
+		return new WeakReference<Bitmap>(value);
+	}
+}

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.core;
+
+import android.annotation.TargetApi;
+import android.app.ActivityManager;
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.os.Build;
+import com.nostra13.universalimageloader.cache.disc.DiskCache;
+import com.nostra13.universalimageloader.cache.disc.impl.UnlimitedDiskCache;
+import com.nostra13.universalimageloader.cache.disc.impl.ext.LruDiskCache;
+import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator;
+import com.nostra13.universalimageloader.cache.disc.naming.HashCodeFileNameGenerator;
+import com.nostra13.universalimageloader.cache.memory.MemoryCache;
+import com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache;
+import com.nostra13.universalimageloader.core.assist.QueueProcessingType;
+import com.nostra13.universalimageloader.core.assist.deque.LIFOLinkedBlockingDeque;
+import com.nostra13.universalimageloader.core.decode.BaseImageDecoder;
+import com.nostra13.universalimageloader.core.decode.ImageDecoder;
+import com.nostra13.universalimageloader.core.display.BitmapDisplayer;
+import com.nostra13.universalimageloader.core.display.SimpleBitmapDisplayer;
+import com.nostra13.universalimageloader.core.download.BaseImageDownloader;
+import com.nostra13.universalimageloader.core.download.ImageDownloader;
+import com.nostra13.universalimageloader.utils.L;
+import com.nostra13.universalimageloader.utils.StorageUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Factory for providing of default options for {@linkplain ImageLoaderConfiguration configuration}
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.5.6
+ */
+public class DefaultConfigurationFactory {
+
+	/** Creates default implementation of task executor */
+	public static Executor createExecutor(int threadPoolSize, int threadPriority,
+			QueueProcessingType tasksProcessingType) {
+		boolean lifo = tasksProcessingType == QueueProcessingType.LIFO;
+		BlockingQueue<Runnable> taskQueue =
+				lifo ? new LIFOLinkedBlockingDeque<Runnable>() : new LinkedBlockingQueue<Runnable>();
+		return new ThreadPoolExecutor(threadPoolSize, threadPoolSize, 0L, TimeUnit.MILLISECONDS, taskQueue,
+				createThreadFactory(threadPriority, "uil-pool-"));
+	}
+
+	/** Creates default implementation of task distributor */
+	public static Executor createTaskDistributor() {
+		return Executors.newCachedThreadPool(createThreadFactory(Thread.NORM_PRIORITY, "uil-pool-d-"));
+	}
+
+	/** Creates {@linkplain HashCodeFileNameGenerator default implementation} of FileNameGenerator */
+	public static FileNameGenerator createFileNameGenerator() {
+		return new HashCodeFileNameGenerator();
+	}
+
+	/**
+	 * Creates default implementation of {@link DiskCache} depends on incoming parameters
+	 */
+	public static DiskCache createDiskCache(Context context, FileNameGenerator diskCacheFileNameGenerator,
+			long diskCacheSize, int diskCacheFileCount) {
+		File reserveCacheDir = createReserveDiskCacheDir(context);
+		if (diskCacheSize > 0 || diskCacheFileCount > 0) {
+			File individualCacheDir = StorageUtils.getIndividualCacheDirectory(context);
+			try {
+				return new LruDiskCache(individualCacheDir, reserveCacheDir, diskCacheFileNameGenerator, diskCacheSize,
+						diskCacheFileCount);
+			} catch (IOException e) {
+				L.e(e);
+				// continue and create unlimited cache
+			}
+		}
+		File cacheDir = StorageUtils.getCacheDirectory(context);
+		return new UnlimitedDiskCache(cacheDir, reserveCacheDir, diskCacheFileNameGenerator);
+	}
+
+	/** Creates reserve disk cache folder which will be used if primary disk cache folder becomes unavailable */
+	private static File createReserveDiskCacheDir(Context context) {
+		File cacheDir = StorageUtils.getCacheDirectory(context, false);
+		File individualDir = new File(cacheDir, "uil-images");
+		if (individualDir.exists() || individualDir.mkdir()) {
+			cacheDir = individualDir;
+		}
+		return cacheDir;
+	}
+
+	/**
+	 * Creates default implementation of {@link MemoryCache} - {@link LruMemoryCache}<br />
+	 * Default cache size = 1/8 of available app memory.
+	 */
+	public static MemoryCache createMemoryCache(Context context, int memoryCacheSize) {
+		if (memoryCacheSize == 0) {
+			ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
+			int memoryClass = am.getMemoryClass();
+			if (hasHoneycomb() && isLargeHeap(context)) {
+				memoryClass = getLargeMemoryClass(am);
+			}
+			memoryCacheSize = 1024 * 1024 * memoryClass / 8;
+		}
+		return new LruMemoryCache(memoryCacheSize);
+	}
+
+	private static boolean hasHoneycomb() {
+		return Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB;
+	}
+
+	@TargetApi(Build.VERSION_CODES.HONEYCOMB)
+	private static boolean isLargeHeap(Context context) {
+		return (context.getApplicationInfo().flags & ApplicationInfo.FLAG_LARGE_HEAP) != 0;
+	}
+
+	@TargetApi(Build.VERSION_CODES.HONEYCOMB)
+	private static int getLargeMemoryClass(ActivityManager am) {
+		return am.getLargeMemoryClass();
+	}
+
+	/** Creates default implementation of {@link ImageDownloader} - {@link BaseImageDownloader} */
+	public static ImageDownloader createImageDownloader(Context context) {
+		return new BaseImageDownloader(context);
+	}
+
+	/** Creates default implementation of {@link ImageDecoder} - {@link BaseImageDecoder} */
+	public static ImageDecoder createImageDecoder(boolean loggingEnabled) {
+		return new BaseImageDecoder(loggingEnabled);
+	}
+
+	/** Creates default implementation of {@link BitmapDisplayer} - {@link SimpleBitmapDisplayer} */
+	public static BitmapDisplayer createBitmapDisplayer() {
+		return new SimpleBitmapDisplayer();
+	}
+
+	/** Creates default implementation of {@linkplain ThreadFactory thread factory} for task executor */
+	private static ThreadFactory createThreadFactory(int threadPriority, String threadNamePrefix) {
+		return new DefaultThreadFactory(threadPriority, threadNamePrefix);
+	}
+
+	private static class DefaultThreadFactory implements ThreadFactory {
+
+		private static final AtomicInteger poolNumber = new AtomicInteger(1);
+
+		private final ThreadGroup group;
+		private final AtomicInteger threadNumber = new AtomicInteger(1);
+		private final String namePrefix;
+		private final int threadPriority;
+
+		DefaultThreadFactory(int threadPriority, String threadNamePrefix) {
+			this.threadPriority = threadPriority;
+			group = Thread.currentThread().getThreadGroup();
+			namePrefix = threadNamePrefix + poolNumber.getAndIncrement() + "-thread-";
+		}
+
+		@Override
+		public Thread newThread(Runnable r) {
+			Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
+			if (t.isDaemon()) t.setDaemon(false);
+			t.setPriority(threadPriority);
+			return t;
+		}
+	}
+}

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.core;
+
+import android.graphics.Bitmap;
+import com.nostra13.universalimageloader.core.assist.LoadedFrom;
+import com.nostra13.universalimageloader.core.display.BitmapDisplayer;
+import com.nostra13.universalimageloader.core.imageaware.ImageAware;
+import com.nostra13.universalimageloader.core.listener.ImageLoadingListener;
+import com.nostra13.universalimageloader.utils.L;
+
+/**
+ * Displays bitmap in {@link ImageAware}. Must be called on UI thread.
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @see ImageLoadingListener
+ * @see BitmapDisplayer
+ * @since 1.3.1
+ */
+final class DisplayBitmapTask implements Runnable {
+
+	private static final String LOG_DISPLAY_IMAGE_IN_IMAGEAWARE = "Display image in ImageAware (loaded from %1$s) [%2$s]";
+	private static final String LOG_TASK_CANCELLED_IMAGEAWARE_REUSED = "ImageAware is reused for another image. Task is cancelled. [%s]";
+	private static final String LOG_TASK_CANCELLED_IMAGEAWARE_COLLECTED = "ImageAware was collected by GC. Task is cancelled. [%s]";
+
+	private final Bitmap bitmap;
+	private final String imageUri;
+	private final ImageAware imageAware;
+	private final String memoryCacheKey;
+	private final BitmapDisplayer displayer;
+	private final ImageLoadingListener listener;
+	private final ImageLoaderEngine engine;
+	private final LoadedFrom loadedFrom;
+
+	public DisplayBitmapTask(Bitmap bitmap, ImageLoadingInfo imageLoadingInfo, ImageLoaderEngine engine,
+			LoadedFrom loadedFrom) {
+		this.bitmap = bitmap;
+		imageUri = imageLoadingInfo.uri;
+		imageAware = imageLoadingInfo.imageAware;
+		memoryCacheKey = imageLoadingInfo.memoryCacheKey;
+		displayer = imageLoadingInfo.options.getDisplayer();
+		listener = imageLoadingInfo.listener;
+		this.engine = engine;
+		this.loadedFrom = loadedFrom;
+	}
+
+	@Override
+	public void run() {
+		if (imageAware.isCollected()) {
+			L.d(LOG_TASK_CANCELLED_IMAGEAWARE_COLLECTED, memoryCacheKey);
+			listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());
+		} else if (isViewWasReused()) {
+			L.d(LOG_TASK_CANCELLED_IMAGEAWARE_REUSED, memoryCacheKey);
+			listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());
+		} else {
+			L.d(LOG_DISPLAY_IMAGE_IN_IMAGEAWARE, loadedFrom, memoryCacheKey);
+			displayer.display(bitmap, imageAware, loadedFrom);
+			engine.cancelDisplayTaskFor(imageAware);
+			listener.onLoadingComplete(imageUri, imageAware.getWrappedView(), bitmap);
+		}
+	}
+
+	/** Checks whether memory cache key (image URI) for current ImageAware is actual */
+	private boolean isViewWasReused() {
+		String currentCacheKey = engine.getLoadingUriForView(imageAware);
+		return !memoryCacheKey.equals(currentCacheKey);
+	}
+}

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.core;
+
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory.Options;
+import android.graphics.drawable.Drawable;
+import android.os.Handler;
+import com.nostra13.universalimageloader.core.listener.ImageLoadingListener;
+import com.nostra13.universalimageloader.core.assist.ImageScaleType;
+import com.nostra13.universalimageloader.core.display.BitmapDisplayer;
+import com.nostra13.universalimageloader.core.display.SimpleBitmapDisplayer;
+import com.nostra13.universalimageloader.core.download.ImageDownloader;
+import com.nostra13.universalimageloader.core.process.BitmapProcessor;
+
+/**
+ * Contains options for image display. Defines:
+ * <ul>
+ * <li>whether stub image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware
+ * image aware view} during image loading</li>
+ * <li>whether stub image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware
+ * image aware view} if empty URI is passed</li>
+ * <li>whether stub image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware
+ * image aware view} if image loading fails</li>
+ * <li>whether {@link com.nostra13.universalimageloader.core.imageaware.ImageAware image aware view} should be reset
+ * before image loading start</li>
+ * <li>whether loaded image will be cached in memory</li>
+ * <li>whether loaded image will be cached on disk</li>
+ * <li>image scale type</li>
+ * <li>decoding options (including bitmap decoding configuration)</li>
+ * <li>delay before loading of image</li>
+ * <li>whether consider EXIF parameters of image</li>
+ * <li>auxiliary object which will be passed to {@link ImageDownloader#getStream(String, Object) ImageDownloader}</li>
+ * <li>pre-processor for image Bitmap (before caching in memory)</li>
+ * <li>post-processor for image Bitmap (after caching in memory, before displaying)</li>
+ * <li>how decoded {@link Bitmap} will be displayed</li>
+ * </ul>
+ * <p/>
+ * You can create instance:
+ * <ul>
+ * <li>with {@link Builder}:<br />
+ * <b>i.e.</b> :
+ * <code>new {@link DisplayImageOptions}.{@link Builder#Builder() Builder()}.{@link Builder#cacheInMemory() cacheInMemory()}.
+ * {@link Builder#showImageOnLoading(int) showImageOnLoading()}.{@link Builder#build() build()}</code><br />
+ * </li>
+ * <li>or by static method: {@link #createSimple()}</li> <br />
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.0.0
+ */
+public final class DisplayImageOptions {
+
+	private final int imageResOnLoading;
+	private final int imageResForEmptyUri;
+	private final int imageResOnFail;
+	private final Drawable imageOnLoading;
+	private final Drawable imageForEmptyUri;
+	private final Drawable imageOnFail;
+	private final boolean resetViewBeforeLoading;
+	private final boolean cacheInMemory;
+	private final boolean cacheOnDisk;
+	private final ImageScaleType imageScaleType;
+	private final Options decodingOptions;
+	private final int delayBeforeLoading;
+	private final boolean considerExifParams;
+	private final Object extraForDownloader;
+	private final BitmapProcessor preProcessor;
+	private final BitmapProcessor postProcessor;
+	private final BitmapDisplayer displayer;
+	private final Handler handler;
+	private final boolean isSyncLoading;
+
+	private DisplayImageOptions(Builder builder) {
+		imageResOnLoading = builder.imageResOnLoading;
+		imageResForEmptyUri = builder.imageResForEmptyUri;
+		imageResOnFail = builder.imageResOnFail;
+		imageOnLoading = builder.imageOnLoading;
+		imageForEmptyUri = builder.imageForEmptyUri;
+		imageOnFail = builder.imageOnFail;
+		resetViewBeforeLoading = builder.resetViewBeforeLoading;
+		cacheInMemory = builder.cacheInMemory;
+		cacheOnDisk = builder.cacheOnDisk;
+		imageScaleType = builder.imageScaleType;
+		decodingOptions = builder.decodingOptions;
+		delayBeforeLoading = builder.delayBeforeLoading;
+		considerExifParams = builder.considerExifParams;
+		extraForDownloader = builder.extraForDownloader;
+		preProcessor = builder.preProcessor;
+		postProcessor = builder.postProcessor;
+		displayer = builder.displayer;
+		handler = builder.handler;
+		isSyncLoading = builder.isSyncLoading;
+	}
+
+	public boolean shouldShowImageOnLoading() {
+		return imageOnLoading != null || imageResOnLoading != 0;
+	}
+
+	public boolean shouldShowImageForEmptyUri() {
+		return imageForEmptyUri != null || imageResForEmptyUri != 0;
+	}
+
+	public boolean shouldShowImageOnFail() {
+		return imageOnFail != null || imageResOnFail != 0;
+	}
+
+	public boolean shouldPreProcess() {
+		return preProcessor != null;
+	}
+
+	public boolean shouldPostProcess() {
+		return postProcessor != null;
+	}
+
+	public boolean shouldDelayBeforeLoading() {
+		return delayBeforeLoading > 0;
+	}
+
+	public Drawable getImageOnLoading(Resources res) {
+		return imageResOnLoading != 0 ? res.getDrawable(imageResOnLoading) : imageOnLoading;
+	}
+
+	public Drawable getImageForEmptyUri(Resources res) {
+		return imageResForEmptyUri != 0 ? res.getDrawable(imageResForEmptyUri) : imageForEmptyUri;
+	}
+
+	public Drawable getImageOnFail(Resources res) {
+		return imageResOnFail != 0 ? res.getDrawable(imageResOnFail) : imageOnFail;
+	}
+
+	public boolean isResetViewBeforeLoading() {
+		return resetViewBeforeLoading;
+	}
+
+	public boolean isCacheInMemory() {
+		return cacheInMemory;
+	}
+
+	public boolean isCacheOnDisk() {
+		return cacheOnDisk;
+	}
+
+	public ImageScaleType getImageScaleType() {
+		return imageScaleType;
+	}
+
+	public Options getDecodingOptions() {
+		return decodingOptions;
+	}
+
+	public int getDelayBeforeLoading() {
+		return delayBeforeLoading;
+	}
+
+	public boolean isConsiderExifParams() {
+		return considerExifParams;
+	}
+
+	public Object getExtraForDownloader() {
+		return extraForDownloader;
+	}
+
+	public BitmapProcessor getPreProcessor() {
+		return preProcessor;
+	}
+
+	public BitmapProcessor getPostProcessor() {
+		return postProcessor;
+	}
+
+	public BitmapDisplayer getDisplayer() {
+		return displayer;
+	}
+
+	public Handler getHandler() {
+		return handler;
+	}
+
+	boolean isSyncLoading() {
+		return isSyncLoading;
+	}
+
+	/**
+	 * Builder for {@link DisplayImageOptions}
+	 *
+	 * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+	 */
+	public static class Builder {
+		private int imageResOnLoading = 0;
+		private int imageResForEmptyUri = 0;
+		private int imageResOnFail = 0;
+		private Drawable imageOnLoading = null;
+		private Drawable imageForEmptyUri = null;
+		private Drawable imageOnFail = null;
+		private boolean resetViewBeforeLoading = false;
+		private boolean cacheInMemory = false;
+		private boolean cacheOnDisk = false;
+		private ImageScaleType imageScaleType = ImageScaleType.IN_SAMPLE_POWER_OF_2;
+		private Options decodingOptions = new Options();
+		private int delayBeforeLoading = 0;
+		private boolean considerExifParams = false;
+		private Object extraForDownloader = null;
+		private BitmapProcessor preProcessor = null;
+		private BitmapProcessor postProcessor = null;
+		private BitmapDisplayer displayer = DefaultConfigurationFactory.createBitmapDisplayer();
+		private Handler handler = null;
+		private boolean isSyncLoading = false;
+
+		public Builder() {
+			decodingOptions.inPurgeable = true;
+			decodingOptions.inInputShareable = true;
+		}
+
+		/**
+		 * Stub image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware
+		 * image aware view} during image loading
+		 *
+		 * @param imageRes Stub image resource
+		 * @deprecated Use {@link #showImageOnLoading(int)} instead
+		 */
+		@Deprecated
+		public Builder showStubImage(int imageRes) {
+			imageResOnLoading = imageRes;
+			return this;
+		}
+
+		/**
+		 * Incoming image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware
+		 * image aware view} during image loading
+		 *
+		 * @param imageRes Image resource
+		 */
+		public Builder showImageOnLoading(int imageRes) {
+			imageResOnLoading = imageRes;
+			return this;
+		}
+
+		/**
+		 * Incoming drawable will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware
+		 * image aware view} during image loading.
+		 * This option will be ignored if {@link Builder#showImageOnLoading(int)} is set.
+		 */
+		public Builder showImageOnLoading(Drawable drawable) {
+			imageOnLoading = drawable;
+			return this;
+		}
+
+		/**
+		 * Incoming image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware
+		 * image aware view} if empty URI (null or empty
+		 * string) will be passed to <b>ImageLoader.displayImage(...)</b> method.
+		 *
+		 * @param imageRes Image resource
+		 */
+		public Builder showImageForEmptyUri(int imageRes) {
+			imageResForEmptyUri = imageRes;
+			return this;
+		}
+
+		/**
+		 * Incoming drawable will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware
+		 * image aware view} if empty URI (null or empty
+		 * string) will be passed to <b>ImageLoader.displayImage(...)</b> method.
+		 * This option will be ignored if {@link Builder#showImageForEmptyUri(int)} is set.
+		 */
+		public Builder showImageForEmptyUri(Drawable drawable) {
+			imageForEmptyUri = drawable;
+			return this;
+		}
+
+		/**
+		 * Incoming image will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware
+		 * image aware view} if some error occurs during
+		 * requested image loading/decoding.
+		 *
+		 * @param imageRes Image resource
+		 */
+		public Builder showImageOnFail(int imageRes) {
+			imageResOnFail = imageRes;
+			return this;
+		}
+
+		/**
+		 * Incoming drawable will be displayed in {@link com.nostra13.universalimageloader.core.imageaware.ImageAware
+		 * image aware view} if some error occurs during
+		 * requested image loading/decoding.
+		 * This option will be ignored if {@link Builder#showImageOnFail(int)} is set.
+		 */
+		public Builder showImageOnFail(Drawable drawable) {
+			imageOnFail = drawable;
+			return this;
+		}
+
+		/**
+		 * {@link com.nostra13.universalimageloader.core.imageaware.ImageAware
+		 * image aware view} will be reset (set <b>null</b>) before image loading start
+		 *
+		 * @deprecated Use {@link #resetViewBeforeLoading(boolean) resetViewBeforeLoading(true)} instead
+		 */
+		public Builder resetViewBeforeLoading() {
+			resetViewBeforeLoading = true;
+			return this;
+		}
+
+		/**
+		 * Sets whether {@link com.nostra13.universalimageloader.core.imageaware.ImageAware
+		 * image aware view} will be reset (set <b>null</b>) before image loading start
+		 */
+		public Builder resetViewBeforeLoading(boolean resetViewBeforeLoading) {
+			this.resetViewBeforeLoading = resetViewBeforeLoading;
+			return this;
+		}
+
+		/**
+		 * Loaded image will be cached in memory
+		 *
+		 * @deprecated Use {@link #cacheInMemory(boolean) cacheInMemory(true)} instead
+		 */
+		@Deprecated
+		public Builder cacheInMemory() {
+			cacheInMemory = true;
+			return this;
+		}
+
+		/** Sets whether loaded image will be cached in memory */
+		public Builder cacheInMemory(boolean cacheInMemory) {
+			this.cacheInMemory = cacheInMemory;
+			return this;
+		}
+
+		/**
+		 * Loaded image will be cached on disk
+		 *
+		 * @deprecated Use {@link #cacheOnDisk(boolean) cacheOnDisk(true)} instead
+		 */
+		@Deprecated
+		public Builder cacheOnDisc() {
+			return cacheOnDisk(true);
+		}
+
+		/**
+		 * Sets whether loaded image will be cached on disk
+		 *
+		 * @deprecated Use {@link #cacheOnDisk(boolean)} instead
+		 */
+		@Deprecated
+		public Builder cacheOnDisc(boolean cacheOnDisk) {
+			return cacheOnDisk(cacheOnDisk);
+		}
+
+		/** Sets whether loaded image will be cached on disk */
+		public Builder cacheOnDisk(boolean cacheOnDisk) {
+			this.cacheOnDisk = cacheOnDisk;
+			return this;
+		}
+
+		/**
+		 * Sets {@linkplain ImageScaleType scale type} for decoding image. This parameter is used while define scale
+		 * size for decoding image to Bitmap. Default value - {@link ImageScaleType#IN_SAMPLE_POWER_OF_2}
+		 */
+		public Builder imageScaleType(ImageScaleType imageScaleType) {
+			this.imageScaleType = imageScaleType;
+			return this;
+		}
+
+		/** Sets {@link Bitmap.Config bitmap config} for image decoding. Default value - {@link Bitmap.Config#ARGB_8888} */
+		public Builder bitmapConfig(Bitmap.Config bitmapConfig) {
+			if (bitmapConfig == null) throw new IllegalArgumentException("bitmapConfig can't be null");
+			decodingOptions.inPreferredConfig = bitmapConfig;
+			return this;
+		}
+
+		/**
+		 * Sets options for image decoding.<br />
+		 * <b>NOTE:</b> {@link Options#inSampleSize} of incoming options will <b>NOT</b> be considered. Library
+		 * calculate the most appropriate sample size itself according yo {@link #imageScaleType(ImageScaleType)}
+		 * options.<br />
+		 * <b>NOTE:</b> This option overlaps {@link #bitmapConfig(Bitmap.Config) bitmapConfig()}
+		 * option.
+		 */
+		public Builder decodingOptions(Options decodingOptions) {
+			if (decodingOptions == null) throw new IllegalArgumentException("decodingOptions can't be null");
+			this.decodingOptions = decodingOptions;
+			return this;
+		}
+
+		/** Sets delay time before starting loading task. Default - no delay. */
+		public Builder delayBeforeLoading(int delayInMillis) {
+			this.delayBeforeLoading = delayInMillis;
+			return this;
+		}
+
+		/** Sets auxiliary object which will be passed to {@link ImageDownloader#getStream(String, Object)} */
+		public Builder extraForDownloader(Object extra) {
+			this.extraForDownloader = extra;
+			return this;
+		}
+
+		/** Sets whether ImageLoader will consider EXIF parameters of JPEG image (rotate, flip) */
+		public Builder considerExifParams(boolean considerExifParams) {
+			this.considerExifParams = considerExifParams;
+			return this;
+		}
+
+		/**
+		 * Sets bitmap processor which will be process bitmaps before they will be cached in memory. So memory cache
+		 * will contain bitmap processed by incoming preProcessor.<br />
+		 * Image will be pre-processed even if caching in memory is disabled.
+		 */
+		public Builder preProcessor(BitmapProcessor preProcessor) {
+			this.preProcessor = preProcessor;
+			return this;
+		}
+
+		/**
+		 * Sets bitmap processor which will be process bitmaps before they will be displayed in
+		 * {@link com.nostra13.universalimageloader.core.imageaware.ImageAware image aware view} but
+		 * after they'll have been saved in memory cache.
+		 */
+		public Builder postProcessor(BitmapProcessor postProcessor) {
+			this.postProcessor = postProcessor;
+			return this;
+		}
+
+		/**
+		 * Sets custom {@link BitmapDisplayer displayer} for image loading task. Default value -
+		 * {@link DefaultConfigurationFactory#createBitmapDisplayer()}
+		 */
+		public Builder displayer(BitmapDisplayer displayer) {
+			if (displayer == null) throw new IllegalArgumentException("displayer can't be null");
+			this.displayer = displayer;
+			return this;
+		}
+
+		Builder syncLoading(boolean isSyncLoading) {
+			this.isSyncLoading = isSyncLoading;
+			return this;
+		}
+
+		/**
+		 * Sets custom {@linkplain Handler handler} for displaying images and firing {@linkplain ImageLoadingListener
+		 * listener} events.
+		 */
+		public Builder handler(Handler handler) {
+			this.handler = handler;
+			return this;
+		}
+
+		/** Sets all options equal to incoming options */
+		public Builder cloneFrom(DisplayImageOptions options) {
+			imageResOnLoading = options.imageResOnLoading;
+			imageResForEmptyUri = options.imageResForEmptyUri;
+			imageResOnFail = options.imageResOnFail;
+			imageOnLoading = options.imageOnLoading;
+			imageForEmptyUri = options.imageForEmptyUri;
+			imageOnFail = options.imageOnFail;
+			resetViewBeforeLoading = options.resetViewBeforeLoading;
+			cacheInMemory = options.cacheInMemory;
+			cacheOnDisk = options.cacheOnDisk;
+			imageScaleType = options.imageScaleType;
+			decodingOptions = options.decodingOptions;
+			delayBeforeLoading = options.delayBeforeLoading;
+			considerExifParams = options.considerExifParams;
+			extraForDownloader = options.extraForDownloader;
+			preProcessor = options.preProcessor;
+			postProcessor = options.postProcessor;
+			displayer = options.displayer;
+			handler = options.handler;
+			isSyncLoading = options.isSyncLoading;
+			return this;
+		}
+
+		/** Builds configured {@link DisplayImageOptions} object */
+		public DisplayImageOptions build() {
+			return new DisplayImageOptions(this);
+		}
+	}
+
+	/**
+	 * Creates options appropriate for single displaying:
+	 * <ul>
+	 * <li>View will <b>not</b> be reset before loading</li>
+	 * <li>Loaded image will <b>not</b> be cached in memory</li>
+	 * <li>Loaded image will <b>not</b> be cached on disk</li>
+	 * <li>{@link ImageScaleType#IN_SAMPLE_POWER_OF_2} decoding type will be used</li>
+	 * <li>{@link Bitmap.Config#ARGB_8888} bitmap config will be used for image decoding</li>
+	 * <li>{@link SimpleBitmapDisplayer} will be used for image displaying</li>
+	 * </ul>
+	 * <p/>
+	 * These option are appropriate for simple single-use image (from drawables or from Internet) displaying.
+	 */
+	public static DisplayImageOptions createSimple() {
+		return new Builder().build();
+	}
+}

+/*******************************************************************************
+ * Copyright 2011-2014 Sergey Tarasevich
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.nostra13.universalimageloader.core;
+
+import android.graphics.Bitmap;
+import android.os.Handler;
+import android.os.Looper;
+import android.text.TextUtils;
+import android.view.View;
+import android.widget.ImageView;
+import com.nostra13.universalimageloader.cache.disc.DiskCache;
+import com.nostra13.universalimageloader.cache.memory.MemoryCache;
+import com.nostra13.universalimageloader.core.assist.FailReason;
+import com.nostra13.universalimageloader.core.assist.FlushedInputStream;
+import com.nostra13.universalimageloader.core.assist.ImageSize;
+import com.nostra13.universalimageloader.core.assist.LoadedFrom;
+import com.nostra13.universalimageloader.core.assist.ViewScaleType;
+import com.nostra13.universalimageloader.core.imageaware.ImageAware;
+import com.nostra13.universalimageloader.core.imageaware.ImageViewAware;
+import com.nostra13.universalimageloader.core.imageaware.NonViewAware;
+import com.nostra13.universalimageloader.core.listener.ImageLoadingListener;
+import com.nostra13.universalimageloader.core.listener.ImageLoadingProgressListener;
+import com.nostra13.universalimageloader.core.listener.SimpleImageLoadingListener;
+import com.nostra13.universalimageloader.utils.ImageSizeUtils;
+import com.nostra13.universalimageloader.utils.L;
+import com.nostra13.universalimageloader.utils.MemoryCacheUtils;
+
+/**
+ * Singletone for image loading and displaying at {@link ImageView ImageViews}<br />
+ * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before any other method.
+ *
+ * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+ * @since 1.0.0
+ */
+public class ImageLoader {
+
+	public static final String TAG = ImageLoader.class.getSimpleName();
+
+	static final String LOG_INIT_CONFIG = "Initialize ImageLoader with configuration";
+	static final String LOG_DESTROY = "Destroy ImageLoader";
+	static final String LOG_LOAD_IMAGE_FROM_MEMORY_CACHE = "Load image from memory cache [%s]";
+
+	private static final String WARNING_RE_INIT_CONFIG = "Try to initialize ImageLoader which had already been initialized before. " + "To re-init ImageLoader with new configuration call ImageLoader.destroy() at first.";
+	private static final String ERROR_WRONG_ARGUMENTS = "Wrong arguments were passed to displayImage() method (ImageView reference must not be null)";
+	private static final String ERROR_NOT_INIT = "ImageLoader must be init with configuration before using";
+	private static final String ERROR_INIT_CONFIG_WITH_NULL = "ImageLoader configuration can not be initialized with null";
+
+	private ImageLoaderConfiguration configuration;
+	private ImageLoaderEngine engine;
+
+	private ImageLoadingListener defaultListener = new SimpleImageLoadingListener();
+
+	private volatile static ImageLoader instance;
+
+	/** Returns singleton class instance */
+	public static ImageLoader getInstance() {
+		if (instance == null) {
+			synchronized (ImageLoader.class) {
+				if (instance == null) {
+					instance = new ImageLoader();
+				}
+			}
+		}
+		return instance;
+	}
+
+	protected ImageLoader() {
+	}
+
+	/**
+	 * Initializes ImageLoader instance with configuration.<br />
+	 * If configurations was set before ( {@link #isInited()} == true) then this method does nothing.<br />
+	 * To force initialization with new configuration you should {@linkplain #destroy() destroy ImageLoader} at first.
+	 *
+	 * @param configuration {@linkplain ImageLoaderConfiguration ImageLoader configuration}
+	 * @throws IllegalArgumentException if <b>configuration</b> parameter is null
+	 */
+	public synchronized void init(ImageLoaderConfiguration configuration) {
+		if (configuration == null) {
+			throw new IllegalArgumentException(ERROR_INIT_CONFIG_WITH_NULL);
+		}
+		if (this.configuration == null) {
+			L.d(LOG_INIT_CONFIG);
+			engine = new ImageLoaderEngine(configuration);
+			this.configuration = configuration;
+		} else {
+			L.w(WARNING_RE_INIT_CONFIG);
+		}
+	}
+
+	/**
+	 * Returns <b>true</b> - if ImageLoader {@linkplain #init(ImageLoaderConfiguration) is initialized with
+	 * configuration}; <b>false</b> - otherwise
+	 */
+	public boolean isInited() {
+		return configuration != null;
+	}
+
+	/**
+	 * Adds display image task to execution pool. Image will be set to ImageAware when it's turn. <br/>
+	 * Default {@linkplain DisplayImageOptions display image options} from {@linkplain ImageLoaderConfiguration
+	 * configuration} will be used.<br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri        Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param imageAware {@linkplain ImageAware Image aware view}
+	 *                   which should display image
+	 * @throws IllegalStateException    if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 * @throws IllegalArgumentException if passed <b>imageAware</b> is null
+	 */
+	public void displayImage(String uri, ImageAware imageAware) {
+		displayImage(uri, imageAware, null, null, null);
+	}
+
+	/**
+	 * Adds display image task to execution pool. Image will be set to ImageAware when it's turn.<br />
+	 * Default {@linkplain DisplayImageOptions display image options} from {@linkplain ImageLoaderConfiguration
+	 * configuration} will be used.<br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri        Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param imageAware {@linkplain ImageAware Image aware view}
+	 *                   which should display image
+	 * @param listener   {@linkplain ImageLoadingListener Listener} for image loading process. Listener fires events on
+	 *                   UI thread if this method is called on UI thread.
+	 * @throws IllegalStateException    if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 * @throws IllegalArgumentException if passed <b>imageAware</b> is null
+	 */
+	public void displayImage(String uri, ImageAware imageAware, ImageLoadingListener listener) {
+		displayImage(uri, imageAware, null, listener, null);
+	}
+
+	/**
+	 * Adds display image task to execution pool. Image will be set to ImageAware when it's turn.<br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri        Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param imageAware {@linkplain ImageAware Image aware view}
+	 *                   which should display image
+	 * @param options    {@linkplain DisplayImageOptions Options} for image
+	 *                   decoding and displaying. If <b>null</b> - default display image options
+	 *                   {@linkplain ImageLoaderConfiguration.Builder#defaultDisplayImageOptions(DisplayImageOptions)
+	 *                   from configuration} will be used.
+	 * @throws IllegalStateException    if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 * @throws IllegalArgumentException if passed <b>imageAware</b> is null
+	 */
+	public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options) {
+		displayImage(uri, imageAware, options, null, null);
+	}
+
+	/**
+	 * Adds display image task to execution pool. Image will be set to ImageAware when it's turn.<br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri        Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param imageAware {@linkplain ImageAware Image aware view}
+	 *                   which should display image
+	 * @param options    {@linkplain DisplayImageOptions Options} for image
+	 *                   decoding and displaying. If <b>null</b> - default display image options
+	 *                   {@linkplain ImageLoaderConfiguration.Builder#defaultDisplayImageOptions(DisplayImageOptions)
+	 *                   from configuration} will be used.
+	 * @param listener   {@linkplain ImageLoadingListener Listener} for image loading process. Listener fires events on
+	 *                   UI thread if this method is called on UI thread.
+	 * @throws IllegalStateException    if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 * @throws IllegalArgumentException if passed <b>imageAware</b> is null
+	 */
+	public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
+			ImageLoadingListener listener) {
+		displayImage(uri, imageAware, options, listener, null);
+	}
+
+	/**
+	 * Adds display image task to execution pool. Image will be set to ImageAware when it's turn.<br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri              Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param imageAware       {@linkplain ImageAware Image aware view}
+	 *                         which should display image
+	 * @param options          {@linkplain DisplayImageOptions Options} for image
+	 *                         decoding and displaying. If <b>null</b> - default display image options
+	 *                         {@linkplain ImageLoaderConfiguration.Builder#defaultDisplayImageOptions(DisplayImageOptions)
+	 *                         from configuration} will be used.
+	 * @param listener         {@linkplain ImageLoadingListener Listener} for image loading process. Listener fires
+	 *                         events on UI thread if this method is called on UI thread.
+	 * @param progressListener {@linkplain ImageLoadingProgressListener
+	 *                         Listener} for image loading progress. Listener fires events on UI thread if this method
+	 *                         is called on UI thread. Caching on disk should be enabled in
+	 *                         {@linkplain DisplayImageOptions options} to make
+	 *                         this listener work.
+	 * @throws IllegalStateException    if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 * @throws IllegalArgumentException if passed <b>imageAware</b> is null
+	 */
+	public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
+			ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
+		checkConfiguration();
+		if (imageAware == null) {
+			throw new IllegalArgumentException(ERROR_WRONG_ARGUMENTS);
+		}
+		if (listener == null) {
+			listener = defaultListener;
+		}
+		if (options == null) {
+			options = configuration.defaultDisplayImageOptions;
+		}
+
+		if (TextUtils.isEmpty(uri)) {
+			engine.cancelDisplayTaskFor(imageAware);
+			listener.onLoadingStarted(uri, imageAware.getWrappedView());
+			if (options.shouldShowImageForEmptyUri()) {
+				imageAware.setImageDrawable(options.getImageForEmptyUri(configuration.resources));
+			} else {
+				imageAware.setImageDrawable(null);
+			}
+			listener.onLoadingComplete(uri, imageAware.getWrappedView(), null);
+			return;
+		}
+
+		ImageSize targetSize = ImageSizeUtils.defineTargetSizeForView(imageAware, configuration.getMaxImageSize());
+		String memoryCacheKey = MemoryCacheUtils.generateKey(uri, targetSize);
+		engine.prepareDisplayTaskFor(imageAware, memoryCacheKey);
+
+		listener.onLoadingStarted(uri, imageAware.getWrappedView());
+
+		Bitmap bmp = configuration.memoryCache.get(memoryCacheKey);
+		if (bmp != null && !bmp.isRecycled()) {
+			L.d(LOG_LOAD_IMAGE_FROM_MEMORY_CACHE, memoryCacheKey);
+
+			if (options.shouldPostProcess()) {
+				ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,
+						options, listener, progressListener, engine.getLockForUri(uri));
+				ProcessAndDisplayImageTask displayTask = new ProcessAndDisplayImageTask(engine, bmp, imageLoadingInfo,
+						defineHandler(options));
+				if (options.isSyncLoading()) {
+					displayTask.run();
+				} else {
+					engine.submit(displayTask);
+				}
+			} else {
+				options.getDisplayer().display(bmp, imageAware, LoadedFrom.MEMORY_CACHE);
+				listener.onLoadingComplete(uri, imageAware.getWrappedView(), bmp);
+			}
+		} else {
+			if (options.shouldShowImageOnLoading()) {
+				imageAware.setImageDrawable(options.getImageOnLoading(configuration.resources));
+			} else if (options.isResetViewBeforeLoading()) {
+				imageAware.setImageDrawable(null);
+			}
+
+			ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,
+					options, listener, progressListener, engine.getLockForUri(uri));
+			LoadAndDisplayImageTask displayTask = new LoadAndDisplayImageTask(engine, imageLoadingInfo,
+					defineHandler(options));
+			if (options.isSyncLoading()) {
+				displayTask.run();
+			} else {
+				engine.submit(displayTask);
+			}
+		}
+	}
+
+	/**
+	 * Adds display image task to execution pool. Image will be set to ImageView when it's turn. <br/>
+	 * Default {@linkplain DisplayImageOptions display image options} from {@linkplain ImageLoaderConfiguration
+	 * configuration} will be used.<br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri       Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param imageView {@link ImageView} which should display image
+	 * @throws IllegalStateException    if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 * @throws IllegalArgumentException if passed <b>imageView</b> is null
+	 */
+	public void displayImage(String uri, ImageView imageView) {
+		displayImage(uri, new ImageViewAware(imageView), null, null, null);
+	}
+
+	/**
+	 * Adds display image task to execution pool. Image will be set to ImageView when it's turn.<br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri       Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param imageView {@link ImageView} which should display image
+	 * @param options   {@linkplain DisplayImageOptions Options} for image
+	 *                  decoding and displaying. If <b>null</b> - default display image options
+	 *                  {@linkplain ImageLoaderConfiguration.Builder#defaultDisplayImageOptions(DisplayImageOptions)
+	 *                  from configuration} will be used.
+	 * @throws IllegalStateException    if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 * @throws IllegalArgumentException if passed <b>imageView</b> is null
+	 */
+	public void displayImage(String uri, ImageView imageView, DisplayImageOptions options) {
+		displayImage(uri, new ImageViewAware(imageView), options, null, null);
+	}
+
+	/**
+	 * Adds display image task to execution pool. Image will be set to ImageView when it's turn.<br />
+	 * Default {@linkplain DisplayImageOptions display image options} from {@linkplain ImageLoaderConfiguration
+	 * configuration} will be used.<br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri       Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param imageView {@link ImageView} which should display image
+	 * @param listener  {@linkplain ImageLoadingListener Listener} for image loading process. Listener fires events on
+	 *                  UI thread if this method is called on UI thread.
+	 * @throws IllegalStateException    if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 * @throws IllegalArgumentException if passed <b>imageView</b> is null
+	 */
+	public void displayImage(String uri, ImageView imageView, ImageLoadingListener listener) {
+		displayImage(uri, new ImageViewAware(imageView), null, listener, null);
+	}
+
+	/**
+	 * Adds display image task to execution pool. Image will be set to ImageView when it's turn.<br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri       Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param imageView {@link ImageView} which should display image
+	 * @param options   {@linkplain DisplayImageOptions Options} for image
+	 *                  decoding and displaying. If <b>null</b> - default display image options
+	 *                  {@linkplain ImageLoaderConfiguration.Builder#defaultDisplayImageOptions(DisplayImageOptions)
+	 *                  from configuration} will be used.
+	 * @param listener  {@linkplain ImageLoadingListener Listener} for image loading process. Listener fires events on
+	 *                  UI thread if this method is called on UI thread.
+	 * @throws IllegalStateException    if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 * @throws IllegalArgumentException if passed <b>imageView</b> is null
+	 */
+	public void displayImage(String uri, ImageView imageView, DisplayImageOptions options,
+			ImageLoadingListener listener) {
+		displayImage(uri, imageView, options, listener, null);
+	}
+
+	/**
+	 * Adds display image task to execution pool. Image will be set to ImageView when it's turn.<br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri              Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param imageView        {@link ImageView} which should display image
+	 * @param options          {@linkplain DisplayImageOptions Options} for image
+	 *                         decoding and displaying. If <b>null</b> - default display image options
+	 *                         {@linkplain ImageLoaderConfiguration.Builder#defaultDisplayImageOptions(DisplayImageOptions)
+	 *                         from configuration} will be used.
+	 * @param listener         {@linkplain ImageLoadingListener Listener} for image loading process. Listener fires
+	 *                         events on UI thread if this method is called on UI thread.
+	 * @param progressListener {@linkplain ImageLoadingProgressListener
+	 *                         Listener} for image loading progress. Listener fires events on UI thread if this method
+	 *                         is called on UI thread. Caching on disk should be enabled in
+	 *                         {@linkplain DisplayImageOptions options} to make
+	 *                         this listener work.
+	 * @throws IllegalStateException    if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 * @throws IllegalArgumentException if passed <b>imageView</b> is null
+	 */
+	public void displayImage(String uri, ImageView imageView, DisplayImageOptions options,
+			ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
+		displayImage(uri, new ImageViewAware(imageView), options, listener, progressListener);
+	}
+
+	/**
+	 * Adds load image task to execution pool. Image will be returned with
+	 * {@link ImageLoadingListener#onLoadingComplete(String, View, Bitmap)} callback}.
+	 * <br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri      Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param listener {@linkplain ImageLoadingListener Listener} for image loading process. Listener fires events on UI
+	 *                 thread if this method is called on UI thread.
+	 * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 */
+	public void loadImage(String uri, ImageLoadingListener listener) {
+		loadImage(uri, null, null, listener, null);
+	}
+
+	/**
+	 * Adds load image task to execution pool. Image will be returned with
+	 * {@link ImageLoadingListener#onLoadingComplete(String, View, Bitmap)} callback}.
+	 * <br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri             Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param targetImageSize Minimal size for {@link Bitmap} which will be returned in
+	 *                        {@linkplain ImageLoadingListener#onLoadingComplete(String, View,
+	 *                        Bitmap)} callback}. Downloaded image will be decoded
+	 *                        and scaled to {@link Bitmap} of the size which is <b>equal or larger</b> (usually a bit
+	 *                        larger) than incoming targetImageSize.
+	 * @param listener        {@linkplain ImageLoadingListener Listener} for image loading process. Listener fires
+	 *                        events on UI thread if this method is called on UI thread.
+	 * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 */
+	public void loadImage(String uri, ImageSize targetImageSize, ImageLoadingListener listener) {
+		loadImage(uri, targetImageSize, null, listener, null);
+	}
+
+	/**
+	 * Adds load image task to execution pool. Image will be returned with
+	 * {@link ImageLoadingListener#onLoadingComplete(String, View, Bitmap)} callback}.
+	 * <br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri      Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param options  {@linkplain DisplayImageOptions Options} for image
+	 *                 decoding and displaying. If <b>null</b> - default display image options
+	 *                 {@linkplain ImageLoaderConfiguration.Builder#defaultDisplayImageOptions(DisplayImageOptions) from
+	 *                 configuration} will be used.<br />
+	 * @param listener {@linkplain ImageLoadingListener Listener} for image loading process. Listener fires events on UI
+	 *                 thread if this method is called on UI thread.
+	 * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 */
+	public void loadImage(String uri, DisplayImageOptions options, ImageLoadingListener listener) {
+		loadImage(uri, null, options, listener, null);
+	}
+
+	/**
+	 * Adds load image task to execution pool. Image will be returned with
+	 * {@link ImageLoadingListener#onLoadingComplete(String, View, Bitmap)} callback}.
+	 * <br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri             Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param targetImageSize Minimal size for {@link Bitmap} which will be returned in
+	 *                        {@linkplain ImageLoadingListener#onLoadingComplete(String, View,
+	 *                        Bitmap)} callback}. Downloaded image will be decoded
+	 *                        and scaled to {@link Bitmap} of the size which is <b>equal or larger</b> (usually a bit
+	 *                        larger) than incoming targetImageSize.
+	 * @param options         {@linkplain DisplayImageOptions Options} for image
+	 *                        decoding and displaying. If <b>null</b> - default display image options
+	 *                        {@linkplain ImageLoaderConfiguration.Builder#defaultDisplayImageOptions(DisplayImageOptions)
+	 *                        from configuration} will be used.<br />
+	 * @param listener        {@linkplain ImageLoadingListener Listener} for image loading process. Listener fires
+	 *                        events on UI thread if this method is called on UI thread.
+	 * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 */
+	public void loadImage(String uri, ImageSize targetImageSize, DisplayImageOptions options,
+			ImageLoadingListener listener) {
+		loadImage(uri, targetImageSize, options, listener, null);
+	}
+
+	/**
+	 * Adds load image task to execution pool. Image will be returned with
+	 * {@link ImageLoadingListener#onLoadingComplete(String, View, Bitmap)} callback}.
+	 * <br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri              Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param targetImageSize  Minimal size for {@link Bitmap} which will be returned in
+	 *                         {@linkplain ImageLoadingListener#onLoadingComplete(String, View,
+	 *                         Bitmap)} callback}. Downloaded image will be decoded
+	 *                         and scaled to {@link Bitmap} of the size which is <b>equal or larger</b> (usually a bit
+	 *                         larger) than incoming targetImageSize.
+	 * @param options          {@linkplain DisplayImageOptions Options} for image
+	 *                         decoding and displaying. If <b>null</b> - default display image options
+	 *                         {@linkplain ImageLoaderConfiguration.Builder#defaultDisplayImageOptions(DisplayImageOptions)
+	 *                         from configuration} will be used.<br />
+	 * @param listener         {@linkplain ImageLoadingListener Listener} for image loading process. Listener fires
+	 *                         events on UI thread if this method is called on UI thread.
+	 * @param progressListener {@linkplain ImageLoadingProgressListener
+	 *                         Listener} for image loading progress. Listener fires events on UI thread if this method
+	 *                         is called on UI thread. Caching on disk should be enabled in
+	 *                         {@linkplain DisplayImageOptions options} to make
+	 *                         this listener work.
+	 * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 */
+	public void loadImage(String uri, ImageSize targetImageSize, DisplayImageOptions options,
+			ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
+		checkConfiguration();
+		if (targetImageSize == null) {
+			targetImageSize = configuration.getMaxImageSize();
+		}
+		if (options == null) {
+			options = configuration.defaultDisplayImageOptions;
+		}
+
+		NonViewAware imageAware = new NonViewAware(uri, targetImageSize, ViewScaleType.CROP);
+		displayImage(uri, imageAware, options, listener, progressListener);
+	}
+
+	/**
+	 * Loads and decodes image synchronously.<br />
+	 * Default display image options
+	 * {@linkplain ImageLoaderConfiguration.Builder#defaultDisplayImageOptions(DisplayImageOptions) from
+	 * configuration} will be used.<br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @return Result image Bitmap. Can be <b>null</b> if image loading/decoding was failed or cancelled.
+	 * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 */
+	public Bitmap loadImageSync(String uri) {
+		return loadImageSync(uri, null, null);
+	}
+
+	/**
+	 * Loads and decodes image synchronously.<br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri     Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param options {@linkplain DisplayImageOptions Options} for image
+	 *                decoding and scaling. If <b>null</b> - default display image options
+	 *                {@linkplain ImageLoaderConfiguration.Builder#defaultDisplayImageOptions(DisplayImageOptions) from
+	 *                configuration} will be used.
+	 * @return Result image Bitmap. Can be <b>null</b> if image loading/decoding was failed or cancelled.
+	 * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 */
+	public Bitmap loadImageSync(String uri, DisplayImageOptions options) {
+		return loadImageSync(uri, null, options);
+	}
+
+	/**
+	 * Loads and decodes image synchronously.<br />
+	 * Default display image options
+	 * {@linkplain ImageLoaderConfiguration.Builder#defaultDisplayImageOptions(DisplayImageOptions) from
+	 * configuration} will be used.<br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri             Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param targetImageSize Minimal size for {@link Bitmap} which will be returned. Downloaded image will be decoded
+	 *                        and scaled to {@link Bitmap} of the size which is <b>equal or larger</b> (usually a bit
+	 *                        larger) than incoming targetImageSize.
+	 * @return Result image Bitmap. Can be <b>null</b> if image loading/decoding was failed or cancelled.
+	 * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 */
+	public Bitmap loadImageSync(String uri, ImageSize targetImageSize) {
+		return loadImageSync(uri, targetImageSize, null);
+	}
+
+	/**
+	 * Loads and decodes image synchronously.<br />
+	 * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call
+	 *
+	 * @param uri             Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")
+	 * @param targetImageSize Minimal size for {@link Bitmap} which will be returned. Downloaded image will be decoded
+	 *                        and scaled to {@link Bitmap} of the size which is <b>equal or larger</b> (usually a bit
+	 *                        larger) than incoming targetImageSize.
+	 * @param options         {@linkplain DisplayImageOptions Options} for image
+	 *                        decoding and scaling. If <b>null</b> - default display image options
+	 *                        {@linkplain ImageLoaderConfiguration.Builder#defaultDisplayImageOptions(DisplayImageOptions)
+	 *                        from configuration} will be used.
+	 * @return Result image Bitmap. Can be <b>null</b> if image loading/decoding was failed or cancelled.
+	 * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 */
+	public Bitmap loadImageSync(String uri, ImageSize targetImageSize, DisplayImageOptions options) {
+		if (options == null) {
+			options = configuration.defaultDisplayImageOptions;
+		}
+		options = new DisplayImageOptions.Builder().cloneFrom(options).syncLoading(true).build();
+
+		SyncImageLoadingListener listener = new SyncImageLoadingListener();
+		loadImage(uri, targetImageSize, options, listener);
+		return listener.getLoadedBitmap();
+	}
+
+	/**
+	 * Checks if ImageLoader's configuration was initialized
+	 *
+	 * @throws IllegalStateException if configuration wasn't initialized
+	 */
+	private void checkConfiguration() {
+		if (configuration == null) {
+			throw new IllegalStateException(ERROR_NOT_INIT);
+		}
+	}
+
+	/** Sets a default loading listener for all display and loading tasks. */
+	public void setDefaultLoadingListener(ImageLoadingListener listener) {
+		defaultListener = listener == null ? new SimpleImageLoadingListener() : listener;
+	}
+
+	/**
+	 * Returns memory cache
+	 *
+	 * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 */
+	public MemoryCache getMemoryCache() {
+		checkConfiguration();
+		return configuration.memoryCache;
+	}
+
+	/**
+	 * Clears memory cache
+	 *
+	 * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 */
+	public void clearMemoryCache() {
+		checkConfiguration();
+		configuration.memoryCache.clear();
+	}
+
+	/**
+	 * Returns disk cache
+	 *
+	 * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 * @deprecated Use {@link #getDiskCache()} instead
+	 */
+	@Deprecated
+	public DiskCache getDiscCache() {
+		return getDiskCache();
+	}
+
+	/**
+	 * Returns disk cache
+	 *
+	 * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 */
+	public DiskCache getDiskCache() {
+		checkConfiguration();
+		return configuration.diskCache;
+	}
+
+	/**
+	 * Clears disk cache.
+	 *
+	 * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 * @deprecated Use {@link #clearDiskCache()} instead
+	 */
+	@Deprecated
+	public void clearDiscCache() {
+		clearDiskCache();
+	}
+
+	/**
+	 * Clears disk cache.
+	 *
+	 * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before
+	 */
+	public void clearDiskCache() {
+		checkConfiguration();
+		configuration.diskCache.clear();
+	}
+
+	/**
+	 * Returns URI of image which is loading at this moment into passed
+	 * {@link ImageAware ImageAware}
+	 */
+	public String getLoadingUriForView(ImageAware imageAware) {
+		return engine.getLoadingUriForView(imageAware);
+	}
+
+	/**
+	 * Returns URI of image which is loading at this moment into passed
+	 * {@link ImageView ImageView}
+	 */
+	public String getLoadingUriForView(ImageView imageView) {
+		return engine.getLoadingUriForView(new ImageViewAware(imageView));
+	}
+
+	/**
+	 * Cancel the task of loading and displaying image for passed
+	 * {@link ImageAware ImageAware}.
+	 *
+	 * @param imageAware {@link ImageAware ImageAware} for
+	 *                   which display task will be cancelled
+	 */
+	public void cancelDisplayTask(ImageAware imageAware) {
+		engine.cancelDisplayTaskFor(imageAware);
+	}
+
+	/**
+	 * Cancel the task of loading and displaying image for passed
+	 * {@link ImageView ImageView}.
+	 *
+	 * @param imageView {@link ImageView ImageView} for which display task will be cancelled
+	 */
+	public void cancelDisplayTask(ImageView imageView) {
+		engine.cancelDisplayTaskFor(new ImageViewAware(imageView));
+	}
+
+	/**
+	 * Denies or allows ImageLoader to download images from the network.<br />
+	 * <br />
+	 * If downloads are denied and if image isn't cached then
+	 * {@link ImageLoadingListener#onLoadingFailed(String, View, FailReason)} callback will be fired with
+	 * {@link FailReason.FailType#NETWORK_DENIED}
+	 *
+	 * @param denyNetworkDownloads pass <b>true</b> - to deny engine to download images from the network; <b>false</b> -
+	 *                             to allow engine to download images from network.
+	 */
+	public void denyNetworkDownloads(boolean denyNetworkDownloads) {
+		engine.denyNetworkDownloads(denyNetworkDownloads);
+	}
+
+	/**
+	 * Sets option whether ImageLoader will use {@link FlushedInputStream} for network downloads to handle <a
+	 * href="http://code.google.com/p/android/issues/detail?id=6066">this known problem</a> or not.
+	 *
+	 * @param handleSlowNetwork pass <b>true</b> - to use {@link FlushedInputStream} for network downloads; <b>false</b>
+	 *                          - otherwise.
+	 */
+	public void handleSlowNetwork(boolean handleSlowNetwork) {
+		engine.handleSlowNetwork(handleSlowNetwork);
+	}
+
+	/**
+	 * Pause ImageLoader. All new "load&display" tasks won't be executed until ImageLoader is {@link #resume() resumed}.
+	 * <br />
+	 * Already running tasks are not paused.
+	 */
+	public void pause() {
+		engine.pause();
+	}
+
+	/** Resumes waiting "load&display" tasks */
+	public void resume() {
+		engine.resume();
+	}
+
+	/**
+	 * Cancels all running and scheduled display image tasks.<br />
+	 * <b>NOTE:</b> This method doesn't shutdown
+	 * {@linkplain ImageLoaderConfiguration.Builder#taskExecutor(java.util.concurrent.Executor)
+	 * custom task executors} if you set them.<br />
+	 * ImageLoader still can be used after calling this method.
+	 */
+	public void stop() {
+		engine.stop();
+	}
+
+	/**
+	 * {@linkplain #stop() Stops ImageLoader} and clears current configuration. <br />
+	 * You can {@linkplain #init(ImageLoaderConfiguration) init} ImageLoader with new configuration after calling this
+	 * method.
+	 */
+	public void destroy() {
+		if (configuration != null) L.d(LOG_DESTROY);
+		stop();
+		configuration.diskCache.close();
+		engine = null;
+		configuration = null;
+	}
+
+	private static Handler defineHandler(DisplayImageOptions options) {
+		Handler handler = options.getHandler();
+		if (options.isSyncLoading()) {
+			handler = null;
+		} else if (handler == null && Looper.myLooper() == Looper.getMainLooper()) {
+			handler = new Handler();
+		}
+		return handler;
+	}
+
+	/**
+	 * Listener which is designed for synchronous image loading.
+	 *
+	 * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
+	 * @since 1.9.0
+	 */
+	private static class SyncImageLoadingListener extends SimpleImageLoadingListener {
+
+		private Bitmap loadedImage;
+
+		@Override
+		public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {
+			this.loadedImage = loadedImage;
+		}
+
+		public Bitmap getLoadedBitmap() {
+			return loadedImage;
+		}
+	}
+}