Kotlin and Android Jetpack Compose masterclass

Master Kotlin foundations from variables to object oriented concepts, and practice flow control, functions, lambdas, and loops to build basic foundational programming algorithms for Android development.

Install Java and IntelliJ IDEA to set up a Kotlin environment, then write a hello world program using a main function and println to run and print hello world.

Explore Kotlin basics through a hello world example, then master single and multi-line comments, why the compiler ignores them, and how to toggle comments with keyboard shortcuts.

Customize your ide theme in IntelliJ Idea, choosing between dark and light options. Prefer Dracula as the dark theme for long development sessions to ease eye strain.

Learn how Kotlin variables serve as data containers, use var for mutable values and val for immutable ones, and follow naming conventions like camelCase to write readable code.

Master strings in Kotlin by defining text with double quotes, escaping quotes and backslashes, using templates with dollar expressions, concatenation, and common string operations like length, uppercase, lowercase, and trim.

Explore drawing a text bunny with variables and strings in Kotlin, using escape sequences to handle backslashes and quotes, and printing multiple lines.

Explore primitive data types in Kotlin, including strings, booleans, and numbers. Learn implicit and explicit typing, and how to use byte, short, int, long, float, and double.

Learn how to convert between Kotlin types using toLong, toInt, and toString, with examples that show the original variable remains unchanged and the converted result becomes a new variable.

Master arithmetic operations in Kotlin, including addition, subtraction, multiplication, division, modulus, and increment and decrement; learn how results take the largest operand, and how augmented assignment operators work with strings.

Explore arithmetic operations in kotlin by calculating the amount after five years with a 5.5% annual rate and printing the result.

Explore Kotlin booleans and logical operators (and, or, not) along with comparison operators (>, <, >=, <=, ==, !=) to build conditional expressions, including teen checks.

Apply logical operators in Kotlin to determine funding eligibility using conditions: no more than five animals, at least one producer, and a three-or-more family members, illustrated with cows and children.

Master Kotlin nullability by learning how nullable variables work, the safe call operator, Elvis operator, and not-null assertions to prevent crashes and interoperate with Java.

Learn how exceptions represent unexpected events that can crash programs. Use try, catch, and finally to handle them, inspect stack traces, and throw exceptions in Kotlin.

Explore Kotlin lists and array lists, learning the difference between immutable and mutable collections, how to index elements, handle duplicates, and perform add, remove, and add all operations.

In Kotlin, build an array list of items, remove a defined removed-items list with removeAll, and print the remaining items (laptop and mouse) to show desk cleanup.

Explore Kotlin sets and hash sets, learning how sets store unique elements with no fixed order, allow a null, and how mutable hash sets enable add, remove, and map transformations.

Add a joining customer to a hash set of customers, print the updated list, then remove a leaving customer and print the final set, showing that order is not important.

Explore maps as key–value structures with unique keys and unordered values. Create maps, access values by key, and use hash maps for mutable add, replace, and remove operations.

Add 26 September to the attendance hash map, then compute the total for 25 and 26 and print whether data for 22 September is available.

Explore flow control in Kotlin by mastering the if statement, including true/false branches, else handling, and shorthand forms; learn nesting and returning values in expressions.

Learn to implement the if conditional in Kotlin for Android Jetpack Compose, modeling a market scenario with has eggs and has bacon, and computing totals from price variables.

Explore the when conditional in Kotlin, which handles expressions with multiple branches and a default case. Learn returning values from a when block and mapping months to days.

Master the Kotlin when conditional by categorizing the first letter of a name into three groups (a–c, d–f, rest) using lowercase for consistency and printing tailored greetings for each group.

Master for loops in Kotlin by iterating collections and ranges with iterators, applying actions to each element, and using nested loops to print a matrix.

Use a for loop to iterate months, compute each month's days, and determine February as 28 or 29 days by year mod 4, with examples for 2004 and 2005.

Explore while loops and do while loops, including how the former checks conditions during execution and the latter after execution, illustrated by a 20-piece puzzle.

Learn Kotlin while loops solution that prints values below a large number that are multiples of seven by iterating a counter and printing when i is a multiple of seven.

Learn how break and continue control Kotlin loops: break terminates a loop when a condition fails, while continue skips the current element and proceeds with the rest of the sequence.

This lecture introduces Kotlin functions, covering defining with fun, calling zero or more times, parameters with defaults and named parameters, and returning values with optional single line syntax and overloading.

Learn to implement a Kotlin function that takes a circle radius, computes the area using pi, and prints the result by calling it three times with different radii.

Master function overloading in Kotlin, using the same name with different parameters, plus varargs and default values. Explore local functions and scope with nested functions and data retrieval examples.

Learn how to use Kotlin lambdas as anonymous functions and apply higher order functions like for each, map, filter, and sorted by length to write flexible, readable code.

Explore object oriented programming by defining classes with properties and methods, creating objects from a class, and using inheritance to extend and customize behavior in Kotlin.

Explore Kotlin class concepts, including constructors with multiple overloads, default and parameterized instantiation, getters and setters, the this keyword, init blocks, and companion objects for static access.

Demonstrates a Kotlin calculator class with total state and add, subtract, multiply, divide, and reset methods, plus console prints in a main function.

Explore the four principles of object oriented programming, inheritance, encapsulation, abstraction, and polymorphism, and learn how they guide clean, scalable, and maintainable code structure.

Learn how interfaces define what a class can do, enabling encapsulation and access through an interface, with practical Kotlin examples of implementing and overriding methods.

Implement a coffee interface with wake up and quench thirst, then build arabica and robusta classes that implement it. A coffee shop supplies either type, showing the power of interfaces.

Learn Kotlin's standard scope functions (let, with, run, apply, and also) and takeIf and takeUnless, exploring how they create temporary scopes, access objects, and return results.

Explore five Kotlin class types—abstract, data, enum, sealed, and nested. Understand abstract class versus interface behavior, data class data storage, and inner-outer class interactions.

Learn how to extend existing code with Kotlin extensions, adding functions, properties, and companion object members to third-party or non-modifiable classes, using practical string and class examples.

Create packages and subpackages to structure code and place the package on the first line. Declare the package at the top of each file and follow lowercase, dot-separated naming.

Explore how Kotlin generics provide a type parameter to classes, enabling a box to handle strings or integers, and how fruit two constrains generics in a chef that peels apples.

Demonstrate generics by implementing a Kotlin generic class with type T and a print function that uses toString, then instantiate with a float and a string-to-int map to print messages.

Master Kotlin type checks with is and is not, the as operator, and null-safe as operator, plus lateinit and lazy initialization illustrated via car and BMW examples.

Explore Kotlin code routines in Android by learning how to run code on a background thread, avoid blocking main thread, and use suspend functions, builders, and jobs to produce outputs.

Explore Kotlin coroutines as a lightweight alternative to threads, utilizing thread pools to run many coroutines in parallel, with simple launch, delay, and pause controls.

Explore core concepts of coroutines: scope and context, global and custom scopes, with Android components. Understand dispatchers such as main, io, and default and how runBlocking affects execution.

Understand suspend functions as a simple, central concept for core routines; they pause and resume execution, and are designed to run from co routines with the suspend keyword.

Explore Kotlin coroutines, including launch and async, within a dedicated code scope, and learn how supervisor scope, run blocking, and awaiting deferred values manage parallel tasks.

Explore how coroutines use jobs to manage execution, creating a parent and child hierarchy and controlling lifecycle, cancellation, and results with join, async, and delay.

Learn to launch 1 million coroutines that print dots to the console, demonstrating how lightweight coroutines are compared to threads and showcasing their practical use in Kotlin.

Explore a Kotlin-based approach to generate all prime numbers below a given limit by testing divisors, optimizing to skip even numbers, and printing primes using a suspend check prime function.

Install the Android system and the editor across Mac, Linux, or Windows, then create a simple Hello World app to verify the setup and establish a foundation for later sections.

Install Java and Android Studio to set up your Android development environment for the Kotlin and Android Jetpack Compose masterclass; verify Java with a version check, then install Android Studio.

Create your first Android app in Android Studio using an empty compose activity, and explore the project structure, Kotlin language focus, and running on an emulator or a real device.

Explore the foundational topics of Jetpack Compose and how it reshapes Android development. Learn about composables, recomposition, state, and state hoisting to build robust, efficient apps.

Explore Jetpack Compose by building a simple click counter app that uses composable functions, column layout, and state management with remember, mutableStateOf, and state hoisting, with recomposition.

Explore composable functions in Jetpack Compose, a declarative Kotlin approach replacing XML imperatives with a tree of composables like Column, Button, and Text.

Recomposition redraws a composable only when its input changes, propagating updates up the tree for efficient screen rendering. Keep side effects in check, and ensure lightweight, fast work on mobile.

Explore how state stores values in a composable and triggers recomposition, using mutable state, remember, and different patterns like by and set counter for a counter.

Hoist state from a composable into the color, decoupling components, enabling reuse across the app, and simplifying testing.

Explore visual elements such as text, buttons, and image display, and learn to organize and build UI with sizing and theming. Practice scrolling, tapping, and side effects through hands-on exercises.

Explore how modifiers in Jetpack Compose control appearance, behavior, and layout, using clickable interactions, background color, padding, and the critical note that modifier order shapes the UI.

Address a common crash by avoiding emulators with the play store button. Test on a real device or create an emulator without this button to prevent System UI isn't responding.

Explore how column, row, and box layouts in Jetpack Compose arrange elements vertically, horizontally, and stacked, using alignment and arrangement controls like center, start, and space between.

Learn to size elements in Jetpack Compose using absolute width and height, fill max width or size, and weights, plus aspect ratio and spacers, with dp and sp units.

In this Kotlin and Android Jetpack Compose masterclass, learn to build a vertical UI with columns, rows, and boxes, using modifiers, alignments, and colors, focusing on structure over exact sizes.

Explore text and text field usage in Jetpack Compose, using string resources, state, and keyboard options to support localization and dynamic user input.

Explore how Jetpack Compose redefines theming with Kotlin-based colors, shapes, and typography in light and dark palettes, guided by Material Design principles.

Learn to display images in Jetpack Compose using bundled images, vector assets, and online images with the coil library, including painterResource, contentScale, color filter, and internet permission.

Explore toast messages, a simple Android pop-up notification (not part of Jetpack), built with a context, and set to short or long durations to show action outcomes in your app.

Master buttons in Jetpack Compose by defining content and on click, showing a toast with context, and customizing with shapes, colors, and optional icons, all centered in a column.

Build a profile-like layout with Jetpack Compose. Arrange a circular profile image with four stat columns, an info section with username and description, and a two-row posts grid.

Explore lazy lists in Jetpack Compose, including lazy column, lazy row, and experimental grids, to load only on-screen items and save memory.

Learn how to convert a long column into a vertical scrollable area in Jetpack Compose, using rememberScrollState and modifier.verticalScroll, with options for horizontal scrolling.

Explore how to make any composable clickable with the clickable modifier, then detect taps, double taps, and long presses using pointer input, and display tap coordinates.

Explore dragging a red box on screen by capturing pointer input and updating a two-axis offset state with drag gestures in Jetpack Compose.

Explore how progress indicators convey background activity to users, using linear and circular composables in jetpack compose with progress percentages such as 60% and 80%.

Explore how to implement a customizable alert dialog in Jetpack Compose, including title, content, confirmation and dismiss buttons, and onDismissRequest handling.

Learn how side effects enable one-time events in composables, using launch effect to run background tasks, display progress, and show a toast once the task completes.

learn to build a list of dog breed cards in Kotlin using Jetpack Compose, including a data class, a get dogs function, and a lazy column with image and text.

Build a tic tac toe game in kotlin and jetpack compose to practice development, including drawing the board with composables, handling moves for user and AI, and detecting game over.

Build a tic tac toe in Kotlin and Jetpack Compose with a header showing whose turn it is and a board driven by a mutable state list of moves.

Build a tic tac toe board in jetpack compose by structuring a header and 3x3 grid, using X and O vector assets, and rendering moves in a composable.

Implement player moves by detecting taps on the game board, calculating grid coordinates from tap offsets, updating the moves, and switching turns to reflect the new state.

Implement an AI move in a tic tac toe game using a random empty position, add a background pause and a red circular progress indicator to show thinking.

Learn to implement an endgame checker for a 3x3 grid game in Kotlin, including horizontal, vertical, and diagonal win detection, draw evaluation, and UI messaging for win or draw.

Add a reset button labeled 'click to start over' that restarts the game by setting player turn to true, clearing the win state, and resetting the board moves to null.

Explore scaffolds and their slots in Jetpack Compose, implement top app bar, bottom app bar, bottom sheets, floating action buttons, and snack bars, and plan a project app while noting navigation topics.

Explore how the scaffold composable provides slots for common Android UI elements—top bar, bottom bar, drawers, floating action button, snack bar, and bottom sheet—for quick layouts.

Learn to display icons in Jetpack Compose using painter resources and vector drawables, explore material icons in filled, outline, and other styles, and use icon buttons for actions.

Create a versatile top app bar in Jetpack Compose featuring a title, navigation icon (up or drawer), actions, and a dropdown menu, with state management and toast feedback.

Explore how to implement a bottom app bar in Jetpack Compose, contrast it with bottom navigation, and build a selectable icon row with tint changes to filter content.

Learn to implement bottom sheets in Jetpack Compose using the bottom sheet scaffold, with non blocking main thread behavior, peek support, and expand and collapse control via sheet state.

Discover a floating action button that hovers over a layout to deliver screen’s most common action, with center bottom or center right placement and docking to a bottom app bar.

Explore how to implement snack bars in Jetpack Compose, including actions, custom layouts, and duration options with scaffold state and a fab-triggered pop-up.

Create a visited cities app in Kotlin and Jetpack Compose that displays cities with countries, allows adding and alphabetically sorting, and demonstrates state hoisting.

Build a cities list app in Kotlin with Jetpack Compose, featuring a scaffold, a floating action button, and a dialog to add cities to a live updating list.

Implement a top app bar with a sort action to alphabetically sort the cities list in a Jetpack Compose app, using hoisted state and a sort toggle.

Explore navigation in Jetpack Compose, moving between screens and managing the back stack with dynamic arguments. Master bottom and drawer navigation and deep links to improve app flow.

Jetpack navigation defines destinations and paths between composables, enabling a navigation graph and deep links, with a nav controller and nav host to move between screens.

Build a three-screen Jetpack Compose app with a home screen that navigates to feed and profile screens using a navigation host and nav controller, illustrating back stack and transitions.

Master the Jetpack back stack: navigate between home, feed, and profile, manage history with pop back stack, and centralize routes using sealed destinations for clear navigation.

Learn to pass static and dynamic parameters through navigation in a Kotlin and Android Jetpack Compose app, using nav controller and routes for list and detail screens with user IDs.

Implement bottom navigation inside a scaffold with a bottom bar and a nav host, navigate between home, feed, and profile screens via the nav controller.

Explore Android's navigation drawer pattern with Jetpack Compose, implementing a scaffold with a drawer, header and body content, and navigation via a nav controller to home, feed, and profile.

Learn how deep links intercept external URLs to navigate directly to a composable. Define URI patterns with schemes and hosts and update the Android manifest to support them.