DEV Community: Khush Panchal

What even is an AI Agent?… Isn’t it just an API Call?

Khush Panchal — Tue, 31 Mar 2026 06:35:38 +0000

If you’ve been hearing “agents will do everything” and thinking…

“Isn’t this just a GPT API with a fancy wrapper?”

You’re not alone.

Here’s the simple truth:

An LLM (like GPT-5) is like a very powerful text-predicting brain.
An Agent is the system you build around that brain.

Let’s simplify what happens behind the scenes. Please note this is the beginner’s guide, we’ll skip the jargon and explain how things work, in layman’s terms.

LLM — The “black box” that answers in English

Let’s start super basic.

An LLM (Large Language Model) is trained to do one main thing:

Given some text, predict what text should come next.

It doesn’t “think” the way humans do. It predicts the next pieces of text using patterns it learned from a vast amount of reading. That’s literally how large language models are trained.

Let’s understand this a bit more with an example.

What happens when you ask: “How does a Car Engine work?”

In the simplest possible story:

Your sentence is split into tokens (numbers — computers love numbers).
The model uses a huge set of learned numbers (the “black box” — the LLM) to predict the next token.

In short, this LLM is using Machine Learning behind the scenes.

It is fed with lots of data (scraped from the internet over the years), learns patterns from that data, and when a new set of numbers is given, it predicts the best possible next response as numbers — which are eventually converted back to text again.

That’s it.

Mini LLM pseudo code

def mini_llm(prompt_text):  
    # 1) Break text into tokens (tiny chunks) because computers work on numbers  
    token_ids = tokenize(prompt_text)  

    # 2) Predict next token again and again  
    while not stop_condition(token_ids):  
        next_id = black_box_predict_next(token_ids)  # "best next number" (probability-based)  
        token_ids.append(next_id)  

    # 3) Convert numbers back to readable text  
    return to_text(token_ids)

This “predict next token” idea, and the repeated loop, is a standard way to describe how modern text-generation systems (LLMs) produce outputs.

Some private model examples are GPT-5, Gemini 2.5 Pro, Opus 4.5, and so on.

Now say you take any model and ask:

“What’s happening today in India?”

It will not be able to answer properly on its own.

As we discussed, a model is something pre-trained with lots of data, and now it understands how to answer questions based on that knowledge. But if you ask the model about today or any current information, it will not reliably know the answer.

So how do we solve that?

Train the model daily?

Issue — Training big models is crazy expensive (like millions of dollars).

That’s why a pure pretrained model may confidently answer “how engines work” but struggle with “what happened today”.

But then how is it that when you type the same query in ChatGPT, it is able to answer properly?

And this is where RAG comes in.

RAG in one line: Search + Attach + Answer

RAG full form is:

Retrieval‑Augmented Generation

Retrieval = go and fetch the right info (like searching)
Augmented = attach that info to your question
Generation = write the final answer

They don’t “retrain the brain”.

They connect the brain to fresh information through external sources.

A beginner mental model:

RAG turns the AI from “closed book exam” into an “open book exam”.

Now if you ask “what’s today’s news?”, I can call a News API, get today’s news, and then silently update the actual prompt I send to the LLM by passing the API data I received from the News API.

Now the LLM knows what to answer, and you see the response you actually wanted.

That’s RAG — passing an external source of information to the LLM.

Mini RAG pseudo code (simple version)

def mini_rag(question):  
    # Step 1: Retrieval (search some knowledge source)  
    context = search_news(question)  # returns response from News API  

    # Step 2: Augment (attach context to the question)  
    prompt = f"""  
    Use the CONTEXT to answer the QUESTION.  

    CONTEXT:  
    {context}  

    QUESTION:  
    {question}  
    """  

    # Step 3: Generation (write the answer)  
    return mini_llm(prompt)

But now a big question:

How does the AI system know that it has to call search_news()?

What if the user asks “What’s the weather in India today?”

This time you need a weather API, not a news API.

This is where MCP comes into the picture.

MCP: A protocol for tools, like HTTP is a protocol for web APIs

In normal software, we have a simple idea:

HTTP is a standard way for apps to talk to servers.

Because of HTTP, your app can call 1,000 different APIs in a predictable way.

MCP (Model Context Protocol) tries to do something similar for AI systems:

A standard way for an AI app to connect to external tools and data sources.

It was introduced as an open standard to make secure, two-way connections between AI apps and tools/data.

MCP is the “common language” between your agent and your tools.

Now, in the structure of MCP, there is metadata that contains the description of that MCP.

So how does this MCP help us solve the problem?

MCP has a structure where each MCP has a description of what it does. We call that metadata.

For example News MCP have:

{  
 "name": "news.latest"  
 "description": "Get today's latest headlines for a topic"  
}

And this News MCP when called will internally use news API to fetch the data and then the MCP will return the response.

So now the question changes to:

How does the LLM know which MCP to call?

So the general flow becomes:

When we ask “What’s today’s news?”, the AI system silently adds the metadata of all available MCPs to the prompt request sent to the LLM and then asks the LLM: if you don’t know the answer directly, choose the correct MCP that does know.

And the LLM, based on its strength in understanding English and descriptions, can correctly identify which MCP should be called for which question.

Then we can call search_news(), and again go back to the LLM — this time with the news information — and perform our RAG.

MCP vs RAG (the clean difference) — RAG is the idea: retrieve info, attach it, answer. MCP is the standard connection method to tools and data.

Agent: the backend “manager” that makes automation real

Now we reach the main hook of this blog:

An agent is not the brain. It’s the system.

The LLM is the “brain that writes”.

The Agent is the system that:

reads your request,
decides if a tool is needed,
calls that tool,
and then asks the LLM to write the final reply using tool results.

This “tool-calling flow” is explicitly a multi-step conversation:

send tools → model chooses tool → we execute tool → send tool output → model produces final response

Big picture architecture: apps → backend agent → tools/LLM

This matches how tool calling is designed in modern LLM APIs: the application (backend) sits in the middle, executes tools, and feeds results back to the model.

The simple “Latest news today” flow you asked to LLM

User question:

“What’s the latest news today in India?”

We’ll show the exact path, and what data is sent at each step.

Key detail: the model first receives the tool menu, not the tool result

When your backend contacts the LLM initially, it sends:

the question,
tool descriptions (what tools exist, what they do, what inputs they accept)

Step-by-step sequence diagram

The “model asks for a tool, app executes it, then model answers” pattern is exactly how tool calling works.

Example pseudo code

TOOLS = [  
  {  
    "name": "news.latest",  
    "description": "Get today's latest headlines for a topic",  
    "inputs": {"query": "text"}  
  }  
]  

def agent_answer(question):  
    # 1) Ask the LLM with the tool descriptions (menu)  
    first = llm_call(  
        prompt=question,  
        tools=TOOLS  
    )  

    # 2) If LLM says: "use the news tool", backend runs it  
    if first.type == "tool_request" and first.tool_name == "news.latest":  
        news = mcp_call("news.latest", {"query": first.args["query"]})  

        # 3) Ask LLM again, now including the fresh news data  
        final = llm_call(  
            prompt=f"Question: {question}\nFresh news data: {news}\nExplain simply.",  
            tools=[]  
        )  
        return final.text  

    # If no tool needed, return what model wrote directly  
    return first.text

Again: the LLM doesn’t “browse”.

Your backend agent does the tool calls, then the model writes the final message.

One more tiny example: “2 + 2”

Here’s the beginner-friendly punchline:

LLMs are great at language, but for guaranteed maths, you can use a Calculator MCP.

So your agent can do:

If question looks like maths → use Calculator MCP
Then ask the LLM to explain nicely.

This is the same tool calling loop, just with a different tool.

Calendar agent

A calendar agent works because you give the backend:

a calendar tool (via MCP),
and the LLM can choose it based on the tool description.

So:

“Schedule a meeting tomorrow 5 pm”

becomes:

model asks to call calendar.create_event,
backend calls it,
model confirms.

That “agent loop with tools + optional human approvals” is also a core pattern described in agent systems.

The simplest takeaway

If you remember only one thing, remember this:

LLM = Machine learning brain that predicts text (token-by-token)
RAG = Give the brain fresh notes before it speaks
MCP = A protocol that plugs tools into your AI system
Agent = Your backend system that connects brain + tools + loop

That’s why “agents” are not just an API call.

They are system design.

And once you see that, all those “agent agent agent” discussions stop sounding like magic — and start sounding like engineering.

Contact Me: LinkedIn | Twitter

Happy coding! ✌️

Run Your MVVM Android App on iOS — KMP Magic ✨

Khush Panchal — Sun, 25 Jan 2026 19:22:34 +0000

In this article, we’ll take an existing Android MVVM app and gradually convert it into a Kotlin Multiplatform (KMP) app — without rewriting the business logic.

The goal is simple:

Share business logic (repository, networking, database) across Android and iOS, while keeping UI native.

Out of scope for this article

To keep things simple and focused, we will not cover:
Common UI (Compose Multiplatform)
Common ViewModel
Publishing shared module remotely (KMMBridge / SPM)

We want clarity first, not complexity.

Outline of our article

Android only MVVM app (Starting point)

- Feature of sample app

- Basic outline of android project

- How data flows (mental model)

- Clone and run the android app
Setup the KMP world

- What’s important from the official guide (summary)
Beginning the KMP magic

- Step 1: Move data folder to the shared module

- Step 2: Replace Hilt with Koin (Multiplatform DI)

- Step 3: Replace Retrofit with Ktor

- Step 4: Replace Room with Room KMP

- Step 5: Create UI and ViewModel alternative for IOS
Final words

Android only MVVM app (Starting point)

We begin with an Android-only MVVM application that follows a clean and well-structured architecture.

Source code (master branch) — Link

Features of the sample app

Movies app using OMDb free API
Offline-first architecture (Database acts as a single source of truth, refer MovieRepository.kt file for implementation)
Two screens: Movie list screen (Uses MovieViewModel and shows a list of movies), Movie detail screen (simple UI, no ViewModel)
Uses: Retrofit → Networking; Room → Local caching; Hilt → Dependency Injection; Jetpack Compose → UI

Basic outline of the android project


└── com.khush.moviesapp
    ├── data
    │   ├── database
    │   │   ├── DatabaseService.kt
    │   │   ├── MovieDao.kt
    │   │   ├── MovieDatabase.kt
    │   │   └── MovieDatabaseService.kt
    │   ├── model
    │   │   └── MovieData.kt
    │   ├── network
    │   │   └── ApiInterface.kt
    │   ├── repository
    │   │   └── MovieRepository.kt
    │   └── utils
    │       └── Const.kt
    ├── di
    │   └── module
    │       └── ApplicationModule.kt
    ├── ui
    │   ├── viewmodel
    │   │   ├── MovieViewModel.kt
    │   │   └── UIState.kt
    │   ├── DetailScreen.kt
    │   ├── MovieActivity.kt
    │   └── MovieScreen.kt
    └── MovieApplication.kt

How data flows (mental model)

UI observes ViewModel
ViewModel talks to Repository
Repository decides: fetch from DB or fetch from API
UI reacts to changes in UIState

This mental model is important — we’ll preserve it even after KMP.

Clone and run the Android app

Before touching KMP, always verify the base app works.

Clone the repo (master branch)
Generate an API key from https://www.omdbapi.com/
Add the API key inside Const.kt
Run the Android app

We should see the movie list screen working correctly.

Setup up the KMP world

Before converting our Android MVVM app to a KMP MVVM app, we must ensure the KMP environment is correctly set up.

We will follow the official Kotlin guide for integrating KMP into an existing Android app — https://kotlinlang.org/docs/multiplatform/multiplatform-integrate-in-existing-app.html

You can follow this guide end-to-end. At this stage:

- Nothing meaningful will be shown on iOS yet

- Our goal is only to ensure the project builds and runs on both platforms

What’s important from the official guide (summary)

Create a shared module for cross-platform code — Link - Once created, we’ll see three important folders:

- commonMain - common kotlin code, accessible by both android and ios
- androidMain - android specific implementations, can use android sdk
- iosMain - ios specific implementations, can use ios platform apis

Add code to the shared module — Link - This allows Android code to access shared Kotlin code. We can see the use of expect/actual in the example, let’s understand the basics

KMP allows us to declare what we need in common code, and define how it works per platform.

- expect class — written in commonMain — method declaration without implementation

- actual class — written in androidMain or iosMain with platform specific implementation

Whenever common code needs different behavior on Android and iOS, we use expect/actual.

Add a dependency on the shared module to your Android application — Link
Now we will run our cross-platform application on Android
Make your cross-platform application work on iOS — Link

- Follow all four steps and finally verify that shared module can be imported in Swift and iOS app builds and runs successfully

Optional (but recommended): Install Kotlin Multiplatform plugin

Android Studio Settings → Plugins → Marketplace → Kotlin Multiplatform
This helps with: Environment checks, Project configuration, Boilerplate generation (We can do KMP without the plugin, but it smoothens the experience)

Beginning the KMP magic ✨

At this point:

• Android app works

• iOS app builds

• Shared module is ready

• KMP pipeline is validated

Now we are finally ready to convert our Android MVVM app into a KMP MVVM app.

At any point, you can refer to the full conversion Pull Request for comparison.

PR — Android → KMP conversion

Highlights of what we will be doing

Moving our data folder from app module to shared module
Replace Android only libraries to KMP compatible libraries

- Hilt → Koin (Dependency Injection)

- Retrofit → Ktor (Networking) (Additionally Gson → Kotlin Serialization)

- Room → Room KMP (Database)
Create native UI and ViewModel in swift for IOS

Step 1: Move data folder to the shared module

The data layer is the most natural candidate for sharing.

What we move

Move the entire data package from:

app/src/main/java

to:

shared/src/commonMain/kotlin

This includes: database, network, repository, model, utils

At this point, the project will break — this is expected.

We’ll fix things step by step.

Clean up Android-only dependencies

Since data logic is now shared, we must remove Android-only dependencies from app.

Remove from app/build.gradle.kts: Hilt, Retrofit, Room, kapt (we’ll use KSPinstead)

Step 2: Replace Hilt with Koin (Multiplatform DI)

Hilt is Android-only, so we replace it with Koin, which works on both Android and iOS.

Remove all Hilt annotations

@HiltViewModel, @AndroidEntryPoint, @HiltAndroidApp, @Inject constructor

Also delete: ApplicationModule.kt (Hilt module)

Create Android-specific Koin module in App module folder, and Shared module in commonMain folder.

#AppModule.kt

val appModule = module {
    viewModel {
        MovieViewModel(
            movieRepository = get()
        )
    }
}

###################################

#SharedModule.kt

val sharedModule = module {
   single<MovieRepository> {
        MovieRepository(
            apiInterface = get(),
            databaseService = get()
        )
    }
}

Now we will add koin related dependencies

#libs.version.toml

koin-bom = "4.1.1"

koin-bom = { module = "io.insert-koin:koin-bom", version.ref = "koin-bom" }
koin-core = { module = "io.insert-koin:koin-core" }
koin-android = { module = "io.insert-koin:koin-android" }
androidx-startup-runtime = { group = "androidx.startup", name = "startup-runtime", version.ref = "startupRuntime" }

###################################

#App Module build.gradle.kts

dependencies {
    implementation(project.dependencies.platform(libs.koin.bom))
    implementation(libs.koin.android)
}

###################################

#Shared Module build.gradle.kts

commonMain {
    dependencies {
        implementation(project.dependencies.platform(libs.koin.bom))
        implementation(libs.koin.core)
    }
}

Sync Gradle and then update MovieApplication.kt and MovieActivity.kt files

#MovieApplication.kt

class MovieApplication: Application() {
    override fun onCreate() {
        super.onCreate()
        // Initialize Koin on Android
        startKoin {
            androidContext(this@MovieApplication)
            modules(listOf(appModule, sharedModule))
        }
    }
}

###################################

#MovieActivity.kt

class MovieActivity : ComponentActivity() {

    // Inject ViewModel
    private val movieViewModel: MovieViewModel by inject()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MainScreen(movieViewModel = movieViewModel, ...)
        ...
    }
}

Step 3: Replace Retrofit with Ktor

Retrofit is Android-only.

We replace it with Ktorfit (built upon Ktor), which gives us a Retrofit-like API but works on KMP.

To do it we will add Ktor, Ktorfit and Kotlin Serialization dependency (We will replace with Gson used in android project). We will also need KSP for this.

#libs.version.toml

ktor = "3.3.3"
ktorfit = "2.7.2"
ksp = "2.3.4"

ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
ktor-serialization = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }
ktor-client-content-negotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" }
ktorfit-lib = {module = "de.jensklingenberg.ktorfit:ktorfit-lib", version.ref = "ktorfit" }

[plugins]
ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
ktorfit = { id = "de.jensklingenberg.ktorfit", version.ref = "ktorfit" }
kotlinxSerialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }

###################################

#Project level build.gradle.kts

alias(libs.plugins.ksp) apply false
alias(libs.plugins.ktorfit) apply false
alias(libs.plugins.kotlinxSerialization) apply false

###################################

#Shared module build.gradle.kts

alias(libs.plugins.ksp)
alias(libs.plugins.ktorfit)
alias(libs.plugins.kotlinxSerialization)

commonMain {
    dependencies {
        // Ktor
        implementation(libs.ktor.client.core)
        implementation(libs.ktor.client.content.negotiation)
        implementation(libs.ktor.serialization)

        // Ktorfit
        implementation(libs.ktorfit.lib)
}

We will use the same ApiInterface.kt class just replace the imports

#ApiInterface.kt

import de.jensklingenberg.ktorfit.http.GET
import de.jensklingenberg.ktorfit.http.Query

interface ApiInterface {
    @GET(".")
    suspend fun getMoviesData(
        @Query("s") s: String = "army",
        @Query("apikey") apikey: String = Const.API_KEY
    ): ApiResponse
}

We will add the dependency in shared module class for Ktorfit

#SharedModule.kt

val sharedModule = module {
    single<ApiInterface> {
        val ktorfit = Ktorfit
            .Builder()
            .baseUrl(Const.BASE_URL)
            .httpClient(
                HttpClient {
                    install(ContentNegotiation) {
                        json(
                            Json {
                                isLenient = true
                                ignoreUnknownKeys = true
                                prettyPrint = true
                            }
                        )
                    }
                }
            )
            .build()

        ktorfit.createApiInterface()
    }
}

To use Kotlin Serialization, inside MovieData.kt replace @Serializable with @SerialName, add @Serializable over data classes

Step 4: Replace Room with Room KMP

We will now replace room with KMP supported Room version.

We will add the dependency for room and all necessary configurations.

#libs.version.toml

room = "2.8.4"
sqlite = "2.6.2"
koin-bom = "4.1.1"
startupRuntime = "1.2.0"

androidx-room-runtime = { group = "androidx.room", name = "room-runtime", version.ref = "room" }
androidx-room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "room" }
androidx-sqlite-bundled = { module = "androidx.sqlite:sqlite-bundled", version.ref = "sqlite" }
androidx-startup-runtime = { group = "androidx.startup", name = "startup-runtime", version.ref = "startupRuntime" }

[plugins]
androidx-room = { id = "androidx.room", version.ref = "room" }

###################################

#Project level build.gradle.kts

alias(libs.plugins.androidx.room) apply false

###################################

#Shared Module build.gradle.kts

alias(libs.plugins.androidx.room)

commonMain {
  dependencies {
      // Room
      implementation(libs.androidx.room.runtime)
      implementation(libs.androidx.sqlite.bundled)
  }
}
androidMain {
  dependencies {
    implementation(libs.androidx.startup.runtime)
  }
}
room {
    schemaDirectory("$projectDir/schemas")
}
dependencies {
    add("kspAndroid", libs.androidx.room.compiler)
    add("kspIosSimulatorArm64", libs.androidx.room.compiler)
    add("kspIosX64", libs.androidx.room.compiler)
    add("kspIosArm64", libs.androidx.room.compiler)
}

###################################

#proguard-rules.pro

-keep class * extends androidx.room.RoomDatabase { <init>(); }

We need to modify MovieDatabase.kt class definition

#MovieDatabase.kt

@Database(entities = [MovieData::class], version = 1, exportSchema = false)
@ConstructedBy(MovieDatabaseConstructor::class)
abstract class MovieDatabase : RoomDatabase() {

    abstract fun getMovieDao(): MovieDao

}

// The Room compiler generates the `actual` implementations.
@Suppress("KotlinNoActualForExpect")
expect object MovieDatabaseConstructor : RoomDatabaseConstructor<MovieDatabase> {
    override fun initialize(): MovieDatabase
}

Now we will create the instance inside SharedModule.kt

val sharedModule = module {
  single<DatabaseService> {
        MovieDatabaseService(
            getDatabaseBuilder()
                .setDriver(BundledSQLiteDriver())
                .setQueryCoroutineContext(Dispatchers.IO)
                .build()
        )
    }
}

You can see getDatabaseBuilder() which is needed for Room to create Database instance, we need to create the RoomDatabase.Builder instance separately for platform specific modules (android and ios).

Before creating expect actual method for database builder, we need app context for creating it for android platform module, we will create it using app startup library that we have added in dependency in *androidMain*module

#androidMain folder AndroidManifest.xml file

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
    <application>
        <provider
            android:name="androidx.startup.InitializationProvider"
            android:authorities="${applicationId}.androidx-startup"
            android:exported="false"
            tools:node="merge">
            <meta-data
                android:name="com.khush.shared.data.database.AppContextInitializer"
                android:value="androidx.startup" />
        </provider>
    </application>
</manifest>

###################################

#AppContextInitializer.kt

class AppContextInitializer: Initializer<Context> {

    companion object {
        lateinit var applicationContext: Context
    }

    override fun create(context: Context): Context {
        applicationContext = context.applicationContext
        return context
    }

    override fun dependencies(): List<Class<out Initializer<*>?>?> {
        return emptyList()
    }

}

Now let’s create Database builder instance

#MovieDatabase.kt

expect fun getDatabaseBuilder(): RoomDatabase.Builder<MovieDatabase>

###################################

#MovieDatabase.android.kt

actual fun getDatabaseBuilder(): RoomDatabase.Builder<MovieDatabase> {
    val appContext = AppContextInitializer.applicationContext
    val dbFile = appContext.getDatabasePath("main_db.db")
    return Room.databaseBuilder<MovieDatabase>(
        context = appContext,
        name = dbFile.absolutePath
    )
}

###################################

#MovieDatabase.ios.kt

actual fun getDatabaseBuilder(): RoomDatabase.Builder<MovieDatabase> {
    val dbFilePath = documentDirectory() + "/main_db.db"
    return Room.databaseBuilder<MovieDatabase>(
        name = dbFilePath,
    )
}

@OptIn(ExperimentalForeignApi::class)
private fun documentDirectory(): String {
    val documentDirectory = NSFileManager.defaultManager.URLForDirectory(
        directory = NSDocumentDirectory,
        inDomain = NSUserDomainMask,
        appropriateForURL = null,
        create = false,
        error = null,
    )
    return requireNotNull(documentDirectory?.path)
}

That’s it, rest room structure remains the same, no changes in DAO or Entity class.

Run Android app: Congrats, Android app now runs fully using KMP shared module

Let’s run it on IOS now.

Step 5: Create UI and ViewModel alternative for IOS

We will first add Skie dependency. Skie library helps between Kotlin and Swift interoperability.

Skie allows Kotlin Flow → Swift async/await.

#libs.version.toml

skie = "0.10.9"

[plugins]
skie = { id = "co.touchlab.skie", version.ref = "skie" }

###################################

#Project level build.gradle.kts

alias(libs.plugins.skie) apply false

###################################

#Shared Module build.gradle.kts

alias(libs.plugins.skie)

We need to start koin and access movie repository from ios swift files, we will create a mediator class in iosMain folder inside shared module that will do the work, we can directly access it from Swift file

#SharedIosInterop.kt

object SharedIosInterop: KoinComponent {

    val movieRepository: MovieRepository by inject()

    fun initKoin() {
        startKoin {
            modules(sharedModule)
        }
    }
}

Let’s create the UI and ViewModel for IOS in iosApp folder. Delete existing Swift file and create the below files.

#iosApp.swift

import SwiftUI
import sharedKit

@main
struct iosAppApp: App {

    private let shared = SharedIosInterop()
    // Initialize Koin on app start 
    init() {
        shared.doInitKoin()
    }

    var body: some Scene {
        WindowGroup {
            MovieScreen(
                vm: MovieViewModel(repo: shared.movieRepository)
            )
        }
    }
}

###################################

#MovieScreen.swift

struct MovieScreen: View {
    @StateObject var vm: MovieViewModel

    var body: some View {
        NavigationStack {
            content
        }
    }

    @ViewBuilder
    private var content: some View {
        switch vm.state {
        case .loading:
            ProgressView()

        case .failure(let msg):
            VStack(spacing: 12) {
                Text(msg).multilineTextAlignment(.center)
                Button("Retry") { vm.start() }
            }
            .padding()

        case .success(let movies):
            List {
                ForEach(movies, id: \.title) { movie in
                    NavigationLink {
                        DetailScreen(title: movie.title, poster: movie.poster)
                    } label: {
                        MovieRow(movie: movie)
                    }
                }
            }
        }
    }
}

struct MovieRow: View {
    let movie: MovieData

    var body: some View {
        HStack(spacing: 12) {
            AsyncImage(url: URL(string: movie.poster)) { phase in
                switch phase {
                case .empty:
                    Rectangle().opacity(0.2)
                case .success(let image):
                    image.resizable().scaledToFill()
                default:
                    Rectangle().opacity(0.2)
                }
            }
            .frame(width: 80, height: 80)
            .clipped()

            Text(movie.title)
                .font(.headline)

            Spacer()
        }
        .padding(.vertical, 6)
    }
}

###################################

#MovieViewModel.swift

import Foundation
import Combine
import sharedKit

@MainActor
final class MovieViewModel: ObservableObject {

    enum ScreenState {
        case loading
        case success([MovieData])
        case failure(String)
    }

    @Published private(set) var state: ScreenState = .loading

    private let repo: MovieRepository
    private var task: Task<Void, Never>?

    init(repo: MovieRepository) {
        self.repo = repo
        start()
    }

    func start() {
        task?.cancel()
        state = .loading

        task = Task {
            do {
                for try await value in repo.getMoviesData() {
                    let movies = (value as? [MovieData]) ?? []
                    if movies.isEmpty {
                        state = .failure("Empty Data")
                    } else {
                        state = .success(movies)
                    }
                }
            } catch {
                state = .failure(error.localizedDescription)
            }
        }
    }

    deinit {
        task?.cancel()
    }
}

###################################

#DetailScreen.swift

import SwiftUI

struct DetailScreen: View {
    let title: String
    let poster: String

    var body: some View {
        VStack(spacing: 16) {
            Text(title).font(.title2)

            AsyncImage(url: URL(string: poster)) { phase in
                switch phase {
                case .empty:
                    ProgressView()
                case .success(let image):
                    image.resizable().scaledToFit()
                default:
                    Text("Image load failed")
                }
            }
        }
        .padding()
    }
}

We will add few files on .gitignore.

#.gitignore

shared/build
xcuserdata
*.xcodeproj/*
!*.xcodeproj/project.pbxproj
!*.xcodeproj/xcshareddata/
!*.xcodeproj/project.xcworkspace/
!*.xcworkspace/contents.xcworkspacedata
**/xcshareddata/WorkspaceSettings.xcsettings

Great, now run the IOS project it should run the MVVM app in IOS using shared module

Finally after all, your structure should look something like this

├── app
│   ├── src
│   │   ├── main
│   │   │   ├── java
│   │   │   │   └── com.khush.moviesapp
│   │   │   │      ├── di.module
│   │   │   │      │   └── AppModule.kt
│   │   │   │      ├── ui
│   │   │   │      │   ├── viewmodel
│   │   │   │      │   │   ├── MovieViewModel.kt
│   │   │   │      │   │   └── UIState.kt
│   │   │   │      │   ├── DetailScreen.kt
│   │   │   │      │   ├── MovieActivity.kt
│   │   │   │      │   └── MovieScreen.kt
│   │   │   │      └── MovieApplication.kt
│   │   │   └── AndroidManifest.xml
│   ├── build.gradle.kts
│   └── proguard-rules.pro
├── gradle
│   └── libs.versions.toml
├── iosApp
│   ├── iosApp
│   │   ├── DetailScreen.swift
│   │   ├── IosApp.swift
│   │   ├── MovieScreen.swift
│   │   └── MovieViewModel.swift
│   └── iosApp.xcodeproj
├── shared
│   ├── src
│   │   ├── androidMain
│   │   │   ├── kotlin
│   │   │   │   └── com.khush.shared
│   │   │   │       └── data
│   │   │   │           └── database
│   │   │   │              ├── AppContextInitializer.kt
│   │   │   │              └── MovieDatabase.android.kt
│   │   │   └── AndroidManifest.xml
│   │   ├── commonMain
│   │   │   └── kotlin
│   │   │       └── com.khush.shared
│   │   │           ├── data
│   │   │           │   ├── database
│   │   │           │   │   ├── DatabaseService.kt
│   │   │           │   │   ├── MovieDao.kt
│   │   │           │   │   ├── MovieDatabase.kt
│   │   │           │   │   └── MovieDatabaseService.kt
│   │   │           │   ├── model
│   │   │           │   │   └── MovieData.kt
│   │   │           │   ├── network
│   │   │           │   │   └── ApiInterface.kt
│   │   │           │   ├── repository
│   │   │           │   │   └── MovieRepository.kt
│   │   │           │   └── utils
│   │   │           │       └── Const.kt
│   │   │           └── di
│   │   │               └── SharedModule.kt
│   │   └── iosMain
│   │       └── kotlin
│   │           └── com.khush.shared
│   │               ├── data
│   │               │   └── database
│   │               │       └── MovieDatabase.ios.kt
│   │               └── interop
│   │                   └── SharedIosInterop.kt
│   └── build.gradle.kts
├── build.gradle.kts
└── settings.gradle.kts

Final words

Congratulations! Now we are able to run same MVVM app on IOS and it is just the beginning, this base understanding will help you integrate more complex project into IOS later.

Source code (master-multiplatform branch) — Link

Check out the pull request for the conversion for better understanding — Link

Contact Me: LinkedIn, Twitter

Happy coding ✌️

Create your own Android ViewModel from scratch

Khush Panchal — Sun, 11 Jan 2026 19:50:48 +0000

You have used ViewModel many times, but do you truly know what purpose it serves, how it is created and how it survives rotation?
In day-to-day Android work, we usually create ViewModels in different ways:

Directly with ViewModelProvider:

val vm = ViewModelProvider(this, factory).get(MyViewModel::class.java)

With Hilt (DI)

val vm: MyViewModel = hiltViewModel() 
// Hilt hides the provider way, but internally the idea is still similar

What is the purpose of ViewModel

ViewModel is just a class that:

holds UI state (example loading, failure, success state),
survives configuration changes (example screen rotation, theme changes),
gets cleared only when the screen (like activity or fragment) is actually finished

In this blog, we’ll build a mini version of this system ourselves — so the “magic” becomes clear.

What we want to achieve

Before writing code, let’s define the goals (this keeps the implementation clean):

ViewModel should survive configuration changes: ViewModel instance should not be cleared when activity is recreated due to configuration changes like screen rotation.
Same ViewModel class can exist in multiple Activities, but should not be shared: Two different Activities can both use SomeViewModel class, but each Activity should have its own separate instance.
One Activity can have multiple ViewModels, but only one instance per ViewModel class: Inside a single Activity: We can have HomeViewModel, ProfileViewModel, etc.; But for each ViewModel class, there should be only one instance; And when the Activity is truly finished (not rotation), all its ViewModels should be cleared.

Mental model: how we can achieve this

Think of the whole system as two-level storage

Level 1: Store ViewModels for an Activity

Since a single Activity can have multiple ViewModels, we need a container that can store them all together

So we create a class called ViewModelStore which holds ViewModels in a HashMap:

key = canonical(fully qualified including path) name of ViewModel class (e.g,: “com.app.ProfileViewModel”)
value = actual ViewModel instance

That way:

if Activity asks again for ProfileViewModel, we return the same instance from the map
if it doesn’t exist, we create and store it
we can clear it when activity is destroyed by calling clear method on map

This solves: “single Activity → multiple ViewModels” and “one instance per ViewModel class”.

Level 2: Store ViewModelStore outside Activity

Now comes the main trick

If ViewModelStore lives inside Activity, it will die whenever Activity dies.

But Activity dies in two situations:

Configuration change → should NOT clear ViewModels
Actual finish (back press) → should clear ViewModels

So we need to store ViewModelStore outside Activity in something that stays alive across rotation

The simplest “lives-through-the-app” place is the Application class.

So inside Application, we keep another HashMap:

key = canonical name of Activity class (example: “com.app.ProfileActivity”)
value = the Activity’s ViewModelStore

This solves: “do not lose ViewModels on rotation”.

Let’s dive into some code for creating the core components that will help us create our own ViewModel:

Core Components

MyViewModel

Base contract for ViewModel class.

interface MyViewModel {
    // Called before actually destroying the viewmodel instance
    fun onCleared() {}
}

MyViewModelStore

Class that stores multiple ViewModels in a HashMap where the key is the ViewModel’s canonical name and the value is the ViewModel instance.

class MyViewModelStore {
    private val map = HashMap<String, MyViewModel>()

    fun put(key: String, viewModel: MyViewModel) {
        val oldViewModel = map.get(key)
        oldViewModel?.onCleared()
        map[key] = viewModel
    }

    fun get(key: String): MyViewModel? {
        return map[key]
    }

    fun clear() {
        for (vm in map.values) {
            vm.onCleared()
        }
        map.clear()
    }
}

MyViewModelStoreOwner

The owner contract. Our Activity will implement this so it can provide the correct MyViewModelStore.

interface MyViewModelStoreOwner {
    fun getMyViewModelStore(): MyViewModelStore
}

MyViewModelProvider(+ Factory)

The manager. This is the class that returns the same ViewModel instance if it already exists in the store, or creates a new one using the factory when it doesn’t.

class MyViewModelProvider(
    private val owner: MyViewModelStoreOwner,
    private val factory: MyViewModelFactory
) {
    fun <T : MyViewModel> get(modelClass: KClass<T>): T {
        val key = modelClass.qualifiedName!! // canonical name
        var viewModel = owner.getMyViewModelStore().get(key)
        // we check if viewModel already exists else create new
        if (modelClass.isInstance(viewModel)) {
            return viewModel as T
        } else {
            viewModel = factory.create(modelClass)
            owner.getMyViewModelStore().put(key, viewModel)
        }
        return viewModel as T
    }

    interface MyViewModelFactory {
        fun <T : MyViewModel> create(modelClass: KClass<T>): T
    }
}

Let’s dive into the some practical example:

Counter Example

To make this system easy to understand, we’ll use a simple UI: a counter text and a button. The counter value is our “UI state”, and the whole purpose of this demo is to prove:

Tap the button → count increases
Rotate the screen → count should stay the same
Press back / close the Activity → ViewModel should clear.

CounterApplication

Application class that will be holding the ViewModelStore in HashMap where key will be the canonical name of our ViewModelStoreOwner (like activity).

class CounterApplication: Application() {
    private val viewModelStores = HashMap<String, MyViewModelStore>()

    fun getViewModelStore(key: String): MyViewModelStore {
        return viewModelStores.getOrPut(key) { MyViewModelStore() }
    }

    fun clearViewModelStore(key: String) {
        viewModelStores.get(key)?.clear()
        viewModelStores.remove(key)
    }
}

CounterViewModel

It holds the count state.

class CounterViewModel : MyViewModel {
    private var count = 0

    init {
        Log.i("CounterViewModel", "ViewModel created")
    }

    fun getCount(): Int {
        return count
    }

    fun incrementCount() {
        count++
    }

    override fun onCleared() {
        super.onCleared()
        Log.i("CounterViewModel", "ViewModel cleared")
    }
}

CounterViewModelFactory

This will create the ViewModel.

class CounterViewModelFactory: MyViewModelProvider.MyViewModelFactory {
    override fun <T : MyViewModel> create(modelClass: KClass<T>): T {
        return CounterViewModel() as T
    }
}

CounterActivity

Implements MyViewModelStoreOwner that provides ViewModelStore.
Requests the ViewModel through MyViewModelProvider, uses it to render the UI, and clears everything only when the Activity is actually finished (not on configuration changes).

class CounterActivity : AppCompatActivity(), MyViewModelStoreOwner {

    private lateinit var counterTv: TextView
    private lateinit var counterIncreaseBtn: Button

    private val viewModel: CounterViewModel by lazy {
        MyViewModelProvider(this, CounterViewModelFactory()).get(CounterViewModel::class)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_counter)
        counterTv = findViewById(R.id.textView)
        counterIncreaseBtn = findViewById(R.id.button)

        counterTv.text = viewModel.getCount().toString()

        counterIncreaseBtn.setOnClickListener {
            viewModel.incrementCount()
            counterTv.text = viewModel.getCount().toString()
        }

    }

    override fun onDestroy() {
        super.onDestroy()
        // check if activity is destroying due to configuration changes
        if (!isChangingConfigurations) {
            (application as CounterApplication).clearViewModelStore(this.javaClass.canonicalName!!)
        }
    }

    override fun getMyViewModelStore(): MyViewModelStore {
        return (application as CounterApplication).getViewModelStore(this@CounterActivity.javaClass.canonicalName!!)
    }
}

Putting it all together (the full picture)

Now our brain can imagine the flow like this:

Activity = ViewModelStoreOwner (as it owns ViewModelStore)

It doesn’t create ViewModels directly
It only knows how to provide its ViewModelStore

Application = the long-living storage

It keeps one ViewModelStore per Activity class
Rotation happens → Activity recreates → Application still has the store → ViewModels survive

ViewModelStore (as it store ViewModels) = the per-Activity container

It keeps one ViewModel instance per ViewModel class using a map

ViewModelProvider = the manager

The provider is the class that “glues everything”
It checks if ViewModel exists in the store; if yes → returns it; if no → creates it using a Factory, stores it, and returns it

Factory = the creator

Only job: create ViewModels when Provider needs a new one.

Application holds Activity’s ViewModelStore, and ViewModelStore holds Activity’s ViewModels.
Two hashmaps → two levels

And this is how the “magic” works :)

Bonus: SavedStateHandle

Our current custom ViewModel already survives rotation, because the store lives outside the Activity.
But it still won't survive process death (when Android kills your app in the background to reclaim memory). In that case, the Application memory is gone too - so your stored ViewModel instances are gone as well.
That's where SavedStateHandle helps:

Think of it as a small key–value storage attached to a ViewModel.
Android can save it into a Bundle and restore it later, even after process death.

Out of scope for this article: we won't build a custom SavedStateHandle implementation here.
But the idea is simple: use onSaveInstanceState(…) to store the important key–values, restore them when the screen comes back, and pass that restored state into your ViewModelFactory, which then passes it into the ViewModel.

Source Code: GitHub

Contact Me: LinkedIn | Twitter

Happy coding! ✌️

Supporting Multiple Languages in Your Android Application

Khush Panchal — Tue, 28 Jan 2025 18:34:37 +0000

In this blog, we will explore how to implement multilingual support in an Android application providing step-by-step implementation with code snippets.

What is Locale?

Before diving into the code, let's understand the term "Locale."

A Locale represents a specific geographical, or cultural region. It is used to customize the app's content, such as language, date formats, currency, etc., to match the user's preferences. For example: Locale for English: en, Locale for Hindi: hi, Locale for French: fr

By setting the appropriate Locale in your app, we can ensure that users experience the application in their preferred language.

Here's what we aim to achieve:

Allow users to select their preferred language.
Save the selected language preference.
Apply the selected language throughout the app.

Step 1: Setting Up the Language Manager

We will create a LanguageManager object to handle saving, retrieving, and applying the selected language.

object LanguageManager {
    private const val LANGUAGE_KEY = "language_key"
    private const val DEFAULT_LANGUAGE = "en"

    fun saveLanguage(context: Context, language: String) {
        val sharedPreferences = context.getSharedPreferences("app_prefs", Context.MODE_PRIVATE)
        sharedPreferences.edit().putString(LANGUAGE_KEY, language).apply()
    }

    fun getLanguage(context: Context): String {
        val sharedPreferences = context.getSharedPreferences("app_prefs", Context.MODE_PRIVATE)
        return sharedPreferences.getString(LANGUAGE_KEY, DEFAULT_LANGUAGE) ?: DEFAULT_LANGUAGE
    }

    fun setLocale(context: Context, language: String): Context {
        val locale = Locale(language)
        Locale.setDefault(locale)
        val config = Configuration(context.resources.configuration)
        config.setLocale(locale)
        return context.createConfigurationContext(config)
    }
}

Explanation:

saveLanguage(): Saves the selected language to SharedPreferences so it persists across app restarts.
getLanguage(): Retrieves the saved language, defaulting to English (en) if none is set.
setLocale(): Updates the app's Locale to reflect the selected language and ensures the app's resources are reloaded accordingly. This function is responsible for setting the Locale for the context, ensuring that any resource fetched from the context is based on the updated Locale.

Step 2: Updating the Base Context

To ensure the selected language is applied throughout the app, we override the attachBaseContext method in a BaseActivity class. All other activities will inherit from this base class.

abstract class BaseActivity : ComponentActivity() {
    override fun attachBaseContext(newBase: Context) {
        val language = LanguageManager.getLanguage(newBase)
        val context = LanguageManager.setLocale(newBase, language)
        super.attachBaseContext(context)
    }
}

How It Works:

When an activity is created, the attachBaseContext method is called (before onCreate).
We fetch the saved language using LanguageManager.getLanguage().
We then apply the saved language by calling LanguageManager.setLocale().
The updated context ensures that the selected language is used for all resources.

Step 3: Creating the Sample Screen

We create the MainActivity class inherits from BaseActivity. It serves as the entry point of our app and provides users with the option to select a language.

class MainActivity : BaseActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            MultiLanguageTheme {
                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                    MainScreen(
                        modifier = Modifier.padding(innerPadding)
                    )
                }
            }
        }
    }
}

The MainScreen composable provides a simple UI for users to select their preferred language.

@Composable
fun MainScreen(
    modifier: Modifier = Modifier,
) {
    val context = LocalContext.current
    Column(
        modifier = modifier
            .fillMaxSize()
            .padding(16.dp),
        verticalArrangement = Arrangement.Center,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        // Welcome Text
        Text(
            text = context.resources.getString(R.string.welcome_text),
            modifier = Modifier.padding(bottom = 16.dp)
        )
        // Language Selection
        Text(
            text = context.resources.getString(R.string.select_language),
            modifier = Modifier.padding(bottom = 8.dp)
        )
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceEvenly
        ) {
            Column(
                horizontalAlignment = Alignment.CenterHorizontally,
                verticalArrangement = Arrangement.SpaceEvenly
            ) {
                Button(onClick = { changeLocale(context, "en") }) {
                    Text(text = "English")
                }
                Button(onClick = { changeLocale(context, "hi") }) {
                    Text(text = "हिंदी")
                }
            }
            Column(
                horizontalAlignment = Alignment.CenterHorizontally,
                verticalArrangement = Arrangement.SpaceEvenly
            ) {
                Button(onClick = { changeLocale(context, "fr") }) {
                    Text(text = "Français")
                }
                Button(onClick = { changeLocale(context, "es") }) {
                    Text(text = "Español")
                }
            }
        }
        // Flag Image
        Image(
            painter = painterResource(id = R.drawable.flag),
            contentDescription = null,
            modifier = Modifier
                .padding(top = 32.dp)
                .size(200.dp)
        )
    }
}

Step 4: Changing the Language Dynamically

When a user selects a language, we need to update the Locale and restart the app.

fun changeLocale(context: Context, language: String) {
    LanguageManager.saveLanguage(context, language)
    LanguageManager.setLocale(context, language)
    restartApp(context)
}

fun restartApp(context: Context) {
    val intent = Intent(context, MainActivity::class.java)
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
    context.startActivity(intent)
    if (context is Activity) {
        context.finish()
    }
}

Step 5: Adding Language Resources

To support multiple languages, create separate values folders for each language in the res directory:

res/values/strings.xml (default English):

<resources>
    <string name="app_name">MultiLanguage</string>
    <string name="welcome_text">Welcome to the MultiLingual App!</string>
    <string name="select_language">Select Language:</string>
</resources>

res/values-hi/strings.xml (Hindi):

<resources>
    <string name="app_name">MultiLanguage</string>
    <string name="welcome_text">मल्टीलिंगुअल ऐप में आपका स्वागत है!</string>
    <string name="select_language">भाषा चुने:</string>
</resources>

Similarly for other language as well, res/values-fr/strings.xml (French), res/values-es/strings.xml (Spanish)
For changing images based on locale, similar to values folder, create drawable folder for each language like drawable, drawable-hi, drawable-fr, drawable-es and add the image with the same name in all the folder.

Sample app

Source Code: GitHub
Contact Me: LinkedIn | Twitter
Happy coding! ✌️

Kotlin Generics Simplified

Khush Panchal — Tue, 14 Jan 2025 19:05:54 +0000

Generics in Kotlin allow us to write flexible and reusable code. In this article, we’ll dive into the world of Kotlin Generics and cover the following topics:

What are Generics and Why Do We Need Them?
Generic Functions
Constraints in Generics
Type Erasure in Generics
Variance in Generics

What are Generics and Why Do We Need Them?

Generics enable us to write a single class, function, or property that can handle different types. This reduces code duplication and increases flexibility.

Imagine we’re building an app where users answer questions. We start with a simple Question class:

data class Question(
    val questionText: String,
    val answer: String
)

fun main() {
    val question = Question("Name your favorite programming language", "Kotlin")
}

This works fine for text answers. But what if the answer can also be a number or a boolean? We’d need multiple versions of the Question class or sacrifice type safety by using Any. Both approaches are less than ideal.

Solution: Generics

Generics allow us to make the Question class type-flexible by introducing a type parameter <T>:

data class Question<T>(
    val questionText: String,
    val answer: T
)

fun main() {
    val questionString = Question("What's your favorite programming language?", "Kotlin")
    val questionBoolean = Question("Kotlin is statically typed?", true)
    val questionInt = Question("How many days are in a week?", 7)
}

Here, <T> is a placeholder for the type of answer. The compiler ensures type safety while providing flexibility. If needed, you can explicitly specify the type:

val questionInt = Question<Int>("2 + 2 equals?", 4)

Why Use Generics?

Avoid code duplication.
Increase reusability.
Maintain type safety.

Generic Functions

Generics aren’t just for classes — they work with functions too! To define a generic function, place the type parameter <T> before the function name.

fun <T> printValue(value: T) {
    println(value)
}

fun <T> T.toCustomString(): String { // Generic extension function
    return "Value: $this"
}

fun main() {
    printValue("Hello, Kotlin!")
    printValue(42)
    println(3.14.toCustomString())
}

Generics Constraints

Sometimes, we need the type parameter to meet certain requirements. Constraints restrict the types that can be used as arguments for generics.

interface Movable {
    fun move()
}

class Car(private val make: String, private val model: String) : Movable {
    override fun move() {
        println("$make $model is moving.")
    }
}

fun <T : Movable> run(vehicle: T) {
    vehicle.move()
}

fun main() {
    run(Car("BMW", "X3 M"))
}

Here, the <T : Movable> constraint ensures that only types implementing Movable can be used. The type specified after a colon is the upper bound (Movable).

The default upper bound (if there was none specified) is Any?

Only one upper bound can be specified inside the angle brackets. If the same type parameter needs more than one upper bound, we need a separate where-clause:

interface Flyable {
    fun fly()
}

class Plane(private val make: String, private val model: String) : Movable, Flyable {
    override fun move() {
        println("$make $model is moving.")
    }

    override fun fly() {
        println("$make $model is flying.")
    }
}

fun <T> operate(vehicle: T) where T : Movable, T : Flyable {
    vehicle.move()
    vehicle.fly()
}

fun main() {
    operate(Plane("Boeing", "747"))
}

The where clause ensures that the type T satisfies multiple constraints.

Type Erasure in Generics

At compile time, the compiler removes the type argument from the function call. This is called type erasure. The reified keyword retains the type information at runtime, but it can only be used in inline functions. Reified let us use reflection on type parameter. Function must be inline to use reified.

// Generics reified
fun <T> printSomething(value: T) {
    println(value.toString())// OK
//    println("Doing something with type: ${T::class.simpleName}") // Error
}

inline fun <reified T> doSomething(value: T) {
    println("Doing something with type: ${T::class.simpleName}") // OK
}

Variance in Generics

Variance modifiers out and in help make generics flexible by controlling how subtypes are treated. Kotlin offers three variance:

Invariant (T)
Covariant (out T)
Contravariant (in T)

Invariant Generics

By default, Kotlin generics are invariant. This means that even if B is a subclass of A, Container<B> is not a subclass of Container<A>.

class Container<T>(val item: T)

fun main() {
    val intContainer = Container(10)
    // val numberContainer: Container<Number> = intContainer // Error: Type mismatch
}

Invariant generics ensure that no unsafe operations occur, as Container<T> guarantees the exact type of T.

Covariant Generics (out T)

The out modifier is used when a generic class or function only produces values of type T. It ensures that subtypes are preserved, meaning if Dog is a subtype of Animal, then Producer<Dog> is also a subtype of Producer<Animal>.

open class Animal
class Dog : Animal()

class AnimalProducer<out T>(private val instance: T) {
    fun produce(): T = instance
    // fun consume(value: T) { /* ... */ } // This will show compile time error
}

fun main() {
    val dogProducer: AnimalProducer<Animal> = AnimalProducer(Dog())
    println("Produced: ${dogProducer.produce()}") // Works because of `out`
}

Contravariant Generics (in T)

The in modifier is used when a generic class or function only consumes values of type T. It reverses the subtyping relationship. If Dog is a subtype of Animal, then Consumer<Animal> is a subtype of Consumer<Dog>.

class AnimalConsumer<in T> {
    fun consume(value: T) {
        println("Consumed: ${value.toString()}")
    }
    // fun produce(): T { /* ... */ } //This will show compile time error
}

fun main() {
    val animalConsumer: AnimalConsumer<Dog> = AnimalConsumer<Animal>()
    animalConsumer.consume(Dog()) // Works because of `in`
}

Source Code: GitHub
Contact Me: LinkedIn | Twitter

Happy coding! ✌️

How to Create and Publish an Android Library for Beginners

Khush Panchal — Sat, 11 Jan 2025 09:15:02 +0000

In this article, we will explore the simplest way to create and publish an open-source Android library. This guide is divided into three parts:

How to push an Android project to GitHub
How to create an Android Library
How to publish the library

Create and Push the Project to GitHub

For demonstration, we’ll create a basic library to show a toast (short UI message).

Open Android Studio and create a new project with an empty activity. Set the project name (e.g., ToastMe) and package name (e.g., com.toastme), then click Finish.

Go to GitHub and create a new repository (e.g., ToastMe).

Open the Android Studio terminal and run the following commands:

git init
git remote add origin git@github.com:khushpanchal/ToastMe.git
git add .
git commit -m "Init commit"
git push -u origin main

Refresh GitHub to confirm the code has been pushed.

Create an Android Library

Now, let’s create the library module.

In Android Studio, go to File > New > New Module.
Select Android Library, set a name (e.g., toastlibrary), and package name (e.g., com.toastlibrary), then click Finish.
You should see a new folder (toastlibrary) in the project structure.
Add a ToastUtil class in the library module with a utility function to show a toast message:

Commit the changes:

git add .
git commit -m "Add toastlibrary module"
git push

To test the library, add the following dependency to the app-level build.gradle:

implementation(project(":toastlibrary"))

Now, ToastUtil can be used anywhere in the app.

Publish the library

Now comes the interesting part, let’s publish it and make it open source for world to use. We will be using JitPack for hosting our library.

Add the maven-publish plugin to the project-level build.gradle.kts:

plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.kotlin.android) apply false
    alias(libs.plugins.android.library) apply false
    `maven-publish` // Add this
}

Update the library (toastlibrary) module’s build.gradle.kts:

plugins {
    alias(libs.plugins.android.library)
    alias(libs.plugins.kotlin.android)
    `maven-publish` // Add this
}

android {
    ..
    ..
    publishing { // Add this
        singleVariant("release") {
            withSourcesJar()
            withJavadocJar()
        }
    }
}

dependencies {
    ..
    ..
}

// Add this
publishing {
    publications {
        create("release", MavenPublication::class) {
            groupId = "com.github.khushpanchal" // com.github.<yourusername>
            artifactId = "ToastMe" // your repository name
            version = "0.0.1" // version we want to publish (say 0.0.1)

            afterEvaluate {
                from(components["release"])
            }
        }
    }
}

Create jitpack.yml file at project root level and add following

jdk:
  - openjdk17

Go to GitHub and create a new release:
- Navigate to the Releases tab in the right and click Create a new release.
- Choose a tag (e.g., 0.0.1), add a title (e.g., v0.0.1), and publish the release.

Go to JitPack.io, log in with GitHub, and enter the repository URL (e.g., khushpanchal/ToastMe). Click Get It and wait for the build to complete.
Once published, the library will be available for use.

Test the Published Library

Add JitPack to the settings.gradle.kts of any Android project:

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven {
            url = uri("https://jitpack.io") // this one
        }
    }
}

Add the library to the module-level build.gradle.kts:

implementation("com.github.khushpanchal:ToastMe:0.0.1")

Conclusion

Congratulations! You have successfully created and published your first Android library. To update the library, modify the code, push the changes to GitHub, create a new release tag, and let JitPack handle the rest.

Source Code: GitHub
Contact Me: LinkedIn | Twitter

Happy coding! ✌️

Step by Step guide to create basic MVVM Application in Android

Khush Panchal — Mon, 24 Jun 2024 05:27:05 +0000

Machine Coding LLD Android — MVVM-Hilt-Retrofit

In this blog we will create a basic mvvm application where user will fetch some data from the api and show it to the UI as a list.

For the sake of this article, we will use OMDb (The Open Movie Database) API to fetch the title and thumbnail image of the movie.

Purpose of this blog is to get started with creating MVVM project following proper architecture which can be used as a base to create any project.

This blog will help in machine coding round in android interviews.

Out of Scope for this blog:

Pagination
Testing
Compose
Offline Caching
Multiple Screen / Search section

Check out the NewsApp that covers all the above out of scope points.

1. Understanding the API

For this article we will be using free open source movie api which can be found at: https://www.omdbapi.com?s=army&apikey=[yourkey] (To Get Free API Key go to https://www.omdbapi.com/ and then API Key tab) ( I have used the search “army” keyword for the sake of this article so we can get some list of data)
Json looks like this:

{
  "Search": [
    {
      "Title": "Hellboy II: The Golden Army",
      "Year": "2008",
      "imdbID": "tt0411477",
      "Type": "movie",
      "Poster": "https://m.media-amazon.com/images/M/MV5BMjA5NzgyMjc2Nl5BMl5BanBnXkFtZTcwOTU3MDI3MQ@@._V1_SX300.jpg"
    },
    {
      "Title": "Army of Darkness",
      "Year": "1992",
      "imdbID": "tt0106308",
      "Type": "movie",
      "Poster": "https://m.media-amazon.com/images/M/MV5BODcyYzM4YTAtNGM5MS00NjU4LTk2Y2ItZjI5NjkzZTk0MmQ1XkEyXkFqcGdeQXVyNjU0OTQ0OTY@._V1_SX300.jpg"
    }, 
    ..
    ..
   ],
  "totalResults": "703",
  "Response": "True"
}

For this project we show the list showing image and title of the movie.

2. Add dependencies

Create the new android project in Android Studio and add the following dependency in app level build.gradle.kts or build.gradle file.

//build.gradle.kts

dependencies {

    //Dagger for dependency injection
    implementation("com.google.dagger:hilt-android:2.51")
    kapt("com.google.dagger:hilt-compiler:2.51")

    //Glide for image loading
    implementation("com.github.bumptech.glide:glide:4.16.0")

    //Retrofit for networking
    implementation("com.squareup.retrofit2:retrofit:2.9.0")
    implementation("com.squareup.retrofit2:converter-gson:2.9.0")

    //ViewModel scope
    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.2")
}

Additionally for Hilt add the following plugins in app level build.gradle.kts or build.gradle file.

//build.gradle.kts

plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
    id("kotlin-kapt") //<-- this one
    id("com.google.dagger.hilt.android") // <-- this one
}

Also add following at root level build.gradle.kts or build.gradle file.

//build.gradle.kts

plugins {
    id("com.android.application") version "8.1.4" apply false
    id("org.jetbrains.kotlin.android") version "1.9.0" apply false
    id("com.google.dagger.hilt.android") version "2.51" apply false //<-- this one
}

Since we will be using view binding for our xml layouts, add the following in app level build.gradle.kts or build.gradle file.

//build.gradle.kts

android {
..
..
  buildFeatures {
      viewBinding = true
  }
}

Sync the gradle and run your project.

3. Create Application class and Add necessary permissions in Manifest file

Create Application class and add @HiltAndroidApp annotation.

//MainApplication.kt

@HiltAndroidApp
class MainApplication: Application()

Add the name in manifest file.

<!--AndroidManifest.xml-->

<application
  android:name=".MainApplication">
</application>

Add Internet permission in manifest file.

<!--AndroidManifest.xml-->

<uses-permission android:name="android.permission.INTERNET"/>

4. Create Folder structure

Create the following folder structure, with empty folders (“common”, “data/model”, “data/network”, “data/repository”, “di/module”, “ui”, “ui/viewmodel”).
Check the below final project structure added for reference only, we will create each file step by step.

|── MainApplication.kt
├── common
│   ├── Const.kt
│   └── UIState.kt
├── data
│   ├── model
│   │   ├── MainData.kt
│   ├── network
│   │   ├── ApiInterface.kt
│   └── repository
│       └── MainRepository.kt
├── di
│   ├── module
│   │   └── ApplicationModule.kt
├── ui
    ├── MainActivity.kt
    ├── MainAdapter.kt
    └── viewmodel
        ├── MainViewModel.kt

5. Create Model class (Data Layer)

Create class MainData.kt inside “data/model” folder and add the following data class based on the JSON, we are using only title and image.

//MainData.kt

data class ApiResponse(
    @SerializedName("Search")
    val dataList: List<MainData>?
)

data class MainData(
    @SerializedName("Title")
    val title: String,

    @SerializedName("Poster")
    val poster: String
)

6. Create Networking interface (Data Layer)

First create object class Const.kt inside “common” folder and add Base url and Api Key.

//Const.kt

object Const {
    const val BASE_URL = "https://www.omdbapi.com/"
    const val API_KEY = "your api key"
}

Then create ApiInterface.kt class inside “data/network” folder with following function.

//ApiInterface.kt

interface ApiInterface {
    @GET(".")
    suspend fun getMoviesData(
        @Query("s") s: String = "army",
        @Query("apikey") apikey: String = Const.API_KEY
    ): ApiResponse
}

We are not using OkHttp interceptor for adding api key for of this article but it is recommended to add api key via interceptors.

7. Create ApplicationModule (DI Layer)

Create ApplicationModule.kt class inside “di/module” folder for providing Retrofit instance.

//ApplicationModule.kt

@Module
@InstallIn(SingletonComponent::class)
class ApplicationModule {

    @Singleton
    @Provides
    fun provideNetworkService(): ApiInterface {
        return Retrofit
            .Builder()
            .baseUrl(Const.BASE_URL)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(ApiInterface::class.java)
    }
}

8. Create Repository class (Data Layer)

Create MainRepository.kt class inside “data/repository” folder that will return flow of list which will be collected by view model.

//MainRepository.kt

@Singleton
class MainRepository @Inject constructor(
    private val apiInterface: ApiInterface
) {

    fun getMainData(): Flow<List<MainData>> {
        return flow {
            emit(
                apiInterface.getMoviesData().dataList ?: emptyList()
            )
        }
    }
}

9. Create ViewModel and UIState (UI Layer)

First create UIState.kt inside “common” folder which is a sealed interface representing the state of UI that will emit and collect between ViewModel and UI component.

//UIState.kt

sealed interface UIState<out T> {
    data class Success<T>(val data: T) : UIState<T>
    data class Failure<T>(val throwable: Throwable, val data: T? = null) : UIState<T>
    data object Loading : UIState<Nothing>
}

Then create MainViewModel.kt inside “ui/viewmodel” folder which extends ViewModel() and inject MainRepository.
We use StateFlow to emit data from ViewModel and then collect by UI.
We use IO dispatcher for network call (For this article we are not injecting dispatcher from outside, but it is recommended to provide from outside).

//MainViewModel.kt

@HiltViewModel
class MainViewModel @Inject constructor(
    private val mainRepository: MainRepository
) : ViewModel() {

    private val _mainItem = MutableStateFlow<UIState<List<MainData>>>(UIState.Loading)
    val mainItem: StateFlow<UIState<List<MainData>>> = _mainItem

    init {
        fetchItems()
    }

    private fun fetchItems() {
        viewModelScope.launch {
            _mainItem.emit(UIState.Loading)
            mainRepository
                .getMainData()
                .flowOn(Dispatchers.IO)
                .catch {
                    _mainItem.emit(UIState.Failure(it))
                }
                .collect {
                    _mainItem.emit(UIState.Success(it))
                }
        }
    }

}

10. Create Layouts (UI Layer)

Edit activity_main.xml with RecyclerView for showing the list, progress bar and error message.

<!--activity_main.xml-->

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".ui.MainActivity">

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/rv"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <ProgressBar
        android:id="@+id/progress"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:visibility="gone"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <TextView
        android:id="@+id/error"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:visibility="gone"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        tools:text="Something went wrong" />

</androidx.constraintlayout.widget.ConstraintLayout>

Create item_main.xml layout and put inside “res” folder for single item visible on UI that will be used by Recycler View Adapter.

<!--item_main.xml-->

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="110dp">

    <ImageView
        android:id="@+id/iv_item"
        android:layout_width="100dp"
        android:layout_height="100dp"
        android:layout_margin="5dp"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        tools:background="@color/design_default_color_secondary" />

    <TextView
        android:id="@+id/tv_item"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_margin="5dp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintStart_toEndOf="@+id/iv_item"
        app:layout_constraintTop_toTopOf="parent"
        tools:text="Hey there" />

</androidx.constraintlayout.widget.ConstraintLayout>

11. Create Adapter class (UI Layer)

Create MainAdapter.kt inside “ui” folder that extends RecyclerView Adapter.
We use DiffUtil for calculating data diff and bind data.
We use Glide for loading image into image view.

//MainAdapter.kt

class MainAdapter : RecyclerView.Adapter<MainAdapter.MainViewHolder>() {

    private val items = ArrayList<MainData>()

    fun setItems(items: List<MainData>) {
        val diffResult = DiffUtil.calculateDiff(MainDiffCallBack(this.items, items))
        this.items.clear()
        this.items.addAll(items)
        diffResult.dispatchUpdatesTo(this)
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MainViewHolder {
        return MainViewHolder(
            ItemMainBinding.inflate(LayoutInflater.from(parent.context), parent, false)
        )
    }

    override fun getItemCount(): Int {
        return items.size
    }

    override fun onBindViewHolder(holder: MainViewHolder, position: Int) {
        holder.bind(items[position])
    }

    inner class MainViewHolder(private val binding: ItemMainBinding) : ViewHolder(binding.root) {

        fun bind(mainData: MainData) {
            binding.tvItem.text = mainData.title
            Glide.with(itemView.context)
                .load(mainData.poster)
                .placeholder(com.google.android.material.R.color.design_default_color_secondary)
                .into(binding.ivItem)
        }

    }
}

class MainDiffCallBack(private val oldList: List<MainData>, private val newList: List<MainData>) :
    DiffUtil.Callback() {
    override fun getOldListSize(): Int {
        return oldList.size
    }

    override fun getNewListSize(): Int {
        return newList.size
    }

    override fun areItemsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
        return (oldList[oldItemPosition].title == newList[newItemPosition].title)

    }

    override fun areContentsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
        return oldList[oldItemPosition] == newList[newItemPosition]
    }
}

12. Observe UIState inside MainActivity (UI Layer)

Drag MainActivity.kt file inside “ui” folder.
We collect Flow from viewmodel and update UI.

//MainActivity.kt

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {

    private lateinit var binding: ActivityMainBinding

    private lateinit var adapter: MainAdapter

    private val mainViewModel: MainViewModel by lazy {
        ViewModelProvider(this)[MainViewModel::class.java]
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        adapter = MainAdapter()
        collector()
        setupUI()
    }

    private fun setupUI() {
        binding.rv.adapter = adapter
        binding.rv.layoutManager =
            LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false)
        binding.rv.addItemDecoration(
            DividerItemDecoration(
                this,
                DividerItemDecoration.VERTICAL
            )
        )
    }

    private fun collector() {
        lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                mainViewModel.mainItem.collect {
                    when (it) {
                        is UIState.Success -> {
                            binding.progress.visibility = View.GONE
                            binding.error.visibility = View.GONE
                            binding.rv.visibility = View.VISIBLE
                            adapter.setItems(it.data)
                        }

                        is UIState.Failure -> {
                            binding.progress.visibility = View.GONE
                            binding.error.visibility = View.VISIBLE
                            binding.rv.visibility = View.GONE
                            binding.error.text = it.throwable.toString()
                        }

                        is UIState.Loading -> {
                            binding.progress.visibility = View.VISIBLE
                            binding.error.visibility = View.GONE
                            binding.rv.visibility = View.GONE
                        }
                    }
                }
            }
        }
    }

}

Run your application after each step to check everything is working fine.

High level flow

Check the below high level flow of how data coming from API and is shown to UI.

Using the above step by step approach help making a base for any MVVM application making it scalable.

Final Result

Source Code: GitHub

Contact Me:

LinkedIn, Twitter

Happy Coding ✌️

Singleton: How to create?

Khush Panchal — Sun, 02 Jun 2024 19:35:30 +0000

In this article, we will understand the Singleton class, the pros and cons of using Singleton, and finally, the ways of writing a Singleton class in Kotlin.

What is Singleton?

Singleton is a creational design pattern that ensures a single instance of a class for the lifetime of an application.

Pros

Global Point of Access: Makes the Singleton class easy to access.
Reduced Memory Usage: Avoids repeated allocation and deallocation of memory, reducing the garbage collector’s overhead.

Cons

Tight Coupling and Difficult Testing: Can create dependencies, making the application hard to test and modify.
Thread Safety and Memory Leaks: If not handled properly, it can lead to problems with thread safety and memory leaks.

Ways to write Singleton:

Double-Checked locking method (Lazy Initialization)

In double-checked locking, we check for an existing instance of the Singleton class twice, before and after entering the synchronized block, ensuring that no more than one instance of Singleton gets created.

class Singleton private constructor() {
  companion object {
    @Volatile
    private var instance: Singleton? = null
    fun getInstance(): Singleton {
        if(instance==null) { //Check 1
            synchronized(this) {
                if(instance==null) {//Check 2
                    instance = Singleton()
                }
            }
        }
        return instance!!
    }
  }
}

Explanation:

Private constructor: Ensures that the constructor can only be accessed within the class.
Synchronized block: Ensures that only one thread can enter the block at a time, preventing multiple instances from being created.
Companion object (can be used without creating instance of a class): Used to create the Singleton class. It contains a static method (getInstance()) which returns the single instance of the class.
Volatile Keyword: Ensures that the instance is immediately visible to other threads after creation.
Check 1: If we do not add this check, every time getInstance() is called thread(s) have to enter synchronized block which will cause performance overhead by blocking other threads.
Check 2: As multiple thread can go in waiting state on synchronized block(but already entered the getInstance() method), if one thread creates the instance and it is visible to all the threads immediately (using volatile), this check will prevent creation of instance again.

Object keyword in Kotlin (Eager Initialization)

There is one more easy way to create a singleton — Object.

Let’s check the example

object Config {
  const val TAG = "Config"
}

Then why do we even need the double-checked locking method?

Let’s decompile the class to understand how the instance is created internally:

public final class Config {
   @NotNull
   public static final String TAG = "Config";
   @NotNull
   public static final Config INSTANCE;

   private Config() {
   }

   static {
      Config var0 = new Config();
      INSTANCE = var0;
   }
}

As we can see, when decompiled, it uses a static block to create the instance. The static block in Java runs as soon as the class is loaded. The JVM internally loads classes lazily, ensuring thread safety.

Difference between both methods:

Object Keyword: Creates the instance as soon as the class is loaded. (Eager Initialization).
Double-Checked Locking: Creates the instance only when getInstance() is called, even if the class is already loaded (Lazy Initialization).

Which method should we use?

Both methods work similarly in creating a Singleton and can be used if handled properly.

Things to consider:

With the object expression, if the class is loaded by mistake and never used, the instance will still occupy memory throughout the application’s lifecycle.

object Config {
    const val TAG = "Config"
}

val nameConfig = Config.javaClass.simpleName //instance of Config will be created

We cannot pass arguments to object class as it does not have a constructor, but we can when creating it manually.

class Singleton private constructor(tag: String) {
    ..
    fun getInstance(tag: String): Singleton {
       ..
       if(instance == null) {
         instance = Singleton(tag)
       }
       ..
       return instance!!
    }
}

Bonus: Companion Object

class Demo {
    companion object DemoConfig {
        const val TAG = "DemoConfig"
    }
}

fun main() {
    val nameDemo = Demo //instance of DemoConfig will be created, Demo instance will not be created
}

The companion object is equivalent to the static keyword in Java. It is associated with the class and is instantiated as soon as the containing class is loaded, even if the companion object itself is not used. We can use the companion object without instantiating the corresponding class.

Source Code: GitHub

Contact Me:
LinkedIn, Twitter

Happy Coding ✌️

Understanding Kotlin’s Any, Unit, Nothing

Khush Panchal — Mon, 20 May 2024 04:30:14 +0000

Kotlin offers unique types that can be quite different from what developers are used to in Java. In this blog, we will explore three such types: Any, Unit, and Nothing.

Any

//SOURCE CODE
package kotlin
/**
 * The root of the Kotlin class hierarchy. Every Kotlin class has [Any] as a superclass.
 */
public open class Any {
    public open operator fun equals(other: Any?): Boolean
    public open fun hashCode(): Int
    public open fun toString(): String
}

Root of the class hierarchy. Every Kotlin class inherits from Any.
Equivalent to Object in Java.
Provides three methods that we can override: equals(), hashCode(), and toString(). This is why when we override methods in any class, these three options are often presented by the IDE.
Non-nullable by Default. If we need a variable to be able to hold null, we can use Any?.

Example

fun printAny(value: Any?) {
    println(value.toString())
}

fun main() {
    printAny("Hello, World!")  // Prints: Hello, World!
    printAny(123)  // Prints: 123
}

//When decompiled, Any becomes Object in Java
public static final void printAny(@Nullable Object value) {
   String var1 = String.valueOf(value);
   System.out.println(var1);
}

Unit

//SOURCE CODE
package kotlin
/**
 * The type with only one value: the `Unit` object. This type corresponds to the `void` type in Java.
 */
public object Unit {
    override fun toString() = "kotlin.Unit"
}

Equivalent to void in Java but unlike void ,Unit is a real class with only one instance (singleton).
Represent a function that does not return any meaningful value.
If we do not specify a return type for a function, Kotlin uses Unit as the default return type.

Example

fun printMessage(message: String): Unit { //There is no need to explicitly write Unit
    println(message)
}

fun main() {
    printMessage("Hello, Unit!")  // Prints: Hello, Unit!
}

//When decompiled, Unit becomes void in Java
public static final void printMessage(@NotNull String message) {
   Intrinsics.checkNotNullParameter(message, "message");
   System.out.println(message);
}

Example: Functional Type

fun runBlock(block: ()->Unit) {
    block()
}

fun main() {
    runBlock { println("Here") } // Prints: Here
}

Here, () -> Unit is a function type and the Unit indicates that this function type does not return any meaningful value.

In function type mentioning the Unit is compulsory.

Nothing

//SOURCE CODE
package kotlin
/**
 * Nothing has no instances. You can use Nothing to represent "a value that never exists": for example,
 * if a function has the return type of Nothing, it means that it never returns (always throws an exception).
 */
public class Nothing private constructor()

Represents the absence of any value indicating that a function will never return normally.
Subtype of all well-formed Kotlin types, including user-defined ones.
Used for functions that never return, either because they throw an exception or enter an infinite loop.
We cannot create an instance of Nothing, nor can any class inherit from it.
Functions with a return type of Nothing doesn’t return any value not even the default return type Unit .
The Nothing return type in Kotlin saves us from potential bugs by making it clear that they do not return. When any function having Nothing as the return type is invoked, then the compiler will not execute beyond this function call and gives us the Unreachable code warning.

Example

fun fail(message: String): Nothing {
    throw IllegalArgumentException(message)
}

fun main() {
    // This will throw an exception and never return normally
    fail("This is an error!")
    println("Hello") // Compiler gives warning "Unreachable code"
}

//When decompiled, Nothing becomes Void in Java
//Void is part of the java.lang package, acts as a reference to objects that wrap the Java primitive type void. It is uninstantiable.
@NotNull
public static final Void fail(@NotNull String message) {
   Intrinsics.checkNotNullParameter(message, "message");
   throw (Throwable)(new IllegalArgumentException(message));
}

Source Code: Github

Contact Me:

LinkedIn, Twitter

Happy Coding ✌️

Ketch — Android File Downloader Library

Khush Panchal — Sun, 05 May 2024 17:44:29 +0000

About Ketch

Ketch is simple, powerful, customisable file downloader library for Android built entirely in Kotlin. It simplifies the process of downloading files in Android applications by leveraging the power of WorkManager. Ketch guarantees the download irrespective of application state.

Why use Ketch?

Ketch can download any type of file. (jpg, png, gif, mp4, mp3, pdf, apk and many more) and guarantees download unless cancelled explicitly or download is failed.
Ketch provide all download info including speed, file size, progress.
Ketch can download multiple files in parallel with support of pause-resume, retry-cancel and deletion of downloads.
Ketch provide notification for each download providing download info (speed, time left, total size, progress) and option to pause, resume, retry and cancel from notification itself.
Ketch provide option to observe download items (or single download item) as Flow.
Ketch provides various customisation including custom timeout, custom okhttp client and custom notification.

Usage

Ketch is very simple to use: Add the dependency, pass the url, path and fileName to download and observe the download.

// build.gradle
dependencies {
  implementation 'com.github.khushpanchal:Ketch:2.0.0'
}

//Application
private lateinit var ketch: Ketch
override fun onCreate() {
  super.onCreate(savedInstanceState)
  ketch = Ketch.builder().build(this)
}

//To download the file
val id = ketch.download(url, fileName, path)
lifecycleScope.launch { // e.g., from activity
  repeatOnLifecycle(Lifecycle.State.STARTED) {
    ketch.observeDownloadById(id)
      .flowOn(Dispatchers.IO)
      .collect { downloadModel -> 
        // use downloadModel
      }
  }
}

// To cancel the download
ketch.cancel(downloadModel.id) // other options: cancel(tag), cancelAll()

// To pause the download
ketch.pause(downloadModel.id) // other options: pause(tag), pauseAll()

// To resume the download
ketch.resume(downloadModel.id) // other options: resume(tag), resumeAll()

// To retry the download
ketch.retry(downloadModel.id) // other options: retry(tag), retryAll()

// To delete the download
ketch.clearDb(downloadModel.id) // other options: clearDb(tag), clearAllDb(), clearDb(timeInMillis)
ketch.clearDb(downloadModel.id, false) // Pass "false" to skip the actual file deletion (only clear entry from DB)

// To observe all the downloads
viewLifecycleOwner.lifecycleScope.launch { // e.g., from fragment
  repeatOnLifecycle(Lifecycle.State.STARTED) {
    ketch.observeDownloads() // other options: observe download by id, by tag
      .flowOn(Dispatchers.IO)      
      .collect { 
         //set items to adapter
      }
  }
}

To enable the notification, add appropriate notification permission and pass notification config while initialising the library.

ketch = Ketch.builder().setNotificationConfig(
         config = NotificationConfig(
           enabled = true,
           smallIcon = R.drawable.ic_launcher_foreground // It is required to pass the smallIcon for notification.
         )
       ).build(this)

How Ketch works?

High Level Design

Component Details

Ketch: It is the core class client interacts with. It has various exposed function including init, download, pause, resume, retry, cancel, clearDb, observeDownloads. It has the instance of DownloadManager.
DownloadManager: It is the central class of library that has instance of downloads database and WorkManager. It is responsible for enqueuing the work request. It directly observe the database carrying all download related information making database the single source of truth. Additionally this class has observe functions that return the flow of list of DownloadModel (data class carrying all download information) to the client.
DownloadWorker: It extends CoroutineWorker for downloading the items in background. It has the instance of DownloadTask, DownloadNotificationManager and Download database.
DownloadTask: It has the suspend function download and provide callbacks like onStart and onProgress. It has the length of file and also carries the logic of calculating download speed. It has DownloadService class that uses Retrofit for making network request.
DownloadNotificationManager: It is responsible for showing the notification to user. It creates notification channel and notification. It also sendBroadcast which is received by NotificationReceiver after work is finished.
DownloadDao: It carryies all database query for storing, updating or getting download info from database. Library uses ROOM for database.
NotificationReceiver: It is responsible for showing the terminating notification to user after DownloadWorker is finished or cancelled. It shows Cancel, Failed (with retry and cancel action), Paused (with resume and cancel action) and Successful Notification message.

Ketch provides lot more features with plenty of customisation options, check out the GitHub project for more information:

Github Project: https://github.com/khushpanchal/Ketch

If this project helps you, show love ❤️ by putting a ⭐ on this project ✌️

Contact Me: LinkedIn, Twitter

Happy coding ✌️

Inline Function — When to use?

Khush Panchal — Mon, 29 Apr 2024 13:54:26 +0000

In this article, we will investigate the Kotlin inline function in detail and come to a conclusion on when and why to use the inline function.

What are inline functions?

To make the function inline, we will add the inline keyword before fun to convert normal function to inline function

inline fun calculateTime() {
    println("Calculate")
}

fun main() {
    println("Start")
    calculateTime()
    println("End")
}

Decompiled:

public void main() {
   System.out.println("Start");
   System.out.println("Calculate");
   System.out.println("End");
}

As we can see complete body of inline function gets inserted at function call site when decompiled.

Inline function are functions whose body gets copied to the calling place

Advantage of Inline function: No function call overhead — Faster program execution.

Why not make every function inline?

Making Every function inline eventually grow the code as same code will repeat everywhere.

Some will say, if function body is small use inline otherwise not. This is correct upto some extent.

But when we inline a normal function with normal parameters, compiler will give us the below warning

Expected performance impact from inlining is insignificant. Inlining works best for functions with parameters of functional types

So this means expected impact of inlining on performance is negligible as most probably compiler will do it if required.

When do we inline the function?

We generally prefer to inline a function when function take functional type parameters (lambdas)

Let’s dive into the reason for this and how inlining actually help us in this case

In normal case:

fun calculateTime(block: ()->Unit): Long {
    val initialTime = System.currentTimeMillis()
    block.invoke()
    return System.currentTimeMillis() - initialTime
}

fun main() {
    val time = calculateTime {
        println("Hello")
    }
    println(time)
}

Decompiled:

public long calculateTime(Function0 block) {
  long initialTime = System.currentTimeMillis();
  block.invoke();
  return System.currentTimeMillis() - initialTime;
}

public void main() {
  long time = calculateTime(
     new Function() {
        @Override
        public void invoke() {
          System.out.print("Hello");
        }
      }
    );
  System.out.println(time);
}

public interface Function0<out R> : Function<R> {
    public operator fun invoke(): R
}

In Kotlin, function types (lambdas) are converted to object of anonymous/regular classes(Function0) that extend the interface Function

Problem? — If we call this function (calculateTime) 100 times, 100 object of Function class will be created and garbage collected. This affects performance.

Solution? — Use inline for preventing object creation

inline fun calculateTime(block: ()->Unit): Long {
    val initialTime = System.currentTimeMillis()
    block.invoke()
    return System.currentTimeMillis() - initialTime
}

fun main() {
    val time = calculateTime {
        println("Hello")
    }
    println(time)
}

Decompiled:

public void main() {
  long initialTime = System.currentTimeMillis();
  System.out.println("Hello");
  long time = System.currentTimeMillis() - initialTime;
  System.out.println(time);
}

So, the functions that take other functions as arguments are faster when they are inlined (since no Function objects are created).

We should use inline function when we have functional type parameter with small function body.

noinline

What if we have multiple functional type parameter in the inline function and we do not want to inline all the parameters, we can use noinline keyword.

fun main() {
    val time = calculateTime({
        println("Hellow")
    }, {
        println("World")
    })
    println(time)
}

inline fun calculateTime(block1: () -> Unit, noinline block2: () -> Unit): Long {
    val initialTime = System.currentTimeMillis()
    block1.invoke()
    block2.invoke()
    return System.currentTimeMillis() - initialTime
}

Decompiled code:

public static final void main() {
  long initialTime = System.currentTimeMillis();
  System.out.println("Hello");
  Function block = new Function() {
        @Override
        public void invoke() {
          System.out.print("World");
        }
      }
    );
  block.invoke();
  long time = System.currentTimeMillis() - initialTime;
  System.out.println(time);
}

crossinline

crossinline keyword is used to avoid non-local returns.

Let’s understand with example

inline fun calculateTime(block: () -> Unit): Long {
    val initialTime = System.currentTimeMillis()
    block.invoke()
    return System.currentTimeMillis() - initialTime
}

fun main() {
    val time = calculateTime {
        println("Hello")
        return
    }
    println(time)
}

Decompiled:

public static final void main() {
   long initialTime = System.currentTimeMillis();
   System.out.println("Hello");
}

Here we can see that after return, no other statement is written (calculating and printing final time). This is non-local return. To avoid this issue, we can mark the lambda as crossinline.

inline fun calculateTime(crossinline block: () -> Unit): Long {
    val initialTime = System.currentTimeMillis()
    block.invoke()
    return System.currentTimeMillis() - initialTime
}

fun main() {
    val time = calculateTime {
        println("Hello")
        return // This will give compile time error
    }
    println(time)
}

When mark lambda parameter as crossinline, if we add return statement, compiler will give the error (‘return’ is not allowed here).

Use inline for reified type parameters

What if we want to work with class type directly in Kotlin generics?

fun <T> doSomething(value: T) {
   println("Value: $value") // OK
   println("Type: ${T::class.simpleName}") // Error
}

fun main() {
   doSomething("something")
}

In the above example we get the error

Cannot use 'T' as reified type parameter. Use a class instead

We cannot work with the type directly, because the type argument gets erased at runtime when we pass to the function. So, we cannot possibly know exactly which type we are handling.

Solution? — Use an inline function along with the reified type parameter.

inline fun <reified T> doSomething(value: T) {
   println("Value: $value") // OK
   println("Type: ${T::class.simpleName}") // OK
}

fun main() {
   doSomething("something")
}

In the above example actual type argument will be copied in place of T. So, T::class.simpleName becomes String::class.simpleName.

The reified keyword can only be used with inline functions.

Source Code: Github

Contact Me:
LinkedIn, Twitter

Happy Coding ✌️

Understanding Broadcast Receivers in Android

Khush Panchal — Wed, 17 Apr 2024 19:04:47 +0000

What are Broadcast Receivers?

Broadcast Receiver is one of the component in Android that enable apps to listen for and respond to broadcast messages from other apps or the system itself. Think of them as listeners waiting for specific events to occur.

Apps can respond to system-wide events like changes in battery level, network connectivity, and incoming SMS messages by using Broadcast Receivers.

The broadcast message is nothing but an Intent. The action string of this Intent identifies the event that occurred (e.g, android.intent.action.AIRPLANE_MODE indicates that Airplane mode is toggled). The intent may also include additional information bundled into its extra field. For example, the airplane mode intent includes a boolean extra that indicates whether or not Airplane Mode is on.

Receiving Broadcast

Apps can receive broadcasts in two ways: Manifest-declared receivers and Context-registered receivers.

Manifest-declared receivers (Static Broadcast Receiver)

If we declare a broadcast receiver in our manifest file, the system launches our app if the app is not already running (Application onCreate() gets triggered) when the broadcast is sent.

Let’s take an example where we have an application that should know whenever there is sms received in the device, to achieve this:

Create a class SmsReceiver that extends android BroadcastReceiver class and overrides onReceive() method

//Receiver App
class SmsReceiver: BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
        if(intent?.action == "android.provider.Telephony.SMS_RECEIVED") { // it's best practice to verify intent action before performing any operation
            Log.i("ReceiverApp", "SMS Received")
        }
    }
}

Add permission to receive sms, then add receiver

<!--Receiver App-->
<uses-permission android:name="android.permission.RECEIVE_SMS"/>

<application>
..
..
  <receiver android:name=".SmsReceiver"
    android:exported="true">
    <intent-filter>
        <action android:name="android.provider.Telephony.SMS_RECEIVED" />
    </intent-filter>
  </receiver>
..
..
</application>

To enable receiver to receive events from outside of our app, set android:exported to true, else set it to false if want to receive locally.

Behind the scenes: The system package manager registers the receiver when the app is installed. The receiver then becomes a separate entry point into our app which means that the system can start the app and deliver the broadcast if the app is not currently running.

Beginning with Android 8.0 (API level 26), we cannot use the manifest to declare a receiver for most implicit broadcasts (broadcasts that don’t target our app specifically). Check this list of Broadcast that can use manifest declared Receivers. However we can always use context-registered receivers.

Context-registered receivers (Dynamic Broadcast Receiver)

Context-registered receivers receive broadcasts as long as their registering context is valid. For an example, if we register within an activity context, we receive broadcasts as long as the activity is not destroyed. If we register with the application context, we receive broadcasts as long as the app is running.

To implement context-registered broadcast, remove receiver from manifest file and instead register it inside the activity:

//Receiver App
private val smsReceiver = SmsReceiver()

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    registerReceiver(smsReceiver, 
        IntentFilter("android.provider.Telephony.SMS_RECEIVED")
    )
}

override fun onDestroy() {
    super.onDestroy()
    unregisterReceiver(smsReceiver)
}

Custom Broadcasts

Till now we have discussed about system broadcast only, now we will see how we can create and send our own custom broadcast.

Sending broadcasts

Any application can send the broadcast using sendBroadcast(Intent).

//Sender App
// To send broadcase from any application, specify the custom action to intent and sendBroadcast
val intent = Intent("TEST_CUSTOM_ACTION")
intent.putExtra("data", "Some custom data")
sendBroadcast(intent)

In this way all the applications that are listening to TEST_CUSTOM_ACTION intent will receive the broadcast asynchronously.

We can also limit a broadcast to a particular app by calling setPackage(String) on the intent. In this way broadcast will be send to only single app with mentioned package name.

//Sender App
val intent = Intent("TEST_CUSTOM_ACTION")
intent.putExtra("data", "Some custom data")
intent.setPackage("com.example.receiverapp")
sendBroadcast(intent)

Receiving Broadcasts

To receive broadcast we need to use context-registered receiver (From Android 8.0, we cannot use manifest-declared receiver for our custom broadcast)

//Receiver App
private val customReceiver = CustomReceiver()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Log.i("ReceiverApp", "activity created")
        setContentView(R.layout.activity_main)
        registerReceiver(customReceiver,
            IntentFilter("TEST_CUSTOM_ACTION"), RECEIVER_EXPORTED
        )
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.i("ReceiverApp", "activity destroyed")
        unregisterReceiver(customReceiver)
    }

RECEIVER_EXPORTED flag needs to be add for custom broadcast, it indicates that other apps can send the broadcast to our app. If we do not add this flag, android will throw the below exception:

java.lang.SecurityException: com.example.receiverapp: One of RECEIVER_EXPORTED or RECEIVER_NOT_EXPORTED should be specified when a receiver isn’t being registered exclusively for system broadcasts

Below is out CustomReceiver class that receives the broadcast

//Receiver App
class CustomReceiver: BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
        if(intent?.action == "TEST_CUSTOM_ACTION") {
            val value = intent.extras?.getString("data")
            Log.i("ReceiverApp", "Custom Received: $value")
        }

    }
}

Restricting broadcasts with permissions

Permissions allow us to restrict broadcasts to the set of apps that hold certain permissions.

Suppose we want to send broadcast to app that have internet permission, we can specify a permission parameter.

//Sender App
val intent = Intent("TEST_CUSTOM_ACTION")
intent.putExtra("data", "Some custom data")
sendBroadcast(intent, Manifest.permission.INTERNET)

Only receivers who have requested that permission with the tag in their manifest (and subsequently been granted the permission if it is dangerous) can receive the broadcast.

To receive the broadcast, declare permission in manifest file

<!--Receiver App-->
<uses-permission android:name="android.permission.INTERNET"/>

//Receiver App  
registerReceiver(customReceiver,
    IntentFilter("TEST_CUSTOM_ACTION"), Manifest.permission.INTERNET, null, RECEIVER_EXPORTED
)

Additionally we can define our own permission as well for custom broadcast (Check Custom permission)

Ordered Broadcast

There is one more way to send broadcast apart from sendBroadcast(Intent) method, i.e.,sendOrderedBroadcast(Intent, String)

It sends broadcasts to one receiver at a time. Say we have multiple receivers listening to our custom action, when we send broadcast using this method, only one receiver at a time will get the onReceive() callback and other will get only when previous function completely executes. The order receivers run in can be controlled with the android:priority attribute of the matching intent-filter; receivers with the same priority will be run in an arbitrary order.

//Sender App
val intent = Intent("TEST_CUSTOM_ACTION")
intent.putExtra("data", "Some custom data")
sendOrderedBroadcast(intent, null)

//Receiver App
registerReceiver(customReceiver,
    IntentFilter("TEST_CUSTOM_ACTION").apply {
        priority = SYSTEM_HIGH_PRIORITY 
    }, RECEIVER_EXPORTED
 )

Local Broadcast

In case we want to communicate inside our own application only, we can use LocalBroadcastManager class provided by android.

LocalBroadcastManager is a helper class to register for and send broadcasts of Intents to local objects within your process.

This has a number of advantages over sending global broadcasts with Context.sendBroadcast:

We know that the data we are broadcasting won’t leave our app, so don’t need to worry about leaking private data.
It is not possible for other applications to send these broadcasts to our app, so we don’t need to worry about having security holes they can exploit.
It is more efficient than sending a global broadcast through the system.

// Reciever App (Same app will send and receive broadcast)
private val localReceiver = LocalReceiver()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Log.i("ReceiverApp", "activity created")
        setContentView(R.layout.activity_main)

        findViewById<Button>(R.id.btn).setOnClickListener {
            //sending broadcast
            val intent = Intent("TEST_CUSTOM_ACTION_LOCAL")
            LocalBroadcastManager.getInstance(this@MainActivity).sendBroadcast(intent)
        }
        //registering local broadcast
        LocalBroadcastManager.getInstance(this).registerReceiver(localReceiver,
            IntentFilter("TEST_CUSTOM_ACTION_LOCAL")
        )

    }

    override fun onDestroy() {
        super.onDestroy()
        Log.i("ReceiverApp", "activity destroyed")
        //unregistering local broadcast
        LocalBroadcastManager.getInstance(this).unregisterReceiver(localReceiver)
    }

Source Code: Github

Contact Me:

LinkedIn, Twitter

Happy Coding ✌️