WIP: clean up V1 multi device

app/src/main/java/org/thoughtcrime/securesms/loki/activities/EditClosedGroupLoader.kt

@@ -2,7 +2,6 @@ package org.thoughtcrime.securesms.loki.activities
 
 import android.content.Context
 import org.thoughtcrime.securesms.database.DatabaseFactory
-import org.thoughtcrime.securesms.loki.utilities.ContactUtilities
 import org.thoughtcrime.securesms.util.AsyncLoader
 
 class EditClosedGroupLoader(context: Context, val groupID: String) : AsyncLoader<List<String>>(context) {

app/src/main/java/org/thoughtcrime/securesms/loki/activities/HomeActivity.kt

@@ -44,12 +44,9 @@ import org.session.libsession.utilities.TextSecurePreferences
 import org.session.libsession.utilities.TextSecurePreferences.getBooleanPreference
 import org.session.libsession.utilities.TextSecurePreferences.setBooleanPreference
 import org.session.libsession.utilities.Util
-import org.session.libsignal.service.loki.api.fileserver.FileServerAPI
 import org.session.libsignal.service.loki.protocol.mentions.MentionsManager
 import org.session.libsignal.service.loki.protocol.meta.SessionMetaProtocol
 import org.session.libsignal.service.loki.protocol.sessionmanagement.SessionManagementProtocol
-import org.session.libsignal.service.loki.protocol.shelved.multidevice.MultiDeviceProtocol
-import org.session.libsignal.service.loki.protocol.shelved.syncmessages.SyncMessagesProtocol
 import org.session.libsignal.utilities.ThreadUtils
 import org.session.libsignal.service.loki.utilities.toHexString
 import org.thoughtcrime.securesms.loki.dialogs.*
@@ -177,20 +174,11 @@ class HomeActivity : PassphraseRequiredActionBarActivity, ConversationClickListe
         if (userPublicKey != null) {
             MentionsManager.configureIfNeeded(userPublicKey, threadDB, userDB)
             SessionMetaProtocol.configureIfNeeded(apiDB, userPublicKey)
-            SyncMessagesProtocol.configureIfNeeded(apiDB, userPublicKey)
             application.publicChatManager.startPollersIfNeeded()
         }
         SessionManagementProtocol.configureIfNeeded(sessionResetImpl, sskDatabase, application)
-        MultiDeviceProtocol.configureIfNeeded(apiDB)
         IP2Country.configureIfNeeded(this)
         application.registerForFCMIfNeeded(false)
-        // Preload device links to make message sending quicker
-        val publicKeys = ContactUtilities.getAllContacts(this).filter { contact ->
-            !contact.recipient.isGroupRecipient && !contact.isOurDevice && !contact.isSlave
-        }.map {
-            it.recipient.address.toString()
-        }.toSet()
-        FileServerAPI.shared.getDeviceLinks(publicKeys)
         // Observe blocked contacts changed events
         val broadcastReceiver = object : BroadcastReceiver() {
 

app/src/main/java/org/thoughtcrime/securesms/loki/api/PublicChatPoller.kt

@@ -27,7 +27,6 @@ import org.session.libsignal.service.loki.api.fileserver.FileServerAPI
 import org.session.libsignal.service.loki.api.opengroups.PublicChat
 import org.session.libsignal.service.loki.api.opengroups.PublicChatAPI
 import org.session.libsignal.service.loki.api.opengroups.PublicChatMessage
-import org.session.libsignal.service.loki.protocol.shelved.multidevice.MultiDeviceProtocol
 import java.security.MessageDigest
 import java.util.*
 
@@ -161,14 +160,11 @@ class PublicChatPoller(private val context: Context, private val group: PublicCh
     fun pollForNewMessages(): Promise<Unit, Exception> {
         fun processIncomingMessage(message: PublicChatMessage) {
             // If the sender of the current message is not a slave device, set the display name in the database
-            val masterHexEncodedPublicKey = MultiDeviceProtocol.shared.getMasterDevice(message.senderPublicKey)
-            if (masterHexEncodedPublicKey == null) {
-                val senderDisplayName = "${message.displayName} (...${message.senderPublicKey.takeLast(8)})"
-                DatabaseFactory.getLokiUserDatabase(context).setServerDisplayName(group.id, message.senderPublicKey, senderDisplayName)
-            }
-            val senderHexEncodedPublicKey = masterHexEncodedPublicKey ?: message.senderPublicKey
+            val senderDisplayName = "${message.displayName} (...${message.senderPublicKey.takeLast(8)})"
+            DatabaseFactory.getLokiUserDatabase(context).setServerDisplayName(group.id, message.senderPublicKey, senderDisplayName)
+            val senderHexEncodedPublicKey = message.senderPublicKey
             val serviceDataMessage = getDataMessage(message)
-            val serviceContent = SignalServiceContent(serviceDataMessage, senderHexEncodedPublicKey, SignalServiceAddress.DEFAULT_DEVICE_ID, message.serverTimestamp, false, false)
+            val serviceContent = SignalServiceContent(serviceDataMessage, senderHexEncodedPublicKey, SignalServiceAddress.DEFAULT_DEVICE_ID, message.serverTimestamp, false)
             if (serviceDataMessage.quote.isPresent || (serviceDataMessage.attachments.isPresent && serviceDataMessage.attachments.get().size > 0) || serviceDataMessage.previews.isPresent) {
                 PushDecryptJob(context).handleMediaMessage(serviceContent, serviceDataMessage, Optional.absent(), Optional.of(message.serverID))
             } else {
@@ -221,8 +217,6 @@ class PublicChatPoller(private val context: Context, private val group: PublicCh
         }
         if (isPollOngoing) { return Promise.of(Unit) }
         isPollOngoing = true
-        val userDevices = MultiDeviceProtocol.shared.getAllLinkedDevices(userHexEncodedPublicKey)
-        var uniqueDevices = setOf<String>()
         val userPrivateKey = IdentityKeyUtil.getIdentityKeyPair(context).privateKey.serialize()
         val apiDB = DatabaseFactory.getLokiAPIDatabase(context)
         FileServerAPI.configure(userHexEncodedPublicKey, userPrivateKey, apiDB)
@@ -240,20 +234,10 @@ class PublicChatPoller(private val context: Context, private val group: PublicCh
              */
             Promise.of(messages)
         }
-        promise.successBackground {
-            /*
-            val newDisplayNameUpdatees = uniqueDevices.mapNotNull {
-                // This will return null if the current device is a master device
-                MultiDeviceProtocol.shared.getMasterDevice(it)
-            }.toSet()
-            // Fetch the display names of the master devices
-            displayNameUpdatees = displayNameUpdatees.union(newDisplayNameUpdatees)
-             */
-        }
         promise.successBackground { messages ->
             // Process messages in the background
             messages.forEach { message ->
-                if (userDevices.contains(message.senderPublicKey)) {
+                if (message.senderPublicKey == userHexEncodedPublicKey) {
                     processOutgoingMessage(message)
                 } else {
                     processIncomingMessage(message)

app/src/main/java/org/thoughtcrime/securesms/loki/database/LokiAPIDatabase.kt

@@ -11,7 +11,6 @@ import org.thoughtcrime.securesms.database.helpers.SQLCipherOpenHelper
 import org.thoughtcrime.securesms.loki.utilities.*
 import org.session.libsignal.service.loki.api.Snode
 import org.session.libsignal.service.loki.database.LokiAPIDatabaseProtocol
-import org.session.libsignal.service.loki.protocol.shelved.multidevice.DeviceLink
 import org.session.libsignal.service.loki.utilities.removing05PrefixIfNeeded
 import org.session.libsignal.service.loki.utilities.toHexString
 import org.thoughtcrime.securesms.crypto.IdentityKeyUtil
@@ -459,48 +458,6 @@ class LokiAPIDatabase(context: Context, helper: SQLCipherOpenHelper) : Database(
         val database = databaseHelper.writableDatabase
         database.delete(closedGroupPublicKeysTable, "${Companion.groupPublicKey} = ?", wrap(groupPublicKey))
     }
-
-    // region Deprecated
-    override fun getDeviceLinks(publicKey: String): Set<DeviceLink> {
-        return setOf()
-        /*
-        val database = databaseHelper.readableDatabase
-        return database.getAll(deviceLinkCache, "$masterPublicKey = ? OR $slavePublicKey = ?", arrayOf( publicKey, publicKey )) { cursor ->
-            val masterHexEncodedPublicKey = cursor.getString(masterPublicKey)
-            val slaveHexEncodedPublicKey = cursor.getString(slavePublicKey)
-            val requestSignature: ByteArray? = if (cursor.isNull(cursor.getColumnIndexOrThrow(requestSignature))) null else cursor.getBase64EncodedData(requestSignature)
-            val authorizationSignature: ByteArray? = if (cursor.isNull(cursor.getColumnIndexOrThrow(authorizationSignature))) null else cursor.getBase64EncodedData(authorizationSignature)
-            DeviceLink(masterHexEncodedPublicKey, slaveHexEncodedPublicKey, requestSignature, authorizationSignature)
-        }.toSet()
-         */
-    }
-
-    override fun clearDeviceLinks(publicKey: String) {
-        /*
-        val database = databaseHelper.writableDatabase
-        database.delete(deviceLinkCache, "$masterPublicKey = ? OR $slavePublicKey = ?", arrayOf( publicKey, publicKey ))
-         */
-    }
-
-    override fun addDeviceLink(deviceLink: DeviceLink) {
-        /*
-        val database = databaseHelper.writableDatabase
-        val values = ContentValues()
-        values.put(masterPublicKey, deviceLink.masterPublicKey)
-        values.put(slavePublicKey, deviceLink.slavePublicKey)
-        if (deviceLink.requestSignature != null) { values.put(requestSignature, Base64.encodeBytes(deviceLink.requestSignature)) }
-        if (deviceLink.authorizationSignature != null) { values.put(authorizationSignature, Base64.encodeBytes(deviceLink.authorizationSignature)) }
-        database.insertOrUpdate(deviceLinkCache, values, "$masterPublicKey = ? AND $slavePublicKey = ?", arrayOf( deviceLink.masterPublicKey, deviceLink.slavePublicKey ))
-         */
-    }
-
-    override fun removeDeviceLink(deviceLink: DeviceLink) {
-        /*
-        val database = databaseHelper.writableDatabase
-        database.delete(deviceLinkCache, "$masterPublicKey = ? OR $slavePublicKey = ?", arrayOf( deviceLink.masterPublicKey, deviceLink.slavePublicKey ))
-         */
-    }
-    // endregion
 }
 
 // region Convenience

app/src/main/java/org/thoughtcrime/securesms/loki/protocol/SessionManagementProtocol.kt

@@ -13,7 +13,6 @@ import org.thoughtcrime.securesms.sms.OutgoingTextMessage
 import org.session.libsession.utilities.TextSecurePreferences
 import org.session.libsignal.libsignal.loki.SessionResetStatus
 import org.session.libsignal.service.api.messages.SignalServiceContent
-import org.session.libsignal.service.loki.protocol.shelved.multidevice.MultiDeviceProtocol
 import java.util.*
 
 object SessionManagementProtocol {
@@ -95,13 +94,12 @@ object SessionManagementProtocol {
 
     @JvmStatic
     fun triggerSessionRestorationUI(context: Context, publicKey: String, errorTimestamp: Long) {
-        val masterDevicePublicKey = MultiDeviceProtocol.shared.getMasterDevice(publicKey) ?: publicKey
-        val masterDeviceAsRecipient = recipient(context, masterDevicePublicKey)
-        if (masterDeviceAsRecipient.isGroupRecipient) { return }
+        val recipient = recipient(context, publicKey)
+        if (recipient.isGroupRecipient) { return }
         if (TextSecurePreferences.getRestorationTime(context) > errorTimestamp) {
             return ApplicationContext.getInstance(context).sendSessionRequestIfNeeded(publicKey)
         }
-        val threadID = DatabaseFactory.getThreadDatabase(context).getOrCreateThreadIdFor(masterDeviceAsRecipient)
+        val threadID = DatabaseFactory.getThreadDatabase(context).getOrCreateThreadIdFor(recipient)
         DatabaseFactory.getLokiThreadDatabase(context).addSessionRestoreDevice(threadID, publicKey)
     }
 }