WebRTC 1.0: Real-Time Communication Between Browsers

Abstract

This document defines a set of ECMAScript APIs in WebIDL to allow media and generic application data to be sent to and received from another browser or device implementing the appropriate set of real-time protocols. This specification is being developed in conjunction with a protocol specification developed by the IETF RTCWEB group and an API specification to get access to local media devices.

An RTCPeerConnection instance allows an application to establish peer-to-peer communications with another RTCPeerConnection instance in another browser, or to another endpoint implementing the required protocols. Communications are coordinated by the exchange of control messages (called a signaling protocol) over a signaling channel which is provided by unspecified means, but generally by a script in the page via the server, e.g. using Web Sockets or XMLHttpRequest [ xhr ].

The RTCConfiguration defines a set of parameters to configure how the peer-to-peer communication established via RTCPeerConnection is established or re-established.

WebIDLdictionary RTCConfiguration {
  sequence<RTCIceServer> iceServers = [];
  RTCIceTransportPolicy iceTransportPolicy = "all";
  RTCBundlePolicy bundlePolicy = "balanced";
  RTCRtcpMuxPolicy rtcpMuxPolicy = "require";
  sequence<RTCCertificate> certificates = [];
  [octet iceCandidatePoolSize = 0;
};

iceServers of type sequence< RTCIceServer > , defaulting to [].

An array of objects describing servers available to be used by ICE, such as STUN and TURN servers. If the number of ICE servers exceeds an implementation-defined limit, ignore the ICE servers above the threshold. This implementation defined limit MUST be at least 32.

iceTransportPolicy of type RTCIceTransportPolicy , defaulting to "all".

Indicates which candidates the ICE Agent is allowed to use.

bundlePolicy of type RTCBundlePolicy , defaulting to "balanced".

Indicates which media-bundling policy to use when gathering ICE candidates.

rtcpMuxPolicy of type RTCRtcpMuxPolicy , defaulting to "require".

Indicates which rtcp-mux policy to use when gathering ICE candidates.

certificates of type sequence< RTCCertificate > , defaulting to [].

A set of certificates that the RTCPeerConnection uses to authenticate.

Valid values for this parameter are created through calls to the generateCertificate () function.

Although any given DTLS connection will use only one certificate, this attribute allows the caller to provide multiple certificates that support different algorithms. The final certificate will be selected based on the DTLS handshake, which establishes which certificates are allowed. The RTCPeerConnection implementation selects which of the certificates is used for a given connection; how certificates are selected is outside the scope of this specification.

Note

Existing implementations only utilize the first certificate provided; the others are ignored.

If this value is absent, then a default set of certificates is generated for each RTCPeerConnection instance.

This option allows applications to establish key continuity. An RTCCertificate can be persisted in [ INDEXEDDB ] and reused. Persistence and reuse also avoids the cost of key generation.

The value for this configuration option cannot change after its value is initially selected.

iceCandidatePoolSize of type octet , defaulting to 0

Size of the prefetched ICE pool as defined in [ RFC8829 ] .

WebIDLenum RTCIceCredentialType {
  "password"
};

`RTCIceCredentialType` Enumeration description
Enum value	Description
`password`	The credential is a long-term authentication username and password, as described in [ RFC5389 ], Section 10.2.

The RTCIceServer dictionary is used to describe the STUN and TURN servers that can be used by the ICE Agent to establish a connection with a peer.

WebIDLdictionary RTCIceServer {
  required (DOMString>) urls;
  DOMString username;
  DOMString credential;
  RTCIceCredentialType credentialType = "password";
};

urls of type (DOMString or sequence<DOMString>) , required

STUN or TURN URI(s) as defined in [ RFC7064 ] and [ RFC7065 ] or other URI types.

username of type DOMString

If this RTCIceServer object represents a TURN server, and credentialType is " password ", then this attribute specifies the username to use with that TURN server.

credential of type DOMString

If this RTCIceServer object represents a TURN server, then this attribute specifies the credential to use with that TURN server.

If credentialType is " password ", credential represents a long-term authentication password, as described in [ RFC5389 ], Section 10.2.

Note

To support additional values of credentialType , credential may evolve in future as a union.

credentialType of type RTCIceCredentialType , defaulting to " password "

If this RTCIceServer object represents a TURN server, then this attribute specifies how credential should be used when that TURN server requests authorization.

An example array of RTCIceServer objects is:

Example 1

[
  {urls: 'stun:stun1.example.net'},
  {urls: ['turns:turn.example.org', 'turn:turn.example.net'],
    username: 'user',
    credential: 'myPassword',
    credentialType: 'password'},
];

As described in [ RFC8829 ] , if the iceTransportPolicy member of the RTCConfiguration is specified, it defines the ICE candidate policy [ RFC8829 ] the browser uses to surface the permitted candidates to the application; only these candidates will be used for connectivity checks.

WebIDLenum RTCIceTransportPolicy {
  "relay",
  "all"
};

`RTCIceTransportPolicy` Enumeration description
Enum value	Description
`relay`	The ICE Agent uses only media relay candidates such as candidates passing through a TURN server. Note This can be used to prevent the remote endpoint from learning the user's IP addresses, which may be desired in certain use cases. For example, in a "call"-based application, the application may want to prevent an unknown caller from learning the callee's IP addresses until the callee has consented in some way.
`all`	The ICE Agent can use any type of candidate when this value is specified. Note The implementation can still use its own candidate filtering policy in order to limit the IP addresses exposed to the application, as noted in the description of `RTCIceCandidate` . `address` .

As described in [ RFC8829 ] , bundle policy affects which media tracks are negotiated if the remote endpoint is not bundle-aware, and what ICE candidates are gathered. If the remote endpoint is bundle-aware, all media tracks and data channels are bundled onto the same transport.

WebIDLenum RTCBundlePolicy {
  "balanced",
  "max-compat",
  "max-bundle"
};

`RTCBundlePolicy` Enumeration description
Enum value	Description
`balanced`	Gather ICE candidates for each media type in use (audio, video, and data). If the remote endpoint is not bundle-aware, negotiate only one audio and video track on separate transports.
`max-compat`	Gather ICE candidates for each track. If the remote endpoint is not bundle-aware, negotiate all media tracks on separate transports.
`max-bundle`	Gather ICE candidates for only one track. If the remote endpoint is not bundle-aware, negotiate only one media track.

As described in [ RFC8829 ] , the RTCRtcpMuxPolicy affects what ICE candidates are gathered to support non-multiplexed RTCP. The only value defined in this spec is " require ".

WebIDLenum RTCRtcpMuxPolicy {
  "require"
};

`RTCRtcpMuxPolicy` Enumeration description
Enum value	Description
`require`	Gather ICE candidates only for RTP and multiplex RTCP on the RTP candidates. If the remote endpoint is not capable of rtcp-mux, session negotiation will fail.

These dictionaries describe the options that can be used to control the offer/answer creation process.



WebIDL




dictionary


RTCOfferAnswerOptions


{};

WebIDLdictionary RTCOfferOptions : RTCOfferAnswerOptions {
  boolean iceRestart = false;
};

iceRestart of type boolean , defaulting to false

When the value of this dictionary member is true, or the relevant RTCPeerConnection object's [[LocalIceCredentialsToReplace]] slot is not empty, then the generated description will have ICE credentials that are different from the current credentials (as visible in the currentLocalDescription attribute's SDP). Applying the generated description will restart ICE, as described in section 9.1.1.1 of [ RFC5245 ].

When the value of this dictionary member is false, and the relevant RTCPeerConnection object's [[LocalIceCredentialsToReplace]] slot is empty, and the currentLocalDescription attribute has valid ICE credentials, then the generated description will have the same ICE credentials as the current value from the currentLocalDescription attribute.

Note

Performing an ICE restart is recommended when iceConnectionState transitions to " failed ". An application may additionally choose to listen for the iceConnectionState transition to " disconnected " and then use other sources of information (such as using getStats to measure if the number of bytes sent or received over the next couple of seconds increases) to determine whether an ICE restart is advisable.

The RTCAnswerOptions dictionary describe options specific to session description of type " answer " (none in this version of the specification).



WebIDL




dictionary


RTCAnswerOptions


:



RTCOfferAnswerOptions



{};

WebIDLenum RTCSignalingState {
  "stable",
  "have-local-offer",
  "have-remote-offer",
  "have-local-pranswer",
  "have-remote-pranswer",
  "closed"
};

`RTCSignalingState` Enumeration description
Enum value	Description
`stable`	There is no offer/answer exchange in progress. This is also the initial state, in which case the local and remote descriptions are empty.
`have-local-offer`	A local description, of type " `offer` ", has been successfully applied.
`have-remote-offer`	A remote description, of type " `offer` ", has been successfully applied.
`have-local-pranswer`	A remote description of type " `offer` " has been successfully applied and a local description of type " `pranswer` " has been successfully applied.
`have-remote-pranswer`	A local description of type " `offer` " has been successfully applied and a remote description of type " `pranswer` " has been successfully applied.
`closed`	The `RTCPeerConnection` has been closed; its `[[IsClosed]]` slot is `true`.

signaling state transition diagram — Figure 1 Non-normative signaling state transitions diagram. Method calls abbreviated.

An example set of transitions might be:

Caller transition:

new RTCPeerConnection(): " stable "
setLocalDescription(offer): " have-local-offer "
setRemoteDescription(pranswer): " have-remote-pranswer "
setRemoteDescription(answer): " stable "

Callee transition:

new RTCPeerConnection(): " stable "
setRemoteDescription(offer): " have-remote-offer "
setLocalDescription(pranswer): " have-local-pranswer "
setLocalDescription(answer): " stable "

WebIDLenum RTCIceGatheringState {
  "new",
  "gathering",
  "complete"
};

`RTCIceGatheringState` Enumeration description
Enum value	Description
`new`	Any of the `RTCIceTransport` s are in the " `new` " gathering state and none of the transports are in the " `gathering` " state, or there are no transports.
`gathering`	Any of the `RTCIceTransport` s are in the " `gathering` " state.
`complete`	At least one `RTCIceTransport` exists, and all `RTCIceTransport` s are in the " `complete` " gathering state.

The set of transports considered is the one presently referenced by the PeerConnection's set of transceivers and the PeerConnection's [[SctpTransport]] internal slot if not null.

WebIDLenum RTCPeerConnectionState {
  "closed",
  "failed",
  "disconnected",
  "new",
  "connecting",
  "connected"
};

`RTCPeerConnectionState` Enumeration description
Enum value	Description
`closed`	The `RTCPeerConnection` object's `[[IsClosed]]` slot is `true`.
`failed`	The previous state doesn't apply and any `RTCIceTransport` s are in the " `failed` " state or any `RTCDtlsTransport` s are in the " `failed` " state.
`disconnected`	None of the previous states apply and any `RTCIceTransport` s are in the " `disconnected` " state.
`new`	None of the previous states apply and all `RTCIceTransport` s are in the " `new` " or " `closed` " state, and all `RTCDtlsTransport` s are in the " `new` " or " `closed` " state, or there are no transports.
`connecting`	None of the previous states apply and any `RTCIceTransport` is in the " `new` " or " `checking` " state or any `RTCDtlsTransport` is in the " `new` " or " `connecting` " state.
`connected`	None of the previous states apply and all `RTCIceTransport` s are in the " `connected` ", " `completed` " or " `closed` " state, and all `RTCDtlsTransport` s are in the " `connected` " or " `closed` " state.

The set of transports considered is the one presently referenced by the PeerConnection's set of transceivers and the PeerConnection's [[SctpTransport]] internal slot if not null.

WebIDLenum RTCIceConnectionState {
  "closed",
  "failed",
  "disconnected",
  "new",
  "checking",
  "completed",
  "connected"
};

`RTCIceConnectionState` Enumeration description
Enum value	Description
`closed`	The `RTCPeerConnection` object's `[[IsClosed]]` slot is `true`.
`failed`	The previous state doesn't apply and any `RTCIceTransport` s are in the " `failed` " state.
`disconnected`	None of the previous states apply and any `RTCIceTransport` s are in the " `disconnected` " state.
`new`	None of the previous states apply and all `RTCIceTransport` s are in the " `new` " or " `closed` " state, or there are no transports.
`checking`	None of the previous states apply and any `RTCIceTransport` s are in the " `new` " or " `checking` " state.
`completed`	None of the previous states apply and all `RTCIceTransport` s are in the " `completed` " or " `closed` " state.
`connected`	None of the previous states apply and all `RTCIceTransport` s are in the " `connected` ", " `completed` " or " `closed` " state.

The set of transports considered is the one presently referenced by the PeerConnection's set of transceivers and the PeerConnection's [[SctpTransport]] internal slot if not null.

Note that if an RTCIceTransport is discarded as a result of signaling (e.g. RTCP mux or bundling), or created as a result of signaling (e.g. adding a new media description ), the state may advance directly from one state to another.

The [ RFC8829 ] specification, as a whole, describes the details of how the RTCPeerConnection operates. References to specific subsections of [ RFC8829 ] are provided as appropriate.

Calling new RTCPeerConnection ( configuration ) creates an RTCPeerConnection object.

configuration. iceServers contains information used to find and access the servers used by ICE. The application can supply multiple servers of each type, and any TURN server MAY also be used as a STUN server for the purposes of gathering server reflexive candidates.

An RTCPeerConnection object has a signaling state , a connection state , an ICE gathering state , and an ICE connection state . These are initialized when the object is created.

The ICE protocol implementation of an RTCPeerConnection is represented by an ICE agent [ RFC5245 ]. Certain RTCPeerConnection methods involve interactions with the ICE Agent , namely addIceCandidate , setConfiguration , setLocalDescription , setRemoteDescription and close . These interactions are described in the relevant sections in this document and in [ RFC8829 ]. The ICE Agent also provides indications to the user agent when the state of its internal representation of an RTCIceTransport changes, as described in 5.6 RTCIceTransport Interface .

The task source for the tasks listed in this section is the networking task source .

Note

The state of the SDP negotiation is represented by the signaling state and the internal variables [[CurrentLocalDescription]] , [[CurrentRemoteDescription]] , [[PendingLocalDescription]] and [[PendingRemoteDescription]] . These are only set inside the setLocalDescription and setRemoteDescription operations, and modified by the addIceCandidate operation and the surface a candidate procedure. In each case, all the modifications to all the five variables are completed before the procedures fire any events or invoke any callbacks, so the modifications are made visible at a single point in time.

As one of the unloading document cleanup steps , run the following steps:

Let window be document 's relevant global object .
For each RTCPeerConnection object connection whose relevant global object is window, close the connection with connection and the value true.

When the RTCPeerConnection.constructor() is invoked, the user agent MUST run the following steps:

If any of the steps enumerated below fails for a reason not specified here, throw an UnknownError with the message attribute set to an appropriate description.
Let connection be a newly created RTCPeerConnection object.
Let connection have a [[DocumentOrigin]] internal slot, initialized to the relevant settings object 's origin .
Let configuration be the method's first argument.
If the certificates value in configuration is non-empty, run the following steps for each certificate in certificates:
1. If the value of certificate. expires is less than the current time, throw an InvalidAccessError .
2. If certificate. [[Origin]] is not same origin with connection. [[DocumentOrigin]] , throw an InvalidAccessError .
3. Store certificate.
Else, generate one or more new RTCCertificate instances with this RTCPeerConnection instance and store them. This MAY happen asynchronously and the value of certificates remains undefined for the subsequent steps. As noted in Section 4.3.2.3 of [ RFC8826 ], WebRTC utilizes self-signed rather than Public Key Infrastructure (PKI) certificates, so that the expiration check is to ensure that keys are not used indefinitely and additional certificate checks are unnecessary.
If configuration. iceServer is an array truncate it to the maximum number of supported elements.
Initialize connection 's ICE Agent .
Let connection have a [[Configuration]] internal slot, initialized to null. Set the configuration specified by configuration.
Let connection have an [[IsClosed]] internal slot, initialized to false.
Let connection have a [[NegotiationNeeded]] internal slot, initialized to false.
Let connection have an [[SctpTransport]] internal slot, initialized to null.
Let connection have an [[Operations]] internal slot, representing an operations chain , initialized to an empty list.
Let connection have a [[UpdateNegotiationNeededFlagOnEmptyChain]] internal slot, initialized to false.
Let connection have an [[LastCreatedOffer]] internal slot, initialized to "".
Let connection have an [[LastCreatedAnswer]] internal slot, initialized to "".
Let connection have an [[EarlyCandidates]] internal slot, initialized to an empty list.
Set connection 's signaling state to " stable ".
Set connection 's ICE connection state to " new ".
Set connection 's ICE gathering state to " new ".
Set connection 's connection state to " new ".
Let connection have a [[PendingLocalDescription]] internal slot, initialized to null.
Let connection have a [[CurrentLocalDescription]] internal slot, initialized to null.
Let connection have a [[PendingRemoteDescription]] internal slot, initialized to null.
Let connection have a [[CurrentRemoteDescription]] internal slot, initialized to null.
Let connection have a [[LocalIceCredentialsToReplace]] internal slot, initialized to an empty set.
Return connection.

An RTCPeerConnection object has an operations chain , [[Operations]] , which ensures that only one asynchronous operation in the chain executes concurrently. If subsequent calls are made while the returned promise of a previous call is still not settled , they are added to the chain and executed when all the previous calls have finished executing and their promises have settled .

To chain an operation to an RTCPeerConnection object's operations chain , run the following steps:

Let connection be the RTCPeerConnection object.
If connection. [[IsClosed]] is true, return a promise rejected with a newly created InvalidStateError .
Let operation be the operation to be chained.
Let p be a new promise.
Append operation to [[Operations]] .
If the length of [[Operations]] is exactly 1, execute operation.
Upon fulfillment or rejection of the promise returned by the operation, run the following steps:
1. If connection. [[IsClosed]] is true, abort these steps.
2. If the promise returned by operation was fulfilled with a value, fulfill p with that value.
3. If the promise returned by operation was rejected with a value, reject p with that value.
4. Upon fulfillment or rejection of p, execute the following steps:
  1. If connection. [[IsClosed]] is true, abort these steps.
  2. Remove the first element of [[Operations]] .
  3. If [[Operations]] is non-empty, execute the operation represented by the first element of [[Operations]] , and abort these steps.
  4. If connection. [[UpdateNegotiationNeededFlagOnEmptyChain]] is false, abort these steps.
  5. Set connection. [[UpdateNegotiationNeededFlagOnEmptyChain]] to false.
  6. Update the negotiation-needed flag for connection.
Return p.

An RTCPeerConnection object has an aggregated connection state . Whenever the state of an RTCDtlsTransport changes or when the [[IsClosed]] slot turns true, the user agent MUST update the connection state by queueing a task that runs the following steps:

Let connection be this RTCPeerConnection object.
Let newState be the value of deriving a new state value as described by the RTCPeerConnectionState enum.
If connection 's connection state is equal to newState, abort these steps.
Let connection 's connection state be newState.
Fire an event named connectionstatechange at connection.

To update the ICE gathering state of an RTCPeerConnection instance connection, the user agent MUST queue a task that runs the following steps:

If connection. [[IsClosed]] is true, abort these steps.
Let newState be the value of deriving a new state value as described by the RTCIceGatheringState enum.
If connection 's ICE gathering state is equal to newState, abort these steps.
Set connection 's ICE gathering state to newState.
Fire an event named icegatheringstatechange at connection.
If newState is " complete ", fire an event named icecandidate using the RTCPeerConnectionIceEvent interface with the candidate attribute set to null at connection.

Note

The null candidate event is fired to ensure legacy compatibility. New code should monitor the gathering state of RTCIceTransport and/or RTCPeerConnection .

To set a local session description description on an RTCPeerConnection object connection, set the session description description on connection with the additional value false.

To set a remote session description description on an RTCPeerConnection object connection, set the session description description on connection with the additional value true.

To set a session description description on an RTCPeerConnection object connection, given a remote boolean, run the following steps:

Let p be a new promise.
If description. type is " rollback " and connection 's signaling state is either " stable ", " have-local-pranswer ", or " have-remote-pranswer ", then reject p with a newly created InvalidStateError and abort these steps.
Let jsepSetOfTransceivers be a shallow copy of connection 's set of transceivers .
In parallel, start the process to apply description as described in [ RFC8829 ] , with these additional restrictions:
1. Use jsepSetOfTransceivers as the source of truth with regard to what "RtpTransceivers" exist, and their [[JsepMid]] internal slot as their "mid property".
2. If remote is false and this triggers the ICE candidate gathering process in [ RFC8829 ] , the ICE Agent MUST NOT gather candidates that would be administratively prohibited .
3. If remote is true and this triggers ICE connectivity checks in [ RFC8829 ] , the ICE Agent MUST NOT attempt to connect to candidates that are administratively prohibited .
4. If remote is true, validate back-to-back offers as if answers were applied in between, by running the check for subsequent offers as if it were in stable state.
5. If applying description leads to modifying a transceiver transceiver, and transceiver. [[Sender]] . [[SendEncodings]] is non-empty, and not equal to the encodings that would result from processing description, the process of applying description fails. This specification does not allow remotely initiated RID renegotiation.
6. If the process to apply description fails for any reason, then the user agent MUST queue a task that runs the following steps:
  1. If connection. [[IsClosed]] is true, then abort these steps.
  2. If description. type is invalid for the current signaling state of connection as described in [ RFC8829 ] , then reject p with a newly created InvalidStateError and abort these steps.
  3. If the content of description is not valid SDP syntax, then reject p with an RTCError (with errorDetail set to " sdp-syntax-error " and the sdpLineNumber attribute set to the line number in the SDP where the syntax error was detected) and abort these steps.
  4. If remote is true, the connection 's RTCRtcpMuxPolicy is require and the description does not use RTCP mux, then reject p with a newly created InvalidAccessError and abort these steps.
  5. If the description attempted to renegotiate RIDs, as described above, then reject p with a newly created InvalidAccessError and abort these steps.
  6. If the content of description is invalid, then reject p with a newly created InvalidAccessError and abort these steps.
  7. For all other errors, reject p with a newly created OperationError .
7. If description is applied successfully, the user agent MUST queue a task that runs the following steps:
  1. If connection. [[IsClosed]] is true, then abort these steps.
  2. If remote is true and description is of type " offer ", then if any addTrack () methods succeeded during the process to apply description, abort these steps and start the process over as if they had succeeded prior, to include the extra transceiver(s) in the process.
  3. If description is of type " offer " and the signaling state of connection is " stable " then for each transceiver in connection 's set of transceivers , run the following steps:
    1. Set transceiver. [[Sender]] . [[LastStableStateSenderTransport]] to transceiver. [[Sender]] . [[SenderTransport]] .
    2. Set transceiver. [[Receiver]] . [[LastStableStateReceiverTransport]] to transceiver. [[Receiver]] . [[ReceiverTransport]] .
    3. Set transceiver. [[Receiver]] . [[LastStableStateAssociatedRemoteMediaStreams]] to transceiver. [[Receiver]] . [[AssociatedRemoteMediaStreams]] .
    4. Set transceiver. [[Receiver]] . [[LastStableStateReceiveCodecs]] to transceiver. [[Receiver]] . [[ReceiveCodecs]] .
  4. If remote is false, then run one of the following steps:
    1. If description is of type " offer ", set connection. [[PendingLocalDescription]] to a new RTCSessionDescription object constructed from description, set connection 's signaling state to " have-local-offer ", and release early candidates .
    2. If description is of type " answer ", then this completes an offer answer negotiation. Set connection. [[CurrentLocalDescription]] to a new RTCSessionDescription object constructed from description, and set connection. [[CurrentRemoteDescription]] to connection. [[PendingRemoteDescription]] . Set both connection. [[PendingRemoteDescription]] and connection. [[PendingLocalDescription]] to null. Set both connection. [[LastCreatedOffer]] and connection. [[LastCreatedAnswer]] to "", set connection 's signaling state to " stable ", and release early candidates . Finally, if none of the ICE credentials in connection. [[LocalIceCredentialsToReplace]] are present in description, then set connection. [[LocalIceCredentialsToReplace]] to an empty set.
    3. If description is of type " pranswer ", then set connection. [[PendingLocalDescription]] to a new RTCSessionDescription object constructed from description, set connection 's signaling state to " have-local-pranswer ", and release early candidates .
  5. Otherwise, (if remote is true ) run one of the following steps:
    1. If description is of type " offer ", set connection. [[PendingRemoteDescription]] attribute to a new RTCSessionDescription object constructed from description, and set connection 's signaling state to " have-remote-offer ".
    2. If description is of type " answer ", then this completes an offer answer negotiation. Set connection. [[CurrentRemoteDescription]] to a new RTCSessionDescription object constructed from description, and set connection. [[CurrentLocalDescription]] to connection. [[PendingLocalDescription]] . Set both connection. [[PendingRemoteDescription]] and connection. [[PendingLocalDescription]] to null. Set both connection. [[LastCreatedOffer]] and connection. [[LastCreatedAnswer]] to "", and set connection 's signaling state to " stable ". Finally, if none of the ICE credentials in connection. [[LocalIceCredentialsToReplace]] are present in the newly set connection. [[CurrentLocalDescription]] , then set connection. [[LocalIceCredentialsToReplace]] to an empty set.
    3. If description is of type " pranswer ", then set connection. [[PendingRemoteDescription]] to a new RTCSessionDescription object constructed from description and set connection 's signaling state to " have-remote-pranswer ".
  6. If description is of type " answer ", and it initiates the closure of an existing SCTP association, as defined in [ RFC8841 ], Sections 10.3 and 10.4, set the value of connection. [[SctpTransport]] to null.
  7. Let trackEventInits, muteTracks, addList, removeList and errorList be empty lists.
  8. If description is of type " answer " or " pranswer ", then run the following steps:
    1. If description initiates the establishment of a new SCTP association, as defined in [ RFC8841 ], Sections 10.3 and 10.4, create an RTCSctpTransport with an initial state of " connecting " and assign the result to the [[SctpTransport]] slot. Otherwise, if an SCTP association is established, but the max-message-size SDP attribute is updated, update the data max message size of connection. [[SctpTransport]] .
    2. If description negotiates the DTLS role of the SCTP transport, then for each RTCDataChannel , channel, with a null id , run the following step:
      1. Give channel a new ID generated according to [ RFC8832 ]. If no available ID could be generated, set channel. [[ReadyState]] to " closed ", and add channnel to errorList.
  9. If description is not of type " rollback ", then run the following steps:
    1. If remote is false, then run the following steps for each media description in description:
      1. If the media description was not yet associated with an RTCRtpTransceiver object then run the following steps:
        
        Let transceiver be the RTCRtpTransceiver used to create the media description .
        
        Set transceiver. [[Mid]] to transceiver. [[JsepMid]] .
        
        If transceiver. [[Stopped]] is true, abort these sub steps.
        
        If the media description is indicated as using an existing media transport according to [ RFC8843 ], let transport be the RTCDtlsTransport object representing the RTP/RTCP component of that transport.
        
        Otherwise, let transport be a newly created RTCDtlsTransport object with a new underlying RTCIceTransport .
        
        Set transceiver. [[Sender]] . [[SenderTransport]] to transport.
        
        Set transceiver. [[Receiver]] . [[ReceiverTransport]] to transport.
      2. Let transceiver be the RTCRtpTransceiver associated with the media description .
      3. If transceiver. [[Stopped]] is true, abort these sub steps.
      4. Let direction be an RTCRtpTransceiverDirection value representing the direction from the media description .
      5. If direction is " sendrecv " or " recvonly ", set transceiver. [[Receptive]] to true, otherwise set it to false.
      6. Set transceiver. [[Receiver]] . [[ReceiveCodecs]] to the codecs that description negotiates for receiving and which the user agent is currently prepared to receive.
        
        Note
        
        If the direction is " sendonly " or " inactive ", the receiver is not prepared to receive anything, and the list will be empty.
      7. If description is of type " answer " or " pranswer ", then run the following steps:
        
        Set transceiver. [[Sender]] . [[SendCodecs]] to the codecs that description negotiates for sending and which the user agent is currently capable of sending, and set transceiver. [[Sender]] . [[LastReturnedParameters]] to null.
        
        If direction is " sendonly " or " inactive ", and transceiver. [[FiredDirection]] is either " sendrecv " or " recvonly ", then run the following steps:
        
        Set the associated remote streams given transceiver. [[Receiver]] , an empty list, another empty list, and removeList.
        
        process the removal of a remote track for the media description , given transceiver and muteTracks.
        
        Set transceiver. [[CurrentDirection]] and transceiver. [[FiredDirection]] to direction.
    2. Otherwise, (if remote is true ) run the following steps for each media description in description:
      1. If the description is of type " offer " and contains a request to receive simulcast, use the order of the rid values specified in the simulcast attribute to create an RTCRtpEncodingParameters dictionary for each of the simulcast layers, populating the rid member according to the corresponding rid value, and let sendEncodings be the list containing the created dictionaries. Otherwise, let sendEncodings be an empty list.
      2. Let supportedEncodings be the maximum number of encodings that the implementation can support. If the length of sendEncodings is greater than supportedEncodings, truncate sendEncodings so that its length is supportedEncodings.
      3. If sendEncodings is non-empty, set each encoding's scaleResolutionDownBy to 2^(length of sendEncodings - encoding index - 1).
      4. As described by [ RFC8829 ] , attempt to find an existing RTCRtpTransceiver object, transceiver, to represent the media description .
      5. If a suitable transceiver was found ( transceiver is set) and sendEncodings is non-empty, set transceiver. [[Sender]] . [[SendEncodings]] to sendEncodings, and set transceiver. [[Sender]] . [[LastReturnedParameters]] to null.
      6. If no suitable transceiver was found ( transceiver is unset), run the following steps:
        
        Create an RTCRtpSender , sender, from the media description using sendEncodings.
        
        Create an RTCRtpReceiver , receiver, from the media description .
        
        Create an RTCRtpTransceiver with sender, receiver and an RTCRtpTransceiverDirection value of " recvonly ", and let transceiver be the result.
        
        Add transceiver to the connection 's set of transceivers .
      7. If description is of type " answer " or " pranswer ", and transceiver. [[Sender]] . [[SendEncodings]] .length is greater than 1, then run the following steps:
        
        If description indicates that simulcast is not supported or desired, then remove all dictionaries in transceiver. [[Sender]] . [[SendEncodings]] except the first one and abort these sub steps.
        
        If description rejects any of the offered layers, then remove the dictionaries that correspond to rejected layers from transceiver. [[Sender]] . [[SendEncodings]] .
      8. Set transceiver. [[Mid]] to transceiver. [[JsepMid]] .
      9. Let direction be an RTCRtpTransceiverDirection value representing the direction from the media description , but with the send and receive directions reversed to represent this peer's point of view. If the media description is rejected, set direction to " inactive ".
      10. If direction is " sendrecv " or " recvonly ", let msids be a list of the MSIDs that the media description indicates transceiver. [[Receiver]] . [[ReceiverTrack]] is to be associated with. Otherwise, let msids be an empty list.
        
        Note
        
        msids will be an empty list here if media description is rejected.
      11. Process remote tracks with transceiver, direction, msids, addList, removeList, and trackEventInits.
      12. Set transceiver. [[Receiver]] . [[ReceiveCodecs]] to the codecs that description negotiates for receiving and which the user agent is currently prepared to receive.
      13. If description is of type " answer " or " pranswer ", then run the following steps:
        
        Set transceiver. [[Sender]] . [[SendCodecs]] to the codecs that description negotiates for sending and which the user agent is currently capable of sending.
        
        Set transceiver. [[CurrentDirection]] to direction.
        
        Let transport be the RTCDtlsTransport object representing the RTP/RTCP component of the media transport used by transceiver 's associated media description , according to [ RFC8843 ].
        
        Set transceiver. [[Sender]] . [[SenderTransport]] to transport.
        
        Set transceiver. [[Receiver]] . [[ReceiverTransport]] to transport.
        
        Set the [[IceRole]] of transport according to the rules of [ RFC8445 ].
        
        Note
        
        The rules of [ RFC8445 ] that apply here are:
        
        If [[IceRole]] is not unknown , do not modify [[IceRole]] .
        
        If description is a local offer, set it to controlling .
        
        If description is a remote offer, and contains a=ice-lite, set [[IceRole]] to controlling .
        
        If description is a remote offer, and does not contain a=ice-lite, set [[IceRole]] to controlled .
        
        This ensures that [[IceRole]] always has a value after the first offer is processed.
      14. If the media description is rejected, and transceiver. [[Stopped]] is false, then stop the RTCRtpTransceiver transceiver.
  10. Otherwise, (if description is of type " rollback ") run the following steps:
    1. Let pendingDescription be either connection. [[PendingLocalDescription]] or connection. [[PendingRemoteDescription]] , whichever one is not null.
    2. For each transceiver in the connection 's set of transceivers run the following steps:
      1. If transceiver was not associated with a media description prior to pendingDescription being set, disassociate it and set both transceiver. [[JsepMid]] and transceiver. [[Mid]] to null.
      2. Set transceiver. [[Sender]] . [[SenderTransport]] to transceiver. [[Sender]] . [[LastStableStateSenderTransport]] .
      3. Set transceiver. [[Receiver]] . [[ReceiverTransport]] to transceiver. [[Receiver]] . [[LastStableStateReceiverTransport]] .
      4. Set transceiver. [[Receiver]] . [[ReceiveCodecs]] to transceiver. [[Receiver]] . [[LastStableStateReceiveCodecs]] .
      5. If the signaling state of connection is " have-remote-offer ", run the following sub steps:
        
        Let msids be a list of the id s of all MediaStream objects in transceiver. [[Receiver]] . [[LastStableStateAssociatedRemoteMediaStreams]] , or an empty list if there are none.
        
        Process remote tracks with transceiver, transceiver. [[CurrentDirection]] , msids, addList, removeList, and trackEventInits.
      6. If transceiver was created when pendingDescription was set, and a track has never been attached to it via addTrack (), then stop the RTCRtpTransceiver transceiver, and remove it from connection 's set of transceivers .
    3. Set connection. [[PendingLocalDescription]] and connection. [[PendingRemoteDescription]] to null, and set connection 's signaling state to " stable ".
  11. If description is of type " answer ", then run the following steps:
    1. For each transceiver in the connection 's set of transceivers run the following steps:
      1. If transceiver is stopped , associated with an m= section and the associated m= section is rejected in connection. [[CurrentLocalDescription]] or connection. [[CurrentRemoteDescription]] , remove the transceiver from the connection 's set of transceivers .
  12. If connection 's signaling state is now " stable ", run the following steps:
    1. For any transceiver that was removed from the set of transceivers in a previous step, if any of its transports ( transceiver. [[Sender]] . [[SenderTransport]] or transceiver. [[Receiver]] . [[ReceiverTransport]] ) are still not closed and they're no longer referenced by a non-stopped transceiver, close the RTCDtlsTransport s and their associated RTCIceTransport s. This results in events firing on these objects in a queued task.
    2. Clear the negotiation-needed flag and update the negotiation-needed flag .
  13. If connection 's signaling state changed above, fire an event named signalingstatechange at connection.
  14. For each channel in errorList, fire an event named error using the RTCErrorEvent interface with the errorDetail attribute set to " data-channel-failure " at channel.
  15. For each track in muteTracks, set the muted state of track to the value true.
  16. For each stream and track pair in removeList, remove the track track from stream.
  17. For each stream and track pair in addList, add the track track to stream.
  18. For each entry entry in trackEventInits, fire an event named track using the RTCTrackEvent interface with its receiver attribute initialized to entry. receiver , its track attribute initialized to entry. track , its streams attribute initialized to entry. streams and its transceiver attribute initialized to entry. transceiver at the connection object.
  19. Resolve p with undefined.
Return p.

To set a configuration with configuration, run the following steps:

Let connection be the target RTCPeerConnection object.
Let oldConfig be connection. [[Configuration]] .
If oldConfig is not null, run the following steps, and if any of them fail, throw an InvalidModificationError :
1. If the length of configuration. certificates is different from the length of oldConfig. certificates , fail.
2. Let index be 0.
3. While index is less than the length of configuration. certificates , run the following steps:
  1. If the ECMAScript object represented by the value of configuration. certificates at index is not the same as the ECMAScript object represented by the value of oldConfig. certificates at index, then fail.
  2. Increment index by 1.
4. If the value of configuration. bundlePolicy differs from oldConfig. bundlePolicy , then fail.
5. If the value of configuration. rtcpMuxPolicy differs from oldConfig. rtcpMuxPolicy , then fail.
6. If the value of configuration. iceCandidatePoolSize differs from oldConfig. iceCandidatePoolSize , and setLocalDescription has already been called, then fail.
For each server in configuration. iceServers , run the following steps:
1. Let urls be server. urls .
2. If urls is a string, set urls to a list consisting of just that string.
3. If urls is empty, throw a SyntaxError .
4. For each url in urls run the following steps:
  1. Parse the url using the generic URI syntax defined in [ RFC3986 ] and obtain the scheme name. If the parsing based on the syntax defined in [ RFC3986 ] fails, throw a SyntaxError . If the scheme name is not implemented by the browser throw a NotSupportedError . If scheme name is turn or turns, and parsing the url using the syntax defined in [ RFC7065 ] fails, throw a SyntaxError . If scheme name is stun or stuns, and parsing the url using the syntax defined in [ RFC7064 ] fails, throw a SyntaxError .
  2. If scheme name is turn or turns, and either of server. username or server. credential are omitted, then throw an InvalidAccessError .
  3. If scheme name is turn or turns, and server. credentialType is " password ", and server. credential is not a DOMString , then throw an InvalidAccessError .
Set the ICE Agent 's ICE transports setting to the value of configuration. iceTransportPolicy . As defined in [ RFC8829 ] , if the new ICE transports setting changes the existing setting, no action will be taken until the next gathering phase. If a script wants this to happen immediately, it should do an ICE restart.
Set the ICE Agent 's prefetched ICE candidate pool size as defined in [ RFC8829 ] to the value of configuration. iceCandidatePoolSize . If the new ICE candidate pool size changes the existing setting, this may result in immediate gathering of new pooled candidates, or discarding of existing pooled candidates, as defined in [ RFC8829 ] .
Set the ICE Agent 's ICE servers list to configuration. iceServers .

As defined in [ RFC8829 ] , if a new list of servers replaces the ICE Agent 's existing ICE servers list , no action will be taken until the next gathering phase. If a script wants this to happen immediately, it should do an ICE restart. However, if the ICE candidate pool has a nonzero size, any existing pooled candidates will be discarded, and new candidates will be gathered from the new servers.
Store configuration in the [[Configuration]] internal slot.

The RTCPeerConnection interface presented in this section is extended by several partial interfaces throughout this specification. Notably, the RTP Media API section, which adds the APIs to send and receive MediaStreamTrack objects.

WebIDL[Exposed=Window]
interface RTCPeerConnection : EventTarget  {
  constructor(optional RTCConfiguration configuration = {});
  Promise<RTCSessionDescriptionInit> createOffer(optional RTCOfferOptions options = {});
  Promise<RTCSessionDescriptionInit> createAnswer(optional RTCAnswerOptions options = {});
  undefined> setLocalDescription(optional RTCLocalSessionDescriptionInit description = {});
  readonly attribute RTCSessionDescription? localDescription;
  readonly attribute RTCSessionDescription? currentLocalDescription;
  readonly attribute RTCSessionDescription? pendingLocalDescription;
  undefined> setRemoteDescription(RTCSessionDescriptionInit description);
  readonly attribute RTCSessionDescription? remoteDescription;
  readonly attribute RTCSessionDescription? currentRemoteDescription;
  readonly attribute RTCSessionDescription? pendingRemoteDescription;
  undefined> addIceCandidate(optional RTCIceCandidateInit candidate = {});
  readonly attribute RTCSignalingState signalingState;
  readonly attribute RTCIceGatheringState iceGatheringState;
  readonly attribute RTCIceConnectionState iceConnectionState;
  readonly attribute RTCPeerConnectionState connectionState;
  readonly attribute boolean? canTrickleIceCandidates;
  undefined restartIce();
  RTCConfiguration getConfiguration();
  undefined setConfiguration(optional RTCConfiguration configuration = {});
  undefined close();
  attribute EventHandler onnegotiationneeded;
  attribute EventHandler onicecandidate;
  attribute EventHandler onicecandidateerror;
  attribute EventHandler onsignalingstatechange;
  attribute EventHandler oniceconnectionstatechange;
  attribute EventHandler onicegatheringstatechange;
  attribute EventHandler onconnectionstatechange;
  / Legacy Interface Extensions
  / Supporting the methods in this section is optional.
  / If these methods are supported
  / they must be implemented as defined
  / in section "Legacy Interface Extensions"
  undefined> createOffer(RTCSessionDescriptionCallback successCallback,
                            RTCPeerConnectionErrorCallback failureCallback,
                            optional RTCOfferOptions options = {});
  undefined> setLocalDescription(RTCLocalSessionDescriptionInit description,
                                    VoidFunction successCallback,
                                    RTCPeerConnectionErrorCallback failureCallback);
  undefined> createAnswer(RTCSessionDescriptionCallback successCallback,
                             RTCPeerConnectionErrorCallback failureCallback);
  undefined> setRemoteDescription(RTCSessionDescriptionInit description,
                                     VoidFunction successCallback,
                                     RTCPeerConnectionErrorCallback failureCallback);
  undefined> addIceCandidate(RTCIceCandidateInit candidate,
                                VoidFunction successCallback,
                                RTCPeerConnectionErrorCallback failureCallback);
};

localDescription of type RTCSessionDescription , readonly, nullable

The localDescription attribute MUST return [[PendingLocalDescription]] if it is not null and otherwise it MUST return [[CurrentLocalDescription]] .

Note that [[CurrentLocalDescription]] . sdp and [[PendingLocalDescription]] . sdp need not be string-wise identical to the sdp value passed to the corresponding setLocalDescription call (i.e. SDP may be parsed and reformatted, and ICE candidates may be added).

currentLocalDescription of type RTCSessionDescription , readonly, nullable

The currentLocalDescription attribute MUST return [[CurrentLocalDescription]] .

It represents the local description that was successfully negotiated the last time the RTCPeerConnection transitioned into the stable state plus any local candidates that have been generated by the ICE Agent since the offer or answer was created.

pendingLocalDescription of type RTCSessionDescription , readonly, nullable

The pendingLocalDescription attribute MUST return [[PendingLocalDescription]] .

It represents a local description that is in the process of being negotiated plus any local candidates that have been generated by the ICE Agent since the offer or answer was created. If the RTCPeerConnection is in the stable state, the value is null.

remoteDescription of type RTCSessionDescription , readonly, nullable

The remoteDescription attribute MUST return [[PendingRemoteDescription]] if it is not null and otherwise it MUST return [[CurrentRemoteDescription]] .

Note that [[CurrentRemoteDescription]] . sdp and [[PendingRemoteDescription]] . sdp need not be string-wise identical to the sdp value passed to the corresponding setRemoteDescription call (i.e. SDP may be parsed and reformatted, and ICE candidates may be added).

currentRemoteDescription of type RTCSessionDescription , readonly, nullable

The currentRemoteDescription attribute MUST return [[CurrentRemoteDescription]] .

It represents the last remote description that was successfully negotiated the last time the RTCPeerConnection transitioned into the stable state plus any remote candidates that have been supplied via addIceCandidate () since the offer or answer was created.

pendingRemoteDescription of type RTCSessionDescription , readonly, nullable

The pendingRemoteDescription attribute MUST return [[PendingRemoteDescription]] .

It represents a remote description that is in the process of being negotiated, complete with any remote candidates that have been supplied via addIceCandidate () since the offer or answer was created. If the RTCPeerConnection is in the stable state, the value is null.

signalingState of type RTCSignalingState , readonly

The signalingState attribute MUST return the RTCPeerConnection object's signaling state .

iceGatheringState of type RTCIceGatheringState , readonly

The iceGatheringState attribute MUST return the ICE gathering state of the RTCPeerConnection instance.

iceConnectionState of type RTCIceConnectionState , readonly

The iceConnectionState attribute MUST return the ICE connection state of the RTCPeerConnection instance.

connectionState of type RTCPeerConnectionState , readonly

The connectionState attribute MUST return the connection state of the RTCPeerConnection instance.

canTrickleIceCandidates of type boolean , readonly, nullable

The canTrickleIceCandidates attribute indicates whether the remote peer is able to accept trickled ICE candidates [ RFC8838 ]. The value is determined based on whether a remote description indicates support for trickle ICE, as defined in [ RFC8829 ] . Prior to the completion of setRemoteDescription , this value is null.

onnegotiationneeded of type EventHandler