The Complete Android Course
Learn Android with Kotlin and Jetpack Compose, from a first composable to a small offline app. Study Text, Image, TextField and everyday composables in ten detailed lessons with interactive demonstrations, worked examples and exercises. Build seven practical projects with complete source code, then explore optional advanced topics.
Build 20 Compose mini projects, including 10 for Phase 1A clear path from your first screen to an offline app
Start with basic Kotlin: functions, collections, data classes, and nullability. Each lesson has a focused example, practice task, and expected result. Complete the phase project before moving on; marked optional lessons can be skipped. Project build time is separate from lesson study estimates.
1. Read and understand
Identify the input, the state owner, and the expected screen result.
2. Practice and verify
Implement the worked exercise in Android Studio and compare observed behavior with the expected checks.
3. Build and review
Finish the phase capstone, demonstrate edge cases and review your implementation with the published criteria.
Choose a practical project
Choose a mini app for focused practice or a phase capstone to combine several skills. Each project includes a focused brief, ordered build steps, expected results, and complete Android Studio source.
Prcatice more · 10 simple Phase 1 apps10 more Jetpack Compose mini projects
Phase capstones
See the Android fundamentals in motion
Follow the journey from source code to a running app, then explore the callbacks behind an Android screen. Play each explanation, pause to inspect a step, and try different scenarios at your own pace.
How Android Works: From Code to App
Follow an animated journey from Android Studio and Kotlin source through compilation, packaging, installation, and the running app.
Explore lesson 02 · Interactive walkthroughAndroid Callback Methods
Explore animated Activity lifecycle scenarios and see how Android callbacks differ from the event callbacks your UI receives.
Explore lessonPhase 1 · Getting Started with Compose
Understand composition, layouts, resources and state; build a daily water counter.
Introduction to Android & Jetpack Compose
What Android is, why Kotlin and Jetpack Compose power modern apps, and what declarative UI really means.
How Android Works: From Code to App
Follow an animated journey from Android Studio and Kotlin source through compilation, packaging, installation, and the running app.
Setting Up Android Studio
Install the tools, create your first Compose project, and run it on an emulator or device.
Your First Composable
Meet @Composable, setContent, Text, and Preview; learn how editor previews and device runs complement each other.
Android Callback Methods
Explore animated Activity lifecycle scenarios and see how Android callbacks differ from the event callbacks your UI receives.
Composable Functions & Previews
Write reusable composables, pass parameters, and understand recomposition and the UI tree.
Text and the Modifier System
Style text and master Modifiers — the chainable system that sizes, spaces, and decorates every composable.
Text: Typography, Layout & Rich Content
Build readable text with theme typography, alignment, wrapping, ellipsis, styled spans and selection. Explore font scaling in an interactive lab.
Images, Icons & Resources
Show images and Material icons, and use Android's resource system for strings, colors, and drawables.
Image & Icon: Resources, Scaling & Semantics
Load local assets, compare Crop and Fit, shape images, control icon tint and write meaningful descriptions. Experiment with image bounds in a visual lab.
Layouts: Column, Row & Box
Arrange UI with the three core layout composables and control spacing, arrangement, and alignment.
Row, Column & Box: Constraints in Practice
Understand measurement, weight, alignment, stacking and scrolling, then compose a reusable layout that handles long content and larger fonts.
State with remember & mutableStateOf
The heart of Compose — how state drives the UI, with remember, mutableStateOf, and your first interactive app.
Prcatice more
Practice your Phase 1 skills with ten simple Compose apps. Follow a project guide, build one screen, and check your work using complete source and downloads.
Phase 1 Capstone · Daily Water Counter
Track up to eight glasses of water on one screen. Add a glass, undo one, or reset the count. Practice a single saved UI value and button callbacks; this is a counter exercise, not health advice.
Phase 2 · Building Interactive UIs
Create forms, lists, themes and accessible layouts; build a packing checklist.
State Management & State Hoisting
Make composables reusable and testable by hoisting state — the key Compose design pattern.
Handling User Input
Buttons, text fields, checkboxes, switches, and sliders — building interactive, validated forms.
TextField: State, Validation & Keyboard Behavior
Trace input events into state, build helpful validation, manage focus and IME actions, and compare value-based and state-based text APIs.
Button, IconButton & FAB: Actions That Work
Choose action emphasis, use content slots, model enabled and busy states, and make labeled buttons, icon actions and floating actions accessible.
Checkbox, Switch, RadioButton, Slider & Chips
Match each control to a selection model, hoist values, make entire labeled rows accessible, and calculate slider steps correctly.
Lists with LazyColumn & LazyRow
Display long, scrolling lists efficiently with lazy composables — the right way to show data.
LazyColumn, LazyRow & Grids: Identity and State
Build efficient lists and grids with stable keys, explicit empty states, immutable updates and a clear owner for scroll and row state.
Material Design 3
Build beautiful, consistent UIs with Google's Material 3 components and design system.
Card, Surface & ListItem: Reusable Content
Choose Material containers, understand tonal and shadow elevation, use content colors and slots, and give interactive content clear ownership.
Scaffold, App Bars & Structure
Give apps their standard structure with Scaffold, top bars, FABs, and snackbars.
Scaffold, App Bars, NavigationBar & FAB
Assemble screen slots, apply Scaffold padding once, reason about system insets, and distinguish local destination selection from a navigation back stack.
Dialogs, Menus, Snackbars & Progress
Represent transient UI with state, separate confirmation from dismissal, anchor menus, launch snackbars from events and show truthful progress.
Styling, Theming & Dark Mode
Craft a custom theme, support dark mode, and use dynamic color (Material You).
Adaptive Layouts & Accessibility
Build for changing window space, large text and assistive technology with responsive layouts and meaningful semantics.
Phase 2 Capstone · Packing Checklist
Build a packing checklist: add a name, mark an item packed, and remove a row. Learn forms, immutable list updates, callbacks, and stable IDs. The list intentionally stays in memory; permanent storage comes later.
Phase 3 · Navigation & Architecture
Typed routes, ViewModels, MVVM and restoration; walk through a two-screen lesson catalog.
Navigation in Compose
Move between screens with Navigation Compose, routes, arguments, and the back stack.
ViewModel & UI State
Hold and expose UI state properly with ViewModel and StateFlow, surviving configuration changes.
Architecture: MVVM
Structure real apps with MVVM and unidirectional data flow — the architecture Google recommends.
Lifecycle & State Restoration
Distinguish recomposition, rotation, system process death and persistent storage; verify small-input restoration with a hands-on lab.
Optional · Multi-Screen Navigation Patterns
Bottom navigation, nested graphs, and type-safe navigation for real multi-screen apps.
Phase 3 Capstone · Offline Lesson Catalog
Browse three bundled lessons, open a lesson by ID, and mark it as a favorite. Two screens introduce typed navigation, Back, safe lookups, and ViewModel state without networking or persistent storage.
Phase 4 · Data & Persistence
Learn coroutines, Flow, databases and APIs; practice persistence with a reading log.
Coroutines in Android
Run asynchronous work without blocking the UI, using suspend functions and viewModelScope.
Kotlin Flow in the UI
Stream data reactively into Compose with Flow and StateFlow, collected safely.
Local Storage with DataStore
Persist simple settings and preferences asynchronously with Jetpack DataStore.
Room Database
Store structured data locally with Room — entities, DAOs, queries, and observing with Flow.
Repository Pattern & Data Layer
Build a clean data layer that combines local and remote sources behind a single repository.
Optional · Networking with Retrofit
Call REST APIs and parse JSON with Retrofit and coroutines — connecting your app to the world.
Optional · Background Work with WorkManager
Schedule repeat-safe persistent refresh work with unique requests, network constraints, cancellation and an explicit retry policy.
Phase 4 Capstone · Reading Log
Save short reading notes in a single-screen Reading Log. Add and delete notes, display a useful empty state, and verify that committed records remain after restarting the app. Room is the only owner of saved notes.
Phase 5 · Screen Behavior & Quality
Use effects carefully, measure performance, and build a simple settings screen. Motion and custom drawing are optional.
Side Effects & Effect Handlers
Run non-UI work safely from composables with LaunchedEffect, DisposableEffect, and friends.
Performance & Best Practices
Keep apps smooth by understanding recomposition, stability, and how to avoid needless work.
Optional · Animations in Compose
Bring your UI to life with Compose's concise, powerful animation APIs.
Optional · Custom Layouts & Canvas
Go beyond built-ins with the Layout composable and custom drawing on the Canvas.
Phase 5 Capstone · Study Preferences
Build one settings screen with two switches and Reset. Practice state hoisting, conditional content, and a readable light/dark theme. Settings use saved UI state; durable preferences are a separate DataStore exercise.
Phase 6 · Professional Android
Learn DI, tests, security and release checks; practice with a tested score calculator.
Testing Compose Apps
Prove your app works with unit tests for logic and Compose UI tests for the interface.
Permissions, Publishing & the Play Store
Handle runtime permissions and take your app all the way to a live Play Store listing.
Android Security & Privacy
Audit real data flows, minimize permissions, select media through system pickers, and protect storage, networking and release credentials.
Optional · Dependency Injection with Hilt
Wire your app together cleanly and testably with Hilt dependency injection.
Phase 6 Capstone · Tested Score Calculator
Calculate a quiz percentage using two whole-number inputs. Extract a pure Kotlin function, test normal and invalid cases, and verify the screen separately. Integer division deliberately rounds down; no money calculations or architecture framework is needed.
Phase 7 · Portfolio
Combine lists, navigation, Room and tests in Study Tasks, with a complete reference solution.