Optimizing community joining process (#1968)

Author: SessionHero01

app/src/main/java/org/session/libsession/database/StorageProtocol.kt

@@ -59,8 +59,6 @@ interface StorageProtocol {
     fun getServerCapabilities(server: String): List<String>?
     fun clearServerCapabilities(server: String)
 
-    // Open Groups
-    suspend fun addOpenGroup(urlAsString: String)
     fun setOpenGroupServerMessageID(messageID: MessageId, serverID: Long, threadID: Long)
 
     // Open Group Public Keys

app/src/main/java/org/session/libsession/messaging/open_groups/OpenGroupApi.kt

@@ -100,7 +100,24 @@ object OpenGroupApi {
         @SerialName("default_upload")
         val defaultUpload: Boolean = false,
         val details: RoomInfoDetails = RoomInfoDetails()
-    )
+    ) {
+        constructor(details: RoomInfoDetails): this(
+            token = details.token,
+            activeUsers = details.activeUsers,
+            admin = details.admin,
+            globalAdmin = details.globalAdmin,
+            moderator = details.moderator,
+            globalModerator = details.globalModerator,
+            read = details.read,
+            defaultRead = details.defaultRead,
+            defaultAccessible = details.defaultAccessible,
+            write = details.write,
+            defaultWrite = details.defaultWrite,
+            upload = details.upload,
+            defaultUpload = details.defaultUpload,
+            details = details
+        )
+    }
 
     @Serializable
     data class DirectMessage(

app/src/main/java/org/session/libsession/messaging/open_groups/api/GetRoomDetailsApi.kt

@@ -0,0 +1,38 @@
+package org.session.libsession.messaging.open_groups.api
+
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.decodeFromStream
+import org.session.libsession.messaging.open_groups.OpenGroupApi
+import org.thoughtcrime.securesms.api.ApiExecutorContext
+import org.thoughtcrime.securesms.api.http.HttpResponse
+
+class GetRoomDetailsApi @AssistedInject constructor(
+    deps: CommunityApiDependencies,
+    @Assisted override val room: String,
+) : CommunityApi<OpenGroupApi.RoomInfoDetails>(deps) {
+    override val requiresSigning: Boolean
+        get() = false
+
+    override val httpMethod: String
+        get() = "GET"
+
+    override val httpEndpoint: String
+        get() =  "/room/${room}"
+
+    override suspend fun handleSuccessResponse(
+        executorContext: ApiExecutorContext,
+        baseUrl: String,
+        response: HttpResponse
+    ): OpenGroupApi.RoomInfoDetails {
+        @Suppress("OPT_IN_USAGE")
+        return response.body.asInputStream().use(json::decodeFromStream)
+    }
+
+    @AssistedFactory
+    interface Factory {
+        fun create(room: String): GetRoomDetailsApi
+    }
+}

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

@@ -871,10 +871,6 @@ open class Storage @Inject constructor(
         return groupDatabase.getAllGroups(includeInactive)
     }
 
-    override suspend fun addOpenGroup(urlAsString: String) {
-        return openGroupManager.get().addOpenGroup(urlAsString)
-    }
-
     override fun getOrCreateThreadIdFor(address: Address): Long {
         return threadDatabase.getOrCreateThreadIdFor(address)
     }

app/src/main/java/org/thoughtcrime/securesms/groups/OpenGroupManager.kt

@@ -1,18 +1,20 @@
 package org.thoughtcrime.securesms.groups
 
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.mapNotNull
-import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
-import org.session.libsession.messaging.open_groups.OpenGroup
+import kotlinx.coroutines.async
+import kotlinx.coroutines.supervisorScope
+import kotlinx.serialization.json.Json
 import org.session.libsession.messaging.open_groups.OpenGroupApi
 import org.session.libsession.messaging.open_groups.api.CommunityApiExecutor
 import org.session.libsession.messaging.open_groups.api.CommunityApiRequest
 import org.session.libsession.messaging.open_groups.api.GetCapsApi
+import org.session.libsession.messaging.open_groups.api.GetRoomDetailsApi
 import org.session.libsession.messaging.open_groups.api.execute
-import org.session.libsession.messaging.sending_receiving.pollers.OpenGroupPollerManager
+import org.session.libsession.utilities.Address
 import org.session.libsession.utilities.ConfigFactoryProtocol
 import org.session.libsession.utilities.withMutableUserConfigs
+import org.session.libsession.utilities.withUserConfigs
 import org.session.libsignal.utilities.Log
+import org.thoughtcrime.securesms.database.CommunityDatabase
 import org.thoughtcrime.securesms.database.LokiAPIDatabase
 import javax.inject.Inject
 import javax.inject.Provider
@@ -26,25 +28,53 @@ private const val TAG = "OpenGroupManager"
 @Singleton
 class OpenGroupManager @Inject constructor(
     private val configFactory: ConfigFactoryProtocol,
-    private val pollerManager: OpenGroupPollerManager,
     private val lokiAPIDatabase: LokiAPIDatabase,
     private val communityApiExecutor: CommunityApiExecutor,
     private val getCapsApi: Provider<GetCapsApi>,
+    private val getRoomDetailsApiFactory: GetRoomDetailsApi.Factory,
+    private val communityDatabase: CommunityDatabase,
+    private val json: Json,
 ) {
-    suspend fun add(server: String, room: String, publicKey: String) {
+    suspend fun add(server: String, room: String, publicKey: String): Unit = supervisorScope {
+        // Check if the community is already added, if so, we can skip the rest of the process
+        val alreadyJoined = configFactory.withUserConfigs {
+            it.userGroups.getCommunityInfo(server, room)
+        } != null
+
+        if (alreadyJoined) {
+            Log.d("OpenGroupManager", "Community $server is already added, skipping add process")
+            return@supervisorScope
+        }
+
         // Fetch the server's capabilities upfront to see if this server is actually running
-        // Note: this process is not essential to adding a community, just a nice to have test
-        // for the user to see if the server they are adding is reachable.
-        // The addition of the community to the config later will always succeed and the poller
-        // will be started regardless of the server's status.
-        val caps = communityApiExecutor.execute(
-            CommunityApiRequest(
-                serverBaseUrl = server,
-                serverPubKey = publicKey,
-                api = getCapsApi.get()
+        val getCaps = async {
+            communityApiExecutor.execute(
+                CommunityApiRequest(
+                    serverBaseUrl = server,
+                    serverPubKey = publicKey,
+                    api = getCapsApi.get()
+                )
+            )
+        }
+
+        // Fetch room details at the same time also
+        val getRoomDetails = async {
+            communityApiExecutor.execute(
+                CommunityApiRequest(
+                    serverBaseUrl = server,
+                    serverPubKey = publicKey,
+                    api = getRoomDetailsApiFactory.create(room)
+                )
             )
-        )
-        lokiAPIDatabase.setServerCapabilities(server, caps.capabilities)
+        }
+
+        val caps = getCaps.await().capabilities
+        val roomDetails = getRoomDetails.await()
+
+        lokiAPIDatabase.setServerCapabilities(server, caps)
+        communityDatabase.patchRoomInfo(Address.Community(server, room),
+            json.encodeToString(OpenGroupApi.RoomInfo(roomDetails)))
+
 
         // We should be good, now go ahead and add the community to the config
         configFactory.withMutableUserConfigs { configs ->
@@ -56,15 +86,6 @@ class OpenGroupManager @Inject constructor(
 
             configs.userGroups.set(community)
         }
-
-        Log.d(TAG, "Waiting for poller for server $server to be started.")
-
-        // Wait until we have a poller for the server, and then request one poll
-        pollerManager.pollers
-            .mapNotNull { it[server] }
-            .first()
-            .poller
-            .manualPollOnce()
     }
 
     fun delete(server: String, room: String) {
@@ -73,13 +94,4 @@ class OpenGroupManager @Inject constructor(
             configs.convoInfoVolatile.eraseCommunity(server, room)
         }
     }
-
-    suspend fun addOpenGroup(urlAsString: String) {
-        val url = urlAsString.toHttpUrlOrNull() ?: return
-        val server = OpenGroup.getServer(urlAsString)
-        val room = url.pathSegments.firstOrNull() ?: return
-        val publicKey = url.queryParameter("public_key") ?: return
-
-        add(server.toString().removeSuffix("/"), room, publicKey) // assume migrated from calling function
-    }
 }