From stock trading apps that show changing prices to ride-sharing widgets that frequently update a car’s location, developers need to deliver solutions that are able to refresh data in real-time. Levi9 mobile tech leads Radu Grigoraș and Tiberiu Grădinariu explain why reactive programming is the more elegant approach to address this challenge in Android and iOS.
Reactive programming focuses on automatic displays of changes in the data flow, such as the price change for a stock. Instead of providing detailed step-by-step instructions, developers specify how the application should respond to events and changes in data. “This makes applications more responsive, more resistant to faults, and easier to understand”, says Radu Grigoraș, Levi9 mobile tech lead. As the logic for asynchronous operations is all in one place, the resulting code is usually cleaner and easier to maintain.
How to use LiveData and Kotlin Flows for Android
For Android, reactive programming is supported by two essential components: LiveData and Kotlin Flows.
Part of Android’s Jetpack Lifecycle library, LiveData makes data management easier as it is aware when the screen is active and visible to the user, and when it’s not. “LiveData is like a box in which we store the data”, explains Radu. “The box is hooked up to the lifecycle, so it cleans up after itself if the component it’s bound to is destroyed. The components observing its contents only get updated on what is in the box if they are in an active lifecycle state.” When a component returns from an inactive to an active state, or if configuration changes occur (like device rotation), it immediately gets the latest box content.
When compared to traditional observer patterns, LiveData offers several important advantages. First, it automatically manages the unsubscription of observers when the UI is destroyed, which helps to prevent memory leaks effectively. Secondly, it keeps data consistent by always delivering the most up-to-date data. Lastly, LiveData handles configuration changes, such as screen rotations, and updates the UI accordingly. See more details here.
Image source: medium.com
Kotlin Flows, which are part of the Kotlin Coroutines library, help manage asynchronous data streams in a more flexible manner than traditional methods. A Flow can be imagined like a pipe that carries data and produces several values one after the other. It relies on a producer-consumer model, where a source (the producer) generates data, which can be then modified by intermediate operators and then received and used at the destination by the consumer.
One example is a repository that generates a list of items based on specific conditions. These items can then be filtered or combined by operators and then they reach a ViewModel, which prepares the data for display in the UI.
Flows are also bidirectional. Not only can data move from the data layer to the UI, but also the user interactions in the UI can generate data that flows back to other parts of the application. “A repository can be a producer that emits new data to be consumed by the UI, or the UI can be a producer that emits input events from the user.”
Image source: developer.android.com
Reactive programming can make use of the advantages of both LiveData and Kotlin Flows by combining them. Flows can be used for complex data transformations and asynchronous operations, while LiveData can be used for updating the UI, since it is lifecycle aware.
Image source: medium.com
How to use the Combine framework and SwiftUI for iOS
Similar to Android applications, the software operating on Apple devices also gets regular updates and needs to show this information in the user interface. On iOS, reactive programming relies on two essential pieces: the Combine framework and SwiftUI.
“Once you get the data, you can apply operators so that you finally get the data in the exact format you want”, explains Tiberiu Grădinariu, Levi9 mobile tech lead. “You map them, you decode them, you remove null values if you want, you handle errors in whatever way you want.”
Then, the data is very easily integrated with SwiftUI. “There is a concept called property wrappers and there are annotations like @Published. In the background, it will create a publisher, but everything is very hidden, and with an annotation, it practically writes much more code for you and already makes a publisher available.” When a value changes, the UI is notified and it updates or redraws the appropriate views.
Handling changing data flows is also made easier by Apple’s SwiftUI Framework. Rather than using storyboard files or writing XML for layouts, developers create their views in code by using composable “View” modules. SwiftUI manages re-rendering automatically: when a Published value changes, SwiftUI re-evaluates the related view hierarchy. Compared to traditional programming and UI design, the codebase in SwiftUI is more clear, easier to understand and easier to maintain.
Tiberiu lays out an example: “In SwiftUI, a list can show dynamic data by just binding to a collection of items in a ViewModel. When the corresponding items change based on fresh data or from new user input, SwiftUI automatically updates the list, drawing only the elements that require refreshing.”
In a project at Levi9 for a truck company, the team led by Tiberiu had to develop an app that displayed a list of timers, combining data from two distinct API sources: timers already configured in the truck and pending timer update requests. The team chose to use Combine to create separate Publishers for each data source, and then merge them in a single Flow, which triggered updates in the SwitUI view.
Both Tiberiu and Radu highlight the fact that one of the main advantages of using reactive programming, either on Android or on iOS, is having an underlying code that is easier to understand and maintain. Traditional programming can still do the job, but the downside is a code that is more complex, more scattered and difficult to understand because of this. Instead, reactive programming focuses on data streams and managing changes in a single location. This helps developers write clean, testable code that can easily adapt to new requirements when needed.
In this article:
