Android course

Lesson 1 • Using Physical Devices for Testing

Connect an Android device via USB and wireless ADB for on-device testing. Physical testing reveals performance issues invisible in emulators.

Lesson 2 • Creating and Running Your First Project

Generate a new Android project using a template and run it on an emulator. This confirms the environment is correctly configured end-to-end.

Lesson 3 • Version Control with Git in Android Studio

Initialise a Git repository and commit code directly from Android Studio. Version control is essential for all professional Android projects.

Lesson 4 • Understanding the Android Studio IDE

Navigate the Android Studio interface, including the project explorer, editor, and tool windows. Familiarity here accelerates every coding task ahead.

Lesson 1 • Kotlin Syntax and Basic Types

Declare variables with val and var, use primitive and string types, and write expressions. These basics underpin every Kotlin program written in this course.

Lesson 2 • Null Safety and Smart Casts

Handle nullable types using safe calls, the Elvis operator, and non-null assertions. Null safety prevents the most common Android runtime crashes.

Lesson 3 • Collections and Functional Operations

Use lists, maps, and sets with functional operators like map, filter, and reduce. Collections are used throughout Android data handling and UI binding.

Lesson 4 • Object-Oriented Programming in Kotlin

Define classes, data classes, interfaces, and inheritance hierarchies in Kotlin. OOP structures are the backbone of Android component design.

Lesson 1 • Styles, Themes, and Material Design

Apply styles, themes, and Material Design components to create consistent, polished UIs. Theming ensures brand consistency across the entire application.

Lesson 2 • RecyclerView and Adapters

Display scrollable lists efficiently using RecyclerView with a custom adapter and ViewHolder. RecyclerView is the standard for all list-based Android UIs.

Lesson 3 • XML Layout Structure and ViewGroups

Understand the XML layout hierarchy and use ConstraintLayout, LinearLayout, and FrameLayout. Layout choice directly affects rendering performance and flexibility.

Lesson 4 • Core View Components

Implement TextView, EditText, Button, ImageView, and CheckBox in layouts. These views form the building blocks of nearly every Android screen.

Lesson 1 • Intents and Activity Communication

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

Lesson 2 • Dialogs, Bottom Sheets, and Menus

Present contextual UI using AlertDialogs, BottomSheetDialogs, and options menus. These patterns handle user decisions and secondary actions cleanly.

Lesson 3 • Activity Lifecycle and State Management

Implement lifecycle callbacks to manage resources and preserve UI state across rotations. Correct lifecycle handling prevents memory leaks and data loss.

Lesson 4 • Fragment Basics and Lifecycle

Create reusable Fragment components and manage their lifecycle within a host Activity. Fragments enable modular, reusable UI sections across multiple screens.

Lesson 1 • Content Providers and Data Sharing

Expose and consume structured data across apps using Content Providers. This enables secure inter-app data access for contacts, media, and custom data.

Lesson 2 • Room Migrations and Relations

Handle schema migrations and model one-to-many and many-to-many relationships in Room. Migrations ensure data integrity across app version updates.

Lesson 3 • SharedPreferences for Simple Data

Read and write key-value pairs using SharedPreferences and DataStore. These tools handle lightweight settings and user preferences efficiently.

Lesson 4 • Room Database Fundamentals

Define entities, DAOs, and a Room database to persist structured data locally. Room provides a type-safe SQLite abstraction used in most production apps.

Lesson 1 • Dependency Injection with Hilt

Inject dependencies into Android components using Hilt annotations and modules. DI reduces coupling and makes components independently testable.

Lesson 2 • LiveData and StateFlow

Expose reactive data streams from ViewModel using LiveData and StateFlow. Reactive streams keep the UI automatically synchronised with underlying data changes.

Lesson 3 • WorkManager for Background Tasks

Schedule deferrable and guaranteed background work using WorkManager constraints and chains. WorkManager handles tasks that must complete even if the app is closed.

Lesson 4 • App Startup and Initialisation Patterns

Optimise app startup time using App Startup library and lazy initialisation strategies. Fast startup directly improves user retention and app store ratings.

Lesson 1 • Retrofit for REST API Calls

Define Retrofit service interfaces and execute GET, POST, PUT, and DELETE requests. Retrofit is the industry-standard Android HTTP client for REST APIs.

Lesson 2 • Coroutines for Asynchronous Networking

Use Kotlin coroutines and Flow to perform network calls off the main thread safely. Coroutines replace callbacks and RxJava for async work in modern Android.

Lesson 3 • JSON Parsing with Gson and Moshi

Deserialise JSON responses into Kotlin data classes using Gson and Moshi converters. Correct parsing prevents data corruption and runtime exceptions.

Lesson 4 • HTTP Basics and OkHttp Client

Understand HTTP methods, headers, and status codes, then configure an OkHttp client. This foundation is required before using higher-level networking libraries.

Lesson 1 • Lists, Grids, and Lazy Layouts

Render large datasets efficiently using LazyColumn, LazyRow, and LazyVerticalGrid. Lazy layouts are the Compose equivalent of RecyclerView for performant lists.

Lesson 2 • Animations and Custom Drawing

Add motion with animate*AsState, AnimatedVisibility, and Canvas drawing APIs. Animations improve perceived quality and guide user attention effectively.

Lesson 3 • Navigation and Interoperability in Compose

Implement Compose Navigation and embed XML views inside composables using interop APIs. Interoperability enables gradual migration of existing XML-based apps.

Lesson 4 • Compose Fundamentals and Composable Functions

Write composable functions, understand recomposition, and use basic layout composables. Compose replaces XML layouts with a reactive, code-first UI paradigm.

Lesson 5 • State Management in Compose

Manage UI state with remember, mutableStateOf, and ViewModel integration in Compose. Correct state hoisting prevents bugs and enables testable composables.