diff --git a/app/src/androidTest/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositorySmokeTest.kt b/app/src/androidTest/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositorySmokeTest.kt
index d6eea3f1..308ca955 100644
--- a/app/src/androidTest/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositorySmokeTest.kt
+++ b/app/src/androidTest/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositorySmokeTest.kt
@@ -37,6 +37,7 @@ class CalendarRepositorySmokeTest {
CalendarPrefs(store),
SettingsPrefs(store),
Dispatchers.IO,
+ AndroidSyncRequester(context),
)
}
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 86fe2f31..0e1635fb 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -41,6 +41,9 @@
-->
+
+
+
@@ -61,6 +64,10 @@
+
+
+
+
Unit)
fun unregisterChangeListener(listener: () -> Unit)
}
@@ -939,8 +945,7 @@ class AndroidCalendarDataSource @Inject constructor(
return eventId
}
- /** The account a calendar belongs to, for scoping a `Colors` lookup. */
- private fun calendarAccount(calendarId: Long): CalendarAccount? = resolver.query(
+ override fun calendarAccount(calendarId: Long): SyncAccount? = resolver.query(
ContentUris.withAppendedId(CalendarContract.Calendars.CONTENT_URI, calendarId),
arrayOf(
CalendarContract.Calendars.ACCOUNT_NAME,
@@ -949,13 +954,17 @@ class AndroidCalendarDataSource @Inject constructor(
null, null, null,
)?.use { c ->
if (c.moveToFirst()) {
- CalendarAccount(name = c.getString(0).orEmpty(), type = c.getString(1).orEmpty())
+ SyncAccount(name = c.getString(0).orEmpty(), type = c.getString(1).orEmpty())
} else {
null
}
}
- private data class CalendarAccount(val name: String, val type: String)
+ override fun eventCalendarId(eventId: Long): Long? = resolver.query(
+ ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
+ arrayOf(CalendarContract.Events.CALENDAR_ID),
+ null, null, null,
+ )?.use { c -> if (c.moveToFirst() && !c.isNull(0)) c.getLong(0) else null }
/**
* The raw provider `MINUTES` to store for one of [form]'s reminders: an
diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepository.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepository.kt
index 850832bc..b3d78961 100644
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepository.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepository.kt
@@ -11,6 +11,7 @@ import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.flow.flowOf
import kotlin.time.Instant
interface CalendarRepository {
@@ -157,6 +158,31 @@ interface CalendarRepository {
/** Delete a recurring event from the occurrence at [beginMillis] onwards. */
suspend fun deleteEventFromOccurrence(eventId: Long, beginMillis: Long)
+
+ /**
+ * Ask every account behind a visible synced calendar to sync now (#240).
+ * Only a request: the adapter may still run it late, or fail.
+ */
+ suspend fun requestSync(): SyncRequest = SyncRequest(SyncRequestResult.NothingToSync)
+
+ /** Wait for the syncs a [requestSync] reached to run, see [awaitSyncs]. */
+ suspend fun awaitSyncs(accounts: Set): SyncWait = SyncWait.Unconfirmed
+
+ /**
+ * The accounts behind visible calendars with a sync adapter, split by
+ * whether [requestSync] can reach them yet. Account access isn't observable:
+ * it is re-read on each collection and on every [refreshSyncAccess].
+ */
+ val syncTargets: Flow get() = flowOf(SyncTargets.None)
+
+ /** Re-read account access for every [syncTargets] collector; it can change outside the app. */
+ fun refreshSyncAccess() {}
+
+ /** Stop or resume asking for [account]'s sync-request access. */
+ suspend fun setSyncAccessDismissed(account: SyncAccount, dismissed: Boolean) {}
+
+ /** Every provider notification and [refresh], including the app's own writes. */
+ val providerChanges: Flow get() = emptyFlow()
}
class NoSuchEventException(eventId: Long) :
diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImpl.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImpl.kt
index fcaef6fc..07a61a36 100644
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImpl.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImpl.kt
@@ -20,6 +20,8 @@ import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.channels.BufferOverflow
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.distinctUntilChanged
import kotlinx.coroutines.flow.drop
@@ -51,6 +53,7 @@ class CalendarRepositoryImpl @Inject constructor(
private val prefs: CalendarPrefs,
private val settingsPrefs: SettingsPrefs,
@IoDispatcher private val io: CoroutineDispatcher,
+ private val syncRequester: SyncRequester,
) : CalendarRepository {
/** The configured wall-clock fire time for all-day reminders, read per write. */
@@ -88,16 +91,172 @@ class CalendarRepositoryImpl @Inject constructor(
onBufferOverflow = BufferOverflow.DROP_OLDEST,
)
- /** Run a provider write on [io], then re-query whether or not it threw. */
- private suspend fun write(block: suspend () -> T): T = withContext(io) {
+ override val providerChanges: Flow get() = ticks
+
+ /**
+ * Run a provider write on [io], then re-query whether or not it threw. The
+ * accounts behind [syncCalendars] (read before the write, which may delete
+ * the row) then get one sync nudge each (#303), also after a failure, which
+ * may have landed part of a multi-row write. Once per write, so a multi-row
+ * save or a whole import asks once per account.
+ */
+ private suspend fun write(
+ syncCalendars: suspend () -> Collection,
+ block: suspend () -> T,
+ ): T = withContext(io) {
+ val accounts = syncAccountsOf(syncCalendars)
try {
block()
} finally {
refresh()
writes.tryEmit(Unit)
+ requestSyncs(accounts, userInitiated = false)
}
}
+ private val noSync: suspend () -> Collection = { emptyList() }
+
+ private suspend fun syncAccountsOf(calendarIds: suspend () -> Collection): Set =
+ try {
+ calendarIds().filterNotNull().distinct()
+ .mapNotNull { accountOf(it) }
+ .withAdapter()
+ } catch (e: CancellationException) {
+ throw e
+ } catch (e: Exception) {
+ Log.w(TAG, "No sync nudge: the calendar account could not be read", e)
+ emptySet()
+ }
+
+ /** From the shared per-tick read; a calendar newer than it is read on its own. */
+ private suspend fun accountOf(calendarId: Long): SyncAccount? =
+ calendarsSnapshot().firstOrNull { it.id == calendarId }
+ ?.let { SyncAccount(it.accountName, it.accountType) }
+ ?: dataSource.calendarAccount(calendarId)
+
+ /** The syncable accounts among these whose type has a calendar sync adapter. */
+ private fun Collection.withAdapter(): Set {
+ val candidates = filter { it.isSyncable }
+ if (candidates.isEmpty()) return emptySet()
+ val adapterTypes = try {
+ syncRequester.adapterAccountTypes()
+ } catch (e: Exception) {
+ Log.w(TAG, "Sync adapters unreadable", e)
+ return emptySet()
+ }
+ return candidates.filterTo(linkedSetOf()) { it.type in adapterTypes }
+ }
+
+ /**
+ * Splits [accounts] by whether a request may name them (see
+ * [SyncRequester.addressableAccounts]). The rest wait for the user's grant:
+ * an account-less request would reach them, but also every other calendar
+ * account on the device, so none is sent.
+ */
+ private fun reach(accounts: Set): SyncTargets {
+ if (accounts.isEmpty()) return SyncTargets.None
+ // Unreadable access counts as reachable: a grant can't fix a failing read.
+ val addressable = try {
+ syncRequester.addressableAccounts(accounts.mapTo(mutableSetOf()) { it.type })
+ } catch (e: Exception) {
+ Log.w(TAG, "Account visibility unreadable", e)
+ null
+ }
+ if (addressable == null) return SyncTargets(reachable = accounts, needsAccess = emptySet())
+ val (reachable, hidden) = accounts.partition { it in addressable }
+ return SyncTargets(reachable.toSet(), hidden.toSet())
+ }
+
+ /** Ask each reachable one of [accounts] once. */
+ private fun requestSyncs(accounts: Set, userInitiated: Boolean) {
+ reach(accounts).reachable.forEach { requestSync(it, userInitiated) }
+ }
+
+ private fun requestSync(account: SyncAccount, userInitiated: Boolean): Boolean = try {
+ syncRequester.requestSync(account, userInitiated)
+ true
+ } catch (e: Exception) {
+ Log.w(TAG, "Sync request refused", e)
+ false
+ }
+
+ /** The event's own calendar (from [original] when given, else read), plus [others]. */
+ private fun eventCalendar(
+ eventId: Long,
+ original: EventForm? = null,
+ vararg others: Long?,
+ ): suspend () -> Collection =
+ { listOf(original?.calendarId ?: dataSource.eventCalendarId(eventId), *others) }
+
+ private fun targetsOf(calendars: List, dismissed: Set): SyncTargets =
+ reach(
+ calendars.syncAccounts().withAdapter()
+ .sortedWith(compareBy({ it.name.lowercase() }, { it.type }))
+ .toSet(),
+ ).let {
+ if (dismissed.isEmpty()) {
+ it
+ } else {
+ it.copy(needsAccess = it.needsAccess - dismissed, dismissed = it.needsAccess intersect dismissed)
+ }
+ }
+
+ private val accessChecks = MutableStateFlow(0)
+
+ override val syncTargets: Flow
+ get() = combine(calendars(), prefs.syncAccessDismissed, accessChecks) { calendars, dismissed, _ ->
+ // One failed read leaves the rows off until the next change, not for good.
+ try {
+ targetsOf(calendars, dismissed)
+ } catch (e: CancellationException) {
+ throw e
+ } catch (e: Exception) {
+ Log.w(TAG, "Sync targets unreadable", e)
+ SyncTargets.None
+ }
+ }.flowOn(io)
+
+ override fun refreshSyncAccess() {
+ accessChecks.update { it + 1 }
+ }
+
+ override suspend fun setSyncAccessDismissed(account: SyncAccount, dismissed: Boolean) {
+ try {
+ prefs.setSyncAccessDismissed(account, dismissed)
+ } catch (e: CancellationException) {
+ throw e
+ } catch (e: Exception) {
+ Log.w(TAG, "Sync access dismissal not saved", e)
+ }
+ }
+
+ override suspend fun requestSync(): SyncRequest = withContext(io) {
+ val targets = try {
+ targetsOf(calendars().first(), prefs.syncAccessDismissed.first())
+ } catch (e: CancellationException) {
+ throw e
+ } catch (e: Exception) {
+ Log.w(TAG, "Sync request skipped: calendars unreadable", e)
+ return@withContext SyncRequest(SyncRequestResult.Failed)
+ }
+ if (targets.reachable.isEmpty()) {
+ return@withContext SyncRequest(
+ if (targets.needsAccess.isEmpty()) SyncRequestResult.NothingToSync else SyncRequestResult.NeedsAccess,
+ )
+ }
+ val sent = targets.reachable.filterTo(linkedSetOf()) { requestSync(it, userInitiated = true) }
+ val result = when {
+ sent.isEmpty() -> SyncRequestResult.Failed
+ sent.size < targets.reachable.size -> SyncRequestResult.PartlyFailed
+ targets.needsAccess.isNotEmpty() -> SyncRequestResult.SomeNeedAccess
+ else -> SyncRequestResult.Requested
+ }
+ SyncRequest(result, sent)
+ }
+
+ override suspend fun awaitSyncs(accounts: Set): SyncWait =
+ withContext(io) { syncRequester.awaitSyncs(accounts) }
+
override val localChanges: Flow = merge(
writes,
prefs.pendingDisabledCalendarIds.distinctUntilChanged().drop(1).map {},
@@ -222,7 +381,7 @@ class CalendarRepositoryImpl @Inject constructor(
displayName: String,
color: Int,
description: String?,
- ): Long = write {
+ ): Long = write(noSync) {
dataSource.createLocalCalendar(displayName, color, description)
}
@@ -231,13 +390,14 @@ class CalendarRepositoryImpl @Inject constructor(
displayName: String,
color: Int,
description: String?,
- ) = write { dataSource.updateCalendar(id, displayName, color, description) }
+ ) = write(noSync) { dataSource.updateCalendar(id, displayName, color, description) }
override suspend fun deleteCalendar(id: Long) =
- write { dataSource.deleteCalendar(id) }
+ write(noSync) { dataSource.deleteCalendar(id) }
override suspend fun setCalendarsVisible(ids: Collection, visible: Boolean) =
- write {
+ // VISIBLE is device-local: nothing for an adapter to upload.
+ write(noSync) {
val canWrite = dataSource.canWriteCalendars()
if (canWrite) ids.forEach { dataSource.setCalendarVisible(it, visible) }
// Nothing of ours is left waiting for the provider once the write
@@ -278,7 +438,7 @@ class CalendarRepositoryImpl @Inject constructor(
targetCalendarId: Long,
events: List,
onProgress: (done: Int) -> Unit,
- ): IcsImportSummary = write {
+ ): IcsImportSummary = write({ listOf(targetCalendarId) }) {
val existing = dataSource.existingUids(targetCalendarId)
// Both are per-calendar, not per-event: looking them up once keeps a
// thousand-event restore to two extra queries. The palette is the
@@ -339,7 +499,7 @@ class CalendarRepositoryImpl @Inject constructor(
)
}
- override suspend fun createEvent(form: EventForm): Long = write {
+ override suspend fun createEvent(form: EventForm): Long = write({ listOf(form.calendarId) }) {
dataSource.insertEvent(form, allDayReminderTimeMinutes())
}
@@ -347,11 +507,11 @@ class CalendarRepositoryImpl @Inject constructor(
eventId: Long,
original: EventForm,
updated: EventForm,
- ) = write {
+ ) = write(eventCalendar(eventId, original, updated.calendarId)) {
dataSource.updateEvent(eventId, original, updated, allDayReminderTimeMinutes())
}
- override suspend fun deleteEvent(eventId: Long) = write {
+ override suspend fun deleteEvent(eventId: Long) = write(eventCalendar(eventId)) {
dataSource.deleteEvent(eventId)
}
@@ -360,7 +520,7 @@ class CalendarRepositoryImpl @Inject constructor(
targetCalendarId: Long,
original: EventForm,
updated: EventForm,
- ): Long = write {
+ ): Long = write(eventCalendar(eventId, original, targetCalendarId)) {
dataSource.moveEvent(
eventId, targetCalendarId, original, updated, allDayReminderTimeMinutes(),
)
@@ -371,7 +531,7 @@ class CalendarRepositoryImpl @Inject constructor(
beginMillis: Long,
original: EventForm,
form: EventForm,
- ): Long = write {
+ ): Long = write(eventCalendar(eventId, original)) {
dataSource.updateOccurrence(
eventId, beginMillis, original, form, allDayReminderTimeMinutes(),
)
@@ -382,7 +542,7 @@ class CalendarRepositoryImpl @Inject constructor(
beginMillis: Long,
original: EventForm,
updated: EventForm,
- ): Long = write {
+ ): Long = write(eventCalendar(eventId, original)) {
dataSource.updateEventFromOccurrence(
eventId, beginMillis, original, updated, allDayReminderTimeMinutes(),
)
@@ -392,14 +552,14 @@ class CalendarRepositoryImpl @Inject constructor(
override val seriesSplits: Flow = splits
- override suspend fun deleteOccurrence(eventId: Long, beginMillis: Long) = write {
+ override suspend fun deleteOccurrence(eventId: Long, beginMillis: Long) = write(eventCalendar(eventId)) {
dataSource.deleteOccurrence(eventId, beginMillis)
}
override suspend fun deleteEventFromOccurrence(
eventId: Long,
beginMillis: Long,
- ) = write {
+ ) = write(eventCalendar(eventId)) {
dataSource.deleteEventFromOccurrence(eventId, beginMillis)
}
diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/SyncRequester.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/SyncRequester.kt
new file mode 100644
index 00000000..e6479672
--- /dev/null
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/SyncRequester.kt
@@ -0,0 +1,215 @@
+package de.jeanlucmakiola.calendula.data.calendar
+
+import android.accounts.Account
+import android.accounts.AccountManager
+import android.content.ContentResolver
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.Bundle
+import android.provider.CalendarContract
+import dagger.hilt.android.qualifiers.ApplicationContext
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.channelFlow
+import kotlinx.coroutines.flow.conflate
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withTimeoutOrNull
+import java.util.concurrent.atomic.AtomicBoolean
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/** The account behind a calendar row (`ACCOUNT_NAME` / `ACCOUNT_TYPE`). */
+data class SyncAccount(val name: String, val type: String) {
+ /** Whether a sync adapter can stand behind it: device-only calendars have none. */
+ val isSyncable: Boolean
+ get() = name.isNotBlank() && type.isNotBlank() && type != CalendarContract.ACCOUNT_TYPE_LOCAL
+}
+
+/**
+ * Asks the system to run a calendar sync adapter sooner (#303, #240). The sync
+ * itself stays the adapter's job; this only schedules it.
+ */
+interface SyncRequester {
+ /** Account types with a calendar sync adapter installed; for any other a request does nothing. */
+ fun adapterAccountTypes(): Set
+
+ /**
+ * The accounts of [types] a request may name, or null when any may. From
+ * Android 13 a request for an account the app can't see is dropped without a word.
+ */
+ fun addressableAccounts(types: Set): Set?
+
+ /**
+ * Schedule a sync of [account]; may throw if the system refuses. [userInitiated]
+ * marks it manual, which also overrides master-sync-off — only for a user's tap.
+ */
+ fun requestSync(account: SyncAccount, userInitiated: Boolean)
+
+ /** Where [account]'s calendar sync stands, or null when the system won't say. */
+ fun syncActivity(account: SyncAccount): SyncActivity?
+
+ /** Fires whenever any sync on the device becomes pending, starts or ends. */
+ fun syncActivityChanges(): Flow
+}
+
+/** A calendar sync adapter's state for one account, from `READ_SYNC_STATS`. */
+enum class SyncActivity { Idle, Pending, Active }
+
+/** How waiting on requested syncs ended: seen through, or not confirmed in time. */
+enum class SyncWait { Completed, Unconfirmed }
+
+/**
+ * Waits until the syncs of [accounts] have run (#240): each account must have
+ * been seen pending or active and be idle again, or — for one that never showed
+ * up within [graceMillis] — be idle. A sync already running at the first look
+ * isn't the requested one, so it has to finish before the account counts. Unconfirmed after [timeoutMillis], or at
+ * once when the system won't report sync state.
+ */
+suspend fun SyncRequester.awaitSyncs(
+ accounts: Set,
+ timeoutMillis: Long = SYNC_WAIT_MILLIS,
+ graceMillis: Long = SYNC_GRACE_MILLIS,
+ pollMillis: Long = SYNC_POLL_MILLIS,
+): SyncWait {
+ if (accounts.isEmpty()) return SyncWait.Completed
+ val seen = HashSet()
+ // One already running when asked is someone else's sync: it only counts once idle again.
+ var priorRuns: MutableSet? = null
+ val graceOver = AtomicBoolean(false)
+ return withTimeoutOrNull(timeoutMillis) {
+ channelFlow {
+ launch { syncActivityChanges().collect { send(Unit) } }
+ launch {
+ delay(graceMillis)
+ graceOver.set(true)
+ send(Unit)
+ }
+ // The listener alone can miss a change made before it was registered.
+ while (true) {
+ send(Unit)
+ delay(pollMillis)
+ }
+ }.conflate().map {
+ val states = accounts.associateWith { syncActivity(it) ?: return@map SyncWait.Unconfirmed }
+ val prior = priorRuns ?: states.filterValues { it == SyncActivity.Active }.keys.toMutableSet()
+ .also { priorRuns = it }
+ states.forEach { (account, state) ->
+ if (state != SyncActivity.Active) prior -= account
+ if (state != SyncActivity.Idle && account !in prior) seen += account
+ }
+ val done = states.all { (account, state) ->
+ state == SyncActivity.Idle && account !in prior && (account in seen || graceOver.get())
+ }
+ if (done) SyncWait.Completed else null
+ }.filterNotNull().first()
+ } ?: SyncWait.Unconfirmed
+}
+
+const val SYNC_WAIT_MILLIS = 60_000L
+const val SYNC_GRACE_MILLIS = 5_000L
+const val SYNC_POLL_MILLIS = 2_000L
+
+@Singleton
+class AndroidSyncRequester @Inject constructor(
+ @ApplicationContext private val context: Context,
+) : SyncRequester {
+ // Lists only adapters in packages visible to the app — hence the SyncAdapter entry.
+ override fun adapterAccountTypes(): Set =
+ ContentResolver.getSyncAdapterTypes()
+ .filter { it.authority == CalendarContract.AUTHORITY }
+ .mapTo(mutableSetOf()) { it.accountType }
+
+ override fun addressableAccounts(types: Set): Set? {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) return null
+ val manager = AccountManager.get(context)
+ return types.flatMapTo(mutableSetOf()) { type ->
+ manager.getAccountsByType(type).map { SyncAccount(it.name, it.type) }
+ }
+ }
+
+ override fun requestSync(account: SyncAccount, userInitiated: Boolean) {
+ val extras = Bundle().apply {
+ putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true)
+ if (userInitiated) putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true)
+ }
+ ContentResolver.requestSync(
+ Account(account.name, account.type),
+ CalendarContract.AUTHORITY,
+ extras,
+ )
+ }
+
+ override fun syncActivity(account: SyncAccount): SyncActivity? = try {
+ val android = Account(account.name, account.type)
+ when {
+ ContentResolver.isSyncActive(android, CalendarContract.AUTHORITY) -> SyncActivity.Active
+ ContentResolver.isSyncPending(android, CalendarContract.AUTHORITY) -> SyncActivity.Pending
+ else -> SyncActivity.Idle
+ }
+ } catch (e: SecurityException) {
+ null
+ }
+
+ override fun syncActivityChanges(): Flow = callbackFlow {
+ val handle = try {
+ ContentResolver.addStatusChangeListener(
+ ContentResolver.SYNC_OBSERVER_TYPE_ACTIVE or ContentResolver.SYNC_OBSERVER_TYPE_PENDING,
+ ) { trySend(Unit) }
+ } catch (e: SecurityException) {
+ null
+ }
+ awaitClose { handle?.let(ContentResolver::removeStatusChangeListener) }
+ }
+}
+
+/** The distinct non-local accounts behind the visible calendars — what a manual refresh asks. */
+fun List.syncAccounts(): Set =
+ filter { it.isVisibleInSystem }
+ .map { SyncAccount(it.accountName, it.accountType) }
+ .filterTo(linkedSetOf()) { it.isSyncable }
+
+/**
+ * Who a sync request can go to: [reachable] by name, [needsAccess] only once the
+ * user lets the app see the account (Android 13+, see [accountAccessIntent]).
+ * [dismissed] are hidden accounts the user said not to ask about.
+ */
+data class SyncTargets(
+ val reachable: Set,
+ val needsAccess: Set,
+ val dismissed: Set = emptySet(),
+) {
+ companion object {
+ val None = SyncTargets(emptySet(), emptySet())
+ }
+}
+
+/**
+ * The system account picker, limited to [account]: once picked it becomes
+ * visible to the app, so sync requests can name it.
+ */
+fun accountAccessIntent(account: SyncAccount, description: String): Intent =
+ AccountManager.newChooseAccountIntent(
+ null,
+ listOf(Account(account.name, account.type)),
+ arrayOf(account.type),
+ description,
+ null,
+ null,
+ null,
+ )
+
+/**
+ * Outcome of a user-triggered sync request (#240). [Completed] is only ever set
+ * once the requested syncs were seen through, see [awaitSyncs].
+ */
+enum class SyncRequestResult { Requested, Completed, SomeNeedAccess, PartlyFailed, NeedsAccess, NothingToSync, Failed }
+
+/** A sync request's [result] and the [accounts] it actually reached. */
+data class SyncRequest(val result: SyncRequestResult, val accounts: Set = emptySet())
diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/di/DataModule.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/di/DataModule.kt
index 3d5e5800..197715e5 100644
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/di/DataModule.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/di/DataModule.kt
@@ -11,9 +11,11 @@ import dagger.hilt.InstallIn
import dagger.hilt.android.qualifiers.ApplicationContext
import dagger.hilt.components.SingletonComponent
import de.jeanlucmakiola.calendula.data.calendar.AndroidCalendarDataSource
+import de.jeanlucmakiola.calendula.data.calendar.AndroidSyncRequester
import de.jeanlucmakiola.calendula.data.calendar.CalendarDataSource
import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
import de.jeanlucmakiola.calendula.data.calendar.CalendarRepositoryImpl
+import de.jeanlucmakiola.calendula.data.calendar.SyncRequester
import de.jeanlucmakiola.calendula.data.contacts.AndroidContactSpecialDatesDataSource
import de.jeanlucmakiola.calendula.data.contacts.AndroidSpecialDatesCalendarSpec
import de.jeanlucmakiola.calendula.data.contacts.ContactSpecialDatesDataSource
@@ -49,6 +51,12 @@ abstract class DataBindModule {
impl: CalendarRepositoryImpl,
): CalendarRepository
+ @Binds
+ @Singleton
+ abstract fun bindSyncRequester(
+ impl: AndroidSyncRequester,
+ ): SyncRequester
+
@Binds
@Singleton
abstract fun bindReminderInstanceSource(
diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/CalendarPrefs.kt b/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/CalendarPrefs.kt
index c99dd887..ca0e15f5 100644
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/CalendarPrefs.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/CalendarPrefs.kt
@@ -7,6 +7,8 @@ import de.jeanlucmakiola.floret.prefs.PrefStore
import de.jeanlucmakiola.floret.prefs.nullableBooleanPref
import de.jeanlucmakiola.floret.prefs.nullableLongPref
import de.jeanlucmakiola.floret.prefs.nullableStringPref
+import de.jeanlucmakiola.floret.prefs.stringSetPref
+import de.jeanlucmakiola.calendula.data.calendar.SyncAccount
import kotlinx.coroutines.flow.Flow
import javax.inject.Inject
import javax.inject.Singleton
@@ -72,7 +74,28 @@ class CalendarPrefs @Inject constructor(
suspend fun setLastUsedCalendarId(id: Long) = prefs.set(LAST_USED_CALENDAR, id)
+ /**
+ * Synced accounts the user chose never to be asked to grant sync-request
+ * access for (#240): no grant row, no "other accounts" receipt.
+ */
+ val syncAccessDismissed: Flow> = prefs.flow(SYNC_ACCESS_DISMISSED)
+
+ suspend fun setSyncAccessDismissed(account: SyncAccount, dismissed: Boolean) {
+ prefs.update(SYNC_ACCESS_DISMISSED) { if (dismissed) it + account else it - account }
+ }
+
private companion object {
+ val SYNC_ACCESS_DISMISSED = stringSetPref("sync_access_dismissed").map>(
+ { stored -> stored.mapNotNullTo(mutableSetOf()) { it.toSyncAccount() } },
+ { accounts -> accounts.mapTo(mutableSetOf()) { "${it.type}$FIELD_SEPARATOR${it.name}" } },
+ )
+ const val FIELD_SEPARATOR = '\u001F'
+
+ fun String.toSyncAccount(): SyncAccount? {
+ val split = indexOf(FIELD_SEPARATOR)
+ return if (split <= 0) null else SyncAccount(name = substring(split + 1), type = substring(0, split))
+ }
+
val HIDDEN_IDS = idSetPref("hidden_calendar_ids")
val DISABLED_IDS = idSetPref("disabled_calendar_ids")
val VISIBILITY_NOTICE = nullableBooleanPref("visibility_notice_pending")
diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/CalendarHost.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/CalendarHost.kt
index d3b8bfb1..d13f7998 100644
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/CalendarHost.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/CalendarHost.kt
@@ -35,6 +35,7 @@ import androidx.compose.runtime.saveable.listSaver
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
import de.jeanlucmakiola.calendula.ui.common.rememberHeld
import de.jeanlucmakiola.calendula.ui.common.screen
import de.jeanlucmakiola.calendula.ui.common.ViewScreen
@@ -52,6 +53,14 @@ import de.jeanlucmakiola.calendula.ui.calendars.CalendarsScreen
import de.jeanlucmakiola.calendula.ui.common.BelowTopBarClip
import de.jeanlucmakiola.calendula.ui.common.StayingPut
import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
+import de.jeanlucmakiola.calendula.ui.common.DrawerSync
+import de.jeanlucmakiola.calendula.ui.common.SyncViewModel
+import de.jeanlucmakiola.calendula.ui.common.RefreshSyncAccessOnOpen
+import de.jeanlucmakiola.calendula.ui.common.rememberSyncChipOutcome
+import de.jeanlucmakiola.calendula.ui.common.SyncAccessSheet
+import de.jeanlucmakiola.calendula.data.calendar.SyncTargets
+import de.jeanlucmakiola.calendula.ui.common.rememberSyncAccessPicker
+import de.jeanlucmakiola.calendula.ui.common.messageRes
import de.jeanlucmakiola.calendula.ui.common.CalendarFab
import de.jeanlucmakiola.calendula.ui.common.CalendarTopBar
import de.jeanlucmakiola.calendula.ui.common.ChromeHost
@@ -441,6 +450,17 @@ fun CalendarHost(
val eventActions: EventActionsViewModel = hiltViewModel()
val moveOutcome by reschedule.outcome.collectAsStateWithLifecycle()
val selectionFailure by eventActions.failure.collectAsStateWithLifecycle()
+ // "Sync now" in the drawer (#240): its outcome shows in the drawer row, or in
+ // the move chip when it lands with the drawer closed.
+ val sync: SyncViewModel = hiltViewModel()
+ val loadedSyncTargets by sync.targets.collectAsStateWithLifecycle()
+ val syncTargets = loadedSyncTargets ?: SyncTargets.None
+ val syncInFlight by sync.inFlight.collectAsStateWithLifecycle()
+ val syncResult by sync.result.collectAsStateWithLifecycle()
+ val selectionFailureMessage = eventActionFailureMessage(selectionFailure)
+ val syncRowMessage = syncResult?.let { stringResource(it.messageRes()) }
+ val launchAccessPicker = rememberSyncAccessPicker(sync)
+ var showSyncAccess by rememberSaveable { mutableStateOf(false) }
val onEditEvent: (EventInstance) -> Unit = { event -> editKey = event.occurrenceKey() }
// A tap opens the edit form instead of the detail screen when the user chose
// so (#178) — only for events whose calendar takes writes. Both are read at
@@ -538,6 +558,9 @@ fun CalendarHost(
val stayingPut = remember { StayingPut() }
val chromeHost = remember { ChromeHost() }
val drawerState = rememberDrawerState(DrawerValue.Closed)
+ RefreshSyncAccessOnOpen(drawerState, sync)
+ val syncChip = rememberSyncChipOutcome(drawerState, sync)
+ val syncChipMessage = syncChip.value?.let { stringResource(it.messageRes()) }
val density = LocalDensity.current
val topBarBottom = TopAppBarDefaults.windowInsets.getTop(density) +
with(density) { TopAppBarDefaults.TopAppBarExpandedHeight.toPx() }
@@ -588,6 +611,17 @@ fun CalendarHost(
onOpenSettings()
switchScope.launch { drawerState.close() }
},
+ sync = remember(syncTargets, syncInFlight, syncRowMessage) {
+ DrawerSync(
+ canSync = syncTargets.reachable.isNotEmpty(),
+ inFlight = syncInFlight,
+ outcome = syncRowMessage,
+ needsAccess = syncTargets.needsAccess.isNotEmpty(),
+ // Stays open, so the row's progress and the result are seen.
+ onSync = { sync.requestSync() },
+ onGrantAccess = { showSyncAccess = true },
+ )
+ },
)
},
) {
@@ -613,10 +647,12 @@ fun CalendarHost(
// A fresh event, like a duplicate from the detail screen (#52).
openImportForm(form, ImportSource.Insert)
},
- chipShown = moveOutcome != null || selectionFailure != null,
+ chipShown = moveOutcome != null || selectionFailure != null || syncChip.value != null,
onDismissChip = {
reschedule.consumeOutcome()
eventActions.consumeFailure()
+ // Only the chip on show: a receipt queued behind it still gets its turn.
+ if (moveOutcome == null && selectionFailure == null) syncChip.value = null
},
)
CalendarFab(chromeHost, todayInToolbar, fabSelection)
@@ -679,10 +715,21 @@ fun CalendarHost(
EventMoveHost(
reschedule,
modifier = Modifier.fillMaxSize(),
- actionFailure = eventActionFailureMessage(selectionFailure),
- onActionFailureShown = eventActions::consumeFailure,
+ notice = selectionFailureMessage ?: syncChipMessage,
+ onNoticeShown = {
+ if (selectionFailureMessage != null) eventActions.consumeFailure() else syncChip.value = null
+ },
)
+ if (showSyncAccess) {
+ SyncAccessSheet(
+ accounts = loadedSyncTargets?.needsAccess?.toList(),
+ onGrant = launchAccessPicker,
+ onDismissAccount = sync::dismissAccess,
+ onDismiss = { showSyncAccess = false },
+ )
+ }
+
// The delete prompt and failure chip of a selected event's actions (#141).
EventSelectionHost(host = chromeHost, viewModel = eventActions)
diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsScreen.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsScreen.kt
index 5be7aacf..e02ccfdb 100644
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsScreen.kt
@@ -85,6 +85,11 @@ import de.jeanlucmakiola.calendula.ui.common.curatedSourcePackage
import de.jeanlucmakiola.calendula.ui.common.orUnnamed
import de.jeanlucmakiola.floret.components.CollapsingScaffold
import de.jeanlucmakiola.floret.components.GroupedHint
+import de.jeanlucmakiola.calendula.data.calendar.SyncAccount
+import de.jeanlucmakiola.calendula.ui.common.SyncAccountRow
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LifecycleEventEffect
+import de.jeanlucmakiola.floret.components.positionOf
import de.jeanlucmakiola.floret.components.GroupedSectionHeader
import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
import de.jeanlucmakiola.floret.identity.collapseExit
@@ -130,6 +135,8 @@ fun CalendarsScreen(
val calendars by viewModel.calendars.collectAsStateWithLifecycle()
val deleteLockedIds by viewModel.deleteLockedCalendarIds.collectAsStateWithLifecycle()
val error by viewModel.error.collectAsStateWithLifecycle()
+ val syncAccessDismissed by viewModel.syncAccessDismissed.collectAsStateWithLifecycle()
+ LifecycleEventEffect(Lifecycle.Event.ON_RESUME) { viewModel.refreshAccess() }
// null = list; NEW_CALENDAR_ID = create; any other id = edit that calendar.
// [editorSession] bumps on every open so the editor's field state resets for
@@ -174,6 +181,8 @@ fun CalendarsScreen(
onEdit = { calendar -> editorSession++; editorId = calendar.id },
onSetVisible = viewModel::setCalendarVisible,
onSetAccountVisible = viewModel::setAccountVisible,
+ syncAccessDismissed = syncAccessDismissed,
+ onAskSyncAccessAgain = viewModel::askSyncAccessAgain,
)
}
}
@@ -191,6 +200,8 @@ private fun CalendarsList(
onEdit: (CalendarSource) -> Unit,
onSetVisible: (Long, Boolean) -> Unit,
onSetAccountVisible: (Collection, Boolean) -> Unit,
+ syncAccessDismissed: List,
+ onAskSyncAccessAgain: (SyncAccount) -> Unit,
) {
val context = LocalContext.current
val snackbarHostState = remember { SnackbarHostState() }
@@ -321,6 +332,20 @@ private fun CalendarsList(
}
}
}
+
+ if (syncAccessDismissed.isNotEmpty()) {
+ Spacer(Modifier.height(16.dp))
+ GroupedSectionHeader(stringResource(R.string.calendars_sync_access_header))
+ GroupedHint(stringResource(R.string.calendars_sync_access_hint), style = MaterialTheme.typography.bodySmall)
+ syncAccessDismissed.forEachIndexed { index, account ->
+ SyncAccountRow(
+ account = account,
+ position = positionOf(index, syncAccessDismissed.size),
+ actionLabel = stringResource(R.string.calendars_sync_access_ask_again),
+ onAction = { onAskSyncAccessAgain(account) },
+ )
+ }
+ }
}
}
diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsViewModel.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsViewModel.kt
index 1480cd91..99b05703 100644
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsViewModel.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsViewModel.kt
@@ -9,6 +9,7 @@ import dagger.hilt.android.lifecycle.HiltViewModel
import dagger.hilt.android.qualifiers.ApplicationContext
import de.jeanlucmakiola.calendula.data.backup.BackupScheduler
import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.calendar.SyncAccount
import de.jeanlucmakiola.calendula.data.ics.IcsExporter
import de.jeanlucmakiola.calendula.data.prefs.BackupStatus
import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
@@ -60,6 +61,23 @@ class CalendarsViewModel @Inject constructor(
initialValue = emptyList(),
)
+ /**
+ * Accounts the drawer was told not to ask sync-request access for (#240),
+ * limited to those still behind a visible calendar and still unreachable.
+ */
+ val syncAccessDismissed: StateFlow> =
+ repository.syncTargets
+ .map { it.dismissed.toList() }
+ .catch { emit(emptyList()) }
+ .stateWhileSubscribed(scope = viewModelScope, initialValue = emptyList())
+
+ /** Re-read account access, which can change outside the app; called on resume. */
+ fun refreshAccess() = repository.refreshSyncAccess()
+
+ fun askSyncAccessAgain(account: SyncAccount) {
+ viewModelScope.launch { repository.setSyncAccessDismissed(account, dismissed = false) }
+ }
+
/**
* The Backup & restore screen's own view of that list, with the loading and
* failure states [calendars] flattens away — it starts empty and catches to
diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarDrawer.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarDrawer.kt
index e2a1d028..9426546d 100644
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarDrawer.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarDrawer.kt
@@ -20,8 +20,12 @@ import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.DateRange
import androidx.compose.material.icons.filled.Settings
+import androidx.compose.material.icons.filled.ManageAccounts
+import androidx.compose.material.icons.filled.Sync
import androidx.compose.material3.DrawerState
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
import androidx.compose.material3.Icon
+import androidx.compose.material3.LoadingIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.ModalDrawerSheet
import androidx.compose.material3.Text
@@ -38,6 +42,8 @@ import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.res.colorResource
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.semantics.stateDescription
import androidx.compose.ui.unit.dp
import de.jeanlucmakiola.calendula.R
import de.jeanlucmakiola.calendula.ui.filter.CalendarFilterList
@@ -61,6 +67,8 @@ import kotlinx.datetime.LocalDate
*
* [currentDate] seeds the jump-to-date picker (the visible day/week-start/month
* anchor); [onJumpToDate] navigates the active view to the chosen day.
+ * [sync] adds "Sync now" beside it while there is a synced calendar (#240),
+ * and a row to grant account access while some account can't be reached yet.
*/
@Composable
fun CalendarDrawer(
@@ -71,6 +79,7 @@ fun CalendarDrawer(
onJumpToDate: (LocalDate) -> Unit,
onSettings: () -> Unit,
viewOrder: List = IMPLEMENTED_VIEWS,
+ sync: DrawerSync? = null,
) {
var showDatePicker by remember { mutableStateOf(false) }
val scope = rememberCoroutineScope()
@@ -103,11 +112,12 @@ fun CalendarDrawer(
Spacer(Modifier.height(16.dp))
GroupedRow(
title = stringResource(R.string.drawer_jump_to_date),
- position = Position.Alone,
+ position = if (sync?.hasRows == true) Position.Top else Position.Alone,
minHeight = 56.dp,
leading = { DrawerLeadingIcon(Icons.Filled.DateRange) },
onClick = { showDatePicker = true },
)
+ if (sync != null) SyncRows(sync)
Spacer(Modifier.height(16.dp))
@@ -138,6 +148,64 @@ fun CalendarDrawer(
}
}
+/**
+ * The drawer's sync rows: "Sync now" when [canSync] ([inFlight] shows progress
+ * and ignores taps, [outcome] the last request's result while the drawer stays
+ * open), and a grant row while some account [needsAccess].
+ */
+data class DrawerSync(
+ val canSync: Boolean,
+ val inFlight: Boolean,
+ val outcome: String?,
+ val needsAccess: Boolean,
+ val onSync: () -> Unit,
+ val onGrantAccess: () -> Unit,
+) {
+ val hasRows: Boolean get() = canSync || needsAccess
+}
+
+@Composable
+private fun SyncRows(sync: DrawerSync) {
+ if (sync.canSync) {
+ SyncNowRow(sync, if (sync.needsAccess) Position.Middle else Position.Bottom)
+ }
+ if (sync.needsAccess) {
+ GroupedRow(
+ title = stringResource(R.string.drawer_sync_access),
+ summary = stringResource(R.string.drawer_sync_access_summary),
+ position = Position.Bottom,
+ minHeight = 56.dp,
+ leading = { DrawerLeadingIcon(Icons.Filled.ManageAccounts) },
+ onClick = sync.onGrantAccess,
+ )
+ }
+}
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun SyncNowRow(sync: DrawerSync, position: Position) {
+ val inFlightText = stringResource(R.string.sync_in_progress)
+ GroupedRow(
+ title = stringResource(R.string.drawer_sync_now),
+ summary = if (sync.inFlight) inFlightText else sync.outcome,
+ position = position,
+ modifier = if (sync.inFlight) {
+ Modifier.semantics { stateDescription = inFlightText }
+ } else {
+ Modifier
+ },
+ dimmed = sync.inFlight,
+ minHeight = 56.dp,
+ leading = { DrawerLeadingIcon(Icons.Filled.Sync) },
+ trailing = if (sync.inFlight) {
+ { LoadingIndicator(Modifier.size(32.dp)) }
+ } else {
+ null
+ },
+ onClick = sync.onSync.takeIf { !sync.inFlight },
+ )
+}
+
/** Leading slot for the drawer's plain icons: the same 40.dp footprint
* [CalendarColorChip] takes, so every leading glyph shares one vertical axis. */
@Composable
diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/EventMoveHost.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/EventMoveHost.kt
index 542222aa..2a0b539e 100644
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/EventMoveHost.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/EventMoveHost.kt
@@ -51,8 +51,8 @@ private val FAB_BAND = 88.dp
fun EventMoveHost(
viewModel: RescheduleViewModel,
modifier: Modifier = Modifier,
- actionFailure: String? = null,
- onActionFailureShown: () -> Unit = {},
+ notice: String? = null,
+ onNoticeShown: () -> Unit = {},
) {
val prompt by viewModel.scopePrompt.collectAsStateWithLifecycle()
val outcome by viewModel.outcome.collectAsStateWithLifecycle()
@@ -81,7 +81,7 @@ fun EventMoveHost(
}
// A failed selection action (#141) shares the chip rather than stacking on it.
val message = when (outcome) {
- null -> actionFailure
+ null -> notice
is MoveOutcome.Moved -> if (resizedLabel != null) {
stringResource(R.string.event_resize_done, resizedLabel)
} else {
@@ -116,10 +116,10 @@ fun EventMoveHost(
viewModel.consumeOutcome()
}
// A failure waits for the chip to be free, then has its own turn.
- LaunchedEffect(actionFailure, outcome == null) {
- if (actionFailure == null || outcome != null) return@LaunchedEffect
+ LaunchedEffect(notice, outcome == null) {
+ if (notice == null || outcome != null) return@LaunchedEffect
delay(CHIP_MILLIS)
- onActionFailureShown()
+ onNoticeShown()
}
BoxWithConstraints(modifier = modifier.fillMaxSize()) {
@@ -138,7 +138,7 @@ fun EventMoveHost(
// write anyway, so offering it would be a button that does nothing.
val undo = content.undo?.takeIf { !writeInFlight }
SnackChip(
- visible = outcome != null || actionFailure != null,
+ visible = outcome != null || notice != null,
message = content.message,
maxWidth = chipMaxWidth,
actionLabel = stringResource(R.string.event_move_undo).takeIf { undo != null },
diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/SyncAccessPicker.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/SyncAccessPicker.kt
new file mode 100644
index 00000000..2863d769
--- /dev/null
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/SyncAccessPicker.kt
@@ -0,0 +1,153 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import kotlinx.coroutines.flow.combine
+import de.jeanlucmakiola.calendula.data.calendar.SyncRequestResult
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.MutableState
+import android.content.ActivityNotFoundException
+import android.util.Log
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.DrawerState
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.LoadingIndicator
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.DrawerValue
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LifecycleEventEffect
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.data.calendar.SyncAccount
+import de.jeanlucmakiola.calendula.data.calendar.accountAccessIntent
+import de.jeanlucmakiola.floret.components.FullScreenPicker
+import de.jeanlucmakiola.floret.components.GroupedHint
+import de.jeanlucmakiola.floret.components.GroupedRow
+import de.jeanlucmakiola.floret.components.Position
+import de.jeanlucmakiola.floret.components.positionOf
+
+/**
+ * Launches the system account picker for an account sync requests can't reach
+ * yet (#240), one launch at a time. Access is re-read on every resume, which covers
+ * the picker's return and grants or revokes made in system settings.
+ */
+@Composable
+fun rememberSyncAccessPicker(sync: SyncViewModel): (SyncAccount) -> Unit {
+ var open by remember { mutableStateOf(false) }
+ val launcher = rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult()) {
+ open = false
+ }
+ LifecycleEventEffect(Lifecycle.Event.ON_RESUME) { sync.refreshAccess() }
+ val description = stringResource(R.string.sync_access_picker_description)
+ return remember(launcher, description) {
+ { account ->
+ if (!open) {
+ try {
+ launcher.launch(accountAccessIntent(account, description))
+ open = true
+ } catch (e: ActivityNotFoundException) {
+ Log.w("SyncAccessPicker", "No account picker", e)
+ }
+ }
+ }
+ }
+}
+
+/** Re-reads account access whenever [drawerState] opens; the app may stay resumed in multi-window. */
+@Composable
+fun RefreshSyncAccessOnOpen(drawerState: DrawerState, sync: SyncViewModel) {
+ LaunchedEffect(drawerState.targetValue) {
+ if (drawerState.targetValue == DrawerValue.Open) sync.refreshAccess()
+ }
+}
+
+/**
+ * Routes "Sync now"'s outcome (#240): one that lands while the drawer is open
+ * shows in its row and is dropped when the drawer closes; one that lands while
+ * it is closed is handed to the returned state, for the chip.
+ */
+@Composable
+fun rememberSyncChipOutcome(drawerState: DrawerState, sync: SyncViewModel): MutableState {
+ val chip = rememberSaveable { mutableStateOf(null) }
+ LaunchedEffect(drawerState, sync) {
+ var shownInRow = false
+ combine(sync.result, snapshotFlow { drawerState.targetValue == DrawerValue.Closed }) { result, closed ->
+ result to closed
+ }.collect { (result, closed) ->
+ when {
+ result == null -> shownInRow = false
+ !closed -> shownInRow = true
+ else -> {
+ if (!shownInRow) chip.value = result
+ shownInRow = false
+ sync.consumeResult()
+ }
+ }
+ }
+ }
+ return chip
+}
+
+/**
+ * The accounts sync requests can't reach yet (#240), one row each: tapping one
+ * opens the system picker for just that account, "Don't ask" stops offering it.
+ * Closes itself once no account is left.
+ */
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun SyncAccessSheet(
+ accounts: List?,
+ onGrant: (SyncAccount) -> Unit,
+ onDismissAccount: (SyncAccount) -> Unit,
+ onDismiss: () -> Unit,
+) {
+ LaunchedEffect(accounts?.isEmpty()) { if (accounts?.isEmpty() == true) onDismiss() }
+ FullScreenPicker(title = stringResource(R.string.drawer_sync_access), onDismiss = onDismiss, predictiveBack = true) {
+ GroupedHint(stringResource(R.string.sync_access_hint), verticalPadding = 8.dp)
+ if (accounts == null) {
+ Box(Modifier.fillMaxWidth().padding(24.dp), contentAlignment = Alignment.Center) { LoadingIndicator() }
+ }
+ accounts.orEmpty().forEachIndexed { index, account ->
+ SyncAccountRow(
+ account = account,
+ position = positionOf(index, accounts.orEmpty().size),
+ actionLabel = stringResource(R.string.sync_access_dont_ask),
+ onAction = { onDismissAccount(account) },
+ onClick = { onGrant(account) },
+ )
+ }
+ }
+}
+
+/** One synced account with a text action, as the access sheet and the calendar manager list them. */
+@Composable
+fun SyncAccountRow(
+ account: SyncAccount,
+ position: Position,
+ actionLabel: String,
+ onAction: () -> Unit,
+ onClick: (() -> Unit)? = null,
+) {
+ GroupedRow(
+ title = account.name,
+ summary = sourceAppName(account.type),
+ position = position,
+ minHeight = 64.dp,
+ leading = { SourceLogo(account.type) },
+ trailing = { TextButton(onClick = onAction) { Text(actionLabel) } },
+ onClick = onClick,
+ )
+}
diff --git a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/SyncViewModel.kt b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/SyncViewModel.kt
new file mode 100644
index 00000000..bcb2f9e8
--- /dev/null
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/SyncViewModel.kt
@@ -0,0 +1,107 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import android.util.Log
+import androidx.annotation.StringRes
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.calendar.SyncAccount
+import de.jeanlucmakiola.calendula.data.calendar.SyncRequestResult
+import de.jeanlucmakiola.calendula.data.calendar.SyncTargets
+import de.jeanlucmakiola.calendula.data.calendar.SyncWait
+import de.jeanlucmakiola.floret.android.stateWhileSubscribed
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.retryWhen
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+/**
+ * The drawer's "Sync now" (#240): asks the sync adapters of every visible synced
+ * calendar to run now, then follows them through the system's sync state.
+ * [inFlight] holds until every reached account has synced or the wait gives up;
+ * [result] then says [SyncRequestResult.Completed] only when that was seen.
+ */
+@HiltViewModel
+class SyncViewModel @Inject constructor(
+ private val repository: CalendarRepository,
+) : ViewModel() {
+
+ /** Who "Sync now" can reach, and who first needs the user's grant; null until first read. */
+ val targets: StateFlow = repository.syncTargets
+ // A failed read hides the rows for now, then reads again rather than for good.
+ .retryWhen { e, attempt ->
+ if (e is CancellationException) return@retryWhen false
+ emit(SyncTargets.None)
+ delay((RETRY_BASE_MILLIS shl attempt.coerceAtMost(5).toInt()).coerceAtMost(RETRY_MAX_MILLIS))
+ true
+ }
+ .stateWhileSubscribed(scope = viewModelScope, initialValue = null)
+
+ /** Re-read account access: on resume (which includes the picker returning) and drawer open. */
+ fun refreshAccess() = repository.refreshSyncAccess()
+
+ private val _inFlight = MutableStateFlow(false)
+ val inFlight: StateFlow = _inFlight.asStateFlow()
+
+ private val _result = MutableStateFlow(null)
+
+ /** The last request's outcome, until [consumeResult]. */
+ val result: StateFlow = _result.asStateFlow()
+
+ fun requestSync() {
+ if (_inFlight.value) return
+ _inFlight.value = true
+ _result.value = null
+ viewModelScope.launch {
+ try {
+ val request = repository.requestSync()
+ val waited = if (request.accounts.isEmpty()) null else repository.awaitSyncs(request.accounts)
+ _result.value = if (waited == SyncWait.Completed && request.result == SyncRequestResult.Requested) {
+ SyncRequestResult.Completed
+ } else {
+ request.result
+ }
+ } catch (e: CancellationException) {
+ throw e
+ } catch (e: Exception) {
+ Log.w(TAG, "Sync now failed", e)
+ _result.value = SyncRequestResult.Failed
+ } finally {
+ _inFlight.value = false
+ }
+ }
+ }
+
+ /** Stop asking for [account]'s access (#240); undone from the calendar manager. */
+ fun dismissAccess(account: SyncAccount) {
+ viewModelScope.launch { repository.setSyncAccessDismissed(account, dismissed = true) }
+ }
+
+ fun consumeResult() {
+ _result.value = null
+ }
+
+ private companion object {
+ const val RETRY_BASE_MILLIS = 1_000L
+ const val RETRY_MAX_MILLIS = 30_000L
+ const val TAG = "SyncViewModel"
+ }
+}
+
+/** The text for a sync request's outcome, in the drawer row or the chip. */
+@StringRes
+fun SyncRequestResult.messageRes(): Int = when (this) {
+ SyncRequestResult.Requested -> R.string.sync_requested
+ SyncRequestResult.Completed -> R.string.sync_completed
+ SyncRequestResult.PartlyFailed -> R.string.sync_request_partly_failed
+ SyncRequestResult.NeedsAccess -> R.string.sync_request_needs_access
+ SyncRequestResult.SomeNeedAccess -> R.string.sync_request_some_need_access
+ SyncRequestResult.NothingToSync -> R.string.sync_nothing_to_sync
+ SyncRequestResult.Failed -> R.string.sync_request_failed
+}
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 0f435bcc..2708d8f1 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -397,6 +397,23 @@
Jump to date
+ Sync now
+ Allow sync requests
+ Pick each account Calendula may ask to sync
+ Android only lets Calendula ask an account to sync once you pick it here. Tap an account to allow it, or choose Don\'t ask to stop offering it.
+ Don\'t ask
+ Not asked for sync access
+ Calendula won\'t offer to request syncs for these accounts. Ask again to bring them back to Allow sync requests in the menu.
+ Ask again
+ Choose an account Calendula may ask to sync your calendars
+ Sync requested
+ Syncing…
+ Sync completed
+ Couldn\'t request a sync
+ Sync requested. Allow sync requests in the menu for the other accounts
+ Allow sync requests in the menu first
+ Sync requested, but not for every account
+ No synced calendars to sync
Today
diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/TestRepositories.kt b/app/src/test/java/de/jeanlucmakiola/calendula/TestRepositories.kt
index 51de87a3..ff668ab0 100644
--- a/app/src/test/java/de/jeanlucmakiola/calendula/TestRepositories.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/TestRepositories.kt
@@ -5,12 +5,17 @@ import androidx.datastore.preferences.core.PreferenceDataStoreFactory
import androidx.datastore.preferences.core.Preferences
import de.jeanlucmakiola.calendula.data.calendar.CalendarDataSource
import de.jeanlucmakiola.calendula.data.calendar.CalendarRepositoryImpl
+import de.jeanlucmakiola.calendula.data.calendar.SyncAccount
+import de.jeanlucmakiola.calendula.data.calendar.SyncActivity
+import de.jeanlucmakiola.calendula.data.calendar.SyncRequester
import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.test.TestDispatcher
import kotlinx.coroutines.test.UnconfinedTestDispatcher
import kotlinx.coroutines.test.resetMain
@@ -43,7 +48,58 @@ fun testRepository(
io: CoroutineDispatcher,
prefs: CalendarPrefs = testPrefs(dir),
settings: SettingsPrefs = testSettings(dir),
-): CalendarRepositoryImpl = CalendarRepositoryImpl(source, prefs, settings, io)
+ syncRequester: SyncRequester = RecordingSyncRequester(),
+): CalendarRepositoryImpl = CalendarRepositoryImpl(source, prefs, settings, io, syncRequester)
+
+/**
+ * Records every sync request; [accepts] false models the system refusing all,
+ * [refusedTypes] refusing those account types, [adapterTypes] the installed
+ * calendar sync adapters (null: a fixed set covering the test accounts),
+ * [hiddenTypes] account types the app can't address by name.
+ */
+class RecordingSyncRequester(
+ var accepts: Boolean = true,
+ var adapterTypes: Set? = null,
+ var refusedTypes: Set = emptySet(),
+ var hiddenTypes: Set = emptySet(),
+) : SyncRequester {
+ data class Request(val account: SyncAccount, val userInitiated: Boolean)
+
+ val requests = mutableListOf()
+
+ override fun adapterAccountTypes(): Set =
+ adapterTypes ?: setOf("bitfire.at.davdroid", "com.google", "LOCAL")
+
+ override fun addressableAccounts(types: Set): Set? {
+ visibilityError?.let { throw it }
+ return if (hiddenTypes.isEmpty()) {
+ null
+ } else {
+ knownAccounts.filterTo(mutableSetOf()) { it.type in types && it.type !in hiddenTypes }
+ }
+ }
+
+ /** Thrown by [addressableAccounts] when set. */
+ var visibilityError: Exception? = null
+
+ /** The accounts on the "device", for [addressableAccounts]. */
+ var knownAccounts: Set = emptySet()
+
+ override fun requestSync(account: SyncAccount, userInitiated: Boolean) {
+ if (!accepts || account.type in refusedTypes) throw SecurityException("refused")
+ requests += Request(account, userInitiated)
+ }
+
+ /** Each account's sync state; null stands for a system that won't say. */
+ var activity: (SyncAccount) -> SyncActivity? = { SyncActivity.Idle }
+
+ /** Emit to tell waiters the sync state changed. */
+ val activityChanges = MutableSharedFlow(extraBufferCapacity = 8)
+
+ override fun syncActivity(account: SyncAccount): SyncActivity? = activity(account)
+
+ override fun syncActivityChanges(): Flow = activityChanges
+}
/** Installs [dispatcher] as `Dispatchers.Main` around each test. */
@OptIn(ExperimentalCoroutinesApi::class)
diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/FakeCalendarDataSource.kt b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/FakeCalendarDataSource.kt
index 794dcb03..4fb9dff0 100644
--- a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/FakeCalendarDataSource.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/FakeCalendarDataSource.kt
@@ -65,14 +65,27 @@ internal class FakeCalendarDataSource : CalendarDataSource {
val updatedCalendars = mutableListOf()
val deletedCalendarIds = mutableListOf()
+ /** eventId → calendarId, for [eventCalendarId]. */
+ val eventCalendars = mutableMapOf()
+
+ override fun calendarAccount(calendarId: Long): SyncAccount? =
+ calendarsResult.firstOrNull { it.id == calendarId }
+ ?.let { SyncAccount(it.accountName, it.accountType) }
+
+ override fun eventCalendarId(eventId: Long): Long? = eventCalendars[eventId]
+
private val listeners = mutableListOf<() -> Unit>()
/** How often [calendars] was queried — the repository shares one read per tick. */
var calendarQueries = 0
private set
+ /** Set to make [calendars] throw until cleared. */
+ var calendarsError: Exception? = null
+
override fun calendars(): List {
calendarQueries++
+ calendarsError?.let { throw it }
return calendarsResult
}
override fun instances(beginMillis: Long, endMillis: Long): List =
diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/SyncNudgeTest.kt b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/SyncNudgeTest.kt
new file mode 100644
index 00000000..abb8f9de
--- /dev/null
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/SyncNudgeTest.kt
@@ -0,0 +1,314 @@
+package de.jeanlucmakiola.calendula.data.calendar
+
+import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.RecordingSyncRequester
+import de.jeanlucmakiola.calendula.RecordingSyncRequester.Request
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.FormTime
+import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
+import de.jeanlucmakiola.calendula.testRepository
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import org.junit.jupiter.api.io.TempDir
+import java.nio.file.Path
+import kotlin.time.Instant
+
+class SyncNudgeTest {
+
+ private val dav = SyncAccount("me@dav", "bitfire.at.davdroid")
+ private val google = SyncAccount("me@gmail.com", "com.google")
+
+ private fun cal(id: Long, account: SyncAccount, visible: Boolean = true) = CalendarSource(
+ id = id,
+ displayName = "Cal $id",
+ accountName = account.name,
+ accountType = account.type,
+ color = 0,
+ isVisibleInSystem = visible,
+ isLocal = account.type == "LOCAL",
+ )
+
+ private val local = SyncAccount("Calendula", "LOCAL")
+
+ private fun fake() = FakeCalendarDataSource().apply {
+ calendarsResult = listOf(cal(1L, dav), cal(2L, dav), cal(3L, google), cal(4L, local))
+ eventCalendars += mapOf(10L to 1L, 30L to 3L, 40L to 4L)
+ }
+
+ private fun form(calendarId: Long) = EventForm(
+ calendarId = calendarId,
+ title = "Stand-up",
+ start = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0))),
+ end = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 15))),
+ )
+
+ private fun auto(account: SyncAccount) = Request(account, userInitiated = false)
+
+ @Test
+ fun `a write to a synced calendar nudges its account once, not manually`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester()
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ repo.createEvent(form(1L))
+
+ assertThat(sync.requests).containsExactly(auto(dav))
+ }
+
+ @Test
+ fun `a write to a local calendar asks for no sync`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester()
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ repo.createEvent(form(4L))
+ repo.deleteEvent(40L)
+
+ assertThat(sync.requests).isEmpty()
+ }
+
+ @Test
+ fun `event writes resolve the account from the event's calendar`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester()
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ repo.updateEventFromOccurrence(10L, 0L, form(1L), form(1L))
+ repo.deleteOccurrence(30L, 0L)
+
+ assertThat(sync.requests).containsExactly(auto(dav), auto(google)).inOrder()
+ }
+
+ @Test
+ fun `a move between accounts nudges both, each once`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester()
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ repo.moveEvent(10L, 3L, form(1L), form(3L))
+
+ assertThat(sync.requests).containsExactly(auto(dav), auto(google))
+ }
+
+ @Test
+ fun `a move between calendars of one account nudges it once`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester()
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ repo.moveEvent(10L, 2L, form(1L), form(2L))
+
+ assertThat(sync.requests).containsExactly(auto(dav))
+ }
+
+ @Test
+ fun `an import nudges once at the end, however many events`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester()
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+ val events = (1..5).map {
+ ParsedIcsEvent(
+ uid = "u$it",
+ summary = "E$it",
+ start = Instant.fromEpochMilliseconds(1_000_000_000L),
+ end = Instant.fromEpochMilliseconds(1_000_003_600L),
+ isAllDay = false,
+ zoneId = "UTC",
+ )
+ }
+
+ repo.importEvents(3L, events)
+
+ assertThat(sync.requests).containsExactly(auto(google))
+ }
+
+ @Test
+ fun `a failed write still nudges, since part of it may have landed`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester()
+ val source = fake().apply { writeError = IllegalStateException("boom") }
+ val repo = testRepository(source, dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ assertThrows { repo.deleteEvent(10L) }
+
+ assertThat(sync.requests).containsExactly(auto(dav))
+ }
+
+ @Test
+ fun `a throwing requester never fails the save`(@TempDir dir: Path) = runTest {
+ val throwing = RecordingSyncRequester(accepts = false)
+ val source = fake().apply { nextInsertId = 77L }
+ val repo = testRepository(source, dir, Dispatchers.Unconfined, syncRequester = throwing)
+
+ assertThat(repo.createEvent(form(1L))).isEqualTo(77L)
+ }
+
+ @Test
+ fun `manual sync asks each visible synced account once, as manual`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester()
+ val source = fake().apply {
+ calendarsResult = calendarsResult + cal(5L, SyncAccount("hidden@dav", "bitfire.at.davdroid"), visible = false)
+ }
+ val repo = testRepository(source, dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ assertThat(repo.requestSync().result).isEqualTo(SyncRequestResult.Requested)
+ assertThat(sync.requests).containsExactly(Request(dav, true), Request(google, true))
+ }
+
+ @Test
+ fun `manual sync with only local calendars has nothing to sync`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester()
+ val source = FakeCalendarDataSource().apply { calendarsResult = listOf(cal(4L, local)) }
+ val repo = testRepository(source, dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ assertThat(repo.requestSync().result).isEqualTo(SyncRequestResult.NothingToSync)
+ assertThat(sync.requests).isEmpty()
+ }
+
+ @Test
+ fun `manual sync the system refuses reports a failure`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester(accepts = false)
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ assertThat(repo.requestSync().result).isEqualTo(SyncRequestResult.Failed)
+ }
+
+ @Test
+ fun `syncAccounts skips local, invisible and blank accounts`() {
+ val calendars = listOf(
+ cal(1L, dav),
+ cal(2L, dav),
+ cal(3L, google, visible = false),
+ cal(4L, local),
+ cal(5L, SyncAccount("", "com.google")),
+ )
+
+ assertThat(calendars.syncAccounts()).containsExactly(dav)
+ }
+
+ @Test
+ fun `accounts without a calendar sync adapter are never asked`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester(adapterTypes = setOf(dav.type))
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ repo.createEvent(form(3L))
+ assertThat(sync.requests).isEmpty()
+
+ assertThat(repo.requestSync().result).isEqualTo(SyncRequestResult.Requested)
+ assertThat(sync.requests).containsExactly(Request(dav, true))
+ }
+
+ @Test
+ fun `syncTargets needs a visible calendar with an adapter`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester(adapterTypes = setOf(google.type))
+ val source = fake().apply {
+ calendarsResult = listOf(cal(1L, dav), cal(3L, google, visible = false), cal(4L, local))
+ }
+ val repo = testRepository(source, dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ assertThat(repo.syncTargets.first()).isEqualTo(SyncTargets.None)
+
+ sync.adapterTypes = setOf(dav.type)
+ assertThat(repo.syncTargets.first()).isEqualTo(SyncTargets(setOf(dav), emptySet()))
+ }
+
+ @Test
+ fun `manual sync refused for some accounts says so`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester(refusedTypes = setOf(google.type))
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ assertThat(repo.requestSync().result).isEqualTo(SyncRequestResult.PartlyFailed)
+ assertThat(sync.requests).containsExactly(Request(dav, true))
+ }
+
+ @Test
+ fun `accounts the app can't see wait for access instead of being asked`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester(hiddenTypes = setOf(google.type))
+ sync.knownAccounts = setOf(dav, google)
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ repo.moveEvent(10L, 3L, form(1L), form(3L))
+ assertThat(sync.requests).containsExactly(auto(dav))
+
+ assertThat(repo.syncTargets.first()).isEqualTo(SyncTargets(setOf(dav), setOf(google)))
+
+ sync.requests.clear()
+ assertThat(repo.requestSync().result).isEqualTo(SyncRequestResult.SomeNeedAccess)
+ assertThat(sync.requests).containsExactly(Request(dav, true))
+ }
+
+ @Test
+ fun `once access is granted the account is asked by name`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester(hiddenTypes = setOf(google.type))
+ sync.knownAccounts = setOf(dav, google)
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ sync.hiddenTypes = setOf("other")
+
+ assertThat(repo.syncTargets.first()).isEqualTo(SyncTargets(setOf(dav, google), emptySet()))
+ assertThat(repo.requestSync().result).isEqualTo(SyncRequestResult.Requested)
+ assertThat(sync.requests).containsExactly(Request(dav, true), Request(google, true))
+ }
+
+ @Test
+ fun `only hidden accounts make manual sync ask for access, asking no one`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester(hiddenTypes = setOf(dav.type, google.type))
+ sync.knownAccounts = setOf(dav, google)
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ assertThat(repo.requestSync().result).isEqualTo(SyncRequestResult.NeedsAccess)
+ repo.createEvent(form(1L))
+ assertThat(sync.requests).isEmpty()
+ }
+
+ @Test
+ fun `unreadable account visibility counts as reachable`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester(hiddenTypes = setOf("other"))
+ sync.visibilityError = SecurityException("no")
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ repo.createEvent(form(1L))
+
+ assertThat(sync.requests).containsExactly(auto(dav))
+ }
+
+ @Test
+ fun `a dismissed hidden account no longer needs access`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester(hiddenTypes = setOf(google.type))
+ sync.knownAccounts = setOf(dav, google)
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ repo.setSyncAccessDismissed(google, dismissed = true)
+
+ assertThat(repo.syncTargets.first()).isEqualTo(SyncTargets(setOf(dav), emptySet(), dismissed = setOf(google)))
+ assertThat(repo.requestSync().result).isEqualTo(SyncRequestResult.Requested)
+
+ repo.setSyncAccessDismissed(google, dismissed = false)
+ assertThat(repo.syncTargets.first()).isEqualTo(SyncTargets(setOf(dav), setOf(google)))
+ }
+
+ @Test
+ fun `with every hidden account dismissed there is nothing to sync or grant`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester(hiddenTypes = setOf(dav.type, google.type))
+ sync.knownAccounts = setOf(dav, google)
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ repo.setSyncAccessDismissed(dav, dismissed = true)
+ repo.setSyncAccessDismissed(google, dismissed = true)
+
+ assertThat(repo.syncTargets.first()).isEqualTo(SyncTargets(emptySet(), emptySet(), dismissed = setOf(dav, google)))
+ assertThat(repo.requestSync().result).isEqualTo(SyncRequestResult.NothingToSync)
+ }
+
+ @Test
+ fun `a dismissed account that becomes visible is still asked`(@TempDir dir: Path) = runTest {
+ val sync = RecordingSyncRequester()
+ val repo = testRepository(fake(), dir, Dispatchers.Unconfined, syncRequester = sync)
+
+ repo.setSyncAccessDismissed(dav, dismissed = true)
+ repo.createEvent(form(1L))
+
+ assertThat(sync.requests).containsExactly(auto(dav))
+ assertThat(repo.syncTargets.first().dismissed).isEmpty()
+ }
+}
diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/CalendarPrefsTest.kt b/app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/CalendarPrefsTest.kt
index 9f0fb46b..8b0010b0 100644
--- a/app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/CalendarPrefsTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/CalendarPrefsTest.kt
@@ -2,6 +2,7 @@ package de.jeanlucmakiola.calendula.data.prefs
import androidx.datastore.preferences.core.stringPreferencesKey
import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.data.calendar.SyncAccount
import de.jeanlucmakiola.calendula.testDataStore
import de.jeanlucmakiola.calendula.testPrefs
import kotlinx.coroutines.flow.first
@@ -108,4 +109,18 @@ class CalendarPrefsTest {
prefs.setVisibilityNoticePending(false)
assertThat(prefs.visibilityNoticePending.first()).isFalse()
}
+
+ @Test
+ fun `sync access dismissals round-trip per account, names with any characters`(@TempDir tempDir: Path) = runTest {
+ val prefs = testPrefs(tempDir)
+ val dav = SyncAccount("me@dav.example/cal, 1", "bitfire.at.davdroid")
+ val google = SyncAccount("me@dav.example/cal, 1", "com.google")
+
+ prefs.setSyncAccessDismissed(dav, dismissed = true)
+ prefs.setSyncAccessDismissed(google, dismissed = true)
+ assertThat(prefs.syncAccessDismissed.first()).containsExactly(dav, google)
+
+ prefs.setSyncAccessDismissed(dav, dismissed = false)
+ assertThat(prefs.syncAccessDismissed.first()).containsExactly(google)
+ }
}
diff --git a/app/src/test/java/de/jeanlucmakiola/calendula/ui/common/SyncViewModelTest.kt b/app/src/test/java/de/jeanlucmakiola/calendula/ui/common/SyncViewModelTest.kt
new file mode 100644
index 00000000..1d525b00
--- /dev/null
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/ui/common/SyncViewModelTest.kt
@@ -0,0 +1,209 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.MainDispatcherExtension
+import de.jeanlucmakiola.calendula.RecordingSyncRequester
+import de.jeanlucmakiola.calendula.data.calendar.FakeCalendarDataSource
+import de.jeanlucmakiola.calendula.data.calendar.SyncAccount
+import de.jeanlucmakiola.calendula.data.calendar.SyncActivity
+import de.jeanlucmakiola.calendula.data.calendar.SyncRequestResult
+import de.jeanlucmakiola.calendula.data.calendar.SyncTargets
+import kotlinx.coroutines.launch
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.testPrefs
+import de.jeanlucmakiola.calendula.testRepository
+import de.jeanlucmakiola.calendula.testSettings
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.RegisterExtension
+import org.junit.jupiter.api.io.TempDir
+import java.nio.file.Path
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class SyncViewModelTest {
+
+ @JvmField @RegisterExtension
+ val mainDispatcher = MainDispatcherExtension(StandardTestDispatcher())
+ private val dispatcher = mainDispatcher.dispatcher
+
+ private val synced = CalendarSource(1L, "Work", "me@dav", "bitfire.at.davdroid", 0, true)
+ private val davAccount = SyncAccount("me@dav", "bitfire.at.davdroid")
+
+ private fun viewModel(dir: Path, sync: RecordingSyncRequester = RecordingSyncRequester()):
+ Pair {
+ val source = FakeCalendarDataSource().apply { calendarsResult = listOf(synced) }
+ val repo = testRepository(
+ source, dir, dispatcher,
+ prefs = testPrefs(dir, CoroutineScope(dispatcher)),
+ settings = testSettings(dir, CoroutineScope(dispatcher)),
+ syncRequester = sync,
+ )
+ return SyncViewModel(repo) to source
+ }
+
+ @Test
+ fun `completed once the reached account has synced`(@TempDir dir: Path) = runTest(dispatcher) {
+ val sync = RecordingSyncRequester()
+ var state = SyncActivity.Pending
+ sync.activity = { state }
+ val (vm, _) = viewModel(dir, sync)
+
+ vm.requestSync()
+ runCurrent()
+ assertThat(vm.inFlight.value).isTrue()
+ assertThat(vm.result.value).isNull()
+
+ state = SyncActivity.Active
+ sync.activityChanges.tryEmit(Unit)
+ runCurrent()
+ assertThat(vm.inFlight.value).isTrue()
+
+ state = SyncActivity.Idle
+ sync.activityChanges.tryEmit(Unit)
+ runCurrent()
+
+ assertThat(vm.inFlight.value).isFalse()
+ assertThat(vm.result.value).isEqualTo(SyncRequestResult.Completed)
+ }
+
+ @Test
+ fun `a sync already running when asked has to finish and the asked one run`(@TempDir dir: Path) = runTest(dispatcher) {
+ val sync = RecordingSyncRequester()
+ var state = SyncActivity.Active
+ sync.activity = { state }
+ val (vm, _) = viewModel(dir, sync)
+
+ vm.requestSync()
+ runCurrent()
+ state = SyncActivity.Pending
+ sync.activityChanges.tryEmit(Unit)
+ runCurrent()
+ assertThat(vm.inFlight.value).isTrue()
+
+ state = SyncActivity.Idle
+ sync.activityChanges.tryEmit(Unit)
+ runCurrent()
+
+ assertThat(vm.inFlight.value).isFalse()
+ assertThat(vm.result.value).isEqualTo(SyncRequestResult.Completed)
+ }
+
+ @Test
+ fun `a sync that never shows up counts as done after the grace`(@TempDir dir: Path) = runTest(dispatcher) {
+ val (vm, _) = viewModel(dir)
+
+ vm.requestSync()
+ advanceTimeBy(4_000L)
+ assertThat(vm.inFlight.value).isTrue()
+
+ advanceTimeBy(1_500L)
+ assertThat(vm.inFlight.value).isFalse()
+ assertThat(vm.result.value).isEqualTo(SyncRequestResult.Completed)
+ }
+
+ @Test
+ fun `a sync still running after a minute stays unconfirmed`(@TempDir dir: Path) = runTest(dispatcher) {
+ val sync = RecordingSyncRequester().apply { activity = { SyncActivity.Active } }
+ val (vm, _) = viewModel(dir, sync)
+
+ vm.requestSync()
+ advanceTimeBy(59_000L)
+ assertThat(vm.inFlight.value).isTrue()
+
+ advanceTimeBy(1_500L)
+ assertThat(vm.inFlight.value).isFalse()
+ assertThat(vm.result.value).isEqualTo(SyncRequestResult.Requested)
+ }
+
+ @Test
+ fun `unreadable sync state says requested at once`(@TempDir dir: Path) = runTest(dispatcher) {
+ val sync = RecordingSyncRequester().apply { activity = { null } }
+ val (vm, _) = viewModel(dir, sync)
+
+ vm.requestSync()
+ runCurrent()
+
+ assertThat(vm.inFlight.value).isFalse()
+ assertThat(vm.result.value).isEqualTo(SyncRequestResult.Requested)
+ }
+
+ @Test
+ fun `a tap while in flight asks only once`(@TempDir dir: Path) = runTest(dispatcher) {
+ val sync = RecordingSyncRequester()
+ val (vm, _) = viewModel(dir, sync)
+
+ vm.requestSync()
+ runCurrent()
+ vm.requestSync()
+ runCurrent()
+
+ assertThat(sync.requests).hasSize(1)
+ }
+
+ @Test
+ fun `a refused request stops at once and says so`(@TempDir dir: Path) = runTest(dispatcher) {
+ val (vm, _) = viewModel(dir, RecordingSyncRequester(accepts = false))
+
+ vm.requestSync()
+ runCurrent()
+
+ assertThat(vm.inFlight.value).isFalse()
+ assertThat(vm.result.value).isEqualTo(SyncRequestResult.Failed)
+
+ vm.consumeResult()
+ assertThat(vm.result.value).isNull()
+ }
+
+ @Test
+ fun `refreshAccess picks up a grant`(@TempDir dir: Path) = runTest(dispatcher) {
+ val sync = RecordingSyncRequester(hiddenTypes = setOf(davAccount.type))
+ sync.knownAccounts = setOf(davAccount)
+ val (vm, _) = viewModel(dir, sync)
+ backgroundScope.launch { vm.targets.collect {} }
+ runCurrent()
+
+ assertThat(vm.targets.value).isEqualTo(SyncTargets(emptySet(), setOf(davAccount)))
+
+ sync.hiddenTypes = setOf("other")
+ vm.refreshAccess()
+ runCurrent()
+
+ assertThat(vm.targets.value).isEqualTo(SyncTargets(setOf(davAccount), emptySet()))
+ }
+
+ @Test
+ fun `dismissing a hidden account takes it out of the grant list`(@TempDir dir: Path) = runTest(dispatcher) {
+ val sync = RecordingSyncRequester(hiddenTypes = setOf(davAccount.type))
+ sync.knownAccounts = setOf(davAccount)
+ val (vm, _) = viewModel(dir, sync)
+ backgroundScope.launch { vm.targets.collect {} }
+ runCurrent()
+ assertThat(vm.targets.value?.needsAccess).containsExactly(davAccount)
+
+ vm.dismissAccess(davAccount)
+ runCurrent()
+
+ assertThat(vm.targets.value).isEqualTo(SyncTargets(emptySet(), emptySet(), dismissed = setOf(davAccount)))
+ }
+
+ @Test
+ fun `a failed read of the targets is retried rather than hiding Sync now for good`(@TempDir dir: Path) =
+ runTest(dispatcher) {
+ val (vm, source) = viewModel(dir)
+ source.calendarsError = IllegalStateException("provider gone")
+ backgroundScope.launch { vm.targets.collect {} }
+ runCurrent()
+ assertThat(vm.targets.value?.reachable.orEmpty()).isEmpty()
+
+ source.calendarsError = null
+ advanceTimeBy(31_000)
+ runCurrent()
+
+ assertThat(vm.targets.value?.reachable).containsExactly(davAccount)
+ }
+}
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index 4bfdf9ee..dc5cb0b6 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -10,6 +10,32 @@ the package list (recurring writes, save conflicts, reminder delivery).
1. **`CalendarContract` is the single source of truth.** No app database,
no caching layer, no sync code. Reads query the provider; writes go
straight back to it. Sync is DAVx5's / Google's / the system's job.
+ The app only *asks* for one through `ContentResolver.requestSync`: an
+ expedited nudge for the account after each of its own writes to a synced
+ calendar (#303, once per write, so a multi-row save or an import asks once
+ per account, and never `MANUAL`, which would override master-sync-off), and
+ a manual request from the drawer's "Sync now" (#240), which like the
+ system's own "Sync now" also runs for accounts whose auto-sync is off. Both
+ go through `SyncRequester` and only ask account types with a calendar sync
+ adapter (visible to the app via a `` entry). From Android 13 a
+ request naming an account the app can't see is silently dropped, and
+ without `GET_ACCOUNTS` that is most of them. Such accounts are not asked at
+ all (an account-less request would sync every account on the device); the
+ drawer offers "Allow sync requests" instead, which opens the system account
+ picker (`AccountManager.newChooseAccountIntent`) — the picked account
+ becomes visible to the app. Access is re-read on every request and on
+ every resume and drawer open, so a revoke simply puts the account back behind the
+ grant row. Per account the user can choose "Don't ask" instead
+ (`CalendarPrefs.syncAccessDismissed`); such accounts drop out of the grant
+ row and the receipts, and the calendar manager lists them to ask again. Whether and when the adapter syncs stays its call.
+ "Sync now" then follows what it asked for through the system's sync state
+ (`READ_SYNC_STATS`: `isSyncPending` / `isSyncActive` plus a status-change
+ listener, see `awaitSyncs`): it reports "Sync completed" once every reached
+ account was seen pending or running and is idle again (or, never seen, is
+ still idle after a short grace), and only "Sync requested" when that isn't
+ seen within a minute or the state can't be read. The outcome shows in the
+ drawer row while the drawer is open; one that lands with the drawer closed
+ gets the chip.
2. **Observer-driven UI.** A `ContentObserver` on the provider triggers
re-queries; every screen recomposes from fresh provider state. After a
write, nothing is patched by hand — the views refresh from the provider.
diff --git a/docs/PRIVACY.md b/docs/PRIVACY.md
index e542cedb..44085894 100644
--- a/docs/PRIVACY.md
+++ b/docs/PRIVACY.md
@@ -98,6 +98,7 @@ The settings screen contains links to the source code, the licence, the issue tr
- `REQUEST_IGNORE_BATTERY_OPTIMIZATIONS`: only to open the system dialog for the “Reliable delivery” setting.
- `USE_FULL_SCREEN_INTENT`, `FOREGROUND_SERVICE`, `FOREGROUND_SERVICE_SYSTEM_EXEMPTED`, `VIBRATE`: for calendars you set to full-screen alerts — showing the alert over the lock screen and, with “Ring until dismissed”, ringing and vibrating until you dismiss or snooze it.
- `WAKE_LOCK`: keeps the phone awake while a full-screen alert rings, and lets the Android component that runs scheduled background work (WorkManager) finish it.
+- `READ_SYNC_STATS`: only to see whether a sync asked for with “Sync now” is still pending or running, so the menu can say when it has finished. It reveals nothing about your data.
## 7. Distribution channels