Release Room FFI handles on disconnect

Room never disposed its RoomHandle on Disconnect(), and Participant /
TrackPublication / Track never disposed theirs at all. Each handle is an
independent entry in the Rust FFI handle table, so dropping one does not
cascade. The handles only got freed when GC eventually finalized each
SafeHandle, which in practice meant the entire Rust-side room (peer
connection, signaling client, libwebrtc state) plus every wrapped
participant, publication, and track lingered for an unpredictable amount
of time after the user-visible session had ended.

Make Room implement IDisposable. Disconnect() now sends the FFI request
and then runs Cleanup(), which unsubscribes from FfiClient events,
walks LocalParticipant + RemoteParticipants disposing each
participant + its publications + the publications' tracks, and finally
disposes RoomHandle itself. The same Cleanup() runs from the
Disconnected room event so server-initiated drops behave the same as
client-initiated ones. OnEventReceived guards against late events
arriving after Cleanup, so the FfiClient unsubscribe race is harmless.

DisposeHandles is added as an internal cascade: Track disposes its own
handle, TrackPublication forwards to its Track, RemoteTrackPublication
also disposes its publication handle, and Participant walks _tracks
before disposing its own handle.

The Meet sample's OnDestroy also calls Disconnect now so a scene change
or quit while still connected releases the handles instead of leaking
them until process exit.

Verified with the FFI handle table diagnostic: a connect / hold /
disconnect cycle now drops rooms, participants, tracks, and remote
publications back to zero. Local publications and audio/video source
handles still leak on this path; those are addressed separately.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: MaxHeimbrock

Runtime/Scripts/Participant.cs

@@ -55,6 +55,14 @@ internal void OnTrackUnpublished(RemoteTrackPublication publication)
         {
             TrackUnpublished?.Invoke(publication);
         }
+
+        internal void DisposeHandles()
+        {
+            foreach (var pub in _tracks.Values)
+                pub.DisposeHandles();
+            _tracks.Clear();
+            Handle?.Dispose();
+        }
     }
 
     public sealed class LocalParticipant : Participant

Runtime/Scripts/Room.cs

@@ -106,9 +106,10 @@ public Proto.RoomOptions ToProto()
         }
     }
 
-    public class Room
+    public class Room : IDisposable
     {
         internal FfiHandle RoomHandle = null;
+        private bool _disposed = false;
         private readonly Dictionary<string, RemoteParticipant> _participants = new();
         private StreamHandlerRegistry _streamHandlers = new();
 
@@ -183,14 +184,46 @@ public ConnectInstruction Connect(string url, string token, RoomOptions options)
 
         public void Disconnect()
         {
-            if (this.RoomHandle == null)
+            if (_disposed || RoomHandle == null)
                 return;
             var (response, _) = FFIBridge.Instance.SendDisconnectRequest(this);
             using (response)
             {
                 Utils.Debug($"Disconnect.... {RoomHandle}");
                 Utils.Debug($"Disconnect response.... {response}");
             }
+            // Release the Rust-side room synchronously. Without this the FfiRoom
+            // (peer connection, signaling client, libwebrtc state) lingers in the
+            // FFI handle table until the SafeHandle finalizer runs.
+            Cleanup();
+        }
+
+        public void Dispose()
+        {
+            Disconnect();
+            GC.SuppressFinalize(this);
+        }
+
+        private void Cleanup()
+        {
+            if (_disposed)
+                return;
+            _disposed = true;
+
+            FfiClient.Instance.RoomEventReceived -= OnEventReceived;
+            FfiClient.Instance.RpcMethodInvocationReceived -= OnRpcMethodInvocationReceived;
+            FfiClient.Instance.DisconnectReceived -= OnDisconnectReceived;
+
+            // Participant + track + publication FFI handles are independent entries in the
+            // Rust handle table — dropping the room handle alone does not cascade to them, so
+            // they would otherwise linger until C# GC finalizes each SafeHandle.
+            LocalParticipant?.DisposeHandles();
+            foreach (var p in _participants.Values)
+                p.DisposeHandles();
+            _participants.Clear();
+
+            RoomHandle?.Dispose();
+            RoomHandle = null;
         }
 
         /// <summary>
@@ -266,6 +299,10 @@ internal void OnRpcMethodInvocationReceived(RpcMethodInvocationEvent e)
 
         internal void OnEventReceived(RoomEvent e)
         {
+            // After Cleanup() the handle is null but late events may still flow
+            // through the FfiClient before the unsubscribe fully takes effect.
+            if (RoomHandle == null)
+                return;
             if (e.RoomHandle != (ulong)RoomHandle.DangerousGetHandle())
                 return;
 
@@ -564,8 +601,7 @@ private void OnDisconnectReceived(DisconnectCallback e)
 
         private void OnDisconnect()
         {
-            FfiClient.Instance.RoomEventReceived -= OnEventReceived;
-            FfiClient.Instance.RpcMethodInvocationReceived -= OnRpcMethodInvocationReceived;
+            Cleanup();
         }
 
         internal RemoteParticipant CreateRemoteParticipantWithTracks(ConnectCallback.Types.ParticipantWithTracks item)

Runtime/Scripts/Track.cs

@@ -108,6 +108,11 @@ internal void UpdateMuted(bool muted)
         {
             _info.Muted = muted;
         }
+
+        internal void DisposeHandles()
+        {
+            Handle?.Dispose();
+        }
     }
 
     public sealed class LocalAudioTrack : Track, ILocalTrack, IAudioTrack

Runtime/Scripts/TrackPublication.cs

@@ -40,6 +40,11 @@ internal void UpdateMuted(bool muted)
             _info.Muted = muted;
             Track?.UpdateMuted(muted);
         }
+
+        internal virtual void DisposeHandles()
+        {
+            Track?.DisposeHandles();
+        }
     }
 
     public sealed class RemoteTrackPublication : TrackPublication
@@ -54,6 +59,12 @@ internal RemoteTrackPublication(TrackPublicationInfo info, FfiHandle handle) : b
             Handle = handle;
         }
 
+        internal override void DisposeHandles()
+        {
+            base.DisposeHandles();
+            Handle?.Dispose();
+        }
+
         public void SetSubscribed(bool subscribed)
         {
             Subscribed = subscribed;

Samples~/Meet/Assets/Runtime/MeetManager.cs

@@ -82,6 +82,7 @@ private void Update()
     private void OnDestroy()
     {
         _webCamTexture?.Stop();
+        _room?.Disconnect();
     }
 
     #endregion