From 0d868961e5b47442b56482d528dad0962219c96e Mon Sep 17 00:00:00 2001
From: Bob <timetobuildbob@gmail.com>
Date: Thu, 17 Sep 2026 22:57:35 +0000
Subject: [PATCH 1/5] feat(sync): show next scheduled sync time in Sync
 Settings
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Surfaces "when will it sync next?" next to the existing "last sync"
status, derived from SyncScheduler's SYNC_INTERVAL_MS and the last
completed run — no new persisted state.

Part of ActivityWatch/aw-android#274 (the per-peer-names half is
tracked separately, blocked on aw-server-rust JNI support).

Git-Session-Id: 4f6d
---
 .../activitywatch/android/SyncScheduler.kt    |  4 +-
 .../android/SyncSettingsActivity.kt           | 34 ++++++++++++++
 .../res/layout/activity_sync_settings.xml     | 12 ++++-
 .../android/SyncSettingsActivityTest.kt       | 46 +++++++++++++++++++
 4 files changed, 94 insertions(+), 2 deletions(-)

diff --git a/mobile/src/main/java/net/activitywatch/android/SyncScheduler.kt b/mobile/src/main/java/net/activitywatch/android/SyncScheduler.kt
index e396203b..922ffbac 100644
--- a/mobile/src/main/java/net/activitywatch/android/SyncScheduler.kt
+++ b/mobile/src/main/java/net/activitywatch/android/SyncScheduler.kt
@@ -12,7 +12,9 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 
 private const val TAG = "SyncScheduler"
-private const val SYNC_INTERVAL_MS = 15 * 60 * 1000L
+// internal (not private): SyncSettingsActivity reads this to render "next sync at" without
+// duplicating the interval or requiring a data-model change.
+internal const val SYNC_INTERVAL_MS = 15 * 60 * 1000L
 private const val ACTION_SYNC_ALARM = "net.activitywatch.android.SYNC_ALARM"
 
 class SyncScheduler(private val context: Context) {
diff --git a/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt b/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt
index dace8df5..7c629ed4 100644
--- a/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt
+++ b/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt
@@ -43,6 +43,27 @@ internal fun formatSyncStatus(status: SyncStatus?, dateFormat: DateFormat): Stri
     return "$headline\n${formatSyncDetail(status)}"
 }
 
+/**
+ * "When will it sync next?" — derived from the existing SyncScheduler interval and the
+ * last completed run, with no new persisted state. The scheduler always reschedules
+ * SYNC_INTERVAL_MS after the previous run completes (SyncScheduler.performSync), so
+ * lastCompletedAt + SYNC_INTERVAL_MS is the real next-run time whenever sync is enabled.
+ */
+internal fun formatNextSyncStatus(
+    enabled: Boolean,
+    lastStatus: SyncStatus?,
+    dateFormat: DateFormat,
+    now: Long = System.currentTimeMillis(),
+): String {
+    if (!enabled) return "Next sync: sync is disabled"
+    if (lastStatus == null) {
+        return "Next sync: shortly (first sync runs about a minute after ActivityWatch starts)"
+    }
+    val nextAt = lastStatus.completedAt + SYNC_INTERVAL_MS
+    if (nextAt <= now) return "Next sync: due now"
+    return "Next sync: ${dateFormat.format(Date(nextAt))}"
+}
+
 /**
  * The per-run facts line: what moved and which peers it came from. Without
  * this, a pass that transferred nothing is indistinguishable from one that
@@ -69,6 +90,7 @@ class SyncSettingsActivity : AppCompatActivity() {
     private lateinit var switchSyncEnabled: SwitchCompat
     private lateinit var tvSyncDirStatus: TextView
     private lateinit var tvLastSyncStatus: TextView
+    private lateinit var tvNextSyncStatus: TextView
     private lateinit var btnChooseDir: Button
 
     // Guards against the switch listener firing when we set isChecked programmatically
@@ -78,6 +100,7 @@ class SyncSettingsActivity : AppCompatActivity() {
         override fun onReceive(context: Context, intent: Intent) {
             if (intent.action == AWPreferences.LAST_SYNC_STATUS_CHANGED_ACTION) {
                 updateLastSyncStatus()
+                updateNextSyncStatus()
             }
         }
     }
@@ -147,6 +170,7 @@ class SyncSettingsActivity : AppCompatActivity() {
         switchSyncEnabled = findViewById(R.id.switch_sync_enabled)
         tvSyncDirStatus = findViewById(R.id.tv_sync_dir_status)
         tvLastSyncStatus = findViewById(R.id.tv_last_sync_status)
+        tvNextSyncStatus = findViewById(R.id.tv_next_sync_status)
         btnChooseDir = findViewById(R.id.btn_choose_sync_dir)
 
         refreshUI()
@@ -160,6 +184,7 @@ class SyncSettingsActivity : AppCompatActivity() {
                 action = BackgroundService.ACTION_SYNC_ENABLED_CHANGED
                 putExtra(BackgroundService.EXTRA_START_ORIGIN, BackgroundService.START_ORIGIN_SETTINGS)
             })
+            updateNextSyncStatus()
         }
 
         btnChooseDir.setOnClickListener {
@@ -197,6 +222,7 @@ class SyncSettingsActivity : AppCompatActivity() {
         isUpdatingSwitch = false
         updateSyncDirStatus()
         updateLastSyncStatus()
+        updateNextSyncStatus()
     }
 
     private fun updateLastSyncStatus() {
@@ -206,6 +232,14 @@ class SyncSettingsActivity : AppCompatActivity() {
         )
     }
 
+    private fun updateNextSyncStatus() {
+        tvNextSyncStatus.text = formatNextSyncStatus(
+            prefs.isSyncEnabled(),
+            prefs.getLastSyncStatus(),
+            combinedDateTimeFormat(),
+        )
+    }
+
     private fun combinedDateTimeFormat(): DateFormat {
         val dateFormat = android.text.format.DateFormat.getMediumDateFormat(this)
         val timeFormat = android.text.format.DateFormat.getTimeFormat(this)
diff --git a/mobile/src/main/res/layout/activity_sync_settings.xml b/mobile/src/main/res/layout/activity_sync_settings.xml
index 7cdd1204..4bc95d70 100644
--- a/mobile/src/main/res/layout/activity_sync_settings.xml
+++ b/mobile/src/main/res/layout/activity_sync_settings.xml
@@ -47,11 +47,21 @@
             android:id="@+id/tv_last_sync_status"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
-            android:layout_marginBottom="16dp"
+            android:layout_marginBottom="8dp"
             android:text="Last sync: never"
             android:textAppearance="?android:attr/textAppearanceSmall"
             android:textColor="?android:attr/textColorSecondary" />
 
+        <!-- Next scheduled automatic sync -->
+        <TextView
+            android:id="@+id/tv_next_sync_status"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginBottom="16dp"
+            android:text="Next sync: sync is disabled"
+            android:textAppearance="?android:attr/textAppearanceSmall"
+            android:textColor="?android:attr/textColorSecondary" />
+
         <!-- Choose directory button -->
         <Button
             android:id="@+id/btn_choose_sync_dir"
diff --git a/mobile/src/test/java/net/activitywatch/android/SyncSettingsActivityTest.kt b/mobile/src/test/java/net/activitywatch/android/SyncSettingsActivityTest.kt
index 3fe62f6c..9a9c12a5 100644
--- a/mobile/src/test/java/net/activitywatch/android/SyncSettingsActivityTest.kt
+++ b/mobile/src/test/java/net/activitywatch/android/SyncSettingsActivityTest.kt
@@ -74,6 +74,52 @@ class SyncSettingsActivityTest {
         )
     }
 
+    @Test
+    fun formatNextSyncStatus_reportsDisabledWhenSyncOff() {
+        assertEquals(
+            "Next sync: sync is disabled",
+            formatNextSyncStatus(enabled = false, lastStatus = null, dateFormat = dateFormat),
+        )
+    }
+
+    @Test
+    fun formatNextSyncStatus_reportsShortlyBeforeFirstSync() {
+        assertEquals(
+            "Next sync: shortly (first sync runs about a minute after ActivityWatch starts)",
+            formatNextSyncStatus(enabled = true, lastStatus = null, dateFormat = dateFormat),
+        )
+    }
+
+    @Test
+    fun formatNextSyncStatus_addsIntervalToLastCompletedRun() {
+        // 2026-09-01 01:30:00 UTC + 15 minutes = 2026-09-01 01:45:00 UTC
+        val completedAt = 1_788_226_200_000L
+        assertEquals(
+            "Next sync: 2026-09-01 01:45",
+            formatNextSyncStatus(
+                enabled = true,
+                lastStatus = SyncStatus(completedAt = completedAt, success = true),
+                dateFormat = dateFormat,
+                now = completedAt,
+            ),
+        )
+    }
+
+    @Test
+    fun formatNextSyncStatus_reportsDueNowWhenIntervalHasElapsed() {
+        val completedAt = 1_788_226_200_000L
+        val wellPastInterval = completedAt + 60 * 60 * 1000L
+        assertEquals(
+            "Next sync: due now",
+            formatNextSyncStatus(
+                enabled = true,
+                lastStatus = SyncStatus(completedAt = completedAt, success = true),
+                dateFormat = dateFormat,
+                now = wellPastInterval,
+            ),
+        )
+    }
+
     @Test
     fun normalizeError_capsLength() {
         val raw = "x".repeat(SyncStatus.MAX_ERROR_CHARS + 50)

From fb7a8539ffb29fe38552965ce6f18a929fe15647 Mon Sep 17 00:00:00 2001
From: Bob <timetobuildbob@gmail.com>
Date: Fri, 18 Sep 2026 01:11:54 +0000
Subject: [PATCH 2/5] fix(sync): anchor next-sync display to scheduler's
 registered run time

formatNextSyncStatus was computing lastCompletedAt + SYNC_INTERVAL_MS, which
diverges from the actual scheduled time whenever the scheduler is (re)started:
start() delays the first run by 60s (not 15min), so the displayed time could
show an old timestamp or "due now" while the real next run is still a minute away.

Fix: SyncScheduler now writes its actual scheduled next-run epoch-ms into
AWPreferences ("schedulerNextRunAt") on start() and after each completed sync.
SyncSettingsActivity reads this stored value and passes it to formatNextSyncStatus,
which uses it in preference to the computed lastCompletedAt+interval fallback.
The fallback is kept for the first-install case before any scheduler run is
recorded.

Adds a unit test that verifies the scheduler-anchored time is used over the
computed interval (shows 01:31 from the registered +60s, not 01:45 from +15min).

Git-Session-Id: ae8f1145-f19e-5b27-8216-f6ff4db022ef
---
 .../activitywatch/android/AWPreferences.kt    | 12 ++++++++++++
 .../activitywatch/android/SyncScheduler.kt    |  5 +++++
 .../android/SyncSettingsActivity.kt           | 14 +++++++++-----
 .../android/SyncSettingsActivityTest.kt       | 19 +++++++++++++++++++
 4 files changed, 45 insertions(+), 5 deletions(-)

diff --git a/mobile/src/main/java/net/activitywatch/android/AWPreferences.kt b/mobile/src/main/java/net/activitywatch/android/AWPreferences.kt
index 83fac3ca..6c4ce7ff 100644
--- a/mobile/src/main/java/net/activitywatch/android/AWPreferences.kt
+++ b/mobile/src/main/java/net/activitywatch/android/AWPreferences.kt
@@ -155,6 +155,18 @@ class AWPreferences(context: Context) {
         )
     }
 
+    // When the SyncScheduler registers the next run (on start or after each completed sync),
+    // it records the epoch-ms of that run here so the UI can display the actual scheduled time
+    // rather than computing it from lastCompletedAt + interval (which diverges after restarts).
+    // Returns 0L if no scheduled time has been recorded yet.
+    fun getSchedulerNextRunAt(): Long {
+        return sharedPreferences.getLong("schedulerNextRunAt", 0L)
+    }
+
+    fun setSchedulerNextRunAt(epochMs: Long) {
+        sharedPreferences.edit().putLong("schedulerNextRunAt", epochMs).apply()
+    }
+
     // Dashboard authentication. Defaults to true so first-run gets a key generated
     // automatically. Set to false when the user explicitly disables auth in settings;
     // ensureDashboardApiKey() checks this before generating a new key so that the
diff --git a/mobile/src/main/java/net/activitywatch/android/SyncScheduler.kt b/mobile/src/main/java/net/activitywatch/android/SyncScheduler.kt
index 922ffbac..430dfd3d 100644
--- a/mobile/src/main/java/net/activitywatch/android/SyncScheduler.kt
+++ b/mobile/src/main/java/net/activitywatch/android/SyncScheduler.kt
@@ -19,6 +19,7 @@ private const val ACTION_SYNC_ALARM = "net.activitywatch.android.SYNC_ALARM"
 
 class SyncScheduler(private val context: Context) {
     private val handler = Handler(Looper.getMainLooper())
+    private val prefs = AWPreferences(context)
     private lateinit var syncInterface: SyncInterface
     private var isRunning = false
 
@@ -48,7 +49,9 @@ class SyncScheduler(private val context: Context) {
                 syncInterface = SyncInterface(context)
 
                 // Handler and AlarmManager calls are thread-safe; post from IO is fine.
+                val firstRunAt = System.currentTimeMillis() + 60 * 1000L
                 handler.postDelayed(syncRunnable, 60 * 1000L)
+                prefs.setSchedulerNextRunAt(firstRunAt)
                 scheduleAlarm()
             } catch (e: UnsatisfiedLinkError) {
                 Log.e(TAG, "aw-sync native library unavailable; sync scheduler disabled", e)
@@ -102,8 +105,10 @@ class SyncScheduler(private val context: Context) {
             }
             // Schedule next sync only after this one completes, preventing overlapping JNI calls.
             if (isRunning) {
+                val nextRunAt = System.currentTimeMillis() + SYNC_INTERVAL_MS
                 Log.i(TAG, "Scheduling next sync in 15 minutes")
                 handler.postDelayed(syncRunnable, SYNC_INTERVAL_MS)
+                prefs.setSchedulerNextRunAt(nextRunAt)
             }
         }
     }
diff --git a/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt b/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt
index 7c629ed4..8f037c78 100644
--- a/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt
+++ b/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt
@@ -44,22 +44,25 @@ internal fun formatSyncStatus(status: SyncStatus?, dateFormat: DateFormat): Stri
 }
 
 /**
- * "When will it sync next?" — derived from the existing SyncScheduler interval and the
- * last completed run, with no new persisted state. The scheduler always reschedules
- * SYNC_INTERVAL_MS after the previous run completes (SyncScheduler.performSync), so
- * lastCompletedAt + SYNC_INTERVAL_MS is the real next-run time whenever sync is enabled.
+ * "When will it sync next?" — uses the scheduler's own recorded next-run time
+ * (written by SyncScheduler.start() and after each completed sync) so the displayed
+ * time matches what the scheduler actually has registered. Falls back to
+ * lastCompletedAt + SYNC_INTERVAL_MS when no scheduler time is recorded (e.g. after
+ * a fresh install before the first start() call).
  */
 internal fun formatNextSyncStatus(
     enabled: Boolean,
     lastStatus: SyncStatus?,
     dateFormat: DateFormat,
     now: Long = System.currentTimeMillis(),
+    schedulerNextRunAt: Long? = null,
 ): String {
     if (!enabled) return "Next sync: sync is disabled"
     if (lastStatus == null) {
         return "Next sync: shortly (first sync runs about a minute after ActivityWatch starts)"
     }
-    val nextAt = lastStatus.completedAt + SYNC_INTERVAL_MS
+    val nextAt = schedulerNextRunAt?.takeIf { it > 0L }
+        ?: (lastStatus.completedAt + SYNC_INTERVAL_MS)
     if (nextAt <= now) return "Next sync: due now"
     return "Next sync: ${dateFormat.format(Date(nextAt))}"
 }
@@ -237,6 +240,7 @@ class SyncSettingsActivity : AppCompatActivity() {
             prefs.isSyncEnabled(),
             prefs.getLastSyncStatus(),
             combinedDateTimeFormat(),
+            schedulerNextRunAt = prefs.getSchedulerNextRunAt().takeIf { it > 0L },
         )
     }
 
diff --git a/mobile/src/test/java/net/activitywatch/android/SyncSettingsActivityTest.kt b/mobile/src/test/java/net/activitywatch/android/SyncSettingsActivityTest.kt
index 9a9c12a5..7651a151 100644
--- a/mobile/src/test/java/net/activitywatch/android/SyncSettingsActivityTest.kt
+++ b/mobile/src/test/java/net/activitywatch/android/SyncSettingsActivityTest.kt
@@ -120,6 +120,25 @@ class SyncSettingsActivityTest {
         )
     }
 
+    @Test
+    fun formatNextSyncStatus_usesSchedulerNextRunAtOverComputedInterval() {
+        // After a service restart, scheduler schedules first run at +60s, not lastCompletedAt+15min.
+        // The UI must show the scheduler-registered time, not the computed one.
+        val completedAt = 1_788_226_200_000L       // 2026-09-01 01:30:00 UTC
+        val now = completedAt + 5 * 1000L           // 5s after last sync
+        val schedulerNextRunAt = now + 60 * 1000L   // scheduler registered +60s from restart
+        assertEquals(
+            "Next sync: 2026-09-01 01:31",
+            formatNextSyncStatus(
+                enabled = true,
+                lastStatus = SyncStatus(completedAt = completedAt, success = true),
+                dateFormat = dateFormat,
+                now = now,
+                schedulerNextRunAt = schedulerNextRunAt,
+            ),
+        )
+    }
+
     @Test
     fun normalizeError_capsLength() {
         val raw = "x".repeat(SyncStatus.MAX_ERROR_CHARS + 50)

From 8ed0c978ab5d6c0af57ace76aa07ec6032fcc115 Mon Sep 17 00:00:00 2001
From: Bob <bob@superuserlabs.org>
Date: Fri, 18 Sep 2026 02:09:06 +0000
Subject: [PATCH 3/5] fix(sync): re-anchor schedulerNextRunAt on
 alarm-triggered sync completion

SyncWorker (the AlarmManager fallback path) never wrote schedulerNextRunAt,
so after the app process is killed and restarted via the alarm instead of
SyncScheduler.start(), the 'Next sync' display got stuck showing a stale
past timestamp ('due now') forever, even though syncs kept happening on
the alarm's interval.

Git-Session-Id: e32bc91c-e9ed-5c1a-b261-c6e94c6ac45d
---
 .../java/net/activitywatch/android/workers/SyncWorker.kt | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/mobile/src/main/java/net/activitywatch/android/workers/SyncWorker.kt b/mobile/src/main/java/net/activitywatch/android/workers/SyncWorker.kt
index 14d4058d..38488c6e 100644
--- a/mobile/src/main/java/net/activitywatch/android/workers/SyncWorker.kt
+++ b/mobile/src/main/java/net/activitywatch/android/workers/SyncWorker.kt
@@ -5,6 +5,8 @@ import android.util.Log
 import androidx.work.CoroutineWorker
 import androidx.work.WorkerParameters
 import kotlinx.coroutines.suspendCancellableCoroutine
+import net.activitywatch.android.AWPreferences
+import net.activitywatch.android.SYNC_INTERVAL_MS
 import net.activitywatch.android.SyncInterface
 import kotlin.coroutines.resume
 
@@ -25,6 +27,13 @@ class SyncWorker(context: Context, params: WorkerParameters) : CoroutineWorker(c
                 syncInterface.syncBothAndMirrorAsync { success, message ->
                     if (!continuation.isActive) return@syncBothAndMirrorAsync
 
+                    // The alarm-triggered path runs independently of SyncScheduler (whose in-process
+                    // Handler chain may be dead after a process kill) — re-anchor here too, or the
+                    // "Next sync" display gets stuck showing a stale/past time forever after a restart.
+                    AWPreferences(applicationContext).setSchedulerNextRunAt(
+                        System.currentTimeMillis() + SYNC_INTERVAL_MS
+                    )
+
                     if (success) {
                         Log.i(TAG, "Automatic sync completed successfully: $message")
                         continuation.resume(Result.success())

From ff8b0609daef51bd451536137825acbb08485e0e Mon Sep 17 00:00:00 2001
From: Bob <bob@superuserlabs.org>
Date: Fri, 18 Sep 2026 02:39:03 +0000
Subject: [PATCH 4/5] fix(sync): periodic refresh keeps 'Next sync' status from
 going stale

While SyncSettingsActivity is visible, the 'Next sync' text was only
refreshed on a switch toggle or a completed-sync broadcast. If the
displayed deadline passed while the screen stayed open, the text kept
showing the old timestamp instead of flipping to 'due now' until
another event arrived.

Add a 30s self-rescheduling Handler tick (started in onStart, stopped
in onStop) that re-renders the next-sync text, mirroring the existing
Handler pattern already used by SyncScheduler.

Git-Session-Id: c450adb7-6205-57e9-9a95-3a7d9ecb50ba
---
 .../android/SyncSettingsActivity.kt            | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt b/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt
index 8f037c78..ff360fb0 100644
--- a/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt
+++ b/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt
@@ -7,6 +7,8 @@ import android.content.Intent
 import android.content.IntentFilter
 import android.net.Uri
 import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
 import android.provider.DocumentsContract
 import android.util.Log
 import android.view.MenuItem
@@ -23,6 +25,12 @@ import java.util.Date
 
 private const val TAG = "SyncSettingsActivity"
 
+// While the screen is visible, "Next sync" is otherwise only refreshed by an explicit event
+// (switch toggle, completed-sync broadcast). Without a periodic tick, a displayed deadline that
+// passes while the user is looking at the screen stays stuck showing the old timestamp instead
+// of flipping to "due now".
+private const val NEXT_SYNC_REFRESH_INTERVAL_MS = 30 * 1000L
+
 internal fun formatSyncStatus(status: SyncStatus?, dateFormat: DateFormat): String {
     if (status == null) return "Last sync: never"
 
@@ -108,6 +116,14 @@ class SyncSettingsActivity : AppCompatActivity() {
         }
     }
 
+    private val nextSyncRefreshHandler = Handler(Looper.getMainLooper())
+    private val nextSyncRefreshRunnable = object : Runnable {
+        override fun run() {
+            updateNextSyncStatus()
+            nextSyncRefreshHandler.postDelayed(this, NEXT_SYNC_REFRESH_INTERVAL_MS)
+        }
+    }
+
     private val openDocumentTree =
         registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
             if (result.resultCode == Activity.RESULT_OK) {
@@ -207,6 +223,7 @@ class SyncSettingsActivity : AppCompatActivity() {
             IntentFilter(AWPreferences.LAST_SYNC_STATUS_CHANGED_ACTION),
             ContextCompat.RECEIVER_NOT_EXPORTED,
         )
+        nextSyncRefreshHandler.postDelayed(nextSyncRefreshRunnable, NEXT_SYNC_REFRESH_INTERVAL_MS)
     }
 
     override fun onResume() {
@@ -216,6 +233,7 @@ class SyncSettingsActivity : AppCompatActivity() {
 
     override fun onStop() {
         unregisterReceiver(syncStatusReceiver)
+        nextSyncRefreshHandler.removeCallbacks(nextSyncRefreshRunnable)
         super.onStop()
     }
 

From 974a2cb919998753989a3307a65f10f6cc5fa8fb Mon Sep 17 00:00:00 2001
From: Bob <timetobuildbob@gmail.com>
Date: Fri, 18 Sep 2026 04:24:20 +0000
Subject: [PATCH 5/5] fix(sync): removeCallbacks before postDelayed in onStart
 to prevent runnable multiplication

If onStart() is called again (activity stops and restarts without being
destroyed), the second postDelayed queues a new runnable while the first
is still pending. Both then reschedule themselves, doubling the refresh
rate on each cycle. Guard with removeCallbacks first so onStart always
has exactly one pending runnable.

Git-Session-Id: 30c6
---
 .../main/java/net/activitywatch/android/SyncSettingsActivity.kt  | 1 +
 1 file changed, 1 insertion(+)

diff --git a/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt b/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt
index ff360fb0..6614e440 100644
--- a/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt
+++ b/mobile/src/main/java/net/activitywatch/android/SyncSettingsActivity.kt
@@ -223,6 +223,7 @@ class SyncSettingsActivity : AppCompatActivity() {
             IntentFilter(AWPreferences.LAST_SYNC_STATUS_CHANGED_ACTION),
             ContextCompat.RECEIVER_NOT_EXPORTED,
         )
+        nextSyncRefreshHandler.removeCallbacks(nextSyncRefreshRunnable)
         nextSyncRefreshHandler.postDelayed(nextSyncRefreshRunnable, NEXT_SYNC_REFRESH_INTERVAL_MS)
     }