TW-2313 Handle login from URI when app is logged with same home server and multiple clients exist

Author: dab246

lib/presentation/mixins/connect_page_mixin.dart

@@ -1,5 +1,6 @@
 import 'dart:convert';
 
+import 'package:collection/collection.dart';
 import 'package:fluffychat/config/app_config.dart';
 import 'package:fluffychat/di/global/get_it_initializer.dart';
 import 'package:fluffychat/domain/repository/federation_configurations_repository.dart';
@@ -301,32 +302,29 @@ mixin ConnectPageMixin {
     );
   }
 
-  Future<bool> validateHomeServerExisted({required String homeServer}) async {
+  Future<Client?> getClientExisted({required String homeServer}) async {
     try {
       final clients = await ClientManager.getClients();
       Logs().d(
-        'ConnectPageMixin::validateHomeServerExisted:Clients = ${clients.map((client) => client.homeserver).toString()}',
+        'ConnectPageMixin::getClientExisted:Clients = ${clients.map((client) => client.homeserver).toString()}',
       );
-
-      final loggedInHomeServers = clients
-          .map((client) => client.homeserver?.toString())
-          .whereType<String>()
-          .toSet();
-
-      Logs().d(
-        'ConnectPageMixin::validateHomeServerExisted: All HomeServers: $loggedInHomeServers',
+      final clientExisted = clients.firstWhereOrNull(
+        (client) => client.homeserver?.toString().contains(homeServer) == true,
       );
-
-      final exists = loggedInHomeServers.any(
-        (existingServer) => existingServer.contains(homeServer),
+      Logs().d(
+        'ConnectPageMixin::getClientExisted: $clientExisted',
       );
-
-      return exists && !AppConfig.supportMultipleAccountsInTheSameHomeserver;
+      if (clientExisted != null &&
+          !AppConfig.supportMultipleAccountsInTheSameHomeserver) {
+        return clientExisted;
+      } else {
+        return null;
+      }
     } catch (e) {
       Logs().e(
-        'ConnectPageMixin::validateHomeServerExisted: Exception: $e',
+        'ConnectPageMixin::getClientExisted: Exception: $e',
       );
-      return false;
+      return null;
     }
   }
 

lib/presentation/mixins/deep_link_intent_mixin.dart

@@ -8,6 +8,7 @@ import 'package:fluffychat/utils/deep_link/deep_link_utils.dart';
 import 'package:fluffychat/utils/dialog/twake_dialog.dart';
 import 'package:fluffychat/utils/platform_infos.dart';
 import 'package:fluffychat/utils/responsive/responsive_utils.dart';
+import 'package:fluffychat/widgets/layouts/agruments/logout_body_args.dart';
 import 'package:fluffychat/widgets/matrix.dart';
 import 'package:fluffychat/widgets/twake_app.dart';
 import 'package:flutter/material.dart';
@@ -58,13 +59,16 @@ mixin DeepLinkIntentMixin<T extends StatefulWidget> on State<T> {
     try {
       TwakeDialog.showLoadingTwakeWelcomeDialog(context);
 
-      final homeServerExisted = await matrixState.validateHomeServerExisted(
+      final clientExisted = await matrixState.getClientExisted(
         homeServer: openAppDeepLink.homeServer,
       );
-      Logs().d("DeepLinkIntentMixin::homeServerExisted: $homeServerExisted");
-      if (homeServerExisted) {
+      Logs().d(
+        "DeepLinkIntentMixin::clientExisted: UserID =${clientExisted?.userID}",
+      );
+      if (clientExisted != null) {
         await _handleSignInWithSameHomeServer(
           openAppDeepLink: openAppDeepLink,
+          clientExisted: clientExisted,
         );
         return;
       }
@@ -114,32 +118,113 @@ mixin DeepLinkIntentMixin<T extends StatefulWidget> on State<T> {
 
   Future<void> _handleSignInWithSameHomeServer({
     required OpenAppDeepLink openAppDeepLink,
+    required Client clientExisted,
   }) async {
-    final isSameAccount =
-        matrixState.activatedUserId == openAppDeepLink.qualifiedUserId;
+    if (clientExisted.userID == null) {
+      TwakeDialog.hideLoadingDialog(context);
+      return;
+    }
+
+    final isSameClient =
+        clientExisted.userID == openAppDeepLink.qualifiedUserId;
+    final isActiveClient = matrixState.activatedUserId == clientExisted.userID;
     Logs().d(
-      'DeepLinkIntentMixin::_handleSignInWithSameHomeServer():activatedUserId = ${matrixState.activatedUserId}, userId = ${openAppDeepLink.qualifiedUserId}, loginToken = ${openAppDeepLink.loginToken}, isSameAccount = $isSameAccount',
+      'DeepLinkIntentMixin::_handleSignInWithSameHomeServer(): isSameClient = $isSameClient, isActiveClient = $isActiveClient',
     );
-    if (!isSameAccount) {
-      final confirmResult = await _showConfirmSwitchAccountDialog(
-        activeUserId: matrixState.activatedUserId,
-        userId: openAppDeepLink.qualifiedUserId,
+    if (isSameClient && isActiveClient) {
+      TwakeDialog.hideLoadingDialog(context);
+    } else if (isSameClient && !isActiveClient) {
+      await _handleSignInWithSameInactiveClient(
+        openAppDeepLink: openAppDeepLink,
+        clientExisted: clientExisted,
+      );
+    } else if (!isSameClient && isActiveClient) {
+      await _handleSignInWithDifferentActiveClient(
+        openAppDeepLink: openAppDeepLink,
+        userIdExisted: clientExisted.userID!,
       );
+    } else {
+      await _handleSignInWithDifferentInactiveClient(
+        openAppDeepLink: openAppDeepLink,
+        clientExisted: clientExisted,
+      );
+    }
+  }
 
-      if (confirmResult == ConfirmResult.cancel) {
-        TwakeDialog.hideLoadingDialog(context);
-        return;
-      }
+  Future<void> _switchActiveClient({required Client clientExisted}) async {
+    final activeClientState = await matrixState.setActiveClient(clientExisted);
+    if (activeClientState.isSuccess) {
+      TwakeApp.router.go(
+        '/rooms',
+        extra: LogoutBodyArgs(newActiveClient: clientExisted),
+      );
+    }
+  }
 
-      processingDeepLink = openAppDeepLink;
-      await _autoLogoutActiveAccount();
-    } else {
+  Future<void> _handleSignInWithSameInactiveClient({
+    required OpenAppDeepLink openAppDeepLink,
+    required Client clientExisted,
+  }) async {
+    Logs().d(
+      'DeepLinkIntentMixin::_handleSignInWithSameInactiveClient():',
+    );
+    final confirmResult = await _showConfirmSwitchAccountDialog(
+      userIdExisted: clientExisted.userID!,
+      userId: openAppDeepLink.qualifiedUserId,
+    );
+
+    if (confirmResult == ConfirmResult.cancel) {
       TwakeDialog.hideLoadingDialog(context);
+      return;
     }
+
+    await _switchActiveClient(clientExisted: clientExisted);
+  }
+
+  Future<void> _handleSignInWithDifferentActiveClient({
+    required OpenAppDeepLink openAppDeepLink,
+    required String userIdExisted,
+  }) async {
+    Logs().d(
+      'DeepLinkIntentMixin::_handleSignInWithDifferentActiveClient(): userIdExisted = $userIdExisted',
+    );
+    final confirmResult = await _showConfirmSwitchAccountDialog(
+      userIdExisted: userIdExisted,
+      userId: openAppDeepLink.qualifiedUserId,
+    );
+
+    if (confirmResult == ConfirmResult.cancel) {
+      TwakeDialog.hideLoadingDialog(context);
+      return;
+    }
+
+    processingDeepLink = openAppDeepLink;
+    await _autoLogoutActiveClient();
+  }
+
+  Future<void> _handleSignInWithDifferentInactiveClient({
+    required OpenAppDeepLink openAppDeepLink,
+    required Client clientExisted,
+  }) async {
+    Logs().d(
+      'DeepLinkIntentMixin::_handleSignInWithDifferentInactiveClient(): UserID = ${clientExisted.userID}',
+    );
+    final confirmResult = await _showConfirmSwitchAccountDialog(
+      userIdExisted: clientExisted.userID!,
+      userId: openAppDeepLink.qualifiedUserId,
+    );
+
+    if (confirmResult == ConfirmResult.cancel) {
+      TwakeDialog.hideLoadingDialog(context);
+      return;
+    }
+
+    processingDeepLink = openAppDeepLink;
+    await _autoLogoutInactiveClient(client: clientExisted);
   }
 
   Future<ConfirmResult> _showConfirmSwitchAccountDialog({
-    required String activeUserId,
+    required String userIdExisted,
     required String userId,
   }) async {
     final l10n = L10n.of(context);
@@ -152,7 +237,7 @@ mixin DeepLinkIntentMixin<T extends StatefulWidget> on State<T> {
       textSpanMessages: [
         TextSpan(text: l10n?.youAreCurrentlyLoggedInWith),
         TextSpan(
-          text: ' $activeUserId',
+          text: ' $userIdExisted',
           style: Theme.of(context).textTheme.bodyMedium?.copyWith(
                 color: Colors.black,
                 fontWeight: FontWeight.bold,
@@ -175,10 +260,23 @@ mixin DeepLinkIntentMixin<T extends StatefulWidget> on State<T> {
     );
   }
 
-  Future<void> _autoLogoutActiveAccount() async {
+  Future<void> _autoLogoutActiveClient() async {
+    Logs().d('DeepLinkIntentMixin::_autoLogoutActiveClient');
     await matrixState.logoutAction(matrix: matrixState);
   }
 
+  Future<void> _autoLogoutInactiveClient({required Client client}) async {
+    Logs().d('DeepLinkIntentMixin::_autoLogoutInactiveClient');
+    final activeClientState = await matrixState.setActiveClient(client);
+
+    if (activeClientState.isSuccess) {
+      await matrixState.logoutAction(matrix: matrixState);
+    } else {
+      processingDeepLink = null;
+      TwakeDialog.hideLoadingDialog(context);
+    }
+  }
+
   void disposeDeepLink() {
     Logs().d('DeepLinkIntentMixin::disposeDeepLink');
     intentUriStreamSubscription?.cancel();

lib/widgets/matrix.dart

@@ -453,7 +453,7 @@ class MatrixState extends State<Matrix>
                 Logs().v(
                   '[MATRIX]:_handleLogoutWithMultipleAccount:: Log out Client ${client.clientName} successful',
                 );
-                if (state != LoginState.loggedIn && result.isSuccess) {
+                if (result.isSuccess) {
                   TwakeApp.router.go(
                     '/rooms',
                     extra: LogoutBodyArgs(