等待 Room @Insert 查询完成

Question

我不知道如何使用 Room 和 MVVM 模式进行“简单”操作。 我正在使用 Retrofit 获取一些数据。 “正确”的响应会触发活动中的观察者，并且响应本身的一小部分使用 Room 库插入到数据库中，擦除所有先前存储的值并插入新的值。否则旧值将保留在 DB 上。 之后，我想检查数据库中的某个字段，但我无法强制此操作等到前一个完成。

型号

@Entity(tableName = "licence")
data class Licence(
    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "licence_id")
    var licenceId: Int = 0,
    @Ignore
    var config: List<LicenceConfig>? = null,
.......
//all the others attributes )

@Entity(foreignKeys = [
ForeignKey(
        entity = Licence::class,
        parentColumns = ["licence_id"],
        childColumns = ["licence_reference"],
        onDelete = ForeignKey.CASCADE
)],tableName = "licence_configurations")
data class LicenceConfig(
    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "licence_config_id")
    var licenceConfigId: Int,

    @ColumnInfo(name="licence_reference")
    var licenceReference: Int,

活动中的观察者

loginViewModel.apiResponse.observe(this, Observer { response ->
        response?.let {
             loginViewModel.insertLicences(response.licence)
        }
           //here I need to wait for the insertion to end
           loginViewModel.methodToCheckForTheFieldOnDatabase()
})

视图模型

fun insertLicences(licences: List<Licence>) = viewModelScope.launch {
    roomRepository.deleteAllLicences()
    licences.forEach { licence ->
        roomRepository.insertLicence(licence).also { insertedLicenceId ->
            licence.config?.forEach { licenceConfiguration ->
                roomRepository.insertLicenceConfiguration(
                        licenceConfiguration.apply { licenceReference = insertedLicenceId.toInt() }
                )
            }
        }
    }
}

房间存储库

class RoomRepository(private val roomDao: RoomDao) {

val allLicences: LiveData<List<Licence>> = roomDao.getAllLicences()

suspend fun insertLicence(licence: Licence): Long {
   return roomDao.insertLicence(licence)
   }

suspend fun insertLicenceConfiguration(licenceConfiguration: LicenceConfig){
    return roomDao.insertLicenceConfiguration(LicenceConfig)
   }
}

房间道

@Dao
interface RoomDao {

@Query("select * from licence")
fun getAllLicences(): LiveData<List<Licence>>

@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insertLicence(licence: Licence): Long

@Insert
suspend fun insertLicenceConfiguration(licence: LicenceConfig)

@Query("DELETE FROM licence")
suspend fun deleteAllLicences()
}

将观察者设置为“allLicences”LiveData 或直接在 DB 上的该字段上不是一个选项，因为操作将在活动创建后立即执行，我必须等到 API 响应才能执行它们。

在另一个没有 Room 的项目中，我使用 async{} 和 .await() 在使用协程时执行顺序操作，但我无法真正让它在这里工作。当我在插入方法之后暂停调试器时，“allLicences”的值始终为空，但在恢复和导出数据库后，数据被正确插入。我还尝试在 ViewModel 方法之后添加 .invokeOnCompletion{}，但结果相同。
基本上我想等待这个方法结束来做另一个操作。

有什么建议吗？

编辑

我完全忘了报告模型！每个许可证都有一个配置列表。当我执行许可证插入时，我采用自动生成的 ID，将其应用于 licenceConfig，然后为每个 licenceConfig 对象（ViewModel 方法的嵌套 forEach 循环中的代码）执行插入。问题似乎是执行这个嵌套循环破坏了操作的“同步性”

Answer 1

要等到插入完成，您需要将协程创建从insertLicences() 移动到您的观察者，并让insertLicences() 成为挂起函数。

---

loginViewModel.apiResponse.observe(this, Observer { response ->
    lifecycleScope.launch { 
        response?.let {
             loginViewModel.insertLicences(response.licence)
        }
        //here I need to wait for the insertion to end
        loginViewModel.methodToCheckForTheFieldOnDatabase()
    }
})

和

suspend fun insertLicences(licences: List<Licence>) {
    roomRepository.deleteAllLicences()
    licences.forEach { licence ->
        roomRepository.insertLicence(licence).also { insertedLicenceId ->
            licence.config?.forEach { licenceConfiguration ->
                roomRepository.insertLicenceConfiguration(
                    licenceConfiguration.apply { licenceReference = insertedLicenceId.toInt() }
                )
            }
        }
    }
}

---

替代解决方案

您可以将观察者中存在的所有代码转移到 ViewModel 中。

loginViewModel.apiResponse.observe(this, Observer { response ->
    loginViewModel.refreshLicenses(response)
})

在 ViewModel 中

fun refreshLicenses(response:Response?){
    viewModelScope.launch{
        response?.let {
            insertLicences(response.licence)
        }
        methodToCheckForTheFieldOnDatabase()
    }
}

并将 insertLicences 设为挂起函数

suspend fun insertLicences(licences: List<Licence>) {
    roomRepository.deleteAllLicences()
    licences.forEach { licence ->
        roomRepository.insertLicence(licence).also { insertedLicenceId ->
            licence.config?.forEach { licenceConfiguration ->
                roomRepository.insertLicenceConfiguration(
                    licenceConfiguration.apply { licenceReference = insertedLicenceId.toInt() }
                )
            }
        }
    }
}

Answer 2

编辑：在我回复之前没有阅读你的结论但是，我仍然认为你的答案在于协程

使用回调或promise，插入查询完成后不会执行你的函数吗？

回调

使用回调，想法是将一个函数作为参数传递给 另一个函数，并在进程完成后调用这个函数 完成。

fun postItem(item: Item) {
    preparePostAsync { token -> 
        submitPostAsync(token, item) { post -> 
            processPost(post)
        }
    }
}

fun preparePostAsync(callback: (Token) -> Unit) {
    // make request and return immediately 
    // arrange callback to be invoked later
}

我希望承诺是诚实的

承诺

期货或承诺背后的想法（还有其他术语 可以根据语言/平台引用），是当我们 打个电话，我们承诺在某个时候它会返回一个 称为 Promise 的对象，然后可以对其进行操作。

fun postItem(item: Item) {
    preparePostAsync() 
        .thenCompose { token -> 
            submitPostAsync(token, item)
        }
        .thenAccept { post -> 
            processPost(post)
        }

}

fun preparePostAsync(): Promise<Token> {
    // makes request an returns a promise that is completed later
    return promise 
}

做好你的工作，当承诺履行完毕后，继续进行数据验证。

您可以阅读有关协程的更多信息here