Question

我正在尝试为始终响应有一定延迟的硬件设备创建通信控制器。如果仅请求一个值，则可以创建一个Single<ByteArray>并在.subscribe{ ...}中进行最终转换。

但是当我请求多个值时，我需要确保第二个请求发生在之后。

我可以使用RxJava做一些事情，例如defer？还是我应该自己创建一个队列并使用队列手动处理事件序列？

无论如何我们都在使用RxJava（我显然是新手），当然也可以为此目的使用它。但这是一个很好的用例吗？

编辑：

我可以使用的代码，但是不够通用：

hardware.write(byteArray)
    .subscribe(
        {
            hardware.receiveResult().take(1)
                .doFinally { /* dispose code */ }
                .subscribe(
                    { /* onSuccess */ }
                    { /* onError */ }
                .let { disposable = it }
        },
        { /* onError */ }
    )

队列中下一个请求的所有代码都可以放在内部onSuccess中，然后放在该onSuccess中。该操作将顺序执行，但不够通用。任何其他发出请求的类都会破坏我的序列。

我正在寻找一种在硬件通信控制器类中自动建立队列的解决方案。

Answer 1

很长一段时间过去了，该项目得以开发，很久以前我们就找到了解决方案。现在我想在这里分享它：

fun writeSequential(data1: ByteArray, data2: ByteArray) {
    disposable = hardwareWrite(data1)
        .zipWith(hardwareWrite(data2))
        .subscribe(
            {
                /* handle results.
                  it.first will be the first response,
                  it.second the second. */
            },
            { /* handle error */ }
        )

    compositeDisposable.add(disposable)
}

fun hardwareWrite(data: ByteArray): Disposable {
    var emitter: SingleEmitter<ByteArray>? = null
    var single = Single.create<ByteArray> { emitter = it }

    return hardware.write(data)
        .subscribe(
            { hardwareRead(emitter) },
            { /* onError */ }
        ))
}

fun hardwareRead(emitter: SingleEmitter<ByteArray>): Disposable {
    return hardware.receiveResult()
        .take(1)
        .timeout( /* your timeout */ )
        .single( /* default value */ )
        .doFinally( /* cleanup queue */ )
        .subscribe(
            { emitter.onSuccess(it) }
            { emitter.onError(it) }
        )
}

该解决方案并不完美，现在我发现中间部分对一次性结果没有任何作用。

此外，在示例中，它有点复杂，因为hardwareWrite不会立即触发但会排队。这样，我们可以确保依次访问硬件，并且不会混淆结果。

我仍然希望这可以帮助正在寻找解决方案的人，并且可能对kotlin和/或RxJava东西是新的（就像我在项目开始时一样）。

发射器响应后顺序运行多个任务

1 个答案: