public void init(
    Resources resources,DeferredReleaser deferredReleaser,DrawableFactory animatedDrawableFactory,Executor uiThreadExecutor,MemoryCache<CacheKey,CloseableImage> memoryCache,@Nullable ImmutableList<DrawableFactory> drawableFactories,@Nullable supplier<Boolean> debugOverlayEnabledsupplier) {
  mResources = resources;
  mDeferredReleaser = deferredReleaser;
  mAnimatedDrawableFactory = animatedDrawableFactory;
  mUiThreadExecutor = uiThreadExecutor;
  mMemoryCache = memoryCache;
  mDrawableFactories = drawableFactories;
  mDebugOverlayEnabledsupplier = debugOverlayEnabledsupplier;
}

protected PipelineDraweeController internalCreateController(
    Resources resources,@Nullable ImmutableList<DrawableFactory> globalDrawableFactories,@Nullable ImmutableList<DrawableFactory> customDrawableFactories,supplier<DataSource<CloseableReference<CloseableImage>>> dataSourcesupplier,String id,CacheKey cacheKey,Object callerContext) {
  PipelineDraweeController controller = new PipelineDraweeController(
      resources,deferredReleaser,animatedDrawableFactory,uiThreadExecutor,memoryCache,dataSourcesupplier,id,cacheKey,callerContext,globalDrawableFactories);
  controller.setCustomDrawableFactories(customDrawableFactories);
  return controller;
}

public PipelineDraweeController(
        Resources resources,Object callerContext) {
  this(
      resources,null);
}

public PipelineDraweeController(
    Resources resources,Object callerContext,@Nullable ImmutableList<DrawableFactory> globalDrawableFactories) {
  super(deferredReleaser,callerContext);
  mResources = resources;
  mAnimatedDrawableFactory = animatedDrawableFactory;
  mMemoryCache = memoryCache;
  mCacheKey = cacheKey;
  mGlobalDrawableFactories = globalDrawableFactories;
  init(dataSourcesupplier);
}

@Before
public void setUp() {
  mDeferredReleaser = mock(DeferredReleaser.class);
  mCallerContext = mock(Object.class);
  mDataSourcesupplier = mock(supplier.class);
  mDraweeHierarchy = mock(SettableDraweeHierarchy.class);
  mUiThreadExecutor = CallerThreadExecutor.getInstance();
  mController = new FakeDraweeController(
      mDeferredReleaser,mUiThreadExecutor,mDataSourcesupplier,"id",mCallerContext);
  doAnswer(
      new Answer<Object>() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
          ((DeferredReleaser.Releasable) invocation.getArguments()[0]).release();
          return null;
        }
      }).when(mDeferredReleaser).scheduleDeferredRelease(any(DeferredReleaser.Releasable.class));
  when(mDataSourcesupplier.get()).thenReturn(SimpleDataSource.<FakeImage>create());
}

public void init(
    Resources resources,@Nullable supplier<Boolean> debugOverlayEnabledsupplier) {
  mResources = resources;
  mDeferredReleaser = deferredReleaser;
  mAnimatedDrawableFactory = animatedDrawableFactory;
  mUiThreadExecutor = uiThreadExecutor;
  mMemoryCache = memoryCache;
  mDrawableFactories = drawableFactories;
  mDebugOverlayEnabledsupplier = debugOverlayEnabledsupplier;
}

protected PipelineDraweeController internalCreateController(
    Resources resources,globalDrawableFactories);
  controller.setCustomDrawableFactories(customDrawableFactories);
  return controller;
}

public PipelineDraweeController(
        Resources resources,null);
}

public PipelineDraweeController(
    Resources resources,callerContext);
  mResources = resources;
  mAnimatedDrawableFactory = animatedDrawableFactory;
  mMemoryCache = memoryCache;
  mCacheKey = cacheKey;
  mGlobalDrawableFactories = globalDrawableFactories;
  init(dataSourcesupplier);
}

@Before
public void setUp() {
  mDeferredReleaser = mock(DeferredReleaser.class);
  mCallerContext = mock(Object.class);
  mDataSourcesupplier = mock(supplier.class);
  mDraweeHierarchy = mock(SettableDraweeHierarchy.class);
  mUiThreadExecutor = CallerThreadExecutor.getInstance();
  mController = new FakeDraweeController(
      mDeferredReleaser,mCallerContext);
  doAnswer(
      new Answer<Object>() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
          ((DeferredReleaser.Releasable) invocation.getArguments()[0]).release();
          return null;
        }
      }).when(mDeferredReleaser).scheduleDeferredRelease(any(DeferredReleaser.Releasable.class));
  when(mDataSourcesupplier.get()).thenReturn(SimpleDataSource.<FakeImage>create());
}

public PipelineDraweeControllerBuildersupplier(
    Context context,ImagePipelineFactory imagePipelineFactory,Set<ControllerListener> boundControllerListeners,@Nullable DraweeConfig draweeConfig) {
  mContext = context;
  mImagePipeline = imagePipelineFactory.getimagePipeline();

  if (draweeConfig != null && draweeConfig.getPipelineDraweeControllerFactory() != null) {
    mPipelineDraweeControllerFactory = draweeConfig.getPipelineDraweeControllerFactory();
  } else {
    mPipelineDraweeControllerFactory = new PipelineDraweeControllerFactory();
  }
  mPipelineDraweeControllerFactory.init(
      context.getResources(),DeferredReleaser.getInstance(),imagePipelineFactory.getAnimatedDrawableFactory(context),UiThreadImmediateExecutorService.getInstance(),mImagePipeline.getBitmapMemoryCache(),draweeConfig != null
          ? draweeConfig.getCustomDrawableFactories()
          : null,draweeConfig != null
          ? draweeConfig.getDebugOverlayEnabledsupplier()
          : null);
  mBoundControllerListeners = boundControllerListeners;
}

public VolleyDraweeController(
    Resources resources,supplier<DataSource<Bitmap>> dataSourcesupplier,Object callerContext) {
  super(deferredReleaser,callerContext);
  mResources = resources;
  init(dataSourcesupplier);
}

public VolleyDraweeControllerBuildersupplier(
    Context context,ImageLoader imageLoader,Set<ControllerListener> boundControllerListeners) {
  mContext = context;
  mImageLoader = imageLoader;
  mVolleyDraweeControllerFactory = new VolleyDraweeControllerFactory(
      context.getResources(),UiThreadImmediateExecutorService.getInstance());
  mBoundControllerListeners = boundControllerListeners;
}

public VolleyDraweeControllerFactory(
    Resources resources,Executor uiThreadExecutor) {
  mResources = resources;
  mDeferredReleaser = deferredReleaser;
  mUiThreadExecutor = uiThreadExecutor;
}

public AbstractDraweeController(
    DeferredReleaser deferredReleaser,Executor uiThreadImmediateExecutor,Object callerContext) {
  mDeferredReleaser = deferredReleaser;
  mUiThreadImmediateExecutor = uiThreadImmediateExecutor;
  init(id,true);
}

public FakeDraweeController(
    DeferredReleaser deferredReleaser,supplier<DataSource<FakeImage>> dataSourcesupplier,callerContext);
  mDataSourcesupplier = dataSourcesupplier;
}

/**
 * Use {@link Builder} to build a DraweeSpan.
 */
private DraweeSpan(String uri,int verticalAlignment,Drawable placeHolder,boolean showAnim) {
    super(verticalAlignment);
    mImageUri = uri;
    mShouldShowAnim = showAnim;
    mDeferredReleaser = DeferredReleaser.getInstance();
    mPlaceHolder = placeHolder;
    // create forwarding drawable with placeholder
    mActualDrawable = new ForwardingDrawable(mPlaceHolder);
}

public PipelineDraweeControllerBuildersupplier(
    Context context,draweeConfig != null
          ? draweeConfig.getDebugOverlayEnabledsupplier()
          : null);
  mBoundControllerListeners = boundControllerListeners;
}

public VolleyDraweeController(
    Resources resources,callerContext);
  mResources = resources;
  init(dataSourcesupplier);
}

public VolleyDraweeControllerBuildersupplier(
    Context context,UiThreadImmediateExecutorService.getInstance());
  mBoundControllerListeners = boundControllerListeners;
}

public VolleyDraweeControllerFactory(
    Resources resources,Executor uiThreadExecutor) {
  mResources = resources;
  mDeferredReleaser = deferredReleaser;
  mUiThreadExecutor = uiThreadExecutor;
}

public AbstractDraweeController(
    DeferredReleaser deferredReleaser,true);
}

public FakeDraweeController(
    DeferredReleaser deferredReleaser,callerContext);
  mDataSourcesupplier = dataSourcesupplier;
}

/**
 * Returns an InputStream from the internal InputStream supplier if it's not null. Otherwise
 * returns an InputStream for the internal buffer reference if valid and null otherwise.
 *
 * <p>The caller has to close the InputStream after using it.
 */
public InputStream getInputStream() {
  if (mInputStreamsupplier != null) {
    return mInputStreamsupplier.get();
  }
  CloseableReference<PooledByteBuffer> pooledByteBufferRef =
      CloseableReference.cloneOrNull(mPooledByteBufferRef);
  if (pooledByteBufferRef != null) {
    try {
      return new PooledByteBufferInputStream(pooledByteBufferRef.get());
    } finally {
      CloseableReference.closeSafely(pooledByteBufferRef);
    }
  }
  return null;
}

/**
 * Returns an InputStream from the internal InputStream supplier if it's not null. Otherwise
 * returns an InputStream for the internal buffer reference if valid and null otherwise.
 *
 * <p>The caller has to close the InputStream after using it.
 */
public InputStream getInputStream() {
  if (mInputStreamsupplier != null) {
    return mInputStreamsupplier.get();
  }
  CloseableReference<PooledByteBuffer> pooledByteBufferRef =
      CloseableReference.cloneOrNull(mPooledByteBufferRef);
  if (pooledByteBufferRef != null) {
    try {
      return new PooledByteBufferInputStream(pooledByteBufferRef.get());
    } finally {
      CloseableReference.closeSafely(pooledByteBufferRef);
    }
  }
  return null;
}

private EncodedImage buildEncodedImage(
    PooledByteBuffer imageBytes,ExifInterface exifInterface) {
  Pair<Integer,Integer> dimensions =
      BitmapUtil.decodeDimensions(new PooledByteBufferInputStream(imageBytes));
  int rotationAngle = getRotationAngle(exifInterface);
  int width = dimensions != null ? dimensions.first : EncodedImage.UNKNowN_WIDTH;
  int height = dimensions != null ? dimensions.second : EncodedImage.UNKNowN_HEIGHT;
  EncodedImage encodedImage;
  CloseableReference<PooledByteBuffer> closeableByteBuffer = CloseableReference.of(imageBytes);
  try {
    encodedImage = new EncodedImage(closeableByteBuffer);
  } finally {
    CloseableReference.closeSafely(closeableByteBuffer);
  }
  encodedImage.setimageFormat(DefaultimageFormats.JPEG);
  encodedImage.setRotationAngle(rotationAngle);
  encodedImage.setWidth(width);
  encodedImage.setHeight(height);
  return encodedImage;
}

@Test
public void testReadFromStream() throws Exception {
  InputStream is = new PooledByteBufferInputStream(mPooledByteBuffer);
  byte[] tmp = new byte[BUFFER_LENGTH + 1];
  int bytesRead = is.read(tmp,tmp.length);
  assertEquals(BUFFER_LENGTH,bytesRead);
  for (int i = 0; i < BUFFER_LENGTH; i++) {
    assertEquals(BYTES[i],tmp[i]);
  }
  assertEquals(-1,is.read());
}

@Test
public void testReadFromStream() throws Exception {
  InputStream is = new PooledByteBufferInputStream(mPooledByteBuffer);
  byte[] tmp = new byte[BUFFER_LENGTH + 1];
  int bytesRead = is.read(tmp,is.read());
}

@Override
public BitmapRegionDecoder intercept(Chain chain) throws IOException {
    final Uri uri = chain.uri();
    BitmapRegionDecoder decoder = chain.chain(uri);
    if (decoder != null){
        return decoder;
    }

    if (UriUtil.isNetworkUri(uri)){
        ImagePipeline imagePipeline = ImagePipelineFactory.getInstance().getimagePipeline();

        ImageRequest request = ImageRequest.fromUri(uri);
        DataSource<CloseableReference<PooledByteBuffer>> dataSource = imagePipeline.fetchEncodedImage(request,null);
        try {
            CloseableReference<PooledByteBuffer> ref = DataSources.waitForFinalResult(dataSource);
            if (ref == null){
                return null;
            }
            PooledByteBuffer result = ref.get();
            if (BuildConfig.DEBUG) {
                Log.d("FrescoInterceptor","从我这加载");
            }
            try {
                InputStream inputStream = new PooledByteBufferInputStream(result);
                Closeables.closeQuietly(inputStream);
                return BitmapRegionDecoder.newInstance(inputStream,false);
            } catch (IOException e) {
                ImageRequest imageRequest=ImageRequest.fromUri(uri);
                CacheKey cacheKey= DefaultCacheKeyFactory.getInstance().getEncodedCacheKey(imageRequest,null);
                BinaryResource resource = ImagePipelineFactory.getInstance().getMainFileCache().getResource(cacheKey);
                File file=((FileBinaryResource)resource).getFile();
                if (BuildConfig.DEBUG) {
                    Log.d("FrescoInterceptor",file.getName());
                }
                return Interceptors.fixJPEGDecoder(file,e);
            }
        } catch (Throwable throwable) {
            if (BuildConfig.DEBUG) {
                Log.d("FrescoInterceptor","intercept: 加载失败了");
            }
            throwable.printstacktrace();
            return null;
        }
    }

    return null;
}

/**
 * Decodes a GIF into a CloseableImage.
 * @param encodedImage encoded image (native byte array holding the encoded bytes and Meta data)
 * @param options the options for the decode
 * @param bitmapConfig the Bitmap.Config used to generate the output bitmaps
 * @return a {@link CloseableImage} for the GIF image
 */
public CloseableImage decodeGif(
    final EncodedImage encodedImage,final ImageDecodeOptions options,final Bitmap.Config bitmapConfig) {
  if (sgifAnimatedimagedecoder == null) {
    throw new UnsupportedOperationException("To encode animated gif please add the dependency " +
        "to the animated-gif module");
  }
  final CloseableReference<PooledByteBuffer> bytesRef = encodedImage.getByteBufferRef();
  Preconditions.checkNotNull(bytesRef);
  try {
    final PooledByteBuffer input = bytesRef.get();
    AnimatedImage gifImage = sgifAnimatedimagedecoder.decode(input.getNativePtr(),input.size());

    return getCloseableImage(options,gifImage,bitmapConfig);
  } finally {
    CloseableReference.closeSafely(bytesRef);
  }
}

/**
 * Decode a WebP into a CloseableImage.
 * @param encodedImage encoded image (native byte array holding the encoded bytes and Meta data)
 * @param options the options for the decode
 * @param bitmapConfig the Bitmap.Config used to generate the output bitmaps
 * @return a {@link CloseableImage} for the WebP image
 */
public CloseableImage decodeWebP(
    final EncodedImage encodedImage,final Bitmap.Config bitmapConfig) {
  if (sWebpAnimatedimagedecoder == null) {
    throw new UnsupportedOperationException("To encode animated webp please add the dependency " +
        "to the animated-webp module");
  }
  final CloseableReference<PooledByteBuffer> bytesRef = encodedImage.getByteBufferRef();
  Preconditions.checkNotNull(bytesRef);
  try {
    final PooledByteBuffer input = bytesRef.get();
    AnimatedImage webPImage = sWebpAnimatedimagedecoder.decode(
        input.getNativePtr(),input.size());
    return getCloseableImage(options,webPImage,bitmapConfig);
  } finally {
    CloseableReference.closeSafely(bytesRef);
  }
}

public EncodedImage cloneOrNull() {
  EncodedImage encodedImage;
  if (mInputStreamsupplier != null) {
      encodedImage = new EncodedImage(mInputStreamsupplier,mStreamSize);
  } else {
    CloseableReference<PooledByteBuffer> pooledByteBufferRef =
        CloseableReference.cloneOrNull(mPooledByteBufferRef);
    try {
      encodedImage = (pooledByteBufferRef == null) ? null : new EncodedImage(pooledByteBufferRef);
    } finally {
      // Close the recently created reference since it will be cloned again in the constructor.
      CloseableReference.closeSafely(pooledByteBufferRef);
    }
  }
  if (encodedImage != null) {
    encodedImage.copyMetaDataFrom(this);
  }
  return encodedImage;
}

/**
 * Returns an InputStream from the internal InputStream supplier if it's not null. Otherwise
 * returns an InputStream for the internal buffer reference if valid and null otherwise.
 *
 * <p>The caller has to close the InputStream after using it.
 */
public InputStream getInputStream() {
  if (mInputStreamsupplier != null) {
    return mInputStreamsupplier.get();
  }
  CloseableReference<PooledByteBuffer> pooledByteBufferRef =
      CloseableReference.cloneOrNull(mPooledByteBufferRef);
  if (pooledByteBufferRef != null) {
    try {
      return new PooledByteBufferInputStream(pooledByteBufferRef.get());
    } finally {
      CloseableReference.closeSafely(pooledByteBufferRef);
    }
  }
  return null;
}

/**
 * Returns first n bytes of encoded image as hexbytes
 *
 * @param length the number of bytes to return
 */
public String getFirstBytesAsHexString(int length) {
  CloseableReference<PooledByteBuffer> imageBuffer = getByteBufferRef();
  if (imageBuffer == null) {
    return "";
  }
  int imageSize = getSize();
  int resultSampleSize = Math.min(imageSize,length);
  byte[] bytesBuffer = new byte[resultSampleSize];
  try {
    PooledByteBuffer pooledByteBuffer = imageBuffer.get();
    if (pooledByteBuffer == null) {
      return "";
    }
    pooledByteBuffer.read(0,bytesBuffer,resultSampleSize);
  } finally {
    imageBuffer.close();
  }
  StringBuilder stringBuilder = new StringBuilder(bytesBuffer.length * 2);
  for (byte b : bytesBuffer) {
    stringBuilder.append(String.format("%02X",b));
  }
  return stringBuilder.toString();
}

public CloseableReference<PooledByteBuffer> generate(short width,short height) {
  PooledByteBufferOutputStream os = null;
  try {
    os = mPooledByteBufferFactory.newOutputStream(
        EMPTY_JPEG_PREFIX.length + EMPTY_JPEG_SUFFIX.length + 4);
    os.write(EMPTY_JPEG_PREFIX);
    os.write((byte) (height >> 8));
    os.write((byte) (height & 0x00ff));
    os.write((byte) (width >> 8));
    os.write((byte) (width & 0x00ff));
    os.write(EMPTY_JPEG_SUFFIX);
    return CloseableReference.of(os.toByteBuffer());
  } catch (IOException e) {
    throw new RuntimeException(e);
  } finally {
    if (os != null) {
      os.close();
    }
  }
}

/**
 * Decodes a byteArray into a purgeable bitmap
 *
 * @param bytesRef the byte buffer that contains the encoded bytes
 * @return
 */
@Override
protected Bitmap decodeByteArrayAsPurgeable(
    CloseableReference<PooledByteBuffer> bytesRef,BitmapFactory.Options options) {
  final PooledByteBuffer pooledByteBuffer = bytesRef.get();
  final int length = pooledByteBuffer.size();
  final CloseableReference<byte[]> encodedBytesArrayRef = mFlexByteArrayPool.get(length);
  try {
    final byte[] encodedBytesArray = encodedBytesArrayRef.get();
    pooledByteBuffer.read(0,encodedBytesArray,length);
    Bitmap bitmap = BitmapFactory.decodeByteArray(
        encodedBytesArray,length,options);
    return Preconditions.checkNotNull(bitmap,"BitmapFactory returned null");
  } finally {
    CloseableReference.closeSafely(encodedBytesArrayRef);
  }
}

/**
 * Creates a bitmap from encoded bytes.
 *
 * @param encodedImage the encoded image with reference to the encoded bytes
 * @param bitmapConfig the {@link android.graphics.Bitmap.Config} used to create the decoded
 *     Bitmap
 * @param regionToDecode optional image region to decode. currently not supported.
 * @return the bitmap
 * @throws TooManyBitmapsException if the pool is full
 * @throws java.lang.OutOfMemoryError if the Bitmap cannot be allocated
 */
@Override
public CloseableReference<Bitmap> decodeFromEncodedImage(
    final EncodedImage encodedImage,Bitmap.Config bitmapConfig,@Nullable Rect regionToDecode) {
  BitmapFactory.Options options = getBitmapFactoryOptions(
      encodedImage.getSampleSize(),bitmapConfig);
  CloseableReference<PooledByteBuffer> bytesRef = encodedImage.getByteBufferRef();
  Preconditions.checkNotNull(bytesRef);
  try {
    Bitmap bitmap = decodeByteArrayAsPurgeable(bytesRef,options);
    return pinBitmap(bitmap);
  } finally {
    CloseableReference.closeSafely(bytesRef);
  }
}

/**
 * Creates a bitmap from encoded JPEG bytes. Supports a partial JPEG image.
 *
 * @param encodedImage the encoded image with reference to the encoded bytes
 * @param bitmapConfig the {@link android.graphics.Bitmap.Config} used to create the decoded
 *     Bitmap
 * @param regionToDecode optional image region to decode. currently not supported.
 * @param length the number of encoded bytes in the buffer
 * @return the bitmap
 * @throws TooManyBitmapsException if the pool is full
 * @throws java.lang.OutOfMemoryError if the Bitmap cannot be allocated
 */
@Override
public CloseableReference<Bitmap> decodeJPEGFromEncodedImage(
    final EncodedImage encodedImage,@Nullable Rect regionToDecode,int length) {
  BitmapFactory.Options options = getBitmapFactoryOptions(
      encodedImage.getSampleSize(),bitmapConfig);
  final CloseableReference<PooledByteBuffer> bytesRef = encodedImage.getByteBufferRef();
  Preconditions.checkNotNull(bytesRef);
  try {
    Bitmap bitmap = decodeJPEGByteArrayAsPurgeable(bytesRef,options);
    return pinBitmap(bitmap);
  } finally {
    CloseableReference.closeSafely(bytesRef);
  }
}

protected Bitmap decodeFileDescriptorAsPurgeable(
    CloseableReference<PooledByteBuffer> bytesRef,int inputLength,byte[] suffix,BitmapFactory.Options options) {
  MemoryFile memoryFile = null;
  try {
    memoryFile = copyToMemoryFile(bytesRef,inputLength,suffix);
    FileDescriptor fd = getMemoryFileDescriptor(memoryFile);
    Bitmap bitmap = sWebpBitmapFactory.decodeFileDescriptor(fd,null,"BitmapFactory returned null");
  } catch (IOException e) {
    throw Throwables.propagate(e);
  } finally {
    if (memoryFile != null) {
      memoryFile.close();
    }
  }
}

public static MemoryCache<CacheKey,PooledByteBuffer> get(
    final CountingMemoryCache<CacheKey,PooledByteBuffer> encodedCountingMemoryCache,final ImageCacheStatsTracker imageCacheStatsTracker) {

  imageCacheStatsTracker.registerEncodedMemoryCache(encodedCountingMemoryCache);

  MemoryCacheTracker memoryCacheTracker = new MemoryCacheTracker<CacheKey>() {
    @Override
    public void onCacheHit(CacheKey cacheKey) {
      imageCacheStatsTracker.onMemoryCacheHit(cacheKey);
    }

    @Override
    public void onCacheMiss() {
      imageCacheStatsTracker.onMemoryCacheMiss();
    }

    @Override
    public void onCachePut() {
      imageCacheStatsTracker.onMemoryCachePut();
    }
  };

  return new InstrumentedMemoryCache<>(encodedCountingMemoryCache,memoryCacheTracker);
}

/** Creates a memory-backed encoded image from the stream. The stream is closed. */
protected EncodedImage getByteBufferBackedEncodedImage(
    InputStream inputStream,int length) throws IOException {
  CloseableReference<PooledByteBuffer> ref = null;
  try {
    if (length <= 0) {
      ref = CloseableReference.of(mPooledByteBufferFactory.newByteBuffer(inputStream));
    } else {
      ref = CloseableReference.of(mPooledByteBufferFactory.newByteBuffer(inputStream,length));
    }
    return new EncodedImage(ref);
  } finally {
    Closeables.closeQuietly(inputStream);
    CloseableReference.closeSafely(ref);
  }
}

ProducerFactory createProducerFactory(
Context context,ByteArrayPool byteArrayPool,imagedecoder imagedecoder,ProgressiveJpegConfig progressiveJpegConfig,boolean downsampleEnabled,boolean resizeAndRotateEnabledForNetwork,boolean decodeCancellationEnabled,supplier<Boolean> experimentalSmartResizingEnabled,Executorsupplier executorsupplier,PooledByteBufferFactory pooledByteBufferFactory,MemoryCache<CacheKey,CloseableImage> bitmapMemoryCache,PooledByteBuffer> encodedMemoryCache,BuffereddiskCache defaultBuffereddiskCache,BuffereddiskCache smallImageBuffereddiskCache,MediaVariationsIndex mediaVariationsIndex,CacheKeyFactory cacheKeyFactory,PlatformBitmapFactory platformBitmapFactory,int bitmapPreparetoDrawMinSizeBytes,int bitmapPreparetoDrawMaxSizeBytes,boolean bitmapPreparetoDrawForPrefetch);

/**
 * Returns a sequence that can be used for a request for an encoded image from either network or
 * local files.
 *
 * @param imageRequest the request that will be submitted
 * @return the sequence that should be used to process the request
 */
public Producer<CloseableReference<PooledByteBuffer>> getEncodedImageProducerSequence(
    ImageRequest imageRequest) {
  validateEncodedImageRequest(imageRequest);
  final Uri uri = imageRequest.getSourceUri();

  switch (imageRequest.getSourceUriType()) {
    case SOURCE_TYPE_NETWORK:
      return getNetworkFetchEncodedImageProducerSequence();
    case SOURCE_TYPE_LOCAL_VIDEO_FILE:
    case SOURCE_TYPE_LOCAL_IMAGE_FILE:
      return getLocalFileFetchEncodedImageProducerSequence();
    default:
      throw new IllegalArgumentException(
          "Unsupported uri scheme for encoded image fetch! Uri is: "
              + getShortenedUriString(uri));
  }
}

public ImagePipeline(
    ProducerSequenceFactory producerSequenceFactory,Set<RequestListener> requestListeners,supplier<Boolean> isPrefetchEnabledsupplier,BuffereddiskCache mainBuffereddiskCache,ThreadHandoffProducerQueue threadHandoffProducerQueue,supplier<Boolean> suppressBitmapPrefetchingsupplier) {
  mIdCounter = new AtomicLong();
  mProducerSequenceFactory = producerSequenceFactory;
  mRequestListener = new ForwardingRequestListener(requestListeners);
  mIsPrefetchEnabledsupplier = isPrefetchEnabledsupplier;
  mBitmapMemoryCache = bitmapMemoryCache;
  mEncodedMemoryCache = encodedMemoryCache;
  mMainBuffereddiskCache = mainBuffereddiskCache;
  mSmallImageBuffereddiskCache = smallImageBuffereddiskCache;
  mCacheKeyFactory = cacheKeyFactory;
  mThreadHandoffProducerQueue = threadHandoffProducerQueue;
  mSuppressBitmapPrefetchingsupplier = suppressBitmapPrefetchingsupplier;
}

/**
 * Returns a DataSource supplier that will on get submit the request for execution and return a
 * DataSource representing the pending results of the task.
 *
 * @param imageRequest the request to submit (what to execute).
 * @return a DataSource representing pending results and completion of the request
 */
public supplier<DataSource<CloseableReference<PooledByteBuffer>>>
getEncodedImageDataSourcesupplier(
    final ImageRequest imageRequest,final Object callerContext) {
  return new supplier<DataSource<CloseableReference<PooledByteBuffer>>>() {
    @Override
    public DataSource<CloseableReference<PooledByteBuffer>> get() {
      return fetchEncodedImage(imageRequest,callerContext);
    }

    @Override
    public String toString() {
      return Objects.toStringHelper(this)
          .add("uri",imageRequest.getSourceUri())
          .toString();
    }
  };
}

@Test
public void testFetchAssetResource() throws Exception {
  PooledByteBuffer pooledByteBuffer = mock(PooledByteBuffer.class);
  when(mAssetManager.open(eq(TEST_FILENAME),eq(AssetManager.ACCESS_STREAMING)))
      .thenReturn(new ByteArrayInputStream(new byte[TEST_DATA_LENGTH]));
  when(mPooledByteBufferFactory.newByteBuffer(any(InputStream.class),eq(TEST_DATA_LENGTH)))
      .thenReturn(pooledByteBuffer);

  mLocalAssetFetchProducer.produceResults(mConsumer,mProducerContext);
  mExecutor.runUntilIdle();

  assertEquals(
      2,mCapturedEncodedImage.getByteBufferRef()
          .getUnderlyingReferenceTestOnly().getRefCountTestOnly());
  assertSame(pooledByteBuffer,mCapturedEncodedImage.getByteBufferRef().get());
  verify(mProducerListener).onProducerStart(mRequestId,PRODUCER_NAME);
  verify(mProducerListener).onProducerFinishWithSuccess(mRequestId,PRODUCER_NAME,null);
  verify(mProducerListener).onUltimateProducerReached(mRequestId,true);
}

@Test
public void testQualifiedResourceUri() throws Exception {
  PooledByteBuffer pooledByteBuffer = mock(PooledByteBuffer.class);
  when(mPooledByteBufferFactory.newByteBuffer(any(InputStream.class)))
      .thenReturn(pooledByteBuffer);

  when(mContentResolver.openInputStream(mContentUri))
      .thenReturn(mock(InputStream.class));

  mQualifiedResourceFetchProducer.produceResults(mConsumer,mProducerContext);
  mExecutor.runUntilIdle();

  verify(mPooledByteBufferFactory,times(1)).newByteBuffer(any(InputStream.class));
  verify(mContentResolver,times(1)).openInputStream(mContentUri);

  verify(mProducerListener).onProducerStart(REQUEST_ID,PRODUCER_NAME);
  verify(mProducerListener).onProducerFinishWithSuccess(REQUEST_ID,null);
}

@Test
public void testFetchLocalResource() throws Exception {
  PooledByteBuffer pooledByteBuffer = mock(PooledByteBuffer.class);
  when(mPooledByteBufferFactory.newByteBuffer(any(InputStream.class),eq(TEST_DATA_LENGTH)))
      .thenReturn(pooledByteBuffer);
  when(mResources.openRawResource(eq(TEST_ID)))
      .thenReturn(new ByteArrayInputStream(new byte[TEST_DATA_LENGTH]));

  mLocalResourceFetchProducer.produceResults(mConsumer,true);
}

@Before
public void setUp() {
  MockitoAnnotations.initMocks(this);
  mRemoveMetaDataProducer = new RemoveImageTransformMetaDataProducer(mInputProducer);

  mIntermediateByteBuffer = mock(PooledByteBuffer.class);
  mFinalByteBuffer = mock(PooledByteBuffer.class);

  mIntermediateResult = CloseableReference.of(mIntermediateByteBuffer);
  mFinalResult = CloseableReference.of(mFinalByteBuffer);

  mRemoveMetaDataConsumer = null;
  doAnswer(
      new Answer() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
          mRemoveMetaDataConsumer = (Consumer<EncodedImage>) invocation.getArguments()[0];
          return null;
        }
      }).when(mInputProducer).produceResults(any(Consumer.class),any(ProducerContext.class));
  mRemoveMetaDataProducer.produceResults(mConsumer,mProducerContext);
}

@Before
public void setUp() {
  MockitoAnnotations.initMocks(this);
  powermockito.mockStatic(ImageFormatChecker.class,JfifUtil.class,BitmapUtil.class);

  mAddMetaDataProducer = new AddImageTransformMetaDataProducer(mInputProducer);

  mIntermediateResultBufferRef = CloseableReference.of(mock(PooledByteBuffer.class));
  mFinalResultBufferRef = CloseableReference.of(mock(PooledByteBuffer.class));

  mIntermediateResult = new EncodedImage(mIntermediateResultBufferRef);
  mFinalResult = new EncodedImage(mFinalResultBufferRef);

  mAddMetaDataConsumer = null;
  doAnswer(
      new Answer() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
          mAddMetaDataConsumer =
              (Consumer<EncodedImage>) invocation.getArguments()[0];
          return null;
        }
      }).when(mInputProducer).produceResults(any(Consumer.class),any(ProducerContext.class));
  mAddMetaDataProducer.produceResults(mConsumer,mProducerContext);
}

@Test
public void testFetchLocalContentUri() throws Exception {
  PooledByteBuffer pooledByteBuffer = mock(PooledByteBuffer.class);
  when(mPooledByteBufferFactory.newByteBuffer(any(InputStream.class)))
      .thenReturn(pooledByteBuffer);

  when(mContentResolver.openInputStream(mContentUri)).thenReturn(mock(InputStream.class));
  mLocalContentUriFetchProducer.produceResults(mConsumer,mProducerContext);

  mExecutor.runUntilIdle();

  assertEquals(
      2,PRODUCER_NAME);
  verify(mProducerListener).onUltimateProducerReached(mRequestId,true);
}

@Test
public void testFetchLocalFile() throws Exception {
  PooledByteBuffer pooledByteBuffer = mock(PooledByteBuffer.class);
  when(mPooledByteBufferFactory.newByteBuffer(any(InputStream.class),eq(INPUT_STREAM_LENGTH)))
      .thenReturn(pooledByteBuffer);
  mLocalFileFetchProducer.produceResults(mConsumer,mProducerContext);
  mExecutor.runUntilIdle();
  assertEquals(
      2,true);
}

@Test
public void testEncodedMemoryCacheGetNotFoundInputProducerSuccess() {
  setupEncodedMemoryCacheGetNotFound();
  setupInputProducerStreamingSuccess();
  mEncodedMemoryCacheProducer.produceResults(mConsumer,mProducerContext);
  verify(mMemoryCache,never()).cache(mCacheKey,mIntermediateImageReference);
  ArgumentCaptor<CloseableReference> argumentCaptor =
      ArgumentCaptor.forClass(CloseableReference.class);
  verify(mMemoryCache).cache(eq(mCacheKey),argumentCaptor.capture());
  CloseableReference<PooledByteBuffer> capturedRef =
      (CloseableReference<PooledByteBuffer>) argumentCaptor.getValue();
  Assert.assertSame(
      mFinalImageReference.getUnderlyingReferenceTestOnly(),capturedRef.getUnderlyingReferenceTestOnly());
  verify(mConsumer).onNewResult(mIntermediateEncodedImage,Consumer.NO_FLAGS);
  verify(mConsumer).onNewResult(mFinalEncodedImage,Consumer.IS_LAST);
  Assert.assertTrue(EncodedImage.isValid(mFinalEncodedImageClone));
  verify(mProducerListener).onProducerStart(mRequestId,PRODUCER_NAME);
  Map<String,String> extraMap =
      ImmutableMap.of(EncodedMemoryCacheProducer.EXTRA_CACHED_VALUE_FOUND,"false");
  verify(mProducerListener).onProducerFinishWithSuccess(mRequestId,extraMap);
  verify(mProducerListener,never())
      .onUltimateProducerReached(anyString(),anyString(),anyBoolean());
}

/**
 * Decodes a GIF into a CloseableImage.
 * @param encodedImage encoded image (native byte array holding the encoded bytes and Meta data)
 * @param options the options for the decode
 * @param bitmapConfig the Bitmap.Config used to generate the output bitmaps
 * @return a {@link CloseableImage} for the GIF image
 */
public CloseableImage decodeGif(
    final EncodedImage encodedImage,bitmapConfig);
  } finally {
    CloseableReference.closeSafely(bytesRef);
  }
}

/**
 * Decode a WebP into a CloseableImage.
 * @param encodedImage encoded image (native byte array holding the encoded bytes and Meta data)
 * @param options the options for the decode
 * @param bitmapConfig the Bitmap.Config used to generate the output bitmaps
 * @return a {@link CloseableImage} for the WebP image
 */
public CloseableImage decodeWebP(
    final EncodedImage encodedImage,bitmapConfig);
  } finally {
    CloseableReference.closeSafely(bytesRef);
  }
}

public EncodedImage cloneOrNull() {
  EncodedImage encodedImage;
  if (mInputStreamsupplier != null) {
      encodedImage = new EncodedImage(mInputStreamsupplier,mStreamSize);
  } else {
    CloseableReference<PooledByteBuffer> pooledByteBufferRef =
        CloseableReference.cloneOrNull(mPooledByteBufferRef);
    try {
      encodedImage = (pooledByteBufferRef == null) ? null : new EncodedImage(pooledByteBufferRef);
    } finally {
      // Close the recently created reference since it will be cloned again in the constructor.
      CloseableReference.closeSafely(pooledByteBufferRef);
    }
  }
  if (encodedImage != null) {
    encodedImage.copyMetaDataFrom(this);
  }
  return encodedImage;
}

/**
 * Returns an InputStream from the internal InputStream supplier if it's not null. Otherwise
 * returns an InputStream for the internal buffer reference if valid and null otherwise.
 *
 * <p>The caller has to close the InputStream after using it.
 */
public InputStream getInputStream() {
  if (mInputStreamsupplier != null) {
    return mInputStreamsupplier.get();
  }
  CloseableReference<PooledByteBuffer> pooledByteBufferRef =
      CloseableReference.cloneOrNull(mPooledByteBufferRef);
  if (pooledByteBufferRef != null) {
    try {
      return new PooledByteBufferInputStream(pooledByteBufferRef.get());
    } finally {
      CloseableReference.closeSafely(pooledByteBufferRef);
    }
  }
  return null;
}

/**
 * Returns first n bytes of encoded image as hexbytes
 *
 * @param length the number of bytes to return
 */
public String getFirstBytesAsHexString(int length) {
  CloseableReference<PooledByteBuffer> imageBuffer = getByteBufferRef();
  if (imageBuffer == null) {
    return "";
  }
  int imageSize = getSize();
  int resultSampleSize = Math.min(imageSize,b));
  }
  return stringBuilder.toString();
}

public CloseableReference<PooledByteBuffer> generate(short width,short height) {
  PooledByteBufferOutputStream os = null;
  try {
    os = mPooledByteBufferFactory.newOutputStream(
        EMPTY_JPEG_PREFIX.length + EMPTY_JPEG_SUFFIX.length + 4);
    os.write(EMPTY_JPEG_PREFIX);
    os.write((byte) (height >> 8));
    os.write((byte) (height & 0x00ff));
    os.write((byte) (width >> 8));
    os.write((byte) (width & 0x00ff));
    os.write(EMPTY_JPEG_SUFFIX);
    return CloseableReference.of(os.toByteBuffer());
  } catch (IOException e) {
    throw new RuntimeException(e);
  } finally {
    if (os != null) {
      os.close();
    }
  }
}

/**
 * Decodes a byteArray into a purgeable bitmap
 *
 * @param bytesRef the byte buffer that contains the encoded bytes
 * @return
 */
@Override
protected Bitmap decodeByteArrayAsPurgeable(
    CloseableReference<PooledByteBuffer> bytesRef,"BitmapFactory returned null");
  } finally {
    CloseableReference.closeSafely(encodedBytesArrayRef);
  }
}

/**
 * Creates a bitmap from encoded bytes.
 *
 * @param encodedImage the encoded image with reference to the encoded bytes
 * @param bitmapConfig the {@link android.graphics.Bitmap.Config} used to create the decoded
 *     Bitmap
 * @param regionToDecode optional image region to decode. currently not supported.
 * @return the bitmap
 * @throws TooManyBitmapsException if the pool is full
 * @throws java.lang.OutOfMemoryError if the Bitmap cannot be allocated
 */
@Override
public CloseableReference<Bitmap> decodeFromEncodedImage(
    final EncodedImage encodedImage,options);
    return pinBitmap(bitmap);
  } finally {
    CloseableReference.closeSafely(bytesRef);
  }
}

/**
 * Creates a bitmap from encoded JPEG bytes. Supports a partial JPEG image.
 *
 * @param encodedImage the encoded image with reference to the encoded bytes
 * @param bitmapConfig the {@link android.graphics.Bitmap.Config} used to create the decoded
 *     Bitmap
 * @param regionToDecode optional image region to decode. currently not supported.
 * @param length the number of encoded bytes in the buffer
 * @return the bitmap
 * @throws TooManyBitmapsException if the pool is full
 * @throws java.lang.OutOfMemoryError if the Bitmap cannot be allocated
 */
@Override
public CloseableReference<Bitmap> decodeJPEGFromEncodedImage(
    final EncodedImage encodedImage,options);
    return pinBitmap(bitmap);
  } finally {
    CloseableReference.closeSafely(bytesRef);
  }
}

protected Bitmap decodeFileDescriptorAsPurgeable(
    CloseableReference<PooledByteBuffer> bytesRef,"BitmapFactory returned null");
  } catch (IOException e) {
    throw Throwables.propagate(e);
  } finally {
    if (memoryFile != null) {
      memoryFile.close();
    }
  }
}

public static MemoryCache<CacheKey,memoryCacheTracker);
}

private void notifyConsumer(
    PooledByteBufferOutputStream pooledOutputStream,@Consumer.Status int status,@Nullable BytesRange responseBytesRange,Consumer<EncodedImage> consumer) {
  CloseableReference<PooledByteBuffer> result =
      CloseableReference.of(pooledOutputStream.toByteBuffer());
  EncodedImage encodedImage = null;
  try {
    encodedImage = new EncodedImage(result);
    encodedImage.setBytesRange(responseBytesRange);
    encodedImage.parseMetaData();
    consumer.onNewResult(encodedImage,status);
  } finally {
    EncodedImage.closeSafely(encodedImage);
    CloseableReference.closeSafely(result);
  }
}

private EncodedImage buildEncodedImage(
    PooledByteBuffer imageBytes,ExifInterface exifInterface) {
  Pair<Integer,Integer> dimensions =
      BitmapUtil.decodeDimensions(new PooledByteBufferInputStream(imageBytes));
  int rotationAngle = getRotationAngle(exifInterface);
  int width = dimensions != null ? dimensions.first : EncodedImage.UNKNowN_WIDTH;
  int height = dimensions != null ? dimensions.second : EncodedImage.UNKNowN_HEIGHT;
  EncodedImage encodedImage;
  CloseableReference<PooledByteBuffer> closeableByteBuffer = CloseableReference.of(imageBytes);
  try {
    encodedImage = new EncodedImage(closeableByteBuffer);
  } finally {
    CloseableReference.closeSafely(closeableByteBuffer);
  }
  encodedImage.setimageFormat(DefaultimageFormats.JPEG);
  encodedImage.setRotationAngle(rotationAngle);
  encodedImage.setWidth(width);
  encodedImage.setHeight(height);
  return encodedImage;
}

/** Creates a memory-backed encoded image from the stream. The stream is closed. */
protected EncodedImage getByteBufferBackedEncodedImage(
    InputStream inputStream,length));
    }
    return new EncodedImage(ref);
  } finally {
    Closeables.closeQuietly(inputStream);
    CloseableReference.closeSafely(ref);
  }
}

ProducerFactory createProducerFactory(
Context context,boolean bitmapPreparetoDrawForPrefetch);

/**
 * Returns a sequence that can be used for a request for an encoded image from either network or
 * local files.
 *
 * @param imageRequest the request that will be submitted
 * @return the sequence that should be used to process the request
 */
public Producer<CloseableReference<PooledByteBuffer>> getEncodedImageProducerSequence(
    ImageRequest imageRequest) {
  validateEncodedImageRequest(imageRequest);
  final Uri uri = imageRequest.getSourceUri();

  switch (imageRequest.getSourceUriType()) {
    case SOURCE_TYPE_NETWORK:
      return getNetworkFetchEncodedImageProducerSequence();
    case SOURCE_TYPE_LOCAL_VIDEO_FILE:
    case SOURCE_TYPE_LOCAL_IMAGE_FILE:
      return getLocalFileFetchEncodedImageProducerSequence();
    default:
      throw new IllegalArgumentException(
          "Unsupported uri scheme for encoded image fetch! Uri is: "
              + getShortenedUriString(uri));
  }
}

/**
 * bitmap cache get ->
 * background thread hand-off -> bitmap cache -> decode -> resize and rotate -> (webp transcode)
 * -> data fetch.
 */
private synchronized Producer<CloseableReference<CloseableImage>> getDataFetchSequence() {
  if (mDataFetchSequence == null) {
    Producer<EncodedImage> inputProducer = mProducerFactory.newDataFetchProducer();
    if (WebpSupportStatus.sIsWebpSupportrequired &&
        (!mWebpSupportEnabled || WebpSupportStatus.sWebpBitmapFactory == null)) {
      inputProducer = mProducerFactory.newWebpTranscodeProducer(inputProducer);
    }
    inputProducer = mProducerFactory.newAddImageTransformMetaDataProducer(inputProducer);
    inputProducer = mProducerFactory.newResizeAndRotateProducer(
        inputProducer,true,mUseDownsamplingRatio);
    mDataFetchSequence = newBitmapCacheGetToDecodeSequence(inputProducer);
  }
  return mDataFetchSequence;
}

/** Creates a memory-backed encoded image from the stream. The stream is closed. */
protected EncodedImage getByteBufferBackedEncodedImage(
    InputStream inputStream,int length) throws IOException {
  CloseableReference<PooledByteBuffer> ref = null;
  try {
    if (length <= 0) {
      ref = CloseableReference.of(mPooledByteBufferFactory.newByteBuffer(inputStream));
    } else {
      ref = CloseableReference.of(mPooledByteBufferFactory.newByteBuffer(inputStream,length));
    }
    return new EncodedImage(ref);
  } finally {
    Closeables.closeQuietly(inputStream);
    CloseableReference.closeSafely(ref);
  }
}

@Test
public void testFetchFromBitmapCacheDuetoMethodCall() {
  Producer<CloseableReference<CloseableImage>> bitmapCacheSequence = mock(Producer.class);
  when(mProducerSequenceFactory.getDecodedImageProducerSequence(mImageRequest))
      .thenReturn(bitmapCacheSequence);
  mImagePipeline.fetchImageFromBitmapCache(mImageRequest,mCallerContext);
  verify(mRequestListener1).onRequestStart(mImageRequest,mCallerContext,"0",false);
  verify(mRequestListener2).onRequestStart(mImageRequest,false);
  ArgumentCaptor<ProducerContext> producerContextArgumentCaptor =
      ArgumentCaptor.forClass(ProducerContext.class);
  verify(bitmapCacheSequence)
      .produceResults(any(Consumer.class),producerContextArgumentCaptor.capture());
  assertTrue(producerContextArgumentCaptor.getValue().isIntermediateResultExpected());
  assertEquals(producerContextArgumentCaptor.getValue().getPriority(),Priority.HIGH);
  assertEquals(
      producerContextArgumentCaptor.getValue().getLowestPermittedRequestLevel(),ImageRequest.RequestLevel.BITMAP_MEMORY_CACHE);
}

private void testInputProducerSuccessButResultNotCacheableDuetoStatusFlags(
    final @Consumer.Status int statusFlags) {
  setupInputProducerStreamingSuccessWithStatusFlags(statusFlags);
  mEncodedMemoryCacheProducer.produceResults(mConsumer,mProducerContext);

  verify(mMemoryCache,never()).cache(any(CacheKey.class),any(CloseableReference.class));
  verify(mConsumer)
      .onNewResult(mIntermediateEncodedImage,statusFlags);
  verify(mConsumer)
      .onNewResult(mFinalEncodedImage,Consumer.IS_LAST | statusFlags);
  Assert.assertTrue(EncodedImage.isValid(mFinalEncodedImageClone));
  verify(mProducerListener).onProducerStart(mRequestId,PRODUCER_NAME);
  Map<String,String> extraMap =
      ImmutableMap.of(EncodedMemoryCacheProducer.EXTRA_CACHED_VALUE_FOUND,"false");
  verify(mProducerListener).onProducerFinishWithSuccess(mRequestId,PRODUCER_NAME,extraMap);
  verify(mProducerListener,never())
      .onUltimateProducerReached(anyString(),anyString(),anyBoolean());
}

/**
 * Decodes a partial jpeg.
 *
 * @param encodedImage input image (encoded bytes plus Meta data)
 * @param length amount of currently available data in bytes
 * @param qualityInfo quality info for the image
 * @return a CloseableStaticBitmap
 */
public CloseableStaticBitmap decodeJpeg(
    final EncodedImage encodedImage,int length,QualityInfo qualityInfo,ImageDecodeOptions options) {
  CloseableReference<Bitmap> bitmapReference =
      mPlatformDecoder.decodeJPEGFromEncodedImage(
          encodedImage,options.bitmapConfig,null,length);
  try {
    return new CloseableStaticBitmap(
        bitmapReference,qualityInfo,encodedImage.getRotationAngle(),encodedImage.getExifOrientation());
  } finally {
    bitmapReference.close();
  }
}

/**
 * Verify that stateful image results,both intermediate and final,are never cached.
 */
@Test
public void testDoNotCacheStatefulImage() {
  when(mCloseableImage1.isstateful()).thenReturn(true);
  when(mCloseableImage2.isstateful()).thenReturn(true);

  setupBitmapMemoryCacheGetNotFound();
  setupInputProducerStreamingSuccess();
  when(mMemoryCache.get(mBitmapMemoryCacheKey)).thenReturn(null);

  mBitmapMemoryCacheProducer.produceResults(mConsumer,mProducerContext);

  verify(mConsumer).onNewResult(mIntermediateImageReference,Consumer.NO_FLAGS);
  verify(mConsumer).onNewResult(mFinalImageReference,Consumer.IS_LAST);
  verify(mMemoryCache,never()).cache(
      any(BitmapMemoryCacheKey.class),any(CloseableReference.class));
}

@Override
public CloseableReference<Bitmap> process(Bitmap sourceBitmap,PlatformBitmapFactory bitmapFactory) {
    CloseableReference<Bitmap> bitmapRef;
    if (isFull) {
        bitmapRef = bitmapFactory.createBitmap(
                sourceBitmap.getWidth() / 2,sourceBitmap.getHeight());
    } else {
        bitmapRef = bitmapFactory.createBitmap(
                sourceBitmap.getWidth(),sourceBitmap.getHeight());
    }

    try {
        Bitmap destBitmap = bitmapRef.get();

        Canvas canvas2d = new Canvas(destBitmap);
        canvas2d.drawBitmap(sourceBitmap,new Rect(0,sourceBitmap.getWidth() / 2,sourceBitmap.getHeight()),destBitmap.getWidth(),destBitmap.getHeight()),null);
        return CloseableReference.cloneOrNull(bitmapRef);
    } finally {
        CloseableReference.closeSafely(bitmapRef);
    }
}

@Override
public synchronized void onFrameRendered(
    int frameNumber,CloseableReference<Bitmap> bitmapReference,@BitmapAnimationBackend.FrameType int frameType) {
  Preconditions.checkNotNull(bitmapReference);

  // Close up prepared references.
  removePreparedReference(frameNumber);

  // Create the new image reference and cache it.
  CloseableReference<CloseableImage> closableReference = null;
  try {
    closableReference = createImageReference(bitmapReference);
    if (closableReference != null) {
      CloseableReference.closeSafely(mLastRenderedItem);
      mLastRenderedItem = mAnimatedFrameCache.cache(frameNumber,closableReference);
    }
  } finally {
    CloseableReference.closeSafely(closableReference);
  }
}

private void verifyState(
    boolean isFinished,boolean hasResult,CloseableReference<Object> resultRef,boolean hasFailed,Throwable failureCause) {
  DataSource<CloseableReference<Object>> dataSource = mDataSource;
  assertEquals("isFinished",isFinished,dataSource.isFinished());
  assertEquals("hasResult",hasResult,dataSource.hasResult());
  CloseableReference<Object> dataSourceRef = dataSource.getResult();
  assertReferencesSame("getResult",resultRef,dataSourceRef);
  CloseableReference.closeSafely(dataSourceRef);
  assertEquals("hasFailed",hasFailed,dataSource.hasFailed());
  if (failureCause == NPE) {
    assertNotNull("failure",dataSource.getFailureCause());
    assertSame("failure",NullPointerException.class,dataSource.getFailureCause().getClass());
  } else {
    assertSame("failure",failureCause,dataSource.getFailureCause());
  }
}

public EncodedImage cloneOrNull() {
  EncodedImage encodedImage;
  if (mInputStreamsupplier != null) {
      encodedImage = new EncodedImage(mInputStreamsupplier,mStreamSize);
  } else {
    CloseableReference<PooledByteBuffer> pooledByteBufferRef =
        CloseableReference.cloneOrNull(mPooledByteBufferRef);
    try {
      encodedImage = (pooledByteBufferRef == null) ? null : new EncodedImage(pooledByteBufferRef);
    } finally {
      // Close the recently created reference since it will be cloned again in the constructor.
      CloseableReference.closeSafely(pooledByteBufferRef);
    }
  }
  if (encodedImage != null) {
    encodedImage.copyMetaDataFrom(this);
  }
  return encodedImage;
}

/**
 * Creates a bitmap from encoded JPEG bytes. Supports a partial JPEG image.
 *
 * @param encodedImage the encoded image with reference to the encoded bytes
 * @param bitmapConfig the {@link android.graphics.Bitmap.Config} used to create the decoded
 *     Bitmap
 * @param regionToDecode optional image region to decode. currently not supported.
 * @param length the number of encoded bytes in the buffer
 * @return the bitmap
 * @throws TooManyBitmapsException if the pool is full
 * @throws java.lang.OutOfMemoryError if the Bitmap cannot be allocated
 */
@Override
public CloseableReference<Bitmap> decodeJPEGFromEncodedImage(
    final EncodedImage encodedImage,Bitmap.Config bitmapConfig,@Nullable Rect regionToDecode,int length) {
  BitmapFactory.Options options = getBitmapFactoryOptions(
      encodedImage.getSampleSize(),bitmapConfig);
  final CloseableReference<PooledByteBuffer> bytesRef = encodedImage.getByteBufferRef();
  Preconditions.checkNotNull(bytesRef);
  try {
    Bitmap bitmap = decodeJPEGByteArrayAsPurgeable(bytesRef,length,options);
    return pinBitmap(bitmap);
  } finally {
    CloseableReference.closeSafely(bytesRef);
  }
}

@Test
public void testReuseExclusive_CacheSameItem() {
  CloseableReference<Integer> cachedRef =
      mCache.cache(KEY,newReference(100),mEntryStateObserver);
  cachedRef.close();
  verify(mEntryStateObserver).onExclusivityChanged(KEY,true);
  assertTotalSize(1,100);
  assertExclusivelyOwnedSize(1,100);
  cachedRef = mCache.reuse(KEY);
  assertNotNull(cachedRef);
  verify(mEntryStateObserver).onExclusivityChanged(KEY,false);
  assertTotalSize(0,0);
  assertExclusivelyOwnedSize(0,0);
  CloseableReference<Integer> newItem = mCache.cache(KEY,cachedRef);
  cachedRef.close();
  assertTotalSize(1,100);
  assertExclusivelyOwnedSize(0,0);
  newItem.close();
  verify(mEntryStateObserver).onExclusivityChanged(KEY,100);
}

/**
 * Decodes a byteArray into a purgeable bitmap
 *
 * @param bytesRef the byte buffer that contains the encoded bytes
 * @return
 */
@Override
protected Bitmap decodeByteArrayAsPurgeable(
    CloseableReference<PooledByteBuffer> bytesRef,BitmapFactory.Options options) {
  final PooledByteBuffer pooledByteBuffer = bytesRef.get();
  final int length = pooledByteBuffer.size();
  final CloseableReference<byte[]> encodedBytesArrayRef = mFlexByteArrayPool.get(length);
  try {
    final byte[] encodedBytesArray = encodedBytesArrayRef.get();
    pooledByteBuffer.read(0,encodedBytesArray,length);
    Bitmap bitmap = BitmapFactory.decodeByteArray(
        encodedBytesArray,options);
    return Preconditions.checkNotNull(bitmap,"BitmapFactory returned null");
  } finally {
    CloseableReference.closeSafely(encodedBytesArrayRef);
  }
}

private void testNewResult(
    CloseableReference<Object> resultRef,boolean isLast,int numSubscribers) {
  mInternalConsumer.onNewResult(resultRef,BaseConsumer.simpleStatusForIsLast(isLast));
  if (isLast) {
    verify(mRequestListener).onRequestSuccess(
        mSettableProducerContext.getimageRequest(),mRequestId,mSettableProducerContext.isPrefetch());
  }
  if (numSubscribers >= 1) {
    verify(mDataSubscriber1).onNewResult(mDataSource);
  }
  if (numSubscribers >= 2) {
    verify(mDataSubscriber2).onNewResult(mDataSource);
  }
  verifyWithResult(resultRef,isLast);
}

/**
 * Submits a request for execution and returns a DataSource representing the pending decoded
 * image(s).
 * <p>The returned DataSource must be closed once the client has finished with it.
 *
 * @param imageRequest the request to submit
 * @param callerContext the caller context for image request
 * @param lowestPermittedRequestLevelOnSubmit the lowest request level permitted for image request
 * @return a DataSource representing the pending decoded image(s)
 */
public DataSource<CloseableReference<CloseableImage>> fetchDecodedImage(
    ImageRequest imageRequest,Object callerContext,ImageRequest.RequestLevel lowestPermittedRequestLevelOnSubmit) {
  try {
    Producer<CloseableReference<CloseableImage>> producerSequence =
        mProducerSequenceFactory.getDecodedImageProducerSequence(imageRequest);
    return submitFetchRequest(
        producerSequence,imageRequest,lowestPermittedRequestLevelOnSubmit,callerContext);
  } catch (Exception exception) {
    return DataSources.immediateFailedDataSource(exception);
  }
}

/**
 * Decodes a GIF into a CloseableImage.
 * @param encodedImage encoded image (native byte array holding the encoded bytes and Meta data)
 * @param options the options for the decode
 * @param bitmapConfig the Bitmap.Config used to generate the output bitmaps
 * @return a {@link CloseableImage} for the GIF image
 */
public CloseableImage decodeGif(
    final EncodedImage encodedImage,final ImageDecodeOptions options,final Bitmap.Config bitmapConfig) {
  if (sgifAnimatedimagedecoder == null) {
    throw new UnsupportedOperationException("To encode animated gif please add the dependency " +
        "to the animated-gif module");
  }
  final CloseableReference<PooledByteBuffer> bytesRef = encodedImage.getByteBufferRef();
  Preconditions.checkNotNull(bytesRef);
  try {
    final PooledByteBuffer input = bytesRef.get();
    AnimatedImage gifImage = sgifAnimatedimagedecoder.decode(input.getNativePtr(),input.size());

    return getCloseableImage(options,gifImage,bitmapConfig);
  } finally {
    CloseableReference.closeSafely(bytesRef);
  }
}

/**
 * Decode a WebP into a CloseableImage.
 * @param encodedImage encoded image (native byte array holding the encoded bytes and Meta data)
 * @param options the options for the decode
 * @param bitmapConfig the Bitmap.Config used to generate the output bitmaps
 * @return a {@link CloseableImage} for the WebP image
 */
public CloseableImage decodeWebP(
    final EncodedImage encodedImage,final Bitmap.Config bitmapConfig) {
  if (sWebpAnimatedimagedecoder == null) {
    throw new UnsupportedOperationException("To encode animated webp please add the dependency " +
        "to the animated-webp module");
  }
  final CloseableReference<PooledByteBuffer> bytesRef = encodedImage.getByteBufferRef();
  Preconditions.checkNotNull(bytesRef);
  try {
    final PooledByteBuffer input = bytesRef.get();
    AnimatedImage webPImage = sWebpAnimatedimagedecoder.decode(
        input.getNativePtr(),input.size());
    return getCloseableImage(options,webPImage,bitmapConfig);
  } finally {
    CloseableReference.closeSafely(bytesRef);
  }
}

@Test
public void testFetchDecodedImageWithRequestLevel() {
  Producer<CloseableReference<CloseableImage>> decodedSequence = mock(Producer.class);
  when(mProducerSequenceFactory.getDecodedImageProducerSequence(mImageRequest))
      .thenReturn(decodedSequence);
  DataSource<CloseableReference<CloseableImage>> dataSource =
      mImagePipeline.fetchDecodedImage(
          mImageRequest,ImageRequest.RequestLevel.disK_CACHE);
  assertFalse(dataSource.isFinished());
  verify(mRequestListener1).onRequestStart(mImageRequest,false);
  ArgumentCaptor<ProducerContext> producerContextArgumentCaptor =
      ArgumentCaptor.forClass(ProducerContext.class);
  verify(decodedSequence)
      .produceResults(any(Consumer.class),ImageRequest.RequestLevel.disK_CACHE);
}

@Test
public void testExtractAndClose_whenBitmapReferenceInvalid_thenReturnReference()
    throws Exception {
  when(mBitmapReference.isValid()).thenReturn(false);

  CloseableReference<Bitmap> extractedReference =
      FrescoFrameCache.convertToBitmapReferenceAndClose(mImageReference);

  // We only detach the reference and do not care if the bitmap reference is valid
  assertthat(extractedReference).isNotNull();
  assertthat(extractedReference.get()).isEqualTo(mUnderlyingBitmap);

  extractedReference.close();

  verify(mImageReference).close();
}

@Test
public void testNonStaticBitmapIsPassedOn() {
  SingleUsePostprocessorConsumer postprocessorConsumer = produceResults();
  CloseableAnimatedImage sourceCloseableAnimatedImage = mock(CloseableAnimatedImage.class);
  CloseableReference<CloseableImage> sourceCloseableImageRef =
      CloseableReference.<CloseableImage>of(sourceCloseableAnimatedImage);
  postprocessorConsumer.onNewResult(sourceCloseableImageRef,Consumer.IS_LAST);
  sourceCloseableImageRef.close();
  mTestExecutorService.runUntilIdle();

  mInorder.verify(mConsumer).onNewResult(any(CloseableReference.class),eq(Consumer.IS_LAST));
  mInorder.verifyNoMoreInteractions();

  assertEquals(1,mResults.size());
  CloseableReference<CloseableImage> res0 = mResults.get(0);
  assertTrue(CloseableReference.isValid(res0));
  assertSame(sourceCloseableAnimatedImage,res0.get());
  res0.close();

  verify(sourceCloseableAnimatedImage).close();
}

/**
 * Returns a sequence that can be used for a request for an encoded image from either network or
 * local files.
 *
 * @param imageRequest the request that will be submitted
 * @return the sequence that should be used to process the request
 */
public Producer<CloseableReference<PooledByteBuffer>> getEncodedImageProducerSequence(
    ImageRequest imageRequest) {
  validateEncodedImageRequest(imageRequest);
  final Uri uri = imageRequest.getSourceUri();

  switch (imageRequest.getSourceUriType()) {
    case SOURCE_TYPE_NETWORK:
      return getNetworkFetchEncodedImageProducerSequence();
    case SOURCE_TYPE_LOCAL_VIDEO_FILE:
    case SOURCE_TYPE_LOCAL_IMAGE_FILE:
      return getLocalFileFetchEncodedImageProducerSequence();
    default:
      throw new IllegalArgumentException(
          "Unsupported uri scheme for encoded image fetch! Uri is: "
              + getShortenedUriString(uri));
  }
}

/**
 * Returns a DataSource supplier that will on get submit the request for execution and return a
 * DataSource representing the pending results of the task.
 *
 * @param imageRequest the request to submit (what to execute).
 * @param callerContext the caller context of the caller of data source supplier
 * @param requestLevel which level to look down until for the image
 * @return a DataSource representing pending results and completion of the request
 */
public supplier<DataSource<CloseableReference<CloseableImage>>> getDataSourcesupplier(
    final ImageRequest imageRequest,final Object callerContext,final ImageRequest.RequestLevel requestLevel) {
  return new supplier<DataSource<CloseableReference<CloseableImage>>>() {
    @Override
    public DataSource<CloseableReference<CloseableImage>> get() {
      return fetchDecodedImage(imageRequest,callerContext,requestLevel);
    }

    @Override
    public String toString() {
      return Objects.toStringHelper(this)
          .add("uri",imageRequest.getSourceUri())
          .toString();
    }
  };
}

@Before
public void setUp() {
  MockitoAnnotations.initMocks(this);
  mBitmapMemoryCacheGetProducer =
      new BitmapMemoryCacheGetProducer(mMemoryCache,mCacheKeyFactory,mInputProducer);
  mCloseableImage1 = mock(CloseableImage.class);
  mFinalImageReference = CloseableReference.of(mCloseableImage1);
  when(mCloseableImage1.getQualityInfo()).thenReturn(ImmutableQualityInfo.FULL_QUALITY);

  when(mProducerContext.getimageRequest()).thenReturn(mImageRequest);
  when(mProducerContext.getListener()).thenReturn(mProducerListener);
  when(mProducerContext.getId()).thenReturn(mRequestId);
  when(mProducerListener.requiresExtraMap(mRequestId)).thenReturn(true);
  when(mProducerContext.getLowestPermittedRequestLevel())
      .thenReturn(ImageRequest.RequestLevel.FULL_FETCH);
  when(mProducerContext.getCallerContext())
      .thenReturn(PRODUCER_NAME);
  when(mCacheKeyFactory.getBitmapCacheKey(mImageRequest,PRODUCER_NAME)).thenReturn(mCacheKey);
}

public PipelineDraweeController newController(
    supplier<DataSource<CloseableReference<CloseableImage>>> dataSourcesupplier,String id,CacheKey cacheKey,Object callerContext) {
  return newController(dataSourcesupplier,id,cacheKey,null);
}

/**
 * swallow result if prefetch -> bitmap cache get ->
 * background thread hand-off -> multiplex -> bitmap cache -> decode -> multiplex ->
 * encoded cache -> disk cache -> (webp transcode) -> network fetch.
 */
private synchronized Producer<CloseableReference<CloseableImage>> getNetworkFetchSequence() {
  if (mNetworkFetchSequence == null) {
    mNetworkFetchSequence =
        newBitmapCacheGetToDecodeSequence(getCommonNetworkFetchToEncodedMemorySequence());
  }
  return mNetworkFetchSequence;
}

/**
 * Initializes this controller with the new data source supplier,id and caller context. This
 * allows for reusing of the existing controller instead of instantiating a new one. This method
 * should be called when the controller is in detached state.
 *
 * @param dataSourcesupplier data source supplier
 * @param id unique id for this controller
 * @param callerContext tag and context for this controller
 */
public void initialize(
    supplier<DataSource<CloseableReference<CloseableImage>>> dataSourcesupplier,@Nullable ImmutableList<DrawableFactory> customDrawableFactories) {
  super.initialize(id,callerContext);
  init(dataSourcesupplier);
  mCacheKey = cacheKey;
  setCustomDrawableFactories(customDrawableFactories);
}

/**
 * Creates a new instance of a CloseableStaticBitmap from an existing CloseableReference. The
 * CloseableStaticBitmap will hold a reference to the Bitmap until it's closed.
 *
 * @param bitmapReference the bitmap reference.
 */
public CloseableStaticBitmap(
    CloseableReference<Bitmap> bitmapReference,int rotationAngle,int exifOrientation) {
  mBitmapReference = Preconditions.checkNotNull(bitmapReference.cloneOrNull());
  mBitmap = mBitmapReference.get();
  mQualityInfo = qualityInfo;
  mRotationAngle = rotationAngle;
  mExifOrientation = exifOrientation;
}

@Before
public void setUp() {
  MockitoAnnotations.initMocks(this);
  mSettableDataSource1 = SettableDataSource.create();
  mSettableDataSource2 = SettableDataSource.create();
  mListDataSource = ListDataSource.create(mSettableDataSource1,mSettableDataSource2);
  mRef1 = CloseableReference.of(1,mResourceReleaser);
  mRef2 = CloseableReference.of(2,mResourceReleaser);
  mRuntimeException = new RuntimeException();
  mListDataSource.subscribe(mDataSubscriber,CallerThreadExecutor.getInstance());
}

/**
 * Try to render the frame to the given target bitmap. If the rendering fails,the target bitmap
 * reference will be closed and false is returned. If rendering succeeds,the target bitmap
 * reference can be drawn and has to be manually closed after drawing has been completed.
 *
 * @param frameNumber the frame number to render
 * @param targetBitmap the target bitmap
 * @return true if rendering successful
 */
private boolean renderFrameInBitmap(
    int frameNumber,@Nullable CloseableReference<Bitmap> targetBitmap) {
  if (!CloseableReference.isValid(targetBitmap)) {
    return false;
  }
  // Render the image
  boolean frameRendered =
      mBitmapFrameRenderer.renderFrame(frameNumber,targetBitmap.get());
  if (!frameRendered) {
    CloseableReference.closeSafely(targetBitmap);
  }
  return frameRendered;
}

/**
 * Creates a new instance of a CloseableStaticBitmap from an existing CloseableReference. The
 * CloseableStaticBitmap will hold a reference to the Bitmap until it's closed.
 *
 * @param bitmapReference the bitmap reference.
 */
public CloseableStaticBitmap(
    CloseableReference<Bitmap> bitmapReference,int rotationAngle) {
  this(bitmapReference,rotationAngle,ExifInterface.ORIENTATION_UNDEFINED);
}

@Override
protected void onFailureImpl(DataSource<CloseableReference<PooledByteBuffer>> dataSource) {
    if (!TextUtils.isEmpty(action)) {
        Intent intent = new Intent(action);
        intent.putExtra("success",false);
        intent.putExtra("uri",uri);
        LocalbroadcastManager.getInstance(ExpressApplication.getApplication())
                .sendbroadcast(intent);
    }
}

@Nullable
@Override
public synchronized CloseableReference<Bitmap> getCachedFrame(int frameNumber) {
  if (mLastFrameNumber == frameNumber) {
    return CloseableReference.cloneOrNull(mLastBitmapReference);
  }
  return null;
}

@Test
public void testCloneUnderlyingBitmapReference() {
  CloseableReference<Bitmap> clonedBitmapReference =
      mCloseableStaticBitmap.cloneUnderlyingBitmapReference();
  assertthat(clonedBitmapReference).isNotNull();
  assertthat(clonedBitmapReference.get()).isEqualTo(mBitmap);
}

@Before
public void setUp() {
  MockitoAnnotations.initMocks(this);
  mSwallowResultProducer =
      new SwallowResultProducer<CloseableReference<CloseableImage>>(mInputProducer);
  mFinalImageReference = CloseableReference.of(mock(CloseableImage.class));
  mIntermediateImageReference = CloseableReference.of(mock(CloseableImage.class));
}

/**
 * swallow result producer -> inputProducer
 */
private synchronized Producer<Void> getDecodedImagePrefetchSequence(
    Producer<CloseableReference<CloseableImage>> inputProducer) {
  if (!mCloseableImagePrefetchSequences.containsKey(inputProducer)) {
    SwallowResultProducer<CloseableReference<CloseableImage>> swallowResultProducer =
        mProducerFactory.newSwallowResultProducer(inputProducer);
    mCloseableImagePrefetchSequences.put(inputProducer,swallowResultProducer);
  }
  return mCloseableImagePrefetchSequences.get(inputProducer);
}

@Override
public void onCancellation(DataSource<CloseableReference<CloseableImage>> dataSource) {
  if (mDataSource == dataSource) {
    mDataSource = null;
  }

  dataSource.close();
}

@Test
public void testLocalContentUriFullFetch() {
  powermockito.when(mImageRequest.getSourceUriType())
      .thenReturn(SOURCE_TYPE_LOCAL_CONTENT);
  Producer<CloseableReference<CloseableImage>> producer =
      mProducerSequenceFactory.getDecodedImageProducerSequence(mImageRequest);
  assertSame(producer,mProducerSequenceFactory.mLocalContentUriFetchSequence);
}

@Override
public synchronized void clear() {
  CloseableReference.closeSafely(mLastRenderedItem);
  mLastRenderedItem = null;
  for (int i = 0; i < mPreparedPendingFrames.size(); i++) {
    CloseableReference.closeSafely(mPreparedPendingFrames.valueAt(i));
  }
  mPreparedPendingFrames.clear();
  // The frame cache will free items when needed
}

private void internalPrepareBitmap(CloseableReference<CloseableImage> newResult) {
  if (newResult == null || !newResult.isValid()) {
    return;
  }

  final CloseableImage closeableImage = newResult.get();
  if (closeableImage == null || closeableImage.isClosed()) {
    return;
  }

  if (closeableImage instanceof CloseableStaticBitmap) {
    final CloseableStaticBitmap staticBitmap = (CloseableStaticBitmap) closeableImage;
    final Bitmap bitmap = staticBitmap.getUnderlyingBitmap();
    if (bitmap == null) {
      return;
    }

    final int bitmapByteCount = bitmap.getRowBytes() * bitmap.getHeight();
    if (bitmapByteCount < mMinBitmapSizeBytes) {
      return;
    }
    if (bitmapByteCount > mMaxBitmapSizeBytes) {
      return;
    }

    bitmap.preparetoDraw();
  }
}

@Override
public CloseableReference<V> get(K key) {
  CloseableReference<V> result = mDelegate.get(key);
  if (result == null) {
    mTracker.onCacheMiss();
  } else {
    mTracker.onCacheHit(key);
  }
  return result;
}

@Test
public void testWidthAndHeightWithRotatedImage() {
  // Reverse width and height as the rotation angle should put them back again
  mBitmap = Bitmap.createBitmap(HEIGHT,WIDTH,Bitmap.Config.ARGB_8888);
  ResourceReleaser<Bitmap> releaser = SimpleBitmapReleaser.getInstance();
  mCloseableStaticBitmap =
      new CloseableStaticBitmap(
          mBitmap,releaser,ImmutableQualityInfo.FULL_QUALITY,90,ExifInterface.ORIENTATION_ROTATE_90);

  assertthat(mCloseableStaticBitmap.getWidth()).isEqualTo(WIDTH);
  assertthat(mCloseableStaticBitmap.getHeight()).isEqualTo(HEIGHT);
}

@Test
public void testWidthAndHeightWithInvertedOrientationImage() {
  // Reverse width and height as the inverted orienvation should put them back again
  mBitmap = Bitmap.createBitmap(HEIGHT,ExifInterface.ORIENTATION_TRANSPOSE);

  assertthat(mCloseableStaticBitmap.getWidth()).isEqualTo(WIDTH);
  assertthat(mCloseableStaticBitmap.getHeight()).isEqualTo(HEIGHT);
}

public BitmapCounter(int maxCount,int maxSize) {
  Preconditions.checkArgument(maxCount > 0);
  Preconditions.checkArgument(maxSize > 0);
  mMaxCount = maxCount;
  mMaxSize = maxSize;
  mUnpooledBitmapsReleaser = new ResourceReleaser<Bitmap>() {
    @Override
    public void release(Bitmap value) {
      try {
        decrease(value);
      } finally {
        value.recycle();
      }
    }
  };
}

public SharedByteArray(
    MemoryTrimmableRegistry memoryTrimmableRegistry,PoolParams params) {
  Preconditions.checkNotNull(memoryTrimmableRegistry);
  Preconditions.checkArgument(params.minBucketSize > 0);
  Preconditions.checkArgument(params.maxBucketSize >= params.minBucketSize);

  mMaxByteArraySize = params.maxBucketSize;
  mMinByteArraySize = params.minBucketSize;
  mByteArraySoftRef = new OOMSoftReference<byte[]>();
  mSemaphore = new Semaphore(1);
  mResourceReleaser = new ResourceReleaser<byte[]>() {
    @Override
    public void release(byte[] unused) {
      mSemaphore.release();
    }
  };

  memoryTrimmableRegistry.registerMemoryTrimmable(this);
}

@Test
public void testWidthAndHeightWithRotatedImage() {
  // Reverse width and height as the rotation angle should put them back again
  mBitmap = Bitmap.createBitmap(HEIGHT,ExifInterface.ORIENTATION_ROTATE_90);

  assertthat(mCloseableStaticBitmap.getWidth()).isEqualTo(WIDTH);
  assertthat(mCloseableStaticBitmap.getHeight()).isEqualTo(HEIGHT);
}

@Test
public void testWidthAndHeightWithInvertedOrientationImage() {
  // Reverse width and height as the inverted orienvation should put them back again
  mBitmap = Bitmap.createBitmap(HEIGHT,ExifInterface.ORIENTATION_TRANSPOSE);

  assertthat(mCloseableStaticBitmap.getWidth()).isEqualTo(WIDTH);
  assertthat(mCloseableStaticBitmap.getHeight()).isEqualTo(HEIGHT);
}

public BitmapCounter(int maxCount,int maxSize) {
  Preconditions.checkArgument(maxCount > 0);
  Preconditions.checkArgument(maxSize > 0);
  mMaxCount = maxCount;
  mMaxSize = maxSize;
  mUnpooledBitmapsReleaser = new ResourceReleaser<Bitmap>() {
    @Override
    public void release(Bitmap value) {
      try {
        decrease(value);
      } finally {
        value.recycle();
      }
    }
  };
}

public SharedByteArray(
    MemoryTrimmableRegistry memoryTrimmableRegistry,PoolParams params) {
  Preconditions.checkNotNull(memoryTrimmableRegistry);
  Preconditions.checkArgument(params.minBucketSize > 0);
  Preconditions.checkArgument(params.maxBucketSize >= params.minBucketSize);

  mMaxByteArraySize = params.maxBucketSize;
  mMinByteArraySize = params.minBucketSize;
  mByteArraySoftRef = new OOMSoftReference<byte[]>();
  mSemaphore = new Semaphore(1);
  mResourceReleaser = new ResourceReleaser<byte[]>() {
    @Override
    public void release(byte[] unused) {
      mSemaphore.release();
    }
  };

  memoryTrimmableRegistry.registerMemoryTrimmable(this);
}

public PooledByteArrayBufferedInputStream(
    InputStream inputStream,byte[] byteArray,ResourceReleaser<byte[]> resourceReleaser) {
  mInputStream = Preconditions.checkNotNull(inputStream);
  mByteArray = Preconditions.checkNotNull(byteArray);
  mResourceReleaser = Preconditions.checkNotNull(resourceReleaser);
  mBufferedSize = 0;
  mBufferOffset = 0;
  mClosed = false;
}

/** Creates a new reference for the client. */
private synchronized CloseableReference<V> newClientReference(final Entry<K,V> entry) {
  increaseClientCount(entry);
  return CloseableReference.of(
      entry.valueRef.get(),new ResourceReleaser<V>() {
        @Override
        public void release(V unused) {
          releaseClientReference(entry);
        }
      });
}

/**
 * Creates a new instance of a CloseableStaticBitmap.
 *
 * @param bitmap the bitmap to wrap
 * @param resourceReleaser ResourceReleaser to release the bitmap to
 */
public CloseableStaticBitmap(
    Bitmap bitmap,ResourceReleaser<Bitmap> resourceReleaser,QualityInfo qualityInfo,int rotationAngle) {
  this(bitmap,resourceReleaser,qualityInfo,rotationAngle,ExifInterface.ORIENTATION_UNDEFINED);
}

/**
 * Creates a new instance of a CloseableStaticBitmap.
 *
 * @param bitmap the bitmap to wrap
 * @param resourceReleaser ResourceReleaser to release the bitmap to
 */
public CloseableStaticBitmap(
    Bitmap bitmap,int rotationAngle,int exifOrientation) {
  mBitmap = Preconditions.checkNotNull(bitmap);
  mBitmapReference = CloseableReference.of(
      mBitmap,Preconditions.checkNotNull(resourceReleaser));
  mQualityInfo = qualityInfo;
  mRotationAngle = rotationAngle;
  mExifOrientation = exifOrientation;
}

@Before
public void setUp() {
  mBitmap = Bitmap.createBitmap(WIDTH,HEIGHT,ExifInterface.ORIENTATION_norMAL);
}

public FlexByteArrayPool(
    MemoryTrimmableRegistry memoryTrimmableRegistry,PoolParams params) {
  Preconditions.checkArgument(params.maxnumThreads > 0);
  mDelegatePool = new SoftRefByteArrayPool(
      memoryTrimmableRegistry,params,NoOpPoolStatsTracker.getInstance());
  mResourceReleaser = new ResourceReleaser<byte[]>() {
    @Override
    public void release(byte[] unused) {
      FlexByteArrayPool.this.release(unused);
    }
  };
}

@Before
public void setUp() {
  MockitoAnnotations.initMocks(this);
  mResourceReleaser = mock(ResourceReleaser.class);
  mResultRef1 = CloseableReference.of(new Object(),mResourceReleaser);
  mResultRef2 = CloseableReference.of(new Object(),mResourceReleaser);
  mResultRef3 = CloseableReference.of(new Object(),mResourceReleaser);
  mException = mock(Exception.class);

  mDataSubscriber1 = mock(DataSubscriber.class);
  mDataSubscriber2 = mock(DataSubscriber.class);

  mSettableProducerContext = mock(SettableProducerContext.class);
  when(mSettableProducerContext.getId()).thenReturn(mRequestId);
  when(mSettableProducerContext.isPrefetch()).thenReturn(false);
  mProducer = mock(Producer.class);
  mDataSource = CloseableProducerToDataSourceAdapter.create(
      mProducer,mSettableProducerContext,mRequestListener);
  ArgumentCaptor<Consumer> captor = ArgumentCaptor.forClass(Consumer.class);
  verify(mRequestListener).onRequestStart(
      mSettableProducerContext.getimageRequest(),mSettableProducerContext.getCallerContext(),mRequestId,mSettableProducerContext.isPrefetch());
  verify(mProducer).produceResults(captor.capture(),any(SettableProducerContext.class));
  mInternalConsumer = captor.getValue();

  mDataSource.subscribe(mDataSubscriber1,CallerThreadExecutor.getInstance());
}

@Before
public void setUp() {

  mBitmap = MockBitmapFactory.create();
  mBitmapCounter = new BitmapCounter(MAX_BITMAP_COUNT,MAX_BITMAP_SIZE);

  mockStatic(BitmapCounterProvider.class);
  when(BitmapCounterProvider.get()).thenReturn(mBitmapCounter);

  mockStatic(BitmapFactory.class);
  when(BitmapFactory.decodeFileDescriptor(
          any(FileDescriptor.class),any(Rect.class),any(BitmapFactory.Options.class)))
      .thenReturn(mBitmap);

  mInputBuf = new byte[LENGTH];
  PooledByteBuffer input = new TrivialPooledByteBuffer(mInputBuf,POINTER);
  mByteBufferRef = CloseableReference.of(input);
  mEncodedImage = new EncodedImage(mByteBufferRef);

  mDecodeBuf = new byte[LENGTH + 2];
  mDecodeBufRef = CloseableReference.of(mDecodeBuf,mock(ResourceReleaser.class));

  mockStatic(Bitmaps.class);
  mGingerbreadPurgeableDecoder = new GingerbreadPurgeableDecoder();
}

@Before
public void setUp() {
  mFlexByteArrayPool = mock(FlexByteArrayPool.class);

  mBitmap = MockBitmapFactory.create();
  mBitmapCounter = new BitmapCounter(MAX_BITMAP_COUNT,MAX_BITMAP_SIZE);

  mockStatic(BitmapCounterProvider.class);
  when(BitmapCounterProvider.get()).thenReturn(mBitmapCounter);

  mockStatic(BitmapFactory.class);
  when(BitmapFactory.decodeByteArray(
          any(byte[].class),anyInt(),mock(ResourceReleaser.class));
  when(mFlexByteArrayPool.get(Integer.valueOf(LENGTH))).thenReturn(mDecodeBufRef);

  mockStatic(Bitmaps.class);
  mKitKatPurgeableDecoder = new KitKatPurgeableDecoder(mFlexByteArrayPool);
}

@Before
public void setUp() {
  mResourceReleaser = mock(ResourceReleaser.class);
  final byte[] bytes = new byte[256];
  for (int i = 0; i < 256; ++i) {
    bytes[i] = (byte) i;
  }
  InputStream unbufferedStream = new ByteArrayInputStream(bytes);
  mBuffer = new byte[10];
  mPooledByteArrayBufferedInputStream = new PooledByteArrayBufferedInputStream(
      unbufferedStream,mBuffer,mResourceReleaser);
}

public PooledByteArrayBufferedInputStream(
    InputStream inputStream,ResourceReleaser<byte[]> resourceReleaser) {
  mInputStream = Preconditions.checkNotNull(inputStream);
  mByteArray = Preconditions.checkNotNull(byteArray);
  mResourceReleaser = Preconditions.checkNotNull(resourceReleaser);
  mBufferedSize = 0;
  mBufferOffset = 0;
  mClosed = false;
}

/** Creates a new reference for the client. */
private synchronized CloseableReference<V> newClientReference(final Entry<K,new ResourceReleaser<V>() {
        @Override
        public void release(V unused) {
          releaseClientReference(entry);
        }
      });
}

/**
 * Creates a new instance of a CloseableStaticBitmap.
 *
 * @param bitmap the bitmap to wrap
 * @param resourceReleaser ResourceReleaser to release the bitmap to
 */
public CloseableStaticBitmap(
    Bitmap bitmap,ExifInterface.ORIENTATION_UNDEFINED);
}

/**
 * Creates a new instance of a CloseableStaticBitmap.
 *
 * @param bitmap the bitmap to wrap
 * @param resourceReleaser ResourceReleaser to release the bitmap to
 */
public CloseableStaticBitmap(
    Bitmap bitmap,Preconditions.checkNotNull(resourceReleaser));
  mQualityInfo = qualityInfo;
  mRotationAngle = rotationAngle;
  mExifOrientation = exifOrientation;
}

@Before
public void setUp() {
  mBitmap = Bitmap.createBitmap(WIDTH,ExifInterface.ORIENTATION_norMAL);
}

public FlexByteArrayPool(
    MemoryTrimmableRegistry memoryTrimmableRegistry,NoOpPoolStatsTracker.getInstance());
  mResourceReleaser = new ResourceReleaser<byte[]>() {
    @Override
    public void release(byte[] unused) {
      FlexByteArrayPool.this.release(unused);
    }
  };
}

@Before
public void setUp() {
  MockitoAnnotations.initMocks(this);
  mResourceReleaser = mock(ResourceReleaser.class);
  mResultRef1 = CloseableReference.of(new Object(),CallerThreadExecutor.getInstance());
}

@Before
public void setUp() {

  mBitmap = MockBitmapFactory.create();
  mBitmapCounter = new BitmapCounter(MAX_BITMAP_COUNT,mock(ResourceReleaser.class));

  mockStatic(Bitmaps.class);
  mGingerbreadPurgeableDecoder = new GingerbreadPurgeableDecoder();
}

@Before
public void setUp() {
  mFlexByteArrayPool = mock(FlexByteArrayPool.class);

  mBitmap = MockBitmapFactory.create();
  mBitmapCounter = new BitmapCounter(MAX_BITMAP_COUNT,mock(ResourceReleaser.class));
  when(mFlexByteArrayPool.get(Integer.valueOf(LENGTH))).thenReturn(mDecodeBufRef);

  mockStatic(Bitmaps.class);
  mKitKatPurgeableDecoder = new KitKatPurgeableDecoder(mFlexByteArrayPool);
}

@Before
public void setUp() {
  mResourceReleaser = mock(ResourceReleaser.class);
  final byte[] bytes = new byte[256];
  for (int i = 0; i < 256; ++i) {
    bytes[i] = (byte) i;
  }
  InputStream unbufferedStream = new ByteArrayInputStream(bytes);
  mBuffer = new byte[10];
  mPooledByteArrayBufferedInputStream = new PooledByteArrayBufferedInputStream(
      unbufferedStream,mResourceReleaser);
}

public ResourceReleaser<Bitmap> getReleaser() {
  return mUnpooledBitmapsReleaser;
}

public ResourceReleaser<Bitmap> getReleaser() {
  return mUnpooledBitmapsReleaser;
}