webrtc-ruby 0.1.0

data/ext/webrtc_ruby/webrtc_ruby.h

@@ -0,0 +1,169 @@
+#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;
+} 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);
+
+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_data_channel(
+    webrtc_peer_connection_t pc,
+    webrtc_data_channel_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 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,154 @@
+# 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 = {}
+      @binary_type = :arraybuffer
+      @buffered_amount_low_threshold = 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
+
+    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
+
+      data_str.bytesize
+    end
+
+    def setup_open_callback
+      callback = proc do |_user_data|
+        @callbacks[:open]&.call
+      end
+      @callbacks[:open_proc] = callback
+      FFI.webrtc_data_channel_on_open(@ptr, callback, ::FFI::Pointer::NULL)
+    end
+
+    def setup_close_callback
+      callback = proc do |_user_data|
+        @callbacks[:close]&.call
+      end
+      @callbacks[:close_proc] = callback
+      FFI.webrtc_data_channel_on_close(@ptr, callback, ::FFI::Pointer::NULL)
+    end
+
+    def setup_message_callback
+      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 = MessageEvent.new(data, is_binary)
+        @callbacks[:message]&.call(message)
+      end
+      @callbacks[:message_proc] = callback
+      FFI.webrtc_data_channel_on_message(@ptr, callback, ::FFI::Pointer::NULL)
+    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/ffi/library.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module WebRTC
+  module FFI
+    extend ::FFI::Library
+
+    LIB_NAME = case RbConfig::CONFIG['host_os']
+               when /darwin/ then 'libwebrtc_ruby.dylib'
+               when /mswin|mingw/ then 'webrtc_ruby.dll'
+               else 'libwebrtc_ruby.so'
+               end
+
+    LIB_PATH = File.join(__dir__, '..', '..', '..', 'ext', 'webrtc_ruby', 'build', LIB_NAME)
+
+    ffi_lib LIB_PATH if File.exist?(LIB_PATH)
+
+    class Error < ::FFI::Struct
+      layout :code, :int,
+             :message, :string
+    end
+
+    class Configuration < ::FFI::Struct
+      layout :ice_servers, :pointer,
+             :ice_servers_count, :size_t,
+             :ice_transport_policy, :pointer,
+             :bundle_policy, :pointer
+    end
+
+    callback :void_callback, [:pointer], :void
+    callback :ice_candidate_callback, %i[string string int pointer], :void
+    callback :data_channel_callback, %i[pointer pointer], :void
+    callback :message_callback, %i[pointer size_t bool pointer], :void
+    callback :state_change_callback, %i[int pointer], :void
+
+    attach_function :webrtc_init, [], :int
+    attach_function :webrtc_cleanup, [], :void
+
+    attach_function :webrtc_peer_connection_create,
+                    [Configuration.by_ref, Error.by_ref], :pointer
+    attach_function :webrtc_peer_connection_destroy, [:pointer], :void
+
+    attach_function :webrtc_peer_connection_create_offer,
+                    [:pointer, :pointer, Error.by_ref], :int
+    attach_function :webrtc_peer_connection_create_answer,
+                    [:pointer, :pointer, Error.by_ref], :int
+
+    attach_function :webrtc_peer_connection_set_local_description,
+                    [:pointer, :pointer, Error.by_ref], :int
+    attach_function :webrtc_peer_connection_set_remote_description,
+                    [:pointer, :pointer, Error.by_ref], :int
+    attach_function :webrtc_peer_connection_add_ice_candidate,
+                    [:pointer, :pointer, Error.by_ref], :int
+
+    attach_function :webrtc_peer_connection_on_ice_candidate,
+                    %i[pointer ice_candidate_callback pointer], :void
+    attach_function :webrtc_peer_connection_on_connection_state_change,
+                    %i[pointer state_change_callback pointer], :void
+    attach_function :webrtc_peer_connection_on_data_channel,
+                    %i[pointer data_channel_callback pointer], :void
+
+    attach_function :webrtc_peer_connection_get_signaling_state, [:pointer], :int
+    attach_function :webrtc_peer_connection_get_ice_gathering_state, [:pointer], :int
+    attach_function :webrtc_peer_connection_get_ice_connection_state, [:pointer], :int
+    attach_function :webrtc_peer_connection_get_connection_state, [:pointer], :int
+
+    attach_function :webrtc_peer_connection_create_data_channel,
+                    [:pointer, :string, :bool, :int, :int, :string, :bool, :int, Error.by_ref],
+                    :pointer
+
+    attach_function :webrtc_data_channel_destroy, [:pointer], :void
+    attach_function :webrtc_data_channel_send,
+                    [:pointer, :pointer, :size_t, :bool, Error.by_ref], :int
+    attach_function :webrtc_data_channel_close, [:pointer], :void
+    attach_function :webrtc_data_channel_get_ready_state, [:pointer], :int
+    attach_function :webrtc_data_channel_get_label, [:pointer], :string
+    attach_function :webrtc_data_channel_get_buffered_amount, [:pointer], :size_t
+
+    attach_function :webrtc_data_channel_on_open,
+                    %i[pointer void_callback pointer], :void
+    attach_function :webrtc_data_channel_on_message,
+                    %i[pointer message_callback pointer], :void
+    attach_function :webrtc_data_channel_on_close,
+                    %i[pointer void_callback pointer], :void
+
+    attach_function :webrtc_session_description_create,
+                    [:string, :string, Error.by_ref], :pointer
+    attach_function :webrtc_session_description_destroy, [:pointer], :void
+    attach_function :webrtc_session_description_get_type, [:pointer], :string
+    attach_function :webrtc_session_description_get_sdp, [:pointer], :string
+
+    attach_function :webrtc_ice_candidate_create,
+                    [:string, :string, :int, Error.by_ref], :pointer
+    attach_function :webrtc_ice_candidate_destroy, [:pointer], :void
+    attach_function :webrtc_ice_candidate_get_candidate, [:pointer], :string
+    attach_function :webrtc_ice_candidate_get_sdp_mid, [:pointer], :string
+    attach_function :webrtc_ice_candidate_get_sdp_mline_index, [:pointer], :int
+  end
+end