Observable.fromCallable()

If you need to perform a calculation or action and then emit it, you can use Observable.just() (or Single.just() or Maybe.just(), which we will learn about later). But sometimes, we want to do this in a lazy or deferred manner. Also, if that procedure throws an error, we want it to be emitted up the Observable chain through onError() rather than throw the error at that location in traditional Java fashion. For instance, if you try to wrap Observable.just() around an expression that divides  1 by 0, the exception will be thrown, not emitted up to Observer:

    import io.reactivex.Observable;
    public class Launcher {
      public static void main(String[] args) {

        Observable.just(1 / 0)
        .subscribe(i -> System.out.println("RECEIVED: " + i),
        e -> System.out.println("Error Captured: " + e));
      }
    }

The output is as follows:

    Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Launcher.main(Launcher.java:6)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke
      (NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.
      invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.intellij.rt.execution.
      application.AppMain.main(AppMain.java:147)

If we are going to be reactive in our error handling, this may not be desirable. Perhaps you would like the error to be emitted down the chain to the Observer where it will be handled. If that is the case, use Observable.fromCallable() instead, as it accepts a lambda Supplier<T> and it will emit any error that occurs down to Observer:

    import io.reactivex.Observable;

    public class Launcher {
    public static void main(String[] args) {

        Observable.fromCallable(() -> 1 / 0)
        .subscribe(i -> System.out.println("Received: " + i),
        e -> System.out.println("Error Captured: " + e));
      }
    }

The output is as follows:

    Error Captured: java.lang.ArithmeticException: / by zero

That is better! The error was emitted to the Observer rather than being thrown where it occurred. If initializing your emission has a likelihood of throwing an error, you should use Observable.fromCallable() instead of Observable.just().