feat: add storage with hashes and some basic profile update logic in config factory probably move that somewhere else

app/src/main/java/org/thoughtcrime/securesms/database/ConfigDatabase.kt

@@ -3,6 +3,7 @@ package org.thoughtcrime.securesms.database
 import android.content.Context
 import androidx.core.content.contentValuesOf
 import androidx.core.database.getBlobOrNull
+import androidx.core.database.getStringOrNull
 import org.thoughtcrime.securesms.database.helpers.SQLCipherOpenHelper
 
 class ConfigDatabase(context: Context, helper: SQLCipherOpenHelper): Database(context, helper) {
@@ -21,24 +22,26 @@ class ConfigDatabase(context: Context, helper: SQLCipherOpenHelper): Database(co
         private const val VARIANT_AND_PUBKEY_WHERE = "$VARIANT = ? AND $PUBKEY = ?"
     }
 
-    fun storeConfig(variant: String, publicKey: String, data: ByteArray) {
+    fun storeConfig(variant: String, publicKey: String, data: ByteArray, hashes: List<String>) {
         val db = writableDatabase
         val contentValues = contentValuesOf(
             VARIANT to variant,
             PUBKEY to publicKey,
-            DATA to data
+            DATA to data,
+            COMBINED_MESSAGE_HASHES to hashes.joinToString(",")
         )
         db.insertOrUpdate(TABLE_NAME, contentValues, VARIANT_AND_PUBKEY_WHERE, arrayOf(variant, publicKey))
     }
 
-    fun retrieveConfig(variant: String, publicKey: String): ByteArray? {
+    fun retrieveConfigAndHashes(variant: String, publicKey: String): Pair<ByteArray,List<String>>? {
         val db = readableDatabase
         val query = db.query(TABLE_NAME, arrayOf(DATA), VARIANT_AND_PUBKEY_WHERE, arrayOf(variant, publicKey),null, null, null)
-        val bytes = query?.use { cursor ->
-            if (!cursor.moveToFirst()) return null
-            cursor.getBlobOrNull(cursor.getColumnIndex(DATA))
+        return query?.use { cursor ->
+            if (!cursor.moveToFirst()) return@use null
+            val bytes = cursor.getBlobOrNull(cursor.getColumnIndex(DATA)) ?: return@use null
+            val hashes = cursor.getStringOrNull(cursor.getColumnIndex(COMBINED_MESSAGE_HASHES))?.split(",") ?: emptyList()
+            bytes to hashes
         }
-        return bytes
     }
 
 }

app/src/main/java/org/thoughtcrime/securesms/database/Storage.kt

@@ -7,11 +7,22 @@ import org.session.libsession.database.StorageProtocol
 import org.session.libsession.messaging.BlindedIdMapping
 import org.session.libsession.messaging.calls.CallMessageType
 import org.session.libsession.messaging.contacts.Contact
-import org.session.libsession.messaging.jobs.*
+import org.session.libsession.messaging.jobs.AttachmentUploadJob
+import org.session.libsession.messaging.jobs.GroupAvatarDownloadJob
+import org.session.libsession.messaging.jobs.Job
+import org.session.libsession.messaging.jobs.JobQueue
+import org.session.libsession.messaging.jobs.MessageReceiveJob
+import org.session.libsession.messaging.jobs.MessageSendJob
 import org.session.libsession.messaging.messages.Message
 import org.session.libsession.messaging.messages.control.ConfigurationMessage
 import org.session.libsession.messaging.messages.control.MessageRequestResponse
-import org.session.libsession.messaging.messages.signal.*
+import org.session.libsession.messaging.messages.signal.IncomingEncryptedMessage
+import org.session.libsession.messaging.messages.signal.IncomingGroupMessage
+import org.session.libsession.messaging.messages.signal.IncomingMediaMessage
+import org.session.libsession.messaging.messages.signal.IncomingTextMessage
+import org.session.libsession.messaging.messages.signal.OutgoingGroupMediaMessage
+import org.session.libsession.messaging.messages.signal.OutgoingMediaMessage
+import org.session.libsession.messaging.messages.signal.OutgoingTextMessage
 import org.session.libsession.messaging.messages.visible.Attachment
 import org.session.libsession.messaging.messages.visible.Profile
 import org.session.libsession.messaging.messages.visible.Reaction
@@ -28,7 +39,7 @@ import org.session.libsession.messaging.utilities.SessionId
 import org.session.libsession.messaging.utilities.SodiumUtilities
 import org.session.libsession.messaging.utilities.UpdateMessageData
 import org.session.libsession.snode.OnionRequestAPI
-import org.session.libsession.utilities.*
+import org.session.libsession.utilities.Address
 import org.session.libsession.utilities.Address.Companion.fromSerialized
 import org.session.libsession.utilities.GroupRecord
 import org.session.libsession.utilities.GroupUtil
@@ -70,13 +81,12 @@ class Storage(context: Context, helper: SQLCipherOpenHelper) : Database(context,
         return Profile(displayName, profileKey, profilePictureUrl)
     }
 
-    override fun setUserProfilePictureURL(newValue: String) {
+    override fun setUserProfilePictureURL(newProfilePicture: String?) {
         val ourRecipient = fromSerialized(getUserPublicKey()!!).let {
             Recipient.from(context, it, false)
         }
-        TextSecurePreferences.setProfilePictureURL(context, newValue)
-        RetrieveProfileAvatarJob(ourRecipient, newValue)
-        ApplicationContext.getInstance(context).jobManager.add(RetrieveProfileAvatarJob(ourRecipient, newValue))
+        TextSecurePreferences.setProfilePictureURL(context, newProfilePicture)
+        ApplicationContext.getInstance(context).jobManager.add(RetrieveProfileAvatarJob(ourRecipient, newProfilePicture))
     }
 
     override fun getOrGenerateRegistrationID(): Int {

app/src/main/java/org/thoughtcrime/securesms/dependencies/ConfigFactory.kt

@@ -1,13 +1,26 @@
 package org.thoughtcrime.securesms.dependencies
 
+import android.content.Context
+import network.loki.messenger.libsession_util.ConfigBase
 import network.loki.messenger.libsession_util.Contacts
 import network.loki.messenger.libsession_util.ConversationVolatileConfig
 import network.loki.messenger.libsession_util.UserProfile
+import org.session.libsession.database.StorageProtocol
+import org.session.libsession.utilities.Address
 import org.session.libsession.utilities.ConfigFactoryProtocol
+import org.session.libsession.utilities.ProfileKeyUtil
+import org.session.libsession.utilities.SSKEnvironment
+import org.session.libsession.utilities.TextSecurePreferences
+import org.session.libsession.utilities.recipients.Recipient
 import org.session.libsignal.protos.SignalServiceProtos.SharedConfigMessage
+import org.session.libsignal.utilities.Base64
 import org.thoughtcrime.securesms.database.ConfigDatabase
+import java.util.concurrent.ConcurrentSkipListSet
 
-class ConfigFactory(private val configDatabase: ConfigDatabase, private val maybeGetUserInfo: ()->Pair<ByteArray, String>?):
+class ConfigFactory(private val context: Context,
+                    private val configDatabase: ConfigDatabase,
+                    private val storage: StorageProtocol,
+                    private val maybeGetUserInfo: ()->Pair<ByteArray, String>?):
     ConfigFactoryProtocol {
 
     fun keyPairChanged() { // this should only happen restoring or clearing data
@@ -21,17 +34,23 @@ class ConfigFactory(private val configDatabase: ConfigDatabase, private val mayb
 
     private val userLock = Object()
     private var _userConfig: UserProfile? = null
-    private val contactLock = Object()
+    private val userHashes = ConcurrentSkipListSet<String>()
+    private val contactsLock = Object()
     private var _contacts: Contacts? = null
+    private val contactsHashes = ConcurrentSkipListSet<String>()
     private val convoVolatileLock = Object()
     private var _convoVolatileConfig: ConversationVolatileConfig? = null
+    private val convoHashes = ConcurrentSkipListSet<String>()
 
     override val user: UserProfile? = synchronized(userLock) {
         if (_userConfig == null) {
             val (secretKey, publicKey) = maybeGetUserInfo() ?: return@synchronized null
-            val userDump = configDatabase.retrieveConfig(SharedConfigMessage.Kind.USER_PROFILE.name, publicKey)
+            val userDump = configDatabase.retrieveConfigAndHashes(SharedConfigMessage.Kind.USER_PROFILE.name, publicKey)
             _userConfig = if (userDump != null) {
-                UserProfile.newInstance(secretKey, userDump)
+                val (bytes, hashes) = userDump
+                userHashes.clear()
+                userHashes.addAll(hashes)
+                UserProfile.newInstance(secretKey, bytes)
             } else {
                 UserProfile.newInstance(secretKey)
             }
@@ -39,12 +58,15 @@ class ConfigFactory(private val configDatabase: ConfigDatabase, private val mayb
         _userConfig
     }
 
-    override val contacts: Contacts? = synchronized(contactLock) {
+    override val contacts: Contacts? = synchronized(contactsLock) {
         if (_contacts == null) {
             val (secretKey, publicKey) = maybeGetUserInfo() ?: return@synchronized null
-            val contactsDump = configDatabase.retrieveConfig(SharedConfigMessage.Kind.CONTACTS.name, publicKey)
+            val contactsDump = configDatabase.retrieveConfigAndHashes(SharedConfigMessage.Kind.CONTACTS.name, publicKey)
             _contacts = if (contactsDump != null) {
-                Contacts.newInstance(secretKey, contactsDump)
+                val (bytes, hashes) = contactsDump
+                contactsHashes.clear()
+                contactsHashes.addAll(hashes)
+                Contacts.newInstance(secretKey, bytes)
             } else {
                 Contacts.newInstance(secretKey)
             }
@@ -55,9 +77,12 @@ class ConfigFactory(private val configDatabase: ConfigDatabase, private val mayb
     override val convoVolatile: ConversationVolatileConfig? = synchronized(convoVolatileLock) {
         if (_convoVolatileConfig == null) {
             val (secretKey, publicKey) = maybeGetUserInfo() ?: return@synchronized null
-            val convoDump = configDatabase.retrieveConfig(SharedConfigMessage.Kind.CONVO_INFO_VOLATILE.name, publicKey)
+            val convoDump = configDatabase.retrieveConfigAndHashes(SharedConfigMessage.Kind.CONVO_INFO_VOLATILE.name, publicKey)
             _convoVolatileConfig = if (convoDump != null) {
-                ConversationVolatileConfig.newInstance(secretKey, convoDump)
+                val (bytes, hashes) = convoDump
+                convoHashes.clear()
+                convoHashes.addAll(hashes)
+                ConversationVolatileConfig.newInstance(secretKey, bytes)
             } else {
                 ConversationVolatileConfig.newInstance(secretKey)
             }
@@ -66,21 +91,84 @@ class ConfigFactory(private val configDatabase: ConfigDatabase, private val mayb
     }
 
 
-    override fun saveUserConfigDump() {
+    private fun persistUserConfigDump() = synchronized(userLock) {
         val dumped = user?.dump() ?: return
         val (_, publicKey) = maybeGetUserInfo() ?: return
-        configDatabase.storeConfig(SharedConfigMessage.Kind.USER_PROFILE.name, publicKey, dumped)
+        configDatabase.storeConfig(SharedConfigMessage.Kind.USER_PROFILE.name, publicKey, dumped, userHashes.toList())
     }
 
-    override fun saveContactConfigDump() {
+    private fun persistContactsConfigDump() = synchronized(contactsLock) {
         val dumped = contacts?.dump() ?: return
         val (_, publicKey) = maybeGetUserInfo() ?: return
-        configDatabase.storeConfig(SharedConfigMessage.Kind.CONTACTS.name, publicKey, dumped)
+        configDatabase.storeConfig(SharedConfigMessage.Kind.CONTACTS.name, publicKey, dumped, contactsHashes.toList())
     }
 
-    override fun saveConvoVolatileConfigDump() {
+    private fun persistConvoVolatileConfigDump() = synchronized (convoVolatileLock) {
         val dumped = convoVolatile?.dump() ?: return
         val (_, publicKey) = maybeGetUserInfo() ?: return
-        configDatabase.storeConfig(SharedConfigMessage.Kind.CONVO_INFO_VOLATILE.name, publicKey, dumped)
+        configDatabase.storeConfig(SharedConfigMessage.Kind.CONVO_INFO_VOLATILE.name, publicKey, dumped, convoHashes.toList())
     }
+
+    override fun persist(forConfigObject: ConfigBase) {
+        when (forConfigObject) {
+            is UserProfile -> persistUserConfigDump()
+            is Contacts -> persistContactsConfigDump()
+            is ConversationVolatileConfig -> persistConvoVolatileConfigDump()
+        }
+    }
+
+    override fun appendHash(configObject: ConfigBase, hash: String) {
+        when (configObject) {
+            is UserProfile -> userHashes.add(hash)
+            is Contacts -> contactsHashes.add(hash)
+            is ConversationVolatileConfig -> convoHashes.add(hash)
+        }
+    }
+
+    override fun notifyUpdates(forConfigObject: ConfigBase) {
+        when (forConfigObject) {
+            is UserProfile -> updateUser(forConfigObject)
+            is Contacts -> updateContacts(forConfigObject)
+            is ConversationVolatileConfig -> updateConvoVolatile(forConfigObject)
+        }
+    }
+
+    private fun updateUser(userProfile: UserProfile) {
+        val (_, userPublicKey) = maybeGetUserInfo() ?: return
+        // would love to get rid of recipient and context from this
+        val recipient = Recipient.from(context, Address.fromSerialized(userPublicKey), false)
+        // update name
+        val name = userProfile.getName() ?: return
+        val userPic = userProfile.getPic()
+        val profileManager = SSKEnvironment.shared.profileManager
+        if (name.isNotEmpty()) {
+            TextSecurePreferences.setProfileName(context, name)
+            profileManager.setName(context, recipient, name)
+        }
+
+        // update pfp
+        if (userPic == null) {
+            // clear picture if userPic is null
+            TextSecurePreferences.setProfileKey(context, null)
+            ProfileKeyUtil.setEncodedProfileKey(context, null)
+            profileManager.setProfileKey(context, recipient, null)
+            storage.setUserProfilePictureURL(null)
+        } else if (userPic.key.isNotEmpty() && userPic.url.isNotEmpty()
+            && TextSecurePreferences.getProfilePictureURL(context) != userPic.url) {
+            val profileKey = Base64.encodeBytes(userPic.key)
+            ProfileKeyUtil.setEncodedProfileKey(context, profileKey)
+            profileManager.setProfileKey(context, recipient, userPic.key)
+            storage.setUserProfilePictureURL(userPic.url)
+        }
+    }
+
+    private fun updateContacts(contacts: Contacts) {
+
+    }
+
+    private fun updateConvoVolatile(convos: ConversationVolatileConfig) {
+
+    }
+
+
 }

app/src/main/java/org/thoughtcrime/securesms/dependencies/SessionUtilModule.kt

@@ -6,6 +6,7 @@ import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
+import org.session.libsession.database.StorageProtocol
 import org.session.libsession.utilities.TextSecurePreferences
 import org.thoughtcrime.securesms.crypto.KeyPairUtilities
 import org.thoughtcrime.securesms.database.ConfigDatabase
@@ -22,8 +23,8 @@ object SessionUtilModule {
 
     @Provides
     @Singleton
-    fun provideConfigFactory(@ApplicationContext context: Context, configDatabase: ConfigDatabase): ConfigFactory =
-        ConfigFactory(configDatabase) {
+    fun provideConfigFactory(@ApplicationContext context: Context, configDatabase: ConfigDatabase, storage: StorageProtocol): ConfigFactory =
+        ConfigFactory(context, configDatabase, storage) {
             val localUserPublicKey = TextSecurePreferences.getLocalNumber(context)
             val secretKey = maybeUserEdSecretKey(context)
             if (localUserPublicKey == null || secretKey == null) null

app/src/main/java/org/thoughtcrime/securesms/sskenvironment/ProfileManager.kt

@@ -54,7 +54,7 @@ class ProfileManager : SSKEnvironment.ProfileManagerProtocol {
         }
     }
 
-    override fun setProfileKey(context: Context, recipient: Recipient, profileKey: ByteArray) {
+    override fun setProfileKey(context: Context, recipient: Recipient, profileKey: ByteArray?) {
         // New API
         val sessionID = recipient.address.serialize()
         val contactDatabase = DatabaseComponent.get(context).sessionContactDatabase()

app/src/main/java/org/thoughtcrime/securesms/util/ConfigurationMessageUtilities.kt

@@ -7,56 +7,69 @@ import network.loki.messenger.libsession_util.util.Contact
 import network.loki.messenger.libsession_util.util.UserPic
 import nl.komponents.kovenant.Promise
 import org.session.libsession.messaging.MessagingModuleConfiguration
+import org.session.libsession.messaging.messages.Destination
 import org.session.libsession.messaging.messages.control.ConfigurationMessage
+import org.session.libsession.messaging.sending_receiving.MessageSender
 import org.session.libsession.utilities.Address
+import org.session.libsession.utilities.TextSecurePreferences
 
 object ConfigurationMessageUtilities {
 
+    const val isNewConfigEnabled = true
+
     @JvmStatic
     fun syncConfigurationIfNeeded(context: Context) {
-        return
-//        val userPublicKey = TextSecurePreferences.getLocalNumber(context) ?: return
-//        val lastSyncTime = TextSecurePreferences.getLastConfigurationSyncTime(context)
-//        val now = System.currentTimeMillis()
-//        if (now - lastSyncTime < 7 * 24 * 60 * 60 * 1000) return
-//        val contacts = ContactUtilities.getAllContacts(context).filter { recipient ->
-//            !recipient.name.isNullOrEmpty() && !recipient.isLocalNumber && recipient.address.serialize().isNotEmpty()
-//        }.map { recipient ->
-//            ConfigurationMessage.Contact(
-//                publicKey = recipient.address.serialize(),
-//                name = recipient.name!!,
-//                profilePicture = recipient.profileAvatar,
-//                profileKey = recipient.profileKey,
-//                isApproved = recipient.isApproved,
-//                isBlocked = recipient.isBlocked,
-//                didApproveMe = recipient.hasApprovedMe()
-//            )
-//        }
-//        val configurationMessage = ConfigurationMessage.getCurrent(contacts) ?: return
-//        MessageSender.send(configurationMessage, Address.fromSerialized(userPublicKey))
-//        TextSecurePreferences.setLastConfigurationSyncTime(context, now)
+        // add if check here to schedule new config job process and return early
+        if (isNewConfigEnabled) {
+            // schedule job if none exist
+            TODO()
+        }
+        val userPublicKey = TextSecurePreferences.getLocalNumber(context) ?: return
+        val lastSyncTime = TextSecurePreferences.getLastConfigurationSyncTime(context)
+        val now = System.currentTimeMillis()
+        if (now - lastSyncTime < 7 * 24 * 60 * 60 * 1000) return
+        val contacts = ContactUtilities.getAllContacts(context).filter { recipient ->
+            !recipient.name.isNullOrEmpty() && !recipient.isLocalNumber && recipient.address.serialize().isNotEmpty()
+        }.map { recipient ->
+            ConfigurationMessage.Contact(
+                publicKey = recipient.address.serialize(),
+                name = recipient.name!!,
+                profilePicture = recipient.profileAvatar,
+                profileKey = recipient.profileKey,
+                isApproved = recipient.isApproved,
+                isBlocked = recipient.isBlocked,
+                didApproveMe = recipient.hasApprovedMe()
+            )
+        }
+        val configurationMessage = ConfigurationMessage.getCurrent(contacts) ?: return
+        MessageSender.send(configurationMessage, Address.fromSerialized(userPublicKey))
+        TextSecurePreferences.setLastConfigurationSyncTime(context, now)
     }
 
     fun forceSyncConfigurationNowIfNeeded(context: Context): Promise<Unit, Exception> {
-        return Promise.ofSuccess(Unit)
-//        val userPublicKey = TextSecurePreferences.getLocalNumber(context) ?: return Promise.ofSuccess(Unit)
-//        val contacts = ContactUtilities.getAllContacts(context).filter { recipient ->
-//            !recipient.isGroupRecipient && !recipient.name.isNullOrEmpty() && !recipient.isLocalNumber && recipient.address.serialize().isNotEmpty()
-//        }.map { recipient ->
-//            ConfigurationMessage.Contact(
-//                publicKey = recipient.address.serialize(),
-//                name = recipient.name!!,
-//                profilePicture = recipient.profileAvatar,
-//                profileKey = recipient.profileKey,
-//                isApproved = recipient.isApproved,
-//                isBlocked = recipient.isBlocked,
-//                didApproveMe = recipient.hasApprovedMe()
-//            )
-//        }
-//        val configurationMessage = ConfigurationMessage.getCurrent(contacts) ?: return Promise.ofSuccess(Unit)
-//        val promise = MessageSender.send(configurationMessage, Destination.from(Address.fromSerialized(userPublicKey)))
-//        TextSecurePreferences.setLastConfigurationSyncTime(context, System.currentTimeMillis())
-//        return promise
+        // add if check here to schedule new config job process and return early
+        if (isNewConfigEnabled) {
+            // schedule job if none exist
+            TODO()
+        }
+        val userPublicKey = TextSecurePreferences.getLocalNumber(context) ?: return Promise.ofSuccess(Unit)
+        val contacts = ContactUtilities.getAllContacts(context).filter { recipient ->
+            !recipient.isGroupRecipient && !recipient.name.isNullOrEmpty() && !recipient.isLocalNumber && recipient.address.serialize().isNotEmpty()
+        }.map { recipient ->
+            ConfigurationMessage.Contact(
+                publicKey = recipient.address.serialize(),
+                name = recipient.name!!,
+                profilePicture = recipient.profileAvatar,
+                profileKey = recipient.profileKey,
+                isApproved = recipient.isApproved,
+                isBlocked = recipient.isBlocked,
+                didApproveMe = recipient.hasApprovedMe()
+            )
+        }
+        val configurationMessage = ConfigurationMessage.getCurrent(contacts) ?: return Promise.ofSuccess(Unit)
+        val promise = MessageSender.send(configurationMessage, Destination.from(Address.fromSerialized(userPublicKey)))
+        TextSecurePreferences.setLastConfigurationSyncTime(context, System.currentTimeMillis())
+        return promise
     }
 
     private fun maybeUserSecretKey() = MessagingModuleConfiguration.shared.getUserED25519KeyPair()?.secretKey?.asBytes
@@ -110,7 +123,7 @@ object ConfigurationMessageUtilities {
         return dump
     }
 
-    fun generateConversationDump(context: Context): ByteArray? {
+    fun generateConversationVolatileDump(context: Context): ByteArray? {
         TODO()
     }