PrecomputedTextCompat

open class PrecomputedTextCompat : Spannable

create

open static fun create(
    @NonNull text: CharSequence, 
    @NonNull params: PrecomputedTextCompat.Params
): PrecomputedTextCompat!

Create a new PrecomputedText which will pre-compute text measurement and glyph positioning information.

This can be expensive, so computing this on a background thread before your text will be presented can save work on the UI thread.

Note that any android.text.NoCopySpan attached to the text won't be passed to the created PrecomputedText.

Parameters
text	CharSequence: the text to be measured
params	PrecomputedTextCompat.Params: parameters that define how text will be precomputed

Return
PrecomputedTextCompat!	A PrecomputedText

get

open fun get(index: Int): Char

getParagraphCount

@IntRange(0) open fun getParagraphCount(): Int

Returns the count of paragraphs.

getParagraphEnd

@IntRange(0) open fun getParagraphEnd(@IntRange(0) paraIndex: Int): Int

Returns the paragraph end offset of the text.

getParagraphStart

@IntRange(0) open fun getParagraphStart(@IntRange(0) paraIndex: Int): Int

Returns the paragraph start offset of the text.

getParams

@NonNull open fun getParams(): PrecomputedTextCompat.Params

Returns the parameters used to measure this text.

getSpanEnd

open fun getSpanEnd(tag: Any!): Int

getSpanFlags

open fun getSpanFlags(tag: Any!): Int

getSpanStart

open fun getSpanStart(tag: Any!): Int

getSpans

open fun <T : Any!> getSpans(
    start: Int, 
    end: Int, 
    type: Class<T>!
): Array<T>!

getTextFuture

@UiThread open static fun getTextFuture(
    @NonNull charSequence: CharSequence, 
    @NonNull params: PrecomputedTextCompat.Params, 
    @Nullable executor: Executor?
): Future<PrecomputedTextCompat!>!

Helper for PrecomputedText that returns a future to be used with androidx.appcompat.widget.AppCompatTextView#setTextFuture. PrecomputedText is suited to compute on a background thread, but when TextView properties are dynamic, it's common to configure text properties and text at the same time, when binding a View. For example, in a RecyclerView Adapter:

void onBindViewHolder(ViewHolder vh, int position) {
              ItemData data = getData(position);
     
              vh.textView.setTextSize(...);
              vh.textView.setFontVariationSettings(...);
              vh.textView.setText(data.text);
          }
      

In such cases, using PrecomputedText is difficult, since it isn't safe to defer the setText() code arbitrarily - a layout pass may happen before computation finishes, and will be incorrect if the text isn't ready yet.

With getTextFuture(), you can block on the result of the precomputation safely before the result is needed. AppCompatTextView provides androidx.appcompat.widget.AppCompatTextView#setTextFuture for exactly this use case. With the following code, the app's layout work is largely done on a background thread:

void onBindViewHolder(ViewHolder vh, int position) {
              ItemData data = getData(position);
     
              vh.textView.setTextSize(...);
              vh.textView.setFontVariationSettings(...);
     
              // start precompute
              Future<precomputedtextcompat>
  future = PrecomputedTextCompat.getTextFuture(
                      data.text, vh.textView.getTextMetricsParamsCompat(), myExecutor);
     
              // and pass future to TextView, which awaits result before measuring
              vh.textView.setTextFuture(future);
          }
      
</precomputedtextcompat>

Because RecyclerView prefetches bind multiple frames in advance while scrolling, the text work generally has plenty of time to complete before measurement occurs.

Note: all TextView layout properties must be set before creating the Params object. If they are changed during the precomputation, this can cause a IllegalArgumentException when the precomputed value is consumed during measure, and doesn't reflect the TextView's current state.

Parameters
charSequence	CharSequence: the text to be displayed
params	PrecomputedTextCompat.Params: the parameters to be used for displaying text
executor	Executor?: the executor to be process the text layout. If null is passed, the default single threaded pool will be used.

Return
Future<PrecomputedTextCompat!>!	a future of the precomputed text

nextSpanTransition

open fun nextSpanTransition(
    start: Int, 
    limit: Int, 
    type: Class<Any!>!
): Int

removeSpan

open fun removeSpan(what: Any!): Unit

Exceptions
IllegalArgumentException	if MetricAffectingSpan is specified.

setSpan

open fun setSpan(
    what: Any!, 
    start: Int, 
    end: Int, 
    flags: Int
): Unit

Exceptions
IllegalArgumentException	if MetricAffectingSpan is specified.

subSequence

open fun subSequence(
    startIndex: Int, 
    endIndex: Int
): CharSequence

toString

@NonNull open fun toString(): String

length

open val length: Int