refactor: replace accountDao with accountService everywhere

Author: JunkFood02

app/src/main/java/me/ash/reader/domain/service/AbstractRssRepository.kt

@@ -10,15 +10,13 @@ import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.mapLatest
 import me.ash.reader.domain.model.account.Account
 import me.ash.reader.domain.model.article.ArchivedArticle
 import me.ash.reader.domain.model.article.Article
 import me.ash.reader.domain.model.article.ArticleWithFeed
 import me.ash.reader.domain.model.feed.Feed
 import me.ash.reader.domain.model.group.Group
 import me.ash.reader.domain.model.group.GroupWithFeed
-import me.ash.reader.domain.repository.AccountDao
 import me.ash.reader.domain.repository.ArticleDao
 import me.ash.reader.domain.repository.FeedDao
 import me.ash.reader.domain.repository.GroupDao
@@ -32,7 +30,6 @@ import java.util.Date
 import java.util.UUID
 
 abstract class AbstractRssRepository(
-    private val accountDao: AccountDao,
     private val articleDao: ArticleDao,
     private val groupDao: GroupDao,
     private val feedDao: FeedDao,
@@ -153,12 +150,12 @@ abstract class AbstractRssRepository(
 
 
     suspend fun clearKeepArchivedArticles(): List<Article> {
-        val articleId = accountService.getCurrentAccountId()
-        val currentAccount = accountDao.queryById(articleId)!!
+        val accountId = accountService.getCurrentAccountId()
+        val currentAccount = accountService.getCurrentAccount()
         val keepArchived = currentAccount.keepArchived
         if (keepArchived != KeepArchivedPreference.Always) {
             val archivedArticles = articleDao.queryArchivedArticleBefore(
-                articleId,
+                accountId,
                 Date(System.currentTimeMillis() - keepArchived.value)
             )
             articleDao.delete(
@@ -188,8 +185,8 @@ abstract class AbstractRssRepository(
         )
     }
 
-    suspend fun initSync() {
-        accountDao.queryById(accountService.getCurrentAccountId())?.let {
+    fun initSync() {
+        accountService.getCurrentAccount().let {
             val syncOnStart = it.syncOnStart.value
             if (syncOnStart) {
                 doSyncOneTime()

app/src/main/java/me/ash/reader/domain/service/AccountService.kt

@@ -4,6 +4,7 @@ import android.content.Context
 import android.os.Looper
 import androidx.datastore.preferences.core.intPreferencesKey
 import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.SharingStarted
@@ -27,44 +28,44 @@ import me.ash.reader.ui.ext.dataStore
 import me.ash.reader.ui.ext.getDefaultGroupId
 import me.ash.reader.ui.ext.put
 import me.ash.reader.ui.ext.showToast
-import javax.inject.Inject
 
-class AccountService @Inject constructor(
-    @ApplicationContext
-    private val context: Context,
+class AccountService
+@Inject
+constructor(
+    @ApplicationContext private val context: Context,
     private val accountDao: AccountDao,
     private val groupDao: GroupDao,
     private val feedDao: FeedDao,
     private val articleDao: ArticleDao,
-    @ApplicationScope
-    private val coroutineScope: CoroutineScope,
+    @ApplicationScope private val coroutineScope: CoroutineScope,
     settingsProvider: SettingsProvider,
 ) {
 
     private val accountIdKey = intPreferencesKey(DataStoreKey.currentAccountId)
 
     val currentAccountIdFlow =
-        settingsProvider.preferencesFlow.map { it[accountIdKey] }
+        settingsProvider.preferencesFlow
+            .map { it[accountIdKey] }
             .stateIn(scope = coroutineScope, started = SharingStarted.Eagerly, initialValue = null)
 
     val currentAccountFlow =
-        currentAccountIdFlow.combine(getAccounts()) { id, accounts ->
-            id?.let { accounts.firstOrNull { it.id == id } }
-        }.stateIn(
-            scope = coroutineScope,
-            SharingStarted.Eagerly,
-            initialValue = null
-        )
+        currentAccountIdFlow
+            .combine(getAccounts()) { id, accounts ->
+                id?.let { accounts.firstOrNull { it.id == id } }
+            }
+            .stateIn(scope = coroutineScope, SharingStarted.Eagerly, initialValue = null)
 
     fun getAccounts(): Flow<List<Account>> = accountDao.queryAllAsFlow()
 
     fun getAccountById(accountId: Int): Flow<Account?> = accountDao.queryAccount(accountId)
 
-    fun getCurrentAccount(): Account =
-        runBlocking { currentAccountFlow.first { it != null } as Account }
+    fun getCurrentAccount(): Account = runBlocking {
+        currentAccountFlow.first { it != null } as Account
+    }
 
-    fun getCurrentAccountId(): Int =
-        runBlocking { currentAccountIdFlow.first { it != null } as Int }
+    fun getCurrentAccountId(): Int = runBlocking {
+        currentAccountIdFlow.first { it != null } as Int
+    }
 
     suspend fun isNoAccount(): Boolean = accountDao.queryAll().isEmpty()
 
@@ -87,28 +88,26 @@ class AccountService @Inject constructor(
         }
     }
 
-    private fun getDefaultAccount(): Account = Account(
-        type = AccountType.Local,
-        name = context.getString(R.string.read_you),
-    )
+    private fun getDefaultAccount(): Account =
+        Account(type = AccountType.Local, name = context.getString(R.string.read_you))
 
-    suspend fun addDefaultAccount(): Account =
-        addAccount(getDefaultAccount())
+    suspend fun addDefaultAccount(): Account = addAccount(getDefaultAccount())
 
-    fun getDefaultGroup(): Group = getCurrentAccountId().let {
-        Group(
-            id = it.getDefaultGroupId(),
-            name = context.getString(R.string.defaults),
-            accountId = it,
-        )
-    }
+    fun getDefaultGroup(): Group =
+        getCurrentAccountId().let {
+            Group(
+                id = it.getDefaultGroupId(),
+                name = context.getString(R.string.defaults),
+                accountId = it,
+            )
+        }
 
     suspend fun update(accountId: Int, block: Account.() -> Account) {
-        accountDao.queryById(accountId)?.let {
-            accountDao.update(it.run(block))
-        }
+        accountDao.queryById(accountId)?.let { accountDao.update(it.run(block)) }
     }
 
+    suspend fun update(account: Account) = accountDao.update(account)
+
     suspend fun delete(accountId: Int) {
         if (accountDao.queryAll().size == 1) {
             Looper.myLooper() ?: Looper.prepare()

app/src/main/java/me/ash/reader/domain/service/FeverRssService.kt

@@ -9,15 +9,13 @@ import com.rometools.rome.feed.synd.SyndFeed
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.supervisorScope
 import me.ash.reader.R
 import me.ash.reader.domain.model.account.Account
 import me.ash.reader.domain.model.account.security.FeverSecurityKey
 import me.ash.reader.domain.model.article.Article
 import me.ash.reader.domain.model.article.ArticleMeta
 import me.ash.reader.domain.model.feed.Feed
 import me.ash.reader.domain.model.group.Group
-import me.ash.reader.domain.repository.AccountDao
 import me.ash.reader.domain.repository.ArticleDao
 import me.ash.reader.domain.repository.FeedDao
 import me.ash.reader.domain.repository.GroupDao
@@ -45,7 +43,6 @@ class FeverRssService @Inject constructor(
     private val feedDao: FeedDao,
     private val rssHelper: RssHelper,
     private val notificationHelper: NotificationHelper,
-    private val accountDao: AccountDao,
     private val groupDao: GroupDao,
     @IODispatcher
     private val ioDispatcher: CoroutineDispatcher,
@@ -56,7 +53,7 @@ class FeverRssService @Inject constructor(
     workManager: WorkManager,
     private val accountService: AccountService,
 ) : AbstractRssRepository(
-    accountDao, articleDao, groupDao,
+    articleDao, groupDao,
     feedDao, workManager, rssHelper, notificationHelper, ioDispatcher, defaultDispatcher,
     accountService
 ) {
@@ -275,7 +272,7 @@ class FeverRssService @Inject constructor(
 
 
                 Log.i("RLog", "onCompletion: ${System.currentTimeMillis() - preTime}")
-                accountDao.update(
+                accountService.update(
                     account.copy(
                         updateAt = Date(),
                         lastArticleId = if (sinceId.isNotEmpty()) {

app/src/main/java/me/ash/reader/domain/service/GoogleReaderRssService.kt

@@ -27,7 +27,6 @@ import me.ash.reader.domain.model.account.security.GoogleReaderSecurityKey
 import me.ash.reader.domain.model.article.Article
 import me.ash.reader.domain.model.feed.Feed
 import me.ash.reader.domain.model.group.Group
-import me.ash.reader.domain.repository.AccountDao
 import me.ash.reader.domain.repository.ArticleDao
 import me.ash.reader.domain.repository.FeedDao
 import me.ash.reader.domain.repository.GroupDao
@@ -59,7 +58,6 @@ constructor(
     private val feedDao: FeedDao,
     private val rssHelper: RssHelper,
     private val notificationHelper: NotificationHelper,
-    private val accountDao: AccountDao,
     private val groupDao: GroupDao,
     @IODispatcher private val ioDispatcher: CoroutineDispatcher,
     @MainDispatcher private val mainDispatcher: CoroutineDispatcher,
@@ -68,7 +66,6 @@ constructor(
     private val accountService: AccountService,
 ) :
     AbstractRssRepository(
-        accountDao,
         articleDao,
         groupDao,
         feedDao,
@@ -104,7 +101,7 @@ constructor(
             if (success)
                 try {
                     getGoogleReaderAPI().getUserInfo().userName?.let {
-                        accountDao.update(account.copy(name = it))
+                        accountService.update(account.copy(name = it))
                     }
                 } catch (ignore: Exception) {
                     Log.e("RLog", "get user info is failed: ", ignore)
@@ -430,7 +427,7 @@ constructor(
                 .filter { it.id !in remoteFeeds.await().map { feed -> feed.id } }
                 .forEach { super.deleteFeed(it, true) }
 
-            accountDao.update(account.copy(updateAt = Date()))
+            accountService.update(account.copy(updateAt = Date()))
             ListenableWorker.Result.success()
         } catch (e: Exception) {
             Timber.tag("RLog").e(e, "On sync exception: ${e.message}")

app/src/main/java/me/ash/reader/domain/service/LocalRssService.kt

@@ -4,7 +4,6 @@ import android.content.Context
 import android.util.Log
 import androidx.work.ListenableWorker
 import androidx.work.WorkManager
-import androidx.work.workDataOf
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
@@ -15,7 +14,6 @@ import kotlinx.coroutines.sync.Semaphore
 import kotlinx.coroutines.sync.withPermit
 import me.ash.reader.domain.model.feed.Feed
 import me.ash.reader.domain.model.feed.FeedWithArticle
-import me.ash.reader.domain.repository.AccountDao
 import me.ash.reader.domain.repository.ArticleDao
 import me.ash.reader.domain.repository.FeedDao
 import me.ash.reader.domain.repository.GroupDao
@@ -35,7 +33,6 @@ class LocalRssService @Inject constructor(
     private val feedDao: FeedDao,
     private val rssHelper: RssHelper,
     private val notificationHelper: NotificationHelper,
-    private val accountDao: AccountDao,
     private val groupDao: GroupDao,
     @IODispatcher
     private val ioDispatcher: CoroutineDispatcher,
@@ -44,7 +41,6 @@ class LocalRssService @Inject constructor(
     private val workManager: WorkManager,
     private val accountService: AccountService,
 ) : AbstractRssRepository(
-    accountDao,
     articleDao,
     groupDao,
     feedDao,
@@ -59,7 +55,8 @@ class LocalRssService @Inject constructor(
     override suspend fun sync(feedId: String?, groupId: String?) = supervisorScope {
         val preTime = System.currentTimeMillis()
         val preDate = Date(preTime)
-        val accountId = accountService.getCurrentAccountId()
+        val currentAccount = accountService.getCurrentAccount()
+        val accountId = currentAccount.id!!
         val semaphore = Semaphore(16)
 
         val feedsToSync = when {
@@ -96,9 +93,7 @@ class LocalRssService @Inject constructor(
         }.awaitAll()
 
         Log.i("RlOG", "onCompletion: ${System.currentTimeMillis() - preTime}")
-        accountDao.queryById(accountId)?.let { account ->
-            accountDao.update(account.copy(updateAt = Date()))
-        }
+        accountService.update(currentAccount.copy(updateAt = Date()))
         ListenableWorker.Result.success()
     }
 

app/src/main/java/me/ash/reader/domain/service/OpmlService.kt

@@ -10,7 +10,6 @@ import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.withContext
 import me.ash.reader.domain.model.feed.Feed
-import me.ash.reader.domain.repository.AccountDao
 import me.ash.reader.domain.repository.FeedDao
 import me.ash.reader.domain.repository.GroupDao
 import me.ash.reader.infrastructure.di.IODispatcher
@@ -29,7 +28,7 @@ class OpmlService @Inject constructor(
     private val context: Context,
     private val groupDao: GroupDao,
     private val feedDao: FeedDao,
-    private val accountDao: AccountDao,
+    private val accountService: AccountService,
     private val rssService: RssService,
     private val OPMLDataSource: OPMLDataSource,
     @IODispatcher
@@ -73,7 +72,7 @@ class OpmlService @Inject constructor(
             Opml(
                 "2.0",
                 Head(
-                    accountDao.queryById(accountId)?.name,
+                    accountService.getCurrentAccount().name,
                     Date().toString(), null, null, null,
                     null, null, null, null,
                     null, null, null, null,

app/src/main/java/me/ash/reader/infrastructure/android/MainActivity.kt

@@ -13,13 +13,12 @@ import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.runtime.DisposableEffect
 import androidx.core.app.NotificationManagerCompat
 import androidx.core.util.Consumer
-import androidx.core.view.WindowCompat
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.navigation.compose.rememberNavController
 import androidx.profileinstaller.ProfileInstallerInitializer
 import coil.ImageLoader
 import dagger.hilt.android.AndroidEntryPoint
-import me.ash.reader.domain.repository.AccountDao
+import me.ash.reader.domain.service.AccountService
 import me.ash.reader.infrastructure.preference.AccountSettingsProvider
 import me.ash.reader.infrastructure.preference.LanguagesPreference
 import me.ash.reader.infrastructure.preference.SettingsProvider
@@ -39,12 +38,11 @@ class MainActivity : AppCompatActivity() {
     @Inject
     lateinit var imageLoader: ImageLoader
 
-    @Inject
-    lateinit var accountDao: AccountDao
-
     @Inject
     lateinit var settingsProvider: SettingsProvider
 
+    @Inject lateinit var accountService: AccountService
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         Log.i("RLog", "onCreate: ${ProfileInstallerInitializer().create(this)}")
@@ -83,7 +81,7 @@ class MainActivity : AppCompatActivity() {
         }
 
         setContent {
-            AccountSettingsProvider(accountDao) {
+            AccountSettingsProvider(accountService = accountService) {
                 settingsProvider.ProvidesSettings {
                     val subscribeViewModel: SubscribeViewModel = hiltViewModel()
                     val navController = rememberNavController()

app/src/main/java/me/ash/reader/infrastructure/di/CacheHolderModule.kt

@@ -38,11 +38,11 @@ object CacheHolderModule {
     fun provideCacheHelper(
         @ApplicationContext context: Context,
         @IODispatcher ioDispatcher: CoroutineDispatcher,
-        settingsProvider: SettingsProvider,
         rssHelper: RssHelper,
+        accountService: AccountService,
     ): ReaderCacheHelper = ReaderCacheHelper(
         context = context, ioDispatcher = ioDispatcher,
         rssHelper = rssHelper,
-        settingsProvider = settingsProvider,
+        accountService = accountService,
     )
 }