Class PeerConnection

java.lang.Object
com.codename1.webrtc.PeerConnection
public final class PeerConnection extends Object

One end of a call: the media this device sends, what it receives, and the network path between the two.

The sequence is the standard one. The caller adds its tracks, creates an offer, sets it as its local description and sends it; the callee sets it as its remote description, adds its own tracks, creates an answer, sets that locally and sends it back; the caller sets it as remote. Meanwhile both sides send each other every candidate their listener is given. Carrying the descriptions and candidates is the app's job -- over its own server, a WebSocket, anything -- and nothing here sends them.

import com.codename1.io.Log;
import com.codename1.webrtc.*;

WebRtc.openUserMedia(true, false, false).ready(media -> {
    PeerConnection pc = WebRtc.createPeerConnection(new PeerConnectionConfig(),
            new PeerConnection.Listener() {
                public void iceCandidate(PeerConnection connection, IceCandidate candidate) {
                    Log.p("send to the other side: " + candidate.getCandidate());
                }

                public void stateChanged(PeerConnection connection, String state) {
                    Log.p("state " + state);
                }

                public void remoteTrack(PeerConnection connection, MediaTrack track) {
                }
            });
    pc.addTrack(media.getAudio());
    pc.createOffer().ready(offer -> pc.setLocalDescription(offer)
            .ready(done -> Log.p("send to the other side: " + offer.getSdp())));
});

  • Field Details

  • Method Details

    • getState

      public String getState()

    • addTrack

      public void addTrack(MediaTrack track)
      Sends a local track to the other side. Add every track before creating the offer or the answer.

    • createOffer

      public AsyncResource<SessionDescription> createOffer()
      Describes this side for the caller's half of the exchange.

    • createAnswer

      public AsyncResource<SessionDescription> createAnswer()
      Describes this side in answer to the remote offer already set.

    • setLocalDescription

      public AsyncResource<Boolean> setLocalDescription(SessionDescription description)

    • setRemoteDescription

      public AsyncResource<Boolean> setRemoteDescription(SessionDescription description)

    • addIceCandidate

      public void addIceCandidate(IceCandidate candidate)
      Tries a path the other side found. A candidate that arrives before the remote description is set is held by the port until it is.

    • restartIce

      public void restartIce()

      Gathers new paths on the next offer, for a connection whose path was lost -- the device changed network, say, and the addresses the two sides agreed on no longer reach it.

      Nothing changes until the offer is exchanged: call this, then createOffer(), and send the offer over the app's signalling as at the start of the call. The other side answers it with setRemoteDescription(SessionDescription) and createAnswer() and sends that back; tracks, views and the call keep going, and the connection reports CONNECTED again once a new path is found.

      Only one side restarts -- by convention the one that made the first offer -- or both offer at once and neither offer can be answered. DISCONNECTED is the cue to show "reconnecting", and to restart if it does not recover within a second or two; FAILED is the cue to restart at once.

    • close

      public void close()
      Ends the connection. Local tracks stay open: release them separately.