Repositories: apply new naming scheme (#1423)

* DavHomeSetRepository, DavServiceRepository: apply new naming scheme for (non-)suspending calls

* AccountRepository: apply new naming scheme for (non-)suspending calls

* Update repository methods to new naming scheme

Author: rfc2822

app/src/androidTest/kotlin/at/bitfire/davdroid/repository/DavHomeSetRepositoryTest.kt

@@ -33,7 +33,7 @@ class DavHomeSetRepositoryTest {
     fun setUp() {
         hiltRule.inject()
 
-        serviceId = serviceRepository.insertOrReplace(
+        serviceId = serviceRepository.insertOrReplaceBlocking(
             Service(id=0, accountName="test", type= Service.TYPE_CALDAV, principal = null)
         )
     }
@@ -43,32 +43,32 @@ class DavHomeSetRepositoryTest {
     fun testInsertOrUpdate() {
         // should insert new row or update (upsert) existing row - without changing its key!
         val entry1 = HomeSet(id=0, serviceId=serviceId, personal=true, url="https://example.com/1".toHttpUrl())
-        val insertId1 = repository.insertOrUpdateByUrl(entry1)
+        val insertId1 = repository.insertOrUpdateByUrlBlocking(entry1)
         assertEquals(1L, insertId1)
-        assertEquals(entry1.copy(id = 1L), repository.getById(1L))
+        assertEquals(entry1.copy(id = 1L), repository.getByIdBlocking(1L))
 
         val updatedEntry1 = HomeSet(id=0, serviceId=serviceId, personal=true, url="https://example.com/1".toHttpUrl(), displayName="Updated Entry")
-        val updateId1 = repository.insertOrUpdateByUrl(updatedEntry1)
+        val updateId1 = repository.insertOrUpdateByUrlBlocking(updatedEntry1)
         assertEquals(1L, updateId1)
-        assertEquals(updatedEntry1.copy(id = 1L), repository.getById(1L))
+        assertEquals(updatedEntry1.copy(id = 1L), repository.getByIdBlocking(1L))
 
         val entry2 = HomeSet(id=0, serviceId=serviceId, personal=true, url= "https://example.com/2".toHttpUrl())
-        val insertId2 = repository.insertOrUpdateByUrl(entry2)
+        val insertId2 = repository.insertOrUpdateByUrlBlocking(entry2)
         assertEquals(2L, insertId2)
-        assertEquals(entry2.copy(id = 2L), repository.getById(2L))
+        assertEquals(entry2.copy(id = 2L), repository.getByIdBlocking(2L))
     }
 
     @Test
-    fun testDelete() {
+    fun testDeleteBlocking() {
         // should delete row with given primary key (id)
         val entry1 = HomeSet(id=1, serviceId=serviceId, personal=true, url= "https://example.com/1".toHttpUrl())
 
-        val insertId1 = repository.insertOrUpdateByUrl(entry1)
+        val insertId1 = repository.insertOrUpdateByUrlBlocking(entry1)
         assertEquals(1L, insertId1)
-        assertEquals(entry1, repository.getById(1L))
+        assertEquals(entry1, repository.getByIdBlocking(1L))
 
-        repository.delete(entry1)
-        assertEquals(null, repository.getById(1L))
+        repository.deleteBlocking(entry1)
+        assertEquals(null, repository.getByIdBlocking(1L))
     }
 
 }

app/src/androidTest/kotlin/at/bitfire/davdroid/sync/JtxSyncManagerTest.kt

@@ -83,7 +83,7 @@ class JtxSyncManagerTest {
 
         // Create dummy dependencies
         val service = Service(0, account.name, Service.TYPE_CALDAV, null)
-        val serviceId = serviceRepository.insertOrReplace(service)
+        val serviceId = serviceRepository.insertOrReplaceBlocking(service)
         val dbCollection = Collection(
             0,
             serviceId,
@@ -106,7 +106,7 @@ class JtxSyncManagerTest {
     fun tearDown() {
         if (this::localJtxCollection.isInitialized)
             localJtxCollectionStore.delete(localJtxCollection)
-        serviceRepository.deleteAll()
+        serviceRepository.deleteAllBlocking()
         if (this::provider.isInitialized)
             provider.closeCompat()
         TestAccount.remove(account)

app/src/androidTest/kotlin/at/bitfire/davdroid/ui/CollectionSelectedUseCaseTest.kt

@@ -76,13 +76,13 @@ class CollectionSelectedUseCaseTest {
     fun setUp() {
         hiltRule.inject()
 
-        serviceRepository.insertOrReplace(service)
+        serviceRepository.insertOrReplaceBlocking(service)
         collectionRepository.insertOrUpdateByUrl(collection)
     }
 
     @After
     fun tearDown() {
-        serviceRepository.deleteAll()
+        serviceRepository.deleteAllBlocking()
     }
 
 

app/src/main/kotlin/at/bitfire/davdroid/push/PushMessageHandler.kt

@@ -53,7 +53,7 @@ class PushMessageHandler @Inject constructor(
             // Sync all authorities of account that the collection belongs to
             // Later: only sync affected collection and authorities
             collectionRepository.getSyncableByTopic(topic)?.let { collection ->
-                serviceRepository.getAsync(collection.serviceId)?.let { service ->
+                serviceRepository.get(collection.serviceId)?.let { service ->
                     val syncDataTypes = mutableSetOf<SyncDataType>()
                     // If the type is an address book, add the contacts type
                     if (collection.type == TYPE_ADDRESSBOOK)
@@ -78,7 +78,7 @@ class PushMessageHandler @Inject constructor(
 
         } else {
             // fallback when no known topic is present (shouldn't happen)
-            val service = instance.toLongOrNull()?.let { serviceRepository.get(it) }
+            val service = instance.toLongOrNull()?.let { serviceRepository.getBlocking(it) }
             if (service != null) {
                 logger.warning("Got push message without topic and service, syncing all accounts")
                 val account = accountRepository.fromName(service.accountName)

app/src/main/kotlin/at/bitfire/davdroid/push/PushRegistrationManager.kt

@@ -92,7 +92,7 @@ class PushRegistrationManager @Inject constructor(
     }
 
     private suspend fun updateService(serviceId: Long) {
-        val service = serviceRepository.getAsync(serviceId) ?: return
+        val service = serviceRepository.get(serviceId) ?: return
 
         val distributorAvailable = UnifiedPush.getSavedDistributor(context) != null
         if (distributorAvailable)
@@ -118,7 +118,7 @@ class PushRegistrationManager @Inject constructor(
      * Uses the subscription to subscribe to syncable collections, and then unsubscribes from non-syncable collections.
      */
     suspend fun processSubscription(serviceId: Long, endpoint: PushEndpoint) = mutex.withLock {
-        val service = serviceRepository.getAsync(serviceId) ?: return
+        val service = serviceRepository.get(serviceId) ?: return
 
         try {
             // subscribe to collections which are selected for synchronization
@@ -165,7 +165,7 @@ class PushRegistrationManager @Inject constructor(
      * Unsubscribes from all subscribed collections.
      */
     suspend fun removeSubscription(serviceId: Long) = mutex.withLock {
-        val service = serviceRepository.getAsync(serviceId) ?: return
+        val service = serviceRepository.get(serviceId) ?: return
         unsubscribeAll(service)
     }
 

app/src/main/kotlin/at/bitfire/davdroid/repository/AccountRepository.kt

@@ -44,15 +44,15 @@ import javax.inject.Inject
  */
 class AccountRepository @Inject constructor(
     private val accountSettingsFactory: AccountSettings.Factory,
-    private val automaticSyncManager: AutomaticSyncManager,
+    private val automaticSyncManager: Lazy<AutomaticSyncManager>,
     @ApplicationContext private val context: Context,
     private val collectionRepository: DavCollectionRepository,
     private val homeSetRepository: DavHomeSetRepository,
     private val localCalendarStore: Lazy<LocalCalendarStore>,
     private val localAddressBookStore: Lazy<LocalAddressBookStore>,
     private val logger: Logger,
     private val serviceRepository: DavServiceRepository,
-    private val syncWorkerManager: SyncWorkerManager,
+    private val syncWorkerManager: Lazy<SyncWorkerManager>,
     private val tasksAppManager: Lazy<TasksAppManager>
 ) {
 
@@ -70,7 +70,7 @@ class AccountRepository @Inject constructor(
      *
      * @return account if account creation was successful; null otherwise (for instance because an account with this name already exists)
      */
-    fun create(accountName: String, credentials: Credentials?, config: DavResourceFinder.Configuration, groupMethod: GroupMethod): Account? {
+    fun createBlocking(accountName: String, credentials: Credentials?, config: DavResourceFinder.Configuration, groupMethod: GroupMethod): Account? {
         val account = fromName(accountName)
 
         // create Android account
@@ -104,7 +104,7 @@ class AccountRepository @Inject constructor(
             }
 
             // set up automatic sync (processes inserted services)
-            automaticSyncManager.updateAutomaticSync(account)
+            automaticSyncManager.get().updateAutomaticSync(account)
 
         } catch(e: InvalidAccountException) {
             logger.log(Level.SEVERE, "Couldn't access account settings", e)
@@ -206,11 +206,11 @@ class AccountRepository @Inject constructor(
             }
 
             // account renamed, cancel maybe running synchronization of old account
-            syncWorkerManager.cancelAllWork(oldAccount)
+            syncWorkerManager.get().cancelAllWork(oldAccount)
 
             // disable periodic syncs for old account
             for (dataType in SyncDataType.entries)
-                syncWorkerManager.disablePeriodic(oldAccount, dataType)
+                syncWorkerManager.get().disablePeriodic(oldAccount, dataType)
 
             // update account name references in database
             serviceRepository.renameAccount(oldName, newName)
@@ -238,7 +238,7 @@ class AccountRepository @Inject constructor(
             }
 
             // update automatic sync
-            automaticSyncManager.updateAutomaticSync(newAccount)
+            automaticSyncManager.get().updateAutomaticSync(newAccount)
         } finally {
             // release AccountsCleanupWorker mutex at the end of this async coroutine
             AccountsCleanupWorker.unlockAccountsCleanup()
@@ -251,11 +251,11 @@ class AccountRepository @Inject constructor(
     private fun insertService(accountName: String, @ServiceType type: String, info: DavResourceFinder.Configuration.ServiceInfo): Long {
         // insert service
         val service = Service(0, accountName, type, info.principal)
-        val serviceId = serviceRepository.insertOrReplace(service)
+        val serviceId = serviceRepository.insertOrReplaceBlocking(service)
 
         // insert home sets
         for (homeSet in info.homeSets)
-            homeSetRepository.insertOrUpdateByUrl(HomeSet(0, serviceId, true, homeSet))
+            homeSetRepository.insertOrUpdateByUrlBlocking(HomeSet(0, serviceId, true, homeSet))
 
         // insert collections
         for (collection in info.collections.values) {

app/src/main/kotlin/at/bitfire/davdroid/repository/DavCollectionRepository.kt

@@ -162,7 +162,7 @@ class DavCollectionRepository @Inject constructor(
 
     /** Deletes the given collection from the server and the database. */
     suspend fun deleteRemote(collection: Collection) {
-        val service = serviceRepository.get(collection.serviceId) ?: throw IllegalArgumentException("Service not found")
+        val service = serviceRepository.getBlocking(collection.serviceId) ?: throw IllegalArgumentException("Service not found")
         val account = Account(service.accountName, context.getString(R.string.account_type))
 
         httpClientBuilder.get()

app/src/main/kotlin/at/bitfire/davdroid/repository/DavHomeSetRepository.kt

@@ -15,16 +15,16 @@ class DavHomeSetRepository @Inject constructor(
     db: AppDatabase
 ) {
 
-    val dao = db.homeSetDao()
+    private val dao = db.homeSetDao()
 
     fun getAddressBookHomeSetsFlow(account: Account) =
         dao.getBindableByAccountAndServiceTypeFlow(account.name, Service.TYPE_CARDDAV)
 
     fun getBindableByServiceFlow(serviceId: Long) = dao.getBindableByServiceFlow(serviceId)
 
-    fun getById(id: Long) = dao.getById(id)
+    fun getByIdBlocking(id: Long) = dao.getById(id)
 
-    fun getByService(serviceId: Long) = dao.getByService(serviceId)
+    fun getByServiceBlocking(serviceId: Long) = dao.getByService(serviceId)
 
     fun getCalendarHomeSetsFlow(account: Account) =
         dao.getBindableByAccountAndServiceTypeFlow(account.name, Service.TYPE_CALDAV)
@@ -38,13 +38,13 @@ class DavHomeSetRepository @Inject constructor(
      * @return ID of the row, that has been inserted or updated. -1 If the insert fails due to other reasons.
      */
     @Transaction
-    fun insertOrUpdateByUrl(homeset: HomeSet): Long =
+    fun insertOrUpdateByUrlBlocking(homeset: HomeSet): Long =
         dao.getByUrl(homeset.serviceId, homeset.url.toString())?.let { existingHomeset ->
             dao.update(homeset.copy(id = existingHomeset.id))
             existingHomeset.id
         } ?: dao.insert(homeset)
 
 
-    fun delete(homeSet: HomeSet) = dao.delete(homeSet)
+    fun deleteBlocking(homeSet: HomeSet) = dao.delete(homeSet)
 
 }

app/src/main/kotlin/at/bitfire/davdroid/repository/DavServiceRepository.kt

@@ -18,8 +18,8 @@ class DavServiceRepository @Inject constructor(
 
     // Read
 
-    fun get(id: Long): Service? = dao.get(id)
-    suspend fun getAsync(id: Long): Service? = dao.getAsync(id)
+    fun getBlocking(id: Long): Service? = dao.get(id)
+    suspend fun get(id: Long): Service? = dao.getAsync(id)
 
     suspend fun getAll(): List<Service> = dao.getAll()
 
@@ -35,7 +35,7 @@ class DavServiceRepository @Inject constructor(
 
     // Create & update
 
-    fun insertOrReplace(service: Service) =
+    fun insertOrReplaceBlocking(service: Service) =
         dao.insertOrReplace(service)
 
     suspend fun renameAccount(oldName: String, newName: String) =
@@ -44,7 +44,7 @@ class DavServiceRepository @Inject constructor(
 
     // Delete
 
-    fun deleteAll() = dao.deleteAll()
+    fun deleteAllBlocking() = dao.deleteAll()
 
     suspend fun deleteByAccount(accountName: String) =
         dao.deleteByAccount(accountName)

app/src/main/kotlin/at/bitfire/davdroid/repository/DavSyncStatsRepository.kt

@@ -9,11 +9,11 @@ import android.content.pm.PackageManager
 import at.bitfire.davdroid.db.AppDatabase
 import at.bitfire.davdroid.db.SyncStats
 import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
 import java.text.Collator
 import java.util.logging.Logger
 import javax.inject.Inject
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.map
 
 class DavSyncStatsRepository @Inject constructor(
     @ApplicationContext val context: Context,
@@ -40,7 +40,7 @@ class DavSyncStatsRepository @Inject constructor(
             }
         }
 
-    fun logSyncTime(collectionId: Long, authority: String, lastSync: Long = System.currentTimeMillis()) {
+    fun logSyncTimeBlocking(collectionId: Long, authority: String, lastSync: Long = System.currentTimeMillis()) {
         dao.insertOrReplace(SyncStats(
             id = 0,
             collectionId = collectionId,