diff --git a/.changes/republish-all-tracks-after-failure b/.changes/republish-all-tracks-after-failure new file mode 100644 index 000000000..732b35b5e --- /dev/null +++ b/.changes/republish-all-tracks-after-failure @@ -0,0 +1 @@ +patch type="fixed" "A track that fails to republish after a full reconnect no longer leaves the tracks after it unpublished or the room without a `RoomReconnectedEvent`. The failure is logged and the remaining tracks are republished" diff --git a/lib/src/core/room.dart b/lib/src/core/room.dart index 5731309e1..37918b77d 100644 --- a/lib/src/core/room.dart +++ b/lib/src/core/room.dart @@ -666,6 +666,8 @@ class Room extends DisposableChangeNotifier with EventsEmittable { ..on((event) async { // re-publish all tracks await localParticipant?.rePublishAllTracks(); + // The room may have closed or started another reconnect while the tracks were republished. + if (engine.isClosed || connectionState != ConnectionState.connected) return; for (var participant in _remoteParticipants.toList()) { for (var pub in participant.trackPublications.values.toList()) { diff --git a/lib/src/participant/local.dart b/lib/src/participant/local.dart index 64848ba6f..b430dab9a 100644 --- a/lib/src/participant/local.dart +++ b/lib/src/participant/local.dart @@ -638,14 +638,19 @@ class LocalParticipant extends Participant { final tracks = trackPublications.values.toList(); trackPublications.clear(); for (LocalTrackPublication track in tracks) { - if (track.track is LocalAudioTrack) { - await publishAudioTrack(track.track as LocalAudioTrack); - } else if (track.track is LocalVideoTrack) { - final videoTrack = track.track as LocalVideoTrack; - // a full reconnect replaced the peer connection, so any simulcast - // codec senders the track still holds belong to the old one - videoTrack.clearSimulcastState(); - await publishVideoTrack(videoTrack); + // one track failing to republish must not leave the others unpublished + try { + if (track.track is LocalAudioTrack) { + await publishAudioTrack(track.track as LocalAudioTrack); + } else if (track.track is LocalVideoTrack) { + final videoTrack = track.track as LocalVideoTrack; + // a full reconnect replaced the peer connection, so any simulcast + // codec senders the track still holds belong to the old one + videoTrack.clearSimulcastState(); + await publishVideoTrack(videoTrack); + } + } catch (error, stackTrace) { + logger.warning('Failed to re-publish ${track.source} track ${track.sid}: $error', error, stackTrace); } } } diff --git a/test/core/room_e2e_test.dart b/test/core/room_e2e_test.dart index 36a844b08..378278b23 100644 --- a/test/core/room_e2e_test.dart +++ b/test/core/room_e2e_test.dart @@ -15,6 +15,7 @@ @Timeout(Duration(seconds: 5)) library; +import 'dart:async'; import 'dart:typed_data'; import 'package:flutter_test/flutter_test.dart'; @@ -23,6 +24,8 @@ import 'package:logging/logging.dart'; import 'package:livekit_client/livekit_client.dart'; import 'package:livekit_client/src/internal/events.dart'; +import 'package:livekit_client/src/proto/livekit_models.pb.dart' as lk_models; +import 'package:livekit_client/src/proto/livekit_rtc.pb.dart' as lk_rtc; import '../mock/e2e_container.dart'; import '../mock/test_data.dart'; import '../mock/websocket_mock.dart'; @@ -59,6 +62,62 @@ void main() { }, skip: 'todo'); }); + group('full reconnect', () { + test('republish failures do not stop other tracks or the reconnection', () async { + final participant = room.localParticipant!; + final tracks = [ + for (final id in ['local_audio_1', 'local_audio_2']) _FailingAudioTrack(id, StateError('republish failed')), + ]; + for (final track in tracks) { + participant.addTrackPublication( + LocalTrackPublication( + participant: participant, + info: remoteAudioTrack.clone()..sid = 'sid_${track.mediaStreamTrack.id}', + track: track, + ), + ); + } + + final reconnected = room.events.waitFor(duration: const Duration(seconds: 1)); + container.engine.events.emit(const EngineRestartedEvent()); + await reconnected; + + expect(tracks.map((track) => track.startAttempts), [1, 1]); + }); + + test('no reconnected event when the server closes the room while a track is republished', () async { + final participant = room.localParticipant!; + final gate = Completer(); + final track = _FailingAudioTrack('local_audio_1', StateError('republish failed'), gate: gate); + participant.addTrackPublication( + LocalTrackPublication( + participant: participant, + info: remoteAudioTrack.clone()..sid = 'sid_local_audio_1', + track: track, + ), + ); + + var reconnected = false; + final listener = room.createListener()..on((_) => reconnected = true); + addTearDown(listener.dispose); + container.engine.events.emit(const EngineRestartedEvent()); + ws.onData( + lk_rtc.SignalResponse( + leave: lk_rtc.LeaveRequest( + action: lk_rtc.LeaveRequest_Action.DISCONNECT, + reason: lk_models.DisconnectReason.ROOM_DELETED, + ), + ).writeToBuffer(), + ); + await room.events.waitFor(duration: const Duration(seconds: 1)); + gate.complete(); + await Future.delayed(const Duration(milliseconds: 100)); + + expect(track.startAttempts, 1); + expect(reconnected, isFalse); + }); + }); + group('room updates', () { test('participant join', () async { final publicEventsStream = room.events.streamCtrl.stream.where((event) => event is! InternalEvent); @@ -362,3 +421,24 @@ class _FakeMediaStreamTrack implements rtc.MediaStreamTrack { @override String toString() => 'FakeMediaStreamTrack(id: $id, kind: $kind, enabled: $enabled)'; } + +class _FailingAudioTrack extends LocalAudioTrack { + final Object error; + final Completer? gate; + int startAttempts = 0; + + _FailingAudioTrack(String id, this.error, {this.gate}) + : super( + TrackSource.microphone, + _FakeMediaStream('local_stream'), + _FakeMediaStreamTrack(id: id, kind: 'audio'), + const AudioCaptureOptions(), + ); + + @override + Future startCapture() async { + startAttempts++; + await gate?.future; + throw error; + } +}