☰
🔍
☰
🔍
20 May 2025
Androidify is a new sample app we built using the latest best practices for mobile apps. Previously, we covered all the different features of the app, from Gemini integration and CameraX functionality to adaptive layouts. In this post, we dive into the Jetpack Compose usage throughout the app, building upon our base knowledge of Compose to add delightful and expressive touches along the way!
Material 3 Expressive is an expansion of the Material 3 design system. It’s a set of new features, updated components, and design tactics for creating emotionally impactful UX.
It’s been released as part of the alpha version of the Material 3 artifact (androidx.compose.material3:material3:1.4.0-alpha10) and contains a wide range of new components you can use within your apps to build more personalized and delightful experiences. Learn more about Material 3 Expressive's component and theme updates for more engaging and user-friendly products.
In addition to the new component updates, Material 3 Expressive introduces a new motion physics system that's encompassed in the Material theme.
In Androidify, we’ve utilized Material 3 Expressive in a few different ways across the app. For example, we’ve explicitly opted-in to the new MaterialExpressiveTheme and chosen MotionScheme.expressive() (this is the default when using expressive) to add a bit of playfulness to the app:
@Composable fun AndroidifyTheme( content: @Composable () -> Unit, ) { val colorScheme = LightColorScheme MaterialExpressiveTheme( colorScheme = colorScheme, typography = Typography, shapes = shapes, motionScheme = MotionScheme.expressive(), content = { SharedTransitionLayout { CompositionLocalProvider(LocalSharedTransitionScope provides this) { content() } } }, ) }
Some of the new componentry is used throughout the app, including the HorizontalFloatingToolbar for the Prompt type selection:
The app also uses MaterialShapes in various locations, which are a preset list of shapes that allow for easy morphing between each other. For example, check out the cute cookie shape for the camera capture button:
Wherever possible, the app leverages the Material 3 Expressive MotionScheme to obtain a themed motion token, creating a consistent motion feeling throughout the app. For example, the scale animation on the camera button press is powered by defaultSpatialSpec(), a specification used for animations that move something across a screen (such as x,y or rotation, scale animations):
val interactionSource = remember { MutableInteractionSource() } val animationSpec = MaterialTheme.motionScheme.defaultSpatialSpec<Float>() Spacer( modifier .indication(interactionSource, ScaleIndicationNodeFactory(animationSpec)) .clip(MaterialShapes.Cookie9Sided.toShape()) .size(size) .drawWithCache { //.. etc }, )
The app uses shared element transitions between different screen states. Last year, we showcased how you can create shared elements in Jetpack Compose, and we’ve extended this in the Androidify sample to create a fun example. It combines the new Material 3 Expressive MaterialShapes, and performs a transition with a morphing shape animation:
To do this, we created a custom Modifier that takes in the target and resting shapes for the sharedBounds transition:
Posted by Rebecca Franks - Developer Relations Engineer
@Composable
fun Modifier.sharedBoundsRevealWithShapeMorph(
sharedContentState:
SharedTransitionScope.SharedContentState,
sharedTransitionScope: SharedTransitionScope =
LocalSharedTransitionScope.current,
animatedVisibilityScope: AnimatedVisibilityScope =
LocalNavAnimatedContentScope.current,
boundsTransform: BoundsTransform =
MaterialTheme.motionScheme.sharedElementTransitionSpec,
resizeMode: SharedTransitionScope.ResizeMode =
SharedTransitionScope.ResizeMode.RemeasureToBounds,
restingShape: RoundedPolygon = RoundedPolygon.rectangle().normalized(),
targetShape: RoundedPolygon = RoundedPolygon.circle().normalized(),
)
Then, we apply a custom OverlayClip to provide the morphing shape, by tying into the AnimatedVisibilityScope provided by the LocalNavAnimatedContentScope:
val animatedProgress = animatedVisibilityScope.transition.animateFloat(targetValueByState = targetValueByState) val morph = remember { Morph(restingShape, targetShape) } val morphClip = MorphOverlayClip(morph, { animatedProgress.value }) return this@sharedBoundsRevealWithShapeMorph .sharedBounds( sharedContentState = sharedContentState, animatedVisibilityScope = animatedVisibilityScope, boundsTransform = boundsTransform, resizeMode = resizeMode, clipInOverlayDuringTransition = morphClip, renderInOverlayDuringTransition = renderInOverlayDuringTransition, )
View the full code snippet for this Modifer on GitHub.
With the latest release of Jetpack Compose 1.8, we added the ability to create text composables that automatically adjust the font size to fit the container’s available size with the new autoSize parameter:
BasicText(text,
style = MaterialTheme.typography.titleLarge,
autoSize = TextAutoSize.StepBased(maxFontSize = 220.sp),
)
This is used front and center for the “Customize your own Android Bot” text:
This text composable is interesting because it needed to have the fun dancing Android bot in the middle of the text. To do this, we use InlineContent, which allows us to append a composable in the middle of the text composable itself:
@Composable private fun DancingBotHeadlineText(modifier: Modifier = Modifier) { Box(modifier = modifier) { val animatedBot = "animatedBot" val text = buildAnnotatedString { append(stringResource(R.string.customize)) // Attach "animatedBot" annotation on the placeholder appendInlineContent(animatedBot) append(stringResource(R.string.android_bot)) } var placeHolderSize by remember { mutableStateOf(220.sp) } val inlineContent = mapOf( Pair( animatedBot, InlineTextContent( Placeholder( width = placeHolderSize, height = placeHolderSize, placeholderVerticalAlign = PlaceholderVerticalAlign.TextCenter, ), ) { DancingBot( modifier = Modifier .padding(top = 32.dp) .fillMaxSize(), ) }, ), ) BasicText( text, modifier = Modifier .align(Alignment.Center) .padding(bottom = 64.dp, start = 16.dp, end = 16.dp), style = MaterialTheme.typography.titleLarge, autoSize = TextAutoSize.StepBased(maxFontSize = 220.sp), maxLines = 6, onTextLayout = { result -> placeHolderSize = result.layoutInput.style.fontSize * 3.5f }, inlineContent = inlineContent, ) } }
With Compose 1.8, a new modifier, Modifier.onLayoutRectChanged, was added. This modifier is a more performant version of onGloballyPositioned, and includes features such as debouncing and throttling to make it performant inside lazy layouts.
In Androidify, we’ve used this modifier for the color splash animation. It determines the position where the transition should start from, as we attach it to the “Let’s Go” button:
var buttonBounds by remember { mutableStateOf<RelativeLayoutBounds?>(null) } var showColorSplash by remember { mutableStateOf(false) } Box(modifier = Modifier.fillMaxSize()) { PrimaryButton( buttonText = "Let's Go", modifier = Modifier .align(Alignment.BottomCenter) .onLayoutRectChanged( callback = { bounds -> buttonBounds = bounds }, ), onClick = { showColorSplash = true }, ) }
We use these bounds as an indication of where to start the color splash animation from.
From fun marquee animations on the results screen, to animated gradient buttons for the AI-powered actions, to the path drawing animation for the loading screen, this app has many delightful touches for you to experience and learn from.
Check out the full codebase at github.com/android/androidify and learn more about the latest in Compose from using Material 3 Expressive, the new modifiers, auto-sizing text and of course a couple of delightful interactions!
Explore this announcement and all Google I/O 2025 updates on io.google starting May 22.
Android Developers
Google Play
