Java Code Examples for com.facebook.common.references.CloseableReference#cloneOrNull()

private void updateSourceImageRef(
    @Nullable CloseableReference<CloseableImage> sourceImageRef, int status) {
  CloseableReference<CloseableImage> oldSourceImageRef;
  boolean shouldSubmit;
  synchronized (PostprocessorConsumer.this) {
    if (mIsClosed) {
      return;
    }
    oldSourceImageRef = mSourceImageRef;
    mSourceImageRef = CloseableReference.cloneOrNull(sourceImageRef);
    mStatus = status;
    mIsDirty = true;
    shouldSubmit = setRunningIfDirtyAndNotRunning();
  }
  CloseableReference.closeSafely(oldSourceImageRef);
  if (shouldSubmit) {
    submitPostprocessing();
  }
}
 

@Override
public CloseableReference<Bitmap> process(Bitmap sourceBitmap, PlatformBitmapFactory bitmapFactory) {
    float scale = 1.0f * width / sourceBitmap.getWidth();
    Log.e("ReScalePostprocessor", "scale:" + scale);

    scaledWidth = (int) (sourceBitmap.getWidth() * scale);
    scaledHeight = (int) (sourceBitmap.getHeight() * scale);

    listener.onProcessFinished(scaledWidth, scaledHeight);

    Matrix matrix = new Matrix();
    matrix.postScale(scale, scale);
    Bitmap bitmap = Bitmap.createBitmap(sourceBitmap, 0, 0, sourceBitmap.getWidth(), sourceBitmap.getHeight(), matrix, true);
    CloseableReference<Bitmap> bitmapRef = bitmapFactory.createBitmap(bitmap);
    try {
        return CloseableReference.cloneOrNull(bitmapRef);
    } finally {
        CloseableReference.closeSafely(bitmapRef);
    }
}
 

@Override
protected CloseableReference<Bitmap> processComposition(
  Bitmap dstImage,
  Bitmap srcImage,
  PlatformBitmapFactory bitmapFactory
) {
  final CloseableReference<Bitmap> outRef = bitmapFactory.createBitmap(
    canvasExtent(dstImage.getWidth(), srcImage.getWidth(), mWidth),
    canvasExtent(dstImage.getHeight(), srcImage.getHeight(), mHeight)
  );

  try {
    final Canvas canvas = new Canvas(outRef.get());
    final int flags = Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG | Paint.FILTER_BITMAP_FLAG;
    final Paint paint = new Paint(flags);

    if (mSwapImages) {
      drawSrc(canvas, srcImage, paint);

    } else {
      drawDst(canvas, dstImage, paint);
    }

    paint.setXfermode(new PorterDuffXfermode(mMode));

    if (mSwapImages) {
      drawDst(canvas, dstImage, paint);

    } else {
      drawSrc(canvas, srcImage, paint);
    }

    return CloseableReference.cloneOrNull(outRef);
  } finally {
    CloseableReference.closeSafely(outRef);
  }
}
 

@Override
public CloseableReference<Bitmap> process(Bitmap sourceBitmap, PlatformBitmapFactory bitmapFactory) {
    try {
        if (PerformanceSpInfoConfig.isLargeImgOpen()) {
            double imgSize = ConvertUtils.byte2MemorySize(sourceBitmap.getByteCount(), MemoryConstants.MB);
            LargePictureManager.getInstance().saveImageInfo(mUri.toString(), imgSize, sourceBitmap.getWidth(), sourceBitmap.getHeight(), "Fresco");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

    if (mOriginalPostprocessor != null) {
        return mOriginalPostprocessor.process(sourceBitmap, bitmapFactory);
    }

    final Bitmap.Config sourceBitmapConfig = sourceBitmap.getConfig();
    CloseableReference<Bitmap> destBitmapRef =
            bitmapFactory.createBitmapInternal(
                    sourceBitmap.getWidth(),
                    sourceBitmap.getHeight(),
                    sourceBitmapConfig != null ? sourceBitmapConfig : FALLBACK_BITMAP_CONFIGURATION);
    try {
        process(destBitmapRef.get(), sourceBitmap);
        return CloseableReference.cloneOrNull(destBitmapRef);
    } finally {
        CloseableReference.closeSafely(destBitmapRef);
    }

}
 

private void setSourceImageRef(CloseableReference<CloseableImage> sourceImageRef) {
  CloseableReference<CloseableImage> oldSourceImageRef;
  synchronized (RepeatedPostprocessorConsumer.this) {
    if (mIsClosed) {
      return;
    }
    oldSourceImageRef = mSourceImageRef;
    mSourceImageRef = CloseableReference.cloneOrNull(sourceImageRef);
  }
  CloseableReference.closeSafely(oldSourceImageRef);
}
 

public @Nullable Drawable setImage(
    @Nullable Drawable imageDrawable,
    @Nullable CloseableReference<CloseableImage> imageReference) {
  CloseableReference.closeSafely(mImageReference);
  mImageReference = CloseableReference.cloneOrNull(imageReference);
  return setDrawable(IMAGE_DRAWABLE_INDEX, imageDrawable);
}
 

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

@Override
protected CloseableReference<Bitmap> processComposition(
  Bitmap dstImage,
  Bitmap srcImage,
  PlatformBitmapFactory bitmapFactory
) {
  final int width = canvasExtent(dstImage.getWidth(), srcImage.getWidth(), mWidth);
  final int height = canvasExtent(dstImage.getHeight(), srcImage.getHeight(), mHeight);

  final CloseableReference<Bitmap> tmpDstRef = bitmapFactory.createBitmap(width, height);
  final CloseableReference<Bitmap> tmpSrcRef = bitmapFactory.createBitmap(width, height);
  final CloseableReference<Bitmap> outRef = bitmapFactory.createBitmap(width, height);

  try {
    final Bitmap out = outRef.get();
    final Bitmap tmpDst = tmpDstRef.get();
    final Bitmap tmpSrc = tmpSrcRef.get();

    final Canvas dstCanvas = new Canvas(tmpDst);
    final Canvas srcCanvas = new Canvas(tmpSrc);
    final int flags = Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG | Paint.FILTER_BITMAP_FLAG;
    final Paint paint = new Paint(flags);

    dstCanvas.drawBitmap(
      dstImage,
      bitmapTransform(width, height, dstImage.getWidth(), dstImage.getHeight(), mDstTransform),
      paint
    );

    srcCanvas.drawBitmap(
      srcImage,
      bitmapTransform(width, height, srcImage.getWidth(), srcImage.getHeight(), mSrcTransform),
      paint
    );

    processRenderscriptComposition(
      mSwapImages ? tmpSrc : tmpDst,
      mSwapImages ? tmpDst : tmpSrc,
      out
    );

    return CloseableReference.cloneOrNull(outRef);
  } finally {
    CloseableReference.closeSafely(tmpDstRef);
    CloseableReference.closeSafely(tmpSrcRef);
    CloseableReference.closeSafely(outRef);
  }
}
 

@Override
protected void onNewResultImpl(
    CloseableReference<T> result, int status, ProducerContext producerContext) {
  super.onNewResultImpl(CloseableReference.cloneOrNull(result), status, producerContext);
}
 

@Nullable
@Override
public synchronized CloseableReference<Bitmap> getFallbackFrame(int frameNumber) {
  return CloseableReference.cloneOrNull(mLastBitmapReference);
}
 

public AnimatedDrawableCachingBackendImpl(
    SerialExecutorService executorService,
    ActivityManager activityManager,
    AnimatedDrawableUtil animatedDrawableUtil,
    MonotonicClock monotonicClock,
    AnimatedDrawableBackend animatedDrawableBackend,
    AnimatedDrawableOptions options) {
  super(animatedDrawableBackend);
  mExecutorService = executorService;
  mActivityManager = activityManager;
  mAnimatedDrawableUtil = animatedDrawableUtil;
  mMonotonicClock = monotonicClock;
  mAnimatedDrawableBackend = animatedDrawableBackend;
  mAnimatedDrawableOptions = options;
  mMaximumBytes = options.maximumBytes >= 0 ?
      options.maximumBytes : getDefaultMaxBytes(activityManager);
  mAnimatedImageCompositor = new AnimatedImageCompositor(
      animatedDrawableBackend,
      new AnimatedImageCompositor.Callback() {
        @Override
        public void onIntermediateResult(int frameNumber, Bitmap bitmap) {
          maybeCacheBitmapDuringRender(frameNumber, bitmap);
        }

        @Override
        public CloseableReference<Bitmap> getCachedBitmap(int frameNumber) {
          synchronized (AnimatedDrawableCachingBackendImpl.this) {
            return CloseableReference.cloneOrNull(mCachedBitmaps.get(frameNumber));
          }
        }
      });
  mResourceReleaserForBitmaps = new ResourceReleaser<Bitmap>() {
    @Override
    public void release(Bitmap value) {
      releaseBitmapInternal(value);
    }
  };
  mFreeBitmaps = new ArrayList<Bitmap>();
  mDecodesInFlight = new SparseArrayCompat<Task<Object>>(10);
  mCachedBitmaps = new SparseArrayCompat<CloseableReference<Bitmap>>(10);
  mBitmapsToKeepCached = new WhatToKeepCachedArray(mAnimatedDrawableBackend.getFrameCount());
  mApproxBytesToHoldAllFrames =
      mAnimatedDrawableBackend.getFrameCount() *
          mAnimatedDrawableBackend.getRenderedWidth() *
          mAnimatedDrawableBackend.getRenderedHeight() * 4;
}
 

@Override
@Nullable
public synchronized CloseableReference<CloseableImage> getCachedImage() {
  return CloseableReference.cloneOrNull(mCachedImage);
}
 

@Override
public synchronized void setCachedImage(
    @Nullable CloseableReference<CloseableImage> cachedImage) {
  CloseableReference.closeSafely(mCachedImage);
  mCachedImage = CloseableReference.cloneOrNull(cachedImage);
}
 

@Override
protected void onNewResultImpl(CloseableReference<T> result, boolean isLast) {
  super.onNewResultImpl(CloseableReference.cloneOrNull(result), isLast);
}
 

public CloseableReference<CloseableImage> cloneOrNull(
    CloseableReference<CloseableImage> closeableImage) {
  return CloseableReference.cloneOrNull(closeableImage);
}
 

/**
 * Gets a decoded frame. This will only return non-null if the {@code ImageDecodeOptions} were
 * configured to decode all frames at decode time.
 *
 * @param index the index of the frame to get
 * @return a reference to the preview bitmap which must be released by the caller when done or
 *     null if there is no preview bitmap set
 */
public synchronized @Nullable CloseableReference<Bitmap> getDecodedFrame(int index) {
  if (mDecodedFrames != null) {
    return CloseableReference.cloneOrNull(mDecodedFrames.get(index));
  }
  return null;
}
 

/**
 * Returns a cloned reference to the stored encoded bytes.
 *
 * <p>The caller has to close the reference once it has finished using it.
 */
public CloseableReference<PooledByteBuffer> getByteBufferRef() {
  return CloseableReference.cloneOrNull(mPooledByteBufferRef);
}
 

/**
 * Get a cloned bitmap reference for the underlying original CloseableReference<Bitmap>.
 *
 * <p>After calling this method, this object can still be used. See {@link
 * #convertToBitmapReference()} for an alternative that detaches the original reference instead.
 *
 * @return the cloned bitmap reference without altering this instance or null if already closed
 */
@Nullable
public synchronized CloseableReference<Bitmap> cloneUnderlyingBitmapReference() {
  return CloseableReference.cloneOrNull(mBitmapReference);
}
 

/**
 * Gets the decoded frames. Only used if the {@code ImageDecodeOptions} were configured to decode
 * all frames at decode time.
 *
 * @return the references to the decoded frames or null if none was set. This returns references
 *     that must be released by the caller
 */
public List<CloseableReference<Bitmap>> getDecodedFrames() {
  return CloseableReference.cloneOrNull(mDecodedFrames);
}
 

/**
 * Sets the value of this data source.
 *
 * <p>This method will return {@code true} if the value was successfully set, or {@code false} if
 * the data source has already been set, failed or closed.
 *
 * <p>Passed CloseableReference is cloned, caller of this method still owns passed reference after
 * the method returns.
 *
 * @param valueRef closeable reference to the value the data source should hold.
 * @return true if the value was successfully set.
 */
public boolean set(@Nullable CloseableReference<T> valueRef) {
  CloseableReference<T> clonedRef = CloseableReference.cloneOrNull(valueRef);
  return super.setResult(clonedRef, /* isLast */ true, null);
}