# Print output for @column tags ?>
Developers

- Design
- Develop
- Distribute

Developer Console

## Most visited

## Recently visited

## Results for

# PostProcessor

`public interface PostProcessor`
``

android.graphics.PostProcessor

Helper interface for adding custom processing to an image.

The image being processed may be a `Drawable`, a `Bitmap`, or a frame of an `AnimatedImageDrawable` produced by `ImageDecoder`. This is called before the requested object is returned.

This custom processing can even be applied to images that will be returned as immutable objects, such as a `Bitmap` with `Config` `Bitmap.Config#HARDWARE` returned by `ImageDecoder`.

On an `AnimatedImageDrawable`, the callback will only be called once, but the drawing commands will be applied to each frame, as if the `Canvas` had been returned by `Picture#beginRecording`.

Supplied to ImageDecoder via `ImageDecoder#setPostProcessor`.

## Summary

### Public methods
`abstract int` | `onPostProcess(Canvas canvas)` Do any processing after (for example) decoding.

## Public methods

### onPostProcess

    public abstract int onPostProcess (Canvas canvas)

Do any processing after (for example) decoding.

Drawing to the `Canvas` will behave as if the initial processing (e.g. decoding) already exists in the Canvas. An implementation can draw effects on top of this, or it can even draw behind it using `PorterDuff.Mode#DST_OVER`. A common effect is to add transparency to the corners to achieve rounded corners. That can be done with the following code:

      Path path = new Path();
      path.setFillType(Path.FillType.INVERSE_EVEN_ODD);
      int width = canvas.getWidth();
      int height = canvas.getHeight();
      path.addRoundRect(0, 0, width, height, 20, 20, Path.Direction.CW);
      Paint paint = new Paint();
      paint.setAntiAlias(true);
      paint.setColor(Color.TRANSPARENT);
      paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC));
      canvas.drawPath(path, paint);
      return PixelFormat.TRANSLUCENT;

Parameters
`canvas` | `Canvas`: The `Canvas` to draw to. This value cannot be `null`.

Returns
`int` | Opacity of the result after drawing. `PixelFormat#UNKNOWN` means that the implementation did not change whether the image has alpha. Return this unless you added transparency (e.g. with the code above, in which case you should return `PixelFormat#TRANSLUCENT`) or you forced the image to be opaque (e.g. by drawing everywhere with an opaque color and `PorterDuff.Mode#DST_OVER`, in which case you should return `PixelFormat#OPAQUE`). `PixelFormat#TRANSLUCENT` means that the implementation added transparency. This is safe to return even if the image already had transparency. This is also safe to return if the result is opaque, though it may draw more slowly. `PixelFormat#OPAQUE` means that the implementation forced the image to be opaque. This is safe to return even if the image was already opaque. `PixelFormat#TRANSPARENT` (or any other integer) is not allowed, and will result in throwing an `IllegalArgumentException`. Value is `PixelFormat.UNKNOWN`, `PixelFormat.TRANSLUCENT`, `PixelFormat.TRANSPARENT`, or `PixelFormat.OPAQUE`

Full name *
Email address *
Company / developer name
One of your Play Store app URLs *
Which best describes your business:*
Apps
Games
Apps & Games
*
*