Reactive Programming with Kotlin : Learn RX with RxJava, RxKotlin and RxAndroid

✍ Scribed by raywenderlich Tutorial Team, Alex Sullivan

• Publisher: Razeware LLC
• Year: 2021
• Tongue: English
• Leaves: 465
• Edition: Second
• Category: Library

✦ Synopsis

Learn Reactive Programming in Kotlin with RxJava!

The popularity of reactive programming continues to grow on an ever-increasing number of platforms and languages. Rx lets developers easily and quickly build apps with code that can be understood by other Rx developers—even over different platforms.

Not only will you learn how to use RxJava to create complex reactive applications on Android, you'll also see how to solve common application design issues by using RxJava. Finally, you'll discover how to exercise full control over the library and leverage the full power of reactive programming in your apps.

Who This Book Is For

This book is for Android developers who already feel comfortable with the Android SDK and Kotlin, and want to dive deep into development with RxJava, RxKotlin, and RxAndroid.

Topics Covered in Reactive Programming with Kotlin:

• Getting Started: Get an introduction to the reactive programming paradigm, learn the terminology involved, and see how to begin using RxJava in your projects.
• Event Management: Learn how to handle asynchronous event sequences via two key concepts in Rx—Observables and Observers.
• Being Selective: See how to work with various events using tools such as filtering, transforming, combining, and timing operators.
• UI Development: RxJava and companion libraries make it easy to work with the UI of your apps, providing a reactive approach to handling user events.
• Intermediate Topics: Level up your RxJava knowledge with chapters on reactive networking, error handling, and schedulers.
• Advanced Topics: Round out your RxJava education by learning about app architecture, repositories, and integrating RxJava with Android Jetpack.
• And much, much more!

By the end of the book, you'll have hands-on experience solving common issues in a reactive paradigm—and you'll be well on your way to coming up with your own Rx patterns and solutions!

✦ Table of Contents

Book License
Book Source Code & Forums
What You Need
Book Updates
About the Cover
Chapter 1: Hello, RxJava!
Defining RxJava and RxKotlin
Introducing asynchronous programming
Learning the foundations of RxJava
App architecture
RxAndroid and RxBinding
Installing RxJava
Community
Key points
Where to go from here?
Chapter 2: Observables
Getting started
What is an observable?
Lifecycle of an observable
Creating observables
Subscribing to observables
Disposing and terminating
The create operator
Creating observable factories
Using other observable types
Challenges
Key points
Chapter 3: Subjects
Getting started
What are subjects?
Working with publish subjects
Working with behavior subjects
Working with replay subjects
Working with async subjects
Working with the RxRelay library
Challenge
Key points
Where to go from here?
Chapter 4: Observables & Subjects in Practice
Getting started
Using a BehaviorSubject in a ViewModel
Adding photos
Communicating with other views via subjects
Creating a custom observable
Review: Single, Maybe, Completable
Using Single in the app
Key points
Where to go from here?
Chapter 5: Filtering Operators
Getting started
Ignoring operators
Skipping operators
Taking operators
Distinct operators
Challenge
Key points
Where to go from here?
Chapter 6: Filtering Operators in Practice
Improving the Combinestagram project
Challenge
Key points
Where to go from here?
Chapter 7: Transforming Operators
Getting started
Transforming elements
Transforming inner observables
Observing events
Challenge
Key points
Where to go from here?
Chapter 8: Transforming Operators in Practice
Getting started with GitFeed
Fetching data from the web
Transforming the response
Processing the response
Persisting objects to disk
Adding a last-modified header
Challenge
Key points
Where to go from here?
Chapter 9: Combining Operators
Getting started
Prefixing and concatenating
Merging
Combining elements
Triggers
Switches
Combining elements within a sequence
Challenge: The zip case
Key points
Where to go from here?
Chapter 10: Combining Operators in Practice
Getting started
Preparing the EONET API class
Add events into the mix
Combining events and categories
Downloading in parallel
Wiring up the days seek bar
Challenge: Adding a progress bar
Key points
Where to go from here?
Chapter 11: Time-Based Operators
Getting started
Buffering operators
Time-shifting operators
Timer operators
Challenge
Key points
Chapter 12: Error Handling in Practice
Getting started
Managing errors
Handling errors with catch
Catching errors
Retrying on error
Errors as objects
Challenges
Key points
Where to go from here?
Chapter 13: Intro to Schedulers
What is a scheduler?
Setting up the project
Switching schedulers
Pitfalls
Best practices and built-in schedulers
Key points
Where to go from here?
Chapter 14: Flowables & Backpressure
Backpresssure
Buffering danger!
Natural backpressure
Introduction to Flowables
Backpressure strategies
Flowables, Observables, Processors and Subjects — Oh, My!
Key points
Where to go from here?
Chapter 15: Testing RxJava Code
Getting started
Introduction to TestObserver
Using a TestScheduler
Injecting schedulers
Using Trampoline schedulers
Using subjects with mocked data
Testing ColorViewModel
Key points
Where to go from here?
Chapter 16: Creating Custom Reactive Extensions
Getting started
Extending a framework class
Wiring the extension up
Wrapping the locations API
The lift and compose functions
Testing your custom reactive extension
Key points
Where to go from here?
Chapter 17: RxBindings
Getting started
Extending ValueAnimator to be reactive
Using RxBindings with Android widgets
Dangerzone!
Working around the issue
Fetching colors from an API
Displaying an information dialog
Challenges
Key points
Where to go from here?
Chapter 18: Retrofit
Getting started
Recap of Retrofit
Including Rx adapters
Creating a JSON object
Updating the JSON
Retrieving JSON
Key points
Where to go from here?
Chapter 19: RxPreferences
Getting started
Using SharedPreferences
Listening for preference updates
Using RxPreferences
Subscribing to preference changes
Dealing with old versions of RxJava
Saving custom objects
Key points
Where to go from here?
Chapter 20: RxPermissions
Getting started
Requesting the location permission
Using RxPermissions
Requesting another permission
Reading from external storage
Writing the weather to external storage
Reacting to orientation changes
Key points
Where to go from here?
Chapter 21: RxJava & Jetpack
Getting started
RxJava and Room
Reacting to database changes
Updating individual items
Starting the app with cached data
Paging data in
Key points
Where to go from here?
Chapter 22: Building a Complete RxJava App
Introducing QuickTodo
Architecting the application
Task model
Task data access object
Task repository
Replacing callbacks with observables
Editing tasks
Challenges
Where to go from here?
Conclusion