Android Compose Essentials - Build Android Apps like a Pro

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.

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.

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 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 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.

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.

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.

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.

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 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.

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.

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.

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.

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.

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.

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 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.

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.

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.

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.

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.

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 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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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 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.

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.

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.

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 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.

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.

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