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