Kotlin & Android, arranged to actually revise from.

val vs var

In Kotlin, val and var both declare variables but differ in mutability: val = read-only reference (cannot be reassigned), var = mutable (can be reassigned).

const val

const val is a compile-time constant — its value must be known at compile time and can only be a top-level or object-level property of a primitive type or String (not inside a function, not a class instance).

const val ek aisa constant hai jiski value compile time par hi known honi chahiye aur baad mein change nahi ho sakti.

fun main() {
    val name = "Alice"      // cannot be reassigned
    var age = 25
    age = 26                // OK

    println("Name: $name")
    println("Age: $age")
}

Name: Alice
Age: 26

Type Inference & Type Conversion

Kotlin infers a variable's type from its assigned value. Convert between types with toInt(), toDouble(), toString(), etc.

Default & Named Arguments

Vararg parameters

fun greetAll(greeting: String, vararg names: String) {
    for (name in names) println("$greeting, $name!")
}
fun main() = greetAll("Hello", "Alice", "Bob", "Charlie")

Hello, Alice!
Hello, Bob!
Hello, Charlie!

Tail-recursive functions

A tail-recursive function's recursive call is the last operation before returning. Marked tailrec, Kotlin compiles it into a loop, avoiding StackOverflowError on deep recursion.

tailrec fun countDown(n: Int) {
    if (n == 0) return
    println(n)
    countDown(n - 1)   // last operation → tail call
}

Inline Function

A higher-order function call has overhead: each lambda is an object, each call creates a stack frame. inline copies the function body to the call site at compile time, removing that overhead — used heavily for small utility HOFs like let, run, forEach.

inline fun myInlineFunc(action: () -> Unit) {
    println("Before action")
    action()
    println("After action")
}

Function Types & it

Functions can be stored, passed, and returned like data. When a lambda has a single parameter, Kotlin auto-names it it.

val sum: (Int, Int) -> Int = { a, b -> a + b }
listOf(1, 2, 3).forEach { println(it) }

Late Initialization (lateinit)

lateinit declares a non-null var without initializing it immediately — useful for Android Views, dependency injection. Accessing it before init throws UninitializedPropertyAccessException. Works only with non-null var of a class/reference type (not primitives, not val).

lateinit var recyclerView: RecyclerView

== vs ===

== checks structural equality (calls equals()). === checks referential equality (same object in memory).

Kotlin's type system distinguishes nullable and non-nullable references at compile time, preventing most NullPointerExceptions.

• ? — Nullable Type — val age: Int? = null
• ?. — Safe Call — val length = name?.length (returns null instead of crashing if name is null)
• ?: — Elvis Operator — val displayName = name ?: "Guest" (fallback if left side is null)
• !! — Not-Null Assertion — forces a NPE if the value is null; use only when you're certain it can't be null
• let — commonly combined with ?. for null-safe scoped operations: name?.let { println(it) }

A lambda is an anonymous function you can store in a variable or pass as an argument.

Higher-Order Function

A function that takes another function as a parameter, returns a function, or both — e.g. map, filter, forEach.

Unit

Unit is Kotlin's equivalent of Java's void — it means the function returns no meaningful value.

fun calculate(x: Int, op: (Int) -> Int) = op(x)
fun main() = println(calculate(10) { it * 2 })  // trailing lambda

20

Lets you add a new function to an existing class without modifying or inheriting from it — resolved statically at compile time based on the declared type.

Existing class mein bina modify/inherit kiye naya function add karna. Code ko clean, reusable, readable banane ke liye Android dev mein bahut use hota hai.

fun String.isValidEmail(): Boolean =
    android.util.Patterns.EMAIL_ADDRESS.matcher(this).matches()

fun main() = println("test@mail.com".isValidEmail())

true

Generics let you write classes/functions that work with any type while keeping compile-time type safety, avoiding unchecked casts.

class Box(val item: T)
fun  printItem(item: T) = println(item)

fun main() {
    val intBox = Box(10)
    val strBox = Box("Hello")
    println(intBox.item)
    println(strBox.item)
}

10
Hello

Variance: out / in

• out (covariant) — the type can only be produced/returned, not consumed. List<out T> means List<Dog> is a List<Animal>.
• in (contravariant) — the type can only be consumed, not produced. Comparable<in T>.

out = "produce only" (returns), in = "consume only" (takes as parameter). Ye Java ke ? extends / ? super jaisa hai.

Reified type parameters

Normally generic type info is erased at runtime (type erasure). Marking an inline function's type parameter reified keeps the type available at runtime.

inline fun  isInstance(value: Any) = value is T
fun main() = println(isInstance("hello"))  // true

Collection operations (map, filter on List) are eager — each operator processes the whole list and creates an intermediate list. A Sequence is lazy — elements are processed one at a time, only computed when a terminal operation (toList(), first(), sum()) is called.

List operations turant poora list process karte hain har step pe. Sequence lazy hai — element-by-element chalti hai, sirf jab terminal operation call ho tab kaam hota hai. Bade datasets ya chained operations (map+filter+...) mein Sequence zyada efficient hai.

val result = listOf(1, 2, 3, 4, 5)
    .asSequence()
    .map { println("map $it"); it * 2 }
    .filter { println("filter $it"); it > 4 }
    .first()
println("Result: $result")

map 1
filter 2
map 2
filter 4
map 3
filter 6
Result: 6

1. Class & Object

A class is a blueprint defining properties and functions. An object is a real instance of that class.

Class = ghar ka naksha (blueprint). Object = naksha se bana actual ghar.

2. Inheritance

A child/derived class inherits properties and functions from a parent/base class.

3. Encapsulation

Internal state is hidden from outside and accessible only through defined methods (getters/setters).

Data = ATM ke andar ka paisa. Methods = ATM screen — sirf PIN daal ke paisa nikaal sakte ho.

4. Polymorphism

Objects of different classes can be treated via a common supertype, and each class responds to the same call differently.

Ek naam, multiple kaam — draw() Circle alag draw karega, Rectangle alag.

5. Abstraction

Hiding unnecessary implementation details, exposing only essential features.

• final (default): All Kotlin classes/members are final by default — cannot be extended/overridden.
• open: Add open to a class or member to allow it to be extended/overridden.

• object declaration: a lazily-created, thread-safe singleton.
• companion object: a named object tied to a class, used like Java's static members.
• object expression: an anonymous, one-off object, often implementing an interface inline.

1) data class

Used to hold data. The compiler auto-generates equals(), hashCode(), toString(), copy(), and componentN() (for destructuring) from the primary-constructor properties.

data class User(val name: String, val age: Int)
fun main() {
    val u1 = User("Zulfikar", 25)
    val u2 = u1.copy(age = 26)
    println(u1)
    println(u2)
    println(u1 == u2)
}

User(name=Zulfikar, age=25)
User(name=Zulfikar, age=26)
false

2) enum class

A fixed, closed set of predefined constants — can't be extended at runtime.

enum class PaymentStatus { PENDING, SUCCESS, FAILED }

3) sealed class

A restricted class hierarchy — all direct subclasses are known at compile time, so a when over them can be exhaustive without an else branch. Perfect for modelling UI/result states where each state carries different data.

sealed class PaymentResult {
    object Loading : PaymentResult()
    data class Success(val transactionId: String) : PaymentResult()
    data class Error(val message: String) : PaymentResult()
}

fun handle(result: PaymentResult) = when (result) {
    is PaymentResult.Loading -> "Loading..."
    is PaymentResult.Success -> "Success: ${result.transactionId}"
    is PaymentResult.Error -> "Error: ${result.message}"
}

Kotlin has three core collection types: List (ordered, duplicates allowed), Set (unique elements), Map (key-value pairs).

val fruits = listOf("Apple", "Banana", "Orange")       // immutable
val mutableFruits = mutableListOf("Apple", "Banana")
mutableFruits.add("Grapes")

val numbers = setOf(1, 2, 2, 3)                         // duplicates removed
val user = mapOf("name" to "Zulfikar", "city" to "Delhi")
println(fruits); println(mutableFruits); println(numbers); println(user["name"])

[Apple, Banana, Orange]
[Apple, Banana, Grapes]
[1, 2, 3]
Zulfikar

Common operations

• forEach — loop; filter — condition-based subset; map — transform each element; contains — membership check.

Execute a block of code within an object's context — five functions differing in receiver (this/it) and return value (object/result).

val intent = Intent(this, MainActivity::class.java).apply {
    putExtra("USER_ID", 101)
}.also { println("Intent created: $it") }

val name = "Zulfikar"
name.let { println(it) }

One object hands responsibility for a task to another object, using the by keyword — favouring composition over inheritance.

Class Delegation

interface Printer { fun print() }
class ConsolePrinter : Printer { override fun print() = println("Printing...") }
class Document(printer: Printer) : Printer by printer

Property Delegation: lazy, observable, vetoable

val lazyValue: String by lazy {
    println("Computing lazy value")
    "Hello, Kotlin!"
}
fun main() {
    println(lazyValue)   // "Computing..." printed, then value
    println(lazyValue)   // cached, no recompute
}

Computing lazy value
Hello, Kotlin!
Hello, Kotlin!

Metadata attached to code that the compiler or a runtime/annotation-processor can read, without changing the code's own logic.

• @Deprecated — flags an API as outdated, with a replacement suggestion.
• @Target — restricts where a custom annotation can be applied.
• @JvmStatic — exposes a companion-object member as a true static method for Java callers.
• @JvmOverloads — generates Java-callable overloads for a function with default parameters.
• @Volatile — ensures a property's writes are immediately visible to other threads.

Inspecting classes, functions, and properties at runtime via kotlin.reflect.

• ::class — a KClass reference to a type at runtime.
• KClass — exposes a class's properties/functions/constructors.
• KFunction — lets you inspect and dynamically invoke a function.

A small, expressive mini-language built with normal Kotlin syntax (lambdas with receivers) for a specific domain — configuration, UI building, scripting.

class Body { private val children = mutableListOf()
    fun p(text: String) { children.add("
$text
") }
    fun content() = children.joinToString("") }
class HTML { private val elements = mutableListOf()
    fun body(block: Body.() -> Unit) {
        val body = Body(); body.block()
        elements.add("${body.content()}")
    }
    fun render() = "${elements.joinToString("")}" }
fun html(block: HTML.() -> Unit): HTML { val h = HTML(); h.block(); return h }

fun main() {
    val page = html { body { p("Hello from Kotlin DSL!"); p("Second paragraph.") } }
    println(page.render())
}

<html><body><p>Hello from Kotlin DSL!</p><p>Second paragraph.</p></body></html>

Real-life DSL examples

• Gradle Kotlin DSL — android {}, dependencies {}
• Jetpack Compose — Column {}, Text()
• Kotlinx HTML, SQL DSL libraries (Exposed)

Lightweight, non-blocking concurrency: coroutines can suspend without blocking the underlying thread, so thousands can run on a handful of OS threads.

Ek thread mein bahut saare tasks non-blocking tarike se chalte hain — CPU time save hota hai, app responsive rehta hai.

Suspend Functions

suspend marks a function that can pause (e.g. during delay or a network call) and resume later, without blocking the thread. Callable only from a coroutine or another suspend function.

suspend fun doLongTask() {
    println("Task start hua")
    delay(1000)
    println("Task complete hua")
}

Coroutine Builders

fun main() = runBlocking {
    val deferred = async { delay(1000); "Result mil gaya" }
    println("Wait kar raha hoon")
    println(deferred.await())
}

Wait kar raha hoon
Result mil gaya

• launch — fire-and-forget, returns a Job, no result.
• async/await — returns a Deferred<T>, use when you need a result.
• runBlocking — blocks the current thread until its coroutine finishes (mainly for main() / tests — never use in production Android UI code).

A CoroutineContext is an immutable, indexed set of elements defining how/where a coroutine runs — includes a Job, a Dispatcher, and optionally a CoroutineName.

• Dispatchers.Main — the UI thread; needed for touching Views.
• Dispatchers.IO — optimized, elastic pool for blocking I/O (network, disk, DB).
• Dispatchers.Default — CPU-bound work, sized to the number of cores (sorting, parsing, heavy computation).
• Dispatchers.Unconfined — starts on the caller's thread, resumes on whatever thread the suspension point returns on; mostly for internal/testing use.

suspend fun loadData() {
    val data = withContext(Dispatchers.IO) { fetchFromNetwork() }
    withContext(Dispatchers.Main) { updateUI(data) }
}

withContext is a suspend function that switches the coroutine's dispatcher for a block, then switches back automatically.

A Job is a cancellable handle to a coroutine's lifecycle.

• cancel() — requests cancellation (cooperative — the coroutine must check isActive or hit a suspension point to actually stop).
• join() — suspends the caller until the coroutine completes.
• isActive — whether the coroutine is still running.

Structured Concurrency

A parent coroutine scope doesn't complete until all its children complete, and cancelling the parent automatically cancels all children — this prevents leaked/orphaned coroutines.

fun main() = runBlocking {
    val job = launch {
        repeat(5) { i ->
            if (!isActive) return@launch
            println("Working: $i")
            delay(500)
        }
    }
    delay(1300)
    job.cancel()
    job.join()
    println("Completed: ${!job.isActive}")
}

Working: 0
Working: 1
Working: 2
Completed: true

Flow represents an asynchronous stream of values, built on coroutines.

A water tap dripping slowly — each drop is a value. Nothing flows until you put your cup under it (collect).

• Cold stream — code only runs when a collector subscribes; each collector gets its own independent run.
• Hot stream — emits regardless of listeners (StateFlow, SharedFlow, Channel).

fun simpleFlow(): Flow = flow {
    for (i in 1..5) { delay(100); emit(i) }
}
fun main() = runBlocking {
    simpleFlow().collect { println("Received $it") }
}

Received 1
Received 2
Received 3
Received 4
Received 5

Flow Operators

• map — transform; filter — condition; catch — handle upstream exceptions; onEach — side effects like logging.

A Channel is a hot, queue-like primitive: one coroutine send()s, another receive()s (or iterates with for). close() stops further sends.

val channel = Channel()
launch {
    for (i in 1..3) { channel.send(i) }
    channel.close()
}
launch {
    for (v in channel) println("Received $v")
}

Received 1
Received 2
Received 3

SharedFlow broadcasts one stream to many subscribers, with a configurable replay of past values for late subscribers — good for events multiple screens need.

Room is Jetpack's persistence library — an abstraction over SQLite with compile-time query validation, less boilerplate, and Coroutine/Flow/LiveData support.

@Entity(tableName = "user")
data class User(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    val name: String, val email: String
)

@Dao
interface UserDao {
    @Insert suspend fun insertUser(user: User)
    @Query("SELECT * FROM user") fun getAllUsers(): Flow>
    @Delete suspend fun deleteUser(user: User)
}

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

Singleton database instance

object RoomDB {
    @Volatile private var INSTANCE: AppDatabase? = null
    fun getDatabase(context: Context): AppDatabase =
        INSTANCE ?: synchronized(this) {
            INSTANCE ?: Room.databaseBuilder(
                context.applicationContext, AppDatabase::class.java, "my_database"
            ).build().also { INSTANCE = it }
        }
}

Migration

Safely updates the schema without wiping data.

val MIGRATION_1_2 = object : Migration(1, 2) {
    override fun migrate(db: SupportSQLiteDatabase) {
        db.execSQL("ALTER TABLE user ADD COLUMN age INTEGER DEFAULT 0 NOT NULL")
    }
}

• @Inject — tells Dagger where to inject a dependency (constructor/field).
• @Module — a class that provides dependencies.
• @Provides — a method describing how to create an object.
• @Component — connects providers to consumers, builds the dependency graph.

Manual DI means creating and wiring objects yourself — messy at scale. Dagger builds a compile-time dependency graph, catching wiring errors at build time instead of runtime.

Hilt new

Hilt is Google's opinionated layer on top of Dagger, built specifically for Android. It removes most of Dagger's boilerplate (components, modules for Android classes) via annotations.

@HiltAndroidApp
class MyApp : Application()

@AndroidEntryPoint
class MainActivity : AppCompatActivity()

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

LiveData is a lifecycle-aware observable holder — it only delivers updates to active (STARTED/RESUMED) observers, avoiding crashes/leaks from updating a destroyed UI.

• Lifecycle-aware — auto unsubscribes on destroy.
• Thread-safe writes from a background thread via postValue() (vs setValue() on the main thread).

Data Binding

Binds UI components directly to data sources in XML layouts, removing findViewById boilerplate and keeping view logic declarative.

A Reactive Extensions library for composing asynchronous, event-based programs using observable streams — predates widespread coroutine adoption, still common in legacy codebases.

• Observable, Observer, subscribe(), Operators, Schedulers (thread management)

Observable observable = Observable.just(1, 2, 3);
observable.subscribe(new Observer() {
    public void onSubscribe(Disposable d) { System.out.println("Subscribed!"); }
    public void onNext(Integer n) { System.out.println("Received: " + n); }
    public void onError(Throwable e) { System.out.println("Error: " + e.getMessage()); }
    public void onComplete() { System.out.println("Completed!"); }
});

Subscribed!
Received: 1
Received: 2
Received: 3
Completed!

Splitting a big app into smaller, independently-buildable modules by responsibility — improves build times (parallel/incremental compilation), enforces boundaries, and enables code reuse.

• App Module — assembles everything into the final APK.
• Feature Module — a specific feature (login, profile).
• Library/Core Module — shared utilities, network, DI, base classes.

MyApp/
├── app/
├── core/
├── network/
├── feature_login/
└── feature_profile/

MVVM (Model-View-ViewModel) separates UI (View) from business/UI logic (ViewModel) and data (Model/Repository). The View observes state exposed by the ViewModel; it never talks to the Model directly.

• View (Activity/Fragment/Compose) — renders state, forwards user actions.
• ViewModel — holds UI state, survives configuration changes (rotation), exposes state via LiveData/StateFlow.
• Model/Repository — single source of truth, abstracts data sources (Room, network).

class UserViewModel(private val repo: UserRepository) : ViewModel() {
    private val _state = MutableStateFlow(UiState.Loading)
    val state: StateFlow = _state

    fun loadUser(id: Int) = viewModelScope.launch {
        _state.value = UiState.Loading
        _state.value = try {
            UiState.Success(repo.getUser(id))
        } catch (e: Exception) {
            UiState.Error(e.message ?: "Unknown error")
        }
    }
}

viewModelScope is automatically cancelled when the ViewModel is cleared — no manual cleanup needed.

Retrofit is a type-safe HTTP client for Android/Java — it turns an interface with annotations into a working REST API client, backed by OkHttp.

interface ApiService {
    @GET("users/{id}")
    suspend fun getUser(@Path("id") id: Int): User
}

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build()

val api = retrofit.create(ApiService::class.java)

A suspend Retrofit function runs on Dispatchers.IO internally and can be called directly from a coroutine, without callbacks.

Compose is Android's modern, declarative UI toolkit — you describe what the UI should look like for a given state, and Compose handles updating the actual UI when that state changes (instead of manually mutating Views).

@Composable
fun Counter() {
    var count by remember { mutableStateOf(0) }
    Column {
        Text("Count: $count")
        Button(onClick = { count++ }) { Text("Increment") }
    }
}

• @Composable — marks a function as UI-emitting.
• remember — keeps a value alive across recompositions.
• mutableStateOf — an observable value; changing it triggers recomposition of anything reading it.
• Recomposition — Compose re-runs only the composables that read changed state, not the whole tree.

Memory leaks

Happens when an object (often an Activity/Fragment/View) is kept referenced longer than its intended lifecycle, so the garbage collector can't reclaim it.

• Common cause: a static field, singleton, or long-lived listener holding an Activity/Context reference.
• Common cause: a coroutine on GlobalScope or an unmanaged callback still holding a UI reference after the screen is destroyed.
• Fix: use applicationContext where a long-lived reference is needed, use lifecycle-scoped coroutines, and unregister listeners in onDestroy.

ANR (Application Not Responding)

Triggered when the main thread is blocked for too long (~5s for input events) — usually from heavy work (I/O, big loops, synchronous network calls) running on the main thread instead of a background dispatcher.

WorkManager is Jetpack's API for deferrable, guaranteed background work that should survive app restarts and device reboots (e.g. syncing data, uploading logs) — it picks the best underlying mechanism (JobScheduler, AlarmManager, etc.) for the OS version automatically.

class SyncWorker(ctx: Context, params: WorkerParameters) : CoroutineWorker(ctx, params) {
    override suspend fun doWork(): Result {
        return try {
            syncData()
            Result.success()
        } catch (e: Exception) {
            Result.retry()
        }
    }
}

val request = OneTimeWorkRequestBuilder()
    .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build())
    .build()
WorkManager.getInstance(context).enqueue(request)