Canvas

ALL_SAVE_FLAG

static val ALL_SAVE_FLAG: Int

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.

Note: all methods that accept this flag have flagless versions that are equivalent to passing this flag.

Value: 31

Canvas

Canvas()

Construct an empty raster canvas. Use setBitmap() to specify a bitmap to draw into. The initial target density is Bitmap.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.

clipOutPath

open fun clipOutPath(path: Path): Boolean

Set the clip to the difference of the current clip and the specified path.

clipOutRect

open fun clipOutRect(rect: Rect): Boolean

Set the clip to the difference of the current clip and the specified rectangle, which is expressed in local coordinates.

clipOutRect

open fun clipOutRect(rect: RectF): Boolean

Set the clip to the difference of the current clip and the specified rectangle, which is expressed in local coordinates.

clipOutRect

open fun clipOutRect(
    left: Float, 
    top: Float, 
    right: Float, 
    bottom: Float
): Boolean

Set the clip to the difference of the current clip and the specified rectangle, which is expressed in local coordinates.

clipOutRect

open fun clipOutRect(
    left: Int, 
    top: Int, 
    right: Int, 
    bottom: Int
): Boolean

Set the clip to the difference of the current clip and the specified rectangle, which is expressed in local coordinates.

clipOutShader

open fun clipOutShader(shader: Shader): Unit

Set the clip to the difference of the current clip and the shader. The shader will be treated as an alpha mask, taking the difference of the two.

clipPath

open fun clipPath(path: Path): Boolean

Intersect the current clip with the specified path.

clipPath

open fun clipPath(
    path: Path, 
    op: Region.Op
): Boolean

Deprecated: Region.Op values other than Region.Op.INTERSECT and Region.Op.DIFFERENCE have the ability to expand the clip. The canvas clipping APIs are intended to only expand the clip as a result of a restore operation. This enables a view parent to clip a canvas to clearly define the maximal drawing area of its children. The recommended alternative calls are clipPath(android.graphics.Path) and clipOutPath(android.graphics.Path); As of API Level API level {@value android.os.Build.VERSION_CODES#P Build.VERSION_CODES.P} only Region.Op.INTERSECT and Region.Op.DIFFERENCE are valid Region.Op parameters.

Modify the current clip with the specified path.

clipRect

open fun clipRect(rect: Rect): Boolean

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

clipRect

open fun clipRect(
    rect: Rect, 
    op: Region.Op
): Boolean

Deprecated: Region.Op values other than Region.Op.INTERSECT and Region.Op.DIFFERENCE have the ability to expand the clip. The canvas clipping APIs are intended to only expand the clip as a result of a restore operation. This enables a view parent to clip a canvas to clearly define the maximal drawing area of its children. The recommended alternative calls are clipRect(android.graphics.Rect) and clipOutRect(android.graphics.Rect); As of API Level API level {@value android.os.Build.VERSION_CODES#P Build.VERSION_CODES.P} only Region.Op.INTERSECT and Region.Op.DIFFERENCE are valid Region.Op parameters.

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

clipRect

open fun clipRect(rect: RectF): Boolean

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

clipRect

open fun clipRect(
    rect: RectF, 
    op: Region.Op
): Boolean

Deprecated: Region.Op values other than Region.Op.INTERSECT and Region.Op.DIFFERENCE have the ability to expand the clip. The canvas clipping APIs are intended to only expand the clip as a result of a restore operation. This enables a view parent to clip a canvas to clearly define the maximal drawing area of its children. The recommended alternative calls are clipRect(android.graphics.RectF) and clipOutRect(android.graphics.RectF); As of API Level API level {@value android.os.Build.VERSION_CODES#P Build.VERSION_CODES.P} only Region.Op.INTERSECT and Region.Op.DIFFERENCE are valid Region.Op parameters.

Modify the current clip with the specified rectangle.

clipRect

open fun clipRect(
    left: Float, 
    top: Float, 
    right: Float, 
    bottom: Float
): Boolean

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

clipRect

open fun clipRect(
    left: Float, 
    top: Float, 
    right: Float, 
    bottom: Float, 
    op: Region.Op
): Boolean

Deprecated: Region.Op values other than Region.Op.INTERSECT and Region.Op.DIFFERENCE have the ability to expand the clip. The canvas clipping APIs are intended to only expand the clip as a result of a restore operation. This enables a view parent to clip a canvas to clearly define the maximal drawing area of its children. The recommended alternative calls are clipRect(float,float,float,float) and clipOutRect(float,float,float,float); As of API Level API level {@value android.os.Build.VERSION_CODES#P Build.VERSION_CODES.P} only Region.Op.INTERSECT and Region.Op.DIFFERENCE are valid Region.Op parameters.

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

clipRect

open fun clipRect(
    left: Int, 
    top: Int, 
    right: Int, 
    bottom: Int
): Boolean

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

clipShader

open fun clipShader(shader: Shader): Unit

Intersect the current clip with the specified shader. The shader will be treated as an alpha mask, taking the intersection of the two.

concat

open fun concat(matrix: Matrix?): Unit

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

concat

open fun concat(m: Matrix44?): Unit

Preconcat the current matrix with the specified matrix. If the specified matrix is null, this method does nothing. If the canvas's matrix is changed in the z-axis through this function, the deprecated getMatrix() method will return a 3x3 with z-axis info stripped away.

disableZ

open fun disableZ(): Unit

Disables Z support, preventing any RenderNodes drawn after this point from being visually reordered or having shadows rendered. Note: This is not impacted by any save() or restore() calls as it is not considered to be part of the current matrix or clip. See enableZ()

drawARGB

open fun drawARGB(
    a: Int, 
    r: Int, 
    g: Int, 
    b: Int
): Unit

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

drawArc

open fun drawArc(
    oval: RectF, 
    startAngle: Float, 
    sweepAngle: Float, 
    useCenter: Boolean, 
    paint: Paint
): Unit

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

open fun drawArc(
    left: Float, 
    top: Float, 
    right: Float, 
    bottom: Float, 
    startAngle: Float, 
    sweepAngle: Float, 
    useCenter: Boolean, 
    paint: Paint
): Unit

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

open fun drawBitmap(
    bitmap: Bitmap, 
    matrix: Matrix, 
    paint: Paint?
): Unit

Draw the bitmap using the specified matrix.

drawBitmap

open fun drawBitmap(
    bitmap: Bitmap, 
    src: Rect?, 
    dst: Rect, 
    paint: Paint?
): Unit

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

open fun drawBitmap(
    bitmap: Bitmap, 
    src: Rect?, 
    dst: RectF, 
    paint: Paint?
): Unit

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

open fun drawBitmap(
    bitmap: Bitmap, 
    left: Float, 
    top: Float, 
    paint: Paint?
): Unit

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

open fun drawBitmap(
    colors: IntArray, 
    offset: Int, 
    stride: Int, 
    x: Float, 
    y: Float, 
    width: Int, 
    height: Int, 
    hasAlpha: Boolean, 
    paint: Paint?
): Unit

Deprecated: 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

open fun drawBitmap(
    colors: IntArray, 
    offset: Int, 
    stride: Int, 
    x: Int, 
    y: Int, 
    width: Int, 
    height: Int, 
    hasAlpha: Boolean, 
    paint: Paint?
): Unit

Deprecated: 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

drawBitmapMesh

open fun drawBitmapMesh(
    bitmap: Bitmap, 
    meshWidth: Int, 
    meshHeight: Int, 
    verts: FloatArray, 
    vertOffset: Int, 
    colors: IntArray?, 
    colorOffset: Int, 
    paint: Paint?
): Unit

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(). Prior to API level {@value android.os.Build.VERSION_CODES#P Build.VERSION_CODES.P} vertOffset and colorOffset were ignored, effectively treating them as zeros. In API level {@value android.os.Build.VERSION_CODES#P Build.VERSION_CODES.P} and above these parameters will be respected.

Note: antialiasing is not supported, therefore Paint.ANTI_ALIAS_FLAG is ignored.

drawCircle

open fun drawCircle(
    cx: Float, 
    cy: Float, 
    radius: Float, 
    paint: Paint
): Unit

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

open fun drawColor(color: Int): Unit

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

drawColor

open fun drawColor(
    color: Int, 
    mode: BlendMode
): Unit

Fill the entire canvas' bitmap (restricted to the current clip) with the specified color and blendmode.

drawColor

open fun drawColor(
    color: Int, 
    mode: PorterDuff.Mode
): Unit

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

drawColor

open fun drawColor(color: Long): Unit

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

drawColor

open fun drawColor(
    color: Long, 
    mode: BlendMode
): Unit

Fill the entire canvas' bitmap (restricted to the current clip) with the specified color and blendmode.

drawDoubleRoundRect

open fun drawDoubleRoundRect(
    outer: RectF, 
    outerRx: Float, 
    outerRy: Float, 
    inner: RectF, 
    innerRx: Float, 
    innerRy: Float, 
    paint: Paint
): Unit

Draws a double rounded rectangle using the specified paint. The resultant round rect will be filled in the area defined between the outer and inner rectangular bounds if the Paint configured with Paint.Style.FILL. Otherwise if Paint.Style.STROKE is used, then 2 rounded rect strokes will be drawn at the outer and inner rounded rectangles

drawDoubleRoundRect

open fun drawDoubleRoundRect(
    outer: RectF, 
    outerRadii: FloatArray, 
    inner: RectF, 
    innerRadii: FloatArray, 
    paint: Paint
): Unit

Draws a double rounded rectangle using the specified paint. The resultant round rect will be filled in the area defined between the outer and inner rectangular bounds if the Paint configured with Paint.Style.FILL. Otherwise if Paint.Style.STROKE is used, then 2 rounded rect strokes will be drawn at the outer and inner rounded rectangles

drawGlyphs

open fun drawGlyphs(
    glyphIds: IntArray, 
    glyphIdOffset: Int, 
    positions: FloatArray, 
    positionOffset: Int, 
    glyphCount: Int, 
    font: Font, 
    paint: Paint
): Unit

Draw array of glyphs with specified font.

drawLine

open fun drawLine(
    startX: Float, 
    startY: Float, 
    stopX: Float, 
    stopY: Float, 
    paint: Paint
): Unit

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

open fun drawLines(
    pts: FloatArray, 
    paint: Paint
): Unit

drawLines

open fun drawLines(
    pts: FloatArray, 
    offset: Int, 
    count: Int, 
    paint: Paint
): Unit

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.

drawMesh

open fun drawMesh(
    mesh: Mesh, 
    blendMode: BlendMode?, 
    paint: Paint
): Unit

Draws a mesh object to the screen.

Note: antialiasing is not supported, therefore Paint.ANTI_ALIAS_FLAG is ignored.

drawOval

open fun drawOval(
    oval: RectF, 
    paint: Paint
): Unit

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

drawOval

open fun drawOval(
    left: Float, 
    top: Float, 
    right: Float, 
    bottom: Float, 
    paint: Paint
): Unit

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

drawPaint

open fun drawPaint(paint: Paint): Unit

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.

drawPatch

open fun drawPatch(
    patch: NinePatch, 
    dst: Rect, 
    paint: Paint?
): Unit

Draws the specified bitmap as an N-patch (most often, a 9-patch.)

Note: antialiasing is not supported, therefore Paint.ANTI_ALIAS_FLAG is ignored.

drawPatch

open fun drawPatch(
    patch: NinePatch, 
    dst: RectF, 
    paint: Paint?
): Unit

Draws the specified bitmap as an N-patch (most often, a 9-patch.)

Note: antialiasing is not supported, therefore Paint.ANTI_ALIAS_FLAG is ignored.

drawPath

open fun drawPath(
    path: Path, 
    paint: Paint
): Unit

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

drawPicture

open fun drawPicture(picture: Picture): Unit

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 Picture.endRecording in order to prepare for playback.

drawPicture

open fun drawPicture(
    picture: Picture, 
    dst: Rect
): Unit

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

drawPicture

open fun drawPicture(
    picture: Picture, 
    dst: RectF
): Unit

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

drawPoint

open fun drawPoint(
    x: Float, 
    y: Float, 
    paint: Paint
): Unit

Helper for drawPoints() for drawing a single point.

drawPoints

open fun drawPoints(
    pts: FloatArray, 
    paint: Paint
): Unit

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

drawPoints

open fun drawPoints(
    pts: FloatArray!, 
    offset: Int, 
    count: Int, 
    paint: Paint
): Unit

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.

drawPosText

open fun drawPosText(
    text: CharArray, 
    index: Int, 
    count: Int, 
    pos: FloatArray, 
    paint: Paint
): Unit

Deprecated: 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

open fun drawPosText(
    text: String, 
    pos: FloatArray, 
    paint: Paint
): Unit

Deprecated: 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

open fun drawRGB(
    r: Int, 
    g: Int, 
    b: Int
): Unit

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

drawRect

open fun drawRect(
    r: Rect, 
    paint: Paint
): Unit

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

drawRect

open fun drawRect(
    rect: RectF, 
    paint: Paint
): Unit

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

drawRect

open fun drawRect(
    left: Float, 
    top: Float, 
    right: Float, 
    bottom: Float, 
    paint: Paint
): Unit

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

drawRenderNode

open fun drawRenderNode(renderNode: RenderNode): Unit

Draws the given RenderNode. This is only supported in hardware rendering, which can be verified by asserting that isHardwareAccelerated() is true. If isHardwareAccelerated() is false then this throws an exception. See RenderNode for more information on what a RenderNode is and how to use it.

drawRoundRect

open fun drawRoundRect(
    rect: RectF, 
    rx: Float, 
    ry: Float, 
    paint: Paint
): Unit

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

drawRoundRect

open fun drawRoundRect(
    left: Float, 
    top: Float, 
    right: Float, 
    bottom: Float, 
    rx: Float, 
    ry: Float, 
    paint: Paint
): Unit

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

drawText

open fun drawText(
    text: CharArray, 
    index: Int, 
    count: Int, 
    x: Float, 
    y: Float, 
    paint: Paint
): Unit

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

open fun drawText(
    text: CharSequence, 
    start: Int, 
    end: Int, 
    x: Float, 
    y: Float, 
    paint: Paint
): Unit

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

open fun drawText(
    text: String, 
    x: Float, 
    y: Float, 
    paint: Paint
): Unit

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

open fun drawText(
    text: String, 
    start: Int, 
    end: Int, 
    x: Float, 
    y: Float, 
    paint: Paint
): Unit

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

open fun drawTextOnPath(
    text: CharArray, 
    index: Int, 
    count: Int, 
    path: Path, 
    hOffset: Float, 
    vOffset: Float, 
    paint: Paint
): Unit

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

drawTextOnPath

open fun drawTextOnPath(
    text: String, 
    path: Path, 
    hOffset: Float, 
    vOffset: Float, 
    paint: Paint
): Unit

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

drawTextRun

open fun drawTextRun(
    text: MeasuredText, 
    start: Int, 
    end: Int, 
    contextStart: Int, 
    contextEnd: Int, 
    x: Float, 
    y: Float, 
    isRtl: Boolean, 
    paint: Paint
): Unit

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

See drawTextRun(java.lang.CharSequence,int,int,int,int,float,float,boolean,android.graphics.Paint) for more details. This method uses a MeasuredText rather than CharSequence to represent the string.

drawTextRun

open fun drawTextRun(
    text: CharArray, 
    index: Int, 
    count: Int, 
    contextIndex: Int, 
    contextCount: Int, 
    x: Float, 
    y: Float, 
    isRtl: Boolean, 
    paint: Paint
): Unit

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

See drawTextRun(java.lang.CharSequence,int,int,int,int,float,float,boolean,android.graphics.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, in this method count and contextCount are used rather than offsets of the end position; count = end - start, contextCount = contextEnd - contextStart.

drawTextRun

open fun drawTextRun(
    text: CharSequence, 
    start: Int, 
    end: Int, 
    contextStart: Int, 
    contextEnd: Int, 
    x: Float, 
    y: Float, 
    isRtl: Boolean, 
    paint: Paint
): Unit

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 context range is useful for contextual shaping, e.g. Kerning, Arabic contextural form.

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 android.graphics.Paint#getRunAdvance for a corresponding method to measure the text; the advance width of the text drawn matches the value obtained from that method.