RxAndroid: create a simple observation

Question

I create an Observable that emits integers when subscribed. My implementation is now set up so that the act of signing on it initiates the creation from the very beginning, as shown below:

private Observable createObservable() {
    return Observable.create (
        new Observable.OnSubscribe<Integer>() {

            @Override
            public void call(Subscriber<? super Integer> sub) {

                for (int i = 1; i < MAX_PROGRESS + 1; i++) {
                    sub.onNext(i);
                    SystemClock.sleep(1000);
                }
                sub.onCompleted();
            }
        }
    );
}

My understanding is cold Observation. I want the sequence to be generated independently of any subscribers, and when the subscriber subscribes, you want them to get the values ​​that are current during the subscription. IOW, turn it into a hot Observed. I would prefer not a subclass of Observable, because this associates it with a specific integer, whereas in practice the actual type will change.

Answer 1

rx.subjects.BehaviorSubject<T>. rx.subjects.Subject, , , , A B. , Observer<T>; onNext() ( : ). , Observable<T>, Observer<T> , onNext() Observer<T>.

Observable<T> src = ...;
Subscriber<T> dst;
src.subscribe(dst);

BehaviorSubject -

Observable<T> src = ...;
BehaviorSubject<T> subject = BehaviorSubject.create(defaultValue);
src.subscribe(subject);

, , . BehaviorSubject .

// safe to do multiple times.
Subscriber<T> dst;
subject.subscribe(dst);

dst src ( defaultValue) , , dst .

. , , .

Answer 2

"Observable.create" . "" - Observable. Rx (cache(), retry()). :

    public Observable<Bitmap> mObservable;
    Subscriber<Bitmap> mSubscriber;
    Subscription mSubscription;
    Bitmap loadedBitmap;

....

@Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {

        if (savedInstanceState != null) {
            loadedBitmap = savedInstanceState.getParcelable("LoadedBitmap");
            imageView.setImageBitmap(loadedBitmap);
        }
        else {
            runNewObservable();
        }
        runSubscribe();
        return mainView;
    }

....

    private void runNewObservable () {
        mObservable =
                Observable.create(new Observable.OnSubscribe<Bitmap>() {
            @Override
            public void call(Subscriber<? super Bitmap> subscriber) {
                subscriber.onNext(new LoadingImage().loadImageFrom(imageURL));
                subscriber.onCompleted();
            }
        })
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .cache();

    }



    private void runNewSubscribe () {
        mSubscriber = new Subscriber<Bitmap>() {

            @Override
            public void onCompleted() { }

            @Override
            public void onError(Throwable e) { }

            @Override
            public void onNext(Bitmap bitmap) {
                loadedBitmap = bitmap;
                imageView.setImageBitmap(bitmap);
            }
        };
    }

    @Override
    public void onResume() {
        super.onResume();
        mSubscription = mObservable.subscribe(mSubscriber);
    }


    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putParcelable("LoadedBitmap", loadedBitmap);
    }



    @Override
    public void onStop() {
        super.onStop();
        mSubscription.unsubscribe();
    }

....

. mSubscription.subscribe() mSubscription.unsubscribe() Observable , saveInstanceState null.