DEV Community: Harsh Lade

Coroutines in Kotlin: A Beginner-Friendly Guide

Harsh Lade — Wed, 18 Jun 2025 09:23:42 +0000

Introduction

You might have come across this definition: "Coroutines are lightweight threads that enable writing asynchronous and non-blocking code." But let’s be honest—it doesn’t make much sense if you’re new to programming or Kotlin. Don’t worry. In this tutorial, we'll break down everything from the basics and build up your understanding of coroutines in a beginner-friendly way.

Coroutines and their need.

To understand coroutines, we must understand some basic terms and definitions.

Program: A program is a set of instructions. Basically, it is the code we write in any language.

Process: A process is a program under execution. When we run our program, it becomes a process.

Thread: A thread is the smallest unit of execution. A thread is a lightweight process. A process can be divided into multiple threads to reduce the workload.

Coroutines: Coroutines are lightweight compared to threads, meaning they require far fewer resources. Unlike threads, coroutines are managed by the Kotlin runtime, making them more efficient and easier to work with.

Don't worry if you are still confused, as we will move forward, you will have a better understanding about the Coroutines.

Need for Coroutines

When we run our application, it runs on a main thread (managed by the Operating System). All operations and UI components run on the main thread. It is fine to run our application on the main thread until our application needs to perform a heavy, long-running task like Input Output Operation. If heavy tasks run on the main thread, the UI may freeze, leading to a poor user experience.

So, we come up with a solution to run these long-running tasks on another secondary thread (called a background thread), so that our main thread can perform its task, and our UI will not freeze. But threads are too expensive, and we have a limit on using threads, so we can't run too many threads for our application, but if we have a large number of long-running tasks, then what will we do?

Here coroutine comes into the scene. With coroutines, we no longer need multiple background threads. A single thread can manage multiple coroutines, each handling a different task like file operations, API calls, or database queries—efficiently and without freezing the UI. For example, we can launch a coroutine to perform a file operation, another one for API call, and another one for Database Queries.

Properties of Coroutines

Coroutines are lightweight and require fewer system resources than threads.
Like threads, coroutines can run in parallel, suspend, resume, and share data.
Coroutines are cheap because they are managed by the Kotlin runtime rather than the OS.

Note: Coroutines are not threads. Threads are very expensive and managed by the operating system.

Working with Threads.

In this section we will learn how to work with threads.

fun main(){
    println("Running on thread: ${Thread.currentThread().name}")//runs on the main thread
    thread{
        println("Running on thread: ${Thread.currentThread().name}")//runs on a new thread
    }
    println("Running on thread: ${Thread.currentThread().name}")//runs on the main thread
}

Output:

The thread {} block starts a new thread, and Thread.currentThread().name helps us identify which thread the code is running on.

Now, we will see how we can use threads for long-running tasks.

fun main(){
    println("Running on thread: ${Thread.currentThread().name}")//runs on the main thread
    fetchData()
    println("Main thread continues during the network call: ${Thread.currentThread().name}")
}
fun fetchData(){
    thread{
        println("Running on thread: ${Thread.currentThread().name}")
        Thread.sleep(3000) //simulating fake network call
    }
}

When you will run the above code you will see this output:
Running on thread: main Main thread continues during the network call: main Fetching data: Thread-0

So, we can conclude that the thread runs concurrently/parallelly as the network call was going on a different thread, and our main thread was free to show any UI changes, providing a smooth user experience.
We can perform the same tasks with the help of coroutines, which will be efficient and less costly.

✅ Conclusion

In this article, you learned the difference between threads and coroutines, why coroutines are more efficient, and how to work with threads in Kotlin. In the next part, we'll dive deeper into coroutines—how to launch them, use suspend functions, and structure them properly for real-world applications.

Android Architecture Components: ViewModel, Lifecycle.

Harsh Lade — Sat, 22 Mar 2025 06:05:20 +0000

Introduction

Welcome back! In the last article, we explored an overview of Android Architecture Components and patterns. Now, let’s zoom into two key players: ViewModel and Lifecycle. These tools help your app handle data and UI states like a pro—think surviving screen rotations or knowing when your app is active. Ready to dive in?

ViewModel: Saving Your Data

What is ViewModel and Why do we use it?

ViewModel is your app’s data guardian. It stores UI-related data that might otherwise disappear during configuration changes—like when a user rotates their screen. Without it, your app’s state resets, frustrating users.

Here’s an example: Imagine a counter app. You set a Text view to "0" and increment it with a Button. After five clicks, it shows "5." But rotate the screen, and boom—it’s back to "0" because the Activity restarts. ViewModel prevents this by keeping the count safe across these changes.

How to use ViewModel

Step 1. add the dependency.

Paste this line in your build.gradle (Module level)

    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.6.1")

Note: If using Jetpack Compose, use lifecycle-viewmodel-compose instead.

Step 2. Make a ViewModel class.

Make a class that extends ViewModel to hold your data:

class MyViewModel : ViewModel() {
    var count by mutableStateOf(0)  // State in ViewModel
        private set  // Only ViewModel can modify it

    fun updateCount() {
        text++ // Update state
    }
}

Step 3. Set up in your App.

Now use the MyViewModel class in your app to show the count value on your UI.


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

@Composable
fun MyApp(viewModel: MyViewModel = viewModel()) { 
//viewModel() function provides the instance of MyViewModel.
    Column(modifier = Modifier.padding(16.dp)) {
        Text(text = "${viewModel.count}")
        Button(onClick = { viewModel.updateCount() }) {
            Text("Click Me")
        }
    }
}

Run it, click a few times, and rotate the screen—the count sticks around!

Lifecycle: Tracking Your App’s States

LEvery Activity or Fragment has a lifecycle—stages like creation, visibility, or destruction. Think of it like a human life: born (onCreate), active (onResume), resting (onPause), or gone (onDestroy). Knowing these states lets you control what happens when—like saving data before the app closes.

Here’s a quick example:

class MainActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Log.d("Lifecycle", "onCreate called")

        setContent {
            MyApp()
        }
    }

    override fun onStart() {
        super.onStart()
        Log.d("Lifecycle", "onStart called")
    }

    override fun onResume() {
        super.onResume()
        Log.d("Lifecycle", "onResume called")
    }

    override fun onPause() {
        super.onPause()
        Log.d("Lifecycle", "onPause called")
    }

    override fun onStop() {
        super.onStop()
        Log.d("Lifecycle", "onStop called")
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.d("Lifecycle", "onDestroy called")
    }
}

Check your Logcat as you open, minimize, or close the app—each state logs a message!

Lifecycle Observer

Want to react to lifecycle changes without overriding methods? Use a Lifecycle Observer. Here’s how:

Here is how we use Lifecycle Observer and Owner.

class MyObserver : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        super.onStart(owner)
        Log.d("LifecycleObserver", "Activity started!")
    }

    override fun onStop(owner: LifecycleOwner) {
        super.onStop(owner)
        Log.d("LifecycleObserver", "Activity stopped!")
    }
}

In above code, we are inheriting DefaultLifecycleObserver to define an observer. Inside the observer we are implementing our tasks.
Now, we need to attach the observer with our activity, here is how do we do it.

@Composable
fun MyComposable() {
    val lifecycleOwner = LocalLifecycleOwner.current
    val observer = remember { MyObserver() }

    DisposableEffect(lifecycleOwner) {
        lifecycleOwner.lifecycle.addObserver(observer)
        onDispose {
            lifecycleOwner.lifecycle.removeObserver(observer)
        }
    }

    Text("Hello, Lifecycle!")
}

Here, LocalLifecycleOwner.current provides the instance of Lifecycle Owner of current activity.
DisposableEffect() is a side-effect function that gets created when the composable starts and gets destroyed when the activity gets disposed.
lifecycleOwner.lifecycle.addObserver(observer) it is adding the observer we made above.
lifecycleOwner.lifecycle.removeObserver(observer) it removes the observer when activity gets disposed.

Conclusion

We’ve unlocked ViewModel to preserve data and Lifecycle to track UI states. Together, they make your app resilient and smart. Next up, we’ll tackle LiveData to keep your UI in sync with changing data. See you there!

Android Architectures: A beginner Guide.

Harsh Lade — Wed, 19 Mar 2025 07:16:42 +0000

Introduction

Android architecture is the backbone of structuring your Android applications. It’s all about organizing your code to make your app scalable, maintainable, and easy to test. Think of it as a blueprint that defines how different parts of your app—like the UI, data, and logic—talk to each other. In this series, we’ll dive deep into these architecture patterns and components to help you build better apps. Let’s get started!

Types of Android Architecture Pattern

MVC (Model-View-Controller) – Historically used in Android, but not popular today. Why? It tightly couples the UI (View) with the logic (Controller), making it harder to modify or test parts independently.
MVP (Model-View-Presenter) – A step up from MVC, it separates the UI (View) from the business logic (Presenter). However, Presenters can still grow complex and bloated over time.
MVVM (Model-View-ViewModel) – Google’s recommended approach! It reduces dependencies between components and pairs beautifully with Jetpack libraries like LiveData and ViewModel.
MVI (Model-View-Intent) – A reactive pattern focused on managing state. It’s ideal for apps with complex, state-driven interfaces (think unidirectional data flow).

Android Architecture Components

1. ViewModel: Stores UI-related data and survives configuration changes (e.g., screen rotations). Without it, your data might vanish when the screen flips—ViewModel keeps it safe!

2. LiveData: An observable data holder that updates the UI only when needed. It’s lifecycle-aware, so no more crashes from updating a destroyed screen.
3. Room: Database layer for SQLite with an abstraction, simplifies database management and reduces boilerplate code.
4. Repository: Acts as a middleman between data sources (e.g., APIs, databases), keeping your logic organized.
5. Paging: Perfect for loading large datasets (like endless lists) efficiently in RecyclerView.
6. WorkManager: Manages background tasks—like syncing data—even if the app closes. Great for both one-off and recurring jobs.
7. Navigation Component: Manages app navigation, simplifies fragment transactions and deep linking.

Why Use Architecture Components?

Avoid memory leaks by using lifecycle-aware components.
Make UI updates easier with LiveData.
Survive configuration changes using ViewModel.
Reduce boilerplate code with Room and Repository.
Enhance testability by following separation of concerns
Provides more control to us.

In this series, we’ll explore each component and pattern in detail. Next up: understanding lifecycles and mastering ViewModel. Stay tuned!

Understanding Firestore in Android: A Beginner's guide.

Harsh Lade — Fri, 17 Jan 2025 18:08:52 +0000

Introduction

Firestore is a noSQL cloud database that helps users to upload, sync and retrieve their data in real-time. It is highly scalable and supports offline mode. Firebase is a hot topic in interviews nowadays.
In this article, we will learn everything about Firebase from scratch.

Key Features of Firestore.

Scalable: it is highly scalable, hence we can use it for large project also
Sync: provides real-time sync for our app.
Queries: provides a large range of advanced queries such as filtering, ordering, and multiple conditions.
It is a noSQL cloud database, so we don't need to learn SQL for it.
It provides offline support to mobile.

Setting-up Firestore in Your App

1. Add Firebase to your Android app.

In this section we will see, how we can implement the Firestore in our app.

Open Firebase console.
Create a project.
Add android app by providing the package name same as your build.gradle.
Install google-service.json file .
Open Android Studio and place the json file in app/ directory.
Add the Firebase SDK dependencies in build.gradle (Project level):

dependencies {
    classpath 'com.google.gms:google-services:4.3.10'
}

7 Add Firebase dependencies in build.gradle (Module level):

dependencies {
    implementation platform('com.google.firebase:firebase-bom:32.7.0')
    implementation 'com.google.firebase:firebase-firestore-ktx'
}

8 Sync your project.

2. Enable Firestore in Firebase Console.

Open your Firebase project in the console.
Click on the Firestore database -> Create Database.
Click start in test mode.
Enable.

3. Initialize Firestore in your app.

Note: Never create Firebase Instance in a singleton object.

val db =FirebaseFirestore.getInstance()

This will return you a Firebase instance and this will be your database.

Firestore CRUD Operations.

In this section we will learn CRUD (Create, Read, Update, Delete) operations provided by the Firestore but first, we should see how Firestore stores our data.

How Firestore Stores The Data.

Firebase is document-based, meaning it stores the data in the form of collection (folder) and inside them document (users/ sub data).

Collection: It consists of different collections of data/documents, you can think of it as table in RDBMS. Example: Users, Students, Courses.
Document: Inside the collections, it stores different data of collection type such as different users, students, and courses. This data is called document. A document is the data of the user.
Fields: Key value pair inside the document, it represents the data of the user (eg. "name":"Harsh", "roll":12).

Example of Firestore Data Structure.

users (Collection)
   ├── user123 (Document)
   │      ├── name: "Harsh"
   │      ├── age: 18
   │      ├── email: "harsh@example.com"
   ├── user456 (Document)
   │      ├── name: "John"
   │      ├── age: 21

1. Adding Data to Firestore.

There are two ways to add data to the Firestore: 1. Autogenerated document id, 2. Custom document id.

1. Autogenerated document id

Firestore will generate a unique ID for the document.

val db = FirebaseFirestore.getInstance()
val user = hashMapOf(
    "name" to "Harsh",
    "age" to 18,
    "email" to "harsh@example.com"
)
// Add data to the "users" collection with an auto-generated ID
db.collection("users")
    .add(user)
    .addOnSuccessListener { documentReference ->
        Log.d("Firestore", "Document added with ID: ${documentReference.id}")
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error adding document", e)
    }

Output:

Document added with ID: xetiRfzp5LSAckrDwEre

Obviously, you will get a different ID.

2. Custom document ID.

In this case, we will give a custom document id for our document to the Firestore.

val db = FirebaseFirestore.getInstance()
val user = hashMapOf(
    "name" to "Harsh",
    "age" to 18,
    "email" to "harsh@example.com"
)
// Set a custom document ID (e.g., email)
db.collection("users")
    .document("harsh@example.com")  // Custom ID
    .set(user)
    .addOnSuccessListener {
        Log.d("Firestore", "Document successfully written!")
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error writing document", e)
    }

.set() will override the user if it already exists.

2. Retrieving The Data.

There are three ways to read the data from Firestore.

1. Get a Single Document (Fetch one user's details).
2. Get All Documents in a Collection (Fetch all users).
3. Query Specific Documents (Filter results, like finding users above age 18).

1. Getting a Single Document.

If we know the document ID, we can retrieve it using .document().get().

val db = FirebaseFirestore.getInstance()

db.collection("users")
    .document("harsh@example.com")  // Use custom document ID
    .get()
    .addOnSuccessListener { document ->
        if (document.exists()) {
            val name = document.getString("name")
            val age = document.getLong("age")
            val email = document.getString("email")

            Log.d("Firestore", "User Data: Name=$name, Age=$age, Email=$email")
        } else {
            Log.d("Firestore", "No such document!")
        }
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error fetching document", e)
    }

Explanation:
.document("harsh@example.com") → Fetches the document with this specific ID.
.get() → Reads data from Firestore.
.exists() → Checks if the document exists.
.getString("name") & .getLong("age") → Extract field values.

####2. Fetch All Documents from a Collection
To get all users from the "users" collection:

db.collection("users")
    .get()
    .addOnSuccessListener { documents ->
        for (document in documents) {
            val name = document.getString("name")
            val age = document.getLong("age")
            val email = document.getString("email")

            Log.d("Firestore", "User: Name=$name, Age=$age, Email=$email")
        }
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error fetching users", e)
    }

Explanation:
.collection("users").get() → Fetches all documents in the "users" collection.
for (document in documents)→ Loops through each document.
.getString("name"), .getLong("age") → Reads field values.

3. Query Specific Documents (Filtering Data)

What if we want only users above age 18? We use queries!

db.collection("users")
    .whereGreaterThan("age", 18)  // Only users older than 18
    .get()
    .addOnSuccessListener { documents ->
        for (document in documents) {
            val name = document.getString("name")
            val age = document.getLong("age")
            Log.d("Firestore", "User: Name=$name, Age=$age")
        }
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error fetching filtered users", e)
    }

Explanation:
.whereGreaterThan("age", 18) → Fetches users where age > 18.
Firestore supports queries like:
whereEqualTo("name", "Harsh") → Find users with a specific name.
whereLessThan("age", 30) → Users younger than 30.
orderBy("age", Query.Direction.ASCENDING) → Sort by age.

3. Updating Data.

Firestore allows two types of updates:

1. Overwrite Entire Document (Replace all fields)
2. Update Specific Fields (Modify only selected fields)

1. Overwrite an Entire Document

Using .set(), we can replace an entire document.

val db = FirebaseFirestore.getInstance()

val updatedUser = hashMapOf(
    "name" to "Harsh Lade",
    "age" to 19,
    "email" to "harsh@example.com"
)

// Overwrite the existing document
db.collection("users")
    .document("harsh@example.com") // Custom document ID
    .set(updatedUser)
    .addOnSuccessListener {
        Log.d("Firestore", "Document successfully updated!")
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error updating document", e)
    }

Warning:
.set(updatedUser) replaces the entire document.
If the document has extra fields (e.g., "phone": "12345"), they will be removed unless included in updatedUser.

2. Update Specific Fields

If we want to update only one or two fields, we use .update().

db.collection("users")
    .document("harsh@example.com")
    .update("age", 20)  // Update only the "age" field
    .addOnSuccessListener {
        Log.d("Firestore", "Field successfully updated!")
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error updating field", e)
    }

Explanation:
.update("age", 20) → Updates only the "age" field to 20.
Other fields (name, email) remain unchanged.

3. Update Multiple Fields at Once

We can update multiple fields together:

db.collection("users")
    .document("harsh@example.com")
    .update(
        "name", "Harsh L.",
        "age", 21
    )
    .addOnSuccessListener {
        Log.d("Firestore", "Multiple fields updated!")
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error updating fields", e)
    }

Explanation:
Updates "name" to "Harsh L." and "age" to 21.
Other fields remain untouched.

4. Add a New Field to an Existing Document.

If we want to add a new field (without replacing old ones), we use .update().

db.collection("users")
    .document("harsh@example.com")
    .update("phone", "9876543210")  // New field "phone" added
    .addOnSuccessListener {
        Log.d("Firestore", "New field added!")
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error adding field", e)
    }

Explanation:
If "phone" does not exist, it gets added.
If "phone" already exists, its value is updated.

4. Deleting Data in Firestore (Delete Operation)

Now that we know how to update data, let's learn how to delete Firestore documents and fields.

Ways to Delete Data in Firestore

Firestore allows three types of deletions:
Delete an Entire Document (Remove a user completely)
Delete a Specific Field (Remove only one field, keeping others) 3 Delete an Entire Collection (Delete all users – not directly supported)

1. Delete an Entire Document

To remove a document completely, use .delete().

db.collection("users")
    .document("harsh@example.com")  // Delete this document
    .delete()
    .addOnSuccessListener {
        Log.d("Firestore", "Document successfully deleted!")
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error deleting document", e)
    }

Explanation:

.delete() removes the entire document from Firestore.
This cannot be undone, so be careful!

2. Delete a Specific Field in a Document

Instead of deleting the whole document, we can remove only one field using FieldValue.delete().

import com.google.firebase.firestore.FieldValue

db.collection("users")
    .document("harsh@example.com")
    .update("phone", FieldValue.delete())  // Remove only the "phone" field
    .addOnSuccessListener {
        Log.d("Firestore", "Field successfully deleted!")
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error deleting field", e)
    }

Explanation:
.update("phone", FieldValue.delete()) → Removes only the "phone" field.
Other fields (name, age, email) remain untouched.

3. Delete an Entire Collection

Firestore does not allow deleting a collection directly, so we must delete each document manually.

db.collection("users")
    .get()
    .addOnSuccessListener { documents ->
        for (document in documents) {
            db.collection("users").document(document.id).delete()
        }
        Log.d("Firestore", "All documents in 'users' deleted!")
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error deleting collection", e)
    }

Explanation:
.get() → Fetches all documents in the "users" collection.
for (document in documents) → Loops through and deletes each document.
This is not atomic, meaning if the process fails midway, some documents may remain.

Querying Data in Firestore

Now that we know how to create, read, update, and delete data, let's learn how to query Firestore efficiently.

Why Are Queries Important?

In real-world apps, we often need to:

Find specific users (e.g., users older than 18).
Sort data (e.g., show the latest products first).
Limit results (e.g., show only the top 10 users).
Apply multiple filters (e.g., users in India AND above 18).

Firestore provides powerful querying features, but it has some limitations we must understand.

1. Basic Query (Filter Data)

We use .whereEqualTo(), .whereGreaterThan(), etc., to filter results.
Example: Get all users where "age" >= 18

db.collection("users")
    .whereGreaterThanOrEqualTo("age", 18)
    .get()
    .addOnSuccessListener { documents ->
        for (document in documents) {
            Log.d("Firestore", "${document.id} => ${document.data}")
        }
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error fetching documents", e)
    }

Explanation:
.whereGreaterThanOrEqualTo("age", 18) → Gets users aged 18 or older.
.get() → Fetches matching documents.
Loop through documents and print results.

📌 Other Query Filters

  Query Method           Example                 Meaning

.whereEqualTo()         "city", "Mumbai"        Users in Mumbai
.whereNotEqualTo()      "city", "Delhi"         Users NOT in Delhi
.whereGreaterThan()     "age", 25               Users older than 25
.whereLessThan()        "age", 30               Users younger than 30
.whereArrayContains()   "hobbies", "chess"      Users who like chess

2. Sorting Data

We use .orderBy() to sort results in ascending or descending order.
Example: Get all users, sorted by "age" (youngest first)

db.collection("users")
    .orderBy("age", Query.Direction.ASCENDING)  // Sort by age (ascending)
    .get()
    .addOnSuccessListener { documents ->
        for (document in documents) {
            Log.d("Firestore", "${document.id} => ${document.data}")
        }
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error fetching documents", e)
    }

Sorting Options:
Query.Direction.ASCENDING → Smallest first (youngest users).
Query.Direction.DESCENDING → Largest first (oldest users).

3. Limiting Data (Pagination)

We use .limit(n) to fetch only the first n results.
Example: Get the top 5 youngest users

db.collection("users")
    .orderBy("age", Query.Direction.ASCENDING)
    .limit(5)
    .get()
    .addOnSuccessListener { documents ->
        for (document in documents) {
            Log.d("Firestore", "${document.id} => ${document.data}")
        }
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error fetching documents", e)
    }

Why Use .limit(n)?

Reduces database load.
Faster performance.
Useful for pagination (loading more results later).

4. Combining Filters & Sorting

Firestore allows only one .orderBy() per query, and all filters must be indexed.
Example: Get all users aged 18+, sorted by "age"

db.collection("users")
    .whereGreaterThanOrEqualTo("age", 18)
    .orderBy("age", Query.Direction.ASCENDING)  // Required for sorting
    .get()
    .addOnSuccessListener { documents ->
        for (document in documents) {
            Log.d("Firestore", "${document.id} => ${document.data}")
        }
    }
    .addOnFailureListener { e ->
        Log.e("Firestore", "Error fetching documents", e)
    }

Firestore Limitation:
You must create an index when using .where() with .orderBy().
Firestore will show an error and provide a link to create the index.

Google Sign-in using Firebase. A beginner Guide.

Harsh Lade — Fri, 17 Jan 2025 09:02:41 +0000

Introduction

In this article, we will see how we can add features of Google sign in in our app using Firebase.

Prerequisits

Firebase project setup and connect to firebase.
Firebase authentication enabled in Project.

You can see them in the previous article.

Step 1: Adding SHA-1 Certificate.

SHA stands for Secure Hash Algorithm. We need to add this certificate in our Firebase project.

1. Finding SHA-1 Certificate

To find SHA-1 certificate, first open your android studio -> terminal, then run the following command on terminal.

./gradlew signingReport

Then you will see something like this:

Store: C:\Users\YourUsername\.android\debug.keystore
Alias: AndroidDebugKey
MD5:  A1:B2:C3:D4:E5:F6:G7:H8:I9:J0:K1:L2:M3:N4:O5:P6
SHA-1: 11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:EE:FF:00:11:22:33
SHA-256: XX:YY:ZZ...

Copy the SHA-1 id from here.

2. Adding SHA-1 to Firebase.

Open Firebase console -> select your app.
Go to Project settings.
Scroll down to your apps -> select your android app.
Click on add fingerprint.
Paste SHA-1 key and save it.

3. Adding new `google-service.json`.

Copy your google-service.json file from firebase.
Now open your android studio and replace the old google-service.json with the new one.

Open the googl-service.json, under client -> outh_Client -> copy the client_id, it is your webClintId save this id we will need in future.

Step 2 (Adding Google Sign in):

Google sign in allows user to sign in using their account.

1. Set up

Open Firebase console -> Authentication -> Sign in Method -> enable Google.
Note down the web client Id.

2. Add Dependencies.

Open your build.gradle file and add the following dependcies.

    //Add the following line.
    implementation ("com.google.firebase:firebase-auth:22.1.1")
    implementation ("com.google.android.gms:play-services-auth:20.7.0")

Step 3 (Creating a Google Sign-in Manager)

We will wrap up all the back-end code into the object GoogleSignInManager, we will add all the functionalities inside this object. It will make a singleton, means it will be same through the whole app. It is a type of pattern.

This ensures that we don't create multiple googleSignInUsers inside our app.

1. Initialize Google Sign-in client.

object GoogleSignInManager {
    private lateinit var googleSignInClient: GoogleSignInClient
    //other code...
}

This will create a variable that we will initialize later. lateinit var is used to define a variable which gets initialize later in future.

2. Set up Google Sign-in options.

Now we will add Google sign-in options in our GoogleSignInManager. We will make a function initialize.

fun initialize(context: Context) {
        val gso = GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
            .requestIdToken("556979410722-v79hg8m78s8tbqt6hqofdhe9a4k1uml7.apps.googleusercontent.com")//replace with `webClientId`(you can check it in google-service.json).
            .requestEmail()
            .build()

        googleSignInClient = GoogleSignIn.getClient(context, gso)
    }

Here, we create GoogleSignInOption, it tells that which type of sign in we want (eg. email, phone).

.requestIdToken(webClientId) requests an id token for Firebase Authentication.
.requestEmail() requests Email of the user.
GoogleSignIn.getClient() set ups a client with the given option(gso).

3. Adding Sign in intent.

We will create a function that returns the intent, which will help us launch Google sign-in.

fun getSignInIntent(): Intent {
        return googleSignInClient.signInIntent
    }

This will return an intent that launches Google sign-in UI. It is used to start the Google sign-in process.

4. Creating Sign-out function.

This sign-out function will help the user to sign out through the account.

    fun signOut(){
        googleSignInClient.signOut()
    }

4. Authenticate with Firebase.

To authenticate the user with Firebase, we will make a function that authenticates the user.

fun authenticateWithFirebase(
        idToken: String,
        onSuccess: (FirebaseUser?) -> Unit,
        onFailure: (Exception?) -> Unit
    ) {
        val credential = GoogleAuthProvider.getCredential(idToken, null)
        FirebaseAuth.getInstance().signInWithCredential(credential)
            .addOnCompleteListener { task ->
                if (task.isSuccessful) {
                    onSuccess(FirebaseAuth.getInstance().currentUser)
                } else {
                    onFailure(task.exception)
                }
            }
    }

val credential =GoogleAuthProvider.getCredential(idToken,null) converts the idToken to Firebase credentials.
FirebaseAuth.getInstance().signInWithCredential(credential) tells the Firebase to sign in with the Google's Credentials.
addOnCompleteListener is used to handle the result case like success and failure, so that we can perform desired task in each situation.

Step 4 (UI & Launcher).

Now, we are done with almost everything but the UI. For testing purposes, we can add only a simple button inside the UI. Also, we will create a launcher, which get called when the user clicks on the Sign in button.

1. Launcher

val launcher= rememberLauncherForActivityResult(
        contract = ActivityResultContracts.StartActivityForResult()
    ) {result->
        val task=GoogleSignIn.getSignedInAccountFromIntent(result.data)
        try{
            val account=task.getResult(ApiException::class.java)
            account?.idToken?.let {idToken->
                GoogleSignInManager.authenticateWithFirebase(
                    idToken,
                    onSuccess = {
                        onSignInSuccess(it)
                    },
                    onFailure = {
                        signInResult="Sign in failed: ${it?.message}"

                        onSignInFailure(signInResult?:"unknown result")
                    }

                )

            }
        }
        catch (e:ApiException){
            signInResult="Sign in failed: ${e.message}"

            onSignInFailure(signInResult?:"unknown result")
        }


    }

rememberLauncherActivityForResult() is a jetpack compose way to handle the activity result (i.e., getting the result from other activities, Google sign-in in this case.
ActivityResultContracts.StartActivityForResult expects an intent and returns a result after the activity (in this case it will return the user's detail after sign-in).
val task=GoogleSignIn.getSignedInAccountFromIntent(result.data) returns the result from intent, which we can then retrieve using .getResult(ApiExcetption::class.java).
try{ val account=task.getResult(ApiException::class.java) it starts a try block and gets the result from the task in account variable.

 account?.idToken?.let {idToken->
                GoogleSignInManager.authenticateWithFirebase(
                    idToken,
                    onSuccess = {
                        onSignInSuccess(it)
                    },
                    onFailure = {
                        signInResult="Sign in failed: ${it?.message}"
                        onSignInFailure(signInResult?:"unknown result")
                    }
                )
            }

Above code will check if account and idToken is not null then it will send the idToken to our authenticateWithFirebase function inside the GoogleSignInManager singleton object and authenticate the user with firebase, also handles the success and failure cases.

Lastly, Catch block handles the exception.

2. Button Component.

Button(onClick = {
            val signInIntent = GoogleSignInManager.getSignInIntent()
            launcher.launch(signInIntent)
        }) {
            Text("Sign in with Google")
        }

When any user clicks on the button, we will get Intent and will launch the launcher.

.getSignInIntent() returns an intent that we will pass into the launcher to Launch the Google sign-in UI.

Conclusion

In this article, we have discussed how we can implement the Google sign-in feature in our app using Firebase Authentication. First, we added the SHA-1 certificate of our app in Firebase, then we added the necessary dependencies to our project. After that, we made a singleton object GoogleSignInManager in which we said all the essential methods for authentication, initialization, getIntent, and sign-out. Then we implemented a launcher that launches the Google sign-in UI and get the result.
Please, give your feedback. Also, you can ask your doubts. Next, we will discuss Firestore so stay tuned.

Authentication in Android Project with Firebase.

Harsh Lade — Mon, 13 Jan 2025 10:13:18 +0000

Introduction

We discussed the benefits and implementation of Firebase in our Android Studio Project. In this article, we will see the practical use of Firebase, we will learn how to use Authentication for your app using Firebase.

Prerequisites

Firebase has already been integrated in project.
google-service.json file has been added in your project.

Implementation

###1. Add Firebase authentication dependency in your build.gradle:

dependencies{
    //other dependencies...
    implementaion("com.google.firebase:firebase-auth:22.1.0")
}

2. Initialize authentication in your App.

Add a Firebase instance in your project.

    private val firebaseInstance=FirebaseAuth.getInstance()

3. Add Functionalities to Your App.

 fun signIn(email:String, password: String, context: Context) {
        firebaseInstance
            .signInWithEmailAndPassword(email, password)
            .addOnCompleteListener { task->
                if(task.isSuccessful) {
                    val user = firebaseInstance.currentUser?.email
                    Toast.makeText(context, "Sign in successful- $user", Toast.LENGTH_SHORT).show()
                }
                else{
                    Toast.makeText(context, "Failed, error: ${task.exception?.message}", Toast.LENGTH_SHORT).show()
                }
            }
    }

 fun signUp(email:String, password: String, context: Context){
        firebaseInstance.createUserWithEmailAndPassword(email,password)
            .addOnCompleteListener { task->
                if(task.isSuccessful) {
                    val user = firebaseInstance.currentUser?.email
                    Toast.makeText(context, "Sign-up successful- $user", Toast.LENGTH_SHORT).show()
                }
                else{
                    Toast.makeText(context, "Failed, error: ${task.exception?.message}", Toast.LENGTH_SHORT).show()
                }
            }
    }

Sign Out Functioality.

fun signOut(context: Context){
        firebaseInstance.signOut()
        Toast.makeText(context, "User signed out.", Toast.LENGTH_SHORT).show()
    }

Manage User Session.

fun checkUserSession() {
    val user = firebaseAuth.currentUser
    if (user != null) {
        println("User already signed in: ${user.email}")
    } else {
        println("No user signed in.")
    }
}

Conclusion.

We have discussed the application of Firebase. We will learn more about Firebase in upcoming lecture, so stay tuned.

Learn Firebase for Android Development from Scratch, a beginner guide.

Harsh Lade — Mon, 13 Jan 2025 10:13:00 +0000

Introduction

Firebase is a BaaS (Backend as a Service) platform provided by Google. It gives all the backend functionality like authentication, servers, or databases. Simplifies the backend so that developers can focus on the front-end.

Key Features of Firebase

Cross Platform: Work with Android, Web, IOS and Unity.
Safe & Secure: Provides build securities for project.
Realtime database & Firebase: Stores and sync data between users in real-time.
Push Notification: Send targeted notifications to users.

Implementation in Android Studio

First, open Firebase Console, create your account (select Google Analytics) and create your new project. Then move to the next step.

Step 1: Connect Firebase to Your App

Firebase provides two ways to integrate: via Firebase Assistance or Manually. Let's go with Firebase Assistance as it is straightforward.

1. Open your Project open Firebase Assistance Tool> Firebase.
2. Choose a service, such as Authentication, click on connect to firebase.
3. Click on authenticate using google, now connect with your google account and choose the firebase project you just created.
4. Now, click on add sdk to your project, accept the changes. It will add necessary dependencies to your project.

If the above steps don't work. add the following dependencies:

dependencies {
    implementation platform('com.google.firebase:firebase-bom:32.1.1') // Firebase BOM
    implementation 'com.google.firebase:firebase-analytics-ktx'       // Analytics KTX
}

Now, open your build.gradle.kts (Module level), add the following line:

plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.jetbrains.kotlin.android) apply false

    id("com.google.gms:google-services:4.4.0") //Add this line
}

Now, Inside your build.gradle.kts (project level), add the google plugin:

plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.jetbrains.kotlin.android)

    id( "com.google.gms.google-services")//Add this line
}

Now, sync your project. Then go to the Firebase Console, download the google-service.json file, add this file in your project's app/ directory

Now, you are Ready to use Firebase in your Project.

Conclusion

In this article, we discussed the implementation of Firebase into your project. In the next article we will see some practical uses of Firebase like Authentication, so stay tuned.

Understanding Room Database in Android: A Beginner's Guide

Harsh Lade — Sat, 04 Jan 2025 07:05:48 +0000

Introduction

Room Database is an essential topic in Android Development, enabling developers to store and manage data efficiently. It acts as an abstraction layer over SQLite, simplifying database operations and making data management more developer-friendly. In this article, we will explore Room Database step by step, with practical examples to help you understand its implementation.

Why to use Room Database

Abstraction Layer: Room provides an abstraction layer over SQLite, allowing developers to write simpler and more idiomatic Kotlin code.
Compile-Time Verification: Room validates queries and schema definitions at compile time, reducing runtime errors and enhancing reliability.

Key Concepts/Terminologies

Entities: Represents table in your Database.
Dao (Data Access Object): Defines the operations with the Database.
Database: Acts as the database holder and contains all the tables.

Step-by-Step Implementation.

Let’s walk through the implementation process using an example of a User Database.

Step 1: Add Plugin

To get started, you need to add a plugin—either kapt or ksp. This plugin will help the compiler to understand the quotations that we will use.

ksp (Kotlin Symbol Processing): Faster and more efficient for annotation processing.
kapt (Kotlin Android Processing Tool): Traditional and widely used.

You can choose either ksp or kapt.
If you want to learn about ksp and kapt then you can refer to the official documentation. For now, you can continue.
In this example, we will use kapt.

Adding Kapt

Open your build.gradle.kts (module level) and add the following line inside plugins block:

plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.jetbrains.kotlin.android)

    id("kotlin-kapt") // Add this line
}

Adding ksp

Open build.gradle.kts (project level) in you project files. Here you have to add plugin for ksp.

plugins {
    //other plugins...

    //Your to add this. The version should be same as your kotlin (for first). 
    //For eg. you have kotlin version 1.9.22 then the version for ksp plugin should be 1.9.22-x.x.x
    id("com.google.devtools.ksp") version "1.9.22-1.0.17" apply false
}

Now, open you build.gradle.kts (module level) add this line in plugins block:

plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.jetbrains.kotlin.android)

    id("com.google.devtools.ksp") // Add this line
}

Sync your project after adding the plugin.

Step 2: Add Dependencies

Add the required dependencies for Room in your build.gradle.kts (module level) file:

dependencies{
    implementation("androidx.room:room-runtime:2.6.1") 
    //For Kotlin extension coroutines for room.
    implementation("androidx.room:room-ktx:2.6.1")
    //To use kotlin annotation processor.
    kapt("androidx.room:room-compiler:2.6.1")
}

Ensure you use the latest versions of these dependencies. After adding these dependencies, sync your project.

Step 3: Creating your First Table/Entity

Create the First Table inside the Database. To create one, define a data class annotate it with @Entity and give a name. Each entity must have at least one primary key annotate by @PrimaryKey, you can set it to auto-generate so it will get generated automatically.

@Entity(tableName="user_table")
data class User(
    @PrimaryKey(autoGenerate = true) val id:Int, //Define a primary key in table
    val name:String,
    val contact:Long
)

Step 4: Define a DAO Interface

DAO (Data Object Interface) defines the operations you can perform on the database such as:

Insert
Delete
Query
Update

Create an interface annotate it by @Dao and give it a name (UserDao, in this case).

@Dao
interface UserDao {
    @Insert //Define more methods as per your use
    suspend fun insert(user: User)

    //we can write any SQL query.
    @Query("select * from user_table order by id ASC")
    fun getData(): Flow<List<User>>
}

Here, getAllUsers() retrieves all users from the user_table in ascending order.

Step 5: Define a Database

Now, we will implement a database. Create an abstract class that will implement RoomDataBase(). Annotate it by @Database inside the annotation you will have to give all the Table/Entity names you are using and a version (we will update this version if we want to update anything in our database).

example:

@Database(entities = [User::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
}

Step 6: Initializing Room

Finally, initialize the Room database in your application. Use the Room.databaseBuilder() method to create an instance.

val db=Room.databaseBuilder(
    context,
    AppDatabase::class.java, //We have to give our database class (abstract class in step 5)
    "app_database" //you can give any name to database.
).build()
val userDao=db.userDao()//It is our dao.

Conclusion

In this article, we explored the fundamentals of Room Database, including adding plugins, dependencies, entities, DAOs, and initializing the database. In the next article, we will learn how to perform operations such as adding and retrieving data from the database.

Stay tuned for more practical insights into Android Development!

DEV Community: Harsh Lade

Coroutines in Kotlin: A Beginner-Friendly Guide

Introduction

Coroutines and their need.

Need for Coroutines

Properties of Coroutines

Working with Threads.

✅ Conclusion

Android Architecture Components: ViewModel, Lifecycle.

Introduction

ViewModel: Saving Your Data

What is ViewModel and Why do we use it?

How to use ViewModel

Step 1. add the dependency.

Step 2. Make a ViewModel class.

Step 3. Set up in your App.

Lifecycle: Tracking Your App’s States

Lifecycle Observer

Conclusion

Android Architectures: A beginner Guide.

Introduction

Types of Android Architecture Pattern

Android Architecture Components

Why Use Architecture Components?

Understanding Firestore in Android: A Beginner's guide.

Introduction

Key Features of Firestore.

Setting-up Firestore in Your App

1. Add Firebase to your Android app.

2. Enable Firestore in Firebase Console.

3. Initialize Firestore in your app.

Firestore CRUD Operations.

How Firestore Stores The Data.

Example of Firestore Data Structure.

1. Adding Data to Firestore.

1. Autogenerated document id

2. Custom document ID.

2. Retrieving The Data.

1. Getting a Single Document.

3. Query Specific Documents (Filtering Data)

3. Updating Data.

1. Overwrite an Entire Document

2. Update Specific Fields

3. Update Multiple Fields at Once

4. Add a New Field to an Existing Document.

4. Deleting Data in Firestore (Delete Operation)

1. Delete an Entire Document

2. Delete a Specific Field in a Document

3. Delete an Entire Collection

Querying Data in Firestore

Why Are Queries Important?

1. Basic Query (Filter Data)

2. Sorting Data

3. Limiting Data (Pagination)

4. Combining Filters & Sorting

Google Sign-in using Firebase. A beginner Guide.

Introduction

Prerequisits

Step 1: Adding SHA-1 Certificate.

1. Finding SHA-1 Certificate

2. Adding SHA-1 to Firebase.

3. Adding new google-service.json.

Step 2 (Adding Google Sign in):

1. Set up

2. Add Dependencies.

Step 3 (Creating a Google Sign-in Manager)

1. Initialize Google Sign-in client.

2. Set up Google Sign-in options.

3. Adding Sign in intent.

4. Creating Sign-out function.

4. Authenticate with Firebase.

Step 4 (UI & Launcher).

1. Launcher

2. Button Component.

Conclusion

Authentication in Android Project with Firebase.

Introduction

Prerequisites

Implementation

2. Initialize authentication in your App.

3. Adding new `google-service.json`.