yongjhih / rxjava2rxjava2

Action0 to Action/Runnable

Before:

new Action0() {
  @Override
  public void call() {
  }
}

After:

new Action() {
  @Override
  public void run() throws Exception {
  }
}

After:

new Runnable() {
  @Override
  public void run() {
  }
}

Action1<T> to Consumer<T>

Before:

new Action1<String>() {
  @Override
  public void call(String text) {
  }
}

After:

new Consumer<String>() {
  @Override
  public void accept(String text) throws Exception {
  }
}

Action2<T> to BiConsumer<T>

Before:

new Action2<String, Integer>() {
  @Override
  public void call(String text, Integer i) {
  }
}

After:

new BiConsumer<String, Integer>() {
  @Override
  public void accept(String text, Integer i) throws Exception {
  }
}

Func0<R> to Callable<R>

Before:

new Func0<Boolean>() {
  @Override
  public Boolean call() {
    return true;
  }
}

After:

new Callable<Boolean>() {
  @Override
  public Boolean call() throws Exception {
    return true;
  }
}

Func1<T, Boolean> to Predicate<T>

Before:

new Func1<String, Boolean>() {
  @Override
  public Boolean call(String text) {
    return true;
  }
}

After:

new Predicate<String>() {
  @Override
  public boolean test(String text) {
    return true;
  }
}

Func1<T, R> to Function<T, R>

Before:

new Func1<String, Integer>() {
  @Override
  public Integer call(String text) {
    return ret;
  }
}

After:

new Function<String, Integer>() {
  @Override
  public Integer apply(String text) {
    return ret;
  }
}

Func2<T, T2, R> to BiFunction<T, T2, R>

Before:

new Func2<String, Integer, Boolean>() {
  @Override
  public Boolean call(String text, Integer i) {
    return true;
  }
}

After:

new BiFunction<String, Integer, Boolean>() {
  @Override
  public Boolean apply(String text, Integer i) {
    return true;
  }
}

ActionN<T> to Action<Object[]>

Before:

new Action3<String, Integer, Boolean>() {
  @Override
  public void call(String text, Integer i, Boolean b) {
  }
}

After:

new Action<Object[]>() {
  @Override
  public void accept(Object[] objects) throws Exception {
  }
}

FuncN<T> to Function<Object[], R>

Before:

new Func3<String, Integer, Float, Boolean>() {
  @Override
  public Boolean call(String text, Integer i, Float f) {
    return true;
  }
}

After:

new Function<Object[], R>() {
  @Override
  public R apply(Object[] objects) throws Exception {
      return ret;
  }
}

Misc.

rx.Observable.OnSubscribe<T> to ObservableOnSubscribe<T>

rx.Subscription to Disposable

BehaviorSubject.create("defaultValue") to BehaviorSubject.createDefault("defaultValue")

Schedulers.immediate() to Schedulers.trampoline()

TestSubscriber<T> to TestObserver<T>

Before:

val subscriber = TestSubscriber<List<Any>>()
store.asObservable().subscribe(subscriber)

store.dispatch(Fire1)
store.dispatch(Fire2)

scheduler.advanceTimeBy(500L, MILLISECONDS)

subscriber.assertValues(
    listOf(
        INIT,
        Fire1
    ),
    listOf(
        INIT,
        Fire1,
        Fire2
    ),
    listOf(
        INIT,
        Fire1,
        Fire2,
        Action1
    ),
    listOf(
        INIT,
        Fire1,
        Fire2,
        Action1,
        Action2
    )
)

After:

val testObserver = store.asObservable().test()

// ...

testObserver.assertValues(
    listOf(
        INIT,
        Fire1
    ),
    listOf(
        INIT,
        Fire1,
        Fire2
    ),
    listOf(
        INIT,
        Fire1,
        Fire2,
        Action1
    ),
    listOf(
        INIT,
        Fire1,
        Fire2,
        Action1,
        Action2
    )
)

RxPlugins.getInstance() to RxPlugins

Before:

RxJavaPlugins.getInstance().reset()
RxJavaPlugins.getInstance().registerErrorHandler(RxJavaPlugins.DEFAULT_ERROR_HANDLER)

RxJavaPlugins.getInstance().registerSchedulersHook(SynchronousSchedulersHook())

//RxJavaPlugins.getInstance().registerObservableExecutionHook(RxJavaObservableExecutionHookDefault.getInstance())

After:

RxJavaPlugins.reset()
RxJavaPlugins.setErrorHandler {}

RxJavaPlugins.setComputationSchedulerHandler { null }
RxJavaPlugins.setIoSchedulerHandler { Schedulers.trampoline() }
RxJavaPlugins.setNewThreadSchedulerHandler { Schedulers.trampoline() }

CompositeSubscription to CompositeDisposable

onErrorResumeNext(Function2<Throwable, Observable<T>>) to onErrorResumeNext(Function2<Throwable, ObservableSource<T>>)

Before:

onErrorResumeNext(e -> { Observable.empty() })

After (do nothing):

onErrorReturn(Observable.empty())

After:

onErrorResumeNext { e: Throwable ->
  // do something
  Observable.empty()
}

Notification.hasThrowable() to Notification.isOnError() & Notification.getThrowable() to Notification.getError()

Before:

notification.hasThrowable() && notification.getThrowable().getClass().isAssignableFrom(errorClazz);

After:

notification.isOnError() && notification.getError().getClass().isAssignableFrom(errorClazz);

See Also

• https://github.com/amitshekhariitbhu/RxJava2-Android-Samples