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
Syllabus

15 modules, 74 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 involvesComing soon
    2. Installing Android Studio and the SDKComing soon
    3. Your first app, runningComing soon
    4. The emulator, and running on your own phoneComing soon
    5. Finding your way around Android StudioComing soon
  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 projectComing soon
    2. The manifest, and what it declaresComing soon
    3. Activities, and why there is usually only one nowComing soon
    4. The lifecycle: the thing that breaks naive appsComing soon
    5. Resources: strings, drawables and configurationComing soon
  3. 3

    Jetpack Compose Fundamentals

    Describing a screen instead of inflating one.

    1. Declarative UI, and how it differs from XMLComing soon
    2. Composable functionsComing soon
    3. Recomposition: what actually re-runsComing soon
    4. Modifiers, and why order mattersComing soon
    5. Previews and the fastest way to iterateComing soon
    6. Material 3 components you will use dailyComing soon
  4. 4

    Layout and Theming

    Looking right across a very wide range of devices.

    1. Row, Column and BoxComing soon
    2. Constraint layouts and flowComing soon
    3. Material theming, colour and typographyComing soon
    4. Dark mode and dynamic colourComing soon
    5. Adapting to phones, foldables and tabletsComing soon
    6. Accessibility: TalkBack, touch targets and contrastComing soon
  5. 5

    State and Lifecycle

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

    1. remember and mutableStateOfComing soon
    2. State hoisting, and stateless composablesComing soon
    3. ViewModel, and surviving rotationComing soon
    4. Saved state, and surviving process deathComing soon
    5. Side effects: LaunchedEffect and friendsComing soon
  6. 6

    Lists and Navigation

    The two things almost every app is made of.

    1. LazyColumn and LazyRowComing soon
    2. Keys, and why your list is jankyComing soon
    3. Navigation between screensComing soon
    4. Passing data, and what not to passComing soon
    5. Bottom bars, drawers and app structureComing soon
  7. 7

    Architecture

    Structure that holds up past the third screen.

    1. Why Android punishes you for skipping thisComing soon
    2. UI, domain and data layersComing soon
    3. Repositories, and a single source of truthComing soon
    4. Modelling UI state as one objectComing soon
    5. Dependency injection with HiltComing soon
    6. Flows from the data layer to the screenComing soon
  8. 8

    Storing Data on Device

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

    1. DataStore for preferencesComing soon
    2. Room: entities, DAOs and the databaseComing soon
    3. Queries, relations and migrationsComing soon
    4. Caching, and an app that works on a bad trainComing soon
    5. Files, and where secrets goComing soon
  9. 9

    Networking

    Talking to an API on a connection that keeps dropping.

    1. Retrofit and typed API callsComing soon
    2. Coroutines, scopes and cancellationComing soon
    3. Loading, empty, error and retryComing soon
    4. Loading remote images efficientlyComing soon
    5. Offline-first, and syncing when you canComing soon
  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 workComing soon
    2. WorkManager for deferrable workComing soon
    3. Foreground services, and when they are justifiedComing soon
    4. Notifications, channels and permissionComing soon
  11. 11

    Permissions and Device Features

    Asking for access without getting refused.

    1. The permission model, and asking at the right momentComing soon
    2. Camera, photos and the media pickerComing soon
    3. Location, and its privacy expectationsComing soon
    4. Intents, sharing and deep linksComing soon
  12. 12

    Meeting XML Layouts

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

    1. Why XML layouts are still everywhereComing soon
    2. Reading a layout and a RecyclerViewComing soon
    3. Mixing Compose and Views in one appComing soon
  13. 13

    Testing, Profiling and Debugging

    Finding problems before a one-star review does.

    1. Logcat, breakpoints and the layout inspectorComing soon
    2. Unit testing ViewModels and repositoriesComing soon
    3. Testing Compose UIComing soon
    4. Profiling: jank, memory and batteryComing soon
    5. Crash reporting, and reading a stack trace from the fieldComing soon
  14. 14

    Shipping to Google Play

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

    1. Release builds, R8 and shrinkingComing soon
    2. Signing and the key you must not loseComing soon
    3. The Play Console and your first listingComing soon
    4. Internal, closed and open testing tracksComing soon
    5. Play policy, data safety and staying publishedComing soon
  15. 15

    Capstone Project

    Design, build, test and publish a complete app.

    1. The brief: a local deals 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

Our internship programme is free and fully remote. You get this curriculum, real project work, and code review from working developers.

Apply for the internshipAll courses