Google revolutionized the way we wrote UIs in Android with the introduction of Compose. As a result, there was a learning curve for developers, and not everyone started on the same page. That’s exactly what happened at SuperShare. So, how do we keep code under control? Jetpack Compose has existed in developer preview for quite some time and has now become alpha, but it hasn’t reached a steady release yet and is still underneath a heavy development process by the people at Google.
Here are 10 ways that will save you some time viewing numerous YouTube presentations and going through numerous documentation and articles, but we have done all jobs for you! So, without any further ado, let dive straight into the top reasons to learn and master Jetpack Compose UI right now. We have done research in brief and covered ten highly compelling reasons in this blog why Jetpack Compose is now the best platform to get started with. So, without further ado, here are the 10 reasons to learn and master Jetpack Compose UI:
Creating The First Compose Project
It’s very simple to set up your first Jetpack Compose project. Simply download Android Studio’s latest Canary version and choose a new Compose project from the list of available Android projects. You’ll start with a simple “Hello world!” text that you can customize. Yes, it’s simple, but getting your first Compose app up and going in 5 minutes isn’t terrible.
Multiple Resources To Learn Jetpack Compose
So you’ve got the first project up and running in AS, but you must be wondering what to do? Fortunately, there are currently a plethora of courses and workshops available to assist you in getting up to speed. Begin by following the official Android Jetpack Compose beginner’s tutorial. The tutorial will help you in walking through the fundamentals of layout elements, including Row and Column, and how to add text and images to the Compose UI. Once you’ve learned and mastered the fundamentals, check out the Android course, which covers codelabs and videos to assist the individual in learning Compose. Of course, this is just the beginning; once you begin scouring the web for Jetpack Compose resources, you’ll find plenty more.
Compose UIs Are Well Supported In Android Studio
You can make Compose apps with the newest Canary version of Android Studio. To make things even easier, the Canary versions include a fantastic preview feature that lets you see how your UI will appear on a device before releasing it. Utilizing the @Preview annotation, the individual can notice what the UI will scrutinize in the preview window. Since the @Preview supports passing arguments from annotation, the individual can even see considerable previews at once delivering various variations, such as how the UI would glance for dark and light themes or on different types and sizes of devices.
However, if you want to see how exactly the UI looks on an emulator or device, you may deploy just the preview – not the entire program. Last but not least, Android Studio has an interactive mode. This enables you to interact with the AS preview’s UI. You can type or click on UI components in interactive mode, and they will respond as if they were installed on a device. Check out the official documentation for additional details on previews in Android Studio.
Compose Comes With A Complete Set Of Components
Compose includes a fully-fledged collection of material layouts and components that can be used to construct rich and complicated UIs, despite the fact that it is currently in development. There are several ways to build your UI, from simple layout components like Columns and Rows to the more complicated Constraint layout.
We have it all, from simple Text and Button composable to more complicated TextFields that allow you to design forms for your UI. If you still need some ideas for what you can do with Compose, the Jetpack Compose sample apps include some amazing examples. There’s not much you can’t do with Compose that you can’t do with current views, as you can see here.
No More Recycler Views
We started with ListViews in Android and then moved on to RecyclerViews, which were considered a significant improvement when dealing with enormous amounts of data that needed to be presented on a screen. Views, as the name implies, are reused on the screen to present enormous amounts of data. This is an excellent technique to make the most of views while keeping the UI responsive. While RecyclerViews did an excellent job, they were not without flaws.
It took some time to get used to them. It was necessary to understand concepts like adapters and view models, as well as write a substantial amount of boilerplate code to implement these components. Horizontal carousels or Vertical lists that can recycle their composable components in each item are exceedingly simple to construct with Compose; only two components are required: LazyRow and LazyColumn. To create a lazy row, simply follow these steps:
As you can see, this is a lot less complicated than using a recycler view. All we’re doing here is executing LazyListScope’s items function and giving it a list of automobiles. The CarComposable is then passed each car, which is subsequently added to the row.
Compose Works Effectively With Legacy Code
If you want to try out Compose in an existing project, the last thing you want to think about is redesigning the entire UI, which might be a big job. Compose, fortunately, allows you to integrate existing code in a variety of ways. To begin, you can quickly migrate an entire screen to Compose by executing the setContent function in your Fragment or Activity and giving your composable:
Now you can use Compose to create the entire UI for this screen. This is useful if you want to utilize Compose to move a feature in your app. But what if you don’t want the entire screen to be migrated? Compose, fortunately, also allows you to add a composable to an existing view hierarchy. We may accomplish this by including a ComposeView in our XML. Simply add the Compose view to the XML as follows:
We can now call setContent on this view in the Activity to apply our composable to this region of our UI:
Finally, in your composable hierarchy, you may want to include a View. When we need to use views that don’t have a composable equivalent, such as a map view, this can come in handy. To provide these old views in your composable UI, you can utilize the AndroidView composable.
It’s relatively simple to experiment with new UI implementations in Compose by employing these strategies. The options for integrating Compose provide you the flexibility to try it in the way that works best for you, whether it’s simply a little area of your UI or an entire screen.
No More XML
If you’re updating an existing app, you’ll probably have to work with XML for a lot longer, but Compose doesn’t require it. While XML is functional, there are a number of disadvantages to utilizing it. To begin with, the fact that we must move back and forth between XML and Kotlin while developing apps is inconvenient. Constructing the UI and the rest structure of the project in Kotlin makes things handled a lot less complicated; remember that there are several disadvantages to adopting XML.
Because XML is not a programming language, it necessitates a number of concessions when used. Although Android Studio can help give the correct ideas that are specific to a given view, it is still easy to add irrelevant and superfluous attributes to XML attributes and layout parameters. We have the concept of range and types because composable is written in Kotlin. This means, that we can’t call a function on a Modifier if the function isn’t applicable to the scope from which it’s being called. When we need to understand and identify what functions are accessible for a UI component, having suitable scopes and types can be very useful.
XML layouts have also been claimed to produce a misleading separation of concerns. We can have a lot of coupling between ViewModels and layouts when we use XML, especially when we use function calls like findViewByID, which require detailed information about the UI hierarchy produced from the XML.
Last but not least, XML layouts are entirely static. When you have dynamic logic in the user interface, XML layouts start to resemble the layout at one point in time. To update the layout at runtime, we’ll need code that hooks into and modifies the XML’s initial layout. As a result, we end up building glue code that allows us to update the state of the UI. A lot of bugs can be introduced this way. Compose enables you to build UI code that defines a consistent user interface across all states.
Because the logic for dynamically modifying the UI as a response to state changes is intrinsically part of composable functions, the initial UI state and the logic that controls the dynamic UI state are no longer artificially separated. We don’t have to create any of the sophisticated error-prone code to connect our view models to our UI because Compose employs the notion of a single source of truth for the state, therefore we’ve decreased coupling in our code.
Simpler State Management
You’re already well on your way to simplifying state management in your app if you’re using ViewModels and techniques like MVI, but if you start utilizing Compose, you’ll be able to go even further. We have a branch of UI widgets with Android’s view hierarchy. To apply our state to this hierarchy, we must first gain a reference to every individual view using operations like findViewById, and then alter the UI using methods like setText or setImage. This state-to-UI wiring code can be time-consuming and error-prone to write, and it has the potential to induce flaws in the code.
We employ an altogether new declarative component-based approach in Jetpack Compose. This implies we define our user interface as a set of functions that turn data into a user interface. The mechanism to handle the state within the functions is included within the functions themselves. The UI hierarchies are automatically resampled to reflect the new UI state as the underlying data changes.
Compose offers interfaces like State to help with the connecting of the state to the UI and the managing of the unidirectional data flow. To use a LiveData in compose, we can use the observeAsState extension function to build a State object. Any changes to the LiveData will cause a recomposition of the Compose tree, and any changes to the state will be handled from each composable once we send this State to it.
Originally, Jetpack Compose was just meant to be used for creating Android UIs, however, there have been recent efforts to broaden the platform support. JetBrains has initiated an open-source project to create a desktop version of Compose. They’ve also been working on a web-based demo project in recent months. As a developer, this means you can now apply your Compose knowledge to a variety of platforms. Who knows what platforms will be supported in the not-too-distant future? If you already know Kotlin, Compose is the UI framework to use because the learning curve is low and the number of potential applications is rising rapidly.
Future Of Jetpack Compose
Declarative UI frameworks are a proven way to develop uncomplicated, effortless UI code with high coherence and low coupling, and a number of competing for successful technologies already do it. It makes UI code simpler and easier to test while also making it easier, faster, and more enjoyable to write. Compose represents a significant investment of time, effort, and resources by Google. They are primarily concerned with improving Compose, rather than maintaining the current View-based system. Other firms, such as JetBrains, are also working on versions for desktop and potentially Web platforms.
Jetpack Compose looks like a valuable technology with its comfort for employment and potential to contact platforms beyond Android. Notably, a regular beta release doesn’t glance too far away. By investing effort and time now, individuals will be able to strike the floor running. When the beta arrives, you’ll create a production-ready application that will be easier and faster to develop support, and manage.