Course contents

Compose Fundamentals

Declarative vs Imperative UIComing soon
Compose Setup and First ComposableComing soon
Composable Functions and @ComposableComing soon
Compose Compiler and RuntimeComing soon
Preview and Tooling SupportComing soon
Composition and RecompositionComing soon
Practice: Hello Compose AppComing soon

Basic UI Components

Text and TypographyComing soon
Buttons and Interactive ElementsComing soon
Images and IconsComing soon
TextFields and Input ComponentsComing soon
Cards and Surface ComponentsComing soon
Dividers and SpacersComing soon
Component AccessibilityComing soon
Practice: Basic UI ComponentsComing soon

Layouts and Arrangement

Column and Row BasicsComing soon
Box Layout and PositioningComing soon
Arrangement and AlignmentComing soon
Modifier System Deep DiveComing soon
Padding, Spacing, and Sizing (no margins in Compose)Coming soon
ConstraintLayout in ComposeComing soon
Responsive Design PatternsComing soon
Custom Layout ComposablesComing soon
Layout Performance ConsiderationsComing soon
Practice: Complex Layout DesignComing soon

State Management

State in Compose FundamentalsComing soon
remember and mutableStateOf
rememberSaveable & process-death: SavedStateHandle patterns
State Hoisting PatternsComing soon
derivedStateOf and Computed StateComing soon
ViewModel IntegrationComing soon
StateFlow/Flow (and when to keep LiveData)Coming soon
State Restoration and SavingComing soon
Complex State Management PatternsComing soon
State Management Best PracticesComing soon
Practice: State-Driven UIComing soon

Side Effects and Lifecycle

Understanding Side Effects in ComposeComing soon
LaunchedEffect for Coroutine-based EffectsComing soon
rememberCoroutineScope for Event HandlersComing soon
DisposableEffect for CleanupComing soon
SideEffect for Non-Compose State SyncComing soon
produceState for Async Data to StateComing soon
rememberUpdatedState for Capturing Latest ValuesComing soon
Effect Keys and Restart BehaviorComing soon
Practice: Building a Timer with EffectsComing soon

Lists and Lazy Components

LazyColumn and LazyRow BasicsComing soon
LazyVerticalGrid and LazyHorizontalGridComing soon
List Item Keys and PerformanceComing soon
Sticky Headers and SectionsComing soon
Pull to Refresh ImplementationComing soon
Paging 3 + Lazy lists (load states, separators, refresh)Coming soon
Custom List LayoutsComing soon
Practice: Advanced List ImplementationComing soon

Forms, Input Validation, and Focus

TextField Variants and ConfigurationComing soon
Input Validation PatternsComing soon
FocusRequester and FocusManagerComing soon
Keyboard Actions and IME OptionsComing soon
Form State Management with StateHolderComing soon
Visual Transformation and MaskingComing soon
Error Handling and Feedback UIComing soon
Practice: Multi-Field Registration FormComing soon

Dialogs, Bottom Sheets, and Scaffold

AlertDialog and Custom DialogsComing soon
ModalBottomSheet ImplementationComing soon
Scaffold, TopAppBar, and FABComing soon
Snackbar and SnackbarHostComing soon
Drawer Layouts (ModalNavigationDrawer)Coming soon
Popup and DropdownMenuComing soon
Modal State Management Best PracticesComing soon
Practice: Settings Screen with DialogsComing soon

Theming and Styling

Material Design 3 in ComposeComing soon
Color Systems and PalettesComing soon
Typography and Text StylingComing soon
Shape System and Custom ShapesComing soon
Dark Theme ImplementationComing soon
Dynamic Color and Material YouComing soon
Custom Theme CreationComing soon
Theme Testing and PreviewsComing soon
Practice: Custom Theme DesignComing soon

Navigation and Screen Management

Navigation Component for ComposeComing soon
NavHost and NavController SetupComing soon
Route Parameters and ArgumentsComing soon
Predictive Back + BackHandler, state restore, and multiple back stacksComing soon
Bottom Navigation ImplementationComing soon
Drawer Navigation and RailsComing soon
Deep Linking and NavigationComing soon
Navigation Testing StrategiesComing soon
Practice: Multi-Screen NavigationComing soon

Animations and Transitions

Animation Fundamentals in ComposeComing soon
animate*AsState FunctionsComing soon
Transition API and StatesComing soon
AnimatedVisibility and Enter/ExitComing soon
AnimatedContent for Content ChangesComing soon
Custom Animations with AnimatableComing soon
Gesture-Based AnimationsComing soon
Shared Element TransitionsComing soon
Animation Performance TipsComing soon
Practice: Advanced Animation ShowcaseComing soon

Gestures and Input Handling

Pointer Input and Touch EventsComing soon
Drag and Drop ImplementationComing soon
Nested scroll & BringIntoView: coordinating scroll behaviorsComing soon
Swipe Gestures and DismissalComing soon
Multi-touch and Zoom GesturesComing soon
Custom Gesture DetectionComing soon
Accessibility and Gesture SupportComing soon
Practice: Gesture-Rich InterfaceComing soon

Custom Composables and Components

Creating Custom ComposablesComing soon
Composable APIs and ParametersComing soon
Slot APIs and Content ComposablesComing soon
Custom Modifier APIs (+ Modifier.Node in modern Compose)Coming soon
Canvas and Custom DrawingComing soon
Component Libraries and Design SystemsComing soon
Composable Testing StrategiesComing soon
Practice: Custom Component LibraryComing soon

Integration and Interoperability

Compose in View-based AppsComing soon
View in Compose with AndroidViewComing soon
Fragment Integration PatternsComing soon
WebView and Maps IntegrationComing soon
Third-party Library AdaptationComing soon
Migration StrategiesComing soon
Practice: Hybrid App DevelopmentComing soon

Testing Compose UIs

Compose Testing FundamentalsComing soon
ComposeTestRule and Test SetupComing soon
Finding and Interacting with NodesComing soon
Assertions and VerificationsComing soon
Semantics matchers, idling, and flake-proof waits (runOnIdle, waitUntil)Coming soon
Testing State and InteractionsComing soon
Screenshot TestingComing soon
Testing Best PracticesComing soon
Practice: Comprehensive Test SuiteComing soon

Performance Optimization

Compose Performance FundamentalsComing soon
Recomposition Optimization: stable data classes, equals(), derivedStateOfComing soon
Stability and ImmutabilityComing soon
LazyList Performance TuningComing soon
@Stable/@Immutable, snapshotFlow pitfalls, and tracing recompositions (Layout Inspector & compiler metrics)Coming soon
Memory Management in ComposeComing soon
Performance Profiling ToolsComing soon
Common Performance PitfallsComing soon
Practice: Performance OptimizationComing soon

Window Insets and Adaptive Layouts

Understanding WindowInsets in ComposeComing soon
Edge-to-Edge ImplementationComing soon
System Bars and Keyboard InsetsComing soon
imePadding and consumeWindowInsetsComing soon
Adaptive Layouts with WindowSizeClassComing soon
ListDetailPaneScaffold for Large ScreensComing soon
Foldable Device SupportComing soon
Testing on Different Screen SizesComing soon
Practice: Adaptive Email Client LayoutComing soon

CompositionLocal and Advanced Theming

CompositionLocal FundamentalsComing soon
staticCompositionLocalOf vs compositionLocalOfComing soon
Creating Custom CompositionLocalsComing soon
When to Use CompositionLocal vs ParametersComing soon
Practice: App-wide Settings with CompositionLocalComing soon

Graphics Layer and Advanced Drawing

graphicsLayer Modifier Deep DiveComing soon
drawBehind and drawWithContentComing soon
Blend Modes and Color FiltersComing soon
Path Drawing and CurvesComing soon
RuntimeShader and AGSL IntroductionComing soon
Image Filters and EffectsComing soon
Performance Considerations for GraphicsComing soon
Practice: Custom Animated BackgroundComing soon

Advanced Topics and Best Practices

Compose BOM and Dependency ManagementComing soon
Compose Multiplatform OverviewComing soon
Architecture Patterns with ComposeComing soon
Accessibility in ComposeComing soon
Internationalization and LocalizationComing soon
Baseline Profiles for PerformanceComing soon
Compose Compiler MetricsComing soon
Future of Compose DevelopmentComing soon
Final Project: Complete Compose AppComing soon

Deep Dive: Nature of Composable Functions

Composable function properties: idempotent, side-effect-free, restartableComing soon
Calling context & colored functions; similarities with suspendComing soon
Positional memoization & why parameter order mattersComing soon
Exercise: Rewrite a side-effecting composable into a pure oneComing soon

Deep Dive: The Compose Compiler

Annotations, IR lowering, and injecting the ComposerComing soon
Stability inference, default params, and control-flow groupsComing soon
Lambda memoization & comparison propagationComing soon
Live literals, version checks, klib/decoy generation (overview)Coming soon
Exercise: Use compiler metrics to spot unnecessary recompositionsComing soon

Deep Dive: Runtime, Slot Table & UI Materialization

Slot table, groups, reads/writes; recompose scopesComing soon
Appliers, LayoutNode lifecycle, and modifier chainsComing soon
Measuring policies, intrinsic measurements, constraintsComing soon
Semantics: merged vs unmerged trees & accessibility signalsComing soon
Exercise: Instrument a custom Layout + measure pass loggingComing soon

Deep Dive: Snapshot State & Concurrency (MVCC)

What snapshot state is; MVCC model & snapshot treeComing soon
Observing reads/writes, nested snapshots, threadingComing soon
Change propagation & merging write conflictsComing soon
Exercise: Diagnose a missed snapshot read in a list screenComing soon

Deep Dive: Smart Recomposition

Skips via stability & equality; when comparison failsComing soon
Keys, derivedStateOf, and minimizing invalidationsComing soon
Recomposer & concurrent recomposition (pitfalls & patterns)Coming soon
Exercise: Make a dashboard skippable without sacrificing correctnessComing soon

Deep Dive: Effects & Lifecycle

Non-suspended vs suspended effects; lifecycle semanticsComing soon
Keying effects correctly; avoiding stale closuresComing soon
Adapters for 3rd-party libs (e.g., listeners, callbacks)Coming soon
Exercise: Refactor side-effects out of composables safelyComing soon

State Management

rememberSaveable & process-death: SavedStateHandle patterns

video12-15 min

Learn through this resource

Handle state effectively in Compose applications

Open learning resource ↗

Learning with a friend?LinkedIn ↗X ↗WhatsApp ↗

YOUR LEARNING JOURNEY

0 of 2 available lessons completed

Progress saved in this browser. No account needed.

rememberSaveable & process-death: SavedStateHandle patterns | Jetpack Compose | Android Engineers