/* * Copyright (C) 2006 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package android.graphics; import static com.android.text.flags.Flags.FLAG_DEPRECATE_ELEGANT_TEXT_HEIGHT_API; import static com.android.text.flags.Flags.FLAG_FIX_LINE_HEIGHT_FOR_LOCALE; import static com.android.text.flags.Flags.FLAG_LETTER_SPACING_JUSTIFICATION; import static com.android.text.flags.Flags.FLAG_TYPEFACE_REDESIGN_READONLY; import static com.android.text.flags.Flags.FLAG_VERTICAL_TEXT_LAYOUT; import android.annotation.ColorInt; import android.annotation.ColorLong; import android.annotation.FlaggedApi; import android.annotation.IntDef; import android.annotation.IntRange; import android.annotation.NonNull; import android.annotation.Nullable; import android.annotation.Px; import android.annotation.Size; import android.app.compat.CompatChanges; import android.compat.annotation.ChangeId; import android.compat.annotation.EnabledSince; import android.compat.annotation.UnsupportedAppUsage; import android.graphics.fonts.FontVariationAxis; import android.graphics.text.TextRunShaper; import android.os.Build; import android.os.LocaleList; import android.text.GraphicsOperations; import android.text.SpannableString; import android.text.SpannedString; import android.text.TextUtils; import android.util.Log; import com.android.internal.annotations.GuardedBy; import com.android.text.flags.Flags; import dalvik.annotation.optimization.CriticalNative; import dalvik.annotation.optimization.FastNative; import libcore.util.NativeAllocationRegistry; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Locale; import java.util.Objects; /** * The Paint class holds the style and color information about how to draw * geometries, text and bitmaps. */ @android.ravenwood.annotation.RavenwoodKeepWholeClass public class Paint { private static final String TAG = "Paint"; @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553) private long mNativePaint; private long mNativeShader; private long mNativeColorFilter; private long mNativeXfermode; // Use a Holder to allow static initialization of Paint in the boot image. private static class NoImagePreloadHolder { public static final NativeAllocationRegistry sRegistry = NativeAllocationRegistry.createMalloced( Paint.class.getClassLoader(), nGetNativeFinalizer()); } @ColorLong private long mColor; private ColorFilter mColorFilter; private MaskFilter mMaskFilter; private PathEffect mPathEffect; private Shader mShader; @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023) private Typeface mTypeface; private Xfermode mXfermode; private boolean mHasCompatScaling; private float mCompatScaling; private float mInvCompatScaling; private LocaleList mLocales; private String mFontFeatureSettings; private String mFontVariationSettings; private String mFontVariationOverride; private float mShadowLayerRadius; private float mShadowLayerDx; private float mShadowLayerDy; @ColorLong private long mShadowLayerColor; private static final Object sCacheLock = new Object(); /** * Cache for the Minikin language list ID. * * A map from a string representation of the LocaleList to Minikin's language list ID. */ @GuardedBy("sCacheLock") private static final HashMap sMinikinLocaleListIdCache = new HashMap<>(); /** * @hide */ public int mBidiFlags = BIDI_DEFAULT_LTR; static final Style[] sStyleArray = { Style.FILL, Style.STROKE, Style.FILL_AND_STROKE }; static final Cap[] sCapArray = { Cap.BUTT, Cap.ROUND, Cap.SQUARE }; static final Join[] sJoinArray = { Join.MITER, Join.ROUND, Join.BEVEL }; static final Align[] sAlignArray = { Align.LEFT, Align.CENTER, Align.RIGHT }; /** @hide */ @Retention(RetentionPolicy.SOURCE) @IntDef(flag = true, value = { ANTI_ALIAS_FLAG, FILTER_BITMAP_FLAG, DITHER_FLAG, UNDERLINE_TEXT_FLAG, STRIKE_THRU_TEXT_FLAG, FAKE_BOLD_TEXT_FLAG, LINEAR_TEXT_FLAG, SUBPIXEL_TEXT_FLAG, EMBEDDED_BITMAP_TEXT_FLAG, TEXT_RUN_FLAG_LEFT_EDGE, TEXT_RUN_FLAG_RIGHT_EDGE }) public @interface PaintFlag{} /** * Paint flag that enables antialiasing when drawing. * *

Enabling this flag will cause all draw operations that support * antialiasing to use it.

* *

Notable draw operations that do not support antialiasing include:

* * * @see #Paint(int) * @see #setFlags(int) */ public static final int ANTI_ALIAS_FLAG = 0x01; /** * Paint flag that enables bilinear sampling on scaled bitmaps. * *

If cleared, scaled bitmaps will be drawn with nearest neighbor * sampling, likely resulting in artifacts. This should generally be on * when drawing bitmaps, unless performance-bound (rendering to software * canvas) or preferring pixelation artifacts to blurriness when scaling * significantly.

* *

If bitmaps are scaled for device density at creation time (as * resource bitmaps often are) the filtering will already have been * done.

* *

On devices running {@link Build.VERSION_CODES#O} and below, hardware * accelerated drawing always uses bilinear sampling on scaled bitmaps, * regardless of this flag. On devices running {@link Build.VERSION_CODES#Q} * and above, this flag defaults to being set on a new {@code Paint}. It can * be cleared with {@link #setFlags} or {@link #setFilterBitmap}.

* * @see #Paint() * @see #Paint(int) * @see #setFlags(int) */ public static final int FILTER_BITMAP_FLAG = 0x02; /** * Paint flag that enables dithering when blitting. * *

Enabling this flag applies a dither to any blit operation where the * target's colour space is more constrained than the source. * * @see #Paint(int) * @see #setFlags(int) */ public static final int DITHER_FLAG = 0x04; /** * Paint flag that applies an underline decoration to drawn text. * * @see #Paint(int) * @see #setFlags(int) */ public static final int UNDERLINE_TEXT_FLAG = 0x08; /** * Paint flag that applies a strike-through decoration to drawn text. * * @see #Paint(int) * @see #setFlags(int) */ public static final int STRIKE_THRU_TEXT_FLAG = 0x10; /** * Paint flag that applies a synthetic bolding effect to drawn text. * *

Enabling this flag will cause text draw operations to apply a * simulated bold effect when drawing a {@link Typeface} that is not * already bold.

* * @see #Paint(int) * @see #setFlags(int) */ public static final int FAKE_BOLD_TEXT_FLAG = 0x20; /** * Paint flag that enables smooth linear scaling of text. * *

Enabling this flag does not actually scale text, but rather adjusts * text draw operations to deal gracefully with smooth adjustment of scale. * When this flag is enabled, font hinting is disabled to prevent shape * deformation between scale factors, and glyph caching is disabled due to * the large number of glyph images that will be generated.

* *

{@link #SUBPIXEL_TEXT_FLAG} should be used in conjunction with this * flag to prevent glyph positions from snapping to whole pixel values as * scale factor is adjusted.

* * @see #Paint(int) * @see #setFlags(int) */ public static final int LINEAR_TEXT_FLAG = 0x40; /** * Paint flag that enables subpixel positioning of text. * *

Enabling this flag causes glyph advances to be computed with subpixel * accuracy.

* *

This can be used with {@link #LINEAR_TEXT_FLAG} to prevent text from * jittering during smooth scale transitions.

* * @see #Paint(int) * @see #setFlags(int) */ public static final int SUBPIXEL_TEXT_FLAG = 0x80; /** Legacy Paint flag, no longer used. */ public static final int DEV_KERN_TEXT_FLAG = 0x100; /** @hide bit mask for the flag enabling subpixel glyph rendering for text */ public static final int LCD_RENDER_TEXT_FLAG = 0x200; /** * Paint flag that enables the use of bitmap fonts when drawing text. * *

Disabling this flag will prevent text draw operations from using * embedded bitmap strikes in fonts, causing fonts with both scalable * outlines and bitmap strikes to draw only the scalable outlines, and * fonts with only bitmap strikes to not draw at all.

* * @see #Paint(int) * @see #setFlags(int) */ public static final int EMBEDDED_BITMAP_TEXT_FLAG = 0x400; /** @hide bit mask for the flag forcing freetype's autohinter on for text */ public static final int AUTO_HINTING_TEXT_FLAG = 0x800; /** * A flat that controls text to be written in vertical orientation * *

* This flag is used for telling the underlying text layout engine that the text is for vertical * direction. By enabling this flag, text measurement, drawing and shaping APIs works for * vertical text layout. For example, {@link Canvas#drawText(String, float, float, Paint)} draws * text from top to bottom. {@link Paint#measureText(String)} returns vertical advances instead * of horizontal advances. {@link TextRunShaper} shapes text vertically and report glyph IDs for * vertical layout. * *

* Do not set this flag for making {@link android.text.Layout}. The {@link android.text.Layout} * class and its subclasses are designed for horizontal text only and does not work for vertical * text. */ @FlaggedApi(FLAG_VERTICAL_TEXT_LAYOUT) public static final int VERTICAL_TEXT_FLAG = 0x1000; /** * A text run flag that indicates the run is located the visually most left segment of the line. *

* This flag is used for telling the underlying text layout engine that the text is located at * the most left of the line. This flag is used for controlling the amount letter spacing * added. If the text is in the middle of the line, the text layout engine assigns additional * letter spacing to the both side of each letter. On the other hand, the letter spacing should * not be added to the visually most left and right of the line. By setting this flag, text * layout engine calculates the layout as it is located at the most visually left of the line * and doesn't add letter spacing to the left of this run. *

* Note that the caller must resolve BiDi runs and reorder them visually and set this flag only * if the target run is located visually most left position. This left does not always mean the * beginning of the text. *

* If the run covers entire line, caller should set {@link #TEXT_RUN_FLAG_RIGHT_EDGE} as well. *

* Note that this flag is only effective for run based APIs. For example, this flag works for * {@link Canvas#drawTextRun(CharSequence, int, int, int, int, float, float, boolean, Paint)} * and * {@link Paint#getRunCharacterAdvance(char[], int, int, int, int, boolean, int, float[], int)}. * However, this doesn't work for * {@link Canvas#drawText(CharSequence, int, int, float, float, Paint)} or * {@link Paint#measureText(CharSequence, int, int)}. The non-run based APIs works as both * {@link #TEXT_RUN_FLAG_LEFT_EDGE} and {@link #TEXT_RUN_FLAG_RIGHT_EDGE} are specified. */ @FlaggedApi(FLAG_LETTER_SPACING_JUSTIFICATION) public static final int TEXT_RUN_FLAG_LEFT_EDGE = 0x2000; /** * A text run flag that indicates the run is located the visually most right segment of the * line. *

* This flag is used for telling the underlying text layout engine that the text is located at * the most right of the line. This flag is used for controlling the amount letter spacing * added. If the text is in the middle of the line, the text layout engine assigns additional * letter spacing to the both side of each letter. On the other hand, the letter spacing should * not be added to the visually most left and right of the line. By setting this flag, text * layout engine calculates the layout as it is located at the most visually left of the line * and doesn't add letter spacing to the left of this run. *

* Note that the caller must resolve BiDi runs and reorder them visually and set this flag only * if the target run is located visually most right position. This right does not always mean * the end of the text. *

* If the run covers entire line, caller should set {@link #TEXT_RUN_FLAG_LEFT_EDGE} as well. *

* Note that this flag is only effective for run based APIs. For example, this flag works for * {@link Canvas#drawTextRun(CharSequence, int, int, int, int, float, float, boolean, Paint)} * and * {@link Paint#getRunCharacterAdvance(char[], int, int, int, int, boolean, int, float[], int)}. * However, this doesn't work for * {@link Canvas#drawText(CharSequence, int, int, float, float, Paint)} or * {@link Paint#measureText(CharSequence, int, int)}. The non-run based APIs works as both * {@link #TEXT_RUN_FLAG_LEFT_EDGE} and {@link #TEXT_RUN_FLAG_RIGHT_EDGE} are specified. */ @FlaggedApi(FLAG_LETTER_SPACING_JUSTIFICATION) public static final int TEXT_RUN_FLAG_RIGHT_EDGE = 0x4000; // These flags are always set on a new/reset paint, even if flags 0 is passed. static final int HIDDEN_DEFAULT_PAINT_FLAGS = DEV_KERN_TEXT_FLAG | EMBEDDED_BITMAP_TEXT_FLAG | FILTER_BITMAP_FLAG; /** * Font hinter option that disables font hinting. * * @see #setHinting(int) */ public static final int HINTING_OFF = 0x0; /** * Font hinter option that enables font hinting. * * @see #setHinting(int) */ public static final int HINTING_ON = 0x1; /** * Bidi flag to set LTR paragraph direction. * * @hide */ public static final int BIDI_LTR = 0x0; /** * Bidi flag to set RTL paragraph direction. * * @hide */ public static final int BIDI_RTL = 0x1; /** * Bidi flag to detect paragraph direction via heuristics, defaulting to * LTR. * * @hide */ public static final int BIDI_DEFAULT_LTR = 0x2; /** * Bidi flag to detect paragraph direction via heuristics, defaulting to * RTL. * * @hide */ public static final int BIDI_DEFAULT_RTL = 0x3; /** * Bidi flag to override direction to all LTR (ignore bidi). * * @hide */ public static final int BIDI_FORCE_LTR = 0x4; /** * Bidi flag to override direction to all RTL (ignore bidi). * * @hide */ public static final int BIDI_FORCE_RTL = 0x5; /** * Maximum Bidi flag value. * @hide */ private static final int BIDI_MAX_FLAG_VALUE = BIDI_FORCE_RTL; /** * Mask for bidi flags. * @hide */ private static final int BIDI_FLAG_MASK = 0x7; /** * Flag for getTextRunAdvances indicating left-to-right run direction. * @hide */ public static final int DIRECTION_LTR = 0; /** * Flag for getTextRunAdvances indicating right-to-left run direction. * @hide */ public static final int DIRECTION_RTL = 1; /** @hide */ @IntDef(prefix = { "CURSOR_" }, value = { CURSOR_AFTER, CURSOR_AT_OR_AFTER, CURSOR_BEFORE, CURSOR_AT_OR_BEFORE }) @Retention(RetentionPolicy.SOURCE) public @interface CursorOption {} /** * Option for getTextRunCursor. * * Compute the valid cursor after offset or the limit of the context, whichever is less. */ public static final int CURSOR_AFTER = 0; /** * Option for getTextRunCursor. * * Compute the valid cursor at or after the offset or the limit of the context, whichever is * less. */ public static final int CURSOR_AT_OR_AFTER = 1; /** * Option for getTextRunCursor. * * Compute the valid cursor before offset or the start of the context, whichever is greater. */ public static final int CURSOR_BEFORE = 2; /** * Option for getTextRunCursor. * * Compute the valid cursor at or before offset or the start of the context, whichever is * greater. */ public static final int CURSOR_AT_OR_BEFORE = 3; /** * Option for getTextRunCursor. * * Return offset if the cursor at offset is valid, or -1 if it isn't. */ public static final int CURSOR_AT = 4; /** * Maximum cursor option value. */ private static final int CURSOR_OPT_MAX_VALUE = CURSOR_AT; /** @hide */ @IntDef(prefix = { "START_HYPHEN_EDIT_" }, value = { START_HYPHEN_EDIT_NO_EDIT, START_HYPHEN_EDIT_INSERT_HYPHEN, START_HYPHEN_EDIT_INSERT_ZWJ }) @Retention(RetentionPolicy.SOURCE) public @interface StartHyphenEdit {} /** * An integer representing the starting of the line has no modification for hyphenation. */ public static final int START_HYPHEN_EDIT_NO_EDIT = 0x00; /** * An integer representing the starting of the line has normal hyphen character (U+002D). */ public static final int START_HYPHEN_EDIT_INSERT_HYPHEN = 0x01; /** * An integer representing the starting of the line has Zero-Width-Joiner (U+200D). */ public static final int START_HYPHEN_EDIT_INSERT_ZWJ = 0x02; /** @hide */ @IntDef(prefix = { "END_HYPHEN_EDIT_" }, value = { END_HYPHEN_EDIT_NO_EDIT, END_HYPHEN_EDIT_REPLACE_WITH_HYPHEN, END_HYPHEN_EDIT_INSERT_HYPHEN, END_HYPHEN_EDIT_INSERT_ARMENIAN_HYPHEN, END_HYPHEN_EDIT_INSERT_MAQAF, END_HYPHEN_EDIT_INSERT_UCAS_HYPHEN, END_HYPHEN_EDIT_INSERT_ZWJ_AND_HYPHEN }) @Retention(RetentionPolicy.SOURCE) public @interface EndHyphenEdit {} /** * An integer representing the end of the line has no modification for hyphenation. */ public static final int END_HYPHEN_EDIT_NO_EDIT = 0x00; /** * An integer representing the character at the end of the line is replaced with hyphen * character (U+002D). */ public static final int END_HYPHEN_EDIT_REPLACE_WITH_HYPHEN = 0x01; /** * An integer representing the end of the line has normal hyphen character (U+002D). */ public static final int END_HYPHEN_EDIT_INSERT_HYPHEN = 0x02; /** * An integer representing the end of the line has Armentian hyphen (U+058A). */ public static final int END_HYPHEN_EDIT_INSERT_ARMENIAN_HYPHEN = 0x03; /** * An integer representing the end of the line has maqaf (Hebrew hyphen, U+05BE). */ public static final int END_HYPHEN_EDIT_INSERT_MAQAF = 0x04; /** * An integer representing the end of the line has Canadian Syllabics hyphen (U+1400). */ public static final int END_HYPHEN_EDIT_INSERT_UCAS_HYPHEN = 0x05; /** * An integer representing the end of the line has Zero-Width-Joiner (U+200D) followed by normal * hyphen character (U+002D). */ public static final int END_HYPHEN_EDIT_INSERT_ZWJ_AND_HYPHEN = 0x06; /** * The Style specifies if the primitive being drawn is filled, stroked, or * both (in the same color). The default is FILL. */ public enum Style { /** * Geometry and text drawn with this style will be filled, ignoring all * stroke-related settings in the paint. */ FILL (0), /** * Geometry and text drawn with this style will be stroked, respecting * the stroke-related fields on the paint. */ STROKE (1), /** * Geometry and text drawn with this style will be both filled and * stroked at the same time, respecting the stroke-related fields on * the paint. This mode can give unexpected results if the geometry * is oriented counter-clockwise. This restriction does not apply to * either FILL or STROKE. */ FILL_AND_STROKE (2); Style(int nativeInt) { this.nativeInt = nativeInt; } final int nativeInt; } /** * The Cap specifies the treatment for the beginning and ending of * stroked lines and paths. The default is BUTT. */ public enum Cap { /** * The stroke ends with the path, and does not project beyond it. */ BUTT (0), /** * The stroke projects out as a semicircle, with the center at the * end of the path. */ ROUND (1), /** * The stroke projects out as a square, with the center at the end * of the path. */ SQUARE (2); private Cap(int nativeInt) { this.nativeInt = nativeInt; } final int nativeInt; } /** * The Join specifies the treatment where lines and curve segments * join on a stroked path. The default is MITER. */ public enum Join { /** * The outer edges of a join meet at a sharp angle */ MITER (0), /** * The outer edges of a join meet in a circular arc. */ ROUND (1), /** * The outer edges of a join meet with a straight line */ BEVEL (2); private Join(int nativeInt) { this.nativeInt = nativeInt; } final int nativeInt; } /** * Align specifies how drawText aligns its text relative to the * [x,y] coordinates. The default is LEFT. */ public enum Align { /** * The text is drawn to the right of the x,y origin */ LEFT (0), /** * The text is drawn centered horizontally on the x,y origin */ CENTER (1), /** * The text is drawn to the left of the x,y origin */ RIGHT (2); private Align(int nativeInt) { this.nativeInt = nativeInt; } final int nativeInt; } /** * Create a new paint with default settings. * *

On devices running {@link Build.VERSION_CODES#O} and below, hardware * accelerated drawing always acts as if {@link #FILTER_BITMAP_FLAG} is set. * On devices running {@link Build.VERSION_CODES#Q} and above, * {@code FILTER_BITMAP_FLAG} is set by this constructor, and it can be * cleared with {@link #setFlags} or {@link #setFilterBitmap}. * On devices running {@link Build.VERSION_CODES#S} and above, {@code ANTI_ALIAS_FLAG} * is set by this constructor, and it can be cleared with {@link #setFlags} or * {@link #setAntiAlias}.

*/ public Paint() { this(ANTI_ALIAS_FLAG); } /** * Create a new paint with the specified flags. Use setFlags() to change * these after the paint is created. * *

On devices running {@link Build.VERSION_CODES#O} and below, hardware * accelerated drawing always acts as if {@link #FILTER_BITMAP_FLAG} is set. * On devices running {@link Build.VERSION_CODES#Q} and above, * {@code FILTER_BITMAP_FLAG} is always set by this constructor, regardless * of the value of {@code flags}. It can be cleared with {@link #setFlags} or * {@link #setFilterBitmap}.

* * @param flags initial flag bits, as if they were passed via setFlags(). */ public Paint(int flags) { mNativePaint = nInit(); NoImagePreloadHolder.sRegistry.registerNativeAllocation(this, mNativePaint); setFlags(flags | HIDDEN_DEFAULT_PAINT_FLAGS); // TODO: Turning off hinting has undesirable side effects, we need to // revisit hinting once we add support for subpixel positioning // setHinting(DisplayMetrics.DENSITY_DEVICE >= DisplayMetrics.DENSITY_TV // ? HINTING_OFF : HINTING_ON); mCompatScaling = mInvCompatScaling = 1; setTextLocales(LocaleList.getAdjustedDefault()); mColor = Color.pack(Color.BLACK); resetElegantTextHeight(); } /** * Create a new paint, initialized with the attributes in the specified * paint parameter. * * @param paint Existing paint used to initialized the attributes of the * new paint. */ public Paint(Paint paint) { mNativePaint = nInitWithPaint(paint.getNativeInstance()); NoImagePreloadHolder.sRegistry.registerNativeAllocation(this, mNativePaint); setClassVariablesFrom(paint); } /** Restores the paint to its default settings. */ public void reset() { nReset(mNativePaint); setFlags(HIDDEN_DEFAULT_PAINT_FLAGS | ANTI_ALIAS_FLAG); // TODO: Turning off hinting has undesirable side effects, we need to // revisit hinting once we add support for subpixel positioning // setHinting(DisplayMetrics.DENSITY_DEVICE >= DisplayMetrics.DENSITY_TV // ? HINTING_OFF : HINTING_ON); mColor = Color.pack(Color.BLACK); mColorFilter = null; mMaskFilter = null; mPathEffect = null; mShader = null; mNativeShader = 0; mNativeXfermode = 0; mTypeface = null; mXfermode = null; mHasCompatScaling = false; mCompatScaling = 1; mInvCompatScaling = 1; mBidiFlags = BIDI_DEFAULT_LTR; setTextLocales(LocaleList.getAdjustedDefault()); resetElegantTextHeight(); mFontFeatureSettings = null; mFontVariationSettings = null; mShadowLayerRadius = 0.0f; mShadowLayerDx = 0.0f; mShadowLayerDy = 0.0f; mShadowLayerColor = Color.pack(0); } /** * Copy the fields from src into this paint. This is equivalent to calling * get() on all of the src fields, and calling the corresponding set() * methods on this. */ public void set(Paint src) { if (this != src) { // copy over the native settings nSet(mNativePaint, src.mNativePaint); setClassVariablesFrom(src); } } /** * Set all class variables using current values from the given * {@link Paint}. */ private void setClassVariablesFrom(Paint paint) { mColor = paint.mColor; mColorFilter = paint.mColorFilter; mMaskFilter = paint.mMaskFilter; mPathEffect = paint.mPathEffect; mShader = paint.mShader; mNativeShader = paint.mNativeShader; mTypeface = paint.mTypeface; mXfermode = paint.mXfermode; mNativeXfermode = paint.mNativeXfermode; mHasCompatScaling = paint.mHasCompatScaling; mCompatScaling = paint.mCompatScaling; mInvCompatScaling = paint.mInvCompatScaling; mBidiFlags = paint.mBidiFlags; mLocales = paint.mLocales; mFontFeatureSettings = paint.mFontFeatureSettings; mFontVariationSettings = paint.mFontVariationSettings; mShadowLayerRadius = paint.mShadowLayerRadius; mShadowLayerDx = paint.mShadowLayerDx; mShadowLayerDy = paint.mShadowLayerDy; mShadowLayerColor = paint.mShadowLayerColor; } /** @hide */ @UnsupportedAppUsage public void setCompatibilityScaling(float factor) { if (factor == 1.0) { mHasCompatScaling = false; mCompatScaling = mInvCompatScaling = 1.0f; } else { mHasCompatScaling = true; mCompatScaling = factor; mInvCompatScaling = 1.0f/factor; } } /** * Return the pointer to the native object while ensuring that any * mutable objects that are attached to the paint are also up-to-date. * * Note: Although this method is |synchronized|, this is simply so it * is not thread-hostile to multiple threads calling this method. It * is still unsafe to attempt to change the Shader/ColorFilter/Xfermode while * another thread attempts to access the native object. * * @hide */ @UnsupportedAppUsage public synchronized long getNativeInstance() { boolean filter = isFilterBitmap(); long newNativeShader = mShader == null ? 0 : mShader.getNativeInstance(filter); if (newNativeShader != mNativeShader) { mNativeShader = newNativeShader; nSetShader(mNativePaint, mNativeShader); } long newNativeColorFilter = mColorFilter == null ? 0 : mColorFilter.getNativeInstance(); if (newNativeColorFilter != mNativeColorFilter) { mNativeColorFilter = newNativeColorFilter; nSetColorFilter(mNativePaint, mNativeColorFilter); } if (com.android.graphics.hwui.flags.Flags.runtimeColorFiltersBlenders()) { if (mXfermode instanceof RuntimeXfermode) { long newNativeXfermode = ((RuntimeXfermode) mXfermode).createNativeInstance(); if (newNativeXfermode != mNativeXfermode) { mNativeXfermode = newNativeXfermode; nSetXfermode(mNativePaint, mNativeXfermode); } } } return mNativePaint; } /** * Return the bidi flags on the paint. * * @return the bidi flags on the paint * @hide */ public int getBidiFlags() { return mBidiFlags; } /** * Set the bidi flags on the paint. * @hide */ public void setBidiFlags(int flags) { // only flag value is the 3-bit BIDI control setting flags &= BIDI_FLAG_MASK; if (flags > BIDI_MAX_FLAG_VALUE) { throw new IllegalArgumentException("unknown bidi flag: " + flags); } mBidiFlags = flags; } /** * Return the paint's flags. Use the Flag enum to test flag values. * * @return the paint's flags (see enums ending in _Flag for bit masks) */ public @PaintFlag int getFlags() { return nGetFlags(mNativePaint); } /** * Set the paint's flags. Use the Flag enum to specific flag values. * * @param flags The new flag bits for the paint */ public void setFlags(@PaintFlag int flags) { nSetFlags(mNativePaint, flags); } /** * Return the paint's hinting mode. Returns either * {@link #HINTING_OFF} or {@link #HINTING_ON}. */ public int getHinting() { return nGetHinting(mNativePaint); } /** * Set the paint's hinting mode. May be either * {@link #HINTING_OFF} or {@link #HINTING_ON}. */ public void setHinting(int mode) { nSetHinting(mNativePaint, mode); } /** * Helper for getFlags(), returning true if ANTI_ALIAS_FLAG bit is set * AntiAliasing smooths out the edges of what is being drawn, but is has * no impact on the interior of the shape. See setDither() and * setFilterBitmap() to affect how colors are treated. * * @return true if the antialias bit is set in the paint's flags. */ public final boolean isAntiAlias() { return (getFlags() & ANTI_ALIAS_FLAG) != 0; } /** * Helper for setFlags(), setting or clearing the ANTI_ALIAS_FLAG bit * AntiAliasing smooths out the edges of what is being drawn, but is has * no impact on the interior of the shape. See setDither() and * setFilterBitmap() to affect how colors are treated. * * @param aa true to set the antialias bit in the flags, false to clear it */ public void setAntiAlias(boolean aa) { nSetAntiAlias(mNativePaint, aa); } /** * Helper for getFlags(), returning true if DITHER_FLAG bit is set * Dithering affects how colors that are higher precision than the device * are down-sampled. No dithering is generally faster, but higher precision * colors are just truncated down (e.g. 8888 -> 565). Dithering tries to * distribute the error inherent in this process, to reduce the visual * artifacts. * * @return true if the dithering bit is set in the paint's flags. */ public final boolean isDither() { return (getFlags() & DITHER_FLAG) != 0; } /** * Helper for setFlags(), setting or clearing the DITHER_FLAG bit * Dithering affects how colors that are higher precision than the device * are down-sampled. No dithering is generally faster, but higher precision * colors are just truncated down (e.g. 8888 -> 565). Dithering tries to * distribute the error inherent in this process, to reduce the visual * artifacts. * * @param dither true to set the dithering bit in flags, false to clear it */ public void setDither(boolean dither) { nSetDither(mNativePaint, dither); } /** * Helper for getFlags(), returning true if LINEAR_TEXT_FLAG bit is set * * @return true if the lineartext bit is set in the paint's flags */ public final boolean isLinearText() { return (getFlags() & LINEAR_TEXT_FLAG) != 0; } /** * Helper for setFlags(), setting or clearing the LINEAR_TEXT_FLAG bit * * @param linearText true to set the linearText bit in the paint's flags, * false to clear it. */ public void setLinearText(boolean linearText) { nSetLinearText(mNativePaint, linearText); } /** * Helper for getFlags(), returning true if SUBPIXEL_TEXT_FLAG bit is set * * @return true if the subpixel bit is set in the paint's flags */ public final boolean isSubpixelText() { return (getFlags() & SUBPIXEL_TEXT_FLAG) != 0; } /** * Helper for setFlags(), setting or clearing the SUBPIXEL_TEXT_FLAG bit * * @param subpixelText true to set the subpixelText bit in the paint's * flags, false to clear it. */ public void setSubpixelText(boolean subpixelText) { nSetSubpixelText(mNativePaint, subpixelText); } /** * Helper for getFlags(), returning true if UNDERLINE_TEXT_FLAG bit is set * * @return true if the underlineText bit is set in the paint's flags. * @see #getUnderlinePosition() * @see #getUnderlineThickness() * @see #setUnderlineText(boolean) */ public final boolean isUnderlineText() { return (getFlags() & UNDERLINE_TEXT_FLAG) != 0; } /** * Returns the distance from top of the underline to the baseline in pixels. * * The result is positive for positions that are below the baseline. * This method returns where the underline should be drawn independent of if the {@link * #UNDERLINE_TEXT_FLAG} bit is set. * * @return the position of the underline in pixels * @see #isUnderlineText() * @see #getUnderlineThickness() * @see #setUnderlineText(boolean) */ public @Px float getUnderlinePosition() { return nGetUnderlinePosition(mNativePaint); } /** * Returns the thickness of the underline in pixels. * * @return the thickness of the underline in pixels * @see #isUnderlineText() * @see #getUnderlinePosition() * @see #setUnderlineText(boolean) */ public @Px float getUnderlineThickness() { return nGetUnderlineThickness(mNativePaint); } /** * Helper for setFlags(), setting or clearing the UNDERLINE_TEXT_FLAG bit * * @param underlineText true to set the underlineText bit in the paint's * flags, false to clear it. * @see #isUnderlineText() * @see #getUnderlinePosition() * @see #getUnderlineThickness() */ public void setUnderlineText(boolean underlineText) { nSetUnderlineText(mNativePaint, underlineText); } /** * Helper for getFlags(), returning true if STRIKE_THRU_TEXT_FLAG bit is set * * @return true if the {@link #STRIKE_THRU_TEXT_FLAG} bit is set in the paint's flags. * @see #getStrikeThruPosition() * @see #getStrikeThruThickness() * @see #setStrikeThruText(boolean) */ public final boolean isStrikeThruText() { return (getFlags() & STRIKE_THRU_TEXT_FLAG) != 0; } /** * Distance from top of the strike-through line to the baseline in pixels. * * The result is negative for positions that are above the baseline. * This method returns where the strike-through line should be drawn independent of if the * {@link #STRIKE_THRU_TEXT_FLAG} bit is set. * * @return the position of the strike-through line in pixels * @see #getStrikeThruThickness() * @see #setStrikeThruText(boolean) * @see #isStrikeThruText() */ public @Px float getStrikeThruPosition() { return nGetStrikeThruPosition(mNativePaint); } /** * Returns the thickness of the strike-through line in pixels. * * @return the position of the strike-through line in pixels * @see #getStrikeThruPosition() * @see #setStrikeThruText(boolean) * @see #isStrikeThruText() */ public @Px float getStrikeThruThickness() { return nGetStrikeThruThickness(mNativePaint); } /** * Helper for setFlags(), setting or clearing the STRIKE_THRU_TEXT_FLAG bit * * @param strikeThruText true to set the strikeThruText bit in the paint's * flags, false to clear it. * @see #getStrikeThruPosition() * @see #getStrikeThruThickness() * @see #isStrikeThruText() */ public void setStrikeThruText(boolean strikeThruText) { nSetStrikeThruText(mNativePaint, strikeThruText); } /** * Helper for getFlags(), returning true if FAKE_BOLD_TEXT_FLAG bit is set * * @return true if the fakeBoldText bit is set in the paint's flags. */ public final boolean isFakeBoldText() { return (getFlags() & FAKE_BOLD_TEXT_FLAG) != 0; } /** * Helper for setFlags(), setting or clearing the FAKE_BOLD_TEXT_FLAG bit * * @param fakeBoldText true to set the fakeBoldText bit in the paint's * flags, false to clear it. */ public void setFakeBoldText(boolean fakeBoldText) { nSetFakeBoldText(mNativePaint, fakeBoldText); } /** * Whether or not the bitmap filter is activated. * Filtering affects the sampling of bitmaps when they are transformed. * Filtering does not affect how the colors in the bitmap are converted into * device pixels. That is dependent on dithering and xfermodes. * * @see #setFilterBitmap(boolean) setFilterBitmap() * @see #FILTER_BITMAP_FLAG */ public final boolean isFilterBitmap() { return (getFlags() & FILTER_BITMAP_FLAG) != 0; } /** * Helper for setFlags(), setting or clearing the FILTER_BITMAP_FLAG bit. * Filtering affects the sampling of bitmaps when they are transformed. * Filtering does not affect how the colors in the bitmap are converted into * device pixels. That is dependent on dithering and xfermodes. * * @param filter true to set the FILTER_BITMAP_FLAG bit in the paint's * flags, false to clear it. * @see #FILTER_BITMAP_FLAG */ public void setFilterBitmap(boolean filter) { nSetFilterBitmap(mNativePaint, filter); } /** * Return the paint's style, used for controlling how primitives' * geometries are interpreted (except for drawBitmap, which always assumes * FILL_STYLE). * * @return the paint's style setting (Fill, Stroke, StrokeAndFill) */ public Style getStyle() { return sStyleArray[nGetStyle(mNativePaint)]; } /** * Set the paint's style, used for controlling how primitives' * geometries are interpreted (except for drawBitmap, which always assumes * Fill). * * @param style The new style to set in the paint */ public void setStyle(Style style) { nSetStyle(mNativePaint, style.nativeInt); } /** * Return the paint's color in sRGB. Note that the color is a 32bit value * containing alpha as well as r,g,b. This 32bit value is not premultiplied, * meaning that its alpha can be any value, regardless of the values of * r,g,b. See the Color class for more details. * * @return the paint's color (and alpha). */ @ColorInt public int getColor() { return Color.toArgb(mColor); } /** * Return the paint's color. Note that the color is a long with an encoded * {@link ColorSpace} as well as alpha and r,g,b. These values are not * premultiplied, meaning that alpha can be any value, regardless of the * values of r,g,b. See the {@link Color} class for more details. * * @return the paint's color, alpha, and {@code ColorSpace} encoded as a * {@code ColorLong} */ @ColorLong public long getColorLong() { return mColor; } /** * Set the paint's color. Note that the color is an int containing alpha * as well as r,g,b. This 32bit value is not premultiplied, meaning that * its alpha can be any value, regardless of the values of r,g,b. * See the Color class for more details. * * @param color The new color (including alpha) to set in the paint. */ public void setColor(@ColorInt int color) { nSetColor(mNativePaint, color); mColor = Color.pack(color); } /** * Set the paint's color with a {@code ColorLong}. Note that the color is * a long with an encoded {@link ColorSpace} as well as alpha and r,g,b. * These values are not premultiplied, meaning that alpha can be any value, * regardless of the values of r,g,b. See the {@link Color} class for more * details. * * @param color The new color (including alpha and {@link ColorSpace}) * to set in the paint. * @throws IllegalArgumentException if the color space encoded in the * {@code ColorLong} is invalid or unknown. */ public void setColor(@ColorLong long color) { ColorSpace cs = Color.colorSpace(color); nSetColor(mNativePaint, cs.getNativeInstance(), color); mColor = color; } /** * Helper to getColor() that just returns the color's alpha value. This is * the same as calling getColor() >>> 24. It always returns a value between * 0 (completely transparent) and 255 (completely opaque). * * @return the alpha component of the paint's color. */ public int getAlpha() { return Math.round(Color.alpha(mColor) * 255.0f); } /** * Helper to setColor(), that only assigns the color's alpha value, * leaving its r,g,b values unchanged. Results are undefined if the alpha * value is outside of the range [0..255] * * @param a set the alpha component [0..255] of the paint's color. */ public void setAlpha(int a) { // FIXME: No need to unpack this. Instead, just update the alpha bits. // b/122959599 ColorSpace cs = Color.colorSpace(mColor); float r = Color.red(mColor); float g = Color.green(mColor); float b = Color.blue(mColor); mColor = Color.pack(r, g, b, a * (1.0f / 255), cs); nSetAlpha(mNativePaint, a); } /** * Helper to setColor(), that takes a,r,g,b and constructs the color int * * @param a The new alpha component (0..255) of the paint's color. * @param r The new red component (0..255) of the paint's color. * @param g The new green component (0..255) of the paint's color. * @param b The new blue component (0..255) of the paint's color. */ public void setARGB(int a, int r, int g, int b) { setColor((a << 24) | (r << 16) | (g << 8) | b); } /** * Return the width for stroking. *

* A value of 0 strokes in hairline mode. * Hairlines always draws a single pixel independent of the canvas's matrix. * * @return the paint's stroke width, used whenever the paint's style is * Stroke or StrokeAndFill. */ public float getStrokeWidth() { return nGetStrokeWidth(mNativePaint); } /** * Set the width for stroking. * Pass 0 to stroke in hairline mode. * Hairlines always draws a single pixel independent of the canvas's matrix. * * @param width set the paint's stroke width, used whenever the paint's * style is Stroke or StrokeAndFill. */ public void setStrokeWidth(float width) { nSetStrokeWidth(mNativePaint, width); } /** * Return the paint's stroke miter value. Used to control the behavior * of miter joins when the joins angle is sharp. * * @return the paint's miter limit, used whenever the paint's style is * Stroke or StrokeAndFill. */ public float getStrokeMiter() { return nGetStrokeMiter(mNativePaint); } /** * Set the paint's stroke miter value. This is used to control the behavior * of miter joins when the joins angle is sharp. This value must be >= 0. * * @param miter set the miter limit on the paint, used whenever the paint's * style is Stroke or StrokeAndFill. */ public void setStrokeMiter(float miter) { nSetStrokeMiter(mNativePaint, miter); } /** * Return the paint's Cap, controlling how the start and end of stroked * lines and paths are treated. * * @return the line cap style for the paint, used whenever the paint's * style is Stroke or StrokeAndFill. */ public Cap getStrokeCap() { return sCapArray[nGetStrokeCap(mNativePaint)]; } /** * Set the paint's Cap. * * @param cap set the paint's line cap style, used whenever the paint's * style is Stroke or StrokeAndFill. */ public void setStrokeCap(Cap cap) { nSetStrokeCap(mNativePaint, cap.nativeInt); } /** * Return the paint's stroke join type. * * @return the paint's Join. */ public Join getStrokeJoin() { return sJoinArray[nGetStrokeJoin(mNativePaint)]; } /** * Set the paint's Join. * * @param join set the paint's Join, used whenever the paint's style is * Stroke or StrokeAndFill. */ public void setStrokeJoin(Join join) { nSetStrokeJoin(mNativePaint, join.nativeInt); } /** * Applies any/all effects (patheffect, stroking) to src, returning the * result in dst. The result is that drawing src with this paint will be * the same as drawing dst with a default paint (at least from the * geometric perspective). * * @param src input path * @param dst output path (may be the same as src) * @return true if the path should be filled, or false if it should be * drawn with a hairline (width == 0) */ public boolean getFillPath(Path src, Path dst) { return nGetFillPath(mNativePaint, src.readOnlyNI(), dst.mutateNI()); } /** * Get the paint's shader object. * * @return the paint's shader (or null) */ public Shader getShader() { return mShader; } /** * Set or clear the shader object. *

* Pass null to clear any previous shader. * As a convenience, the parameter passed is also returned. * * @param shader May be null. the new shader to be installed in the paint * @return shader */ public Shader setShader(Shader shader) { // If mShader changes, cached value of native shader aren't valid, since // old shader's pointer may be reused by another shader allocation later if (mShader != shader) { mNativeShader = -1; // Release any native references to the old shader content nSetShader(mNativePaint, 0); } // Defer setting the shader natively until getNativeInstance() is called mShader = shader; return shader; } /** * Get the paint's colorfilter (maybe be null). * * @return the paint's colorfilter (maybe be null) */ public ColorFilter getColorFilter() { return mColorFilter; } /** * Set or clear the paint's colorfilter, returning the parameter. * * @param filter May be null. The new filter to be installed in the paint * @return filter */ public ColorFilter setColorFilter(ColorFilter filter) { // If mColorFilter changes, cached value of native shader aren't valid, since // old shader's pointer may be reused by another shader allocation later if (mColorFilter != filter) { mNativeColorFilter = -1; } // Defer setting the filter natively until getNativeInstance() is called mColorFilter = filter; return filter; } /** * Get the paint's transfer mode object. * * @return the paint's transfer mode (or null) */ public Xfermode getXfermode() { return mXfermode; } /** * Get the paint's blend mode object. Will return null if there is a Xfermode applied that * cannot be represented by a blend mode (i.e. a custom {@code RuntimeXfermode} * * @return the paint's blend mode (or null) */ @Nullable public BlendMode getBlendMode() { if (mXfermode == null || !(mXfermode instanceof PorterDuffXfermode)) { return null; } else { return BlendMode.fromValue(((PorterDuffXfermode) mXfermode).porterDuffMode); } } /** * Set or clear the transfer mode object. A transfer mode defines how * source pixels (generate by a drawing command) are composited with * the destination pixels (content of the render target). *

* Pass null to clear any previous transfer mode. * As a convenience, the parameter passed is also returned. *

* {@link PorterDuffXfermode} is the most common transfer mode. * * @param xfermode May be null. The xfermode to be installed in the paint * @return xfermode */ public Xfermode setXfermode(Xfermode xfermode) { return installXfermode(xfermode); } @Nullable private Xfermode installXfermode(Xfermode xfermode) { if (com.android.graphics.hwui.flags.Flags.runtimeColorFiltersBlenders()) { if (xfermode instanceof RuntimeXfermode) { mXfermode = xfermode; nSetXfermode(mNativePaint, ((RuntimeXfermode) xfermode).createNativeInstance()); return xfermode; } } int newMode = (xfermode instanceof PorterDuffXfermode) ? ((PorterDuffXfermode) xfermode).porterDuffMode : PorterDuffXfermode.DEFAULT; int curMode = (mXfermode instanceof PorterDuffXfermode) ? ((PorterDuffXfermode) mXfermode).porterDuffMode : PorterDuffXfermode.DEFAULT; if (newMode != curMode) { nSetXfermode(mNativePaint, newMode); } mXfermode = xfermode; return xfermode; } /** * Set or clear the blend mode. A blend mode defines how source pixels * (generated by a drawing command) are composited with the destination pixels * (content of the render target). *

* Pass null to clear any previous blend mode. *

* * @see BlendMode * * @param blendmode May be null. The blend mode to be installed in the paint */ public void setBlendMode(@Nullable BlendMode blendmode) { installXfermode(blendmode != null ? blendmode.getXfermode() : null); } /** * Get the paint's patheffect object. * * @return the paint's patheffect (or null) */ public PathEffect getPathEffect() { return mPathEffect; } /** * Set or clear the patheffect object. *

* Pass null to clear any previous patheffect. * As a convenience, the parameter passed is also returned. * * @param effect May be null. The patheffect to be installed in the paint * @return effect */ public PathEffect setPathEffect(PathEffect effect) { long effectNative = 0; if (effect != null) { effectNative = effect.native_instance; } nSetPathEffect(mNativePaint, effectNative); mPathEffect = effect; return effect; } /** * Get the paint's maskfilter object. * * @return the paint's maskfilter (or null) */ public MaskFilter getMaskFilter() { return mMaskFilter; } /** * Set or clear the maskfilter object. *

* Pass null to clear any previous maskfilter. * As a convenience, the parameter passed is also returned. * * @param maskfilter May be null. The maskfilter to be installed in the * paint * @return maskfilter */ public MaskFilter setMaskFilter(MaskFilter maskfilter) { long maskfilterNative = 0; if (maskfilter != null) { maskfilterNative = maskfilter.native_instance; } nSetMaskFilter(mNativePaint, maskfilterNative); mMaskFilter = maskfilter; return maskfilter; } /** * Get the paint's typeface object. *

* The typeface object identifies which font to use when drawing or * measuring text. * * @return the paint's typeface (or null) */ public Typeface getTypeface() { return mTypeface; } /** * Set or clear the typeface object. *

* Pass null to clear any previous typeface. * As a convenience, the parameter passed is also returned. * * @param typeface May be null. The typeface to be installed in the paint * @return typeface */ public Typeface setTypeface(Typeface typeface) { if (Flags.typefaceRedesignReadonly() && typeface != null && typeface.isVariationInstance()) { Log.w(TAG, "Attempting to set a Typeface on a Paint object that was previously " + "configured with setFontVariationSettings(). This is no longer supported as " + "of Target SDK " + Build.VERSION_CODES.BAKLAVA + ". To apply font" + " variations, call setFontVariationSettings() directly on the Paint object" + " instead."); } return setTypefaceWithoutWarning(typeface); } private Typeface setTypefaceWithoutWarning(Typeface typeface) { final long typefaceNative = typeface == null ? 0 : typeface.native_instance; nSetTypeface(mNativePaint, typefaceNative); mTypeface = typeface; return typeface; } /** * Get the paint's rasterizer (or null). *

* The raster controls/modifies how paths/text are turned into alpha masks. * * @return the paint's rasterizer (or null) * * @deprecated Rasterizer is not supported by either the HW or PDF backends. * @removed */ @Deprecated public Rasterizer getRasterizer() { return null; } /** * Set or clear the rasterizer object. *

* Pass null to clear any previous rasterizer. * As a convenience, the parameter passed is also returned. * * @param rasterizer May be null. The new rasterizer to be installed in * the paint. * @return rasterizer * * @deprecated Rasterizer is not supported by either the HW or PDF backends. * @removed */ @Deprecated public Rasterizer setRasterizer(Rasterizer rasterizer) { return rasterizer; } /** * This draws a shadow layer below the main layer, with the specified * offset and color, and blur radius. If radius is 0, then the shadow * layer is removed. *

* Can be used to create a blurred shadow underneath text. Support for use * with other drawing operations is constrained to the software rendering * pipeline. *

* The alpha of the shadow will be the paint's alpha if the shadow color is * opaque, or the alpha from the shadow color if not. */ public void setShadowLayer(float radius, float dx, float dy, @ColorInt int shadowColor) { setShadowLayer(radius, dx, dy, Color.pack(shadowColor)); } /** * This draws a shadow layer below the main layer, with the specified * offset and color, and blur radius. If radius is 0, then the shadow * layer is removed. *

* Can be used to create a blurred shadow underneath text. Support for use * with other drawing operations is constrained to the software rendering * pipeline. *

* The alpha of the shadow will be the paint's alpha if the shadow color is * opaque, or the alpha from the shadow color if not. * * @throws IllegalArgumentException if the color space encoded in the * {@code ColorLong} is invalid or unknown. */ public void setShadowLayer(float radius, float dx, float dy, @ColorLong long shadowColor) { ColorSpace cs = Color.colorSpace(shadowColor); nSetShadowLayer(mNativePaint, radius, dx, dy, cs.getNativeInstance(), shadowColor); mShadowLayerRadius = radius; mShadowLayerDx = dx; mShadowLayerDy = dy; mShadowLayerColor = shadowColor; } /** * Clear the shadow layer. */ public void clearShadowLayer() { setShadowLayer(0, 0, 0, 0); } /** * Checks if the paint has a shadow layer attached * * @return true if the paint has a shadow layer attached and false otherwise * @hide */ public boolean hasShadowLayer() { return nHasShadowLayer(mNativePaint); } /** * Returns the blur radius of the shadow layer. * @see #setShadowLayer(float,float,float,int) * @see #setShadowLayer(float,float,float,long) */ public float getShadowLayerRadius() { return mShadowLayerRadius; } /** * Returns the x offset of the shadow layer. * @see #setShadowLayer(float,float,float,int) * @see #setShadowLayer(float,float,float,long) */ public float getShadowLayerDx() { return mShadowLayerDx; } /** * Returns the y offset of the shadow layer. * @see #setShadowLayer(float,float,float,int) * @see #setShadowLayer(float,float,float,long) */ public float getShadowLayerDy() { return mShadowLayerDy; } /** * Returns the color of the shadow layer. * @see #setShadowLayer(float,float,float,int) * @see #setShadowLayer(float,float,float,long) */ public @ColorInt int getShadowLayerColor() { return Color.toArgb(mShadowLayerColor); } /** * Returns the color of the shadow layer. * * @return the shadow layer's color encoded as a {@code ColorLong}. * @see #setShadowLayer(float,float,float,int) * @see #setShadowLayer(float,float,float,long) * @see Color */ public @ColorLong long getShadowLayerColorLong() { return mShadowLayerColor; } /** * Return the paint's Align value for drawing text. This controls how the * text is positioned relative to its origin. LEFT align means that all of * the text will be drawn to the right of its origin (i.e. the origin * specifies the LEFT edge of the text) and so on. * * @return the paint's Align value for drawing text. */ public Align getTextAlign() { return sAlignArray[nGetTextAlign(mNativePaint)]; } /** * Set the paint's text alignment. This controls how the * text is positioned relative to its origin. LEFT align means that all of * the text will be drawn to the right of its origin (i.e. the origin * specifies the LEFT edge of the text) and so on. * * @param align set the paint's Align value for drawing text. */ public void setTextAlign(Align align) { nSetTextAlign(mNativePaint, align.nativeInt); } /** * Get the text's primary Locale. Note that this is not all of the locale-related information * Paint has. Use {@link #getTextLocales()} to get the complete list. * * @return the paint's primary Locale used for drawing text, never null. */ @NonNull public Locale getTextLocale() { return mLocales.get(0); } /** * Get the text locale list. * * @return the paint's LocaleList used for drawing text, never null or empty. */ @NonNull @Size(min=1) public LocaleList getTextLocales() { return mLocales; } /** * Set the text locale list to a one-member list consisting of just the locale. * * See {@link #setTextLocales(LocaleList)} for how the locale list affects * the way the text is drawn for some languages. * * @param locale the paint's locale value for drawing text, must not be null. */ public void setTextLocale(@NonNull Locale locale) { if (locale == null) { throw new IllegalArgumentException("locale cannot be null"); } if (mLocales != null && mLocales.size() == 1 && locale.equals(mLocales.get(0))) { return; } mLocales = new LocaleList(locale); syncTextLocalesWithMinikin(); } /** * Set the text locale list. * * The text locale list affects how the text is drawn for some languages. * * For example, if the locale list contains {@link Locale#CHINESE} or {@link Locale#CHINA}, * then the text renderer will prefer to draw text using a Chinese font. Likewise, * if the locale list contains {@link Locale#JAPANESE} or {@link Locale#JAPAN}, then the text * renderer will prefer to draw text using a Japanese font. If the locale list contains both, * the order those locales appear in the list is considered for deciding the font. * * This distinction is important because Chinese and Japanese text both use many * of the same Unicode code points but their appearance is subtly different for * each language. * * By default, the text locale list is initialized to a one-member list just containing the * system locales. This assumes that the text to be rendered will most likely be in the user's * preferred language. * * If the actual language or languages of the text is/are known, then they can be provided to * the text renderer using this method. The text renderer may attempt to guess the * language script based on the contents of the text to be drawn independent of * the text locale here. Specifying the text locales just helps it do a better * job in certain ambiguous cases. * * @param locales the paint's locale list for drawing text, must not be null or empty. */ public void setTextLocales(@NonNull @Size(min=1) LocaleList locales) { if (locales == null || locales.isEmpty()) { throw new IllegalArgumentException("locales cannot be null or empty"); } if (locales.equals(mLocales)) return; mLocales = locales; syncTextLocalesWithMinikin(); } private void syncTextLocalesWithMinikin() { final String languageTags = mLocales.toLanguageTags(); final Integer minikinLocaleListId; synchronized (sCacheLock) { minikinLocaleListId = sMinikinLocaleListIdCache.get(languageTags); if (minikinLocaleListId == null) { final int newID = nSetTextLocales(mNativePaint, languageTags); sMinikinLocaleListIdCache.put(languageTags, newID); return; } } nSetTextLocalesByMinikinLocaleListId(mNativePaint, minikinLocaleListId.intValue()); } /** * Get the elegant metrics flag. * * Note: * For applications target API 35 or later, this function returns true by default. * For applications target API 36 or later, the function call will be ignored and the elegant * text height is always enabled. * * @return true if elegant metrics are enabled for text drawing. * @deprecated The underlying UI fonts are deprecated and will be removed from the system image. * Applications supporting scripts with large vertical metrics should adapt their UI by using * fonts designed with corresponding vertical metrics. */ @Deprecated @FlaggedApi(FLAG_DEPRECATE_ELEGANT_TEXT_HEIGHT_API) public boolean isElegantTextHeight() { return nGetElegantTextHeight(mNativePaint) != ELEGANT_TEXT_HEIGHT_DISABLED; } // Note: the following three values must be equal to the ones in the JNI file: Paint.cpp private static final int ELEGANT_TEXT_HEIGHT_UNSET = -1; private static final int ELEGANT_TEXT_HEIGHT_ENABLED = 0; private static final int ELEGANT_TEXT_HEIGHT_DISABLED = 1; /** * Set the paint's elegant height metrics flag. This setting selects font * variants that have not been compacted to fit Latin-based vertical * metrics, and also increases top and bottom bounds to provide more space. * *

* Note: * For applications target API 35 or later, the default value will be true by default. * For applications target API 36 or later, the function call will be ignored and the elegant * text height is always enabled. * * @param elegant set the paint's elegant metrics flag for drawing text. * @deprecated This API will be no-op at some point in the future. The underlying UI fonts is * deprecated and will be removed from the system image. Applications supporting scripts with * large vertical metrics should adapt their UI by using fonts designed with corresponding * vertical metrics. */ @Deprecated @FlaggedApi(FLAG_DEPRECATE_ELEGANT_TEXT_HEIGHT_API) public void setElegantTextHeight(boolean elegant) { if (Flags.deprecateElegantTextHeightApi() && !elegant && CompatChanges.isChangeEnabled(DEPRECATE_UI_FONT_ENFORCE)) { if (!elegant) { Log.w(TAG, "The elegant text height cannot be turned off."); } return; } nSetElegantTextHeight(mNativePaint, elegant ? ELEGANT_TEXT_HEIGHT_ENABLED : ELEGANT_TEXT_HEIGHT_DISABLED); } /** * A change ID for deprecating UI fonts. * * From API {@link Build.VERSION_CODES#VANILLA_ICE_CREAM}, the default value will be true by * default if the app has a target SDK of API {@link Build.VERSION_CODES#VANILLA_ICE_CREAM} or * later. * * @hide */ @ChangeId @EnabledSince(targetSdkVersion = Build.VERSION_CODES.VANILLA_ICE_CREAM) public static final long DEPRECATE_UI_FONT = 279646685L; /** * A change ID for deprecating UI fonts enforced. * * From API 36, the elegant text height will not be able to be overridden and always true if the * app has a target SDK of API 36 or later. * * @hide */ @ChangeId @EnabledSince(targetSdkVersion = 36) public static final long DEPRECATE_UI_FONT_ENFORCE = 349519475L; private void resetElegantTextHeight() { if (CompatChanges.isChangeEnabled(DEPRECATE_UI_FONT)) { nSetElegantTextHeight(mNativePaint, ELEGANT_TEXT_HEIGHT_UNSET); } else { nSetElegantTextHeight(mNativePaint, ELEGANT_TEXT_HEIGHT_DISABLED); } } /** * Return the paint's text size. * * @return the paint's text size in pixel units. */ public float getTextSize() { return nGetTextSize(mNativePaint); } /** * Set the paint's text size. This value must be > 0 * * @param textSize set the paint's text size in pixel units. */ public void setTextSize(float textSize) { nSetTextSize(mNativePaint, textSize); } /** * Return the paint's horizontal scale factor for text. The default value * is 1.0. * * @return the paint's scale factor in X for drawing/measuring text */ public float getTextScaleX() { return nGetTextScaleX(mNativePaint); } /** * Set the paint's horizontal scale factor for text. The default value * is 1.0. Values > 1.0 will stretch the text wider. Values < 1.0 will * stretch the text narrower. * * @param scaleX set the paint's scale in X for drawing/measuring text. */ public void setTextScaleX(float scaleX) { nSetTextScaleX(mNativePaint, scaleX); } /** * Return the paint's horizontal skew factor for text. The default value * is 0. * * @return the paint's skew factor in X for drawing text. */ public float getTextSkewX() { return nGetTextSkewX(mNativePaint); } /** * Set the paint's horizontal skew factor for text. The default value * is 0. For approximating oblique text, use values around -0.25. * * @param skewX set the paint's skew factor in X for drawing text. */ public void setTextSkewX(float skewX) { nSetTextSkewX(mNativePaint, skewX); } /** * Return the paint's letter-spacing for text. The default value * is 0. * * @return the paint's letter-spacing for drawing text. */ public float getLetterSpacing() { return nGetLetterSpacing(mNativePaint); } /** * Set the paint's letter-spacing for text. The default value * is 0. The value is in 'EM' units. Typical values for slight * expansion will be around 0.05. Negative values tighten text. * * @param letterSpacing set the paint's letter-spacing for drawing text. */ public void setLetterSpacing(float letterSpacing) { nSetLetterSpacing(mNativePaint, letterSpacing); } /** * Return the paint's extra word-spacing for text. * * The default value is 0. * * @return the paint's extra word-spacing for drawing text in pixels. * @see #setWordSpacing(float) */ public @Px float getWordSpacing() { return nGetWordSpacing(mNativePaint); } /** * Set the paint's extra word-spacing for text. * * Increases the white space width between words with the given amount of pixels. * The default value is 0. * * @param wordSpacing set the paint's extra word-spacing for drawing text in pixels. * @see #getWordSpacing() */ public void setWordSpacing(@Px float wordSpacing) { nSetWordSpacing(mNativePaint, wordSpacing); } /** * Returns the font feature settings. The format is the same as the CSS * font-feature-settings attribute: * * https://www.w3.org/TR/css-fonts-3/#font-feature-settings-prop * * @return the paint's currently set font feature settings. Default is null. * * @see #setFontFeatureSettings(String) */ public String getFontFeatureSettings() { return mFontFeatureSettings; } /** * Set font feature settings. * * The format is the same as the CSS font-feature-settings attribute: * * https://www.w3.org/TR/css-fonts-3/#font-feature-settings-prop * * @see #getFontFeatureSettings() * * @param settings the font feature settings string to use, may be null. */ public void setFontFeatureSettings(String settings) { if (settings != null && settings.equals("")) { settings = null; } if ((settings == null && mFontFeatureSettings == null) || (settings != null && settings.equals(mFontFeatureSettings))) { return; } mFontFeatureSettings = settings; nSetFontFeatureSettings(mNativePaint, settings); } /** * Returns the font variation settings. * * @return the paint's currently set font variation settings. Default is null. * * @see #setFontVariationSettings(String) */ public String getFontVariationSettings() { return mFontVariationSettings; } /** * Sets TrueType or OpenType font variation settings. The settings string is constructed from * multiple pairs of axis tag and style values. The axis tag must contain four ASCII characters * and must be wrapped with single quotes (U+0027) or double quotes (U+0022). Axis strings that * are longer or shorter than four characters, or contain characters outside of U+0020..U+007E * are invalid. If a specified axis name is not defined in the font, the settings will be * ignored. * * Examples, *

* * @param fontVariationSettings font variation settings. You can pass null or empty string as * no variation settings. * * @return true if the given settings is effective to at least one font file underlying this * typeface. This function also returns true for empty settings string. Otherwise * returns false * * @throws IllegalArgumentException If given string is not a valid font variation settings * format * * @see #getFontVariationSettings() * @see FontVariationAxis */ // Add following API description once the setFontVariationOverride becomes public. // This method generates new variation instance of the {@link Typeface} instance and set it to // this object. Therefore, subsequent {@link #setTypeface(Typeface)} call will clear the font // variation settings. Also, creating variation instance of the Typeface requires non trivial // amount of time and memories, therefore consider using // {@link #setFontVariationOverride(String, int)} for better performance. public boolean setFontVariationSettings(String fontVariationSettings) { final String settings = TextUtils.nullIfEmpty(fontVariationSettings); if (settings == mFontVariationSettings || (settings != null && settings.equals(mFontVariationSettings))) { return true; } if (settings == null || settings.length() == 0) { mFontVariationSettings = null; setTypefaceWithoutWarning(Typeface.createFromTypefaceWithVariation(mTypeface, Collections.emptyList())); return true; } // The null typeface is valid and it is equivalent to Typeface.DEFAULT. // To call isSupportedAxes method, use Typeface.DEFAULT instance. Typeface targetTypeface = mTypeface == null ? Typeface.DEFAULT : mTypeface; FontVariationAxis[] axes = FontVariationAxis.fromFontVariationSettings(settings); final ArrayList filteredAxes = new ArrayList(); for (final FontVariationAxis axis : axes) { if (targetTypeface.isSupportedAxes(axis.getOpenTypeTagValue())) { filteredAxes.add(axis); } } if (filteredAxes.isEmpty()) { return false; } mFontVariationSettings = settings; setTypefaceWithoutWarning( Typeface.createFromTypefaceWithVariation(targetTypeface, filteredAxes)); return true; } /** * Sets TrueType or OpenType font variation settings for overriding. * * The settings string is constructed from multiple pairs of axis tag and style values. The axis * tag must contain four ASCII characters and must be wrapped with single quotes (U+0027) or * double quotes (U+0022). Axis strings that are longer or shorter than four characters, or * contain characters outside of U+0020..U+007E are invalid. * * If invalid font variation settings is provided, this method does nothing and returning false * with printing error message to the logcat. * * Different from {@link #setFontVariationSettings(String)}, this overrides the font variation * settings which is already assigned to the font instance. For example, if the underlying font * is configured as {@code 'wght' 500, 'ital' 1}, and if the override is specified as * {@code 'wght' 700, `wdth` 150}, then the effective font variation setting is * {@code `wght' 700, 'ital' 1, 'wdth' 150}. The `wght` value is updated by override, 'ital' * value is preserved because no overrides, and `wdth` value is added by override. If the font * variation override is empty or null, nothing overrides and original font variation settings * assigned to the font instance is used as it is. * * @param fontVariationOverride font variation override. You can pass null or empty string for * clearing font variation override. * * @throws IllegalArgumentException If given string is not a valid font variation settings * format * @see #getFontVariationSettings() * @see #setFontVariationSettings(String) * @see #getFontVariationOverride() * @see FontVariationAxis */ @FlaggedApi(FLAG_TYPEFACE_REDESIGN_READONLY) public void setFontVariationOverride(@Nullable String fontVariationOverride) { if (Objects.equals(fontVariationOverride, mFontVariationOverride)) { return; } List axes = FontVariationAxis.fromFontVariationSettingsForList(fontVariationOverride); long builderPtr = nCreateFontVariationBuilder(axes.size()); for (int i = 0; i < axes.size(); ++i) { FontVariationAxis axis = axes.get(i); nAddFontVariationToBuilder( builderPtr, axis.getOpenTypeTagValue(), axis.getStyleValue()); } nSetFontVariationOverride(mNativePaint, builderPtr); mFontVariationOverride = fontVariationOverride; } /** * Gets the current font variation override value. * * @return a current font variation override value. */ @FlaggedApi(FLAG_TYPEFACE_REDESIGN_READONLY) public @Nullable String getFontVariationOverride() { return mFontVariationOverride; } /** * Get the current value of start hyphen edit. * * The default value is 0 which is equivalent to {@link #START_HYPHEN_EDIT_NO_EDIT}. * * @return the current starting hyphen edit value * @see #setStartHyphenEdit(int) */ public @StartHyphenEdit int getStartHyphenEdit() { return nGetStartHyphenEdit(mNativePaint); } /** * Get the current value of end hyphen edit. * * The default value is 0 which is equivalent to {@link #END_HYPHEN_EDIT_NO_EDIT}. * * @return the current starting hyphen edit value * @see #setStartHyphenEdit(int) */ public @EndHyphenEdit int getEndHyphenEdit() { return nGetEndHyphenEdit(mNativePaint); } /** * Set a start hyphen edit on the paint. * * By setting start hyphen edit, the measurement and drawing is performed with modifying * hyphenation at the start of line. For example, by passing * {@link #START_HYPHEN_EDIT_INSERT_HYPHEN} like as follows, HYPHEN(U+2010) * character is appended at the start of line. * * 
     * 
     *   Paint paint = new Paint();
     *   paint.setStartHyphenEdit(Paint.START_HYPHEN_EDIT_INSERT_HYPHEN);
     *   paint.measureText("abc", 0, 3);  // Returns the width of "-abc"
     *   Canvas.drawText("abc", 0, 3, 0f, 0f, paint);  // Draws "-abc"
     * 
     *
* * The default value is 0 which is equivalent to * {@link #START_HYPHEN_EDIT_NO_EDIT}. * * @param startHyphen a start hyphen edit value. * @see #getStartHyphenEdit() */ public void setStartHyphenEdit(@StartHyphenEdit int startHyphen) { nSetStartHyphenEdit(mNativePaint, startHyphen); } /** * Set a end hyphen edit on the paint. * * By setting end hyphen edit, the measurement and drawing is performed with modifying * hyphenation at the end of line. For example, by passing * {@link #END_HYPHEN_EDIT_INSERT_HYPHEN} like as follows, HYPHEN(U+2010) * character is appended at the end of line. * * 
     * 
     *   Paint paint = new Paint();
     *   paint.setEndHyphenEdit(Paint.END_HYPHEN_EDIT_INSERT_HYPHEN);
     *   paint.measureText("abc", 0, 3);  // Returns the width of "abc-"
     *   Canvas.drawText("abc", 0, 3, 0f, 0f, paint);  // Draws "abc-"
     * 
     *
* * The default value is 0 which is equivalent to {@link #END_HYPHEN_EDIT_NO_EDIT}. * * @param endHyphen a end hyphen edit value. * @see #getEndHyphenEdit() */ public void setEndHyphenEdit(@EndHyphenEdit int endHyphen) { nSetEndHyphenEdit(mNativePaint, endHyphen); } /** * Return the distance above (negative) the baseline (ascent) based on the * current typeface and text size. * *

Note that this is the ascent of the main typeface, and actual text rendered may need a * larger ascent because fallback fonts may get used in rendering the text. * * @return the distance above (negative) the baseline (ascent) based on the * current typeface and text size. */ public float ascent() { return nAscent(mNativePaint); } /** * Return the distance below (positive) the baseline (descent) based on the * current typeface and text size. * *

Note that this is the descent of the main typeface, and actual text rendered may need a * larger descent because fallback fonts may get used in rendering the text. * * @return the distance below (positive) the baseline (descent) based on * the current typeface and text size. */ public float descent() { return nDescent(mNativePaint); } /** * Class that describes the various metrics for a font at a given text size. * Remember, Y values increase going down, so those values will be positive, * and values that measure distances going up will be negative. This class * is returned by getFontMetrics(). */ public static class FontMetrics { /** * The maximum distance above the baseline for the tallest glyph in * the font at a given text size. */ public float top; /** * The recommended distance above the baseline for singled spaced text. */ public float ascent; /** * The recommended distance below the baseline for singled spaced text. */ public float descent; /** * The maximum distance below the baseline for the lowest glyph in * the font at a given text size. */ public float bottom; /** * The recommended additional space to add between lines of text. */ public float leading; @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || !(o instanceof FontMetrics)) return false; FontMetrics that = (FontMetrics) o; return that.top == top && that.ascent == ascent && that.descent == descent && that.bottom == bottom && that.leading == leading; } @Override public int hashCode() { return Objects.hash(top, ascent, descent, bottom, leading); } @Override public String toString() { return "FontMetrics{" + "top=" + top + ", ascent=" + ascent + ", descent=" + descent + ", bottom=" + bottom + ", leading=" + leading + '}'; } } /** * Return the font's recommended interline spacing, given the Paint's * settings for typeface, textSize, etc. If metrics is not null, return the * fontmetric values in it. * *

Note that these are the values for the main typeface, and actual text rendered may need a * larger set of values because fallback fonts may get used in rendering the text. * * @param metrics If this object is not null, its fields are filled with * the appropriate values given the paint's text attributes. * @return the font's recommended interline spacing. */ public float getFontMetrics(FontMetrics metrics) { return nGetFontMetrics(mNativePaint, metrics, false); } /** * Allocates a new FontMetrics object, and then calls getFontMetrics(fm) * with it, returning the object. */ public FontMetrics getFontMetrics() { FontMetrics fm = new FontMetrics(); getFontMetrics(fm); return fm; } /** * Get the font metrics used for the locale * * Obtain the metrics of the font that is used for the specified locale by * {@link #setTextLocales(LocaleList)}. If multiple locales are specified, the minimum ascent * and maximum descent will be set. * * This API is useful for determining the default line height of the empty text field, e.g. * {@link android.widget.EditText}. * * Note, if the {@link android.graphics.Typeface} is created from the custom font files, its * metrics are reserved, i.e. the ascent will be the custom font's ascent or smaller, the * descent will be the custom font's descent or larger. * * Note, if the {@link android.graphics.Typeface} is a system fallback, e.g. * {@link android.graphics.Typeface#SERIF}, the default font's metrics are reserved, i.e. the * ascent will be the serif font's ascent or smaller, the descent will be the serif font's * descent or larger. * * @param metrics an output parameter. All members will be set by calling this function. */ @FlaggedApi(FLAG_FIX_LINE_HEIGHT_FOR_LOCALE) public void getFontMetricsForLocale(@NonNull FontMetrics metrics) { nGetFontMetrics(mNativePaint, metrics, true); } /** * Returns the font metrics value for the given text. * * If the text is rendered with multiple font files, this function returns the large ascent and * descent that are enough for drawing all font files. * * The context range is used for shaping context. Some script, e.g. Arabic or Devanagari, * changes letter shape based on its location or surrounding characters. * * @param text a text to be measured. * @param start a starting offset in the text. * @param count a length of the text to be measured. * @param contextStart a context starting offset in the text. * @param contextCount a length of the context to be used. * @param isRtl true if measuring on RTL context, otherwise false. * @param outMetrics the output font metrics. */ public void getFontMetricsInt( @NonNull CharSequence text, @IntRange(from = 0) int start, @IntRange(from = 0) int count, @IntRange(from = 0) int contextStart, @IntRange(from = 0) int contextCount, boolean isRtl, @NonNull FontMetricsInt outMetrics) { if (text == null) { throw new IllegalArgumentException("text must not be null"); } if (start < 0 || start >= text.length()) { throw new IllegalArgumentException("start argument is out of bounds."); } if (count < 0 || start + count > text.length()) { throw new IllegalArgumentException("count argument is out of bounds."); } if (contextStart < 0 || contextStart >= text.length()) { throw new IllegalArgumentException("ctxStart argument is out of bounds."); } if (contextCount < 0 || contextStart + contextCount > text.length()) { throw new IllegalArgumentException("ctxCount argument is out of bounds."); } if (outMetrics == null) { throw new IllegalArgumentException("outMetrics must not be null."); } if (count == 0) { getFontMetricsInt(outMetrics); return; } if (text instanceof String) { nGetFontMetricsIntForText(mNativePaint, (String) text, start, count, contextStart, contextCount, isRtl, outMetrics); } else { char[] buf = TemporaryBuffer.obtain(contextCount); try { TextUtils.getChars(text, contextStart, contextStart + contextCount, buf, 0); nGetFontMetricsIntForText(mNativePaint, buf, start - contextStart, count, 0, contextCount, isRtl, outMetrics); } finally { TemporaryBuffer.recycle(buf); } } } /** * Returns the font metrics value for the given text. * * If the text is rendered with multiple font files, this function returns the large ascent and * descent that are enough for drawing all font files. * * The context range is used for shaping context. Some script, e.g. Arabic or Devanagari, * changes letter shape based on its location or surrounding characters. * * @param text a text to be measured. * @param start a starting offset in the text. * @param count a length of the text to be measured. * @param contextStart a context starting offset in the text. * @param contextCount a length of the context to be used. * @param isRtl true if measuring on RTL context, otherwise false. * @param outMetrics the output font metrics. */ public void getFontMetricsInt(@NonNull char[] text, @IntRange(from = 0) int start, @IntRange(from = 0) int count, @IntRange(from = 0) int contextStart, @IntRange(from = 0) int contextCount, boolean isRtl, @NonNull FontMetricsInt outMetrics) { if (text == null) { throw new IllegalArgumentException("text must not be null"); } if (start < 0 || start >= text.length) { throw new IllegalArgumentException("start argument is out of bounds."); } if (count < 0 || start + count > text.length) { throw new IllegalArgumentException("count argument is out of bounds."); } if (contextStart < 0 || contextStart >= text.length) { throw new IllegalArgumentException("ctxStart argument is out of bounds."); } if (contextCount < 0 || contextStart + contextCount > text.length) { throw new IllegalArgumentException("ctxCount argument is out of bounds."); } if (outMetrics == null) { throw new IllegalArgumentException("outMetrics must not be null."); } if (count == 0) { getFontMetricsInt(outMetrics); return; } nGetFontMetricsIntForText(mNativePaint, text, start, count, contextStart, contextCount, isRtl, outMetrics); } /** * Convenience method for callers that want to have FontMetrics values as * integers. */ public static class FontMetricsInt { /** * The maximum distance above the baseline for the tallest glyph in * the font at a given text size. */ public int top; /** * The recommended distance above the baseline for singled spaced text. */ public int ascent; /** * The recommended distance below the baseline for singled spaced text. */ public int descent; /** * The maximum distance below the baseline for the lowest glyph in * the font at a given text size. */ public int bottom; /** * The recommended additional space to add between lines of text. */ public int leading; /** * Set values from {@link FontMetricsInt}. * @param fontMetricsInt a font metrics. */ @FlaggedApi(FLAG_FIX_LINE_HEIGHT_FOR_LOCALE) public void set(@NonNull FontMetricsInt fontMetricsInt) { top = fontMetricsInt.top; ascent = fontMetricsInt.ascent; descent = fontMetricsInt.descent; bottom = fontMetricsInt.bottom; leading = fontMetricsInt.leading; } /** * Set values from {@link FontMetrics} with rounding accordingly. * @param fontMetrics a font metrics. */ @FlaggedApi(FLAG_FIX_LINE_HEIGHT_FOR_LOCALE) public void set(@NonNull FontMetrics fontMetrics) { // See GraphicsJNI::set_metrics_int method for consistency. top = (int) Math.floor(fontMetrics.top); ascent = Math.round(fontMetrics.ascent); descent = Math.round(fontMetrics.descent); bottom = (int) Math.ceil(fontMetrics.bottom); leading = Math.round(fontMetrics.leading); } @Override public String toString() { return "FontMetricsInt: top=" + top + " ascent=" + ascent + " descent=" + descent + " bottom=" + bottom + " leading=" + leading; } @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof FontMetricsInt)) return false; FontMetricsInt that = (FontMetricsInt) o; return top == that.top && ascent == that.ascent && descent == that.descent && bottom == that.bottom && leading == that.leading; } @Override public int hashCode() { return Objects.hash(top, ascent, descent, bottom, leading); } } /** * Return the font's interline spacing, given the Paint's settings for * typeface, textSize, etc. If metrics is not null, return the fontmetric * values in it. Note: all values have been converted to integers from * floats, in such a way has to make the answers useful for both spacing * and clipping. If you want more control over the rounding, call * getFontMetrics(). * *

Note that these are the values for the main typeface, and actual text rendered may need a * larger set of values because fallback fonts may get used in rendering the text. * * @return the font's interline spacing. */ public int getFontMetricsInt(FontMetricsInt fmi) { return nGetFontMetricsInt(mNativePaint, fmi, false); } public FontMetricsInt getFontMetricsInt() { FontMetricsInt fm = new FontMetricsInt(); getFontMetricsInt(fm); return fm; } /** * Get the font metrics used for the locale * * Obtain the metrics of the font that is used for the specified locale by * {@link #setTextLocales(LocaleList)}. If multiple locales are specified, the minimum ascent * and maximum descent will be set. * * This API is useful for determining the default line height of the empty text field, e.g. * {@link android.widget.EditText}. * * Note, if the {@link android.graphics.Typeface} is created from the custom font files, its * metrics are reserved, i.e. the ascent will be the custom font's ascent or smaller, the * descent will be the custom font's descent or larger. * * Note, if the {@link android.graphics.Typeface} is a system fallback, e.g. * {@link android.graphics.Typeface#SERIF}, the default font's metrics are reserved, i.e. the * ascent will be the serif font's ascent or smaller, the descent will be the serif font's * descent or larger. * * @param metrics an output parameter. All members will be set by calling this function. */ @FlaggedApi(FLAG_FIX_LINE_HEIGHT_FOR_LOCALE) public void getFontMetricsIntForLocale(@NonNull FontMetricsInt metrics) { nGetFontMetricsInt(mNativePaint, metrics, true); } /** @hide */ public static final class RunInfo { private int mClusterCount = 0; public int getClusterCount() { return mClusterCount; } public void setClusterCount(int clusterCount) { mClusterCount = clusterCount; } } /** * Return the recommend line spacing based on the current typeface and * text size. * *

Note that this is the value for the main typeface, and actual text rendered may need a * larger value because fallback fonts may get used in rendering the text. * * @return recommend line spacing based on the current typeface and * text size. */ public float getFontSpacing() { return getFontMetrics(null); } /** * Return the width of the text. * * @param text The text to measure. Cannot be null. * @param index The index of the first character to start measuring * @param count THe number of characters to measure, beginning with start * @return The width of the text */ public float measureText(char[] text, int index, int count) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if ((index | count) < 0 || index + count > text.length) { throw new ArrayIndexOutOfBoundsException(); } if (text.length == 0 || count == 0) { return 0f; } int oldFlag = getFlags(); setFlags(getFlags() | (TEXT_RUN_FLAG_LEFT_EDGE | TEXT_RUN_FLAG_RIGHT_EDGE)); try { if (!mHasCompatScaling) { return (float) Math.ceil(nGetTextAdvances(mNativePaint, text, index, count, index, count, mBidiFlags, null, 0)); } final float oldSize = getTextSize(); setTextSize(oldSize * mCompatScaling); final float w = nGetTextAdvances(mNativePaint, text, index, count, index, count, mBidiFlags, null, 0); setTextSize(oldSize); return (float) Math.ceil(w * mInvCompatScaling); } finally { setFlags(oldFlag); } } /** * Return the width of the text. * * @param text The text to measure. Cannot be null. * @param start The index of the first character to start measuring * @param end 1 beyond the index of the last character to measure * @return The width of the text */ public float measureText(String text, int start, int end) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if ((start | end | (end - start) | (text.length() - end)) < 0) { throw new IndexOutOfBoundsException(); } if (text.length() == 0 || start == end) { return 0f; } int oldFlag = getFlags(); setFlags(getFlags() | (TEXT_RUN_FLAG_LEFT_EDGE | TEXT_RUN_FLAG_RIGHT_EDGE)); try { if (!mHasCompatScaling) { return (float) Math.ceil(nGetTextAdvances(mNativePaint, text, start, end, start, end, mBidiFlags, null, 0)); } final float oldSize = getTextSize(); setTextSize(oldSize * mCompatScaling); final float w = nGetTextAdvances(mNativePaint, text, start, end, start, end, mBidiFlags, null, 0); setTextSize(oldSize); return (float) Math.ceil(w * mInvCompatScaling); } finally { setFlags(oldFlag); } } /** * Return the width of the text. * * @param text The text to measure. Cannot be null. * @return The width of the text */ public float measureText(String text) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } return measureText(text, 0, text.length()); } /** * Return the width of the text. * * @param text The text to measure * @param start The index of the first character to start measuring * @param end 1 beyond the index of the last character to measure * @return The width of the text */ public float measureText(CharSequence text, int start, int end) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if ((start | end | (end - start) | (text.length() - end)) < 0) { throw new IndexOutOfBoundsException(); } if (text.length() == 0 || start == end) { return 0f; } if (text instanceof String) { return measureText((String)text, start, end); } if (text instanceof SpannedString || text instanceof SpannableString) { return measureText(text.toString(), start, end); } if (text instanceof GraphicsOperations) { return ((GraphicsOperations)text).measureText(start, end, this); } char[] buf = TemporaryBuffer.obtain(end - start); TextUtils.getChars(text, start, end, buf, 0); float result = measureText(buf, 0, end - start); TemporaryBuffer.recycle(buf); return result; } /** * Measure the text, stopping early if the measured width exceeds maxWidth. * Return the number of chars that were measured, and if measuredWidth is * not null, return in it the actual width measured. * * @param text The text to measure. Cannot be null. * @param index The offset into text to begin measuring at * @param count The number of maximum number of entries to measure. If count * is negative, then the characters are measured in reverse order. * @param maxWidth The maximum width to accumulate. * @param measuredWidth Optional. If not null, returns the actual width * measured. * @return The number of chars that were measured. Will always be <= * abs(count). */ public int breakText(char[] text, int index, int count, float maxWidth, float[] measuredWidth) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if (index < 0 || text.length - index < Math.abs(count)) { throw new ArrayIndexOutOfBoundsException(); } if (text.length == 0 || count == 0) { return 0; } if (!mHasCompatScaling) { return nBreakText(mNativePaint, text, index, count, maxWidth, mBidiFlags, measuredWidth); } final float oldSize = getTextSize(); setTextSize(oldSize * mCompatScaling); final int res = nBreakText(mNativePaint, text, index, count, maxWidth * mCompatScaling, mBidiFlags, measuredWidth); setTextSize(oldSize); if (measuredWidth != null) measuredWidth[0] *= mInvCompatScaling; return res; } /** * Measure the text, stopping early if the measured width exceeds maxWidth. * Return the number of chars that were measured, and if measuredWidth is * not null, return in it the actual width measured. * * @param text The text to measure. Cannot be null. * @param start The offset into text to begin measuring at * @param end The end of the text slice to measure. * @param measureForwards If true, measure forwards, starting at start. * Otherwise, measure backwards, starting with end. * @param maxWidth The maximum width to accumulate. * @param measuredWidth Optional. If not null, returns the actual width * measured. * @return The number of chars that were measured. Will always be <= * abs(end - start). */ public int breakText(CharSequence text, int start, int end, boolean measureForwards, float maxWidth, float[] measuredWidth) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if ((start | end | (end - start) | (text.length() - end)) < 0) { throw new IndexOutOfBoundsException(); } if (text.length() == 0 || start == end) { return 0; } if (start == 0 && text instanceof String && end == text.length()) { return breakText((String) text, measureForwards, maxWidth, measuredWidth); } char[] buf = TemporaryBuffer.obtain(end - start); int result; TextUtils.getChars(text, start, end, buf, 0); if (measureForwards) { result = breakText(buf, 0, end - start, maxWidth, measuredWidth); } else { result = breakText(buf, 0, -(end - start), maxWidth, measuredWidth); } TemporaryBuffer.recycle(buf); return result; } /** * Measure the text, stopping early if the measured width exceeds maxWidth. * Return the number of chars that were measured, and if measuredWidth is * not null, return in it the actual width measured. * * @param text The text to measure. Cannot be null. * @param measureForwards If true, measure forwards, starting with the * first character in the string. Otherwise, * measure backwards, starting with the * last character in the string. * @param maxWidth The maximum width to accumulate. * @param measuredWidth Optional. If not null, returns the actual width * measured. * @return The number of chars that were measured. Will always be <= * abs(count). */ public int breakText(String text, boolean measureForwards, float maxWidth, float[] measuredWidth) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if (text.length() == 0) { return 0; } if (!mHasCompatScaling) { return nBreakText(mNativePaint, text, measureForwards, maxWidth, mBidiFlags, measuredWidth); } final float oldSize = getTextSize(); setTextSize(oldSize*mCompatScaling); final int res = nBreakText(mNativePaint, text, measureForwards, maxWidth*mCompatScaling, mBidiFlags, measuredWidth); setTextSize(oldSize); if (measuredWidth != null) measuredWidth[0] *= mInvCompatScaling; return res; } /** * Return the advance widths for the characters in the string. * * @param text The text to measure. Cannot be null. * @param index The index of the first char to to measure * @param count The number of chars starting with index to measure * @param widths array to receive the advance widths of the characters. * Must be at least a large as count. * @return the actual number of widths returned. */ public int getTextWidths(char[] text, int index, int count, float[] widths) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if ((index | count) < 0 || index + count > text.length || count > widths.length) { throw new ArrayIndexOutOfBoundsException(); } if (text.length == 0 || count == 0) { return 0; } int oldFlag = getFlags(); setFlags(getFlags() | (TEXT_RUN_FLAG_LEFT_EDGE | TEXT_RUN_FLAG_RIGHT_EDGE)); try { if (!mHasCompatScaling) { nGetTextAdvances(mNativePaint, text, index, count, index, count, mBidiFlags, widths, 0); return count; } final float oldSize = getTextSize(); setTextSize(oldSize * mCompatScaling); nGetTextAdvances(mNativePaint, text, index, count, index, count, mBidiFlags, widths, 0); setTextSize(oldSize); for (int i = 0; i < count; i++) { widths[i] *= mInvCompatScaling; } return count; } finally { setFlags(oldFlag); } } /** * Return the advance widths for the characters in the string. * * @param text The text to measure. Cannot be null. * @param start The index of the first char to to measure * @param end The end of the text slice to measure * @param widths array to receive the advance widths of the characters. * Must be at least a large as (end - start). * @return the actual number of widths returned. */ public int getTextWidths(CharSequence text, int start, int end, float[] widths) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if ((start | end | (end - start) | (text.length() - end)) < 0) { throw new IndexOutOfBoundsException(); } if (end - start > widths.length) { throw new ArrayIndexOutOfBoundsException(); } if (text.length() == 0 || start == end) { return 0; } if (text instanceof String) { return getTextWidths((String) text, start, end, widths); } if (text instanceof SpannedString || text instanceof SpannableString) { return getTextWidths(text.toString(), start, end, widths); } if (text instanceof GraphicsOperations) { return ((GraphicsOperations) text).getTextWidths(start, end, widths, this); } char[] buf = TemporaryBuffer.obtain(end - start); TextUtils.getChars(text, start, end, buf, 0); int result = getTextWidths(buf, 0, end - start, widths); TemporaryBuffer.recycle(buf); return result; } /** * Return the advance widths for the characters in the string. * * @param text The text to measure. Cannot be null. * @param start The index of the first char to to measure * @param end The end of the text slice to measure * @param widths array to receive the advance widths of the characters. * Must be at least a large as the text. * @return the number of code units in the specified text. */ public int getTextWidths(String text, int start, int end, float[] widths) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if ((start | end | (end - start) | (text.length() - end)) < 0) { throw new IndexOutOfBoundsException(); } if (end - start > widths.length) { throw new ArrayIndexOutOfBoundsException(); } if (text.length() == 0 || start == end) { return 0; } int oldFlag = getFlags(); setFlags(getFlags() | (TEXT_RUN_FLAG_LEFT_EDGE | TEXT_RUN_FLAG_RIGHT_EDGE)); try { if (!mHasCompatScaling) { nGetTextAdvances(mNativePaint, text, start, end, start, end, mBidiFlags, widths, 0); return end - start; } final float oldSize = getTextSize(); setTextSize(oldSize * mCompatScaling); nGetTextAdvances(mNativePaint, text, start, end, start, end, mBidiFlags, widths, 0); setTextSize(oldSize); for (int i = 0; i < end - start; i++) { widths[i] *= mInvCompatScaling; } return end - start; } finally { setFlags(oldFlag); } } /** * Return the advance widths for the characters in the string. * * @param text The text to measure * @param widths array to receive the advance widths of the characters. * Must be at least a large as the text. * @return the number of code units in the specified text. */ public int getTextWidths(String text, float[] widths) { return getTextWidths(text, 0, text.length(), widths); } /** * Retrieve the character advances of the text. * * Returns the total advance width for the characters in the run from {@code index} for * {@code count} of chars, and if {@code advances} is not null, the advance assigned to each of * these characters (java chars). * *

* The trailing surrogate in a valid surrogate pair is assigned an advance of 0. Thus the * number of returned advances is always equal to count, not to the number of unicode codepoints * represented by the run. *

* *

* In the case of conjuncts or combining marks, the total advance is assigned to the first * logical character, and the following characters are assigned an advance of 0. *

* *

* This generates the sum of the advances of glyphs for characters in a reordered cluster as the * width of the first logical character in the cluster, and 0 for the widths of all other * characters in the cluster. In effect, such clusters are treated like conjuncts. *

* *

* The shaping bounds limit the amount of context available outside start and end that can be * used for shaping analysis. These bounds typically reflect changes in bidi level or font * metrics across which shaping does not occur. *

* * @param chars the text to measure. * @param index the index of the first character to measure * @param count the number of characters to measure * @param contextIndex the index of the first character to use for shaping context. * Context must cover the measureing target. * @param contextCount the number of character to use for shaping context. * Context must cover the measureing target. * @param isRtl whether the run is in RTL direction * @param advances array to receive the advances, must have room for all advances. * This can be null if only total advance is needed * @param advancesIndex the position in advances at which to put the advance corresponding to * the character at start * @return the total advance in pixels */ public float getTextRunAdvances(@NonNull char[] chars, @IntRange(from = 0) int index, @IntRange(from = 0) int count, @IntRange(from = 0) int contextIndex, @IntRange(from = 0) int contextCount, boolean isRtl, @Nullable float[] advances, @IntRange(from = 0) int advancesIndex) { if (chars == null) { throw new IllegalArgumentException("text cannot be null"); } if ((index | count | contextIndex | contextCount | advancesIndex | (index - contextIndex) | (contextCount - count) | ((contextIndex + contextCount) - (index + count)) | (chars.length - (contextIndex + contextCount)) | (advances == null ? 0 : (advances.length - (advancesIndex + count)))) < 0) { throw new IndexOutOfBoundsException(); } if (chars.length == 0 || count == 0){ return 0f; } if (!mHasCompatScaling) { return nGetTextAdvances(mNativePaint, chars, index, count, contextIndex, contextCount, isRtl ? BIDI_FORCE_RTL : BIDI_FORCE_LTR, advances, advancesIndex); } final float oldSize = getTextSize(); setTextSize(oldSize * mCompatScaling); final float res = nGetTextAdvances(mNativePaint, chars, index, count, contextIndex, contextCount, isRtl ? BIDI_FORCE_RTL : BIDI_FORCE_LTR, advances, advancesIndex); setTextSize(oldSize); if (advances != null) { for (int i = advancesIndex, e = i + count; i < e; i++) { advances[i] *= mInvCompatScaling; } } return res * mInvCompatScaling; // assume errors are not significant } /** * Returns the next cursor position in the run. * * This avoids placing the cursor between surrogates, between characters that form conjuncts, * between base characters and combining marks, or within a reordering cluster. * *

* ContextStart and offset are relative to the start of text. * The context is the shaping context for cursor movement, generally the bounds of the metric * span enclosing the cursor in the direction of movement. * *

* If cursorOpt is {@link #CURSOR_AT} and the offset is not a valid cursor position, this * returns -1. Otherwise this will never return a value before contextStart or after * contextStart + contextLength. * * @param text the text * @param contextStart the start of the context * @param contextLength the length of the context * @param isRtl true if the paragraph context is RTL, otherwise false * @param offset the cursor position to move from * @param cursorOpt how to move the cursor * @return the offset of the next position, or -1 */ public int getTextRunCursor(@NonNull char[] text, @IntRange(from = 0) int contextStart, @IntRange(from = 0) int contextLength, boolean isRtl, @IntRange(from = 0) int offset, @CursorOption int cursorOpt) { int contextEnd = contextStart + contextLength; if (((contextStart | contextEnd | offset | (contextEnd - contextStart) | (offset - contextStart) | (contextEnd - offset) | (text.length - contextEnd) | cursorOpt) < 0) || cursorOpt > CURSOR_OPT_MAX_VALUE) { throw new IndexOutOfBoundsException(); } return nGetTextRunCursor(mNativePaint, text, contextStart, contextLength, isRtl ? DIRECTION_RTL : DIRECTION_LTR, offset, cursorOpt); } /** * Returns the next cursor position in the run. * * This avoids placing the cursor between surrogates, between characters that form conjuncts, * between base characters and combining marks, or within a reordering cluster. * *

* ContextStart, contextEnd, and offset are relative to the start of * text. The context is the shaping context for cursor movement, generally * the bounds of the metric span enclosing the cursor in the direction of * movement. * *

* If cursorOpt is {@link #CURSOR_AT} and the offset is not a valid cursor position, this * returns -1. Otherwise this will never return a value before contextStart or after * contextEnd. * * @param text the text * @param contextStart the start of the context * @param contextEnd the end of the context * @param isRtl true if the paragraph context is RTL, otherwise false * @param offset the cursor position to move from * @param cursorOpt how to move the cursor * @return the offset of the next position, or -1 */ public int getTextRunCursor(@NonNull CharSequence text, @IntRange(from = 0) int contextStart, @IntRange(from = 0) int contextEnd, boolean isRtl, @IntRange(from = 0) int offset, @CursorOption int cursorOpt) { if (text instanceof String || text instanceof SpannedString || text instanceof SpannableString) { return getTextRunCursor(text.toString(), contextStart, contextEnd, isRtl, offset, cursorOpt); } if (text instanceof GraphicsOperations) { return ((GraphicsOperations) text).getTextRunCursor( contextStart, contextEnd, isRtl, offset, cursorOpt, this); } int contextLen = contextEnd - contextStart; char[] buf = TemporaryBuffer.obtain(contextLen); TextUtils.getChars(text, contextStart, contextEnd, buf, 0); int relPos = getTextRunCursor(buf, 0, contextLen, isRtl, offset - contextStart, cursorOpt); TemporaryBuffer.recycle(buf); return (relPos == -1) ? -1 : relPos + contextStart; } /** * Returns the next cursor position in the run. * * This avoids placing the cursor between surrogates, between characters that form conjuncts, * between base characters and combining marks, or within a reordering cluster. * *

* ContextStart, contextEnd, and offset are relative to the start of text. The context is the * shaping context for cursor movement, generally the bounds of the metric span enclosing the * cursor in the direction of movement. *

* *

* If cursorOpt is {@link #CURSOR_AT} and the offset is not a valid cursor position, this * returns -1. Otherwise this will never return a value before contextStart or after * contextEnd. *

* * @param text the text * @param contextStart the start of the context * @param contextEnd the end of the context * @param isRtl true if the paragraph context is RTL, otherwise false. * @param offset the cursor position to move from * @param cursorOpt how to move the cursor * @return the offset of the next position, or -1 * @hide */ public int getTextRunCursor(@NonNull String text, @IntRange(from = 0) int contextStart, @IntRange(from = 0) int contextEnd, boolean isRtl, @IntRange(from = 0) int offset, @CursorOption int cursorOpt) { if (((contextStart | contextEnd | offset | (contextEnd - contextStart) | (offset - contextStart) | (contextEnd - offset) | (text.length() - contextEnd) | cursorOpt) < 0) || cursorOpt > CURSOR_OPT_MAX_VALUE) { throw new IndexOutOfBoundsException(); } return nGetTextRunCursor(mNativePaint, text, contextStart, contextEnd, isRtl ? DIRECTION_RTL : DIRECTION_LTR, offset, cursorOpt); } /** * Return the path (outline) for the specified text. * Note: just like Canvas.drawText, this will respect the Align setting in * the paint. * * @param text the text to retrieve the path from * @param index the index of the first character in text * @param count the number of characters starting with index * @param x the x coordinate of the text's origin * @param y the y coordinate of the text's origin * @param path the path to receive the data describing the text. Must be allocated by the caller */ public void getTextPath(char[] text, int index, int count, float x, float y, Path path) { if ((index | count) < 0 || index + count > text.length) { throw new ArrayIndexOutOfBoundsException(); } nGetTextPath(mNativePaint, mBidiFlags, text, index, count, x, y, path.mutateNI()); } /** * Return the path (outline) for the specified text. * Note: just like Canvas.drawText, this will respect the Align setting * in the paint. * * @param text the text to retrieve the path from * @param start the first character in the text * @param end 1 past the last character in the text * @param x the x coordinate of the text's origin * @param y the y coordinate of the text's origin * @param path the path to receive the data describing the text. Must be allocated by the caller */ public void getTextPath(String text, int start, int end, float x, float y, Path path) { if ((start | end | (end - start) | (text.length() - end)) < 0) { throw new IndexOutOfBoundsException(); } nGetTextPath(mNativePaint, mBidiFlags, text, start, end, x, y, path.mutateNI()); } /** * Retrieve the text boundary box and store to bounds. * * Return in bounds (allocated by the caller) the smallest rectangle that * encloses all of the characters, with an implied origin at (0,0). * * @param text string to measure and return its bounds * @param start index of the first char in the string to measure * @param end 1 past the last char in the string to measure * @param bounds returns the unioned bounds of all the text. Must be allocated by the caller */ public void getTextBounds(String text, int start, int end, Rect bounds) { if ((start | end | (end - start) | (text.length() - end)) < 0) { throw new IndexOutOfBoundsException(); } if (bounds == null) { throw new NullPointerException("need bounds Rect"); } nGetStringBounds(mNativePaint, text, start, end, mBidiFlags, bounds); } /** * Retrieve the text boundary box and store to bounds. * * Return in bounds (allocated by the caller) the smallest rectangle that * encloses all of the characters, with an implied origin at (0,0). * * Note that styles are ignored even if you pass {@link android.text.Spanned} instance. * Use {@link android.text.StaticLayout} for measuring bounds of {@link android.text.Spanned}. * * @param text text to measure and return its bounds * @param start index of the first char in the text to measure * @param end 1 past the last char in the text to measure * @param bounds returns the unioned bounds of all the text. Must be allocated by the caller */ public void getTextBounds(@NonNull CharSequence text, int start, int end, @NonNull Rect bounds) { if ((start | end | (end - start) | (text.length() - end)) < 0) { throw new IndexOutOfBoundsException(); } if (bounds == null) { throw new NullPointerException("need bounds Rect"); } char[] buf = TemporaryBuffer.obtain(end - start); TextUtils.getChars(text, start, end, buf, 0); getTextBounds(buf, 0, end - start, bounds); TemporaryBuffer.recycle(buf); } /** * Return in bounds (allocated by the caller) the smallest rectangle that * encloses all of the characters, with an implied origin at (0,0). * * @param text array of chars to measure and return their unioned bounds * @param index index of the first char in the array to measure * @param count the number of chars, beginning at index, to measure * @param bounds returns the unioned bounds of all the text. Must be allocated by the caller */ public void getTextBounds(char[] text, int index, int count, Rect bounds) { if ((index | count) < 0 || index + count > text.length) { throw new ArrayIndexOutOfBoundsException(); } if (bounds == null) { throw new NullPointerException("need bounds Rect"); } nGetCharArrayBounds(mNativePaint, text, index, count, mBidiFlags, bounds); } /** * Determine whether the typeface set on the paint has a glyph supporting the string. The * simplest case is when the string contains a single character, in which this method * determines whether the font has the character. In the case of multiple characters, the * method returns true if there is a single glyph representing the ligature. For example, if * the input is a pair of regional indicator symbols, determine whether there is an emoji flag * for the pair. * *

Finally, if the string contains a variation selector, the method only returns true if * the fonts contains a glyph specific to that variation. * *

Checking is done on the entire fallback chain, not just the immediate font referenced. * * @param string the string to test whether there is glyph support * @return true if the typeface has a glyph for the string */ public boolean hasGlyph(String string) { return nHasGlyph(mNativePaint, mBidiFlags, string); } /** * Measure cursor position within a run of text. * *

The run of text includes the characters from {@code start} to {@code end} in the text. In * addition, the range {@code contextStart} to {@code 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 {@code contextStart..contextEnd} is ignored. The text between * {@code start} and {@code end} will be laid out to be measured. * *

The returned width measurement is the advance from {@code start} to {@code offset}. It is * generally a positive value, no matter the direction of the run. If {@code offset == end}, * the return value is simply the width of the whole run from {@code start} to {@code end}. * *

Ligatures are formed for characters in the range {@code start..end} (but not for * {@code start..contextStart} or {@code end..contextEnd}). If {@code offset} points to a * character in the middle of such a formed ligature, but at a grapheme cluster boundary, the * return value will also reflect an advance in the middle of the ligature. See * {@link #getOffsetForAdvance} for more discussion of grapheme cluster boundaries. * *

The direction of the run is explicitly specified by {@code isRtl}. Thus, this method is * suitable only for runs of a single direction. * *

All indices are relative to the start of {@code text}. Further, {@code 0 <= contextStart * <= start <= offset <= end <= contextEnd <= text.length} must hold on entry. * * @param text the text to measure. Cannot be null. * @param start the index of the start of the range to measure * @param end the index + 1 of the end of the range to measure * @param contextStart the index of the start of the shaping context * @param contextEnd the index + 1 of the end of the shaping context * @param isRtl whether the run is in RTL direction * @param offset index of caret position * @return width measurement between start and offset */ public float getRunAdvance(char[] text, int start, int end, int contextStart, int contextEnd, boolean isRtl, int offset) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if ((contextStart | start | offset | end | contextEnd | start - contextStart | offset - start | end - offset | contextEnd - end | text.length - contextEnd) < 0) { throw new IndexOutOfBoundsException(); } if (end == start) { return 0.0f; } // TODO: take mCompatScaling into account (or eliminate compat scaling)? return nGetRunAdvance(mNativePaint, text, start, end, contextStart, contextEnd, isRtl, offset); } /** * @see #getRunAdvance(char[], int, int, int, int, boolean, int) * * @param text the text to measure. Cannot be null. * @param start the index of the start of the range to measure * @param end the index + 1 of the end of the range to measure * @param contextStart the index of the start of the shaping context * @param contextEnd the index + 1 of the end of the shaping context * @param isRtl whether the run is in RTL direction * @param offset index of caret position * @return width measurement between start and offset */ public float getRunAdvance(CharSequence text, int start, int end, int contextStart, int contextEnd, boolean isRtl, int offset) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if ((contextStart | start | offset | end | contextEnd | start - contextStart | offset - start | end - offset | contextEnd - end | text.length() - contextEnd) < 0) { throw new IndexOutOfBoundsException(); } if (end == start) { return 0.0f; } // TODO performance: specialized alternatives to avoid buffer copy, if win is significant char[] buf = TemporaryBuffer.obtain(contextEnd - contextStart); TextUtils.getChars(text, contextStart, contextEnd, buf, 0); float result = getRunAdvance(buf, start - contextStart, end - contextStart, 0, contextEnd - contextStart, isRtl, offset - contextStart); TemporaryBuffer.recycle(buf); return result; } /** * Measure the advance of each character within a run of text and also return the cursor * position within the run. * * @see #getRunAdvance(char[], int, int, int, int, boolean, int) for more details. * * @param text the text to measure. Cannot be null. * @param start the start index of the range to measure, inclusive * @param end the end index of the range to measure, exclusive * @param contextStart the start index of the shaping context, inclusive * @param contextEnd the end index of the shaping context, exclusive * @param isRtl whether the run is in RTL direction * @param offset index of caret position * @param advances the array that receives the computed character advances * @param advancesIndex the start index from which the advances array is filled * @return width measurement between start and offset * @throws IndexOutOfBoundsException if a) contextStart or contextEnd is out of array's range * or contextStart is larger than contextEnd, * b) start or end is not within the range [contextStart, contextEnd), or start is larger than * end, * c) offset is not within the range [start, end), * d) advances.length - advanceIndex is smaller than the length of the run, which equals to * end - start. * */ public float getRunCharacterAdvance(@NonNull char[] text, int start, int end, int contextStart, int contextEnd, boolean isRtl, int offset, @Nullable float[] advances, int advancesIndex) { return getRunCharacterAdvance(text, start, end, contextStart, contextEnd, isRtl, offset, advances, advancesIndex, null, null); } /** * Measure the advance of each character within a run of text and also return the cursor * position within the run. * * @see #getRunAdvance(char[], int, int, int, int, boolean, int) for more details. * * @param text the text to measure. Cannot be null. * @param start the start index of the range to measure, inclusive * @param end the end index of the range to measure, exclusive * @param contextStart the start index of the shaping context, inclusive * @param contextEnd the end index of the shaping context, exclusive * @param isRtl whether the run is in RTL direction * @param offset index of caret position * @param advances the array that receives the computed character advances * @param advancesIndex the start index from which the advances array is filled * @param drawBounds the output parameter for the bounding box of drawing text, optional * @param runInfo the output parameter for storing run information. * @return width measurement between start and offset * @hide TODO: Reorganize APIs */ public float getRunCharacterAdvance(@NonNull char[] text, int start, int end, int contextStart, int contextEnd, boolean isRtl, int offset, @Nullable float[] advances, int advancesIndex, @Nullable RectF drawBounds, @Nullable RunInfo runInfo) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if (contextStart < 0 || contextEnd > text.length) { throw new IndexOutOfBoundsException("Invalid Context Range: " + contextStart + ", " + contextEnd + " must be in 0, " + text.length); } if (start < contextStart || contextEnd < end) { throw new IndexOutOfBoundsException("Invalid start/end range: " + start + ", " + end + " must be in " + contextStart + ", " + contextEnd); } if (offset < start || end < offset) { throw new IndexOutOfBoundsException("Invalid offset position: " + offset + " must be in " + start + ", " + end); } if (advances != null && advances.length < advancesIndex - start + end) { throw new IndexOutOfBoundsException("Given array doesn't have enough space to receive " + "the result, advances.length: " + advances.length + " advanceIndex: " + advancesIndex + " needed space: " + (offset - start)); } if (end == start) { if (runInfo != null) { runInfo.setClusterCount(0); } return 0.0f; } return nGetRunCharacterAdvance(mNativePaint, text, start, end, contextStart, contextEnd, isRtl, offset, advances, advancesIndex, drawBounds, runInfo); } /** * @see #getRunCharacterAdvance(char[], int, int, int, int, boolean, int, float[], int) * * @param text the text to measure. Cannot be null. * @param start the index of the start of the range to measure * @param end the index + 1 of the end of the range to measure * @param contextStart the index of the start of the shaping context * @param contextEnd the index + 1 of the end of the shaping context * @param isRtl whether the run is in RTL direction * @param offset index of caret position * @param advances the array that receives the computed character advances * @param advancesIndex the start index from which the advances array is filled * @return width measurement between start and offset * @throws IndexOutOfBoundsException if a) contextStart or contextEnd is out of array's range * or contextStart is larger than contextEnd, * b) start or end is not within the range [contextStart, contextEnd), or end is larger than * start, * c) offset is not within the range [start, end), * d) advances.length - advanceIndex is smaller than the run length, which equals to * end - start. */ public float getRunCharacterAdvance(@NonNull CharSequence text, int start, int end, int contextStart, int contextEnd, boolean isRtl, int offset, @Nullable float[] advances, int advancesIndex) { return getRunCharacterAdvance(text, start, end, contextStart, contextEnd, isRtl, offset, advances, advancesIndex, null, null); } /** * @see #getRunCharacterAdvance(char[], int, int, int, int, boolean, int, float[], int) * * @param text the text to measure. Cannot be null. * @param start the index of the start of the range to measure * @param end the index + 1 of the end of the range to measure * @param contextStart the index of the start of the shaping context * @param contextEnd the index + 1 of the end of the shaping context * @param isRtl whether the run is in RTL direction * @param offset index of caret position * @param advances the array that receives the computed character advances * @param advancesIndex the start index from which the advances array is filled * @param drawBounds the output parameter for the bounding box of drawing text, optional * @param runInfo an optional output parameter for filling run information. * @return width measurement between start and offset * @hide TODO: Reorganize APIs */ public float getRunCharacterAdvance(@NonNull CharSequence text, int start, int end, int contextStart, int contextEnd, boolean isRtl, int offset, @Nullable float[] advances, int advancesIndex, @Nullable RectF drawBounds, @Nullable RunInfo runInfo) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if (contextStart < 0 || contextEnd > text.length()) { throw new IndexOutOfBoundsException("Invalid Context Range: " + contextStart + ", " + contextEnd + " must be in 0, " + text.length()); } if (start < contextStart || contextEnd < end) { throw new IndexOutOfBoundsException("Invalid start/end range: " + start + ", " + end + " must be in " + contextStart + ", " + contextEnd); } if (offset < start || end < offset) { throw new IndexOutOfBoundsException("Invalid offset position: " + offset + " must be in " + start + ", " + end); } if (advances != null && advances.length < advancesIndex - start + end) { throw new IndexOutOfBoundsException("Given array doesn't have enough space to receive " + "the result, advances.length: " + advances.length + " advanceIndex: " + advancesIndex + " needed space: " + (offset - start)); } if (end == start) { return 0.0f; } char[] buf = TemporaryBuffer.obtain(contextEnd - contextStart); TextUtils.getChars(text, contextStart, contextEnd, buf, 0); final float result = getRunCharacterAdvance(buf, start - contextStart, end - contextStart, 0, contextEnd - contextStart, isRtl, offset - contextStart, advances, advancesIndex, drawBounds, runInfo); TemporaryBuffer.recycle(buf); return result; } /** * Get the character offset within the string whose position is closest to the specified * horizontal position. * *

The returned value is generally the value of {@code offset} for which * {@link #getRunAdvance} yields a result most closely approximating {@code advance}, * and which is also on a grapheme cluster boundary. As such, it is the preferred method * for positioning a cursor in response to a touch or pointer event. The grapheme cluster * boundaries are based on * Unicode Standard Annex #29 but with some * tailoring for better user experience. * *

Note that {@code advance} is a (generally positive) width measurement relative to the start * of the run. Thus, for RTL runs it the distance from the point to the right edge. * *

All indices are relative to the start of {@code text}. Further, {@code 0 <= contextStart * <= start <= end <= contextEnd <= text.length} must hold on entry, and {@code start <= result * <= end} will hold on return. * * @param text the text to measure. Cannot be null. * @param start the index of the start of the range to measure * @param end the index + 1 of the end of the range to measure * @param contextStart the index of the start of the shaping context * @param contextEnd the index + 1 of the end of the range to measure * @param isRtl whether the run is in RTL direction * @param advance width relative to start of run * @return index of offset */ public int getOffsetForAdvance(char[] text, int start, int end, int contextStart, int contextEnd, boolean isRtl, float advance) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if ((contextStart | start | end | contextEnd | start - contextStart | end - start | contextEnd - end | text.length - contextEnd) < 0) { throw new IndexOutOfBoundsException(); } // TODO: take mCompatScaling into account (or eliminate compat scaling)? return nGetOffsetForAdvance(mNativePaint, text, start, end, contextStart, contextEnd, isRtl, advance); } /** * @see #getOffsetForAdvance(char[], int, int, int, int, boolean, float) * * @param text the text to measure. Cannot be null. * @param start the index of the start of the range to measure * @param end the index + 1 of the end of the range to measure * @param contextStart the index of the start of the shaping context * @param contextEnd the index + 1 of the end of the range to measure * @param isRtl whether the run is in RTL direction * @param advance width relative to start of run * @return index of offset */ public int getOffsetForAdvance(CharSequence text, int start, int end, int contextStart, int contextEnd, boolean isRtl, float advance) { if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if ((contextStart | start | end | contextEnd | start - contextStart | end - start | contextEnd - end | text.length() - contextEnd) < 0) { throw new IndexOutOfBoundsException(); } // TODO performance: specialized alternatives to avoid buffer copy, if win is significant char[] buf = TemporaryBuffer.obtain(contextEnd - contextStart); TextUtils.getChars(text, contextStart, contextEnd, buf, 0); int result = getOffsetForAdvance(buf, start - contextStart, end - contextStart, 0, contextEnd - contextStart, isRtl, advance) + contextStart; TemporaryBuffer.recycle(buf); return result; } /** * Returns true of the passed {@link Paint} will have the same effect on text measurement * * @param other A {@link Paint} object. * @return true if the other {@link Paint} has the same effect on text measurement. */ public boolean equalsForTextMeasurement(@NonNull Paint other) { return nEqualsForTextMeasurement(mNativePaint, other.mNativePaint); } // regular JNI private static native long nGetNativeFinalizer(); private static native long nInit(); private static native long nInitWithPaint(long paint); private static native int nBreakText(long nObject, char[] text, int index, int count, float maxWidth, int bidiFlags, float[] measuredWidth); private static native int nBreakText(long nObject, String text, boolean measureForwards, float maxWidth, int bidiFlags, float[] measuredWidth); private static native float nGetTextAdvances(long paintPtr, char[] text, int index, int count, int contextIndex, int contextCount, int bidiFlags, float[] advances, int advancesIndex); private static native float nGetTextAdvances(long paintPtr, String text, int start, int end, int contextStart, int contextEnd, int bidiFlags, float[] advances, int advancesIndex); private native int nGetTextRunCursor(long paintPtr, char[] text, int contextStart, int contextLength, int dir, int offset, int cursorOpt); private native int nGetTextRunCursor(long paintPtr, String text, int contextStart, int contextEnd, int dir, int offset, int cursorOpt); private static native void nGetTextPath(long paintPtr, int bidiFlags, char[] text, int index, int count, float x, float y, long path); private static native void nGetTextPath(long paintPtr, int bidiFlags, String text, int start, int end, float x, float y, long path); private static native void nGetStringBounds(long nativePaint, String text, int start, int end, int bidiFlags, Rect bounds); private static native void nGetCharArrayBounds(long nativePaint, char[] text, int index, int count, int bidiFlags, Rect bounds); private static native boolean nHasGlyph(long paintPtr, int bidiFlags, String string); private static native float nGetRunAdvance(long paintPtr, char[] text, int start, int end, int contextStart, int contextEnd, boolean isRtl, int offset); private static native float nGetRunCharacterAdvance(long paintPtr, char[] text, int start, int end, int contextStart, int contextEnd, boolean isRtl, int offset, float[] advances, int advancesIndex, RectF drawingBounds, RunInfo runInfo); private static native int nGetOffsetForAdvance(long paintPtr, char[] text, int start, int end, int contextStart, int contextEnd, boolean isRtl, float advance); private static native void nGetFontMetricsIntForText(long paintPtr, char[] text, int start, int count, int ctxStart, int ctxCount, boolean isRtl, FontMetricsInt outMetrics); private static native void nGetFontMetricsIntForText(long paintPtr, String text, int start, int count, int ctxStart, int ctxCount, boolean isRtl, FontMetricsInt outMetrics); // ---------------- @FastNative ------------------------ @FastNative private static native int nSetTextLocales(long paintPtr, String locales); @FastNative private static native void nSetFontFeatureSettings(long paintPtr, String settings); @FastNative private static native float nGetFontMetrics(long paintPtr, FontMetrics metrics, boolean useLocale); @FastNative private static native int nGetFontMetricsInt(long paintPtr, FontMetricsInt fmi, boolean useLocale); // ---------------- @CriticalNative ------------------------ @CriticalNative private static native void nReset(long paintPtr); @CriticalNative private static native void nSet(long paintPtrDest, long paintPtrSrc); @CriticalNative private static native int nGetStyle(long paintPtr); @CriticalNative private static native void nSetStyle(long paintPtr, int style); @CriticalNative private static native int nGetStrokeCap(long paintPtr); @CriticalNative private static native void nSetStrokeCap(long paintPtr, int cap); @CriticalNative private static native int nGetStrokeJoin(long paintPtr); @CriticalNative private static native void nSetStrokeJoin(long paintPtr, int join); @CriticalNative private static native boolean nGetFillPath(long paintPtr, long src, long dst); @CriticalNative private static native long nSetShader(long paintPtr, long shader); @CriticalNative private static native long nSetColorFilter(long paintPtr, long filter); @CriticalNative private static native void nSetXfermode(long paintPtr, int xfermode); @CriticalNative private static native void nSetXfermode(long paintPtr, long xfermodePtr); @CriticalNative private static native long nSetPathEffect(long paintPtr, long effect); @CriticalNative private static native long nSetMaskFilter(long paintPtr, long maskfilter); @CriticalNative private static native void nSetTypeface(long paintPtr, long typeface); @CriticalNative private static native int nGetTextAlign(long paintPtr); @CriticalNative private static native void nSetTextAlign(long paintPtr, int align); @CriticalNative private static native void nSetTextLocalesByMinikinLocaleListId(long paintPtr, int mMinikinLocaleListId); @CriticalNative private static native void nSetShadowLayer(long paintPtr, float radius, float dx, float dy, long colorSpaceHandle, @ColorLong long shadowColor); @CriticalNative private static native boolean nHasShadowLayer(long paintPtr); @CriticalNative private static native float nGetLetterSpacing(long paintPtr); @CriticalNative private static native void nSetLetterSpacing(long paintPtr, float letterSpacing); @CriticalNative private static native float nGetWordSpacing(long paintPtr); @CriticalNative private static native void nSetWordSpacing(long paintPtr, float wordSpacing); @CriticalNative private static native int nGetStartHyphenEdit(long paintPtr); @CriticalNative private static native int nGetEndHyphenEdit(long paintPtr); @CriticalNative private static native void nSetStartHyphenEdit(long paintPtr, int hyphen); @CriticalNative private static native void nSetEndHyphenEdit(long paintPtr, int hyphen); @CriticalNative private static native void nSetStrokeMiter(long paintPtr, float miter); @CriticalNative private static native float nGetStrokeMiter(long paintPtr); @CriticalNative private static native void nSetStrokeWidth(long paintPtr, float width); @CriticalNative private static native float nGetStrokeWidth(long paintPtr); @CriticalNative private static native void nSetAlpha(long paintPtr, int a); @CriticalNative private static native void nSetDither(long paintPtr, boolean dither); @CriticalNative private static native int nGetFlags(long paintPtr); @CriticalNative private static native void nSetFlags(long paintPtr, int flags); @CriticalNative private static native int nGetHinting(long paintPtr); @CriticalNative private static native void nSetHinting(long paintPtr, int mode); @CriticalNative private static native void nSetAntiAlias(long paintPtr, boolean aa); @CriticalNative private static native void nSetLinearText(long paintPtr, boolean linearText); @CriticalNative private static native void nSetSubpixelText(long paintPtr, boolean subpixelText); @CriticalNative private static native void nSetUnderlineText(long paintPtr, boolean underlineText); @CriticalNative private static native void nSetFakeBoldText(long paintPtr, boolean fakeBoldText); @CriticalNative private static native void nSetFilterBitmap(long paintPtr, boolean filter); @CriticalNative private static native void nSetColor(long paintPtr, long colorSpaceHandle, @ColorLong long color); @CriticalNative private static native void nSetColor(long paintPtr, @ColorInt int color); @CriticalNative private static native void nSetStrikeThruText(long paintPtr, boolean strikeThruText); @CriticalNative private static native int nGetElegantTextHeight(long paintPtr); @CriticalNative private static native void nSetElegantTextHeight(long paintPtr, int elegant); @CriticalNative private static native float nGetTextSize(long paintPtr); @CriticalNative private static native float nGetTextScaleX(long paintPtr); @CriticalNative private static native void nSetTextScaleX(long paintPtr, float scaleX); @CriticalNative private static native float nGetTextSkewX(long paintPtr); @CriticalNative private static native void nSetTextSkewX(long paintPtr, float skewX); @CriticalNative private static native float nAscent(long paintPtr); @CriticalNative private static native float nDescent(long paintPtr); @CriticalNative private static native float nGetUnderlinePosition(long paintPtr); @CriticalNative private static native float nGetUnderlineThickness(long paintPtr); @CriticalNative private static native float nGetStrikeThruPosition(long paintPtr); @CriticalNative private static native float nGetStrikeThruThickness(long paintPtr); @CriticalNative private static native void nSetTextSize(long paintPtr, float textSize); @CriticalNative private static native boolean nEqualsForTextMeasurement(long leftPaintPtr, long rightPaintPtr); @CriticalNative private static native long nCreateFontVariationBuilder(int size); @CriticalNative private static native void nAddFontVariationToBuilder(long builderPtr, int tag, float value); @CriticalNative private static native void nSetFontVariationOverride(long paintPtr, long builderPtr); // Following Native methods are kept for old Robolectric JNI signature used by // SystemUIGoogleRoboRNGTests private static native float nGetRunCharacterAdvance(long paintPtr, char[] text, int start, int end, int contextStart, int contextEnd, boolean isRtl, int offset, float[] advances, int advancesIndex, RectF drawingBounds); }