RxApplications

Transcript

RxApplications
Kevin Carpenter
Notion AI

Application behavior is asynchronous.

Pull to Refresh

GET https://hacker-news.firebaseio.com/v0/items
[{
"by": "jamesblonde",
"descendants": 0,
"id": 11595667,
"score": 2,
"time": 1461937655,
"title": “Make email great again”,
"type": "story",
"url": “https:\/\/email.net/great”
}]

View Slide

INSERT INTO items (title, author, points, date) 
VALUES (‘Rx’, ‘kevcar’, 90, 1492278237562)

View Slide

DELETE FROM items WHERE date <
1492278000 AND date > 1492280000

View Slide

☝

View Slide

☝
swipeRefreshLayout.setOnRefreshListener(
new SwipeRefreshLayout.OnRefreshListener() {
@Override
public void onRefresh() {
// make update request
}
}
);

RxJava

RxJava
RxJS

RxJava
RxJS
RxKotlin

RxJava
RxJS
RxKotlin
RxSwift

View Slide

“ReactiveX is a combination of the best ideas from the
Observer pattern, the Iterator pattern, and functional programming”

View Slide

abstract class Observer {
 
fun update(T notification)
 
}

View Slide

abstract class Observable {
 
private val ArrayList> observers;  
 
fun registerObserver(Observer observer) {  
observers.add(observer);  
}  
 
fun unregisterObserver(Observer observer) {  
observers.remove(observer);  
}  
}  

View Slide

abstract class Observable {
 
private val observers: ArrayList>  
 
fun registerObserver(observer: Observer) {  
}  
 
fun unregisterObserver(observer: Observer) {  
}  
}  

View Slide

abstract class Observable {  
private val observers: ArrayList> 
 
void registerObserver(observer: Observer) {  
observers.add(observer)  
}  
 
void unregisterObserver(observer: Observer) {  
observers.remove(observer); 
}  
 
void setValue(newValue: T) {  
this.value = newValue 
notifyObservers(newValue) 
}  
}  

View Slide

abstract class Observable {  
private val observers: ArrayList> ;  
 
fun registerObserver(observer: Observer) {  
}  
 
fun unregisterObserver(observer: Observer) {  
}  
 
fun setValue(newValue: T) {  
this.value = newValue;  
notifyObservers(newValue);  
}  
 
fun notifyObservers(value: T) {  
for (observer : observers) {  
observer.update(value);  
}  
}  
}

View Slide

interface Iterable  
 
fun iterator(): Iterator  
 
}

View Slide

interface Iterator  
 
fun hasNext(): Boolean  
 
fun next(): T  
 
}

View Slide

val sounds: Iterable = listOf(
"moo", "cluck", “quack"
)  
 
while (sounds.iterator().hasNext()) {  
log.d("Animal Sound", sounds.next())  
}

View Slide

)  
 
}
D/Animal Sound: moo

View Slide

)  
 
}
D/Animal Sound: moo
D/Animal Sound: cluck

View Slide

)  
 
}
D/Animal Sound: moo
D/Animal Sound: quack 

View Slide

)  
 
sounds.map { sound ->  
sound + sound // "$sound $sound"  
}  
.map { doubleSound ->  
log.d("Animal Sound", doubleSound)  
}

View Slide

)  
 
}  
}
D/Animal Sound: moo moo 

View Slide

)  
 
}  
}
D/Animal Sound: moo moo
D/Animal Sound: cluck cluck

View Slide

)  
 
}  
}
D/Animal Sound: moo moo
D/Animal Sound: cluck cluck
D/Animal Sound: quack quack 

View Slide

f(x) = y

View Slide

{ x ->
x * x;
}

View Slide

int square(int x) {  
int square = x * x;  
textView.text = square;  
return result;  
}  

View Slide

int square(int x) {  
int square = x * x;  
this.state.latestSquare = square;  
return result;  
}  

View Slide

// 1, 2, 3 
Observable intObservable = Observable.range(1, 4)  
 
intObservable.map { x ->  
x * x  
}  
.map { squared ->  
"Result: " + squared  
}  
.map { str ->  
log.d(str)  
}

Observable

time

time

time

Observable.from(listOf("moo", "cluck", "quack"))
time

time
moo

time
moo cluck

time
moo cluck quack

time
moo cluck
X

time
moo X

time
moo cluck

Observable.subscribe(
Subscriber subscriber
)

View Slide

abstract class Subscriber {
 
onNext(T t);
 
onError(Throwable e); // Terminal
 
onCompleted(); // Terminal  
}  

View Slide

abstract class Subscriber {  
onNext(T t);  
onError(Throwable e); // Terminal  
onCompleted(); // Terminal  
}  
 
Observable.subscribe(  
Action1 onNext,  
Action1, onError,  
Action0 onCompleted)  

View Slide

val action = Action1 {  
fun event (event: String) {  
log.d("Animal Sound", event)  
}  
}  
 
val errorAction = Action1 {  
fun event (event: Throwable) {  
log.e(event, "Error in Animal Sounds Example")  
}  
}  
 
val completedAction = Action0 {  
fun call {  
log.d("Completed Event", "Animal Sounds are done.")  
}  
}  
 
observable.subscribe(action, errorAction, completedAction)

View Slide

}  
}  
 
}  
}  
 
fun call {  
}  
}  
 

View Slide

}  
}  
 
}  
}  
 
fun call {  
}  
}  
 

View Slide

}  
}  
 
}  
}  
 
fun call {  
}  
}  
 

View Slide

Observable.from(listOf("moo", "cluck", “quack"))
time

View Slide

time
moo
D/Animal Sound: moo

View Slide

time
moo cluck
D/Animal Sound: moo

View Slide

time
moo cluck quack
D/Animal Sound: moo
D/Animal Sound: quack

View Slide

time
moo cluck quack
D/Animal Sound: moo
D/Animal Sound: quack
D/Completed Event: Animal Sounds are Done

View Slide

time
moo cluck
D/Animal Sound: moo
E/Error Event: Error in Animal Sounds example
at com.rxapplications.example.ExampleClass…
X

View Slide

Non-RxViews

View Slide

Pull to Refresh

View Slide

class ItemListView : FrameLayout, IItemListView {  
 
@Inject  
private val model: ItemListViewModel  
 
private val refreshView by bindView(R.id.swipe_view)  
private val adapter = ItemListViewAdapter(context)  
 
override fun onFinishInflate() {  
super.onFinishInflate()  
refreshView.setOnRefreshListener(listener)  
}  
 
override fun onAttachedToWindow() {  
super.onAttachedToWindow()  
model.attach(this)  
}  
 
override fun onDetachedFromWindow() {  
model.detach(this)  
super.onDetachedFromWindow()  
}  
 
private val listener = object : SwipeRefreshLayout.OnRefreshListener {  
override fun onRefresh() {  
model.requestRefresh()  
}  
}
}

View Slide

 
@Inject  
 
 
}  
 
}  
 
}  
 
}  
}
}

View Slide

 
@Inject  
 
 
}  
 
}  
 
}  
 
}  
}
}

View Slide

 
@Inject  
 
 
}  
 
}  
 
}  
 
}  
}
}

View Slide

// Set up 
 
}  
 
}  
 
}
}

View Slide

// Set up 
 
}  
 
}  
 
}
}

View Slide

// Set up 
 
}  
 
}  
 
}
}

View Slide

interface IItemListView {  
 
fun onItemsResponse(items: List)  
 
fun onItemsError(error: Throwable)  
 
fun onRefreshComplete()  
}  
 

View Slide

 
 
 
}  
 

View Slide

 
 
 
}  
 

View Slide

// Set up 
 
}  
 
}  
 
}
private val listener = object : OnRefreshListener {  
}  
}
}

View Slide

// Set up 
 
}  
 
}  
 
}
}  
}
}

View Slide

 
}  
}  
 
override fun onItemsResponse(items: List) {  
adapter.setItems(items)  
}  
 
override fun onItemsError(error: Throwable) {  
log.e(error, "Error in ItemListView")  
}  
 
override fun onRefreshComplete() {  
refreshView.setRefreshing(false)  
}  
 
}

View Slide

 
}  
}  
 
}  
 
}  
 
}  
 
}

View Slide

 
}  
}  
 
}  
 
}  
 
}  
 
}

View Slide

 
}  
}  
 
}  
 
}  
 
}  
 
}

View Slide

 
fun onItemsResponse(items: List)
fun onItemsError(error: Throwable) 
 
fun onRefreshComplete() 
}  
 

View Slide

 
fun onItemsResponse(items: List)
fun onItemsError(error: Throwable) 
 
fun onRefreshComplete()
fun onNextResponsePage(items: List)
fun onNextResponsePageError(error: Throwable) 
 
fun onNextResponsePageComplete() 
}  
 

View Slide

RxViews

View Slide

Pull to Refresh

View Slide

class ItemListView : FrameLayout {  
 
@Inject  
private val subscriptions = CompositeSubscription()  
 
private val refreshView by bindView(R.id.swipe)  
private val adapter = ItemListViewAdapter(context)
 
}  
 

View Slide

 
@Inject  
private val subscriptions = CompositeSubscription()  
 
private val refreshView by bindView(R.id.swipe)  
private val adapter = ItemListViewAdapter(context)
 
}  
 

View Slide

 
super.onAttachedToWindow()
 
subscriptions.add(  
swipeRefreshLayout.refreshes()  
.subscribe(refreshObserver)  
)  
 
model.observeResponse()  
.observeOn(AndroidSchedulers.mainThread())  
.subscribe(responseObserver)  
 
}  
}

View Slide

RxBinding

View Slide

final class SwipeRefreshLayoutRefreshObservable
extends Observable {  
private final SwipeRefreshLayout view;  
 
SwipeRefreshLayoutRefreshObservable(SwipeRefreshLayout view) {  
this.view = view;  
}  
 
@Override
protected void subscribeActual(
Observer super Object> observer) {  
if (!checkMainThread(observer)) {  
return;  
}  
Listener listener = new Listener(view, observer);  
observer.onSubscribe(listener);  
view.setOnRefreshListener(listener);  
}

View Slide

 
}  
 
@Override
return;  
}  
}

View Slide

 
}  
 
@Override
return;  
}  
}

View Slide

 
}  
 
@Override
return;  
}  
Listener listener = new Listener(view, observer); 
}

View Slide

static final class Listener
extends MainThreadDisposable implements OnRefreshListener {
 
private final Observer super Object> observer;  
 
@Override public void onRefresh() {  
if (!isDisposed()) {  
observer.onNext(Notification.INSTANCE);  
}  
}  
 
@Override protected void onDispose() {  
view.setOnRefreshListener(null);  
}  
}  

View Slide

 
 
}  
}  
 
}  
}  

View Slide

 
 
}  
}  
 
}  
}  

View Slide

 
 
)  
 
)  
}  
}  
 

View Slide

 
 
)  
 
)  
}
 
}  
 

View Slide

 
 
)  
 
)  
}
private val refreshObserver = { refresh: Unit ->  
model.refreshMessages()  
} 
}  
 

View Slide

 
 
)  
 
)  
}  
}  
 

View Slide

 
 
)  
 
)  
}  
}  
 

View Slide

 
/* Subscriptions defined here.*/ 
}
private val responseObserver = {
response: Response ->  
if (response.isSuccess()) {  
adapter.setItems(response.items)  
}  
else {
val error = /* Pull Throwable from response */ 
}  
//refreshView.setRefreshing(false) 
refreshView.refreshing = false 
} 
}

View Slide

 
}
}  
else {  
log.e(error, "Error in ItemListView") 
}  
} 
}

View Slide

 
}
}  
else {
}  
} 
}

View Slide

 
}
}  
else {  
log.e(error, "Error in ItemListView") 
} 
} 
}

View Slide

 
 
val responseObservable = model.observeResponse()  
.publish()  
 
responseObservable  
.filter { it.isSuccessful() }  
.subscribe(successObserver)  
)  
 
.filter { !it.isSuccessful() }  
.subscribe(errorObserver)  
)  
 
.subscribe(refreshView.refreshing()) // RxBinding!  
)  
 
.connect()  
)  
} 
}  
 

View Slide

 
 
.publish()  
 
/* subscriptions created here */
.connect()  
) 
}
}  
 

View Slide

override fun onAttachedToWindow() {
 
 
)  
 
)  
}

View Slide

override fun onAttachedToWindow() {
 
 
)  
 
)
responseObservable.connect()  
) 
}

View Slide

 
 
val responseObservable = // Connectable Observable 
 
)  
 
)  
 
.subscribe(refreshView.refreshing()) // RxBinding!  
)  
 
// Connect Observable here 
} 
}  
 

View Slide

 
 
 
)  
}
private val successObserver = {  
adapter.setItems(response.body)  
}
}

View Slide

 
 
 
) 
}
private val errorObserver = {  
val error = /* extract error from response */  
} 
}  
 

View Slide

 
 
 
)  
 
)  
 
.subscribe(refreshView.refreshing())  
)  
 
} 
}  
 

View Slide

 
 
 
.subscribe(successObserver, errorObserver)  
)  
 
)  
 
)  
 
} 
}  
 

View Slide

 
 
 
)  
 
.subscribe(errorObserver, errorObserver)  
)  
 
)  
 
} 
}  
 

View Slide

 
 
 
)  
 
.subscribe(errorObserver, errorObserver)  
)  
 
.subscribe(refreshView.refreshing(), errorObserver)  
)  
 
} 
}  
 

View Slide

RxRequests

View Slide

interface ItemService {
 
@GET("/items")  
fun getItems(): Response>
 
}  
 

View Slide

@Inject  
class GetItems(val service: ItemService) : UseCase {  
 
override fun execute(request: Request): Observable 
 
class Request(val save: Boolean)  
 
class Response(items: Either>)  
}

View Slide

@Inject  
 
override fun execute(request: Request): Observable
 
 
}

View Slide

@Inject  
 
 
 
}

View Slide

@Inject  
 
 
 
}

View Slide

@Inject  
 
override fun execute(request: Request): Observable {  
return service.getItems()  
.map { response ->  
if (response.isSuccessful) {  
Response(Either.ofRight(response.body))  
}  
else {  
val error = /* Pull error out of Response */  
Response(Either.ofLeft(error))  
}  
}  
.onErrorReturn { error ->  
}  
}  
}

View Slide

@Inject  
 
}  
else {  
}  
}  
}  
}  
}

View Slide

@Inject  
 
}  
else {  
}  
}  
}  
}  
}

View Slide

@Inject  
 
}  
else {  
}  
}  
}  
}  
}

View Slide

@Inject  
 
}  
else {  
}  
}  
}  
}  
}

View Slide

@Inject  
class GetItems(
val service: ItemService
val db: SqliteDb) : UseCase {  
 
/* Return Left or Right! */ 
}  
}
.doOnNext { either ->
when (either) {
is Either.Left -> {
db.saveAll(either.data).subscribe()
}
}
} 
}  
}

View Slide

class ItemListViewModel(val getItems: GetItems) {  
 
fun observeResponse(): Observable> {  
return getItems.execute(GetItems.Request(true))  
}  
 
}  
 

View Slide

RxDatabase

View Slide

Observable.create()
(or Flowable.create() or unsafeCreate())

View Slide

Observable.create()
(or Flowable.create() or unsafeCreate())

View Slide

class DbItemDataSource(private val db: SqliteDb) : DbDataSource {  
 
override fun saveAll(items: List): Observable {  
Observable.fromCallable {  
items.forEach {  
db.replaceOrThrow("items", null, items.toQueryString())  
} != -1L  
}  
}  
}

View Slide

RxTesting

View Slide

 
@RunWith(RobolectricTestRunner::class.java)  
class ItemListViewTest {  
 
private var model: ItemListViewModel = /* Instantiate */ 
private val myView: ItemListView = /* Create View */  
 
private val goodResponse: =  
Either.Right(/* List of Items */)  
 
@Test  
fun testAdapterItems() {  
Mockito.when(model.fetchItems())
.thenReturn(goodResponse)
 
myView.invokeRefresh()
 
assertEquals(
goodResponse.data,
myView.getAdapter().items)  
}  
}

View Slide