[MS-939] Sync UI/UX update

feature/dashboard/src/main/java/com/simprints/feature/dashboard/logout/LogoutSyncViewModel.kt

@@ -2,20 +2,49 @@ package com.simprints.feature.dashboard.logout
 
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.ViewModel
+import androidx.lifecycle.asFlow
+import androidx.lifecycle.asLiveData
 import androidx.lifecycle.liveData
 import androidx.lifecycle.viewModelScope
 import com.simprints.core.livedata.LiveDataEventWithContent
 import com.simprints.feature.dashboard.logout.usecase.LogoutUseCase
+import com.simprints.infra.authstore.AuthStore
 import com.simprints.infra.config.store.models.SettingsPasswordConfig
 import com.simprints.infra.config.sync.ConfigManager
+import com.simprints.infra.eventsync.EventSyncManager
+import com.simprints.infra.sync.SyncOrchestrator
 import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.map
 import javax.inject.Inject
 
 @HiltViewModel
 internal class LogoutSyncViewModel @Inject constructor(
     private val configManager: ConfigManager,
+    eventSyncManager: EventSyncManager,
+    syncOrchestrator: SyncOrchestrator,
+    authStore: AuthStore,
     private val logoutUseCase: LogoutUseCase,
 ) : ViewModel() {
+    val logoutEventLiveData: LiveData<Unit> =
+        authStore
+            .observeSignedInProjectId()
+            .filter { projectId ->
+                projectId.isEmpty()
+            }.distinctUntilChanged()
+            .map { /* Unit on every "true" */ }
+            .asLiveData()
+
+    val isLogoutWithoutSyncVisibleLiveData: LiveData<Boolean> = combine(
+        eventSyncManager.getLastSyncState(useDefaultValue = true).asFlow(),
+        syncOrchestrator.observeImageSyncStatus(),
+    ) { eventSyncState, imageSyncStatus ->
+        !eventSyncState.isSyncCompleted() || imageSyncStatus.isSyncing
+    }.debounce(timeoutMillis = ANTI_JITTER_DELAY_MILLIS).asLiveData()
+
     val settingsLocked: LiveData<LiveDataEventWithContent<SettingsPasswordConfig>>
         get() = liveData(context = viewModelScope.coroutineContext) {
             emit(LiveDataEventWithContent(configManager.getProjectConfiguration().general.settingsPassword))
@@ -24,4 +53,8 @@ internal class LogoutSyncViewModel @Inject constructor(
     fun logout() {
         logoutUseCase()
     }
+
+    private companion object {
+        private const val ANTI_JITTER_DELAY_MILLIS = 1000L
+    }
 }

feature/dashboard/src/main/java/com/simprints/feature/dashboard/logout/sync/LogoutSyncFragment.kt

@@ -1,31 +1,24 @@
 package com.simprints.feature.dashboard.logout.sync
 
-import android.content.Intent
 import android.os.Bundle
-import android.provider.Settings
 import android.view.View
-import androidx.core.view.isInvisible
-import androidx.core.view.isVisible
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.viewModels
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
 import androidx.navigation.fragment.findNavController
-import com.simprints.core.livedata.LiveDataEventWithContentObserver
 import com.simprints.feature.dashboard.R
 import com.simprints.feature.dashboard.databinding.FragmentLogoutSyncBinding
 import com.simprints.feature.dashboard.logout.LogoutSyncViewModel
-import com.simprints.feature.dashboard.main.sync.SyncViewModel
-import com.simprints.feature.dashboard.views.SyncCardState
-import com.simprints.feature.login.LoginContract
-import com.simprints.feature.login.LoginResult
-import com.simprints.infra.uibase.navigation.handleResult
 import com.simprints.infra.uibase.navigation.navigateSafely
 import com.simprints.infra.uibase.viewbinding.viewBinding
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.launch
 
 @AndroidEntryPoint
 class LogoutSyncFragment : Fragment(R.layout.fragment_logout_sync) {
-    private val logoutSyncViewModel by viewModels<LogoutSyncViewModel>()
-    private val syncViewModel by viewModels<SyncViewModel>()
+    private val viewModel by viewModels<LogoutSyncViewModel>()
     private val binding by viewBinding(FragmentLogoutSyncBinding::bind)
 
     override fun onViewCreated(
@@ -35,25 +28,9 @@ class LogoutSyncFragment : Fragment(R.layout.fragment_logout_sync) {
         super.onViewCreated(view, savedInstanceState)
         initViews()
         observeLiveData()
-
-        findNavController().handleResult<LoginResult>(
-            viewLifecycleOwner,
-            R.id.logOutSyncFragment,
-            LoginContract.DESTINATION,
-        ) { result -> syncViewModel.handleLoginResult(result) }
     }
 
     private fun initViews() = with(binding) {
-        logoutSyncCard.onSyncButtonClick = { syncViewModel.sync() }
-        logoutSyncCard.onOfflineButtonClick =
-            { startActivity(Intent(Settings.ACTION_WIRELESS_SETTINGS)) }
-        logoutSyncCard.onSelectNoModulesButtonClick = {
-            findNavController().navigateSafely(
-                this@LogoutSyncFragment,
-                LogoutSyncFragmentDirections.actionLogoutSyncFragmentToModuleSelectionFragment(),
-            )
-        }
-        logoutSyncCard.onLoginButtonClick = { syncViewModel.login() }
         logoutSyncToolbar.setNavigationOnClickListener {
             findNavController().popBackStack()
         }
@@ -63,38 +40,22 @@ class LogoutSyncFragment : Fragment(R.layout.fragment_logout_sync) {
                 LogoutSyncFragmentDirections.actionLogoutSyncFragmentToLogoutSyncDeclineFragment(),
             )
         }
-        logoutButton.setOnClickListener {
-            logoutSyncViewModel.logout()
-            findNavController().navigateSafely(
-                this@LogoutSyncFragment,
-                LogoutSyncFragmentDirections.actionLogoutSyncFragmentToRequestLoginFragment(),
-            )
-        }
     }
 
     private fun observeLiveData() = with(binding) {
-        syncViewModel.syncCardLiveData.observe(viewLifecycleOwner) { state ->
-            val isLogoutButtonVisible = isLogoutButtonVisible(state)
-            logoutSyncCard.render(state)
-            logoutButton.isVisible = isLogoutButtonVisible
-            logoutWithoutSyncButton.isVisible = isLogoutButtonVisible.not()
-            logoutSyncInfo.isInvisible = isLogoutButtonVisible
+        lifecycleScope.launch {
+            repeatOnLifecycle(Lifecycle.State.RESUMED) {
+                viewModel.isLogoutWithoutSyncVisibleLiveData.observe(viewLifecycleOwner) { isLogoutWithoutSyncVisible ->
+                    logoutSyncInfo.visibility = if (isLogoutWithoutSyncVisible) View.VISIBLE else View.INVISIBLE
+                    logoutWithoutSyncButton.visibility = if (isLogoutWithoutSyncVisible) View.VISIBLE else View.INVISIBLE
+                }
+            }
+        }
+        viewModel.logoutEventLiveData.observe(viewLifecycleOwner) {
+            findNavController().navigateSafely(
+                this@LogoutSyncFragment,
+                R.id.action_logoutSyncFragment_to_requestLoginFragment,
+            )
         }
-        syncViewModel.loginRequestedEventLiveData.observe(
-            viewLifecycleOwner,
-            LiveDataEventWithContentObserver { loginArgs ->
-                findNavController().navigateSafely(
-                    this@LogoutSyncFragment,
-                    R.id.action_logOutSyncFragment_to_login,
-                    loginArgs,
-                )
-            },
-        )
     }
-
-    /**
-     * Helper function that calculates whether the 'proceed to log out' button should be visible.
-     * The button should be visible only when synchronization is complete
-     */
-    private fun isLogoutButtonVisible(state: SyncCardState) = state is SyncCardState.SyncComplete
 }