com.facebook.imagepipeline.request.Postprocessor Java Examples

/**
 * Utility method which adds optional configuration to ImageRequest
 *
 * @param imageRequestBuilder The Builder for ImageRequest
 * @param config The Config
 */
public static void addOptionalFeatures(ImageRequestBuilder imageRequestBuilder, Config config) {
  if (config.usePostprocessor) {
    final Postprocessor postprocessor;
    switch (config.postprocessorType) {
      case "use_slow_postprocessor":
        postprocessor = DelayPostprocessor.getMediumPostprocessor();
        break;
      case "use_fast_postprocessor":
        postprocessor = DelayPostprocessor.getFastPostprocessor();
        break;
      default:
        postprocessor = DelayPostprocessor.getMediumPostprocessor();
    }
    imageRequestBuilder.setPostprocessor(postprocessor);
  }
  if (config.rotateUsingMetaData) {
    imageRequestBuilder.setRotationOptions(RotationOptions.autoRotateAtRenderTime());
  } else {
    imageRequestBuilder.setRotationOptions(
        RotationOptions.forceRotation(config.forcedRotationAngle));
  }
}
 

@Override
public void produceResults(
    final Consumer<CloseableReference<CloseableImage>> consumer,
    ProducerContext context) {
  final ProducerListener listener = context.getListener();
  final Postprocessor postprocessor = context.getImageRequest().getPostprocessor();
  Consumer<CloseableReference<CloseableImage>> postprocessorConsumer;
  if (postprocessor instanceof RepeatedPostprocessor) {
    postprocessorConsumer =
        new RepeatedPostprocessorConsumer(
            consumer,
            listener,
            context.getId(),
            (RepeatedPostprocessor) postprocessor,
            context);
  } else {
    postprocessorConsumer =
        new SingleUsePostprocessorConsumer(consumer, listener, context.getId(), postprocessor);
  }
  mNextProducer.produceResults(postprocessorConsumer, context);
}
 

@Override
public CacheKey getPostprocessedBitmapCacheKey(
    ImageRequest request, @Nullable Object callerContext) {
  final Postprocessor postprocessor = request.getPostprocessor();
  final CacheKey postprocessorCacheKey;
  final String postprocessorName;
  if (postprocessor != null) {
    postprocessorCacheKey = postprocessor.getPostprocessorCacheKey();
    postprocessorName = postprocessor.getClass().getName();
  } else {
    postprocessorCacheKey = null;
    postprocessorName = null;
  }
  return new BitmapMemoryCacheKey(
      getCacheKeySourceUri(request.getSourceUri()).toString(),
      request.getResizeOptions(),
      request.getRotationOptions(),
      request.getImageDecodeOptions(),
      postprocessorCacheKey,
      postprocessorName,
      callerContext);
}
 

@Override
public void produceResults(
    final Consumer<CloseableReference<CloseableImage>> consumer, ProducerContext context) {
  final ProducerListener2 listener = context.getProducerListener();
  final Postprocessor postprocessor = context.getImageRequest().getPostprocessor();
  final PostprocessorConsumer basePostprocessorConsumer =
      new PostprocessorConsumer(consumer, listener, postprocessor, context);
  final Consumer<CloseableReference<CloseableImage>> postprocessorConsumer;
  if (postprocessor instanceof RepeatedPostprocessor) {
    postprocessorConsumer =
        new RepeatedPostprocessorConsumer(
            basePostprocessorConsumer, (RepeatedPostprocessor) postprocessor, context);
  } else {
    postprocessorConsumer = new SingleUsePostprocessorConsumer(basePostprocessorConsumer);
  }
  mInputProducer.produceResults(postprocessorConsumer, context);
}
 

public PostprocessorConsumer(
    Consumer<CloseableReference<CloseableImage>> consumer,
    ProducerListener2 listener,
    Postprocessor postprocessor,
    ProducerContext producerContext) {
  super(consumer);
  mListener = listener;
  mPostprocessor = postprocessor;
  mProducerContext = producerContext;
  producerContext.addCallbacks(
      new BaseProducerContextCallbacks() {
        @Override
        public void onCancellationRequested() {
          maybeNotifyOnCancellation();
        }
      });
}
 

@Nullable
Postprocessor createComposition(
  @Nullable String name,
  int width,
  int height,
  @Nullable JSONObject config,
  @Nonnull CloseableReference<CloseableImage> imageRef,
  @Nonnull CacheKey imageKey,
  @Nonnull Context context
) {
  @Nullable CreateComposition filter = mCompositions.get(name);

  Assertions.assertCondition(
    filter != null,
    "ImageFilterKit: Can't find '" + name + "' filter in registry."
  );

  return filter != null
    ? filter.create(width, height, config, imageRef, imageKey, context)
    : null;
}
 

@Nullable
Postprocessor createSingular(
  @Nullable String name,
  int width,
  int height,
  @Nullable JSONObject config,
  @Nonnull Context context
) {
  @Nullable CreateSingular filter = mSingulars.get(name);

  Assertions.assertCondition(
    filter != null,
    "ImageFilterKit: Can't find '" + name + "' filter in registry."
  );

  return filter != null ? filter.create(width, height, config, context) : null;
}
 

@Override
public CloseableReference<Bitmap> process(
  Bitmap src,
  PlatformBitmapFactory bitmapFactory
) {
  CloseableReference<Bitmap> prevBitmap = null, nextBitmap = null;

  try {
    for (Postprocessor p : mPostProcessors) {
      nextBitmap = p.process(prevBitmap != null ? prevBitmap.get() : src, bitmapFactory);
      CloseableReference.closeSafely(prevBitmap);
      prevBitmap = nextBitmap.clone();
    }

    return nextBitmap == null ? super.process(src, bitmapFactory) : nextBitmap.clone();
  } finally {
    CloseableReference.closeSafely(nextBitmap);
  }
}
 

private @Nullable Map<String, String> getExtraMap(
    ProducerListener2 listener, ProducerContext producerContext, Postprocessor postprocessor) {
  if (!listener.requiresExtraMap(producerContext, NAME)) {
    return null;
  }
  return ImmutableMap.of(POSTPROCESSOR, postprocessor.getName());
}
 

private void setPostprocessor(Postprocessor postprocessor) {
  final ImageRequest imageRequest =
      ImageRequestBuilder.newBuilderWithSource(mUri).setPostprocessor(postprocessor).build();

  final DraweeController draweeController =
      Fresco.newDraweeControllerBuilder()
          .setOldController(mDraweeMain.getController())
          .setImageRequest(imageRequest)
          .build();

  mDraweeMain.setController(draweeController);
}
 

private SingleUsePostprocessorConsumer(
    Consumer<CloseableReference<CloseableImage>> consumer,
    ProducerListener listener,
    String requestId,
    Postprocessor postprocessor) {
  super(consumer, listener, requestId, postprocessor);
}
 

private Map<String, String> getExtraMap(
    ProducerListener listener,
    String requestId,
    Postprocessor postprocessor) {
  if (!listener.requiresExtraMap(requestId)) {
    return null;
  }
  return ImmutableMap.of(POSTPROCESSOR, postprocessor.getName());
}
 

private void postprocessBitmap(
    CloseableReference<CloseableImage> destinationCloseableImageRef,
    Postprocessor postprocessor) {
  Bitmap destinationBitmap =
      ((CloseableBitmap) destinationCloseableImageRef.get()).getUnderlyingBitmap();
  postprocessor.process(destinationBitmap);
}
 

private AbstractPostprocessorConsumer(
    Consumer<CloseableReference<CloseableImage>> consumer,
    ProducerListener listener,
    String requestId,
    Postprocessor postprocessor) {
  mConsumer = consumer;
  mListener = listener;
  mRequestId = requestId;
  mPostprocessor = postprocessor;
}
 

private static void init(FrescoImageView imageView, int cornerRadius, boolean isCircle, boolean isAnima,
                         Point size, Postprocessor postprocessor) {
    imageView.setAnim(isAnima);
    imageView.setCornerRadius(cornerRadius);
    imageView.setFadeTime(300);
    if (isCircle)
        imageView.asCircle();
    if (postprocessor != null)
        imageView.setPostProcessor(postprocessor);
    if (size != null) {
        imageView.setResize(size);
    }
}
 

@Override
public CloseableReference<Bitmap>	process(Bitmap sourceBitmap, PlatformBitmapFactory bitmapFactory) {
  CloseableReference<Bitmap> prevBitmap = null, nextBitmap = null;

  try {
    for (Postprocessor p : mPostprocessors) {
      nextBitmap = p.process(prevBitmap != null ? prevBitmap.get() : sourceBitmap, bitmapFactory);
      CloseableReference.closeSafely(prevBitmap);
      prevBitmap = nextBitmap.clone();
    }
    return nextBitmap.clone();
  } finally {
    CloseableReference.closeSafely(nextBitmap);
  }
}
 

@Override
public CacheKey getPostprocessorCacheKey () {
  LinkedList<CacheKey> keys = new LinkedList<>();
  for (Postprocessor p: mPostprocessors) {
    keys.push(p.getPostprocessorCacheKey());
  }
  return new MultiCacheKey(keys);
}
 

@Override
public String getName () {
  StringBuilder name = new StringBuilder();
  for (Postprocessor p: mPostprocessors) {
    if (name.length() > 0) {
      name.append(",");
    }
    name.append(p.getName());
  }
  name.insert(0, "MultiPostProcessor (");
  name.append(")");
  return name.toString();
}
 

public static Postprocessor from(List<Postprocessor> postprocessors) {
  switch (postprocessors.size()) {
    case 0:
      return null;
    case 1:
      return postprocessors.get(0);
    default:
      return new MultiPostprocessor(postprocessors);
  }
}
 

@Override
public String getName() {
  StringBuilder name = new StringBuilder();
  for (Postprocessor p: mPostProcessors) {
    if (name.length() > 0) {
      name.append(",");
    }
    name.append(p.getName());
  }
  name.insert(0, "MultiPostProcessor (");
  name.append(")");
  return name.toString();
}
 

Postprocessor create(
  int width,
  int height,
  @Nullable JSONObject config,
  @Nonnull CloseableReference<CloseableImage> imageRef,
  @Nonnull CacheKey imageKey,
  @Nonnull Context context
);
 

WeakFilterableImage(
  final @Nonnull ArrayList<Postprocessor> postProcessors,
  final boolean cacheDisabled
) {
  mCacheDisabled = cacheDisabled;
  mPostProcessors = new ArrayList<>();

  for (Postprocessor p : postProcessors) {
    mPostProcessors.add(new WeakReference<>(p));
  }
}
 

@Nullable ArrayList<Postprocessor> getPostProcessors() {
  ArrayList<Postprocessor> ps = new ArrayList<>();

  for (WeakReference<Postprocessor> weak : mPostProcessors) {
    Postprocessor p = weak.get();

    if (p == null) {
      return null;
    }

    ps.add(p);
  }

  return ps;
}
 

FilterableImage(
  final @Nonnull ReactImageView image,
  final @Nonnull ArrayList<Postprocessor> postProcessors,
  final boolean cacheDisabled
) {
  mImage = image;
  mPostProcessors = postProcessors;
  mCacheDisabled = cacheDisabled;
}
 

CacheKey generatedCacheKey() {
  final ArrayList<CacheKey> keys = new ArrayList<>(
    Collections.singletonList(ReactImageViewUtils.getCacheKey(mImage))
  );

  for (Postprocessor p : mPostProcessors) {
    keys.add(
      p instanceof CacheablePostProcessor
        ? ((CacheablePostProcessor) p).generateCacheKey()
        : p.getPostprocessorCacheKey()
    );
  }

  return new MultiCacheKey(keys);
}
 

private Task<FilterableImage> createSingularImage(
  final @Nonnull JSONObject config,
  final @Nonnull Task<FilterableImage> prevImage
) throws JSONException {
  final String name = config.getString("name");

  return prevImage
    .onSuccess(task -> {
      final FilterableImage result = task.getResult();
      final ArrayList<Postprocessor> postProcessors = new ArrayList<>(result.getPostProcessors());

      postProcessors.add(
        PostProcessorRegistry.getInstance()
          .createSingular(
            name,
            mDefaultWidth,
            mDefaultHeight,
            config,
            getContext()
          )
      );

      final boolean cacheDisabled = CacheablePostProcessor.cacheDisabled(config);

      return new FilterableImage(result.getImage(), postProcessors, cacheDisabled);
    }, mFiltering.getToken());
}
 

ArrayList<Postprocessor> getPostProcessors() {
  return mPostProcessors;
}
 

private MultiPostprocessor(List<Postprocessor> postprocessors) {
   mPostprocessors = new LinkedList<>(postprocessors);
}
 

Entry(int descriptionId, Postprocessor postprocessor) {
  this.descriptionId = descriptionId;
  this.postprocessor = postprocessor;
}
 

Postprocessor create(
  int width,
  int height,
  @Nullable JSONObject config,
  @Nonnull Context context
);