Jetpack Compose Modern App development using latest tech

Create a from-scratch Android project in Android Studio, configure Gradle with copy-paste libraries, and learn how to retrieve and place Marvel API keys.

Set up a new empty compose activity project in Android Studio, configure module Gradle with library versions and dependencies, apply Kotlin, kapt, and Hilt, then sync.

Learn to create and manage Marvel api keys, including public and private keys, from the Marvel portal, store them in properties file, and expose them in build config for authentication.

Get a high-level view of navigation in Jetpack Compose, set up a navigation host, and build dummy screens with a bottom navigation bar to switch between screens.

Explore how Jetpack Compose navigation uses a nav controller and a nav host to move between screens, manage the back stack, and pass arguments.

Create dummy composable screens: library, collection, and character detail, to prototype navigation and display API results within an MDM architecture and prepare for bottom navigation in the next video.

Learn to set up navigation in Jetpack Compose by defining a sealed destination with library, collection, and character detail routes, using a NavHost and a scaffold with a start destination.

Create vector assets for the bottom navigation bar by adding library and collection icons, labeling them library and collection, and previewing them in the asset panel.

Create a bottom navigation bar in Jetpack Compose with nav host controller, applying five dpi elevation and enabling library and collection navigation via pop up to and launch single top.

Explore retrofit and hilt fundamentals, set up a network service and manifest, and implement a clean separation between the API client and the view model before actual data retrieval.

Explore retrofit, defining an API interface for a get request to characters, using a name starts with query parameter, and building retrofit service with base URL and a JSON converter.

Explain using health in an app with the Health Android app annotation, Android entry point, ADD module annotation, and injecting the Marvel API repo into the view model.

Implement API communication by adding a characters API response model and a Retrofit get request for the characters endpoint with a name starts with query, producing a characters data set.

Define the Marvel api service layer with retrofit and an interceptor that appends ts, api key, and MD5 hash to requests.

Create a network result with initial, loading, success, and error states, and expose it via a Marvel api repo that uses Kotlin flows to fetch characters.

Create a comics application class as the health entry point and configure the Android manifest with internet, network state, and clear text traffic permissions for the Hilt Android app.

Add a health module with Hilt by defining a module, installIn, and a provides function for the Marvel API repo, enabling injection into the view module and future view models.

Define a view model and update the UI to perform network communication and health checks, retrieve data, and display characters on screen based on search criteria.

Create a library view model wired to a backend API via hilt and a repository, exposing a debounced, two-character query flow for the ui display.

Create a library UI in Jetpack Compose that displays characters from a backend API using a nav controller, view model, and a query field, with images, titles, descriptions, and attribution.

Define the character data type, create a DAO to translate between app and database, and set up the database, then update Hilt for injection and review the overview before coding.

Learn to implement a room database by defining an entity and table, a data access object for queries, and exposing characters via a repository with hilt and a view model.

Define a db character entity and constants, map from character results to the database, and convert comics and thumbnail path and extension into strings with a list extension.

Define a character dao annotated with @Dao, exposing queries to fetch all characters and a single character by id, and provide insert, update, and delete operations using flow.

Set up the Comics DB room database with entity DBCharacter and version one. Export schema false and implement a repo and dao to access characters via flows.

Update Hilt in the health module by providing collection DB, context, and character DAO, build the Room database, and expose a collection DB repo implementation to manage data.

Implement a character detail screen in Jetpack Compose to view a single character and add it to a local collection via a collection view model and local database.

Build a detail screen by updating the API repo and retrieving a single character by ID. Use a view model and mutable state to supply character details to the UI.

This lecture guides building a character detail screen in Jetpack Compose, displaying image, title, comics, and description, with an add-to-collection button and navigation handling.

Create a collection db view model to manage database interactions for the detail and collection screens, including current character, collection state, and conversion from character results to db characters.

Update the character detail screen UI by integrating the collection view model, tracking current character and in-collection status, and toggling add/check button, with IO dispatcher database writes.

Implement the collection screen in a Jetpack Compose app, displaying characters in a lazy column with images and names, plus delete actions and expand/collapse capability.

Update the database to store nodes locally, then wire the view model to manage these nodes, and finally present a user interface form to add nodes to specific characters.

Create a Kotlin node data class and a Room database entity, define constants, and implement a from node converter to map title, text, and character id for storage.

Define a note dao interface annotated with @Dao. Query all nodes and by character ID, and insert (onConflict ignore), update, delete, and delete all by character ID with Kotlin Flow.

Implement a collection database for nodes by adding node dao, db node, and repo methods (get all nodes, add, update, delete), and update the health module to provide node dao.

Update the view model to manage notes via get notes, add note, and delete note, using the IO dispatcher, and ensure deleting a character removes its related notes.

Update the collection screen UI by displaying filtered nodes for a character, using the KVM to manage state, and providing a create node form and delete actions within Jetpack Compose.

Implement a singleton connectivity manager to monitor system network status and update the UI with banners when internet disappears or returns, finalizing the app’s connectivity feature.

Implement a connectivity manager and connectivity observable that expose network status as a flow of available or unavailable, using a singleton, callback flow, and distinct until changed.

Inject a connectivity monitor into the library view model and observe network status to display a red network unavailable banner in the library screen.

Congratulates learners on completing the course and encourages continued practice to build apps using retrofit, hilt, and room database, a common tech stack in modern android development.