Increase RMF update frequency while removing parallel execution (#6128)

Task/Issue URL:
https://app.asana.com/1/137249556945/project/1149059203486286/task/1210364424198509?focus=true

### Description
Increase frequency of RMF worker updates.
Process config on every download.

FeatureFlags:
- `scheduleEveryHour`: schedule 1h frequency (before: every 4h / app
launch)
- `alwaysProcessRemoteConfig`: Allow remote config to be processed on
every download (before: when invalidated or expired)
- `canScheduleOnPrivacyConfigUpdates`: Allow also scheduling after
privacy config downloaded (before: only on app launch or periodic)

### Steps to test this PR

#### Scenario 1: Remote messages shows and hides when feature flag is
enabled/disabled

1. Clear the app's cache.
2. Open the app and verify you see the current production UI.
3. Update RemoteMessagingService with
https://www.jsonblob.com/api/1369932692346560512
4. Update PRIVACY_REMOTE_CONFIG_URL with
https://www.jsonblob.com/api/1370023061872631808
5. install code changes
6. ensure on app launch you might see visual updates applied and RMF, if
not restart the app
7. Now update PRIVACY_REMOTE_CONFIG_URL with
https://www.jsonblob.com/api/1370374056737693696
8. install code changes
6. ensure on app launch you don't see visual updates applied and no RMF,
if not restart the app
10. Verify that you don't see the visual design nor the message anymore.

### UI changes
| Before  | After |
| ------ | ----- |
!(Upload before screenshot)|(Upload after screenshot)|

Author: cmonfortep

remote-messaging/remote-messaging-impl/build.gradle

@@ -69,6 +69,7 @@ dependencies {
     implementation AndroidX.lifecycle.viewModelKtx
 
     testImplementation project(path: ':common-test')
+    testImplementation project(path: ':feature-toggles-test')
     testImplementation Testing.junit4
     testImplementation "org.mockito.kotlin:mockito-kotlin:_"
     testImplementation CashApp.turbine

remote-messaging/remote-messaging-impl/src/main/java/com/duckduckgo/remote/messaging/impl/RemoteMessagingConfigDownloadScheduler.kt

@@ -18,14 +18,17 @@ package com.duckduckgo.remote.messaging.impl
 
 import android.content.Context
 import androidx.lifecycle.LifecycleOwner
-import androidx.work.*
+import androidx.work.BackoffPolicy
+import androidx.work.CoroutineWorker
+import androidx.work.ExistingPeriodicWorkPolicy.CANCEL_AND_REENQUEUE
+import androidx.work.PeriodicWorkRequestBuilder
+import androidx.work.WorkManager
+import androidx.work.WorkerParameters
 import com.duckduckgo.anvil.annotations.ContributesWorker
 import com.duckduckgo.app.di.AppCoroutineScope
 import com.duckduckgo.app.lifecycle.MainProcessLifecycleObserver
 import com.duckduckgo.common.utils.DispatcherProvider
 import com.duckduckgo.di.scopes.AppScope
-import com.duckduckgo.privacy.config.api.PrivacyConfigCallbackPlugin
-import com.duckduckgo.remote.messaging.store.RemoteMessagingConfigRepository
 import com.squareup.anvil.annotations.ContributesMultibinding
 import java.util.concurrent.TimeUnit
 import javax.inject.Inject
@@ -34,6 +37,8 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import timber.log.Timber
 
+const val REMOTE_MESSAGING_DOWNLOADER_WORKER_TAG = "REMOTE_MESSAGING_DOWNLOADER_WORKER_TAG"
+
 @ContributesWorker(AppScope::class)
 class RemoteMessagingConfigDownloadWorker(
     context: Context,
@@ -61,44 +66,30 @@ class RemoteMessagingConfigDownloadWorker(
     scope = AppScope::class,
     boundType = MainProcessLifecycleObserver::class,
 )
-
-@ContributesMultibinding(
-    AppScope::class,
-    boundType = PrivacyConfigCallbackPlugin::class,
-)
 class RemoteMessagingConfigDownloadScheduler @Inject constructor(
     private val workManager: WorkManager,
-    private val downloader: RemoteMessagingConfigDownloader,
     @AppCoroutineScope private val appCoroutineScope: CoroutineScope,
     private val dispatcherProvider: DispatcherProvider,
-    private val remoteMessagingConfigRepository: RemoteMessagingConfigRepository,
     private val remoteMessagingFeatureToggles: RemoteMessagingFeatureToggles,
-) : MainProcessLifecycleObserver, PrivacyConfigCallbackPlugin {
+) : MainProcessLifecycleObserver {
 
     override fun onCreate(owner: LifecycleOwner) {
-        scheduleDownload()
-    }
-
-    override fun onPrivacyConfigDownloaded() {
-        if (remoteMessagingFeatureToggles.invalidateRMFAfterPrivacyConfigDownloaded().isEnabled()) {
-            appCoroutineScope.launch(context = dispatcherProvider.io()) {
-                Timber.d("RMF: onPrivacyConfigDownloaded, invalidating and re-downloading")
-                remoteMessagingConfigRepository.invalidate()
-                downloader.download()
-            }
+        appCoroutineScope.launch(dispatcherProvider.io()) {
+            scheduleDownload()
         }
     }
 
     private fun scheduleDownload() {
-        Timber.v("RMF: Scheduling remote config worker")
-        val workerRequest = PeriodicWorkRequestBuilder<RemoteMessagingConfigDownloadWorker>(4, TimeUnit.HOURS)
+        val refreshInterval = if (remoteMessagingFeatureToggles.scheduleEveryHour().isEnabled()) 1L else 4L
+        Timber.v("RMF: Scheduling remote config worker with fresh interval of $refreshInterval hours")
+        val requestBuilder = PeriodicWorkRequestBuilder<RemoteMessagingConfigDownloadWorker>(refreshInterval, TimeUnit.HOURS)
             .addTag(REMOTE_MESSAGING_DOWNLOADER_WORKER_TAG)
             .setBackoffCriteria(BackoffPolicy.LINEAR, 10, TimeUnit.MINUTES)
-            .build()
-        workManager.enqueueUniquePeriodicWork(REMOTE_MESSAGING_DOWNLOADER_WORKER_TAG, ExistingPeriodicWorkPolicy.REPLACE, workerRequest)
-    }
-
-    companion object {
-        private const val REMOTE_MESSAGING_DOWNLOADER_WORKER_TAG = "REMOTE_MESSAGING_DOWNLOADER_WORKER_TAG"
+        if (remoteMessagingFeatureToggles.canScheduleOnPrivacyConfigUpdates().isEnabled()) {
+            Timber.v("RMF: Add delay to remote config worker")
+            requestBuilder.setInitialDelay(5L, TimeUnit.MINUTES)
+        }
+        val workerRequest = requestBuilder.build()
+        workManager.enqueueUniquePeriodicWork(REMOTE_MESSAGING_DOWNLOADER_WORKER_TAG, CANCEL_AND_REENQUEUE, workerRequest)
     }
 }

remote-messaging/remote-messaging-impl/src/main/java/com/duckduckgo/remote/messaging/impl/RemoteMessagingConfigProcessor.kt

@@ -34,18 +34,24 @@ class RealRemoteMessagingConfigProcessor(
     private val remoteMessagingConfigRepository: RemoteMessagingConfigRepository,
     private val remoteMessagingRepository: RemoteMessagingRepository,
     private val remoteMessagingConfigMatcher: RemoteMessagingConfigMatcher,
+    private val remoteMessagingFeatureToggles: RemoteMessagingFeatureToggles,
 ) : RemoteMessagingConfigProcessor {
 
     override suspend fun process(jsonRemoteMessagingConfig: JsonRemoteMessagingConfig) {
         Timber.v("RMF: process ${jsonRemoteMessagingConfig.version}")
-        val currentConfig = remoteMessagingConfigRepository.get()
-        val currentVersion = currentConfig.version
-        val newVersion = jsonRemoteMessagingConfig.version
 
-        val isNewVersion = currentVersion != newVersion
-        val shouldProcess = currentConfig.invalidated() || currentConfig.expired()
+        val shouldProcess = if (remoteMessagingFeatureToggles.alwaysProcessRemoteConfig().isEnabled()) {
+            true
+        } else {
+            val currentConfig = remoteMessagingConfigRepository.get()
+            val currentVersion = currentConfig.version
+            val newVersion = jsonRemoteMessagingConfig.version
+
+            val isNewVersion = currentVersion != newVersion
+            isNewVersion || currentConfig.invalidated() || currentConfig.expired()
+        }
 
-        if (isNewVersion || shouldProcess) {
+        if (shouldProcess) {
             val config = remoteMessagingConfigJsonMapper.map(jsonRemoteMessagingConfig)
             val message = remoteMessagingConfigMatcher.evaluate(config)
             remoteMessagingConfigRepository.insert(RemoteMessagingConfig(version = jsonRemoteMessagingConfig.version))

remote-messaging/remote-messaging-impl/src/main/java/com/duckduckgo/remote/messaging/impl/RemoteMessagingFeatureToggles.kt

@@ -30,6 +30,15 @@ interface RemoteMessagingFeatureToggles {
     @Toggle.DefaultValue(DefaultFeatureValue.TRUE)
     fun self(): Toggle
 
-    @Toggle.DefaultValue(DefaultFeatureValue.TRUE)
+    @Toggle.DefaultValue(DefaultFeatureValue.FALSE)
     fun invalidateRMFAfterPrivacyConfigDownloaded(): Toggle
+
+    @Toggle.DefaultValue(DefaultFeatureValue.TRUE)
+    fun alwaysProcessRemoteConfig(): Toggle
+
+    @Toggle.DefaultValue(DefaultFeatureValue.TRUE)
+    fun scheduleEveryHour(): Toggle
+
+    @Toggle.DefaultValue(DefaultFeatureValue.TRUE)
+    fun canScheduleOnPrivacyConfigUpdates(): Toggle
 }

remote-messaging/remote-messaging-impl/src/main/java/com/duckduckgo/remote/messaging/impl/RemoteMessagingPrivacyConfigObserver.kt

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2025 DuckDuckGo
+ *
+ * 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 com.duckduckgo.remote.messaging.impl
+
+import androidx.work.BackoffPolicy
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.PeriodicWorkRequestBuilder
+import androidx.work.WorkManager
+import com.duckduckgo.app.di.AppCoroutineScope
+import com.duckduckgo.common.utils.DispatcherProvider
+import com.duckduckgo.di.scopes.AppScope
+import com.duckduckgo.privacy.config.api.PrivacyConfigCallbackPlugin
+import com.duckduckgo.remote.messaging.store.RemoteMessagingConfigRepository
+import com.squareup.anvil.annotations.ContributesMultibinding
+import java.util.concurrent.TimeUnit
+import javax.inject.Inject
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import timber.log.Timber
+
+@ContributesMultibinding(
+    AppScope::class,
+    boundType = PrivacyConfigCallbackPlugin::class,
+)
+class RemoteMessagingPrivacyConfigObserver @Inject constructor(
+    @AppCoroutineScope private val appCoroutineScope: CoroutineScope,
+    private val dispatcherProvider: DispatcherProvider,
+    private val remoteMessagingConfigRepository: RemoteMessagingConfigRepository,
+    private val remoteMessagingFeatureToggles: RemoteMessagingFeatureToggles,
+    private val workManager: WorkManager,
+) : PrivacyConfigCallbackPlugin {
+
+    override fun onPrivacyConfigDownloaded() {
+        appCoroutineScope.launch(context = dispatcherProvider.io()) {
+            val invalidateConfig = remoteMessagingFeatureToggles.invalidateRMFAfterPrivacyConfigDownloaded().isEnabled()
+            val alwaysProcess = remoteMessagingFeatureToggles.alwaysProcessRemoteConfig().isEnabled()
+            // we only need to invalidate, so we process config next run, if alwaysProcess is not enabled
+            val shouldInvalidate = invalidateConfig && alwaysProcess.not()
+
+            if (shouldInvalidate) {
+                Timber.d("RMF: onPrivacyConfigDownloaded, invalidate so next run we process the config")
+                remoteMessagingConfigRepository.invalidate()
+            }
+            scheduleDownload()
+        }
+    }
+
+    private fun scheduleDownload() {
+        if (remoteMessagingFeatureToggles.canScheduleOnPrivacyConfigUpdates().isEnabled()) {
+            val refreshInterval = if (remoteMessagingFeatureToggles.scheduleEveryHour().isEnabled()) 1L else 4L
+
+            Timber.v("RMF: Scheduling remote config worker with fresh interval of $refreshInterval hours")
+            val workerRequest = PeriodicWorkRequestBuilder<RemoteMessagingConfigDownloadWorker>(refreshInterval, TimeUnit.HOURS)
+                .addTag(REMOTE_MESSAGING_DOWNLOADER_WORKER_TAG)
+                .setBackoffCriteria(BackoffPolicy.LINEAR, 10, TimeUnit.MINUTES)
+                .build()
+            workManager.enqueueUniquePeriodicWork(
+                REMOTE_MESSAGING_DOWNLOADER_WORKER_TAG,
+                ExistingPeriodicWorkPolicy.CANCEL_AND_REENQUEUE,
+                workerRequest,
+            )
+        }
+    }
+}

remote-messaging/remote-messaging-impl/src/main/java/com/duckduckgo/remote/messaging/impl/di/RemoteMessagingModule.kt

@@ -72,12 +72,14 @@ object DataSourceModule {
         remoteMessagingConfigRepository: RemoteMessagingConfigRepository,
         remoteMessagingRepository: RemoteMessagingRepository,
         remoteMessagingConfigMatcher: RemoteMessagingConfigMatcher,
+        remoteMessagingFeatureToggles: RemoteMessagingFeatureToggles,
     ): RemoteMessagingConfigProcessor {
         return RealRemoteMessagingConfigProcessor(
             remoteMessagingConfigJsonMapper,
             remoteMessagingConfigRepository,
             remoteMessagingRepository,
             remoteMessagingConfigMatcher,
+            remoteMessagingFeatureToggles,
         )
     }
 

remote-messaging/remote-messaging-impl/src/test/java/com/duckduckgo/remote/messaging/impl/RealRemoteMessagingConfigProcessorTest.kt

@@ -16,8 +16,11 @@
 
 package com.duckduckgo.remote.messaging.impl
 
+import android.annotation.SuppressLint
 import com.duckduckgo.appbuildconfig.api.AppBuildConfig
 import com.duckduckgo.common.test.CoroutineTestRule
+import com.duckduckgo.feature.toggles.api.FakeFeatureToggleFactory
+import com.duckduckgo.feature.toggles.api.Toggle.State
 import com.duckduckgo.remote.messaging.api.RemoteMessagingRepository
 import com.duckduckgo.remote.messaging.fixtures.JsonRemoteMessageOM.aJsonRemoteMessagingConfig
 import com.duckduckgo.remote.messaging.fixtures.RemoteMessagingConfigOM.aRemoteMessagingConfig
@@ -39,6 +42,7 @@ import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
 
+@SuppressLint("DenyListedApi")
 class RealRemoteMessagingConfigProcessorTest {
 
     @get:Rule var coroutineRule = CoroutineTestRule()
@@ -53,12 +57,16 @@ class RealRemoteMessagingConfigProcessorTest {
     private val remoteMessagingRepository = mock<RemoteMessagingRepository>()
     private val remoteMessagingCohortStore = mock<RemoteMessagingCohortStore>()
     private val remoteMessagingConfigMatcher = RemoteMessagingConfigMatcher(setOf(mock(), mock(), mock()), mock(), remoteMessagingCohortStore)
+    private var remoteMessagingFeatureToggles: RemoteMessagingFeatureToggles = FakeFeatureToggleFactory.create(
+        RemoteMessagingFeatureToggles::class.java,
+    )
 
     private val testee = RealRemoteMessagingConfigProcessor(
         remoteMessagingConfigJsonMapper,
         remoteMessagingConfigRepository,
         remoteMessagingRepository,
         remoteMessagingConfigMatcher,
+        remoteMessagingFeatureToggles,
     )
 
     @Before
@@ -78,7 +86,8 @@ class RealRemoteMessagingConfigProcessorTest {
     }
 
     @Test
-    fun whenSameVersionThenDoNothing() = runTest {
+    fun whenSameVersionThenDoNothingIfAlwaysProcessFFDisabled() = runTest {
+        remoteMessagingFeatureToggles.alwaysProcessRemoteConfig().setRawStoredState(State(false))
         val dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss")
         whenever(remoteMessagingConfigRepository.get()).thenReturn(
             aRemoteMessagingConfig(
@@ -92,6 +101,22 @@ class RealRemoteMessagingConfigProcessorTest {
         verify(remoteMessagingConfigRepository, times(0)).insert(any())
     }
 
+    @Test
+    fun whenSameVersionThenProcessIfAlwaysProcessFFEnabled() = runTest {
+        remoteMessagingFeatureToggles.alwaysProcessRemoteConfig().setRawStoredState(State(true))
+        val dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss")
+        whenever(remoteMessagingConfigRepository.get()).thenReturn(
+            aRemoteMessagingConfig(
+                version = 1L,
+                evaluationTimestamp = dateTimeFormatter.format(LocalDateTime.now()),
+            ),
+        )
+
+        testee.process(aJsonRemoteMessagingConfig(version = 1L))
+
+        verify(remoteMessagingConfigRepository).insert(any())
+    }
+
     @Test
     fun whenSameVersionButExpiredThenEvaluate() = runTest {
         val dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss")