Merge pull request #51 from paullouisageneau/refactor-reliability

Refactor reliability API

wasm/include/rtc/datachannel.hpp

@@ -25,6 +25,7 @@
 
 #include "channel.hpp"
 #include "common.hpp"
+#include "reliability.hpp"
 
 namespace rtc {
 
@@ -41,6 +42,7 @@ class DataChannel final : public Channel {
 	bool isClosed() const override;
 	size_t bufferedAmount() const override;
 	string label() const;
+	Reliability reliability() const;
 
 	void setBufferedAmountLowThreshold(size_t amount) override;
 

wasm/include/rtc/reliability.hpp

@@ -30,11 +30,18 @@
 namespace rtc {
 
 struct Reliability {
-	enum class Type { Reliable = 0, Rexmit, Timed };
-
-	Type type = Type::Reliable;
+	// It true, the channel does not enforce message ordering and out-of-order delivery is allowed
 	bool unordered = false;
-	variant<int, std::chrono::milliseconds> rexmit = 0;
+
+	// If both maxPacketLifeTime or maxRetransmits are unset, the channel is reliable.
+	// If either maxPacketLifeTime or maxRetransmits is set, the channel is unreliable.
+	// (The settings are exclusive so both maxPacketLifetime and maxRetransmits must not be set.)
+
+	// Time window during which transmissions and retransmissions may occur
+	optional<std::chrono::milliseconds> maxPacketLifeTime;
+
+	// Maximum number of retransmissions that are attempted
+	optional<unsigned int> maxRetransmits;
 };
 
 } // namespace rtc

wasm/js/webrtc.js

@@ -301,7 +301,7 @@
 			peerConnection.rtcStateChangeCallback = stateChangeCallback;
 		},
 
-    rtcSetIceStateChangeCallback: function(pc, iceStateChangeCallback) {
+		rtcSetIceStateChangeCallback: function(pc, iceStateChangeCallback) {
 			if(!pc) return;
 			var peerConnection = WEBRTC.peerConnectionsMap[pc];
 			peerConnection.rtcIceStateChangeCallback = iceStateChangeCallback;
@@ -356,12 +356,32 @@
 		},
 
 		rtcGetDataChannelLabel: function(dc, pBuffer, size) {
+			if(!dc) return 0;
 			var label = WEBRTC.dataChannelsMap[dc].label;
 			stringToUTF8(label, pBuffer, size);
 			return lengthBytesUTF8(label);
 		},
 
+		rtcGetDataChannelUnordered: function(dc) {
+			if(!dc) return 0;
+			var dataChannel = WEBRTC.dataChannelsMap[dc];
+			return dataChannel.ordered ? 0 : 1;
+		},
+
+		rtcGetDataChannelMaxPacketLifeTime: function(dc) {
+			if(!dc) return -1;
+			var dataChannel = WEBRTC.dataChannelsMap[dc];
+			return dataChannel.maxPacketLifeTime !== null ? dataChannel.maxPacketLifeTime : -1;
+		},
+
+		rtcGetDataChannelMaxRetransmits: function(dc) {
+			if(!dc) return -1;
+			var dataChannel = WEBRTC.dataChannelsMap[dc];
+			return dataChannel.maxRetransmits !== null ? dataChannel.maxRetransmits : -1;
+		},
+
 		rtcSetOpenCallback: function(dc, openCallback) {
+			if(!dc) return;
 			var dataChannel = WEBRTC.dataChannelsMap[dc];
 			var cb = function() {
 				if(dataChannel.rtcUserDeleted) return;
@@ -373,6 +393,7 @@
 		},
 
 		rtcSetErrorCallback: function(dc, errorCallback) {
+			if(!dc) return;
 			var dataChannel = WEBRTC.dataChannelsMap[dc];
 			var cb = function(evt) {
 				if(dataChannel.rtcUserDeleted) return;
@@ -385,6 +406,7 @@
 		},
 
 		rtcSetMessageCallback: function(dc, messageCallback) {
+			if(!dc) return;
 			var dataChannel = WEBRTC.dataChannelsMap[dc];
 			dataChannel.onmessage = function(evt) {
 				if(dataChannel.rtcUserDeleted) return;
@@ -411,6 +433,7 @@
 		},
 
 		rtcSetBufferedAmountLowCallback: function(dc, bufferedAmountLowCallback) {
+			if(!dc) return;
 			var dataChannel = WEBRTC.dataChannelsMap[dc];
 			var cb = function(evt) {
 				if(dataChannel.rtcUserDeleted) return;
@@ -421,16 +444,19 @@
 		},
 
 		rtcGetBufferedAmount: function(dc) {
+			if(!dc) return;
 			var dataChannel = WEBRTC.dataChannelsMap[dc];
 			return dataChannel.bufferedAmount;
 		},
 
 		rtcSetBufferedAmountLowThreshold: function(dc, threshold) {
+			if(!dc) return;
 			var dataChannel = WEBRTC.dataChannelsMap[dc];
 			dataChannel.bufferedAmountLowThreshold = threshold;
 		},
 
 		rtcSendMessage: function(dc, pBuffer, size) {
+			if(!dc) return;
 			var dataChannel = WEBRTC.dataChannelsMap[dc];
 			if(dataChannel.readyState != 'open') return -1;
 			if(size >= 0) {

wasm/src/datachannel.cpp

@@ -24,12 +24,16 @@
 
 #include <emscripten/emscripten.h>
 
+#include <chrono>
 #include <exception>
 #include <stdexcept>
 
 extern "C" {
 extern void rtcDeleteDataChannel(int dc);
 extern int rtcGetDataChannelLabel(int dc, char *buffer, int size);
+extern int rtcGetDataChannelUnordered(int dc);
+extern int rtcGetDataChannelMaxPacketLifeTime(int dc);
+extern int rtcGetDataChannelMaxRetransmits(int dc);
 extern void rtcSetOpenCallback(int dc, void (*openCallback)(void *));
 extern void rtcSetErrorCallback(int dc, void (*errorCallback)(const char *, void *));
 extern void rtcSetMessageCallback(int dc, void (*messageCallback)(const char *, int, void *));
@@ -139,6 +143,26 @@ size_t DataChannel::bufferedAmount() const {
 
 std::string DataChannel::label() const { return mLabel; }
 
+Reliability DataChannel::reliability() const {
+	Reliability reliability = {};
+
+	if (!mId)
+		return reliability;
+
+	reliability.unordered = rtcGetDataChannelUnordered(mId) ? true : false;
+
+	int maxRetransmits = rtcGetDataChannelMaxRetransmits(mId);
+	int maxPacketLifeTime = rtcGetDataChannelMaxPacketLifeTime(mId);
+
+	if (maxRetransmits >= 0)
+		reliability.maxRetransmits = unsigned(maxRetransmits);
+
+	if (maxPacketLifeTime >= 0)
+		reliability.maxPacketLifeTime = std::chrono::milliseconds(maxPacketLifeTime);
+
+	return reliability;
+}
+
 void DataChannel::setBufferedAmountLowThreshold(size_t amount) {
 	if (!mId)
 		return;

wasm/src/peerconnection.cpp

@@ -194,13 +194,14 @@ optional<Description> PeerConnection::remoteDescription() const {
 
 shared_ptr<DataChannel> PeerConnection::createDataChannel(const string &label,
                                                           DataChannelInit init) {
-	int maxRetransmits = init.reliability.type == Reliability::Type::Rexmit
-	                         ? std::get<int>(init.reliability.rexmit)
-	                         : -1;
+	const Reliability &reliability = init.reliability;
+	if (reliability.maxPacketLifeTime && reliability.maxRetransmits)
+		throw std::invalid_argument("Both maxPacketLifeTime and maxRetransmits are set");
+
+	int maxRetransmits = reliability.maxRetransmits ? int(*reliability.maxRetransmits) : -1;
 	int maxPacketLifeTime =
-	    init.reliability.type == Reliability::Type::Timed
-	        ? int(std::get<std::chrono::milliseconds>(init.reliability.rexmit).count())
-	        : -1;
+	    reliability.maxPacketLifeTime ? int(reliability.maxPacketLifeTime->count()) : -1;
+
 	return std::make_shared<DataChannel>(rtcCreateDataChannel(
 	    mId, label.c_str(), init.reliability.unordered, maxRetransmits, maxPacketLifeTime));
 }