Skip to main content

54 posts tagged with "Kotlin"

View All Tags

LiveData: An Observable Data Holder for Android Apps

Published: · Last updated: · 5 min read
Don Peter
Cofounder and CTO, Appxiom

LiveData is an observable data holder class in Android as part of androidx package. It notifies the UI about data changes, but unlike its regular counterparts, it's lifecycle-aware. This means that it adheres to the lifecycles of activities, fragments, and other app components, ensuring that the data updates only reach the active observers, thus preventing memory leaks.

Consider a use-case where the app displays a screen with the latest blog posts. With LiveData, you,

  • Fetch the blog posts data from database or API call and set it to a MutableLiveData instance.

  • Create an Observer object in your activity/fragment to update the UI.

  • Observe the LiveData object using observe().

Whenever the blog post data changes (due to network calls, etc.), only the active activity/fragment receives the update. If it's in the background, it'll automatically receive the latest data when it resumes. No more manual lifecycle handling or data redundancy.

Working with LiveData​

Following steps will help you get started with implementing a LiveData instance in a Kotlin based android app using MVVM architecture. Here we are using LiveData to update the UI when the data changes at the source.

  • Create a LiveData instance: In MVVM architecture, data is fetched in a ViewModel class. Create a LiveData instance in your ViewModel class.

  • Create an Observer object: Define the observer, listen to LiveData and update the UI based on data changes.

  • Attach the Observer: Use observe() with the relevant LifecycleOwner to connect the Observer to the LiveData object.

Defining LiveData in a ViewModel class (MVVM architecture)​

class UserViewModel : ViewModel() 
// MutableLiveData to hold post data
private val _posts = MutableLiveData<List<Post>>()
val posts: LiveData<List<Post>>
get() = _posts
// Fetch posts from a repository (replace with your implementation)
fun fetchPosts() {
//This will be a function call to repository class to fetch data
val dummyPosts = listOf(
Post(1, "Title 1", "Content 1"),
Post(2, "Title 2", "Content 2")
)
_posts.postValue(dummyPosts) // Update LiveData with fetched posts from a worker thread.

}

}
  • We define a MutableLiveData called _posts to hold the list of Post objects.

  • We expose a public posts LiveData that other components can observe.

  • The fetchPosts() method simulates fetching posts from a repository and updates the _posts value using postValue().

Observing LiveData​

class UserPostsActivity : AppCompatActivity() {
private val model: UserViewModel by viewModels()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)

// Update your UI with the list of posts
val postObserver = Observer<List<Post>> { posts ->
recyclerView.adapter = PostAdapter(posts) // Update your UI with the list of posts
}

// Observe the posts LiveData with UserPostActivity as the lifecycleowner.
model.posts.observe(this, postObserver)

//fetch the post data.
model.fetchPosts()
}
}
  • We get a reference to the UserViewModel.

  • We define an Observer that receives the list of Post objects when the posts LiveData changes.

  • In onCreate(), we observe the posts LiveData using observe() and the current LifecycleOwner (UserViewModel).

  • When new data arrives, the postObserver updates the UI, e.g., by setting the adapter for a RecyclerView with the list of posts.

This is a basic example that demonstrates how LiveData can simplify data management and improve responsiveness of the UI in a Kotlin based Android app. Remember to adapt it to your specific data and UI needs.

*Update LiveData objects using ****setValue() ****from the main thread and postValue() from a worker thread. *

Benefits of using LiveData in MVVM​

  • Separation of concerns: ViewModel manages data and updates LiveData, while the activity/fragment handles UI.

  • Lifecycle awareness: Only active components receive data updates, preventing crashes and unnecessary calculations.

  • Single source of truth: posts LiveData acts as the central source for post data, ensuring consistency across the UI.

  • Simplified UI updates: Observer handles data changes and updates the UI automatically.

Using MediatorLiveData​

MediatorLiveData is a special type of LiveData in Android, combining data from multiple LiveData sources and creating a single unified information. 

It's useful when you need to:

  • Merge data from multiple sources: Imagine displaying comments and reactions on a post. You'd have separate LiveData objects for both, and MediatorLiveData can combine them into a single "post details" feed.

  • Respond to complex data conditions: You can define custom logic based on values from different sources. For example, show a "New" badge on a post only if both comments and reactions have updates.

  • Simplify data access: Instead of observing multiple sources, you just observe the MediatorLiveData, making your work flow cleaner and more centralized.

Common Scenarios to use LiveData​

  • Use LiveData with Room's observable queries to keep your UI in sync with the database.

  • Combine LiveData with Kotlin coroutines for asynchronous data handling especially when making API calls.

  • Leverage MediatorLiveData to merge multiple LiveData sources for unified data access.

LiveData is a powerful tool that simplifies data management, improves UI responsiveness and help avoid memory related issues like leaks.

Understanding Flow in Kotlin

Published: · Last updated: · 4 min read
Don Peter
Cofounder and CTO, Appxiom

Kotlin, a statically-typed, modern programming language, has introduced a powerful asynchronous programming concept called Flow. Flow simplifies asynchronous programming in Kotlin, making it more efficient and expressive.

In this blog post, we'll delve into what Flow is, how to use it, and provide practical examples in the context of Android app development. We'll explore how to send internal notifications to different modules within an Android application using Kotlin Flow.

What is Flow in Kotlin?​

Flow is a new asynchronous stream processing library introduced in Kotlin, specifically designed to handle streams of data asynchronously and in a non-blocking way. It's built on top of Kotlin's coroutines and allows you to work with sequences of values as they become available.

Key features of Flow:​

  • Asynchronous: Flow is designed for asynchronous operations and is perfect for use cases where you want to handle data asynchronously without blocking the main thread.

  • Non-blocking: Flow works seamlessly with Kotlin's coroutines, which means it is non-blocking and doesn't freeze your app while processing data.

  • Backpressure: Flow can handle backpressure, allowing you to control the flow of data between the producer and consumer, preventing overloading of resources.

  • Composability: Flow can be easily combined, transformed, and modified, making it a versatile tool for stream processing.

How to use Flow in Kotlin?​

To use Flow in your Kotlin application, follow these steps:

1. Import the necessary dependencies:​

To use Flow in an Android app, you need to include the Kotlin coroutines library in your project.

You can add it to your app-level build.gradle file:

implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:x.x.x" // Use the latest version

2. Create a Flow:​

You can create a Flow using the following code, providing the values you want to emit.

For example:

fun fetchUserData(): Flow<User> = flow {
// Fetch user data asynchronously
val user = api.fetchUser()
emit(user)
}

3. Collect data from a Flow:​

To consume data from a Flow, you can use the collect extension function. This allows you to receive emitted values and handle them:

viewModelScope.launch {
fetchUserData().collect { user ->
// Handle the user data
}
}

4. Transform and combine Flows:​

You can use various operators on Flow to transform, filter, and combine multiple Flows. Some common operators include map, filter, zip, and merge.

val transformedFlow = fetchUserData()
.map { user -> user.name }

Now that you understand the basics of using Flow, let's explore a practical example in an Android app.

Sending Internal Notifications in an Android App​

In Android app development, you often need to communicate between different modules or components within your app. Using Flow, you can send internal notifications from one module to another without tightly coupling them. Here's how you can achieve this,

Create a Notification Flow:​

Define a Flow that represents the notifications you want to send. For example, let's create a simple Flow for sending notifications of new messages:

object MessageNotificationManager {
private val notificationFlow = MutableSharedFlow<Message>()

fun sendNotification(message: Message) {
viewModelScope.launch {
notificationFlow.emit(message)
}
}

fun getNotificationFlow(): Flow<Message> = notificationFlow
}

In this example, MessageNotificationManager provides methods to send notifications and get the Flow to receive notifications.

Subscribe to the Notification Flow:​

In the module that needs to receive notifications, subscribe to the Flow.

class ChatFragment : Fragment() {
// ...

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)

MessageNotificationManager.getNotificationFlow()
.onEach { message ->
// Handle the new message notification
}
.launchIn(viewLifecycleOwner.lifecycleScope)
}
}

In this example, ChatFragment listens to the notification Flow using onEach and processes incoming messages.

Sending Notifications:​

In the module where you want to send notifications, call the sendNotification method.

val newMessage = Message("Hello, world!")
MessageNotificationManager.sendNotification(newMessage)

By using Flow to send and receive internal notifications, you decouple different parts of your Android app, making it more modular and maintainable.

Use Cases for Flow in Android Apps​

Flow is a powerful tool for handling asynchronous and non-blocking operations in Android apps. Here are some common use cases for Flow:

  • Data fetching and processing: Use Flow to fetch data from network requests, databases, or other sources asynchronously.

  • Real-time updates: Implement real-time features in your app, such as chat applications or live notifications, using Flow to handle data updates.

  • User interface updates: Update UI components when data changes, ensuring a smooth and responsive user experience.

  • Event handling: Manage and process events, such as button clicks, gestures, or sensor data, using Flow to handle events as they occur.

​

Conclusion​

In Android app development, Flow allows for efficient communication between different modules and components, making your code more modular and maintainable. By following the steps outlined in this blog post and considering the practical examples, you can effectively incorporate Flow into your Kotlin-based Android applications.

Get Started with Glide Kotlin Library for Android

Published: · Last updated: · 3 min read
Don Peter
Cofounder and CTO, Appxiom

Glide is an image loading library for Android that is known for its speed and efficiency. It is an open-source library that is maintained by Google and is used by many popular apps, such as Twitter, Facebook, and Amazon.

Advantages of using Glide​

There are many reasons why you might want to use Glide in your Android app. Here are a few:

  • Performance: Glide is one of the fastest image loading libraries available for Android. It is able to load images quickly and efficiently, even on large or complex images.

  • Memory efficiency: Glide is also very memory-efficient. It uses a variety of techniques to reduce the memory usage of your app, such as image caching and image recycling.

  • Flexibility: Glide is very flexible and can be used to load images from a variety of sources, including local storage, network resources, and even other image loading libraries.

  • Ease of use: Glide is easy to use and integrate into your Android app. It provides a simple API that makes it easy to get started with loading images.

Integrating Glide with an Android Kotlin project​

To integrate Glide with your Android Kotlin project, you will need to follow these steps:

  • Add the Glide dependency to your project's build.gradle file.
// Add the Glide dependency to your project's build.gradle file.
dependencies {
implementation 'com.github.bumptech.glide:glide:x.x.x'
}
  • Create a Glide object in your activity or fragment.
import com.bumptech.glide.Glide
import com.bumptech.glide.request.RequestOptions


Glide.with(this)
.load(R.drawable.your_image) // Replace with your image resource or URL
.into(imageView)
  • Use the Glide object to load images into your app.
// Use the Glide object to load images into your app.
Glide.with(this).load("https://example.com/image.png").into(imageView)

Top features of Glide​

Glide provides a variety of features that make it a powerful and versatile image loading library. Here are a few of the most notable features:

  • Image caching: Glide caches images in memory and on disk to improve performance and reduce network traffic.

  • Image decoding: Glide can decode images from a variety of formats, including JPEG, PNG, GIF, and WebP.

  • Image transformations: Glide can perform a variety of image transformations, such as cropping, scaling, and rotating.

Glide.with(this)
.load(R.drawable.your_image)
.apply(RequestOptions.circleCropTransform()) // Circular transformation
.into(imageView)
  • Image placeholders: Glide can display placeholder images while images are loading.
Glide.with(this)
.load(R.drawable.your_image)
.placeholder(R.drawable.placeholder_image)
.into(imageView)
  • Error handling: Glide provides robust error handling to ensure that images are always displayed correctly, even if there is an error loading the image.
Glide.with(this)
.load(R.drawable.your_image)
.error(R.drawable.error_image)
.into(imageView)

​

Glide is a powerful and versatile image loading library for Android applications. It simplifies the process of loading and displaying images, offers extensive customization options, and handles caching efficiently. By following the steps outlined in this blog, you can quickly integrate Glide into your Kotlin Android app and provide a smoother image loading experience for your users.

CoroutineWorker: The Kotlin-Friendly Way to Run Asynchronous Tasks in Android

Published: · Last updated: · 4 min read
Don Peter
Cofounder and CTO, Appxiom

CoroutineWorker is a Kotlin-specific class in Android WorkManager that allows you to run asynchronous tasks in the background. It is a wrapper around the Worker class, and it provides a number of benefits, including:

  • Support for Kotlin Coroutines: CoroutineWorker uses Kotlin Coroutines to run asynchronous tasks, which makes your code more concise and expressive.

  • Automatic handling of stoppages and cancellation: CoroutineWorker automatically handles stoppages and cancellation, so you don't have to worry about manually managing these states.

  • Better performance: CoroutineWorker can often perform better than the Worker class because it uses Kotlin Coroutines to manage its state.

  • To take advantage of the latest Android features: CoroutineWorker is a newer class than the Worker class, and it supports some of the latest Android features, such as Kotlin Flow.

Implementing CoroutineWorker​

To use CoroutineWorker, you first need to create a subclass of the CoroutineWorker class. In your subclass, you need to implement the doWork() method. This method is where you will write your asynchronous code.

Here is a simple example of a CoroutineWorker subclass:

class MyCoroutineWorker : CoroutineWorker() {

override suspend fun doWork(): Result {
// Perform your asynchronous task here.

return Result.success()
}
}

Once you have created your CoroutineWorker subclass, you can schedule it to run using the WorkManager class.

Here is an example of how to schedule a CoroutineWorker to run:

val work = OneTimeWorkRequestBuilder<MyCoroutineWorker>()
.build()

WorkManager.getInstance(context).enqueue(work)

Scheduling Tasks with CoroutineWorker​

You can do this by using the PeriodicWorkRequestBuilder class. This class allows you to create a WorkRequest that will be executed periodically at a specified interval.

Here is an example of how to schedule a task to run periodically with CoroutineWorker:

val work = PeriodicWorkRequestBuilder<MyCoroutineWorker>(
repeatInterval = Duration.ofHours(1)
).build()

WorkManager.getInstance(context).enqueue(work)

This code will schedule a CoroutineWorker to run every hour. The CoroutineWorker will be executed in the background, and it will be able to access all of the same resources as a regular CoroutineWorker.

You can also schedule tasks with CoroutineWorker to run only once. To do this, you can use the OneTimeWorkRequestBuilder class. This class allows you to create a WorkRequest that will be executed once and then discarded.

When to use CoroutineWorker​

You should use CoroutineWorker whenever you need to run an asynchronous task in the background. This includes tasks such as:

  • Downloading data from the internet

  • Uploading data to the cloud

  • Performing database queries

  • Processing images

  • Sending notifications

CoroutineWorker is a good choice for these types of tasks because it is easy to use, efficient, and reliable.

Limitations of CoroutineWorker​

Here are some cases where you should not use CoroutineWorker:

  • If you need to run a task that requires a lot of CPU or memory resources. CoroutineWorker is designed for running lightweight background tasks. If you need to run a task that requires a lot of resources, you should use a different approach, such as starting a service or using a foreground process.

  • If you need to run a task that needs to be able to interact with the UI. CoroutineWorker runs in the background, so it cannot interact with the UI directly. If you need to run a task that needs to be able to interact with the UI, you should use a different approach, such as using a worker thread or posting a message to the main thread.

  • If you need to run a task that is critical to the user experience. CoroutineWorker does not guarantee that tasks will be executed in a timely manner. If you need to run a task that is critical to the user experience, you should use a different approach, such as using a service or using a foreground process.

Overall, CoroutineWorker is a good choice for running lightweight background tasks in Android apps. However, it is important to be aware of its limitations and to use it in the appropriate scenarios.

What Are the Best Practices in Kotlin to Avoid Crashes in Android Apps

Published: · Last updated: · 4 min read
Appxiom Team
Mobile App Performance Experts

In the world of Android app development, crashes are an unfortunate reality. No matter how well you write your code, there's always a chance that something unexpected will happen on a user's device, leading to a crash. These crashes can result in a poor user experience, negative reviews, and lost revenue. To build robust Android apps, it's crucial to not only prevent crashes but also monitor and report them when they occur.

In this blog post, we'll explore how to avoid crashes in Android apps using Kotlin and how to report crashes using Appxiom, a powerful APM tool.

Avoiding Crashes​

1. Null Safety with Kotlin​

Kotlin, as a modern programming language, brings a significant advantage to Android development - null safety. Null pointer exceptions (NPEs) are one of the most common causes of app crashes. Kotlin's null safety features, such as nullable types and safe calls, help you prevent NPEs at compile time.

Here's an example of how to use nullable types:

var name: String? = null // Declare a nullable String
name?.length // Safe call: returns null if 'name' is null

By using nullable types and safe calls, you can catch potential null references early in the development process.

2. Exception Handling​

While you can't always prevent exceptions, you can handle them gracefully to avoid app crashes. Use try-catch blocks to catch exceptions and provide a fallback or error message to the user.

For example:

try {
// Code that might throw an exception
} catch (e: Exception) {
// Handle the exception, e.g., log it or display an error message
}

By handling exceptions properly, you can prevent crashes and provide a better user experience.

3. Defensive Programming​

Adopt defensive programming practices by validating inputs, using assertions, and adding proper checks throughout your code. For instance, when accessing an array or list, ensure that you're within the bounds to avoid index out of bounds exceptions.

val list = listOf(1, 2, 3)
if (index >= 0 && index < list.size) {
val item = list[index]
// Use 'item' safely
} else {
// Handle the out-of-bounds condition
}

4. Robust API Calls​

When making network requests or interacting with external services, always assume that the network may fail or the data may be invalid. Implement retry mechanisms, timeouts, and data validation to handle unexpected scenarios gracefully.

Reporting Crashes with Appxiom​

Even with the best preventative measures, crashes may still occur. When they do, it's essential to gather detailed information about the crash to diagnose and fix the issue. Appxiom is a powerful tool for crash reporting and analysis.

1. Integrating Appxiom into Your App​

To get started, sign up for a Appxiom account. Then, add the Appxiom SDK to your Android project. You can do this by adding the following dependency to your app's build.gradle file:

dependencies {
implementation 'com.appxiom:appxiomcore:x.x.x'
}

Initialize Appxiom in your app's Application class:

import android.app.Application

class MyApplication : Application() {
override fun onCreate() {
super.onCreate()
Ax.init(this, appKey, platformKey)
}
}

​

2. Capturing and Reporting Crashes​

Appxiom automatically captures crashes and unhandled exceptions in your app. When a crash occurs, it collects valuable information, including the stack trace, device details, and user actions leading up to the crash.

You can also manually report non-fatal errors and exceptions using the following code:

try {
// Code that might throw a non-fatal exception
} catch (e: Exception) {
Ax.reportException(this, e, Severity.MAJOR)
}

For more on how to use Appxiom to detect crashes and other issues like memory leak and frame rate issues, check the Appxiom documentation at https://docs.appxiom.com.

​

3. Analyzing Crash Reports​

Once crashes are reported to Appxiom, you can log in to your Appxiom dashboard to view and analyze crash reports. Appxiom provides detailed insights into the root cause of crashes, enabling you to prioritize and fix issues quickly. You can see stack traces, device information, and the activity trail of the user that led to the crash.

Conclusion​

Building crash-resilient Android apps is a critical aspect of delivering a positive user experience. By following best practices in Kotlin for avoiding crashes and integrating crash reporting and analysis tools like Appxiom, you can significantly reduce the impact of crashes on your app and ensure that your users have a smooth and trouble-free experience.

Remember that continuous monitoring and improvement are essential for maintaining the reliability of your Android app.

How to Avoid Memory Leaks in Jetpack Compose

Published: · Last updated: · 4 min read
Appxiom Team
Mobile App Performance Experts

Jetpack Compose is a modern Android UI toolkit introduced by Google, designed to simplify UI development and create more efficient and performant apps. While it offers numerous advantages, like a declarative UI syntax and increased developer productivity, it's not immune to memory leaks.

Memory leaks in Android can lead to sluggish performance and even app crashes. In this blog post, we'll explore the possibilities of causing memory leaks in Jetpack Compose and common reasons behind them. We'll also provide code examples and discuss strategies to prevent and fix these issues.

Understanding Memory Leaks​

Before diving into Jetpack Compose-specific issues, let's briefly understand what a memory leak is. A memory leak occurs when objects that are no longer needed are not released from memory, causing a gradual increase in memory consumption over time. In Android, this is typically caused by retaining references to objects that should be garbage collected.

How to Avoid Memory Leaks in Jetpack Compose​

1. Lambda Expressions and Captured Variables​

Jetpack Compose heavily relies on lambda expressions and function literals. When these lambdas capture references to objects, they can unintentionally keep those objects in memory longer than necessary. This often happens when lambdas capture references to ViewModels or other long-lived objects.

@Composable
fun MyComposable(viewModel: MyViewModel) {
// This lambda captures a reference to viewModel
Button(onClick = { viewModel.doSomething() }) {
Text("Click me")
}
}

In this example, the lambda passed to Button captures a reference to the viewModel parameter. If MyComposable gets recomposed, a new instance of the lambda will be created, but it still captures the same viewModel reference. If the old MyComposable instance is no longer in use, the captured viewModel reference will keep it from being garbage collected, potentially causing a memory leak.

To avoid this, you can use the remember function to ensure that the lambda captures a stable reference:

@Composable
fun MyComposable(viewModel: MyViewModel) {
val viewModelState by remember { viewModel.state }

Button(onClick = { viewModelState.doSomething() }) {
Text("Click me")
}
}

Here, remember is used to cache the value of viewModel.state. This ensures that the lambda inside Button captures a stable reference to viewModelState. As a result, even if MyComposable is recomposed, it won't create unnecessary new references to viewModel, reducing the risk of memory leaks.

2. Composable Functions and State​

Composables are functions that can rebuild when their inputs change. If you're not careful, unnecessary recompositions can lead to memory leaks. Composable functions that create and hold onto state objects, especially those with a long lifecycle, can cause memory leaks.

@Composable
fun MyComposable() {
val context = LocalContext.current
val database = Room.databaseBuilder(context, MyDatabase::class.java, "my-database").build()

// ...
}

To mitigate this, prefer creating and closing resources within a DisposableEffect:

@Composable
fun MyComposable() {
val context = LocalContext.current

DisposableEffect(Unit) {
val database = Room.databaseBuilder(context, MyDatabase::class.java, "my-database").build()
onDispose {
database.close()
}
}

// ...
}

​

3. Forgetting to Dispose of Observers​

Jetpack Compose's LiveData and State are commonly used for observing and updating UI. However, not removing observers correctly can result in memory leaks. When a Composable is removed from the UI hierarchy, you should ensure that it no longer observes any LiveData or State.

@Composable
fun MyComposable(viewModel: MyViewModel) {
val data = viewModel.myLiveData.observeAsState()

// ...
}

To address this, use the DisposableEffect to automatically remove observers when the Composable is no longer needed:

@Composable
fun MyComposable(viewModel: MyViewModel) {
DisposableEffect(viewModel) {
val data = viewModel.myLiveData.observeAsState()
onDispose {
// Remove observers or do necessary cleanup here
}
}

// ...
}

Conclusion​

Jetpack Compose is a powerful tool for building modern Android user interfaces. However, like any technology, it's essential to be aware of potential pitfalls, especially regarding memory management.

By understanding the common causes of memory leaks and following best practices, you can create efficient and performant Compose-based apps that delight your users.

Integrating Google Maps in Jetpack Compose Android Apps

Published: · Last updated: · 4 min read
Appxiom Team
Mobile App Performance Experts

Are you looking to add Google Maps integration to your Jetpack Compose Android app and display a moving vehicle on the map?

You're in the right place!

In this step-by-step guide, we'll walk you through the process of setting up Google Maps in your Android app using Jetpack Compose and adding a dynamic moving vehicle marker.

Prerequisites​

Before we dive into the implementation, make sure you have the following prerequisites in place:

  • Android Studio Arctic Fox: Ensure you have the latest version of Android Studio installed.

  • Google Maps Project: Create a Google Maps project in Android Studio using the "Empty Compose Activity" template. This template automatically includes the necessary dependencies for Jetpack Compose.

  • Google Maps API Key: You'll need a Google Maps API key for your project.

Now, let's get started with the integration:

Step 1: Set Up the Android Project​

  • Open Android Studio and create a new Jetpack Compose project.

  • In the build.gradle (Project) file, add the Google Maven repository:

allprojects {
repositories {
// other repositories

google()
}
}

In the build.gradle (app) file, add the dependencies for Jetpack Compose, Google Maps, and Permissions:

android {
// ...

defaultConfig {
// ...

// Add the following line
resValue "string", "google_maps_api_key", "{YOUR_API_KEY}"
}

// ...
}

dependencies {
// ...

// Google Maps

implementation "com.google.android.gms:play-services-maps:18.1.0"
implementation "com.google.maps.android:maps-ktx:3.2.1"

// Permissions
implementation "com.permissionx.guolindev:permissionx:1.7.0"
}

Replace {YOUR_API_KEY} with your actual Google Maps API key.

Step 2: Request Location Permissions​

In your Compose activity or fragment, request location permissions from the user using PermissionX or any other permission library of your choice.

import com.permissionx.guolindev.PermissionX

// Inside your Composable function
PermissionX.init(this@YourActivity)
.permissions(Manifest.permission.ACCESS_FINE_LOCATION)
.request { granted, _, _ ->
if (granted) {
// User granted location permission
} else {
// Handle permission denied
}
}

Step 3: Create a Map Composable​

Now, let's create a Composable function to display the Google Map.

import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.viewinterop.AndroidView
import com.google.android.gms.maps.CameraUpdateFactory
import com.google.android.gms.maps.GoogleMap
import com.google.android.gms.maps.MapView
import com.google.android.gms.maps.model.LatLng
import com.google.android.gms.maps.model.MarkerOptions

@Composable
fun MapView() {
val mapView = rememberMapViewWithLifecycle()

AndroidView(
modifier = Modifier.fillMaxSize(),
factory = { context ->
mapView.apply {
// Initialize the MapView
onCreate(null)
getMapAsync { googleMap ->
// Set up Google Map settings here
val initialLocation = LatLng(37.7749, -122.4194) // Default location (San Francisco)
googleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(initialLocation, 12f))

// Add a marker for the vehicle
val vehicleLocation = LatLng(37.7749, -122.4194) // Example vehicle location
val vehicleMarker = MarkerOptions().position(vehicleLocation).title("Vehicle")
googleMap.addMarker(vehicleMarker)
}
}
}
)
}

Replace the default and example coordinates with the desired starting location for your map and the initial vehicle position.

Step 4: Animate the Vehicle​

To animate the vehicle, you'll need to update its position periodically. You can use Handler or a timer for this purpose. Here's a simplified example of how to animate the vehicle:

import android.os.Handler
import androidx.compose.runtime.*

@Composable
fun MapWithAnimatedVehicle() {
val mapView = rememberMapViewWithLifecycle()
var vehicleLocation by remember { mutableStateOf(LatLng(37.7749, -122.4194)) }

AndroidView(
modifier = Modifier.fillMaxSize(),
factory = { context ->
mapView.apply {
// Initialize the MapView
onCreate(null)
getMapAsync { googleMap ->
// Set up Google Map settings here
googleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(vehicleLocation, 12f))

// Add a marker for the vehicle
val vehicleMarker = MarkerOptions().position(vehicleLocation).title("Vehicle")
googleMap.addMarker(vehicleMarker)

// Animate the vehicle's movement
val handler = Handler()
val runnable = object : Runnable {
override fun run() {
// Update the vehicle's position (e.g., simulate movement)
vehicleLocation = LatLng(
vehicleLocation.latitude + 0.001,
vehicleLocation.longitude + 0.001
)
googleMap.animateCamera(
CameraUpdateFactory.newLatLng(vehicleLocation)
)
handler.postDelayed(this, 1000) // Update every 1 second
}
}
handler.post(runnable)
}
}
}
)
}

This code sets up a simple animation that moves the vehicle marker by a small amount every second. You can customize this animation to fit your specific use case.

Step 5: Display the Map in Your UI​

Finally, you can use the MapView or MapWithAnimatedVehicle Composable functions within your Compose UI hierarchy to display the map. For example:

@Composable
fun YourMapScreen() {
Column {
// Other Composables and UI elements
MapWithAnimatedVehicle()
// Other Composables and UI elements
}
}

That's it! You've successfully integrated Google Maps into your Jetpack Compose Android app and animated a moving vehicle marker on the map.

Conclusion​

In this blog post, we've covered the basics of integrating Google Maps into your Jetpack Compose Android app and added a dynamic moving marker. You can further enhance this example by integrating location tracking, route rendering, and more, depending on your project requirements.

I hope this guide was helpful in getting you started with Google Maps in Jetpack Compose. If you have any questions or need further assistance, please don't hesitate to ask.

Happy coding!

Common Mistakes While Using Jetpack Compose

Published: · Last updated: · 4 min read
Appxiom Team
Mobile App Performance Experts

Jetpack Compose has revolutionized the way we build user interfaces for Android applications. With its declarative syntax and efficient UI updates, it offers a fresh approach to UI development. However, like any technology, using Jetpack Compose effectively requires a solid understanding of its principles and potential pitfalls.

In this blog, we'll explore some common mistakes developers might make when working with Jetpack Compose and how to avoid them.

Mistake 1: Incorrect Usage of Modifier Order​

Modifiers in Jetpack Compose are used to apply various transformations and styling to UI elements. However, the order in which you apply these modifiers matters. For example, consider the following code:

Text(
text = "Hello, World!",
modifier = Modifier
.padding(16.dp)
.background(Color.Blue)
)

In this code, the padding modifier is applied before the background modifier. This means the background color might not be applied as expected because the padding could cover it up. To fix this, reverse the order of the modifiers:

Text(
text = "Hello, World!",
modifier = Modifier
.background(Color.Blue)
.padding(16.dp)
)

Always make sure to carefully order your modifiers based on the effect you want to achieve.

Mistake 2: Excessive Re-Composition​

One of the key advantages of Jetpack Compose is its ability to automatically handle UI updates through recomposition. However, excessive recomposition can lead to performance issues. Avoid unnecessary recomposition by ensuring that only the parts of the UI that actually need to be updated are recomposed.

Avoid using functions with side effects, such as network requests or database queries, directly within a composable function. Instead, use the remember and derivedStateOf functions to manage state and perform these operations outside the composable scope.

val data by remember { mutableStateOf(fetchData()) }

Mistake 3: Misusing State Management in Jetpack Compose​

Jetpack Compose provides several options for managing state, such as mutableStateOf, remember, and viewModel. Choosing the right state management approach for your use case is crucial.

Using mutableStateOf inappropriately can lead to unexpected behavior. For instance, avoid using mutableStateOf for complex objects like lists. Instead, use the state parameter of the LazyColumn or LazyRow composables.

LazyColumn(
state = rememberLazyListState(),
content = { /* items here */ }
)

For more advanced scenarios, consider using the viewModel and stateFlow combination, which provides a solid architecture for managing state across different parts of your application.

Mistake 4: Ignoring Composable Constraints​

Composables in Jetpack Compose are designed to be flexible and responsive to layout constraints. Ignoring these constraints can lead to UI elements overflowing or not being displayed correctly.

When working with layouts like Column or Row, ensure that you specify the modifier correctly to ensure proper spacing and alignment. Additionally, use the weight modifier to distribute available space proportionally among child elements.

Column(
modifier = Modifier.fillMaxHeight(),
verticalArrangement = Arrangement.SpaceBetween
) {
Text("Top Text")
Text("Bottom Text")
}

​

Mistake 5: Inefficient List Handling​

Working with lists in Jetpack Compose is quite different from traditional Android views. Mistakes can arise from using the wrong composables or inefficiently handling list updates.

Prefer using LazyColumn and LazyRow for lists, as they load only the visible items, resulting in better performance for larger lists. Use the items parameter of LazyColumn to efficiently render dynamic lists:

LazyColumn {
items(itemsList) { item ->
Text(text = item)
}
}

When updating lists, avoid using the += or -= operators with mutable lists. Instead, use the appropriate list modification functions to ensure proper recomposition:

val updatedList = currentList.toMutableList()
updatedList.add(newItem)

​

Conclusion​

Jetpack Compose is an exciting technology that simplifies UI development for Android applications. However, avoiding common mistakes is essential for a smooth development experience and optimal performance. By understanding and addressing the issues outlined in this guide, you can make the most out of Jetpack Compose and create stunning, efficient user interfaces for your Android apps.

Remember, learning from mistakes is part of the development journey. Happy coding with Jetpack Compose!

Happy Coding!

Note: The code snippets provided in this blog are for illustrative purposes and might not represent complete working examples. Always refer to the official Jetpack Compose documentation for accurate and up-to-date information.

Using MonkeyRunner to Test Android Apps

Published: · Last updated: · 3 min read
Appxiom Team
Mobile App Performance Experts

Mobile app testing is an essential part of the development process to ensure that your app functions correctly across various devices and scenarios. However, manual testing can be time-consuming and error-prone. To streamline the testing process, developers often turn to automation tools. One such tool is MonkeyRunner, a script-based testing framework for Android apps.

In this blog post, we'll explore how to use MonkeyRunner to automate the testing of Android apps.

What is MonkeyRunner?​

MonkeyRunner is a part of the Android SDK that provides a way to write scripts to automate tasks and test Android apps on physical devices or emulators. It simulates user interactions, such as tapping, swiping, and pressing hardware buttons, to mimic real-world usage scenarios.

Setting Up the Environment​

Before we dive into the code, make sure you have the following prerequisites:

  • Android SDK: Install the Android SDK and add the tools and platform-tools directories to your system's PATH.

  • Python: MonkeyRunner scripts are written in Python. Ensure you have Python installed on your system.

Writing the MonkeyRunner Script​

Let's write a basic MonkeyRunner script in Python that interacts with an Android app. This script will launch the app, simulate touch events, and capture screenshots.

Step 1: Create the MonkeyRunner Script​

Create a new Python (.py) file in your project directory and name it app_test.py.

Step 2: Import MonkeyRunner Modules​

In your app_test.py file, import the necessary MonkeyRunner modules:

from com.android.monkeyrunner import MonkeyRunner, MonkeyDevice

​

Step 3: Connect to the Device​

Connect to the Android device or emulator using MonkeyRunner:

device = MonkeyRunner.waitForConnection()

​

Step 4: Launch the App​

Launch the target app on the connected device:

package_name = "com.example.myapp"  # Replace with your app's package name
activity_name = "com.example.myapp.MainActivity" # Replace with the main activity's name

device.startActivity(component=package_name + "/" + activity_name)
MonkeyRunner.sleep(5) # Wait for the app to launch (adjust the time as needed)

​

Step 5: Simulate Touch Events​

Simulate touch events on the app screen:

device.touch(500, 1000, MonkeyDevice.DOWN_AND_UP)  # Replace with desired coordinates
MonkeyRunner.sleep(2) # Wait for 2 seconds

​

Step 6: Capture Screenshots​

Capture screenshots of the app:

screenshot = device.takeSnapshot()
screenshot_path = "path/to/save/screenshot.png"
screenshot.writeToFile(screenshot_path, "png")

​

Step 7: Clean Up​

Close the app and disconnect from the device:

device.shell("am force-stop " + package_name)
device.dispose()

​

Running the MonkeyRunner Script​

To run the MonkeyRunner script, execute the following command in your terminal:

monkeyrunner app_test.py

This will execute the script, simulating touch events on the target app and capturing screenshots.

Conclusion​

Automating Android app testing with MonkeyRunner can save you time and effort while ensuring your app's functionality across various scenarios. By integrating MonkeyRunner scripts, you can harness the power of one of the best automation tools to create a seamless testing process for your Android apps. Remember to customize the scripts according to your app's specific features and requirements.

Happy testing!

Cold Start, Warm Start and Hot Start in Android Apps

Published: · Last updated: · 5 min read
Appxiom Team
Mobile App Performance Experts

In the world of mobile app development, creating a seamless user experience is paramount. One of the critical factors that contribute to this experience is how quickly an app starts up and becomes responsive. This process is known as app start-up, and it can be categorized into three phases: Cold Start, Warm Start, and Hot Start.

In this blog, we will delve into each of these start-up phases, explore their implications on user experience, and provide insights into how to improve them.

Android App start scenarios​

When you launch an Android app, there are three possible scenarios:

  • Cold start: The app is starting from scratch. This is the slowest type of launch, as the system has to create the app's process, load its code and resources, and initialize its components.

  • Warm start: The app's process is already running in the background. In this case, the system only needs to bring the app's activity to the foreground. This is faster than a cold start, but it is still slower than a hot start.

  • Hot start: The app's activity is already in the foreground. In this case, the system does not need to do anything, as the app is already running. This is the fastest type of launch.

The following sections will discuss each of these types of launch in more detail, and provide tips on how to improve them.

Cold start​

A cold start occurs when the app is launched for the first time after installation or after the system has killed the app process. The following are some of the steps involved in a cold start:

  • The system creates the app's process.

  • The system loads the app's code and resources.

  • The system initializes the app's components.

  • The app's main activity is displayed. The cold start is the slowest type of launch because it involves loading all of the app's code and resources from scratch. This can take a significant amount of time, especially for large apps.

Ideally the app should complete a cold start in 500 milli seconds or less. That could be challenging sometimes, but make sure the app does the cold start in under 5 seconds. There are a number of things you can do to improve the cold start time of your app:

  • Use lazy loading: Lazy loading means loading resources only when they are needed. This can help to reduce the amount of time it takes to load the app.

  • Use a profiler: A profiler can help you to identify the parts of your app that are taking the most time to load. This can help you to focus your optimization efforts on the most critical areas.

  • Use a caching mechanism: A caching mechanism can store frequently used resources in memory, so that they do not have to be loaded from disk each time the app is launched.

  • Use a custom launcher: A custom launcher can preload the app's resources in the background before the app is launched. This can significantly reduce the cold start time.

To check whether cold starts are slow for real users and not only on your test device, Appxiom detects cold start delays in Android apps in production and shows what caused them.

Warm start​

A warm start occurs when the app's process is already running in the background. In this case, the system only needs to bring the app's activity to the foreground. This is faster than a cold start, but it is still slower than a hot start.

The following are some of the steps involved in a warm start:

  • The system finds the app's process.

  • The system brings the app's activity to the foreground.

The warm start is faster than a cold start because the app's process is already running. However, the system still needs to bring the app's activity to the foreground, which can take some time.

Ideally the app should complete a warm start in 200 milli seconds or less. In any case, try not to breach the 2 seconds window. There are a number of things you can do to improve the warm start time of your app:

  • Use a profiler: A profiler can help you to identify the parts of your app that are taking the most time to bring to the foreground. This can help you to focus your optimization efforts on the most critical areas.

  • Use a caching mechanism: A caching mechanism can store frequently used activities in memory, so that they do not have to be recreated each time the app is launched.

  • Use a custom launcher: A custom launcher can preload the app's activities in the background before the app is launched. This can significantly reduce the warm start time.

Hot start​

A hot start occurs when the app's activity is already in the foreground. In this case, the system does not need to do anything, as the app is already running. This is the fastest type of launch.

There is not much you can do to improve the hot start time of your app, as it is already running. However, you can take steps to prevent the app from being killed by the system, such as using a foreground service or a wake lock. Ideally the app should complete a hot start in 100 milli seconds or less, or in a worst case scenario, under 1.5 seconds.

Conclusion​

The cold start, warm start, and hot start are the three different types of app launches in Android. The cold start is the slowest type of launch, while the hot start is the fastest.

There are a number of things you can do to improve the launch time of your app, such as using lazy loading, caching, and a custom launcher.

I hope this blog post has been helpful. If you have any questions, please feel free to leave a comment below.

Accessibility Guidelines for Android Apps

Published: · Last updated: · 3 min read
Appxiom Team
Mobile App Performance Experts

Accessibility is a crucial aspect of app development as it ensures that all users, including those with disabilities, can fully access and interact with your Android app. Jetpack Compose, the modern UI toolkit for building Android apps, provides powerful tools and features to make your app more accessible and inclusive.

In this blog, we'll explore some accessibility guidelines and demonstrate how to implement them using Jetpack Compose.

1. Provide Content Descriptions for Images​

For users who rely on screen readers, providing content descriptions for images is essential. It allows them to understand the context of the image. In Jetpack Compose, you can use the Image composable and include a contentDescription parameter.

import androidx.compose.foundation.Image
import androidx.compose.runtime.Composable
import androidx.compose.ui.res.painterResource

@Composable
fun AccessibleImage() {
Image(
painter = painterResource(id = R.drawable.my_image),
contentDescription = "A beautiful sunset at the beach"
)
}

2. Add Accessibility Labels to Interactive Elements​

For interactive elements like buttons and clickable components, adding accessibility labels is crucial. These labels are read aloud by screen readers to inform users about the purpose of the element. You can use the contentDescription parameter for buttons and other interactive components as well.

import androidx.compose.material.Button
import androidx.compose.runtime.Composable

@Composable
fun AccessibleButton() {
Button(
onClick = { /* Handle button click */ },
contentDescription = "Click to submit the form"
) {
// Button content
}
}

​

3. Ensure Sufficient Contrast​

Maintaining sufficient color contrast is essential for users with low vision or color blindness. Jetpack Compose Color object has luminance funcction to check the contrast ratio between text and background colors.

import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.luminance

fun isContrastRatioSufficient(textColor: Color, backgroundColor: Color): Boolean {
val luminanceText = textColor.luminance()
val luminanceBackground = backgroundColor.luminance()
val contrastRatio = (luminanceText + 0.05) / (luminanceBackground + 0.05)
return contrastRatio >= 4.5
}

This function demonstrates how to validate the contrast ratio and adjust colors accordingly to meet the accessibility standards.

4. Manage Focus and Navigation​

Properly managing focus and navigation is essential for users who rely on keyboards or other input methods. In Jetpack Compose, you can use the clickable modifier and the semantics modifier to manage focus and navigation.

import androidx.compose.foundation.clickable
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier

@Composable
fun AccessibleClickableItem() {
Box(
modifier = Modifier
.clickable { /* Handle click */ }
.semantics { /* Provide accessibility information */ }
) {
// Item content
}
}

​

5. Provide Text Scale and Font Size Options​

Some users may require larger text or different font sizes to read the content comfortably. Jetpack Compose makes it easy to implement text scaling and provide font size options.

import androidx.compose.material.LocalTextStyle
import androidx.compose.runtime.Composable
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.unit.TextUnit
import androidx.compose.ui.unit.sp

@Composable
fun ScalableText(
text: String,
textSize: TextUnit = 16.sp
) {
val density = LocalDensity.current.density
val scaledTextSize = with(density) { textSize.toDp() }
LocalTextStyle.current = TextStyle(fontSize = scaledTextSize)

// Render the text
}

​

6. Test Android App with Accessibility Services​

Testing your app's accessibility features is crucial to ensure they work as intended. You can use built-in Android accessibility tools like TalkBack to test your app's compatibility. Turn on TalkBack or other accessibility services on your device and navigate through your app to see how it interacts with these services.

Conclusion​

By following these accessibility guidelines and using Jetpack Compose's built-in accessibility features, you can create Android apps that are more inclusive and provide a better user experience for all users, regardless of their abilities.

Remember, this blog provides only an overview of accessibility guidelines for Android apps using Jetpack Compose. For more detailed guidelines and specifications, refer to the official Android Accessibility documentation.

Ensuring accessibility in your app not only improves user satisfaction but also demonstrates your commitment to creating an inclusive digital environment. So, let's make our apps accessible and embrace the diversity of our users!

Happy coding!

Quick Start Guide on Hilt and Dependency Injection in Kotlin Android Apps

Published: · Last updated: · 5 min read
Appxiom Team
Mobile App Performance Experts

Dependency injection is an essential architectural pattern in Android app development that allows us to manage and provide dependencies to classes or components in a flexible and scalable way. Traditionally, setting up dependency injection in Android apps involved writing a significant amount of boilerplate code. However, with the introduction of Hilt, a dependency injection library from Google built on top of Dagger, this process has become much more streamlined and intuitive.

In this blog, we will explore the step-by-step process of integrating Hilt into a Kotlin Android app and leverage its power to manage dependencies effortlessly.

What is Hilt?​

Hilt is a dependency injection library for Android, developed by Google. It is designed to simplify the implementation of dependency injection in Android apps by reducing boilerplate code and providing a set of predefined components and annotations.

Hilt is built on top of Dagger, which is a popular dependency injection framework for Java and Android. By using Hilt, developers can focus more on writing clean and modular code, and Hilt takes care of generating the necessary Dagger code under the hood.

Prerequisites​

Before we proceed, make sure you have the following set up in your development environment:

  • Android Studio with the latest Kotlin plugin.

  • A Kotlin-based Android project.

Integrating Hilt with Kotlin Android app​

Step 1: Add Hilt Dependencies​

The first step is to include the necessary Hilt dependencies in your project.

Open your app's build.gradle file and add the following lines:

dependencies {
implementation "com.google.dagger:hilt-android:2.41"
kapt "com.google.dagger:hilt-android-compiler:2.41"
}

Hilt requires two dependencies - hilt-android for the runtime library and hilt-android-compiler for annotation processing during build time.

Step 2: Enable Hilt in the Application Class​

Next, we need to enable Hilt in the Application class of our app. If you don't already have an Application class, create one by extending the Application class. Then, annotate the Application class with @HiltAndroidApp, which informs Hilt that this class will be the entry point for dependency injection in our app:

@HiltAndroidApp
class MyApp : Application() {
// ...
}

The @HiltAndroidApp annotation generates the necessary Dagger components and modules under the hood, and it also initializes Hilt in the Application class.

Step 3: Setting up Hilt Modules​

Hilt uses modules to provide dependencies. A module is a class annotated with @Module, and it contains methods annotated with @Provides. These methods define how to create and provide instances of different classes. Let's create an example module that provides a singleton instance of a network service:

@Module
@InstallIn(ApplicationComponent::class)
object NetworkModule {
@Singleton
@Provides
fun provideNetworkService(): NetworkService {
return NetworkService()
}
}

In this example, we define a method provideNetworkService() annotated with @Provides that returns a NetworkService instance. The @Singleton annotation ensures that the same instance of NetworkService is reused whenever it is requested.

Step 4: Injecting Dependencies​

After setting up the module, we can now use the @Inject annotation to request dependencies in our Android components, such as activities, fragments, or view models. For example, to inject the NetworkService into a ViewModel, annotate the View Model with @HiltViewModel.

@HiltViewModel
class MyViewModel @Inject constructor(
private val networkService: NetworkService
) : ViewModel() {
// ...
}

In this example, the MyViewModel class requests the NetworkService dependency via constructor injection. Hilt will automatically provide the required NetworkService instance when creating MyViewModel.

Step 5: AndroidEntryPoint Annotation​

To enable dependency injection in activities and fragments, annotate them with @AndroidEntryPoint:

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
@Inject
lateinit var networkService: NetworkService

// ...
}

By using the @AndroidEntryPoint annotation, we tell Hilt to inject dependencies into this activity. Here, we inject the NetworkService instance into the networkService variable using field injection. After injecting, the networkService variable will be ready to use within the MainActivity.

Step 6: Gradle Plugin Configuration​

To ensure smooth integration and prevent certain issues, we need to configure the Gradle plugin. Add the following configurations to your app's build.gradle file:

android {
// ...
defaultConfig {
// ...
javaCompileOptions {
annotationProcessorOptions {
arguments["dagger.hilt.android.internal.disableAndroidSuperclassValidation"] = "true"
}
}
}
// ...
}

With this configuration, we disable certain superclass validation checks that can interfere with Hilt's code generation and avoid potential runtime issues.

Usage and Benefits of Hilt​

  • Simplified Dependency Injection: Hilt significantly reduces the boilerplate code required for dependency injection. The use of annotations allows developers to declare dependencies clearly and concisely.

  • Scoping and Caching: Hilt provides built-in support for scoping annotations like @Singleton, @ActivityScoped, @FragmentScoped, etc., ensuring that singleton instances are cached and reused when requested. This saves memory and processing time.

  • Easy Testing: Hilt simplifies testing by allowing you to swap out dependencies easily using different modules for testing, providing clear separation between production and test code.

  • Seamless Integration with Android Components: Hilt seamlessly integrates with Android activities, fragments, services, and view models, making it convenient to inject dependencies into these components. It allows for smooth development without worrying about manual instantiation or passing dependencies around.

Conclusion​

In this blog, we explored the step-by-step process of integrating Hilt into a Kotlin Android app. We started with a brief introduction to Hilt and its benefits. Then, we walked through the integration process, including adding dependencies, enabling Hilt in the Application class, setting up Hilt modules, injecting dependencies into Android components, and configuring the Gradle plugin. Hilt significantly simplifies the dependency injection process, resulting in a cleaner and more maintainable codebase.

By leveraging Hilt's power, developers can enhance the modularity and testability of their Android apps, leading to a smoother development process and a better user experience.

Happy coding!