Looking Ahead To RxJava 2 (Droidcon NYC 2016)

Slide 1

Slide 1 text

Looking Ahead To   RxJava 2 Jake Wharton

Slide 2

Slide 2 text

Reactive Streams ...is an initiative to provide a standard for asynchronous stream processing with non-blocking back pressure.

Slide 3

Slide 3 text

Reactive Streams interface Publisher {  void subscribe(Subscriber super T> s);  }A

Slide 4

Slide 4 text

Reactive Streams interface Publisher {  void subscribe(Subscriber super T> s);  }A interface Subscriber {  void onNext(T t);  void onComplete();  void onError(Throwable t);  }B

Slide 5

Slide 5 text

Slide 6

Slide 6 text

Reactive Streams interface Publisher {  void subscribe(Subscriber super T> s);  }A interface Subscriber {  void onNext(T t);  void onComplete();  void onError(Throwable t);  void onSubscribe(Subscription s);  }B interface Subscription {  void request(long n);  void cancel();  }C

Slide 7

Slide 7 text

Slide 8

Slide 8 text

Reactive Streams class RxReactiveStreams {  static Publisher toPublisher(Observable o) { … }  static Observable toObservable(Publisher p) { … }  static Publisher toPublisher(Single o) { … }  static Single toSingle(Publisher p) { … }  static Publisher toPublisher(Completable o) { … }  static Completable toCompletable(Publisher> p) { … }  }

Slide 9

Slide 9 text

Slide 10

Slide 10 text

Reactive Streams interface Subscriber {  void onNext(T t);  void onComplete();  void onError(Throwable t);  void onSubscribe(Subscription s);  }B

Slide 11

Slide 11 text

Slide 12

Slide 12 text

Reactive Streams interface Subscriber {  void onNext(T t);  void onComplete();  void onError(Throwable t);  void onSubscribe(Subscription s);  }B Calling onSubscribe, onNext, onError or onComplete MUST return normally except when any provided parameter is null in which case it MUST throw a java.lang.NullPointerException to the caller

Slide 13

Slide 13 text

Slide 14

Slide 14 text

Flowable

Slide 15

Slide 15 text

Flowable ALL NEW!!!!!

Slide 16

Slide 16 text

Flowable • Implementation of Reactive Streams Publisher. ALL NEW!!!!!

Slide 17

Slide 17 text

Flowable • Implementation of Reactive Streams Publisher. • Observed with Reactive Streams Subscriber. ALL NEW!!!!!

Slide 18

Slide 18 text

Flowable • Implementation of Reactive Streams Publisher. • Observed with Reactive Streams Subscriber. • 0 to many items, completes or errors. ALL NEW!!!!!

Slide 19

Slide 19 text

Flowable • Implementation of Reactive Streams Publisher. • Observed with Reactive Streams Subscriber. • 0 to many items, completes or errors. • Handles backpressure to slow down events  with Reactive Streams Subscription. ALL NEW!!!!!

Slide 20

Slide 20 text

Slide 21

Slide 21 text

Slide 22

Slide 22 text

Flowable (aka RxJava 1.x's Observable) • Implementation of Reactive Streams Publisher. • Observed with Reactive Streams Subscriber. • 0 to many items, completes or errors. • Handles backpressure to slow down events  with Reactive Streams Subscription. • Hundreds of convenience methods for  transforming and composing data.

Slide 23

Slide 23 text

FlowableProcessor

Slide 24

Slide 24 text

FlowableProcessor ALL NEW!!!!!

Slide 25

Slide 25 text

FlowableProcessor • Implementation of Reactive Streams Processor  (aka Publisher via Flowable + Subscriber). ALL NEW!!!!!

Slide 26

Slide 26 text

FlowableProcessor • Implementation of Reactive Streams Processor  (aka Publisher via Flowable + Subscriber). ALL NEW!!!!!

Slide 27

Slide 27 text

FlowableProcessor (aka 1.x's Subject) • Implementation of Reactive Streams Processor  (aka Publisher via Flowable + Subscriber).

Slide 28

Slide 28 text

Observable? Subject?

Slide 29

Slide 29 text

Observable • Observed with an Observer (not Reactive Streams type). • 0 to many items, completes or errors. • No backpressure support. • Hundreds of convenience methods for transforming and  composing data.

Slide 30

Slide 30 text

Slide 31

Slide 31 text

Subject • Implementation of Observable and Observer.

Slide 32

Slide 32 text

Flowable vs. Observable

Slide 33

Slide 33 text

Flowable vs. Observable • RxJava 1.x added backpressure late in the design process.

Slide 34

Slide 34 text

Flowable vs. Observable • RxJava 1.x added backpressure late in the design process. • All types exposed backpressure but not all sources respected it.

Slide 35

Slide 35 text

Flowable vs. Observable • RxJava 1.x added backpressure late in the design process. • All types exposed backpressure but not all sources respected it. • Backpressure, like inheritance, must be designed for.

Slide 36

Slide 36 text

Flowable vs. Observable • Backpressure, like inheritance, must be designed for. RxView.touches(paintView) .subscribe(e -> draw(e));

Slide 37

Slide 37 text

Flowable vs. Observable • Backpressure, like inheritance, must be designed for. RxView.touches(paintView) .subscribe(e -> draw(e));

Slide 38

Slide 38 text

Flowable vs. Observable • Backpressure, like inheritance, must be designed for. RxView.touches(paintView) .subscribe(e -> draw(e)); db.createQuery("SELECT * …") .subscribe(e -> update(e));

Slide 39

Slide 39 text

Flowable vs. Observable • Backpressure, like inheritance, must be designed for. RxView.touches(paintView) .subscribe(e -> draw(e)); db.createQuery("SELECT * …") .subscribe(e -> update(e));

Slide 40

Slide 40 text

Flowable vs. Observable • Backpressure, like inheritance, must be designed for. RxView.touches(paintView) .subscribe(e -> draw(e)); db.createQuery("SELECT * …") .subscribe(e -> update(e)); Observable Observable

Slide 41

Slide 41 text

Slide 42

Slide 42 text

Slide 43

Slide 43 text

Flowable vs. Observable Observable Flowable interface Subscriber {  void onNext(T t);  void onComplete();  void onError(Throwable t);  void onSubscribe(Subscription s);  }B interface Observer {  void onNext(T t);  void onComplete();  void onError(Throwable t);  void onSubscribe(Disposable d);  }B

Slide 44

Slide 44 text

Slide 45

Slide 45 text

Converting

Slide 46

Slide 46 text

Converting Observable

Slide 47

Slide 47 text

Converting 1 2 3 4 5 6 7 8 9 10 11 Observable

Slide 48

Slide 48 text

Converting Observable toFlowable()X

Slide 49

Slide 49 text

Converting Observable toFlowable(DROP)X

Slide 50

Slide 50 text

Converting Observable toFlowable(DROP)X Flowable

Slide 51

Slide 51 text

Converting Observable Flowable toFlowable(DROP)X request(5)

Slide 52

Slide 52 text

Converting 1 2 3 4 5 Observable Flowable toFlowable(DROP)X 1 2 3 4 5 request(5)

Slide 53

Slide 53 text

Converting 1 2 3 4 5 6 7 8 Observable Flowable toFlowable(DROP)X 1 2 3 4 5 request(5)

Slide 54

Slide 54 text

Converting 1 2 3 4 5 6 7 8 Observable Flowable toFlowable(DROP)X 1 2 3 4 5 request(5) request(2)

Slide 55

Slide 55 text

Converting 1 2 3 4 5 6 7 8 9 10 11 Observable Flowable toFlowable(DROP)X 1 2 3 4 5 9 10 request(5) request(2)

Slide 56

Slide 56 text

Converting Observable toFlowable(LATEST)X Flowable

Slide 57

Slide 57 text

Converting Observable Flowable request(5) toFlowable(LATEST)X

Slide 58

Slide 58 text

Converting 1 2 3 4 5 Observable Flowable 1 2 3 4 5 request(5) toFlowable(LATEST)X

Slide 59

Slide 59 text

Converting 1 2 3 4 5 6 7 8 Observable Flowable 1 2 3 4 5 request(5) toFlowable(LATEST)X

Slide 60

Slide 60 text

Converting 1 2 3 4 5 6 7 8 Observable Flowable 1 2 3 4 5 request(5) request(2) toFlowable(LATEST)X

Slide 61

Slide 61 text

Converting 1 2 3 4 5 6 7 8 Observable Flowable 1 2 3 4 5 request(5) request(2) toFlowable(LATEST)X 8

Slide 62

Slide 62 text

Converting 1 2 3 4 5 6 7 8 9 10 11 Observable Flowable 1 2 3 4 5 9 request(5) request(2) toFlowable(LATEST)X 8

Slide 63

Slide 63 text

Converting Observable BUFFER Flowable toFlowable( )X

Slide 64

Slide 64 text

Converting Observable Flowable request(5) toFlowable(BUFFER)X

Slide 65

Slide 65 text

Converting 1 2 3 4 5 Observable Flowable 1 2 3 4 5 request(5) toFlowable(BUFFER)X

Slide 66

Slide 66 text

Converting 1 2 3 4 5 6 7 8 Observable Flowable 1 2 3 4 5 request(5) toFlowable(BUFFER)X

Slide 67

Slide 67 text

Converting 1 2 3 4 5 6 7 8 Observable Flowable 1 2 3 4 5 request(5) request(2) toFlowable(BUFFER)X

Slide 68

Slide 68 text

Converting 1 2 3 4 5 6 7 8 Observable Flowable 1 2 3 4 5 request(5) request(2) toFlowable(BUFFER)X 6 7

Slide 69

Slide 69 text

Converting 1 2 3 4 5 6 7 8 9 10 11 Observable Flowable 1 2 3 4 5 request(5) request(2) toFlowable(BUFFER)X 6 7

Slide 70

Slide 70 text

Converting toObservable() Observable Flowable

Slide 71

Slide 71 text

Converting Observable Flowable request(Long.MAX_VALUE) toObservable()

Slide 72

Slide 72 text

Converting 1 2 3 4 5 6 7 8 9 10 11 Observable Flowable 1 2 3 4 5 request(Long.MAX_VALUE) 6 7 8 9 10 11 toObservable()

Slide 73

Slide 73 text

Specializations

Slide 74

Slide 74 text

Specializations • Encoding subsets of Observable into the type system.

Slide 75

Slide 75 text

Single

Slide 76

Slide 76 text

Single • Either succeeds with an item or errors. • No backpressure support. • Convenience methods for transforming and composing data.

Slide 77

Slide 77 text

Single • Either succeeds with an item or errors. • No backpressure support. • Convenience methods for transforming and composing data. • Think "reactive scalar".

Slide 78

Slide 78 text

Completable

Slide 79

Slide 79 text

Completable • Either completes or errors. Has no items! • No backpressure support. • Convenience methods for transforming and composing data.

Slide 80

Slide 80 text

Completable • Either completes or errors. Has no items! • No backpressure support. • Convenience methods for transforming and composing data. • Think "reactive runnable".

Slide 81

Slide 81 text

Maybe

Slide 82

Slide 82 text

Maybe ALL NEW!!!!!

Slide 83

Slide 83 text

Maybe • Either succeeds with an item, completes with no items, or errors. • No backpressure support. • Convenience methods for transforming  and composing data. ALL NEW!!!!!

Slide 84

Slide 84 text

Maybe • Either succeeds with an item, completes with no items, or errors. • No backpressure support. • Convenience methods for transforming  and composing data. • Think "reactive optional". ALL NEW!!!!!

Slide 85

Slide 85 text

Specializations • Encoding subsets of Observable into the type system. • Single – Item or error. Think "scalar". • Completable – Complete or error. Think "runnable". • Maybe – Item, complete, or error. Think "optional".

Slide 86

Slide 86 text

Slide 87

Slide 87 text

Operator Specialization

Slide 88

Slide 88 text

Operator Specialization first() Observable

Slide 89

Slide 89 text

Operator Specialization first() Observable Observable

Slide 90

Slide 90 text

Operator Specialization 1 2 3 4 5 6 7 8 9 10 11 first() 1 Observable Observable

Slide 91

Slide 91 text

Operator Specialization first() Observable Single

Slide 92

Slide 92 text

Operator Specialization 1 2 3 4 5 6 7 8 9 10 11 first() 1 Observable Single

Slide 93

Slide 93 text

Operator Specialization first() Observable Single NoSuchElementException

Slide 94

Slide 94 text

Operator Specialization firstElement() Observable

Slide 95

Slide 95 text

Operator Specialization firstElement() Observable Maybe

Slide 96

Slide 96 text

Operator Specialization firstElement() Observable Maybe

Slide 97

Slide 97 text

Operator Specialization ignoreElements() Observable

Slide 98

Slide 98 text

Operator Specialization ignoreElements() Observable Completable

Slide 99

Slide 99 text

Operator Specialization 1 2 3 4 5 6 7 8 9 ignoreElements() Observable Completable

Slide 100

Slide 100 text

Operator Specialization ignoreElements() Flowable Completable

Slide 101

Slide 101 text

Operator Specialization 1 2 3 4 5 6 7 8 9 ignoreElements() Flowable Completable

Slide 102

Slide 102 text

Operator Specialization firstElement() Flowable Maybe

Slide 103

Slide 103 text

Operator Specialization first() Flowable Single

Slide 104

Slide 104 text

Flowable Observable Maybe Single Completable Flowable toObservable() reduce() elementAt() firstElement() lastElement() singleElement() scan() elementAt() first()/firstOrError() last()/lastOrError() single/singleOrError() all()/any()/count() (and more) ignoreElements() Observable toFlowable() reduce() elementAt() firstElement() lastElement() singleElement() scan() elementAt() first()/firstOrError() last()/lastOrError() single/singleOrError() all()/any()/count() (and more) ignoreElements() Maybe toFlowable() toObservable() toSingle() sequenceEqual() toCompletable() Single toFlowable() toObservable() toMaybe() toCompletable() Completable toFlowable() toObservable() toMaybe() toSingle() toSingleDefault() From To

Slide 105

Slide 105 text

Slide 106

Slide 106 text

Slide 107

Slide 107 text

Creating Sources

Slide 108

Slide 108 text

Creating Sources Flowable.just("Hello");  Flowable.just("Hello", "World");   Observable.just("Hello");  Observable.just("Hello", "World");  Maybe.just("Hello");  Single.just("Hello");

Slide 109

Slide 109 text

Creating Sources String[] array = { "Hello", "World" };  List list = Arrays.asList(array);  Flowable.fromArray(array); Flowable.fromIterable(list); Observable.fromArray(array); Observable.fromIterable(list);

Slide 110

Slide 110 text

Creating Sources Future future = CompletableFuture.completedFuture("Hello");  Flowable.fromFuture(future);  Observable.fromFuture(future);

Slide 111

Slide 111 text

Creating Sources Flowable.empty();    Observable.empty();    Maybe.empty();    Completable.complete();

Slide 112

Slide 112 text

Creating Sources Flowable.never();    Observable.never();    Maybe.never(); Single.never();    Completable.never();

Slide 113

Slide 113 text

Creating Sources Flowable.error(new RuntimeException());  Observable.error(new RuntimeException());  Maybe.error(new RuntimeException());  Single.error(new RuntimeException());  Completable.error(new RuntimeException());

Slide 114

Slide 114 text

Creating Sources Observable.fromCallable(new Callable() {  @Override public String call() {Y  return getName();  }X  });

Slide 115

Slide 115 text

Creating Sources Observable.fromCallable(new Callable() {  @Override public String call() throws Exception {Y  return getName();Z  }X  });

Slide 116

Slide 116 text

Creating Sources OkHttpClient client = // … Request request = // … Observable.fromCallable(new Callable() {  @Override public String call() throws Exception {Y  return client.newCall(request).execute();Z  }X  });     getName()

Slide 117

Slide 117 text

Creating Sources Flowable.fromCallable(() -> "Hello");    Observable.fromCallable(() -> "Hello");    Maybe.fromCallable(() -> "Hello");  Maybe.fromAction(() -> System.out.println("Hello"));  Maybe.fromRunnable(() -> System.out.println("Hello"))    Single.fromCallable(() -> "Hello");    Completable.fromCallable(() -> "Ignored!");  Completable.fromAction(() -> System.out.println("Hello"));  Completable.fromRunnable(() -> System.out.println("Hello"));

Slide 118

Slide 118 text

Creating Sources Observable.create();

Slide 119

Slide 119 text

Creating Sources Observable.create(); 100% LESS AWFUL!!!

Slide 120

Slide 120 text

Creating Sources Observable.create(new ObservableOnSubscribe() {  @Override  public void subscribe(ObservableEmitter e) throws Exception {  e.onNext("Hello");  e.onComplete();  }X  });

Slide 121

Slide 121 text

Creating Sources Observable.create(new ObservableOnSubscribe() {  @Override  public void subscribe(ObservableEmitter e) throws Exception {  e.onNext("Hello");  e.onComplete();  }X  });

Slide 122

Slide 122 text

Creating Sources Observable.create(new ObservableOnSubscribe() {  @Override  public void subscribe(ObservableEmitter e) throws Exception {  e.onNext("Hello");  e.onComplete();  }X  });

Slide 123

Slide 123 text

Creating Sources Observable.create(e -> {  e.onNext("Hello");  e.onComplete();  }); new ObservableOnSubscribe()  @Override  public void subscribe(ObservableEmitter ) throws Exception {      }X 

Slide 124

Slide 124 text

Creating Sources Observable.create(e -> {  e.onNext("Hello"); e.onNext("World");  e.onComplete();  });

Slide 125

Slide 125 text

Creating Sources OkHttpClient client = // … Request request = // … Observable.create(e -> { client.newCall(request).enqueue(new Callback() { @Override public void onResponse(Response r) throws IOException { e.onNext(r.body().string()); e.onComplete(); }A @Override public void onFailure(IOException e) { e.onError(e); }B });  });   e.onNext("Hello"); e.onNext("World");  e.onComplete();

Slide 126

Slide 126 text

Creating Sources OkHttpClient client = // … Request request = // … Observable.create(e -> { Call call = client.newCall(request); call.enqueue(new Callback() { @Override public void onResponse(Response r) throws IOException { e.onNext(r.body().string()); e.onComplete(); }A @Override public void onFailure(IOException e) { e.onError(e); }B });  });

Slide 127

Slide 127 text

Creating Sources OkHttpClient client = // … Request request = // … Observable.create(e -> { Call call = client.newCall(request); e.setCancelation(() -> call.cancel()); call.enqueue(new Callback() { @Override public void onResponse(Response r) throws IOException { e.onNext(r.body().string()); e.onComplete(); }A @Override public void onFailure(IOException e) { e.onError(e); }B });  });

Slide 128

Slide 128 text

Slide 129

Slide 129 text

Creating Sources View view = // … Observable.create(e -> { e.setCancelation(() -> view.setOnClickListener(null)); view.setOnClickListener(v -> e.onNext(v));  }); OkHttpClient client = // ... Request request = // ... Call call = client.newCall(request); e.setCancelation(() -> call.cancel()); call.enqueue(new Callback() { @Override public void onResponse(Response r) throws IOException { e.onNext(r.body().string()); e.onComplete(); }A @Override public void onFailure(IOException e) { e.onError(e); }B }); 

Slide 130

Slide 130 text

Creating Sources Flowable.create(e -> { … }); Observable.create(e -> { … }); Maybe.create(e -> { … }); Single.create(e -> { … }); Completable.create(e -> { … });

Slide 131

Slide 131 text

Observing Sources

Slide 132

Slide 132 text

Observing Sources Observable Flowable interface Subscriber {  void onNext(T t);  void onComplete();  void onError(Throwable t);  void onSubscribe(Subscription s);  }B interface Observer {  void onNext(T t);  void onComplete();  void onError(Throwable t);  void onSubscribe(Disposable d);  }B

Slide 133

Slide 133 text

Observing Sources Observable Flowable interface Subscriber {  void onNext(T t);  void onComplete();  void onError(Throwable t);  void onSubscribe(Subscription s);  }B interface Observer {  void onNext(T t);A  void onComplete();B  void onError(Throwable t);C  void onSubscribe(Disposable d);D  }B interface Disposable {  void dispose();  }B interface Subscription {  void cancel();  void request(long r);  }B

Slide 134

Slide 134 text

Observing Sources Observable o = Observable.just("Hello"); o.subscribe(new Observer() {  @Override public void onNext(String s) { … }  @Override public void onComplete() { … }  @Override public void onError(Throwable t) { … }   @Override public void onSubscribe(Disposable d) { ??? }B  }); Flowable interface Subscriber {  void onNext(T t);  void onComplete();  void onError(Throwable t);  void onSubscribe(Subscription s);  }B interface Disposable {  void dispose();  }B interface Subscription {  void cancel();  void request(long r);  }B interface T  T t ;A  ;B  ;C  ;D 

Slide 135

Slide 135 text

Observing Sources Observable o = Observable.just("Hello"); o.subscribe(new DisposableObserver() {  @Override public void onNext(String s) { … }  @Override public void onComplete() { … }  @Override public void onError(Throwable t) { … }  });         @Override public void onSubscribe(Disposable d) { ??? }B 

Slide 136

Slide 136 text

Slide 137

Slide 137 text

Observing Sources Observable o = Observable.just("Hello"); DisposableObserver observer = new DisposableObserver() {  @Override public void onNext(String s) { … }  @Override public void onComplete() { … }  @Override public void onError(Throwable t) { … }  } o.subscribe(observer);Z unsubscribe???

Slide 138

Slide 138 text

Slide 139

Slide 139 text

Slide 140

Slide 140 text

Observing Sources Observable o = Observable.just("Hello"); o.subscribeWith(new DisposableObserver() {  @Override public void onNext(String s) { … }  @Override public void onComplete() { … }  @Override public void onError(Throwable t) { … }  });Z

Slide 141

Slide 141 text

Observing Sources Observable o = Observable.just("Hello"); Disposable d = o.subscribeWith(new DisposableObserver() {  @Override public void onNext(String s) { … }  @Override public void onComplete() { … }  @Override public void onError(Throwable t) { … }  });Z d.dispose();

Slide 142

Slide 142 text

Observing Sources Observable o = Observable.just("Hello"); CompositeDisposable disposables = new CompositeDisposable(); Disposable d = o.subscribeWith(new DisposableObserver() {  @Override public void onNext(String s) { … }  @Override public void onComplete() { … }  @Override public void onError(Throwable t) { … }  });Z disposables.add(d);         d.dispose();

Slide 143

Slide 143 text

Slide 144

Slide 144 text

Observing Sources Observable o = Observable.just("Hello"); o.subscribeWith(new DisposableObserver() { … });Z Maybe m = Maybe.just("Hello"); m.subscribeWith(new DisposableMaybeObserver() { … });Z Single s = Single.just("Hello"); s.subscribeWith(new DisposableSingleObserver() { … });Z Completable c = Completable.completed(); c.subscribeWith(new DisposableCompletableObserver() { … });Z

Slide 145

Slide 145 text

Observing Sources Flowable f = Flowable.just("Hello"); f.subscribeWith(new DisposableSubscriber() { … }); Observable o = Observable.just("Hello"); o.subscribeWith(new DisposableObserver() { … }); Maybe m = Maybe.just("Hello"); m.subscribeWith(new DisposableMaybeObserver() { … }); Single s = Single.just("Hello"); s.subscribeWith(new DisposableSingleObserver() { … }); Completable c = Completable.completed(); c.subscribeWith(new DisposableCompletableObserver() { … });

Slide 146

Slide 146 text

Slide 147

Slide 147 text

Observing Sources Flowable f = Flowable.just("Hello"); Disposable d1 = f.subscribeWith(new DisposableSubscriber() { … }); Observable o = Observable.just("Hello"); Disposable d2 = o.subscribeWith(new DisposableObserver() { … }); Maybe m = Maybe.just("Hello"); Disposable d3 = m.subscribeWith(new DisposableMaybeObserver() { … }); Single s = Single.just("Hello"); Disposable d4 = s.subscribeWith(new DisposableSingleObserver() { … }); Completable c = Completable.completed(); Disposable d5 = c.subscribeWith(new DisposableCompletableObserver() { … });

Slide 148

Slide 148 text

RxJava

Slide 149

Slide 149 text

RxJava • 2.0.0-RC3 was released 2016-09-23.

Slide 150

Slide 150 text

RxJava • 2.0.0-RC3 was released 2016-09-23. • Releases are more like developer previews than release candidates.

Slide 151

Slide 151 text

RxJava • 2.0.0-RC3 was released 2016-09-23. • Releases are more like developer previews than release candidates. • Next two are scheduled for 2016-10-07 and 2016-10-21.

Slide 152

Slide 152 text

RxJava • 2.0.0-RC3 was released 2016-09-23. • Releases are more like developer previews than release candidates. • Next two are scheduled for 2016-10-07 and 2016-10-21. • Final release scheduled for 2016-10-29.

Slide 153

Slide 153 text

RxJava • Package name is io.reactivex.*.

Slide 154

Slide 154 text

RxJava • Package name is io.reactivex.*. • Maven coordinates are io.reactivex.rxjava2:rxjava.

Slide 155

Slide 155 text

RxJava • Package name is io.reactivex.*. • Maven coordinates are io.reactivex.rxjava2:rxjava. • Why the change? See http://jakes.link/major-versions

Slide 156

Slide 156 text

RxAndroid

Slide 157

Slide 157 text

RxAndroid • 2.0.0-RC1 was released 2016-08-25.

Slide 158

Slide 158 text

RxAndroid • 2.0.0-RC1 was released 2016-08-25. • Provides facilities for dealing with the main thread (or any Looper).

Slide 159

Slide 159 text

RxAndroid • 2.0.0-RC1 was released 2016-08-25. • Provides facilities for dealing with the main thread (or any Looper). • Package name is io.reactivex.android.*.

Slide 160

Slide 160 text

RxAndroid • 2.0.0-RC1 was released 2016-08-25. • Provides facilities for dealing with the main thread (or any Looper). • Package name is io.reactivex.android.*. • Maven coordinates are io.reactivex.rxjava2:rxandroid.

Slide 161

Slide 161 text

Living with 1.x and 2.x

Slide 162

Slide 162 text

Living with 1.x and 2.x class RxJavaInterop {  static Flowable toV2Flowable(rx.Observable o) { … }  static Observable toV2Observable(rx.Observable o) { … } static Maybe toV2Maybe(rx.Single s) { … } static Maybe toV2Maybe(rx.Completable c) { … }  static Single toV2Single(rx.Single s) { … }  static Completable toV2Completable(rx.Completable c) { … }   static rx.Observable toV1Observable(Publisher p) { … } static rx.Observable toV1Observable(Observable o, …) { … }  static rx.Single toV1Single(Single o) { … } static rx.Single toV1Single(Maybe m) { … }  static rx.Completable toV1Completable(Completable c) { … } static rx.Completable toV1Completable(Maybe m) { … }  }X

Slide 163

Slide 163 text

Slide 164

Slide 164 text

dependencies {  compile 'io.reactivex.rxjava2:rxjava:2.0.0-RC3'  compile 'io.reactivex.rxjava2:rxandroid:2.0.0-RC1' // Optionally...  compile 'com.github.akarnokd:rxjava2-interop:0.3.0' }

Slide 165

Slide 165 text

Other Libraries We Control

Slide 166

Slide 166 text

Other Libraries We Control • Retroﬁt 2 – github.com/JakeWharton/retroﬁt2-rxjava2-adapter/

Slide 167

Slide 167 text

Other Libraries We Control • Retrofit 2 – github.com/JakeWharton/retrofit2-rxjava2-adapter/ • RxBinding – waiting for 2.0 final • RxRelay – waiting for 2.0 final • RxReplayingShare – waiting for 2.0 final • SQL Brite – waiting for 2.0 final • Whorlwind – waiting for 2.0 final

Slide 168

Slide 168 text

RxJava 2

Slide 169

Slide 169 text

RxJava 2 • Reactive Streams compliant.

Slide 170

Slide 170 text

RxJava 2 • Reactive Streams compliant. • Backpressure in the type system (Flowable).

Slide 171

Slide 171 text

RxJava 2 • Reactive Streams compliant. • Backpressure in the type system (Flowable). • New Maybe type.

Slide 172

Slide 172 text

RxJava 2 • Reactive Streams compliant. • Backpressure in the type system (Flowable). • New Maybe type. • Actually usable create().

Slide 173

Slide 173 text

RxJava 2 • Reactive Streams compliant. • Backpressure in the type system (Flowable). • New Maybe type. • Actually usable create(). • All the same operators.

Slide 174

Slide 174 text

RxJava 2 • Reactive Streams compliant. • Backpressure in the type system (Flowable). • New Maybe type. • Actually usable create(). • All the same operators. • Preview releases now, ﬁnal release in a month.

Slide 175

Slide 175 text

jakewharton jakewharton jakewharton twitter.com/ google.com/+ .com Looking Ahead To   RxJava 2