SpeziAccount & SpeziFirebase

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/AccountConfiguration.kt

@@ -0,0 +1,39 @@
+package edu.stanford.spezi.module.account
+
+import androidx.annotation.MainThread
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextField
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty1
+
+// SpeziAccount
+
+/*
+
+interface AccountKeyInput<Value : Any> {
+    val id: String?
+    val name: String
+    val category: AccountKeyCategory
+    val displayView: @Composable (Value) -> Unit
+    val entryView: @Composable (MutableState<Value>) -> Unit
+}
+
+annotation class AccountValue<Input: AccountKeyInput<*>>
+
+data class NameAccountKeyInput(val input: Unit): AccountKeyInput<String> {
+    override val id: String? get() = null
+    override val name: String get() = "Name"
+    override val category: AccountKeyCategory get() = AccountKeyCategory.name
+    override val displayView: @Composable (String) -> Unit get() = { text ->
+        Text(text)
+    }
+    override val entryView: @Composable (MutableState<String>) -> Unit get() = { state ->
+        TextField(value = state.value, onValueChange = { state.value = it })
+    }
+}
+
+@AccountValue<NameAccountKeyInput>
+val AccountDetails.name: String? get() = null
+ */

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/account/Account.kt

@@ -0,0 +1,14 @@
+package edu.stanford.spezi.module.account.account
+
+import edu.stanford.spezi.module.account.account.service.AccountService
+import edu.stanford.spezi.module.account.account.value.collections.AccountDetails
+
+class Account(
+    service: AccountService,
+    configuration: AccountValueConfiguration = AccountValueConfiguration.default,
+    details: AccountDetails? = null
+) {
+    var signedIn: Boolean = details != null
+        private set
+
+}

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/account/AccountConfiguration.kt

@@ -0,0 +1,20 @@
+package edu.stanford.spezi.module.account.account
+
+import edu.stanford.spezi.core.logging.speziLogger
+import edu.stanford.spezi.module.account.account.service.AccountService
+import edu.stanford.spezi.module.account.spezi.Module
+import edu.stanford.spezi.module.account.spezi.Standard
+
+class AccountConfiguration<Service: AccountService>: Module {
+    private val logger by speziLogger()
+
+    val account: Account = TODO()
+    private val externalStorage: ExternalAccountStorage = TODO()
+    private val accountService: Service = TODO()
+    private val storageProvider: List<Module> = TODO()
+    private val standard: Standard = TODO()
+
+    override fun configure() {
+        TODO()
+    }
+}

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/account/AccountDetailsCache.kt

@@ -0,0 +1,49 @@
+package edu.stanford.spezi.module.account.account
+
+import edu.stanford.spezi.core.logging.speziLogger
+import edu.stanford.spezi.module.account.account.value.collections.AccountDetails
+import edu.stanford.spezi.module.account.account.value.collections.AccountKey
+import edu.stanford.spezi.module.account.account.value.collections.AccountModifications
+import edu.stanford.spezi.module.account.spezi.Module
+import kotlin.reflect.KClass
+
+class AccountDetailsCache: Module {
+    private val logger by speziLogger()
+
+    private val localCache = mutableMapOf<String, AccountDetails>()
+
+    fun loadEntry(accountId: String, keys: Set<KClass<AccountKey<*>>>): AccountDetails? {
+        localCache[accountId]?.let {
+            return it
+        }
+
+        return null // TODO: lead from persistency as well
+    }
+
+    fun clearEntry(accountId: String) {
+        localCache.remove(accountId)
+        // TODO: Delete persistence as well
+    }
+
+    internal fun purgeMemoryCache(accountId: String) {
+        localCache.remove(accountId)
+    }
+
+    fun communicateModifications(accountId: String, modifications: AccountModifications) {
+        val details = AccountDetails()
+        localCache[accountId]?.let {
+            // TODO("AccountDetails.add(contentsOf:) missing!")
+        }
+        // TODO("AccountDetails.add(contentsOf:merge:) missing!")
+        // TODO("AccountDetails.removeAll() missing!")
+
+        communicateRemoteChanges(accountId, details)
+    }
+
+    fun communicateRemoteChanges(accountId: String, details: AccountDetails) {
+        localCache[accountId] = details
+
+        // TODO: Persistent store missing
+    }
+
+}

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/account/AccountNotifications.kt

@@ -0,0 +1,61 @@
+package edu.stanford.spezi.module.account.account
+
+import android.text.style.TabStopSpan.Standard
+import edu.stanford.spezi.module.account.account.value.collections.AccountDetails
+import edu.stanford.spezi.module.account.account.value.keys.accountId
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.FlowCollector
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.onCompletion
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import java.util.UUID
+
+class AccountNotifications {
+    sealed interface Event {
+        data class DeletingAccount(val accountId: String): Event
+        data class AssociatedAccount(val details: AccountDetails): Event
+        data class DetailsChanged(val previous: AccountDetails, val new: AccountDetails): Event
+        data class DisassociatingAccount(val details: AccountDetails): Event
+    }
+
+    private val standard: Standard = TODO()
+    private val storage: ExternalAccountStorage = TODO()
+    private val collectors = mutableMapOf<UUID, FlowCollector<Event>>()
+    private val mutex = Mutex()
+
+    val events: Flow<Event> get() = newSubscription()
+
+    suspend fun respondToEvent(event: Event) {
+        (standard as? AccountNotifyConstraint)?.respondToEvent(event)
+
+        when (event) {
+            is Event.DeletingAccount -> {
+                storage.willDeleteAccount(event.accountId)
+            }
+            is Event.DisassociatingAccount -> {
+                storage.userWillDisassociate(event.details.accountId)
+            }
+            else -> {}
+        }
+
+        mutex.withLock {
+            for (collector in collectors.values) {
+                collector.emit(event)
+            }
+        }
+    }
+
+    private fun newSubscription(): Flow<Event> {
+        val key = UUID.randomUUID()
+        return flow {
+            mutex.withLock {
+                collectors[key] = this
+            }
+        }.onCompletion {
+            mutex.withLock {
+                collectors.remove(key)
+            }
+        }
+    }
+}

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/account/AccountNotifyConstraint.kt

@@ -0,0 +1,5 @@
+package edu.stanford.spezi.module.account.account
+
+interface AccountNotifyConstraint {
+    fun respondToEvent(event: AccountNotifications.Event)
+}

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/account/AccountStorageProvider.kt

@@ -0,0 +1,18 @@
+package edu.stanford.spezi.module.account.account
+
+import edu.stanford.spezi.module.account.account.value.collections.AccountDetails
+import edu.stanford.spezi.module.account.account.value.collections.AccountKey
+import edu.stanford.spezi.module.account.account.value.collections.AccountModifications
+import edu.stanford.spezi.module.account.spezi.Module
+import kotlin.reflect.KClass
+
+interface AccountStorageProvider: Module {
+    suspend fun load(accountId: String, keys: Set<KClass<AccountKey<*>>>): AccountDetails?
+    suspend fun store(accountId: String, details: AccountDetails) {
+        val modifications = AccountModifications(modifiedDetails = details)
+        store(accountId, modifications)
+    }
+    suspend fun store(accountId: String, modifications: AccountModifications)
+    suspend fun disassociate(accountId: String)
+    suspend fun delete(accountId: String)
+}

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/account/ExternalAccountStorage.kt

@@ -0,0 +1,74 @@
+package edu.stanford.spezi.module.account.account
+
+import edu.stanford.spezi.module.account.account.value.collections.AccountDetails
+import edu.stanford.spezi.module.account.account.value.collections.AccountKey
+import edu.stanford.spezi.module.account.account.value.collections.AccountModifications
+import edu.stanford.spezi.module.account.account.value.keys.isIncomplete
+import edu.stanford.spezi.module.account.spezi.Module
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.FlowCollector
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.onCompletion
+import java.util.UUID
+import kotlin.reflect.KClass
+
+class ExternalAccountStorage: Module {
+
+    data class ExternallyStoredDetails(
+        val accountId: String,
+        val details: AccountDetails,
+    )
+
+    private var subscriptions = mutableMapOf<UUID, FlowCollector<ExternallyStoredDetails>>()
+    private var storageProvider: AccountStorageProvider? = null
+
+    val updatedDetails: Flow<ExternallyStoredDetails> get() {
+        val id = UUID.randomUUID()
+        return flow {
+            subscriptions[id] = this
+        }.onCompletion {
+            subscriptions.remove(id)
+        }
+    }
+
+    suspend fun notifyAboutUpdatedDetails(accountId: String, details: AccountDetails) {
+        val newDetails = details.copy()
+        newDetails.isIncomplete = false
+        val update = ExternallyStoredDetails(accountId, newDetails)
+        for (subscription in subscriptions) {
+            subscription.value.emit(update)
+        }
+    }
+
+    suspend fun requestExternalStorage(accountId: String, details: AccountDetails) {
+        // TODO: Check for emptiness and making sure storageProvider exists
+        storageProvider?.store(accountId, details)
+    }
+
+    suspend fun retrieveExternalStorage(accountId: String, keys: List<KClass<AccountKey<*>>>): AccountDetails {
+        if (keys.isEmpty()) return AccountDetails()
+
+        storageProvider?.let { storageProvider ->
+            storageProvider.load(accountId, keys)?.let { details ->
+                return details
+            }
+            val details = AccountDetails()
+            details.isIncomplete = true
+            return details
+        } ?: throw Error("")
+    }
+
+    suspend fun updateExternalStorage(accountId: String, modifications: AccountModifications) {
+        val storageProvider = storageProvider ?: throw Error("")
+        storageProvider.store(accountId, modifications)
+    }
+
+    suspend fun willDeleteAccount(accountId: String) {
+        storageProvider?.delete(accountId)
+    }
+
+    suspend fun userWillDisassociate(accountId: String) {
+        storageProvider?.disassociate(accountId)
+    }
+
+}

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/account/compositionLocal/FollowUpBehavior.kt

@@ -0,0 +1,13 @@
+package edu.stanford.spezi.module.account.account.compositionLocal
+
+import androidx.compose.runtime.compositionLocalOf
+
+enum class FollowUpBehavior {
+    DISABLED, MINIMAL, REDUNDANT;
+
+    companion object {
+        val automatic: FollowUpBehavior get() = MINIMAL
+    }
+}
+
+val localFollowUpBehaviorAfterSetup = compositionLocalOf { FollowUpBehavior.automatic }