Replaced LiveData with StateFlow

app/src/main/java/io/xxlabs/messenger/start/model/AppState.kt

+package io.xxlabs.messenger.start.model
+
+data class AppState(
+    val userState: UserState,
+    val versionState: VersionState
+)
\ No newline at end of file

app/src/main/java/io/xxlabs/messenger/start/model/AppVersionStatus.kt → app/src/main/java/io/xxlabs/messenger/start/model/UserState.kt

 package io.xxlabs.messenger.start.model
 
-enum class AppVersionStatus {
-    Ok, UpdateRecommended, UpdateRequired
+enum class UserState {
+    NewUser, ExistingUser
 }

app/src/main/java/io/xxlabs/messenger/start/model/VersionState.kt

+package io.xxlabs.messenger.start.model
+
+import io.xxlabs.messenger.start.ui.VersionAlertUi
+
+sealed class VersionState
+
+class Checking: VersionState()
+class VersionOk : VersionState()
+class UpdateRecommended(val alertUi: VersionAlertUi) : VersionState()
+class UpdateRequired(val alertUi: VersionAlertUi) : VersionState()
\ No newline at end of file

app/src/main/java/io/xxlabs/messenger/start/ui/ColdStartActivity.kt

@@ -9,6 +9,9 @@ import androidx.core.view.ViewCompat
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
 import io.elixxir.feature.home.MainActivity
 import io.elixxir.feature.home.MainActivity.Companion.INTENT_INVITATION
 import io.elixxir.feature.home.MainActivity.Companion.INTENT_NOTIFICATION_CLICK
@@ -16,6 +19,8 @@ import io.xxlabs.messenger.R
 import io.elixxir.feature.registration.registration.RegistrationFlowActivity
 import io.elixxir.core.ui.util.getTransition
 import io.elixxir.core.ui.util.openLink
+import io.xxlabs.messenger.start.model.*
+import kotlinx.coroutines.launch
 
 /**
  * The app entry point when initially launched. Has no UI.
@@ -29,6 +34,13 @@ class ColdStartActivity : AppCompatActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+
+        lifecycleScope.launch {
+            repeatOnLifecycle(Lifecycle.State.STARTED) {
+                observeState()
+            }
+        }
+
         WindowCompat.setDecorFitsSystemWindows(window, false)
         hideSystemBars()
 
@@ -83,44 +95,29 @@ class ColdStartActivity : AppCompatActivity() {
         }
     }
 
-    override fun onStart() {
-        super.onStart()
-        observeUi()
+    private fun observeState() {
+        lifecycleScope.launch {
+            viewModel.appState.collect {
+                with(it) {
+                    when (versionState) {
+                        is VersionOk -> {
+                            if (userState == UserState.NewUser) navigateToRegistration()
+                            else navigateToMain()
                         }
-
-    private fun observeUi() {
-        viewModel.navigateToRegistration.observe(this) { go ->
-            if (go) {
-                navigateToRegistration()
-                viewModel.onNavigationHandled()
+                        is UpdateRecommended -> showAlert(versionState.alertUi)
+                        is UpdateRequired -> showAlert(versionState.alertUi)
+                        else -> {}
                     }
                 }
-
-        viewModel.navigateToMain.observe(this) { go ->
-            if (go) {
-                navigateToMain()
-                viewModel.onNavigationHandled()
             }
         }
 
-        viewModel.versionAlert.observe(this) { alert ->
-            alert?.let {
-                showAlert(it)
-                viewModel.onVersionAlertShown()
+        lifecycleScope.launch {
+            viewModel.launchUrl.collect {
+                it?.let {
+                    openLink(it)
                 }
             }
-
-        viewModel.error.observe(this) { error ->
-            error?.let {
-                showError(error)
-            }
-        }
-
-        viewModel.navigateToUrl.observe(this) { url ->
-            url?.let {
-                openLink(url)
-                viewModel.onUrlHandled()
-            }
         }
     }
 
@@ -147,10 +144,10 @@ class ColdStartActivity : AppCompatActivity() {
     }
 
     private fun showAlert(alertUi: VersionAlertUi) {
-
+        TODO()
     }
 
     private fun showError(error: String) {
-
+        TODO()
     }
 }
\ No newline at end of file

app/src/main/java/io/xxlabs/messenger/start/ui/ColdStartViewModel.kt

@@ -3,12 +3,16 @@ package io.xxlabs.messenger.start.ui
 import androidx.lifecycle.*
 import com.google.gson.JsonElement
 import com.google.gson.JsonObject
+import io.elixxir.core.logging.NotExposedYet
 import io.elixxir.core.logging.log
 import io.elixxir.core.preferences.PreferencesRepository
-import io.xxlabs.messenger.start.model.VersionData
+import io.elixxir.core.ui.model.UiText
+import io.xxlabs.messenger.R
+import io.xxlabs.messenger.start.model.*
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
+import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
 import java.io.File
 
@@ -19,20 +23,16 @@ class ColdStartViewModel(
     private val preferences: PreferencesRepository
 ) : ViewModel() {
 
-    val navigateToRegistration: LiveData<Boolean> by ::_navigateToRegistration
-    private val _navigateToRegistration = MutableLiveData(false)
+    private val _appState = MutableStateFlow(
+        AppState(userState, Checking())
+    )
+    val appState = _appState.asStateFlow()
 
-    val navigateToMain: LiveData<Boolean> by ::_navigateToMain
-    private val _navigateToMain = MutableLiveData(false)
+    private val _launchUrl = MutableSharedFlow<String?>()
+    val launchUrl = _launchUrl.asSharedFlow()
 
-    val versionAlert: LiveData<VersionAlertUi?> by ::_versionAlert
-    private val _versionAlert = MutableLiveData<VersionAlertUi?>(null)
-
-    val error: LiveData<String?> by ::_error
-    private val _error = MutableLiveData<String?>(null)
-
-    val navigateToUrl: LiveData<String?> by ::_navigateToUrl
-    private val _navigateToUrl = MutableLiveData<String?>(null)
+    private val userState: UserState
+        get() = if (userExists()) UserState.ExistingUser else UserState.NewUser
 
     init {
         initializeApp()
@@ -43,18 +43,23 @@ class ColdStartViewModel(
             maybeClearData()
 //            fetchCommonErrors()
 //            parseJson(downloadRegistrationJson())
-            versionOk()
+            _appState.emit(
+                AppState(
+                    userState = userState,
+                    versionState = VersionOk()
+                )
+            )
         }
     }
 
+    fun userExists(): Boolean = preferences.doesUserExist()
+
     private suspend fun maybeClearData(): Boolean{
         return if (!userExists()) {
             clearAppDataAsync().await()
         } else true
     }
 
-    fun userExists(): Boolean = preferences.doesUserExist()
-
     private fun clearAppDataAsync() : Deferred<Boolean> {
         return viewModelScope.async {
             File("Session folder").apply {
@@ -70,14 +75,14 @@ class ColdStartViewModel(
     }
 
     private fun fetchCommonErrors() {
-        TODO()
+        NotExposedYet()
     }
 
     private fun downloadRegistrationJson(): JsonObject {
-        TODO()
+        NotExposedYet()
     }
 
-    private fun parseJson(json: JsonElement) {
+    private fun parseJson(json: JsonElement): VersionState {
         val registrationWrapper = VersionData.from(json)
         val appVersion = registrationWrapper.appVersion
         val minVersion = registrationWrapper.minVersion
@@ -85,61 +90,59 @@ class ColdStartViewModel(
         val downloadUrl = registrationWrapper.downloadUrl
         val popupMessage = registrationWrapper.minPopupMessage
 
-        when {
-            appVersion < minVersion -> updateRequiredAlert(popupMessage, downloadUrl)
+        return when {
+            appVersion < minVersion -> updateRequired(popupMessage, downloadUrl)
             appVersion >= minVersion && appVersion < recommendedVersion -> {
-                updateRecommendedAlert(downloadUrl)
-            }
-            else -> versionOk()
-        }
-    }
-
-    private fun updateRecommendedAlert(downloadUrl: String): VersionAlertUi {
-        TODO()
-    }
-
-    private fun updateRequiredAlert(message: String, downloadUrl: String): VersionAlertUi {
-        TODO()
-    }
-
-    private fun versionOk() {
-        _versionAlert.value = null
-        determineNavigation()
-    }
-
-    private fun determineNavigation() {
-        if (userExists()) {
-            _navigateToMain.value = true
-            _navigateToRegistration.value = false
-        } else {
-            _navigateToRegistration.value = true
-            _navigateToMain.value = false
-        }
-    }
-
-    fun onNavigationHandled() {
-        _navigateToMain.value = null
-        _navigateToRegistration.value = null
-    }
-
-    fun onVersionAlertShown() {
-        _versionAlert.value = null
-    }
-
-    fun onUrlHandled() {
-        _navigateToUrl.value = null
+                updateRecommended(downloadUrl)
+            }
+            else -> VersionOk()
+        }
+    }
+
+    private fun updateRecommended(downloadUrl: String): VersionState {
+        return UpdateRecommended(
+            VersionAlert(
+                title = UiText.StringResource(R.string.version_alert_update_recommended_title),
+                body = UiText.StringResource(R.string.version_alert_update_recommended_subtitle),
+                positiveLabel = UiText.StringResource(R.string.version_alert_update_required_positive_label),
+                negativeLabel = UiText.StringResource(R.string.version_alert_update_recommended_negative_label),
+                onPositiveClick = { onUpdateRequiredPositiveClick(downloadUrl) },
+                onNegativeClick = ::onUpdateRecommendedNegativeClick,
+                onDismissed = ::onUpdateRecommendedDismissed,
+                dismissable = true,
+                downloadUrl = downloadUrl
+            )
+        )
+    }
+
+    private fun updateRequired(message: String, downloadUrl: String): VersionState {
+        return UpdateRequired(
+            VersionAlert(
+                title = UiText.StringResource(R.string.version_alert_update_required_title),
+                body = UiText.DynamicString(message),
+                positiveLabel = UiText.StringResource(R.string.version_alert_update_required_positive_label),
+                negativeLabel = UiText.StringResource(R.string.version_alert_update_recommended_negative_label),
+                onPositiveClick = { onUpdateRequiredPositiveClick(downloadUrl) },
+                onNegativeClick = { },
+                onDismissed = { },
+                dismissable = false,
+                downloadUrl = downloadUrl
+            )
+        )
     }
 
     private fun onUpdateRecommendedPositiveClick(url: String) {
-        _navigateToUrl.value = url
+        viewModelScope.launch {
+            _launchUrl.emit(url)
+        }
     }
 
     private fun onUpdateRecommendedNegativeClick() {
-        determineNavigation()
+        onUpdateRecommendedDismissed()
     }
 
     private fun onUpdateRecommendedDismissed() {
-        determineNavigation()
+        _appState.value = AppState(userState, VersionOk())
     }
 
     private fun onUpdateRequiredPositiveClick(url: String) {