Extract getting DisplayAccounts into use case

feature/navigation/drawer/src/main/kotlin/app/k9mail/feature/navigation/drawer/NavigationDrawerModule.kt

@@ -1,5 +1,7 @@
 package app.k9mail.feature.navigation.drawer
 
+import app.k9mail.feature.navigation.drawer.domain.DomainContract.UseCase
+import app.k9mail.feature.navigation.drawer.domain.usecase.GetDisplayAccounts
 import app.k9mail.feature.navigation.drawer.legacy.AccountsViewModel
 import app.k9mail.feature.navigation.drawer.legacy.FoldersViewModel
 import app.k9mail.feature.navigation.drawer.ui.DrawerViewModel
@@ -11,16 +13,20 @@ import org.koin.dsl.module
 
 val navigationDrawerModule: Module = module {
 
-    viewModel { DrawerViewModel() }
+    single<UseCase.GetDisplayAccounts> {
-
+        GetDisplayAccounts(
-    viewModel {
-        AccountsViewModel(
             accountManager = get(),
             messageCountsProvider = get(),
             messageListRepository = get(),
         )
     }
 
+    viewModel {
+        AccountsViewModel(
+            getDisplayAccounts = get(),
+        )
+    }
+
     viewModel {
         val coreResourceProvider = get<CoreResourceProvider>()
 
@@ -32,4 +38,6 @@ val navigationDrawerModule: Module = module {
             getUnifiedInboxDetail = { coreResourceProvider.searchUnifiedInboxDetail() },
         )
     }
+
+    viewModel { DrawerViewModel() }
 }

feature/navigation/drawer/src/main/kotlin/app/k9mail/feature/navigation/drawer/domain/DomainContract.kt

@@ -0,0 +1,13 @@
+package app.k9mail.feature.navigation.drawer.domain
+
+import app.k9mail.feature.navigation.drawer.domain.entity.DisplayAccount
+import kotlinx.coroutines.flow.Flow
+
+interface DomainContract {
+
+    interface UseCase {
+        fun interface GetDisplayAccounts {
+            fun execute(): Flow<List<DisplayAccount>>
+        }
+    }
+}

feature/navigation/drawer/src/main/kotlin/app/k9mail/feature/navigation/drawer/domain/usecase/GetDisplayAccounts.kt

@@ -0,0 +1,65 @@
+package app.k9mail.feature.navigation.drawer.domain.usecase
+
+import app.k9mail.feature.navigation.drawer.domain.DomainContract.UseCase
+import app.k9mail.feature.navigation.drawer.domain.entity.DisplayAccount
+import app.k9mail.legacy.account.Account
+import app.k9mail.legacy.account.AccountManager
+import app.k9mail.legacy.mailstore.MessageListChangedListener
+import app.k9mail.legacy.mailstore.MessageListRepository
+import app.k9mail.legacy.message.controller.MessageCounts
+import app.k9mail.legacy.message.controller.MessageCountsProvider
+import kotlin.coroutines.CoroutineContext
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.launch
+
+class GetDisplayAccounts(
+    private val accountManager: AccountManager,
+    private val messageCountsProvider: MessageCountsProvider,
+    private val messageListRepository: MessageListRepository,
+    private val coroutineContext: CoroutineContext = Dispatchers.IO,
+) : UseCase.GetDisplayAccounts {
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    override fun execute(): Flow<List<DisplayAccount>> {
+        return accountManager.getAccountsFlow()
+            .flatMapLatest { accounts ->
+                val messageCountsFlows: List<Flow<MessageCounts>> = accounts.map { account ->
+                    getMessageCountsFlow(account)
+                }
+
+                combine(messageCountsFlows) { messageCountsList ->
+                    messageCountsList.mapIndexed { index, messageCounts ->
+                        DisplayAccount(
+                            account = accounts[index],
+                            unreadMessageCount = messageCounts.unread,
+                            starredMessageCount = messageCounts.starred,
+                        )
+                    }
+                }
+            }
+    }
+
+    private fun getMessageCountsFlow(account: Account): Flow<MessageCounts> {
+        return callbackFlow {
+            send(messageCountsProvider.getMessageCounts(account))
+
+            val listener = MessageListChangedListener {
+                launch {
+                    send(messageCountsProvider.getMessageCounts(account))
+                }
+            }
+            messageListRepository.addListener(account.uuid, listener)
+
+            awaitClose {
+                messageListRepository.removeListener(listener)
+            }
+        }.flowOn(coroutineContext)
+    }
+}

feature/navigation/drawer/src/main/kotlin/app/k9mail/feature/navigation/drawer/legacy/AccountsViewModel.kt

@@ -3,62 +3,11 @@ package app.k9mail.feature.navigation.drawer.legacy
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.asLiveData
+import app.k9mail.feature.navigation.drawer.domain.DomainContract.UseCase
 import app.k9mail.feature.navigation.drawer.domain.entity.DisplayAccount
-import app.k9mail.legacy.account.Account
-import app.k9mail.legacy.account.AccountManager
-import app.k9mail.legacy.mailstore.MessageListChangedListener
-import app.k9mail.legacy.mailstore.MessageListRepository
-import app.k9mail.legacy.message.controller.MessageCounts
-import app.k9mail.legacy.message.controller.MessageCountsProvider
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.channels.awaitClose
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.callbackFlow
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.launch
 
-@OptIn(ExperimentalCoroutinesApi::class)
 class AccountsViewModel(
-    accountManager: AccountManager,
+    getDisplayAccounts: UseCase.GetDisplayAccounts,
-    private val messageCountsProvider: MessageCountsProvider,
-    private val messageListRepository: MessageListRepository,
 ) : ViewModel() {
-    private val displayAccountFlow: Flow<List<DisplayAccount>> = accountManager.getAccountsFlow()
+    val displayAccountsLiveData: LiveData<List<DisplayAccount>> = getDisplayAccounts.execute().asLiveData()
-        .flatMapLatest { accounts ->
-            val messageCountsFlows: List<Flow<MessageCounts>> = accounts.map { account ->
-                getMessageCountsFlow(account)
-            }
-
-            combine(messageCountsFlows) { messageCountsList ->
-                messageCountsList.mapIndexed { index, messageCounts ->
-                    DisplayAccount(
-                        account = accounts[index],
-                        unreadMessageCount = messageCounts.unread,
-                        starredMessageCount = messageCounts.starred,
-                    )
-                }
-            }
-        }
-
-    private fun getMessageCountsFlow(account: Account): Flow<MessageCounts> {
-        return callbackFlow {
-            send(messageCountsProvider.getMessageCounts(account))
-
-            val listener = MessageListChangedListener {
-                launch {
-                    send(messageCountsProvider.getMessageCounts(account))
-                }
-            }
-            messageListRepository.addListener(account.uuid, listener)
-
-            awaitClose {
-                messageListRepository.removeListener(listener)
-            }
-        }.flowOn(Dispatchers.IO)
-    }
-
-    val displayAccountsLiveData: LiveData<List<DisplayAccount>> = displayAccountFlow.asLiveData()
 }