Simulcast, Screen sharing & Various improvements (#4)

* Respect `RTCIceTransportPolicy` enum and organize

* Simplify syntax where possible etc.

* Combine `VideoPreset` and `VideoPresets`

* Default values for `ConnectOptions`

* Build URI instead of String manipulation

* Slight modifications to Exception

* `LiveKitTheme` for example

* `VideoEncoding` class

* Organize imports

* First simulcast implementation

* Remove unnecessary try-catches

* Update Android settings

* Remember uri and token

* example improvements

* `fit` parameter for VideoTrackRenderer

* Simulcast option for example

* Pass `defaultPublishOptions`

* Show only `VideoQuality`

* Pass tests

* Better buildUri logic

* Named parameter to positional

* Explicit imports

* `VideoParameter` instead of `VideoPreset`

* Use `mediaTrack.getSettings` when possible

* Safer dispose logic

* Safer `PCTransport`

Update transport.dart

* Synchronized events for `SignalClient`

* Use logger instead of print

* Make example compile for iOS

* First screen share implementation

* Make example work with screen share

* Example improvement

* Code optimization

* Don't depend on web_socket_channel

* Fix: Unpublish track bug

* Show participant mute state & identity

* Update protos

* Remote mute/unmute

* iOS Background mode

* Separate `createCameraTrack` and `createScreenTrack`

* Clean up

* PB fix

* format

* Fix analyzer warning

* Android clean up

* Update README.md

* Clean up

lib/src/transport.dart

@@ -1,36 +1,68 @@
 import 'package:flutter_webrtc/flutter_webrtc.dart';
 
+import 'logger.dart';
+
 /// a wrapper around PeerConnection
 class PCTransport {
-  RTCPeerConnection pc;
-  List<RTCIceCandidate> pendingCandidates = [];
+  final RTCPeerConnection pc;
+  final List<RTCIceCandidate> _pendingCandidates = [];
   bool restartingIce = false;
 
   PCTransport(this.pc);
 
+  Future<void> dispose() async {
+    // Ensure callbacks won't fire any more
+    pc.onRenegotiationNeeded = null;
+    pc.onIceCandidate = null;
+    pc.onIceConnectionState = null;
+    pc.onTrack = null;
+
+    List<RTCRtpSender> senders = [];
+    try {
+      senders = await pc.getSenders();
+    } catch (_) {}
+
+    for (final e in senders) {
+      try {
+        await pc.removeTrack(e);
+      } catch (_) {}
+    }
+
+    await pc.close();
+    await pc.dispose();
+  }
+
   Future<void> setRemoteDescription(RTCSessionDescription sd) async {
     await pc.setRemoteDescription(sd);
 
-    await Future.forEach<RTCIceCandidate>(pendingCandidates, (candidate) async {
+    await Future.forEach<RTCIceCandidate>(_pendingCandidates, (candidate) async {
       await pc.addCandidate(candidate);
     });
 
-    pendingCandidates.clear();
+    _pendingCandidates.clear();
     restartingIce = false;
   }
 
   Future<void> addIceCandidate(RTCIceCandidate candidate) async {
     final desc = await getRemoteDescription();
+
     if (desc != null && !restartingIce) {
-      return pc.addCandidate(candidate);
+      await pc.addCandidate(candidate);
+      return;
     }
-    pendingCandidates.add(candidate);
+
+    _pendingCandidates.add(candidate);
   }
 
   Future<RTCSessionDescription?> getRemoteDescription() async {
-    if (pc.iceConnectionState == null) {
-      return null;
+    // Checking agains null doesn't work as intended
+    // if (pc.iceConnectionState == null) return null;
+    try {
+      final result = await pc.getRemoteDescription();
+      logger.fine('pc.getRemoteDescription $result');
+      return result;
+    } catch (_) {
+      logger.warning('pc.getRemoteDescription did throw: $_');
     }
-    return pc.getRemoteDescription();
   }
 }