Canvas

ALL_SAVE_FLAG

int ALL_SAVE_FLAG

Restore everything when restore() is called (standard save flags).

Note: for performance reasons, it is strongly recommended to pass this - the complete set of flags - to any call to saveLayer() and saveLayerAlpha() variants.

Constant Value: 31 (0x0000001f)

CLIP_SAVE_FLAG

int CLIP_SAVE_FLAG

Restore the current clip when restore() is called.

Constant Value: 2 (0x00000002)

CLIP_TO_LAYER_SAVE_FLAG

int CLIP_TO_LAYER_SAVE_FLAG

Clip drawing to the bounds of the offscreen layer, omit at your own peril.

Note: it is strongly recommended to not omit this flag for any call to saveLayer() and saveLayerAlpha() variants. Not passing this flag generally triggers extremely poor performance with hardware accelerated rendering.

Constant Value: 16 (0x00000010)

FULL_COLOR_LAYER_SAVE_FLAG

int FULL_COLOR_LAYER_SAVE_FLAG

The layer requires full 8-bit precision for each color channel.

Constant Value: 8 (0x00000008)

HAS_ALPHA_LAYER_SAVE_FLAG

int HAS_ALPHA_LAYER_SAVE_FLAG

The layer requires a per-pixel alpha channel.

Constant Value: 4 (0x00000004)

MATRIX_SAVE_FLAG

int MATRIX_SAVE_FLAG

Restore the current matrix when restore() is called.

Constant Value: 1 (0x00000001)

Canvas

Canvas ()

Construct an empty raster canvas. Use setBitmap() to specify a bitmap to draw into. The initial target density is DENSITY_NONE; this will typically be replaced when a target bitmap is set for the canvas.

Canvas

Canvas (Bitmap bitmap)

Construct a canvas with the specified bitmap to draw into. The bitmap must be mutable.

The initial target density of the canvas is the same as the given bitmap's density.

clipPath

boolean clipPath (Path path, 
                Region.Op op)

Modify the current clip with the specified path.

clipPath

boolean clipPath (Path path)

Intersect the current clip with the specified path.

clipRect

boolean clipRect (float left, 
                float top, 
                float right, 
                float bottom, 
                Region.Op op)

Modify the current clip with the specified rectangle, which is expressed in local coordinates.

clipRect

boolean clipRect (RectF rect)

Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

clipRect

boolean clipRect (Rect rect, 
                Region.Op op)

Modify the current clip with the specified rectangle, which is expressed in local coordinates.

clipRect

boolean clipRect (int left, 
                int top, 
                int right, 
                int bottom)

Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

clipRect

boolean clipRect (float left, 
                float top, 
                float right, 
                float bottom)

Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

clipRect

boolean clipRect (RectF rect, 
                Region.Op op)

Modify the current clip with the specified rectangle.

clipRect

boolean clipRect (Rect rect)

Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

clipRegion

boolean clipRegion (Region region)

This method was deprecated in API level 21.
Unlike all other clip calls this API does not respect the current matrix. Use clipRect(Rect) as an alternative.

Intersect the current clip with the specified region. Note that unlike clipRect() and clipPath() which transform their arguments by the current matrix, clipRegion() assumes its argument is already in the coordinate system of the current layer's bitmap, and so not transformation is performed.

clipRegion

boolean clipRegion (Region region, 
                Region.Op op)

This method was deprecated in API level 21.
Unlike all other clip calls this API does not respect the current matrix. Use clipRect(Rect) as an alternative.

Modify the current clip with the specified region. Note that unlike clipRect() and clipPath() which transform their arguments by the current matrix, clipRegion() assumes its argument is already in the coordinate system of the current layer's bitmap, and so not transformation is performed.

concat

void concat (Matrix matrix)

Preconcat the current matrix with the specified matrix. If the specified matrix is null, this method does nothing.

drawARGB

void drawARGB (int a, 
                int r, 
                int g, 
                int b)

Fill the entire canvas' bitmap (restricted to the current clip) with the specified ARGB color, using srcover porterduff mode.

drawArc

void drawArc (float left, 
                float top, 
                float right, 
                float bottom, 
                float startAngle, 
                float sweepAngle, 
                boolean useCenter, 
                Paint paint)

Draw the specified arc, which will be scaled to fit inside the specified oval.

If the start angle is negative or >= 360, the start angle is treated as start angle modulo 360.

If the sweep angle is >= 360, then the oval is drawn completely. Note that this differs slightly from SkPath::arcTo, which treats the sweep angle modulo 360. If the sweep angle is negative, the sweep angle is treated as sweep angle modulo 360

The arc is drawn clockwise. An angle of 0 degrees correspond to the geometric angle of 0 degrees (3 o'clock on a watch.)

drawArc

void drawArc (RectF oval, 
                float startAngle, 
                float sweepAngle, 
                boolean useCenter, 
                Paint paint)

Draw the specified arc, which will be scaled to fit inside the specified oval.

If the start angle is negative or >= 360, the start angle is treated as start angle modulo 360.

If the sweep angle is >= 360, then the oval is drawn completely. Note that this differs slightly from SkPath::arcTo, which treats the sweep angle modulo 360. If the sweep angle is negative, the sweep angle is treated as sweep angle modulo 360

The arc is drawn clockwise. An angle of 0 degrees correspond to the geometric angle of 0 degrees (3 o'clock on a watch.)

drawBitmap

void drawBitmap (Bitmap bitmap, 
                Matrix matrix, 
                Paint paint)

Draw the bitmap using the specified matrix.

drawBitmap

void drawBitmap (int[] colors, 
                int offset, 
                int stride, 
                float x, 
                float y, 
                int width, 
                int height, 
                boolean hasAlpha, 
                Paint paint)

This method was deprecated in API level 21.
Usage with a hardware accelerated canvas requires an internal copy of color buffer contents every time this method is called. Using a Bitmap avoids this copy, and allows the application to more explicitly control the lifetime and copies of pixel data.

Treat the specified array of colors as a bitmap, and draw it. This gives the same result as first creating a bitmap from the array, and then drawing it, but this method avoids explicitly creating a bitmap object which can be more efficient if the colors are changing often.

drawBitmap

void drawBitmap (int[] colors, 
                int offset, 
                int stride, 
                int x, 
                int y, 
                int width, 
                int height, 
                boolean hasAlpha, 
                Paint paint)

This method was deprecated in API level 21.
Usage with a hardware accelerated canvas requires an internal copy of color buffer contents every time this method is called. Using a Bitmap avoids this copy, and allows the application to more explicitly control the lifetime and copies of pixel data.

Legacy version of drawBitmap(int[] colors, ...) that took ints for x,y

drawBitmap

void drawBitmap (Bitmap bitmap, 
                Rect src, 
                Rect dst, 
                Paint paint)

Draw the specified bitmap, scaling/translating automatically to fill the destination rectangle. If the source rectangle is not null, it specifies the subset of the bitmap to draw.

Note: if the paint contains a maskfilter that generates a mask which extends beyond the bitmap's original width/height (e.g. BlurMaskFilter), then the bitmap will be drawn as if it were in a Shader with CLAMP mode. Thus the color outside of the original width/height will be the edge color replicated.

This function ignores the density associated with the bitmap. This is because the source and destination rectangle coordinate spaces are in their respective densities, so must already have the appropriate scaling factor applied.

drawBitmap

void drawBitmap (Bitmap bitmap, 
                float left, 
                float top, 
                Paint paint)

Draw the specified bitmap, with its top/left corner at (x,y), using the specified paint, transformed by the current matrix.

Note: if the paint contains a maskfilter that generates a mask which extends beyond the bitmap's original width/height (e.g. BlurMaskFilter), then the bitmap will be drawn as if it were in a Shader with CLAMP mode. Thus the color outside of the original width/height will be the edge color replicated.

If the bitmap and canvas have different densities, this function will take care of automatically scaling the bitmap to draw at the same density as the canvas.

drawBitmap

void drawBitmap (Bitmap bitmap, 
                Rect src, 
                RectF dst, 
                Paint paint)

Draw the specified bitmap, scaling/translating automatically to fill the destination rectangle. If the source rectangle is not null, it specifies the subset of the bitmap to draw.

Note: if the paint contains a maskfilter that generates a mask which extends beyond the bitmap's original width/height (e.g. BlurMaskFilter), then the bitmap will be drawn as if it were in a Shader with CLAMP mode. Thus the color outside of the original width/height will be the edge color replicated.

This function ignores the density associated with the bitmap. This is because the source and destination rectangle coordinate spaces are in their respective densities, so must already have the appropriate scaling factor applied.

drawBitmapMesh

void drawBitmapMesh (Bitmap bitmap, 
                int meshWidth, 
                int meshHeight, 
                float[] verts, 
                int vertOffset, 
                int[] colors, 
                int colorOffset, 
                Paint paint)

Draw the bitmap through the mesh, where mesh vertices are evenly distributed across the bitmap. There are meshWidth+1 vertices across, and meshHeight+1 vertices down. The verts array is accessed in row-major order, so that the first meshWidth+1 vertices are distributed across the top of the bitmap from left to right. A more general version of this method is drawVertices().

drawCircle

void drawCircle (float cx, 
                float cy, 
                float radius, 
                Paint paint)

Draw the specified circle using the specified paint. If radius is <= 0, then nothing will be drawn. The circle will be filled or framed based on the Style in the paint.

drawColor

void drawColor (int color)

Fill the entire canvas' bitmap (restricted to the current clip) with the specified color, using srcover porterduff mode.

drawColor

void drawColor (int color, 
                PorterDuff.Mode mode)

Fill the entire canvas' bitmap (restricted to the current clip) with the specified color and porter-duff xfermode.

drawLine

void drawLine (float startX, 
                float startY, 
                float stopX, 
                float stopY, 
                Paint paint)

Draw a line segment with the specified start and stop x,y coordinates, using the specified paint.

Note that since a line is always "framed", the Style is ignored in the paint.

Degenerate lines (length is 0) will not be drawn.

drawLines

void drawLines (float[] pts, 
                int offset, 
                int count, 
                Paint paint)

Draw a series of lines. Each line is taken from 4 consecutive values in the pts array. Thus to draw 1 line, the array must contain at least 4 values. This is logically the same as drawing the array as follows: drawLine(pts[0], pts[1], pts[2], pts[3]) followed by drawLine(pts[4], pts[5], pts[6], pts[7]) and so on.

drawLines

void drawLines (float[] pts, 
                Paint paint)

drawOval

void drawOval (float left, 
                float top, 
                float right, 
                float bottom, 
                Paint paint)

Draw the specified oval using the specified paint. The oval will be filled or framed based on the Style in the paint.

drawOval

void drawOval (RectF oval, 
                Paint paint)

Draw the specified oval using the specified paint. The oval will be filled or framed based on the Style in the paint.

drawPaint

void drawPaint (Paint paint)

Fill the entire canvas' bitmap (restricted to the current clip) with the specified paint. This is equivalent (but faster) to drawing an infinitely large rectangle with the specified paint.

drawPath

void drawPath (Path path, 
                Paint paint)

Draw the specified path using the specified paint. The path will be filled or framed based on the Style in the paint.

drawPicture

void drawPicture (Picture picture, 
                Rect dst)

Draw the picture, stretched to fit into the dst rectangle.

drawPicture

void drawPicture (Picture picture, 
                RectF dst)

Draw the picture, stretched to fit into the dst rectangle.

drawPicture

void drawPicture (Picture picture)

Save the canvas state, draw the picture, and restore the canvas state. This differs from picture.draw(canvas), which does not perform any save/restore.

Note: This forces the picture to internally call endRecording() in order to prepare for playback.

drawPoint

void drawPoint (float x, 
                float y, 
                Paint paint)

Helper for drawPoints() for drawing a single point.

drawPoints

void drawPoints (float[] pts, 
                int offset, 
                int count, 
                Paint paint)

Draw a series of points. Each point is centered at the coordinate specified by pts[], and its diameter is specified by the paint's stroke width (as transformed by the canvas' CTM), with special treatment for a stroke width of 0, which always draws exactly 1 pixel (or at most 4 if antialiasing is enabled). The shape of the point is controlled by the paint's Cap type. The shape is a square, unless the cap type is Round, in which case the shape is a circle.

drawPoints

void drawPoints (float[] pts, 
                Paint paint)

Helper for drawPoints() that assumes you want to draw the entire array

drawPosText

void drawPosText (String text, 
                float[] pos, 
                Paint paint)

This method was deprecated in API level 16.
This method does not support glyph composition and decomposition and should therefore not be used to render complex scripts. It also doesn't handle supplementary characters (eg emoji).

Draw the text in the array, with each character's origin specified by the pos array.

drawPosText

void drawPosText (char[] text, 
                int index, 
                int count, 
                float[] pos, 
                Paint paint)

This method was deprecated in API level 16.
This method does not support glyph composition and decomposition and should therefore not be used to render complex scripts. It also doesn't handle supplementary characters (eg emoji).

Draw the text in the array, with each character's origin specified by the pos array.

drawRGB

void drawRGB (int r, 
                int g, 
                int b)

Fill the entire canvas' bitmap (restricted to the current clip) with the specified RGB color, using srcover porterduff mode.

drawRect

void drawRect (float left, 
                float top, 
                float right, 
                float bottom, 
                Paint paint)

Draw the specified Rect using the specified paint. The rectangle will be filled or framed based on the Style in the paint.

drawRect

void drawRect (Rect r, 
                Paint paint)

Draw the specified Rect using the specified Paint. The rectangle will be filled or framed based on the Style in the paint.

drawRect

void drawRect (RectF rect, 
                Paint paint)

Draw the specified Rect using the specified paint. The rectangle will be filled or framed based on the Style in the paint.

drawRoundRect

void drawRoundRect (RectF rect, 
                float rx, 
                float ry, 
                Paint paint)

Draw the specified round-rect using the specified paint. The roundrect will be filled or framed based on the Style in the paint.

drawRoundRect

void drawRoundRect (float left, 
                float top, 
                float right, 
                float bottom, 
                float rx, 
                float ry, 
                Paint paint)

Draw the specified round-rect using the specified paint. The roundrect will be filled or framed based on the Style in the paint.

drawText

void drawText (CharSequence text, 
                int start, 
                int end, 
                float x, 
                float y, 
                Paint paint)

Draw the specified range of text, specified by start/end, with its origin at (x,y), in the specified Paint. The origin is interpreted based on the Align setting in the Paint.

drawText

void drawText (String text, 
                float x, 
                float y, 
                Paint paint)

Draw the text, with origin at (x,y), using the specified paint. The origin is interpreted based on the Align setting in the paint.

drawText

void drawText (String text, 
                int start, 
                int end, 
                float x, 
                float y, 
                Paint paint)

Draw the text, with origin at (x,y), using the specified paint. The origin is interpreted based on the Align setting in the paint.

drawText

void drawText (char[] text, 
                int index, 
                int count, 
                float x, 
                float y, 
                Paint paint)

Draw the text, with origin at (x,y), using the specified paint. The origin is interpreted based on the Align setting in the paint.

drawTextOnPath

void drawTextOnPath (String text, 
                Path path, 
                float hOffset, 
                float vOffset, 
                Paint paint)

Draw the text, with origin at (x,y), using the specified paint, along the specified path. The paint's Align setting determins where along the path to start the text.

drawTextOnPath

void drawTextOnPath (char[] text, 
                int index, 
                int count, 
                Path path, 
                float hOffset, 
                float vOffset, 
                Paint paint)

Draw the text, with origin at (x,y), using the specified paint, along the specified path. The paint's Align setting determins where along the path to start the text.

drawTextRun

void drawTextRun (char[] text, 
                int index, 
                int count, 
                int contextIndex, 
                int contextCount, 
                float x, 
                float y, 
                boolean isRtl, 
                Paint paint)

Draw a run of text, all in a single direction, with optional context for complex text shaping.

See drawTextRun(CharSequence, int, int, int, int, float, float, boolean, Paint) for more details. This method uses a character array rather than CharSequence to represent the string. Also, to be consistent with the pattern established in drawText(char[], int, int, float, float, Paint), in this method count and contextCount are used rather than offsets of the end position; count = end - start, contextCount = contextEnd - contextStart.

drawTextRun

void drawTextRun (CharSequence text, 
                int start, 
                int end, 
                int contextStart, 
                int contextEnd, 
                float x, 
                float y, 
                boolean isRtl, 
                Paint paint)

Draw a run of text, all in a single direction, with optional context for complex text shaping.

The run of text includes the characters from start to end in the text. In addition, the range contextStart to contextEnd is used as context for the purpose of complex text shaping, such as Arabic text potentially shaped differently based on the text next to it.

All text outside the range contextStart..contextEnd is ignored. The text between start and end will be laid out and drawn.

The direction of the run is explicitly specified by isRtl. Thus, this method is suitable only for runs of a single direction. Alignment of the text is as determined by the Paint's TextAlign value. Further, 0 <= contextStart <= start <= end <= contextEnd <= text.length must hold on entry.

Also see getRunAdvance(char[], int, int, int, int, boolean, int) for a corresponding method to measure the text; the advance width of the text drawn matches the value obtained from that method.

drawVertices

void drawVertices (Canvas.VertexMode mode, 
                int vertexCount, 
                float[] verts, 
                int vertOffset, 
                float[] texs, 
                int texOffset, 
                int[] colors, 
                int colorOffset, 
                short[] indices, 
                int indexOffset, 
                int indexCount, 
                Paint paint)

Draw the array of vertices, interpreted as triangles (based on mode). The verts array is required, and specifies the x,y pairs for each vertex. If texs is non-null, then it is used to specify the coordinate in shader coordinates to use at each vertex (the paint must have a shader in this case). If there is no texs array, but there is a color array, then each color is interpolated across its corresponding triangle in a gradient. If both texs and colors arrays are present, then they behave as before, but the resulting color at each pixels is the result of multiplying the colors from the shader and the color-gradient together. The indices array is optional, but if it is present, then it is used to specify the index of each triangle, rather than just walking through the arrays in order.

getClipBounds

boolean getClipBounds (Rect bounds)

Return the bounds of the current clip (in local coordinates) in the bounds parameter, and return true if it is non-empty. This can be useful in a way similar to quickReject, in that it tells you that drawing outside of these bounds will be clipped out.

getClipBounds

Rect getClipBounds ()

Retrieve the bounds of the current clip (in local coordinates).

getDensity

int getDensity ()

Returns the target density of the canvas. The default density is derived from the density of its backing bitmap, or DENSITY_NONE if there is not one.

getDrawFilter

DrawFilter getDrawFilter ()

getHeight

int getHeight ()

Returns the height of the current drawing layer

getMatrix

Matrix getMatrix ()

This method was deprecated in API level 16.
Hardware accelerated canvases may have any matrix when passed to a View or Drawable, as it is implementation defined where in the hierarchy such canvases are created. It is recommended in such cases to either draw contents irrespective of the current matrix, or to track relevant transform state outside of the canvas.

Return a new matrix with a copy of the canvas' current transformation matrix.

getMatrix

void getMatrix (Matrix ctm)

This method was deprecated in API level 16.
Hardware accelerated canvases may have any matrix when passed to a View or Drawable, as it is implementation defined where in the hierarchy such canvases are created. It is recommended in such cases to either draw contents irrespective of the current matrix, or to track relevant transform state outside of the canvas.

Return, in ctm, the current transformation matrix. This does not alter the matrix in the canvas, but just returns a copy of it.

getMaximumBitmapHeight

int getMaximumBitmapHeight ()

Returns the maximum allowed height for bitmaps drawn with this canvas. Attempting to draw with a bitmap taller than this value will result in an error.

getMaximumBitmapWidth

int getMaximumBitmapWidth ()

Returns the maximum allowed width for bitmaps drawn with this canvas. Attempting to draw with a bitmap wider than this value will result in an error.

getSaveCount

int getSaveCount ()

Returns the number of matrix/clip states on the Canvas' private stack. This will equal # save() calls - # restore() calls.

getWidth

int getWidth ()

Returns the width of the current drawing layer

isHardwareAccelerated

boolean isHardwareAccelerated ()

Indicates whether this Canvas uses hardware acceleration. Note that this method does not define what type of hardware acceleration may or may not be used.

isOpaque

boolean isOpaque ()

Return true if the device that the current layer draws into is opaque (i.e. does not support per-pixel alpha).

quickReject

boolean quickReject (float left, 
                float top, 
                float right, 
                float bottom, 
                Canvas.EdgeType type)

Return true if the specified rectangle, after being transformed by the current matrix, would lie completely outside of the current clip. Call this to check if an area you intend to draw into is clipped out (and therefore you can skip making the draw calls).

quickReject

boolean quickReject (Path path, 
                Canvas.EdgeType type)

Return true if the specified path, after being transformed by the current matrix, would lie completely outside of the current clip. Call this to check if an area you intend to draw into is clipped out (and therefore you can skip making the draw calls). Note: for speed it may return false even if the path itself might not intersect the clip (i.e. the bounds of the path intersects, but the path does not).

quickReject

boolean quickReject (RectF rect, 
                Canvas.EdgeType type)

Return true if the specified rectangle, after being transformed by the current matrix, would lie completely outside of the current clip. Call this to check if an area you intend to draw into is clipped out (and therefore you can skip making the draw calls).

restore

void restore ()

This call balances a previous call to save(), and is used to remove all modifications to the matrix/clip state since the last save call. It is an error to call restore() more times than save() was called.

restoreToCount

void restoreToCount (int saveCount)

Efficient way to pop any calls to save() that happened after the save count reached saveCount. It is an error for saveCount to be less than 1. Example: int count = canvas.save(); ... // more calls potentially to save() canvas.restoreToCount(count); // now the canvas is back in the same state it was before the initial // call to save().

rotate

void rotate (float degrees, 
                float px, 
                float py)

Preconcat the current matrix with the specified rotation.

rotate

void rotate (float degrees)

Preconcat the current matrix with the specified rotation.

save

int save (int saveFlags)

Based on saveFlags, can save the current matrix and clip onto a private stack.

Note: if possible, use the parameter-less save(). It is simpler and faster than individually disabling the saving of matrix or clip with this method.

Subsequent calls to translate,scale,rotate,skew,concat or clipRect, clipPath will all operate as usual, but when the balancing call to restore() is made, those calls will be forgotten, and the settings that existed before the save() will be reinstated.

save

int save ()

Saves the current matrix and clip onto a private stack.

Subsequent calls to translate,scale,rotate,skew,concat or clipRect, clipPath will all operate as usual, but when the balancing call to restore() is made, those calls will be forgotten, and the settings that existed before the save() will be reinstated.

saveLayer

int saveLayer (float left, 
                float top, 
                float right, 
                float bottom, 
                Paint paint)

Convenience for saveLayer(left, top, right, bottom, paint, ALL_SAVE_FLAG)

saveLayer

int saveLayer (RectF bounds, 
                Paint paint, 
                int saveFlags)

This behaves the same as save(), but in addition it allocates and redirects drawing to an offscreen bitmap.

Note: this method is very expensive, incurring more than double rendering cost for contained content. Avoid using this method, especially if the bounds provided are large, or if the CLIP_TO_LAYER_SAVE_FLAG is omitted from the saveFlags parameter. It is recommended to use a hardware layer on a View to apply an xfermode, color filter, or alpha, as it will perform much better than this method.

All drawing calls are directed to a newly allocated offscreen bitmap. Only when the balancing call to restore() is made, is that offscreen buffer drawn back to the current target of the Canvas (either the screen, it's target Bitmap, or the previous layer).

Attributes of the Paint - alpha, Xfermode, and ColorFilter are applied when the offscreen bitmap is drawn back when restore() is called.

saveLayer

int saveLayer (RectF bounds, 
                Paint paint)

Convenience for saveLayer(bounds, paint, ALL_SAVE_FLAG)

saveLayer

int saveLayer (float left, 
                float top, 
                float right, 
                float bottom, 
                Paint paint, 
                int saveFlags)

Helper version of saveLayer() that takes 4 values rather than a RectF.

saveLayerAlpha

int saveLayerAlpha (float left, 
                float top, 
                float right, 
                float bottom, 
                int alpha, 
                int saveFlags)

Helper for saveLayerAlpha() that takes 4 values instead of a RectF.

saveLayerAlpha

int saveLayerAlpha (RectF bounds, 
                int alpha, 
                int saveFlags)

This behaves the same as save(), but in addition it allocates and redirects drawing to an offscreen bitmap.

Note: this method is very expensive, incurring more than double rendering cost for contained content. Avoid using this method, especially if the bounds provided are large, or if the CLIP_TO_LAYER_SAVE_FLAG is omitted from the saveFlags parameter. It is recommended to use a hardware layer on a View to apply an xfermode, color filter, or alpha, as it will perform much better than this method.

All drawing calls are directed to a newly allocated offscreen bitmap. Only when the balancing call to restore() is made, is that offscreen buffer drawn back to the current target of the Canvas (either the screen, it's target Bitmap, or the previous layer).

The alpha parameter is applied when the offscreen bitmap is drawn back when restore() is called.

saveLayerAlpha

int saveLayerAlpha (float left, 
                float top, 
                float right, 
                float bottom, 
                int alpha)

Helper for saveLayerAlpha(left, top, right, bottom, alpha, ALL_SAVE_FLAG)

saveLayerAlpha

int saveLayerAlpha (RectF bounds, 
                int alpha)

Convenience for saveLayerAlpha(bounds, alpha, ALL_SAVE_FLAG)

scale

void scale (float sx, 
                float sy, 
                float px, 
                float py)

Preconcat the current matrix with the specified scale.

scale

void scale (float sx, 
                float sy)

Preconcat the current matrix with the specified scale.

setBitmap

void setBitmap (Bitmap bitmap)

Specify a bitmap for the canvas to draw into. All canvas state such as layers, filters, and the save/restore stack are reset with the exception of the current matrix and clip stack. Additionally, as a side-effect the canvas' target density is updated to match that of the bitmap.

setDensity

void setDensity (int density)

Specifies the density for this Canvas' backing bitmap. This modifies the target density of the canvas itself, as well as the density of its backing bitmap via Bitmap.setDensity(int).

setDrawFilter

void setDrawFilter (DrawFilter filter)

setMatrix

void setMatrix (Matrix matrix)

Completely replace the current matrix with the specified matrix. If the matrix parameter is null, then the current matrix is reset to identity. Note: it is recommended to use concat(Matrix), scale(float, float), translate(float, float) and rotate(float) instead of this method.

skew

void skew (float sx, 
                float sy)

Preconcat the current matrix with the specified skew.

translate

void translate (float dx, 
                float dy)

Preconcat the current matrix with the specified translation