Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.koushikdutta.ion.bitmap;
  
  import  android.annotation.TargetApi;
  import  android.app.ActivityManager;
  import  android.content.Context;
  import  android.content.res.AssetManager;
  import  android.content.res.Resources;
  import  android.graphics.Bitmap;
  import  android.graphics.BitmapFactory;
 import  android.graphics.BitmapRegionDecoder;
 import  android.graphics.Matrix;
 import  android.graphics.Point;
 import  android.graphics.Rect;
 import  android.net.Uri;
 import  android.os.Build;
 import  android.os.Looper;
 import  android.util.DisplayMetrics;
 import  android.util.Log;
 import  android.view.WindowManager;
 
 
 import java.io.File;
Created by koush on 5/23/13.
 
 public class IonBitmapCache {
     public static final long DEFAULT_ERROR_CACHE_DURATION = 30000L;
 
     Resources resources;
     DisplayMetrics metrics;
     Ion ion;
 
     public long getErrorCacheDuration() {
         return ;
     }
 
     public void setErrorCacheDuration(long errorCacheDuration) {
         this. = errorCacheDuration;
     }
 
     public IonBitmapCache(Ion ion) {
         Context context = ion.getContext();
         this. = ion;
          = new DisplayMetrics();
         ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE))
                 .getDefaultDisplay().getMetrics();
         final AssetManager mgr = context.getAssets();
          = new Resources(mgrcontext.getResources().getConfiguration());
          = new LruBitmapCache(getHeapSize(context) / 7);
     }
 
     public BitmapInfo remove(String key) {
         return .removeBitmapInfo(key);
     }
 
     public void clear() {
         .evictAllBitmapInfo();
     }
 
     double heapRatio = 1d / 7d;
     public double getHeapRatio() {
         return ;
     }
 
     public void setHeapRatio(double heapRatio) {
         this. = heapRatio;
     }
 
     public void put(BitmapInfo info) {
         assert Thread.currentThread() == Looper.getMainLooper().getThread();
         int maxSize = (int)(getHeapSize(.getContext()) * );
         if (maxSize != .maxSize())
             .setMaxSize(maxSize);
         .put(info.keyinfo);
     }
 
     public BitmapInfo get(String key) {
         if (key == null)
             return null;
 
         // see if this thing has an immediate cache hit
         BitmapInfo ret = .getBitmapInfo(key);
         if (ret == null || ret.bitmaps != null)
             return ret;
 
         // if this bitmap load previously errored out, see if it is time to retry
         // the fetch. connectivity error, server failure, etc, shouldn't be
         // cached indefinitely...
         if (ret.loadTime +  > System.currentTimeMillis())
             return ret;
        .remove(key);
        return null;
    }
    public void dump() {
        Log.i("IonBitmapCache""bitmap cache: " + .size());
        Log.i("IonBitmapCache""freeMemory: " + Runtime.getRuntime().freeMemory());
    }
    private Point computeTarget(int minxint miny) {
        int targetWidth = minx;
        int targetHeight = miny;
        if (targetWidth == 0)
            targetWidth = .;
        if (targetWidth <= 0)
            targetWidth = .;
        if (targetHeight == 0)
            targetHeight = .;
        if (targetHeight <= 0)
            targetHeight = .;
        return new Point(targetWidthtargetHeight);
    }
    private BitmapFactory.Options prepareBitmapOptions(BitmapFactory.Options oint minxint miny) {
        if (o.outWidth < 0 || o.outHeight < 0)
            return null;
        Point target = computeTarget(minxminy);
        int scale = Math.max(o.outWidth / target.x, o.outHeight / target.y);
        BitmapFactory.Options ret = new BitmapFactory.Options();
        ret.inSampleSize = scale;
        ret.outWidth = o.outWidth;
        ret.outHeight = o.outHeight;
        ret.outMimeType = o.outMimeType;
        return ret;
    }
    public BitmapFactory.Options prepareBitmapOptions(File fileint minxint miny) {
        BitmapFactory.Options o = new BitmapFactory.Options();
        o.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(file.toString(), o);
        return prepareBitmapOptions(ominxminy);
    }
    public BitmapFactory.Options prepareBitmapOptions(byte[] bytesint offsetint lengthint minxint miny) {
        BitmapFactory.Options o = new BitmapFactory.Options();
        o.inJustDecodeBounds = true;
        BitmapFactory.decodeByteArray(bytesoffsetlengtho);
        return prepareBitmapOptions(ominxminy);
    }
    public BitmapFactory.Options prepareBitmapOptions(Resources resint idint minxint miny) {
        BitmapFactory.Options o = new BitmapFactory.Options();
        o.inJustDecodeBounds = true;
        BitmapFactory.decodeResource(resido);
        return prepareBitmapOptions(ominxminy);
    }
    public BitmapFactory.Options prepareBitmapOptions(InputStream inint minxint miny) {
        BitmapFactory.Options o = new BitmapFactory.Options();
        o.inJustDecodeBounds = true;
        BitmapFactory.decodeStream(innullo);
        return prepareBitmapOptions(ominxminy);
    }
    private static Bitmap getRotatedBitmap(Bitmap bitmapint rotation) {
        if (bitmap == null)
            return null;
        if (rotation == 0)
            return bitmap;
        Matrix matrix = new Matrix();
        matrix.postRotate(rotation);
        return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrixtrue);
    }
    public static Bitmap loadBitmap(byte[] bytesint offsetint length, BitmapFactory.Options o) {
        assert Thread.currentThread() != Looper.getMainLooper().getThread();
        Bitmap bitmap = BitmapFactory.decodeByteArray(bytesoffsetlengtho);
        if (bitmap == null)
            return null;
        int rotation = Exif.getOrientation(bytesoffsetlength);
        return getRotatedBitmap(bitmaprotation);
    }
    @TargetApi(Build.VERSION_CODES.GINGERBREAD_MR1)
    public static Bitmap loadRegion(final BitmapRegionDecoder decoder, Rect sourceRectint inSampleSize) {
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inSampleSize = inSampleSize;
        return decoder.decodeRegion(sourceRectoptions);
    }
    public static Bitmap loadBitmap(Resources resint id, BitmapFactory.Options o) {
        assert Thread.currentThread() != Looper.getMainLooper().getThread();
        int rotation;
        InputStream in = null;
        try {
            in = res.openRawResource(id);
            byte[] bytes = new byte[50000];
            int length = in.read(bytes);
            rotation = Exif.getOrientation(bytes, 0, length);
        }
        catch (Exception e) {
            rotation = 0;
        }
        StreamUtility.closeQuietly(in);
        Bitmap bitmap = BitmapFactory.decodeResource(resido);
        return getRotatedBitmap(bitmaprotation);
    }
    public static Bitmap loadBitmap(InputStream stream, BitmapFactory.Options othrows IOException {
        assert Thread.currentThread() != Looper.getMainLooper().getThread();
        int rotation;
        MarkableInputStream in = new MarkableInputStream(stream);
        in.mark(50000);
        try {
            byte[] bytes = new byte[50000];
            int length = in.read(bytes);
            rotation = Exif.getOrientation(bytes, 0, length);
        }
        catch (Exception e) {
            rotation = 0;
        }
        in.reset();
        Bitmap bitmap = BitmapFactory.decodeStream(innullo);
        return getRotatedBitmap(bitmaprotation);
    }
    public static Bitmap loadBitmap(File file, BitmapFactory.Options o) {
        assert Thread.currentThread() != Looper.getMainLooper().getThread();
        int rotation;
        FileInputStream fin = null;
        try {
            fin = new FileInputStream(file);
            byte[] bytes = new byte[50000];
            int length = fin.read(bytes);
            rotation = Exif.getOrientation(bytes, 0, length);
        }
        catch (Exception e) {
            rotation = 0;
        }
        StreamUtility.closeQuietly(fin);
        Bitmap bitmap = BitmapFactory.decodeFile(file.toString(), o);
        return getRotatedBitmap(bitmaprotation);
    }
    private static int getHeapSize(final Context context) {
        return ((ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE)).getMemoryClass() * 1024 * 1024;
    }
New to GrepCode? Check out our FAQ X