WebRTCPeerConnection

package
v0.0.0-...-0d6c339 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 16, 2025 License: MIT Imports: 23 Imported by: 0

Documentation

Overview

A WebRTC connection between the local computer and a remote peer. Provides an interface to connect, maintain and monitor the connection.

Setting up a WebRTC connection between two peers may not seem a trivial task, but it can be broken down into 3 main steps:

- The peer that wants to initiate the connection (A from now on) creates an offer and send it to the other peer (B from now on).

- B receives the offer, generate and answer, and sends it to A).

- A and B then generates and exchange ICE candidates with each other.

After these steps, the connection should become connected. Keep on reading or look into the tutorial for more information.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func SetDefaultExtension 

func SetDefaultExtension(extension_class string)

Sets the 'extension_class' as the default graphics.gd/classdb/WebRTCPeerConnectionExtension returned when creating a new graphics.gd/classdb/WebRTCPeerConnection.

Types

type Advanced 

type Advanced = class

Advanced exposes a 1:1 low-level instance of the class, undocumented, for those who know what they are doing.

type Any 

type Any interface {
	gd.IsClass
	AsWebRTCPeerConnection() Instance
}

type Configuration 

type Configuration struct {
	IceServers []IceServer `gd:"ice_servers"`
}

type ConnectionState 

type ConnectionState int //gd:WebRTCPeerConnection.ConnectionState

const (
	// The connection is new, data channels and an offer can be created in this state.
	StateNew ConnectionState = 0
	// The peer is connecting, ICE is in progress, none of the transports has failed.
	StateConnecting ConnectionState = 1
	// The peer is connected, all ICE transports are connected.
	StateConnected ConnectionState = 2
	// At least one ICE transport is disconnected.
	StateDisconnected ConnectionState = 3
	// One or more of the ICE transports failed.
	StateFailed ConnectionState = 4
	// The peer connection is closed (after calling [Instance.Close] for example).
	StateClosed ConnectionState = 5
)

type Expanded 

type Expanded [1]gdclass.WebRTCPeerConnection

func (Expanded) CreateDataChannel 

func (self Expanded) CreateDataChannel(label string, options Options) WebRTCDataChannel.Instance

Returns a new graphics.gd/classdb/WebRTCDataChannel (or null on failure) with given 'label' and optionally configured via the 'options' dictionary. This method can only be called when the connection is in state StateNew.

There are two ways to create a working data channel: either call Instance.CreateDataChannel on only one of the peer and listen to Instance.OnDataChannelReceived on the other, or call Instance.CreateDataChannel on both peers, with the same values, and the "negotiated" option set to true.

Valid 'options' are:

Note: You must keep a reference to channels created this way, or it will be closed.

func (Expanded) Initialize 

func (self Expanded) Initialize(configuration Configuration) error

Re-initialize this peer connection, closing any previously active connection, and going back to state StateNew. A dictionary of 'configuration' options can be passed to configure the peer connection.

Valid 'configuration' options are:

type Extension 

type Extension[T gdclass.Interface] struct{ gdclass.Extension[T, Instance] }

Extension can be embedded in a new struct to create an extension of this class. T should be the type that is embedding this Extension

func (*Extension[T]) AsObject 

func (self *Extension[T]) AsObject() [1]gd.Object

func (*Extension[T]) AsRefCounted 

func (self *Extension[T]) AsRefCounted() [1]gd.RefCounted

func (*Extension[T]) AsWebRTCPeerConnection 

func (self *Extension[T]) AsWebRTCPeerConnection() Instance

type GatheringState 

type GatheringState int //gd:WebRTCPeerConnection.GatheringState

const (
	// The peer connection was just created and hasn't done any networking yet.
	GatheringStateNew GatheringState = 0
	// The ICE agent is in the process of gathering candidates for the connection.
	GatheringStateGathering GatheringState = 1
	// The ICE agent has finished gathering candidates. If something happens that requires collecting new candidates, such as a new interface being added or the addition of a new ICE server, the state will revert to gathering to gather those candidates.
	GatheringStateComplete GatheringState = 2
)

type ID 

type ID Object.ID

ID is a typed object ID (reference) to an instance of this class, use it to store references to objects with unknown lifetimes, as an ID will not panic on use if the underlying object has been destroyed.

func (ID) Instance 

func (id ID) Instance() (Instance, bool)

type IceServer 

type IceServer struct {
	URLs       []string `gd:"urls"`
	Username   string   `gd:"username"`
	Credential string   `gd:"credential"`
}

type Instance 

type Instance [1]gdclass.WebRTCPeerConnection

Instance of the class with convieniently typed arguments and results. 

var Nil Instance

Nil is a nil/null instance of the class. Equivalent to the zero value.

func New 

func New() Instance

func (Instance) AddIceCandidate 

func (self Instance) AddIceCandidate(media string, index int, name string) error

Add an ice candidate generated by a remote peer (and received over the signaling server). See Instance.OnIceCandidateCreated.

func (Instance) AsObject 

func (self Instance) AsObject() [1]gd.Object

func (Instance) AsRefCounted 

func (self Instance) AsRefCounted() [1]gd.RefCounted

func (Instance) AsWebRTCPeerConnection 

func (self Instance) AsWebRTCPeerConnection() Instance

func (Instance) Close 

func (self Instance) Close()

Close the peer connection and all data channels associated with it.

Note: You cannot reuse this object for a new connection unless you call Instance.Initialize.

func (Instance) CreateDataChannel 

func (self Instance) CreateDataChannel(label string) WebRTCDataChannel.Instance

Returns a new graphics.gd/classdb/WebRTCDataChannel (or null on failure) with given 'label' and optionally configured via the 'options' dictionary. This method can only be called when the connection is in state StateNew.

There are two ways to create a working data channel: either call Instance.CreateDataChannel on only one of the peer and listen to Instance.OnDataChannelReceived on the other, or call Instance.CreateDataChannel on both peers, with the same values, and the "negotiated" option set to true.

Valid 'options' are:

Note: You must keep a reference to channels created this way, or it will be closed.

func (Instance) CreateOffer 

func (self Instance) CreateOffer() error

Creates a new SDP offer to start a WebRTC connection with a remote peer. At least one graphics.gd/classdb/WebRTCDataChannel must have been created before calling this method.

If this functions returns [Ok], Instance.OnSessionDescriptionCreated will be called when the session is ready to be sent.

func (Instance) GetConnectionState 

func (self Instance) GetConnectionState() ConnectionState

Returns the connection state.

func (Instance) GetGatheringState 

func (self Instance) GetGatheringState() GatheringState

Returns the ICE GatheringState of the connection. This lets you detect, for example, when collection of ICE candidates has finished.

func (Instance) GetSignalingState 

func (self Instance) GetSignalingState() SignalingState

Returns the signaling state on the local end of the connection while connecting or reconnecting to another peer.

func (Instance) ID 

func (self Instance) ID() ID

func (Instance) Initialize 

func (self Instance) Initialize() error

Re-initialize this peer connection, closing any previously active connection, and going back to state StateNew. A dictionary of 'configuration' options can be passed to configure the peer connection.

Valid 'configuration' options are:

func (Instance) OnDataChannelReceived 

func (self Instance) OnDataChannelReceived(cb func(channel WebRTCDataChannel.Instance), flags ...Signal.Flags)

func (Instance) OnIceCandidateCreated 

func (self Instance) OnIceCandidateCreated(cb func(media string, index int, name string), flags ...Signal.Flags)

func (Instance) OnSessionDescriptionCreated 

func (self Instance) OnSessionDescriptionCreated(cb func(atype string, sdp string), flags ...Signal.Flags)

func (Instance) Poll 

func (self Instance) Poll() error

Call this method frequently (e.g. in graphics.gd/classdb/Node.Instance.Process or graphics.gd/classdb/Node.Instance.PhysicsProcess) to properly receive signals.

func (Instance) SetLocalDescription 

func (self Instance) SetLocalDescription(atype string, sdp string) error

Sets the SDP description of the local peer. This should be called in response to Instance.OnSessionDescriptionCreated.

After calling this function the peer will start emitting Instance.OnIceCandidateCreated (unless an [Error] different from [Ok] is returned).

func (*Instance) SetObject 

func (self *Instance) SetObject(obj [1]gd.Object) bool

func (Instance) SetRemoteDescription 

func (self Instance) SetRemoteDescription(atype string, sdp string) error

Sets the SDP description of the remote peer. This should be called with the values generated by a remote peer and received over the signaling server.

If 'type' is "offer" the peer will emit Instance.OnSessionDescriptionCreated with the appropriate answer.

If 'type' is "answer" the peer will start emitting Instance.OnIceCandidateCreated.

func (Instance) Virtual 

func (self Instance) Virtual(name string) reflect.Value

type Options 

type Options struct {
	Negotiated        bool   `gd:"negotiated"`
	ID                int    `gd:"id"`
	MaxRetransmits    int    `gd:"max_retransmits"`
	MaxPacketLifeTime int    `gd:"max_packet_life_time"`
	Ordered           bool   `gd:"ordered"`
	Protocol          string `gd:"protocol"`
}

type SignalingState 

type SignalingState int //gd:WebRTCPeerConnection.SignalingState

const (
	// There is no ongoing exchange of offer and answer underway. This may mean that the [graphics.gd/classdb/WebRTCPeerConnection] is new ([StateNew]) or that negotiation is complete and a connection has been established ([StateConnected]).
	SignalingStateStable SignalingState = 0
	// The local peer has called [Instance.SetLocalDescription], passing in SDP representing an offer (usually created by calling [Instance.CreateOffer]), and the offer has been applied successfully.
	SignalingStateHaveLocalOffer SignalingState = 1
	// The remote peer has created an offer and used the signaling server to deliver it to the local peer, which has set the offer as the remote description by calling [Instance.SetRemoteDescription].
	SignalingStateHaveRemoteOffer SignalingState = 2
	// The offer sent by the remote peer has been applied and an answer has been created and applied by calling [Instance.SetLocalDescription]. This provisional answer describes the supported media formats and so forth, but may not have a complete set of ICE candidates included. Further candidates will be delivered separately later.
	SignalingStateHaveLocalPranswer SignalingState = 3
	// A provisional answer has been received and successfully applied in response to an offer previously sent and established by calling [Instance.SetLocalDescription].
	SignalingStateHaveRemotePranswer SignalingState = 4
	// The [graphics.gd/classdb/WebRTCPeerConnection] has been closed.
	SignalingStateClosed SignalingState = 5
)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.