Java 获取对原始调度程序的引用

我有以下RxJava

可观察的

：

final class MapBitmapObservable {

    static Observable<Bitmap> create(@NonNull final MapView mapView) {
        return Observable.create(new Observable.OnSubscribe<Bitmap>() {
            @Override
            public void call(final Subscriber<? super Bitmap> subscriber) {
                mapView.getMapAsync(new OnMapReadyCallback() {
                    @Override
                    public void onMapReady(@NonNull final GoogleMap googleMap) {
                        googleMap.snapshot(new GoogleMap.SnapshotReadyCallback() {
                            @Override
                            public void onSnapshotReady(@Nullable final Bitmap bitmap) {
                                if (bitmap != null) {
                                    subscriber.onNext(bitmap);
                                    subscriber.onCompleted();
                                } else {
                                    subscriber.onError(new MapSnapshotFailedException());
                                }
                            }
                        });
                    }
                });
            }
        });
    }

    private MapBitmapObservable() {

    }

}

假设

MapBitmapObservable

用作

Observable

链的一部分，在该链中，先前和后续操作可能会长期运行，并且应该在主线程之外执行。简化的示例如下所示：

Observable.just(activity)
        .flatmap(new Func1<Activity, Observable<MapView>>() {
            @Override
            public Observable<Bitmap> call(@NonNull final Activity activity) {
                return ExpensiveToCreateObservable.create(activity);
            }
        })
        .flatmap(new Func1<MapView, Observable<Bitmap>>() {
            @Override
            public Observable<Bitmap> call(@NonNull final MapView mapView) {
                return MapBitmapObservable.create(mapView);
            }
        })
        .flatmap(new Func1<Bitmap, Observable<Uri>>() {
            @Override
            public Observable<Uri> call(@NonNull final Bitmap bitmap) {
                return SomeOtherExpensiveToCreateObservable.create(bitmap);
            }
        })
        .subscribeOn(Schedulers.io())
        .subscribe();

这可能吗？

从

另一方面，ObserveOn影响被观察者将在操作符出现的下方使用的线程。因此，您可以在可观察操作符链的不同点多次调用ObserveOn，以更改某些操作符操作的线程

因此，正如Aaron He所提到的，您可以保留一些对正在使用的调度程序的引用，并在后一个“observeOn”上使用它

---

我有时使用的另一种方法是删除“observeOn”函数，并确保Activity.runOnUiThread正在UI线程上处理视图项。类似于-

static Observable<Bitmap> create(@NonNull final Activity activity,@NonNull final SomeObject someObject) {
        return Observable.create(new Observable.OnSubscribe<Pair<Activity,SomeObject>>() {
            @Override
            public void call(final Subscriber<? super Pair<Activity,SomeObject>> subscriber) {
                activity.runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        someObject.doStuff();
                    }
                });  
            }
        });
    }

静态可观察创建（@NonNull final Activity活动，@NonNull final SomeObject SomeObject）{
返回Observable.create（newobservable.OnSubscribe（）{
@凌驾
public void call（final subscriber）保留原始
调度程序的引用并在以后使用？感谢您的输入！如果链都是在线构造的，这是可行的，如上面的简化示例所示；但是，原始问题的以下警告：（尽管需要注意的是，在我的实际应用中，链接分布在几种不同的方法中）这意味着
subscribeOn
的调用与使用
MapBitmapObservable
的
flatmap
相去甚远。这意味着我理想上想要一个更“本地化”的解决方案，其中两个
observeOn
调用包装所述
flatmap
不需要知道原始的
调度程序
类型。（定义见呼叫站点）。好主意！我对前者的回答是对原始问题的评论。关于后者：我很好奇，当您使用此模式时，您是否通常调用订户方法（例如
subscriber.onNext
）在
Runnable
内部，或者直接在
call
方法内部？我想象在
Runnable
内部调用是我想在这里尝试的。这取决于我需要执行的操作。我只在需要更新UI时使用
Runnable
。因此，例如，如果在完成更新后，我想调用
onNext
它将进入
Runnable
。但是通常情况并非如此，我直接从
call
方法调用它。
Observable.just(activity)
        .flatmap(new Func1<Activity, Observable<MapView>>() {
            @Override
            public Observable<Bitmap> call(@NonNull final Activity activity) {
                return ExpensiveToCreateObservable.create(activity);
            }
        })
        .observeOn(AndroidSchedulers.mainThread()) // This is real, and resolves bullet 1.
        .flatmap(new Func1<MapView, Observable<Bitmap>>() {
            @Override
            public Observable<Bitmap> call(@NonNull final MapView mapView) {
                return MapBitmapObservable.create(mapView);
            }
        })
        .observeOn(/* Some way of referencing the thread on which I originally subscribed, to resolve bullet 2. */)
        .flatmap(new Func1<Bitmap, Observable<Uri>>() {
            @Override
            public Observable<Uri> call(@NonNull final Bitmap bitmap) {
                return SomeOtherExpensiveToCreateObservable.create(bitmap);
            }
        })
        .subscribeOn(Schedulers.io()) // I do not want to rely on knowledge of the Scheduler type used at this call-site. 
        .subscribe();

static Observable<Bitmap> create(@NonNull final Activity activity,@NonNull final SomeObject someObject) {
        return Observable.create(new Observable.OnSubscribe<Pair<Activity,SomeObject>>() {
            @Override
            public void call(final Subscriber<? super Pair<Activity,SomeObject>> subscriber) {
                activity.runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        someObject.doStuff();
                    }
                });  
            }
        });
    }