noheltcj / rxcommon

Multiplatform implementation of ReactiveX providing a common way to build one set of business logic for native, iOS, Javascript, Android, JVM, and other platforms.

RxCommon

A multi-platform ReactiveX implementation targetting JVM, iOS, Android, and JS.

More targets can be added upon request.

Documentation

Please refer to https://reactivex.io for documentation.

Sources

The reactivex documentation covers much of the functionality. If there are any significant discrepancies, excluding those illuminated within this documentation, please post an issue.

• Observable
• Single - Similar to observable, but will complete when the first value is emitted.
• BehaviorRelay - Subject which ignores all notifications. Relays retain and emit the latest element.
• BehaviorSubject - Similar to the BehaviorRelay, but acknowledges notifications
• PublishSubject
• More coming, new collaborators / contributions are greatly appreciated.

Operators

More operators are coming quickly, but not all have been implemented.

Currently supported operators:

• map
• filter
• flatMap
• switchMap (non-interleaving variant of FlatMap)
• combineLatest
• onErrorReturn
• toSingle
• first

Examples

Single(just = "hello")
  .map { "$it world" }
  .subscribe(NextObserver { result ->
    // result => "hello world"
  })

/* Be sure to dispose when this is no longer needed to prevent leaks. */
val disposable = Observable<String>(createWithEmitter = { emitter ->
  emitter.next("we're happy")
  emitter.next("la la la")

  Disposables.create {
    /*
     * This block is called when this cold observable loses all of its observers or
     * a notification is received. Use this to clean up any open connections, etc.
     */
  }
}).flatMap { happyText ->
  /* Use the text to maybe fetch something from an api. */
  return@flatMap Single<String>(error = UnauthorizedException()) // Uh oh, expired access
    .onErrorReturn { throwable ->
      /* Handle throwable, maybe check for unauthorized and recover */
      return@onErrorReturn Single(just = "$happyText recovery")
    }
}.subscribe(NextTerminalObserver({ emission ->
  /*
   * emission => "we're happy recovery"
   * emission => "la la la recovery"
   */
}, { throwable ->
  /* No terminal notifications in this example */
}))

Installing

Please ensure you're using gradle 5.3+.

Installing has recently become significantly easier. Now it's as simple as including the following:

Kotlin Build Script

kotlin {
    sourceSets {
        val commonMain by getting {
            dependencies {
                api("com.noheltcj:rxcommon:0.6.1")
            }
        }
    }
}

Groovy Build Script

kotlin {
    sourceSets {
        commonMain {
            dependencies {
                api 'com.noheltcj:rxcommon:0.6.1'
            }
        }
    }
}

Kotlin Support Map (For Native)

Since native modules require dependencies to be compiled with the same kotlin version, we will be keeping up with this support map going forward.

0.4.2 -> 1.3.20
0.5.0 -> 1.3.21
0.5.1 -> 1.3.21
0.5.2 -> 1.3.30
0.5.3 -> 1.3.31
0.6.0 -> 1.3.50
0.6.1 -> 1.3.61

Objective-C Generics

Objective-c only has partial generics support, so we lose a bit of information when this library is imported as a framework in XCode.

To help with this, when you produce an Objective-C framework, be sure to enable generics support.

components.main {
    outputKinds("framework")
    extraOpts "-Xobjc-generics"
}

Concurrency

This library doesn't support concurrency. In the majority of cases, concurrency is a side effect that can be handled on the platform. If you are doing anything that requires a significant amount of time to operate, it's important to do this work off the main thread (Especially if your application has a user interface). Of course do that using other resources such as RxSwift, RxJava, or basic platform concurrency frameworks, but ensure you've returned to the main thread before re-entering the common code.

rxcommon's Issues

Platform examples

Discovered MMP a couple of weeks back, thought ho no there is no rx.. Didn't not thought It would come so quickly thank for the great job !

Reading your readme especially "I personally use the existing platform specific implementations of Rx (RxSwift, RxJava, etc) combined with platform scheduling (ExecutorService, DispatchQueue, etc) to do this." Could you provide a minimal example with RxCommon and RxSwift/RxJava ? I'm interested in the setup / conversion between observables

Subject subscribeTo does not provide a way to dispose the internal observer

Due to the fact that the disposable created when adding the subject as an observer of the upstream source is not exposed by the subscribeTo method, cleanup is not possible.

Additional integration tests for the DoOnEach operator.

Regression/integration tests covering the Source's doOnError and doOnComplete methods including making sure that the operator itself always properly disposes the upstream and removes observers from the emitter when the created disposables are disposed.

Access modifier is incorrect for Single emitter

Currently, the emitter is public for Single. This should not be directly accessible.

Document usage in the wiki and put some simple examples in the README

Title explains itself. The goal is to make the library more accessible.
Ideally, the wiki would cover each source type and the operators.

Sources need a doOnNext method and operator

While it's possible to work around not having this. Semantically, the workaround does not fit.

Reaktive

Hi, thank you for this project, i just wanted to be sure that you are aware that https://github.com/badoo/Reaktive is also working on multiplatform Rx. Maybe you can kind of work together

Implement properly synchronized access to state

Probably the biggest blocker in this case is that state can be accidentally modified simultaneously by separate concurrent threads. Each platform will require separate implementations.

Implement non-blocking delay operator

The delay operator will likely need to have multiple platform dependent implementations.

Delay should shift emissions and the complete notification by the specified amount of time (timeshiftInMillis: Long). An error notification should still propagate immediately downstream and dispose the upstream subscription.

Happy to collaborate if anyone wants to take this one.