Switching user cause ChannelScreen goes in an infinite loop and no chats are shown

[geolyth]

Describe the bug
Trying to switch the user, the second one logged is not able to see chats. It remains in an infinite loop.

SDK version

• 6.27.0

To Reproduce
Steps to reproduce the behavior:

1. Log in with user A
2. ChannelsScreen loads the channels
3. Logout (calling disconnect(flushPersistence = true)?.await()
4. Log in with user B
5. ChannelsScreen not load anything but in the log all seems correct

Expected behavior
Switching the user the ChannelsScreen works

Device:

• Vendor and model: Any
• Android version: Any

[geolyth]

@VelikovPetar I found a workaround to switch the user but it should be not a good one...so I hope another approach exists to fix this...after the disconnect is called I trigger this function:

private fun restartApp() {
        Timber.i("Restarting app for complete cleanup...")
        try {
            val packageManager = context.packageManager
            val intent = packageManager.getLaunchIntentForPackage(context.packageName)
            intent?.let { launchIntent ->
                launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
                context.startActivity(launchIntent)
            }

            // Kill all processes and activities
            android.os.Process.killProcess(android.os.Process.myPid())
            exitProcess(0)
        } catch (e: Exception) {
            Timber.e(e, "Error restarting app, forcing complete exit")
            android.os.Process.killProcess(android.os.Process.myPid())
            exitProcess(0)
        }
    }

[VelikovPetar]

Hi @geolyth, this sounds strange and it shouldn't happen.
Can you check what do the connect and disconnect calls return? If they return an error, it would mean that the user was not connected/disconnected, so the ChatClient might not be in a state where it could show the channel list. Killing the app is definitely not necessary, most likely something goes wrong during the connect / disconnect calls.

[geolyth]

@VelikovPetar I have this code for the disconnect:

_chatClient.value?.disconnect(flushPersistence = true)?.enqueue { result ->
                    when(result) {
                        is Result.Success -> {
                            // Reset all internal state
                            _chatClient.value = null
                            _isInitialized.value = false
                            _connectionState.value = ChatConnectionState.Disconnected
                            currentUserId = null
                        }
                        is Result.Failure -> {
                            Timber.e("Error disconnecting Stream Chat: ${result.errorOrNull()?.message}")
                        }
                    }
                }

And the method always goes in the Success for a logout.

I also printed some logs and the outcome is:

User change detected (current: null, new: user_38961) - initializing chat client
Initializing Stream Chat with API Key: XXX, User ID: user_38961
Stream Chat initialized successfully
Stream Chat disconnected and user ID reset
(Logout executed)
User change detected (current: null, new: user_6915) - initializing chat client
Initializing Stream Chat with API Key: XXX, User ID: user_6915
Stream Chat initialized successfully
Stream Chat disconnected and user ID reset

The outcome, without killing the app, is that when the chat tab is opened again I am not able to see channels.

[VelikovPetar]

Is it possible that the ChannelListViewModel is persisted across the different sessions of the ChatClient?
For example if the ViewModel is scoped to an Activity, but your login screen / chat list screen are used in fragments, it is possible that the ChannelListViewModel instantiated in the first session, it still persisted and used in the second session (with the second user)?

Can you please check if a different instance of the ViewModel is used for the different user sessions?

[geolyth]

@VelikovPetar my app is in pure Compose so I have only one Activity.
I am using

ChannelsScreen(
            viewModelFactory = channelViewModelFactory,
            viewModelKey = channelViewModelKey,
            isShowingHeader = false,
            searchMode = SearchMode.Messages,
            onChannelClick = { channel ->
                onIntent(ChatsIntent.NavigateToChannel(channel.cid))
            },
        )

I also tried to pass a new channelViewModelKey but the issue still exists.

[geolyth]

@VelikovPetar Maybe this #6022 could be related to mine?

[VelikovPetar]

Hi @geolyth,

I think that it is possible that the linked issue is related to yours - can you check if the same channelViewModelFactory/channelViewModel instance is preserved between the different user sessions? If yes, you would need to make sure that a different instance of the ChannelViewModelFactory is also created across the sessions, so that it can used be used to re-create the ViewModel for the new user. Note that this is extremely important because the ViewModelFactory will most likely be referencing a filter matching equality on the current user:

ChannelViewModelFactory(
            chatClient = chatClient,
            filters = Filters.and(
                Filters.eq("type", "messaging"),
                Filters.`in`("members", listOf(currentUserId)), // <-- The factory must be recreated after a user switch, otherwise it will reference the old `userId`
            ),
        )

So if the old factory is used, while logged in with a different user, most likely no channels will be returned because they won't match the userId equality filter.

Best regards,
Petar

[geolyth]

@VelikovPetar I also cleared all the viewmodels attached to the Activity but currently the only way to have a switch user working properly seems to execute this code after I cleaned up all:

private fun restartApp() {
        Timber.i("Restarting app for complete cleanup...")
        try {
            val packageManager = context.packageManager
            val intent = packageManager.getLaunchIntentForPackage(context.packageName)
            intent?.let { launchIntent ->
                launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
                context.startActivity(launchIntent)
            }

            // Kill all processes and activities
            android.os.Process.killProcess(android.os.Process.myPid())
            exitProcess(0)
        } catch (e: Exception) {
            Timber.e(e, "Error restarting app, forcing complete exit")
            android.os.Process.killProcess(android.os.Process.myPid())
            exitProcess(0)
        }
    }

[VelikovPetar]

Hi @geolyth,

Would it be possible to try something like the following:

@Composable
    fun ChannelsContent(
        userId: String,
    ) {
        val factory = remember(userId) {
            ChannelViewModelFactory(
                chatClient = ChatClient.instance(),
                querySort = QuerySortByField.descByName("last_updated"),
                filters = Filters.and(
                    Filters.eq("type", "messaging"),
                    Filters.`in`("members", listOf(userId)),
                ),
            )
        }

        // Key forces ViewModel recreation when userId
        val viewModel: ChannelListViewModel = viewModel(
            key = "channels_$userId",
            factory = factory,
        )

        // Use viewModel...
    }

The idea is to create a new ChannelViewModelFactory AND ChannelListViewModel whenever the userId changes. You can observe the changes in the currently logged in user via the:

val user by ChatClient.instance().clientState.user.collectAsStateWithLifecycle()

Let me know if this makes any difference.

Bets regards,
Petar

[geolyth]

Hey @VelikovPetar ,
I alreay tried also in that way and the outcome is the same, seems something goes wrong in the rendering of the ChannelsScreen because I see userId changed.
Is there I can see in the GS logs from the viewmodel/UI to understand what happens on the rendering side?

Currently when I try to switch the user (with a logout) and I try to open again the ChannelsScreen I see that loader and nothing else.

[VelikovPetar]

Hey @geolyth,

Could you maybe share your implementation of the ChannelsScreen + the login/logout logic? I would like to see how the Channels screen is switched with the login screen composables.

I would like to implement a similar scenario in our sample app to reproduce it properly, it will help us with the analysis.

Thanks,
Petar

[geolyth]

Hey @VelikovPetar ,
copying all the current implementation is a bit hard for me because it is pretty much complex.
I can try to provide more informations and copy/paste some important code blocks.

A bit of context, currently I have one activity and all the views lives in Compose (and use Hilt for DI). I also have a ChatManager that wraps ChatClient to execute all the operations (so only ChatManager is used around the app and it is consistent because I always checked the data before to use it).
ChatManager is executed only after a successfull login using dynamic data coming from an API and it executes disconnection if a logout is clicked by the user.

This is the significant code for ChatManager.

@Singleton
class ChatManager @Inject constructor(
    ...
) {
    // Coroutine scope for managing async operations with supervisor job for error isolation
    private val scope = CoroutineScope(SupervisorJob() + dispatcher)

    // Internal mutable state for the chat client instance
    private val _chatClient = MutableStateFlow<ChatClient?>(null)

    // Internal mutable state for initialization status
    private val _isInitialized = MutableStateFlow(false)

    /**
     * Indicates whether the chat client is successfully initialized and ready for use.
     */
    val isInitialized: Flow<Boolean> = _isInitialized.asStateFlow()

    // Internal mutable state for connection status
    private val _connectionState = MutableStateFlow<ChatConnectionState>(ChatConnectionState.Disconnected)

    /**
     * Current connection state of the chat client.
     * Provides detailed information about connection status, errors, and connected user.
     */
    val connectionState: Flow<ChatConnectionState> = _connectionState.asStateFlow()

    // Track the current user ID to detect user changes
    private var currentUserId: String? = null

    init {
        // Start observing chat configuration changes immediately
        observeChatConfiguration()
    }

    /**
     * Observes chat configuration changes and manages client lifecycle accordingly.
     * Automatically initializes or disconnects the client based on configuration validity.
     * Only reinitializes the client when switching users or on first login.
     */
    private fun observeChatConfiguration() {
        scope.launch {
            chatConfigRepository.getChatConfig()
                .distinctUntilChanged() // Only react to actual configuration changes
                .collect { chatConfig ->
                    if (chatConfig != null && chatConfig.isEnabled &&
                        chatConfig.apiKey.isNotBlank() &&
                        chatConfig.userToken.isNotBlank() &&
                        chatConfig.userId.isNotBlank() &&
                        chatConfig.pushNotificationProvider.isNotBlank()
                    ) {
                        // Check if this is a new user or first time initialization
                        val isNewUser = currentUserId != chatConfig.userId

                        if (isNewUser) {
                            // New user detected or first initialization - initialize the client
                            Timber.d(
                                "User change detected (current: $currentUserId, " +
                                    "new: ${chatConfig.userId}) - initializing chat client"
                            )
                            currentUserId = chatConfig.userId
                            initializeChatClient(
                                chatConfig.apiKey,
                                chatConfig.userToken,
                                chatConfig.userId,
                                chatConfig.pushNotificationProvider,
                            )
                        } else {
                            // Same user, check if client needs connection (might have been disconnected)
                            if (_chatClient.value == null || _connectionState.value !is ChatConnectionState.Connected) {
                                Timber.d("Same user but client disconnected - reconnecting existing client")
                                _chatClient.value?.let { client ->
                                    val user = User(id = chatConfig.userId)
                                    connectUser(client, user, chatConfig.userToken)
                                }
                            } else {
                                Timber.d("Same user and client already connected - no action needed")
                            }
                        }
                    } else {
                        // Invalid or disabled configuration - disconnect the client and reset user
                        currentUserId = null
                        disconnectChatClient()
                    }
                }
        }
    }

    /**
     * Initializes the Stream Chat client with the provided configuration.
     *
     * This method sets up the client with offline support, state management,
     * and appropriate logging based on build configuration.
     *
     * @param apiKey The Stream Chat API key
     * @param userToken The user's authentication token
     * @param userId The unique identifier for the user
     */
    private suspend fun initializeChatClient(
        apiKey: String,
        userToken: String,
        userId: String,
        pushNotificationProvider: String,
    ) {
        withContext(dispatcher) {
            try {
                Timber.d("Initializing Stream Chat with API Key: $apiKey, User ID: $userId")
                _connectionState.value = ChatConnectionState.Connecting

                val notificationConfig = NotificationConfig(
                    pushDeviceGenerators = listOf(
                        FirebasePushDeviceGenerator(
                            context = context,
                            providerName = pushNotificationProvider,
                        ),
                    ),
                    ignorePushMessagesWhenUserOnline = false,
                    autoTranslationEnabled = false,
                )

                val soundUri = Uri.parse("android.resource://${context.packageName}/raw/notification_sound")
                val attributes = AudioAttributes.Builder()
                    .setUsage(AudioAttributes.USAGE_NOTIFICATION)
                    .build()

                val notificationHandler = NotificationHandlerFactory.createNotificationHandler(
                    context = context,
                    notificationConfig = notificationConfig,
                    newMessageIntent = { message: Message, channel: Channel ->
                        createNotificationIntent(message, channel)
                    },
                    notificationChannel = {
                        NotificationChannel(
                            context.getString(R.string.notification_channel_id),
                            context.getString(R.string.notification_channel_name),
                            NotificationManager.IMPORTANCE_HIGH,
                        ).apply {
                            description = context.getString(R.string.notification_channel_description)
                            setSound(soundUri, attributes)
                            enableLights(true)
                            enableVibration(true)
                            setShowBadge(true)
                        }
                    },
                    notificationBuilderTransformer = { builder, notification ->
                        chatNotificationBuilder.build(notification, builder)
                    }
                )

                // Configure offline plugin for local data persistence and sync
                val offlinePluginFactory = StreamOfflinePluginFactory(appContext = context)

                // Configure state plugin for real-time state management
                val statePluginFactory = StreamStatePluginFactory(
                    config = StatePluginConfig(),
                    appContext = context,
                )

                // Set appropriate log level based on build configuration
                val logLevel = if (BuildConfig.DEBUG) ChatLogLevel.ALL else ChatLogLevel.NOTHING

                // Build the chat client with all necessary configurations
                val client = ChatClient.Builder(apiKey, context)
                    .notifications(notificationConfig, notificationHandler)
                    .withPlugins(offlinePluginFactory, statePluginFactory)
                    .logLevel(logLevel)
                    .uploadAttachmentsNetworkType(UploadAttachmentsNetworkType.NOT_ROAMING)
                    .appName(stringProvider.getString(R.string.app_name))
                    .build()

                // Create user object for authentication
                val user = User(
                    id = userId,
                )

                // Connect the user using our custom connection logic
                connectUser(client, user, userToken)
            } catch (e: Exception) {
                _connectionState.value = ChatConnectionState.Error(e.message ?: "Unknown error")
                Timber.e(e, "Error initializing Stream Chat")
            }
        }
    }

    /**
     * Handles user connection to Stream Chat with proper state management.
     *
     * This method implements smart connection logic that avoids unnecessary
     * reconnections and properly manages the client lifecycle. It checks if
     * the user is already connected before attempting a new connection.
     *
     * @param client The Stream Chat client instance
     * @param user The user object to connect
     * @param token The authentication token for the user
     * @param onSuccess Callback executed on successful connection
     * @param onError Callback executed on connection failure
     */
    private suspend fun connectUser(
        client: ChatClient,
        user: User,
        token: String,
        onSuccess: () -> Unit = {},
        onError: (Error) -> Unit = {},
    ) {
        try {
            // Wait for client initialization and handle connection
            client.clientState.initializationState
                .transformWhile {
                    emit(it)
                    // Continue until initialization is complete
                    it != InitializationState.COMPLETE
                }
                .collect { state ->
                    // Only attempt connection when client is not initialized
                    if (state == InitializationState.NOT_INITIALIZED) {
                        val result = client.connectUser(user = user, token = token).await()

                        if (result.isSuccess) {
                            // Connection successful - update all internal state
                            _chatClient.value = client
                            _isInitialized.value = true
                            _connectionState.value = ChatConnectionState.Connected(result.getOrThrow())

                            // Refresh Firebase token to keep it up to date
                            refreshFirebaseTokenUseCase()


                            Timber.d("Stream Chat initialized successfully")
                            onSuccess()
                        } else {
                            // Connection failed - update state with error information
                            val error = result.errorOrNull()
                            _connectionState.value = ChatConnectionState.Error(
                                error?.message ?: "Unknown error during connection",
                            )
                            Timber.e("Failed to connect to Stream Chat: ${error?.message}")
                            if (error != null) {
                                onError(error)
                            }
                        }
                    }
                }
        } catch (e: Exception) {
            // Handle any unexpected exceptions during connection
            _connectionState.value = ChatConnectionState.Error(e.message ?: "Unknown error")
            Timber.e(e, "Error connecting user to Stream Chat")
        }
    }

    /**
     * Disconnects the current chat client and cleans up resources.
     *
     * This method safely disconnects the client without flushing persistence
     * to maintain offline data, and resets all internal state to reflect
     * the disconnected status.
     */
    private suspend fun disconnectChatClient() {
        withContext(dispatcher) {
            try {
                _chatClient.value?.let { client ->
                    when (val result = client.disconnect(flushPersistence = true).await()) {
                        is Result.Success -> {
                            _chatClient.value = null
                            _isInitialized.value = false
                            _connectionState.value = ChatConnectionState.Disconnected
                            currentUserId = null
                            Timber.d("Stream Chat disconnected successfully")
                        }
                        is Result.Failure -> {
                            _chatClient.value = null
                            _isInitialized.value = false
                            _connectionState.value = ChatConnectionState.Disconnected
                            currentUserId = null
                            Timber.e("Error disconnecting Stream Chat: ${result.errorOrNull()?.message}")
                        }
                    }
                } ?: run {
                    _isInitialized.value = false
                    _connectionState.value = ChatConnectionState.Disconnected
                    currentUserId = null
                }
            } catch (e: Exception) {
                _chatClient.value = null
                _isInitialized.value = false
                _connectionState.value = ChatConnectionState.Disconnected
                currentUserId = null
                Timber.e(e, "Exception during disconnect")
            }
        }
    }

    /**
     * Returns the current chat client instance.
     * This method is internal and should only be used within ChatManager.
     *
     * @return The current ChatClient instance or null if not connected
     */
    internal suspend fun getCurrentClient(): ChatClient? {
        return _chatClient.first()
    }

    /**
     * Checks if the chat client is currently connected.
     *
     * @return true if connected, false otherwise
     */
    suspend fun isConnected(): Boolean {
        return connectionState.first() is ChatConnectionState.Connected
    }

    ...

    /**
     * Gets the currently logged in user.
     *
     * @return The current User or null if not connected
     */
    fun getCurrentUser(): User? {
        return _chatClient.value?.getCurrentUser()
    }

    ...

}

This is significant code for CleanupUserDatabaseCase, use case executed when the user clicks on logout (I attached the current working code with the workaround but you can just imagine to comment restartApp function to have the error scenario):

class CleanupUserDataUseCase @Inject constructor(
    @param:Named("AuthApiService") private val apiService: ApiService,
    private val appDatabase: AppDatabase,
    private val networkUtils: NetworkUtils,
    private val imageLoader: ImageLoader,
    private val userPreferencesRepository: UserPreferencesRepository,
    private val logoutEventEmitter: LogoutEventEmitter,
    private val deleteFirebaseTokenUseCase: DeleteFirebaseTokenUseCase,
    @param:ApplicationContext private val context: Context,
    @param:IoDispatcher private val dispatcher: CoroutineDispatcher,
) {

    /**
     * Performs comprehensive cleanup of all user data and services.
     * Operations are performed in a specific order to ensure proper cleanup.
     */
    suspend operator fun invoke() = withContext(dispatcher) {
        Timber.i("Starting comprehensive user data cleanup...")

        // Step 1: Attempt server logout (best-effort)
        performServerLogout()

        // Step 2: Clear local database (triggers automatic ChatClient disconnection)
        clearLocalDatabase()

        // Step 3: Clear image caches
        clearImageCaches()

        // Step 4: Clear local preferences and tokens
        clearLocalPreferences()

        // Step 5: Unregister Firebase token
        unregisterFirebaseToken()

        // Step 6: Emit logout event for app-wide cleanup
        emitLogoutEvent()

        Timber.i("User data cleanup completed successfully.")

        // Step 7: Kill app and restart from scratch
        restartApp()
    }

   ...

    /**
     * Step 2: Clears all local database tables.
     *
     * ⚠️ IMPORTANT: ChatClient disconnection happens automatically here!
     * When chat_config table is cleared, ChatManager observes this change through
     * chatConfigRepository.getChatConfig() flow and automatically:
     * 1. Detects invalid/empty configuration
     * 2. Calls disconnectChatClient() internally
     * 3. Performs client.disconnect(flushPersistence = false)
     * 4. Resets all internal ChatManager state
     */
    private fun clearLocalDatabase() {
        Timber.d("Clearing local database...")
        try {
            appDatabase.clearAllTables()
            Timber.i("Local database cleared successfully.")
        } catch (e: Exception) {
            Timber.e(e, "Error clearing local database.")
            throw e
        }
    }

   ...

    /**
     * Step 6: Emits logout event to notify other parts of the application.
     */
    private suspend fun emitLogoutEvent() {
        Timber.d("Emitting logout event...")
        try {
            logoutEventEmitter.emitLogoutEvent()
            Timber.i("Logout event emitted successfully.")
        } catch (e: Exception) {
            Timber.e(e, "Error emitting logout event.")
        }
    }

    /**
     * Step 7: Kills the app and restarts it from scratch to ensure completely clean state.
     */
    private fun restartApp() {
        // TODO: Refactor this code to use the right way to restart the app
        Timber.i("Restarting app for complete cleanup...")
        try {
            val packageManager = context.packageManager
            val intent = packageManager.getLaunchIntentForPackage(context.packageName)
            intent?.let { launchIntent ->
                launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
                context.startActivity(launchIntent)
            }

            // Kill all processes and activities
            android.os.Process.killProcess(android.os.Process.myPid())
            exitProcess(0)
        } catch (e: Exception) {
            Timber.e(e, "Error restarting app, forcing complete exit")
            android.os.Process.killProcess(android.os.Process.myPid())
            exitProcess(0)
        }
    }
}

This is the significant code that contains ChannelsScreen usage (I reverted all your suggested changes):

@Composable
private fun Chats(
    channelViewModelFactory: ChannelViewModelFactory,
    onIntent: (ChatsIntent) -> Unit
) {

    Column {
        ChannelsScreen(
            viewModelFactory = channelViewModelFactory,
            viewModelKey = CHANNEL_VIEW_MODEL_KEY,
            isShowingHeader = false,
            searchMode = SearchMode.Messages,
            onChannelClick = { channel ->
                onIntent(ChatsIntent.NavigateToChannel(channel.cid))
            },
            onBackPressed = {
                onIntent(ChatsIntent.BackPressed)
            }
        )
    }
}

private val channelViewModelFactory = buildChannelViewModelFactory()
private const val CHANNEL_VIEW_MODEL_KEY = "ChannelListViewModel"

fun buildChannelViewModelFactory() = ChannelViewModelFactory(
    filters = buildInitialFilters(),
    querySort = QuerySortByField
        .descByName<Channel>(GET_STREAM_FIELD_NAME_PINNED_AT) // pinned channels first
        .desc(GET_STREAM_FIELD_NAME_LAST_MESSAGE_AT), // then by last updated at
)

If you need other informations, let me know.

Thanks