An Introduction to RxJava

1. An Introduction
to RxJava
Matt Dupree

5. mSearchView.setOnQueryTextListener(
new SearchView.OnQueryTextListener() {
@Override
public boolean onQueryTextSubmit(String s) {
mSearchView.clearFocus();
return true;
}
@Override
public boolean onQueryTextChange(String s) {
searchFor(s);
return true;
}
});

6. mSearchView.setOnQueryTextListener(
new SearchView.OnQueryTextListener() {
@Override
public boolean onQueryTextSubmit(String s) {
mSearchView.clearFocus();
return true;
}
@Override
public boolean onQueryTextChange(String s) {
searchFor(s);
return true;
}
});

7. private void searchFor(String query) {
// ANALYTICS EVENT: Start a search on the Search activity
// Contains: Nothing (Event params are constant: Search query
// not included)
AnalyticsHelper.sendEvent(SCREEN_LABEL, "Search", "");
Bundle args = new Bundle(1);
if (query == null) {
query = "";
}
args.putString(ARG_QUERY, query);
if (TextUtils.equals(query, mQuery)) {
getLoaderManager()
.initLoader(SearchTopicsSessionsQuery.TOKEN, args,
this);
} else {
getLoaderManager()
.restartLoader(SearchTopicsSessionsQuery.TOKEN, args,
this);
}
mQuery = query;
}

8. private void searchFor(String query) {
// ANALYTICS EVENT: Start a search on the Search activity
// Contains: Nothing (Event params are constant: Search query
// not included)
AnalyticsHelper.sendEvent(SCREEN_LABEL, "Search", "");
Bundle args = new Bundle(1);
if (query == null) {
query = "";
}
args.putString(ARG_QUERY, query);
if (TextUtils.equals(query, mQuery)) {
getLoaderManager()
.initLoader(SearchTopicsSessionsQuery.TOKEN, args,
this);
} else {
getLoaderManager()
.restartLoader(SearchTopicsSessionsQuery.TOKEN, args,
this);
}
mQuery = query;
}

9. @Override
public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
mResultsAdapter.swapCursor(data);
mSearchResults.setVisibility(
data.getCount() > 0 ? View.VISIBLE : View.GONE);
}

10. we’re missing an
abstraction

11. Observable

12. declaratively
composable sequence

13. declaratively
composable sequence

14. declaratively
composable sequence

15. Observables in Action

16. I was pretty much dragged into RxJava by my coworkers...[RxJava]
was a lot like git...when I first learned git, I didn’t really learn it. I just
spent three weeks being mad at it...and then something clicked
and I was like ‘Oh! I get it! And this is amazing and I love it!' The
same thing happened with RxJava.
—Dan Lew, Google Developer Expert

17. Java’s
Array
Memory
Composition
Rx
Observable

18. Java’s
Array
Memory
Composition
Rx
Observable

19. Java’s
Array
Memory
Composition
Rx
Observable

20. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable

21. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable

22. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable

23. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable

24. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable
???
???

25. declaratively
composable sequence

26. declaratively
composable sequence

27. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable

28. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable
Javascript’s
Array

29. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable
Javascript’s
Array

30. declaratively
composable array

31. imperatively
composable array

32. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable
Javascript’s
Array

33. Country[] northAmericanCountries = {
new Country("United States", 300e6),
new Country("Canada", 36e6),
new Country("Mexico", 127e6),
//...
};

34. double[] getPopulations(Country[] counties) {
double[] populations = new double[counties.length];
for (int i = 0; i < counties.length; i++) {
populations[i] = counties[i].getPopulation();
}
return populations;
}

35. double[] getPopulations(Country[] counties) {
double[] populations = new double[counties.length];
for (int i = 0; i < counties.length; i++) {
populations[i] = counties[i].getPopulation();
}
return populations;
}

36. double[] getPopulations(Country[] counties) {
double[] populations = new double[counties.length];
for (int i = 0; i < counties.length; i++) {
populations[i] = counties[i].getPopulation();
}
return populations;
}

37. double[] getPopulations(Country[] counties) {
double[] populations = new double[counties.length];
for (int i = 0; i < counties.length; i++) {
populations[i] = counties[i].getPopulation();
}
return populations;
}

38. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable
Javascript’s
Array

39. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable
Javascript’s
Array

40. const countries = [
{ name: "United States", population: 300e6 },
{ name: "Canada", population: 36e6 },
{ name: "Mexico", population: 107e6 }
];

41. const getPopulations
= (countries) => countries.map(it => it.population);

42. class Array {
map(transform) {
const newList = [];
for (let i = 0; i < this.size; i++) {
newList.push(transform(this[i]));
}
return newList;
}
}

43. map

44. map
filter

45. map
filter
reduce

46. const northAmericanPopExcludingUs = countries
.filter(it => it.name === "United States")
.map(it => it.population)
.reduce((totalPop, countryPop) => totalPop + countryPop);

47. const northAmericanPopExcludingUs = countries
.filter(it => it.name === "United States")
.map(it => it.population)
.reduce((totalPop, countryPop) => totalPop + countryPop);

48. const northAmericanPopExcludingUs = countries
.filter(it => it.name === "United States")
.map(it => it.population)
.reduce((totalPop, countryPop) => totalPop + countryPop);

49. const northAmericanPopExcludingUs = countries
.filter(it => it.name === "United States")
.map(it => it.population)
.reduce((totalPop, countryPop) => totalPop + countryPop);

50. const northAmericanPopExcludingUs = countries
.filter(it => it.name === "United States")
.map(it => it.population)
.reduce((totalPop, countryPop) => totalPop + countryPop);

51. const northAmericanPopExcludingUs = countries
.filter(it => it.name === "United States")
.map(it => it.population)
.reduce((totalPop, countryPop) => totalPop + countryPop);

52. 300e6 + 36e6 + 127e6 + …

53. declaratively
composable array

54. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable
Javascript’s
Array

55. map
filter
reduce

56. map
filter
reduce
+ LinkedList

57. map
filter
reduce
+ LinkedList = 💥

58. How is the sequence
stored in memory?

59. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable
Javascript’s
Array

60. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable
Javascript’s
Array

61. Array

62. Array LinkedList

63. Array LinkedList
Iterable

64. Country[] northAmericanCountries = {
new Country("United States", 300e6),
new Country("Canada", 36e6),
new Country("Mexico", 127e6),
//...
};

65. for (int i = 0; i < northAmericanCountries.length; i++) {
System.out.println(northAmericanCountries[i]);
}

66. for (int i = 0; i < linkedList.length; i++) {
System.out.println(linkedList[i]);
}

67. for (final Object object : array) {
System.out.println(object);
}

68. for (final Object object : linkedList) {
System.out.println(object);
}

69. for (final Object object : iterable) {
System.out.println(object);
}

70. How is the sequence
stored in memory?

71. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable
Javascript’s
Array

72. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable
Javascript’s
Array

73. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable
Javascript’s
Array

74. declaratively
composable iterable

75. fun getPopulations(countries: Iterable<Country>)
= countries.map { it.population }

76. fun getPopulations(countries: Iterable<Country>)
= countries.map { it.population }

77. fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {
val destination = ArrayList<R>(collectionSizeOrDefault(10))
for (item in this)
destination.add(transform(item))
return destination
}

78. fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {
val destination = ArrayList<R>(collectionSizeOrDefault(10))
for (item in this)
destination.add(transform(item))
return destination
}

79. fun getTotalPopulationExcludingUs(countries: Iterable<Country>)
= countries
.filter { it.name == "United States" }
.map { it.population }
.reduce { total, currentPop -> total + currentPop }

80. fun getTotalPopulationExcludingUs(countries: Iterable<Country>)
= countries
.filter { it.name == "United States" }
.map { it.population }
.reduce { total, currentPop -> total + currentPop }

81. fun getTotalPopulationExcludingUs(countries: Iterable<Country>)
= countries
.filter { it.name == "United States" }
.map { it.population }
.reduce { total, currentPop -> total + currentPop }

82. fun getTotalPopulationExcludingUs(countries: Iterable<Country>)
= countries
.filter { it.name == "United States" }
.map { it.population }
.reduce { total, currentPop -> total + currentPop }

83. 300e6 + 36e6 + 127e6 + …

84. declaratively
composable iterable

85. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable
Javascript’s
Array

86. Java’s
Array
Java’s
Iterable
Memory
Composition
Kotlin’s
Iterable;
Java 8
Streams
Rx
Observable
Javascript’s
Array

88. declaratively
composable sequence

89. declaratively
composable sequence

90. button.setOnClickListener(new View.OnClickListener() {
@Override public void onClick(View v) {
trackClick();
}
});

91. for (int buttonClick : buttonClicks) {
trackClick();
}
button.setOnClickListener(new View.OnClickListener() {
@Override public void onClick(View v) {
trackClick();
}
});

92. for (int buttonClick : buttonClicks) {
trackClick();
}
button.forEachClick(new View.OnClickListener() {
@Override public void onClick(View v) {
trackClick();
}
});

93. for (int buttonClick : buttonClicks) {
trackClick();
}
clickSequence.forEachClick(new View.OnClickListener() {
@Override public void onClick(View v) {
trackClick();
}
});

94. clickSequence.forEachClick(new View.OnClickListener() {
@Override public void onClick(View v) {
trackClick();
}
});

95. clickObservable.subscribe(new Consumer<View> {
@Override public void accept(View v) {
trackClick();
}
});

96. declaratively
composable sequence

97. declaratively
composable sequence

98. declaratively composable
iterable

99. map
filter
reduce

100. map
filter
reduce
+ LinkedList

101. map
filter
reduce
+ LinkedList = 💥

102. How is the sequence
stored in memory?

103. Iterable

104. How is the sequence
stored in memory?

105. map
filter
reduce

106. map
filter
reduce
+ Async

107. map
filter
reduce
+ Async = 💥

108. Is the sequence
currently in memory?

109. Observable

110. Is the sequence
currently in memory?

111. Array

112. Array LinkedList

113. Array LinkedList
Iterable

114. Array LinkedList
Iterable
…

115. Array LinkedList
Iterable
…

116. Array LinkedList
Iterable
…
Sequence

117. Array LinkedList
Iterable
…
Sequence

118. Array LinkedList
Iterable
…
Observable

119. declaratively
composable sequence

122. [k, ke, key, keyn, keyno, keynot, keynote]
[results for ‘k’, results for ‘ke', results for ‘key’…]
for each result, update UI

123. makeQueryTextObservable(mSearchView)
.flatMap { s -> makeLoadObservable(s) }
.subscribe { cursor ->
mResultsAdapter.swapCursor(cursor)
}

124. makeQueryTextObservable(mSearchView)
.flatMap { s -> makeLoadObservable(s) }
.subscribe { cursor ->
mResultsAdapter.swapCursor(cursor)
}

125. [k, ke, key, keyn, keyno, keynot, keynote]
makeQueryTextObservable(mSearchView)
.flatMap { s -> makeLoadObservable(s) }
.subscribe { cursor ->
mResultsAdapter.swapCursor(cursor)
}

126. makeQueryTextObservable(mSearchView)
.flatMap { s -> makeLoadObservable(s) }
.subscribe { cursor ->
mResultsAdapter.swapCursor(cursor)
}

127. makeQueryTextObservable(mSearchView)
.flatMap { s -> makeLoadObservable(s) }
.subscribe { cursor ->
mResultsAdapter.swapCursor(cursor)
}

128. makeQueryTextObservable(mSearchView)
.flatMap { s -> makeLoadObservable(s) }
.subscribe { cursor ->
mResultsAdapter.swapCursor(cursor)
}
[results for ‘k’, results for ‘ke', results for ‘key’…]

129. makeQueryTextObservable(mSearchView)
.flatMap { s -> makeLoadObservable(s) }
.subscribe { cursor ->
mResultsAdapter.swapCursor(cursor)
}

130. makeQueryTextObservable(mSearchView)
.flatMap { s -> makeLoadObservable(s) }
.subscribe { cursor ->
mResultsAdapter.swapCursor(cursor)
}

131. makeQueryTextObservable(mSearchView)
.flatMap { s -> makeLoadObservable(s) }
.subscribe { cursor ->
mResultsAdapter.swapCursor(cursor)
}

132. makeQueryTextObservable(mSearchView)
.filter { s -> s.length > 3 }
.flatMap { s -> makeLoadObservable(s) }
.subscribe { cursor ->
mResultsAdapter.swapCursor(cursor)
}

133. makeQueryTextObservable(mSearchView)
.filter { s -> s.length > 3 }
.flatMap { s -> makeLoadObservable(s) }
.subscribe { cursor ->
mResultsAdapter.swapCursor(cursor)
}

134. [k, ke, key, keyn, keyno, keynot, keynote]
filter
[keyn, keyno, keynot, keynote]

135. makeQueryTextObservable(mSearchView)
.filter { s -> s.length > 3 }
.flatMap { s -> makeLoadObservable(s) }
.subscribe { cursor ->
mResultsAdapter.swapCursor(cursor)
}

136. makeQueryTextObservable(mSearchView!!)
.filter { s -> s.length > 3 }
.debounce(300, TimeUnit.MILLISECONDS)
.flatMap { s -> makeLoadObservable(s) }
.subscribe { cursor ->
mResultsAdapter!!.swapCursor(cursor)
}

137. makeQueryTextObservable(mSearchView!!)
.filter { s -> s.length > 3 }
.debounce(300, TimeUnit.MILLISECONDS)
.flatMap { s -> makeLoadObservable(s) }
.subscribe { cursor ->
mResultsAdapter!!.swapCursor(cursor)
}

138. makeQueryTextObservable(mSearchView!!)
.filter { s -> s.length > 3 }
.debounce(300, TimeUnit.MILLISECONDS)
.flatMap { s -> makeLoadObservable(s) }
.subscribe { cursor ->
mResultsAdapter!!.swapCursor(cursor)
}

139. makeQueryTextObservable(mSearchView!!)
.filter { s -> s.length > 3 }
.debounce(300, TimeUnit.MILLISECONDS)
.flatMap { s -> makeLoadObservable(s) }
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe { cursor ->
mResultsAdapter!!.swapCursor(cursor)
}

140. makeQueryTextObservable(mSearchView!!)
.filter { s -> s.length > 3 }
.debounce(300, TimeUnit.MILLISECONDS)
.flatMap { s -> makeLoadObservable(s) }
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe { cursor ->
mResultsAdapter!!.swapCursor(cursor)
}

141. makeQueryTextObservable(mSearchView!!)
.filter { s -> s.length > 3 }
.debounce(300, TimeUnit.MILLISECONDS)
.flatMap { s -> makeLoadObservable(s) }
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe { cursor ->
mResultsAdapter!!.swapCursor(cursor)
}

142. declaratively
composable sequence

144. An Introduction to
RxJava
https://twitter.com/philosohacker
https://twitter.com/unikeytech