A response to a change in events is important to create optimal user interfaces. In many cases, users don’t enter correct inputs and the UI has to change when the user changes preferences or location.
To keep the user interface up-to-date, Jetpack Compose, a UI framework, has come up with a technique called recomposition. Recomposition updates the UI when the user input changes.
For example, the text will be displayed on the screen as a result of recomposition, which is triggered when the user presses on the button:
@Composable
fun ButtonCounter(clicks: Int, onClick: () -> Unit) {
Button(onClick = onClick) {
Text("Recomposition will occur when the button gets clicked and test is displayed on the screen")
}
}
In this article, you will learn more about Jetpack Composition and what recomposition is:
The Replay is a weekly newsletter for dev and engineering leaders.
Delivered once a week, it's your curated guide to the most important conversations around frontend dev, emerging AI tools, and the state of modern software.
Every developer wants to create apps that stand out. However, with so many apps competing for attention, it can be tricky to come up with something new and exciting. This is where frameworks like Android Jetpack Compose come in!
Android Jetpack is a collection of modular libraries that can make your apps smarter, more efficient, and more engaging. These libraries are built on top of the new Android Architecture Components, so they’re designed to work together to make it easier to build high-quality apps.
Jetpack Compose contains several APIs that help make your app faster, smarter, and more engaging for your users — all while reducing the amount of code you need to write.
Jetpack is helpful when it comes to creating user interfaces. It is a toolkit that provides you with functions that build native UI. It gives you:
Here are the benefits of using Jetpack Compose:
The first and most important benefit of using Android Jetpack Compose is that it reduces boilerplate code. A lot of the code you write in the first few weeks of app development is repetitive.
There are a few ways in which the Jetpack Compose toolkit can help reduce boilerplate code. It uses pre-written code that you can drop into your project by configuring it. You can also use a visual tool to build your app. One example is the visual view editor tool. This tool allows you to create app layouts visually, as opposed to manually writing code to do so. This is helpful if you’re not very familiar with Android layouts.
Android Jetpack comes with many code samples and APIs that are designed to make it easier to write less code while still producing high-quality apps. These APIs also make it easier to deal with common issues like managing state and managing network connections. They also make it easier to create apps that take advantage of the latest Android innovations.
Jetpack Compose has a flexible and adaptive layout that makes it possible for you to build Android apps across different devices with different compatibilities.
Jetpack Compose Wear provides developers with UI tools and features used to build apps for smart watches while Jetpack Compose Mobile provides UI tools for building mobile application. Jetpack Compose Wear and Jetpack Compose Mobile are similar with only a few differences. This means that you will use most of the knowledge and code you used to build mobile apps to build Wear OS applications.
In Jetpack Compose, a composable is a UI function. A group of composables and the way they relate to each is called a composition. When the composition structure and relations change, the process is called recomposition.
An example of recomposition is when a user enters a wrong input through the UI and Jetpack Compose responds by adding a sad animation or prompting the user to reset their password. Before recomposition, there was the invalidate() method.
Recomposition is important because it eliminates the need to call all functions whenever the input changes. The state variable is used to trigger recomposition. Recomposition is essential in Jetpack Compose because Kotlin files are prioritized over XML files.
Many Android developers compare the recomposition process to a donut to simplify how it works; a donut has a hole in the center, which is seen as the scope. This scope is used to show how recomposition will leave out functions that are not in the scope.
Also, recomposition is not executed in any particular order or hierarchy. Here is an example of a composable that will enter a recomposition stage when the user changes the model of the car:
Learn more →@Composable
fun CarSelector(
model: String,
names: List<String>,
onNameClicked: (String) -> Unit
) {
Column {
Text(model, style = MaterialTheme.typography.h5)
Divider()
}
}
A composable has the following stages:
This lifecycle is less complex when compared to the activity lifecycle. A composable can be called by one or more methods many times. This will cause multiple instances to be created in a composition. The instances of the composable will be sorted and organized using the call site. If the composable is called multiple times from the same call time, it will be hard for Jetpack Compose to sort the calls.
Jetpack uses a data structure called a gap buffer, which stores data effectively and improves performance to handle recompositions. During recomposition, composables that were not called during the first composition can also be called and those that were called during the first composition will only change if the state has changed. Composables are called in any order during recomposition.
Changing the whole activity consumes more resources and battery percentage. That’s why it is important to re-render composables that have only changed state.
Recomposition in Jetpack Compose focuses on updating elements that have changed. It is able to do this because it keeps track of the composable state. Recomposition will be triggered when the stored state changes.
Sometimes, many components have to be changed during recomposition. To keep up, Jetpack Compose runs recomposition in parallel to optimize performance.
Recomposition was meant to keep the UI up to date when the user input changed. So, if the user changes the input while the app is going through recomposition, compose will cancel the ongoing recomposition and start a new recomposition that will adjust the UI following the new user input.
When updating the composable, do not use a setter. Instead, call the composable with new data. In addition, it is important to carry out heavy tasks such as reading preferences when using composables.
Jetpack Compose has surely improved developers’ worlds by eliminating the need for XML files and bringing in more Kotlin files. This means that developers do not have to spend more time mastering XML and creating spaghetti code, which is hard to debug.
Moreover, features such as lazy layouts and recomposition greatly improve Android apps. Recomposition has to be understood to be able to build responsive applications. Users don’t want to know why your application performance is lagging. Therefore, it is important to use Jetpack Compose to improve the performance and feel of the app.
LogRocket is an Android monitoring solution that helps you reproduce issues instantly, prioritize bugs, and understand performance in your Android apps.
LogRocket's Galileo AI watches sessions for you, instantly identifying and explaining user struggles with automated monitoring of your entire product experience.
LogRocket also helps you increase conversion rates and product usage by showing you exactly how users are interacting with your app. LogRocket's product analytics features surface the reasons why users don't complete a particular flow or don't adopt a new feature.
Start proactively monitoring your Android apps — try LogRocket for free.
VSCode has architectural performance limits. Compare six fast, native code editors built for lower resource usage.
Build a React infinite scroll gallery with TanStack Pacer. Learn debouncing, throttling, batching, and rate limiting without RxJS complexity.
Discover what’s new in The Replay, LogRocket’s newsletter for dev and engineering leaders, in the January 7th issue.
useEffectEventJack Herrington breaks down how React’s new useEffectEvent Hook stabilizes behavior, simplifies timers, and enables predictable abstractions.
Would you be interested in joining LogRocket's developer community?
Join LogRocket’s Content Advisory Board. You’ll help inform the type of content we create and get access to exclusive meetups, social accreditation, and swag.
Sign up now
One Reply to "Understanding recomposition in Jetpack Compose"
It looks like recomposition solves a problem that Reactive JS frameworks solved a long time ago.
Isn’t reactivity a strong selling point of Flutter? Too bad they don’t have one, good oficial State Management solution like Vue.