Android development with kotlin course

Lesson 1 • Android Project Structure

Explains the folder layout, manifest, and Gradle build files. Connects project organisation to how Android compiles and packages an app.

Lesson 2 • Running and Debugging Apps

Covers running on emulators and physical devices with debugging tools. Builds the workflow learners use throughout every subsequent chapter.

Lesson 3 • Installing and Configuring Android Studio

Walks through SDK installation, emulator setup, and IDE preferences. Ensures a fully functional development environment before writing any app code.

Lesson 1 • Object-Oriented Programming in Kotlin

Introduces classes, inheritance, and interfaces specific to Kotlin. Prepares learners to model Android app data and behaviour using OOP.

Lesson 2 • Control Flow and Functions

Teaches conditionals, loops, and function definitions in Kotlin. Enables writing reusable logic blocks used throughout Android components.

Lesson 3 • Kotlin Language Basics

Covers variables, data types, and basic syntax rules. Establishes the language foundation every subsequent Android concept depends on.

Lesson 4 • Collections and Functional Idioms

Covers lists, maps, sets, and higher-order functions. Equips learners to process data collections efficiently in Android apps.

Lesson 1 • Styles, Themes, and Material Design

Applies Material Design components and theme attributes to layouts. Produces professional, brand-consistent UIs aligned with platform guidelines.

Lesson 2 • Layout Managers and Hierarchy

Teaches ConstraintLayout, LinearLayout, and FrameLayout positioning rules. Proper layout choice directly impacts performance and maintainability.

Lesson 3 • Core View Components

Introduces TextView, Button, ImageView, and EditText widgets. These are the building blocks of every Android screen covered later.

Lesson 4 • Responsive and Adaptive Layouts

Addresses screen size qualifiers and density-independent units. Ensures UIs render correctly on phones, tablets, and varied screen densities.

Lesson 1 • Intents and Activity Communication

Teaches explicit and implicit intents for launching activities and sharing data. Connects screens and integrates with system apps like camera and maps.

Lesson 2 • Activity Lifecycle Deep Dive

Maps every lifecycle callback to real app scenarios like rotation and backgrounding. Prevents data loss and memory leaks caused by lifecycle misuse.

Lesson 3 • ViewModel and State Preservation

Uses ViewModel to survive configuration changes and separate UI state. Establishes the state management pattern extended in later architecture chapters.

Lesson 4 • Fragment Fundamentals

Introduces Fragment lifecycle, transactions, and the back stack. Fragments enable modular, reusable UI panels used in navigation patterns.

Lesson 1 • Coroutines for Async Networking

Replaces callbacks with suspend functions and coroutine scopes for network calls. Produces readable, non-blocking networking code free of callback hell.

Lesson 2 • HTTP and REST Fundamentals

Reviews HTTP methods, status codes, and REST conventions relevant to Android. Provides the conceptual base for configuring Retrofit clients correctly.

Lesson 3 • Handling Network State and Errors

Implements sealed Result classes and connectivity checks for robust error handling. Ensures apps degrade gracefully when offline or when APIs return errors.

Lesson 4 • Retrofit Client Setup

Configures Retrofit with base URL, converters, and service interfaces. Connects the networking library to real API endpoints used in the app.

Lesson 1 • Advanced Room Queries and Relations

Covers complex queries, relationships, and database migrations in Room. Enables production-grade data models with one-to-many and many-to-many relations.

Lesson 2 • File Storage on Android

Explains internal, external, and cache storage directories and their access rules. Teaches safe file I/O patterns respecting scoped storage restrictions.

Lesson 3 • Room Database Fundamentals

Builds a local SQLite database using Room entities, DAOs, and the database class. Room is the primary persistence layer for complex structured data.

Lesson 4 • Testing Local Data Layers

Validates Room DAOs and DataStore logic using in-memory databases and test coroutines. Ensures data layer correctness before integrating with UI.

Lesson 1 • Dependency Injection with Hilt

Automates dependency creation and injection using Hilt annotations. Reduces boilerplate and makes components independently testable.

Lesson 2 • MVVM Architecture Overview

Defines Model, View, and ViewModel roles and their data-flow contracts. Establishes the architectural pattern that organises all subsequent app layers.

Lesson 3 • Repository Pattern and Data Sources

Abstracts local and remote data behind a Repository interface. Decouples ViewModels from data source details, enabling easy testing and swapping.

Lesson 4 • Modularising the App Architecture

Splits the app into feature and data modules with defined API boundaries. Improves build speed, team scalability, and code ownership clarity.

Lesson 1 • Compose Fundamentals and Composables

Introduces the @Composable annotation, recomposition, and basic UI elements. Establishes the mental model shift from imperative XML to declarative UI.

Lesson 2 • Layouts and Modifiers in Compose

Covers Column, Row, Box, and the Modifier chain for positioning and styling. Replaces ConstraintLayout and LinearLayout with composable layout primitives.

Lesson 3 • State Management in Compose

Manages UI state with remember, mutableStateOf, and hoisted state patterns. Ensures composables remain predictable and testable through state hoisting.

Lesson 4 • Animations and Compose Navigation

Adds motion with animate* APIs and wires screens using Compose Navigation. Delivers polished, navigable UIs that match modern app quality standards.