feat: allow multiple simultaneous active calls (#977)

* allow multiple simultaneous active calls

* linter fix

* dogfooding fix

* added backwards compatibility

* linter fix

* Update packages/stream_video/lib/src/core/client_state.dart

Co-authored-by: Rene Floor <[email protected]>

* tweak

* added tests for active call functionality

---------

Co-authored-by: Rene Floor <[email protected]>

Author: Brazol

dogfooding/lib/screens/home_screen.dart

@@ -59,7 +59,10 @@ class _HomeScreenState extends State<HomeScreen> {
           case ServiceType.call:
             call.reject(reason: CallRejectReason.cancel());
           case ServiceType.screenSharing:
-            StreamVideoFlutterBackground.stopService(ServiceType.screenSharing);
+            StreamVideoFlutterBackground.stopService(
+              ServiceType.screenSharing,
+              callCid: call.callCid.value,
+            );
             call.setScreenShareEnabled(enabled: false);
         }
       },

packages/stream_video/lib/src/call/call.dart

@@ -276,8 +276,8 @@ class Call {
   String get id => state.value.callId;
   StreamCallCid get callCid => state.value.callCid;
   StreamCallType get type => state.value.callType;
-  bool get isActiveCall =>
-      _streamVideo.state.activeCall.valueOrNull?.callCid == callCid;
+  bool get isActiveCall => _streamVideo.state.activeCalls.value
+      .any((call) => call.callCid == callCid);
 
   StateEmitter<CallState> get state => _stateManager.callStateStream;
   Stream<Duration> get callDurationStream => _stateManager.durationStream;
@@ -541,11 +541,13 @@ class Call {
       await _streamVideo.state.setOutgoingCall(null);
     }
 
-    final activeCall = _streamVideo.state.activeCall.valueOrNull;
-    if (activeCall != null && activeCall.callCid != callCid) {
-      _logger.i(() => '[accept] canceling another active call: $activeCall');
-      await activeCall.leave(reason: DisconnectReason.ended());
-      await _streamVideo.state.setActiveCall(null);
+    if (!_streamVideo.options.allowMultipleActiveCalls) {
+      final activeCall = _streamVideo.activeCall;
+      if (activeCall != null && activeCall.callCid != callCid) {
+        _logger.i(() => '[accept] canceling another active call: $activeCall');
+        await activeCall.leave(reason: DisconnectReason.replaced());
+        await _streamVideo.state.removeActiveCall(activeCall);
+      }
     }
 
     final result = await _coordinatorClient.acceptCall(cid: state.callCid);
@@ -614,7 +616,8 @@ class Call {
       return const Result.success(none);
     }
 
-    if (_streamVideo.state.activeCall.valueOrNull?.callCid == callCid) {
+    if (_streamVideo.state.activeCalls.value
+        .any((call) => call.callCid == callCid)) {
       _logger.w(
         () => '[join] rejected (a call with the same cid is in progress)',
       );
@@ -1419,9 +1422,7 @@ class Call {
     await _session?.dispose();
     await dynascaleManager.dispose();
 
-    if (_streamVideo.state.activeCall.valueOrNull?.callCid == callCid) {
-      await _streamVideo.state.setActiveCall(null);
-    }
+    await _streamVideo.state.removeActiveCall(this);
 
     if (_streamVideo.state.outgoingCall.valueOrNull?.callCid == callCid) {
       await _streamVideo.state.setOutgoingCall(null);
@@ -2334,7 +2335,7 @@ class Call {
 
       // Set multitasking camera access for iOS
       final multitaskingResult = await setMultitaskingCameraAccessEnabled(
-        enabled && !_streamVideo.muteVideoWhenInBackground,
+        enabled && !_streamVideo.options.muteVideoWhenInBackground,
       );
 
       _stateManager.participantSetCameraEnabled(

packages/stream_video/lib/src/core/client_state.dart

@@ -1,3 +1,6 @@
+import 'package:collection/collection.dart';
+
+import '../../stream_video.dart' show DisconnectReason, StreamVideoOptions;
 import '../call/call.dart';
 import '../models/user.dart';
 import '../state_emitter.dart';
@@ -16,7 +19,11 @@ abstract class ClientState {
   /// Emits StreamVideo connection changes.
   StateEmitter<ConnectionState> get connection;
 
-  /// Sets when a call being joined.
+  /// Emits a list of active calls.
+  StateEmitter<List<Call>> get activeCalls;
+
+  /// Emits an active call.
+  /// Will only emit if options.allowMultipleActiveCalls is set to false, use activeCalls otherwise.
   StateEmitter<Call?> get activeCall;
 
   /// Emits when a call was created by another user with ringing set as True.
@@ -25,23 +32,38 @@ abstract class ClientState {
   /// Emits when a call was created by current user with ringing set as True.
   StateEmitter<Call?> get outgoingCall;
 
+  /// Sets the call as a current outgoing call.
   Future<void> setOutgoingCall(Call? call);
+
+  /// Set the active call. Will end the currently active call if `options.allowMultipleActiveCalls` is `false.
+  /// When `allowMultipleActiveCalls` is `true` calling this with `call: null` will have no effect.
+  /// Otherwise the call is added to the list of active calls.
   Future<void> setActiveCall(Call? call);
+
+  /// Removes the call from the list of active calls.
+  /// It won't `leave` the call, just removes it from the list.
+  Future<void> removeActiveCall(Call call);
 }
 
 class MutableClientState implements ClientState {
-  MutableClientState(User user)
+  MutableClientState(User user, this.options)
       : user = MutableStateEmitterImpl(user),
+        activeCalls = MutableStateEmitterImpl([]),
         activeCall = MutableStateEmitterImpl(null),
         incomingCall = MutableStateEmitterImpl(null),
         outgoingCall = MutableStateEmitterImpl(null),
         connection = MutableStateEmitterImpl(
           ConnectionState.disconnected(user.id),
         );
 
+  final StreamVideoOptions options;
+
   @override
   final MutableStateEmitter<User> user;
 
+  @override
+  final MutableStateEmitter<List<Call>> activeCalls;
+
   @override
   final MutableStateEmitter<Call?> activeCall;
 
@@ -58,22 +80,49 @@ class MutableClientState implements ClientState {
   User get currentUser => user.value;
 
   Future<void> clear() async {
-    activeCall.value = null;
+    activeCalls.value = [];
     outgoingCall.value = null;
     connection.value = ConnectionState.disconnected(user.value.id);
   }
 
-  Call? getActiveCall() => activeCall.valueOrNull;
+  Call? getActiveCall() {
+    if (options.allowMultipleActiveCalls) {
+      throw Exception(
+        'Multiple active calls are enabled, use getActiveCalls instead',
+      );
+    }
+
+    return activeCalls.value.firstOrNull;
+  }
+
+  List<Call> getActiveCalls() => activeCalls.value;
   Call? getOutgoingCall() => outgoingCall.valueOrNull;
 
   @override
   Future<void> setActiveCall(Call? call) async {
-    final currentlyActiveCall = activeCall.valueOrNull;
-    if (currentlyActiveCall != null && call != null) {
-      await currentlyActiveCall.leave();
+    if (!options.allowMultipleActiveCalls) {
+      final currentlyActiveCall = activeCalls.value.firstOrNull;
+      if (currentlyActiveCall != null) {
+        await currentlyActiveCall.leave(reason: DisconnectReason.replaced());
+      }
+
+      activeCall.value = call;
+      activeCalls.value = call == null ? [] : [call];
+    } else if (call != null) {
+      activeCalls.value = [...activeCalls.value, call];
+    }
+  }
+
+  @override
+  Future<void> removeActiveCall(Call call) async {
+    if (!options.allowMultipleActiveCalls &&
+        activeCall.value?.callCid == call.callCid) {
+      activeCall.value = null;
     }
 
-    activeCall.value = call;
+    activeCalls.value = [
+      ...activeCalls.value.where((it) => it.callCid != call.callCid),
+    ];
   }
 
   @override

packages/stream_video/lib/src/models/disconnect_reason.dart

@@ -27,6 +27,10 @@ abstract class DisconnectReason extends Equatable {
     return DisconnectReasonEnded();
   }
 
+  factory DisconnectReason.replaced() {
+    return DisconnectReasonReplaced();
+  }
+
   factory DisconnectReason.lastParticipantLeft() {
     return DisconnectReasonLastParticipantLeft();
   }
@@ -112,6 +116,22 @@ class DisconnectReasonEnded extends DisconnectReason {
   }
 }
 
+class DisconnectReasonReplaced extends DisconnectReason {
+  factory DisconnectReasonReplaced() {
+    return _instance;
+  }
+
+  const DisconnectReasonReplaced._internal();
+
+  static const DisconnectReasonReplaced _instance =
+      DisconnectReasonReplaced._internal();
+
+  @override
+  String toString() {
+    return 'Replaced';
+  }
+}
+
 class DisconnectReasonLastParticipantLeft extends DisconnectReason {
   factory DisconnectReasonLastParticipantLeft() {
     return _instance;