next-coder
diff --git a/‎android/src/main/java/com/cloudwebrtc/webrtc/MethodCallHandlerImpl.java
Lines changed: 42 additions & 0 deletions b/‎android/src/main/java/com/cloudwebrtc/webrtc/MethodCallHandlerImpl.java
Lines changed: 42 additions & 0 deletions
diff --git a/‎android/src/main/java/com/cloudwebrtc/webrtc/PeerConnectionObserver.java
Lines changed: 34 additions & 1 deletion b/‎android/src/main/java/com/cloudwebrtc/webrtc/PeerConnectionObserver.java
Lines changed: 34 additions & 1 deletion
diff --git a/‎common/darwin/Classes/FlutterWebRTCPlugin.m
Lines changed: 63 additions & 6 deletions b/‎common/darwin/Classes/FlutterWebRTCPlugin.m
Lines changed: 63 additions & 6 deletions
diff --git a/‎example/lib/src/loopback_sample.dart
Lines changed: 8 additions & 0 deletions b/‎example/lib/src/loopback_sample.dart
Lines changed: 8 additions & 0 deletions
diff --git a/‎lib/src/interface/rtc_peerconnection.dart
Lines changed: 11 additions & 3 deletions b/‎lib/src/interface/rtc_peerconnection.dart
Lines changed: 11 additions & 3 deletions
diff --git a/‎lib/src/native/rtc_peerconnection_impl.dart
Lines changed: 32 additions & 16 deletions b/‎lib/src/native/rtc_peerconnection_impl.dart
Lines changed: 32 additions & 16 deletions
diff --git a/‎lib/src/native/rtc_rtp_receiver_impl.dart
Lines changed: 4 additions & 0 deletions b/‎lib/src/native/rtc_rtp_receiver_impl.dart
Lines changed: 4 additions & 0 deletions
diff --git a/‎lib/src/native/rtc_rtp_sender_impl.dart
Lines changed: 8 additions & 5 deletions b/‎lib/src/native/rtc_rtp_sender_impl.dart
Lines changed: 8 additions & 5 deletions
diff --git a/‎lib/src/native/rtc_rtp_transceiver_impl.dart
Lines changed: 8 additions & 0 deletions b/‎lib/src/native/rtc_rtp_transceiver_impl.dart
Lines changed: 8 additions & 0 deletions
@@ -629,6 +629,21 @@ public void onMethodCall(MethodCall call, @NonNull Result notSafeResult) {
         rtpSenderDispose(peerConnectionId, rtpSenderId, result);
         break;
       }
+      case "getSenders": {
+        String peerConnectionId = call.argument("peerConnectionId");
+        getSenders(peerConnectionId, result);
+        break;
+      }
+      case "getReceivers": {
+        String peerConnectionId = call.argument("peerConnectionId");
+        getReceivers(peerConnectionId, result);
+        break;
+      }
+      case "getTransceivers": {
+        String peerConnectionId = call.argument("peerConnectionId");
+        getTransceivers(peerConnectionId, result);
+        break;
+      }
       default:
         result.notImplemented();
         break;
@@ -1573,6 +1588,33 @@ public void rtpSenderDispose(String peerConnectionId, String rtpSenderId, Result
     }
   }
 
+  public void getSenders(String peerConnectionId, Result result) {
+    PeerConnectionObserver pco = mPeerConnectionObservers.get(peerConnectionId);
+    if (pco == null || pco.getPeerConnection() == null) {
+      resultError("getSenders", "peerConnection is null", result);
+    } else {
+      pco.getSenders(result);
+    }
+  }
+
+  public void getReceivers(String peerConnectionId, Result result) {
+    PeerConnectionObserver pco = mPeerConnectionObservers.get(peerConnectionId);
+    if (pco == null || pco.getPeerConnection() == null) {
+      resultError("getReceivers", "peerConnection is null", result);
+    } else {
+      pco.getReceivers(result);
+    }
+  }
+
+  public void getTransceivers(String peerConnectionId, Result result) {
+    PeerConnectionObserver pco = mPeerConnectionObservers.get(peerConnectionId);
+    if (pco == null || pco.getPeerConnection() == null) {
+      resultError("getTransceivers", "peerConnection is null", result);
+    } else {
+      pco.getTransceivers(result);
+    }
+  }
+
   public void rtpSenderSetTrack(String peerConnectionId, String rtpSenderId, String trackId, boolean replace,  Result result) {
     PeerConnectionObserver pco = mPeerConnectionObservers.get(peerConnectionId);
     if (pco == null || pco.getPeerConnection() == null) {
 
@@ -734,7 +734,7 @@ private Map<String, Object> rtpParametersToMap(RtpParameters rtpParameters){
               map.putInt("maxBitrate", encoding.maxBitrateBps);
           }
           if (encoding.minBitrateBps != null) {
-              map.putInt("minBitrateBps", encoding.minBitrateBps);
+              map.putInt("minBitrate", encoding.minBitrateBps);
           }
           if (encoding.maxFramerate != null) {
               map.putInt("maxFramerate", encoding.maxFramerate);
@@ -964,4 +964,37 @@ public void rtpSenderDispose(String rtpSenderId, Result result) {
         sender.dispose();
         result.success(null);
     }
+
+    public void getSenders(Result result) {
+      List<RtpSender> senders = peerConnection.getSenders();
+      ConstraintsArray sendersParams = new ConstraintsArray();
+      for(RtpSender sender : senders){
+        sendersParams.pushMap(new ConstraintsMap(rtpSenderToMap(sender)));
+      }
+      ConstraintsMap params = new ConstraintsMap();
+      params.putArray("senders", sendersParams.toArrayList());
+      result.success(params.toMap());
+    }
+  
+    public void getReceivers(Result result) {
+      List<RtpReceiver> receivers = peerConnection.getReceivers();
+      ConstraintsArray receiversParams = new ConstraintsArray();
+      for(RtpReceiver receiver : receivers){
+        receiversParams.pushMap(new ConstraintsMap(rtpReceiverToMap(receiver)));
+      }
+      ConstraintsMap params = new ConstraintsMap();
+      params.putArray("receivers", receiversParams.toArrayList());
+      result.success(params.toMap());
+    }
+  
+    public void getTransceivers(Result result) {
+      List<RtpTransceiver> transceivers = peerConnection.getTransceivers();
+      ConstraintsArray transceiversParams = new ConstraintsArray();
+      for(RtpTransceiver receiver : transceivers){
+        transceiversParams.pushMap(new ConstraintsMap(transceiverToMap(receiver)));
+      }
+      ConstraintsMap params = new ConstraintsMap();
+      params.putArray("transceivers", transceiversParams.toArrayList());
+      result.success(params.toMap());
+    }
 }
@@ -7,7 +7,13 @@
 #import <AVFoundation/AVFoundation.h>
 #import <WebRTC/WebRTC.h>
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wprotocol"
+
 @implementation FlutterWebRTCPlugin {
+    
+#pragma clang diagnostic pop
+
     FlutterMethodChannel *_methodChannel;
     id _registry;
     id _messenger;
@@ -852,7 +858,58 @@ - (void)handleMethodCall:(FlutterMethodCall*)call result:(FlutterResult) result
         }
         [peerConnection removeTrack:sender];
         result(nil);
-    }  else {
+    } else if ([@"getSenders" isEqualToString:call.method]){
+        NSDictionary* argsMap = call.arguments;
+        NSString* peerConnectionId = argsMap[@"peerConnectionId"];
+        RTCPeerConnection *peerConnection = self.peerConnections[peerConnectionId];
+        if(peerConnection == nil) {
+            result([FlutterError errorWithCode:[NSString stringWithFormat:@"%@Failed",call.method]
+            message:[NSString stringWithFormat:@"Error: peerConnection not found!"]
+            details:nil]);
+            return;
+        }
+        
+        NSMutableArray *senders = [NSMutableArray array];
+        for (RTCRtpSender *sender in peerConnection.senders) {
+            [senders addObject:[self rtpSenderToMap:sender]];
+        }
+
+        result(@{ @"senders":senders});
+    } else if ([@"getReceivers" isEqualToString:call.method]){
+        NSDictionary* argsMap = call.arguments;
+        NSString* peerConnectionId = argsMap[@"peerConnectionId"];
+        RTCPeerConnection *peerConnection = self.peerConnections[peerConnectionId];
+        if(peerConnection == nil) {
+            result([FlutterError errorWithCode:[NSString stringWithFormat:@"%@Failed",call.method]
+            message:[NSString stringWithFormat:@"Error: peerConnection not found!"]
+            details:nil]);
+            return;
+        }
+        
+        NSMutableArray *receivers = [NSMutableArray array];
+        for (RTCRtpReceiver *receiver in peerConnection.receivers) {
+            [receivers addObject:[self receiverToMap:receiver]];
+        }
+
+        result(@{ @"receivers":receivers});
+    } else if ([@"getTransceivers" isEqualToString:call.method]){
+        NSDictionary* argsMap = call.arguments;
+        NSString* peerConnectionId = argsMap[@"peerConnectionId"];
+        RTCPeerConnection *peerConnection = self.peerConnections[peerConnectionId];
+        if(peerConnection == nil) {
+            result([FlutterError errorWithCode:[NSString stringWithFormat:@"%@Failed",call.method]
+            message:[NSString stringWithFormat:@"Error: peerConnection not found!"]
+            details:nil]);
+            return;
+        }
+        
+        NSMutableArray *transceivers = [NSMutableArray array];
+        for (RTCRtpTransceiver *transceiver in peerConnection.transceivers) {
+            [transceivers addObject:[self transceiverToMap:transceiver]];
+        }
+
+        result(@{ @"transceivers":transceivers});
+    } else {
         result(FlutterMethodNotImplemented);
     }
 }
@@ -1131,7 +1188,7 @@ - (NSDictionary*)rtpParametersToMap:(RTCRtpParameters*)parameters {
     for (RTCRtpEncodingParameters* encoding in parameters.encodings) {
         [encodings addObject:@{
             @"active": @(encoding.isActive),
-            @"minBitrateBps": encoding.minBitrateBps? encoding.minBitrateBps : [NSNumber numberWithInt:0],
+            @"minBitrate": encoding.minBitrateBps? encoding.minBitrateBps : [NSNumber numberWithInt:0],
             @"maxBitrate": encoding.maxBitrateBps? encoding.maxBitrateBps : [NSNumber numberWithInt:0],
             @"maxFramerate": encoding.maxFramerate? encoding.maxFramerate : @(30),
             @"numTemporalLayers": encoding.numTemporalLayers? encoding.numTemporalLayers : @(1),
@@ -1348,19 +1405,19 @@ -(RTCRtpParameters *)updateRtpParameters :(NSDictionary *)newParameters : (RTCRt
         RTCRtpEncodingParameters *nativeEncoding = [nativeEncodings objectAtIndex:i];
         NSDictionary *encoding = [encodings objectAtIndex:i];
         if([encoding objectForKey:@"active"]){
-            nativeEncoding.isActive =  [encoding objectForKey:@"active"];
+            nativeEncoding.isActive =  [[encoding objectForKey:@"active"] boolValue];
         }
         if([encoding objectForKey:@"maxBitrate"]){
             nativeEncoding.maxBitrateBps =  [encoding objectForKey:@"maxBitrate"];
         }
-        if([encoding objectForKey:@"minBitrateBps"]){
-            nativeEncoding.minBitrateBps =  [encoding objectForKey:@"minBitrateBps"];
+        if([encoding objectForKey:@"minBitrate"]){
+            nativeEncoding.minBitrateBps =  [encoding objectForKey:@"minBitrate"];
         }
         if([encoding objectForKey:@"maxFramerate"]){
             nativeEncoding.maxFramerate =  [encoding objectForKey:@"maxFramerate"];
         }
         if([encoding objectForKey:@"numTemporalLayers"]){
-            nativeEncoding.isActive =  [encoding objectForKey:@"numTemporalLayers"];
+            nativeEncoding.numTemporalLayers =  [encoding objectForKey:@"numTemporalLayers"];
         }
         if([encoding objectForKey:@"scaleResolutionDownBy"]){
             nativeEncoding.scaleResolutionDownBy =  [encoding objectForKey:@"scaleResolutionDownBy"];
 
@@ -55,6 +55,14 @@ class _MyAppState extends State<LoopBackSample> {
         print('    }');
         print('}');
       });
+      /*
+      var senders = await _peerConnection.getSenders();
+      print(senders.toString());
+      var receivers = await _peerConnection.getReceivers();
+      print(receivers.toString());
+      var transceivers = await _peerConnection.getTransceivers();
+      print(transceivers.toString());
+      */
     }
   }
 
 
@@ -1,3 +1,5 @@
+import 'dart:async';
+
 import 'enums.dart';
 import 'media_stream.dart';
 import 'media_stream_track.dart';
@@ -93,11 +95,17 @@ abstract class RTCPeerConnection {
   RTCDTMFSender createDtmfSender(MediaStreamTrack track);
 
   /// Unified-Plan.
-  List<RTCRtpSender> get senders;
+  Future<List<RTCRtpSender>> getSenders();
+
+  Future<List<RTCRtpSender>> get senders => getSenders();
+
+  Future<List<RTCRtpReceiver>> getReceivers();
+
+  Future<List<RTCRtpReceiver>> get receivers => getReceivers();
 
-  List<RTCRtpReceiver> get receivers;
+  Future<List<RTCRtpTransceiver>> getTransceivers();
 
-  List<RTCRtpTransceiver> get transceivers;
+  Future<List<RTCRtpTransceiver>> get transceivers => getTransceivers();
 
   Future<RTCRtpSender> addTrack(MediaStreamTrack track, [MediaStream stream]);
 
 
@@ -40,9 +40,6 @@ class RTCPeerConnectionNative extends RTCPeerConnection {
   StreamSubscription<dynamic> _eventSubscription;
   final _localStreams = <MediaStream>[];
   final _remoteStreams = <MediaStream>[];
-  final List<RTCRtpSender> _senders = <RTCRtpSender>[];
-  final List<RTCRtpReceiver> _receivers = <RTCRtpReceiver>[];
-  final List<RTCRtpTransceiver> _transceivers = <RTCRtpTransceiver>[];
   RTCDataChannelNative _dataChannel;
   Map<String, dynamic> _configuration;
   RTCSignalingState _signalingState;
@@ -436,13 +433,39 @@ class RTCPeerConnectionNative extends RTCPeerConnection {
 
   /// Unified-Plan.
   @override
-  List<RTCRtpSender> get senders => _senders;
+  Future<List<RTCRtpSender>> getSenders() async {
+    try {
+      final response = await _channel.invokeMethod('getSenders',
+          <String, dynamic>{'peerConnectionId': _peerConnectionId});
+      return RTCRtpSenderNative.fromMaps(response['senders'],
+          peerConnectionId: _peerConnectionId);
+    } on PlatformException catch (e) {
+      throw 'Unable to RTCPeerConnection::addTrack: ${e.message}';
+    }
+  }
 
   @override
-  List<RTCRtpReceiver> get receivers => _receivers;
+  Future<List<RTCRtpReceiver>> getReceivers() async {
+    try {
+      final response = await _channel.invokeMethod('getReceivers',
+          <String, dynamic>{'peerConnectionId': _peerConnectionId});
+      return RTCRtpReceiverNative.fromMaps(response['receivers']);
+    } on PlatformException catch (e) {
+      throw 'Unable to RTCPeerConnection::addTrack: ${e.message}';
+    }
+  }
 
   @override
-  List<RTCRtpTransceiver> get transceivers => _transceivers;
+  Future<List<RTCRtpTransceiver>> getTransceivers() async {
+    try {
+      final response = await _channel.invokeMethod('getTransceivers',
+          <String, dynamic>{'peerConnectionId': _peerConnectionId});
+      return RTCRtpTransceiverNative.fromMaps(response['transceivers'],
+          peerConnectionId: _peerConnectionId);
+    } on PlatformException catch (e) {
+      throw 'Unable to RTCPeerConnection::addTrack: ${e.message}';
+    }
+  }
 
   @override
   Future<RTCRtpSender> addTrack(MediaStreamTrack track,
@@ -454,10 +477,8 @@ class RTCPeerConnectionNative extends RTCPeerConnection {
         'trackId': track.id,
         'streamIds': [stream.id]
       });
-      var sender = RTCRtpSenderNative.fromMap(response);
-      sender.peerConnectionId = _peerConnectionId;
-      _senders.add(sender);
-      return sender;
+      return RTCRtpSenderNative.fromMap(response,
+          peerConnectionId: _peerConnectionId);
     } on PlatformException catch (e) {
       throw 'Unable to RTCPeerConnection::addTrack: ${e.message}';
     }
@@ -472,9 +493,6 @@ class RTCPeerConnectionNative extends RTCPeerConnection {
         'senderId': sender.senderId
       });
       bool result = response['result'];
-      _senders.removeWhere((item) {
-        return sender.senderId == item.senderId;
-      });
       return result;
     } on PlatformException catch (e) {
       throw 'Unable to RTCPeerConnection::removeTrack: ${e.message}';
@@ -495,10 +513,8 @@ class RTCPeerConnectionNative extends RTCPeerConnection {
         if (init != null)
           'transceiverInit': RTCRtpTransceiverInitNative.initToMap(init)
       });
-      var transceiver = RTCRtpTransceiverNative.fromMap(response,
+      return RTCRtpTransceiverNative.fromMap(response,
           peerConnectionId: _peerConnectionId);
-      _transceivers.add(transceiver);
-      return transceiver;
     } on PlatformException catch (e) {
       throw 'Unable to RTCPeerConnection::addTransceiver: ${e.message}';
     }
 
@@ -12,6 +12,10 @@ class RTCRtpReceiverNative extends RTCRtpReceiver {
     return RTCRtpReceiverNative(map['receiverId'], track, parameters);
   }
 
+  static List<RTCRtpReceiverNative> fromMaps(List<dynamic> map) {
+    return map.map((e) => RTCRtpReceiverNative.fromMap(e)).toList();
+  }
+
   /// private:
   String _id;
   MediaStreamTrack _track;
 
@@ -26,18 +26,21 @@ class RTCRtpSenderNative extends RTCRtpSender {
         peerConnectionId);
   }
 
+  static List<RTCRtpSenderNative> fromMaps(List<dynamic> map,
+      {String peerConnectionId}) {
+    return map
+        .map((e) =>
+            RTCRtpSenderNative.fromMap(e, peerConnectionId: peerConnectionId))
+        .toList();
+  }
+
   final MethodChannel _channel = WebRTC.methodChannel();
   String _peerConnectionId;
   String _id;
   MediaStreamTrack _track;
   RTCDTMFSender _dtmf;
   RTCRtpParameters _parameters;
   bool _ownsTrack = false;
-
-  set peerConnectionId(String id) {
-    _peerConnectionId = id;
-  }
-
   @override
   Future<bool> setParameters(RTCRtpParameters parameters) async {
     _parameters = parameters;
 
@@ -71,6 +71,14 @@ class RTCRtpTransceiverNative extends RTCRtpTransceiver {
     return transceiver;
   }
 
+  static List<RTCRtpTransceiverNative> fromMaps(List<dynamic> map,
+      {String peerConnectionId}) {
+    return map
+        .map((e) => RTCRtpTransceiverNative.fromMap(e,
+            peerConnectionId: peerConnectionId))
+        .toList();
+  }
+
   final MethodChannel _channel = WebRTC.methodChannel();
   String _peerConnectionId;
   String _id;