RizTech Academy logo
RizTech Academy

Android Development with Kotlin

Build and ship native Android apps with Kotlin and Jetpack Compose — from your first screen to Google Play.

Android is the platform most people in India actually use, and it is where most mobile work here starts. This course takes you from a blank Android Studio project to an app on Google Play.

Jetpack Compose throughout. XML layouts get one module, because every existing app you join will still have them and you need to read them — but nobody starts new screens that way, so that is all the time they get.

It spends real time on architecture, because Android punishes you for skipping it. An app that ignores the lifecycle looks fine until a phone call arrives, the screen rotates, or Android reclaims memory, and then it loses the user's work. The module on state and lifecycle exists precisely to stop that.

You need no Mac and no paid account to follow along. A Google Play developer account is a one-off fee and only matters for the final module.

Who this is for

  • Anyone who has finished our Kotlin Complete Foundation course
  • Developers who want to build for the platform most of their users are on
  • iOS developers adding Android
  • Interns joining Android client work

What you need first

  • Solid Kotlin. Our Kotlin Complete Foundation course covers everything assumed here, including coroutines.
  • A computer that can run Android Studio comfortably — 8 GB of RAM is realistically the floor.
  • A physical Android phone is useful but not required; the emulator is fine for most of the course.
  • A Google Play developer account is needed only for the final module, and costs a one-off fee.

Tools you will use

Android StudioKotlinJetpack ComposeRoomRetrofitHiltWorkManagerGradle

By the end you can

  • Build Android interfaces with Jetpack Compose
  • Handle state, recomposition and the activity lifecycle correctly
  • Structure an app with ViewModels, repositories and dependency injection
  • Navigate between screens and pass data without leaking it
  • Store data locally with Room and DataStore
  • Call APIs with Retrofit and coroutines, and survive a bad network
  • Run work in the background that outlives your screen
  • Request permissions without the user refusing them
  • Test, profile and debug a real app
  • Publish to Google Play and ship an update
Reference code

Stuck? Compare your work

Mandi Bhav as the course builds it, one branch per module that adds to the app. Modules that teach concepts without changing the app have no checkpoint. Compare against it when you are stuck rather than starting from it.

It is there for when you are stuck, not to start from. Type the code yourself first — copying it will teach you very little.

View on GitHub
Syllabus

16 modules, 82 lessons

Work through these in order. Each lesson is short enough to finish in one sitting and ends with something to build, not a quiz.

  1. 1

    Getting Started

    Android Studio, an emulator, and an app running on it.

    1. What Android development actually involves20 min
    2. Installing Android Studio and the SDK30 min
    3. Your first app, running30 min
    4. The emulator, and running on your own phone25 min
    5. Finding your way around Android Studio25 min
  2. 2

    How an Android App Is Put Together

    The pieces the platform expects, and the lifecycle that catches everyone.

    1. The anatomy of a project25 min
    2. Gradle, the version catalog and build variants35 min
    3. The manifest, and what it declares25 min
    4. Activities, and why there is usually only one now30 min
    5. The lifecycle: the thing that breaks naive apps35 min
    6. Resources: strings, drawables and configuration30 min
  3. 3

    Jetpack Compose Fundamentals

    Describing a screen instead of inflating one.

    1. Declarative UI, and how it differs from XML25 min
    2. Composable functions30 min
    3. Recomposition: what actually re-runs35 min
    4. Modifiers, and why order matters30 min
    5. Previews and the fastest way to iterate20 min
    6. Material 3 components you will use daily30 min
  4. 4

    Layout and Theming

    Looking right across a very wide range of devices.

    1. Row, Column and Box30 min
    2. Edge-to-edge, and drawing under the system bars30 min
    3. Constraint layouts and flow30 min
    4. Material theming, colour and typography30 min
    5. Dark mode and dynamic colour25 min
    6. Adapting to phones, foldables and tablets35 min
    7. Accessibility: TalkBack, touch targets and contrast30 min
  5. 5

    State and Lifecycle

    The module that stops your app losing the user's work.

    1. remember and mutableStateOf30 min
    2. State hoisting, and stateless composables35 min
    3. ViewModel, and surviving rotation35 min
    4. Saved state, and surviving process death35 min
    5. Side effects: LaunchedEffect and friends35 min
  6. 6

    Lists and Navigation

    The two things almost every app is made of.

    1. LazyColumn and LazyRow35 min
    2. Keys, and why your list is janky30 min
    3. Navigation between screens35 min
    4. Passing data, and what not to pass30 min
    5. Bottom bars, drawers and app structure30 min
  7. 7

    Architecture

    Structure that holds up past the third screen.

    1. Why Android punishes you for skipping this25 min
    2. UI, domain and data layers35 min
    3. Repositories, and a single source of truth35 min
    4. Modelling UI state as one object35 min
    5. Dependency injection with Hilt35 min
    6. Flows from the data layer to the screen35 min
  8. 8

    Storing Data on Device

    What survives the app being closed, and what should not.

    1. DataStore for preferences30 min
    2. Room: entities, DAOs and the database35 min
    3. Queries, relations and migrations35 min
    4. Caching, and an app that works on a bad train35 min
    5. Files, and where secrets go30 min
  9. 9

    Networking

    Talking to an API on a connection that keeps dropping.

    1. Retrofit and typed API calls35 min
    2. Coroutines, scopes and cancellation35 min
    3. The main thread, ANRs and StrictMode35 min
    4. Loading, empty, error and retry35 min
    5. Loading remote images efficiently25 min
    6. Offline-first, and syncing when you can35 min
  10. 10

    Work That Outlives the Screen

    Background work on a platform that is actively trying to stop you.

    1. Why Android keeps killing your background work30 min
    2. WorkManager for deferrable work35 min
    3. Foreground services, and when they are justified35 min
    4. Notifications, channels and permission30 min
  11. 11

    Permissions and Device Features

    Asking for access without getting refused.

    1. The permission model, and asking at the right moment35 min
    2. Camera, photos and the media picker35 min
    3. Location, and its privacy expectations30 min
    4. Intents, sharing and deep links30 min
  12. 12

    Meeting XML Layouts

    One module, because the app you join will be full of them.

    1. Why XML layouts are still everywhere30 min
    2. Reading a layout and a RecyclerView35 min
    3. Mixing Compose and Views in one app30 min
  13. 13

    Testing, Profiling and Debugging

    Finding problems before a one-star review does.

    1. Logcat, breakpoints and the layout inspector30 min
    2. Unit testing ViewModels and repositories35 min
    3. Testing Compose UI35 min
    4. Profiling: jank, memory and battery35 min
    5. Crash reporting, and reading a stack trace from the field25 min
  14. 14

    Shipping to Google Play

    Release builds, signing, the console, and the review you can fail.

    1. Release builds, R8 and shrinking45 min
    2. Signing and the key you must not lose30 min
    3. The Play Console and your first listing40 min
    4. Internal, closed and open testing tracks35 min
    5. Play policy, data safety and staying published45 min
  15. 15

    Android Best Practices

    The habits that keep an Android codebase working after the tenth screen.

    1. Naming across layers, from table to screen35 min
    2. Where logic lives: composable, ViewModel or repository35 min
    3. Defensive Android: process death, the main thread and config changes40 min
    4. Compose rules that keep screens fast35 min
    5. Reviewing an Android change35 min
  16. 16

    Capstone Project

    Design, build, test and publish a complete app.

    1. The brief: a medicine reminder appComing soon
    2. Designing it before building itComing soon
    3. Building it screen by screenComing soon
    4. Polish, icons and empty statesComing soon
    5. Publishing itComing soon
Previous courseTypeScript FoundationNext courseSwift and iOS Development

Learning this with a mentor is faster

Going through a course like this one is how you qualify for our six-month internship, for selected students, mostly from Pune. Clear the interview and you build real-world projects with my mentorship.

About the internshipAll courses