Kotlin and Android App Development

What Kotlin and Android are, your first program, val and var, the basic types, string templates, conditions with if and when, and loops with ranges. After this module you can write and run small Kotlin programs that calculate, decide and repeat.

1. Kotlin and Android: the big pictureAndroid is the operating system on most smartphones in India, and Kotlin is the language Google recommends for building Android apps. Kotlin is modern, short to write, protects you from null crashes, and works with existing Java code. In this course you first learn Kotlin itself, then build Android apps with Jetpack Compose.20 min
2. First program, val and var, and typesEvery Kotlin program starts in fun main(). println prints a line. val creates a read-only variable and var creates one you can change; prefer val. Kotlin works out types like Int, Double, Boolean and String for you, and string templates put values into text with $name and ${expression}.30 min
3. Conditions: if and whenif runs code only when a condition is true, and in Kotlin it is an expression, so it can give a value: val fee = if (member) 0 else 50. when is Kotlin's powerful replacement for switch: it checks a value against several options, ranges or types, and can also be used as an expression with an else branch.25 min
4. Loops and rangesLoops repeat code. for goes over ranges like 1..5 (both ends included), 1 until 5 or 1..<5 (end excluded), 5 downTo 1, and step 2, and over lists. while repeats while a condition is true, do-while runs at least once, and repeat(n) runs a block n times. break stops a loop; continue skips to the next round.25 min

How Kotlin prevents null crashes with nullable types, safe calls and the Elvis operator; how to write functions with default and named arguments; lambdas and higher-order functions; and extension and scope functions. After this module you can write safe, short Kotlin functions and read the lambda-heavy style used everywhere in Android code.

1. Null safetyIn Kotlin a normal type like String can never hold null. If a value may be missing, its type says so with a question mark: String?. You then use the safe call ?. , the Elvis operator ?: for a default, smart casts after a null check, or let to run code only when the value exists. The !! operator forces a value and crashes if it is null, so avoid it.30 min
2. FunctionsFunctions are declared with fun, a name, typed parameters and an optional return type after a colon. A function that returns nothing returns Unit. Short functions can be written as a single expression with =. Default and named arguments make calls clear and remove the need for many overloads; vararg accepts any number of values.30 min
3. Lambdas and higher-order functionsA lambda is a small function without a name, written in braces: { a: Int, b: Int -> a + b }. Functions are values in Kotlin, with types like (Int) -> Int. A higher-order function takes or returns a function. When a lambda has one parameter, you can call it it, and when it is the last argument it goes outside the parentheses: this trailing-lambda syntax is why Compose code looks the way it does.30 min
4. Extension functions and scope functionsAn extension function adds a new function to an existing type without changing its code: fun String.initials(). Scope functions (let, run, with, apply, also) run a block of code on an object; they differ in whether the object is it or this inside, and whether they return the object or the block's result. Use them to make code clearer, not cleverer.25 min

Model real things with classes, properties and constructors; use data, enum and sealed classes and objects; reuse code with inheritance and interfaces; store data in lists, sets and maps; and transform it with map, filter, groupBy and friends. After this module you can design the data layer of an app and process lists of data in a few clear lines.

1. Classes and objectsA class is a blueprint that groups data (properties) and behaviour (functions) for one kind of thing, such as a Student or a CartItem. You create objects (instances) by calling the class like a function. Kotlin's primary constructor declares properties right in the class header with val or var, and init blocks run setup code.30 min
2. Data, enum and sealed classes, and objectsA data class holds data and gets equals, hashCode, toString, copy and destructuring for free. An enum class lists a fixed set of constants. A sealed class or sealed interface lists a fixed set of subtypes that can carry different data, which is perfect for screen states, and when on it needs no else. object creates a single instance (a singleton); a companion object holds class-level members.30 min
3. Inheritance and interfacesInheritance lets a class reuse and extend another class. In Kotlin, classes are final (closed) by default: you must mark a class open to inherit from it and a function open to override it. Abstract classes leave some members for subclasses to fill in. Interfaces describe abilities that many unrelated classes can share, and a class can implement several interfaces.25 min
4. Collections: List, Set and MapKotlin has three main collections: List (ordered, may repeat), Set (unique items) and Map (key-value pairs). Each comes in a read-only form (listOf, setOf, mapOf) and a mutable form (mutableListOf, mutableSetOf, mutableMapOf). Read-only means you cannot change it through that reference, which is not quite the same as immutable.25 min
5. Collection operationsKotlin collections have powerful built-in functions that take lambdas: map transforms, filter keeps matching items, sumOf adds, count counts, sortedBy and sortedByDescending sort, groupBy groups, associateBy builds a map, first and firstOrNull find, and any, all and none check conditions. Chaining them replaces most hand-written loops with short, readable code.30 min

Why slow work must never run on the main thread, how suspend functions and coroutines solve it, launching work with launch and async under structured concurrency, choosing dispatchers with withContext, and streams of values with Flow and StateFlow. After this module you can write non-blocking Kotlin code exactly the way modern Android apps do.

1. Why coroutines? suspend functionsAn Android app draws its screen and handles taps on one main thread. If slow work like a network call runs there, the app freezes, and after about 5 seconds Android may show an "App Not Responding" dialog. Coroutines let you write slow work in simple top-to-bottom code that pauses (suspends) without blocking the thread. A suspend function is a function that can pause.30 min
2. launch, async and structured concurrencyCoroutines start inside a CoroutineScope. launch starts a coroutine that does a job and returns a Job; async starts one that produces a value and returns a Deferred, whose await() gives the result. Structured concurrency means every coroutine belongs to a scope: the parent waits for its children, and cancelling the scope cancels them all, so nothing leaks. On Android you use viewModelScope and lifecycleScope.30 min
3. Dispatchers and withContextA dispatcher decides which thread or thread pool a coroutine runs on. Dispatchers.Main is the UI thread, Dispatchers.IO is for blocking input/output like files and old blocking APIs, and Dispatchers.Default is for heavy CPU work like sorting or parsing big data. withContext(Dispatchers.IO) { } switches threads for a block and returns its result. Good suspend functions are main-safe.25 min
4. Flow and StateFlowA suspend function returns one value; a Flow emits many values over time, like live scores or database changes. A cold Flow built with flow { emit(...) } runs each time someone collects it. Operators like map and filter transform it. StateFlow is a hot flow that always holds a current value and is the standard way for a ViewModel to expose UI state; SharedFlow is for one-off events.30 min

Install Android Studio, create an emulator and run on a real phone, understand every folder and Gradle file of a new project, learn the activity lifecycle and what happens on rotation, and write your first Jetpack Compose screen with previews and Logcat. After this module you can create, run and debug an Android app on an emulator and on your own phone.

1. Setting up Android Studio, an emulator and your phoneAndroid Studio is the official free tool (IDE) for building Android apps. It includes the Android SDK, an emulator that runs a virtual phone on your computer, and tools for building and debugging. 8 GB of RAM is a workable minimum and 16 GB is comfortable. You can also run apps on your own phone by turning on Developer options and USB debugging.35 min
2. Project structure and GradleA new project has an app module with Kotlin code under src/main/java, resources (strings, images, themes) under src/main/res, and AndroidManifest.xml describing the app. Gradle build files written in Kotlin (build.gradle.kts) set the applicationId, minSdk, targetSdk, compileSdk, version and dependencies, and a version catalog (libs.versions.toml) keeps library versions in one place.30 min
3. Activities and the lifecycleAn Activity is an entry point that shows a screen. Android moves it through lifecycle states and calls onCreate, onStart, onResume, onPause, onStop and onDestroy as the user opens, leaves and returns to it. On a configuration change such as rotation, the activity is destroyed and recreated, so screen state must be kept in a ViewModel or with rememberSaveable.30 min
4. Hello Compose: your first screenJetpack Compose builds UI from Kotlin functions marked @Composable. setContent in the activity shows them, wrapped in your app theme. @Preview shows a composable in Android Studio without running the app. Use string resources with stringResource, log with Log.d and read crashes in Logcat.30 min

Build screens with Compose: basic composables and modifiers, state and recomposition, state hoisting, layouts with Column, Row, Box and Scaffold, fast lists and grids with lazy layouts, and text input forms with validation. After this module you can build any common app screen and make it react to user input.

1. Composables and modifiersScreens are built from small composable functions such as Text, Button, Image and Icon. A Modifier is a chain of instructions that changes how a composable looks or behaves: size, padding, background, click handling. The order of modifiers matters, because each one wraps the next. Use dp for sizes and sp for text.30 min
2. State and recompositionState is any value that can change over time and should be shown on screen. In Compose, store it in a State object, usually with remember { mutableStateOf(...) }. When the value changes, Compose re-runs (recomposes) the composables that read it. A plain var does not trigger updates. rememberSaveable also survives rotation. State hoisting moves state up to the caller, giving reusable, stateless composables.35 min
3. Layouts: Column, Row, Box and ScaffoldColumn stacks children vertically, Row places them horizontally, and Box layers them on top of each other. Arrangement controls spacing along the main direction and Alignment positions children across it. weight shares leftover space. Scaffold gives a standard screen frame with a top bar, bottom bar, floating action button and correct padding.30 min
4. Lists and gridsLazyColumn and LazyRow show long, scrollable lists efficiently: only the items on screen (plus a few) are composed. Fill them with items(list, key = { it.id }) { item -> ... }. Stable keys keep scroll position and state correct when items move. LazyVerticalGrid shows a grid with GridCells.Fixed or GridCells.Adaptive.30 min
5. Text input and formsTextField and OutlinedTextField take a value and an onValueChange lambda, so the text lives in your state. KeyboardOptions choose the keyboard (Phone, Number, Email) and the action button; PasswordVisualTransformation hides passwords. Show validation errors with isError and supportingText, and enable the submit button only when every field is valid.30 min

Move between screens with Navigation Compose and type-safe routes, keep screen state in a ViewModel exposed as StateFlow, organise code into UI, domain and data layers with repositories, and wire dependencies with Hilt. After this module you can structure a multi-screen app the way professional Android teams do.

1. Navigation ComposeNavigation Compose moves between screens inside one activity. A NavHost holds the screens, a NavController (from rememberNavController) moves between them, and each destination is a route. With type-safe routes, a route is a @Serializable object or data class, so arguments like an order id are checked by the compiler. navigate pushes a screen onto the back stack and popBackStack goes back.35 min
2. ViewModel and MVVMMVVM splits a screen into the Model (data), the View (composables) and the ViewModel, which holds screen state and logic. A ViewModel survives configuration changes like rotation. It exposes a UiState data class through a read-only StateFlow, receives events as function calls, and runs work in viewModelScope. The UI collects the state with collectAsStateWithLifecycle().35 min
3. App architecture: layers and repositoriesGoogle's recommended app architecture has a UI layer (composables and ViewModels), an optional domain layer (use cases for shared business logic) and a data layer (repositories and data sources). Repositories are the single source of truth for each kind of data and hide whether it comes from the network, a database or both. State flows down, events flow up.30 min
4. Dependency injection with HiltDependency injection (DI) means a class receives the objects it needs (its dependencies) from outside instead of creating them itself. This makes classes easy to test with fakes and easy to reconfigure. Hilt is the DI library recommended for Android: annotate the Application with @HiltAndroidApp, activities with @AndroidEntryPoint, ViewModels with @HiltViewModel and @Inject constructor, and provide objects in @Module classes.30 min

Store structured data on the device with Room, call web APIs with Retrofit, turn JSON into Kotlin objects with kotlinx.serialization, show loading, success and error states, keep small settings in DataStore, and combine everything into an offline-first repository. After this module you can build an app that works with real data, online and offline.

1. Room databaseRoom is Android's recommended library for a local SQLite database. You describe a table with an @Entity data class, write queries in a @Dao interface with @Insert, @Update, @Delete and @Query, and create the database from a @Database class. DAO functions can be suspend for one-off work or return Flow to get live updates whenever the table changes.35 min
2. Networking with RetrofitRetrofit turns a Kotlin interface into an HTTP client. You declare functions with annotations like @GET, @POST, @Path, @Query and @Body, mark them suspend, and Retrofit performs the request on a background thread and converts the JSON response with a converter. You need the INTERNET permission, HTTPS URLs, and a base URL that ends with a slash.35 min
3. JSON models and handling errorskotlinx.serialization turns JSON into @Serializable data classes; @SerialName maps different JSON names, default values cover missing fields, and ignoreUnknownKeys keeps old app versions working when the server adds fields. Network calls fail (no internet, timeouts, server errors), so catch IOException and HttpException and expose Loading, Success and Error states with a sealed interface, plus a Retry button.30 min
4. Offline-first apps and DataStoreAn offline-first app shows data from its local database first and refreshes it from the network in the background. The repository makes the database the single source of truth: the UI observes Room, and network results are saved into Room. Small settings (dark mode, language, last city) go in Preferences DataStore, which replaced SharedPreferences. WorkManager runs sync jobs that must survive app restarts.30 min

Ask for runtime permissions the right way, theme your app with Material 3 colours, typography and dynamic colour, use the standard Material components, and make the app accessible and ready for tablets and foldables. After this module your apps feel professional, respect users' privacy and work for everyone.

1. Runtime permissionsAndroid protects private data and hardware with permissions. Normal permissions (like INTERNET) are granted at install. Dangerous permissions (camera, location, contacts, microphone, and notifications on Android 13+) must be declared in the manifest and also requested at run time, at the moment the feature is used, with rememberLauncherForActivityResult and ActivityResultContracts.RequestPermission. Always handle "denied" gracefully.35 min
2. Material 3 themingMaterial Design 3 (Material You) is Google's design system. In Compose, MaterialTheme provides a colorScheme, typography and shapes that every component uses. Define light and dark colour schemes for your brand, optionally use dynamic colour from the user's wallpaper on Android 12+, and always read colours from MaterialTheme.colorScheme instead of hard-coding them.30 min
3. Material componentsMaterial 3 gives ready components that users already understand: TopAppBar for the screen title and actions, NavigationBar for 3 to 5 main sections, FloatingActionButton for the main action, Card for grouped content, AlertDialog for important decisions, Snackbar for short messages with an optional action, and ModalBottomSheet for extra options.30 min
4. Accessibility and adaptive layoutsAccessible apps work for everyone, including people who use TalkBack (the screen reader), large fonts or have low vision. Give images and icons content descriptions, keep touch targets at least 48 dp, use enough colour contrast, use sp for text and test at the largest font size. Adaptive layouts use window size classes to show richer layouts on tablets and foldables.30 min

Understand local and instrumented tests and the test pyramid, write JUnit unit tests for Kotlin logic and ViewModels with fakes and runTest, write Compose UI tests with finders, actions and assertions, and debug and profile apps with Logcat, breakpoints, Layout Inspector and the Profiler. After this module you can prove your app works and find out why when it does not.

1. Testing basics and the test pyramidTests are code that checks your code automatically. Android has local tests (in src/test, run on your computer's JVM in seconds) and instrumented tests (in src/androidTest, run on a device or emulator). The test pyramid says: many fast unit tests, fewer integration tests, and a small number of slow end-to-end UI tests.25 min
2. Unit tests with JUnit and coroutinesWrite unit tests with JUnit: a class with functions marked @Test that use assertions such as assertEquals and assertTrue. Test ViewModels by giving them a fake repository, calling their event functions and checking the UI state. For coroutine code, use runTest from kotlinx-coroutines-test, and replace Dispatchers.Main with a test dispatcher.35 min
3. Compose UI testsCompose UI tests set content on a test rule (createComposeRule), find nodes with finders such as onNodeWithText, onNodeWithTag and onNodeWithContentDescription, perform actions like performClick and performTextInput, and check them with assertions like assertIsDisplayed and assertIsEnabled. Add Modifier.testTag for elements without unique text. Espresso is the older tool for View-based screens.30 min
4. Debugging and performanceFind bugs with Logcat filters and the debugger: set breakpoints, step through code and inspect variables. Layout Inspector shows the live Compose tree and recomposition counts. The Android Studio Profiler measures CPU, memory and more. Common fixes for slow screens: lazy lists with keys, no heavy work in composables, remember expensive values, and always judge speed on a release build.30 min

Prepare a release build with R8, sign it with an upload key and build an Android App Bundle; set up Google Play Console, the store listing and testing tracks; meet Play policies such as the Data safety form and target API requirements; and add Firebase for login, a cloud database, crash reports and push notifications. After this module you can take an app from your laptop to real users on Google Play.

1. Release builds, signing and the App BundleA release build is optimised and shrunk by R8 (isMinifyEnabled = true). Every app must be signed with a private key: you sign uploads with your upload key, and with Play App Signing Google keeps the final app signing key. Increase versionCode for every upload. Google Play requires new apps to be published as an Android App Bundle (AAB), from which Play builds small, device-specific APKs.35 min
2. Google Play Console and testing tracksTo publish, create a Google Play Console developer account (a one-time US$25 fee and identity verification), create the app, fill in the store listing (name, descriptions, icon, feature graphic, screenshots), and release through testing tracks: internal, closed and open, then production. New personal developer accounts must run a closed test with at least 12 testers for 14 days before production access (as of 2025; check the current rules). Use staged rollouts for updates.30 min
3. Play policies: privacy, data safety and targetsGoogle Play reviews apps against its Developer Program Policies. You must complete the Data safety section (what data you collect, share and why), give a privacy policy URL when you handle personal or sensitive data, declare and justify sensitive permissions, answer the content rating questionnaire, declare ads and target audience, and keep targetSdk at the level Play currently requires. Most rejections are fixable by being honest and specific.30 min
4. Firebase basicsFirebase is Google's set of backend services for apps. Add it with the Firebase console, the google-services.json file, the Google services Gradle plugin and the Firebase BoM. Common services: Authentication (email, phone OTP, Google sign-in), Cloud Firestore (a cloud database with real-time listeners), Crashlytics (crash reports), Cloud Messaging (push notifications) and Analytics. Always write Firestore security rules.35 min

An honest view of Android jobs in India, the Kotlin and Android interview questions you will face with model answers, how to handle take-home assignments, and how to build a portfolio and keep growing (including Kotlin Multiplatform). After this module you can plan your Android career, answer common interview questions clearly and show work that gets you shortlisted.

1. Android jobs in IndiaAndroid developers work at product companies, IT service companies, startups and agencies, or freelance. Job posts commonly ask for Kotlin, Jetpack Compose, MVVM, coroutines and Flow, Room, Retrofit, Git, and sometimes XML Views and Java for older code. Salaries vary widely by city, company and skill; treat any range as approximate.25 min
2. Interview questions: KotlinKotlin interview questions check whether you truly understand the language: val versus var, null safety operators, data and sealed classes, extension and scope functions, lambdas, coroutines versus threads, launch versus async, Flow versus StateFlow, and collection operations. Answer with a definition, a reason and a tiny example.35 min
3. Interview questions: Android and ComposeAndroid interviews cover the activity lifecycle and configuration changes, ViewModel and state, Compose recomposition, remember versus rememberSaveable, state hoisting, lazy lists and keys, navigation, Room, Retrofit and offline handling, permissions, testing and publishing (AAB, signing). Many companies also give a take-home assignment.35 min
4. Portfolio and next stepsBuild 3 or 4 portfolio apps that show different skills (Room, Retrofit with offline support, Firebase, a published Play Store app), each with a clear GitHub README and screenshots. Keep learning with the official Android samples such as Now in Android, follow Android releases, and look at Kotlin Multiplatform and Compose Multiplatform as next steps.25 min