IssueTracker

With the change of lifecycle-common to KMP, we might be able to just move this into the right spot (since it'll mirror the same structure as lifecycle-runtime, which does work).

lifecycle-common even after conversion to KMP is still a jar. We do not want to change that to an AAR as that is a breaking change for consumers, so i dont think we can make it work this project.

Ah yeah good point.

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.