آشنایی با برنامه نویسی واکنش گرا RxJava، RxAndroid در اندروید

// RxJava
implementation "io.reactivex.rxjava2:rxjava:2.2.21"
 
// RxAndroid
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'

	
Observable<String> animalsObservable = Observable.just("Ant", "Bee", "Cat", "Dog", "Fox");

Observer<String> animalsObserver = getAnimalsObserver();
  
private Observer<String> getAnimalsObserver() {
        return new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe");
            }
  
            @Override
            public void onNext(String s) {
                Log.d(TAG, "Name: " + s);
            }
  
            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError: " + e.getMessage());
            }
  
            @Override
            public void onComplete() {
                Log.d(TAG, "All items are emitted!");
            }
        };
    }

animalsObservable
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(animalsObserver);

onSubscribe
Name: Ant
Name: Bee
Name: Cat
Name: Dog
Name: Fox
All items are emitted!

public class Example1Activity extends AppCompatActivity {
  
    /**
     * Basic Observable, Observer, Subscriber example
     * Observable emits list of animal names
     */
  
    private static final String TAG = Example1Activity.class.getSimpleName();
  
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_example1);
  
        // observable
        Observable<String> animalsObservable = getAnimalsObservable();
  
        // observer
        Observer<String> animalsObserver = getAnimalsObserver();
  
        // observer subscribing to observable
        animalsObservable
                .observeOn(Schedulers.io())
                .subscribeOn(AndroidSchedulers.mainThread())
                .subscribe(animalsObserver);
    }
  
    private Observer<String> getAnimalsObserver() {
        return new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe");
            }
  
            @Override
            public void onNext(String s) {
                Log.d(TAG, "Name: " + s);
            }
  
            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError: " + e.getMessage());
            }
  
            @Override
            public void onComplete() {
                Log.d(TAG, "All items are emitted!");
            }
        };
    }
  
    private Observable<String> getAnimalsObservable() {
        return Observable.just("Ant", "Bee", "Cat", "Dog", "Fox");
    }
}

onSubscribe
Name: Ant
Name: Bee
Name: Cat
Name: Dog
Name: Fox
All items are emitted!

public class Example2Activity extends AppCompatActivity {
  
    /**
     * Basic Observable, Observer, Subscriber example
     * Observable emits list of animal names
     * You can see Disposable introduced in this example
     */
    private static final String TAG = Example2Activity.class.getSimpleName();
  
    private Disposable disposable;
  
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_example2);
  
        // observable
        Observable<String> animalsObservable = getAnimalsObservable();
  
        // observer
        Observer<String> animalsObserver = getAnimalsObserver();
  
        // observer subscribing to observable
        animalsObservable
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeWith(animalsObserver);
    }
  
    private Observer<String> getAnimalsObserver() {
        return new Observer<String>() {
  
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe");
                disposable = d;
            }
  
            @Override
            public void onNext(String s) {
                Log.d(TAG, "Name: " + s);
            }
  
            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError: " + e.getMessage());
            }
  
            @Override
            public void onComplete() {
                Log.d(TAG, "All items are emitted!");
            }
        };
    }
  
    private Observable<String> getAnimalsObservable() {
        return Observable.just("Ant", "Bee", "Cat", "Dog", "Fox");
    }
  
    @Override
    protected void onDestroy() {
        super.onDestroy();
  
        // don't send events once the activity is destroyed
        disposable.dispose();
    }
}

public class Example3Activity extends AppCompatActivity {
  
    /**
     * Basic Observable, Observer, Subscriber example
     * Observable emits list of animal names
     * You can see Disposable introduced in this example
     */
    private static final String TAG = Example3Activity.class.getSimpleName();
  
    private Disposable disposable;
  
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_example3);
  
        // observable
        Observable<String> animalsObservable = getAnimalsObservable();
  
        // observer
        Observer<String> animalsObserver = getAnimalsObserver();
  
        // observer subscribing to observable
        animalsObservable
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .filter(new Predicate<String>() {
                    @Override
                    public boolean test(String s) throws Exception {
                        return s.toLowerCase().startsWith("b");
                    }
                })
                .subscribeWith(animalsObserver);
    }
  
    private Observer<String> getAnimalsObserver() {
        return new Observer<String>() {
  
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe");
                disposable = d;
            }
  
            @Override
            public void onNext(String s) {
                Log.d(TAG, "Name: " + s);
            }
  
            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError: " + e.getMessage());
            }
  
            @Override
            public void onComplete() {
                Log.d(TAG, "All items are emitted!");
            }
        };
    }
  
    private Observable<String> getAnimalsObservable() {
        return Observable.fromArray(
                "Ant", "Ape",
                "Bat", "Bee", "Bear", "Butterfly",
                "Cat", "Crab", "Cod",
                "Dog", "Dove",
                "Fox", "Frog");
    }
  
    @Override
    protected void onDestroy() {
        super.onDestroy();
  
        // don't send events once the activity is destroyed
        disposable.dispose();
    }
}

onSubscribe
Name: Bat
Name: Bee
Name: Bear
Name: Butterfly
All items are emitted!

public class Example4Activity extends AppCompatActivity {
  
    /**
     * Basic Observable, Observer, Subscriber example
     * Observable emits list of animal names
     * You can see filter() operator is used to filter out the
     * animal names that starts with letter `b`
     */
    private static final String TAG = Example4Activity.class.getSimpleName();
  
    private CompositeDisposable compositeDisposable = new CompositeDisposable();
  
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_example4);
  
        Observable<String> animalsObservable = getAnimalsObservable();
  
        DisposableObserver<String> animalsObserver = getAnimalsObserver();
  
        DisposableObserver<String> animalsObserverAllCaps = getAnimalsAllCapsObserver();
  
        /**
         * filter() is used to filter out the animal names starting with `b`
         * */
        compositeDisposable.add(
                animalsObservable
                        .subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .filter(new Predicate<String>() {
                            @Override
                            public boolean test(String s) throws Exception {
                                return s.toLowerCase().startsWith("b");
                            }
                        })
                        .subscribeWith(animalsObserver));
  
        /**
         * filter() is used to filter out the animal names starting with 'c'
         * map() is used to transform all the characters to UPPER case
         * */
  
        compositeDisposable.add(
                animalsObservable
                        .subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .filter(new Predicate<String>() {
                            @Override
                            public boolean test(String s) throws Exception {
                                return s.toLowerCase().startsWith("c");
                            }
                        })
                        .map(new Function<String, String>() {
                            @Override
                            public String apply(String s) throws Exception {
                                return s.toUpperCase();
                            }
                        })
                        .subscribeWith(animalsObserverAllCaps));
    }
  
    private DisposableObserver<String> getAnimalsObserver() {
        return new DisposableObserver<String>() {
  
            @Override
            public void onNext(String s) {
                Log.d(TAG, "Name: " + s);
            }
  
            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError: " + e.getMessage());
            }
  
            @Override
            public void onComplete() {
                Log.d(TAG, "All items are emitted!");
            }
        };
    }
  
    private DisposableObserver<String> getAnimalsAllCapsObserver() {
        return new DisposableObserver<String>() {
  
  
            @Override
            public void onNext(String s) {
                Log.d(TAG, "Name: " + s);
            }
  
            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError: " + e.getMessage());
            }
  
            @Override
            public void onComplete() {
                Log.d(TAG, "All items are emitted!");
            }
        };
    }
  
    private Observable<String> getAnimalsObservable() {
        return Observable.fromArray(
                "Ant", "Ape",
                "Bat", "Bee", "Bear", "Butterfly",
                "Cat", "Crab", "Cod",
                "Dog", "Dove",
                "Fox", "Frog");
    }
  
    @Override
    protected void onDestroy() {
        super.onDestroy();
  
        // don't send events once the activity is destroyed
        compositeDisposable.clear();
    }
}

Name: Bat
Name: Bee
Name: Bear
Name: Butterfly
All items are emitted!
Name: CAT
Name: CRAB
Name: COD
All items are emitted!

public class Example4Activity extends AppCompatActivity {
  
  
    /**
     * Basic Observable, Observer, Subscriber example
     * Introduced CompositeDisposable and DisposableObserver
     * The observable emits custom data type (Note) instead of primitive data types
     * ----
     * .map() operator is used to turn the note into all uppercase letters
     * ----
     * You can also notice we got rid of the below declarations
     * Observable<Note> notesObservable = getNotesObservable();
     * DisposableObserver<Note> notesObserver = getNotesObserver();
     */
    private static final String TAG = Example4Activity.class.getSimpleName();
  
    private CompositeDisposable disposable = new CompositeDisposable();
  
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_example4);
  
        // add to Composite observable
        // .map() operator is used to turn the note into all uppercase letters
        disposable.add(getNotesObservable()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .map(new Function<Note, Note>() {
                    @Override
                    public Note apply(Note note) throws Exception {
                        // Making the note to all uppercase
                        note.setNote(note.getNote().toUpperCase());
                        return note;
                    }
                })
                .subscribeWith(getNotesObserver()));
    }
  
    private DisposableObserver<Note> getNotesObserver() {
        return new DisposableObserver<Note>() {
  
            @Override
            public void onNext(Note note) {
                Log.d(TAG, "Note: " + note.getNote());
            }
  
            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError: " + e.getMessage());
            }
  
            @Override
            public void onComplete() {
                Log.d(TAG, "All notes are emitted!");
            }
        };
    }
  
    private Observable<Note> getNotesObservable() {
        final List<Note> notes = prepareNotes();
  
        return Observable.create(new ObservableOnSubscribe<Note>() {
            @Override
            public void subscribe(ObservableEmitter<Note> emitter) throws Exception {
                for (Note note : notes) {
                    if (!emitter.isDisposed()) {
                        emitter.onNext(note);
                    }
                }
  
                if (!emitter.isDisposed()) {
                    emitter.onComplete();
                }
            }
        });
    }
  
    private List<Note> prepareNotes() {
        List<Note> notes = new ArrayList<>();
        notes.add(new Note(1, "buy tooth paste!"));
        notes.add(new Note(2, "call brother!"));
        notes.add(new Note(3, "watch narcos tonight!"));
        notes.add(new Note(4, "pay power bill!"));
  
        return notes;
    }
  
    class Note {
        int id;
        String note;
  
        public Note(int id, String note) {
            this.id = id;
            this.note = note;
        }
  
        public int getId() {
            return id;
        }
  
        public String getNote() {
            return note;
        }
  
        public void setId(int id) {
            this.id = id;
        }
  
        public void setNote(String note) {
            this.note = note;
        }
    }
  
    @Override
    protected void onDestroy() {
        super.onDestroy();
        disposable.clear();
    }
}

Id: 1, note: BUY TOOTH PASTE!
Id: 2, note: CALL BROTHER!
Id: 3, note: WATCH NARCOS TONIGHT!
Id: 4, note: PAY POWER BILL!
All notes are emitted!