added createAnswer, setRemoteDescription, datachannel

Author: Clément Charmet

binding.gyp

@@ -15,6 +15,7 @@
                 'src/rtcicecandidate.cc',
                 'src/rtcpeerconnection.cc',
                 'src/rtcsessiondescription.cc',
+                'src/rtcdatachannel.cc',
             ],
             'include_dirs' : [
                 'build/include',

src/common.h

@@ -62,6 +62,9 @@
 #define ERROR_ARGUMENT_NOT_FUNCTION(INDEX, NAME) \
   "parameter " << INDEX << " ('" << NAME << "') is not a function."
 
+#define ERROR_ARGUMENT_NOT_STRING(INDEX, NAME) \
+  "parameter " << INDEX << " ('" << NAME << "') is not a string."
+
 #ifdef DEBUG
 #define CONSTRUCTOR_HEADER(NAME) \
   LOG(LS_INFO) << __PRETTY_FUNCTION__; \
@@ -124,7 +127,7 @@
 
 #define ASSERT_STRING_ARGUMENT(I, N) \
   if (!info[I]->IsString()) { \
-    errorStream << ERROR_ARGUMENT_NOT_FUNCTION(I + 1, #N); \
+    errorStream << ERROR_ARGUMENT_NOT_STRING(I + 1, #N); \
     return Nan::ThrowTypeError(errorStream.str().c_str()); \
   } \
   \

src/module.cc

@@ -21,6 +21,7 @@
 #include "rtcicecandidate.h"
 #include "rtcpeerconnection.h"
 #include "rtcsessiondescription.h"
+#include "rtcdatachannel.h"
 
 NAN_MODULE_INIT(Init) {
   if (!Globals::Init()) {
@@ -31,6 +32,7 @@ NAN_MODULE_INIT(Init) {
   RTCIceCandidate::Init(target);
   RTCPeerConnection::Init(target);
   RTCSessionDescription::Init(target);
+  RTCDataChannel::Init(target);
 
   node::AtExit(Globals::Cleanup);
 }

src/rtcdatachannel.cc

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2017 Axel Isouard <axel@isouard.fr>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <iostream>
+#include <webrtc/api/datachannelinterface.h>
+#include "rtcdatachannel.h"
+#include "common.h"
+
+static const char sRTCDataChannel[] = "RTCDataChannel";
+
+static const char kLabel[] = "label";
+static const char kOrdered[] = "ordered";
+static const char kReadyState[] = "readyState";
+
+NAN_MODULE_INIT(RTCDataChannel::Init) {
+  Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(New);
+  ctor->SetClassName(LOCAL_STRING(sRTCDataChannel));
+  ctor->InstanceTemplate()->SetInternalFieldCount(1);
+
+  Local<ObjectTemplate> prototype = ctor->PrototypeTemplate();
+  Nan::SetAccessor(prototype, LOCAL_STRING(kLabel), GetLabel);
+  Nan::SetAccessor(prototype, LOCAL_STRING(kOrdered), GetOrdered);
+  Nan::SetAccessor(prototype, LOCAL_STRING(kReadyState), GetReadyState);
+  
+  constructor().Reset(Nan::GetFunction(ctor).ToLocalChecked());
+}
+
+RTCDataChannel::RTCDataChannel(
+    const rtc::scoped_refptr<webrtc::DataChannelInterface> &datachannel)
+    : _datachannel(datachannel) {
+}
+
+RTCDataChannel::~RTCDataChannel() {}
+
+Local<Object> RTCDataChannel::Create(
+  const rtc::scoped_refptr<webrtc::DataChannelInterface> &datachannel) {
+  Local<Function> cons = Nan::New(RTCDataChannel::constructor());
+  Local<Object> instance = Nan::NewInstance(cons, 0, NULL).ToLocalChecked();
+
+  RTCDataChannel *_datachannel = new RTCDataChannel(datachannel);
+  _datachannel->Wrap(instance);
+
+  return instance;
+}
+
+NAN_METHOD(RTCDataChannel::New) {
+}
+
+NAN_GETTER(RTCDataChannel::GetLabel) {
+  UNWRAP_OBJECT(RTCDataChannel, object);
+  info.GetReturnValue().Set(LOCAL_STRING(object->_datachannel->label()));
+}
+
+NAN_GETTER(RTCDataChannel::GetOrdered) {
+  UNWRAP_OBJECT(RTCDataChannel, object);
+  info.GetReturnValue().Set(object->_datachannel->ordered());
+}
+
+NAN_GETTER(RTCDataChannel::GetReadyState) {
+  UNWRAP_OBJECT(RTCDataChannel, object);
+  const char* readyState = webrtc::DataChannelInterface::DataStateString(object->_datachannel->state());
+  info.GetReturnValue().Set(LOCAL_STRING(readyState));
+}

src/rtcdatachannel.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2017 Axel Isouard <axel@isouard.fr>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RTCDATACHANNEL_H_
+#define RTCDATACHANNEL_H_
+
+#include <nan.h>
+#include <webrtc/api/jsep.h>
+#include <string>
+
+using namespace v8;
+
+class RTCDataChannel : public Nan::ObjectWrap {
+ public:
+  static NAN_MODULE_INIT(Init);
+
+  static NAN_GETTER(GetLabel);
+  static NAN_GETTER(GetOrdered);
+  static NAN_GETTER(GetReadyState);
+
+  static Local<Object> Create(
+    const rtc::scoped_refptr<webrtc::DataChannelInterface>& datachannel);
+
+  static inline Nan::Persistent<v8::Function>& constructor() {
+    static Nan::Persistent<v8::Function> _constructor;
+    return _constructor;
+  }
+
+  const rtc::scoped_refptr<webrtc::DataChannelInterface> _datachannel;
+
+ private:
+  explicit RTCDataChannel(
+    const rtc::scoped_refptr<webrtc::DataChannelInterface>& datachannel);
+  ~RTCDataChannel();
+
+  static NAN_METHOD(New);
+
+};
+
+#endif  // RTCDATACHANNEL_H_

src/rtcpeerconnection.cc

@@ -26,13 +26,16 @@
 #include "rtccertificate.h"
 #include "rtcpeerconnection.h"
 #include "rtcsessiondescription.h"
+#include "rtcdatachannel.h"
 
 Nan::Persistent<FunctionTemplate> RTCPeerConnection::constructor;
 
 static const char sRTCPeerConnection[] = "RTCPeerConnection";
 
 static const char kCreateOffer[] = "createOffer";
+static const char kCreateAnswer[] = "createAnswer";
 static const char kSetLocalDescription[] = "setLocalDescription";
+static const char kSetRemoteDescription[] = "setRemoteDescription";
 static const char kCreateDataChannel[] = "createDataChannel";
 static const char kGenerateCertificate[] = "generateCertificate";
 
@@ -94,7 +97,9 @@ NAN_MODULE_INIT(RTCPeerConnection::Init) {
 
   Local<ObjectTemplate> prototype = ctor->InstanceTemplate();
   Nan::SetMethod(prototype, kCreateOffer, CreateOffer);
+  Nan::SetMethod(prototype, kCreateAnswer, CreateAnswer);
   Nan::SetMethod(prototype, kSetLocalDescription, SetLocalDescription);
+  Nan::SetMethod(prototype, kSetRemoteDescription, SetRemoteDescription);
   Nan::SetMethod(prototype, kCreateDataChannel, CreateDataChannel);
 
   Local<ObjectTemplate> tpl = ctor->InstanceTemplate();
@@ -159,7 +164,6 @@ NAN_METHOD(RTCPeerConnection::New) {
         ASSERT_PROPERTY_STRING(kIceServerUrls, iceServerUrlVal, iceServerUrl);
         server.urls.push_back(*iceServerUrl);
       }
-
       _config.servers.push_back(server);
     }
 
@@ -228,6 +232,35 @@ NAN_METHOD(RTCPeerConnection::CreateOffer) {
   object->_peerConnection->CreateOffer(observer, &constraints);
 }
 
+NAN_METHOD(RTCPeerConnection::CreateAnswer) {
+  METHOD_HEADER("RTCPeerConnection", "createAnswer");
+  UNWRAP_OBJECT(RTCPeerConnection, object);
+
+  unsigned char start = 0;
+  rtc::scoped_refptr<webrtc::CreateSessionDescriptionObserver> observer;
+
+  if (info.Length() < 2) {
+    DECLARE_PROMISE_RESOLVER;
+
+    observer = CreateSessionDescriptionObserver::Create(
+        new Nan::Persistent<Promise::Resolver>(resolver));
+  } else if (info.Length() > 1) {
+    if (info.Length() > 2) {
+      start = 1;
+    }
+
+    ASSERT_FUNCTION_ARGUMENT(start, successCallback);
+    ASSERT_FUNCTION_ARGUMENT(start + 1, failureCallback);
+
+    observer = CreateSessionDescriptionObserver::Create(
+        new Nan::Persistent<Function>(successCallback),
+        new Nan::Persistent<Function>(failureCallback));
+  }
+
+  webrtc::FakeConstraints constraints;
+  object->_peerConnection->CreateAnswer(observer, &constraints);
+}
+
 NAN_METHOD(RTCPeerConnection::SetLocalDescription) {
   METHOD_HEADER("RTCPeerConnection", "setLocalDescription");
   UNWRAP_OBJECT(RTCPeerConnection, object);
@@ -245,19 +278,41 @@ NAN_METHOD(RTCPeerConnection::SetLocalDescription) {
       new Nan::Persistent<Promise::Resolver>(resolver));
 
   object->_peerConnection->SetLocalDescription(observer, _sessionDescription->_sessionDescription);
+}
+
+NAN_METHOD(RTCPeerConnection::SetRemoteDescription) {
+  METHOD_HEADER("RTCPeerConnection", "setRemoteDescription");
+  UNWRAP_OBJECT(RTCPeerConnection, object);
+
+  rtc::scoped_refptr<webrtc::SetSessionDescriptionObserver> observer;
+
+  // FIXME: Promise implementation only
+  DECLARE_PROMISE_RESOLVER;
+  ASSERT_REJECT_OBJECT_ARGUMENT(0, sessionDescription);
+
+  // FIXME: validate it's a RTCSessionDescription object
+  RTCSessionDescription* _sessionDescription = Nan::ObjectWrap::Unwrap<RTCSessionDescription>(sessionDescription);
 
+  observer = SetSessionDescriptionObserver::Create(
+      new Nan::Persistent<Promise::Resolver>(resolver));
+
+  object->_peerConnection->SetRemoteDescription(observer, _sessionDescription->_sessionDescription);
 }
 
 NAN_METHOD(RTCPeerConnection::CreateDataChannel) {
-  METHOD_HEADER("RTCPeerConnection", "setLocalDescription");
+  METHOD_HEADER("RTCPeerConnection", "createDataChannel");
   UNWRAP_OBJECT(RTCPeerConnection, object);
 
   ASSERT_STRING_ARGUMENT(0, name);
 
+  // FIXME: add init options
   const webrtc::DataChannelInit init;
 
-  object->_peerConnection->CreateDataChannel(*name, &init);
+  rtc::scoped_refptr<webrtc::DataChannelInterface> _channel = object->_peerConnection->CreateDataChannel(*name, &init);
+
+  Local<Object> datachannel = RTCDataChannel::Create(_channel);
 
+  info.GetReturnValue().Set(datachannel);
 }
 
 NAN_GETTER(RTCPeerConnection::GetConnectionState) {

src/rtcpeerconnection.h

@@ -36,7 +36,9 @@ class RTCPeerConnection : public Nan::ObjectWrap {
 
   static NAN_METHOD(New);
   static NAN_METHOD(CreateOffer);
+  static NAN_METHOD(CreateAnswer);
   static NAN_METHOD(SetLocalDescription);
+  static NAN_METHOD(SetRemoteDescription);
   static NAN_METHOD(CreateDataChannel);
   static NAN_METHOD(GenerateCertificate);