Rejoin a call without duplication

[qu0cquyen]

When the user changes microphone or camera permissions in system settings, the app restarts (expected behavior on iOS/Android). After the restart, I want the user to automatically rejoin the ongoing call.

The problem is: when rejoining, the SDK creates a new session instead of continuing the old one. This causes the same user to appear twice in the call — sometimes disappearing after a short time, but other times staying stuck in the call.

From looking at the source code, I see that the join method always creates a new SFU session with rejoin: false. Since I can’t control the SessionID or CallState, I’m wondering if there’s any way to set rejoin to true so that the SDK treats it as a proper rejoin.

Final goal: rejoin the existing call after app restart without creating duplicate participants.

[renefloor]

Hi @qu0cquyen,
The duplicated session is expected. The app tries to reconnect to the same session while it's open, but we don't store the session on disk, so when the app is killed and you rejoin it will create a new session.

sometimes disappearing after a short time, but other times staying stuck in the call.

This is not supposed to happen. A user disconnected should always disappear after some time, about 10 seconds. I couldn't reproduce the user staying stuck in the call, about how often does that happen to you? Compared to the user disappearing from the call.

[qu0cquyen]

This problem happens most of the time.

Here’s what I tried:

Join the call

Change permissions and rejoin (the earlier session had dropped)

Change permissions again and rejoin (the earlier session seems to persist)

[renefloor]

When you rejoined the first time, did you fully rejoin the session?
After rejoining the second time, the session of the first rejoin persist right? Or was it the original one that came back?

[qu0cquyen]

Join (No rejoin)
sessionId: 215c08b0-fdf4-4cc9-a83c-fbf8d5f78bab

First rejoin
sessionId: 215c08b0-fdf4-4cc9-a83c-fbf8d5f78bab (Early sessionId) - This will be dropped out.
sessionId: de5480e3-3573-4163-bf45-995e82de041f (Rejoin sessionId - new)

Second rejoin
sessionId: de5480e3-3573-4163-bf45-995e82de041f (Old sessionId from First join) - This is not gonna be dropped out.
sessionId: 68dcde52-edff-4c07-8dc0-755953caf151 (Rejoin sessionId - new)

And this is how we currently integrate the re-join feature:

final sharedPrefs = await container.read(sharedPreferencesProvider);
      final videoClient = container.read(callClientProvider);

      videoClient.listenActiveCall((call) async {

        if (call == null) return;

        final callId = call.id;
        final callType = call.type.value;

        await sharedPrefs.setString('on-going-call-id', callId);
        await sharedPrefs.setString('on-going-call-type', callType);
      });

      /// Listen to Call end to remove SharedPrefs
      videoClient.events.listen((CoordinatorEvent event) async {
        if (event is CoordinatorCallEndedEvent ||
            event is CallEndedEvent ||
            event is CallSessionEndedEvent) {
          final removedCallId = await sharedPrefs.remove('on-going-call-id');
          final removedCallType =
              await sharedPrefs.remove('on-going-call-type');

        }
      });

      final onGoingCallId = sharedPrefs.getString('on-going-call-id');
      final onGoingCallType = sharedPrefs.getString('on-going-call-type');

      print('OnGOING  CALL INFO: ${onGoingCallId} - ${onGoingCallType}');

      if (onGoingCallId != null && onGoingCallType != null) {
        /// Query Call

        final onGoingCallObj = videoClient.makeCall(
          callType: StreamCallType.custom(onGoingCallType),
          id: onGoingCallId,
        );


        /// Remove saved [CallID] & [CallType] since we're going to consume this call
        await sharedPrefs.remove('on-going-call-id');
        await sharedPrefs.remove('on-going-call-type');

        await onGoingCallObj.join();

        onGoingCallObj.state.value.callParticipants.map((p) {
          print('ON GOING CALL STATE: ${p.userId} - ${p.name}');
        }).toList();

      
         /// This is basically navigate to `CallScreen`
          container.read(eventManagerProvider).dispatchEvent(
              OnNavigateToCallInCompanyScreenEvent(call: onGoingCallObj));
          return;
       

       
      }

And this is our current implementation for CallScreen

class CallInCompanyContent extends ConsumerStatefulWidget {
  const CallInCompanyContent({super.key, required this.call});

  final stream_video.Call call;

  @override
  ConsumerState<CallInCompanyContent> createState() =>
      _CallInCompanyContentState();
}

class _CallInCompanyContentState extends ConsumerState<CallInCompanyContent> {
  @override
  Widget build(BuildContext context) {
    return stream_video.StreamCallContainer(
      call: widget.call,
      callConnectOptions: stream_video.CallConnectOptions(
        camera: stream_video.TrackOption.disabled(),
        microphone: stream_video.TrackOption.enabled(),
      ),
      callContentWidgetBuilder: (context, call) {
        return BackgroundCallInCompanyDecoration(
          call: call,
        );
      },
      outgoingCallWidgetBuilder: (context, call) {
        return stream_video.StreamOutgoingCallContent(
          call: call,
          callBackgroundWidgetBuilder: (context, call, defaultWidget) {
            return BackgroundCallInCompanyOutgoing(
              call: call,
            );
          },
        );
      },
    );
  }
}