The Complete Android JetPack Course - Mastering Jetpack

explains how the MVP architecture uses the view model to preserve UI data across configuration changes, linking the model and view and preventing data loss in android apps.

Implement a view model to preserve the counter across configuration changes and rotation, using android x lifecycle dependencies from google maven.

Learn how live data, a lifecycle-aware data holder, works with a view model to observe changes, update the UI automatically, and preserve state across configuration changes without boilerplate.

Explore Room database basics, including entities, tables, and DAOs, and learn how Room annotations streamline database creation and operations like insert, query, and delete.

Build a contacts manager app using Room database to save, add, update, and delete contacts, starting with a plain SQLite approach and migrating to the Room persistence library.

Create a lightweight android database project using sqlite, focusing on an entity class for contact with id, name, and email, plus a database helper and a create table sql statement.

Create a database helper by extending the allied open helper, define name and version, implement onCreate and onUpgrade, and add insert, get contact, get all contacts, update, and delete methods.

Design the main activity layout by creating content_main and include layouts, add a floating action button, and configure the app bar with a toolbar and the recycler view.

Create a menu resource with a settings action in category 100 and implement a contacts adapter with a view holder, inflating the contact list and binding names and emails.

Initialize widgets by wiring the contact adapter and recycler view, load contacts from the database on launch, and enable adding or editing via a floating action button and alert dialog.

Develop and test CRUD methods for contacts by creating, deleting, and updating entries with an ArrayList and a database, and update the adapter with notifyDataSetChanged and the options menu.

Test and run the allied database app, add and manage contacts in the Contacts Manager, update and delete entries, and verify the app works on the emulator.

Implement Room database in the contact app by replacing legacy code with Room dependencies, adding Room 2.4.0, and syncing the Gradle build to enable entity-based persistence.

Create a room entity for a contact by annotating the model as @Entity with tableName 'contacts', use @ColumnInfo for id, name, and email, and @PrimaryKey(autoGenerate = true).

Learn to migrate to the room persistence library by creating a DAO interface and an entity with annotations, reducing boilerplate while implementing insert, update, delete, and query methods for contacts.

Create a room database class that links an abstract contacts app database to a contact dao, with one table named contact containing id, email, and name, version 1.

Migrate your Android app to the Room library by defining a Contact entity and data access object. Include insert, update, delete, and get all contacts or by id.

Learn to execute database queries on a background thread using java.util.concurrent executor and a handler, then update the recycler view adapter on the main thread with notifyDataSetChanged.

Learn how to use Room database callbacks to run code on database creation and opening, initialize built-in data, and log database events while keeping operations in the background.

Learn how data binding connects user interface components to data sources with declarative layouts, removing find-by-id calls and boilerplate code, and enabling xml fonts and recycler view usage.

Explore data binding with text views by building an app that binds a Person model’s name and email to two text views, using layout data tags and a main binding.

Bind data to text views and wire two buttons to event listeners using data binding, then implement a click handler in the main activity to display hello and goodbye messages.

Master data binding with include layouts in Android by nesting layouts, defining a Person model, and binding a Person object from the main activity to an included layout.

Learn two-way data binding in Android Jetpack by binding a person object's name to a text view and an edit text using observable, base observable, and findable annotations.

Learn to build a contact manager app from scratch using Android data binding, binding text views, recycler view items, nested and included layouts, and a fab with swipe-to-delete.

Continue building a contacts app with data binding and a recycler view, set up a room database with entity and data access object, and bind in main activity.

Create a contact data adapter for a RecyclerView with a contact view holder that binds name and email from the contact. Implement getItemCount and setContacts to update data and notifyDataSetChanged.

Create a contacts manager app using room database, recycler view, and data binding, enabling add (via add-contact activity), delete (swipe), and load with background threading and a floating action button.

Learn to build the add new contact activity with data binding, wire click handlers, handle on submit, and pass name and email via an intent back to the main activity.

Debug and test the contacts manager app, fix entity and primary key issues using room persistence, then switch from find-by-id to data binding for the recycler.

Launch a data binding enabled RecyclerView in an Android Jetpack app, transforming item layouts into binding layouts and binding contact data via view holders and adapters for dynamic display.

Build a learning management app using the MVP pattern with Room database, view model, live data, and data binding, featuring a spinner and recycler view with add, update, and swipe-to-delete.

Implement a Room database with category and course entities, their DAOs, a singleton database, a repository, and a view model using LiveData to manage courses and categories.

Create Android room database entities for category and course, with a foreign key link and cascade delete. Integrate Jetpack room dependencies and data binding for observable data.

Build data access objects for category and course in Room database, enabling insert, update, delete, and queries returning live data for all items or by category id.

Create a singleton course database using Room, linking category and course entities with abstract DAOs. Initialize the database with a Room callback to prepopulate categories and courses on first launch.

Build a simple repository to manage category and course data with Room, LiveData, and a singleton pattern. Execute inserts, deletions, and updates on background executors to keep the app responsive.

Build a main activity view model with Android X lifecycle, live data, and a repository to manage categories and courses from a room database, supporting add, update, and delete.

Develop the main activity UI with a spinner and adapter, data binding for the recycler view, and wire insert, update, delete via a floating action button.

Design a banner and add a dropdown spinner to select a course category, using data binding to bind a spinner adapter and handle item selection in the main activity.

Initialize the Room database with ready-made categories and courses on first launch using a background thread. Insert via DAO and display data in a recycler view with view binding.

Create and bind a recycler view to display courses, build its adapter with data binding, and design the item layout with a name text view and a second text view.

Build a RecyclerView-based course list in Android using data binding, with a custom adapter and view holder, item click handling, and live loading of courses in the main activity.

Master the add/edit course workflow with data binding in an Android Jetpack app: build an add/edit activity with name and price fields, validate input, and return results via intents.

Learn to implement create, insert, update, and delete in Android Jetpack by wiring the main and add/edit activities, a recycler view with swipe-to-delete, and startActivityForResult for data exchange.

Learn to use DiffUtil to efficiently update a RecyclerView in an MVP Android app by implementing a diff callback, overriding equals for item comparison, and dispatching minimal updates.

Introduce retrofit as a type-safe rest client for Android and Java, and learn to fetch JSON from web services using a REST-based API with MVP architecture.

Learn to use retrofit to communicate with REST APIs by defining interfaces, building a retrofit instance, and modeling responses, using a JSON converter factory and singleton pattern.

Learn how to convert JSON to Java objects and vice versa using online tools, and format and fetch JSON data for Android recycler views.

Create a retrofit instance, interface, and a model class for albums from json placeholder, mapping userId, id, and title with json to pojo tooling and gson annotations for nested json.

Learn to use Gson, Google's JSON library, to convert Java objects to JSON and back. Explore SerializedName and Expose annotations, and apply it with Retrofit.

Build a country names app by fetching data from the countries API, transforming it into recycler view items with retrofit, and laying groundwork for MVP patterns in upcoming projects.

Create a country names app in Android by configuring a new project, adding internet permission, and wiring Retrofit with a Gson converter and a model class to map country data.

Create a retrofit interface for the country names app to fetch data from api.printfull.com/countries using a get annotation, mapping the response to the result model with code and extra.

Implement a private static retrofit reference and a public static accessor to create a singleton Retrofit instance for the GetCountryDataService interface using the base URL and converter factory.

Create the main activity and set up a retrofit call to fetch country data. Log and store the results in an array list for future display in a recycler view.

Fetch country data from the internet with retrofit, transform JSON into country models, and display country names in a recycler view using a card view and an adapter.

Build a movie app that fetches remote data via retrofit, uses model, view model, repository, and live data, and shows films in a recycler view with details in separate activity.

Set up a retrofit-based remote data source for a movie app, building the model, interface, and retrofit instance with data binding and api key, base url, and converter.

Develop a movie model class to map the popular movies api response, fetch details using a movie id and api key, and prepare image loading with the Glide library.

Learn to implement parcel in a movie model by writing and reading values, enable data binding with observable fields and notify property change, and pass data between activities.

Create a result model class for movie data, including page, total results, total pages, and a results list of movie objects; implement parcel to read from and write to parcel.

Develop the movie repository using retrofit integration, create a movie data service interface, and expose live data for popular movie results via api calls with an api key.

Create a singleton retrofit instance to optimize memory and network usage, using a base url and converter factory, and provide a movie data service interface.

Implement Retrofit calls to fetch popular movies by obtaining the service, passing the API key from strings, and handling responses to populate a movies list via mutable live data.

Create an Android view model that interacts with a movie repository, exposes immutable live data of a movie list, and implements get all movies and insert operations.

Build the main activity layout with data binding and swipe refresh layout. Add the AndroidX swipe refresh dependency and prepare the main and details activities.

Create a movie list item layout for a recycler view using data binding, binding a Movie model to a card view with image, title, and vote average.

Design the movie details screen in an Android Jetpack app using data binding and a collapsing toolbar, with MVP architecture, Retrofit API calls, and Glide-based poster loading.

Learn to build the content underscore movie layout, bind a movie data model, and display title, poster, release date, and overview in a scroll view with constraint and linear layouts.

Create a recycler view adapter to display a list of movies, binding data with movie list item binding and handling item clicks to start the movie activity.

Build a movie details activity by wiring data binding, setting up a toolbar, and receiving the selected movie via intent extras from the main activity.

Implement the main activity by wiring a movie list with a recycler view, data binding, and a view model, then enable swipe-to-refresh and a responsive grid layout for popular movies.

Test and debug the app by running it, exploring the movie list, and verifying poster, title, rating, and description; fix a toolbar crash in mvp within clean architecture.

Fetch popular IMDb movies with retrofit, display them in a recycler view, and load on demand using the paging library, while wiring dagger/hilt, view model, and MVP architecture.

Master how the paging library loads and displays data pages from large datasets as you scroll, with on-demand requests, in-memory caching, and robust error handling.

Add dependencies for Retrofit, json converter, paging library, Dagger Hilt, Glide, and lifecycle components to fetch movies and ratings from the movie db api using MVP.

Create the app layout for a single-activity paging app, configuring a recycler view and load state and single movie item layouts, while integrating the paging library and MVP architecture.

Plan and implement a paging app using mvvm, retrofit, dagger hilt, and the paging library to fetch movie data and movie response, displaying them in a recycler view.

Create a util package with a Utils class containing the API key and base URL, plus a movie comparator extending util.ItemCallback and a grid space decorator using RecyclerView.ItemDecoration.

Create an API client and API interface for the movie popular endpoint using retrofit, with a page-parameterized get request and an interceptor to append the API key.

Create a view model for movie data, extend the view model superclass, and configure a paging source and pager with paging config to expose a flowable paging data stream.

Learn to implement a paging source using a page key data source in the paging library to fetch movies by page, map results, and wire a pager with paging config.

Explore dependency injection in an Android app by creating an app module with Dagger Hilt, providing a Glide instance, and configuring request options and placeholders.

Learn how to migrate to paging three and build a paging data adapter for movies, using view binding, a movie item binding, and Glide to load poster images.

Learn to create a movies load state adapter, extending the paging library's load state adapter, to show a loading spinner or retry error in a recycler view.

Configure the main activity with view binding, a paging-enabled two-column grid recycler view, and a view model, injecting a request manager and handling API key errors to display loading states.

Run and test the Android app, fix manifest errors by specifying the application class name, and verify paging loads data from the API with Retrofit, Dagger, Glide, and ViewModel.

Explore the Android Jetpack work manager, the primary API for persistent background tasks, including immediate, expedited, long-running, and deferral tasks, and learn why it replaces older schedulers.

Build an app with work manager by creating a demo worker that counts to 1000 in background, using a one-time work request with constraints and handling success, failure, or retry.

Learn to display worker status in your app by observing the work manager, retrieving work info, and showing a toast with running or succeeded states as you count to 1000.

Learn to use WorkManager constraints to run tasks only when devices are charging or on wifi, building a constraints object and testing it in an emulator.

Learn how to send and receive data with Android Jetpack WorkManager by creating input data via a builder, passing it to a work request, and retrieving output in main activity.

Explore the solid principles - single responsibility, open-closed, Liskov substitution, interface segregation, and dependency inversion - and how dependency injection enhances maintainable, testable code.

Explore pure dependency injection in Android by building a dependency app that demonstrates constructor injection, method injection, and field injection, and compare manual vs Dagger-based injection for Android Jetpack projects.

Introduce Dagger, a compile-time dependency injection framework for Java and Android, replacing manual injection with generated code via inject annotations and components in a mobile example.

Discover how dagger modules enable dependency injection for third-party classes like retrofit, using a battery module with a provides method to supply instances through a component.

Learn to work with interfaces and constructor injection by implementing a battery interface with a nickel battery and providing it through a module for Android Jetpack.

Explore dependency injection with parameterized constructors by building a battery module, a provide battery method, and a Dagger component builder to supply a configured battery.

Create a custom application class to initialize global data, network clients, persistence, and crash analytics before launching the first activity, wiring Dagger components for clean architecture and dependency injection.

Learn to implement a Dagger singleton by annotating with Singleton to ensure one runtime instance, prevent memory leaks, and support clean architecture through single dependency injection across activities.

Apply dependency injection with Dagger to decouple the main activity from the room database. Build clean architecture using modules, a component, and singleton provisioning, with unit testing in mind.

Learn to add dagger 2 to the LMA app’s MVP AMP architecture by configuring app and repository modules, a singleton repository, and a main activity view model factory.