\n
![](\"https:\/\/blogger.googleusercontent.com\/img\/b\/R29vZ2xl\/AVvXsEhvmObDTm_UvKKZP8bDM_YVpknfPh2MBo1pZun6Vc_0CTOsoxvFAq0O_tIa33owHNckOXqKEGGf35C7PccmUFU9gA9VX7djih13zWISVNwdqAHY7waJ7tcWoZJUSuCwSnrLCmhQzNCr21e61IJ_8PLUzj6eKApPrxmK-cwMHrYp-iCbQ6XPyiLxIKvRZPU\/s1600\/Jetpack%20Adaptive%20Compose%20Metadata.png\")
<\/p>\nPosted by Rebecca Franks – Developer Relations Engineer<\/em><\/p>\n This blog post is part of our series: Adaptive Spotlight Week where we provide resources\u2014blog posts, videos, sample code, and more\u2014all designed to help you adapt your apps to phones, foldables, tablets, ChromeOS and even cars. You can read more in the overview of the Adaptive Spotlight Week<\/a>, which will be updated throughout the week.<\/i><\/p>\n We\u2019ve heard the news, creating adaptive layouts<\/a> in Jetpack Compose is easier than ever. As a declarative UI toolkit, Jetpack Compose is well suited for designing and implementing layouts that adjust themselves to render content differently across a variety of sizes. By using logic coupled with Window Size Classes<\/a>, Flow layouts<\/a>, movableContentOf<\/a> and LookaheadScope<\/a>, we can ensure fluid responsive layouts in Jetpack Compose.<\/p>\n Following the release of the JetLagged<\/a> sample at Google I\/O 2023, we decided to add more examples to it. Specifically, we wanted to demonstrate how Compose can be used to create a beautiful dashboard-like layout. This article shows how we\u2019ve achieved this.<\/p>\n <\/a> Using Flow layouts<\/a> ( FlowRow<\/span> and FlowColumn<\/span> ) make it much easier to implement responsive, reflowing layouts that respond to screen sizes and automatically flow content to a new line when the available space in a row or column is full.<\/p>\n In the JetLagged example, we use a FlowRow<\/span>, with a maxItemsInEachRow<\/span> set to 3. This ensures we maximize the space available for the dashboard, and place each individual card in a row or column where space is used wisely, and on mobile devices, we mostly have 1 card per row, only if the items are smaller are there two visible per row.<\/p>\n Some cards leverage Modifiers that don\u2019t specify an exact size, therefore allowing the cards to grow to fill the available width, for instance using Modifier.widthIn(max = 400.dp)<\/span>, or set a certain size, like Modifier.width(200.dp)<\/span>.<\/p>\n We could also leverage the weight modifier to divide up the remaining area of a row or column, check out the documentation on item weights<\/a> for more information.<\/p>\n <\/p>\n WindowSizeClasses<\/a> are useful for building up breakpoints in our UI for when elements should display differently. In JetLagged, we use the classes to know whether we should include cards in Columns or keep them flowing one after the other.<\/p>\n For example, if WindowWidthSizeClass.COMPACT<\/span>, we keep items in the same FlowRow<\/span>, where as if the layout it larger than compact, they are placed in a FlowColumn<\/span>, nested inside a FlowRow<\/span>:<\/p>\n From the above logic, the UI will appear in the following ways on different device sizes:<\/p>\n <\/a> Movable content allows you to save the contents of a Composable to move it around your layout hierarchy without losing state. It should be used for content that is perceived to be the same – just in a different location on screen.<\/p>\n Imagine this, you are moving house to a different city, and you pack a box with a clock inside of it. Opening the box in the new home, you\u2019d see that the time would still be ticking from where it left off. It might not be the correct time of your new timezone, but it will definitely have ticked on from where you left it. The contents inside the box don\u2019t reset their internal state when the box is moved around.<\/p>\n What if you could use the same concept in Compose to move items on screen without losing their internal state?<\/p>\n Take the following scenario into account: Define different Tile<\/span> composables that display an infinitely animating value between 0 and 100 over 5000ms.<\/p>\n <\/p>\n We then display them on screen using a Column Layout – showing the infinite animations as they go:<\/p>\n <\/image><\/p>\n But what If we wanted to lay the tiles differently, based on if the phone is in a different orientation (or different screen size), and we don\u2019t want the animation values to stop running? Something like the following:<\/p>\n This looks pretty standard, but running this on device – we can see that switching between the two layouts causes our animations to restart.<\/p>\n <\/a><\/image><\/p>\n This is the perfect case for movable content – it is the same Composables on screen, they are just in a different location. So how do we use it? We can just define our tiles in a movableContentOf<\/a><\/span> block, using remember<\/a><\/span> to ensure its saved across compositions:<\/p>\n Now instead of calling our composables again inside the Column<\/span> and Row<\/span> respectively, we call tiles()<\/span> instead.<\/p>\n This will then remember the nodes generated by those Composables and preserve the internal state that these composables currently have.<\/p>\n <\/a><\/image><\/p>\n We can now see that our animation state is remembered across the different compositions. Our clock in the box will now keep state when it’s moved around the world. <\/p>\n Using this concept, we can keep the animating bubble state of our cards, by placing the cards in movableContentOf<\/span>:<\/p>\n This allows the cards state to be remembered and the cards won’t be recomposed. This is evident when observing the bubbles in the background of the cards, on resizing the screen the bubble animation continues without restarting the animation.<\/p>\n <\/a><\/image><\/p>\n From the above example, we can see that state is maintained between changes in layout size (or layout itself), but the difference between the two layouts is a bit jarring. We\u2019d like this to animate between the two states without issue.<\/p>\n In the latest compose-bom-alpha<\/a> (2024.09.03), there is a new experimental custom Modifier, Modifier.animateBounds()<\/a><\/span>. The animateBounds<\/span> modifier requires a LookaheadScope<\/a><\/span>.<\/p>\n LookaheadScope<\/span> enables Compose to perform intermediate measurement passes of layout changes, notifying composables of the intermediate states between them. LookaheadScope<\/span> is also used for the new shared element APIs<\/a>, that you may have seen recently.<\/p>\n To use Modifier.animateBounds()<\/span>, we wrap the top-level FlowRow<\/span> in a LookaheadScope<\/span>, and then apply the animateBounds<\/span> modifier to each card. We can also customize how the animation runs, by specifying the boundsTransform<\/span> parameter to a custom spring spec:<\/p>\n Applying this to our layout, we can see the transition between the two states is more seamless without jarring interruptions.<\/p>\n <\/a><\/image><\/p>\n Applying this logic to our whole dashboard, when resizing our layout, you will see that we now have a fluid UI interaction throughout the whole screen.<\/p>\n <\/a><\/image><\/p>\n As you can see from this article, using Compose has enabled us to build a responsive dashboard-like layout by leveraging flow layouts, WindowSizeClasses<\/span>, movable content and LookaheadScope<\/span>. These concepts can also be used for your own layouts that may have items moving around in them too.<\/p>\n For more information on these different topics, be sure to check out the official documentation<\/a>, for the detailed changes to JetLagged, take a look at this pull request<\/a>.<\/p>\n<\/div>\n![](\"https:\/\/blogger.googleusercontent.com\/img\/b\/R29vZ2xl\/AVvXsEiq-xjyTG_ks5AfowEaHg8NFwpTVt0EqH59N_7RExbYOHp8WESDEmFbRFPB7kc3_tP0B7XGARTbDvX6woNwZgRtwX2xH8xJI0uq4w7T3b2JFOjzB3qfU6EZC-MpYSZ537orOmLoI5VY69Fc-h9XMiJ3MRe7rk66yTMcEdDxSWlrOY71cQ04-kxG-kFalms\/s1600\/Jetpack%20Adaptive%20Compose%20%281%29.png\")
<\/a><\/p>\n<\/div>\nUse FlowRow and FlowColumn to build layouts that respond to different screen sizes<\/h3>\n
FlowRow(\n modifier = Modifier.fillMaxSize(),\n horizontalArrangement = Arrangement.Center,\n verticalArrangement = Arrangement.Center,\n maxItemsInEachRow = 3<\/span>\n) {\n Box(modifier = Modifier.widthIn(max = 400.d<\/span>p))\n Box(modifier = Modifier.width(200.d<\/span>p))\n Box(modifier = Modifier.size(200.d<\/span>p))\n \/\/ etc <\/span>\n}\n<\/pre>\n<\/div>\nUse WindowSizeClasses to differentiate between devices<\/h3>\n
FlowRow(\n modifier = Modifier.fillMaxSize(),\n horizontalArrangement = Arrangement.Center,\n verticalArrangement = Arrangement.Center,\n maxItemsInEachRow = 3<\/span>\n ) {\n JetLaggedSleepGraphCard(uiState.value.sleepGraphData)\n if<\/span> (windowSizeClass == WindowWidthSizeClass.COMPACT) {\n AverageTimeInBedCard()\n AverageTimeAsleepCard()\n } else<\/span> {\n FlowColumn {\n AverageTimeInBedCard()\n AverageTimeAsleepCard()\n }\n }\n if<\/span> (windowSizeClass == WindowWidthSizeClass.COMPACT) {\n WellnessCard(uiState.value.wellnessData)\n HeartRateCard(uiState.value.heartRateData)\n } else<\/span> {\n FlowColumn {\n WellnessCard(uiState.value.wellnessData)\n HeartRateCard(uiState.value.heartRateData)\n }\n }\n }\n<\/pre>\n<\/div>\n<\/div>\nUse movableContentOf to maintain bits of UI state across screen resizes<\/h3>\n
@Composable\nfun<\/span> Tile1<\/span>() {\n val<\/span> repeatingAnimation = rememberInfiniteTransition()\n\n val<\/span> float<\/span> = repeatingAnimation.animateFloat(\n initialValue = 0f<\/span>,\n targetValue = 100f<\/span>,\n animationSpec = infiniteRepeatable(repeatMode = RepeatMode.Reverse,\n animation = tween(5000<\/span>))\n )\n Box(modifier = Modifier\n .size(100.d<\/span>p)\n .background(purple, RoundedCornerShape(8.d<\/span>p))){\n Text(\"Tile 1 ${float.value.roundToInt()}\"<\/span>,\n modifier = Modifier.align(Alignment.Center))\n }\n}\n<\/pre>\n<\/div>\n<\/div>\n@Composable\nfun<\/span> WithoutMovableContentDemo<\/span>() {\n val<\/span> mode = remember {\n mutableStateOf(Mode.Portrait)\n }\n if<\/span> (mode.value == Mode.Landscape) {\n Row {\n Tile1()\n Tile2()\n }\n } else<\/span> {\n Column {\n Tile1()\n Tile2()\n }\n }\n}\n<\/pre>\n<\/div>\n<\/div>\nval<\/span> tiles = remember {\n movableContentOf {\n Tile1()\n Tile2()\n }\n }\n<\/pre>\n<\/div>\n@Composable\nfun<\/span> MovableContentDemo<\/span>() {\n val<\/span> mode = remember {\n mutableStateOf(Mode.Portrait)\n }\n val<\/span> tiles = remember {\n movableContentOf {\n Tile1()\n Tile2()\n }\n }\n Box(modifier = Modifier.fillMaxSize()) {\n if<\/span> (mode.value == Mode.Landscape) {\n Row {\n tiles()\n }\n } else<\/span> {\n Column {\n tiles()\n }\n }\n\n Button(onClick = {\n if<\/span> (mode.value == Mode.Portrait) {\n mode.value = Mode.Landscape\n } else<\/span> {\n mode.value = Mode.Portrait\n }\n }, modifier = Modifier.align(Alignment.BottomCenter)) {\n Text(\"Change layout\"<\/span>)\n }\n }\n}\n<\/pre>\n<\/div>\n<\/div>\nLanguage<\/b>
<\/div>\nUse Modifier.animateBounds() to have fluid animations between different window sizes<\/h3>\n
val<\/span> boundsTransform = { _ : Rect, _: Rect ->\n spring(\n dampingRatio = Spring.DampingRatioNoBouncy,\n stiffness = Spring.StiffnessMedium,\n visibilityThreshold = Rect.VisibilityThreshold\n )\n}\n\n\nLookaheadScope {\n val<\/span> animateBoundsModifier = Modifier.animateBounds(\n lookaheadScope = this<\/span>@LookaheadScope,\n boundsTransform = boundsTransform)\n val<\/span> timeSleepSummaryCards = remember {\n movableContentOf {\n AverageTimeInBedCard(animateBoundsModifier)\n AverageTimeAsleepCard(animateBoundsModifier)\n }\n }\n FlowRow(\n modifier = Modifier\n .fillMaxSize()\n .windowInsetsPadding(insets),\n horizontalArrangement = Arrangement.Center,\n verticalArrangement = Arrangement.Center,\n maxItemsInEachRow = 3<\/span>\n ) {\n JetLaggedSleepGraphCard(uiState.value.sleepGraphData, animateBoundsModifier.widthIn(max = 600.d<\/span>p))\n if<\/span> (windowSizeClass == WindowWidthSizeClass.Compact) {\n timeSleepSummaryCards()\n } else<\/span> {\n FlowColumn {\n timeSleepSummaryCards()\n }\n }\n\n\n FlowColumn {\n WellnessCard(\n wellnessData = uiState.value.wellnessData,\n modifier = animateBoundsModifier\n .widthIn(max = 400.d<\/span>p)\n .heightIn(min = 200.d<\/span>p)\n )\n HeartRateCard(\n modifier = animateBoundsModifier\n .widthIn(max = 400.d<\/span>p, min = 200.d<\/span>p),\n uiState.value.heartRateData\n )\n }\n }\n}\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\nSummary<\/h3>\n