Show a loader while the group is updating

res/layout/activity_edit_closed_group.xml

@@ -1,9 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
-<RelativeLayout
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     xmlns:tools="http://schemas.android.com/tools"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
     tools:context="org.thoughtcrime.securesms.loki.activities.EditClosedGroupActivity">
 
     <LinearLayout
@@ -146,4 +146,22 @@
 
     </LinearLayout>
 
+    <RelativeLayout
+        android:id="@+id/loader"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:background="#A4000000"
+        android:visibility="gone"
+        android:alpha="0">
+
+        <com.github.ybq.android.spinkit.SpinKitView
+            style="@style/SpinKitView.Large.ThreeBounce"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="8dp"
+            android:layout_centerInParent="true"
+            app:SpinKit_Color="@android:color/white" />
+
+    </RelativeLayout>
+
 </RelativeLayout>

src/org/thoughtcrime/securesms/loki/activities/EditClosedGroupActivity.kt

@@ -13,17 +13,23 @@ import android.view.inputmethod.EditorInfo
 import android.view.inputmethod.InputMethodManager
 import android.widget.Toast
 import androidx.appcompat.content.res.AppCompatResources
+import kotlinx.android.synthetic.main.activity_create_closed_group.*
 import kotlinx.android.synthetic.main.activity_create_closed_group.emptyStateContainer
 import kotlinx.android.synthetic.main.activity_create_closed_group.mainContentContainer
 import kotlinx.android.synthetic.main.activity_edit_closed_group.*
+import kotlinx.android.synthetic.main.activity_edit_closed_group.loader
 import kotlinx.android.synthetic.main.activity_linked_devices.recyclerView
 import network.loki.messenger.R
+import nl.komponents.kovenant.ui.failUi
+import nl.komponents.kovenant.ui.successUi
 import org.thoughtcrime.securesms.PassphraseRequiredActionBarActivity
 import org.thoughtcrime.securesms.database.Address
 import org.thoughtcrime.securesms.database.DatabaseFactory
 import org.thoughtcrime.securesms.groups.GroupManager
 import org.thoughtcrime.securesms.loki.dialogs.ClosedGroupEditingOptionsBottomSheet
 import org.thoughtcrime.securesms.loki.protocol.ClosedGroupsProtocol
+import org.thoughtcrime.securesms.loki.utilities.fadeIn
+import org.thoughtcrime.securesms.loki.utilities.fadeOut
 import org.thoughtcrime.securesms.mms.GlideApp
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.util.GroupUtil
@@ -238,10 +244,16 @@ class EditClosedGroupActivity : PassphraseRequiredActionBarActivity() {
         }
 
         if (isSSKBasedClosedGroup) {
-            ClosedGroupsProtocol.update(this, groupPublicKey!!, members.map { it.address.serialize() }, name)
+            loader.fadeIn()
+            ClosedGroupsProtocol.update(this, groupPublicKey!!, members.map { it.address.serialize() }, name).successUi {
+                loader.fadeOut()
+                finish()
+            }.failUi { exception ->
+                val message = if (exception is ClosedGroupsProtocol.Error) exception.description else "An error occurred"
+                Toast.makeText(this@EditClosedGroupActivity, message, Toast.LENGTH_LONG).show()
+            }
         } else {
             GroupManager.updateGroup(this, groupID, members, null, name, admins)
         }
-        finish()
     }
 }

src/org/thoughtcrime/securesms/loki/protocol/ClosedGroupsProtocol.kt

@@ -25,6 +25,7 @@ import org.whispersystems.signalservice.api.messages.SignalServiceGroup
 import org.whispersystems.signalservice.api.messages.SignalServiceGroup.GroupType
 import org.whispersystems.signalservice.internal.push.SignalServiceProtos
 import org.whispersystems.signalservice.internal.push.SignalServiceProtos.GroupContext
+import org.whispersystems.signalservice.loki.api.SnodeAPI
 import org.whispersystems.signalservice.loki.protocol.closedgroups.ClosedGroupRatchet
 import org.whispersystems.signalservice.loki.protocol.closedgroups.ClosedGroupSenderKey
 import org.whispersystems.signalservice.loki.protocol.closedgroups.SharedSenderKeysImplementation
@@ -38,7 +39,13 @@ import kotlin.jvm.Throws
 object ClosedGroupsProtocol {
     val isSharedSenderKeysEnabled = true
     val groupSizeLimit = 20
-    
+
+    sealed class Error(val description: String) : Exception() {
+        object NoThread : Error("Couldn't find a thread associated with the given group public key")
+        object NoPrivateKey : Error("Couldn't find a private key associated with the given group public key.")
+        object InvalidUpdate : Error("Invalid group update.")
+    }
+
     public fun createClosedGroup(context: Context, name: String, members: Collection<String>): Promise<String, Exception> {
         val deferred = deferred<String, Exception>()
         Thread {
@@ -98,123 +105,128 @@ object ClosedGroupsProtocol {
         val name = group.title
         val oldMembers = group.members.map { it.serialize() }.toSet()
         val newMembers = oldMembers.minus(userPublicKey)
-        update(context, groupPublicKey, newMembers, name)
+        return update(context, groupPublicKey, newMembers, name).get()
     }
 
-    public fun update(context: Context, groupPublicKey: String, members: Collection<String>, name: String) {
+    public fun update(context: Context, groupPublicKey: String, members: Collection<String>, name: String): Promise<Unit, Exception> {
-        val userPublicKey = TextSecurePreferences.getLocalNumber(context)
+        val deferred = deferred<Unit, Exception>()
-        val sskDatabase = DatabaseFactory.getSSKDatabase(context)
+        Thread {
-        val groupDB = DatabaseFactory.getGroupDatabase(context)
+            val userPublicKey = TextSecurePreferences.getLocalNumber(context)
-        val groupID = doubleEncodeGroupID(groupPublicKey)
+            val sskDatabase = DatabaseFactory.getSSKDatabase(context)
-        val group = groupDB.getGroup(groupID).orNull()
+            val groupDB = DatabaseFactory.getGroupDatabase(context)
-        if (group == null) {
+            val groupID = doubleEncodeGroupID(groupPublicKey)
-            Log.d("Loki", "Can't update nonexistent closed group.")
+            val group = groupDB.getGroup(groupID).orNull()
-            return
+            if (group == null) {
-        }
+                Log.d("Loki", "Can't update nonexistent closed group.")
-        val oldMembers = group.members.map { it.serialize() }.toSet()
+                return@Thread deferred.reject(Error.NoThread)
-        val newMembers = members.minus(oldMembers)
-        val membersAsData = members.map { Hex.fromStringCondensed(it) }
-        val admins = group.admins.map { it.serialize() }
-        val adminsAsData = admins.map { Hex.fromStringCondensed(it) }
-        val groupPrivateKey = DatabaseFactory.getSSKDatabase(context).getClosedGroupPrivateKey(groupPublicKey)
-        if (groupPrivateKey == null) {
-            Log.d("Loki", "Couldn't get private key for closed group.")
-            return
-        }
-        val wasAnyUserRemoved = members.toSet().intersect(oldMembers) != oldMembers.toSet()
-        val removedMembers = oldMembers.minus(members)
-        val isUserLeaving = removedMembers.contains(userPublicKey)
-        var newSenderKeys = listOf<ClosedGroupSenderKey>()
-        if (wasAnyUserRemoved) {
-            if (isUserLeaving && removedMembers.count() != 1) {
-                Log.d("Loki", "Can't remove self and others simultaneously.")
-                return
             }
-            // Establish sessions if needed
+            val oldMembers = group.members.map { it.serialize() }.toSet()
-            establishSessionsWithMembersIfNeeded(context, members)
+            val newMembers = members.minus(oldMembers)
-            // Send the update to the existing members using established channels (don't include new ratchets as everyone should regenerate new ratchets individually)
+            val membersAsData = members.map { Hex.fromStringCondensed(it) }
-            for (member in oldMembers) {
+            val admins = group.admins.map { it.serialize() }
-                @Suppress("NAME_SHADOWING")
+            val adminsAsData = admins.map { Hex.fromStringCondensed(it) }
-                val closedGroupUpdateKind = ClosedGroupUpdateMessageSendJob.Kind.Info(Hex.fromStringCondensed(groupPublicKey),
+            val groupPrivateKey = DatabaseFactory.getSSKDatabase(context).getClosedGroupPrivateKey(groupPublicKey)
-                    name, setOf(), membersAsData, adminsAsData)
+            if (groupPrivateKey == null) {
-                @Suppress("NAME_SHADOWING")
+                Log.d("Loki", "Couldn't get private key for closed group.")
-                val job = ClosedGroupUpdateMessageSendJob(member, closedGroupUpdateKind)
+                return@Thread deferred.reject(Error.NoPrivateKey)
-                job.setContext(context)
-                job.onRun() // Run the job immediately
             }
-            // Delete all ratchets (it's important that this happens * after * sending out the update)
+            val wasAnyUserRemoved = members.toSet().intersect(oldMembers) != oldMembers.toSet()
-            sskDatabase.removeAllClosedGroupRatchets(groupPublicKey)
+            val removedMembers = oldMembers.minus(members)
-            // Remove the group from the user's set of public keys to poll for if the user is leaving. Otherwise generate a new ratchet and
+            val isUserLeaving = removedMembers.contains(userPublicKey)
-            // send it out to all members (minus the removed ones) using established channels.
+            var newSenderKeys = listOf<ClosedGroupSenderKey>()
-            if (isUserLeaving) {
+            if (wasAnyUserRemoved) {
-                sskDatabase.removeClosedGroupPrivateKey(groupPublicKey)
+                if (isUserLeaving && removedMembers.count() != 1) {
-                groupDB.setActive(groupID, false)
+                    Log.d("Loki", "Can't remove self and others simultaneously.")
-                groupDB.remove(groupID, Address.fromSerialized(userPublicKey))
+                    return@Thread deferred.reject(Error.InvalidUpdate)
-                // Notify the PN server
+                }
-                LokiPushNotificationManager.performOperation(context, ClosedGroupOperation.Unsubscribe, groupPublicKey, userPublicKey)
+                // Establish sessions if needed
-            } else {
+                establishSessionsWithMembersIfNeeded(context, members)
-                // Send closed group update messages to any new members using established channels
+                // Send the update to the existing members using established channels (don't include new ratchets as everyone should regenerate new ratchets individually)
+                for (member in oldMembers) {
+                    @Suppress("NAME_SHADOWING")
+                    val closedGroupUpdateKind = ClosedGroupUpdateMessageSendJob.Kind.Info(Hex.fromStringCondensed(groupPublicKey),
+                        name, setOf(), membersAsData, adminsAsData)
+                    @Suppress("NAME_SHADOWING")
+                    val job = ClosedGroupUpdateMessageSendJob(member, closedGroupUpdateKind)
+                    job.setContext(context)
+                    job.onRun() // Run the job immediately
+                }
+                // Delete all ratchets (it's important that this happens * after * sending out the update)
+                sskDatabase.removeAllClosedGroupRatchets(groupPublicKey)
+                // Remove the group from the user's set of public keys to poll for if the user is leaving. Otherwise generate a new ratchet and
+                // send it out to all members (minus the removed ones) using established channels.
+                if (isUserLeaving) {
+                    sskDatabase.removeClosedGroupPrivateKey(groupPublicKey)
+                    groupDB.setActive(groupID, false)
+                    groupDB.remove(groupID, Address.fromSerialized(userPublicKey))
+                    // Notify the PN server
+                    LokiPushNotificationManager.performOperation(context, ClosedGroupOperation.Unsubscribe, groupPublicKey, userPublicKey)
+                } else {
+                    // Send closed group update messages to any new members using established channels
+                    for (member in newMembers) {
+                        @Suppress("NAME_SHADOWING")
+                        val closedGroupUpdateKind = ClosedGroupUpdateMessageSendJob.Kind.New(Hex.fromStringCondensed(groupPublicKey), name,
+                            Hex.fromStringCondensed(groupPrivateKey), listOf(), membersAsData, adminsAsData)
+                        @Suppress("NAME_SHADOWING")
+                        val job = ClosedGroupUpdateMessageSendJob(member, closedGroupUpdateKind)
+                        ApplicationContext.getInstance(context).jobManager.add(job)
+                    }
+                    // Send out the user's new ratchet to all members (minus the removed ones) using established channels
+                    val userRatchet = SharedSenderKeysImplementation.shared.generateRatchet(groupPublicKey, userPublicKey)
+                    val userSenderKey = ClosedGroupSenderKey(Hex.fromStringCondensed(userRatchet.chainKey), userRatchet.keyIndex, Hex.fromStringCondensed(userPublicKey))
+                    for (member in members) {
+                        if (member == userPublicKey) { continue }
+                        @Suppress("NAME_SHADOWING")
+                        val closedGroupUpdateKind = ClosedGroupUpdateMessageSendJob.Kind.SenderKey(Hex.fromStringCondensed(groupPublicKey), userSenderKey)
+                        @Suppress("NAME_SHADOWING")
+                        val job = ClosedGroupUpdateMessageSendJob(member, closedGroupUpdateKind)
+                        ApplicationContext.getInstance(context).jobManager.add(job)
+                    }
+                }
+            } else if (newMembers.isNotEmpty()) {
+                // Generate ratchets for any new members
+                newSenderKeys = newMembers.map { publicKey ->
+                    val ratchet = SharedSenderKeysImplementation.shared.generateRatchet(groupPublicKey, publicKey)
+                    ClosedGroupSenderKey(Hex.fromStringCondensed(ratchet.chainKey), ratchet.keyIndex, Hex.fromStringCondensed(publicKey))
+                }
+                // Send a closed group update message to the existing members with the new members' ratchets (this message is aimed at the group)
+                val closedGroupUpdateKind = ClosedGroupUpdateMessageSendJob.Kind.Info(Hex.fromStringCondensed(groupPublicKey), name,
+                    newSenderKeys, membersAsData, adminsAsData)
+                val job = ClosedGroupUpdateMessageSendJob(groupPublicKey, closedGroupUpdateKind)
+                ApplicationContext.getInstance(context).jobManager.add(job)
+                // Establish sessions if needed
+                establishSessionsWithMembersIfNeeded(context, newMembers)
+                // Send closed group update messages to the new members using established channels
+                var allSenderKeys = sskDatabase.getAllClosedGroupSenderKeys(groupPublicKey);
+                allSenderKeys = allSenderKeys.union(newSenderKeys)
                 for (member in newMembers) {
                     @Suppress("NAME_SHADOWING")
                     val closedGroupUpdateKind = ClosedGroupUpdateMessageSendJob.Kind.New(Hex.fromStringCondensed(groupPublicKey), name,
-                        Hex.fromStringCondensed(groupPrivateKey), listOf(), membersAsData, adminsAsData)
+                        Hex.fromStringCondensed(groupPrivateKey), allSenderKeys, membersAsData, adminsAsData)
                     @Suppress("NAME_SHADOWING")
                     val job = ClosedGroupUpdateMessageSendJob(member, closedGroupUpdateKind)
                     ApplicationContext.getInstance(context).jobManager.add(job)
                 }
-                // Send out the user's new ratchet to all members (minus the removed ones) using established channels
+            } else {
-                val userRatchet = SharedSenderKeysImplementation.shared.generateRatchet(groupPublicKey, userPublicKey)
+                val allSenderKeys = sskDatabase.getAllClosedGroupSenderKeys(groupPublicKey);
-                val userSenderKey = ClosedGroupSenderKey(Hex.fromStringCondensed(userRatchet.chainKey), userRatchet.keyIndex, Hex.fromStringCondensed(userPublicKey))
+                val closedGroupUpdateKind = ClosedGroupUpdateMessageSendJob.Kind.Info(Hex.fromStringCondensed(groupPublicKey), name,
-                for (member in members) {
+                    allSenderKeys, membersAsData, adminsAsData)
-                    if (member == userPublicKey) { continue }
+                val job = ClosedGroupUpdateMessageSendJob(groupPublicKey, closedGroupUpdateKind)
-                    @Suppress("NAME_SHADOWING")
-                    val closedGroupUpdateKind = ClosedGroupUpdateMessageSendJob.Kind.SenderKey(Hex.fromStringCondensed(groupPublicKey), userSenderKey)
-                    @Suppress("NAME_SHADOWING")
-                    val job = ClosedGroupUpdateMessageSendJob(member, closedGroupUpdateKind)
-                    ApplicationContext.getInstance(context).jobManager.add(job)
-                }
-            }
-        } else if (newMembers.isNotEmpty()) {
-            // Generate ratchets for any new members
-            newSenderKeys = newMembers.map { publicKey ->
-                val ratchet = SharedSenderKeysImplementation.shared.generateRatchet(groupPublicKey, publicKey)
-                ClosedGroupSenderKey(Hex.fromStringCondensed(ratchet.chainKey), ratchet.keyIndex, Hex.fromStringCondensed(publicKey))
-            }
-            // Send a closed group update message to the existing members with the new members' ratchets (this message is aimed at the group)
-            val closedGroupUpdateKind = ClosedGroupUpdateMessageSendJob.Kind.Info(Hex.fromStringCondensed(groupPublicKey), name,
-                newSenderKeys, membersAsData, adminsAsData)
-            val job = ClosedGroupUpdateMessageSendJob(groupPublicKey, closedGroupUpdateKind)
-            ApplicationContext.getInstance(context).jobManager.add(job)
-            // Establish sessions if needed
-            establishSessionsWithMembersIfNeeded(context, newMembers)
-            // Send closed group update messages to the new members using established channels
-            var allSenderKeys = sskDatabase.getAllClosedGroupSenderKeys(groupPublicKey);
-            allSenderKeys = allSenderKeys.union(newSenderKeys)
-            for (member in newMembers) {
-                @Suppress("NAME_SHADOWING")
-                val closedGroupUpdateKind = ClosedGroupUpdateMessageSendJob.Kind.New(Hex.fromStringCondensed(groupPublicKey), name,
-                    Hex.fromStringCondensed(groupPrivateKey), allSenderKeys, membersAsData, adminsAsData)
-                @Suppress("NAME_SHADOWING")
-                val job = ClosedGroupUpdateMessageSendJob(member, closedGroupUpdateKind)
                 ApplicationContext.getInstance(context).jobManager.add(job)
             }
-        } else {
+            // Update the group
-            val allSenderKeys = sskDatabase.getAllClosedGroupSenderKeys(groupPublicKey);
+            groupDB.updateTitle(groupID, name)
-            val closedGroupUpdateKind = ClosedGroupUpdateMessageSendJob.Kind.Info(Hex.fromStringCondensed(groupPublicKey), name,
+            if (!isUserLeaving) {
-                allSenderKeys, membersAsData, adminsAsData)
+                // The call below sets isActive to true, so if the user is leaving we have to use groupDB.remove(...) instead
-            val job = ClosedGroupUpdateMessageSendJob(groupPublicKey, closedGroupUpdateKind)
+                groupDB.updateMembers(groupID, members.map { Address.fromSerialized(it) })
-            ApplicationContext.getInstance(context).jobManager.add(job)
+            }
-        }
+            // Notify the user
-        // Update the group
+            val infoType = if (isUserLeaving) GroupContext.Type.QUIT else GroupContext.Type.UPDATE
-        groupDB.updateTitle(groupID, name)
+            val threadID = DatabaseFactory.getThreadDatabase(context).getThreadIdFor(Recipient.from(context, Address.fromSerialized(groupID), false))
-        if (!isUserLeaving) {
+            insertOutgoingInfoMessage(context, groupID, infoType, name, members, admins, threadID)
-            // The call below sets isActive to true, so if the user is leaving we have to use groupDB.remove(...) instead
+            deferred.resolve(Unit)
-            groupDB.updateMembers(groupID, members.map { Address.fromSerialized(it) })
+        }.start()
-        }
+        return deferred.promise
-        // Notify the user
-        val infoType = if (isUserLeaving) GroupContext.Type.QUIT else GroupContext.Type.UPDATE
-        val threadID = DatabaseFactory.getThreadDatabase(context).getThreadIdFor(Recipient.from(context, Address.fromSerialized(groupID), false))
-        insertOutgoingInfoMessage(context, groupID, infoType, name, members, admins, threadID)
     }
 
     @JvmStatic