Java 类com.facebook.common.internal.Closeables 实例源码

/** 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);
  }
}

/**
 * Decodes gif into CloseableImage.
 *
 * @param encodedImage input image (encoded bytes plus meta data)
 * @return a CloseableImage
 */
public CloseableImage decodeGif(
    final EncodedImage encodedImage,
    final int length,
    final QualityInfo qualityInfo,
    final ImageDecodeOptions options) {
  InputStream is = encodedImage.getInputStream();
  if (is == null) {
    return null;
  }
  try {
    if (!options.forceStaticImage
        && mAnimatedGifDecoder != null) {
      return mAnimatedGifDecoder.decode(encodedImage, length, qualityInfo, options);
    }
    return decodeStaticImage(encodedImage, options);
  } finally {
    Closeables.closeQuietly(is);
  }
}

@Override
public CloseableImage decode(
    EncodedImage encodedImage,
    int length,
    QualityInfo qualityInfo,
    ImageDecodeOptions options) {
  InputStream encodedInputStream = null;
  try {
    encodedInputStream = encodedImage.getInputStream();
    return new CloseableKeyframesImage(
        KFImageDeserializer.deserialize(encodedInputStream));
  } catch (IOException e) {
    e.printStackTrace();
    return null;
  } finally {
    Closeables.closeQuietly(encodedInputStream);
  }
}

private void checkFileInputStream(int size) throws IOException {
  byte[] bytesToWrite = new byte[size];
  for (int i=0; i<size; i++) {
    bytesToWrite[i] = (byte)i; // It's okay to truncate
  }

  File tmpFile = File.createTempFile("streamUtil", "test");
  InputStream input = null;
  OutputStream output = null;
  try {
    output = new FileOutputStream(tmpFile);
    output.write(bytesToWrite);
    output.close();

    input = new FileInputStream(tmpFile);
    byte[] bytesRead = StreamUtil.getBytesFromStream(input);
    assertTrue(Arrays.equals(bytesToWrite, bytesRead));
  } finally {
    Closeables.close(input, true);
    Closeables.close(output, false);
    assertTrue(tmpFile.delete());
  }
}

/** 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);
  }
}

@Override
public CloseableImage decode(
    EncodedImage encodedImage,
    int length,
    QualityInfo qualityInfo,
    ImageDecodeOptions options) {
  InputStream encodedInputStream = null;
  try {
    encodedInputStream = encodedImage.getInputStream();
    return new CloseableKeyframesImage(
        KFImageDeserializer.deserialize(encodedInputStream));
  } catch (IOException e) {
    e.printStackTrace();
    return null;
  } finally {
    Closeables.closeQuietly(encodedInputStream);
  }
}

@Override
public void release(Closeable value) {
  try {
    Closeables.close(value, true);
  } catch (IOException ioe) {
    // This will not happen, Closeable.close swallows and logs IOExceptions
  }
}

@Override
public void release(Thing value) {
  try {
    Closeables.close(value, true);
  } catch (IOException ioe) {
    // this should not happen
    Assert.fail();
  }
}

/**
 * Verify that using a ByteArrayInputStream does not allocate a new byte array.
 */
@Test
public void testByteArrayInputStream() throws Exception {
  byte[] bytes = new byte[8];
  InputStream input = new ByteArrayInputStream(bytes);
  try {
    byte[] bytesRead = StreamUtil.getBytesFromStream(input);
    assertTrue(Arrays.equals(bytes, bytesRead));
  } finally {
    Closeables.close(input, true);
  }
}

/**
 * Verify that using an offset with ByteArrayInputStream still produces correct output.
 */
@Test
public void testByteArrayInputStreamWithOffset() throws Exception {
  byte[] bytes = new byte[] {0, 1, 2, 3, 4};
  InputStream input = new ByteArrayInputStream(bytes, 1, 4);
  try {
    byte[] bytesRead = StreamUtil.getBytesFromStream(input);
    byte[] expectedBytes = new byte[] {1, 2, 3, 4};
    assertTrue(Arrays.equals(expectedBytes, bytesRead));
  } finally {
    Closeables.close(input, true);
  }
}

/**
 * If this is the first time calling this method, the buffer will be checked to make sure it
 * starts with SOI marker (0xffd8). If the image has been identified as a non-JPEG, data will be
 * ignored and false will be returned immediately on all subsequent calls.
 *
 * This object maintains state of the position of the last read byte. On repeated calls to this
 * method, it will continue from where it left off.
 *
 * @param encodedImage Next set of bytes received by the caller
 * @return true if a new full scan has been found
 */
public boolean parseMoreData(final EncodedImage encodedImage) {
  if (mParserState == NOT_A_JPEG) {
    return false;
  }

  final int dataBufferSize = encodedImage.getSize();

  // Is there any new data to parse?
  // mBytesParsed might be greater than size of dataBuffer - that happens when
  // we skip more data than is available to read inside doParseMoreData method
  if (dataBufferSize <= mBytesParsed) {
    return false;
  }

  final InputStream bufferedDataStream = new PooledByteArrayBufferedInputStream(
      encodedImage.getInputStream(),
      mByteArrayPool.get(BUFFER_SIZE),
      mByteArrayPool);
  try {
    StreamUtil.skip(bufferedDataStream, mBytesParsed);
    return doParseMoreData(bufferedDataStream);
  } catch (IOException ioe) {
    // Does not happen - streams returned by PooledByteBuffers do not throw IOExceptions
    Throwables.propagate(ioe);
    return false;
  } finally {
    Closeables.closeQuietly(bufferedDataStream);
  }
}

@Override
public void release(Closeable value) {
  try {
    Closeables.close(value, true);
  } catch (IOException ioe) {
    // This will not happen, Closeable.close swallows and logs IOExceptions
  }
}

@Override
public void release(Thing value) {
  try {
    Closeables.close(value, true);
  } catch (IOException ioe) {
    // this should not happen
    Assert.fail();
  }
}

/**
 * Verify that using a ByteArrayInputStream does not allocate a new byte array.
 */
@Test
public void testByteArrayInputStream() throws Exception {
  byte[] bytes = new byte[8];
  InputStream input = new ByteArrayInputStream(bytes);
  try {
    byte[] bytesRead = StreamUtil.getBytesFromStream(input);
    assertTrue(Arrays.equals(bytes, bytesRead));
  } finally {
    Closeables.close(input, true);
  }
}

/**
 * Verify that using an offset with ByteArrayInputStream still produces correct output.
 */
@Test
public void testByteArrayInputStreamWithOffset() throws Exception {
  byte[] bytes = new byte[] {0, 1, 2, 3, 4};
  InputStream input = new ByteArrayInputStream(bytes, 1, 4);
  try {
    byte[] bytesRead = StreamUtil.getBytesFromStream(input);
    byte[] expectedBytes = new byte[] {1, 2, 3, 4};
    assertTrue(Arrays.equals(expectedBytes, bytesRead));
  } finally {
    Closeables.close(input, true);
  }
}

/**
 * Reads image header from a file indicated by provided filename and determines
 * its format. This method does not throw IOException if one occurs. In this case,
 * {@link ImageFormat#UNKNOWN} will be returned.
 * @param filename
 * @return ImageFormat for image stored in filename
 */
public static ImageFormat getImageFormat(String filename) {
  FileInputStream fileInputStream = null;
  try {
    fileInputStream = new FileInputStream(filename);
    return getImageFormat(fileInputStream);
  } catch (IOException ioe) {
    return ImageFormat.UNKNOWN;
  } finally {
    Closeables.closeQuietly(fileInputStream);
  }
}

/**
 * If this is the first time calling this method, the buffer will be checked to make sure it
 * starts with SOI marker (0xffd8). If the image has been identified as a non-JPEG, data will be
 * ignored and false will be returned immediately on all subsequent calls.
 *
 * This object maintains state of the position of the last read byte. On repeated calls to this
 * method, it will continue from where it left off.
 *
 * @param encodedImage Next set of bytes received by the caller
 * @return true if a new full scan has been found
 */
public boolean parseMoreData(final EncodedImage encodedImage) {
  if (mParserState == NOT_A_JPEG) {
    return false;
  }

  final int dataBufferSize = encodedImage.getSize();

  // Is there any new data to parse?
  // mBytesParsed might be greater than size of dataBuffer - that happens when
  // we skip more data than is available to read inside doParseMoreData method
  if (dataBufferSize <= mBytesParsed) {
    return false;
  }

  final InputStream bufferedDataStream = new PooledByteArrayBufferedInputStream(
      encodedImage.getInputStream(),
      mByteArrayPool.get(BUFFER_SIZE),
      mByteArrayPool);
  try {
    StreamUtil.skip(bufferedDataStream, mBytesParsed);
    return doParseMoreData(bufferedDataStream);
  } catch (IOException ioe) {
    // Does not happen - streams returned by PooledByteBuffers do not throw IOExceptions
    Throwables.propagate(ioe);
    return false;
  } finally {
    Closeables.closeQuietly(bufferedDataStream);
  }
}

@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;
}

private void doTransform(EncodedImage encodedImage, @Status int status) {
  mProducerContext.getListener().onProducerStart(mProducerContext.getId(), PRODUCER_NAME);
  ImageRequest imageRequest = mProducerContext.getImageRequest();
  PooledByteBufferOutputStream outputStream = mPooledByteBufferFactory.newOutputStream();
  Map<String, String> extraMap = null;
  EncodedImage ret = null;
  InputStream is = null;
  try {
    final int softwareNumerator = getSoftwareNumerator(
        imageRequest,
        encodedImage,
        mResizingEnabled);
    final int downsampleRatio = DownsampleUtil.determineSampleSize(imageRequest, encodedImage);
    final int downsampleNumerator = calculateDownsampleNumerator(downsampleRatio);
    final int numerator;
    if (mUseDownsamplingRatio) {
      numerator = downsampleNumerator;
    } else {
      numerator = softwareNumerator;
    }
    is = encodedImage.getInputStream();
    if (INVERTED_EXIF_ORIENTATIONS.contains(encodedImage.getExifOrientation())) {
      // Use exif orientation to rotate since we can't use the rotation angle for
      // inverted exif orientations
      final int exifOrientation =
          getForceRotatedInvertedExifOrientation(
              imageRequest.getRotationOptions(), encodedImage);
      extraMap =
          getExtraMap(
              encodedImage, imageRequest, numerator, downsampleNumerator, softwareNumerator, 0);
      JpegTranscoder.transcodeJpegWithExifOrientation(
          is, outputStream, exifOrientation, numerator, DEFAULT_JPEG_QUALITY);
    } else {
      // Use actual rotation angle in degrees to rotate
      final int rotationAngle =
          getRotationAngle(imageRequest.getRotationOptions(), encodedImage);
      extraMap =
          getExtraMap(
              encodedImage,
              imageRequest,
              numerator,
              downsampleNumerator,
              softwareNumerator,
              rotationAngle);
      JpegTranscoder.transcodeJpeg(
          is, outputStream, rotationAngle, numerator, DEFAULT_JPEG_QUALITY);
    }
    CloseableReference<PooledByteBuffer> ref =
        CloseableReference.of(outputStream.toByteBuffer());
    try {
      ret = new EncodedImage(ref);
      ret.setImageFormat(DefaultImageFormats.JPEG);
      try {
        ret.parseMetaData();
        mProducerContext.getListener().
            onProducerFinishWithSuccess(mProducerContext.getId(), PRODUCER_NAME, extraMap);
        if (downsampleRatio != DownsampleUtil.DEFAULT_SAMPLE_SIZE) {
          status |= Consumer.IS_RESIZING_DONE;
        }
        getConsumer().onNewResult(ret, status);
      } finally {
        EncodedImage.closeSafely(ret);
      }
    } finally {
      CloseableReference.closeSafely(ref);
    }
  } catch (Exception e) {
    mProducerContext.getListener().
        onProducerFinishWithFailure(mProducerContext.getId(), PRODUCER_NAME, e, extraMap);
    if (isLast(status)) {
      getConsumer().onFailure(e);
    }
    return;
  } finally {
    Closeables.closeQuietly(is);
    outputStream.close();
  }
}