Java tutorial
/* * 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.android.volley.plus; import android.app.ActivityManager; import android.content.Context; import android.graphics.Bitmap; import android.graphics.Bitmap.CompressFormat; import android.os.Environment; import android.os.StatFs; import android.support.v4.util.LruCache; import android.text.TextUtils; import android.util.Log; import com.android.volley.toolbox.ImageLoader; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; /** * This class holds our bitmap caches (memory and disk). */ public class ImageCache implements ImageLoader.ImageCache, PersistentCache { static final String TAG = "ImageCache"; // Default memory cache size private static final int DEFAULT_MEM_CACHE_SIZE = 1024 * 1024 * 5; // 5MB // Default disk cache size // private static final int DEFAULT_DISK_CACHE_SIZE = 1024 * 100; // 100k private static final int DEFAULT_DISK_CACHE_SIZE = 1024 * 1024 * 20; // 20MB // Compression settings when writing images to disk cache private static final CompressFormat DEFAULT_COMPRESS_FORMAT = CompressFormat.JPEG; private static final int DEFAULT_COMPRESS_QUALITY = 70; private static final int DISK_CACHE_INDEX = 0; // Constants to easily toggle various caches private static final boolean DEFAULT_MEM_CACHE_ENABLED = true; private static final boolean DEFAULT_DISK_CACHE_ENABLED = true; private static final boolean DEFAULT_CLEAR_DISK_CACHE_ON_START = false; private static final boolean DEFAULT_INIT_DISK_CACHE_ON_CREATE = true; private DiskLruCache mDiskLruCache; private LruCache<String, Bitmap> mMemoryCache; private ImageCacheParams mCacheParams; private final Object mDiskCacheLock = new Object(); private boolean mDiskCacheStarting = true; /** * Creating a new ImageCache object using the specified parameters. */ public ImageCache(ImageCacheParams cacheParams) { init(cacheParams); } /** * Initialize the cache, providing all parameters. * * @param cacheParams The cache parameters to initialize the cache */ private void init(ImageCacheParams cacheParams) { mCacheParams = cacheParams; // Set up memory cache if (mCacheParams.memoryCacheEnabled) { // if (BuildConfig.DEBUG) { // Log.d(TAG, "Memory cache created (size = " + mCacheParams.memCacheSize + ")"); // } mMemoryCache = new LruCache<String, Bitmap>(mCacheParams.memCacheSize) { /** * Measure item size in bytes rather than units which is more practical * for a bitmap cache */ @Override protected int sizeOf(String key, Bitmap bitmap) { return getBitmapSize(bitmap); } }; } // By default the disk cache is not initialized here as it should be initialized // on a separate thread due to disk access. if (cacheParams.initDiskCacheOnCreate) { // Set up disk cache initDiskCache(); } } /** * Initializes the disk cache. Note that this includes disk access so this should not be * executed on the main/UI thread. By default an ImageCache does not initialize the disk * cache when it is created, instead you should call initDiskCache() to initialize it on a * background thread. */ private void initDiskCache() { // Set up disk cache synchronized (mDiskCacheLock) { if (mDiskLruCache == null || mDiskLruCache.isClosed()) { File diskCacheDir = mCacheParams.diskCacheDir; if (mCacheParams.diskCacheEnabled && diskCacheDir != null) { if (!diskCacheDir.exists()) { diskCacheDir.mkdirs(); } if (getUsableSpace(diskCacheDir) > mCacheParams.diskCacheSize) { try { mDiskLruCache = DiskLruCache.open(diskCacheDir, 1, 1, mCacheParams.diskCacheSize); // if (BuildConfig.DEBUG) { // Log.d(TAG, "Disk cache initialized"); // } } catch (final IOException e) { mCacheParams.diskCacheDir = null; Log.e(TAG, "initDiskCache - " + e); } } } } mDiskCacheStarting = false; mDiskCacheLock.notifyAll(); } } /** * Adds a bitmap to both memory and disk cache. * * @param key Unique identifier for the bitmap to store * @param bitmap The bitmap to store */ public void addBitmapToCache(String key, Bitmap bitmap, CompressFormat format) { if (key == null || bitmap == null) { return; } // Add to memory cache if (mMemoryCache != null && mMemoryCache.get(key) == null) { mMemoryCache.put(key, bitmap); } synchronized (mDiskCacheLock) { // Add to disk cache if (mDiskLruCache != null) { // final String key = hashKeyForDisk(data); OutputStream out = null; try { DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key); if (snapshot == null) { final DiskLruCache.Editor editor = mDiskLruCache.edit(key); if (editor != null) { out = editor.newOutputStream(DISK_CACHE_INDEX); bitmap.compress(format, mCacheParams.compressQuality, out); editor.commit(); // Log.d("rodrigo", "bitmap:" + key + " added to disk"); out.close(); } } else { snapshot.getInputStream(DISK_CACHE_INDEX).close(); } } catch (final IOException e) { Log.e(TAG, "addBitmapToCache - " + e); } catch (Exception e) { Log.e(TAG, "addBitmapToCache - " + e); } finally { try { flush(); if (out != null) { out.close(); } } catch (IOException e) { } } } } } @Override public void addBitmapToMemCache(String key, Bitmap bitmap) { if (mMemoryCache != null && mMemoryCache.get(key) == null) { mMemoryCache.put(key, bitmap); } } /** * Get from memory cache. * * @param url Unique identifier for which item to get * @return The bitmap if found in cache, null otherwise */ public Bitmap getBitmapFromMemCache(String url) { if (mMemoryCache != null && url != null && !url.equals("")) { final Bitmap memBitmap = mMemoryCache.get(getCacheKey(url)); if (memBitmap != null) { // if (BuildConfig.DEBUG) { // Log.d(TAG, "Memory cache hit"); // } return memBitmap; } } return null; } /** * Get from disk cache. * * @param key Unique identifier for which item to get * @return The bitmap if found in cache, null otherwise */ public Bitmap getBitmapFromDiskCache(String key, int width, int height) { // final String key = hashKeyForDisk(data); synchronized (mDiskCacheLock) { while (mDiskCacheStarting) { try { mDiskCacheLock.wait(); } catch (InterruptedException e) { } } if (mDiskLruCache != null) { InputStream inputStream = null; try { final DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key); if (snapshot != null) { // if (BuildConfig.DEBUG) { // Log.d(TAG, "Disk cache hit"); // } inputStream = snapshot.getInputStream(DISK_CACHE_INDEX); if (inputStream != null) { return ImageReSizer.decodeSampledBitmapFromStream(inputStream, width, height); } } } catch (final IOException e) { Log.e(TAG, "getBitmapFromDiskCache - " + e); } finally { try { if (inputStream != null) { inputStream.close(); } } catch (IOException e) { } } } return null; } } /** * Clears both the memory and disk cache associated with this ImageCache object. Note that * this includes disk access so this should not be executed on the main/UI thread. */ public void clearCache() { if (mMemoryCache != null) { mMemoryCache.evictAll(); // if (BuildConfig.DEBUG) { // Log.d(TAG, "Memory cache cleared"); // } } synchronized (mDiskCacheLock) { mDiskCacheStarting = true; if (mDiskLruCache != null && !mDiskLruCache.isClosed()) { try { mDiskLruCache.delete(); // if (BuildConfig.DEBUG) { // Log.d(TAG, "Disk cache cleared"); // } } catch (IOException e) { Log.e(TAG, "clearCache - " + e); } mDiskLruCache = null; initDiskCache(); } } } /** * Flushes the disk cache associated with this ImageCache object. Note that this includes * disk access so this should not be executed on the main/UI thread. */ public void flush() { synchronized (mDiskCacheLock) { if (mDiskLruCache != null) { try { mDiskLruCache.flush(); // if (BuildConfig.DEBUG) { // Log.d(TAG, "Disk cache flushed"); // } } catch (IOException e) { Log.e(TAG, "flush - " + e); } } } } /** * Closes the disk cache associated with this ImageCache object. Note that this includes * disk access so this should not be executed on the main/UI thread. */ public void close() { synchronized (mDiskCacheLock) { if (mDiskLruCache != null) { try { if (!mDiskLruCache.isClosed()) { mDiskLruCache.close(); mDiskLruCache = null; // if (BuildConfig.DEBUG) { // Log.d(TAG, "Disk cache closed"); // } } } catch (IOException e) { Log.e(TAG, "close - " + e); } } } } /** * set a cache item to be persistent. Persistent cache items will not be removed when trimming, and their size is excluded in total size of disk cache. * Remember call setBrittle if an item needs no longer to be kept. * works only when disk cache is enabled(cacheParams.initDiskCacheOnCreate == true). * * @param url */ @Override public void setPersistent(String url) { synchronized (mDiskCacheLock) { if (mDiskLruCache != null) { try { mDiskLruCache.setPersistent(getCacheKey(url)); } catch (IOException e) { e.printStackTrace(); } } } } /** * set a cache item to be brittle, no longer persistent. * works only when disk cache is enabled(cacheParams.initDiskCacheOnCreate == true). * * @param url */ @Override public void setBrittle(String url) { synchronized (mDiskCacheLock) { if (mDiskLruCache != null) { try { mDiskLruCache.setBrittle(getCacheKey(url)); } catch (IOException e) { e.printStackTrace(); } } } } private boolean isStorageWritable() { return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED); } /** * A hashing method that changes a string (like a URL) into a hash suitable for using as a * disk filename. */ public static String hashKeyForDisk(String key) { if (TextUtils.isEmpty(key)) return null; String cacheKey; try { final MessageDigest mDigest = MessageDigest.getInstance("MD5"); mDigest.update(key.getBytes()); cacheKey = bytesToHexString(mDigest.digest()); } catch (NoSuchAlgorithmException e) { cacheKey = String.valueOf(key.hashCode()); } return cacheKey; } /** * Creates a cache key for use with the L1 cache. * * @param url The URL of the request. */ public String getCacheKey(String url) { return hashKeyForDisk(url); // return new StringBuilder(url.length()).append(url).append("#W").append(maxWidth) // .append("#H").append(maxHeight).toString(); } /** * A holder class that contains cache parameters. */ public static class ImageCacheParams { public int memCacheSize = DEFAULT_MEM_CACHE_SIZE; public int diskCacheSize = DEFAULT_DISK_CACHE_SIZE; public File diskCacheDir; public CompressFormat compressFormat = DEFAULT_COMPRESS_FORMAT; public int compressQuality = DEFAULT_COMPRESS_QUALITY; public boolean memoryCacheEnabled = DEFAULT_MEM_CACHE_ENABLED; public boolean diskCacheEnabled = DEFAULT_DISK_CACHE_ENABLED; public boolean clearDiskCacheOnStart = DEFAULT_CLEAR_DISK_CACHE_ON_START; public boolean initDiskCacheOnCreate = DEFAULT_INIT_DISK_CACHE_ON_CREATE; public ImageCacheParams(Context context, String uniqueName) { diskCacheDir = getDiskCacheDir(context, uniqueName); } public ImageCacheParams(File diskCacheDir) { this.diskCacheDir = diskCacheDir; } public void setDiskCacheSize(int diskCacheSize) { if (diskCacheSize < 1024 * 1024) { throw new IllegalArgumentException( "setDiskCacheSize - disk cache size must be " + "bigger than 1MB"); } this.diskCacheSize = diskCacheSize; } /** * Sets the memory cache size based on a percentage of the device memory class. * Eg. setting percent to 0.2 would set the memory cache to one fifth of the device memory * class. Throws {@link IllegalArgumentException} if percent is < 0.05 or > .8. * <p/> * This value should be chosen carefully based on a number of factors * Refer to the corresponding Android Training class for more discussion: * http://developer.android.com/training/displaying-bitmaps/ * * @param context Context to use to fetch memory class * @param percent Percent of memory class to use to size memory cache */ public void setMemCacheSizePercent(Context context, float percent) { if (percent < 0.05f || percent > 0.8f) { throw new IllegalArgumentException( "setMemCacheSizePercent - percent must be " + "between 0.05 and 0.8 (inclusive)"); } memCacheSize = Math.round(percent * getMemoryClass(context) * 1024 * 1024); } private static int getMemoryClass(Context context) { return ((ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE)).getMemoryClass(); } } /** * Get a usable cache directory (external if available, internal otherwise). * * @param context The context to use * @param uniqueName A unique directory name to append to the cache dir * @return The cache dir */ public static File getDiskCacheDir(Context context, String uniqueName) { // Check if media is mounted , if so, try and use external cache dir // otherwise use internal cache dir if (!isSdCardOK()) { return null; } final String cachePath = Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()) ? getExternalCacheDir(context).getPath() : context.getCacheDir().getPath(); return new File(cachePath + File.separator + uniqueName); } private static boolean isSdCardOK() { return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED); } private static String bytesToHexString(byte[] bytes) { // http://stackoverflow.com/questions/332079 StringBuilder sb = new StringBuilder(); for (byte aByte : bytes) { String hex = Integer.toHexString(0xFF & aByte); if (hex.length() == 1) { sb.append('0'); } sb.append(hex); } return sb.toString(); } /** * Get the size in bytes of a bitmap. * * @param bitmap * @return size in bytes */ // @TargetApi(12) public static int getBitmapSize(Bitmap bitmap) { if (OsVersionUtils.hasHoneycombMR1()) { return bitmap.getByteCount(); } // Pre HC-MR1 return bitmap.getRowBytes() * bitmap.getHeight(); } /** * Check if external storage is built-in or removable. * * @return True if external storage is removable (like an SD card), false * otherwise. */ // @TargetApi(9) public static boolean isExternalStorageRemovable() { return !OsVersionUtils.hasGingerbread() || Environment.isExternalStorageRemovable(); } /** * Get the external app cache directory. * * @param context The context to use * @return The external cache dir */ // @TargetApi(8) public static File getExternalCacheDir(Context context) { if (OsVersionUtils.hasFroyo()) { File file = context.getExternalCacheDir(); if (file != null) return file; } // Before Froyo we need to construct the external cache dir ourselves final String cacheDir = "/Android/data/" + context.getPackageName() + "/cache/"; return new File(Environment.getExternalStorageDirectory().getPath() + cacheDir); } /** * Check how much usable space is available at a given path. * * @param path The path to check * @return The space available in bytes */ // @TargetApi(9) public static long getUsableSpace(File path) { if (OsVersionUtils.hasGingerbread()) { return path.getUsableSpace(); } final StatFs stats = new StatFs(path.getPath()); return (long) stats.getBlockSize() * (long) stats.getAvailableBlocks(); } }