From d261dd705d51928141fd07da0ee38c0ccd59083d Mon Sep 17 00:00:00 2001
From: Andrew Aylett <andrew@aylett.co.uk>
Date: Sun, 31 Jan 2021 18:13:53 +0000
Subject: [PATCH 01/16] Periodic sync to re-kick-off rapid sync

---
 .../matrix/android/sdk/api/session/Session.kt |  5 ++--
 .../sdk/internal/di/WorkManagerProvider.kt    | 10 +++++++
 .../sdk/internal/session/DefaultSession.kt    |  4 +--
 .../internal/session/sync/job/SyncWorker.kt   | 29 ++++++++++++++++---
 .../app/fdroid/BackgroundSyncStarter.kt       |  1 +
 .../java/im/vector/app/push/fcm/FcmHelper.kt  |  7 ++++-
 .../features/call/webrtc/WebRtcCallManager.kt |  2 +-
 7 files changed, 47 insertions(+), 11 deletions(-)

diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/Session.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/Session.kt
index d4bfd4ee8c..74b3876177 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/Session.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/Session.kt
@@ -121,10 +121,9 @@ interface Session :
 
     /**
      * Launches infinite periodic background syncs
-     * This does not work in doze mode :/
-     * If battery optimization is on it can work in app standby but that's all :/
+     * Doze mode will probably interrupt rapid sync, but it should start up again the next time we run a periodic sync
      */
-    fun startAutomaticBackgroundSync(timeOutInSeconds: Long, repeatDelayInSeconds: Long)
+    fun startAutomaticBackgroundSync(timeOutInSeconds: Long, rapidSync: Boolean, repeatDelayInSeconds: Long)
 
     fun stopAnyBackgroundSync()
 
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/di/WorkManagerProvider.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/di/WorkManagerProvider.kt
index bafffdf852..2fef48e17b 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/di/WorkManagerProvider.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/di/WorkManagerProvider.kt
@@ -50,6 +50,16 @@ internal class WorkManagerProvider @Inject constructor(
             PeriodicWorkRequestBuilder<W>(repeatInterval, repeatIntervalTimeUnit)
                     .addTag(tag)
 
+    /**
+     * Create a PeriodicWorkRequestBuilder, with the Matrix SDK tag
+     */
+    inline fun <reified W : ListenableWorker> matrixPeriodicWorkRequestBuilder(repeatInterval: Long,
+                                                                               repeatIntervalTimeUnit: TimeUnit,
+                                                                               flexTimeInterval: Long,
+                                                                               flexTimeIntervalUnit: TimeUnit) =
+            PeriodicWorkRequestBuilder<W>(repeatInterval, repeatIntervalTimeUnit, flexTimeInterval, flexTimeIntervalUnit)
+                    .addTag(tag)
+
     /**
      * Cancel all works instantiated by the Matrix SDK for the current session, and not those from the SDK client, or for other sessions
      */
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt
index c52462612a..8b89ee04cc 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt
@@ -184,8 +184,8 @@ internal class DefaultSession @Inject constructor(
         SyncWorker.requireBackgroundSync(workManagerProvider, sessionId)
     }
 
-    override fun startAutomaticBackgroundSync(timeOutInSeconds: Long, repeatDelayInSeconds: Long) {
-        SyncWorker.automaticallyBackgroundSync(workManagerProvider, sessionId, timeOutInSeconds, repeatDelayInSeconds)
+    override fun startAutomaticBackgroundSync(timeOutInSeconds: Long, rapidSync: Boolean, repeatDelayInSeconds: Long) {
+        SyncWorker.automaticallyPeriodicBackgroundSync(workManagerProvider, sessionId, timeOutInSeconds, rapidSync, repeatDelayInSeconds)
     }
 
     override fun stopAnyBackgroundSync() {
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncWorker.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncWorker.kt
index b81804feb5..bcc9f4d995 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncWorker.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncWorker.kt
@@ -17,7 +17,9 @@ package org.matrix.android.sdk.internal.session.sync.job
 
 import android.content.Context
 import androidx.work.BackoffPolicy
+import androidx.work.ExistingPeriodicWorkPolicy
 import androidx.work.ExistingWorkPolicy
+import androidx.work.WorkRequest
 import androidx.work.WorkerParameters
 import com.squareup.moshi.JsonClass
 import org.matrix.android.sdk.api.failure.isTokenError
@@ -73,7 +75,7 @@ internal class SyncWorker(context: Context,
                     Result.success().also {
                         if (params.periodic) {
                             // we want to schedule another one after delay
-                            automaticallyBackgroundSync(workManagerProvider, params.sessionId, params.timeout, params.delay)
+                            automaticallyRapidBackgroundSync(workManagerProvider, params.sessionId, params.timeout, params.delay)
                         }
                     }
                 },
@@ -101,6 +103,8 @@ internal class SyncWorker(context: Context,
 
     companion object {
         private const val BG_SYNC_WORK_NAME = "BG_SYNCP"
+        private const val BG_RAPID_SYNC_WORK_NAME = "BG_RAPID_SYNCP"
+        private const val BG_PERIODIC_SYNC_WORK_NAME = "BG_PERIODIC_SYNCP"
 
         fun requireBackgroundSync(workManagerProvider: WorkManagerProvider, sessionId: String, serverTimeout: Long = 0) {
             val data = WorkerParamsFactory.toData(Params(sessionId, serverTimeout, 0L, false))
@@ -109,11 +113,12 @@ internal class SyncWorker(context: Context,
                     .setBackoffCriteria(BackoffPolicy.LINEAR, WorkManagerProvider.BACKOFF_DELAY_MILLIS, TimeUnit.MILLISECONDS)
                     .setInputData(data)
                     .build()
+            // If we've already scheduled a sync that's not yet run, defer to the existing one
             workManagerProvider.workManager
-                    .enqueueUniqueWork(BG_SYNC_WORK_NAME, ExistingWorkPolicy.APPEND_OR_REPLACE, workRequest)
+                    .enqueueUniqueWork(BG_SYNC_WORK_NAME, ExistingWorkPolicy.KEEP, workRequest)
         }
 
-        fun automaticallyBackgroundSync(workManagerProvider: WorkManagerProvider, sessionId: String, serverTimeout: Long = 0, delayInSeconds: Long = 30) {
+        fun automaticallyRapidBackgroundSync(workManagerProvider: WorkManagerProvider, sessionId: String, serverTimeout: Long = 0, delayInSeconds: Long = 30) {
             val data = WorkerParamsFactory.toData(Params(sessionId, serverTimeout, delayInSeconds, true))
             val workRequest = workManagerProvider.matrixOneTimeWorkRequestBuilder<SyncWorker>()
                     .setConstraints(WorkManagerProvider.workConstraints)
@@ -121,14 +126,30 @@ internal class SyncWorker(context: Context,
                     .setBackoffCriteria(BackoffPolicy.LINEAR, WorkManagerProvider.BACKOFF_DELAY_MILLIS, TimeUnit.MILLISECONDS)
                     .setInitialDelay(delayInSeconds, TimeUnit.SECONDS)
                     .build()
+            // Avoid risking multiple chains of syncs by replacing the existing chain
+            workManagerProvider.workManager
+                    .enqueueUniqueWork(BG_RAPID_SYNC_WORK_NAME, ExistingWorkPolicy.REPLACE, workRequest)
+        }
+
+        fun automaticallyPeriodicBackgroundSync(workManagerProvider: WorkManagerProvider, sessionId: String, serverTimeout: Long = 0, restartRapidSync: Boolean = true, delayInSeconds: Long = 30) {
+            val data = WorkerParamsFactory.toData(Params(sessionId, serverTimeout, delayInSeconds, restartRapidSync))
+            val workRequest = workManagerProvider.matrixPeriodicWorkRequestBuilder<SyncWorker>(1, TimeUnit.HOURS, 15, TimeUnit.MINUTES)
+                    .setConstraints(WorkManagerProvider.workConstraints)
+                    .setInputData(data)
+                    .setBackoffCriteria(BackoffPolicy.LINEAR, WorkRequest.MIN_BACKOFF_MILLIS, TimeUnit.MILLISECONDS)
+                    .build()
 
             workManagerProvider.workManager
-                    .enqueueUniqueWork(BG_SYNC_WORK_NAME, ExistingWorkPolicy.APPEND_OR_REPLACE, workRequest)
+                    .enqueueUniquePeriodicWork(BG_PERIODIC_SYNC_WORK_NAME, ExistingPeriodicWorkPolicy.KEEP, workRequest)
         }
 
         fun stopAnyBackgroundSync(workManagerProvider: WorkManagerProvider) {
             workManagerProvider.workManager
                     .cancelUniqueWork(BG_SYNC_WORK_NAME)
+            workManagerProvider.workManager
+                    .cancelUniqueWork(BG_RAPID_SYNC_WORK_NAME)
+            workManagerProvider.workManager
+                    .cancelUniqueWork(BG_PERIODIC_SYNC_WORK_NAME)
         }
     }
 }
diff --git a/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt b/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt
index 7221e2b065..46762f8be7 100644
--- a/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt
+++ b/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt
@@ -34,6 +34,7 @@ object BackgroundSyncStarter {
                     Timber.i("## Sync: Work scheduled to periodically sync in ${vectorPreferences.backgroundSyncDelay()}s")
                     activeSession.startAutomaticBackgroundSync(
                             vectorPreferences.backgroundSyncTimeOut().toLong(),
+                            true,
                             vectorPreferences.backgroundSyncDelay().toLong()
                     )
                 }
diff --git a/vector/src/gplay/java/im/vector/app/push/fcm/FcmHelper.kt b/vector/src/gplay/java/im/vector/app/push/fcm/FcmHelper.kt
index fe091ffda3..d4f2b0dd57 100755
--- a/vector/src/gplay/java/im/vector/app/push/fcm/FcmHelper.kt
+++ b/vector/src/gplay/java/im/vector/app/push/fcm/FcmHelper.kt
@@ -108,6 +108,11 @@ object FcmHelper {
 
     @Suppress("UNUSED_PARAMETER")
     fun onEnterBackground(context: Context, vectorPreferences: VectorPreferences, activeSessionHolder: ActiveSessionHolder) {
-        // TODO FCM fallback
+        val activeSession = activeSessionHolder.getSafeActiveSession() ?: return
+        activeSession.startAutomaticBackgroundSync(
+                vectorPreferences.backgroundSyncTimeOut().toLong(),
+                false,
+                vectorPreferences.backgroundSyncDelay().toLong()
+        )
     }
 }
diff --git a/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCallManager.kt b/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCallManager.kt
index 9e620174f3..828dbc21e3 100644
--- a/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCallManager.kt
+++ b/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCallManager.kt
@@ -373,7 +373,7 @@ class WebRtcCallManager @Inject constructor(
         if (isInBackground) {
             if (FcmHelper.isPushSupported()) {
                 // only for push version as fdroid version is already doing it?
-                currentSession?.startAutomaticBackgroundSync(30, 0)
+                currentSession?.startAutomaticBackgroundSync(30, true, 0)
             } else {
                 // Maybe increase sync freq? but how to set back to default values?
             }

From e14fb16db2f193e8cb53899cc698bfc45a5a04f9 Mon Sep 17 00:00:00 2001
From: Marcel Langner <langner.marcel@myiq.de>
Date: Fri, 13 Aug 2021 12:29:11 +0200
Subject: [PATCH 02/16] initial commit of a permanent GuardService for fdroid
 background syncing

---
 .../util/BackgroundDetectionObserver.kt       |   2 +-
 vector/src/fdroid/AndroidManifest.xml         |   7 +
 .../app/fdroid/BackgroundSyncStarter.kt       |  22 ++-
 .../vector/app/fdroid/service/GuardService.kt | 156 ++++++++++++++++++
 4 files changed, 184 insertions(+), 3 deletions(-)
 create mode 100644 vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt

diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/util/BackgroundDetectionObserver.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/util/BackgroundDetectionObserver.kt
index 7cc00d023f..a12587ac56 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/util/BackgroundDetectionObserver.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/util/BackgroundDetectionObserver.kt
@@ -29,7 +29,7 @@ import javax.inject.Inject
 @MatrixScope
 internal class BackgroundDetectionObserver @Inject constructor() : LifecycleObserver {
 
-    var isInBackground: Boolean = false
+    var isInBackground: Boolean = true
         private set
 
     private
diff --git a/vector/src/fdroid/AndroidManifest.xml b/vector/src/fdroid/AndroidManifest.xml
index 3a7c107138..022b08f16d 100644
--- a/vector/src/fdroid/AndroidManifest.xml
+++ b/vector/src/fdroid/AndroidManifest.xml
@@ -1,9 +1,11 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
     package="im.vector.app">
 
     <uses-permission android:name="android.permission.WAKE_LOCK" />
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <!--
     Required for long polling account synchronisation in background.
     If not present ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS intent action won't work
@@ -24,6 +26,11 @@
             android:enabled="true"
             android:exported="false" />
 
+        <service
+            android:name=".fdroid.service.GuardService"
+            android:exported="false"
+            tools:ignore="Instantiatable" />
+
     </application>
 
 </manifest>
\ No newline at end of file
diff --git a/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt b/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt
index 46762f8be7..1e2ed58a17 100644
--- a/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt
+++ b/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt
@@ -19,17 +19,35 @@ package im.vector.app.fdroid
 import android.content.Context
 import im.vector.app.core.di.ActiveSessionHolder
 import im.vector.app.fdroid.receiver.AlarmSyncBroadcastReceiver
+import im.vector.app.fdroid.service.GuardService
 import im.vector.app.features.settings.BackgroundSyncMode
 import im.vector.app.features.settings.VectorPreferences
 import timber.log.Timber
+import android.content.Intent
+import androidx.core.content.ContextCompat
+import org.matrix.android.sdk.internal.session.sync.job.SyncService
 
 object BackgroundSyncStarter {
     fun start(context: Context, vectorPreferences: VectorPreferences, activeSessionHolder: ActiveSessionHolder) {
         if (vectorPreferences.areNotificationEnabledForDevice()) {
             val activeSession = activeSessionHolder.getSafeActiveSession() ?: return
 
+            val intent = Intent(context, GuardService::class.java)
+            if (vectorPreferences.getFdroidSyncBackgroundMode() == BackgroundSyncMode.FDROID_BACKGROUND_SYNC_MODE_FOR_REALTIME) {
+                intent.putExtra(SyncService.EXTRA_SESSION_ID, activeSession.sessionId)
+            } else {
+                intent.putExtra(SyncService.EXTRA_SESSION_ID, "") // this assures the GuardService runs, but will not start VectorSyncService
+            }
+            intent.putExtra(SyncService.EXTRA_DELAY_SECONDS, vectorPreferences.backgroundSyncDelay())
+            try {
+                Timber.i("## Sync: starting GuardService")
+                ContextCompat.startForegroundService(context, intent)
+            } catch (ex: Throwable) {
+                Timber.e("## Sync: ERROR starting GuardService")
+            }
+
             when (vectorPreferences.getFdroidSyncBackgroundMode()) {
-                BackgroundSyncMode.FDROID_BACKGROUND_SYNC_MODE_FOR_BATTERY -> {
+                BackgroundSyncMode.FDROID_BACKGROUND_SYNC_MODE_FOR_BATTERY  -> {
                     // we rely on periodic worker
                     Timber.i("## Sync: Work scheduled to periodically sync in ${vectorPreferences.backgroundSyncDelay()}s")
                     activeSession.startAutomaticBackgroundSync(
@@ -43,7 +61,7 @@ object BackgroundSyncStarter {
                     AlarmSyncBroadcastReceiver.scheduleAlarm(context, activeSession.sessionId, vectorPreferences.backgroundSyncDelay())
                     Timber.i("## Sync: Alarm scheduled to start syncing")
                 }
-                BackgroundSyncMode.FDROID_BACKGROUND_SYNC_MODE_DISABLED -> {
+                BackgroundSyncMode.FDROID_BACKGROUND_SYNC_MODE_DISABLED     -> {
                     // we do nothing
                     Timber.i("## Sync: background sync is disabled")
                 }
diff --git a/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt b/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
new file mode 100644
index 0000000000..6fa2f1f357
--- /dev/null
+++ b/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2021 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package im.vector.app.fdroid.service
+
+import android.app.Service
+import android.content.Intent
+import android.os.IBinder
+import androidx.core.content.getSystemService
+import timber.log.Timber
+import im.vector.app.R
+import im.vector.app.core.extensions.vectorComponent
+import im.vector.app.features.notifications.NotificationUtils
+import java.util.Timer
+import java.util.TimerTask
+import im.vector.app.core.services.VectorSyncService
+import androidx.core.content.ContextCompat
+import org.matrix.android.sdk.internal.session.sync.job.SyncService
+import android.app.AlarmManager
+import android.os.Build
+import android.app.PendingIntent
+import im.vector.app.features.settings.BackgroundSyncMode
+
+/**
+ */
+class GuardService : Service() {
+
+    private var timer = Timer()
+    private var sessionId: String? = null
+    private var running: Boolean = false
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        Timber.i("## Sync: onStartCommand GuardService running:$running")
+        if (running) {
+            if (intent != null) {
+                val liveLine = intent.getBooleanExtra(EXTRA_LIFELINE, false)
+                if (liveLine) {//called from lifeLine?
+                    scheduleLifeLine()
+                    return START_STICKY
+                }
+            }
+        }
+        try {
+            timer.cancel()
+        } catch (ex: Exception) {
+        }
+        val notificationSubtitleRes = R.string.notification_listening_for_events
+        val notification = notificationUtils.buildForegroundServiceNotification(notificationSubtitleRes, false)
+        startForeground(NotificationUtils.NOTIFICATION_ID_FOREGROUND_SERVICE + 1, notification)
+        try {
+            val sharedPref = getSharedPreferences(PREF_NAME_SESSION_ID, 0)
+            var delayInSeconds = BackgroundSyncMode.DEFAULT_SYNC_DELAY_SECONDS
+            if (intent != null) {
+                sessionId = intent.getStringExtra(SyncService.EXTRA_SESSION_ID)
+                delayInSeconds = intent.getIntExtra(SyncService.EXTRA_DELAY_SECONDS, BackgroundSyncMode.DEFAULT_SYNC_DELAY_SECONDS)
+                val liveLine = intent.getBooleanExtra(EXTRA_LIFELINE, false)
+                if (liveLine) {
+                    Timber.i("## Sync: GuardService restarted by liveLine")
+                }
+                if (sessionId.isNullOrEmpty()) {
+                    Timber.i("## Sync: GuardService getting sessionId from sharedPreferences")
+                    sessionId = sharedPref.getString(PREF_NAME_SESSION_ID, null)
+                } else {
+                    Timber.i("## Sync: GuardService saving sessionId to sharedPreferences")
+                    val editor = sharedPref.edit()
+                    editor.putString(PREF_NAME_SESSION_ID, sessionId)
+                    editor.apply()
+                }
+            } else {
+                Timber.i("## Sync: GuardService intent is null in GuardService, getting sessionId from sharedPreferences")
+                sessionId = sharedPref.getString(PREF_NAME_SESSION_ID, null)
+            }
+            timer = Timer()
+            timer.scheduleAtFixedRate(object : TimerTask() {
+                override fun run() {
+                    if (sessionId.isNullOrEmpty()) {
+                        Timber.i("## Sync: timer still alive GuardService sessionId:nullOrEmpty")
+                    } else {
+                        Timber.i("## Sync: timer still alive GuardService sessionId:${sessionId}")
+                        try {
+                            val syncIntent = Intent(applicationContext, VectorSyncService::class.java)
+                            syncIntent.putExtra(SyncService.EXTRA_SESSION_ID, sessionId)
+                            syncIntent.putExtra(SyncService.EXTRA_PERIODIC, true)
+                            ContextCompat.startForegroundService(applicationContext, syncIntent)
+                        } catch (ex: Throwable) {
+                        }
+                    }
+                }
+            }, delayInSeconds * 1000L, delayInSeconds * 1000L)
+        } catch (ex: Exception) {
+            Timber.e("## Sync: error in GuardService when creating timer")
+        }
+        if (!running) {
+            scheduleLifeLine()
+        }
+        running = true
+        return START_STICKY
+    }
+
+    private lateinit var notificationUtils: NotificationUtils
+
+    override fun onCreate() {
+        Timber.i("## Sync: onCreate GuardService")
+        super.onCreate()
+        notificationUtils = vectorComponent().notificationUtils()
+    }
+
+    override fun onDestroy() {
+        Timber.i("## Sync: onDestroy GuardService")
+        try {
+            timer.cancel()
+        } catch (ex: Exception) {
+        }
+        super.onDestroy()
+    }
+
+    override fun onBind(intent: Intent?): IBinder? {
+        return null
+    }
+
+    private fun scheduleLifeLine() {
+        Timber.d("## Sync: GuardService scheduleLifeLine")
+        val intent = Intent(applicationContext, GuardService::class.java)
+        intent.putExtra(EXTRA_LIFELINE, true)
+
+        val pendingIntent = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            PendingIntent.getForegroundService(this, 0, intent, 0)
+        } else {
+            PendingIntent.getService(this, 0, intent, 0)
+        }
+        val firstMillis = System.currentTimeMillis() + 60 * 1000L
+        val alarmMgr = getSystemService<AlarmManager>()!!
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            alarmMgr.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, firstMillis, pendingIntent)
+        } else {
+            alarmMgr.set(AlarmManager.RTC_WAKEUP, firstMillis, pendingIntent)
+        }
+    }
+
+    companion object {
+        const val PREF_NAME_SESSION_ID = "GuardServiceLastActiveSessionId"
+        const val EXTRA_LIFELINE = "GuardServiceLifeLine"
+    }
+}

From 97b4fd69b4b52153ada5802cb37458f03a4bd30a Mon Sep 17 00:00:00 2001
From: Marcel Langner <langner.marcel@myiq.de>
Date: Mon, 16 Aug 2021 17:40:38 +0200
Subject: [PATCH 03/16] fixed typo

---
 .../java/im/vector/app/fdroid/service/GuardService.kt  | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt b/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
index 6fa2f1f357..f6d29c75da 100644
--- a/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
+++ b/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
@@ -45,8 +45,8 @@ class GuardService : Service() {
         Timber.i("## Sync: onStartCommand GuardService running:$running")
         if (running) {
             if (intent != null) {
-                val liveLine = intent.getBooleanExtra(EXTRA_LIFELINE, false)
-                if (liveLine) {//called from lifeLine?
+                val lifeLine = intent.getBooleanExtra(EXTRA_LIFELINE, false)
+                if (lifeLine) {//called from lifeLine?
                     scheduleLifeLine()
                     return START_STICKY
                 }
@@ -65,9 +65,9 @@ class GuardService : Service() {
             if (intent != null) {
                 sessionId = intent.getStringExtra(SyncService.EXTRA_SESSION_ID)
                 delayInSeconds = intent.getIntExtra(SyncService.EXTRA_DELAY_SECONDS, BackgroundSyncMode.DEFAULT_SYNC_DELAY_SECONDS)
-                val liveLine = intent.getBooleanExtra(EXTRA_LIFELINE, false)
-                if (liveLine) {
-                    Timber.i("## Sync: GuardService restarted by liveLine")
+                val lifeLine = intent.getBooleanExtra(EXTRA_LIFELINE, false)
+                if (lifeLine) {
+                    Timber.i("## Sync: GuardService restarted by lifeLine")
                 }
                 if (sessionId.isNullOrEmpty()) {
                     Timber.i("## Sync: GuardService getting sessionId from sharedPreferences")

From c6b942cd316decdf8863ff5b79394622a8ef2a73 Mon Sep 17 00:00:00 2001
From: Marcel Langner <langner.marcel@myiq.de>
Date: Mon, 16 Aug 2021 19:29:40 +0200
Subject: [PATCH 04/16] fixed ktlint complaining and errors in italian
 translation file

---
 .../fdroid/java/im/vector/app/fdroid/service/GuardService.kt | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt b/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
index f6d29c75da..16f8331586 100644
--- a/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
+++ b/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
@@ -46,7 +46,8 @@ class GuardService : Service() {
         if (running) {
             if (intent != null) {
                 val lifeLine = intent.getBooleanExtra(EXTRA_LIFELINE, false)
-                if (lifeLine) {//called from lifeLine?
+                if (lifeLine) {
+                    // called from lifeLine?
                     scheduleLifeLine()
                     return START_STICKY
                 }
@@ -88,7 +89,7 @@ class GuardService : Service() {
                     if (sessionId.isNullOrEmpty()) {
                         Timber.i("## Sync: timer still alive GuardService sessionId:nullOrEmpty")
                     } else {
-                        Timber.i("## Sync: timer still alive GuardService sessionId:${sessionId}")
+                        Timber.i("## Sync: timer still alive GuardService sessionId:$sessionId")
                         try {
                             val syncIntent = Intent(applicationContext, VectorSyncService::class.java)
                             syncIntent.putExtra(SyncService.EXTRA_SESSION_ID, sessionId)

From 71b27bfd5d310648b6fe2f2f237c4c80ac686b9e Mon Sep 17 00:00:00 2001
From: Adam Brown <adampsbrown@gmail.com>
Date: Thu, 21 Oct 2021 19:14:33 +0100
Subject: [PATCH 05/16] making the guard service a noop, lifeline scheduling
 will be brought back if we confirm the service by itself is not enough

- reuses the sync foreground notification for the guard foreground service
---
 .../java/im/vector/app/di/FlavorModule.kt     |  40 +++++
 .../app/fdroid/BackgroundSyncStarter.kt       |  15 --
 .../service/FDroidGuardServiceStarter.kt      |  49 +++++++
 .../vector/app/fdroid/service/GuardService.kt | 138 ++----------------
 .../java/im/vector/app/di/FlavorModule.kt     |  37 +++++
 .../java/im/vector/app/VectorApplication.kt   |   3 +
 .../im/vector/app/core/di/SingletonModule.kt  |   1 +
 .../app/core/services/GuardServiceStarter.kt  |  22 +++
 ...rSettingsNotificationPreferenceFragment.kt |  13 +-
 9 files changed, 178 insertions(+), 140 deletions(-)
 create mode 100644 vector/src/fdroid/java/im/vector/app/di/FlavorModule.kt
 create mode 100644 vector/src/fdroid/java/im/vector/app/fdroid/service/FDroidGuardServiceStarter.kt
 create mode 100644 vector/src/gplay/java/im/vector/app/di/FlavorModule.kt
 create mode 100644 vector/src/main/java/im/vector/app/core/services/GuardServiceStarter.kt

diff --git a/vector/src/fdroid/java/im/vector/app/di/FlavorModule.kt b/vector/src/fdroid/java/im/vector/app/di/FlavorModule.kt
new file mode 100644
index 0000000000..39b5c4a976
--- /dev/null
+++ b/vector/src/fdroid/java/im/vector/app/di/FlavorModule.kt
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2021 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.app.di
+
+import android.content.Context
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import im.vector.app.core.services.GuardServiceStarter
+import im.vector.app.fdroid.service.FDroidGuardServiceStarter
+import im.vector.app.features.settings.VectorPreferences
+
+@Module
+@InstallIn(SingletonComponent::class)
+abstract class FlavorModule {
+
+    companion object {
+
+        @Provides
+        @JvmStatic
+        fun provideGuardServiceStarter(preferences: VectorPreferences, appContext: Context): GuardServiceStarter {
+            return FDroidGuardServiceStarter(preferences, appContext)
+        }
+    }
+}
diff --git a/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt b/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt
index 1e2ed58a17..f952fe6abe 100644
--- a/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt
+++ b/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt
@@ -31,21 +31,6 @@ object BackgroundSyncStarter {
     fun start(context: Context, vectorPreferences: VectorPreferences, activeSessionHolder: ActiveSessionHolder) {
         if (vectorPreferences.areNotificationEnabledForDevice()) {
             val activeSession = activeSessionHolder.getSafeActiveSession() ?: return
-
-            val intent = Intent(context, GuardService::class.java)
-            if (vectorPreferences.getFdroidSyncBackgroundMode() == BackgroundSyncMode.FDROID_BACKGROUND_SYNC_MODE_FOR_REALTIME) {
-                intent.putExtra(SyncService.EXTRA_SESSION_ID, activeSession.sessionId)
-            } else {
-                intent.putExtra(SyncService.EXTRA_SESSION_ID, "") // this assures the GuardService runs, but will not start VectorSyncService
-            }
-            intent.putExtra(SyncService.EXTRA_DELAY_SECONDS, vectorPreferences.backgroundSyncDelay())
-            try {
-                Timber.i("## Sync: starting GuardService")
-                ContextCompat.startForegroundService(context, intent)
-            } catch (ex: Throwable) {
-                Timber.e("## Sync: ERROR starting GuardService")
-            }
-
             when (vectorPreferences.getFdroidSyncBackgroundMode()) {
                 BackgroundSyncMode.FDROID_BACKGROUND_SYNC_MODE_FOR_BATTERY  -> {
                     // we rely on periodic worker
diff --git a/vector/src/fdroid/java/im/vector/app/fdroid/service/FDroidGuardServiceStarter.kt b/vector/src/fdroid/java/im/vector/app/fdroid/service/FDroidGuardServiceStarter.kt
new file mode 100644
index 0000000000..7a1c4dbe0b
--- /dev/null
+++ b/vector/src/fdroid/java/im/vector/app/fdroid/service/FDroidGuardServiceStarter.kt
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2021 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.app.fdroid.service
+
+import android.content.Context
+import android.content.Intent
+import androidx.core.content.ContextCompat
+import im.vector.app.core.services.GuardServiceStarter
+import im.vector.app.features.settings.VectorPreferences
+import timber.log.Timber
+import javax.inject.Inject
+
+class FDroidGuardServiceStarter @Inject constructor(
+        private val preferences: VectorPreferences,
+        private val appContext: Context
+) : GuardServiceStarter {
+
+    override fun start() {
+        if (preferences.isBackgroundSyncEnabled()) {
+            try {
+                Timber.i("## Sync: starting GuardService")
+                val intent = Intent(appContext, GuardService::class.java)
+                ContextCompat.startForegroundService(appContext, intent)
+            } catch (ex: Throwable) {
+                Timber.e("## Sync: ERROR starting GuardService")
+            }
+        }
+    }
+
+    override fun stop() {
+        val intent = Intent(appContext, GuardService::class.java)
+        appContext.stopService(intent)
+    }
+}
+
diff --git a/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt b/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
index 16f8331586..631efdbc51 100644
--- a/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
+++ b/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
@@ -18,140 +18,34 @@ package im.vector.app.fdroid.service
 import android.app.Service
 import android.content.Intent
 import android.os.IBinder
-import androidx.core.content.getSystemService
-import timber.log.Timber
+import dagger.hilt.android.AndroidEntryPoint
 import im.vector.app.R
-import im.vector.app.core.extensions.vectorComponent
 import im.vector.app.features.notifications.NotificationUtils
-import java.util.Timer
-import java.util.TimerTask
-import im.vector.app.core.services.VectorSyncService
-import androidx.core.content.ContextCompat
-import org.matrix.android.sdk.internal.session.sync.job.SyncService
-import android.app.AlarmManager
-import android.os.Build
-import android.app.PendingIntent
-import im.vector.app.features.settings.BackgroundSyncMode
+import timber.log.Timber
+import javax.inject.Inject
 
 /**
+ * This no-op foreground service acts as a deterrent for the system
+ * to avoid eagerly killing the app process.
+ * Keeping the app process alive avoids some OEMs ignoring scheduled WorkManager and AlarmManager tasks
+ * when the app is not in the foreground.
  */
+@AndroidEntryPoint
 class GuardService : Service() {
 
-    private var timer = Timer()
-    private var sessionId: String? = null
-    private var running: Boolean = false
+    @Inject lateinit var notificationUtils: NotificationUtils
 
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        Timber.i("## Sync: onStartCommand GuardService running:$running")
-        if (running) {
-            if (intent != null) {
-                val lifeLine = intent.getBooleanExtra(EXTRA_LIFELINE, false)
-                if (lifeLine) {
-                    // called from lifeLine?
-                    scheduleLifeLine()
-                    return START_STICKY
-                }
-            }
-        }
-        try {
-            timer.cancel()
-        } catch (ex: Exception) {
-        }
-        val notificationSubtitleRes = R.string.notification_listening_for_events
-        val notification = notificationUtils.buildForegroundServiceNotification(notificationSubtitleRes, false)
-        startForeground(NotificationUtils.NOTIFICATION_ID_FOREGROUND_SERVICE + 1, notification)
-        try {
-            val sharedPref = getSharedPreferences(PREF_NAME_SESSION_ID, 0)
-            var delayInSeconds = BackgroundSyncMode.DEFAULT_SYNC_DELAY_SECONDS
-            if (intent != null) {
-                sessionId = intent.getStringExtra(SyncService.EXTRA_SESSION_ID)
-                delayInSeconds = intent.getIntExtra(SyncService.EXTRA_DELAY_SECONDS, BackgroundSyncMode.DEFAULT_SYNC_DELAY_SECONDS)
-                val lifeLine = intent.getBooleanExtra(EXTRA_LIFELINE, false)
-                if (lifeLine) {
-                    Timber.i("## Sync: GuardService restarted by lifeLine")
-                }
-                if (sessionId.isNullOrEmpty()) {
-                    Timber.i("## Sync: GuardService getting sessionId from sharedPreferences")
-                    sessionId = sharedPref.getString(PREF_NAME_SESSION_ID, null)
-                } else {
-                    Timber.i("## Sync: GuardService saving sessionId to sharedPreferences")
-                    val editor = sharedPref.edit()
-                    editor.putString(PREF_NAME_SESSION_ID, sessionId)
-                    editor.apply()
-                }
-            } else {
-                Timber.i("## Sync: GuardService intent is null in GuardService, getting sessionId from sharedPreferences")
-                sessionId = sharedPref.getString(PREF_NAME_SESSION_ID, null)
-            }
-            timer = Timer()
-            timer.scheduleAtFixedRate(object : TimerTask() {
-                override fun run() {
-                    if (sessionId.isNullOrEmpty()) {
-                        Timber.i("## Sync: timer still alive GuardService sessionId:nullOrEmpty")
-                    } else {
-                        Timber.i("## Sync: timer still alive GuardService sessionId:$sessionId")
-                        try {
-                            val syncIntent = Intent(applicationContext, VectorSyncService::class.java)
-                            syncIntent.putExtra(SyncService.EXTRA_SESSION_ID, sessionId)
-                            syncIntent.putExtra(SyncService.EXTRA_PERIODIC, true)
-                            ContextCompat.startForegroundService(applicationContext, syncIntent)
-                        } catch (ex: Throwable) {
-                        }
-                    }
-                }
-            }, delayInSeconds * 1000L, delayInSeconds * 1000L)
-        } catch (ex: Exception) {
-            Timber.e("## Sync: error in GuardService when creating timer")
-        }
-        if (!running) {
-            scheduleLifeLine()
-        }
-        running = true
-        return START_STICKY
-    }
-
-    private lateinit var notificationUtils: NotificationUtils
+    override fun onBind(intent: Intent?): IBinder? = null
 
     override fun onCreate() {
-        Timber.i("## Sync: onCreate GuardService")
         super.onCreate()
-        notificationUtils = vectorComponent().notificationUtils()
+        Timber.i("## Sync: onCreate GuardService")
     }
 
-    override fun onDestroy() {
-        Timber.i("## Sync: onDestroy GuardService")
-        try {
-            timer.cancel()
-        } catch (ex: Exception) {
-        }
-        super.onDestroy()
-    }
-
-    override fun onBind(intent: Intent?): IBinder? {
-        return null
-    }
-
-    private fun scheduleLifeLine() {
-        Timber.d("## Sync: GuardService scheduleLifeLine")
-        val intent = Intent(applicationContext, GuardService::class.java)
-        intent.putExtra(EXTRA_LIFELINE, true)
-
-        val pendingIntent = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            PendingIntent.getForegroundService(this, 0, intent, 0)
-        } else {
-            PendingIntent.getService(this, 0, intent, 0)
-        }
-        val firstMillis = System.currentTimeMillis() + 60 * 1000L
-        val alarmMgr = getSystemService<AlarmManager>()!!
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            alarmMgr.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, firstMillis, pendingIntent)
-        } else {
-            alarmMgr.set(AlarmManager.RTC_WAKEUP, firstMillis, pendingIntent)
-        }
-    }
-
-    companion object {
-        const val PREF_NAME_SESSION_ID = "GuardServiceLastActiveSessionId"
-        const val EXTRA_LIFELINE = "GuardServiceLifeLine"
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        val notificationSubtitleRes = R.string.notification_listening_for_events
+        val notification = notificationUtils.buildForegroundServiceNotification(notificationSubtitleRes, false)
+        startForeground(NotificationUtils.NOTIFICATION_ID_FOREGROUND_SERVICE, notification)
+        return START_STICKY
     }
 }
diff --git a/vector/src/gplay/java/im/vector/app/di/FlavorModule.kt b/vector/src/gplay/java/im/vector/app/di/FlavorModule.kt
new file mode 100644
index 0000000000..61fd476c87
--- /dev/null
+++ b/vector/src/gplay/java/im/vector/app/di/FlavorModule.kt
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2021 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.app.di
+
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import im.vector.app.core.services.GuardServiceStarter
+
+@InstallIn(SingletonComponent::class)
+@Module
+abstract class FlavorModule {
+
+    companion object {
+
+        @Provides
+        @JvmStatic
+        fun provideGuardServiceStarter(): GuardServiceStarter {
+            return object : GuardServiceStarter {}
+        }
+    }
+}
diff --git a/vector/src/main/java/im/vector/app/VectorApplication.kt b/vector/src/main/java/im/vector/app/VectorApplication.kt
index d9027231da..9b3db9d4cf 100644
--- a/vector/src/main/java/im/vector/app/VectorApplication.kt
+++ b/vector/src/main/java/im/vector/app/VectorApplication.kt
@@ -44,6 +44,7 @@ import im.vector.app.core.di.ActiveSessionHolder
 import im.vector.app.core.extensions.configureAndStart
 import im.vector.app.core.extensions.startSyncing
 import im.vector.app.core.rx.RxConfig
+import im.vector.app.core.services.GuardServiceStarter
 import im.vector.app.features.call.webrtc.WebRtcCallManager
 import im.vector.app.features.configuration.VectorConfiguration
 import im.vector.app.features.disclaimer.doNotShowDisclaimerDialog
@@ -99,6 +100,7 @@ class VectorApplication :
     @Inject lateinit var callManager: WebRtcCallManager
     @Inject lateinit var invitesAcceptor: InvitesAcceptor
     @Inject lateinit var vectorFileLogger: VectorFileLogger
+    @Inject lateinit var guardServiceStarter: GuardServiceStarter
 
     // font thread handler
     private var fontThreadHandler: Handler? = null
@@ -164,6 +166,7 @@ class VectorApplication :
         if (authenticationService.hasAuthenticatedSessions() && !activeSessionHolder.hasActiveSession()) {
             val lastAuthenticatedSession = authenticationService.getLastAuthenticatedSession()!!
             activeSessionHolder.setActiveSession(lastAuthenticatedSession)
+            guardServiceStarter.start()
             lastAuthenticatedSession.configureAndStart(applicationContext, startSyncing = false)
         }
 
diff --git a/vector/src/main/java/im/vector/app/core/di/SingletonModule.kt b/vector/src/main/java/im/vector/app/core/di/SingletonModule.kt
index e89a060022..b4e0700d5f 100644
--- a/vector/src/main/java/im/vector/app/core/di/SingletonModule.kt
+++ b/vector/src/main/java/im/vector/app/core/di/SingletonModule.kt
@@ -29,6 +29,7 @@ import dagger.hilt.components.SingletonComponent
 import im.vector.app.core.dispatchers.CoroutineDispatchers
 import im.vector.app.core.error.DefaultErrorFormatter
 import im.vector.app.core.error.ErrorFormatter
+import im.vector.app.di.FlavorModule
 import im.vector.app.features.invite.AutoAcceptInvites
 import im.vector.app.features.invite.CompileTimeAutoAcceptInvites
 import im.vector.app.features.navigation.DefaultNavigator
diff --git a/vector/src/main/java/im/vector/app/core/services/GuardServiceStarter.kt b/vector/src/main/java/im/vector/app/core/services/GuardServiceStarter.kt
new file mode 100644
index 0000000000..71c6816cea
--- /dev/null
+++ b/vector/src/main/java/im/vector/app/core/services/GuardServiceStarter.kt
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2021 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.app.core.services
+
+interface GuardServiceStarter {
+    fun start() {}
+    fun stop() {}
+}
diff --git a/vector/src/main/java/im/vector/app/features/settings/notifications/VectorSettingsNotificationPreferenceFragment.kt b/vector/src/main/java/im/vector/app/features/settings/notifications/VectorSettingsNotificationPreferenceFragment.kt
index b014b3d2dc..4199bd1753 100644
--- a/vector/src/main/java/im/vector/app/features/settings/notifications/VectorSettingsNotificationPreferenceFragment.kt
+++ b/vector/src/main/java/im/vector/app/features/settings/notifications/VectorSettingsNotificationPreferenceFragment.kt
@@ -37,6 +37,7 @@ import im.vector.app.core.preference.VectorPreference
 import im.vector.app.core.preference.VectorPreferenceCategory
 import im.vector.app.core.preference.VectorSwitchPreference
 import im.vector.app.core.pushers.PushersManager
+import im.vector.app.core.services.GuardServiceStarter
 import im.vector.app.core.utils.isIgnoringBatteryOptimizations
 import im.vector.app.core.utils.requestDisablingBatteryOptimization
 import im.vector.app.features.notifications.NotificationUtils
@@ -61,7 +62,8 @@ import javax.inject.Inject
 class VectorSettingsNotificationPreferenceFragment @Inject constructor(
         private val pushManager: PushersManager,
         private val activeSessionHolder: ActiveSessionHolder,
-        private val vectorPreferences: VectorPreferences
+        private val vectorPreferences: VectorPreferences,
+        private val guardServiceStarter: GuardServiceStarter
 ) : VectorSettingsBaseFragment(),
         BackgroundSyncModeChooserDialog.InteractionListener {
 
@@ -216,14 +218,19 @@ class VectorSettingsNotificationPreferenceFragment @Inject constructor(
             it.isVisible = !FcmHelper.isPushSupported()
         }
 
+        val backgroundSyncEnabled = vectorPreferences.isBackgroundSyncEnabled()
         findPreference<VectorEditTextPreference>(VectorPreferences.SETTINGS_SET_SYNC_TIMEOUT_PREFERENCE_KEY)?.let {
-            it.isEnabled = vectorPreferences.isBackgroundSyncEnabled()
+            it.isEnabled = backgroundSyncEnabled
             it.summary = secondsToText(vectorPreferences.backgroundSyncTimeOut())
         }
         findPreference<VectorEditTextPreference>(VectorPreferences.SETTINGS_SET_SYNC_DELAY_PREFERENCE_KEY)?.let {
-            it.isEnabled = vectorPreferences.isBackgroundSyncEnabled()
+            it.isEnabled = backgroundSyncEnabled
             it.summary = secondsToText(vectorPreferences.backgroundSyncDelay())
         }
+        when {
+            backgroundSyncEnabled -> guardServiceStarter.start()
+            else                  -> guardServiceStarter.stop()
+        }
     }
 
     /**

From 56d5a38e80d086821855c8d9759c8c6d6fb04136 Mon Sep 17 00:00:00 2001
From: Adam Brown <adampsbrown@gmail.com>
Date: Fri, 22 Oct 2021 10:39:52 +0100
Subject: [PATCH 06/16] reverting parts of the rapid periodic sync,
 unfortunately it suffers from the same issue as the one shot workers - the
 system can ignore them if the application process is in the background

---
 .../matrix/android/sdk/api/session/Session.kt |  7 +++--
 .../sdk/internal/di/WorkManagerProvider.kt    | 10 -------
 .../sdk/internal/session/DefaultSession.kt    |  4 +--
 .../internal/session/sync/job/SyncWorker.kt   | 29 +++----------------
 .../app/fdroid/BackgroundSyncStarter.kt       |  5 ----
 .../java/im/vector/app/push/fcm/FcmHelper.kt  |  1 -
 .../features/call/webrtc/WebRtcCallManager.kt |  2 +-
 7 files changed, 11 insertions(+), 47 deletions(-)

diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/Session.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/Session.kt
index 74b3876177..fb425399d0 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/Session.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/Session.kt
@@ -120,10 +120,11 @@ interface Session :
     fun requireBackgroundSync()
 
     /**
-     * Launches infinite periodic background syncs
-     * Doze mode will probably interrupt rapid sync, but it should start up again the next time we run a periodic sync
+     * Launches infinite self rescheduling background syncs
+     * This does not work in doze mode :/
+     * If battery optimization is on it can work in app standby but that's all :/
      */
-    fun startAutomaticBackgroundSync(timeOutInSeconds: Long, rapidSync: Boolean, repeatDelayInSeconds: Long)
+    fun startAutomaticBackgroundSync(timeOutInSeconds: Long, repeatDelayInSeconds: Long)
 
     fun stopAnyBackgroundSync()
 
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/di/WorkManagerProvider.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/di/WorkManagerProvider.kt
index 2fef48e17b..bafffdf852 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/di/WorkManagerProvider.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/di/WorkManagerProvider.kt
@@ -50,16 +50,6 @@ internal class WorkManagerProvider @Inject constructor(
             PeriodicWorkRequestBuilder<W>(repeatInterval, repeatIntervalTimeUnit)
                     .addTag(tag)
 
-    /**
-     * Create a PeriodicWorkRequestBuilder, with the Matrix SDK tag
-     */
-    inline fun <reified W : ListenableWorker> matrixPeriodicWorkRequestBuilder(repeatInterval: Long,
-                                                                               repeatIntervalTimeUnit: TimeUnit,
-                                                                               flexTimeInterval: Long,
-                                                                               flexTimeIntervalUnit: TimeUnit) =
-            PeriodicWorkRequestBuilder<W>(repeatInterval, repeatIntervalTimeUnit, flexTimeInterval, flexTimeIntervalUnit)
-                    .addTag(tag)
-
     /**
      * Cancel all works instantiated by the Matrix SDK for the current session, and not those from the SDK client, or for other sessions
      */
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt
index 8b89ee04cc..c52462612a 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt
@@ -184,8 +184,8 @@ internal class DefaultSession @Inject constructor(
         SyncWorker.requireBackgroundSync(workManagerProvider, sessionId)
     }
 
-    override fun startAutomaticBackgroundSync(timeOutInSeconds: Long, rapidSync: Boolean, repeatDelayInSeconds: Long) {
-        SyncWorker.automaticallyPeriodicBackgroundSync(workManagerProvider, sessionId, timeOutInSeconds, rapidSync, repeatDelayInSeconds)
+    override fun startAutomaticBackgroundSync(timeOutInSeconds: Long, repeatDelayInSeconds: Long) {
+        SyncWorker.automaticallyBackgroundSync(workManagerProvider, sessionId, timeOutInSeconds, repeatDelayInSeconds)
     }
 
     override fun stopAnyBackgroundSync() {
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncWorker.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncWorker.kt
index bcc9f4d995..41bb1a44a6 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncWorker.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncWorker.kt
@@ -17,9 +17,7 @@ package org.matrix.android.sdk.internal.session.sync.job
 
 import android.content.Context
 import androidx.work.BackoffPolicy
-import androidx.work.ExistingPeriodicWorkPolicy
 import androidx.work.ExistingWorkPolicy
-import androidx.work.WorkRequest
 import androidx.work.WorkerParameters
 import com.squareup.moshi.JsonClass
 import org.matrix.android.sdk.api.failure.isTokenError
@@ -75,7 +73,7 @@ internal class SyncWorker(context: Context,
                     Result.success().also {
                         if (params.periodic) {
                             // we want to schedule another one after delay
-                            automaticallyRapidBackgroundSync(workManagerProvider, params.sessionId, params.timeout, params.delay)
+                            automaticallyBackgroundSync(workManagerProvider, params.sessionId, params.timeout, params.delay)
                         }
                     }
                 },
@@ -103,8 +101,6 @@ internal class SyncWorker(context: Context,
 
     companion object {
         private const val BG_SYNC_WORK_NAME = "BG_SYNCP"
-        private const val BG_RAPID_SYNC_WORK_NAME = "BG_RAPID_SYNCP"
-        private const val BG_PERIODIC_SYNC_WORK_NAME = "BG_PERIODIC_SYNCP"
 
         fun requireBackgroundSync(workManagerProvider: WorkManagerProvider, sessionId: String, serverTimeout: Long = 0) {
             val data = WorkerParamsFactory.toData(Params(sessionId, serverTimeout, 0L, false))
@@ -113,12 +109,11 @@ internal class SyncWorker(context: Context,
                     .setBackoffCriteria(BackoffPolicy.LINEAR, WorkManagerProvider.BACKOFF_DELAY_MILLIS, TimeUnit.MILLISECONDS)
                     .setInputData(data)
                     .build()
-            // If we've already scheduled a sync that's not yet run, defer to the existing one
             workManagerProvider.workManager
-                    .enqueueUniqueWork(BG_SYNC_WORK_NAME, ExistingWorkPolicy.KEEP, workRequest)
+                    .enqueueUniqueWork(BG_SYNC_WORK_NAME, ExistingWorkPolicy.APPEND_OR_REPLACE, workRequest)
         }
 
-        fun automaticallyRapidBackgroundSync(workManagerProvider: WorkManagerProvider, sessionId: String, serverTimeout: Long = 0, delayInSeconds: Long = 30) {
+        fun automaticallyBackgroundSync(workManagerProvider: WorkManagerProvider, sessionId: String, serverTimeout: Long = 0, delayInSeconds: Long = 30) {
             val data = WorkerParamsFactory.toData(Params(sessionId, serverTimeout, delayInSeconds, true))
             val workRequest = workManagerProvider.matrixOneTimeWorkRequestBuilder<SyncWorker>()
                     .setConstraints(WorkManagerProvider.workConstraints)
@@ -128,28 +123,12 @@ internal class SyncWorker(context: Context,
                     .build()
             // Avoid risking multiple chains of syncs by replacing the existing chain
             workManagerProvider.workManager
-                    .enqueueUniqueWork(BG_RAPID_SYNC_WORK_NAME, ExistingWorkPolicy.REPLACE, workRequest)
-        }
-
-        fun automaticallyPeriodicBackgroundSync(workManagerProvider: WorkManagerProvider, sessionId: String, serverTimeout: Long = 0, restartRapidSync: Boolean = true, delayInSeconds: Long = 30) {
-            val data = WorkerParamsFactory.toData(Params(sessionId, serverTimeout, delayInSeconds, restartRapidSync))
-            val workRequest = workManagerProvider.matrixPeriodicWorkRequestBuilder<SyncWorker>(1, TimeUnit.HOURS, 15, TimeUnit.MINUTES)
-                    .setConstraints(WorkManagerProvider.workConstraints)
-                    .setInputData(data)
-                    .setBackoffCriteria(BackoffPolicy.LINEAR, WorkRequest.MIN_BACKOFF_MILLIS, TimeUnit.MILLISECONDS)
-                    .build()
-
-            workManagerProvider.workManager
-                    .enqueueUniquePeriodicWork(BG_PERIODIC_SYNC_WORK_NAME, ExistingPeriodicWorkPolicy.KEEP, workRequest)
+                    .enqueueUniqueWork(BG_SYNC_WORK_NAME, ExistingWorkPolicy.REPLACE, workRequest)
         }
 
         fun stopAnyBackgroundSync(workManagerProvider: WorkManagerProvider) {
             workManagerProvider.workManager
                     .cancelUniqueWork(BG_SYNC_WORK_NAME)
-            workManagerProvider.workManager
-                    .cancelUniqueWork(BG_RAPID_SYNC_WORK_NAME)
-            workManagerProvider.workManager
-                    .cancelUniqueWork(BG_PERIODIC_SYNC_WORK_NAME)
         }
     }
 }
diff --git a/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt b/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt
index f952fe6abe..0fe89e7fe5 100644
--- a/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt
+++ b/vector/src/fdroid/java/im/vector/app/fdroid/BackgroundSyncStarter.kt
@@ -19,13 +19,9 @@ package im.vector.app.fdroid
 import android.content.Context
 import im.vector.app.core.di.ActiveSessionHolder
 import im.vector.app.fdroid.receiver.AlarmSyncBroadcastReceiver
-import im.vector.app.fdroid.service.GuardService
 import im.vector.app.features.settings.BackgroundSyncMode
 import im.vector.app.features.settings.VectorPreferences
 import timber.log.Timber
-import android.content.Intent
-import androidx.core.content.ContextCompat
-import org.matrix.android.sdk.internal.session.sync.job.SyncService
 
 object BackgroundSyncStarter {
     fun start(context: Context, vectorPreferences: VectorPreferences, activeSessionHolder: ActiveSessionHolder) {
@@ -37,7 +33,6 @@ object BackgroundSyncStarter {
                     Timber.i("## Sync: Work scheduled to periodically sync in ${vectorPreferences.backgroundSyncDelay()}s")
                     activeSession.startAutomaticBackgroundSync(
                             vectorPreferences.backgroundSyncTimeOut().toLong(),
-                            true,
                             vectorPreferences.backgroundSyncDelay().toLong()
                     )
                 }
diff --git a/vector/src/gplay/java/im/vector/app/push/fcm/FcmHelper.kt b/vector/src/gplay/java/im/vector/app/push/fcm/FcmHelper.kt
index d4f2b0dd57..b11e86507d 100755
--- a/vector/src/gplay/java/im/vector/app/push/fcm/FcmHelper.kt
+++ b/vector/src/gplay/java/im/vector/app/push/fcm/FcmHelper.kt
@@ -111,7 +111,6 @@ object FcmHelper {
         val activeSession = activeSessionHolder.getSafeActiveSession() ?: return
         activeSession.startAutomaticBackgroundSync(
                 vectorPreferences.backgroundSyncTimeOut().toLong(),
-                false,
                 vectorPreferences.backgroundSyncDelay().toLong()
         )
     }
diff --git a/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCallManager.kt b/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCallManager.kt
index 828dbc21e3..9e620174f3 100644
--- a/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCallManager.kt
+++ b/vector/src/main/java/im/vector/app/features/call/webrtc/WebRtcCallManager.kt
@@ -373,7 +373,7 @@ class WebRtcCallManager @Inject constructor(
         if (isInBackground) {
             if (FcmHelper.isPushSupported()) {
                 // only for push version as fdroid version is already doing it?
-                currentSession?.startAutomaticBackgroundSync(30, true, 0)
+                currentSession?.startAutomaticBackgroundSync(30, 0)
             } else {
                 // Maybe increase sync freq? but how to set back to default values?
             }

From c14ffefe7cefda427fe3d402abf293ecde83b244 Mon Sep 17 00:00:00 2001
From: Adam Brown <adampsbrown@gmail.com>
Date: Fri, 22 Oct 2021 10:49:36 +0100
Subject: [PATCH 07/16] updating background sync function docs with more
 information

---
 .../java/org/matrix/android/sdk/api/session/Session.kt    | 8 +++++---
 .../java/im/vector/app/fdroid/service/GuardService.kt     | 4 ++--
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/Session.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/Session.kt
index fb425399d0..dfe43aed6f 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/Session.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/Session.kt
@@ -120,9 +120,11 @@ interface Session :
     fun requireBackgroundSync()
 
     /**
-     * Launches infinite self rescheduling background syncs
-     * This does not work in doze mode :/
-     * If battery optimization is on it can work in app standby but that's all :/
+     * Launches infinite self rescheduling background syncs via the WorkManager
+     *
+     * While dozing, syncs will only occur during maintenance windows
+     * For reliability it's recommended to also start a long running foreground service
+     * along with disabling battery optimizations
      */
     fun startAutomaticBackgroundSync(timeOutInSeconds: Long, repeatDelayInSeconds: Long)
 
diff --git a/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt b/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
index 631efdbc51..612f78eb0b 100644
--- a/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
+++ b/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
@@ -25,8 +25,8 @@ import timber.log.Timber
 import javax.inject.Inject
 
 /**
- * This no-op foreground service acts as a deterrent for the system
- * to avoid eagerly killing the app process.
+ * This no-op foreground service acts as a deterrent to the system eagerly killing the app process.
+ *
  * Keeping the app process alive avoids some OEMs ignoring scheduled WorkManager and AlarmManager tasks
  * when the app is not in the foreground.
  */

From ace9f89569c6aeac8b515b7acd4619b0739b9039 Mon Sep 17 00:00:00 2001
From: Adam Brown <adampsbrown@gmail.com>
Date: Fri, 22 Oct 2021 10:58:03 +0100
Subject: [PATCH 08/16] always trigger guard service start when a session is
 activated - fixes missing guard after login

---
 vector/src/main/java/im/vector/app/VectorApplication.kt      | 2 --
 .../main/java/im/vector/app/core/di/ActiveSessionHolder.kt   | 5 ++++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/vector/src/main/java/im/vector/app/VectorApplication.kt b/vector/src/main/java/im/vector/app/VectorApplication.kt
index 9b3db9d4cf..ce0c8166fb 100644
--- a/vector/src/main/java/im/vector/app/VectorApplication.kt
+++ b/vector/src/main/java/im/vector/app/VectorApplication.kt
@@ -44,7 +44,6 @@ import im.vector.app.core.di.ActiveSessionHolder
 import im.vector.app.core.extensions.configureAndStart
 import im.vector.app.core.extensions.startSyncing
 import im.vector.app.core.rx.RxConfig
-import im.vector.app.core.services.GuardServiceStarter
 import im.vector.app.features.call.webrtc.WebRtcCallManager
 import im.vector.app.features.configuration.VectorConfiguration
 import im.vector.app.features.disclaimer.doNotShowDisclaimerDialog
@@ -166,7 +165,6 @@ class VectorApplication :
         if (authenticationService.hasAuthenticatedSessions() && !activeSessionHolder.hasActiveSession()) {
             val lastAuthenticatedSession = authenticationService.getLastAuthenticatedSession()!!
             activeSessionHolder.setActiveSession(lastAuthenticatedSession)
-            guardServiceStarter.start()
             lastAuthenticatedSession.configureAndStart(applicationContext, startSyncing = false)
         }
 
diff --git a/vector/src/main/java/im/vector/app/core/di/ActiveSessionHolder.kt b/vector/src/main/java/im/vector/app/core/di/ActiveSessionHolder.kt
index e739cac95f..6b7b5f7f62 100644
--- a/vector/src/main/java/im/vector/app/core/di/ActiveSessionHolder.kt
+++ b/vector/src/main/java/im/vector/app/core/di/ActiveSessionHolder.kt
@@ -18,6 +18,7 @@ package im.vector.app.core.di
 
 import arrow.core.Option
 import im.vector.app.ActiveSessionDataSource
+import im.vector.app.core.services.GuardServiceStarter
 import im.vector.app.features.call.webrtc.WebRtcCallManager
 import im.vector.app.features.crypto.keysrequest.KeyRequestHandler
 import im.vector.app.features.crypto.verification.IncomingVerificationRequestHandler
@@ -36,7 +37,8 @@ class ActiveSessionHolder @Inject constructor(private val sessionObservableStore
                                               private val callManager: WebRtcCallManager,
                                               private val pushRuleTriggerListener: PushRuleTriggerListener,
                                               private val sessionListener: SessionListener,
-                                              private val imageManager: ImageManager
+                                              private val imageManager: ImageManager,
+                                              private val guardServiceStarter: GuardServiceStarter
 ) {
 
     private var activeSession: AtomicReference<Session?> = AtomicReference()
@@ -52,6 +54,7 @@ class ActiveSessionHolder @Inject constructor(private val sessionObservableStore
         pushRuleTriggerListener.startWithSession(session)
         session.callSignalingService().addCallListener(callManager)
         imageManager.onSessionStarted(session)
+        guardServiceStarter.start()
     }
 
     fun clearActiveSession() {

From b1afc26d650af33aa2700b7b2e6b7a32197b3a98 Mon Sep 17 00:00:00 2001
From: Adam Brown <adampsbrown@gmail.com>
Date: Fri, 22 Oct 2021 12:09:13 +0100
Subject: [PATCH 09/16] using start_redeliver_intent to allow the system to
 restart killed sync services - memory restricted devices may have the sync
 service destroyed whilst in progress causing future sync to no longer be
 scheduled

---
 .../android/sdk/internal/session/sync/job/SyncService.kt     | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncService.kt
index 9480cc73f1..c17b31b910 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncService.kt
@@ -105,9 +105,8 @@ abstract class SyncService : Service() {
                 }
             }
         }
-
-        // It's ok to be not sticky because we will explicitly start it again on the next alarm?
-        return START_NOT_STICKY
+        // Attempt to continue scheduling syncs after killed service is restarted
+        return START_REDELIVER_INTENT
     }
 
     override fun onDestroy() {

From b41875672796e8e9fad7d0f3cb69cf737e05a953 Mon Sep 17 00:00:00 2001
From: Adam Brown <adampsbrown@gmail.com>
Date: Fri, 22 Oct 2021 12:45:31 +0100
Subject: [PATCH 10/16] adding changelog entry

---
 changelog.d/4298.bugfix | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 changelog.d/4298.bugfix

diff --git a/changelog.d/4298.bugfix b/changelog.d/4298.bugfix
new file mode 100644
index 0000000000..4da2ff899b
--- /dev/null
+++ b/changelog.d/4298.bugfix
@@ -0,0 +1 @@
+Fixing missing F-Droid notifications when in background due to background syncs not triggering
\ No newline at end of file

From 006ad103925e6363409852108ff7eded64690320 Mon Sep 17 00:00:00 2001
From: Adam Brown <adampsbrown@gmail.com>
Date: Fri, 22 Oct 2021 12:47:07 +0100
Subject: [PATCH 11/16] removing extra blank line

---
 .../im/vector/app/fdroid/service/FDroidGuardServiceStarter.kt    | 1 -
 1 file changed, 1 deletion(-)

diff --git a/vector/src/fdroid/java/im/vector/app/fdroid/service/FDroidGuardServiceStarter.kt b/vector/src/fdroid/java/im/vector/app/fdroid/service/FDroidGuardServiceStarter.kt
index 7a1c4dbe0b..d421c8bb87 100644
--- a/vector/src/fdroid/java/im/vector/app/fdroid/service/FDroidGuardServiceStarter.kt
+++ b/vector/src/fdroid/java/im/vector/app/fdroid/service/FDroidGuardServiceStarter.kt
@@ -46,4 +46,3 @@ class FDroidGuardServiceStarter @Inject constructor(
         appContext.stopService(intent)
     }
 }
-

From a6eadfe894b20e84a49d7c901b106d0adff697a0 Mon Sep 17 00:00:00 2001
From: Adam Brown <adampsbrown@gmail.com>
Date: Thu, 28 Oct 2021 14:04:10 +0100
Subject: [PATCH 12/16] removing unused starter field

---
 vector/src/main/java/im/vector/app/VectorApplication.kt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/vector/src/main/java/im/vector/app/VectorApplication.kt b/vector/src/main/java/im/vector/app/VectorApplication.kt
index ce0c8166fb..d9027231da 100644
--- a/vector/src/main/java/im/vector/app/VectorApplication.kt
+++ b/vector/src/main/java/im/vector/app/VectorApplication.kt
@@ -99,7 +99,6 @@ class VectorApplication :
     @Inject lateinit var callManager: WebRtcCallManager
     @Inject lateinit var invitesAcceptor: InvitesAcceptor
     @Inject lateinit var vectorFileLogger: VectorFileLogger
-    @Inject lateinit var guardServiceStarter: GuardServiceStarter
 
     // font thread handler
     private var fontThreadHandler: Handler? = null

From c173adb7839e4c2402bd322bef141fd1b225555d Mon Sep 17 00:00:00 2001
From: Adam Brown <adampsbrown@gmail.com>
Date: Thu, 28 Oct 2021 14:06:19 +0100
Subject: [PATCH 13/16] removing google play background task starting, we
 should rely on play services

---
 vector/src/gplay/java/im/vector/app/push/fcm/FcmHelper.kt | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/vector/src/gplay/java/im/vector/app/push/fcm/FcmHelper.kt b/vector/src/gplay/java/im/vector/app/push/fcm/FcmHelper.kt
index b11e86507d..52ad4be087 100755
--- a/vector/src/gplay/java/im/vector/app/push/fcm/FcmHelper.kt
+++ b/vector/src/gplay/java/im/vector/app/push/fcm/FcmHelper.kt
@@ -108,10 +108,6 @@ object FcmHelper {
 
     @Suppress("UNUSED_PARAMETER")
     fun onEnterBackground(context: Context, vectorPreferences: VectorPreferences, activeSessionHolder: ActiveSessionHolder) {
-        val activeSession = activeSessionHolder.getSafeActiveSession() ?: return
-        activeSession.startAutomaticBackgroundSync(
-                vectorPreferences.backgroundSyncTimeOut().toLong(),
-                vectorPreferences.backgroundSyncDelay().toLong()
-        )
+        // No op
     }
 }

From 48678382baed91cea89074bec616a61e5d21189f Mon Sep 17 00:00:00 2001
From: Adam Brown <adampsbrown@gmail.com>
Date: Thu, 28 Oct 2021 14:08:13 +0100
Subject: [PATCH 14/16] adding new copy for the foreground listening
 notification

---
 .../fdroid/java/im/vector/app/fdroid/service/GuardService.kt    | 2 +-
 .../main/java/im/vector/app/core/services/VectorSyncService.kt  | 2 +-
 vector/src/main/res/values/strings.xml                          | 1 +
 3 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt b/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
index 612f78eb0b..324af8272a 100644
--- a/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
+++ b/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
@@ -43,7 +43,7 @@ class GuardService : Service() {
     }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        val notificationSubtitleRes = R.string.notification_listening_for_events
+        val notificationSubtitleRes = R.string.notification_listening_for_notifications
         val notification = notificationUtils.buildForegroundServiceNotification(notificationSubtitleRes, false)
         startForeground(NotificationUtils.NOTIFICATION_ID_FOREGROUND_SERVICE, notification)
         return START_STICKY
diff --git a/vector/src/main/java/im/vector/app/core/services/VectorSyncService.kt b/vector/src/main/java/im/vector/app/core/services/VectorSyncService.kt
index 1fd86cac4d..08db8227a6 100644
--- a/vector/src/main/java/im/vector/app/core/services/VectorSyncService.kt
+++ b/vector/src/main/java/im/vector/app/core/services/VectorSyncService.kt
@@ -83,7 +83,7 @@ class VectorSyncService : SyncService() {
         val notificationSubtitleRes = if (isInitialSync) {
             R.string.notification_initial_sync
         } else {
-            R.string.notification_listening_for_events
+            R.string.notification_listening_for_notifications
         }
         val notification = notificationUtils.buildForegroundServiceNotification(notificationSubtitleRes, false)
         startForeground(NotificationUtils.NOTIFICATION_ID_FOREGROUND_SERVICE, notification)
diff --git a/vector/src/main/res/values/strings.xml b/vector/src/main/res/values/strings.xml
index 0e8197dbae..d345971962 100644
--- a/vector/src/main/res/values/strings.xml
+++ b/vector/src/main/res/values/strings.xml
@@ -322,6 +322,7 @@
     <string name="notification_sync_init">Initializing service</string>
     <string name="notification_sync_in_progress">Synchronising…</string>
     <string name="notification_listening_for_events">Listening for events</string>
+    <string name="notification_listening_for_notifications">Listening for notifications</string>
     <string name="notification_noisy_notifications">Noisy notifications</string>
     <string name="notification_silent_notifications">Silent notifications</string>
 

From 036a81d60ba7aedeea34993273bf4e1b8fe58743 Mon Sep 17 00:00:00 2001
From: Adam Brown <adampsbrown@gmail.com>
Date: Thu, 4 Nov 2021 09:47:16 +0000
Subject: [PATCH 15/16] extending from the vector service to avoid extra
 service boilerplate

---
 .../im/vector/app/fdroid/service/GuardService.kt    | 13 ++-----------
 1 file changed, 2 insertions(+), 11 deletions(-)

diff --git a/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt b/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
index 324af8272a..053cf87c17 100644
--- a/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
+++ b/vector/src/fdroid/java/im/vector/app/fdroid/service/GuardService.kt
@@ -15,13 +15,11 @@
  */
 package im.vector.app.fdroid.service
 
-import android.app.Service
 import android.content.Intent
-import android.os.IBinder
 import dagger.hilt.android.AndroidEntryPoint
 import im.vector.app.R
+import im.vector.app.core.services.VectorService
 import im.vector.app.features.notifications.NotificationUtils
-import timber.log.Timber
 import javax.inject.Inject
 
 /**
@@ -31,17 +29,10 @@ import javax.inject.Inject
  * when the app is not in the foreground.
  */
 @AndroidEntryPoint
-class GuardService : Service() {
+class GuardService : VectorService() {
 
     @Inject lateinit var notificationUtils: NotificationUtils
 
-    override fun onBind(intent: Intent?): IBinder? = null
-
-    override fun onCreate() {
-        super.onCreate()
-        Timber.i("## Sync: onCreate GuardService")
-    }
-
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
         val notificationSubtitleRes = R.string.notification_listening_for_notifications
         val notification = notificationUtils.buildForegroundServiceNotification(notificationSubtitleRes, false)

From 432d4801c96081bd02d1d9ad6b73dc3b91fd9631 Mon Sep 17 00:00:00 2001
From: Adam Brown <adampsbrown@gmail.com>
Date: Thu, 4 Nov 2021 10:12:24 +0000
Subject: [PATCH 16/16] removing unused import

---
 vector/src/main/java/im/vector/app/core/di/SingletonModule.kt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/vector/src/main/java/im/vector/app/core/di/SingletonModule.kt b/vector/src/main/java/im/vector/app/core/di/SingletonModule.kt
index b4e0700d5f..e89a060022 100644
--- a/vector/src/main/java/im/vector/app/core/di/SingletonModule.kt
+++ b/vector/src/main/java/im/vector/app/core/di/SingletonModule.kt
@@ -29,7 +29,6 @@ import dagger.hilt.components.SingletonComponent
 import im.vector.app.core.dispatchers.CoroutineDispatchers
 import im.vector.app.core.error.DefaultErrorFormatter
 import im.vector.app.core.error.ErrorFormatter
-import im.vector.app.di.FlavorModule
 import im.vector.app.features.invite.AutoAcceptInvites
 import im.vector.app.features.invite.CompileTimeAutoAcceptInvites
 import im.vector.app.features.navigation.DefaultNavigator