在循环中等待事件监听器？

Question

我有一个控制器类，它需要对列表中的每个项目执行各种异步操作：

• 对于每个 A
  • 播放音频并等待完成
  • 等待 t 秒
  • 对于 A 的每个子部分 B：
    • 播放音频并等待
    • 等待 t2 秒

当我的OnCompletionListener.onCompletion 方法被触发时，我知道音频已完成，当我的CountDownTimer.onFinish() 方法被触发时，我知道计时器何时完成。我试过返回听众：

for (final A a : getAs()) {
   show(a);
   playAudio(a.audioBegin, new MediaPlayer.OnCompletionListener() {
     @Override
     public void onCompletion(MediaPlayer mp) {
       wait(a.secs, new OnFinishListener() {
         @Override
         public void onFinish() {
           if (a.hasSubparts) {
             for (final B b : a.getBs()) {
               playAudio(b.audioBegin, new MediaPlayer.OnCompletionListener() {
               ...
       }
     }
   }
}

但最后我无法摆脱内部循环，这让我觉得整个想法都行不通。我查看了Future 界面，但这似乎也不是我想要的。

我知道我可以用一堆变量来解决这个问题，以跟踪我在状态流中的位置，但是带有一些框架的循环会更清晰。谢谢:)

Answer 1

这种任务听起来是 RxJava 的好地方。

请看这个post，它向您展示了如何包装 MediaPlayer 以使用 Rx。

我会使用timer 运算符来制作您感兴趣的延迟，并使用From 运算符来逐一检查您的列表。

祝你好运

编辑：这是使用 rxJava 的一种方法，但是这是一个简化的版本，一旦你更好地理解 rxJava，你可以让它稍微好一点，例如包装回调，替换主题机制，处理错误等等开。

所以，首先我们将制作一个可播放对象的平面列表，我假设 A 和 B 对象有一个共同的父对象，因为 A 实际上比 B 有更多的方法，我假设这个结构：

private interface B {
    Object audioBegin();
    long getWaitSecs();
}

private interface A extends B {
    boolean hasSubparts();
    List<B> getBs();
}

所以为了使播放列表可以观察到，我们将这样做：

    //this will create a flat play list
    List<B> flatPlayList = new ArrayList<>();
    for ( A a : getAs()){
       flatPlayList.add(a);
       if ( a.hasSubparts()){
           for (B b : a.getBs()){
               flatPlayList.add(b);
           }
       }
    }
    //just creating an observable out of it
    Observable<B> playListObservable = Observable.from(flatPlayList);

现在我们有一个播放列表，我们需要一个接一个地播放，但是等待上一个完成+等待，为此我们将使用一个主题：

    //this will be used to inform every time an audio has completed playing after a wait
    final PublishSubject<Void> onCompleteSubject = PublishSubject.create();

并修补在一起：

//zip will send the next B on the list every time there was an audio completion
    Observable.zip(playListObservable, onCompleteSubject, new Func2<B, Void, B>() {
        @Override
        public B call(B b, Void aVoid) {
            return b;
        }
    }).subscribe(new Action1<B>() {
        @Override
        public void call(final B b) {
            //play the actual audio
            playAudio(b.audioBegin(), new MediaPlayer.OnCompletionListener() {
                @Override
                public void onCompletion(MediaPlayer mp) {
                    //audio has completed playing, so we will wait sec as needed then infrom that we completed;
                    Observable.timer(b.getWaitSecs(), TimeUnit.SECONDS).subscribe(new Action1<Long>() {
                        @Override
                        public void call(Long aLong) {
                            onCompleteSubject.onNext(null);
                        }
                    });
                }
            });
        }
    });

最后，因为第一个项目在完整事件之前不会开始播放，我们将只发送一个来启动整个事件链：

onCompleteSubject.onNext(null); //will cause to start playing