DEV Community: AhsanAhmed03

Top Causes of ANRs in Android and How to Eliminate Them (Complete Developer Guide)

AhsanAhmed03 — Mon, 06 Apr 2026 18:33:15 +0000

Introduction

Imagine a user opens your Android app, taps a button, and nothing happens.

The screen freezes.

After a few seconds, Android shows:

Application Not Responding (ANR)

Most users don’t wait.

They close the app and uninstall it.

That’s why ANRs are one of the most dangerous performance issues in Android apps.

According to Android Developers documentation, ANRs happen when the main thread is blocked and cannot respond to user input within a specific time.

And if your ANR rate becomes high, Google Play can reduce your app visibility.

So understanding ANRs is not optional — it’s critical.

**What is an ANR? (Simple Explanation)

Official Definition**

ANR occurs when the UI thread is blocked and cannot process user input or draw frames.

Android shows ANR when:

Input event not handled within 5 seconds
BroadcastReceiver runs too long
Service takes too long to start
Job or foreground service delays response

Real-World Example

Think of your app like a restaurant.

UI Thread = Waiter
Background Thread = Kitchen
User = Customer

Good Flow

Customer orders → Waiter sends to kitchen → Kitchen prepares → Waiter delivers

Everything runs smoothly.

Bad Flow (ANR)

Customer orders → Waiter goes to kitchen and starts cooking himself

Now:

No one takes new orders
No one serves food
Restaurant stops working

This is exactly what happens when UI thread does heavy work.

Top Causes of ANRs

1. Heavy Work on Main Thread ❌

Problem

Running:

Network calls
Database queries
File reading
JSON parsing
Image processing

on UI thread.

Android documentation clearly states:

Keep main thread unblocked and move heavy work to worker threads

2. Long Database or Network Operations ❌

Example:

val data = api.getUsers() // running on main thread

This blocks UI.

Result → ANR.

3. BroadcastReceiver Doing Heavy Work ❌

BroadcastReceiver should do small quick tasks only.

If it runs too long → ANR.

Android recommends moving work to background threads.

4. Service Not Starting in Time ❌

Foreground service must call:

startForeground()

within 5 seconds.

Otherwise → ANR.

5. Deadlocks and Thread Blocking ❌

Example:

Thread A waiting for Thread B
Thread B waiting for Thread A

Result:

App freezes.

Android documentation calls this deadlock, a major ANR cause.

**Common Developer Mistakes

❌ Running API calls in Activity**

override fun onCreate() {
    super.onCreate()

    val users = api.getUsers()
}

Wrong approach.

❌ Large JSON parsing on UI thread

val json = File("data.json").readText()

ANR risk.

Best Practices to Avoid ANRs

✅ Use Coroutines

viewModelScope.launch {
    val users = repository.getUsers()
}

Moves work off main thread.

✅ Use Dispatchers.IO

withContext(Dispatchers.IO) {
    api.getUsers()
}

Optimized for I/O.

✅ Use Flow for Continuous Data

repository.getUsersFlow()
    .flowOn(Dispatchers.IO)

Efficient and non-blocking.

✅ Use WorkManager for Background Tasks

Good for:

Sync
Upload
Downloads
Scheduling

✅ Keep BroadcastReceiver Lightweight

override fun onReceive(context: Context, intent: Intent) {

    CoroutineScope(Dispatchers.IO).launch {
        repository.sync()
    }
}

Modern Kotlin Code Example
Repository

class UserRepository(
    private val api: UserApi
) {

    suspend fun getUsers(): List<User> {
        return withContext(Dispatchers.IO) {
            api.getUsers()
        }
    }
}

ViewModel

@HiltViewModel
class UserViewModel @Inject constructor(
    private val repository: UserRepository
) : ViewModel() {

    private val _users = MutableStateFlow<List<User>>(emptyList())
    val users = _users.asStateFlow()

    init {
        loadUsers()
    }

    private fun loadUsers() {
        viewModelScope.launch {
            _users.value = repository.getUsers()
        }
    }
}

Jetpack Compose UI

@Composable
fun UserScreen(viewModel: UserViewModel) {

    val users by viewModel.users.collectAsState()

    LazyColumn {
        items(users) { user ->
            Text(user.name)
        }
    }
}

Real-World Use Case
Video Fetching App

Scenario:

App scans device videos.

Wrong

Scanning files in Activity.

UI freezes.

ANR occurs.

Correct

Splash loads videos
Repository uses Dispatchers.IO
Flow emits data
UI updates smoothly

Result:

✔ No ANR
✔ Smooth scrolling
✔ Fast loading
✔ Better Play Store rating

**Key Takeaways

Core Rule**

Never block the main thread

Important Points

✔ UI thread must always be free
✔ Move heavy work to background threads
✔ Use Coroutines and Flow
✔ Keep BroadcastReceiver lightweight
✔ Use WorkManager for long tasks
✔ Avoid deadlocks and thread blocking
✔ Monitor ANR in Play Console

Conclusion

ANRs are not just performance issues.

They directly impact:

User experience
App rating
Play Store ranking
Revenue

The safest strategy is simple:

Keep the UI thread clean and move all heavy work to background threads.

If you follow Android’s official guidelines and modern Kotlin practices, ANRs can be almost eliminated.

Feel free to reach out to me with any questions or opportunities at (aahsanaahmed26@gmail.com)
LinkedIn (https://www.linkedin.com/in/ahsan-ahmed-39544b246/)
Facebook (https://www.facebook.com/profile.php?id=100083917520174).
YouTube (https://www.youtube.com/@mobileappdevelopment4343)
Instagram (https://www.instagram.com/ahsanahmed_03/)

🚀 Why Your Android App is Slow (And How to Fix It)

AhsanAhmed03 — Mon, 06 Apr 2026 18:07:29 +0000

You launch your app…
It takes 3 seconds to open.

You scroll a list…
It lags and stutters.

You tap a button…
Nothing happens for a moment.

Sound familiar?

If yes, your app isn’t just “a bit slow” — it’s silently losing users.

👉 Studies show users uninstall apps that feel sluggish within minutes.

The good news?
Most performance issues in Android apps are predictable and fixable — once you understand what’s happening under the hood.

🧠 Deep Dive: Why Android Apps Become Slow

Let’s simplify how Android works internally.

🧩 The Main Thread (UI Thread)
Think of your app like a restaurant kitchen:

The Main Thread = the chef
UI rendering, clicks, animations = orders

👉 If the chef is busy doing something heavy (like calculating data or loading images), new orders get delayed.

Result:

UI freezes
Laggy scrolling
ANRs (Application Not Responding)

⏱️ The 16ms Rule
Android tries to render 60 frames per second.

That means:

Each frame must be drawn in 16ms

If your app takes longer:

Frames drop ❌
UI becomes janky ❌

🔥 Common Causes of Slowness

Problem: Heavy work on Main Thread
Why: Blocks UI

Problem: Unoptimized RecyclerView
Why: Rebinding too much

Problem: Memory leaks
Why: App slows over time

Problem: Too many recompositions (Compose)
Why: Extra rendering

Problem: Large images
Why: High memory + slow decoding

Problem: Bad architecture
Why: Uncontrolled state updates

**🛠️ Fix #1: Move Work Off the Main Thread (Coroutines)

❌ Bad Example (UI Freeze)**

fun loadData() {
    val data = repository.getDataFromNetwork() // Blocking call
    textView.text = data
}

👉 This blocks UI.

**✅ Good Example (Using Coroutines)

ViewModel (Best Practice)**

class MainViewModel(
    private val repository: DataRepository
) : ViewModel() {

    private val _data = MutableStateFlow<String>("")
    val data: StateFlow<String> = _data

    fun loadData() {
        viewModelScope.launch {
            val result = withContext(Dispatchers.IO) {
                repository.getDataFromNetwork()
            }
            _data.value = result
        }
    }
}

👉 Why this works:

Dispatchers.IO → runs in background thread
viewModelScope → lifecycle-safe (no leaks)

**🧱 Fix #2: Optimize RecyclerView (XML)

❌ Common Mistakes**

Not using DiffUtil
Calling notifyDataSetChanged()
Heavy work in onBindViewHolder

✅ Use ListAdapter + DiffUtil

class UserAdapter : ListAdapter<User, UserAdapter.ViewHolder>(DiffCallback()) {

    class ViewHolder(val binding: ItemUserBinding) :
        RecyclerView.ViewHolder(binding.root)

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        val binding = ItemUserBinding.inflate(
            LayoutInflater.from(parent.context), parent, false
        )
        return ViewHolder(binding)
    }

    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        val user = getItem(position)
        holder.binding.name.text = user.name
    }
}

class DiffCallback : DiffUtil.ItemCallback<User>() {
    override fun areItemsTheSame(old: User, new: User) = old.id == new.id
    override fun areContentsTheSame(old: User, new: User) = old == new
}

👉 Why this is fast:

Only updates changed items
Avoids full list redraw

**⚡ Fix #3: Jetpack Compose Performance

❌ Bad Compose Code**

@Composable
fun UserScreen(users: List<User>) {
    users.forEach {
        Text(it.name)
    }
}

👉 Problem:

No lazy loading
Renders everything at once

*✅ Use LazyColumn *

@Composable
fun UserScreen(users: List<User>) {
    LazyColumn {
        items(users) { user ->
            Text(text = user.name)
        }
    }
}

🔁 Avoid Unnecessary Recompositions

@Composable
fun UserItem(user: User) {
    val name = remember(user.id) { user.name }
    Text(text = name)
}

👉 remember prevents recomputation.

**🧠 Fix #4: Memory Leaks (Silent Killer)

❌ Common Leak**

object Singleton {
    lateinit var context: Context
}

👉 Holding Activity context = memory leak.

✅ Correct Way

object Singleton {
    lateinit var context: Context

    fun init(appContext: Context) {
        context = appContext.applicationContext
    }
}

💡 Use LeakCanary

debugImplementation "com.squareup.leakcanary:leakcanary-android:2.12"

👉 Detects memory leaks automatically.

**🖼️ Fix #5: Image Optimization

❌ Problem**

Loading full-size images
No caching

✅ Use Coil (Modern Best Practice)

implementation "io.coil-kt:coil-compose:2.5.0"

AsyncImage(
    model = "https://example.com/image.jpg",
    contentDescription = null
)

👉 Benefits:

Auto caching
Efficient decoding
Works with Compose

🧱 Fix #6: Avoid Overdraw
👉 Overdraw = drawing pixels multiple times

Solution:

Use fewer nested layouts
Avoid unnecessary backgrounds

⚡ Fix #7: Use Baseline Profiles (Advanced 🚀)

👉 Speeds up app startup significantly.

Dependency

implementation "androidx.profileinstaller:profileinstaller:1.3.1"

👉 Pre-compiles critical code paths.

🚨 Edge Cases & Real Problems

1. ANR (Application Not Responding)

Caused by blocking UI thread > 5 seconds
Fix → Move work to background

2. Too Many API Calls

Use caching (Room / memory cache)
Debounce user input

3. ViewBinding Leaks (Important ⚠️)

private var _binding: FragmentMainBinding? = null
private val binding get() = _binding!!

override fun onDestroyView() {
    _binding = null
}

👉 Prevents fragment leaks.

4. Compose + State Explosion

👉 Avoid:

var state by mutableStateOf(...)

inside large composables without scoping.

👉 Use:

ViewModel
StateFlow

🧩 Architecture Matters

👉 Bad architecture = performance issues

Recommended Stack:

MVVM
StateFlow
Repository pattern
Single source of truth

📊 Quick Performance Checklist

✅ No heavy work on Main Thread
✅ Use LazyColumn / RecyclerView properly
✅ Optimize images
✅ Avoid memory leaks
✅ Minimize recompositions
✅ Use background threads
✅ Use profiling tools (Android Studio Profiler)

🎯 Final Thought

Performance is not something you “add later.”

It’s something you design from day one.

A fast app feels:

Premium 💎
Reliable 🔒
Professional 🚀

💬 Your Challenge

👉 Open your current project and answer this:

“Where am I blocking the main thread without realizing it?”

“How many unnecessary recompositions are happening in my Compose UI?”

Drop your answer in the comments 👇
Let’s debug together.

Networking in Android: Why Ktor is the Modern Choice for Kotlin Developers

AhsanAhmed03 — Tue, 31 Mar 2026 14:59:16 +0000

Are you still using Retrofit because “that’s how it’s always been done”? It’s time to look at a networking engine built from the ground up for Kotlin Multiplatform and Coroutines.

Introduction
For years, Retrofit has been the undisputed king of Android networking. But as the ecosystem shifts toward Kotlin Multiplatform (KMP) and Compose Multiplatform, we need a tool that speaks “native Kotlin.”

Enter Ktor. Developed by JetBrains, Ktor is a lightweight, asynchronous framework that allows you to build both servers and clients. In Android, the Ktor Client provides a flexible, coroutine-powered way to handle API calls with less “magic” and more control.

Why Switch to Ktor?

Multiplatform Ready: Use the same networking code for Android, iOS, Desktop, and Web.
Coroutine First: No more adapters or complex wrappers; it works with suspend functions out of the box.
Modular: You only install the features you need (Logging, Content Negotiation, Auth), keeping your app lean.

Setting Up Ktor in Android

To get started, add these dependencies to your libs.versions.toml or build.gradle.kts file. We’ll use the Android engine and Serialization for JSON parsing.

// Dependencies (Simplified)
implementation("io.ktor:ktor-client-android:2.3.x")
implementation("io.ktor:ktor-client-content-negotiation:2.3.x")
implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.x")
implementation("io.ktor:ktor-client-logging:2.3.x")

Practical Implementation: The “Ktor Way”

Following modern Android architecture (MVVM), here is how you define a clean, production-ready API client.

1. The Data Model

@Serializable
data class Post(
    val id: Int,
    val title: String,
    val body: String
)

2. The Ktor Client Configuration

Unlike Retrofit interfaces, Ktor uses a functional approach.

object KtorClient {
    val httpClient = HttpClient(Android) {
        // 1. JSON Parsing
        install(ContentNegotiation) {
            json(Json {
                prettyPrint = true
                ignoreUnknownKeys = true
            })
        }

        // 2. Logging for debugging
        install(Logging) {
            level = LogLevel.BODY
        }

        // 3. Default Request configuration
        defaultRequest {
            url("https://jsonplaceholder.typicode.com/")
            header(HttpHeaders.ContentType, ContentType.Application.Json)
        }
    }
}

3. The Repository and ViewModel

Using StateFlow and Coroutines to fetch data safely.

class PostRepository {
    suspend fun getPosts(): List<Post> {
        return KtorClient.httpClient.get("posts").body()
    }
}

class PostViewModel(private val repository: PostRepository = PostRepository()) : ViewModel() {
    private val _posts = MutableStateFlow<List<Post>>(emptyList())
    val posts = _posts.asStateFlow()

    fun fetchPosts() {
        viewModelScope.launch {
            try {
                _posts.value = repository.getPosts()
            } catch (e: Exception) {
                // Handle errors (Timeout, Connectivity, etc.)
            }
        }
    }
}

Best Practices

Close the Client: Always close the HttpClient when it’s no longer needed (though in a singleton Android app, it usually lives with the App lifecycle).
Use Plugins: Don’t write manual JSON parsers; use the ContentNegotiation plugin.
Platform Engines: Use CIO (Coroutine-based I/O) for high performance or Android for better integration with system proxy settings.

Common Mistakes to Avoid

Hardcoding URLs: Use the defaultRequest block to manage base URLs.
Blocking the Main Thread: Ktor is asynchronous, but always ensure your calls are wrapped in a viewModelScope or appropriate Coroutine Scope.
Forgetting ProGuard Rules: If you use Kotlinx Serialization, ensure your ProGuard rules keep your @Serializable classes.

Conclusion
Ktor isn’t just a “Retrofit alternative” — it’s the future of Kotlin networking. It offers more flexibility and is essential if you ever plan to share your logic with an iOS app.

What do you think? Have you tried Ktor in a production Android app yet, or are you sticking with Retrofit for now? Let’s chat in the comments!

Android XML vs Jetpack Compose — Which One Should You Use in 2026?

AhsanAhmed03 — Mon, 30 Mar 2026 18:41:33 +0000

Every Android Developer Faces This

You open a new Android project and get stuck at one question:

Should I use XML or Jetpack Compose?

If you’ve been working with Android for a while, XML feels familiar. It’s stable, predictable, and widely used.

But then you see Jetpack Compose — modern, Kotlin-first, less boilerplate, and backed heavily by Google.

Now the confusion starts:

Is XML outdated?
Is Compose production-ready?
Which one is better for performance?
What should I use in real apps?

Let’s break it down deeply, but simply.

🧠 Understanding the Core Difference

🏗️ XML (View System)

Think of XML like designing a house blueprint separately from construction.

UI is written in XML files
Logic is written in Kotlin/Java
You connect them using findViewById or ViewBinding

👉 Two separate worlds:

XML → UI
Kotlin → Logic

⚡ Jetpack Compose

Compose is like building the house directly in code, live, and reactive.

UI is written in Kotlin
No XML at all
UI automatically updates when data changes

👉 Single source of truth:

Kotlin handles everything

🔍 Deep Dive (Based on Official Android Architecture)

XML (View System Internals)
Uses View hierarchy (ViewGroup → View)
UI rendering happens via:
Measure → Layout → Draw
Heavy nesting = performance cost

Problem:

Updating UI manually:

textView.text = "Hello"
button.visibility = View.GONE

👉 You control everything manually.

Jetpack Compose Internals

Compose works on Declarative UI + State-driven rendering

Core Concepts:

Composable Functions
State
Recomposition

How it works:

You describe UI as a function
When state changes → Compose redraws only affected parts

👉 Think like this:

@Composable
fun Greeting(name: String) {
    Text(text = "Hello $name")
}

If name changes → UI updates automatically.

🛠️ Implementation (Production-Ready Examples)

🧱 XML Example (Classic UI)

Gradle

android {
    buildFeatures {
        viewBinding true
    }
}

layout/activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="vertical">

    <TextView
        android:id="@+id/tvTitle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello XML"
        android:textSize="20sp"/>

    <Button
        android:id="@+id/btnClick"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Click Me"/>
</LinearLayout>

MainActivity.kt

class MainActivity : AppCompatActivity() {

    private lateinit var binding: ActivityMainBinding // Avoid findViewById

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

        binding.btnClick.setOnClickListener {
            binding.tvTitle.text = "Clicked!"
        }
    }
}

⚠️ Issues in XML Approach

Boilerplate code
Manual UI updates
Risk of memory leaks (if binding mishandled)
Hard to maintain large UI

⚡ Jetpack Compose Example

Dependencies

implementation "androidx.compose.ui:ui:1.6.0"
implementation "androidx.compose.material3:material3:1.2.0"
implementation "androidx.activity:activity-compose:1.8.2"

MainActivity.kt

class MainActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MyApp()
        }
    }
}

UI Code

@Composable
fun MyApp() {
    var text by remember { mutableStateOf("Hello Compose") }

    Column(
        modifier = Modifier.fillMaxSize(),
        verticalArrangement = Arrangement.Center,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {

        Text(
            text = text,
            fontSize = 20.sp
        )

        Button(
            onClick = {
                text = "Clicked!"
            }
        ) {
            Text("Click Me")
        }
    }
}

🔥 Why This Is Better

No XML
No binding
No manual UI updates

State-driven UI
👉 UI reacts automatically

⚠️ Edge Cases & Real-World Considerations

1. Performance

XML:

Faster initial load
Heavy layouts = slow rendering

Compose:

Slight startup overhead
Faster updates due to recomposition

👉 Best Practice:

Avoid unnecessary recompositions

Use remember, derivedStateOf

2. Memory Management

XML:

Risk of leaks with binding
Fragment lifecycle issues

Compose:

Lifecycle-aware by default
Safer memory handling

👉 Compose reduces leak chances significantly.

3. Large Projects

XML:

Hard to scale
Multiple files → difficult navigation

Compose:

Modular UI
Reusable components

4. Interoperability (IMPORTANT)

You don’t need to fully switch.

👉 You can mix both:

setContent {
    AndroidView(
        factory = { context ->
            LayoutInflater.from(context).inflate(R.layout.old_layout, null)
        }
    )
}

🧠 When Should You Use What?

Use XML if:

Maintaining legacy apps
Team not trained in Compose
Simple static UI

Use Compose if:

Starting a new project
Building scalable UI
Want modern architecture
Using Kotlin fully

🏁 Final Verdict

👉 XML is stable and proven

👉 Compose is the future

Google is clearly pushing Compose:

New libraries → Compose-first
Material 3 → Compose-first
Updates → Compose-focused

🎯 Challenge for You

👉 Have you tried migrating an XML screen to Compose?

What problems did you face?
Did performance improve or not?

💬 Drop your experience in comments — let’s learn from real-world cases.

Understanding Flows in Android: A Simple Guide with Examples

AhsanAhmed03 — Tue, 03 Dec 2024 17:21:16 +0000

When building Android apps, you often deal with data that changes over time — like user input, API responses, or database updates. Handling these changes efficiently and reactively can be tricky. That’s where Kotlin Flows come in!

Kotlin Flows are a powerful tool for working with streams of data asynchronously. They’re part of Kotlin’s coroutines framework, designed to handle data that flows over time, making your code clean, efficient, and reactive.

What Are Flows?

Think of Flows as a stream of data that emits values over time. For example:

A flow might emit values when a database gets updated.
It could emit a new value every time a user enters text in a search bar.

Flows are cold by default, meaning they don’t start emitting values until they are collected. This makes them efficient since no work is done unless there’s a listener (collector).

Why Use Flows?

Simplify Asynchronous Tasks: Flows make it easier to handle data that updates over time without writing complex callback code.

Efficient & Reactive: They only do work when needed, saving resources.

Built for Coroutines: Since Flows are part of Kotlin’s coroutine library, they play well with other coroutine features like launch and async.

Flows in Android: Some Practical Examples

Imagine you want to fetch and display a list of items from a database that updates in real time. Here’s how you might use a Flow:

Steps:

Create a Fake Database with a method to return a Flow of items.
Use a Repository to provide the data from the fake database.
Collect the data in your ViewModel and expose it as a StateFlow or LiveData.
Observe the data in the Activity/Fragment

// Fake Database
object FakeDatabase {
    // Simulate fetching a list of items from a database
    fun getItems(): Flow<List<String>> = flow {
        emit(emptyList()) // Emit an empty list initially
        delay(1000) // Simulate a delay for fetching data
        emit(listOf("Item 1", "Item 2", "Item 3", "Item 4")) // Emit the actual list
    }
}

Repository Implementation:

class FakeRepository {
    // Fetch items from the fake database
    fun fetchItems(): Flow<List<String>> = FakeDatabase.getItems()
}

ViewModel Implementation:

class ItemViewModel : ViewModel() {
    private val repository = FakeRepository()

    // StateFlow to hold the list of items
    private val _items = MutableStateFlow<List<String>>(emptyList())
    val items: StateFlow<List<String>> get() = _items

    init {
        fetchItems()
    }

    private fun fetchItems() {
        viewModelScope.launch {
            repository.fetchItems().collectLatest { fetchedItems ->
                _items.value = fetchedItems
            }
        }
    }
}

Activity/Fragment Implementation

class MainActivity : AppCompatActivity() {

    private val viewModel: ItemViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Collect items and update the RecyclerView adapter
        lifecycleScope.launch {
            viewModel.items.collectLatest { items ->
                Log.d("LOG_TAG","Data from Database: $items")
            }
        }
    }
}

Key Points in This Example:

Fake Database: Provides data using a Flow. Simulates asynchronous fetching.
Repository: Acts as a bridge between the database and ViewModel.
ViewModel: Uses a StateFlow to expose the fetched data.
Activity/Fragment: Collects the StateFlow and print it on logcat

Monitor network connection Using Flows

Steps:

Use ConnectivityManager to monitor the network connection.
Create a Flow to emit connection status updates.
Collect the Flow in your activity or fragment and show the toast accordingly.

Code Implementation:

// Create a Flow to emit internet connectivity status
    fun observeNetworkStatus(context: Context): Flow<Boolean> = callbackFlow {
        val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

        val networkCallback = object : ConnectivityManager.NetworkCallback() {
            override fun onAvailable(network: Network) {
                trySend(true) // Emit 'true' when connected
            }

            override fun onLost(network: Network) {
                trySend(false) // Emit 'false' when disconnected
            }
        }

        // Register network callback
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            connectivityManager.registerDefaultNetworkCallback(networkCallback)
        } else {
            val networkRequest = android.net.NetworkRequest.Builder()
                .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                .build()
            connectivityManager.registerNetworkCallback(networkRequest, networkCallback)
        }

        awaitClose {
            // Unregister callback when Flow collection is canceled
            connectivityManager.unregisterNetworkCallback(networkCallback)
        }
    }.distinctUntilChanged(
Usage in an Activity or Fragment:

// Observe network status and show toast
        lifecycleScope.launch {
            observeNetworkStatus(this@MainActivity).collectLatest { isConnected ->
                val message = if (isConnected) {
                    "Internet Connected"
                } else {
                    "Internet Disconnected"
                }
                Toast.makeText(this@MainActivity, message, Toast.LENGTH_SHORT).show()
            }
        }

Conclusion

Kotlin Flows make managing asynchronous data streams a breeze. They simplify your code, eliminate callback hell, and make your apps more reactive. Whether you’re handling user interactions or real-time updates, Flows are a go-to solution for modern Android development.

Start exploring Flows today and take your Android apps to the next level!

Getting Started with Coroutines in Android Kotlin: Asynchronous Programming in Android

AhsanAhmed03 — Tue, 03 Dec 2024 17:11:23 +0000

When building Android apps, you’ll often need to perform tasks like fetching data from a server, accessing a database, or processing files. These tasks can take time and, if not handled properly, may cause your app to freeze. Enter Kotlin Coroutines: a powerful tool that simplifies asynchronous programming while keeping your app smooth and responsive.

What Are Coroutines?

Coroutines are Kotlin’s way of handling asynchronous tasks in a structured and simple manner. Think of them as lightweight threads that let you perform long-running tasks like downloading files or fetching data without blocking the main thread.

Why Use Coroutines in Android?

Avoid Freezing the UI: Coroutines let you offload long-running tasks to a background thread, keeping the app’s user interface smooth and responsive.
Simpler Code: No more messy callbacks or complex threading logic. Coroutines allow you to write asynchronous code sequentially, making it easy to read and maintain.
Lightweight: Unlike traditional threads, coroutines are very efficient and lightweight. You can run thousands of coroutines without straining system resources.

Getting Started with Coroutines

Basic Coroutine Example
Here’s how you can launch a coroutine to perform a task in the background:

fun main() = runBlocking { // Start a coroutine scope
    launch { // Launch a coroutine
        delay(1000L) // Simulate a background task (1-second delay)
        println("Task completed!")
    }
    println("Hello, coroutines!")
}

Output:

Hello, coroutines!
Task completed! (after 1 second)

Using Coroutines in Android

In Android, coroutines are often used with ViewModel, Room, or network calls. Here’s how to use coroutines in an Android project:

1. Launching Coroutines in the ViewModel

Use the viewModelScope to launch coroutines tied to the lifecycle of a ViewModel:

class MyViewModel : ViewModel() {

    fun fetchData() {
        viewModelScope.launch { // Launch coroutine tied to ViewModel
            delay(2000L) // Simulate network call
            println("Data fetched!")
        }
    }
}

2. Making Network Requests with Coroutines

You can perform network operations using libraries like Retrofit with coroutines:

Retrofit Service:

interface ApiService {
    @GET("data")
    suspend fun fetchData(): List<String> // `suspend` makes it coroutine-friendly
}

ViewModel Example:

class MyViewModel(private val apiService: ApiService) : ViewModel() {

    fun fetchApiData() {
        viewModelScope.launch {
            try {
                val data = apiService.fetchData() // Call API
                println("Received data: $data")
            } catch (e: Exception) {
                println("Error: ${e.message}")
            }
        }
    }
}

Key Coroutine Builders

launch

Launches a coroutine that doesn’t return a result.
Example: Background tasks like database updates.

async

Launches a coroutine that returns a result using await().
Example: Fetching data from multiple APIs in parallel.

runBlocking

Blocks the thread until the coroutine completes (used mainly for testing).

Coroutine Scopes in Android

GlobalScope

For long-running application-wide tasks (use cautiously).

viewModelScope

Ideal for launching coroutines in a ViewModel.

lifecycleScope

For launching coroutines in an Activity or Fragment tied to their lifecycle.

Practical Example: Room Database + Coroutines

Here’s how you can use coroutines with Room to fetch data:

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    suspend fun getUsers(): List<User> // Coroutine-friendly
}

class UserRepository(private val userDao: UserDao) {
    suspend fun fetchUsers() = userDao.getUsers()
}

class MyViewModel(private val repository: UserRepository) : ViewModel() {
    fun loadUsers() {
        viewModelScope.launch {
            val users = repository.fetchUsers()
            println("Loaded users: $users")
        }
    }
}

Conclusion

Kotlin Coroutines are a game-changer for Android development. They make asynchronous programming easy to understand and maintain, ensuring that your app remains responsive. With the ability to handle background tasks seamlessly, coroutines are an essential tool for every Android developer.

Start using coroutines today, and make your code cleaner, faster, and more efficient!

Create Responsive UI in Android Studio using SDP & SSP

AhsanAhmed03 — Tue, 03 Dec 2024 15:43:36 +0000

Creating a responsive UI is essential for Android apps to look good on devices with different screen sizes. Hardcoding dimensions and text sizes using dp and sp can lead to inconsistencies. This is where SDP (Scalable DP) and SSP (Scalable SP) come to the rescue! These libraries ensure that your app adapts gracefully to various screen sizes.

What Are SDP and SSP?

SDP (Scalable DP): A library that scales your layout dimensions (like width, height, margins, or paddings) automatically based on the screen size.

SSP (Scalable SP): Similar to SDP, but specifically for text sizes. It ensures text remains legible across devices without looking too big or small.

Why Use SDP and SSP?

Consistency: Ensures your app looks uniform across small, medium, and large devices.

Ease of Use: Removes the need to create multiple layout files for different screen sizes.

Scalability: Automatically adjusts dimensions and text sizes for various screen densities.

How to Use SDP and SSP in Your Project

Step 1: Add the Dependencies

First, you need to add the SDP and SSP libraries to your project.
Open the build.gradle file for your app module.
Add the following dependencies:

implementation ("com.intuit.sdp:sdp-android:1.1.1") implementation ("com.intuit.ssp:ssp-android:1.1.1")

Click Sync Now to download the libraries.

Step 2: Use SDP for Dimensions

Instead of hardcoding dp values in your XML layout, use SDP values like @dimen/_16sdp. The SDP library provides pre-defined values that scale automatically.

Example

<TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Welcome!" android:textSize="@dimen/_16ssp" android:textColor="@color/black" />

Here, the text size adjusts automatically while maintaining proportionality with other elements.

Step 4: Test Your Layout

Open the Preview panel in Android Studio.
Use the device size switcher (top bar in the design view) to simulate different screen sizes and densities.
Ensure all elements scale properly without overlapping or cutting off.

Tips for Best Results

Always combine SDP and SSP with ConstraintLayout or LinearLayout for better alignment and scaling.
Avoid fixed sizes (e.g., match_parentor wrap_content) when SDP or SSP can handle it.
Use tools attributes in your layouts to preview different text and dimension sizes without running the app.

Conclusion

Using SDP and SSP is a simple yet powerful way to create a responsive UI in Android. By following the steps above, you can ensure your app looks great on any screen size — no more messy layouts or unreadable text!

Give SDP and SSP a try in your next project and see the difference it makes. Happy coding! 😊

Implementing Firebase Cloud Messaging (FCM) in Android Studio with Kotlin | Step-by-Step Tutorial

AhsanAhmed03 — Fri, 12 Apr 2024 18:45:12 +0000

Welcome to this tutorial where we'll explore the powerful capabilities of Firebase Cloud Messaging (FCM) in Android Studio using Kotlin. FCM enables you to send and receive push notifications effortlessly in your app. From setting up Firebase in your project to implementing FCM messaging, this tutorial covers everything you need to know to leverage the full potential of Firebase in your Android app development journey.

Step 1: Setting Up Firebase in Your Project
Firstly, we'll guide you through the process of setting up Firebase in your Android Studio project. You'll learn how to create a Firebase project, add your app to the Firebase project, and configure the necessary dependencies.

Step 2: Configuring FCM in Firebase Console
Next, we'll show you how to configure Firebase Cloud Messaging in the Firebase console. You'll understand how to generate and retrieve the necessary credentials for integrating FCM into your app.

Step 3: Integrating FCM into Your App
In this step, we'll dive into the implementation details of integrating FCM into your Android app using Kotlin. You'll learn how to handle device registration, receive FCM messages, and process them to display push notifications.

Step 4: Sending Push Notifications from Firebase Console
We'll demonstrate how to send push notifications from the Firebase console to your app using FCM. You'll understand the various options available for targeting specific devices and user segments with personalized notifications.

Step 5: Testing and Debugging FCM Integration
Finally, we'll cover testing and debugging techniques to ensure the seamless integration of FCM into your app. You'll learn how to verify the delivery of push notifications and troubleshoot common issues.

Conclusion:
Congratulations! You've successfully learned how to implement Firebase Cloud Messaging (FCM) in Android Studio using Kotlin. This tutorial has equipped you with the knowledge and skills to leverage FCM for sending and receiving push notifications in your Android app. We hope you found this tutorial helpful in enhancing your app's engagement and user experience.

If you have any questions or comments, please feel free to leave them below. Don't forget to subscribe to our channel for more tutorials on Android app development with Kotlin and Firebase integration.

Now, armed with the capabilities of Firebase Cloud Messaging, you're ready to enhance communication with your app users through timely and relevant push notifications. Happy coding!

Implementing Google AdMob Interstitial Ads in Android Studio with Java | Step-by-Step Tutorial

AhsanAhmed03 — Tue, 09 Apr 2024 18:18:14 +0000

Welcome to this detailed guide on implementing Google AdMob Interstitial Ads in Android Studio using Java. This tutorial covers the entire process, from loading Interstitial ads to displaying them in your app. Whether you're a seasoned developer or just beginning your app monetization journey, this video provides essential insights into maximizing your earnings through AdMob Interstitial ads.

Step 1: Setting Up Google AdMob Account and Creating Ad Units
To start, we'll guide you through the process of setting up a Google AdMob account and creating Interstitial ad units. You'll learn how to configure ad units to match the requirements of your app.

Step 2: Adding Google AdMob Dependency to Your Project
Next, we'll demonstrate how to add the Google AdMob dependency to your Android Studio project using Java. You'll understand the importance of integrating the AdMob SDK for seamless ad functionality.

Step 3: Loading Interstitial Ads
In this step, we'll cover how to load Interstitial ads into your app. You'll learn the necessary code implementation to fetch ads from the AdMob network.

Step 4: Displaying Interstitial Ads
We'll guide you through the process of displaying Interstitial ads at appropriate moments within your app. You'll understand how to trigger ad display events and ensure a smooth user experience.

Step 5: Maximizing Revenue and User Experience
In this final step, we'll discuss strategies for maximizing revenue while maintaining a positive user experience. You'll gain insights into ad placement, frequency, and other best practices.

Conclusion:
Congratulations! You've successfully learned how to implement Google AdMob Interstitial Ads in Android Studio using Java. This tutorial has equipped you with practical insights to monetize your app effectively and maximize earnings through AdMob Interstitial ads.

If you have any questions or comments, please feel free to leave them below. Don't forget to subscribe to our YouTube channel for more exciting tutorials on Android app development and monetization strategies.

Now, armed with the knowledge of Google AdMob Interstitial ads implementation, you're ready to boost your app's revenue and provide users with a seamless ad experience. Happy coding!

Source Code: https://github.com/AhsanAhmed03/AdMob-Ads-Java

Implementing Google AdMob Banner Ads in Android Studio with Java | Easy Step-by-Step Guide

AhsanAhmed03 — Sun, 28 Jan 2024 08:38:19 +0000

Welcome to this step-by-step tutorial where we'll dive into the world of app monetization. In this video, you'll learn how to implement Google AdMob Banner Ads in Android Studio using Java. We'll cover the integration of three distinct banner ad sizes—Simple Banner Ad, Medium Rectangle Banner Ad, and Large Banner Ad. Whether you're a seasoned developer or just starting with app monetization, this tutorial offers valuable insights into maximizing revenue through AdMob ads.

Step 1: Setting Up Google AdMob Account and Creating Ad Units
To begin, we'll guide you through the process of setting up a Google AdMob account and creating ad units. You'll learn how to configure different banner ad sizes to suit your app's layout.

Step 2: Adding Google AdMob Dependency to Your Project
In this step, we'll demonstrate how to add the Google AdMob dependency to your Android Studio project using Java. You'll understand the importance of integrating the AdMob SDK for seamless ad functionality.

Step 3: Implementing Simple Banner Ads
Next, we'll guide you through the implementation of simple banner ads. You'll learn how to seamlessly integrate banner ads into your app's layout, providing a non-intrusive monetization strategy.

Step 4: Implementing Medium Rectangle and Large Banner Ads
We'll cover the implementation of medium rectangle and large banner ads, offering you flexibility in choosing ad formats that complement your app's design and layout.

Step 5: Maximizing Revenue and User Experience
In this step, we'll discuss strategies for maximizing revenue while ensuring a positive user experience. You'll gain insights into ad placement, frequency, and other best practices.

Conclusion:
Congratulations! You've successfully learned how to implement Google AdMob banner ads in Android Studio using Java. This tutorial has equipped you with practical insights to monetize your app effectively and enhance user engagement through well-integrated ads.

Now, armed with the knowledge of Google AdMob implementation, you're ready to boost your app's revenue and provide users with a seamless ad experience. Happy coding!

Build android apps without coding
Start for free: https://try.draftbit.com/buildwithoutcode

Source Code: https://github.com/AhsanAhmed03/AdMob-Ads-Java

Implementing Google AdMob Banner Ads with Shimmer Effect in Android Studio using Kotlin | Step-by-Step Guide

AhsanAhmed03 — Fri, 12 Jan 2024 17:39:02 +0000

Welcome to this tutorial where you'll learn how to seamlessly integrate different types of banner ads from Google AdMob into your Android Studio project using Kotlin. We'll cover the implementation of simple banner ads, medium rectangle banner ads, and large banner ads, providing you with a comprehensive guide to monetizing your app. Whether you're a developer exploring ad integration or aiming to enhance your app's revenue, this video offers practical insights for successful Google AdMob implementation in Kotlin.

Step 1: Setting Up Google AdMob Account
To start, we'll guide you through the process of setting up a Google AdMob account and creating ad units. You'll learn how to configure different types of banner ads to suit your app's layout.

Step 2: Adding Google AdMob Dependency to Your Project
In this step, we'll demonstrate how to add the Google AdMob dependency to your Android Studio project using Kotlin. You'll understand the importance of integrating the AdMob SDK for ad functionality.

Step 3: Implementing Simple Banner Ads
Next, we'll guide you through the implementation of simple banner ads. You'll learn how to integrate banner ads seamlessly into your app's layout, enhancing the overall user experience.

Step 4: Adding Shimmer Effect to Banner Ads
In this step, we'll explore how to add a shimmer effect to your banner ads, creating an eye-catching and engaging visual experience for users.

Step 5: Implementing Medium Rectangle and Large Banner Ads
We'll cover the implementation of medium rectangle and large banner ads, providing you with the flexibility to choose ad formats that best suit your app's design and layout.

Conclusion:
Congratulations! You've successfully learned how to implement Google AdMob banner ads with a shimmer effect in Android Studio using Kotlin. This tutorial has equipped you with practical insights to monetize your app and enhance user engagement through well-integrated ads.

Now, armed with the knowledge of Google AdMob implementation, you're ready to boost your app's revenue and provide users with a visually appealing ad experience. Happy coding!

Source Code:https://github.com/AhsanAhmed03/AdMob-Ads

How to Upload and Push Android Studio Projects to GitHub | Step-by-Step Guide

AhsanAhmed03 — Thu, 28 Dec 2023 17:41:07 +0000

Welcome to this step-by-step tutorial where you'll explore the straightforward process of uploading your Android Studio projects to GitHub. From initializing a repository to pushing your code to the cloud, you'll gain practical insights to streamline project collaboration and version control. Whether you're a seasoned developer or just getting started, this video provides essential knowledge for integrating GitHub into your Android Studio workflow.

Step 1: Initializing a Repository on GitHub
To start, we'll guide you through the process of initializing a new repository on GitHub. You'll learn how to set up the repository with a README file and choose options that suit your project.

Step 2: Configuring Git in Android Studio
In this step, we'll walk you through configuring Git in Android Studio. You'll set up your Git username and email, ensuring that your contributions are properly attributed.

Step 3: Creating a Local Git Repository
Next, we'll explore how to create a local Git repository within your Android Studio project. You'll learn the necessary Git commands to initialize the repository and establish a connection with the GitHub repository.

Step 4: Adding, Committing, and Pushing Code
We'll guide you through the process of adding, committing, and pushing your code to GitHub. You'll understand the importance of committing changes with meaningful messages and pushing them to the remote repository.

Step 5: Verifying Changes on GitHub
In this step, you'll verify that your code changes have been successfully pushed to GitHub. We'll explore the GitHub repository to ensure that the project is up to date.

Conclusion:
Congratulations! You've successfully learned how to upload and push Android Studio projects to GitHub. This tutorial has equipped you with practical insights to streamline your project collaboration and version control using GitHub.

Now, armed with the knowledge of uploading and pushing projects to GitHub, you're ready to efficiently collaborate, contribute, and maintain version control in your Android Studio projects. Happy coding!