The Complete RxJava For Android Development Masterclass

Explore reactive programming with ReactiveX, RxJava, and RxAndroid, learn how data streams from clicks, network calls, and errors are observed and scheduled on threads for clean, scalable Android apps.

Learn the core RxJava and RxAndroid concepts, including observables and observers, schedulers, and key operators like map, flatMap, debounce, and range.

Create a basic Android app using RxJava and RxAndroid, introduce an observable from a string with just, and implement an observer handling onSubscribe, onNext, and onComplete.

Examine how RxJava schedulers enable concurrency by moving work between io and main threads with subscribeOn and observeOn, and explore scheduler types like io, mainThread, newThread, single, trampoline, and from(executor).

Use Disposable in RxJava 3 to dispose subscriptions when an activity or fragment is destroyed via onDestroy, preventing memory leaks and app crashes during network calls.

Discover how to use DisposableObserver as a base class to manage disposables in RxJava 3, reducing code and enabling direct dispose calls in onDestroy for Android apps.

Learn to manage multiple observers in RxJava Android with composite disposable, which maintains a pool of subscriptions and disposes them all at once in onDestroy.

Demonstrate efficient RxJava 3 patterns by chaining subscribeOn(Schedulers.io()) with observerOn, using subscribeWith() to return a DisposableObserver, and adding it to a compositeDisposable for cleaner subscriptions.

Explore how the RxJava just operator emits provided items as separate values or as a single array when passed as one argument, with fromArray discussed next.

Learn how the fromArray operator in RxJava converts array items into an observable, emitting each string or integer one by one, with practical string and integer examples.

Explore the range operator in RxJava 3 for Android development, emitting numbers from 1 to 20 and switching from fromArray to range in a rangedemo project.

Create an observable from scratch with the create operator to emit student objects and handle onNext with a student observer.

Transform student data with the map operator in RxJava 3 by applying a function to each emitted item, such as converting names to uppercase.

Explore how the flatMap operator differs from map by transforming items into observables and flattening emissions, including a network call example for movies and locations.

Explore the RxJava 3 operator concatMap in Android development, contrasting it with flatMap: concatMap preserves order but processes observables serially, offering a trade-off between order and efficiency.

Apply the RxJava 3 filter operator to an observable of numbers, emitting multiples of 3 by a predicate, using range 1 to 20, and logging results via subscribe and onComplete.

Explore the distinct() operator in RxJava 3, filtering an observable to emit only new items and skip duplicates in a ten-item example with logging.

Apply the RxJava skip operator to ignore the first n items of an observable and emit the remaining items. A 10-item example shows skipping the first 6 items.

Learn how the skip last operator in RxJava 3 omits items from the end of a stream. Observe the log results showing 1, 2, 3, and 7.

Explore RxJava subjects that act as observable and observer, including Async Subject, Behavior Subject, Publish Subject, and Replay Subject, and learn how they bridge imperative to reactive code for subscribers.

Explore RxJava subjects, including AsyncSubject emits the last item on completion, BehaviorSubject emits the latest value and subsequent ones, PublishSubject emits items after subscription, and ReplaySubject replays all items to every subscriber.

Explore how RxBinding converts Android view events into observables, simplifying UI event handling with RxJava. See practical examples using RxTextView and RxView to manage input and clicks.

Apply RxJava knowledge to a real project by exploring a partially completed two-tab to-do app, including todo and done tasks, a responsive options bar, and a sqlite-backed data manager.

Integrate rxjava into the project by creating an observable from the todo data in sqlite, then filter and map items and display them in a recycler view.

Leverage RxJava to provide a better search experience by debouncing input and filtering the to-do list in a RecyclerView. Integrate RxBinding to map searchEditText changes to an observable, apply skipInitialValue, distinctUntilChanged, and a 300 ms debounce, and update the RecyclerView via the adapter filter.

Learn how retrofit simplifies network communications by handling parameters, urls, and data writing, while managing multi-threading, enabling faster, safer rest api calls in android and java.

Create a retrofit instance with the builder pattern, set base url, and define endpoints in an interface to enable rest api communication, using gson or simple xml converters as needed.

Learn to convert JSON or XML data to Java objects and back with Retrofit and Gson, and generate model classes using online tools, with @SerializedName and @Expose annotations.

Define API endpoints with a Retrofit interface using a fixed base URL and varying endpoints. Explore get and post methods and annotations like path and query to construct requests.

Learn to implement the Retrofit call interface, define methods returning info and string, and use enqueue to asynchronously handle responses with onResponse and onFailure.

Learn to use retrofit path parameters in android apps by passing dynamic values like alpha2_code with @Path annotations to build endpoints and fetch a single country in json.

Learn how to add retrofit query parameters with @Query and @QueryMap, build URLs with dynamic key value pairs, and pass a map from activities to influence the REST API sorting.

Explore Retrofit's body annotation and how it sends a user object with user name and password in the POST body to a REST API.

Learn how to send header data in HTTP requests using Retrofit: add static headers with @Headers, dynamic headers with @Header, and header maps with @HeaderMap for JSON post requests.

Explore a Retrofit POST example using JSONPlaceholder REST API to send a user object with username and password, and receive it back with a newly added id.

Create a simple Retrofit post app by modeling a user with id, email, and password, enabling internet permission, and integrating Retrofit, Gson, and a design dependency for the view.

Define a post endpoint using @POST and @Body in a retrofit service, implement getResult returning a User, and build a singleton with base URL and Gson converter.

Build a simple post request using retrofit in an Android view, with input fields and a submit button, then display the returned id from the API response.

Build a TMDB client app that fetches popular movies with Retrofit and an API key, and display details on click. Learn Glide, Parcelable, and SwipeRefreshLayout as you progress.

Register and log in to the TMDB site, create an API key, and copy it to use the API, as explained in the getting started guide.

Set up the TMDBClient project by adding internet permission, retrofit and gson dependencies, and UI components like RecyclerView and CardView, with Glide for images, design library, and custom colors.

Set up a Retrofit instance and a MovieDataService interface to fetch popular movies from the TMDB API, using a query parameter for the API key and a Gson converter.

Connect to the rest api with Retrofit, fetch popular movies using getPopularMovies and an api key, and debug the response by aligning Gson @SerializedName mappings for total_results and results.

Display movies in grid with a RecyclerView backed by an ArrayList of Movie objects, using a MovieAdapter and Glide for images, and configure a CardView grid for portrait and landscape.

Enable swipe to refresh in the movie app using swipe refresh layout; connect the on refresh callback to fetch popular movies and update the recycler view for fresh data.

Open a movie details screen from a list item by passing a Parcelable movie via an Intent, and display poster, title, rating, and plot with a collapsing toolbar using Glide.

Learn why integrating Retrofit with RxJava helps manage large data streams and parallel API calls, leveraging RxJava operators and schedulers for cleaner error handling and reduced leaks.

Learn to integrate Retrofit with RxJava to fetch popular movie data from TMDB, convert responses to observables, and use operators like flatMap and filter to manage and display results.

Explore Room data persistence library as part of Android architecture components, learn how it simplifies SQLite access with database object mapping, and use entities and DAOs with compile-time query verification.

Explore core Room annotations for Android persistence, including Database, Entity, Primary key, Foreign key, ColumnInfo, and Dao annotations. Learn insert, query, update, and delete operations.

Demonstrates implementing CRUD operations with the Room data persistence library, compares it to plain SQLite code, and refactors a contact manager app into a cleaner, maintainable Room-based approach.

Replace sqlite with the Room persistence library, add Room dependencies and annotation processor version 1.1.1 in gradle, and implement Room for this project; next, learn Room annotations for entity tables.

Create a Room entity class to represent the contacts table, using entity and column info annotations, define primary key with auto generate, and manage constructors with ignore to simplify persistence.

Create data access objects using Room annotations to insert, update, delete, and query contacts, returning a list or a single contact by id, replacing the old SQLite helper.

Create a room database class by extending roomdatabase, annotate with entities and version, and define an abstract method to expose the contactdao, enabling database operations via getcontactdao.

Implement CRUD using Room by creating a contact entity, DAO, and database, then perform add, update, and delete operations via the Room database instance.