Java binding for RtpSender/RtpReceiver.

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

 /*
  * libjingle
  * Copyright 2013 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 11 matching lines @@
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 
 package org.webrtc;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 
 /**
  * Java-land version of the PeerConnection APIs; wraps the C++ API
  * http://www.webrtc.org/reference/native-apis, which in turn is inspired by the
  * JS APIs: http://dev.w3.org/2011/webrtc/editor/webrtc.html and
  * http://www.w3.org/TR/mediacapture-streams/
  */
 public class PeerConnection {
@@ skipping 121 matching lines @@
       audioJitterBufferFastAccelerate = false;
       iceConnectionReceivingTimeout = -1;
       keyType = KeyType.ECDSA;
       continualGatheringPolicy = ContinualGatheringPolicy.GATHER_ONCE;
     }
   };
 
   private final List<MediaStream> localStreams;
   private final long nativePeerConnection;
   private final long nativeObserver;
+  private List<RtpSender> senders;
+  private List<RtpReceiver> receivers;
 
   PeerConnection(long nativePeerConnection, long nativeObserver) {
     this.nativePeerConnection = nativePeerConnection;
     this.nativeObserver = nativeObserver;
     localStreams = new LinkedList<MediaStream>();
+    senders = new LinkedList<RtpSender>();
+    receivers = new LinkedList<RtpReceiver>();
   }
 
   // JsepInterface.
   public native SessionDescription getLocalDescription();
 
   public native SessionDescription getRemoteDescription();
 
   public native DataChannel createDataChannel(
       String label, DataChannel.Init init);
 
@@ skipping 23 matching lines @@
     }
     localStreams.add(stream);
     return true;
   }
 
   public void removeStream(MediaStream stream) {
     nativeRemoveLocalStream(stream.nativeStream);
     localStreams.remove(stream);
   }
 
+  // Note that calling getSenders will dispose of the senders previously
+  // returned (and same goes for getReceivers).
+  public List<RtpSender> getSenders() {
+    for (RtpSender sender : senders) {
+      sender.dispose();
+    }
+    senders = nativeGetSenders();
+    return Collections.unmodifiableList(senders);
+  }
+
+  public List<RtpReceiver> getReceivers() {
+    for (RtpReceiver receiver : receivers) {
+      receiver.dispose();
+    }
+    receivers = nativeGetReceivers();
+    return Collections.unmodifiableList(receivers);
+  }
+
   public boolean getStats(StatsObserver observer, MediaStreamTrack track) {
     return nativeGetStats(observer, (track == null) ? 0 : track.nativeTrack);
   }
 
   // TODO(fischman): add support for DTMF-related methods once that API
   // stabilizes.
   public native SignalingState signalingState();
 
   public native IceConnectionState iceConnectionState();
 
   public native IceGatheringState iceGatheringState();
 
   public native void close();
 
   public void dispose() {
     close();
     for (MediaStream stream : localStreams) {
       nativeRemoveLocalStream(stream.nativeStream);
       stream.dispose();
     }
     localStreams.clear();
+    for (RtpSender sender : senders) {
+      sender.dispose();
+    }
+    senders.clear();
+    for (RtpReceiver receiver : receivers) {
+      receiver.dispose();
+    }
+    receivers.clear();
     freePeerConnection(nativePeerConnection);
     freeObserver(nativeObserver);
   }
 
   private static native void freePeerConnection(long nativePeerConnection);
 
   private static native void freeObserver(long nativeObserver);
 
   private native boolean nativeAddIceCandidate(
       String sdpMid, int sdpMLineIndex, String iceCandidateSdp);
 
   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();
 }