fix: Use mutex for processing state validation

Change-Id: I738e565067770fb80003b7bd0dc040e3e2fd855b
XayahSuSuSu · Oct 4, 2023 · be8fa57 · be8fa57
1 parent e8422ba
commit be8fa57
Show file tree

Hide file tree

Showing 4 changed files with 79 additions and 40 deletions.
diff --git a/...c/main/java/com/xayah/databackup/ui/activity/operation/page/media/backup/ListViewModel.kt b/...c/main/java/com/xayah/databackup/ui/activity/operation/page/media/backup/ListViewModel.kt
@@ -4,6 +4,7 @@ import android.content.Context
 import android.widget.Toast
 import androidx.activity.ComponentActivity
 import androidx.compose.runtime.State
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
@@ -27,6 +28,8 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import javax.inject.Inject
 
 enum class OpType {
@@ -35,6 +38,7 @@ enum class OpType {
 }
 
 data class MediaBackupListUiState(
+    val mutex: Mutex,
     val isLoading: Boolean,
     val opType: OpType,
     val timestamp: Long,
@@ -48,6 +52,7 @@ data class MediaBackupListUiState(
 class MediaBackupListViewModel @Inject constructor(private val mediaDao: MediaDao) : ViewModel() {
     private val _uiState = mutableStateOf(
         MediaBackupListUiState(
+            mutex = Mutex(),
             isLoading = true,
             opType = OpType.LIST,
             timestamp = DateUtil.getTimestamp(),
@@ -132,18 +137,24 @@ class MediaBackupListViewModel @Inject constructor(private val mediaDao: MediaDa
     }
 
     fun onProcessing() {
-        if (uiState.value.opType == OpType.LIST)
-            viewModelScope.launch {
-                withIOContext {
-                    updateTimestamp()
-                    setType(OpType.PROCESSING)
+        val uiState by uiState
+
+        viewModelScope.launch {
+            uiState.mutex.withLock {
+                if (uiState.opType == OpType.LIST) {
+                    withIOContext {
+                        setType(OpType.PROCESSING)
 
-                    val operationLocalService = OperationLocalService(context = DataBackupApplication.application)
-                    operationLocalService.backupMedium(uiState.value.timestamp)
-                    operationLocalService.destroyService()
+                        updateTimestamp()
 
-                    setType(OpType.LIST)
+                        val operationLocalService = OperationLocalService(context = DataBackupApplication.application)
+                        operationLocalService.backupMedium(uiState.timestamp)
+                        operationLocalService.destroyService()
+
+                        setType(OpType.LIST)
+                    }
                 }
             }
+        }
     }
 }
diff --git a/.../main/java/com/xayah/databackup/ui/activity/operation/page/media/restore/ListViewModel.kt b/.../main/java/com/xayah/databackup/ui/activity/operation/page/media/restore/ListViewModel.kt
@@ -18,9 +18,12 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import javax.inject.Inject
 
 data class MediaRestoreListUiState(
+    val mutex: Mutex,
     val isLoading: Boolean,
     val opType: OpType,
     val timestamps: List<Long>,
@@ -37,6 +40,7 @@ data class MediaRestoreListUiState(
 class MediaRestoreListViewModel @Inject constructor(private val mediaDao: MediaDao) : ViewModel() {
     private val _uiState = mutableStateOf(
         MediaRestoreListUiState(
+            mutex = Mutex(),
             isLoading = false,
             opType = OpType.LIST,
             timestamps = listOf(),
@@ -85,17 +89,22 @@ class MediaRestoreListViewModel @Inject constructor(private val mediaDao: MediaD
     }
 
     fun onProcessing() {
-        if (uiState.value.opType == OpType.LIST)
-            viewModelScope.launch {
-                withIOContext {
-                    setType(OpType.PROCESSING)
+        val uiState by uiState
 
-                    val operationLocalService = OperationLocalService(context = DataBackupApplication.application)
-                    operationLocalService.restoreMedium(uiState.value.timestamp)
-                    operationLocalService.destroyService()
+        viewModelScope.launch {
+            uiState.mutex.withLock {
+                if (uiState.opType == OpType.LIST) {
+                    withIOContext {
+                        setType(OpType.PROCESSING)
 
-                    setType(OpType.LIST)
+                        val operationLocalService = OperationLocalService(context = DataBackupApplication.application)
+                        operationLocalService.restoreMedium(uiState.timestamp)
+                        operationLocalService.destroyService()
+
+                        setType(OpType.LIST)
+                    }
                 }
             }
+        }
     }
 }
diff --git a/...va/com/xayah/databackup/ui/activity/operation/page/packages/backup/ProcessingViewModel.kt b/...va/com/xayah/databackup/ui/activity/operation/page/packages/backup/ProcessingViewModel.kt
@@ -2,6 +2,7 @@ package com.xayah.databackup.ui.activity.operation.page.packages.backup
 
 import android.app.Application
 import androidx.compose.runtime.State
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
@@ -15,6 +16,8 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import javax.inject.Inject
 
 enum class ProcessingState {
@@ -24,6 +27,7 @@ enum class ProcessingState {
 }
 
 data class ProcessingUiState(
+    val mutex: Mutex,
     val timestamp: Long,
     var effectLaunched: Boolean,
     var effectFinished: Boolean,
@@ -44,6 +48,7 @@ class ProcessingViewModel @Inject constructor(
 ) : ViewModel() {
     private val _uiState = mutableStateOf(
         ProcessingUiState(
+            mutex = Mutex(),
             timestamp = DateUtil.getTimestamp(),
             effectLaunched = false,
             effectFinished = false,
@@ -56,23 +61,28 @@ class ProcessingViewModel @Inject constructor(
         get() = _uiState
 
     fun backupPackages() {
-        val uiState = uiState.value
-        if (_uiState.value.effectLaunched.not())
-            viewModelScope.launch {
-                withIOContext {
-                    _uiState.value = uiState.copy(effectLaunched = true)
-                    val operationLocalService = OperationLocalService(context = context)
-                    val preparation = operationLocalService.backupPackagesPreparation()
+        val uiState by uiState
 
-                    _uiState.value = uiState.copy(effectState = ProcessingState.Processing)
-                    operationLocalService.backupPackages(timestamp = uiState.timestamp)
+        viewModelScope.launch {
+            uiState.mutex.withLock {
+                if (uiState.effectLaunched.not()) {
+                    withIOContext {
+                        _uiState.value = uiState.copy(effectLaunched = true)
 
-                    _uiState.value = uiState.copy(effectState = ProcessingState.Waiting)
-                    operationLocalService.backupPackagesAfterwards(preparation)
+                        val operationLocalService = OperationLocalService(context = context)
+                        val preparation = operationLocalService.backupPackagesPreparation()
 
-                    operationLocalService.destroyService()
-                    _uiState.value = uiState.copy(effectFinished = true)
+                        _uiState.value = uiState.copy(effectState = ProcessingState.Processing)
+                        operationLocalService.backupPackages(timestamp = uiState.timestamp)
+
+                        _uiState.value = uiState.copy(effectState = ProcessingState.Waiting)
+                        operationLocalService.backupPackagesAfterwards(preparation)
+
+                        operationLocalService.destroyService()
+                        _uiState.value = uiState.copy(effectFinished = true)
+                    }
                 }
             }
+        }
     }
 }
diff --git a/...a/com/xayah/databackup/ui/activity/operation/page/packages/restore/ProcessingViewModel.kt b/...a/com/xayah/databackup/ui/activity/operation/page/packages/restore/ProcessingViewModel.kt
@@ -17,9 +17,12 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import javax.inject.Inject
 
 data class ProcessingUiState(
+    val mutex: Mutex,
     val timestamp: Long,
     var effectLaunched: Boolean,
     var effectFinished: Boolean,
@@ -40,6 +43,7 @@ class ProcessingViewModel @Inject constructor(
 ) : ViewModel() {
     private val _uiState = mutableStateOf(
         ProcessingUiState(
+            mutex = Mutex(),
             timestamp = DateUtil.getTimestamp(),
             effectLaunched = false,
             effectFinished = false,
@@ -53,19 +57,24 @@ class ProcessingViewModel @Inject constructor(
 
     fun restorePackages() {
         val uiState by uiState
-        if (uiState.effectLaunched.not())
-            viewModelScope.launch {
-                withIOContext {
-                    _uiState.value = uiState.copy(effectLaunched = true)
-                    val operationLocalService = OperationLocalService(context = context)
-                    operationLocalService.restorePackagesPreparation()
 
-                    _uiState.value = uiState.copy(effectState = ProcessingState.Processing)
-                    operationLocalService.restorePackages(timestamp = uiState.timestamp)
+        viewModelScope.launch {
+            uiState.mutex.withLock {
+                if (uiState.effectLaunched.not()) {
+                    withIOContext {
+                        _uiState.value = uiState.copy(effectLaunched = true)
 
-                    operationLocalService.destroyService()
-                    _uiState.value = uiState.copy(effectFinished = true)
+                        val operationLocalService = OperationLocalService(context = context)
+                        operationLocalService.restorePackagesPreparation()
+
+                        _uiState.value = uiState.copy(effectState = ProcessingState.Processing)
+                        operationLocalService.restorePackages(timestamp = uiState.timestamp)
+
+                        operationLocalService.destroyService()
+                        _uiState.value = uiState.copy(effectFinished = true)
+                    }
                 }
             }
+        }
     }
 }