From 097dc273b02f9cfd78d5e07fb10e69f33da46936 Mon Sep 17 00:00:00 2001 From: SessionHero01 <180888785+SessionHero01@users.noreply.github.com> Date: Thu, 20 Feb 2025 10:26:17 +1100 Subject: [PATCH] [SES-2970] - Add expired groups handling (#962) --- .../securesms/ApplicationContext.java | 11 +- .../securesms/configs/ConfigToDatabaseSync.kt | 8 +- .../conversation/v2/ConversationActivityV2.kt | 48 +++--- .../conversation/v2/ConversationViewModel.kt | 13 ++ .../securesms/dependencies/PollerFactory.kt | 71 --------- .../dependencies/SessionUtilModule.kt | 35 +--- .../securesms/groups/ExpiredGroupManager.kt | 57 +++++++ .../securesms/groups/GroupManagerV2Impl.kt | 15 +- .../securesms/groups/GroupPollerManager.kt | 149 ++++++++++++++++++ .../securesms/util/AppVisibilityManager.kt | 28 ++++ .../res/layout/activity_conversation_v2.xml | 133 ++-------------- .../res/layout/view_conversation_header.xml | 84 ++++++++++ .../view_conversation_message_request_bar.xml | 59 +++++++ libsession-util/src/main/cpp/group_keys.cpp | 8 + .../loki/messenger/libsession_util/Config.kt | 2 + .../libsession_util/util/GroupInfo.kt | 3 + .../pollers/ClosedGroupPoller.kt | 21 ++- .../session/libsignal/utilities/AccountId.kt | 7 + 18 files changed, 483 insertions(+), 269 deletions(-) delete mode 100644 app/src/main/java/org/thoughtcrime/securesms/dependencies/PollerFactory.kt create mode 100644 app/src/main/java/org/thoughtcrime/securesms/groups/ExpiredGroupManager.kt create mode 100644 app/src/main/java/org/thoughtcrime/securesms/groups/GroupPollerManager.kt create mode 100644 app/src/main/java/org/thoughtcrime/securesms/util/AppVisibilityManager.kt create mode 100644 app/src/main/res/layout/view_conversation_header.xml create mode 100644 app/src/main/res/layout/view_conversation_message_request_bar.xml diff --git a/app/src/main/java/org/thoughtcrime/securesms/ApplicationContext.java b/app/src/main/java/org/thoughtcrime/securesms/ApplicationContext.java index 0d0f230ce7..683c4d943a 100644 --- a/app/src/main/java/org/thoughtcrime/securesms/ApplicationContext.java +++ b/app/src/main/java/org/thoughtcrime/securesms/ApplicationContext.java @@ -78,12 +78,13 @@ import org.thoughtcrime.securesms.dependencies.AppComponent; import org.thoughtcrime.securesms.dependencies.ConfigFactory; import org.thoughtcrime.securesms.dependencies.DatabaseComponent; import org.thoughtcrime.securesms.dependencies.DatabaseModule; -import org.thoughtcrime.securesms.dependencies.PollerFactory; import org.thoughtcrime.securesms.emoji.EmojiSource; +import org.thoughtcrime.securesms.groups.ExpiredGroupManager; import org.thoughtcrime.securesms.groups.OpenGroupManager; import org.thoughtcrime.securesms.groups.handler.AdminStateSync; import org.thoughtcrime.securesms.groups.handler.CleanupInvitationHandler; import org.thoughtcrime.securesms.groups.handler.DestroyedGroupSync; +import org.thoughtcrime.securesms.groups.GroupPollerManager; import org.thoughtcrime.securesms.groups.handler.RemoveGroupMemberHandler; import org.thoughtcrime.securesms.home.HomeActivity; import org.thoughtcrime.securesms.jobmanager.impl.NetworkConstraint; @@ -98,6 +99,7 @@ import org.thoughtcrime.securesms.service.ExpiringMessageManager; import org.thoughtcrime.securesms.service.KeyCachingService; import org.thoughtcrime.securesms.sskenvironment.ReadReceiptManager; import org.thoughtcrime.securesms.sskenvironment.TypingStatusRepository; +import org.thoughtcrime.securesms.util.AppVisibilityManager; import org.thoughtcrime.securesms.util.Broadcaster; import org.thoughtcrime.securesms.util.VersionDataFetcher; import org.thoughtcrime.securesms.webrtc.CallMessageProcessor; @@ -151,7 +153,6 @@ public class ApplicationContext extends Application implements DefaultLifecycleO @Inject MessageDataProvider messageDataProvider; @Inject TextSecurePreferences textSecurePreferences; @Inject ConfigFactory configFactory; - @Inject PollerFactory pollerFactory; @Inject LastSentTimestampCache lastSentTimestampCache; @Inject VersionDataFetcher versionDataFetcher; @Inject PushRegistrationHandler pushRegistrationHandler; @@ -175,6 +176,9 @@ public class ApplicationContext extends Application implements DefaultLifecycleO @Inject LegacyClosedGroupPollerV2 legacyClosedGroupPollerV2; @Inject LegacyGroupDeprecationManager legacyGroupDeprecationManager; @Inject CleanupInvitationHandler cleanupInvitationHandler; + @Inject AppVisibilityManager appVisibilityManager; // Exists here only to start upon app starts + @Inject GroupPollerManager groupPollerManager; // Exists here only to start upon app starts + @Inject ExpiredGroupManager expiredGroupManager; // Exists here only to start upon app starts public volatile boolean isAppVisible; public String KEYGUARD_LOCK_TAG = NonTranslatableStringConstants.APP_NAME + ":KeyguardLock"; @@ -350,7 +354,6 @@ public class ApplicationContext extends Application implements DefaultLifecycleO if (poller != null) { poller.stopIfNeeded(); } - pollerFactory.stopAll(); legacyClosedGroupPollerV2.stopAll(); versionDataFetcher.stopTimedVersionCheck(); } @@ -359,7 +362,6 @@ public class ApplicationContext extends Application implements DefaultLifecycleO public void onTerminate() { stopKovenant(); // Loki OpenGroupManager.INSTANCE.stopPolling(); - pollerFactory.stopAll(); versionDataFetcher.stopTimedVersionCheck(); super.onTerminate(); } @@ -462,7 +464,6 @@ public class ApplicationContext extends Application implements DefaultLifecycleO if (poller != null) { poller.startIfNeeded(); } - pollerFactory.startAll(); legacyClosedGroupPollerV2.start(); } diff --git a/app/src/main/java/org/thoughtcrime/securesms/configs/ConfigToDatabaseSync.kt b/app/src/main/java/org/thoughtcrime/securesms/configs/ConfigToDatabaseSync.kt index 8d7a70c141..d2efc8ceba 100644 --- a/app/src/main/java/org/thoughtcrime/securesms/configs/ConfigToDatabaseSync.kt +++ b/app/src/main/java/org/thoughtcrime/securesms/configs/ConfigToDatabaseSync.kt @@ -42,7 +42,6 @@ import org.thoughtcrime.securesms.database.MmsSmsDatabase import org.thoughtcrime.securesms.database.RecipientDatabase import org.thoughtcrime.securesms.database.ThreadDatabase import org.thoughtcrime.securesms.database.model.MmsMessageRecord -import org.thoughtcrime.securesms.dependencies.PollerFactory import org.thoughtcrime.securesms.groups.ClosedGroupManager import org.thoughtcrime.securesms.groups.OpenGroupManager import org.thoughtcrime.securesms.repository.ConversationRepository @@ -63,7 +62,6 @@ class ConfigToDatabaseSync @Inject constructor( private val storage: StorageProtocol, private val threadDatabase: ThreadDatabase, private val recipientDatabase: RecipientDatabase, - private val pollerFactory: PollerFactory, private val clock: SnodeClock, private val profileManager: ProfileManager, private val preferences: TextSecurePreferences, @@ -321,9 +319,6 @@ class ConfigToDatabaseSync @Inject constructor( groupThreadsToKeep[closedGroup.groupAccountId] = threadId storage.setPinned(threadId, closedGroup.priority == PRIORITY_PINNED) - if (!closedGroup.invited && !closedGroup.kicked) { - pollerFactory.pollerFor(closedGroup.groupAccountId)?.start() - } if (closedGroup.destroyed) { handleDestroyedGroup(threadId = threadId) @@ -332,8 +327,7 @@ class ConfigToDatabaseSync @Inject constructor( val toRemove = existingClosedGroupThreads - groupThreadsToKeep.keys Log.d(TAG, "Removing ${toRemove.size} closed groups") - toRemove.forEach { (groupId, threadId) -> - pollerFactory.pollerFor(groupId)?.stop() + toRemove.forEach { (_, threadId) -> storage.removeClosedGroupThread(threadId) } diff --git a/app/src/main/java/org/thoughtcrime/securesms/conversation/v2/ConversationActivityV2.kt b/app/src/main/java/org/thoughtcrime/securesms/conversation/v2/ConversationActivityV2.kt index ecdd66eb65..531c7ed3f9 100644 --- a/app/src/main/java/org/thoughtcrime/securesms/conversation/v2/ConversationActivityV2.kt +++ b/app/src/main/java/org/thoughtcrime/securesms/conversation/v2/ConversationActivityV2.kt @@ -481,6 +481,7 @@ class ConversationActivityV2 : PassphraseRequiredActionBarActivity(), InputBarDe updateUnreadCountIndicator() updatePlaceholder() setUpBlockedBanner() + setUpExpiredGroupBanner() binding.searchBottomBar.setEventListener(this) updateSendAfterApprovalText() setUpMessageRequests() @@ -822,9 +823,18 @@ class ConversationActivityV2 : PassphraseRequiredActionBarActivity(), InputBarDe // called from onCreate private fun setUpBlockedBanner() { val recipient = viewModel.recipient?.takeUnless { it.isGroupOrCommunityRecipient } ?: return - binding.blockedBannerTextView.text = applicationContext.getString(R.string.blockBlockedDescription) - binding.blockedBanner.isVisible = recipient.isBlocked - binding.blockedBanner.setOnClickListener { unblock() } + binding.conversationHeader.blockedBannerTextView.text = applicationContext.getString(R.string.blockBlockedDescription) + binding.conversationHeader.blockedBanner.isVisible = recipient.isBlocked + binding.conversationHeader.blockedBanner.setOnClickListener { unblock() } + } + + private fun setUpExpiredGroupBanner() { + lifecycleScope.launch { + viewModel.showExpiredGroupBanner + .collectLatest { + binding.conversationHeader.groupExpiredBanner.isVisible = it + } + } } private fun setUpOutdatedClientBanner() { @@ -833,13 +843,13 @@ class ConversationActivityV2 : PassphraseRequiredActionBarActivity(), InputBarDe val shouldShowLegacy = ExpirationConfiguration.isNewConfigEnabled && legacyRecipient != null - binding.outdatedDisappearingBanner.isVisible = shouldShowLegacy + binding.conversationHeader.outdatedDisappearingBanner.isVisible = shouldShowLegacy if (shouldShowLegacy) { val txt = Phrase.from(this, R.string.disappearingMessagesLegacy) .put(NAME_KEY, legacyRecipient!!.toShortString()) .format() - binding.outdatedDisappearingBannerTextView.text = txt + binding.conversationHeader.outdatedDisappearingBannerTextView.text = txt } } @@ -848,11 +858,11 @@ class ConversationActivityV2 : PassphraseRequiredActionBarActivity(), InputBarDe viewModel.legacyGroupBanner .collectLatest { banner -> if (banner == null) { - binding.outdatedGroupBanner.isVisible = false - binding.outdatedGroupBanner.text = null + binding.conversationHeader.outdatedGroupBanner.isVisible = false + binding.conversationHeader.outdatedGroupBanner.text = null } else { - binding.outdatedGroupBanner.isVisible = true - binding.outdatedGroupBanner.text = SpannableStringBuilder(banner) + binding.conversationHeader.outdatedGroupBanner.isVisible = true + binding.conversationHeader.outdatedGroupBanner.text = SpannableStringBuilder(banner) .apply { // Append a space as a placeholder append(" ") @@ -875,7 +885,7 @@ class ConversationActivityV2 : PassphraseRequiredActionBarActivity(), InputBarDe ) } - binding.outdatedGroupBanner.setOnClickListener { + binding.conversationHeader.outdatedGroupBanner.setOnClickListener { showOpenUrlDialog("https://getsession.org/groups") } } @@ -1018,7 +1028,7 @@ class ConversationActivityV2 : PassphraseRequiredActionBarActivity(), InputBarDe runOnUiThread { val threadRecipient = viewModel.recipient ?: return@runOnUiThread if (threadRecipient.isContactRecipient) { - binding.blockedBanner.isVisible = threadRecipient.isBlocked + binding.conversationHeader.blockedBanner.isVisible = threadRecipient.isBlocked } invalidateOptionsMenu() updateSendAfterApprovalText() @@ -1035,15 +1045,15 @@ class ConversationActivityV2 : PassphraseRequiredActionBarActivity(), InputBarDe } private fun setUpMessageRequests() { - binding.acceptMessageRequestButton.setOnClickListener { + binding.messageRequestBar.acceptMessageRequestButton.setOnClickListener { viewModel.acceptMessageRequest() } - binding.messageRequestBlock.setOnClickListener { + binding.messageRequestBar.messageRequestBlock.setOnClickListener { block(deleteThread = true) } - binding.declineMessageRequestButton.setOnClickListener { + binding.messageRequestBar.declineMessageRequestButton.setOnClickListener { fun doDecline() { viewModel.declineMessageRequest() finish() @@ -1063,12 +1073,12 @@ class ConversationActivityV2 : PassphraseRequiredActionBarActivity(), InputBarDe .map { it.messageRequestState } .distinctUntilChanged() .collectLatest { state -> - binding.messageRequestBar.isVisible = state is MessageRequestUiState.Visible + binding.messageRequestBar.root.isVisible = state is MessageRequestUiState.Visible if (state is MessageRequestUiState.Visible) { - binding.sendAcceptsTextView.setText(state.acceptButtonText) - binding.messageRequestBlock.isVisible = state.blockButtonText != null - binding.messageRequestBlock.text = state.blockButtonText + binding.messageRequestBar.sendAcceptsTextView.setText(state.acceptButtonText) + binding.messageRequestBar.messageRequestBlock.isVisible = state.blockButtonText != null + binding.messageRequestBar.messageRequestBlock.text = state.blockButtonText } } } @@ -1076,7 +1086,7 @@ class ConversationActivityV2 : PassphraseRequiredActionBarActivity(), InputBarDe } private fun acceptMessageRequest() { - binding.messageRequestBar.isVisible = false + binding.messageRequestBar.root.isVisible = false viewModel.acceptMessageRequest() } diff --git a/app/src/main/java/org/thoughtcrime/securesms/conversation/v2/ConversationViewModel.kt b/app/src/main/java/org/thoughtcrime/securesms/conversation/v2/ConversationViewModel.kt index 0be440c334..c1d8b6a2ea 100644 --- a/app/src/main/java/org/thoughtcrime/securesms/conversation/v2/ConversationViewModel.kt +++ b/app/src/main/java/org/thoughtcrime/securesms/conversation/v2/ConversationViewModel.kt @@ -16,6 +16,7 @@ import dagger.hilt.android.qualifiers.ApplicationContext import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.GlobalScope import kotlinx.coroutines.channels.consumeEach +import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.MutableSharedFlow import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.SharedFlow @@ -23,6 +24,7 @@ import kotlinx.coroutines.flow.SharingStarted import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.combine import kotlinx.coroutines.flow.filterNotNull +import kotlinx.coroutines.flow.flowOf import kotlinx.coroutines.flow.map import kotlinx.coroutines.flow.stateIn import kotlinx.coroutines.flow.update @@ -60,6 +62,7 @@ import org.thoughtcrime.securesms.database.model.MessageId import org.thoughtcrime.securesms.database.model.MessageRecord import org.thoughtcrime.securesms.database.model.MmsMessageRecord import org.thoughtcrime.securesms.dependencies.ConfigFactory +import org.thoughtcrime.securesms.groups.ExpiredGroupManager import org.thoughtcrime.securesms.groups.OpenGroupManager import org.thoughtcrime.securesms.mms.AudioSlide import org.thoughtcrime.securesms.repository.ConversationRepository @@ -82,6 +85,7 @@ class ConversationViewModel( private val configFactory: ConfigFactory, private val groupManagerV2: GroupManagerV2, val legacyGroupDeprecationManager: LegacyGroupDeprecationManager, + private val expiredGroupManager: ExpiredGroupManager, ) : ViewModel() { val showSendAfterApprovalText: Boolean @@ -245,6 +249,13 @@ class ConversationViewModel( && state != LegacyGroupDeprecationManager.DeprecationState.NOT_DEPRECATING }.stateIn(viewModelScope, SharingStarted.Eagerly, false) + val showExpiredGroupBanner: Flow = if (recipient?.isGroupV2Recipient != true) { + flowOf(false) + } else { + val groupId = AccountId(recipient!!.address.toString()) + expiredGroupManager.expiredGroups.map { groupId in it } + } + private val attachmentDownloadHandler = AttachmentDownloadHandler( storage = storage, messageDataProvider = messageDataProvider, @@ -1089,6 +1100,7 @@ class ConversationViewModel( private val configFactory: ConfigFactory, private val groupManagerV2: GroupManagerV2, private val legacyGroupDeprecationManager: LegacyGroupDeprecationManager, + private val expiredGroupManager: ExpiredGroupManager, ) : ViewModelProvider.Factory { override fun create(modelClass: Class): T { @@ -1107,6 +1119,7 @@ class ConversationViewModel( configFactory = configFactory, groupManagerV2 = groupManagerV2, legacyGroupDeprecationManager = legacyGroupDeprecationManager, + expiredGroupManager = expiredGroupManager, ) as T } } diff --git a/app/src/main/java/org/thoughtcrime/securesms/dependencies/PollerFactory.kt b/app/src/main/java/org/thoughtcrime/securesms/dependencies/PollerFactory.kt deleted file mode 100644 index 2cebce488d..0000000000 --- a/app/src/main/java/org/thoughtcrime/securesms/dependencies/PollerFactory.kt +++ /dev/null @@ -1,71 +0,0 @@ -package org.thoughtcrime.securesms.dependencies - -import dagger.Lazy -import kotlinx.coroutines.CoroutineDispatcher -import kotlinx.coroutines.CoroutineScope -import network.loki.messenger.libsession_util.util.GroupInfo -import org.session.libsession.database.StorageProtocol -import org.session.libsession.messaging.groups.GroupManagerV2 -import org.session.libsession.messaging.sending_receiving.pollers.ClosedGroupPoller -import org.session.libsession.snode.SnodeClock -import org.session.libsession.utilities.getGroup -import org.session.libsignal.database.LokiAPIDatabaseProtocol -import org.session.libsignal.utilities.AccountId -import java.util.concurrent.ConcurrentHashMap - -class PollerFactory( - private val scope: CoroutineScope, - private val executor: CoroutineDispatcher, - private val configFactory: ConfigFactory, - private val groupManagerV2: Lazy, - private val storage: Lazy, - private val lokiApiDatabase: LokiAPIDatabaseProtocol, - private val clock: SnodeClock, - ) { - - private val pollers = ConcurrentHashMap() - - fun pollerFor(sessionId: AccountId): ClosedGroupPoller? { - // Check if the group is currently in our config and approved, don't start if it isn't - val invited = configFactory.getGroup(sessionId)?.invited - - if (invited != false) return null - - return pollers.getOrPut(sessionId) { - ClosedGroupPoller( - scope = scope, - executor = executor, - closedGroupSessionId = sessionId, - configFactoryProtocol = configFactory, - groupManagerV2 = groupManagerV2.get(), - storage = storage.get(), - lokiApiDatabase = lokiApiDatabase, - clock = clock, - ) - } - } - - fun startAll() { - configFactory - .withUserConfigs { it.userGroups.allClosedGroupInfo() } - .filterNot(GroupInfo.ClosedGroupInfo::invited) - .forEach { pollerFor(it.groupAccountId)?.start() } - } - - fun stopAll() { - pollers.forEach { (_, poller) -> - poller.stop() - } - } - - fun updatePollers() { - val currentGroups = configFactory - .withUserConfigs { it.userGroups.allClosedGroupInfo() }.filterNot(GroupInfo.ClosedGroupInfo::invited) - val toRemove = pollers.filter { (id, _) -> id !in currentGroups.map { it.groupAccountId } } - toRemove.forEach { (id, _) -> - pollers.remove(id)?.stop() - } - startAll() - } - -} \ No newline at end of file diff --git a/app/src/main/java/org/thoughtcrime/securesms/dependencies/SessionUtilModule.kt b/app/src/main/java/org/thoughtcrime/securesms/dependencies/SessionUtilModule.kt index 1ead123b59..9be41c1191 100644 --- a/app/src/main/java/org/thoughtcrime/securesms/dependencies/SessionUtilModule.kt +++ b/app/src/main/java/org/thoughtcrime/securesms/dependencies/SessionUtilModule.kt @@ -1,38 +1,32 @@ package org.thoughtcrime.securesms.dependencies -import android.content.Context -import dagger.Lazy import dagger.Module import dagger.Provides import dagger.hilt.InstallIn -import dagger.hilt.android.qualifiers.ApplicationContext import dagger.hilt.components.SingletonComponent import kotlinx.coroutines.CoroutineDispatcher import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.DelicateCoroutinesApi import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.GlobalScope import org.session.libsession.database.StorageProtocol -import org.session.libsession.messaging.groups.GroupManagerV2 import org.session.libsession.messaging.groups.GroupScope import org.session.libsession.messaging.groups.LegacyGroupDeprecationManager +import org.session.libsession.messaging.sending_receiving.pollers.ClosedGroupPoller import org.session.libsession.messaging.sending_receiving.pollers.LegacyClosedGroupPollerV2 import org.session.libsession.snode.SnodeClock -import org.session.libsession.utilities.ConfigFactoryProtocol import org.session.libsession.utilities.TextSecurePreferences -import org.session.libsignal.database.LokiAPIDatabaseProtocol -import org.thoughtcrime.securesms.database.ConfigDatabase -import org.thoughtcrime.securesms.database.ThreadDatabase import javax.inject.Named import javax.inject.Singleton -@Suppress("OPT_IN_USAGE") +const val POLLER_SCOPE = "poller_coroutine_scope" + @Module @InstallIn(SingletonComponent::class) object SessionUtilModule { - private const val POLLER_SCOPE = "poller_coroutine_scope" - + @OptIn(DelicateCoroutinesApi::class) @Provides @Named(POLLER_SCOPE) fun providePollerScope(): CoroutineScope = GlobalScope @@ -42,24 +36,6 @@ object SessionUtilModule { @Named(POLLER_SCOPE) fun provideExecutor(): CoroutineDispatcher = Dispatchers.IO.limitedParallelism(1) - @Provides - @Singleton - fun providePollerFactory(@Named(POLLER_SCOPE) coroutineScope: CoroutineScope, - @Named(POLLER_SCOPE) dispatcher: CoroutineDispatcher, - configFactory: ConfigFactory, - storage: Lazy, - groupManagerV2: Lazy, - lokiApiDatabase: LokiAPIDatabaseProtocol, - clock: SnodeClock) = PollerFactory( - scope = coroutineScope, - executor = dispatcher, - configFactory = configFactory, - groupManagerV2 = groupManagerV2, - storage = storage, - lokiApiDatabase = lokiApiDatabase, - clock = clock, - ) - @Provides @Singleton fun provideSnodeClock() = SnodeClock() @@ -77,6 +53,7 @@ object SessionUtilModule { return LegacyClosedGroupPollerV2(storage, deprecationManager) } + @Provides @Singleton fun provideLegacyGroupDeprecationManager(prefs: TextSecurePreferences): LegacyGroupDeprecationManager { diff --git a/app/src/main/java/org/thoughtcrime/securesms/groups/ExpiredGroupManager.kt b/app/src/main/java/org/thoughtcrime/securesms/groups/ExpiredGroupManager.kt new file mode 100644 index 0000000000..0483d748b2 --- /dev/null +++ b/app/src/main/java/org/thoughtcrime/securesms/groups/ExpiredGroupManager.kt @@ -0,0 +1,57 @@ +package org.thoughtcrime.securesms.groups + +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.flow.SharingStarted +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.mapNotNull +import kotlinx.coroutines.flow.scan +import kotlinx.coroutines.flow.stateIn +import org.session.libsession.messaging.sending_receiving.pollers.ClosedGroupPoller +import org.session.libsignal.utilities.AccountId +import org.session.libsignal.utilities.Log +import javax.inject.Inject +import javax.inject.Singleton + +/** + * This class keeps track of what groups are expired. + * + * This is done by listening to the state of all group pollers and keeping track of last + * known expired state of each group. + * + * The end result is not persisted and is only available in memory. + */ +@Singleton +class ExpiredGroupManager @Inject constructor( + pollerManager: GroupPollerManager, +) { + @Suppress("OPT_IN_USAGE") + val expiredGroups: StateFlow> = pollerManager.watchAllGroupPollingState() + .mapNotNull { (groupId, state) -> + val expired = (state as? ClosedGroupPoller.StartedState)?.expired + + if (expired == null) { + // Poller doesn't know about the expiration state yet, so we skip + // the this update. It's important we do this as we want to use the + // "last known state" if the poller doesn't know about the expiration state yet. + return@mapNotNull null + } + + groupId to expired + } + + // This scan keep track of all expired groups. Whenever there is a new state for a group + // poller, we compare the state with the previous state and update the set of expired groups. + .scan(emptySet()) { previous, (groupId, expired) -> + if (expired && groupId !in previous) { + Log.d("ExpiredGroupManager", "Marking group $groupId expired.") + previous + groupId + } else if (!expired && groupId in previous) { + Log.d("ExpiredGroupManager", "Unmarking group $groupId expired.") + previous - groupId + } else { + previous + } + } + + .stateIn(GlobalScope, SharingStarted.Eagerly, emptySet()) +} \ No newline at end of file diff --git a/app/src/main/java/org/thoughtcrime/securesms/groups/GroupManagerV2Impl.kt b/app/src/main/java/org/thoughtcrime/securesms/groups/GroupManagerV2Impl.kt index 350640c230..c91aa09df2 100644 --- a/app/src/main/java/org/thoughtcrime/securesms/groups/GroupManagerV2Impl.kt +++ b/app/src/main/java/org/thoughtcrime/securesms/groups/GroupManagerV2Impl.kt @@ -63,7 +63,6 @@ import org.thoughtcrime.securesms.database.LokiMessageDatabase import org.thoughtcrime.securesms.database.MmsSmsDatabase import org.thoughtcrime.securesms.database.ThreadDatabase import org.thoughtcrime.securesms.dependencies.ConfigFactory -import org.thoughtcrime.securesms.dependencies.PollerFactory import org.thoughtcrime.securesms.util.SessionMetaProtocol import java.util.concurrent.TimeUnit import javax.inject.Inject @@ -78,7 +77,6 @@ class GroupManagerV2Impl @Inject constructor( private val mmsSmsDatabase: MmsSmsDatabase, private val lokiDatabase: LokiMessageDatabase, private val threadDatabase: ThreadDatabase, - private val pollerFactory: PollerFactory, private val profileManager: SSKEnvironment.ProfileManagerProtocol, @ApplicationContext val application: Context, private val clock: SnodeClock, @@ -86,6 +84,7 @@ class GroupManagerV2Impl @Inject constructor( private val lokiAPIDatabase: LokiAPIDatabase, private val configUploader: ConfigUploader, private val scope: GroupScope, + private val groupPollerManager: GroupPollerManager, ) : GroupManagerV2 { private val dispatcher = Dispatchers.Default @@ -196,7 +195,6 @@ class GroupManagerV2Impl @Inject constructor( profileManager.setName(application, recipient, groupName) storage.setRecipientApprovedMe(recipient, true) storage.setRecipientApproved(recipient, true) - pollerFactory.updatePollers() // Invite members JobQueue.shared.add( @@ -494,8 +492,6 @@ class GroupManagerV2Impl @Inject constructor( } } - pollerFactory.pollerFor(groupId)?.stop() - // Delete conversation and group configs storage.getThreadId(Address.fromSerialized(groupId.hexString)) ?.let(storage::deleteConversation) @@ -678,14 +674,12 @@ class GroupManagerV2Impl @Inject constructor( )) } - val poller = checkNotNull(pollerFactory.pollerFor(group.groupAccountId)) { "Unable to start a poller for groups " } - poller.start() - // We need to wait until we have the first data polled from the poller, otherwise // we won't have the necessary configs to send invite response/or do anything else. // We can't hang on here forever if things don't work out, bail out if it's the camse withTimeout(20_000L) { - poller.state.filterIsInstance() + groupPollerManager.watchGroupPollingState(group.groupAccountId) + .filterIsInstance() .filter { it.hadAtLeastOneSuccessfulPoll } .first() } @@ -905,9 +899,6 @@ class GroupManagerV2Impl @Inject constructor( override suspend fun handleKicked(groupId: AccountId): Unit = scope.launchAndWait(groupId, "Handle kicked") { Log.d(TAG, "We were kicked from the group, delete and stop polling") - // Stop polling the group immediately - pollerFactory.pollerFor(groupId)?.stop() - val userId = requireNotNull(storage.getUserPublicKey()) { "No current user available" } val group = configFactory.getGroup(groupId) ?: return@launchAndWait diff --git a/app/src/main/java/org/thoughtcrime/securesms/groups/GroupPollerManager.kt b/app/src/main/java/org/thoughtcrime/securesms/groups/GroupPollerManager.kt new file mode 100644 index 0000000000..02080c70bd --- /dev/null +++ b/app/src/main/java/org/thoughtcrime/securesms/groups/GroupPollerManager.kt @@ -0,0 +1,149 @@ +package org.thoughtcrime.securesms.groups + +import dagger.Lazy +import kotlinx.coroutines.CoroutineDispatcher +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.GlobalScope +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.SharingStarted +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.flow.distinctUntilChanged +import kotlinx.coroutines.flow.filter +import kotlinx.coroutines.flow.flatMapLatest +import kotlinx.coroutines.flow.flowOf +import kotlinx.coroutines.flow.map +import kotlinx.coroutines.flow.merge +import kotlinx.coroutines.flow.onStart +import kotlinx.coroutines.flow.scan +import kotlinx.coroutines.flow.stateIn +import org.session.libsession.database.StorageProtocol +import org.session.libsession.messaging.groups.GroupManagerV2 +import org.session.libsession.messaging.sending_receiving.pollers.ClosedGroupPoller +import org.session.libsession.snode.SnodeClock +import org.session.libsession.utilities.ConfigUpdateNotification +import org.session.libsession.utilities.TextSecurePreferences +import org.session.libsignal.database.LokiAPIDatabaseProtocol +import org.session.libsignal.utilities.AccountId +import org.session.libsignal.utilities.Log +import org.thoughtcrime.securesms.dependencies.ConfigFactory +import org.thoughtcrime.securesms.dependencies.POLLER_SCOPE +import org.thoughtcrime.securesms.util.AppVisibilityManager +import javax.inject.Inject +import javax.inject.Named +import javax.inject.Singleton + +/** + * This class manages the lifecycle of group pollers. + * + * It listens for changes in the user's groups config and starts or stops pollers as needed. It + * also considers the app's visibility state to decide whether to start or stop pollers. + * + * All the processes here are automatic and you don't need to do anything to start or stop pollers. + * + * This class also provide state monitoring facilities to check the state of a group poller. + */ +@Singleton +class GroupPollerManager @Inject constructor( + @Named(POLLER_SCOPE) scope: CoroutineScope, + @Named(POLLER_SCOPE) executor: CoroutineDispatcher, + configFactory: ConfigFactory, + groupManagerV2: Lazy, + storage: StorageProtocol, + lokiApiDatabase: LokiAPIDatabaseProtocol, + clock: SnodeClock, + preferences: TextSecurePreferences, + appVisibilityManager: AppVisibilityManager, +) { + @Suppress("OPT_IN_USAGE") + private val activeGroupPollers: StateFlow> = + combine( + preferences.watchLocalNumber(), + appVisibilityManager.isAppVisible + ) { localNumber, visible -> localNumber != null && visible } + .distinctUntilChanged() + + // This flatMap produces a flow of groups that should be polled now + .flatMapLatest { shouldPoll -> + if (shouldPoll) { + (configFactory.configUpdateNotifications + .filter { it is ConfigUpdateNotification.UserConfigsMerged || it == ConfigUpdateNotification.UserConfigsModified } as Flow<*>) + .onStart { emit(Unit) } + .map { + configFactory.withUserConfigs { it.userGroups.allClosedGroupInfo() } + .mapNotNullTo(hashSetOf()) { group -> + group.groupAccountId.takeIf { group.shouldPoll } + } + } + .distinctUntilChanged() + } else { + // There shouldn't be any group polling at this stage + flowOf(emptySet()) + } + } + + // This scan compares the previous active group pollers with the incoming set of groups + // that should be polled now, to work out which pollers should be started or stopped, + // and finally emits the new state + .scan(emptyMap()) { previous, newActiveGroupIDs -> + // Go through previous pollers and stop those that are not in the new set + for ((groupId, poller) in previous) { + if (groupId !in newActiveGroupIDs) { + Log.d(TAG, "Stopping poller for $groupId") + poller.stop() + } + } + + // Go through new set, pick the existing pollers and create/start those that are + // not in the previous map + newActiveGroupIDs.associateWith { groupId -> + var poller = previous[groupId] + + if (poller == null) { + Log.d(TAG, "Starting poller for $groupId") + poller = ClosedGroupPoller( + scope = scope, + executor = executor, + closedGroupSessionId = groupId, + configFactoryProtocol = configFactory, + groupManagerV2 = groupManagerV2.get(), + storage = storage, + lokiApiDatabase = lokiApiDatabase, + clock = clock, + ).also { it.start() } + } + + poller + } + } + + .stateIn(GlobalScope, SharingStarted.Eagerly, emptyMap()) + + + @Suppress("OPT_IN_USAGE") + fun watchGroupPollingState(groupId: AccountId): Flow { + return activeGroupPollers + .flatMapLatest { pollers -> + pollers[groupId]?.state ?: flowOf(ClosedGroupPoller.IdleState) + } + .distinctUntilChanged() + } + + @OptIn(ExperimentalCoroutinesApi::class) + fun watchAllGroupPollingState(): Flow> { + return activeGroupPollers + .flatMapLatest { pollers -> + // Merge all poller states into a single flow of (groupId, state) pairs + merge( + *pollers + .map { (id, poller) -> poller.state.map { state -> id to state } } + .toTypedArray() + ) + } + } + + companion object { + private const val TAG = "GroupPollerHandler" + } +} diff --git a/app/src/main/java/org/thoughtcrime/securesms/util/AppVisibilityManager.kt b/app/src/main/java/org/thoughtcrime/securesms/util/AppVisibilityManager.kt new file mode 100644 index 0000000000..78016d3ccc --- /dev/null +++ b/app/src/main/java/org/thoughtcrime/securesms/util/AppVisibilityManager.kt @@ -0,0 +1,28 @@ +package org.thoughtcrime.securesms.util + +import androidx.lifecycle.DefaultLifecycleObserver +import androidx.lifecycle.LifecycleOwner +import androidx.lifecycle.ProcessLifecycleOwner +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import javax.inject.Inject +import javax.inject.Singleton + +@Singleton +class AppVisibilityManager @Inject constructor() { + private val mutableIsAppVisible = MutableStateFlow(false) + + init { + ProcessLifecycleOwner.get().lifecycle.addObserver(object : DefaultLifecycleObserver { + override fun onStart(owner: LifecycleOwner) { + mutableIsAppVisible.value = true + } + + override fun onStop(owner: LifecycleOwner) { + mutableIsAppVisible.value = false + } + }) + } + + val isAppVisible: StateFlow get() = mutableIsAppVisible +} diff --git a/app/src/main/res/layout/activity_conversation_v2.xml b/app/src/main/res/layout/activity_conversation_v2.xml index e1cbfd83d2..55fa1bd1af 100644 --- a/app/src/main/res/layout/activity_conversation_v2.xml +++ b/app/src/main/res/layout/activity_conversation_v2.xml @@ -37,10 +37,11 @@ android:id="@+id/conversationRecyclerView" android:layout_width="match_parent" android:layout_height="0dp" + tools:visibility="gone" app:layout_constraintVertical_weight="1" app:layout_constraintStart_toStartOf="parent" app:layout_constraintBottom_toTopOf="@+id/typingIndicatorViewContainer" - app:layout_constraintTop_toBottomOf="@id/outdatedGroupBanner" /> + app:layout_constraintTop_toBottomOf="@id/conversation_header" /> + tools:text="8" /> @@ -223,70 +225,12 @@ android:visibility="gone" app:layout_constraintBottom_toBottomOf="parent" /> - - - - - - - - - - - - - + layout="@layout/view_conversation_header" /> - - - - - - - - -