[DI] Use constructor injection for SyncManager sub-classes (#874)

bitfireAT · Jul 2, 2024 · 48855c7 · 48855c7
1 parent 7a8761f
commit 48855c7
Show file tree

Hide file tree

Showing 9 changed files with 182 additions and 61 deletions.
diff --git a/app/src/main/kotlin/at/bitfire/davdroid/sync/AddressBookSyncer.kt b/app/src/main/kotlin/at/bitfire/davdroid/sync/AddressBookSyncer.kt
@@ -38,15 +38,16 @@ class AddressBookSyncer(
 
     @EntryPoint
     @InstallIn(SingletonComponent::class)
-    interface AddressBooksSyncAdapterEntryPoint {
+    interface AddressBooksSyncerEntryPoint {
+        fun contactsSyncManagerFactory(): ContactsSyncManager.Factory
         fun settingsManager(): SettingsManager
     }
 
     companion object {
         const val PREVIOUS_GROUP_METHOD = "previous_group_method"
     }
 
-    val entryPoint = EntryPointAccessors.fromApplication(context, AddressBooksSyncAdapterEntryPoint::class.java)
+    private val entryPoint = EntryPointAccessors.fromApplication<AddressBooksSyncerEntryPoint>(context)
     val settingsManager = entryPoint.settingsManager()
 
 
@@ -162,7 +163,10 @@ class AddressBookSyncer(
             Logger.log.info("Synchronizing address book: ${addressBook.url}")
             Logger.log.info("Taking settings from: ${addressBook.mainAccount}")
 
-            ContactsSyncManager(context, account, accountSettings, httpClient.value, extras, authority, syncResult, provider, addressBook).performSync()
+            val syncManagerFactory = entryPoint.contactsSyncManagerFactory()
+            val syncManager = syncManagerFactory.contactsSyncManager(account, accountSettings, httpClient.value, extras, authority, syncResult, provider, addressBook)
+            syncManager.performSync()
+
         } catch(e: Exception) {
             Logger.log.log(Level.SEVERE, "Couldn't sync contacts", e)
         }

diff --git a/app/src/main/kotlin/at/bitfire/davdroid/sync/CalendarSyncManager.kt b/app/src/main/kotlin/at/bitfire/davdroid/sync/CalendarSyncManager.kt
@@ -19,6 +19,7 @@ import at.bitfire.dav4jvm.property.webdav.GetETag
 import at.bitfire.dav4jvm.property.webdav.SupportedReportSet
 import at.bitfire.dav4jvm.property.webdav.SyncToken
 import at.bitfire.davdroid.R
+import at.bitfire.davdroid.db.AppDatabase
 import at.bitfire.davdroid.db.SyncState
 import at.bitfire.davdroid.log.Logger
 import at.bitfire.davdroid.network.HttpClient
@@ -30,6 +31,10 @@ import at.bitfire.davdroid.util.lastSegment
 import at.bitfire.ical4android.Event
 import at.bitfire.ical4android.InvalidCalendarException
 import at.bitfire.ical4android.util.DateUtils
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import dagger.hilt.android.qualifiers.ApplicationContext
 import net.fortuna.ical4j.model.Component
 import net.fortuna.ical4j.model.component.VAlarm
 import net.fortuna.ical4j.model.property.Action
@@ -48,16 +53,30 @@ import java.util.logging.Level
 /**
  * Synchronization manager for CalDAV collections; handles events (VEVENT)
  */
-class CalendarSyncManager(
-    context: Context,
-    account: Account,
-    accountSettings: AccountSettings,
-    extras: Array<String>,
-    httpClient: HttpClient,
-    authority: String,
-    syncResult: SyncResult,
-    localCalendar: LocalCalendar
-): SyncManager<LocalEvent, LocalCalendar, DavCalendar>(context, account, accountSettings, httpClient, extras, authority, syncResult, localCalendar) {
+class CalendarSyncManager @AssistedInject constructor(
+    @Assisted account: Account,
+    @Assisted accountSettings: AccountSettings,
+    @Assisted extras: Array<String>,
+    @Assisted httpClient: HttpClient,
+    @Assisted authority: String,
+    @Assisted syncResult: SyncResult,
+    @Assisted localCalendar: LocalCalendar,
+    @ApplicationContext context: Context,
+    db: AppDatabase
+): SyncManager<LocalEvent, LocalCalendar, DavCalendar>(account, accountSettings, httpClient, extras, authority, syncResult, localCalendar, context, db) {
+
+    @AssistedFactory
+    interface Factory {
+        fun calendarSyncManager(
+            account: Account,
+            accountSettings: AccountSettings,
+            extras: Array<String>,
+            httpClient: HttpClient,
+            authority: String,
+            syncResult: SyncResult,
+            localCalendar: LocalCalendar
+        ): CalendarSyncManager
+    }
 
     override fun prepare(): Boolean {
         collectionURL = (localCollection.name ?: return false).toHttpUrlOrNull() ?: return false
@@ -246,4 +265,4 @@ class CalendarSyncManager(
     override fun notifyInvalidResourceTitle(): String =
         context.getString(R.string.sync_invalid_event)
 
-}
+}
diff --git a/app/src/main/kotlin/at/bitfire/davdroid/sync/CalendarSyncer.kt b/app/src/main/kotlin/at/bitfire/davdroid/sync/CalendarSyncer.kt
@@ -16,6 +16,10 @@ import at.bitfire.davdroid.network.HttpClient
 import at.bitfire.davdroid.resource.LocalCalendar
 import at.bitfire.davdroid.settings.AccountSettings
 import at.bitfire.ical4android.AndroidCalendar
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.android.EntryPointAccessors
+import dagger.hilt.components.SingletonComponent
 import okhttp3.HttpUrl
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import java.util.logging.Level
@@ -25,6 +29,15 @@ import java.util.logging.Level
  */
 class CalendarSyncer(context: Context): Syncer(context) {
 
+    @EntryPoint
+    @InstallIn(SingletonComponent::class)
+    interface CalendarSyncerEntryPoint {
+        fun calendarSyncManagerFactory(): CalendarSyncManager.Factory
+    }
+
+    private val entryPoint = EntryPointAccessors.fromApplication<CalendarSyncerEntryPoint>(context)
+
+
     override fun sync(
         account: Account,
         extras: Array<String>,
@@ -46,7 +59,10 @@ class CalendarSyncer(context: Context): Syncer(context) {
             .find(account, provider, LocalCalendar.Factory, "${CalendarContract.Calendars.SYNC_EVENTS}!=0", null)
         for (calendar in calendars) {
             Logger.log.info("Synchronizing calendar #${calendar.id}, URL: ${calendar.name}")
-            CalendarSyncManager(context, account, accountSettings, extras, httpClient.value, authority, syncResult, calendar).performSync()
+
+            val syncManagerFactory = entryPoint.calendarSyncManagerFactory()
+            val syncManager = syncManagerFactory.calendarSyncManager(account, accountSettings, extras, httpClient.value, authority, syncResult, calendar)
+            syncManager.performSync()
         }
     }
 

diff --git a/app/src/main/kotlin/at/bitfire/davdroid/sync/ContactsSyncManager.kt b/app/src/main/kotlin/at/bitfire/davdroid/sync/ContactsSyncManager.kt
@@ -24,6 +24,7 @@ import at.bitfire.dav4jvm.property.webdav.ResourceType
 import at.bitfire.dav4jvm.property.webdav.SupportedReportSet
 import at.bitfire.dav4jvm.property.webdav.SyncToken
 import at.bitfire.davdroid.R
+import at.bitfire.davdroid.db.AppDatabase
 import at.bitfire.davdroid.db.SyncState
 import at.bitfire.davdroid.log.Logger
 import at.bitfire.davdroid.network.HttpClient
@@ -40,6 +41,10 @@ import at.bitfire.davdroid.util.DavUtils.sameTypeAs
 import at.bitfire.davdroid.util.lastSegment
 import at.bitfire.vcard4android.Contact
 import at.bitfire.vcard4android.GroupMethod
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import dagger.hilt.android.qualifiers.ApplicationContext
 import ezvcard.VCardVersion
 import ezvcard.io.CannotParseException
 import okhttp3.HttpUrl
@@ -90,17 +95,35 @@ import java.util.logging.Level
  *   [LocalGroup.COLUMN_PENDING_MEMBERS]. In [postProcess],
  *   these "pending memberships" are assigned to the actual contacts and then cleaned up.
  */
-class ContactsSyncManager(
-    context: Context,
-    account: Account,
-    accountSettings: AccountSettings,
-    httpClient: HttpClient,
-    extras: Array<String>,
-    authority: String,
-    syncResult: SyncResult,
-    val provider: ContentProviderClient,
-    localAddressBook: LocalAddressBook
-): SyncManager<LocalAddress, LocalAddressBook, DavAddressBook>(context, account, accountSettings, httpClient, extras, authority, syncResult, localAddressBook) {
+class ContactsSyncManager @AssistedInject constructor(
+    @Assisted account: Account,
+    @Assisted accountSettings: AccountSettings,
+    @Assisted httpClient: HttpClient,
+    @Assisted extras: Array<String>,
+    @Assisted authority: String,
+    @Assisted syncResult: SyncResult,
+    @Assisted val provider: ContentProviderClient,
+    @Assisted localAddressBook: LocalAddressBook,
+    @ApplicationContext context: Context,
+    db: AppDatabase
+): SyncManager<LocalAddress, LocalAddressBook, DavAddressBook>(
+    account, accountSettings, httpClient, extras, authority, syncResult, localAddressBook,
+    context, db
+) {
+
+    @AssistedFactory
+    interface Factory {
+        fun contactsSyncManager(
+            account: Account,
+            accountSettings: AccountSettings,
+            httpClient: HttpClient,
+            extras: Array<String>,
+            authority: String,
+            syncResult: SyncResult,
+            provider: ContentProviderClient,
+            localAddressBook: LocalAddressBook
+        ): ContactsSyncManager
+    }
 
     companion object {
         infix fun <T> Set<T>.disjunct(other: Set<T>) = (this - other) union (other - this)

diff --git a/app/src/main/kotlin/at/bitfire/davdroid/sync/JtxSyncManager.kt b/app/src/main/kotlin/at/bitfire/davdroid/sync/JtxSyncManager.kt
@@ -17,6 +17,7 @@ import at.bitfire.dav4jvm.property.caldav.MaxResourceSize
 import at.bitfire.dav4jvm.property.webdav.GetETag
 import at.bitfire.dav4jvm.property.webdav.SyncToken
 import at.bitfire.davdroid.R
+import at.bitfire.davdroid.db.AppDatabase
 import at.bitfire.davdroid.db.SyncState
 import at.bitfire.davdroid.log.Logger
 import at.bitfire.davdroid.network.HttpClient
@@ -27,6 +28,10 @@ import at.bitfire.davdroid.settings.AccountSettings
 import at.bitfire.davdroid.util.lastSegment
 import at.bitfire.ical4android.InvalidCalendarException
 import at.bitfire.ical4android.JtxICalObject
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import dagger.hilt.android.qualifiers.ApplicationContext
 import okhttp3.HttpUrl
 import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
 import okhttp3.RequestBody
@@ -37,16 +42,31 @@ import java.io.Reader
 import java.io.StringReader
 import java.util.logging.Level
 
-class JtxSyncManager(
-    context: Context,
-    account: Account,
-    accountSettings: AccountSettings,
-    extras: Array<String>,
-    httpClient: HttpClient,
-    authority: String,
-    syncResult: SyncResult,
-    localCollection: LocalJtxCollection
-):  SyncManager<LocalJtxICalObject, LocalJtxCollection, DavCalendar>(context, account, accountSettings, httpClient, extras, authority, syncResult, localCollection) {
+class JtxSyncManager @AssistedInject constructor(
+    @Assisted account: Account,
+    @Assisted accountSettings: AccountSettings,
+    @Assisted extras: Array<String>,
+    @Assisted httpClient: HttpClient,
+    @Assisted authority: String,
+    @Assisted syncResult: SyncResult,
+    @Assisted localCollection: LocalJtxCollection,
+    @ApplicationContext context: Context,
+    db: AppDatabase
+): SyncManager<LocalJtxICalObject, LocalJtxCollection, DavCalendar>(account, accountSettings, httpClient, extras, authority, syncResult, localCollection, context, db) {
+
+    @AssistedFactory
+    interface Factory {
+        fun jtxSyncManager(
+            account: Account,
+            accountSettings: AccountSettings,
+            extras: Array<String>,
+            httpClient: HttpClient,
+            authority: String,
+            syncResult: SyncResult,
+            localCollection: LocalJtxCollection
+        ): JtxSyncManager
+    }
+
 
     override fun prepare(): Boolean {
         collectionURL = (localCollection.url ?: return false).toHttpUrlOrNull() ?: return false

diff --git a/app/src/main/kotlin/at/bitfire/davdroid/sync/JtxSyncer.kt b/app/src/main/kotlin/at/bitfire/davdroid/sync/JtxSyncer.kt
@@ -19,6 +19,7 @@ import at.bitfire.davdroid.settings.AccountSettings
 import at.bitfire.davdroid.util.TaskUtils
 import at.bitfire.ical4android.JtxCollection
 import at.bitfire.ical4android.TaskProvider
+import dagger.hilt.android.EntryPointAccessors
 import okhttp3.HttpUrl
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import java.util.logging.Level
@@ -28,6 +29,13 @@ import java.util.logging.Level
  */
 class JtxSyncer(context: Context): Syncer(context) {
 
+    interface JtxSyncerEntryPoint {
+        fun jtxSyncManagerFactory(): JtxSyncManager.Factory
+    }
+
+    private val entryPoint = EntryPointAccessors.fromApplication<JtxSyncerEntryPoint>(context)
+
+
     override fun sync(
         account: Account,
         extras: Array<String>,
@@ -59,7 +67,10 @@ class JtxSyncer(context: Context): Syncer(context) {
             val collections = JtxCollection.find(account, provider, context, LocalJtxCollection.Factory, null, null)
             for (collection in collections) {
                 Logger.log.info("Synchronizing $collection")
-                JtxSyncManager(context, account, accountSettings, extras, httpClient.value, authority, syncResult, collection).performSync()
+
+                val syncManagerFactory = entryPoint.jtxSyncManagerFactory()
+                val syncManager = syncManagerFactory.jtxSyncManager(account, accountSettings, extras, httpClient.value, authority, syncResult, collection)
+                syncManager.performSync()
             }
 
         } catch (e: TaskProvider.ProviderTooOldException) {

diff --git a/app/src/main/kotlin/at/bitfire/davdroid/sync/SyncManager.kt b/app/src/main/kotlin/at/bitfire/davdroid/sync/SyncManager.kt
@@ -59,10 +59,6 @@ import at.bitfire.ical4android.Ical4Android
 import at.bitfire.ical4android.TaskProvider
 import at.bitfire.ical4android.UsesThreadContextClassLoader
 import at.bitfire.vcard4android.ContactsStorageException
-import dagger.hilt.EntryPoint
-import dagger.hilt.InstallIn
-import dagger.hilt.android.EntryPointAccessors
-import dagger.hilt.components.SingletonComponent
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
@@ -83,22 +79,18 @@ import javax.net.ssl.SSLHandshakeException
 
 @UsesThreadContextClassLoader
 abstract class SyncManager<ResourceType: LocalResource<*>, out CollectionType: LocalCollection<ResourceType>, RemoteType: DavCollection>(
-    val context: Context,
     val account: Account,
     val accountSettings: AccountSettings,
     val httpClient: HttpClient,
     val extras: Array<String>,
     val authority: String,
     val syncResult: SyncResult,
-    val localCollection: CollectionType
+    val localCollection: CollectionType,
+    // injected
+    val context: Context,
+    val db: AppDatabase
 ) {
 
-    @EntryPoint
-    @InstallIn(SingletonComponent::class)
-    interface SyncManagerEntryPoint {
-        fun appDatabase(): AppDatabase
-    }
-
     enum class SyncAlgorithm {
         PROPFIND_REPORT,
         COLLECTION_SYNC
@@ -344,7 +336,6 @@ abstract class SyncManager<ResourceType: LocalResource<*>, out CollectionType: L
             else
                 account.name
 
-        val db = EntryPointAccessors.fromApplication(context, SyncManagerEntryPoint::class.java).appDatabase()
         db.runInTransaction {
             val service = db.serviceDao().getByAccountAndType(accountName, serviceType)
                 ?: return@runInTransaction

diff --git a/app/src/main/kotlin/at/bitfire/davdroid/sync/TaskSyncer.kt b/app/src/main/kotlin/at/bitfire/davdroid/sync/TaskSyncer.kt
@@ -19,6 +19,10 @@ import at.bitfire.davdroid.settings.AccountSettings
 import at.bitfire.davdroid.util.TaskUtils
 import at.bitfire.ical4android.DmfsTaskList
 import at.bitfire.ical4android.TaskProvider
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.android.EntryPointAccessors
+import dagger.hilt.components.SingletonComponent
 import okhttp3.HttpUrl
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import org.dmfs.tasks.contract.TaskContract
@@ -29,6 +33,16 @@ import java.util.logging.Level
  */
 class TaskSyncer(context: Context): Syncer(context) {
 
+    @EntryPoint
+    @InstallIn(SingletonComponent::class)
+    interface TaskSyncerEntryPoint {
+        fun tasksSyncManagerFactory(): TasksSyncManager.Factory
+    }
+
+    private val entryPoint = EntryPointAccessors.fromApplication<TaskSyncerEntryPoint>(context)
+
+
+
     override fun sync(
         account: Account,
         extras: Array<String>,
@@ -59,7 +73,10 @@ class TaskSyncer(context: Context): Syncer(context) {
                 .find(account, taskProvider, LocalTaskList.Factory, "${TaskContract.TaskLists.SYNC_ENABLED}!=0", null)
             for (taskList in taskLists) {
                 Logger.log.info("Synchronizing task list #${taskList.id} [${taskList.syncId}]")
-                TasksSyncManager(context, account, accountSettings, httpClient.value, extras, authority, syncResult, taskList).performSync()
+
+                val syncManagerFactory = entryPoint.tasksSyncManagerFactory()
+                val syncManager = syncManagerFactory.tasksSyncManager(account, accountSettings, httpClient.value, extras, authority, syncResult, taskList)
+                syncManager.performSync()
             }
         } catch (e: TaskProvider.ProviderTooOldException) {
             TaskUtils.notifyProviderTooOld(context, e)