Feature/spaces group space beta

vector/src/main/java/im/vector/app/AppStateHandler.kt

@@ -22,17 +22,25 @@ import androidx.lifecycle.OnLifecycleEvent
 import arrow.core.Option
 import im.vector.app.core.di.ActiveSessionHolder
 import im.vector.app.core.utils.BehaviorDataSource
-import im.vector.app.features.spaces.ALL_COMMUNITIES_GROUP_ID
 import im.vector.app.features.ui.UiStateRepository
 import io.reactivex.disposables.CompositeDisposable
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
-import org.matrix.android.sdk.api.MatrixPatterns
 import org.matrix.android.sdk.api.extensions.tryOrNull
+import org.matrix.android.sdk.api.session.Session
+import org.matrix.android.sdk.api.session.group.model.GroupSummary
 import org.matrix.android.sdk.api.session.room.model.RoomSummary
 import javax.inject.Inject
 import javax.inject.Singleton
 
+sealed class RoomGroupingMethod {
+    data class ByLegacyGroup(val groupSummary: GroupSummary?) : RoomGroupingMethod()
+    data class BySpace(val spaceSummary: RoomSummary?) : RoomGroupingMethod()
+}
+
+fun RoomGroupingMethod.space() = (this as? RoomGroupingMethod.BySpace)?.spaceSummary
+fun RoomGroupingMethod.group() = (this as? RoomGroupingMethod.ByLegacyGroup)?.groupSummary
+
 /**
  * This class handles the global app state.
  * It requires to be added to ProcessLifecycleOwner.get().lifecycle
@@ -47,43 +55,65 @@ class AppStateHandler @Inject constructor(
 
     private val compositeDisposable = CompositeDisposable()
 
-    private val selectedSpaceDataSource = BehaviorDataSource<Option<RoomSummary>>(Option.empty())
+    private val selectedSpaceDataSource = BehaviorDataSource<Option<RoomGroupingMethod>>(Option.empty())
+
+    val selectedRoomGroupingObservable = selectedSpaceDataSource.observe()
 
-    val selectedSpaceObservable = selectedSpaceDataSource.observe()
+    fun getCurrentRoomGroupingMethod(): RoomGroupingMethod? = selectedSpaceDataSource.currentValue?.orNull()
 
-    fun setCurrentSpace(space: RoomSummary?) {
-        if (space == selectedSpaceDataSource.currentValue?.orNull()) return
-        selectedSpaceDataSource.post(space?.let { Option.just(it) } ?: Option.empty())
-        if (space != null && space.roomId != ALL_COMMUNITIES_GROUP_ID) {
+    fun setCurrentSpace(spaceId: String?, session: Session? = null) {
+        val uSession = session ?: activeSessionHolder.getSafeActiveSession()
+        if (selectedSpaceDataSource.currentValue?.orNull() is RoomGroupingMethod.BySpace
+                && spaceId == selectedSpaceDataSource.currentValue?.orNull()?.space()?.roomId) return
+        val spaceSum = spaceId?.let { uSession?.getRoomSummary(spaceId) }
+        selectedSpaceDataSource.post(Option.just(RoomGroupingMethod.BySpace(spaceSum)))
+        if (spaceId != null) {
             GlobalScope.launch {
                 tryOrNull {
-                    activeSessionHolder.getSafeActiveSession()?.getRoom(space.roomId)?.loadRoomMembersIfNeeded()
+                    uSession?.getRoom(spaceId)?.loadRoomMembersIfNeeded()
                 }
             }
         }
     }
 
-    init {
-        // restore current space from ui state
-        sessionDataSource.currentValue?.orNull()?.let { session ->
-            uiStateRepository.getSelectedSpace(session.sessionId)?.let { selectedSpaceId ->
-                session.getRoomSummary(selectedSpaceId)?.let {
-                    setCurrentSpace(it)
+    fun setCurrentGroup(groupId: String?, session: Session? = null) {
+        val uSession = session ?: activeSessionHolder.getSafeActiveSession()
+        if (selectedSpaceDataSource.currentValue?.orNull() is RoomGroupingMethod.ByLegacyGroup
+                && groupId == selectedSpaceDataSource.currentValue?.orNull()?.group()?.groupId) return
+        val activeGroup = groupId?.let { uSession?.getGroupSummary(groupId) }
+        selectedSpaceDataSource.post(Option.just(RoomGroupingMethod.ByLegacyGroup(activeGroup)))
+        if (groupId != null) {
+            GlobalScope.launch {
+                tryOrNull {
+                    uSession?.getGroup(groupId)?.fetchGroupData()
                 }
             }
         }
     }
 
+    init {
+        sessionDataSource.observe()
+                .distinctUntilChanged()
+                .subscribe {
+                    // sessionDataSource could already return a session while acitveSession holder still returns null
+                    it.orNull()?.let { session ->
+                        if (uiStateRepository.isGroupingMethodSpace(session.sessionId)) {
+                            setCurrentSpace(uiStateRepository.getSelectedSpace(session.sessionId), session)
+                        } else {
+                            setCurrentGroup(uiStateRepository.getSelectedGroup(session.sessionId), session)
+                        }
+                    }
+                }.also {
+                    compositeDisposable.add(it)
+                }
+    }
+
     fun safeActiveSpaceId(): String? {
-        return selectedSpaceDataSource.currentValue?.orNull()?.roomId?.takeIf {
-            MatrixPatterns.isRoomId(it)
-        }
+        return (selectedSpaceDataSource.currentValue?.orNull() as? RoomGroupingMethod.BySpace)?.spaceSummary?.roomId
     }
 
-    fun safeActiveSpace(): RoomSummary? {
-        return selectedSpaceDataSource.currentValue?.orNull()?.takeIf {
-            MatrixPatterns.isRoomId(it.roomId)
-        }
+    fun safeActiveGroupId(): String? {
+        return (selectedSpaceDataSource.currentValue?.orNull() as? RoomGroupingMethod.ByLegacyGroup)?.groupSummary?.groupId
     }
 
     @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
@@ -93,5 +123,16 @@ class AppStateHandler @Inject constructor(
     @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
     fun entersBackground() {
         compositeDisposable.clear()
+        val session = activeSessionHolder.getSafeActiveSession() ?: return
+        when (val currentMethod = selectedSpaceDataSource.currentValue?.orNull() ?: RoomGroupingMethod.BySpace(null)) {
+            is RoomGroupingMethod.BySpace -> {
+                uiStateRepository.storeGroupingMethod(true, session.sessionId)
+                uiStateRepository.storeSelectedSpace(currentMethod.spaceSummary?.roomId, session.sessionId)
+            }
+            is RoomGroupingMethod.ByLegacyGroup -> {
+                uiStateRepository.storeGroupingMethod(false, session.sessionId)
+                uiStateRepository.storeSelectedGroup(currentMethod.groupSummary?.groupId, session.sessionId)
+            }
+        }
     }
 }

vector/src/main/java/im/vector/app/core/di/FragmentModule.kt

@@ -51,7 +51,6 @@ import im.vector.app.features.devtools.RoomDevToolSendFormFragment
 import im.vector.app.features.devtools.RoomDevToolStateEventListFragment
 import im.vector.app.features.discovery.DiscoverySettingsFragment
 import im.vector.app.features.discovery.change.SetIdentityServerFragment
-import im.vector.app.features.grouplist.GroupListFragment
 import im.vector.app.features.home.HomeDetailFragment
 import im.vector.app.features.home.HomeDrawerFragment
 import im.vector.app.features.home.LoadingFragment
@@ -150,11 +149,6 @@ interface FragmentModule {
     @FragmentKey(LocalePickerFragment::class)
     fun bindLocalePickerFragment(fragment: LocalePickerFragment): Fragment
 
-    @Binds
-    @IntoMap
-    @FragmentKey(GroupListFragment::class)
-    fun bindGroupListFragment(fragment: GroupListFragment): Fragment
-
     @Binds
     @IntoMap
     @FragmentKey(SpaceListFragment::class)

vector/src/main/java/im/vector/app/core/di/VectorComponent.kt

@@ -35,7 +35,6 @@ import im.vector.app.features.call.webrtc.WebRtcCallManager
 import im.vector.app.features.configuration.VectorConfiguration
 import im.vector.app.features.crypto.keysrequest.KeyRequestHandler
 import im.vector.app.features.crypto.verification.IncomingVerificationRequestHandler
-import im.vector.app.features.grouplist.SelectedGroupDataSource
 import im.vector.app.features.home.AvatarRenderer
 import im.vector.app.features.home.CurrentSpaceSuggestedRoomListDataSource
 import im.vector.app.features.home.room.detail.RoomDetailPendingActionStore
@@ -115,8 +114,6 @@ interface VectorComponent {
 
     fun errorFormatter(): ErrorFormatter
 
-    fun selectedGroupStore(): SelectedGroupDataSource
-
     fun appStateHandler(): AppStateHandler
 
     fun currentSpaceSuggestedRoomListDataSource(): CurrentSpaceSuggestedRoomListDataSource