Add webrtc signaling example

Author: Faless

networking/webrtc_signaling/.gitignore

@@ -0,0 +1 @@
+webrtc

networking/webrtc_signaling/README.md

@@ -0,0 +1,32 @@
+# A WebSocket signaling server/client for WebRTC.
+
+This demo is devided in 4 parts:
+
+- The `server` folder contains the signaling server implementation written in GDScript (so it can be run by a game server running Godot)
+- The `server_node` folder contains the signaling server implementation written in Node.js (if you don't plan to run a game server but only match-making).
+- The `client` part contains the client implementation in GDScript.
+  - Itself divided into raw protocol and `WebRTCMultiplayer` handling.
+- The `demo` contains a small app that uses it.
+
+**NOTE**: You must extract the [latest version](https://github.com/godotengine/webrtc-native/releases) of the WebRTC GDNative plugin in the project folder to run from desktop.
+
+## Protocol
+
+The protocol is text based, and composed by a command and possibly multiple payload arguments, each separated by a new line.
+
+Messages without payload must still end with a newline and are the following:
+- `J: ` (or `J: <ROOM>`), must be sent by client immediately after connection to get a lobby assigned or join a known one.
+  This messages is also sent by server back to the client to notify assigned lobby, or simply a successful join.
+- `I: <ID>`, sent by server to identify the client when it joins a room.
+- `N: <ID>`, sent by server to notify new peers in the same lobby.
+- `D: <ID>`, sent by server to notify when a peer in the same lobby disconnects.
+- `S: `, sent by client to seal the lobby (only the client that created it is allowed to seal a lobby).
+
+When a lobby is sealed, no new client will be able to join, and the lobby will be destroyed (and clients disconnected) after 10 seconds.
+
+Messages with payload (used to transfer WebRTC parameters) are:
+- `O: <ID>`, used to send an offer.
+- `A: <ID>`, used to send an answer.
+- `C: <ID>`, used to send a candidate.
+
+When sending the parameter, a client will set `<ID>` as the destination peer, the server will replace it with the id of the sending peer, and rely it to the proper destination.

networking/webrtc_signaling/client/multiplayer_client.gd

@@ -0,0 +1,86 @@
+extends "ws_webrtc_client.gd"
+
+var rtc_mp : WebRTCMultiplayer = WebRTCMultiplayer.new()
+var sealed = false
+
+func _init():
+	connect("connected", self, "connected")
+	connect("disconnected", self, "disconnected")
+
+	connect("offer_received", self, "offer_received")
+	connect("answer_received", self, "answer_received")
+	connect("candidate_received", self, "candidate_received")
+
+	connect("lobby_joined", self, "lobby_joined")
+	connect("lobby_sealed", self, "lobby_sealed")
+	connect("peer_connected", self, "peer_connected")
+	connect("peer_disconnected", self, "peer_disconnected")
+
+func start(url, lobby = ""):
+	stop()
+	sealed = false
+	self.lobby = lobby
+	connect_to_url(url)
+
+func stop():
+	rtc_mp.close()
+	close()
+
+func _create_peer(id : int):
+	var peer : WebRTCPeerConnection = WebRTCPeerConnection.new()
+	peer.initialize({
+		"iceServers": [ { "urls": ["stun:stun.l.google.com:19302"] } ]
+	})
+	peer.connect("session_description_created", self, "_offer_created", [id])
+	peer.connect("ice_candidate_created", self, "_new_ice_candidate", [id])
+	rtc_mp.add_peer(peer, id)
+	if id > rtc_mp.get_unique_id():
+		peer.create_offer()
+	return peer
+
+func _new_ice_candidate(mid_name : String, index_name : int, sdp_name : String, id : int):
+	send_candidate(id, mid_name, index_name, sdp_name)
+
+func _offer_created(type : String, data : String, id : int):
+	if not rtc_mp.has_peer(id):
+		return
+	print("created", type)
+	rtc_mp.get_peer(id).connection.set_local_description(type, data)
+	if type == "offer": send_offer(id, data)
+	else: send_answer(id, data)
+
+func connected(id : int):
+	print("Connected %d" % id)
+	rtc_mp.initialize(id, true)
+
+func lobby_joined(lobby : String):
+	self.lobby = lobby
+
+func lobby_sealed():
+	sealed = true
+
+func disconnected():
+	print("Disconnected: %d: %s" % [code, reason])
+	if not sealed:
+		stop() # Unexpected disconnect
+
+func peer_connected(id : int):
+	print("Peer connected %d" % id)
+	_create_peer(id)
+
+func peer_disconnected(id : int):
+	if rtc_mp.has_peer(id): rtc_mp.remove_peer(id)
+
+func offer_received(id : int, offer : String):
+	print("Got offer: %d" % id)
+	if rtc_mp.has_peer(id):
+		rtc_mp.get_peer(id).connection.set_remote_description("offer", offer)
+
+func answer_received(id : int, answer : String):
+	print("Got answer: %d" % id)
+	if rtc_mp.has_peer(id):
+		rtc_mp.get_peer(id).connection.set_remote_description("answer", answer)
+
+func candidate_received(id : int, mid : String, index : int, sdp : String):
+	if rtc_mp.has_peer(id):
+		rtc_mp.get_peer(id).connection.add_ice_candidate(mid, index, sdp)

networking/webrtc_signaling/client/ws_webrtc_client.gd

@@ -0,0 +1,116 @@
+extends Node
+
+export var autojoin = true
+export var lobby = "" # Will create a new lobby if empty
+
+var client : WebSocketClient = WebSocketClient.new()
+var code = 1000
+var reason = "Unknown"
+
+signal lobby_joined(lobby)
+signal connected(id)
+signal disconnected()
+signal peer_connected(id)
+signal peer_disconnected(id)
+signal offer_received(id, offer)
+signal answer_received(id, answer)
+signal candidate_received(id, mid, index, sdp)
+signal lobby_sealed()
+
+func _init():
+	client.connect("data_received", self, "_parse_msg")
+	client.connect("connection_established", self, "_connected")
+	client.connect("connection_closed", self, "_closed")
+	client.connect("connection_error", self, "_closed")
+	client.connect("server_close_request", self, "_close_request")
+
+func connect_to_url(url : String):
+	close()
+	code = 1000
+	reason = "Unknown"
+	client.connect_to_url(url)
+
+func close():
+	client.disconnect_from_host()
+
+func _closed(was_clean : bool = false):
+	emit_signal("disconnected")
+
+func _close_request(code : int, reason : String):
+	self.code = code
+	self.reason = reason
+
+func _connected(protocol = ""):
+	client.get_peer(1).set_write_mode(WebSocketPeer.WRITE_MODE_TEXT)
+	if autojoin:
+		join_lobby(lobby)
+
+func _parse_msg():
+	var pkt_str : String = client.get_peer(1).get_packet().get_string_from_utf8()
+
+	var req : PoolStringArray = pkt_str.split('\n', true, 1)
+	if req.size() != 2: # Invalid request size
+		return
+
+	var type : String = req[0]
+	if type.length() < 3: # Invalid type size
+		return
+
+	if type.begins_with("J: "):
+		emit_signal("lobby_joined", type.substr(3, type.length() - 3))
+		return
+	elif type.begins_with("S: "):
+		emit_signal("lobby_sealed")
+		return
+
+	var src_str : String = type.substr(3, type.length() - 3)
+	if not src_str.is_valid_integer(): # Source id is not an integer
+		return
+
+	var src_id : int = int(src_str)
+
+	if type.begins_with("I: "):
+		emit_signal("connected", src_id)
+	elif type.begins_with("N: "):
+		# Client connected
+		emit_signal("peer_connected", src_id)
+	elif type.begins_with("D: "):
+		# Client connected
+		emit_signal("peer_disconnected", src_id)
+	elif type.begins_with("O: "):
+		# Offer received
+		emit_signal("offer_received", src_id, req[1])
+	elif type.begins_with("A: "):
+		# Answer received
+		emit_signal("answer_received", src_id, req[1])
+	elif type.begins_with("C: "):
+		# Candidate received
+		var candidate : PoolStringArray = req[1].split('\n', false)
+		if candidate.size() != 3:
+			return
+		if not candidate[1].is_valid_integer():
+			return
+		emit_signal("candidate_received", src_id, candidate[0], int(candidate[1]), candidate[2])
+
+func join_lobby(lobby : String):
+	return client.get_peer(1).put_packet(("J: %s\n" % lobby).to_utf8())
+
+func seal_lobby():
+	return client.get_peer(1).put_packet("S: \n".to_utf8())
+
+func send_candidate(id : int, mid : String, index : int, sdp : String) -> int:
+	return _send_msg("C", id, "\n%s\n%d\n%s" % [mid, index, sdp])
+
+func send_offer(id : int, offer : String) -> int:
+	return _send_msg("O", id, offer)
+
+func send_answer(id : int, answer : String) -> int:
+	return _send_msg("A", id, answer)
+
+func _send_msg(type : String, id : int, data : String) -> int:
+	return client.get_peer(1).put_packet(("%s: %d\n%s" % [type, id, data]).to_utf8())
+
+func _process(delta):
+	var status : int = client.get_connection_status()
+	if status == WebSocketClient.CONNECTION_CONNECTING or status == WebSocketClient.CONNECTION_CONNECTED:
+		client.poll()

networking/webrtc_signaling/demo/client_ui.gd

@@ -0,0 +1,64 @@
+extends Control
+
+onready var client = $Client
+
+func _ready():
+	client.connect("lobby_joined", self, "_lobby_joined")
+	client.connect("lobby_sealed", self, "_lobby_sealed")
+	client.connect("connected", self, "_connected")
+	client.connect("disconnected", self, "_disconnected")
+	client.rtc_mp.connect("peer_connected", self, "_mp_peer_connected")
+	client.rtc_mp.connect("peer_disconnected", self, "_mp_peer_disconnected")
+	client.rtc_mp.connect("server_disconnected", self, "_mp_server_disconnect")
+	client.rtc_mp.connect("connection_succeeded", self, "_mp_connected")
+
+func _process(delta):
+	client.rtc_mp.poll()
+	while client.rtc_mp.get_available_packet_count() > 0:
+		_log(client.rtc_mp.get_packet().get_string_from_utf8())
+
+func _connected(id):
+	_log("Signaling server connected with ID: %d" % id)
+
+func _disconnected():
+	_log("Signaling server disconnected: %d - %s" % [client.code, client.reason])
+
+func _lobby_joined(lobby):
+	_log("Joined lobby %s" % lobby)
+
+func _lobby_sealed():
+	_log("Lobby has been sealed")
+
+func _mp_connected():
+	_log("Multiplayer is connected (I am %d)" % client.rtc_mp.get_unique_id())
+
+func _mp_server_disconnect():
+	_log("Multiplayer is disconnected (I am %d)" % client.rtc_mp.get_unique_id())
+
+func _mp_peer_connected(id : int):
+	_log("Multiplayer peer %d connected" % id)
+
+func _mp_peer_disconnected(id : int):
+	_log("Multiplayer peer %d disconnected" % id)
+
+func _log(msg):
+	print(msg)
+	$vbox/TextEdit.text += str(msg) + "\n"
+
+func ping():
+	_log(client.rtc_mp.put_packet("ping".to_utf8()))
+
+func _on_Peers_pressed():
+	var d = client.rtc_mp.get_peers()
+	_log(d)
+	for k in d:
+		_log(client.rtc_mp.get_peer(k))
+
+func start():
+	client.start($vbox/connect/host.text, $vbox/connect/RoomSecret.text)
+
+func _on_Seal_pressed():
+	client.seal_lobby()
+
+func stop():
+	client.stop()