Skip to content

Commit f13dab5

Browse files
maciej-nowakmaciej-nowak
authored
codes added to rxandroid
1 parent 5a1257c commit f13dab5

File tree

1 file changed

+216
-18
lines changed

1 file changed

+216
-18
lines changed

‎_drafts/2019-05-27-rxandroid.md‎

Lines changed: 216 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -16,35 +16,233 @@ keywords: "reaktywne, reactive, rxandroid, rxjava, reactivex, obserwator, obserw
1616
## Wzorzec
1717
Zadaniem wzorca `Obserwator` jest realizacja mechanizmu komunikacji między obiektami zależnymi poprzez powiadamianie obiektów subskrybentów o zmianie stanu obiektu obserwowanego czy statusie operacji. Obiekt może być obserwowany (`Observable`) przez wielu obserwatorów (`Observer`) i sam może być obserwatorem innych obiektów. Obiekt obserwowany emituje zdarzenia, które trafiają do obserwatorów, a następnie są przez nich przetwarzane.
1818

19-
## Harmonogramy
20-
Wprowadzone w module `RxAndroid` harmonogramy decydują o tym na jakim wątku obiekt obserwowany będzie wykonywał zadanie oraz na jakim wątku obiekt obserwatora będzie odbierał i przetwarzał wyemitowane dane. Najpopularniejszymi harmonogrami są: `AndroidSchedulers.mainThread` - odpowiada za główny wątek aplikacji, `Schedulers.io` - wykorzystywany w nie wymagających operacjach i `Schedulers.computation` - przeznaczony do przetwarzania intensywnych zadań. Wyróżnia się także `Schedulers.newThread`, `Schedulers.single`, `Schedulers.immediate`, `Schedulers.trampoline`, `Schedulers.from`, które różnią się synchronicznością, kolejnością, czasem rozpoczęcia i ilością przetwarzanych zadań. Przypisanie harmonogramu dokonywane jest na obiekcie obserwowanym za pomocą metod `subscribeOn` i `observeOn`.
21-
22-
//TODO example with register schedulers on Observable
23-
2419
## Obserwator
2520
Obiekt obserwatora dokonuje subskrybcji obiektu obserwowanego za pomocą metody `subscribe` wywołanej na obiekcie obserwowanym oraz implementuje metody `onSubscribe`, `onNext`, `onError`, `onComplete` interfejsu `Observer` w celu podjęcia działania w odpowiedzi na stan i emisje obiektu obserwowanego.
2621

27-
//TODO example with Observer interface implementation
22+
{% highlight java %}
23+
private Observer<String> createObserver() {
24+
Observer<String> observer = new Observer<String>() {
25+
@Override
26+
public void onSubscribe(Disposable d) {
27+
//Observer subscribe to Observable
28+
}
29+
30+
@Override
31+
public void onNext(String s) {
32+
//Observer received some data stream
33+
}
34+
35+
@Override
36+
public void onError(Throwable e) {
37+
//Observer received emitted error
38+
}
39+
40+
@Override
41+
public void onComplete() {
42+
//Observer completed receiving data from Observable
43+
}
44+
};
45+
return observer;
46+
}
47+
{% endhighlight %}
2848

2949
## Obserwowany
30-
Obiekt obserwowany w `RxJava` jest strumieniem danych wykonującym operacje i emitującym dane. Podstawowym typem obiektu obserwowanego jest `Observable` - emituje dowolną ilość elementów i kończy się sukcesem lub zdarzeniem błędu. Wyróżnia się również także: `Flowable` - rozszerza `Observable` o wsparcie dla `backpressure` (zarządzanie czasem emitowania i konsumowania zdarzenia), `Single` - emituje jedno zdarzenie lub błąd, `Maybe` - może emitować jedno zdarzenie lub błąd, `Completable` - nie emituje zdarzenia, kończy się sukcesem lub błędem. Obiekt obserwowany może być tworzony za pomocą kilku operatorów jak np.: `create`, `just`, `defer`, `from`, `interval`, `range`, `repeat`, `timer`, które różnią się sposobem definicji, momentem, częstotliwością i zwracanym typem danych emisji.
31-
32-
//TODO example with Observable created with: create (custom type), just, from
33-
34-
## Uchwyt
35-
W celu uniknięcia wycieków pamięci związanych z niepożądaną dłużej subskrypcją obserwatora należy przypisać referencje `Disposable` z poziomu obserwatora oraz wypisać go z subskrypcji.
50+
Obiekt obserwowany w `RxJava` jest strumieniem danych wykonującym operacje i emitującym dane. Podstawowym typem obiektu obserwowanego jest `Observable` - emituje dowolną ilość elementów i kończy się sukcesem lub zdarzeniem błędu. Wyróżnia się również także: `Flowable` - rozszerza `Observable` o wsparcie dla `backpressure` (zarządzanie czasem emitowania i konsumowania zdarzenia), `Single` - emituje jedno zdarzenie lub błąd, `Maybe` - może emitować jedno zdarzenie lub błąd, `Completable` - nie emituje zdarzenia, kończy się sukcesem lub błędem. Obiekt obserwowany może być tworzony za pomocą kilku operatorów jak np.: `create`, `just`, `defer`, `from`, `interval`, `range`, `repeat`, `timer`, które różnią się sposobem definicji, czasem, częstotliwością i zwracanym typem danych emisji.
51+
52+
{% highlight java %}
53+
private Observable<String> createObservableJust() {
54+
//up to 10 items
55+
Observable<String> observable = Observable.just("Catan", "Splendor", "7 Wonders", "Codenames", "Taboo");
56+
return observable;
57+
}
58+
59+
private Observable<String> createObservableFrom() {
60+
//create Observable by one of: fromArray, fromCallable, fromFuture, fromIterable, fromPublisher
61+
Observable<String> observable = Observable.fromArray("Catan", "Splendor", "7 Wonders", "Codenames", "Taboo");
62+
return observable;
63+
}
64+
65+
private Observable<String> createObservable() {
66+
final List<String> data = prepareData();
67+
Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
68+
@Override
69+
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
70+
//emit all data one by one
71+
for(String item : data) {
72+
if(!emitter.isDisposed()) {
73+
emitter.onNext(item);
74+
}
75+
}
76+
//emit completed event
77+
if(!emitter.isDisposed()) {
78+
emitter.onComplete();
79+
}
80+
}
81+
});
82+
return observable;
83+
}
84+
85+
private List<String> prepareData() {
86+
List<String> data = new ArrayList<>();
87+
data.add("Catan");
88+
data.add("Splendor");
89+
data.add("7 Wonders");
90+
data.add("Codenames");
91+
data.add("Taboo");
92+
return data;
93+
}
94+
{% endhighlight %}
3695

37-
//TODO example
96+
## Harmonogramy
97+
Wprowadzone w module `RxAndroid` harmonogramy decydują o tym na jakim wątku obiekt obserwowany będzie wykonywał zadanie oraz na jakim wątku obiekt obserwatora będzie odbierał i przetwarzał wyemitowane dane. Najpopularniejszymi harmonogrami są: `AndroidSchedulers.mainThread` - odpowiada za główny wątek aplikacji, `Schedulers.io` - wykorzystywany w nie wymagających operacjach i `Schedulers.computation` - przeznaczony do przetwarzania intensywnych zadań. Wyróżnia się także `Schedulers.newThread`, `Schedulers.single`, `Schedulers.immediate`, `Schedulers.trampoline`, `Schedulers.from`, które różnią się synchronicznością, kolejnością, czasem rozpoczęcia i ilością przetwarzanych zadań. Przypisanie harmonogramu dokonywane jest na obiekcie obserwowanym za pomocą metod `subscribeOn` i `observeOn`.
3898

39-
W przypadku wielu obserwatorów manualne niszczenie subskrypcji może być żmudne i podatne błędy dlatego w takiej sytuacji warto użyć `CompositeDisposable`, który utrzymuje listę subskrypcji obiektów `DisposableObserver` w puli i potrafi zlikwidować je wszystkie naraz.
99+
{% highlight java %}
100+
private void startWorkAndSubscribe() {
101+
//create Observable and Observer
102+
Observable<String> observable = createObservable();
103+
Observer<String> observer = createObserver();
40104

41-
//TODO example
105+
//subscribe on choosen schedulers
106+
observable
107+
.observeOn(Schedulers.io()) //emit data on background thread
108+
.subscribeOn(AndroidSchedulers.mainThread()) //receive data on UI thread
109+
.subscribe(observer); //subscribe observer to observable
110+
}
111+
{% endhighlight %}
42112

43113
## Operatory
44114
Operatory pozwalają na manipulacje i modyfikacje emitowanych danych za pomocą zadań transformacji, filtrowania, łączenia, agregacji czy tworzenia. RxJava dostarcza szeroki zbiór operatorów podzielonych na kategorie w zależności od rodzaju operacji, a ich łączenie umożliwia uzyskanie dowolnego złożonego strumienia danych. Poza operatorami odpowiedzialnymi za tworzenie obiektów obserwowanych (`create`, `just`, `from` itp) do często wykorzystywanych należą m.in. `filter`, `map`, `skip`, `take`, `concat`.
45115

46-
//TODO example
116+
private void startWorkAndSubscribeWithOperators() {
117+
Observable<String> observable = createObservable();
118+
Observer<Object> observer = createObserver();
119+
120+
observable
121+
.observeOn(Schedulers.io())
122+
.subscribeOn(AndroidSchedulers.mainThread())
123+
.filter(new Predicate<String>() { //emit only some elements
124+
@Override
125+
public boolean test(String s) throws Exception {
126+
return s.toLowerCase().startsWith("c");
127+
}
128+
})
129+
.map(new Function<String, Object>() { //modify data
130+
@Override
131+
public Object apply(String s) {
132+
return s.toUpperCase();
133+
}
134+
})
135+
.subscribe(observer);
136+
}
137+
138+
## Uchwyt
139+
W celu uniknięcia wycieków pamięci związanych z niepożądaną dłużej subskrypcją obserwatora należy przypisać referencje `Disposable` z poziomu obserwatora oraz wypisać go z subskrypcji.
140+
141+
{% highlight java %}
142+
public class SingleObserverActivity extends AppCompatActivity {
143+
144+
private Disposable disposable;
145+
146+
@Override
147+
protected void onCreate(Bundle savedInstanceState) {
148+
super.onCreate(savedInstanceState);
149+
setContentView(R.layout.activity_single_observer);
150+
151+
Observable<String> observable = createObservableWithDispose();
152+
Observer<String> observer = createObserver();
153+
154+
observable
155+
.observeOn(Schedulers.io())
156+
.subscribeOn(AndroidSchedulers.mainThread())
157+
.subscribe(observer);
158+
}
159+
160+
@Override
161+
protected void onDestroy() {
162+
super.onDestroy();
163+
disposable.dispose(); //don't send event anymore
164+
}
165+
166+
167+
private Observer<String> createObserverWithDispose() {
168+
Observer<String> observer = new Observer<String>() {
169+
@Override
170+
public void onSubscribe(Disposable d) {
171+
//assign subscription to dispoable
172+
disposable = d;
173+
}
174+
@Override
175+
public void onNext(String s) { }
176+
@Override
177+
public void onError(Throwable e) { }
178+
@Override
179+
public void onComplete() { }
180+
};
181+
return observer;
182+
}
183+
184+
private Observable<String> createObservableJust() {
185+
Observable<String> observable = Observable.just("Catan", "Splendor", "7 Wonders", "Codenames", "Taboo");
186+
return observable;
187+
}
188+
}
189+
{% endhighlight %}
47190

48-
## Przykład
191+
W przypadku wielu obserwatorów manualne niszczenie subskrypcji może być żmudne i podatne błędy dlatego w takiej sytuacji warto użyć `CompositeDisposable`, który utrzymuje listę subskrypcji obiektów `DisposableObserver` w puli i potrafi zlikwidować je wszystkie naraz.
49192

50-
//TODO example
193+
{% highlight java %}
194+
public class MultipleObserversActivity extends AppCompatActivity {
195+
196+
private CompositeDisposable compositeDisposable = new CompositeDisposable();
197+
198+
@Override
199+
protected void onCreate(Bundle savedInstanceState) {
200+
super.onCreate(savedInstanceState);
201+
setContentView(R.layout.activity_multiple_observers);
202+
203+
Observable<String> observable = createObservable();
204+
DisposableObserver<String> observerGames = createDisposableObserver();
205+
DisposableObserver<String> observerFilteredGames = createDisposableObserver();
206+
207+
compositeDisposable.add(observable
208+
.subscribeOn(Schedulers.io())
209+
.observeOn(AndroidSchedulers.mainThread())
210+
.subscribeWith(observerGames));
211+
212+
compositeDisposable.add(observable
213+
.subscribeOn(Schedulers.io())
214+
.observeOn(AndroidSchedulers.mainThread())
215+
.filter(new Predicate<String>() {
216+
@Override
217+
public boolean test(String s) throws Exception {
218+
return s.toLowerCase().startsWith("c");
219+
}
220+
})
221+
.subscribeWith(observerFilteredGames));
222+
223+
}
224+
225+
@Override
226+
protected void onDestroy() {
227+
super.onDestroy();
228+
compositeDisposable.clear(); //clear all disposable
229+
}
230+
231+
private Observable<String> createObservableJust() {
232+
Observable<String> observable = Observable.just("Catan", "Splendor", "7 Wonders", "Codenames", "Taboo");
233+
return observable;
234+
}
235+
236+
private DisposableObserver<String> createDisposableObserver() {
237+
DisposableObserver<String> observer = new DisposableObserver<String>() {
238+
@Override
239+
public void onNext(String s) { }
240+
@Override
241+
public void onError(Throwable e) { }
242+
@Override
243+
public void onComplete() { }
244+
};
245+
return observer;
246+
}
247+
}
248+
{% endhighlight %}

0 commit comments

Comments
 (0)