IssueTracker

The following release(s) address this bug.It is possible this bug has only been partially addressed:

• androidx.compose.material3:material3-adaptive-navigation-suite:1.0.0-alpha02
• androidx.compose.material3:material3-adaptive-navigation-suite-android:1.0.0-alpha02
• androidx.compose.material3:material3-adaptive-navigation-suite-desktop:1.0.0-alpha02

Is there an example somewhere of the new expanded and collapsed height parameters being used with dynamic font sizes? I've tried measuring the text, using onGloballyPositioned, etc, and nothing seems to quite work in both the collapsed and expanded states for all text sizes, especially if the increased font size makes the text wrap to a second line

The most simplistic approach I can think of is using the LocalConfiguration.current.fontScale.

@Composable
fun AppBarDynamicHeightSamples() {
    val scrollBehavior = TopAppBarDefaults.exitUntilCollapsedScrollBehavior()
    val expandedHeightRatio = LocalConfiguration.current.fontScale
    Scaffold(
        modifier = Modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
        topBar = {
            TopAppBar(
                title = {
                    Text("Title")
                },
                expandedHeight = TopAppBarDefaults.TopAppBarExpandedHeight * expandedHeightRatio,
                colors = TopAppBarDefaults.topAppBarColors(containerColor = Color.Green),
                scrollBehavior = scrollBehavior
            )
        },
        content = { ... }
        }
    )
}

But note that the docs indicate that: "Please do not use this to hardcode font size equations. The equation for font scaling is now non-linear;... Please use android. util. TypedValue. applyDimension(int, float, DisplayMetrics) or android. util. TypedValue. deriveDimension(int, float, DisplayMetrics) to convert between scaled font size dimensions and pixels.", which can also help here to get a better formula.

Hope that helps

Thank you for your response - unfortunately that approach only works in the most basic of circumstances (single line text). In the event that the text gets big enough to run onto two lines, or there's a subtitle, simply multiplying by the font scale is not sufficient.

Take the following as an example:

val heightRatio = LocalConfiguration.current.fontScale

MediumTopAppBar(
    modifier = modifier,
    title = {
        Column {
            Text(text = title)
            Text(text = subtitle)
        }
    },
    expandedHeight = TopAppBarDefaults.MediumAppBarExpandedHeight * heightRatio,
    collapsedHeight = TopAppBarDefaults.MediumAppBarCollapsedHeight * heightRatio,
    navigationIcon = /* back arrow */,
    scrollBehavior = TopAppBarDefaults.exitUntilCollapsedScrollBehavior()
)

The expanded height takes into account space for the collapsed height as well, so multiplying by the font scale doesn't produce an accurate result.

It seems to me that this should be something the TopAppBar handles on its own - I would expect the app bar to wrap its content in both the expanded and collapsed states. Right now the default behavior is to cut off the content if it doesn't fit, which makes it difficult to use an customize, but more importantly is a serious accessibility issue for when the font size is increased, even for single-line titles.

Is there a way to have the app bar support this natively such that it has a minimum height (likely just the current default values), and expands to wrap its content in the event that the content is too big? I imagine this could be done while still leaving the collapsedHeight and expandedHeight fields as is, so that the developer could hard-code that if they'd like to.

I would expect this component to support font accessibility by default, so I'd love to see that change if it's something that's possible.

The proposed solution is not valid. The height should never be fixed, it should always be auto-calculated based on the content. Otherwise, you will never comply with A11y and without traps or tricks that will cause you other problems in the long run.