TextUtils

CAP_MODE_CHARACTERS

static val CAP_MODE_CHARACTERS: Int

Capitalization mode for getCapsMode: capitalize all characters. This value is explicitly defined to be the same as InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS.

Value: 4096

CAP_MODE_SENTENCES

static val CAP_MODE_SENTENCES: Int

Capitalization mode for getCapsMode: capitalize the first character of each sentence. This value is explicitly defined to be the same as InputType.TYPE_TEXT_FLAG_CAP_SENTENCES.

Value: 16384

CAP_MODE_WORDS

static val CAP_MODE_WORDS: Int

Capitalization mode for getCapsMode: capitalize the first character of all words. This value is explicitly defined to be the same as InputType.TYPE_TEXT_FLAG_CAP_WORDS.

Value: 8192

SAFE_STRING_FLAG_FIRST_LINE

static val SAFE_STRING_FLAG_FIRST_LINE: Int

Return only first line of text (truncate at first newline). Cannot be set at the same time as SAFE_STRING_FLAG_SINGLE_LINE.

Value: 4

SAFE_STRING_FLAG_SINGLE_LINE

static val SAFE_STRING_FLAG_SINGLE_LINE: Int

Force entire string into single line of text (no newlines). Cannot be set at the same time as SAFE_STRING_FLAG_FIRST_LINE.

Value: 2

SAFE_STRING_FLAG_TRIM

static val SAFE_STRING_FLAG_TRIM: Int

Remove whitespace and non-breaking spaces from the edges of the label.

Value: 1

commaEllipsize

open static fun commaEllipsize(
    text: CharSequence!, 
    p: TextPaint!, 
    avail: Float, 
    oneMore: String!, 
    more: String!
): CharSequence!

Deprecated: Do not use. This is not internationalized, and has known issues with right-to-left text, languages that have more than one plural form, languages that use a different character as a comma-like separator, etc. Use listEllipsize instead.

Converts a CharSequence of the comma-separated form "Andy, Bob, Charles, David" that is too wide to fit into the specified width into one like "Andy, Bob, 2 more".

concat

open static fun concat(vararg text: CharSequence!): CharSequence!

Returns a CharSequence concatenating the specified CharSequences, retaining their spans if any. If there are no parameters, an empty string will be returned. If the number of parameters is exactly one, that parameter is returned as output, even if it is null. If the number of parameters is at least two, any null CharSequence among the parameters is treated as if it was the string "null". If there are paragraph spans in the source CharSequences that satisfy paragraph boundary requirements in the sources but would no longer satisfy them in the concatenated CharSequence, they may get extended in the resulting CharSequence or not retained.

copySpansFrom

open static fun copySpansFrom(
    source: Spanned!, 
    start: Int, 
    end: Int, 
    kind: Class<Any!>!, 
    dest: Spannable!, 
    destoff: Int
): Unit

Copies the spans from the region start...end in source to the region destoff...destoff+end-start in dest. Spans in source that begin before start or end after end but overlap this range are trimmed as if they began at start or ended at end.

dumpSpans

open static fun dumpSpans(
    cs: CharSequence!, 
    printer: Printer!, 
    prefix: String!
): Unit

Debugging tool to print the spans in a CharSequence. The output will be printed one span per line. If the CharSequence is not a Spanned, then the entire string will be printed on a single line.

ellipsize

open static fun ellipsize(
    text: CharSequence!, 
    p: TextPaint!, 
    avail: Float, 
    where: TextUtils.TruncateAt!
): CharSequence!

Returns the original text if it fits in the specified width given the properties of the specified Paint, or, if it does not fit, a truncated copy with ellipsis character added at the specified edge or center.

ellipsize

open static fun ellipsize(
    text: CharSequence!, 
    paint: TextPaint!, 
    avail: Float, 
    where: TextUtils.TruncateAt!, 
    preserveLength: Boolean, 
    callback: TextUtils.EllipsizeCallback?
): CharSequence!

Returns the original text if it fits in the specified width given the properties of the specified Paint, or, if it does not fit, a copy with ellipsis character added at the specified edge or center. If preserveLength is specified, the returned copy will be padded with zero-width spaces to preserve the original length and offsets instead of truncating. If callback is non-null, it will be called to report the start and end of the ellipsized range. TextDirection is determined by the first strong directional character.

equals

open static fun equals(
    a: CharSequence!, 
    b: CharSequence!
): Boolean

Returns true if a and b are equal, including if they are both null.

Note: In platform versions 1.1 and earlier, this method only worked well if both the arguments were instances of String.

expandTemplate

open static fun expandTemplate(
    template: CharSequence!, 
    vararg values: CharSequence!
): CharSequence!

Replace instances of "^1", "^2", etc. in the template CharSequence with the corresponding values. "^^" is used to produce a single caret in the output. Only up to 9 replacement values are supported, "^10" will be produce the first replacement value followed by a '0'.

getCapsMode

open static fun getCapsMode(
    cs: CharSequence!, 
    off: Int, 
    reqModes: Int
): Int

Determine what caps mode should be in effect at the current offset in the text. Only the mode bits set in reqModes will be checked. Note that the caps mode flags here are explicitly defined to match those in InputType.

getChars

open static fun getChars(
    s: CharSequence!, 
    start: Int, 
    end: Int, 
    dest: CharArray!, 
    destoff: Int
): Unit

getLayoutDirectionFromLocale

open static fun getLayoutDirectionFromLocale(locale: Locale!): Int

Return the layout direction for a given Locale

getOffsetAfter

open static fun getOffsetAfter(
    text: CharSequence!, 
    offset: Int
): Int

getOffsetBefore

open static fun getOffsetBefore(
    text: CharSequence!, 
    offset: Int
): Int

getReverse

open static fun getReverse(
    source: CharSequence!, 
    start: Int, 
    end: Int
): CharSequence!

Deprecated: Do not use.

This function only reverses individual chars and not their associated spans. It doesn't support surrogate pairs (that correspond to non-BMP code points), combining sequences or conjuncts either.

getTrimmedLength

open static fun getTrimmedLength(s: CharSequence!): Int

Returns the length that the specified CharSequence would have if spaces and ASCII control characters were trimmed from the start and end, as by String.trim.

htmlEncode

open static fun htmlEncode(s: String!): String!

Html-encode the string.

indexOf

open static fun indexOf(
    s: CharSequence!, 
    ch: Char
): Int

indexOf

open static fun indexOf(
    s: CharSequence!, 
    ch: Char, 
    start: Int
): Int

indexOf

open static fun indexOf(
    s: CharSequence!, 
    ch: Char, 
    start: Int, 
    end: Int
): Int

indexOf

open static fun indexOf(
    s: CharSequence!, 
    needle: CharSequence!
): Int

indexOf

open static fun indexOf(
    s: CharSequence!, 
    needle: CharSequence!, 
    start: Int
): Int

indexOf

open static fun indexOf(
    s: CharSequence!, 
    needle: CharSequence!, 
    start: Int, 
    end: Int
): Int

isDigitsOnly

open static fun isDigitsOnly(str: CharSequence!): Boolean

Returns whether the given CharSequence contains only digits.

isEmpty

open static fun isEmpty(str: CharSequence?): Boolean

Returns true if the string is null or 0-length.

isGraphic

open static fun isGraphic(c: Char): Boolean

Deprecated: Use isGraphic(java.lang.CharSequence) instead.

Returns whether this character is a printable character. This does not support non-BMP characters and should not be used.

isGraphic

open static fun isGraphic(str: CharSequence!): Boolean

Returns whether the given CharSequence contains any printable characters.

join

open static fun join(
    delimiter: CharSequence, 
    tokens: MutableIterable<Any?>
): String!

Returns a string containing the tokens joined by delimiters.

join

open static fun join(
    delimiter: CharSequence, 
    tokens: Array<Any!>
): String!

Returns a string containing the tokens joined by delimiters.

lastIndexOf

open static fun lastIndexOf(
    s: CharSequence!, 
    ch: Char
): Int

lastIndexOf

open static fun lastIndexOf(
    s: CharSequence!, 
    ch: Char, 
    last: Int
): Int

lastIndexOf

open static fun lastIndexOf(
    s: CharSequence!, 
    ch: Char, 
    start: Int, 
    last: Int
): Int

listEllipsize

open static fun listEllipsize(
    context: Context?, 
    elements: MutableList<CharSequence!>?, 
    separator: String, 
    paint: TextPaint, 
    avail: Float, 
    moreId: Int
): CharSequence!

Formats a list of CharSequences by repeatedly inserting the separator between them, but stopping when the resulting sequence is too wide for the specified width. This method actually tries to fit the maximum number of elements. So if "A, 11 more" fits, "A, B, 10 more" doesn't fit, but "A, B, C, 9 more" fits again (due to the glyphs for the digits being very wide, for example), it returns "A, B, C, 9 more". Because of this, this method may be inefficient for very long lists. Note that the elements of the returned value, as well as the string for moreId, will be bidi-wrapped using android.text.BidiFormatter#unicodeWrap based on the locale of the input Context. If the input Context is null, the default BidiFormatter from BidiFormatter.getInstance() will be used.

makeSafeForPresentation

open static fun makeSafeForPresentation(
    unclean: String, 
    maxCharactersToConsider: Int, 
    ellipsizeDip: Float, 
    flags: Int
): CharSequence

Remove html, remove bad characters, and truncate string.

This method is meant to remove common mistakes and nefarious formatting from strings that were loaded from untrusted sources (such as other packages).

This method first android.text.Html#fromHtml and then ...

• Removes new lines or truncates at first new line
• Trims the white-space off the end
• Truncates the string

regionMatches

open static fun regionMatches(
    one: CharSequence!, 
    toffset: Int, 
    two: CharSequence!, 
    ooffset: Int, 
    len: Int
): Boolean

replace

open static fun replace(
    template: CharSequence!, 
    sources: Array<String!>!, 
    destinations: Array<CharSequence!>!
): CharSequence!

Return a new CharSequence in which each of the source strings is replaced by the corresponding element of the destinations.

split

open static fun split(
    text: String!, 
    expression: String!
): Array<String!>!

This method yields the same result as text.split(expression, -1) except that if text.isEmpty() then this method returns an empty array whereas "".split(expression, -1) would have returned an array with a single "". The -1 means that trailing empty Strings are not removed from the result; for example split("a,", "," ) returns {"a", ""}. Note that whether a leading zero-width match can result in a leading "" depends on whether your app targets an SDK version <= 28; see Pattern.split(CharSequence, int).

split

open static fun split(
    text: String!, 
    pattern: Pattern!
): Array<String!>!

Splits a string on a pattern. This method yields the same result as pattern.split(text, -1) except that if text.isEmpty() then this method returns an empty array whereas pattern.split("", -1) would have returned an array with a single "". The -1 means that trailing empty Strings are not removed from the result; Note that whether a leading zero-width match can result in a leading "" depends on whether your app targets <= 28; see Pattern.split(CharSequence, int).

stringOrSpannedString

open static fun stringOrSpannedString(source: CharSequence!): CharSequence!

substring

open static fun substring(
    source: CharSequence!, 
    start: Int, 
    end: Int
): String!

Create a new String object containing the given range of characters from the source string. This is different than simply calling CharSequence.subSequence in that it does not preserve any style runs in the source sequence, allowing a more efficient implementation.

writeToParcel

open static fun writeToParcel(
    cs: CharSequence?, 
    p: Parcel, 
    parcelableFlags: Int
): Unit

Flatten a CharSequence and whatever styles can be copied across processes into the parcel.

CHAR_SEQUENCE_CREATOR

static val CHAR_SEQUENCE_CREATOR: Parcelable.Creator<CharSequence!>!