DEV Community: Mohit Rajput

[Boost]

Mohit Rajput — Thu, 13 Nov 2025 12:13:17 +0000

From Material 2 to Material You: Everything New in Material 3 for Android Developers

Mohit Rajput ・ Nov 11

#androiddevelopment #jetpackcompose #material3 #materialdesign

From Material 2 to Material You: Everything New in Material 3 for Android Developers

Mohit Rajput — Tue, 11 Nov 2025 18:45:36 +0000

What is Material 3?

Material 3 (a.k.a. Material You) is the latest version of Google’s Material Design system (released with Android 12+).
It’s all about personalization, dynamic color, and adaptive UI.

In Jetpack Compose, it’s supported by:

import androidx.compose.material3.*

Key New Features (vs. Material 2)

Area	Material 2	Material 3 (New)	Why It Matters (Interview Tip)
🎨 Theming System	Static color palette (light/dark)	Dynamic color system — UI automatically adapts colors from wallpaper (via Material You / Monet engine)	More user personalization & consistency with system theme
🧱 Components	Old components (`Button`, `TextField`, etc.)	New & redesigned ones: `FilledTonalButton`, `OutlinedCard`, `AssistChip`, `SuggestionChip`, etc.	More flexible + accessible UI components
⚙️ Typography	Hardcoded `Typography` styles	`Typography` with scalable design tokens and dynamic defaults (`displayLarge`, `headlineMedium` etc.)	Easier responsive design
🧩 Shapes & Elevation	Fixed shapes/elevation	Uses tonal elevation (surface color shifts instead of shadows)	Better dark theme consistency
🌈 Color System	`primary`, `secondary`, etc.	Extended color roles: `primaryContainer`, `onPrimaryContainer`, `surfaceVariant`, `errorContainer`, etc.	Fine-grained theming & contrast control
🧭 Navigation Bar / FABs	Flat styles	New FAB variants, NavigationBar with rounded highlights	Modern look (aligns with Android 13 UI)
🕹 State handling	Manual states	New StateLayer built into components (hover, focus, pressed)	Better touch/hover feedback automatically
⚡ Adaptive Design	Not responsive-friendly	M3 supports adaptive layouts (large screens, foldables, tablets)	Crucial for multi-device apps
♿ Accessibility	Basic	Larger default text sizes, better contrast, color harmonization	Easier accessibility compliance

1. Dynamic Color (Biggest Feature)

Material 3 allows auto-theming based on wallpaper (Android 12+).

Example in Compose:

@Composable
fun MyApp() {
    val dynamicColor = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
    val colorScheme = when {
        dynamicColor -> dynamicColorScheme(LocalContext.current)
        else -> lightColorScheme()
    }

    MaterialTheme(
        colorScheme = colorScheme,
        typography = Typography,
        content = { MyScreen() }
    )
}

Tip: This is implemented using Monet color extraction engine, generating tonal palettes from wallpaper.

2. New Design Tokens

Material 3 introduces design tokens for all system attributes:

Color roles (instead of primary/secondary alone)
Typography roles (headlineLarge, bodySmall, etc.)
Shape tokens (extraSmall, medium, extraLarge)
Elevation tokens (level0 to level5)

These give consistent scaling across UI components.

Example:

val shapes = Shapes(
    small = RoundedCornerShape(8.dp),
    medium = RoundedCornerShape(12.dp),
    large = RoundedCornerShape(24.dp)
)

3. New Components

🪄 Buttons

FilledButton
FilledTonalButton
OutlinedButton
TextButton
ElevatedButton

Example:

FilledTonalButton(onClick = { }) {
    Text("Save")
}

🪩 Chips

New types of Chips for input, filters, suggestions:

AssistChip(onClick = { }, label = { Text("Assist") })

SuggestionChip(onClick = { }, label = { Text("Suggestion") })

FilterChip(selected = true, onClick = { }, label = { Text("Filter") })

🧠 Cards

More expressive variants:

ElevatedCard { /* shadowed */ }
OutlinedCard { /* border only */ }
FilledCard { /* background filled */ }

🧭 Navigation Bars

New composables:

NavigationBar { /* bottom nav */ }

NavigationDrawer { /* side drawer */ }

TopAppBar / CenterAlignedTopAppBar

They support scroll behavior and tonal color adaptation.

4. Tonal Elevation (Instead of Shadows)

Material 3 prefers tonal color blending to indicate elevation:

Higher elevation = lighter/darker surface color
Better suited for dark theme (no unnatural shadows)

Compose handles this via:

surfaceColorAtElevation(elevation = 3.dp)

5. MaterialTheme Changes

In M2:

MaterialTheme(colors = ...)

In M3:

MaterialTheme(colorScheme = ..., typography = ..., shapes = ...)

And for colors:

val color = MaterialTheme.colorScheme.primaryContainer

6. Updated Typography System

val typography = Typography(
    displayLarge = TextStyle(...),
    headlineMedium = TextStyle(...),
    bodySmall = TextStyle(...)
)

Instead of old h1, h2, subtitle1, etc.

Example Source Code (Jetpack Compose M3)

@Composable
fun Material3Demo() {
    MaterialTheme(
        colorScheme = dynamicColorScheme(LocalContext.current),
        typography = Typography()
    ) {
        Scaffold(
            topBar = {
                CenterAlignedTopAppBar(title = { Text("Material 3 Demo") })
            },
            floatingActionButton = {
                FloatingActionButton(onClick = { }) {
                    Icon(Icons.Default.Add, contentDescription = "Add")
                }
            }
        ) { padding ->
            Column(
                modifier = Modifier
                    .padding(padding)
                    .fillMaxSize(),
                verticalArrangement = Arrangement.spacedBy(12.dp)
            ) {
                FilledTonalButton(onClick = {}) { Text("Save") }
                AssistChip(onClick = {}, label = { Text("Assist") })
                ElevatedCard { Text("Modern Card") }
            }
        }
    }
}

Summary

Category	What’s New
🎨 Dynamic Color (Material You)	Auto wallpaper-based theming
🧱 New Components	Buttons, Chips, Cards, Navigation Bars
🧩 Tonal Elevation	No shadow, uses color blending
⚙️ Color Roles	`primaryContainer`, `surfaceVariant`, etc.
🧠 New Typography Tokens	`displayLarge`, `bodyMedium`, etc.
🧭 Adaptive Layouts	Responsive for tablets, foldables
♿ Accessibility	Better contrast, dynamic sizing

Don’t let unnecessary recompositions kill your performance

Mohit Rajput — Wed, 05 Nov 2025 14:22:02 +0000

In my previous blog, I introduced a library called Rebugger — a handy tool to detect why recompositions occur in Jetpack Compose.

After that post, several developers asked me to cover common mistakes in Compose and how to fix them.

So, I’ve written a detailed follow-up article highlighting major pitfalls and best practices to avoid unnecessary recompositions in your Compose code.

👉 Read the full article on Medium

Debugging Recompositions in Jetpack Compose

Mohit Rajput — Tue, 28 Oct 2025 20:43:57 +0000

If you've ever wondered, "Why is my composable recomposing so many times?" — you're not alone 😅

Jetpack Compose makes UI building elegant, but understanding when and why recomposition happens can get tricky.

Recently, I came across an awesome open-source library 👉 Rebugger — and it's a total game-changer!

🔍 What Rebugger Does

Rebugger helps you visualise recompositions in real-time by showing which parameters triggered a recomposition and how often it happens — right inside your UI or logcat.

No need to guess anymore — you see exactly what changed and why Compose decided to recompose.

🧠 How to Use

Just wrap your composable with the Rebugger composable, providing the variables you want to track in the trackMap:

Rebugger(trackMap = mapOf(
    "state" to statekot, // Replace with your actual state/variable
    "user" to user,       // Replace with your actual state/variable
    "products" to products // Replace with your actual state/variable
)) {
    // Your Composable Content goes here
}

And you'll instantly see recomposition info in logcat.

This is perfect for performance tuning and code reviews.

⚡ Why It’s Useful

Identify unnecessary recompositions instantly.
Optimize your Compose code for better performance.
Great tool for learning Compose internals and debugging UI behavior.

Big thanks 🙌 to @theapache64 for creating this tool — I wish I had it when I started migrating to Compose!

If you’re working with Jetpack Compose, this one is absolutely worth adding to your dev toolbox. 🧰

Try it out here: https://github.com/theapache64/rebugger

💬 Let's Discuss

Have you used any other tools or tricks to debug recomposition?

Would love to hear your favourites below 👇

#Android #JetpackCompose #Recomposition #Performance #AndroidDev #Kotlin #MobileDevelopment

Mastering Kotlin Coroutines in Android: A Practical Guide

Mohit Rajput — Sun, 04 May 2025 17:59:57 +0000

Modern Android development is all about writing clean, efficient, and asynchronous code — and Kotlin Coroutines have become the go-to tool for that. If you're tired of callback hell and want to write non-blocking, readable code, coroutines are your best friend.

In this post, we'll cover:

✅ What are Coroutines?
🔁 Coroutine vs Thread
🧭 Coroutine Scope
🚀 launch vs async
🔄 withContext
⚠️ Exception handling
📱 Real-world Android examples

🌱 What is a Coroutine?

A coroutine is a lightweight thread that can be suspended and resumed. It allows you to perform long-running tasks like network calls or database operations without blocking the main thread.

Coroutine = Co + routine i.e. it's the cooperation among routines(functions).

Think of it as a function that can pause mid-way and resume later, keeping your UI responsive.

GlobalScope.launch {
    val data = fetchDataFromNetwork()
    updateUI(data)
}

🧵 Coroutine vs Thread

Feature	Coroutine	Thread
Lightweight	✅ Yes	❌ No (heavy OS object)
Performance	🚀 High (thousands at once)	🐌 Limited (few hundred)
Blocking	❌ Non-blocking	❗ Blocking
Context Switching	✨ Easy with `withContext`	⚠️ Complex
Cancellation	✅ Scoped and structured	❌ Manual and error-prone

Coroutines don’t create new threads — they efficiently use existing ones via dispatchers.

🧭 Coroutine Scope

A CoroutineScope defines the lifecycle of a coroutine. If the scope is canceled, so are all its coroutines.

Common scopes:

GlobalScope: Application-wide (⚠️ Avoid in Android)
lifecycleScope: Tied to Activity/Fragment
viewModelScope: Tied to ViewModel lifecycle

viewModelScope.launch(Dispatchers.IO) {
    val user = userRepository.getUser()
    _userState.value = user
}

🚀 `launch` vs `async`

Both start coroutines, but differ in intent:

🔹 `launch`: fire-and-forget

Doesn’t return a result
Ideal for background tasks

launch {
    saveDataToDb()
}

🔹 `async`: returns a `Deferred`

Used when you need a result

val deferred = async {
    fetchDataFromApi()
}
val result = deferred.await()

You can call functions concurrently using async. Here is the example:

class UserViewModel : ViewModel() {

    private val _userInfo = MutableLiveData<String>()
    val userInfo: LiveData<String> get() = _userInfo

    fun loadUserData() {
        viewModelScope.launch {
            val userDeferred = async { fetchUser() }
            val settingsDeferred = async { fetchUserSettings() }

            try {
                val user = userDeferred.await()
                val settings = settingsDeferred.await()

                _userInfo.value = "User: $user, Settings: $settings"
            } catch (e: Exception) {
                _userInfo.value = "Error: ${e.message}"
            }
        }
    }

    // Simulated suspending functions
    private suspend fun fetchUser(): String {
        delay(1000) // Simulate network/API delay
        return "Alice"
    }

    private suspend fun fetchUserSettings(): String {
        delay(1200) // Simulate network/API delay
        return "Dark Mode"
    }
}

🔄 `withContext`: for switching threads

Switch coroutine execution to a different dispatcher.

withContext(Dispatchers.IO) {
    val data = fetchData()
    withContext(Dispatchers.Main) {
        updateUI(data)
    }
}

✅ Use withContext for sequential tasks. Prefer it over async/await when there's no concurrency benefit.

⚠️ Exception Handling in Coroutines

✅ Use `try-catch` inside coroutine blocks

viewModelScope.launch(Dispatchers.IO) {
    try {
        val result = repository.getData()
        _dataLiveData.postValue(result)
    } catch (e: Exception) {
        _errorLiveData.postValue("Something went wrong")
    }
}

✅ Use `CoroutineExceptionHandler` for top-level coroutines

val exceptionHandler = CoroutineExceptionHandler { _, exception ->
    Log.e("CoroutineError", "Caught $exception")
}

viewModelScope.launch(Dispatchers.IO + exceptionHandler) {
    throw RuntimeException("Oops!")
}

📱 Real-world Example (Network + DB)

viewModelScope.launch(Dispatchers.Main) {
    try {
        val user = withContext(Dispatchers.IO) {
            val networkUser = apiService.fetchUser()
            userDao.insertUser(networkUser)
            networkUser
        }
        _userLiveData.postValue(user)
    } catch (e: Exception) {
        _errorLiveData.postValue("Failed to load user")
    }
}

🧼 Best Practices

Always use viewModelScope or lifecycleScope, not GlobalScope
Use Dispatchers.IO for heavy I/O tasks (network, DB)
Use withContext for sequential switching
Catch exceptions explicitly
Avoid blocking calls like Thread.sleep() inside coroutines

📚 Final Thoughts

Kotlin Coroutines are powerful, concise, and align beautifully with modern Android architecture. Once you embrace them, you’ll write faster, cleaner, and more maintainable asynchronous code.

✍️ Enjoyed this post? Drop a ❤️, share it with your Android dev circle, or follow me for more practical guides.

Got questions or want advanced coroutine topics like Flow, SupervisorJob? Let me know in the comments! I will cover that in the next blog.

New Android Studio Logcat

Mohit Rajput — Mon, 04 Sep 2023 10:58:01 +0000

The Android Studio Dolphin 🐬 update brought an exciting revamp to the logcat feature, but with great power comes the challenge of mastering log filtering. Many developers have found themselves swimming in a sea of logs. Fear not! Dive into this blog for a handy cheat sheet that'll have you effortlessly surfacing the logs you need with a grin 😃.

Filter Fields

package:mine - Displays the logs of package names of currently open project.
package:com.example - Displays the logs of package name specified i.e. com.example in given example.

is:crash - Displays the logs related to crashes.
is:stacktrace - Displays the logs of full stack trace.
is:firebase - Displays the logs related to firebase.

tag:AppName - Displays the logs matching log tag AppName.
message:AppName - Displays the logs matching log tag AppName. If the sentence has spaces, separate the words with the slash \ sign.
level:DEBUG - Displays the logs matching log level DEBUG. Other valid values are: VERBOSE, WARNING, INFO, ERROR and FATAL.

age:1m - Displays the logs with a timestamp of the last 1 minute. There are following supported time units:
- s - seconds
- m - minutes
- h - hours
- d - days

Match Operators

Regex - Append ~ after any field. E.g. tag~:Activity displays logs which contain log tag "Activity".
Exact match - Append = after any field. E.g. tag=:Activity displays logs which exactly has log tag "Activity".
Negation - It works like NOT operator. Prepend - to the field name. E.g. -tag:Activity displays logs which don't have the log tag "Activity".
Logical Operators - AND(&) and OR(|) signs are supported in logs. E.g. package:mine & (tag:AppName | message:This\is\sample).
Space - Space is an implicit AND logical operator. E.g. package:mine tag:AppName message:Sample will evaluated as package:mine & tag:AppName & message:Sample

That is all about it. Before we sign off, remember that the world of Android development is full of hidden gems and ingenious tricks. Given options work till latest Android Studio G. If you've got some secret logcat filtering sorcery up your sleeve, don't be shy – share it in the comments! Happy coding, and may your lines of code always compile with a sprinkle of developer magic ✨😇.

Event Bus Pattern in Android Using Kotlin Flows

Mohit Rajput — Sun, 25 Dec 2022 10:35:10 +0000

The event bus design pattern is very popular and advantageous in programming. The publishers trigger events and subscribers can listen to those events from anywhere. It reduces unnecessary coupling. With the arrival of observers and other frameworks, this design pattern is in less use nowadays. To achieve broadcasting of events in Android, we already had the following options:

RxBus
Local Broadcast
Third parties i.e. green robot etc.

While Kotlin is gaining popularity, language is providing so many cutting-edge frameworks. Flow is one of them. Kotlin released a stable version of StateFlow and SharedFlow with the language's 1.4 release. We can achieve the EventBus design pattern using SharedFlow and leverage the benefits of language and framework.

Implementation

You can achieve event bus using shared flow using following easy steps:

Step 1:

Create a generic event bus class as follows:

object EventBus {
  private val _events = MutableSharedFlow<Any>()
  val events = _events.asSharedFlow()

  suspend fun publish(event: Any) {
    _events.emit(event)
  }

  suspend inline fun <reified T> subscribe(crossinline onEvent: (T) -> Unit) {
    events.filterIsInstance<T>()
      .collectLatest { event ->
        coroutineContext.ensureActive()
        onEvent(event)
      }
  }
}

Here, the publish method posts an event passed as a parameter. Subscribe method collects those events. It does some utility work i.e. filtering correct event, ensuring coroutine context is active or not then providing event on the onEvent() method. Moreover, you can collect public events shared flow variable to apply custom logic if needed.

Step 2:

Create an event class as follows:

data class LoginEvent(
  val userId: String,
  val userName: String
)

Ideally, your event classes would be data classes as in any event, you would require some data. But it could be any kind of class.

Step 3:

Now use those methods to publish and subscribe to events. Creating a separate class would be preferred as per module or feature. One example is as follows:

class LoginEventHandler {
  suspend fun postLoginEvent(loginEvent: LoginEvent) {
    EventBus.publish(loginEvent)
  }

  fun subscribeLoginEvent(lifecycleOwner: LifecycleOwner) {
    lifecycleOwner.lifecycleScope.launch {
      EventBus.subscribe<LoginEvent> { loginEvent ->
        Log.d("LoginEventHandler", "${loginEvent.userName} logged-in successfully")
      }
    }
  }
}

And that's it!!!

Conclusion

Event bus has been a debatable topic among developers. Some say it should not be followed because it could act as a single point of failure. Sometimes, it could be hard to debug what is the source of the event.
However, it is widely accepted and useful for many use cases i.e. updating UI on internet connectivity changes, refreshing UI on login once login popup dismisses i.e. in e-commerce apps, etc. In my opinion, don't be too dependent on it. Use it as minimally as possible. Your opinion and approaches are welcome in the comments.

You can check my articles on Medium also.

RecyclerView pagination scroll listener in Android

Mohit Rajput — Mon, 28 Nov 2022 17:25:20 +0000

What is pagination

Loading a list of items in batches instead of loading all items in a single go is called pagination. When you open the Gmail web app, you see 50 emails by default in a single page. To see the 51st mail, you have to click on next page button.

Why pagination

Consider in your Gmail account, there are about one thousand plus emails. Loading all a thousand emails at once will have the following drawbacks:

Database read operation will be very costly. So you will get a list with a great amount of latency.
After fetching the list, rendering a large number of items in a single go can slow down GUI.

Ways to use pagination

In Android, there are two ways to implement pagination:

Using jetpack's paging library. You can see the detailed implementation of the paging library using MVVM in my other blog Paging with MVVM and coroutines.
Using our own implementation of RecyclerView scroll listener.

Simple scroll listener

This article focuses on our own implementation. There are many ways to implement logic inside the scroll listener of RecyclerView. I have created a generic implementation of scroll listener which you can simply copy-paste into your code:


/**
 * Created by Mohit Rajput on 20/03/22.
 * Used for the load more functionality.
 */
abstract class PaginationScrollListener(private val layoutManager: LinearLayoutManager) :
    RecyclerView.OnScrollListener() {

    override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
        super.onScrolled(recyclerView, dx, dy)
        val visibleItemCount: Int = layoutManager.childCount
        val totalItemCount: Int = layoutManager.itemCount
        val firstVisibleItemPosition: Int = layoutManager.findFirstVisibleItemPosition()
        if (!isLoading() && !isLastPage()) {
            if (visibleItemCount + firstVisibleItemPosition >= totalItemCount
                && firstVisibleItemPosition >= 0
            ) {
                loadMoreItems()
            }
        }
    }

    protected abstract fun loadMoreItems()
    abstract fun isLastPage(): Boolean
    abstract fun isLoading(): Boolean
}

Here is an example usage of this scroll listener:


private var isLoadingEmails = false
private val viewModel by viewModels<EmailsViewModel>()

private fun addScrollListener() {
        recyclerView.addOnScrollListener(object :
            PaginationScrollListener(recyclerView.layoutManager as LinearLayoutManager) {
            override fun loadMoreItems() {
                viewModel.fetchEmails()
            }

            override fun isLastPage() = viewModel.isAllEmailLoaded

            override fun isLoading() = isLoadingEmails
        })
    }

Explanation

When you start loading the list, set isLoadingEmails value to true. Once loaded, set it to false. This can be managed by view state triggered through live data or state flow.
viewModel.isAllEmailLoaded value depends on API call implementation. If your API provides the total count of list items, you can simply implement it as isAllEmailLoaded = currentList.size == totalListItems.
This implementation is for LinearLayoutManager only. I will provide an efficient code for GridLayoutManager soon.

Conclusion

Load more or pagination is a widespread concept that almost every app uses. We write the code of the scroll listener again and again. So I created a small generic class that structures the load more so that it can be reused easily. If loading is in progress, it will not make a loading call simultaneously.
Thanks for the reading. 😊😊😊

Launch modes of Android Activity

Mohit Rajput — Fri, 26 Aug 2022 15:28:27 +0000

Welcome to one of the most important topics of Android application development. In this article we will see detailed explanation of launch modes with examples.

Important terms

Here are a few important terms before jumping on to launch modes.

Task

A task is a collection of activities. An application can have single or multiple tasks. On application launch, a new task is created and launcher activity becomes the root of the task. New task creation depends upon launch modes which we will see later in this article.

Back Stack

Maintaining activities in the stack data structure is called the back stack. Activities can be pushed into the stack and popped from it based on user actions and launch modes.

Launch Modes

There are four types of launch modes:

Standard
Single top
Single task
Single instance

Let's understand each of them.

1. Standard

When you don't specify any launch mode, standard is the default one. It creates a new instance of the activity every time you start it. Suppose A, B, C, D, etc. are activities. It works as follows:

The task with activities:

A -> B -> C -> D

Start new activity E:

A -> B -> C -> D -> E

Start activity B again:

A -> B -> C -> D -> E -> B

2. Single top

In this launch mode, if an activity is at the top of the task and you create its instance again, then a new instance will not be created. Instead onNewIntent() will be called with updated data. If activity is not on top, a new instance will be pushed. See with examples:

The task with activities:

A -> B -> C -> D

Launch activity B. As B is not on top, a new instance will be created:

A -> B -> C -> D -> B

Launch activity B again. As B is on top, onNewIntent() on B will be called:

A -> B -> C -> D -> B

3. Single task

In this launch mode, if the activity doesn't exist in the task, a new instance is created otherwise onNewIntent() is called. Additionally, activities above it get destroyed. Let's understand this with examples:

The task with activities:

A -> B -> C -> D

Start activity E with launch mode single task:

A -> B -> C -> D -> E

Start activity B with launch mode single task:

A -> B

Now you can see that B is already there. So a new instance is not created. The onNewIntent() of B is called. Also, C, D, and E which are above B were destroyed.

4. Single instance

For an activity that has a single instance launch mode, a new task is created. First, see the example, then we can explain it.

The task with activities:

A -> B -> C -> D

Launch E with launch mode single instance:

Task-1: A -> B -> C -> D

Task-2: E

If you launch E again, it will not create a new task. In the same instance of E, the onNewIntent() method will be called.

How to add launch modes

Launch mode can be set from AndroidManifest.xml like this:

<activity android:name=”.MainActivity”
          android:launchMode=”singleTop” />

or Java/Kotlin code using flags like this:

val intent = Intent(activity, HomeGenericActivity::class.java).apply { 
            addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
        }

See, that's very easy!!! 😁😁😁 I hope you enjoyed reading this article.

New Splash Screen API from Android

Mohit Rajput — Sat, 12 Feb 2022 11:37:10 +0000

Billions of Android apps are there in play store. Most of the apps have one thing common, Splash Screen. Android 12 brought us the official splash screen support. Previously, we have to add a custom implementation i.e. there was no uniform way to implement it. You can implement this feature in lower versions(minimum SDK 23) also with support library.

Definition of splash screen

When your app is not in memory or its process is not active, it takes time to open. It takes time to load first frame of your app. Till then even if you implement an activity as splash, you will see a plain white screen for some time. It's better to show some graphical assets i.e. app logo, animation, background color etc. to users instead of showing white screen. This graphic is called Splash Screen.

An example of splash screen animation from Android's official document:

Splash screen will be shown in following scenarios:

Cold Start- A cold start refers to an app’s starting from scratch. Cold starts happen in cases such as your app’s being launched for the first time since the device booted, or since the system killed the app.
Warm Start- Warm start happen when user backs out from the app or when system evicts your app from memory, then user re-launches the app.

Implementation of Splash Screen API

Let's do some coding together.

Step 1:

Add following gradle dependency in your app level build.gradle file:

implementation "androidx.core:core-splashscreen:1.0.0-beta01"

Make sure compileSdkVersion of your app is 31 or above.

Now sync gradle.

Step 2:

Create a splash theme in values/themes.xml. Also it's night mode counterpart if you are supporting night mode i.e. in values-night/themes.xml. Splash theme would look like as follows:

<style name="Theme.MySplash" parent="Theme.SplashScreen">
        <item name="windowSplashScreenBackground">@color/purple_500</item>
        <item name="windowSplashScreenAnimatedIcon">@drawable/splash_animation</item>
        <item name="postSplashScreenTheme">@style/AppTheme</item>
        <item name="windowSplashScreenAnimationDuration">2000</item>
    </style>

where,

windowSplashScreenBackground- is the background color of your splash screen.
windowSplashScreenAnimatedIcon- is the icon resource to display at the centre of splash screen. This could be a normal drawable icon or animated drawable or animated vector drawable.
windowSplashScreenAnimationDuration- Duration(in milliseconds) of centre icon animation if it is animated resource. Keep in mind that, animation here will only work in Android 12 or above.
postSplashScreenTheme- This is the your app theme which will be applied after completion of splash screen.

Step 3:

Add this theme in AndroidManifest.xml file. Your manifest will look like as follows:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.otb.splashdemo">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.MySplash">
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

see android:theme="@style/Theme.MySplash" property.

Step 4

Inside the launcher activity, call activity's installSplashScreen() extension function before setContentView(). Below is an example:

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        installSplashScreen()
        setContentView(R.layout.activity_main)
    }
}

😃 That's it!!! Really simple steps right?

Advance Steps

Now what if you want to keep the splash screen till loading some data from local or remote data source? Then you can follow some advance steps:

Step 5

To keep splash screen even after app came in process, you need to use pre draw listener. Modify your activity as follows:

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        installSplashScreen()
        setContentView(R.layout.activity_main)
        setupPreDrawListener()
    }

    /**
     * Use this method only if you want to keep splash screen for longer than cold start time.
     * Manage `isReady` flag according to your logic.
     */
    private fun setupPreDrawListener() {
        // Set up an OnPreDrawListener to the root view.
        val content: View = findViewById(android.R.id.content)
        content.viewTreeObserver.addOnPreDrawListener(
            object : ViewTreeObserver.OnPreDrawListener {
                override fun onPreDraw(): Boolean {
                    // Check if the initial data is ready.
                    val isReady = true
                    return if (isReady) {
                        // The content is ready; start drawing.
                        content.viewTreeObserver.removeOnPreDrawListener(this)
                        true
                    } else {
                        // The content is not ready; suspend.
                        false
                    }
                }
            }
        )
    }
}

where, isReady is the flag which should come from your app's logical layer ViewModel.

Step 6

If you want to exit splash screen with some animation, you can do this using extension field splashScreen. This will work only for Android 12. Use below method creating custom exit animation:

private fun exitWithSlideUp(){
        splashScreen.setOnExitAnimationListener { splashScreenView ->
            // Create your custom animation.
            val slideUp = ObjectAnimator.ofFloat(
                splashScreenView,
                View.TRANSLATION_Y,
                0f,
                -splashScreenView.height.toFloat()
            )
            slideUp.interpolator = AnticipateInterpolator()
            slideUp.duration = 200L

            // Call SplashScreenView.remove at the end of your custom animation.
            slideUp.doOnEnd { splashScreenView.remove() }

            // Run your animation.
            slideUp.start()
        }
    }

For the ease of my readers, I have created Splash Demo GitHub Repo where you can see example implementation of splash screen API.

Conclusion

First impression is the last impression. If user sees blank screen on launching the app, it will create bad impact. To provide a better user experience, splash screen is a very useful API. To read more about splash screen, you can read official document.
Blog's banner credit goes to Wajahat Karim.
Thanks for reading my blog. 😇😇😇

Android app with MVVM + Room + Paging + Koin + Coroutine + Live Data + Retrofit

Mohit Rajput — Thu, 05 Nov 2020 13:35:20 +0000

Earlier, we didn't have architecture components officially from Android. A few years ago, Android introduced a set of components to develop Android applications with proper architecture under "Android Jetpack".

Jetpack is a suite of libraries to help developers follow best practices, reduce boilerplate code, and write code that works consistently across Android versions and devices so that developers can focus on the code they care about.

Components Used

In this article, we will develop a small Android application to demonstrate jetpack as well as a few more components which are as follows:

ViewModel- A jetpack component to architect app with MVVM. Here we will use data binding as well.
Room Database- It's a wrapper over the SQLite database to give developers an ORM-like feel.
Paging Library - The Paging Library helps you load and display a small amount of data at a time. Loading partial data on-demand reduces the usage of network bandwidth and system resources.
Coroutine- Coroutine is a framework in Kotlin to make asynchronous calls in a more readable fashion.
Koin- It's a dependency injection library that is very easy to use as compare to dagger or hilt.
Live Data- It's a life cycle aware observable data holder.
Retrofit- It's the most famous web service calling library which we will use in the app to fetch data from web API.

Repositories

I have developed the following apps to demonstrate these components-

Feel free to fork these repositories, add new features, and raise pull requests.

Coding Starts

Without too much description, I will add code snippets from GitHub Issues project here which are self-explanatory. For any query, you can use the comment section.

Here is the contract for github pull request list feature:

interface IssuesContract {
    interface ViewModel {
        fun getIssues(): LiveData<PagedList<IssuesModels.Issue>>
        fun getProgressStatus(): LiveData<ProgressStatus>
        fun searchIssues(githubOwner: String, repoName: String, state: String)
    }

    interface Repository {
        suspend fun searchIssues(githubOwner: String, repoName: String, state: String, pageNumber: Int): DataResult<List<IssuesModels.Issue>>
    }
}

Here is the implementation of our data layer:

class IssuesRepository(private val gitHubApiService: GitHubApiService, private val issuesDao: IssuesDao) : IssuesContract.Repository {
    companion object {
        const val PAGE_SIZE = 20
    }

    override suspend fun searchIssues(githubOwner: String, repoName: String, state: String, pageNumber: Int): DataResult<List<IssuesModels.Issue>> {
        val storedIssues = issuesDao.getIssues(githubOwner, repoName, state, ((pageNumber - 1) * PAGE_SIZE), PAGE_SIZE)
        if (storedIssues.isNotEmpty()) {
            val refreshInterval = 30 * 60 * 1000
            val oldestIssue = storedIssues.minBy { it.storedAt }
            if (System.currentTimeMillis() - oldestIssue!!.storedAt < refreshInterval) {
                return DataResult.DataSuccess(IssuesResponseToIssuesMapper().mapFromDatabase(storedIssues))
            } else {
                issuesDao.deleteIssues(githubOwner, repoName, state)
            }
        }

        val response = gitHubApiService.fetchIssues(githubOwner, repoName, state, pageNumber, PAGE_SIZE)
        return if (response.isSuccessful) {
            val issuesResponse = response.body()!!
            val issues = IssuesResponseToIssuesMapper().map(issuesResponse)
            issuesDao.insertAll(issues.map { IssuesModels.IssueEntity(it.id, it.patchUrl, it.title, it.number, it.userName, it.state, githubOwner, repoName, System.currentTimeMillis()) })
            DataResult.DataSuccess(issues)
        } else {
            DataResult.DataError(ErrorHandler.getError(response))
        }
    }
}

Here is the implementation of ViewModel:

class IssuesViewModel(private val repository: IssuesContract.Repository) : ViewModel(), IssuesContract.ViewModel {
    private val issuesDataSourceFactory: IssuesDataSourceFactory = IssuesDataSourceFactory(repository, viewModelScope)
    private val progressLoadStatus: LiveData<ProgressStatus>
    private val issues: LiveData<PagedList<IssuesModels.Issue>>

    init {
        val pagedListConfig = PagedList.Config.Builder()
                .setEnablePlaceholders(true)
                .setInitialLoadSizeHint(20)
                .setPageSize(20)
                .build()

        issues = LivePagedListBuilder<Int, IssuesModels.Issue>(issuesDataSourceFactory, pagedListConfig)
                .build()

        progressLoadStatus = Transformations.switchMap(issuesDataSourceFactory.liveData, IssuesDataSource::getProgressLiveStatus)
    }

    override fun getIssues() = issues

    override fun getProgressStatus() = progressLoadStatus

    override fun searchIssues(githubOwner: String, repoName: String, state: String) {
        issuesDataSourceFactory.githubOwner = githubOwner
        issuesDataSourceFactory.repoName = repoName
        issuesDataSourceFactory.state = state
        issues.value?.dataSource?.invalidate()
    }
}

Here you can see, we have used live data of PagedList. We have initialized paging related instanced i.e. paging config, data source etc. Now we will create data source factory:

class IssuesDataSourceFactory(private val repository: IssuesContract.Repository, private val scope: CoroutineScope) : DataSource.Factory<Int, IssuesModels.Issue>() {
    var githubOwner: String = ""
    var repoName: String = ""
    var state: String = ""

    val liveData = MutableLiveData<IssuesDataSource>()
    lateinit var issuesDataSource: IssuesDataSource

    override fun create(): DataSource<Int, IssuesModels.Issue> {
        issuesDataSource = IssuesDataSource(repository, scope, githubOwner, repoName, state)
        liveData.postValue(issuesDataSource)
        return issuesDataSource
    }
}

and here is the implementation of data source:

class IssuesDataSource(private val repository: IssuesContract.Repository, private val scope: CoroutineScope, private val githubOwner: String, private val repoName: String, private val state: String) : PageKeyedDataSource<Int, IssuesModels.Issue>() {
    private val progressLiveStatus = MutableLiveData<ProgressStatus>()

    fun getProgressLiveStatus() = progressLiveStatus

    override fun loadInitial(params: LoadInitialParams<Int>, callback: LoadInitialCallback<Int, IssuesModels.Issue>) {
        scope.launch {
            progressLiveStatus.postValue(ProgressStatus.Loading)
            when (val dataResult = repository.searchIssues(githubOwner, repoName, state, 1)) {
                is DataResult.DataSuccess -> {
                    progressLiveStatus.postValue(ProgressStatus.Success)
                    callback.onResult(dataResult.data, null, 2)
                }
                is DataResult.DataError -> progressLiveStatus.postValue(ProgressStatus.Error(dataResult.errorMessage))
            }
        }
    }

    override fun loadAfter(params: LoadParams<Int>, callback: LoadCallback<Int, IssuesModels.Issue>) {
        scope.launch {
            progressLiveStatus.postValue(ProgressStatus.Loading)
            when (val dataResult = repository.searchIssues(githubOwner, repoName, state, params.key)) {
                is DataResult.DataSuccess -> {
                    progressLiveStatus.postValue(ProgressStatus.Success)
                    callback.onResult(dataResult.data, params.key + 1)
                }
                is DataResult.DataError -> progressLiveStatus.postValue(ProgressStatus.Error(dataResult.errorMessage))
            }
        }
    }

    override fun loadBefore(params: LoadParams<Int>, callback: LoadCallback<Int, IssuesModels.Issue>) {

    }
}

Now it's time to create adapter for RecyclerView according to paging library:

class IssueAdapter : PagedListAdapter<IssuesModels.Issue, IssueAdapter.IssueViewHolder>(DiffUtilCallBack()) {

    inner class IssueViewHolder(private val binding: ItemIssueBinding) : RecyclerView.ViewHolder(binding.root) {

        fun bind(issue: IssuesModels.Issue) {
            binding.issue = issue
            binding.executePendingBindings()
        }
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): IssueViewHolder {
        val itemBinding: ItemIssueBinding = ItemIssueBinding.inflate(LayoutInflater.from(parent.context), parent, false)
        return IssueViewHolder(itemBinding)
    }

    override fun onBindViewHolder(holder: IssueViewHolder, position: Int) {
        holder.bind(getItem(position)!!)
    }
}

class DiffUtilCallBack : DiffUtil.ItemCallback<IssuesModels.Issue>() {
    override fun areItemsTheSame(oldItem: IssuesModels.Issue, newItem: IssuesModels.Issue) = oldItem.id == newItem.id

    override fun areContentsTheSame(oldItem: IssuesModels.Issue, newItem: IssuesModels.Issue): Boolean {
        return oldItem.id == newItem.id
                && oldItem.title == newItem.title
                && oldItem.number == newItem.number
    }
}

In the source code of GitHub Issues, IssuesFragment has complete code for initializing the ViewModel. Here is a snippet how can we observe data and set it to adapter:

private fun setupViewModel() {
        issuesViewModel.getIssues().observe(this, Observer {
            (rvIssues.adapter as IssueAdapter).submitList(it)
        })

        issuesViewModel.getProgressStatus().observe(this, Observer {
            when (it) {
                is ProgressStatus.Loading -> displayLoading()
                is ProgressStatus.Success -> hideLoading()
                is ProgressStatus.Error -> displayError(it.errorMessage)
            }
        })
        issuesViewModel.searchIssues(githubOwner, repoName, issueState)
    }

In the GitHubApp application class, you can see the setup of Koin and its global modules

class GitHubApp : Application() {
    override fun onCreate() {
        super.onCreate()
        initKoin()
    }

    private fun initKoin() {
        startKoin {
            androidLogger(Level.DEBUG)
            androidContext(this@GitHubApp)
            androidFileProperties()
            modules(provideModules())
        }
    }

    private fun provideModules() = listOf(retrofitModule, apiModule, databaseModule)
}

To see the complete working source code, fork

GitHub Issues or
Photo Search repository and run on the latest Android Studio.

If you have any doubt or query or need a detailed explanation of any component, drop in the comment box.

Publish Android Library Using GitHub Packages

Mohit Rajput — Mon, 24 Aug 2020 09:35:45 +0000

GitHub released GitHub Packages in November 2019. Now you can publish different kinds of packages or libraries i.e. maven, npm, ruby gems, docker, etc without subscribing to third party services.

In this article, we will see how to publish the Android library or any maven package i.e. JAR, AAR, etc. to GitHub Packages.
You can see the example project here.

You will learn everything about it in these simple steps:

Setup credentials
Publish Android library
Use the library in another project

Let's jump into the details:

Setup credentials

To publish any package to GitHub, you need GitHub username and GitHub token. Username is not a problem which you already have. Now you need to create GitHub token.
To create a new token, open menu by clicking on your profile picture at the top right of the GitHub account. Then go to,
Developer settings ➡ Personal access tokens ➡ Generate new token.
Here, make sure you checked the following permissions:

read:packages
write:packages
repo

This token cannot be seen again in GitHub. So copy the token and save it somewhere in your system or a secure place. If you didn't save copy it, you can generate a new one.

Publish Android library

When credentials are ready, it's time to add some code on your module-level gradle file.
Open module or library's build.gradle file and apply following plugin:

apply plugin: 'maven-publish'

Now it's time to define some methods which will return the information related to the library. Here are those methods:

// Place the version of your library here
def getVersionName = { ->
    return "0.0.1"
}

// Add the name of your library here
def getArtifactId = { ->
    return "analytics-sdk"
}

// Add the group ID of your library here
def getGroupId = { ->
    return "com.otb"
}

// Prepare URL of maven package.
// Replace 'mohitrajput987' with your github repo's username or organization name.
// Replace 'analytics-sdk-android' with the name of github repo
def getGitHubUrl = { ->
    return "https://maven.pkg.github.com/mohitrajput987/analytics-sdk-android"
}

Complete build.gradle file of library module will look like this:

apply plugin: 'java-library'
apply plugin: 'kotlin'
apply plugin: 'maven-publish'

def getVersionName = { ->
    return "0.0.1"
}

def getArtifactId = { ->
    return "analytics-sdk"
}

def getGroupId = { ->
    return "com.otb"
}

def getGitHubUrl = { ->
    return "https://maven.pkg.github.com/mohitrajput987/analytics-sdk-android"
}

publishing {
    publications {
        bar(MavenPublication) {
            groupId getGroupId()
            artifactId getArtifactId()
            version getVersionName()
            // Place the path of your artifact here
            artifact("$buildDir/libs/${getArtifactId()}.jar")
        }
    }
    repositories {
        maven {
            name = "GitHubPackages"

            url = uri(getGitHubUrl())
            credentials {
                username = System.getenv("GITHUB_USER_NAME")
                password = System.getenv("GITHUB_TOKEN")
            }
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
}

I have stored GitHub's username and password in an environment variable and getting those as follows:

username = System.getenv("GITHUB_USER_NAME")
password = System.getenv("GITHUB_TOKEN")

You can access them from local.properties file also.
Now sync gradle and you will see new gradle task publish.

It's time to create a new artifact and upload it to the GitHub package.
To create a new build, run following command:

./gradlew analytics-sdk:assemble

It will create the JAR file. To publish this to GitHub packages, run following command:

./gradlew analytics-sdk:publish

Replace analytics-sdk with your module project name.

After running these two commands, our package is published successfully. You can see that package in GitHub Packages.

You can also see the complete code of this project in this public repository:
Analytics GitHub Repository

Use the library in another project

We have published our library successfully to GitHub packages. To use this library in another project, add the following gradle dependency to app-level gradle file:

implementation "com.otb:analytics-sdk:0.0.1"

Whether it's a public or private repository, the user has to add package url and credentials in root level gradle file:

repositories {
   maven {
       url = "https://maven.pkg.github.com/mohitrajput987/analytics-sdk"
       credentials {
           username = GITHUB_USER
           password = GITHUB_TOKEN
       }
   }
}

The user's github token should have repo and read package permissions.
I know adding these credentials is painful for the open-source projects but it's mandatory for now. We can only hope that GitHub host these libraries in a central repository.

Yes, that's it!!!

Conclusion

Our library is published in GitHub packages and you can use it in your project. Do check this library at GitHub which will make your life easy if you are integrating analytics i.e. Mixpanel, Google Analytics to your project.
GitHub packages are really useful if you are already using GitHub ecosystem. You can easily publish Android and Java libraries here with few lines of setup.

DEV Community: Mohit Rajput

[Boost]

From Material 2 to Material You: Everything New in Material 3 for Android Developers

Mohit Rajput ・ Nov 11

From Material 2 to Material You: Everything New in Material 3 for Android Developers

What is Material 3?

Key New Features (vs. Material 2)

1. Dynamic Color (Biggest Feature)

2. New Design Tokens

3. New Components

🪄 Buttons

🪩 Chips

🧠 Cards

🧭 Navigation Bars

4. Tonal Elevation (Instead of Shadows)

5. MaterialTheme Changes

6. Updated Typography System

Example Source Code (Jetpack Compose M3)

Summary

Don’t let unnecessary recompositions kill your performance

Debugging Recompositions in Jetpack Compose

🔍 What Rebugger Does

🧠 How to Use

⚡ Why It’s Useful

💬 Let's Discuss

Mastering Kotlin Coroutines in Android: A Practical Guide

🌱 What is a Coroutine?

🧵 Coroutine vs Thread

🧭 Coroutine Scope

Common scopes:

🚀 launch vs async

🔹 launch: fire-and-forget

🔹 async: returns a Deferred

🔄 withContext: for switching threads

⚠️ Exception Handling in Coroutines

✅ Use try-catch inside coroutine blocks

✅ Use CoroutineExceptionHandler for top-level coroutines

📱 Real-world Example (Network + DB)

🧼 Best Practices

📚 Final Thoughts

New Android Studio Logcat

Filter Fields

Match Operators

Event Bus Pattern in Android Using Kotlin Flows

Implementation

Step 1:

Step 2:

Step 3:

Conclusion

RecyclerView pagination scroll listener in Android

What is pagination

Why pagination

Ways to use pagination

Simple scroll listener

Explanation

Conclusion

Launch modes of Android Activity

Important terms

Task

Back Stack

Launch Modes

1. Standard

2. Single top

3. Single task

4. Single instance

How to add launch modes

New Splash Screen API from Android

Definition of splash screen

Implementation of Splash Screen API

Step 1:

Step 2:

Step 3:

Step 4

Advance Steps

Step 5

Step 6

Conclusion

Android app with MVVM + Room + Paging + Koin + Coroutine + Live Data + Retrofit

Components Used

Repositories

🚀 `launch` vs `async`

🔹 `launch`: fire-and-forget

🔹 `async`: returns a `Deferred`

🔄 `withContext`: for switching threads

✅ Use `try-catch` inside coroutine blocks

✅ Use `CoroutineExceptionHandler` for top-level coroutines