RxJava 3 For Android Developer Masterclass

Build a database application using a persistent library, focusing on room persistence with RxJava for an Android project, including setting, saving, and editing records.

Create a new Android project and add Room and RxJava 3 dependencies to build a database app. Prepare to define entities and the database in the next lecture.

Create a room entity named student with a table name and a primary key, plus columns for name, age, and subjects, and a dao with insert, update, delete, and get-all.

Create a singleton database instance using a volatile companion object and synchronized block to prevent multiple instances across threads, building with application context and database builder.

Create a student repository by adding a repository class with a database service, implementing insert and get operations for a student entity, and preparing to use it in the view.

Create a view model to manage a student repository with insert, update, delete, and fetch all operations using RxJava 3, with loading, error, and success states.

Add the lifecycle and room dependencies to support the view model, initialize the view model with the application, and observe loading, errors, and data to drive the user interface.

Create a form layout in an Android activity, add text fields and constraints for name, idea, number, and subject, and integrate a dialog to present input and actions.

Implement an add dialog in an Android RxJava project by wiring a private function, configuring the dialog with positive and negative buttons, and handling user input and dialog sorting.

Learn to insert a new student record by creating a model with name and subject, converting inputs, and invoking the insert function, while observing table changes with an observable.

Implement a RecyclerView layout for the student list in an Android app, adjusting horizontal and vertical orientations, defining the student item layout, and outlining the upcoming adapter setup.

Build a recycler view adaptor for student entities, wiring the view holder and dataset, and set up the layout manager to reflect additions and updates.

Learn to add, edit, and delete items in an Android app using a button and card view, with practical UI event wiring.

Implement the edit flow by wiring the edit button in the adapter, showing a dialog with the student data, and updating the view model on submit through a dedicated listener.

Implement delete functionality by wiring the delete button in a dialogue to remove a record after a confirmation message, updating the list and handling title and message fields.

Demonstrates adding a progress bar in the main activity, adjusting color and layout constraints, and toggling visibility to reflect student progress via the view model.

Implement a success dialog flow in the RxJava 3 for Android developer masterclass by wiring updates, configuring the title and the message, and handling dismissal via an observer.

Implement a deleted dialog flow by wiring the view model to observe deletion status, show a dialog in the main activity, and handle success and error messages during deletion.

Implement an error dialog in RxJava 3 for Android by building a dialogue with a title and message, pass the message to the observer, and simulate errors using composite dispersement.

Clear the composite disposable when the view model is destroyed to cancel background tasks and database access, preventing memory leaks. This prevents memory errors from long-running background work.

Learn to automatically scroll a RecyclerView to a new record's position when adding items, ensuring the latest entry becomes visible, and test behavior with varying ages and subjects.

An introduction to the RxJava 3 for Android developer masterclass, guiding you to build the ZabaSearch app and implement its service in this section.

Build a database search query using a search view and menu in Android, wire the search field to a query function, and prepare the new model.

Implement a search query feature by wiring the search view to pass the query to the model, filter the student list, and handle results in the main activity.

Implement a search view in RxJava 3 by observing text input, emitting onNext values, debouncing for 1 second, and using distinctUntilChanged to prevent duplicate queries, reducing database calls.

Add a composite disposable to manage observables, dispose it when the activity is destroyed, and run background tasks on the correct scheduler to prevent leaks.

Learn how to use Retrofit to build a composite Android app, performing CRUD operations against an API with a task list that includes title, body, note, and status.

Create a new Android project with an empty activity, then add and configure Retrofit with RxJava 3 and Kotlin dependencies, including converters and logging, and synchronize to resolve build errors.

Set up a base URL and define endpoints for the API, configure build-time constants, and implement get all and add operations to fetch and manage data in the app.

Create a response model in a new data package under remote, generate the tax response class, and wire a list of tax responses into the app for handling incoming responses.

Create a Retrofit service by defining an internet service interface, annotate endpoints, and return a single response using Retrofit in an Android app.

Create a retrofit instance with the RxJava adapter and converter, configure the base URL and service, and enable RxJava calls via a call adapter factory and interceptor-based logging.

Extend the application class to initialize the networking service on app startup and expose a single shared network service accessible from anywhere.

Create a new task repository in the project and implement a function to fetch all tasks from the service, returning a Single suitable for the view model.

Create a new model and view model, wiring a networking service to fetch data and expose a tax list via RxJava, with loading and error handling and proper schedulers.

initialize viewmodel in android app using RxJava 3, pass application to ViewModel via factory, troubleshoot network access and data loading issues, test UI data population and error handling.

design and implement a recycler view item layout with title, body, status, and constraints, and wire up a reusable item view for list entries in Android.

Create and wire a RecyclerView adapter, including its core methods and binding steps. Run updates in a background thread to keep the UI responsive and manage the item list.

Implement RecyclerView to display a tax list by creating a data model, binding title, body, and status, and wiring a list adapter to render items.

design a layout to add a task, using a text input layout with a title and body, a dialog, hints, and a floating action button to submit.

Learn to implement and show an add task dialog in an Android app, configuring the dialog view, corner radius, cancelability, and its positive and negative buttons.

Implement an add task dialog by wiring the view model to set the title, body, and status, then trigger the add action and prepare endpoint and network service for integration.

Add a task request and an API endpoint. Build and serialize the request body with title and status, then route to the network service for a single response item.

Implement add task using the repository function and return task request with a user id. Subscribe and observe with schedulers, show loading, and verify the added value in the app.

Build the edit and delete view, implement the edit and delete buttons, and test the app using a real persistent library.

Implement an edit dialog to update tax data via a new endpoint, wiring a repository and view model to handle edits and reflect changes in the UI.

Implement the edit click listener to open a dialog, set the title and body text, handle the positive button to call a function, update data, and test the app.

Implement a delete task in an android app using rxjava 3. Build a delete request with user id and endpoint, wiring repository and view model to handle the response.

Implement delete task by configuring the dialogue title and message, then update the main activity and model to remove a record from the list. Test the deletion.

Design and test a progress bar in an Android app, observe loading behavior in the main activity, and validate add, edit, and update flows.

Implement a success dialog in an Android app by observing success and error messages, updating the dialog with the appropriate success message, and displaying it to the user.

Learn to implement search with a search view that queries the API, clears filters with a button, and shows API results using RxJava 3.

Build and wire a search endpoint in an Android app using RxJava 3, including endpoint creation, header handling, query passing, and repository integration with observe and subscribe.

Learn to integrate a search view in the app menu using Android X, inflate a search item, and wire it to search a data list.

Implement a RxJava search view in Android by wiring a PublishSubject input, debouncing text changes, filtering non-empty queries, and using switchMap to observe only the latest results.

Implement a clear search filter in an Android app by adding a top menu item and icon, wiring to a Retrofit API call, and enabling clearing to show all data.

Congratulates learners on completing the RxJava 3 for Android developer masterclass. Builds confidence in Java development for Android projects, while highlighting adaptive extension and dependency injection as career development topics.

Master the paging 3 library for Android by loading pages from local storage or network, reducing bandwidth and resource use, and integrating with data sources, view models, and adapters.

Learn to add Paging 3 dependencies to your Android project by copying the dependency block into the top-level build file and syncing the project for reliable data loading.

Create a network endpoint and a paginated get request with page and size parameters, headers, and a dedicated single response type to fetch and map data.

Implement RxPagingSource for Android by creating a network-backed paging source, mapping the server response to a model, and handling page keys, current and last pages, and refresh logic.

Build a repository and Beijing-specific data source, implement paging with a page config, and tune initial load size, page size, max size, placeholders, and distance for efficient data loading.

learn to create a new Beijing view model, extend the view model base, inject a repository, and return a Beijing data RPV trajectory with optional mapping and catch logic.

Implement a custom view model provider factory to create view models with constructor parameters, wiring a tax repository and network service through the create function.

Extend PagingDataAdapter to implement a Beijing data adapter with a view holder and binding. Bind items from the view model to the UI and handle data types with appropriate binding.

Implement a recycler view adapter and swap in a paging adapter, integrate with the view model to fetch API data across pages, and observe data loading tied to the lifecycle.

Implement a paging data adapter with a load state listener to show a progress bar during loading and handle errors by combining states from the data source and remote mediator.

Configure paging to preload enough pages on initial load before user scrolls, balancing distance and page size to reduce server requests and save bandwidth and resources.