add lazy suspend

Author: Razeeman

domain/src/main/java/com/example/util/simpletimetracker/domain/base/LazySuspend.kt

@@ -0,0 +1,16 @@
+package com.example.util.simpletimetracker.domain.base
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.async
+
+fun <T> CoroutineScope.suspendLazy(
+    initializer: suspend CoroutineScope.() -> T
+) = object : SuspendLazy<T> {
+    private val deferred = async(start = CoroutineStart.LAZY, block = initializer)
+    override suspend operator fun invoke(): T = deferred.await()
+}
+
+interface SuspendLazy<T> {
+    suspend operator fun invoke(): T
+}

domain/src/main/java/com/example/util/simpletimetracker/domain/record/interactor/AddRunningRecordMediator.kt

@@ -11,10 +11,13 @@ import com.example.util.simpletimetracker.domain.notifications.interactor.Update
 import com.example.util.simpletimetracker.domain.recordType.model.RecordType
 import com.example.util.simpletimetracker.domain.base.ResultContainer
 import com.example.util.simpletimetracker.domain.base.CurrentTimestampProvider
+import com.example.util.simpletimetracker.domain.base.SuspendLazy
+import com.example.util.simpletimetracker.domain.base.suspendLazy
 import com.example.util.simpletimetracker.domain.record.model.Record
 import com.example.util.simpletimetracker.domain.record.model.RecordBase
 import com.example.util.simpletimetracker.domain.record.model.RecordDataSelectionDialogResult
 import com.example.util.simpletimetracker.domain.record.model.RunningRecord
+import kotlinx.coroutines.coroutineScope
 import java.util.concurrent.TimeUnit
 import javax.inject.Inject
 
@@ -72,21 +75,16 @@ class AddRunningRecordMediator @Inject constructor(
         timeStarted: StartTime = StartTime.TakeCurrent,
         updateNotificationSwitch: Boolean = true,
         checkDefaultDuration: Boolean = true,
-    ) {
+    ) = coroutineScope {
         val currentTime = currentTimestampProvider.get()
         val actualTimeStarted = when (timeStarted) {
             is StartTime.Current -> timeStarted.currentTimeStampMs
             is StartTime.TakeCurrent -> currentTime
             is StartTime.Timestamp -> timeStarted.timestampMs
         }.coerceAtMost(currentTime)
         val retroactiveTrackingMode = prefsInteractor.getRetroactiveTrackingMode()
-        val actualPrevRecords = if (
-            retroactiveTrackingMode ||
-            complexRuleProcessActionInteractor.hasRules()
-        ) {
+        val actualPrevRecords = suspendLazy {
             recordInteractor.getAllPrev(actualTimeStarted)
-        } else {
-            emptyList()
         }
         val rulesResult = if (
             retroactiveTrackingMode &&
@@ -184,7 +182,7 @@ class AddRunningRecordMediator @Inject constructor(
 
     private suspend fun addRetroactiveModeInternal(
         params: StartParams,
-        prevRecords: List<Record>,
+        prevRecords: SuspendLazy<List<Record>>,
     ) {
         val type = recordTypeInteractor.get(params.typeId) ?: return
 
@@ -247,7 +245,7 @@ class AddRunningRecordMediator @Inject constructor(
 
     private suspend fun addRecordRetroactively(
         params: StartParams,
-        prevRecords: List<Record>,
+        prevRecords: SuspendLazy<List<Record>>,
     ) {
         val prevRecord = getPrevRecordToMergeWith(params.typeId, prevRecords)
         val sameTags = prevRecord?.tags.orEmpty().sortedBy { it.tagId } == params.tags.sortedBy { it.tagId }
@@ -265,7 +263,7 @@ class AddRunningRecordMediator @Inject constructor(
                     ?: prevRecord.tags,
             )
         } else {
-            val newTimeStarted = prevRecords.firstOrNull()?.timeEnded
+            val newTimeStarted = prevRecords().firstOrNull()?.timeEnded
                 ?: (params.timeStarted - TimeUnit.MINUTES.toMillis(5))
             Record(
                 id = 0L, // Creates new record.
@@ -285,7 +283,7 @@ class AddRunningRecordMediator @Inject constructor(
     private suspend fun processRules(
         typeId: Long,
         timeStarted: Long,
-        prevRecords: List<Record>,
+        prevRecords: SuspendLazy<List<Record>>,
     ): ComplexRuleProcessActionInteractor.Result {
         // If no rules - no need to check them.
         return if (complexRuleProcessActionInteractor.hasRules()) {
@@ -297,7 +295,7 @@ class AddRunningRecordMediator @Inject constructor(
                 hasAnyRunningTimersOnTimeStarted
 
             // If no current records - check closest previous.
-            val records = if (takeCurrentRecords) currentRecords else prevRecords
+            val records = if (takeCurrentRecords) currentRecords else prevRecords()
 
             val currentTypeIds = records
                 .map { it.typeIds }
@@ -350,15 +348,15 @@ class AddRunningRecordMediator @Inject constructor(
 
     private suspend fun processRetroactiveMultitasking(
         params: StartParams,
-        prevRecords: List<Record>,
+        prevRecords: SuspendLazy<List<Record>>,
     ) {
         if (!params.isMultitaskingAllowed) return
 
         val recordTypesMap = recordTypeInteractor.getAll().associateBy(RecordType::id)
         val mergedRecord = getPrevRecordToMergeWith(params.typeId, prevRecords)
 
         // Extend prev records to current time.
-        prevRecords.filter {
+        prevRecords().filter {
             // Skip record that would be merge.
             it.id != mergedRecord?.id
         }.filter {
@@ -392,11 +390,11 @@ class AddRunningRecordMediator @Inject constructor(
         return result.distinctBy { it.tagId }
     }
 
-    private fun getPrevRecordToMergeWith(
+    private suspend fun getPrevRecordToMergeWith(
         typeId: Long,
-        prevRecords: List<Record>,
+        prevRecords: SuspendLazy<List<Record>>,
     ): Record? {
-        return prevRecords.firstOrNull { it.typeId == typeId }
+        return prevRecords().firstOrNull { it.typeId == typeId }
     }
 
     private data class StartParams(