Android App Development with Kotlin & Jetpack Compose

Create a new android studio project for phone and tablet with an empty activity, name compose demo, set minimum sdk 24 and kotlin dsl, then finish to generate files.

Explain how composable functions emit UI elements in Jetpack Compose, and how setContent connects an activity to the Compose UI.

Learn to use Jetpack Compose previews in Android Studio to view composables instantly without launching apps, test light and dark modes, multiple device configurations, and group or customize previews.

Explore how to customize text with the text composable in Jetpack Compose, arrange texts vertically with a column, and use strings.xml for localization and consistency.

Style text by applying text style, colors from resources, and typography to ensure consistent appearance across the app. Use column layout with modifiers and alignment to position content effectively.

Jetpack Compose uses recomposition to update only affected UI when state changes. Remember and mutableStateOf manage state across recompositions, illustrated by an interactive counter example.

Design a pet card layout by combining a row, a column, and a box, using modifiers to style a card showing the pet’s name, last fed time, image, and checkbox.

Design a pet card by clipping the image into a circle, using content scale crop, and layering a status icon in a box, arranged in a row with padding.

Learn to use the scaffold layout to structure an Android screen with a top bar, bottom bar, floating action button, and content, including a hamburger drawer and action buttons.

Learn to build a bottom navigation bar with three items in a pets app using a navigation bar composable, managing selected state with remember and mutable state across recompositions.

Level up your ui beyond the compose basics with complex dynamic layouts, including modal drawers for elegant navigation and lazy lists for long data with high performance.

Learn to implement a modal navigation drawer in Jetpack Compose using material three, control its open state with a draw state, and define drawer content and UI preview.

Create navigation drawer items (home, profile, settings) in a modal drawer sheet, wire on-click actions, and separate draw content for reusable scaffold integration.

Link the top bar navigation icon to a modal drawer by passing an on menu click lambda through the scaffold, and manage drawer state with a coroutine scope.

Explore building dynamic lists with lazy column and lazy row in Jetpack Compose by displaying departments and their tools, enabling vertical and horizontal scrolling with efficient rendering.

Master asynchronous programming with Kotlin coroutines and flows to keep apps responsive during network requests and database queries, running tasks in the background without freezing UI for robust, high-performance applications.

Create a coroutine scope and launch a suspend function to run tasks on a background thread without blocking the main thread, observe thread names with delays and default dispatcher workers.

Explore Kotlin flows as a reactive, asynchronous data stream powered by coroutines. Create cold flows with flow builders, emit values, and use map, filter, collect to transform and consume data.

Build focus notes, a Kotlin and Jetpack Compose based note taking app, with writing, editing, and persistent local storage, while exploring state management, MVVM, Room, StateFlow, and navigation.

Build small components first, then assemble them into larger screens using a bottom-up approach, enabling reusable note items and app drawer navigation in Jetpack Compose.

Create a note item card and an add note floating action button using material three, with list item slots for headline, supporting content, and trailing date.

Learn the notes list component that uses a lazy column to display notes, shows a no notes yet state, and contrasts hard-coded data with database-backed notes for real apps.

Compose the notes list screen by combining the top app bar, the floating action button, and notes list into a scaffold, applying content padding to prevent overlap and support theming.

Design the app drawer with a modular draw header and draw body in Jetpack Compose, using reusable draw item components and a header row with an icon button.

Pass a drawer state from the Focus Notes app to the notes list screen and top app bar, then open and close with a coroutine in a reusable composable flow.

Set up navigation in jetpack compose with the navigation library and controller. Define a nav host with start destination notes_list and composable destinations for notes list and add note.

Learn to wire the floating action button to navigate from the notes list to the add note screen using lambdas and a nav controller, defining on click callbacks.

Learn how Room sits on top of SQLite to simplify local storage by defining Kotlin entities and DAOs, enabling easy save, update, and retrieval of notes.

Define a local node entity for the nodes table with primary key id, title, content, created at, updated at, and configure a room database with a dao and type converters.

Adopt a layered mvvm architecture by separating ui, domain logic, and data access, and inject dependencies to avoid calling a dao directly from composables.

Learn how view models separate user interface from business logic, endure configuration changes like screen rotations, and apply best practices for clean, testable Android architecture.

Apply the single responsibility principle by moving data handling and validation out of composables, using a lifecycle-aware ViewModel between UI and data layer to manage state and separate concerns.

Explore the repository pattern as a single access point for local dao/room and remote data sources, decoupling the view model and enabling domain layer use cases.

A clean, layered architecture separates the UI, ViewModel, and repository; the UI renders notes and emits events, while the ViewModel manages state and delegates data tasks through the repository.

Learn unidirectional data flow in Jetpack Compose: the UI sends events to the ViewModel, which updates a single source of truth via StateFlow, and the UI observes state to recompose.

Implement the dao layer by adding remote and local data sources, creating a data-layer repository, and using room with suspend functions and flow to observe notes.

Explore dependency injection with Hilt, decouple the order service from payment implementations, and see how Hilt injects view models, repositories, and APIs with lifecycle management.

Configure Hilt in an Android app using Kotlin and Jetpack Compose by adding libraries, annotating the application and entry point, and providing the node Dao via a data module.

Explore retrofit basics for API integration, including setting up a network data source and mapping local room entities to domain nodes with extension functions.

Define a retrofit notes api service with suspend get and post operations, deserializing json to network node objects, and inject into the repository via Hilt.

Dive into ViewModel and advanced state handling in Jetpack Compose, mastering patterns for managing complex user interface states, user interactions, and data consistency to build highly interactive experiences.

Examine the Focus Notes app structure, create a notes view model and UI state to separate screen data from UI, and wire a repository with Hilt for data sources.

Expose view model state via a private mutable state flow and a read-only state flow, enabling unidirectional data flow to the screen and observe via collect as state with lifecycle.

Expose note screen events as lambdas in the view model, enabling on add note, on note click, and on toggle star to a decoupled UI and notes from the repository.

Learn how state hoisting turns a stateful composable into a stateless one by moving the state to the caller and replacing it with the current value and events.

See how saving a note updates the room database and, via flow to the view model, automatically refreshes the notes list with the latest content.

Build a notes app using Kotlin, Jetpack Compose, MVVM, Room, Retrofit, Coroutines, and Hilt; learn local databases, async code, and API connections with ideas for cloud sync and search.