Merge sync work

pull/2003/head
Alex Baker 2 years ago
parent d589a89506
commit eaa47029e7

@ -53,7 +53,6 @@ class Tasks : Application(), Configuration.Provider {
buildSetup.setup()
upgrade()
preferences.isSyncOngoing = false
preferences.setBoolean(R.string.p_sync_ongoing_opentasks, false)
ThemeBase.getThemeBase(preferences, inventory, null).setDefaultNightMode()
localBroadcastManager.registerRefreshReceiver(RefreshBroadcastReceiver())
backgroundWork()

@ -2,12 +2,7 @@ package org.tasks.data
import android.content.Context
import androidx.lifecycle.LiveData
import androidx.room.Dao
import androidx.room.Delete
import androidx.room.Insert
import androidx.room.Query
import androidx.room.Transaction
import androidx.room.Update
import androidx.room.*
import com.todoroo.andlib.utility.DateUtilities.now
import com.todoroo.astrid.api.FilterListItem.NO_ORDER
import com.todoroo.astrid.core.SortHelper.APPLE_EPOCH
@ -176,9 +171,9 @@ SELECT EXISTS(SELECT 1
INNER JOIN caldav_lists ON cdl_uuid = cd_calendar
INNER JOIN caldav_accounts ON cda_uuid = cdl_account
WHERE cd_task = :id
AND cda_account_type = :type)
AND cda_account_type IN (:types))
""")
abstract suspend fun isAccountType(id: Long, type: Int): Boolean
abstract suspend fun isAccountType(id: Long, types: List<Int>): Boolean
suspend fun getTasks(taskIds: List<Long>): List<CaldavTask> =
taskIds.chunkedMap { getTasksInternal(it) }

@ -1,50 +0,0 @@
package org.tasks.jobs
import android.content.Context
import androidx.hilt.work.HiltWorker
import androidx.work.WorkerParameters
import dagger.assisted.Assisted
import dagger.assisted.AssistedInject
import kotlinx.coroutines.*
import org.tasks.LocalBroadcastManager
import org.tasks.R
import org.tasks.analytics.Firebase
import org.tasks.billing.Inventory
import org.tasks.caldav.CaldavSynchronizer
import org.tasks.data.CaldavAccount.Companion.TYPE_CALDAV
import org.tasks.data.CaldavAccount.Companion.TYPE_TASKS
import org.tasks.data.CaldavDao
import org.tasks.preferences.Preferences
@HiltWorker
class SyncCaldavWork @AssistedInject constructor(
@Assisted context: Context,
@Assisted workerParams: WorkerParameters,
firebase: Firebase,
localBroadcastManager: LocalBroadcastManager,
preferences: Preferences,
private val caldavDao: CaldavDao,
private val caldavSynchronizer: CaldavSynchronizer,
private val inventory: Inventory
) : SyncWork(context, workerParams, firebase, localBroadcastManager, preferences) {
override suspend fun enabled() = getAccounts().isNotEmpty()
override val syncStatus = R.string.p_sync_ongoing_caldav
override suspend fun doSync() {
caldavJobs().awaitAll()
inventory.updateTasksAccount()
}
private suspend fun caldavJobs(): List<Deferred<Unit>> = coroutineScope {
getAccounts().map {
async(Dispatchers.IO) {
caldavSynchronizer.sync(it)
}
}
}
private suspend fun getAccounts() =
caldavDao.getAccounts(TYPE_CALDAV, TYPE_TASKS)
}

@ -1,44 +0,0 @@
package org.tasks.jobs
import android.content.Context
import androidx.hilt.work.HiltWorker
import androidx.work.WorkerParameters
import dagger.assisted.Assisted
import dagger.assisted.AssistedInject
import kotlinx.coroutines.*
import org.tasks.LocalBroadcastManager
import org.tasks.R
import org.tasks.analytics.Firebase
import org.tasks.data.CaldavAccount.Companion.TYPE_ETEBASE
import org.tasks.data.CaldavDao
import org.tasks.etebase.EtebaseSynchronizer
import org.tasks.preferences.Preferences
@HiltWorker
class SyncEtebaseWork @AssistedInject constructor(
@Assisted context: Context,
@Assisted workerParams: WorkerParameters,
firebase: Firebase,
localBroadcastManager: LocalBroadcastManager,
preferences: Preferences,
private val caldavDao: CaldavDao,
private val synchronizer: EtebaseSynchronizer
) : SyncWork(context, workerParams, firebase, localBroadcastManager, preferences) {
override suspend fun enabled() = caldavDao.getAccounts(TYPE_ETEBASE).isNotEmpty()
override val syncStatus = R.string.p_sync_ongoing_etebase
override suspend fun doSync() {
jobs().awaitAll()
}
private suspend fun jobs(): List<Deferred<Unit>> = coroutineScope {
caldavDao.getAccounts(TYPE_ETEBASE)
.map {
async(Dispatchers.IO) {
synchronizer.sync(it)
}
}
}
}

@ -1,47 +0,0 @@
package org.tasks.jobs
import android.content.Context
import androidx.hilt.work.HiltWorker
import androidx.work.WorkerParameters
import dagger.assisted.Assisted
import dagger.assisted.AssistedInject
import kotlinx.coroutines.*
import org.tasks.LocalBroadcastManager
import org.tasks.R
import org.tasks.analytics.Firebase
import org.tasks.data.GoogleTaskListDao
import org.tasks.gtasks.GoogleTaskSynchronizer
import org.tasks.preferences.Preferences
@HiltWorker
class SyncGoogleTasksWork @AssistedInject constructor(
@Assisted context: Context,
@Assisted workerParams: WorkerParameters,
firebase: Firebase,
localBroadcastManager: LocalBroadcastManager,
private val preferences: Preferences,
private val googleTaskListDao: GoogleTaskListDao,
private val googleTaskSynchronizer: GoogleTaskSynchronizer
) : SyncWork(context, workerParams, firebase, localBroadcastManager, preferences) {
override suspend fun enabled() = googleTaskListDao.getAccounts().isNotEmpty()
override val syncStatus = R.string.p_sync_ongoing_google_tasks
override suspend fun doSync() {
if (preferences.isManualSort) {
preferences.isPositionHackEnabled = true
}
googleTaskJobs().awaitAll()
}
private suspend fun googleTaskJobs(): List<Deferred<Unit>> = coroutineScope {
googleTaskListDao
.getAccounts()
.mapIndexed { i, account ->
async(Dispatchers.IO) {
googleTaskSynchronizer.sync(account, i)
}
}
}
}

@ -1,53 +0,0 @@
package org.tasks.jobs
import android.accounts.AccountManager
import android.content.ContentResolver
import android.content.Context
import android.os.Bundle
import androidx.hilt.work.HiltWorker
import androidx.work.WorkerParameters
import dagger.assisted.Assisted
import dagger.assisted.AssistedInject
import org.tasks.LocalBroadcastManager
import org.tasks.R
import org.tasks.analytics.Firebase
import org.tasks.data.OpenTaskDao
import org.tasks.data.OpenTaskDao.Companion.SUPPORTED_TYPES
import org.tasks.opentasks.OpenTasksSynchronizer
import org.tasks.preferences.Preferences
@HiltWorker
class SyncOpenTasksWork @AssistedInject constructor(
@Assisted context: Context,
@Assisted workerParams: WorkerParameters,
firebase: Firebase,
localBroadcastManager: LocalBroadcastManager,
preferences: Preferences,
private val openTasksSynchronizer: OpenTasksSynchronizer,
private val openTaskDao: OpenTaskDao
) : SyncWork(context, workerParams, firebase, localBroadcastManager, preferences) {
override val syncStatus = R.string.p_sync_ongoing_opentasks
override suspend fun enabled() = openTaskDao.shouldSync()
override suspend fun doSync() {
openTasksSynchronizer.sync()
if (isImmediate) {
AccountManager
.get(context)
.accounts
.filter { SUPPORTED_TYPES.contains(it.type) }
.forEach {
ContentResolver.requestSync(
it,
openTaskDao.authority,
Bundle().apply {
putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true)
putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true)
}
)
}
}
}
}

@ -1,30 +1,56 @@
package org.tasks.jobs
import android.accounts.AccountManager
import android.content.ContentResolver
import android.content.Context
import android.net.ConnectivityManager
import androidx.core.content.ContextCompat.getSystemService
import androidx.core.net.ConnectivityManagerCompat.RESTRICT_BACKGROUND_STATUS_ENABLED
import android.os.Bundle
import androidx.core.content.ContextCompat
import androidx.core.net.ConnectivityManagerCompat
import androidx.hilt.work.HiltWorker
import androidx.work.WorkerParameters
import dagger.Lazy
import dagger.assisted.Assisted
import dagger.assisted.AssistedInject
import kotlinx.coroutines.*
import org.tasks.LocalBroadcastManager
import org.tasks.R
import org.tasks.analytics.Firebase
import org.tasks.billing.Inventory
import org.tasks.caldav.CaldavSynchronizer
import org.tasks.data.CaldavAccount.Companion.TYPE_CALDAV
import org.tasks.data.CaldavAccount.Companion.TYPE_ETEBASE
import org.tasks.data.CaldavAccount.Companion.TYPE_TASKS
import org.tasks.data.CaldavDao
import org.tasks.data.GoogleTaskListDao
import org.tasks.data.OpenTaskDao
import org.tasks.etebase.EtebaseSynchronizer
import org.tasks.gtasks.GoogleTaskSynchronizer
import org.tasks.injection.BaseWorker
import org.tasks.opentasks.OpenTasksSynchronizer
import org.tasks.preferences.Preferences
abstract class SyncWork constructor(
context: Context,
workerParams: WorkerParameters,
firebase: Firebase,
private val localBroadcastManager: LocalBroadcastManager,
private val preferences: Preferences
@HiltWorker
class SyncWork @AssistedInject constructor(
@Assisted context: Context,
@Assisted workerParams: WorkerParameters,
firebase: Firebase,
private val localBroadcastManager: LocalBroadcastManager,
private val preferences: Preferences,
private val caldavDao: CaldavDao,
private val caldavSynchronizer: Lazy<CaldavSynchronizer>,
private val etebaseSynchronizer: Lazy<EtebaseSynchronizer>,
private val googleTaskSynchronizer: Lazy<GoogleTaskSynchronizer>,
private val openTasksSynchronizer: Lazy<OpenTasksSynchronizer>,
private val googleTaskListDao: GoogleTaskListDao,
private val openTaskDao: OpenTaskDao,
private val inventory: Inventory
) : BaseWorker(context, workerParams, firebase) {
final override suspend fun run(): Result {
if (!enabled()) {
return Result.failure()
}
override suspend fun run(): Result {
if (isBackground) {
getSystemService(context, ConnectivityManager::class.java)?.apply {
if (restrictBackgroundStatus == RESTRICT_BACKGROUND_STATUS_ENABLED) {
ContextCompat.getSystemService(context, ConnectivityManager::class.java)?.apply {
if (restrictBackgroundStatus == ConnectivityManagerCompat.RESTRICT_BACKGROUND_STATUS_ENABLED) {
return Result.failure()
}
}
@ -48,17 +74,68 @@ abstract class SyncWork constructor(
return Result.success()
}
val isImmediate: Boolean
private val isImmediate: Boolean
get() = inputData.getBoolean(EXTRA_IMMEDIATE, false)
private val isBackground: Boolean
get() = inputData.getBoolean(EXTRA_BACKGROUND, false)
protected abstract val syncStatus: Int
private val syncStatus = R.string.p_sync_ongoing
private suspend fun doSync() {
if (preferences.isManualSort) {
preferences.isPositionHackEnabled = true
}
googleTaskJobs().plus(caldavJobs()).awaitAll()
inventory.updateTasksAccount()
if (openTaskDao.shouldSync()) {
openTasksSynchronizer.get().sync()
if (isImmediate) {
AccountManager
.get(context)
.accounts
.filter { OpenTaskDao.SUPPORTED_TYPES.contains(it.type) }
.forEach {
ContentResolver.requestSync(
it,
openTaskDao.authority,
Bundle().apply {
putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true)
putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true)
}
)
}
}
}
}
private suspend fun googleTaskJobs(): List<Deferred<Unit>> = coroutineScope {
getGoogleAccounts()
.mapIndexed { i, account ->
async(Dispatchers.IO) {
googleTaskSynchronizer.get().sync(account, i)
}
}
}
private suspend fun caldavJobs(): List<Deferred<Unit>> = coroutineScope {
getCaldavAccounts().map {
async(Dispatchers.IO) {
when (it.accountType) {
TYPE_ETEBASE -> etebaseSynchronizer.get().sync(it)
TYPE_TASKS,
TYPE_CALDAV -> caldavSynchronizer.get().sync(it)
}
}
}
}
protected abstract suspend fun enabled(): Boolean
private suspend fun getGoogleAccounts() =
googleTaskListDao.getAccounts()
protected abstract suspend fun doSync()
private suspend fun getCaldavAccounts() =
caldavDao.getAccounts(TYPE_CALDAV, TYPE_TASKS, TYPE_ETEBASE)
companion object {
private val LOCK = Any()

@ -16,13 +16,7 @@ interface WorkManager {
fun migrateLocalTasks(caldavAccount: CaldavAccount)
suspend fun googleTaskSync(immediate: Boolean)
suspend fun caldavSync(immediate: Boolean)
suspend fun eteBaseSync(immediate: Boolean)
suspend fun openTaskSync(immediate: Boolean)
suspend fun sync(immediate: Boolean)
fun reverseGeocode(place: Place)
@ -50,14 +44,8 @@ interface WorkManager {
const val TAG_BACKUP = "tag_backup"
const val TAG_REFRESH = "tag_refresh"
const val TAG_MIDNIGHT_REFRESH = "tag_midnight_refresh"
const val TAG_SYNC_GOOGLE_TASKS = "tag_sync_google_tasks"
const val TAG_SYNC_CALDAV = "tag_sync_caldav"
const val TAG_SYNC_ETEBASE = "tag_sync_etebase"
const val TAG_SYNC_OPENTASK = "tag_sync_opentask"
const val TAG_BACKGROUND_SYNC_GOOGLE_TASKS = "tag_background_sync_google_tasks"
const val TAG_BACKGROUND_SYNC_CALDAV = "tag_background_sync_caldav"
const val TAG_BACKGROUND_SYNC_ETEBASE = "tag_background_sync_etebase"
const val TAG_BACKGROUND_SYNC_OPENTASKS = "tag_background_sync_opentasks"
const val TAG_SYNC = "tag_sync"
const val TAG_BACKGROUND_SYNC = "tag_background_sync"
const val TAG_REMOTE_CONFIG = "tag_remote_config"
const val TAG_MIGRATE_LOCAL = "tag_migrate_local"
const val TAG_UPDATE_PURCHASES = "tag_update_purchases"

@ -6,18 +6,9 @@ import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.net.Uri
import androidx.work.Constraints
import androidx.work.ExistingPeriodicWorkPolicy
import androidx.work.*
import androidx.work.ExistingWorkPolicy.APPEND_OR_REPLACE
import androidx.work.ExistingWorkPolicy.REPLACE
import androidx.work.NetworkType
import androidx.work.OneTimeWorkRequest
import androidx.work.PeriodicWorkRequest
import androidx.work.WorkContinuation
import androidx.work.WorkInfo
import androidx.work.WorkRequest
import androidx.work.Worker
import androidx.work.workDataOf
import com.todoroo.andlib.utility.AndroidUtilities
import com.todoroo.andlib.utility.DateUtilities
import com.todoroo.astrid.data.Task
@ -25,14 +16,10 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import org.tasks.BuildConfig
import org.tasks.R
import org.tasks.data.CaldavAccount
import org.tasks.data.*
import org.tasks.data.CaldavAccount.Companion.TYPE_CALDAV
import org.tasks.data.CaldavAccount.Companion.TYPE_ETEBASE
import org.tasks.data.CaldavAccount.Companion.TYPE_TASKS
import org.tasks.data.CaldavDao
import org.tasks.data.GoogleTaskListDao
import org.tasks.data.OpenTaskDao
import org.tasks.data.Place
import org.tasks.date.DateTimeUtils.midnight
import org.tasks.date.DateTimeUtils.newDateTime
import org.tasks.jobs.DriveUploader.Companion.EXTRA_PURGE
@ -42,19 +29,13 @@ import org.tasks.jobs.SyncWork.Companion.EXTRA_BACKGROUND
import org.tasks.jobs.SyncWork.Companion.EXTRA_IMMEDIATE
import org.tasks.jobs.WorkManager.Companion.MAX_CLEANUP_LENGTH
import org.tasks.jobs.WorkManager.Companion.REMOTE_CONFIG_INTERVAL_HOURS
import org.tasks.jobs.WorkManager.Companion.TAG_BACKGROUND_SYNC_CALDAV
import org.tasks.jobs.WorkManager.Companion.TAG_BACKGROUND_SYNC_ETEBASE
import org.tasks.jobs.WorkManager.Companion.TAG_BACKGROUND_SYNC_GOOGLE_TASKS
import org.tasks.jobs.WorkManager.Companion.TAG_BACKGROUND_SYNC_OPENTASKS
import org.tasks.jobs.WorkManager.Companion.TAG_BACKGROUND_SYNC
import org.tasks.jobs.WorkManager.Companion.TAG_BACKUP
import org.tasks.jobs.WorkManager.Companion.TAG_MIDNIGHT_REFRESH
import org.tasks.jobs.WorkManager.Companion.TAG_MIGRATE_LOCAL
import org.tasks.jobs.WorkManager.Companion.TAG_REFRESH
import org.tasks.jobs.WorkManager.Companion.TAG_REMOTE_CONFIG
import org.tasks.jobs.WorkManager.Companion.TAG_SYNC_CALDAV
import org.tasks.jobs.WorkManager.Companion.TAG_SYNC_ETEBASE
import org.tasks.jobs.WorkManager.Companion.TAG_SYNC_GOOGLE_TASKS
import org.tasks.jobs.WorkManager.Companion.TAG_SYNC_OPENTASK
import org.tasks.jobs.WorkManager.Companion.TAG_SYNC
import org.tasks.jobs.WorkManager.Companion.TAG_UPDATE_PURCHASES
import org.tasks.notifications.Throttle
import org.tasks.preferences.Preferences
@ -109,36 +90,21 @@ class WorkManagerImpl constructor(
}
}
override suspend fun googleTaskSync(immediate: Boolean) =
sync(immediate, TAG_SYNC_GOOGLE_TASKS, SyncGoogleTasksWork::class.java)
override suspend fun caldavSync(immediate: Boolean) =
sync(immediate, TAG_SYNC_CALDAV, SyncCaldavWork::class.java)
override suspend fun eteBaseSync(immediate: Boolean) =
sync(immediate, TAG_SYNC_ETEBASE, SyncEtebaseWork::class.java)
override suspend fun openTaskSync(immediate: Boolean) =
sync(immediate, TAG_SYNC_OPENTASK, SyncOpenTasksWork::class.java, false)
@SuppressLint("EnqueueWork")
private suspend fun sync(immediate: Boolean, tag: String, c: Class<out SyncWork>, requireNetwork: Boolean = true) {
Timber.d("sync(immediate = $immediate, $tag, $c, requireNetwork = $requireNetwork)")
val builder = OneTimeWorkRequest.Builder(c)
override suspend fun sync(immediate: Boolean) {
Timber.d("sync(immediate = $immediate)")
val builder = OneTimeWorkRequest.Builder(SyncWork::class.java)
.setInputData(EXTRA_IMMEDIATE to immediate)
if (requireNetwork) {
builder.setConstraints(networkConstraints)
}
.setConstraints(networkConstraints)
if (!immediate) {
builder.setInitialDelay(1, TimeUnit.MINUTES)
}
val append = withContext(Dispatchers.IO) {
workManager.getWorkInfosByTag(tag).get().any {
workManager.getWorkInfosByTag(TAG_SYNC).get().any {
it.state == WorkInfo.State.RUNNING
}
}
enqueue(workManager.beginUniqueWork(
tag,
TAG_SYNC,
if (append) APPEND_OR_REPLACE else REPLACE,
builder.build())
)
@ -156,42 +122,23 @@ class WorkManagerImpl constructor(
override fun updateBackgroundSync() {
throttle.run {
scheduleBackgroundSync(
TAG_BACKGROUND_SYNC_GOOGLE_TASKS,
SyncGoogleTasksWork::class.java,
googleTaskListDao.accountCount() > 0)
}
throttle.run {
scheduleBackgroundSync(
TAG_BACKGROUND_SYNC_CALDAV,
SyncCaldavWork::class.java,
caldavDao.getAccounts(TYPE_CALDAV, TYPE_TASKS).isNotEmpty())
}
throttle.run {
scheduleBackgroundSync(
TAG_BACKGROUND_SYNC_ETEBASE,
SyncEtebaseWork::class.java,
caldavDao.getAccounts(TYPE_ETEBASE).isNotEmpty())
}
throttle.run {
scheduleBackgroundSync(
TAG_BACKGROUND_SYNC_OPENTASKS,
SyncOpenTasksWork::class.java,
val enabled = googleTaskListDao.accountCount() > 0 ||
caldavDao.getAccounts(TYPE_CALDAV, TYPE_TASKS, TYPE_ETEBASE).isNotEmpty() ||
openTaskDao.shouldSync()
)
}
}
private fun scheduleBackgroundSync(tag: String, c: Class<out SyncWork>, enabled: Boolean) {
Timber.d("scheduleBackgroundSync($tag, $c, enabled = $enabled)")
if (enabled) {
val builder = PeriodicWorkRequest.Builder(c, 1, TimeUnit.HOURS)
if (enabled) {
Timber.d("Enabling background sync")
val builder = PeriodicWorkRequest.Builder(SyncWork::class.java, 1, TimeUnit.HOURS)
.setInputData(EXTRA_BACKGROUND to true)
.setConstraints(networkConstraints)
workManager.enqueueUniquePeriodicWork(
tag, ExistingPeriodicWorkPolicy.KEEP, builder.build())
} else {
workManager.cancelUniqueWork(tag)
workManager.enqueueUniquePeriodicWork(
TAG_BACKGROUND_SYNC,
ExistingPeriodicWorkPolicy.KEEP,
builder.build()
)
} else {
Timber.d("Disabling background sync")
workManager.cancelUniqueWork(TAG_BACKGROUND_SYNC)
}
}
}

@ -557,10 +557,8 @@ class Preferences @JvmOverloads constructor(
context.packageName + "_preferences"
private val syncFlags = listOf(
R.string.p_sync_ongoing_google_tasks,
R.string.p_sync_ongoing_caldav,
R.string.p_sync_ongoing,
R.string.p_sync_ongoing_android,
R.string.p_sync_ongoing_etebase,
)
}
}

@ -1,12 +1,9 @@
package org.tasks.sync
import com.todoroo.astrid.data.SyncFlags
import com.todoroo.astrid.data.SyncFlags.FORCE_CALDAV_SYNC
import com.todoroo.astrid.data.Task
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.asCoroutineDispatcher
import kotlinx.coroutines.async
import kotlinx.coroutines.launch
import kotlinx.coroutines.*
import org.tasks.LocalBroadcastManager
import org.tasks.R
import org.tasks.data.CaldavAccount.Companion.TYPE_CALDAV
@ -18,10 +15,7 @@ import org.tasks.data.GoogleTaskDao
import org.tasks.data.GoogleTaskListDao
import org.tasks.data.OpenTaskDao
import org.tasks.jobs.WorkManager
import org.tasks.jobs.WorkManager.Companion.TAG_SYNC_CALDAV
import org.tasks.jobs.WorkManager.Companion.TAG_SYNC_ETEBASE
import org.tasks.jobs.WorkManager.Companion.TAG_SYNC_GOOGLE_TASKS
import org.tasks.jobs.WorkManager.Companion.TAG_SYNC_OPENTASK
import org.tasks.jobs.WorkManager.Companion.TAG_SYNC
import org.tasks.preferences.Preferences
import java.util.concurrent.Executors.newSingleThreadExecutor
import javax.inject.Inject
@ -38,14 +32,11 @@ class SyncAdapters @Inject constructor(
private val localBroadcastManager: LocalBroadcastManager
) {
private val scope = CoroutineScope(newSingleThreadExecutor().asCoroutineDispatcher() + SupervisorJob())
private val googleTasks = Debouncer(TAG_SYNC_GOOGLE_TASKS) { workManager.googleTaskSync(it) }
private val caldav = Debouncer(TAG_SYNC_CALDAV) { workManager.caldavSync(it) }
private val eteBaseSync = Debouncer(TAG_SYNC_ETEBASE) { workManager.eteBaseSync(it) }
private val opentasks = Debouncer(TAG_SYNC_OPENTASK) { workManager.openTaskSync(it) }
private val syncStatus = Debouncer("sync_status") {
if (preferences.getBoolean(R.string.p_sync_ongoing_android, false) != it
&& isOpenTaskSyncEnabled()) {
preferences.setBoolean(R.string.p_sync_ongoing_android, it)
private val sync = Debouncer(TAG_SYNC) { workManager.sync(it) }
private val syncStatus = Debouncer("sync_status") { newState ->
val currentState = preferences.getBoolean(R.string.p_sync_ongoing_android, false)
if (currentState != newState && isOpenTaskSyncEnabled()) {
preferences.setBoolean(R.string.p_sync_ongoing_android, newState)
localBroadcastManager.broadcastRefresh()
}
}
@ -54,21 +45,12 @@ class SyncAdapters @Inject constructor(
if (task.checkTransitory(SyncFlags.SUPPRESS_SYNC)) {
return@launch
}
if (!task.googleTaskUpToDate(original)
&& googleTaskDao.getAllByTaskId(task.id).isNotEmpty()) {
googleTasks.sync(false)
}
if (task.checkTransitory(SyncFlags.FORCE_CALDAV_SYNC) || !task.caldavUpToDate(original)) {
if (caldavDao.isAccountType(task.id, TYPE_CALDAV)
|| caldavDao.isAccountType(task.id, TYPE_TASKS)) {
caldav.sync(false)
}
if (caldavDao.isAccountType(task.id, TYPE_ETEBASE)) {
eteBaseSync.sync(false)
}
if (caldavDao.isAccountType(task.id, TYPE_OPENTASKS)) {
opentasks.sync(false)
}
val needsGoogleTaskSync = !task.googleTaskUpToDate(original)
&& googleTaskDao.getAllByTaskId(task.id).isNotEmpty()
val needsIcalendarSync = (task.checkTransitory(FORCE_CALDAV_SYNC) || !task.caldavUpToDate(original))
&& caldavDao.isAccountType(task.id, TYPE_ICALENDAR)
if (needsGoogleTaskSync || needsIcalendarSync) {
sync.sync(false)
}
}
@ -77,7 +59,7 @@ class SyncAdapters @Inject constructor(
}
fun syncOpenTasks() = scope.launch {
opentasks.sync(true)
sync.sync(true)
}
fun sync() {
@ -86,33 +68,27 @@ class SyncAdapters @Inject constructor(
fun sync(immediate: Boolean) = scope.launch {
val googleTasksEnabled = async { isGoogleTaskSyncEnabled() }
val caldavEnabled = async { isCaldavSyncEnabled() }
val eteBaseEnabled = async { isEtebaseEnabled() }
val caldavEnabled = async { isSyncEnabled() }
val opentasksEnabled = async { isOpenTaskSyncEnabled() }
if (googleTasksEnabled.await()) {
googleTasks.sync(immediate)
}
if (caldavEnabled.await()) {
caldav.sync(immediate)
}
if (eteBaseEnabled.await()) {
eteBaseSync.sync(immediate)
}
if (opentasksEnabled.await()) {
opentasks.sync(immediate)
if (googleTasksEnabled.await() || caldavEnabled.await() || opentasksEnabled.await()) {
sync.sync(immediate)
}
}
private suspend fun isGoogleTaskSyncEnabled() = googleTaskListDao.getAccounts().isNotEmpty()
private suspend fun isCaldavSyncEnabled() =
caldavDao.getAccounts(TYPE_CALDAV, TYPE_TASKS).isNotEmpty()
private suspend fun isEtebaseEnabled() = caldavDao.getAccounts(TYPE_ETEBASE).isNotEmpty()
private suspend fun isSyncEnabled() =
caldavDao.getAccounts(TYPE_CALDAV, TYPE_TASKS, TYPE_ETEBASE).isNotEmpty()
private suspend fun isOpenTaskSyncEnabled() = openTaskDao.shouldSync()
companion object {
private val TYPE_ICALENDAR = listOf(
TYPE_CALDAV,
TYPE_TASKS,
TYPE_ETEBASE,
TYPE_OPENTASKS
)
}
}

@ -378,10 +378,7 @@
<string name="p_flipper">p_flipper</string>
<string name="p_debug_pro">debug_pro</string>
<string name="p_crash_main_queries">debug_crash_main_queries</string>
<string name="p_sync_ongoing_google_tasks">sync_ongoing_google_tasks</string>
<string name="p_sync_ongoing_caldav">sync_ongoing_caldav</string>
<string name="p_sync_ongoing_etebase">sync_ongoing_etebase</string>
<string name="p_sync_ongoing_opentasks">sync_ongoing_opentasks</string>
<string name="p_sync_ongoing">sync_ongoing</string>
<string name="p_sync_ongoing_android">sync_ongoing_android</string>
<string name="p_last_backup">last_backup</string>
<string name="p_show_description">show_description</string>

Loading…
Cancel
Save