webrtc-ruby 1.0.0

data/ext/webrtc_ruby/webrtc_ruby.h

@@ -0,0 +1,212 @@
+#ifndef WEBRTC_RUBY_H
+#define WEBRTC_RUBY_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+  #ifdef WEBRTC_RUBY_BUILDING
+    #define WEBRTC_RUBY_API __declspec(dllexport)
+  #else
+    #define WEBRTC_RUBY_API __declspec(dllimport)
+  #endif
+#else
+  #define WEBRTC_RUBY_API __attribute__((visibility("default")))
+#endif
+
+typedef struct webrtc_peer_connection* webrtc_peer_connection_t;
+typedef struct webrtc_data_channel* webrtc_data_channel_t;
+typedef struct webrtc_session_description* webrtc_session_description_t;
+typedef struct webrtc_ice_candidate* webrtc_ice_candidate_t;
+
+typedef struct {
+    int code;
+    const char* message;
+} webrtc_error_t;
+
+typedef struct {
+    const char** ice_servers;
+    size_t ice_servers_count;
+    const char* ice_transport_policy;
+    const char* bundle_policy;
+    const char* rtcp_mux_policy;
+    bool enable_ice_tcp;
+    bool enable_ice_udp_mux;
+    bool disable_auto_negotiation;
+    bool force_media_transport;
+    int mtu;
+    int max_message_size;
+} webrtc_configuration_t;
+
+typedef void (*webrtc_void_callback)(void* user_data);
+typedef void (*webrtc_ice_candidate_callback)(const char* candidate,
+                                              const char* sdp_mid,
+                                              int sdp_mline_index,
+                                              void* user_data);
+typedef void (*webrtc_data_channel_callback)(webrtc_data_channel_t dc,
+                                             void* user_data);
+typedef void (*webrtc_message_callback)(const uint8_t* data,
+                                        size_t length,
+                                        bool is_binary,
+                                        void* user_data);
+typedef void (*webrtc_state_change_callback)(int state, void* user_data);
+typedef void (*webrtc_track_callback)(int track_id, void* user_data);
+
+WEBRTC_RUBY_API int webrtc_init(void);
+WEBRTC_RUBY_API void webrtc_cleanup(void);
+
+WEBRTC_RUBY_API webrtc_peer_connection_t webrtc_peer_connection_create(
+    const webrtc_configuration_t* config,
+    webrtc_error_t* error);
+WEBRTC_RUBY_API void webrtc_peer_connection_destroy(webrtc_peer_connection_t pc);
+
+WEBRTC_RUBY_API int webrtc_peer_connection_create_offer(
+    webrtc_peer_connection_t pc,
+    webrtc_session_description_t* out_sdp,
+    webrtc_error_t* error);
+
+WEBRTC_RUBY_API int webrtc_peer_connection_create_answer(
+    webrtc_peer_connection_t pc,
+    webrtc_session_description_t* out_sdp,
+    webrtc_error_t* error);
+
+WEBRTC_RUBY_API int webrtc_peer_connection_set_local_description(
+    webrtc_peer_connection_t pc,
+    webrtc_session_description_t sdp,
+    webrtc_error_t* error);
+
+WEBRTC_RUBY_API int webrtc_peer_connection_set_remote_description(
+    webrtc_peer_connection_t pc,
+    webrtc_session_description_t sdp,
+    webrtc_error_t* error);
+
+WEBRTC_RUBY_API int webrtc_peer_connection_add_ice_candidate(
+    webrtc_peer_connection_t pc,
+    webrtc_ice_candidate_t candidate,
+    webrtc_error_t* error);
+
+WEBRTC_RUBY_API void webrtc_peer_connection_on_ice_candidate(
+    webrtc_peer_connection_t pc,
+    webrtc_ice_candidate_callback callback,
+    void* user_data);
+
+WEBRTC_RUBY_API void webrtc_peer_connection_on_connection_state_change(
+    webrtc_peer_connection_t pc,
+    webrtc_state_change_callback callback,
+    void* user_data);
+
+WEBRTC_RUBY_API void webrtc_peer_connection_on_ice_connection_state_change(
+    webrtc_peer_connection_t pc,
+    webrtc_state_change_callback callback,
+    void* user_data);
+
+WEBRTC_RUBY_API void webrtc_peer_connection_on_ice_gathering_state_change(
+    webrtc_peer_connection_t pc,
+    webrtc_state_change_callback callback,
+    void* user_data);
+
+WEBRTC_RUBY_API void webrtc_peer_connection_on_signaling_state_change(
+    webrtc_peer_connection_t pc,
+    webrtc_state_change_callback callback,
+    void* user_data);
+
+WEBRTC_RUBY_API void webrtc_peer_connection_on_data_channel(
+    webrtc_peer_connection_t pc,
+    webrtc_data_channel_callback callback,
+    void* user_data);
+
+WEBRTC_RUBY_API void webrtc_peer_connection_on_track(
+    webrtc_peer_connection_t pc,
+    webrtc_track_callback callback,
+    void* user_data);
+
+WEBRTC_RUBY_API int webrtc_peer_connection_get_signaling_state(
+    webrtc_peer_connection_t pc);
+WEBRTC_RUBY_API int webrtc_peer_connection_get_ice_gathering_state(
+    webrtc_peer_connection_t pc);
+WEBRTC_RUBY_API int webrtc_peer_connection_get_ice_connection_state(
+    webrtc_peer_connection_t pc);
+WEBRTC_RUBY_API int webrtc_peer_connection_get_connection_state(
+    webrtc_peer_connection_t pc);
+
+WEBRTC_RUBY_API int webrtc_peer_connection_add_track(
+    webrtc_peer_connection_t pc,
+    const char* kind,
+    int direction,
+    int* out_track_id,
+    webrtc_error_t* error);
+
+WEBRTC_RUBY_API int webrtc_peer_connection_remove_track(
+    webrtc_peer_connection_t pc,
+    int track_id,
+    webrtc_error_t* error);
+
+WEBRTC_RUBY_API int webrtc_track_get_direction(int track_id);
+WEBRTC_RUBY_API const char* webrtc_track_get_kind(int track_id);
+
+WEBRTC_RUBY_API webrtc_data_channel_t webrtc_peer_connection_create_data_channel(
+    webrtc_peer_connection_t pc,
+    const char* label,
+    bool ordered,
+    int max_retransmits,
+    int max_packet_life_time,
+    const char* protocol,
+    bool negotiated,
+    int id,
+    webrtc_error_t* error);
+
+WEBRTC_RUBY_API void webrtc_data_channel_destroy(webrtc_data_channel_t dc);
+WEBRTC_RUBY_API int webrtc_data_channel_send(webrtc_data_channel_t dc,
+                                             const uint8_t* data,
+                                             size_t length,
+                                             bool is_binary,
+                                             webrtc_error_t* error);
+WEBRTC_RUBY_API void webrtc_data_channel_close(webrtc_data_channel_t dc);
+WEBRTC_RUBY_API int webrtc_data_channel_get_ready_state(webrtc_data_channel_t dc);
+WEBRTC_RUBY_API const char* webrtc_data_channel_get_label(webrtc_data_channel_t dc);
+WEBRTC_RUBY_API size_t webrtc_data_channel_get_buffered_amount(webrtc_data_channel_t dc);
+
+WEBRTC_RUBY_API void webrtc_data_channel_on_open(webrtc_data_channel_t dc,
+                                                  webrtc_void_callback callback,
+                                                  void* user_data);
+WEBRTC_RUBY_API void webrtc_data_channel_on_message(webrtc_data_channel_t dc,
+                                                     webrtc_message_callback callback,
+                                                     void* user_data);
+WEBRTC_RUBY_API void webrtc_data_channel_on_close(webrtc_data_channel_t dc,
+                                                   webrtc_void_callback callback,
+                                                   void* user_data);
+
+WEBRTC_RUBY_API webrtc_session_description_t webrtc_session_description_create(
+    const char* type,
+    const char* sdp,
+    webrtc_error_t* error);
+WEBRTC_RUBY_API void webrtc_session_description_destroy(
+    webrtc_session_description_t sd);
+WEBRTC_RUBY_API const char* webrtc_session_description_get_type(
+    webrtc_session_description_t sd);
+WEBRTC_RUBY_API const char* webrtc_session_description_get_sdp(
+    webrtc_session_description_t sd);
+
+WEBRTC_RUBY_API webrtc_ice_candidate_t webrtc_ice_candidate_create(
+    const char* candidate,
+    const char* sdp_mid,
+    int sdp_mline_index,
+    webrtc_error_t* error);
+WEBRTC_RUBY_API void webrtc_ice_candidate_destroy(webrtc_ice_candidate_t ic);
+WEBRTC_RUBY_API const char* webrtc_ice_candidate_get_candidate(
+    webrtc_ice_candidate_t ic);
+WEBRTC_RUBY_API const char* webrtc_ice_candidate_get_sdp_mid(
+    webrtc_ice_candidate_t ic);
+WEBRTC_RUBY_API int webrtc_ice_candidate_get_sdp_mline_index(
+    webrtc_ice_candidate_t ic);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/lib/webrtc/configuration.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class RTCConfiguration
+    ICE_TRANSPORT_POLICIES = %i[all relay].freeze
+    BUNDLE_POLICIES = %i[balanced max_compat max_bundle].freeze
+    RTCP_MUX_POLICIES = %i[require].freeze
+
+    attr_accessor :ice_servers, :ice_transport_policy, :bundle_policy, :rtcp_mux_policy, :certificates,
+                  :ice_candidate_pool_size
+
+    def initialize(options = {})
+      @ice_servers = normalize_ice_servers(options[:ice_servers] || options[:iceServers] || [])
+      @ice_transport_policy = options[:ice_transport_policy] || options[:iceTransportPolicy] || :all
+      @bundle_policy = options[:bundle_policy] || options[:bundlePolicy] || :balanced
+      @rtcp_mux_policy = options[:rtcp_mux_policy] || options[:rtcpMuxPolicy] || :require
+      @certificates = options[:certificates] || []
+      @ice_candidate_pool_size = options[:ice_candidate_pool_size] || options[:iceCandidatePoolSize] || 0
+
+      validate!
+    end
+
+    def to_h
+      {
+        iceServers: @ice_servers.map(&:to_h),
+        iceTransportPolicy: @ice_transport_policy,
+        bundlePolicy: @bundle_policy,
+        rtcpMuxPolicy: @rtcp_mux_policy,
+        iceCandidatePoolSize: @ice_candidate_pool_size
+      }
+    end
+
+    private
+
+    def normalize_ice_servers(servers)
+      servers.map do |server|
+        server.is_a?(RTCIceServer) ? server : RTCIceServer.new(server)
+      end
+    end
+
+    def validate!
+      unless ICE_TRANSPORT_POLICIES.include?(@ice_transport_policy)
+        raise InvalidParameterError, "Invalid ice_transport_policy: #{@ice_transport_policy}"
+      end
+
+      unless BUNDLE_POLICIES.include?(@bundle_policy)
+        raise InvalidParameterError, "Invalid bundle_policy: #{@bundle_policy}"
+      end
+
+      return if @ice_candidate_pool_size.between?(0, 255)
+
+      raise InvalidParameterError, 'ice_candidate_pool_size must be 0-255'
+    end
+  end
+
+  class RTCIceServer
+    attr_accessor :urls, :username, :credential, :credential_type
+
+    def initialize(options = {})
+      @urls = normalize_urls(options[:urls] || options[:url])
+      @username = options[:username]
+      @credential = options[:credential]
+      @credential_type = options[:credential_type] || options[:credentialType] || :password
+
+      validate!
+    end
+
+    def to_h
+      hash = { urls: @urls }
+      hash[:username] = @username if @username
+      hash[:credential] = @credential if @credential
+      hash[:credentialType] = @credential_type if @credential
+      hash
+    end
+
+    private
+
+    def normalize_urls(urls)
+      case urls
+      when String
+        [urls]
+      when Array
+        urls
+      else
+        []
+      end
+    end
+
+    def validate!
+      raise InvalidParameterError, 'ICE server URLs required' if @urls.empty?
+
+      @urls.each do |url|
+        unless url.start_with?('stun:', 'stuns:', 'turn:', 'turns:')
+          raise InvalidParameterError, "Invalid ICE server URL: #{url}"
+        end
+      end
+    end
+  end
+end

data/lib/webrtc/data_channel.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class RTCDataChannel
+    READY_STATES = %i[connecting open closing closed].freeze
+    BINARY_TYPES = %i[blob arraybuffer].freeze
+
+    attr_reader :label, :ordered, :max_packet_life_time, :max_retransmits, :protocol, :negotiated, :id
+    attr_accessor :buffered_amount_low_threshold, :binary_type
+
+    def initialize(ptr, options = {})
+      @ptr = ptr
+      @callbacks = {}
+      @internal_callbacks = Hash.new { |h, k| h[k] = [] }
+      @native_callbacks_setup = {}
+      @binary_type = :arraybuffer
+      @buffered_amount_low_threshold = 0
+      @messages_sent = 0
+      @bytes_sent = 0
+      @messages_received = 0
+      @bytes_received = 0
+
+      @label = options[:label] || FFI.webrtc_data_channel_get_label(ptr)
+      @ordered = options.fetch(:ordered, true)
+      @max_packet_life_time = options[:max_packet_life_time]
+      @max_retransmits = options[:max_retransmits]
+      @protocol = options[:protocol] || ''
+      @negotiated = options.fetch(:negotiated, false)
+      @id = options[:id]
+    end
+
+    def ready_state
+      return :closed if @ptr.nil?
+
+      state_index = FFI.webrtc_data_channel_get_ready_state(@ptr)
+      READY_STATES[state_index] || :unknown
+    end
+
+    def buffered_amount
+      return 0 if @ptr.nil?
+
+      FFI.webrtc_data_channel_get_buffered_amount(@ptr)
+    end
+
+    def send(data)
+      raise InvalidStateError, 'DataChannel is not open' unless ready_state == :open
+
+      is_binary = data.is_a?(String) && data.encoding == Encoding::BINARY
+      send_data(data, is_binary)
+    end
+
+    def send_text(data)
+      raise InvalidStateError, 'DataChannel is not open' unless ready_state == :open
+
+      send_data(data.to_s, false)
+    end
+
+    def send_binary(data)
+      raise InvalidStateError, 'DataChannel is not open' unless ready_state == :open
+
+      send_data(data, true)
+    end
+
+    def close
+      return if @ptr.nil?
+
+      FFI.webrtc_data_channel_close(@ptr)
+    end
+
+    def destroy
+      return if @ptr.nil?
+
+      FFI.webrtc_data_channel_destroy(@ptr)
+      @ptr = nil
+    end
+
+    def on_open(&block)
+      @callbacks[:open] = block
+      setup_open_callback
+    end
+
+    def on_close(&block)
+      @callbacks[:close] = block
+      setup_close_callback
+    end
+
+    def on_error(&block)
+      @callbacks[:error] = block
+    end
+
+    def on_message(&block)
+      @callbacks[:message] = block
+      setup_message_callback
+    end
+
+    def on_buffered_amount_low(&block)
+      @callbacks[:buffered_amount_low] = block
+    end
+
+    def observe(observer)
+      return self unless observer.respond_to?(:bind)
+
+      observer.bind(self)
+    end
+
+    def add_internal_listener(event, &block)
+      return self unless block
+
+      @internal_callbacks[event] << block
+      case event
+      when :open
+        setup_open_callback
+      when :close
+        setup_close_callback
+      when :message
+        setup_message_callback
+      end
+      self
+    end
+
+    def stats_snapshot
+      {
+        messages_sent: @messages_sent,
+        bytes_sent: @bytes_sent,
+        messages_received: @messages_received,
+        bytes_received: @bytes_received,
+        state: ready_state
+      }
+    end
+
+    private
+
+    def send_data(data, is_binary)
+      data_str = data.to_s
+      ptr = ::FFI::MemoryPointer.from_string(data_str)
+      error = FFI::Error.new
+
+      result = FFI.webrtc_data_channel_send(@ptr, ptr, data_str.bytesize, is_binary, error)
+      raise OperationError, error[:message] if result != 0
+
+      @messages_sent += 1
+      @bytes_sent += data_str.bytesize
+      emit_internal(:sent, data_str.bytesize, is_binary)
+
+      data_str.bytesize
+    end
+
+    def setup_open_callback
+      return if @native_callbacks_setup[:open] || @ptr.nil?
+
+      callback = proc do |_user_data|
+        emit_internal(:open)
+        @callbacks[:open]&.call
+      end
+      @callbacks[:open_proc] = callback
+      @native_callbacks_setup[:open] = true
+      FFI.webrtc_data_channel_on_open(@ptr, callback, ::FFI::Pointer::NULL)
+    end
+
+    def setup_close_callback
+      return if @native_callbacks_setup[:close] || @ptr.nil?
+
+      callback = proc do |_user_data|
+        emit_internal(:close)
+        @callbacks[:close]&.call
+      end
+      @callbacks[:close_proc] = callback
+      @native_callbacks_setup[:close] = true
+      FFI.webrtc_data_channel_on_close(@ptr, callback, ::FFI::Pointer::NULL)
+    end
+
+    def setup_message_callback
+      return if @native_callbacks_setup[:message] || @ptr.nil?
+
+      callback = proc do |data_ptr, length, is_binary, _user_data|
+        data = data_ptr.read_bytes(length)
+        data = data.force_encoding(Encoding::UTF_8) unless is_binary
+
+        message = DataChannelMessage.new(data, is_binary)
+        @messages_received += 1
+        @bytes_received += data.bytesize
+        emit_internal(:message, message)
+        @callbacks[:message]&.call(message)
+      end
+      @callbacks[:message_proc] = callback
+      @native_callbacks_setup[:message] = true
+      FFI.webrtc_data_channel_on_message(@ptr, callback, ::FFI::Pointer::NULL)
+    end
+
+    def emit_internal(event, *args)
+      callbacks = @internal_callbacks[event]
+      return if callbacks.nil? || callbacks.empty?
+
+      callbacks.each { |callback| callback.call(*args) }
+    end
+  end
+
+  class MessageEvent
+    attr_reader :data, :origin, :last_event_id
+
+    def initialize(data, is_binary)
+      @data = data
+      @is_binary = is_binary
+      @origin = ''
+      @last_event_id = ''
+    end
+
+    def binary?
+      @is_binary
+    end
+
+    def text?
+      !@is_binary
+    end
+  end
+end

data/lib/webrtc/dtls_transport.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class RTCDtlsTransport
+    STATES = %i[new connecting connected closed failed].freeze
+
+    attr_reader :ice_transport, :state
+
+    def initialize(options = {})
+      @ice_transport = options[:ice_transport] || RTCIceTransport.new
+      @state = :new
+      @remote_certificates = []
+      @callbacks = {}
+      @ptr = options[:ptr]
+    end
+
+    def get_remote_certificates
+      @remote_certificates.dup
+    end
+
+    def on_state_change(&block)
+      @callbacks[:state_change] = block
+    end
+
+    def on_error(&block)
+      @callbacks[:error] = block
+    end
+
+    private
+
+    def set_state(new_state)
+      return if @state == new_state
+
+      @state = new_state
+      @callbacks[:state_change]&.call
+    end
+  end
+
+  class RTCDtlsFingerprint
+    attr_reader :algorithm, :value
+
+    def initialize(algorithm:, value:)
+      @algorithm = algorithm
+      @value = value
+    end
+
+    def to_h
+      {
+        algorithm: @algorithm,
+        value: @value
+      }
+    end
+  end
+end

data/lib/webrtc/dtmf_sender.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class RTCDTMFSender
+    VALID_TONES = '0123456789ABCD*#,'
+
+    attr_reader :tone_buffer, :duration, :inter_tone_gap
+
+    def initialize(options = {})
+      @sender = options[:sender]
+      @tone_buffer = ''
+      @duration = 100
+      @inter_tone_gap = 70
+      @callbacks = {}
+    end
+
+    def can_insert_dtmf?
+      @sender&.track&.kind == :audio
+    end
+
+    def insert_dtmf(tones, duration: 100, inter_tone_gap: 70)
+      raise InvalidStateError, 'Cannot insert DTMF' unless can_insert_dtmf?
+
+      validate_tones!(tones)
+      validate_duration!(duration)
+      validate_inter_tone_gap!(inter_tone_gap)
+
+      @duration = duration
+      @inter_tone_gap = inter_tone_gap
+      @tone_buffer = tones.upcase
+
+      schedule_tone_playback
+    end
+
+    def on_tone_change(&block)
+      @callbacks[:tone_change] = block
+    end
+
+    private
+
+    def validate_tones!(tones)
+      tones.each_char do |char|
+        raise InvalidParameterError, "Invalid DTMF tone: #{char}" unless VALID_TONES.include?(char.upcase)
+      end
+    end
+
+    def validate_duration!(duration)
+      return if duration >= 40 && duration <= 6000
+
+      raise InvalidParameterError, 'Duration must be between 40 and 6000 ms'
+    end
+
+    def validate_inter_tone_gap!(gap)
+      return if gap >= 30
+
+      raise InvalidParameterError, 'Inter-tone gap must be at least 30 ms'
+    end
+
+    def schedule_tone_playback
+      return if @tone_buffer.empty?
+
+      tone = @tone_buffer[0]
+      @tone_buffer = @tone_buffer[1..]
+
+      emit_tone_change(tone)
+    end
+
+    def emit_tone_change(tone)
+      event = RTCDTMFToneChangeEvent.new(tone: tone)
+      @callbacks[:tone_change]&.call(event)
+    end
+  end
+
+  class RTCDTMFToneChangeEvent
+    attr_reader :tone
+
+    def initialize(tone:)
+      @tone = tone
+    end
+  end
+end

data/lib/webrtc/errors.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class Error < StandardError; end
+
+  class InitializationError < Error; end
+  class OperationError < Error; end
+  class InvalidStateError < Error; end
+  class InvalidParameterError < Error; end
+end

data/lib/webrtc/factory.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class CurrentTaskQueueFactory
+    def create
+      self
+    end
+  end
+
+  class PeerConnectionFactory
+    attr_reader :task_queue_factory
+
+    def initialize(task_queue_factory: CurrentTaskQueueFactory.new, default_configuration: nil)
+      @task_queue_factory = task_queue_factory
+      @default_configuration = default_configuration
+    end
+
+    def create_peer_connection(configuration = nil)
+      RTCPeerConnection.new(configuration || @default_configuration, factory: self)
+    end
+  end
+
+  class << self
+    def create_modular_peer_connection_factory(task_queue_factory: CurrentTaskQueueFactory.new)
+      PeerConnectionFactory.new(task_queue_factory: task_queue_factory)
+    end
+  end
+end