configuration message

libsession/src/main/java/org/session/libsession/messaging/StorageProtocol.kt

@@ -108,6 +108,8 @@ interface StorageProtocol {
     fun isClosedGroup(publicKey: String): Boolean
     fun getClosedGroupEncryptionKeyPairs(groupPublicKey: String): MutableList<ECKeyPair>
     fun getLatestClosedGroupEncryptionKeyPair(groupPublicKey: String): ECKeyPair?
+    // Groups
+    fun getAllGroups(): List<GroupRecord>
 
     // Settings
     fun setProfileSharing(address: Address, value: Boolean)

libsession/src/main/java/org/session/libsession/messaging/messages/control/ConfigurationMessage.kt

@@ -0,0 +1,105 @@
+package org.session.libsession.messaging.messages.control
+
+import com.google.protobuf.ByteString
+import org.session.libsession.messaging.MessagingConfiguration
+import org.session.libsession.messaging.threads.Address
+import org.session.libsession.utilities.GroupUtil
+import org.session.libsignal.libsignal.ecc.DjbECPrivateKey
+import org.session.libsignal.libsignal.ecc.DjbECPublicKey
+import org.session.libsignal.libsignal.ecc.ECKeyPair
+import org.session.libsignal.service.internal.push.SignalServiceProtos
+import org.session.libsignal.service.loki.utilities.removing05PrefixIfNeeded
+import org.session.libsignal.service.loki.utilities.toHexString
+
+class ConfigurationMessage(val closedGroups: List<ClosedGroup>, val openGroups: List<String>): ControlMessage() {
+
+    class ClosedGroup(val publicKey: String, val name: String, val encryptionKeyPair: ECKeyPair, val members: List<String>, val admins: List<String>) {
+        val isValid: Boolean get() = members.isNotEmpty() && admins.isNotEmpty()
+
+        override fun toString(): String {
+            return name
+        }
+
+        companion object {
+            fun fromProto(proto: SignalServiceProtos.ConfigurationMessage.ClosedGroup): ClosedGroup? {
+                if (!proto.hasPublicKey() || !proto.hasName() || !proto.hasEncryptionKeyPair()) return null
+                val publicKey = proto.publicKey.toByteArray().toHexString()
+                val name = proto.name
+                val encryptionKeyPairAsProto = proto.encryptionKeyPair
+                val encryptionKeyPair = ECKeyPair(DjbECPublicKey(encryptionKeyPairAsProto.publicKey.toByteArray().removing05PrefixIfNeeded()),
+                                                  DjbECPrivateKey(encryptionKeyPairAsProto.privateKey.toByteArray()))
+                val members = proto.membersList.map { it.toByteArray().toHexString() }
+                val admins = proto.adminsList.map { it.toByteArray().toHexString() }
+                return ClosedGroup(publicKey, name, encryptionKeyPair, members, admins)
+            }
+        }
+
+        fun toProto(): SignalServiceProtos.ConfigurationMessage.ClosedGroup? {
+            val result = SignalServiceProtos.ConfigurationMessage.ClosedGroup.newBuilder()
+            result.publicKey = ByteString.copyFrom(publicKey.toByteArray())
+            result.name = name
+            val encryptionKeyPairAsProto = SignalServiceProtos.KeyPair.newBuilder()
+            encryptionKeyPairAsProto.publicKey = ByteString.copyFrom(encryptionKeyPair.publicKey.serialize().removing05PrefixIfNeeded())
+            encryptionKeyPairAsProto.privateKey = ByteString.copyFrom(encryptionKeyPair.privateKey.serialize())
+            result.encryptionKeyPair = encryptionKeyPairAsProto.build()
+            result.addAllMembers(members.map { ByteString.copyFrom(it.toByteArray()) })
+            result.addAllAdmins(admins.map { ByteString.copyFrom(it.toByteArray()) })
+            return result.build()
+        }
+    }
+
+    override val ttl: Long = 4 * 24 * 60 * 60 * 1000
+    override val isSelfSendValid: Boolean = true
+
+    companion object {
+
+        fun getCurrent(): ConfigurationMessage {
+            val closedGroups = mutableListOf<ClosedGroup>()
+            val openGroups = mutableListOf<String>()
+            val storage = MessagingConfiguration.shared.storage
+            val groups = storage.getAllGroups()
+            for (groupRecord in groups) {
+                if (groupRecord.isClosedGroup) {
+                    if (!groupRecord.members.contains(Address.fromSerialized(storage.getUserPublicKey()!!))) continue
+                    val groupPublicKey = GroupUtil.getDecodedGroupID(groupRecord.encodedId) // TODO: Check if this is correct. Does it need to be double decoded?
+                    if (!storage.isClosedGroup(groupPublicKey)) continue
+                    val encryptionKeyPair = storage.getLatestClosedGroupEncryptionKeyPair(groupPublicKey) ?: continue
+                    val closedGroup = ClosedGroup(groupPublicKey, groupRecord.title, encryptionKeyPair, groupRecord.members.map { it.serialize() }, groupRecord.admins.map { it.serialize() })
+                    closedGroups.add(closedGroup)
+                }
+                if (groupRecord.isOpenGroup) {
+                    val threadID = storage.getThreadID(groupRecord.encodedId) ?: continue
+                    val openGroup = storage.getOpenGroup(threadID) ?: continue
+                    openGroups.add(openGroup.server)
+                }
+            }
+            return ConfigurationMessage(closedGroups, openGroups)
+        }
+
+        fun fromProto(proto: SignalServiceProtos.Content): ConfigurationMessage? {
+            if (!proto.hasConfigurationMessage()) return null
+            val configurationProto = proto.configurationMessage
+            val closedGroups = configurationProto.closedGroupsList.mapNotNull { ClosedGroup.fromProto(it) }
+            val openGroups = configurationProto.openGroupsList
+            return ConfigurationMessage(closedGroups, openGroups)
+        }
+    }
+
+    override fun toProto(): SignalServiceProtos.Content? {
+        val configurationProto = SignalServiceProtos.ConfigurationMessage.newBuilder()
+        configurationProto.addAllClosedGroups(closedGroups.mapNotNull { it.toProto() })
+        configurationProto.addAllOpenGroups(openGroups)
+        val contentProto = SignalServiceProtos.Content.newBuilder()
+        contentProto.configurationMessage = configurationProto.build()
+        return contentProto.build()
+    }
+
+    override fun toString(): String {
+        return """ 
+            ConfigurationMessage(
+                closedGroups: ${(closedGroups)}
+                openGroups: ${(openGroups)}
+            )
+        """.trimIndent()
+    }
+}

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

@@ -128,6 +128,29 @@ object TextSecurePreferences {
     private const val FCM_TOKEN = "pref_fcm_token"
     private const val LAST_FCM_TOKEN_UPLOAD_TIME = "pref_last_fcm_token_upload_time_2"
 
+    // region Multi Device
+    private const val IS_USING_MULTI_DEVICE = "pref_is_using_multi_device"
+    private const val LAST_CONFIGURATION_SYNC_TIME = "pref_last_configuration_sync_time"
+
+    @JvmStatic
+    fun isUsingMultiDevice(context: Context): Boolean {
+        return getBooleanPreference(context, IS_USING_MULTI_DEVICE, false)
+    }
+
+    @JvmStatic
+    fun setIsUsingMultiDevice(context: Context, value: Boolean) {
+        setBooleanPreference(context, IS_USING_MULTI_DEVICE, value)
+    }
+
+    @JvmStatic
+    fun getLastConfigurationSyncTime(context: Context): Long {
+        return getLongPreference(context, LAST_CONFIGURATION_SYNC_TIME, 0)
+    }
+
+    @JvmStatic
+    fun setLastConfigurationSyncTime(context: Context, value: Long) {
+        setLongPreference(context, LAST_CONFIGURATION_SYNC_TIME, value)
+    }
 
     @JvmStatic
     fun isUsingFCM(context: Context): Boolean {