feat: adding a force new configs flag and logic for timestamp handling / forced configs, fix issue with handling legacy messages

libsession/src/main/java/org/session/libsession/messaging/jobs/ConfigurationSyncJob.kt

@@ -2,14 +2,13 @@ package org.session.libsession.messaging.jobs
 
 import network.loki.messenger.libsession_util.ConfigBase
 import network.loki.messenger.libsession_util.ConfigBase.Companion.protoKindFor
-import nl.komponents.kovenant.functional.bind
 import org.session.libsession.messaging.MessagingModuleConfiguration
 import org.session.libsession.messaging.messages.Destination
 import org.session.libsession.messaging.messages.control.SharedConfigurationMessage
 import org.session.libsession.messaging.sending_receiving.MessageSender
 import org.session.libsession.messaging.utilities.Data
-import org.session.libsession.snode.RawResponse
 import org.session.libsession.snode.SnodeAPI
+import org.session.libsession.utilities.TextSecurePreferences
 import org.session.libsignal.utilities.Log
 import java.util.concurrent.atomic.AtomicBoolean
 
@@ -25,12 +24,14 @@ data class ConfigurationSyncJob(val destination: Destination): Job {
 
     override suspend fun execute(dispatcherName: String) {
         val storage = MessagingModuleConfiguration.shared.storage
+        val forcedConfig = TextSecurePreferences.hasForcedNewConfig(MessagingModuleConfiguration.shared.context)
+        val currentTime = SnodeAPI.nowWithOffset
         val userEdKeyPair = MessagingModuleConfiguration.shared.getUserED25519KeyPair()
         val userPublicKey = storage.getUserPublicKey()
         val delegate = delegate
         if (destination is Destination.ClosedGroup // TODO: closed group configs will be handled in closed group feature
             // if we haven't enabled the new configs don't run
-            || !ConfigBase.isNewConfigEnabled
+            || !ConfigBase.isNewConfigEnabled(forcedConfig, currentTime)
             // if we don't have a user ed key pair for signing updates
             || userEdKeyPair == null
             // this will be useful to not handle null delegate cases

libsession/src/main/java/org/session/libsession/messaging/sending_receiving/ReceivedMessageHandler.kt

@@ -149,8 +149,11 @@ private fun handleConfigurationMessage(message: ConfigurationMessage) {
 
     TextSecurePreferences.setConfigurationMessageSynced(context, true)
     TextSecurePreferences.setLastProfileUpdateTime(context, message.sentTimestamp!!)
-    if (ConfigBase.isNewConfigEnabled) {
+    val isForceSync = TextSecurePreferences.hasForcedNewConfig(context)
+    val currentTime = SnodeAPI.nowWithOffset
+    if (ConfigBase.isNewConfigEnabled(isForceSync, currentTime)) {
         TextSecurePreferences.setHasLegacyConfig(context, true)
+        if (!firstTimeSync) return
     }
     val allClosedGroupPublicKeys = storage.getAllClosedGroupPublicKeys()
     for (closedGroup in message.closedGroups) {

libsession/src/main/java/org/session/libsession/messaging/sending_receiving/pollers/Poller.kt

@@ -151,7 +151,7 @@ class Poller(private val configFactory: ConfigFactoryProtocol, debounceTimer: Ti
                 val (message, _) = MessageReceiver.parse(data = envelope.toByteArray(), openGroupServerID = null)
                 // sanity checks
                 if (message !is SharedConfigurationMessage) {
-                    Log.w("Loki-DBG", "shared config message handled in configs wasn't SharedConfigurationMessage but was ${message.javaClass.simpleName}")
+                    Log.w("Loki", "shared config message handled in configs wasn't SharedConfigurationMessage but was ${message.javaClass.simpleName}")
                     return@forEach
                 }
                 forConfigObject.merge(hash!! to message.data)
@@ -213,11 +213,11 @@ class Poller(private val configFactory: ConfigFactoryProtocol, debounceTimer: Ti
                         if (personalResponseIndex >= 0) {
                             responseList.getOrNull(personalResponseIndex)?.let { rawResponse ->
                                 if (rawResponse["code"] as? Int != 200) {
-                                    Log.e("Loki-DBG", "Batch sub-request for personal messages had non-200 response code, returned code ${(rawResponse["code"] as? Int) ?: "[unknown]"}")
+                                    Log.e("Loki", "Batch sub-request for personal messages had non-200 response code, returned code ${(rawResponse["code"] as? Int) ?: "[unknown]"}")
                                 } else {
                                     val body = rawResponse["body"] as? RawResponse
                                     if (body == null) {
-                                        Log.e("Loki-DBG", "Batch sub-request for personal messages didn't contain a body")
+                                        Log.e("Loki", "Batch sub-request for personal messages didn't contain a body")
                                     } else {
                                         processPersonalMessages(snode, body)
                                     }
@@ -230,12 +230,12 @@ class Poller(private val configFactory: ConfigFactoryProtocol, debounceTimer: Ti
                             requestSparseArray.keyIterator().withIndex().forEach { (requestIndex, key) ->
                                 responseList.getOrNull(requestIndex)?.let { rawResponse ->
                                     if (rawResponse["code"] as? Int != 200) {
-                                        Log.e("Loki-DBG", "Batch sub-request had non-200 response code, returned code ${(rawResponse["code"] as? Int) ?: "[unknown]"}")
+                                        Log.e("Loki", "Batch sub-request had non-200 response code, returned code ${(rawResponse["code"] as? Int) ?: "[unknown]"}")
                                         return@forEach
                                     }
                                     val body = rawResponse["body"] as? RawResponse
                                     if (body == null) {
-                                        Log.e("Loki-DBG", "Batch sub-request didn't contain a body")
+                                        Log.e("Loki", "Batch sub-request didn't contain a body")
                                         return@forEach
                                     }
                                     if (key == Namespace.DEFAULT) {

libsession/src/main/java/org/session/libsession/utilities/TextSecurePreferences.kt

@@ -180,6 +180,8 @@ interface TextSecurePreferences {
     fun setThemeStyle(themeStyle: String)
     fun setFollowSystemSettings(followSystemSettings: Boolean)
     fun autoplayAudioMessages(): Boolean
+    fun setForceNewConfig()
+    fun hasForcedNewConfig(): Boolean
     fun hasPreference(key: String): Boolean
     fun clearAll()
 
@@ -268,6 +270,7 @@ interface TextSecurePreferences {
         const val SELECTED_ACCENT_COLOR = "selected_accent_color"
 
         const val HAS_RECEIVED_LEGACY_CONFIG = "has_received_legacy_config"
+        const val HAS_FORCED_NEW_CONFIG = "has_forced_new_config"
 
         const val GREEN_ACCENT = "accent_green"
         const val BLUE_ACCENT = "accent_blue"
@@ -811,6 +814,16 @@ interface TextSecurePreferences {
             setIntegerPreference(context, NOTIFICATION_MESSAGES_CHANNEL_VERSION, version)
         }
 
+        @JvmStatic
+        fun setForceNewConfig(context: Context) {
+            setBooleanPreference(context, HAS_FORCED_NEW_CONFIG, true)
+        }
+
+        @JvmStatic
+        fun hasForcedNewConfig(context: Context): Boolean {
+            return getBooleanPreference(context, HAS_FORCED_NEW_CONFIG, false)
+        }
+
         @JvmStatic
         fun getBooleanPreference(context: Context, key: String?, defaultValue: Boolean): Boolean {
             return getDefaultSharedPreferences(context).getBoolean(key, defaultValue)
@@ -1447,6 +1460,13 @@ class AppTextSecurePreferences @Inject constructor(
         setIntegerPreference(TextSecurePreferences.NOTIFICATION_MESSAGES_CHANNEL_VERSION, version)
     }
 
+    override fun setForceNewConfig() {
+        setBooleanPreference(TextSecurePreferences.HAS_FORCED_NEW_CONFIG, true)
+    }
+
+    override fun hasForcedNewConfig(): Boolean =
+        getBooleanPreference(TextSecurePreferences.HAS_FORCED_NEW_CONFIG, false)
+
     override fun getBooleanPreference(key: String?, defaultValue: Boolean): Boolean {
         return getDefaultSharedPreferences(context).getBoolean(key, defaultValue)
     }