在循环中发出值（RxJava）

我是Rx新手，我一直想知道如何正确地一个接一个地发出值（本例中为延迟加载图像）。 不遇到并发问题的最佳方法是什么

这是我的代码：

@Override
public Observable<Bitmap> getPhotos(final String placeId) {
    return Observable.create(new ObservableOnSubscribe<Bitmap>() {
        @Override
        public void subscribe(ObservableEmitter<Bitmap> emitter) throws Exception {
            try {
                PlacePhotoMetadataResult res = Places.GeoDataApi
                        .getPlacePhotos(googleApiClient, placeId)
                        .await();
                PlacePhotoMetadataBuffer buffer = res.getPhotoMetadata();

                for (PlacePhotoMetadata photoMetadata : buffer) {
                    Bitmap photo = photoMetadata
                            .getPhoto(googleApiClient)
                            .await()
                            .getBitmap();

                    emitter.onNext(photo);
                }

                buffer.release();
            } catch (Exception ex) {
                emitter.onError(ex);
            } finally {
                emitter.onComplete();
            }
        }
    });
}

@覆盖
公共可观察的getPhotos（最终字符串placeId）{
返回Observable.create（newobservableOnSubscribe（）{
@凌驾
public void subscribe（observeItemer发射器）引发异常{
试一试{
PlacePhotoMetadataResult=Places.GeoDataApi
.getPlacePhotos（GoogleAppClient，placeId）
.等待（）；
placephotometadabuffer buffer=res.getPhotoMetadata（）；
用于（PlacePhotoMetadata photoMetadata:缓冲区）{
位图照片=光模板数据
.getPhoto（谷歌客户端）
.等待
.getBitmap（）；
emitter.onNext（照片）；
}
buffer.release（）；
}捕获（例外情况除外）{
发射极误差（ex）；
}最后{
emitter.onComplete（）；
}
}
});
}

---

谢谢

你真的应该花点时间把

pendingreult

连接到

可观察的
（或者
单个的
，或者
可流动的
（我的偏好））。然后，您的所有代码都可以表示为：

private static <T> Observable<T> toObservable(PendingResult<T> result) {
    // 
}

public Observable<Bitmap> getPhotos(final String placeId) {
    return Observable
            .just(placeId)
            .flatMap(id -> toObservable(Places.GeoDataApi.getPlacePhotos(googleApiClient, placeId)))
            .flatMapIterable(PlacePhotoMetadataResult::getPhotoMetadata)
            .flatMap(metadata -> toObservable(metadata.getPhoto(googleApiClient)))
            .map(Photo::getBitmap);
}

private static Observable to Observable（Pendingreult结果）{
// 
}
公共可观察的getPhotos（最终字符串placeId）{
可观测回波
.just（placeId）
.flatMap（id->toObservable（Places.GeoDataApi.getPlacePhotos（googleApiClient，placeId）））
.FlatMapiteTable（PlacePhotoMetadataResult:：getPhotoMetadata）
.flatMap（metadata->toObservable（metadata.getPhoto（GoogleAppClient）））
.map（照片：：getBitmap）；
}

开始研究如何进行桥接的一个好地方是，但它只是RxJava 1。
这里的循环在哪里？只返回一个可流动的而不是可观察的，并保持代码的其余部分不变，这样可以吗？我应该使用什么背压策略？当然你可以使用
可流动的
，我只是使用可观察的，因为这就是你使用的！在这种情况下，您不需要指定背压策略，
flatMapIterable
将处理它。你需要适应可观察的tho。