WebRTCPeerConnection

package
v0.0.0-...-e741f2f Latest Latest
Warning

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

 Go to latest Published: Aug 7, 2025 License: MIT Imports: 22 Imported by: 0

Documentation

Overview

Package WebRTCPeerConnection provides methods for working with WebRTCPeerConnection object instances.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func SetDefaultExtension 

func SetDefaultExtension(extension_class string)

Sets the [param extension_class] as the default [WebRTCPeerConnectionExtension] returned when creating a new [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 [method 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 [WebRTCDataChannel] (or [code]null[/code] on failure) with given [param label] and optionally configured via the [param options] dictionary. This method can only be called when the connection is in state [constant STATE_NEW]. There are two ways to create a working data channel: either call [method create_data_channel] on only one of the peer and listen to [signal data_channel_received] on the other, or call [method create_data_channel] on both peers, with the same values, and the [code]"negotiated"[/code] option set to [code]true[/code]. Valid [param options] are: [codeblock] 

{
    "negotiated": true, # When set to true (default off), means the channel is negotiated out of band. "id" must be set too. "data_channel_received" will not be called.
    "id": 1, # When "negotiated" is true this value must also be set to the same value on both peer.

    # Only one of maxRetransmits and maxPacketLifeTime can be specified, not both. They make the channel unreliable (but also better at real time).
    "maxRetransmits": 1, # Specify the maximum number of attempt the peer will make to retransmits packets if they are not acknowledged.
    "maxPacketLifeTime": 100, # Specify the maximum amount of time before giving up retransmitions of unacknowledged packets (in milliseconds).
    "ordered": true, # When in unreliable mode (i.e. either "maxRetransmits" or "maxPacketLifetime" is set), "ordered" (true by default) specify if packet ordering is to be enforced.

    "protocol": "my-custom-protocol", # A custom sub-protocol string for this channel.
}

[/codeblock] [b]Note:[/b] 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 [constant STATE_NEW]. A dictionary of [param configuration] options can be passed to configure the peer connection. Valid [param configuration] options are: [codeblock] 

{
    "iceServers": [
        {
            "urls": [ "stun:stun.example.com:3478" ], # One or more STUN servers.
        },
        {
            "urls": [ "turn:turn.example.com:3478" ], # One or more TURN servers.
            "username": "a_username", # Optional username for the TURN server.
            "credential": "a_password", # Optional password for the TURN server.
        }
    ]
}

[/codeblock]

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

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 ([code]A[/code] from now on) creates an offer and send it to the other peer ([code]B[/code] from now on). - [code]B[/code] receives the offer, generate and answer, and sends it to [code]A[/code]). - [code]A[/code] and [code]B[/code] 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. 

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 [signal ice_candidate_created].

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. [b]Note:[/b] You cannot reuse this object for a new connection unless you call [method initialize].

func (Instance) CreateDataChannel 

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

Returns a new [WebRTCDataChannel] (or [code]null[/code] on failure) with given [param label] and optionally configured via the [param options] dictionary. This method can only be called when the connection is in state [constant STATE_NEW]. There are two ways to create a working data channel: either call [method create_data_channel] on only one of the peer and listen to [signal data_channel_received] on the other, or call [method create_data_channel] on both peers, with the same values, and the [code]"negotiated"[/code] option set to [code]true[/code]. Valid [param options] are: [codeblock] 

{
    "negotiated": true, # When set to true (default off), means the channel is negotiated out of band. "id" must be set too. "data_channel_received" will not be called.
    "id": 1, # When "negotiated" is true this value must also be set to the same value on both peer.

    # Only one of maxRetransmits and maxPacketLifeTime can be specified, not both. They make the channel unreliable (but also better at real time).
    "maxRetransmits": 1, # Specify the maximum number of attempt the peer will make to retransmits packets if they are not acknowledged.
    "maxPacketLifeTime": 100, # Specify the maximum amount of time before giving up retransmitions of unacknowledged packets (in milliseconds).
    "ordered": true, # When in unreliable mode (i.e. either "maxRetransmits" or "maxPacketLifetime" is set), "ordered" (true by default) specify if packet ordering is to be enforced.

    "protocol": "my-custom-protocol", # A custom sub-protocol string for this channel.
}

[/codeblock] [b]Note:[/b] 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 [WebRTCDataChannel] must have been created before calling this method. If this functions returns [constant OK], [signal session_description_created] will be called when the session is ready to be sent.

func (Instance) GetConnectionState 

func (self Instance) GetConnectionState() ConnectionState

Returns the connection state. See [enum ConnectionState].

func (Instance) GetGatheringState 

func (self Instance) GetGatheringState() GatheringState

Returns the ICE [enum 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 [constant STATE_NEW]. A dictionary of [param configuration] options can be passed to configure the peer connection. Valid [param configuration] options are: [codeblock] 

{
    "iceServers": [
        {
            "urls": [ "stun:stun.example.com:3478" ], # One or more STUN servers.
        },
        {
            "urls": [ "turn:turn.example.com:3478" ], # One or more TURN servers.
            "username": "a_username", # Optional username for the TURN server.
            "credential": "a_password", # Optional password for the TURN server.
        }
    ]
}

[/codeblock]

func (Instance) OnDataChannelReceived 

func (self Instance) OnDataChannelReceived(cb func(channel WebRTCDataChannel.Instance))

func (Instance) OnIceCandidateCreated 

func (self Instance) OnIceCandidateCreated(cb func(media string, index int, name string))

func (Instance) OnSessionDescriptionCreated 

func (self Instance) OnSessionDescriptionCreated(cb func(atype string, sdp string))

func (Instance) Poll 

func (self Instance) Poll() error

Call this method frequently (e.g. in [method Node._process] or [method Node._physics_process]) 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 [signal session_description_created]. After calling this function the peer will start emitting [signal ice_candidate_created] (unless an [enum Error] different from [constant OK] is returned).

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 [param type] is [code]"offer"[/code] the peer will emit [signal session_description_created] with the appropriate answer. If [param type] is [code]"answer"[/code] the peer will start emitting [signal ice_candidate_created].

func (*Instance) UnsafePointer 

func (self *Instance) UnsafePointer() unsafe.Pointer

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 [WebRTCPeerConnection] is new ([constant STATE_NEW]) or that negotiation is complete and a connection has been established ([constant STATE_CONNECTED]).*/
	SignalingStateStable SignalingState = 0
	/*The local peer has called [method set_local_description], passing in SDP representing an offer (usually created by calling [method create_offer]), 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 [method set_remote_description].*/
	SignalingStateHaveRemoteOffer SignalingState = 2
	/*The offer sent by the remote peer has been applied and an answer has been created and applied by calling [method set_local_description]. 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 [method set_local_description].*/
	SignalingStateHaveRemotePranswer SignalingState = 4
	/*The [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.