Exposing RtpSenders and RtpReceivers from PeerConnection.

talk/app/webrtc/java/src/org/webrtc/PeerConnection.java

Index: talk/app/webrtc/java/src/org/webrtc/PeerConnection.java
diff --git a/talk/app/webrtc/java/src/org/webrtc/PeerConnection.java b/talk/app/webrtc/java/src/org/webrtc/PeerConnection.java
index 8730af96c90035f42e767f73e913f5c849ead55d..ac9009cc2222dd714340a178bde26b8de3198c9e 100644
--- a/talk/app/webrtc/java/src/org/webrtc/PeerConnection.java
+++ b/talk/app/webrtc/java/src/org/webrtc/PeerConnection.java
@@ -161,6 +161,8 @@ public class PeerConnection {
   };
 
   private final List<MediaStream> localStreams;
+  private final List<RtpSender> rtpSenders;
+  private final List<RtpReceiver> rtpReceivers;

[pthatcher1, 2015/09/23 14:47:39]

I'd just shorten these to senders and receivers.

   private final long nativePeerConnection;
   private final long nativeObserver;
 
@@ -168,6 +170,8 @@ public class PeerConnection {
     this.nativePeerConnection = nativePeerConnection;
     this.nativeObserver = nativeObserver;
     localStreams = new LinkedList<MediaStream>();
+    rtpSenders = new LinkedList<RtpSender>();
+    rtpReceivers = new LinkedList<RtpReceiver>();
   }
 
   // JsepInterface.
@@ -184,11 +188,15 @@ public class PeerConnection {
   public native void createAnswer(
       SdpObserver observer, MediaConstraints constraints);
 
-  public native void setLocalDescription(
-      SdpObserver observer, SessionDescription sdp);
+  public void setLocalDescription(SdpObserver observer, SessionDescription sdp) {
+      nativeSetLocalDescription(observer, sdp);
+      updateRtpSenders();
+  }
 
-  public native void setRemoteDescription(
-      SdpObserver observer, SessionDescription sdp);
+  public void setRemoteDescription(SdpObserver observer, SessionDescription sdp) {
+      nativeSetRemoteDescription(observer, sdp);
+      updateRtpReceivers();
+  }
 
   public native boolean updateIce(
       List<IceServer> iceServers, MediaConstraints constraints);
@@ -204,12 +212,22 @@ public class PeerConnection {
       return false;
     }
     localStreams.add(stream);
+    updateRtpSenders();
     return true;
   }
 
   public void removeStream(MediaStream stream) {
     nativeRemoveLocalStream(stream.nativeStream);
     localStreams.remove(stream);
+    updateRtpSenders();
+  }
+
+  public List<RtpSender> getSenders() {
+      return new ArrayList<RtpSender>(rtpSenders);
+  }
+
+  public List<RtpReceiver> getReceivers() {
+      return new ArrayList<RtpReceiver>(rtpReceivers);
   }
 
   public boolean getStats(StatsObserver observer, MediaStreamTrack track) {
@@ -233,6 +251,14 @@ public class PeerConnection {
       stream.dispose();
     }
     localStreams.clear();
+    for (RtpSender sender : rtpSenders) {
+        sender.dispose();
+    }
+    rtpSenders.clear();
+    for (RtpReceiver receiver : rtpReceivers) {
+        receiver.dispose();
+    }
+    rtpReceivers.clear();
     freePeerConnection(nativePeerConnection);
     freeObserver(nativeObserver);
   }
@@ -241,13 +267,99 @@ public class PeerConnection {
 
   private static native void freeObserver(long nativeObserver);
 
+  private void updateRtpSenders() {
+      List<RtpSender> newRtpSenders = nativeGetSenders();
+
+      // Remove obsolete senders.
+      ArrayList<RtpSender> toRemove = new ArrayList<RtpSender>();
+      for (RtpSender oldSender : rtpSenders) {
+          boolean found = false;
+          for (RtpSender newSender : newRtpSenders) {
+              if (newSender.nativeRtpSender == oldSender.nativeRtpSender) {
+                  found = true;
+                  break;
+              }
+          }
+          if (!found) {
+              toRemove.add(oldSender);
+          }
+      }
+      for (RtpSender removed : toRemove) {
+          rtpSenders.remove(removed);
+          removed.dispose();
+      }
+
+      // Add new senders.
+      for (RtpSender newSender : newRtpSenders) {
+          boolean found = false;
+          for (RtpSender oldSender : rtpSenders) {
+              if (newSender.nativeRtpSender == oldSender.nativeRtpSender) {
+                  found = true;
+                  // Dispose of the duplicate RtpSender.
+                  newSender.dispose();
+                  break;
+              }
+          }
+          if (!found) {
+              rtpSenders.add(newSender);
+          }
+      }
+  }
+
+  private void updateRtpReceivers() {
+      List<RtpReceiver> newRtpReceivers = nativeGetReceivers();
+
+      // Remove obsolete receivers.
+      ArrayList<RtpReceiver> toRemove = new ArrayList<RtpReceiver>();
+      for (RtpReceiver oldReceiver : rtpReceivers) {
+          boolean found = false;
+          for (RtpReceiver newReceiver : newRtpReceivers) {
+              if (newReceiver.nativeRtpReceiver == oldReceiver.nativeRtpReceiver) {
+                  found = true;
+                  break;
+              }
+          }
+          if (!found) {
+              toRemove.add(oldReceiver);
+          }
+      }
+      for (RtpReceiver removed : toRemove) {
+          rtpReceivers.remove(removed);
+          removed.dispose();
+      }
+
+      // Add new receivers.
+      for (RtpReceiver newReceiver : newRtpReceivers) {
+          boolean found = false;
+          for (RtpReceiver oldReceiver : rtpReceivers) {
+              if (newReceiver.nativeRtpReceiver == oldReceiver.nativeRtpReceiver) {
+                  found = true;
+                  // Dispose of the duplicate RtpReceiver.
+                  newReceiver.dispose();
+                  break;
+              }
+          }
+          if (!found) {
+              rtpReceivers.add(newReceiver);
+          }
+      }

[pthatcher1, 2015/09/23 14:47:39]

It seems like a helper method called hasReceiver could clean this up a bit:

bool native hasReceiver(Iterable<RtpReceiver> receivers, RtpReceiver receiver) {
  for (RtpReceiver receiver2: receivers) {
    if (receiver.nativeRtpReceiver == receiver2.nativeRtpReceiver) {
      return true;
    }
  }
  return false;
}
for (RtpReceiver oldReceiver: receivers) {
  if (!hasReceiver(newReceivers, oldReceiver)) {
    toRemove.add(oldReceiver);
  }
}

for (RtpReceiver removed : toRemove) {
  rtpReceivers.remove(removed);
  removed.dispose();
}

for (RtpReceiver newReceiver : newReceivers) {
  if (hasReceiver(receivers, newReceiver)) {
    newReceiver.dispose();
  } else {
    receivers.add(newReceiver);
  }
}


And if you just copy the old receivers, it's even more readable:

List<RtpReceiver> oldReceivers = getReceivers();
for (RtpReceiver oldReceiver: oldReceivers) {
  if (!hasReceiver(newReceivers, oldReceiver)) {
    receivers.remove(oldReceiver);
  }
}

for (RtpReceiver newReceiver : newReceivers) {
  if (hasReceiver(oldReceivers, newReceiver)) {
    newReceiver.dispose();
  } else {
    receivers.add(newReceiver);
  }
}

+  }
+
   private native boolean nativeAddIceCandidate(
       String sdpMid, int sdpMLineIndex, String iceCandidateSdp);
 
+  public native void nativeSetLocalDescription(SdpObserver observer, SessionDescription sdp);
+
+  public native void nativeSetRemoteDescription(SdpObserver observer, SessionDescription sdp);
+
   private native boolean nativeAddLocalStream(long nativeStream);
 
   private native void nativeRemoveLocalStream(long nativeStream);
 
   private native boolean nativeGetStats(
       StatsObserver observer, long nativeTrack);
+
+  private native List<RtpSender> nativeGetSenders();
+
+  private native List<RtpReceiver> nativeGetReceivers();
 }