RxJava对列表进行迭代，对每个项进行API调用，并将结果收集到单个列表中

我面临着一个奇怪的问题，最近我才开始将我的大部分代码库迁移到reactive，也就是说我几乎是RxJava新手，我使用RxJava2进行API处理，下面是我的问题陈述

API

getGameDetails

返回一个

Observable

，其中包含关于特定游戏的信息，需要每10秒轮询服务器以获取最新游戏状态，游戏状态响应包含

列表

，系统需要查询服务器以检查

玩家

是否是客人或注册的

由于它包含多个API调用，我尝试将它们链接在一起，因此最终我将获得更新信息的

列表，下面是我的尝试，但不幸的是它没有按预期工作，需要您的帮助来调试相同的内容

提前谢谢

    Disposable d = Observable.interval(10, TimeUnit.SECONDS)
            .flatMap(new Function<Long, ObservableSource<GameResponse>>() {
                @Override
                public ObservableSource<GameResponse> apply(@NonNull Long aLong) throws Exception {
                    return  gamePlayManager
                            .getGameDetails(mGameId)
                            .doOnError(new Consumer<Throwable>() {
                                @Override
                                public void accept(@NonNull Throwable throwable) throws Exception {
                                    Log.d("####", throwable.getMessage(), throwable);
                                }
                            })
                            .onErrorResumeNext(new Function<Throwable, ObservableSource<GameResponse>>() {
                                @Override
                                public ObservableSource<GameResponse> apply(@NonNull Throwable throwable)
                                        throws Exception {
                                    return Observable.empty();
                                }
                            });
                }
            })
            .takeUntil(new Predicate<GameResponse>() {
                @Override
                public boolean test(@NonNull GameResponse gameResponse) throws Exception {

                    // check if it has reached X players limit already
                    if (gameResponse != null && gameResponse.players != null) {
                        if (gameResponse.players.size()
                                >= MAXIMUM_NUMBER_OF_PLAYERS_IN_ROOM) {
                            return true;
                        }
                    }
                    return false;

                }
            })

            .map(new Function<GameResponse, List<Player>>() {
                @Override
                public List<Player> apply(@NonNull GameResponse gameResponse) throws Exception {
                    gameDetailResponse = gameResponse;
                    return gameResponse.players;

                }
            })
            .flatMap(new Function<List<Player>, ObservableSource<List<Player>>>() {
                @Override
                public ObservableSource<List<Player>> apply(@NonNull List<Player> players) throws Exception {

                    return Observable.fromIterable(players).flatMap(new Function<Player, ObservableSource<Player>>() {
                        @Override
                        public ObservableSource<Player> apply(@NonNull final Player player) throws Exception {
                            return Observable.fromCallable(new Callable<Player>() {
                                @Override
                                public Player call() throws Exception {


                                    UserProfile profile = userService.profile(token,
                                            player.playerId);
                                    if (profile != null) {
                                        player.internalUser = true;
                                    }
                                    return player;

                                }
                            });
                        }
                    })
                            .toList()
                            .toObservable();

                }
            })
            .doOnNext(new Consumer<List<Player>>() {
                @Override
                public void accept(@NonNull List<Player> players) throws Exception {

                    // Some code for presenting UI here

                    //
                }
            })
            .doOnError(new Consumer<Throwable>() {
                @Override
                public void accept(@NonNull Throwable throwable) throws Exception {
                    Log.d("####",throwable.getMessage(),throwable);
                    startGameView.showErrorMessage();
                }
            })
            .subscribe();
    subscriptions.add(d);

d=可观察的时间间隔（10，时间单位。秒）
.flatMap（新函数（）{
@凌驾
public observesource apply（@NonNull Long-aLong）引发异常{
返回游戏管理器
.getGameDetails（mGameId）
.doOnError（新使用者（）{
@凌驾
public void accept（@NonNull Throwable Throwable）引发异常{
Log.d（“#####”，throwable.getMessage（），throwable）；
}
})
.onErrorResumeNext（新函数（）{
@凌驾
公共可观察资源应用（@NonNull Throwable Throwable）
抛出异常{
return-Observable.empty（）；
}
});
}
})
.takeUntil（新谓词（）{
@凌驾
公共布尔测试（@NonNull GameResponse GameResponse）引发异常{
//检查是否已经达到X玩家限制
if（gameResponse！=null&&gameResponse.players！=null）{
if（gameResponse.players.size（）
>=最大\u人数\u房间内的\u玩家\u）{
返回true；
}
}
返回false；
}
})
.map（新函数（）{
@凌驾
公共列表应用（@NonNull GameResponse GameResponse）引发异常{
gameDetailResponse=gameResponse；
返回gameResponse.players；
}
})
.flatMap（新函数（）{
@凌驾
public observesource apply（@NonNull List players）引发异常{
返回Observable.fromIterable（players）.flatMap（新函数（）{
@凌驾
公共可观测资源应用（@NonNull final Player）引发异常{
返回Observable.fromCallable（newcallable（））{
@凌驾
public Player call（）引发异常{
UserProfile profile=userService.profile（令牌，
player.playerId）；
if（profile！=null）{
player.internalUser=true；
}
返回球员；
}
});
}
})
托利斯先生（）
.toObservable（）；
}
})
.doOnNext（新消费者）{
@凌驾
public void accept（@NonNull List players）引发异常{
//这里有一些显示UI的代码
//
}
})
.doOnError（新使用者（）{
@凌驾
public void accept（@NonNull Throwable Throwable）引发异常{
Log.d（“#####”，throwable.getMessage（），throwable）；
startGameView.batherRorMessage（）；
}
})
.subscribe（）；
添加（d）；
为什么在这里使用takeUntil（）运算符？如果已满足某些条件@SagarTrehanok，我想停止连续轮询。问题是什么？。当不满足条件时，连续轮询是否没有暂停？