diff --git a/packages/SystemUI/animation/src/com/android/systemui/animation/FontInterpolator.kt b/packages/SystemUI/animation/src/com/android/systemui/animation/FontInterpolator.kt index 3d341af3b3970..290328894439b 100644 --- a/packages/SystemUI/animation/src/com/android/systemui/animation/FontInterpolator.kt +++ b/packages/SystemUI/animation/src/com/android/systemui/animation/FontInterpolator.kt @@ -33,9 +33,7 @@ private const val FONT_ITALIC_MIN = 0f private const val FONT_ITALIC_ANIMATION_STEP = 0.1f private const val FONT_ITALIC_DEFAULT_VALUE = 0f -/** - * Provide interpolation of two fonts by adjusting font variation settings. - */ +/** Provide interpolation of two fonts by adjusting font variation settings. */ class FontInterpolator { /** @@ -61,11 +59,14 @@ class FontInterpolator { var index: Int, val sortedAxes: MutableList ) { - constructor(font: Font, axes: List) : - this(font.sourceIdentifier, - font.ttcIndex, - axes.toMutableList().apply { sortBy { it.tag } } - ) + constructor( + font: Font, + axes: List + ) : this( + font.sourceIdentifier, + font.ttcIndex, + axes.toMutableList().apply { sortBy { it.tag } } + ) fun set(font: Font, axes: List) { sourceId = font.sourceIdentifier @@ -86,9 +87,7 @@ class FontInterpolator { private val tmpInterpKey = InterpKey(null, null, 0f) private val tmpVarFontKey = VarFontKey(0, 0, mutableListOf()) - /** - * Linear interpolate the font variation settings. - */ + /** Linear interpolate the font variation settings. */ fun lerp(start: Font, end: Font, progress: Float): Font { if (progress == 0f) { return start @@ -115,27 +114,34 @@ class FontInterpolator { // this doesn't take much time since the variation axes is usually up to 5. If we need to // support more number of axes, we may want to preprocess the font and store the sorted axes // and also pre-fill the missing axes value with default value from 'fvar' table. - val newAxes = lerp(startAxes, endAxes) { tag, startValue, endValue -> - when (tag) { - // TODO: Good to parse 'fvar' table for retrieving default value. - TAG_WGHT -> adjustWeight( - MathUtils.lerp( + val newAxes = + lerp(startAxes, endAxes) { tag, startValue, endValue -> + when (tag) { + // TODO: Good to parse 'fvar' table for retrieving default value. + TAG_WGHT -> + adjustWeight( + MathUtils.lerp( startValue ?: FONT_WEIGHT_DEFAULT_VALUE, endValue ?: FONT_WEIGHT_DEFAULT_VALUE, - progress)) - TAG_ITAL -> adjustItalic( - MathUtils.lerp( + progress + ) + ) + TAG_ITAL -> + adjustItalic( + MathUtils.lerp( startValue ?: FONT_ITALIC_DEFAULT_VALUE, endValue ?: FONT_ITALIC_DEFAULT_VALUE, - progress)) - else -> { - require(startValue != null && endValue != null) { - "Unable to interpolate due to unknown default axes value : $tag" + progress + ) + ) + else -> { + require(startValue != null && endValue != null) { + "Unable to interpolate due to unknown default axes value : $tag" + } + MathUtils.lerp(startValue, endValue, progress) } - MathUtils.lerp(startValue, endValue, progress) } } - } // Check if we already make font for this axes. This is typically happens if the animation // happens backward. @@ -149,9 +155,7 @@ class FontInterpolator { // This is the first time to make the font for the axes. Build and store it to the cache. // Font.Builder#build won't throw IOException since creating fonts from existing fonts will // not do any IO work. - val newFont = Font.Builder(start) - .setFontVariationSettings(newAxes.toTypedArray()) - .build() + val newFont = Font.Builder(start).setFontVariationSettings(newAxes.toTypedArray()).build() interpCache[InterpKey(start, end, progress)] = newFont verFontCache[VarFontKey(start, newAxes)] = newFont return newFont @@ -173,26 +177,28 @@ class FontInterpolator { val tagA = if (i < start.size) start[i].tag else null val tagB = if (j < end.size) end[j].tag else null - val comp = when { - tagA == null -> 1 - tagB == null -> -1 - else -> tagA.compareTo(tagB) - } + val comp = + when { + tagA == null -> 1 + tagB == null -> -1 + else -> tagA.compareTo(tagB) + } - val axis = when { - comp == 0 -> { - val v = filter(tagA!!, start[i++].styleValue, end[j++].styleValue) - FontVariationAxis(tagA, v) + val axis = + when { + comp == 0 -> { + val v = filter(tagA!!, start[i++].styleValue, end[j++].styleValue) + FontVariationAxis(tagA, v) + } + comp < 0 -> { + val v = filter(tagA!!, start[i++].styleValue, null) + FontVariationAxis(tagA, v) + } + else -> { // comp > 0 + val v = filter(tagB!!, null, end[j++].styleValue) + FontVariationAxis(tagB, v) + } } - comp < 0 -> { - val v = filter(tagA!!, start[i++].styleValue, null) - FontVariationAxis(tagA, v) - } - else -> { // comp > 0 - val v = filter(tagB!!, null, end[j++].styleValue) - FontVariationAxis(tagB, v) - } - } result.add(axis) } @@ -202,21 +208,21 @@ class FontInterpolator { // For the performance reasons, we animate weight with FONT_WEIGHT_ANIMATION_STEP. This helps // Cache hit ratio in the Skia glyph cache. private fun adjustWeight(value: Float) = - coerceInWithStep(value, FONT_WEIGHT_MIN, FONT_WEIGHT_MAX, FONT_WEIGHT_ANIMATION_STEP) + coerceInWithStep(value, FONT_WEIGHT_MIN, FONT_WEIGHT_MAX, FONT_WEIGHT_ANIMATION_STEP) // For the performance reasons, we animate italic with FONT_ITALIC_ANIMATION_STEP. This helps // Cache hit ratio in the Skia glyph cache. private fun adjustItalic(value: Float) = - coerceInWithStep(value, FONT_ITALIC_MIN, FONT_ITALIC_MAX, FONT_ITALIC_ANIMATION_STEP) + coerceInWithStep(value, FONT_ITALIC_MIN, FONT_ITALIC_MAX, FONT_ITALIC_ANIMATION_STEP) private fun coerceInWithStep(v: Float, min: Float, max: Float, step: Float) = - (v.coerceIn(min, max) / step).toInt() * step + (v.coerceIn(min, max) / step).toInt() * step companion object { private val EMPTY_AXES = arrayOf() // Returns true if given two font instance can be interpolated. fun canInterpolate(start: Font, end: Font) = - start.ttcIndex == end.ttcIndex && start.sourceIdentifier == end.sourceIdentifier + start.ttcIndex == end.ttcIndex && start.sourceIdentifier == end.sourceIdentifier } } diff --git a/packages/SystemUI/animation/src/com/android/systemui/animation/TextAnimator.kt b/packages/SystemUI/animation/src/com/android/systemui/animation/TextAnimator.kt index 5f1bb83715c2f..fdab7490e476f 100644 --- a/packages/SystemUI/animation/src/com/android/systemui/animation/TextAnimator.kt +++ b/packages/SystemUI/animation/src/com/android/systemui/animation/TextAnimator.kt @@ -36,8 +36,8 @@ typealias GlyphCallback = (TextAnimator.PositionedGlyph, Float) -> Unit * Currently this class can provide text style animation for text weight and text size. For example * the simple view that draws text with animating text size is like as follows: * - * 
- * 
+ * 
 
+ * ```
  *     class SimpleTextAnimation : View {
  *         @JvmOverloads constructor(...)
  *
@@ -53,83 +53,63 @@ typealias GlyphCallback = (TextAnimator.PositionedGlyph, Float) -> Unit
  *             animator.setTextStyle(-1 /* unchanged weight */, sizePx, animate)
  *         }
  *     }
- * 
- * 

+ * ```
+ *
*/ -class TextAnimator( - layout: Layout, - private val invalidateCallback: () -> Unit -) { +class TextAnimator(layout: Layout, private val invalidateCallback: () -> Unit) { // Following two members are for mutable for testing purposes. public var textInterpolator: TextInterpolator = TextInterpolator(layout) - public var animator: ValueAnimator = ValueAnimator.ofFloat(1f).apply { - duration = DEFAULT_ANIMATION_DURATION - addUpdateListener { - textInterpolator.progress = it.animatedValue as Float - invalidateCallback() - } - addListener(object : AnimatorListenerAdapter() { - override fun onAnimationEnd(animation: Animator?) { - textInterpolator.rebase() + public var animator: ValueAnimator = + ValueAnimator.ofFloat(1f).apply { + duration = DEFAULT_ANIMATION_DURATION + addUpdateListener { + textInterpolator.progress = it.animatedValue as Float + invalidateCallback() } - override fun onAnimationCancel(animation: Animator?) = textInterpolator.rebase() - }) - } + addListener( + object : AnimatorListenerAdapter() { + override fun onAnimationEnd(animation: Animator?) { + textInterpolator.rebase() + } + override fun onAnimationCancel(animation: Animator?) = textInterpolator.rebase() + } + ) + } sealed class PositionedGlyph { - /** - * Mutable X coordinate of the glyph position relative from drawing offset. - */ + /** Mutable X coordinate of the glyph position relative from drawing offset. */ var x: Float = 0f - /** - * Mutable Y coordinate of the glyph position relative from the baseline. - */ + /** Mutable Y coordinate of the glyph position relative from the baseline. */ var y: Float = 0f - /** - * The current line of text being drawn, in a multi-line TextView. - */ + /** The current line of text being drawn, in a multi-line TextView. */ var lineNo: Int = 0 - /** - * Mutable text size of the glyph in pixels. - */ + /** Mutable text size of the glyph in pixels. */ var textSize: Float = 0f - /** - * Mutable color of the glyph. - */ + /** Mutable color of the glyph. */ var color: Int = 0 - /** - * Immutable character offset in the text that the current font run start. - */ + /** Immutable character offset in the text that the current font run start. */ abstract var runStart: Int protected set - /** - * Immutable run length of the font run. - */ + /** Immutable run length of the font run. */ abstract var runLength: Int protected set - /** - * Immutable glyph index of the font run. - */ + /** Immutable glyph index of the font run. */ abstract var glyphIndex: Int protected set - /** - * Immutable font instance for this font run. - */ + /** Immutable font instance for this font run. */ abstract var font: Font protected set - /** - * Immutable glyph ID for this glyph. - */ + /** Immutable glyph ID for this glyph. */ abstract var glyphId: Int protected set } @@ -147,20 +127,18 @@ class TextAnimator( /** * GlyphFilter applied just before drawing to canvas for tweaking positions and text size. * - * This callback is called for each glyphs just before drawing the glyphs. This function will - * be called with the intrinsic position, size, color, glyph ID and font instance. You can - * mutate the position, size and color for tweaking animations. - * Do not keep the reference of passed glyph object. The interpolator reuses that object for - * avoiding object allocations. + * This callback is called for each glyphs just before drawing the glyphs. This function will be + * called with the intrinsic position, size, color, glyph ID and font instance. You can mutate + * the position, size and color for tweaking animations. Do not keep the reference of passed + * glyph object. The interpolator reuses that object for avoiding object allocations. * - * Details: - * The text is drawn with font run units. The font run is a text segment that draws with the - * same font. The {@code runStart} and {@code runLimit} is a range of the font run in the text - * that current glyph is in. Once the font run is determined, the system will convert characters - * into glyph IDs. The {@code glyphId} is the glyph identifier in the font and - * {@code glyphIndex} is the offset of the converted glyph array. Please note that the - * {@code glyphIndex} is not a character index, because the character will not be converted to - * glyph one-by-one. If there are ligatures including emoji sequence, etc, the glyph ID may be + * Details: The text is drawn with font run units. The font run is a text segment that draws + * with the same font. The {@code runStart} and {@code runLimit} is a range of the font run in + * the text that current glyph is in. Once the font run is determined, the system will convert + * characters into glyph IDs. The {@code glyphId} is the glyph identifier in the font and {@code + * glyphIndex} is the offset of the converted glyph array. Please note that the {@code + * glyphIndex} is not a character index, because the character will not be converted to glyph + * one-by-one. If there are ligatures including emoji sequence, etc, the glyph ID may be * composed from multiple characters. * * Here is an example of font runs: "fin. 終わり" @@ -193,7 +171,9 @@ class TextAnimator( */ var glyphFilter: GlyphCallback? get() = textInterpolator.glyphFilter - set(value) { textInterpolator.glyphFilter = value } + set(value) { + textInterpolator.glyphFilter = value + } fun draw(c: Canvas) = textInterpolator.draw(c) @@ -208,7 +188,7 @@ class TextAnimator( * @param weight an optional text weight. * @param textSize an optional font size. * @param colors an optional colors array that must be the same size as numLines passed to - * the TextInterpolator + * the TextInterpolator * @param animate an optional boolean indicating true for showing style transition as animation, * false for immediate style transition. True by default. * @param duration an optional animation duration in milliseconds. This is ignored if animate is @@ -237,10 +217,11 @@ class TextAnimator( if (weight >= 0) { // Paint#setFontVariationSettings creates Typeface instance from scratch. To reduce the // memory impact, cache the typeface result. - textInterpolator.targetPaint.typeface = typefaceCache.getOrElse(weight) { - textInterpolator.targetPaint.fontVariationSettings = "'$TAG_WGHT' $weight" - textInterpolator.targetPaint.typeface - } + textInterpolator.targetPaint.typeface = + typefaceCache.getOrElse(weight) { + textInterpolator.targetPaint.fontVariationSettings = "'$TAG_WGHT' $weight" + textInterpolator.targetPaint.typeface + } } if (color != null) { textInterpolator.targetPaint.color = color @@ -249,22 +230,24 @@ class TextAnimator( if (animate) { animator.startDelay = delay - animator.duration = if (duration == -1L) { - DEFAULT_ANIMATION_DURATION - } else { - duration - } + animator.duration = + if (duration == -1L) { + DEFAULT_ANIMATION_DURATION + } else { + duration + } interpolator?.let { animator.interpolator = it } if (onAnimationEnd != null) { - val listener = object : AnimatorListenerAdapter() { - override fun onAnimationEnd(animation: Animator?) { - onAnimationEnd.run() - animator.removeListener(this) + val listener = + object : AnimatorListenerAdapter() { + override fun onAnimationEnd(animation: Animator?) { + onAnimationEnd.run() + animator.removeListener(this) + } + override fun onAnimationCancel(animation: Animator?) { + animator.removeListener(this) + } } - override fun onAnimationCancel(animation: Animator?) { - animator.removeListener(this) - } - } animator.addListener(listener) } animator.start() diff --git a/packages/SystemUI/animation/src/com/android/systemui/animation/TextInterpolator.kt b/packages/SystemUI/animation/src/com/android/systemui/animation/TextInterpolator.kt index 681e4d1fdd023..341784e262571 100644 --- a/packages/SystemUI/animation/src/com/android/systemui/animation/TextInterpolator.kt +++ b/packages/SystemUI/animation/src/com/android/systemui/animation/TextInterpolator.kt @@ -26,12 +26,8 @@ import android.util.MathUtils import com.android.internal.graphics.ColorUtils import java.lang.Math.max -/** - * Provide text style linear interpolation for plain text. - */ -class TextInterpolator( - layout: Layout -) { +/** Provide text style linear interpolation for plain text. */ +class TextInterpolator(layout: Layout) { /** * Returns base paint used for interpolation. @@ -64,12 +60,11 @@ class TextInterpolator( var baseFont: Font, var targetFont: Font ) { - val length: Int get() = end - start + val length: Int + get() = end - start } - /** - * A class represents text layout of a single run. - */ + /** A class represents text layout of a single run. */ private class Run( val glyphIds: IntArray, val baseX: FloatArray, // same length as glyphIds @@ -79,12 +74,8 @@ class TextInterpolator( val fontRuns: List ) - /** - * A class represents text layout of a single line. - */ - private class Line( - val runs: List - ) + /** A class represents text layout of a single line. */ + private class Line(val runs: List) private var lines = listOf() private val fontInterpolator = FontInterpolator() @@ -106,8 +97,8 @@ class TextInterpolator( /** * The layout used for drawing text. * - * Only non-styled text is supported. Even if the given layout is created from Spanned, the - * span information is not used. + * Only non-styled text is supported. Even if the given layout is created from Spanned, the span + * information is not used. * * The paint objects used for interpolation are not changed by this method call. * @@ -133,8 +124,8 @@ class TextInterpolator( /** * Recalculate internal text layout for interpolation. * - * Whenever the target paint is modified, call this method to recalculate internal - * text layout used for interpolation. + * Whenever the target paint is modified, call this method to recalculate internal text layout + * used for interpolation. */ fun onTargetPaintModified() { updatePositionsAndFonts(shapeText(layout, targetPaint), updateBase = false) @@ -143,8 +134,8 @@ class TextInterpolator( /** * Recalculate internal text layout for interpolation. * - * Whenever the base paint is modified, call this method to recalculate internal - * text layout used for interpolation. + * Whenever the base paint is modified, call this method to recalculate internal text layout + * used for interpolation. */ fun onBasePaintModified() { updatePositionsAndFonts(shapeText(layout, basePaint), updateBase = true) @@ -155,11 +146,11 @@ class TextInterpolator( * * The text interpolator does not calculate all the text position by text shaper due to * performance reasons. Instead, the text interpolator shape the start and end state and - * calculate text position of the middle state by linear interpolation. Due to this trick, - * the text positions of the middle state is likely different from the text shaper result. - * So, if you want to start animation from the middle state, you will see the glyph jumps due to - * this trick, i.e. the progress 0.5 of interpolation between weight 400 and 700 is different - * from text shape result of weight 550. + * calculate text position of the middle state by linear interpolation. Due to this trick, the + * text positions of the middle state is likely different from the text shaper result. So, if + * you want to start animation from the middle state, you will see the glyph jumps due to this + * trick, i.e. the progress 0.5 of interpolation between weight 400 and 700 is different from + * text shape result of weight 550. * * After calling this method, do not call onBasePaintModified() since it reshape the text and * update the base state. As in above notice, the text shaping result at current progress is @@ -171,8 +162,8 @@ class TextInterpolator( * animate weight from 200 to 400, then if you want to move back to 200 at the half of the * animation, it will look like * - * 
-     * 
+     * 
 
+     * ```
      *     val interp = TextInterpolator(layout)
      *
      *     // Interpolate between weight 200 to 400.
@@ -202,9 +193,8 @@ class TextInterpolator(
      *         // progress is 0.5
      *         animator.start()
      *     }
-     * 
-     * 

-     *
+     * ```
+     *
*/ fun rebase() { if (progress == 0f) { @@ -266,69 +256,73 @@ class TextInterpolator( } var maxRunLength = 0 - lines = baseLayout.zip(targetLayout) { baseLine, targetLine -> - val runs = baseLine.zip(targetLine) { base, target -> - - require(base.glyphCount() == target.glyphCount()) { - "Inconsistent glyph count at line ${lines.size}" - } - - val glyphCount = base.glyphCount() - - // Good to recycle the array if the existing array can hold the new layout result. - val glyphIds = IntArray(glyphCount) { - base.getGlyphId(it).also { baseGlyphId -> - require(baseGlyphId == target.getGlyphId(it)) { - "Inconsistent glyph ID at $it in line ${lines.size}" + lines = + baseLayout.zip(targetLayout) { baseLine, targetLine -> + val runs = + baseLine.zip(targetLine) { base, target -> + require(base.glyphCount() == target.glyphCount()) { + "Inconsistent glyph count at line ${lines.size}" } - } - } - val baseX = FloatArray(glyphCount) { base.getGlyphX(it) } - val baseY = FloatArray(glyphCount) { base.getGlyphY(it) } - val targetX = FloatArray(glyphCount) { target.getGlyphX(it) } - val targetY = FloatArray(glyphCount) { target.getGlyphY(it) } + val glyphCount = base.glyphCount() - // Calculate font runs - val fontRun = mutableListOf() - if (glyphCount != 0) { - var start = 0 - var baseFont = base.getFont(start) - var targetFont = target.getFont(start) - require(FontInterpolator.canInterpolate(baseFont, targetFont)) { - "Cannot interpolate font at $start ($baseFont vs $targetFont)" - } - - for (i in 1 until glyphCount) { - val nextBaseFont = base.getFont(i) - val nextTargetFont = target.getFont(i) - - if (baseFont !== nextBaseFont) { - require(targetFont !== nextTargetFont) { - "Base font has changed at $i but target font has not changed." + // Good to recycle the array if the existing array can hold the new layout + // result. + val glyphIds = + IntArray(glyphCount) { + base.getGlyphId(it).also { baseGlyphId -> + require(baseGlyphId == target.getGlyphId(it)) { + "Inconsistent glyph ID at $it in line ${lines.size}" + } + } } - // Font transition point. push run and reset context. - fontRun.add(FontRun(start, i, baseFont, targetFont)) - maxRunLength = max(maxRunLength, i - start) - baseFont = nextBaseFont - targetFont = nextTargetFont - start = i + + val baseX = FloatArray(glyphCount) { base.getGlyphX(it) } + val baseY = FloatArray(glyphCount) { base.getGlyphY(it) } + val targetX = FloatArray(glyphCount) { target.getGlyphX(it) } + val targetY = FloatArray(glyphCount) { target.getGlyphY(it) } + + // Calculate font runs + val fontRun = mutableListOf() + if (glyphCount != 0) { + var start = 0 + var baseFont = base.getFont(start) + var targetFont = target.getFont(start) require(FontInterpolator.canInterpolate(baseFont, targetFont)) { "Cannot interpolate font at $start ($baseFont vs $targetFont)" } - } else { // baseFont === nextBaseFont - require(targetFont === nextTargetFont) { - "Base font has not changed at $i but target font has changed." + + for (i in 1 until glyphCount) { + val nextBaseFont = base.getFont(i) + val nextTargetFont = target.getFont(i) + + if (baseFont !== nextBaseFont) { + require(targetFont !== nextTargetFont) { + "Base font has changed at $i but target font is unchanged." + } + // Font transition point. push run and reset context. + fontRun.add(FontRun(start, i, baseFont, targetFont)) + maxRunLength = max(maxRunLength, i - start) + baseFont = nextBaseFont + targetFont = nextTargetFont + start = i + require(FontInterpolator.canInterpolate(baseFont, targetFont)) { + "Cannot interpolate font at $start" + + " ($baseFont vs $targetFont)" + } + } else { // baseFont === nextBaseFont + require(targetFont === nextTargetFont) { + "Base font is unchanged at $i but target font has changed." + } + } } + fontRun.add(FontRun(start, glyphCount, baseFont, targetFont)) + maxRunLength = max(maxRunLength, glyphCount - start) } + Run(glyphIds, baseX, baseY, targetX, targetY, fontRun) } - fontRun.add(FontRun(start, glyphCount, baseFont, targetFont)) - maxRunLength = max(maxRunLength, glyphCount - start) - } - Run(glyphIds, baseX, baseY, targetX, targetY, fontRun) + Line(runs) } - Line(runs) - } // Update float array used for drawing. if (tmpPositionArray.size < maxRunLength * 2) { @@ -360,9 +354,9 @@ class TextInterpolator( if (glyphFilter == null) { for (i in run.start until run.end) { tmpPositionArray[arrayIndex++] = - MathUtils.lerp(line.baseX[i], line.targetX[i], progress) + MathUtils.lerp(line.baseX[i], line.targetX[i], progress) tmpPositionArray[arrayIndex++] = - MathUtils.lerp(line.baseY[i], line.targetY[i], progress) + MathUtils.lerp(line.baseY[i], line.targetY[i], progress) } c.drawGlyphs(line.glyphIds, run.start, tmpPositionArray, 0, run.length, font, paint) return @@ -391,13 +385,14 @@ class TextInterpolator( tmpPaintForGlyph.color = tmpGlyph.color c.drawGlyphs( - line.glyphIds, - prevStart, - tmpPositionArray, - 0, - i - prevStart, - font, - tmpPaintForGlyph) + line.glyphIds, + prevStart, + tmpPositionArray, + 0, + i - prevStart, + font, + tmpPaintForGlyph + ) prevStart = i arrayIndex = 0 } @@ -407,13 +402,14 @@ class TextInterpolator( } c.drawGlyphs( - line.glyphIds, - prevStart, - tmpPositionArray, - 0, - run.end - prevStart, - font, - tmpPaintForGlyph) + line.glyphIds, + prevStart, + tmpPositionArray, + 0, + run.end - prevStart, + font, + tmpPaintForGlyph + ) } private fun updatePositionsAndFonts( @@ -421,9 +417,7 @@ class TextInterpolator( updateBase: Boolean ) { // Update target positions with newly calculated text layout. - check(layoutResult.size == lines.size) { - "The new layout result has different line count." - } + check(layoutResult.size == lines.size) { "The new layout result has different line count." } lines.zip(layoutResult) { line, runs -> line.runs.zip(runs) { lineRun, newGlyphs -> @@ -439,7 +433,7 @@ class TextInterpolator( } require(newFont === newGlyphs.getFont(i)) { "The new layout has different font run." + - " $newFont vs ${newGlyphs.getFont(i)} at $i" + " $newFont vs ${newGlyphs.getFont(i)} at $i" } } @@ -447,7 +441,7 @@ class TextInterpolator( // check new font can be interpolatable with base font. require(FontInterpolator.canInterpolate(newFont, run.baseFont)) { "New font cannot be interpolated with existing font. $newFont," + - " ${run.baseFont}" + " ${run.baseFont}" } if (updateBase) { @@ -483,10 +477,7 @@ class TextInterpolator( } // Shape the text and stores the result to out argument. - private fun shapeText( - layout: Layout, - paint: TextPaint - ): List> { + private fun shapeText(layout: Layout, paint: TextPaint): List> { var text = StringBuilder() val out = mutableListOf>() for (lineNo in 0 until layout.lineCount) { // Shape all lines. @@ -500,10 +491,13 @@ class TextInterpolator( } val runs = mutableListOf() - TextShaper.shapeText(layout.text, lineStart, count, layout.textDirectionHeuristic, - paint) { _, _, glyphs, _ -> - runs.add(glyphs) - } + TextShaper.shapeText( + layout.text, + lineStart, + count, + layout.textDirectionHeuristic, + paint + ) { _, _, glyphs, _ -> runs.add(glyphs) } out.add(runs) if (lineNo > 0) { @@ -517,8 +511,8 @@ class TextInterpolator( } private fun Layout.getDrawOrigin(lineNo: Int) = - if (getParagraphDirection(lineNo) == Layout.DIR_LEFT_TO_RIGHT) { - getLineLeft(lineNo) - } else { - getLineRight(lineNo) - } + if (getParagraphDirection(lineNo) == Layout.DIR_LEFT_TO_RIGHT) { + getLineLeft(lineNo) + } else { + getLineRight(lineNo) + } diff --git a/packages/SystemUI/ktfmt_includes.txt b/packages/SystemUI/ktfmt_includes.txt index 6fe804bbb935e..1f00812780929 100644 --- a/packages/SystemUI/ktfmt_includes.txt +++ b/packages/SystemUI/ktfmt_includes.txt @@ -1,7 +1,5 @@ +packages/SystemUI --packages/SystemUI/animation/src/com/android/systemui/animation/FontInterpolator.kt -packages/SystemUI/animation/src/com/android/systemui/animation/TextAnimator.kt --packages/SystemUI/animation/src/com/android/systemui/animation/TextInterpolator.kt -packages/SystemUI/animation/src/com/android/systemui/animation/ViewHierarchyAnimator.kt -packages/SystemUI/checks/src/com/android/internal/systemui/lint/BindServiceViaContextDetector.kt -packages/SystemUI/checks/src/com/android/internal/systemui/lint/BroadcastSentViaContextDetector.kt