An app developer should understand the importance of creating a smooth, responsive, and efficient app.
With millions of apps on the Google Play Store, users have come to expect a high level of performance, and any subpar experience can lead to negative reviews or, worse, uninstalls.
In this article series, we will delve into the key areas to focus on to improve your app's performance, including code optimization, UI/UX enhancements, network usage optimization, multithreading, storage, battery usage, and more. We will also discuss the importance of utilizing Android Jetpack libraries, keeping your app size small, and maintaining up-to-date libraries and SDKs.
Code optimization is crucial for ensuring your app runs smoothly and efficiently. Let’s look at some ways of achieving performance using code optimisation
Optimize Code
The Android Profiler is a powerful tool integrated into android studio that helps track your app's performance in real-time. It monitors CPU, memory, and network usage, and identify bottlenecks that may be slowing down the app. By addressing these bottlenecks, you can significantly improve app's performance. However this can be sometimes resource-intensive and might slow down your development environment.
Reduce object allocations to avoid garbage collection
Minimizing object allocations reduces garbage collection events, leading to fewer performance hiccups. In Kotlin, you can use extension functions like apply, also, let, and with to avoid creating unnecessary temporary objects. Also, consider using the object keyword for singletons and avoiding anonymous inner classes that can lead to memory leaks.
See example:
object Singleton {
fun doSomething() { }
}
val modifiedList = myList.map { it * 2 }.filter { it > 10 }
Use the appropriate data structures and algorithms
Selecting the right data structures and algorithms can significantly impact your app's performance. For example, if you need to look up items by their keys, using a HashMap instead of a List can speed up your app:
val itemsMap: HashMap<String, Item> = hashMapOf()
itemsMap["itemKey"] = item
val retrievedItem = itemsMap["itemKey"]
Avoid memory leaks by managing resources carefully
Memory leaks occur when you hold references to objects that are no longer needed. This can lead to increased memory usage and ultimately cause your app to crash. You can use the use function to automatically close resources like streams and avoid memory leaks.
FileInputStream("file.txt").use { inputStream ->
}
For computationally intensive tasks, you might benefit from writing native code using the Android NDK. Kotlin/Native allows you to write platform-specific code that can be called from your Kotlin code. However, keep in mind that using native code increases complexity and should only be considered when necessary.
import kotlinx.cinterop.*
import platform.posix.*
fun readNativeFile() {
val file = fopen("file.txt", "r") ?: throw Error("Cannot open file")
try {
} finally {
fclose(file)
}
}
UI/UX
A smooth and efficient user interface is essential for a great user experience. There are several techniques to achieve this.
Optimize layouts with Android Studio's Layout Inspector and Hierarchy Viewer
These tools help you analyze and optimize your app's layouts. By simplifying view hierarchies, you can reduce overdraw and improve rendering performance. However this may be a little time consuming.
Minimize overdraw by simplifying view hierarchies and using background colors
Overdraw occurs when multiple layers are drawn over each other, causing unnecessary rendering work. You can minimize overdraw by flattening your layouts and setting backgrounds only when needed
<LinearLayout
android:background="@color/background"
...>
<TextView .../>
<TextView .../>
</LinearLayout>
<LinearLayout ...>
<TextView
android:background="@color/background"
.../>
<TextView
android:background="@color/background"
.../>
</LinearLayout>
Use AndroidX
The RenderScript API has been deprecated in Android 12, and it is recommended to migrate to the AndroidX library for hardware-accelerated computations. The androidx.core:graphics library provides classes and methods for performing computationally intensive tasks like image processing.
Other options like using Vulkan API or OpenGL ES can also be explored. It's important to thoroughly test the app after making significant changes.
Choose the right image format (e.g., WebP, JPEG, or PNG) and resolution for your app to reduce memory usage and loading times. Android Studio has a built-in image asset importer that helps generate different resolutions for your images
Use placeholder content or skeleton loading to enhance perceived performance
While your app fetches data or loads resources, use placeholders or skeleton loading to give users visual feedback, making the app feel more responsive
val imageView: ImageView = findViewById(R.id.my_image_view)
Glide.with(this)
.load(imageUrl)
.placeholder(R.drawable.placeholder_image)
.into(imageView)
Network usage
Efficient network usage is crucial for providing a smooth user experience, especially on slow or unreliable connections. Let’s see what techniques we can put in action for this
Use caching and local storage to reduce network requests
Caching data locally can help reduce network requests and improve app performance. For example, you can use Android's SharedPreferences or Room library to cache data, however this might result in in increased local storage usage.
See example:
val sharedPreferences = getSharedPreferences("MyAppCache", Context.MODE_PRIVATE)
val editor = sharedPreferences.edit()
editor.putString("key", "value")
editor.apply()
val cachedValue = sharedPreferences.getString("key", null)
Use background tasks and services for network operations
Running network operations in the background can help keep your app responsive. For example, you can use Kotlin coroutines for asynchronous tasks:
import kotlinx.coroutines.*
fun fetchData() {
CoroutineScope(Dispatchers.IO).launch {
val data = apiCall()
withContext(Dispatchers.Main) {
updateUI(data)
}
}
}
Use data compression techniques to reduce payload size
Compressing data before sending it over the network can help reduce payload size and improve app performance. You can use libraries like GZIP or Brotli to compress and decompress data. but this requires requires additional processing for compression and decompression.
See example:
val client = OkHttpClient.Builder()
.addInterceptor {
val request = it.request().newBuilder()
.header("Accept-Encoding", "gzip")
.build()
it.proceed(request)
}
.build()
Monitor network connectivity and adapt app behaviour accordingly
Adapting your app's behaviour based on network connectivity can improve user experience. You can use the ConnectivityManager to detect network changes.
val connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
val networkCallback = object : ConnectivityManager.NetworkCallback() {
override fun onAvailable(network: Network) {
}
override fun onLost(network: Network) {
}
}
connectivityManager.registerDefaultNetworkCallback(networkCallback)
Use Firebase Cloud Messaging (FCM) for efficient push notifications
Leverage FCM to deliver push notifications with minimal battery and network impact.
class MyFirebaseMessagingService : FirebaseMessagingService() {
override fun onMessageReceived(remoteMessage: RemoteMessage) {
}
}
Multithreading
Efficient use of multiple threads can help you execute tasks concurrently, leading to a smoother and more responsive app. Here are some essential techniques
Use Kotlin Coroutines for asynchronous tasks
Kotlin coroutines allow you to write asynchronous code in a more readable and efficient way.
Example:
import kotlinx.coroutines.*
fun fetchData() {
CoroutineScope(Dispatchers.IO).launch {
val data = apiCall()
withContext(Dispatchers.Main) {
updateUI(data)
}
}
}
Use ThreadPoolExecutor for concurrent tasks
ThreadPoolExecutor can help you manage a pool of worker threads for executing tasks concurrently. It Improves performance by parallelizing independent tasks. Example:
import java.util.concurrent.Executors
val threadPoolExecutor = Executors.newFixedThreadPool(4)
fun performTask(task: Runnable) {
threadPoolExecutor.execute(task)
}
Use WorkManager for deferrable, guaranteed tasks
WorkManager is part of Android Jetpack and provides a simple way to schedule background tasks. However it is not suitable for tasks that need to be executed immediately.
Example:
import androidx.work.OneTimeWorkRequest
import androidx.work.WorkManager
import androidx.work.Worker
import androidx.work.WorkerParameters
class MyWorker(appContext: Context, workerParams: WorkerParameters) : Worker(appContext, workerParams) {
override fun doWork(): Result {
// Perform background task
return Result.success()
}
}
val myWorkRequest = OneTimeWorkRequest.Builder(MyWorker::class.java).build()
WorkManager.getInstance(this).enqueue(myWorkRequest)
Storage Optimization
Use appropriate storage options
- Use Shared Preferences for small amounts of data in key-value pairs. It is perfect for storing simple configuration settings or user preferences.
val sharedPreferences = getSharedPreferences("MyAppPrefs", Context.MODE_PRIVATE)
val editor = sharedPreferences.edit()
editor.putString("username", "JohnDoe")
editor.apply()
- SQLite: A lightweight relational database that allows you to store structured data. It's useful for apps that need to manage a moderate amount of data with complex relationships. See example:
val dbHelper = object : SQLiteOpenHelper(context, "my_database.db", null, 1) {
override fun onCreate(db: SQLiteDatabase) {
db.execSQL("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
}
override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {}
}
val db = dbHelper.writableDatabase
val contentValues = ContentValues().apply {
put("id", 1)
put("name", "John Doe")
}
db.insert("users", null, contentValues)
- Room: A higher-level abstraction over SQLite, providing a more robust and type-safe way to manage structured data storage. Room simplifies database operations and integrates with other Android components like LiveData.
val db = Room.databaseBuilder(applicationContext, AppDatabase::class.java, "my-db").build()
val userDao = db.userDao()
Optimize database queries and transactions
Efficient database queries and transactions are essential for reducing the time your app spends accessing the database, which in turn improves performance.
Some tips for optimizing database operations include:
Use indexes on frequently queried columns to speed up query execution.
Limit the number of rows returned by a query using the LIMIT keyword.
Write transactions to batch multiple insertions, updates, or deletions together, reducing the overhead of individual operations.
Use parameterized queries to prevent SQL injection attacks and improve performance.
Example of using LIMIT and parameterized query with Room:
@Dao
interface UserDao {
@Query("SELECT * FROM user WHERE age > :minAge LIMIT 10")
fun getUsersAboveAge(minAge: Int): List<User>
}
Running storage operations asynchronously prevents blocking the main thread, ensuring a smooth user experience. You can use Kotlin Coroutines, AsyncTask, or other multithreading techniques to achieve this
Use Android Jetpack Libraries
Android Jetpack is a collection of libraries that aim to simplify and streamline UI development. They are designed to improve app performance, maintainability, and reduce boilerplate code.
Architecture components: ViewModel, LiveData, and Data Binding
ViewModel: A class that helps manage and store UI-related data in a lifecycle-conscious way. It allows data to survive configuration changes and keeps UI data separate from the activity or fragment.
LiveData: An observable data holder class that is lifecycle-aware. It ensures that updates are only sent to active observers, such as an activity or fragment in the started or resumed state. Example with LiveData (combined with ViewModel):
class MainActivity : AppCompatActivity() {
private lateinit var userViewModel: UserViewModel
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
userViewModel = ViewModelProvider(this).get(UserViewModel::class.java)
userViewModel.userName
userViewModel.userName.observe(this, { name ->
textView.text = name
})
- Data Binding: A library that allows you to bind UI components directly to data sources in your XML layouts, reducing the need for boilerplate code in your activities or fragments.
WorkManager for efficient background tasks
WorkManager is a library for managing and scheduling deferrable, asynchronous tasks that must run even if the app exits or the device restarts. It takes care of handling compatibility issues and provides a simplified API for performing background work. However this might introduce some overhead in certain cases.
Android KTX for Kotlin extensions that simplify code
KTX is a set of Kotlin extensions designed to make android dev with Kotlin more concise and idiomatic. It provides extension functions and properties for common tasks, simplifying your code.
ConstraintLayout for more efficient UI design
ConstraintLayout is a flexible layout manager that allows you to create complex UIs with a flat view hierarchy, improving performance. It also provides a powerful design editor in Android Studio, making it easy to create and modify layouts visually.
That’s it for now!
By implementing these strategies, you're well on your way to building a high-performance Android app that users will love. In the upcoming part 2 of this series, we'll delve into the remaining optimization techniques, such as optimizing battery usage, ensuring compatibility across various devices, and keeping app size small, among others.
Stay tuned. Happy coding!
