Java CloseableReference.isValid方法代码示例

import com.facebook.common.references.CloseableReference; //导入方法依赖的package包/类
private boolean renderFrameAndCache(
    int frameNumber,
    CloseableReference<Bitmap> bitmapReference,
    @BitmapAnimationBackend.FrameType int frameType) {
  // Check if the bitmap is valid
  if (!CloseableReference.isValid(bitmapReference)) {
    return false;
  }
  // Try to render the frame
  if (!mBitmapFrameRenderer.renderFrame(frameNumber, bitmapReference.get())) {
    return false;
  }
  FLog.v(TAG, "Frame %d ready.", mFrameNumber);
  // Cache the frame
  synchronized (mPendingFrameDecodeJobs) {
    mBitmapFrameCache.onFramePrepared(mFrameNumber, bitmapReference, frameType);
  }
  return true;
}
 

import com.facebook.common.references.CloseableReference; //导入方法依赖的package包/类
/**
 * Converts the given image reference to a bitmap reference
 * and closes the original image reference.
 *
 * @param closeableImage the image to convert. It will be closed afterwards and will be invalid
 * @return the closeable bitmap reference to be used
 */
@VisibleForTesting
@Nullable
static CloseableReference<Bitmap> convertToBitmapReferenceAndClose(
    final @Nullable CloseableReference<CloseableImage> closeableImage) {
  try {
    if (CloseableReference.isValid(closeableImage) &&
        closeableImage.get() instanceof CloseableStaticBitmap) {

      CloseableStaticBitmap closeableStaticBitmap = (CloseableStaticBitmap) closeableImage.get();
      if (closeableStaticBitmap != null) {
        // We return a clone of the underlying bitmap reference that has to be manually closed
        // and then close the passed CloseableStaticBitmap in order to preserve correct
        // cache size calculations.
        return closeableStaticBitmap.cloneUnderlyingBitmapReference();
      }
    }
    // Not a bitmap reference, so we return null
    return null;
  } finally {
    CloseableReference.closeSafely(closeableImage);
  }
}
 

import com.facebook.common.references.CloseableReference; //导入方法依赖的package包/类
/**
 * 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;
}
 

import com.facebook.common.references.CloseableReference; //导入方法依赖的package包/类
/**
 * Helper method that draws the given bitmap on the canvas respecting the bounds (if set).
 *
 * If rendering was successful, it notifies the cache that the frame has been rendered with the
 * given bitmap. In addition, it will notify the {@link FrameListener} if set.
 *
 * @param frameNumber the current frame number passed to the cache
 * @param bitmapReference the bitmap to draw
 * @param canvas the canvas to draw an
 * @param frameType the {@link FrameType} to be rendered
 * @return true if the bitmap has been drawn
 */
private boolean drawBitmapAndCache(
    int frameNumber,
    @Nullable CloseableReference<Bitmap> bitmapReference,
    Canvas canvas,
    @FrameType int frameType) {
  if (!CloseableReference.isValid(bitmapReference)) {
    return false;
  }
  if (mBounds == null) {
    canvas.drawBitmap(bitmapReference.get(), 0f, 0f, mPaint);
  } else {
    canvas.drawBitmap(bitmapReference.get(), null, mBounds, mPaint);
  }

  // Notify the cache that a frame has been rendered.
  // We should not cache fallback frames since they do not represent the actual frame.
  if (frameType != FRAME_TYPE_FALLBACK) {
    mBitmapFrameCache.onFrameRendered(
        frameNumber,
        bitmapReference,
        frameType);
  }

  if (mFrameListener != null) {
    mFrameListener.onFrameDrawn(this, frameNumber, frameType);
  }
  return true;
}
 

import com.facebook.common.references.CloseableReference; //导入方法依赖的package包/类
@Override
public synchronized void onFramePrepared(
    int frameNumber,
    CloseableReference<Bitmap> bitmapReference,
    @BitmapAnimationBackend.FrameType int frameType) {
  Preconditions.checkNotNull(bitmapReference);
  CloseableReference<CloseableImage> closableReference = null;
  try {
    closableReference = createImageReference(bitmapReference);
    if (closableReference == null) {
      return;
    }
    CloseableReference<CloseableImage> newReference =
        mAnimatedFrameCache.cache(frameNumber, closableReference);
    if (CloseableReference.isValid(newReference)) {
      CloseableReference<CloseableImage> oldReference = mPreparedPendingFrames.get(frameNumber);
      CloseableReference.closeSafely(oldReference);
      // For performance reasons, we don't clone the reference and close the original one
      // but cache the reference directly.
      mPreparedPendingFrames.put(frameNumber, newReference);
      FLog.v(
          TAG,
          "cachePreparedFrame(%d) cached. Pending frames: %s",
          frameNumber,
          mPreparedPendingFrames);
    }
  } finally {
    CloseableReference.closeSafely(closableReference);
  }
}
 

import com.facebook.common.references.CloseableReference; //导入方法依赖的package包/类
private static int getBitmapSizeBytes(
    @Nullable CloseableReference<CloseableImage> imageReference) {
  if (!CloseableReference.isValid(imageReference)) {
    return 0;
  }
  return getBitmapSizeBytes(imageReference.get());
}
 

import com.facebook.common.references.CloseableReference; //导入方法依赖的package包/类
@Override
protected void onNewResultImpl(
    CloseableReference<CloseableImage> newResult,
    @Status int status) {
  if (!CloseableReference.isValid(newResult)) {
    // try to propagate if the last result is invalid
    if (isLast(status)) {
      maybeNotifyOnNewResult(null, status);
    }
    // ignore if invalid
    return;
  }
  updateSourceImageRef(newResult, status);
}
 

import com.facebook.common.references.CloseableReference; //导入方法依赖的package包/类
private synchronized boolean setRunningIfDirtyAndNotRunning() {
  if (!mIsClosed && mIsDirty && !mIsPostProcessingRunning &&
      CloseableReference.isValid(mSourceImageRef)) {
    mIsPostProcessingRunning = true;
    return true;
  }
  return false;
}
 

import com.facebook.common.references.CloseableReference; //导入方法依赖的package包/类
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();
  }
}
 

import com.facebook.common.references.CloseableReference; //导入方法依赖的package包/类
/**
 * Returns whether the image is stored in the bitmap memory cache.
 *
 * @param imageRequest the imageRequest for the image to be looked up.
 * @return true if the image was found in the bitmap memory cache, false otherwise.
 */
public boolean isInBitmapMemoryCache(final ImageRequest imageRequest) {
  if (imageRequest == null) {
    return false;
  }
  final CacheKey cacheKey = mCacheKeyFactory.getBitmapCacheKey(imageRequest, null);
  CloseableReference<CloseableImage> ref = mBitmapMemoryCache.get(cacheKey);
  try {
    return CloseableReference.isValid(ref);
  } finally {
    CloseableReference.closeSafely(ref);
  }
}
 

import com.facebook.common.references.CloseableReference; //导入方法依赖的package包/类
@Override
public synchronized boolean contains(int frameNumber) {
  return frameNumber == mLastFrameNumber && CloseableReference.isValid(mLastBitmapReference);
}
 

import com.facebook.common.references.CloseableReference; //导入方法依赖的package包/类
/**
 * Check if this bytebuffer is already closed
 * @return true if this bytebuffer is closed.
 */
@Override
public synchronized boolean isClosed() {
  return !CloseableReference.isValid(mBufRef);
}
 

import com.facebook.common.references.CloseableReference; //导入方法依赖的package包/类
/**
 * Ensure that the current stream is valid, that is underlying closeable reference is not null
 * and is valid
 * @throws InvalidStreamException if the stream is invalid
 */
private void ensureValid() {
  if (!CloseableReference.isValid(mBufRef)) {
    throw new InvalidStreamException();
  }
}
 

import com.facebook.common.references.CloseableReference; //导入方法依赖的package包/类
@Override
public synchronized boolean contains(int frameNumber) {
  return CloseableReference.isValid(mBitmapSparseArray.get(frameNumber));
}
 

import com.facebook.common.references.CloseableReference; //导入方法依赖的package包/类
/**
 * Returns true if the internal buffer reference is valid or the InputStream Supplier is not null,
 * false otherwise.
 */
public synchronized boolean isValid() {
  return CloseableReference.isValid(mPooledByteBufferRef) || mInputStreamSupplier != null;
}