diff --git a/.changes/public-subscribed-quality-event b/.changes/public-subscribed-quality-event new file mode 100644 index 000000000..f9e2bead3 --- /dev/null +++ b/.changes/public-subscribed-quality-event @@ -0,0 +1 @@ +minor type="added" "LocalTrackSubscribedQualityUpdatedEvent: the layers and codecs subscribers request for a local track, as a public room and participant event" diff --git a/lib/src/core/room.dart b/lib/src/core/room.dart index 5731309e1..10fb09c37 100644 --- a/lib/src/core/room.dart +++ b/lib/src/core/room.dart @@ -38,6 +38,7 @@ import '../participant/remote.dart'; import '../preconnect/pre_connect_audio_buffer.dart'; import '../proto/livekit_models.pb.dart' as lk_models; import '../proto/livekit_rtc.pb.dart' as lk_rtc; +import '../publication/local.dart'; import '../rpc/rpc_client_manager.dart'; import '../rpc/rpc_server_manager.dart'; import '../support/disposable.dart'; @@ -444,18 +445,21 @@ class Room extends DisposableChangeNotifier with EventsEmittable { ..on((event) => _onSignalConnectionQualityUpdateEvent(event.updates)) ..on((event) => _onSignalStreamStateUpdateEvent(event.updates)) ..on((event) async { + // Find the publication + final publication = localParticipant?.trackPublications[event.trackSid]; + if (publication == null) { + logger.warning('Received subscribed quality update for unknown track (${event.trackSid})'); + return; + } + // Taken before the layers are applied: for SVC codecs that marks every listed layer enabled. + final qualities = _subscribedQualities(event, publication); // Dynacast is off or is unsupported if (!roomOptions.dynacast || _serverVersion == '0.15.1') { logger.fine( 'Received subscribed quality update' ' but Dynacast is off or server version is not supported.', ); - return; - } - // Find the publication - final publication = localParticipant?.trackPublications[event.trackSid]; - if (publication == null) { - logger.warning('Received subscribed quality update for unknown track (${event.trackSid})'); + _emitSubscribedQualityUpdated(publication, qualities); return; } if (event.subscribedCodecs.isNotEmpty) { @@ -478,6 +482,7 @@ class Room extends DisposableChangeNotifier with EventsEmittable { isSVC: isSVCCodec(videoTrack.codec ?? ''), ); } + _emitSubscribedQualityUpdated(publication, qualities); }) ..on((event) async { logger.fine( @@ -1228,6 +1233,33 @@ extension RoomPrivateMethods on Room { } } + Map> _subscribedQualities( + SignalSubscribedQualityUpdatedEvent event, + LocalTrackPublication publication, + ) { + Map byQuality(Iterable qualities) => { + for (final q in qualities) q.quality.toLKType(): q.enabled, + }; + return event.subscribedCodecs.isNotEmpty + ? {for (final c in event.subscribedCodecs) c.codec: byQuality(c.qualities)} + : { + (publication.track?.codec ?? publication.mimeType.split('/').last).toLowerCase(): byQuality( + event.subscribedQualities, + ), + }; + } + + void _emitSubscribedQualityUpdated( + LocalTrackPublication publication, + Map> qualities, + ) { + final participant = localParticipant; + if (participant == null || connectionState != ConnectionState.connected) return; + [participant.events, events].emit( + LocalTrackSubscribedQualityUpdatedEvent(participant: participant, publication: publication, qualities: qualities), + ); + } + @internal void emitWhenConnected(RoomEvent event) { if (connectionState == ConnectionState.connected) { diff --git a/lib/src/events.dart b/lib/src/events.dart index 1ba8cf5d6..f880f5f2e 100644 --- a/lib/src/events.dart +++ b/lib/src/events.dart @@ -117,6 +117,26 @@ class RoomReconnectedEvent with RoomEvent { String toString() => '${runtimeType}()'; } +/// The server updated the requested layers and codecs of a local track (dynacast). Emitted +/// after the SDK has applied them, and also when [RoomOptions.dynacast] is off. +/// Emitted by [Room] and [LocalParticipant]. +class LocalTrackSubscribedQualityUpdatedEvent with RoomEvent, ParticipantEvent { + final LocalParticipant participant; + final LocalTrackPublication publication; + + /// Per codec (e.g. 'vp8'), whether subscribers request each layer. + final Map> qualities; + const LocalTrackSubscribedQualityUpdatedEvent({ + required this.participant, + required this.publication, + required this.qualities, + }); + + @override + String toString() => + '${runtimeType}(participant: ${participant}, publication: ${publication}, qualities: ${qualities})'; +} + /// Disconnected from the room /// Emitted by [Room]. class RoomDisconnectedEvent with RoomEvent { diff --git a/test/core/room_e2e_test.dart b/test/core/room_e2e_test.dart index 36a844b08..488eacf4a 100644 --- a/test/core/room_e2e_test.dart +++ b/test/core/room_e2e_test.dart @@ -23,7 +23,10 @@ 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/peerconnection_mock.dart'; import '../mock/test_data.dart'; import '../mock/websocket_mock.dart'; import 'signal_client_test.dart'; @@ -233,6 +236,86 @@ void main() { }); }); + group('subscribed quality', () { + lk_rtc.SignalResponse update(String trackSid) => lk_rtc.SignalResponse( + subscribedQualityUpdate: lk_rtc.SubscribedQualityUpdate( + trackSid: trackSid, + subscribedQualities: [ + lk_rtc.SubscribedQuality(quality: lk_models.VideoQuality.LOW, enabled: true), + lk_rtc.SubscribedQuality(quality: lk_models.VideoQuality.HIGH, enabled: false), + ], + ), + ); + + test('emits the requested layers of a local track, with dynacast off', () async { + final lp = room.localParticipant!; + final track = LocalVideoTrack( + TrackSource.camera, + _FakeMediaStream('local_stream'), + _FakeMediaStreamTrack(id: 'local_video', kind: 'video'), + const CameraCaptureOptions(), + ); + final publication = LocalTrackPublication( + participant: lp, + info: lk_models.TrackInfo(sid: 'TR_local', type: lk_models.TrackType.VIDEO, mimeType: 'video/VP8'), + track: track, + ); + lp.addTrackPublication(publication); + + final future = room.events.waitFor(duration: const Duration(seconds: 1)); + ws.onData(update('TR_local').writeToBuffer()); + final event = await future; + expect(event.publication, publication); + expect(event.qualities, { + 'vp8': {VideoQuality.LOW: true, VideoQuality.HIGH: false}, + }); + }); + + test('emits the requested layers, not the ones kept active for an SVC codec', () async { + final dynacast = E2EContainer(roomOptions: const RoomOptions(dynacast: true)); + await dynacast.connectRoom(); + final lp = dynacast.room.localParticipant!; + final track = LocalVideoTrack( + TrackSource.camera, + _FakeMediaStream('svc_stream'), + _FakeMediaStreamTrack(id: 'svc_video', kind: 'video'), + const CameraCaptureOptions(), + )..codec = 'vp9'; + final sender = _ParamsSender([ + rtc.RTCRtpEncoding(rid: 'q', active: true), + rtc.RTCRtpEncoding(rid: 'f', active: true), + ]); + track.transceiver = MockRtpTransceiver(sender); + final publication = LocalTrackPublication( + participant: lp, + info: lk_models.TrackInfo(sid: 'TR_svc', type: lk_models.TrackType.VIDEO, mimeType: 'video/VP9'), + track: track, + ); + lp.addTrackPublication(publication); + + final future = dynacast.room.events.waitFor( + duration: const Duration(seconds: 1), + ); + dynacast.wsConnector.onData(update('TR_svc').writeToBuffer()); + final event = await future; + expect(event.qualities, { + 'vp9': {VideoQuality.LOW: true, VideoQuality.HIGH: false}, + }); + // The sender keeps every SVC layer on. + expect(sender.parameters.encodings!.every((e) => e.active), isTrue); + await dynacast.room.dispose(); + }); + + test('skips unknown tracks', () async { + var emitted = false; + final cancel = room.events.on((_) => emitted = true); + ws.onData(update('TR_unknown').writeToBuffer()); + await Future.delayed(const Duration(milliseconds: 100)); + expect(emitted, isFalse); + await cancel(); + }); + }); + group('publish guards', () { test('concurrent setSourceEnabled serializes calls', () async { final lp = room.localParticipant!; @@ -362,3 +445,23 @@ class _FakeMediaStreamTrack implements rtc.MediaStreamTrack { @override String toString() => 'FakeMediaStreamTrack(id: $id, kind: $kind, enabled: $enabled)'; } + +/// A sender with fixed encodings, accepting any parameters. +class _ParamsSender implements rtc.RTCRtpSender { + _ParamsSender(List encodings) : parameters = rtc.RTCRtpParameters(encodings: encodings); + + @override + rtc.RTCRtpParameters parameters; + + @override + String get senderId => 'svc_sender'; + + @override + Future setParameters(rtc.RTCRtpParameters parameters) async { + this.parameters = parameters; + return true; + } + + @override + dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation); +}