Android development course

Lesson 1 • Using Physical Devices for Testing

Connect an Android device via USB and wireless debugging. Physical device testing reveals real-world performance differences from emulators.

Lesson 2 • Navigating the Android Studio IDE

Explore the IDE layout, tool windows, and project navigator. Familiarity with the interface accelerates every development task in the course.

Lesson 3 • Creating and Running Your First Project

Generate a new Android project using a template and run it on an emulator. This validates the environment and introduces the project scaffold.

Lesson 1 • Coroutines Introduction

Introduce coroutines for asynchronous programming without blocking threads. This prepares learners for network and database operations in later chapters.

Lesson 2 • Functions and Lambdas

Define named functions, default parameters, and higher-order functions. Lambda expressions enable concise callbacks used extensively in Android APIs.

Lesson 3 • Kotlin Syntax and Basic Types

Cover variables, data types, operators, and control flow in Kotlin. These primitives underpin every class and function written throughout the course.

Lesson 4 • Object-Oriented Programming in Kotlin

Implement classes, inheritance, interfaces, and data classes. Android components are class-based, making OOP mastery essential.

Lesson 1 • Core UI Widgets

Implement TextView, EditText, Button, ImageView, and CheckBox widgets. These components form the interactive elements users engage with directly.

Lesson 2 • XML Layout Basics

Write XML layout files and understand the View hierarchy. Layouts are the visual backbone of every Android screen.

Lesson 3 • RecyclerView and Adapters

Build scrollable lists with RecyclerView and a custom Adapter. Efficient list rendering is critical for data-heavy Android applications.

Lesson 4 • Common Layout Managers

Use LinearLayout, RelativeLayout, and ConstraintLayout to position UI elements. ConstraintLayout is the industry-standard approach for complex screens.

Lesson 1 • Bottom Navigation and Drawer Patterns

Integrate BottomNavigationView and NavigationDrawer with the Navigation component. These patterns match standard Android UX conventions expected by users.

Lesson 2 • Jetpack Navigation Component

Implement single-Activity navigation using a NavGraph and NavController. The Navigation component standardises deep links, back stack, and transitions.

Lesson 3 • Intents and Activity Communication

Launch activities with explicit and implicit Intents and pass data between them. Intents are the primary inter-component communication mechanism in Android.

Lesson 4 • Activity Lifecycle Deep Dive

Trace all Activity lifecycle callbacks and handle configuration changes. Correct lifecycle management prevents memory leaks and data loss.

Lesson 1 • StateFlow and SharedFlow

Replace LiveData with Kotlin StateFlow and SharedFlow for reactive streams. Flow-based state management integrates naturally with coroutines and Compose.

Lesson 2 • ViewModel Scope and Lifecycle

Create ViewModels that survive configuration changes and scope data correctly. ViewModels eliminate the need to re-fetch data on every screen rotation.

Lesson 3 • MVVM Architecture Overview

Understand the Model-View-ViewModel pattern and its benefits for Android. Separating concerns reduces coupling and improves testability across the codebase.

Lesson 4 • LiveData Observation Pattern

Expose data from ViewModel using LiveData and observe it in the UI layer. Lifecycle-aware observation prevents updates to stopped or destroyed components.

Lesson 1 • Room Architecture and Setup

Understand Room's three-layer architecture: Entity, DAO, and Database. Proper setup ensures type-safe, compile-time-verified database access.

Lesson 2 • Integrating Room with Repository Pattern

Wrap Room DAOs in a Repository class consumed by ViewModels. The Repository pattern decouples data sources from business logic effectively.

Lesson 3 • Data Access Objects and Queries

Write DAO interfaces with annotated SQL queries for CRUD operations. DAOs abstract database logic from the rest of the application cleanly.

Lesson 1 • HTTP and REST Fundamentals

Review HTTP methods, status codes, and JSON structure as they apply to Android. This context ensures correct API consumption and error interpretation.

Lesson 2 • Loading Images with Coil

Load and cache remote images efficiently using the Coil library. Image loading is a common networking task requiring memory and disk cache management.

Lesson 3 • Offline-First Strategy with Repository

Combine Room and Retrofit in a Repository to serve cached data when offline. This pattern improves perceived performance and resilience on poor networks.

Lesson 4 • Handling API Responses and Errors

Parse successful responses and handle network errors gracefully. Robust error handling prevents crashes and provides meaningful feedback to users.

Lesson 1 • Navigation and Side Effects in Compose

Implement Compose Navigation and manage side effects with LaunchedEffect. These complete the Compose skill set needed for full production app development.

Lesson 2 • State Management in Compose

Manage UI state with remember, mutableStateOf, and hoisted state patterns. Correct state management ensures predictable UI behaviour during recomposition.

Lesson 3 • Material Design 3 in Compose

Apply Material Design 3 components, typography, and colour schemes in Compose. Consistent theming produces professional, accessible apps aligned with platform standards.

Lesson 4 • Layouts and Modifiers in Compose

Arrange composables using Column, Row, Box, and Modifier chains. Modifiers replace XML attributes and enable flexible, chainable UI customisation.