Android Compose Essentials - Build Android Apps like a Pro

Learn the core Kotlin building blocks for Android development with Jetpack Compose, including variables, data types, operators, control flow, data structures, functions, null safety, scope functions, and object oriented concepts.

Learn Kotlin by writing and running a hello world program in a Kotlin playground, then explore building Android apps with Jetpack Compose in Android Studio using emulator or real device.

Declare Kotlin variables with val or var and assign an int to store in memory. Name using camelCase, specify the type with a colon, and print values.

Explore Kotlin data types, including double, int, long (with L), float (with F), char (single quotes), and string; compare print and println and use boolean values.

Demonstrate string interpolation in Kotlin by declaring two integer variables x and y and printing their sum within a println using a dollar sign before variables and braces for expressions.

Learn how to use Kotlin operators for assignment, arithmetic, and comparison in Android apps, including plus, minus, multiply, divide, remainder, equality, and relational operators.

Use if-else with an else block to compare two integers x and y and print which is greater, illustrating max and min outputs.

Explore how Kotlin's if-else can be used as an expression that returns a value, including returning strings and storing results, versus printing.

Harness if-else conditionals to categorize temperatures into weather states, using nested else-if chains to print freezing, chilling, cold, pleasant, and hot.

Use Kotlin ranges to cut boilerplate when checking temperature values and determine if numbers fall within inclusive ranges like 5..9, 10..14, or 25..29.

Replace lengthy if-else chains with a when expression to improve readability and return values for temperature ranges, using when with a parameter to pass the temperature value.

Learn to implement for, while, and do-while loops in Kotlin using ranges, type inference, and print statements to repeat tasks efficiently.

Explore collections as groups of items, distinguish var and val for mutable versus immutable values, and work with immutable lists, indices, and methods like indexOf, contains, first, last, and joinToString.

Explore mutable lists and how they differ from immutable lists. Learn to add and remove items, and use a for loop to print each integer in the collection.

Explore map data structures with key-value pairs, distinguishing mutable and immutable maps, and access values by keys; learn keys are unique and maps support json and rest api workflows.

Learn to declare Kotlin functions with parameters, including signature and body, and return types. See get full name with two strings, single-expression bodies, and the fat arrow for concise returns.

Learn to use named arguments and optional parameters in Kotlin, with default values and flexible argument order, and how Kotlin handles optional parameters instead of Java-style overloading.

Explore anonymous and lambda expressions in Kotlin, assign functions to variables, and invoke via function references. Apply higher-order function concepts to Jetpack Compose text composables.

Explore a real lambda implementation in Kotlin by using forEach to iterate a list, pass anonymous functions, and chain map and filter to extract even numbers and transform results.

Explore Kotlin's null safety, converting non-null types to nullable with ?, use safe calls and the Elvis operator to avoid null pointer exceptions, and understand non-null assertions.

Create a Kotlin class with a primary constructor to store properties, name classes in Pascal case, instantiate objects, and compare references to observe separate memory locations.

Learn how a Kotlin class uses a primary constructor to declare properties with val or var and how init blocks assign constructor parameters to class members.

Create a shape class with private width and height and expose getters. Init block validates values with require and handles illegal argument exceptions to prevent app crashes.

Handle exceptions in Android Compose by using a try-catch block to catch illegal argument exceptions, print the exception message, and prevent the app from crashing.

Override the toString method in a Kotlin class to display a meaningful summary, such as name and id, instead of the memory address coming from Any.

Override the equals method in a subclass to customize object equality by id, using type checks and casting instead of memory address comparison.

Identify how Kotlin data class simplifies Android development by auto-generating toString, equals, hashCode, and copy, while modeling data and enabling safe object creation from existing instances.

Explore the dry principle in kotlin by using inheritance to share common properties for base and hourly salaried employees, while noting when composition or association may be preferable.

Demonstrates how to refactor salary calculation by moving a common method to a base class and overriding it in subclasses to compute total salary.

Define abstract methods by removing the body and using the abstract keyword, making the parent class abstract and uninstantiable; child classes override and access properties such as name and id.

Learn how Kotlin interfaces enable multiple inheritance, declare abstract methods and properties without state, and add features like allowances while honoring the open-closed principle.

Explore implementing singletons in Kotlin with object and companion object. See how to expose data like pi and use anonymous objects to override abstract methods, as with a database singleton.

Learn to install and configure the essential android development toolkit by using JetBrains Toolbox to install Android Studio, discover IntelliJ IDEA, add plugins, and set up the Android SDK.

Learn to install android studio via JetBrains toolbox, configure the android sdk location, accept licenses, and download platform tools, system image, and emulators for testing on real or virtual devices.

Open the virtual device manager, create an emulator with play store, download an api level 35 system image, and remember the emulator uses your pc's gpu, so choose lower resolution.

Create your first Android project by selecting an empty Jetpack Compose activity, configure the app name, unique package name, minimum SDK, and Kotlin DSL, then build in Android Studio.

Run your first Android app on an emulator by configuring Android Studio and using the Jetpack Compose template; learn how Gradle builds and installs the app.

learn how Jetpack Compose renders a text composable and a greeting function, and see how to update on-screen text while debugging with build and Logcat messages in Kotlin.

This lecture covers the starter Android project with a single main activity and setContent using composable functions to render hello world. It highlights the app structure and key files.

Learn how to define user interfaces with composable functions in Android app development; each composable function is annotated and returns unit, passes parameters, and renders UI via the compose library.

Discover how Android Studio's preview shows composable functions in real time without restarting the app, using preview annotations and parallel design and code panes to speed ui iteration.

Explore preview composable functions, understand how the preview pane shows partial screens, and create top-level composable functions annotated with @Composable to reduce duplication and drive setContent usage.

Learn how to change text size and color in Jetpack Compose using the text composable. Discover how SP units scale fonts and how to apply color values to style text.

Discover how to display an image with the image composable by importing a drawable resource, using painterResource and R.drawable, and adding content description for accessibility.

Learn how modifiers decorate Android composables, resize images with size and content scale crop, and pass modifiers from callers into custom composables to guide layout.

Master the layout composables in Jetpack Compose—column, row, and box—apply modifiers like weight, and use Lazy Column and Lazy Row with Material Design scaffold, app bar, and floating action button.

Create a new compose project and learn how the column composable organizes its children vertically, using vertical arrangement and horizontal alignment to control position, spacing, and centering.

Explore the row layout composable to arrange items horizontally, alongside icons and text, with modifiers, horizontal arrangement, and vertical alignment for centered, spaced, or nested layouts.

Master the box composable to stack children over each other, set content alignment (top start, center, bottom end), and use modifiers to place text, icons, or backgrounds over a screen.

Design a profile page layout using row, column, and box with image, text, and buttons. Split UI into composables for background image, circular avatar, header, divider, contact details, and actions.

Create a professional profile page in android compose, combining a cover background, circular bordered profile image, header and contact rows, dividers, and two call-to-action buttons, with portrait and landscape responsiveness.

Apply the weight modifier within row and column to distribute available space for a responsive layout in Jetpack Compose. Learn how weights control vertical or horizontal space.

Design a layout using the weight modifier on both row and column to equally distribute four colored boxes with centered color names across the screen.

Design a four-box 2x2 layout in Jetpack Compose using weight modifiers to divide screen space evenly, arranging boxes with rows and columns and centering text on colored surfaces.

Build a scrollable list of persons with lazy column, rendering each item via a person item composable that shows name and email from a simple data class.

Compare column and lazy column in Android Compose to understand when to use each; learn that column renders all items, while lazy column loads items on demand.

Explore material design as Google's design system, with material three as the latest version, and learn how Jetpack Compose applies its guidelines through scaffold to build consistent app layouts.

Explore how the scaffold composable builds a page with a top app bar, action buttons, and a floating action button, while configuring colors and top bar variants.

Explore how Jetpack Compose manages state declaratively with remember and mutableState to build dynamic UIs, driving from models and applying it in a photo gallery and BMI calculator.

Build a counter app in Android Studio using Compose, creating a new project, removing scaffold, and updating a counter with a button, while exploring previews and debugging basics.

Explore the declarative programming paradigm in Jetpack Compose by comparing it with the imperative approach, showing how composable functions render UI and how Compose handles updates automatically.

Discover how the compose framework uses a declarative UI with mutable state and remember to trigger efficient recomposition as state changes.

Create a simple photo gallery app in Android Compose that uses state and remember for recomposition, with a scaffolded user interface, next/previous navigation, and crossfade animation.

this BMI calculator app uses weight in kilograms and height in meters to compute body mass index (weight divided by height squared) and show health status ranges.

Build a BMI calculator page using a text field composable, scaffold, and state management with remember to capture weight input, label hints, and number keyboard options.

Create reusable text fields by extracting an edit number field composable for a bmi calculator. Learn state hoisting, passing value, label, keyboard options, and on value changed from outside.

Build a BMI calculator in android compose by creating weight and height inputs, computing BMI as weight divided by height squared, formatting to one decimal, and displaying the result.

Develop an Android Compose BMI calculator user interface by building a reference status table with ranges and a dynamic composable to display results and prepare for highlighting the matching row.

Finalize the BMI calculator app by highlighting the matching status row with color and bold text, and reveal BMI results only after calculation, including a top BMI icon.

Rotate the device triggers configuration changes that destroy and recreate the screen, causing state loss. Use remember Saveable to preserve state across orientation changes via a bundle.

Explore the Android activity lifecycle, from onCreate to onDestroy, including how orientation changes destroy and recreate screens, set content with Jetpack Compose, and manage states.

Explore the Android activity lifecycle by overriding lifecycle methods, logging state changes, and observing how rotation and navigation trigger onCreate, onStart, onResume, onPause, onStop, onRestart, and onDestroy.

Learn how a ViewModel serves as a screen-level state holder that caches and persists UI state through configuration changes, while separating UI from business logic for scalable apps.

Create your first view model to manage a counter app’s state with a mutable state and by delegation, inside a dedicated viewmodels package and Android X lifecycle.

Find and add the required external libraries, like lifecycle ViewModel compose, via Android Studio's project structure. Copy, search, and paste dependencies in the dependencies block or the version catalog.

Move all counter state and business logic into the CounterViewModel, access and update state through the view model, and demonstrate state persistence across configuration changes.

Move all BMI calculator states and logic into a BMI view model, enabling configuration-change survival, and use a companion object status map and calculate BMI logic for UI updates.

Learn to drive the user interface from a data model by refactoring BMI state into an immutable data class, using a view model and copy-based updates for reusable state management.

Understand the single source of truth principle that centralizes data changes in its owner, the BMI view model, with two APIs that update state while preserving immutable UI data.

Explore Kotlin coroutines to write concurrent, responsive apps by distinguishing synchronous and asynchronous code, using suspend functions, launch, async/await, and launchedEffect in Jetpack Compose, showcased with a timer app.

Explore concurrency by contrasting synchronous and asynchronous code with simple Kotlin examples. Understand how a main function executes lines in sequence and how IntelliJ IDEA and Kotlin playground aid learning.

Explore how the delay suspend function from Kotlin coroutines simulates a one second weather fetch and learn to call it inside a coroutine scope rather than the main function.

Explore how the runBlocking function blocks the main thread, provides a coroutine scope, and runs suspended functions inside a synchronous event loop to execute multiple tasks in Kotlin coroutines.

Explore calling multiple suspend functions within a coroutine, refactor code into suspend functions like print forecast and print temperature, and measure execution time to contrast synchronous runBlocking with concurrency.

Learn to use suspend functions and delay, and launch multiple coroutines to run tasks in parallel within a coroutine scope, reducing execution time and improving user experience.

Use the async and await pair to fetch forecast and temperature in parallel, returning deferred results from suspend functions and building a unified weather report.

Apply parallel decomposition to weather data by running forecast and temperature tasks in parallel with coroutines inside a coordinating scope, returning a combined report only after both complete.

Build a simple timer app in Android Studio using coroutines inside a composable, featuring a 10-second countdown, a launchedEffect coroutine scope, and play/pause controls with a progress bar.

Build a timer app UI in Android Studio with Jetpack Compose, featuring initial time state, remaining time, a circular progress indicator, formatted time display, and play, pause, and refresh controls.

Learn to build a timer in a composable using launchedEffect to run a coroutine, delay one second, and decrement the remaining time while updating progress.

Build a weather app that fetches live data from a REST API using Retrofit, parses JSON with data classes, and applies Hilt, coroutines, Flow, and the repository pattern.

Create a new Android Compose project, set package, sdk, and build settings, then add retrofit, converter, coil compose, and font dependencies with Kotlin and compose compiler updates.

Add the compose ViewModel dependency and organize the weather app into data, pages, custom ui, util, and network packages, creating weather home screen, ui state, and ViewModel.

Create an app background composable in Android compose by loading a drawable resource, applying a translucent blur, and displaying it behind the weather home screen using a box and scaffold.

Set up a custom font in Android Compose with a Google font provider, certificates, and Rajdhani font family for a weather app, then customize the app typography.

Explore weather data from OpenWeatherMap, including current conditions and five day forecast, using API keys, unit options, and retrofit to fetch and map JSON into Kotlin data classes.

Explore RESTful APIs and how URL-based requests fetch JSON data from a server, using GET, POST, PUT, and DELETE, with weather data examples and API as a bridge.

Install the json to kotlin class plugin in android studio to convert json into kotlin data classes, then build current weather and forecast models mapped by retrofit.

Configure retrofit with a base url and two end points for current and forecast weather, then define a weather api service with suspend get methods and lazy retrofit initialization.

Explore the three-layer Android architecture—user interface layer, data layer, and an optional domain layer—and see how view models and repositories enable unidirectional data flow and clean data exposure.

Define a weather repository interface with get current weather and get forecast weather. Each method accepts a dynamic end URL and is implemented by a weather repository impl using retrofit.

Learn to implement a view model that calls a repository to fetch current and forecast weather data using suspend functions and a view model scope, with error handling.

Model a weather data class and user interface states in an Android Compose app. Use a sealed interface to manage loading, success, and error states for current and forecast weather.

Propagate exceptions from a failing data fetch through a coroutine exception handler to a launch block, then update UI state to show an error when fetching current weather data.

Design and implement a weather home screen in Jetpack Compose, splitting the UI into current and forecast sections, and display city, country, and a formatted date.

Fix the type mismatch by converting integers and doubles to the number type and repair the weather typography file to render fonts and display temperature, wind speed, icon, and description.

Display the current temperature with a degree symbol and a feels-like value, and load a weather icon from a network link using coil, plus the description.

finalizes the current weather section by building a row with a vertical divider and two columns showing humidity, pressure (hpa), wind, and sunrise and sunset.

Create a forecast weather section as a composable, pass forecast items to a lazy row in the weather section, and render each item with weekday, time, icon, and temperature.

Enable dynamic weather data by integrating the Play Location Service dependency to fetch the user's device location and update latitude and longitude in the app, while handling runtime permissions.

Master runtime location permissions in an Android compose app using manifest entries for coarse and fine location, a launcher for permission requests, and fused location provider to fetch weather data.

Explore how an Android Compose app requests approximate location permission, uses the while using this app option to enable location-based weather data, and handles emulator versus real device behavior.

Learn to handle internet outages in a connectivity-reliant app by checking the device network state, showing a clear no-internet message, and observing state changes to update the user interface.

Create a connectivity repository that exposes a connectivity state via state flow, using a mutable state flow behind a private variable and a network callback to toggle available and unavailable.

Integrate a connectivity repository in the weather home view model and observe its state flow to report available or unavailable internet.

Implement a ViewModel factory to instantiate Weather Home ViewModel with connectivity awareness, handle no internet with an error state, and provide a refresh button to reload data.

Explore dependency injection, including constructor and field injection, and learn how dagger and hilt support Android apps for easier testing, refactoring, and reusability.

Add hilt dependencies and plugins to an android project, configure kapt for hilt android compiler, and sync gradle files to enable dependency injection in the app.

Learn to enable Hilt in your Android app, create a Hilt application class, and inject dependencies into view models and repositories via constructor injection, replacing manual instantiation.

Create a Hilt module installed in singleton component to provide Retrofit client, Weather API service, connectivity manager, and repositories for clean dependency injection.

Learn how to handle location permission and last cached location in Android apps, manage off switch scenarios, and prompt users to enable and request a fresh location.

Modify the weather app's main activity to manage precise location permissions and settings using compose states, launchers, and a location request.

Modify the launch effect to trigger when location is enabled, fetch a fresh location with get current location using high accuracy, and use the coordinates to fetch weather data.

Explore the Room persistence library in Jetpack Compose to build a shopping list app, using Hilt for dependency injection, implement CRUD operations, complex queries, and navigation with dynamic composables.

Create a new Android project and add Room dependencies—Room runtime, Room compiler, and Room extension—using Kotlin 2.0.20 and KSP instead of Kapt for faster code generation.

Add the hilt dependency and the dagger hilt android plugin, set the hilt compiler version to 2.52 via KSP, and update both project and app Gradle files.

Add Navigation Compose and Kotlin serialization dependencies to enable multi-screen navigation and JSON handling in Android Compose apps. Integrate Hilt for navigation and view models to streamline dependency injection.

Create a robust Android app structure by adding a hilt-enabled application class, annotating it, configuring the manifest, and organizing UI packages for home, add event, and event details with navigation.

build a reusable shopping app bar in a custom composables package that accepts a title, an optional back button, and a navigate up callback, rendered as a top app bar.

Create three composable pages - home, add event, and event details - using a scaffold with a top bar, text placeholders, and navigation hooks for back and navigate up.

Explore navigation in a shopping app using a nav controller and nav host, build a nav graph with start destination, and declare composable destinations with route aliases.

Define route objects for each destination using serializable routes and replace hard-coded strings with navigation in Android compose, creating home, add event, and event details routes and enabling navigation.

Navigate from the home page to the add event page with a floating action button, using a top-level nav controller and a callback to trigger route changes.

Define two Kotlin data classes for shopping events and items, with id, name, initial budget, total cost, date, and completion status, linking items to events via eventId.

Create add event ui states with addEventDetails and addEventUIState, set defaults like totalCost 0.0, and implement addEventViewModel with mutableStateOf and input validation to enable save.

Learn to build add event page in Android compose essentials with name and budget fields, a date picker, and a save action gated by input validation.

Implement a date picker dialog in an Android compose add-event form by managing open state and date picker state, wiring confirm and cancel actions, and displaying the formatted date.

Build a save button on the add event page, validate name and date, convert details to a shopping event via an extension function, and persist to a Room SQLite database.

Learn to build a local persistent database in Android with SQLite and the Room library, covering Room database, data access object, entities, and relational tables with primary and foreign keys.

Define entities for a room database by annotating data classes, turning them into tables, and configuring primary keys, column names, and ignores to control the schema.

Learn how entities map to tables and how DAOs and Room enable insert, update, delete, and query for shopping events and items, with plural table naming and migration.

Create daos for shopping event and shopping item entities, annotate with the Dao annotation, and define suspend insert, update, and delete methods; return a flow for all events.

Annotate a room database class with two entities, shopping event and shopping item, set version, extend RoomDatabase as abstract, and implement a singleton via companion object with getDatabase(context) using Room.databaseBuilder.

Create and implement repositories for shopping event and shopping item to bridge the UI and data layers, injecting DAOs, exposing insert, update, delete, and get operations, with future ViewModel integration.

Inject the shopping event repository into the add event view model with hilt, convert the UI state to a shopping event, and save it to the database.

Run the app on an emulator or device, open Android Studio's app inspection database inspector, and view the shopping events table with id, name, event date, and completion status.

Fetch all shopping events on app launch and display them on the home page using a home view model. Manage ui state with a flow and a lazy column.

Showcases building home page with a view model, collect as state, and a lazy column to display events, with empty-state handling and list items showing name, date, and total cost.

Tap a home page event to navigate to its details page, passing the event id and name, with a type-safe route using a data class to fetch linked items.

Extract event id and name in the event details view model using saved state handle, retrieving the details route from a map and injecting repositories to query and manage items.

Define event details UI state and item states with Kotlin data classes and a state flow in the event details view model, preparing to fetch data and display items.

Add new items to a shopping event with Android Compose, using a floating action button to create items, save them to the item table, and enable editing and live updates.

Learn how SQL joins connect related tables to show combined data, covering inner, left, right, and full outer joins, with primary and foreign keys guiding relationships.

Learn to write a left join query in a room database dao to fetch an event with its items, calculate total cost via sum(price*quantity), and return a map.

Learn to run a join query returning a map of shopping events to items, and convert results into add event details and item details for the event details page.

Populate the event details page using an empty state, extract and reuse the empty list composable, and build a shopping item list with a header, lazy column, and item details.

Add a fixed bottom spacer to the lazy list to keep the last item visible under the floating action button, and animate scrolling to the last item on updates.

Build an editable list item in Android compose by adding an edit button to switch the item into edit mode with name, quantity, and price fields.

Show how to toggle list items between a plain view and an editable form with a dedicated single item view, driven by item UI state and an edit mode flag.

Wire on value change to update item details in the UI state, replace the item by id in the list, and persist changes via repository and dao on save.

Update a shopping item in an Android compose app by wiring on item update callbacks and converting item details to a shopping item entity, with a flow-driven UI refresh.

Modify the shopping events query to calculate each event's total cost by summing item price times quantity from the items table, joining events with items, and grouping by event.

Design a dismissible list item in Jetpack Compose with a DismissibleItem that enables swipe-to-dismiss right-to-left to delete after a confirmation dialog, while edit mode prevents swiping.

Create a swipe to dismiss box UI in android compose essentials, integrating an alert dialog to confirm deleting the item with confirm and cancel actions.

Swipe to delete items by wiring an on delete callback from the dismissible item to the view model, which deletes the item from the database via the repository.

Learn how deleting an event automatically removes related items by configuring a foreign key with on delete cascade in Room, avoiding orphaned items.

Build a dynamic AI-powered quiz master app with Jetpack Compose, generating questions by type and difficulty, with Firebase Authentication, Cloud Firestore, AI-based logic, and navigation tree support for modern Compose.

Create a Firebase project for your Android app, register the Android package, and download google-services.json. Add authentication, Cloud Firestore, and Firebase AI logic dependencies, then sync.

Enable email and password authentication in a Firebase project, create a user from the dashboard, and use the generated UID to associate data in the database.

Observe the auth state flow in AuthViewModel and derive the current user, then navigate to login or home after a 1-second delay. Introduce navigation tree for Jetpack Compose.

Learn to fix Firebase authentication flow by awaiting sign-in and create-user tasks, manage loading indicators, and validate login and registration across the app's home and quiz screens.

In Android Compose, build a quiz main screen driven by a view model with AI-generated questions, supporting idle, loading, success, error, and personality evaluation states.

Learn to display all quiz questions with options on the quiz main screen using a lazy column, indexed items, and a reusable question item with radio buttons to capture selections.

Create a saved quiz result data class with a document id and implement a Firestore service with a suspend saveQuizResult to store results in the quiz_results collection via hilt.

Run the app and save quiz results to firestore, exploring quiz types, scores, timestamps, and user data stored under the quiz results collection for the dashboard.

Define a getQuizResults function returning a flow of quiz results for a user, using Firestore snapshots to stream from the quiz results collection, filtered by user id and timestamp descending.

Build the MyQuiz screen by wiring MyQuizViewModel, implementing onBack navigation, and rendering UI states with scaffold, top app bar, and a lazy column of quizzes.

Create a quiz history item composable to display saved quizzes in a list, format timestamps to dates, show quiz type, difficulty, and score, and open a personality-evolution dialogue on click.

Change model configuration parameters to generate varied quiz questions in Android compose apps, and fetch Firebase Firestore questions to avoid repeats while tuning temperature and max tokens.