Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.koushikdutta.ion;
  
  import  android.graphics.Bitmap;
  import  android.os.Build;
  import  android.view.animation.Animation;
  import  android.view.animation.AnimationUtils;
  import  android.widget.ImageView;
  
 
 import java.util.List;

Created by koush on 5/23/13.
 
 abstract class IonBitmapRequestBuilder implements BitmapFutureBuilderBuilders.Any.BF {
     private static final SimpleFuture<Bitmap> FUTURE_BITMAP_NULL_URI = new SimpleFuture<Bitmap>() {
         {
             setComplete(new NullPointerException("uri"));
         }
     };
 
     Ion ion;
     int resizeWidth;
     int resizeHeight;
     boolean deepZoom;
 
     void reset() {
          = null;
          = null;
          = null;
          = 0;
          = 0;
          = .;
          = null;
          = false;
          = null;
     }
 
     public IonBitmapRequestBuilder(IonRequestBuilder builder) {
         this. = builder;
          = builder.ion;
     }
 
     public IonBitmapRequestBuilder(Ion ion) {
         this. = ion;
     }
 
     static void doAnimation(ImageView imageView, Animation animationint animationResource) {
         if (imageView == null)
             return;
         if (animation == null && animationResource != 0)
             animation = AnimationUtils.loadAnimation(imageView.getContext(), animationResource);
         if (animation == null) {
             imageView.setAnimation(null);
             return;
         }
 
         imageView.startAnimation(animation);
     }
 
     protected IonRequestBuilder ensureBuilder() {
         return ;
     }
 
     @Override
     public IonBitmapRequestBuilder transform(Transform transform) {
         if (transform == null)
             return this;
         if ( == null)
              = new ArrayList<Transform>();
         .add(transform);
         return this;
     }
 
     @Override
     public IonBitmapRequestBuilder postProcess(PostProcess postProcess) {
         if (this. == null)
             this. = new ArrayList<PostProcess>();
         this..add(postProcess);
         return transform(new TransformBitmap.PostProcessNullTransform(postProcess.key()));
     }
 
    private String computeDecodeKey() {
    }
    public static String computeDecodeKey(IonRequestBuilder builderint resizeWidthint resizeHeightboolean animateGifboolean deepZoom) {
        // the decode key is a hash of the uri of the image, and any decode
        // specific flags. this includes:
        // inSampleSize (determined from resizeWidth/resizeHeight)
        // gif animation mode
        // deep zoom
        String decodeKey = builder.uri;
        decodeKey += "resize=" + resizeWidth + "," + resizeHeight;
        if (!animateGif)
            decodeKey += ":noAnimate";
        if (deepZoom)
            decodeKey += ":deepZoom";
        return FileCache.toKeyString(decodeKey);
    }
    public void addDefaultTransform() {
        if ( > 0 ||  > 0) {
            if ( == null)
                 = new ArrayList<Transform>();
            .add(0, new DefaultTransform());
        }
        else if ( != null) {
            throw new IllegalStateException("Must call resize when using " + );
        }
    }
    public String computeBitmapKey(String decodeKey) {
        return computeBitmapKey(decodeKey);
    }
    public static String computeBitmapKey(String decodeKeyList<Transformtransforms) {
        assert decodeKey != null;
        // determine the key for this bitmap after all transformations
        String bitmapKey = decodeKey;
        if (transforms != null && transforms.size() > 0) {
            for (Transform transform : transforms) {
                bitmapKey += transform.key();
            }
            bitmapKey = FileCache.toKeyString(bitmapKey);
        }
        return bitmapKey;
    }
    @Override
        if (. || )
            return .;
        final String decodeKey = computeDecodeKey();
        addDefaultTransform();
        String bitmapKey = computeBitmapKey(decodeKey);
        BitmapInfo info = ...get(bitmapKey);
        // memory cache
        if (info != null && info.exception == null)
            return .;
        FileCache fileCache = ..getFileCache();
        if (hasTransforms() && fileCache.exists(bitmapKey))
            return .;
        if (fileCache.exists(decodeKey))
            return .;
        return .;
    }
    @Override
    public BitmapInfo asCachedBitmap() {
        final String decodeKey = computeDecodeKey();
        addDefaultTransform();
        String bitmapKey = computeBitmapKey(decodeKey);
        return ...get(bitmapKey);
    }
        return executeCache();
    }
    BitmapFetcher executeCache(int sampleWidthint sampleHeight) {
        final String decodeKey = computeDecodeKey();
        String bitmapKey = computeBitmapKey(decodeKey);
        // TODO: eliminate this allocation?
        BitmapFetcher ret = new BitmapFetcher();
        ret.bitmapKey = bitmapKey;
        ret.decodeKey = decodeKey;
        ret.hasTransforms = hasTransforms();
        ret.sampleWidth = sampleWidth;
        ret.sampleHeight = sampleHeight;
        ret.builder = ;
        ret.transforms = ;
        ret.animateGif =  != .;
        ret.deepZoom = ;
        ret.postProcess = ;
        // see if this request can be fulfilled from the cache
        if (!.) {
            BitmapInfo bitmap = ...get(bitmapKey);
            if (bitmap != null) {
                ret.info = bitmap;
                return ret;
            }
        }
        return ret;
    }
    @Override
    public Future<Bitmap> asBitmap() {
        if (. == null) {
            return ;
        }
        // see if we get something back synchronously
        addDefaultTransform();
        final BitmapFetcher bitmapFetcher = executeCache();
        if (bitmapFetcher.info != null) {
            SimpleFuture<Bitmap> ret = new SimpleFuture<Bitmap>();
            ret.setComplete(bitmapFetcher.info.exceptionbitmapFetcher.info.bitmap);
            return ret;
        }
        final BitmapInfoToBitmap ret = new BitmapInfoToBitmap(.);
        AsyncServer.post(.new Runnable() {
            @Override
            public void run() {
                bitmapFetcher.execute();
                // we're loading, so let's register for the result.
                ..add(bitmapFetcher.bitmapKeyret);
            }
        });
        return ret;
    }
    private void checkNoTransforms(String name) {
        if (hasTransforms()) {
            throw new IllegalStateException("Can't apply " + name + " after transform has been called."
             + name + " is applied to the original resized bitmap.");
        }
    }
    @Override
        checkNoTransforms("centerCrop");
         = .;
        return this;
    }
    @Override
    public IonBitmapRequestBuilder fitXY() {
        checkNoTransforms("fitXY");
         = .;
        return this;
    }
    @Override
        checkNoTransforms("fitCenter");
         = .;
        return this;
    }
    @Override
        checkNoTransforms("centerInside");
         = .;
        return this;
    }
    @Override
    public IonBitmapRequestBuilder resize(int widthint height) {
        // TODO: prevent multiple calls to resize and friends?
        if (hasTransforms()) {
            throw new IllegalStateException("Can't apply resize after transform has been called." +
            "resize is applied to the original bitmap.");
        }
        if ()
            throw new IllegalStateException("Can not resize with deepZoom.");
         = width;
         = height;
        return this;
    }
    @Override
    public IonBitmapRequestBuilder resizeWidth(int width) {
        return resize(width, 0);
    }
    @Override
    public IonBitmapRequestBuilder resizeHeight(int height) {
        return resize(0, height);
    }
	public IonBitmapRequestBuilder smartSize(boolean smartSize) {
        //don't want to disable device resize if user has already resized the Bitmap.
        if ( > 0 ||  > 0)
            throw new IllegalStateException("Can't set smart size after resize has been called.");
        if ()
            throw new IllegalStateException("Can not smartSize with deepZoom.");
        if (!smartSize) {
		}
        else {
             = 0;
             = 0;
        }
		return this;
	}
    @Override
        this. = mode;
        return this;
    }
    @Override
    public IonBitmapRequestBuilder deepZoom() {
        if (Build.VERSION.SDK_INT < 10)
            return this;
        this. = true;
        if ( > 0 ||  > 0)
            throw new IllegalStateException("Can't deepZoom with resize.");
        if (hasTransforms())
            throw new IllegalStateException("Can't deepZoom with transforms.");
         = 0;
         = 0;
        return this;
    }
    boolean hasTransforms() {
        return  != null && .size() > 0;
    }
New to GrepCode? Check out our FAQ X