IssueTracker

This is probably closely related to b/230756508.

#comment2 Yeah kind of, except that here I only need the selected line to come into view, not the whole TextField (which is already always resized to be on top of the keyboard by setting imePadding()).

I tried wrapping the text in a Box with verticalScroll Modifier, and then using the results from onTextLayout in addition to current selection (through TextFieldValue) to determine current line offset and scroll to it on every change (tracked using onSizeChanged), but I guess I messed up something in there, it didn't work very well.

(btw, onTextLayout returns Float values for offsets, while the scroll state's scrollBy() function accepts Integers. I only round these Floats to Integers, could that be the problem?)

Anyways I honestly got tired of trying to hack around it. I'd love to know if there's any workaround for this in the moment, and I hope you fix this soon.

It's kind of a crazy convoluted workaround, but this seems to work very well for me:

@Composable
fun AppScreen() {
    val coroutineScope = rememberCoroutineScope()

    var value by remember { mutableStateOf(TextFieldValue()) }
    val scrollState = rememberScrollState()
    var height by remember { mutableStateOf(0) }
    var layoutResult: TextLayoutResult? by remember { mutableStateOf(null) }

    BasicTextField(
        value = value,
        onValueChange = { value = it },
        decorationBox = {
            Box(modifier = Modifier.verticalScroll(scrollState)) {
                it()
            }
        },
        onTextLayout = { layoutResult = it },
        textStyle = LocalTextStyle.current.copy(color = MaterialTheme.colors.onBackground),
        cursorBrush = SolidColor(MaterialTheme.colors.secondary),
        modifier = Modifier
            .fillMaxSize()
            .onSizeChanged {
                coroutineScope.launch {
                    val cursorInView = value.isCursorInView(
                        layoutResult = layoutResult!!,
                        height = it.height.toFloat(),
                        scrollValue = scrollState.value.toFloat()
                    )
                    if (!cursorInView && height > it.height) {
                        scrollState.scrollBy(
                            value.calculateRequiredSizeScroll(
                                layoutResult = layoutResult!!,
                                oldHeight = height.toFloat(),
                                newHeight = it.height.toFloat(),
                                scrollValue = scrollState.value.toFloat()
                            )
                        )
                    }
                    height = it.height
                }
            }
    )

    LaunchedEffect(value.selection) {
        val cursorInView = value.isCursorInView(
            layoutResult = layoutResult!!,
            height = height.toFloat(),
            scrollValue = scrollState.value.toFloat()
        )
        if (!cursorInView) {
            scrollState.scrollBy(
                value.calculateRequiredSelectionScroll(
                    layoutResult = layoutResult!!,
                    height = height.toFloat(),
                    scrollValue = scrollState.value.toFloat()
                )
            )
        }
    }
}

fun TextFieldValue.isCursorInView(
    layoutResult: TextLayoutResult,
    height: Float,
    scrollValue: Float
) = with(layoutResult) {
    val currentLine = try {
        getLineForOffset(selection.min)
    } catch (ex: IllegalArgumentException) {
        System.err.println("Corrected Wrong Offset!")
        getLineForOffset(selection.min - 1)
    }
    val lineBottom = getLineBottom(currentLine)
    val lineTop = getLineTop(currentLine)
    lineBottom <= height + scrollValue && lineTop >= scrollValue
}

fun TextFieldValue.calculateRequiredSelectionScroll(
    layoutResult: TextLayoutResult,
    height: Float,
    scrollValue: Float
) = with(layoutResult) {
    val currentLine = try {
        getLineForOffset(selection.min)
    } catch (ex: IllegalArgumentException) {
        System.err.println("Corrected Wrong Offset!")
        getLineForOffset(selection.min - 1)
    }
    val lineTop = getLineTop(currentLine)
    val lineBottom = getLineBottom(currentLine)
    if (lineTop < scrollValue) -(scrollValue - lineTop)
    else if (lineBottom > height + scrollValue) lineBottom - (height + scrollValue)
    else 0f
}

fun TextFieldValue.calculateRequiredSizeScroll(
    layoutResult: TextLayoutResult,
    oldHeight: Float,
    newHeight: Float,
    scrollValue: Float
) = with(layoutResult) {
    val currentLine = try {
        getLineForOffset(selection.min)
    } catch (ex: IllegalArgumentException) {
        System.err.println("Corrected Wrong Offset!")
        getLineForOffset(selection.min - 1)
    }
    val sizeDifference = oldHeight - newHeight
    val lineBottom = getLineBottom(currentLine)
    if (lineBottom in (newHeight + scrollValue)..(oldHeight + scrollValue))
        sizeDifference - (oldHeight - (lineBottom - scrollValue))
    else 0f
}

I basically wrapped the inner text field Composable in a Box with the verticalScroll modifier, and then using these parameters: TextLayoutResult (to get the current line position), scroll value, and height; all to determine if the cursor is currently visible on the screen, and if it's not, calculate the minimal amount of scroll needed to get it back on the screen, both when the TextField size changes (which is the goal), and also when navigating around the text or editing it (this works fine in Compose by default, but using a scroll modifier breaks it, so I have to manually scroll to follow the cursor).

It works perfectly well for me, with a small annoyance being that sometimes (when typing really fast) the selection I get from the TextFieldValue is higher than what the TextLayoutResult expects, causing a crash. I worked around this by wrapping it in a try/catch, and decrementing the selection value by 1 to get it working. Pretty hacky and lazy, but it works flawlessly now, and those catched exceptions don't seem to affect performance in any noticeable way.

Yet having something like this implemented properly would still be far better than these hacky and convoluted workarounds.