[NEMO-201] only retrieve data set once

Author: PecaWolf

data/src/commonMain/kotlin/org/tidepool/sdk/repository/DataRepositoryImpl.kt

@@ -45,6 +45,9 @@ import org.tidepool.sdk.model.data.NewDataSource
 import org.tidepool.sdk.runCatchingNetworkExceptions
 import java.time.Instant
 import kotlin.collections.toTypedArray
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 
 class DataRepositoryImpl(
     private val dataApi: DataApi,
@@ -63,15 +66,58 @@ class DataRepositoryImpl(
 
     private val KEY_CACHED_DATA_SET_ID: String = "KEY_CACHED_DATA_SET_ID"
 
-    override var cachedDataSetId: String? = null
-        get() {
-            return field ?: keyValueStorage.getString(KEY_CACHED_DATA_SET_ID)
-        }
+    private var cachedDataSetId: String? = null
+        get() = field ?: keyValueStorage.getString(KEY_CACHED_DATA_SET_ID)
+            .also { field = it }
         set(value) {
             field = value
             keyValueStorage.putString(KEY_CACHED_DATA_SET_ID, value)
         }
 
+    private val dataSetIdMutex: Mutex = Mutex()
+    private var dataSetIdDeferred: CompletableDeferred<String>? = null
+
+    override suspend fun awaitOrCreateCachedDataSetId(
+        create: suspend () -> Result<String>,
+    ): Result<String> {
+        // Fast-path when already available
+        cachedDataSetId?.let { return Result.success(it) }
+
+        var isCreator = false
+        val localDeferred: CompletableDeferred<String> = dataSetIdMutex.withLock {
+            // Re-check after acquiring the lock
+            cachedDataSetId?.let { return Result.success(it) }
+            if (dataSetIdDeferred == null) {
+                dataSetIdDeferred = CompletableDeferred()
+                isCreator = true
+            }
+            dataSetIdDeferred!!
+        }
+
+        if (isCreator) {
+            val result = create()
+            dataSetIdMutex.withLock {
+                if (result.isSuccess) {
+                    val id = result.getOrThrow()
+                    cachedDataSetId = id
+                    dataSetIdDeferred?.complete(id)
+                } else {
+                    val throwable = result.exceptionOrNull()
+                        ?: IllegalStateException("Unknown error creating dataset id")
+                    dataSetIdDeferred?.completeExceptionally(throwable)
+                }
+                dataSetIdDeferred = null
+            }
+            return result
+        }
+
+        return try {
+            Result.success(localDeferred.await())
+        } catch (t: Throwable) {
+            Result.failure(t)
+        }
+    }
+
     override suspend fun getDataForUser(
         userId: String,
         uploadId: String?,

domain/src/commonMain/kotlin/org/tidepool/sdk/repository/DataRepository.kt

@@ -10,7 +10,14 @@ import java.time.Instant
 
 interface DataRepository {
 
-    var cachedDataSetId: String?
+    /**
+     * Returns the cached data set id if available. If not available, ensures that at most one
+     * coroutine performs the discovery/creation via [create], while all other callers wait for
+     * the result. This provides a three-state behavior: Uninitialized, Loading, and Ready.
+     */
+    suspend fun awaitOrCreateCachedDataSetId(
+        create: suspend () -> Result<String>,
+    ): Result<String>
 
     suspend fun getDataForUser(
         userId: String,

domain/src/commonMain/kotlin/org/tidepool/sdk/service/DataService.kt

@@ -343,11 +343,8 @@ class DataService internal constructor(
 
     suspend fun uploadData(data: BaseData): Result<List<BaseData>> = uploadData(listOf(data))
 
-    private suspend fun getDataSetId(): Result<String> {
-        println("DataService: Getting data set ID")
-        return dataRepository.cachedDataSetId?.let {
-            Result.success(it)
-        } ?: getUserDataSets()
+    private suspend fun getDataSetId() = dataRepository.awaitOrCreateCachedDataSetId {
+        getUserDataSets()
             .flatMap { dataSets ->
                 dataSets
                     .filter { it.uploadId != null }
@@ -387,8 +384,5 @@ class DataService internal constructor(
                 it.id?.let { Result.success(it) }
                     ?: Result.failure(IllegalStateException("No id"))
             }
-            .onSuccess {
-                dataRepository.cachedDataSetId = it
-            }
     }
 }