Android 条件单链和完全链_Android_Multithreading_Parallel Processing_Kotlin_Rx Java

Android 条件单链和完全链

android multithreading parallel-processing kotlin rx-java

Android 条件单链和完全链,android,multithreading,parallel-processing,kotlin,rx-java,Android,Multithreading,Parallel Processing,Kotlin,Rx Java,我的接收呼叫总体工作流程应如下所示（无论当前接收代码如何）：从房间Dao获取运动传感器读数列表（目的是将其上传到REST API）。我用的是单曲如果该读数列表为空，则执行jobFinished（）回调并在此之后不执行任何操作如果读数不为空，则将网络调用链接到此单个。网络调用返回一个可完成的 Single从不在逻辑上抛出错误，因为它获取的是空的或非空的读数列表当整个Rx调用链终止时，执行jobFinished（）回调在整个接收呼叫链成功后，从Dao 当单个成功，但可完成错误时，更新Da

我的接收呼叫总体工作流程应如下所示（无论当前接收代码如何）：

从
```
房间
```
```
Dao
```
获取运动传感器读数列表（目的是将其上传到REST API）。我用的是
```
单曲
```
如果该
```
读数
```
列表为空，则执行
```
jobFinished（）
```
回调并在此之后不执行任何操作
如果
```
读数
```
不为空，则将网络调用链接到此
```
单个
```
。网络调用返回一个
```
可完成的
```
```
Single
```
从不在逻辑上抛出错误，因为它获取的是空的或非空的
```
读数
```
列表
当整个Rx调用链终止时，执行
```
jobFinished（）
```
回调
在整个接收呼叫链成功后，从
```
Dao
```
当
```
单个
```
成功，但
```
可完成
```
错误时，更新
```
Dao中的读数
```

我目前的代码如下：

  Single.create<List<Reading>> {
        readings = readingDao.getNextUploadBatch()

        if (readings.isEmpty()) {
            jobFinished(job, false)
            return@create
        }

        it.onSuccess(readings)
    }
            .flatMapCompletable { api.uploadSensorReadings(it) }
            .doOnTerminate {
                jobFinished(job, !readingDao.isEmpty())
            }
            .subscribeOn(rxSchedulers.network)
            .observeOn(rxSchedulers.database)
            .subscribe(
                    {
                        readingDao.delete(*readings.toTypedArray())
                    },
                    {
                        markCurrentReadingsAsNotUploading()
                    }
            )

Single.create{
readings=readingDao.getNextUploadBatch（）
if（readings.isEmpty（））{
作业已完成（作业，错误）
return@create
}
it.onSuccess（读数）
}
.flatMapCompletable{api.UploadSensorReads（it）}
杜恩特先生{
作业已完成（作业，！readingDao.isEmpty（））
}
.subscribeOn（rxSchedulers.network）
.observeOn（rxSchedulers.database）
.订阅(
{
readingDao.delete（*readings.toTypedArray（））
},
{
MarkCurrentReadingSasNotUpload（）
}
)

上述代码的逻辑问题是（尚未在运行时对其进行测试，但已编译）：

如果
```
读数
```
列表为空，我想从
```
flatMapCompletable
```
中切断代码
如果
```
读数
```
为空，我不希望执行
```
dointerminate
```
我不希望执行
```
subscribe
```
的
```
onComplete
```
部分（第一个
```
{}
```
块），除非
```
reads
```
为非空，并且
```
Completable
```
也返回了成功
我不希望执行
```
subscribe
```
的
```
onError
```
部分（第二个
```
{}
```
块），除非
```
reads
```
为非空且
```
Completable
```
失败

我不知道如何将我的工作流程作为一个高效、整洁的Rx呼叫链来实施。欢迎提出任何建议

如果要根据值执行不同的操作，请考虑

flatMap

：

Single.fromCallable(() -> readingDao.getNextUploadBatch())
.subscribeOn(rxSchedulers.network)
.flatMapCompletable(readings -> {
    if (readings.isEmpty()) {
        jobFinished(job, false);
        return Completable.complete();
    }
    return api.uploadSensorReadings(readings)
           .doFinally(() -> jobFinished(job, !readingDao.isEmpty()))
           .observeOn(rxSchedulers.database)
           .doOnComplete(() -> readingDao.delete(readings.toTypedArray()))
})
.subscribe(() -> /* ignored */, error -> markCurrentReadingsAsNotUploading());

我甚至不想去想你在周五晚上要做什么，但作为一个一般（和个人）的建议，我想说你应该把这些长长的接收调用链分解成多个方法或接收调用。为什么？维修由于一连串的事件，在8个月内调试这个笨蛋将是一场噩梦。更不用说只有stacktraceIt的崩溃报告实际上似乎是一项非常简单的任务。我只是在如何在Rx中实际实现它方面存在知识差距。我肯定见过更复杂的Rx代码；只是需要一点时间来让你的头围绕它！这和我在发帖几个小时后的想法非常相似！做了一些研究，发现返回

Completable.complete（）

将是另一个空返回值，用于跳过下一个

Completable

。谢谢