webrtc-ruby 1.0.0

data/lib/webrtc/ffi/library.rb

@@ -0,0 +1,122 @@
+# 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,
+             :rtcp_mux_policy, :pointer,
+             :enable_ice_tcp, :bool,
+             :enable_ice_udp_mux, :bool,
+             :disable_auto_negotiation, :bool,
+             :force_media_transport, :bool,
+             :mtu, :int,
+             :max_message_size, :int
+    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
+    callback :track_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_ice_connection_state_change,
+                    %i[pointer state_change_callback pointer], :void
+    attach_function :webrtc_peer_connection_on_ice_gathering_state_change,
+                    %i[pointer state_change_callback pointer], :void
+    attach_function :webrtc_peer_connection_on_signaling_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_on_track,
+                    %i[pointer track_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_add_track,
+                    [:pointer, :string, :int, :pointer, Error.by_ref], :int
+    attach_function :webrtc_peer_connection_remove_track,
+                    [:pointer, :int, Error.by_ref], :int
+    attach_function :webrtc_track_get_direction, [:int], :int
+    attach_function :webrtc_track_get_kind, [:int], :string
+
+    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

data/lib/webrtc/ice_candidate.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class RTCIceCandidate
+    attr_reader :candidate, :sdp_mid, :sdp_m_line_index, :username_fragment
+
+    def initialize(init = {})
+      init = init.to_h if init.respond_to?(:to_h)
+      @candidate = init[:candidate] || ''
+      @sdp_mid = init[:sdp_mid] || init[:sdpMid]
+      @sdp_m_line_index = init[:sdp_m_line_index] || init[:sdpMLineIndex]
+      @username_fragment = init[:username_fragment] || init[:usernameFragment]
+      @ptr = nil
+    end
+
+    def self.from_ptr(ptr)
+      return nil if ptr.nil? || ptr.null?
+
+      candidate_str = FFI.webrtc_ice_candidate_get_candidate(ptr)
+      sdp_mid_str = FFI.webrtc_ice_candidate_get_sdp_mid(ptr)
+      sdp_m_line_index = FFI.webrtc_ice_candidate_get_sdp_mline_index(ptr)
+
+      ice = new(
+        candidate: candidate_str,
+        sdp_mid: sdp_mid_str,
+        sdp_m_line_index: sdp_m_line_index
+      )
+      ice.instance_variable_set(:@ptr, ptr)
+      ice
+    end
+
+    def to_ptr
+      return @ptr if @ptr && !@ptr.null?
+
+      error = FFI::Error.new
+      @ptr = FFI.webrtc_ice_candidate_create(
+        candidate,
+        sdp_mid,
+        sdp_m_line_index || 0,
+        error
+      )
+      raise OperationError, error[:message] if error[:code] != 0
+
+      @ptr
+    end
+
+    def to_h
+      {
+        candidate: candidate,
+        sdpMid: sdp_mid,
+        sdpMLineIndex: sdp_m_line_index,
+        usernameFragment: username_fragment
+      }
+    end
+
+    def release
+      return unless @ptr && !@ptr.null?
+
+      FFI.webrtc_ice_candidate_destroy(@ptr)
+      @ptr = nil
+    end
+  end
+end

data/lib/webrtc/ice_transport.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class RTCIceTransport
+    STATES = %i[new checking connected completed failed disconnected closed].freeze
+    GATHERING_STATES = %i[new gathering complete].freeze
+    ROLES = %i[controlling controlled unknown].freeze
+
+    attr_reader :role, :component, :state, :gathering_state
+
+    def initialize(options = {})
+      @state = :new
+      @gathering_state = :new
+      @role = options[:role] || :unknown
+      @component = options[:component] || :rtp
+      @local_candidates = []
+      @remote_candidates = []
+      @local_parameters = nil
+      @remote_parameters = nil
+      @callbacks = {}
+      @ptr = options[:ptr]
+    end
+
+    def get_local_candidates
+      @local_candidates.dup
+    end
+
+    def get_remote_candidates
+      @remote_candidates.dup
+    end
+
+    def get_local_parameters
+      @local_parameters
+    end
+
+    def get_remote_parameters
+      @remote_parameters
+    end
+
+    def get_selected_candidate_pair
+      return nil if @local_candidates.empty? || @remote_candidates.empty?
+
+      RTCIceCandidatePair.new(
+        local: @local_candidates.first,
+        remote: @remote_candidates.first
+      )
+    end
+
+    def on_state_change(&block)
+      @callbacks[:state_change] = block
+    end
+
+    def on_gathering_state_change(&block)
+      @callbacks[:gathering_state_change] = block
+    end
+
+    def on_selected_candidate_pair_change(&block)
+      @callbacks[:selected_candidate_pair_change] = block
+    end
+
+    private
+
+    def set_state(new_state)
+      return if @state == new_state
+
+      @state = new_state
+      @callbacks[:state_change]&.call
+    end
+  end
+
+  class RTCIceCandidatePair
+    attr_reader :local, :remote
+
+    def initialize(local:, remote:)
+      @local = local
+      @remote = remote
+    end
+  end
+
+  class RTCIceParameters
+    attr_reader :username_fragment, :password
+
+    def initialize(username_fragment:, password:)
+      @username_fragment = username_fragment
+      @password = password
+    end
+
+    def to_h
+      {
+        usernameFragment: @username_fragment,
+        password: @password
+      }
+    end
+  end
+end

data/lib/webrtc/media_interfaces.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class MediaStreamInterface
+    attr_reader :stream
+
+    def initialize(stream = MediaStream.new)
+      @stream = stream
+    end
+
+    def add_track(track)
+      @stream.add_track(track)
+    end
+
+    def remove_track(track)
+      @stream.remove_track(track)
+    end
+
+    def get_tracks
+      @stream.get_tracks
+    end
+  end
+
+  class AudioTrackSinkInterface
+    def on_data(_frame); end
+  end
+
+  class AudioTrackSourceInterface
+    def initialize
+      @sinks = []
+    end
+
+    def add_sink(sink)
+      @sinks << sink unless @sinks.include?(sink)
+    end
+
+    def remove_sink(sink)
+      @sinks.delete(sink)
+    end
+
+    def push_data(frame)
+      @sinks.each { |sink| sink.on_data(frame) if sink.respond_to?(:on_data) }
+    end
+  end
+
+  class AudioTrackInterface < MediaStreamTrack
+    attr_reader :source
+
+    def initialize(source: AudioTrackSourceInterface.new, **options)
+      super({ kind: :audio }.merge(options))
+      @source = source
+    end
+
+    def add_sink(sink)
+      @source.add_sink(sink)
+    end
+
+    def remove_sink(sink)
+      @source.remove_sink(sink)
+    end
+  end
+
+  class VideoTrackSinkInterface
+    def on_frame(_frame); end
+  end
+
+  class VideoTrackSourceInterface
+    def initialize
+      @sinks = []
+    end
+
+    def add_sink(sink)
+      @sinks << sink unless @sinks.include?(sink)
+    end
+
+    def remove_sink(sink)
+      @sinks.delete(sink)
+    end
+
+    def push_frame(frame)
+      @sinks.each { |sink| sink.on_frame(frame) if sink.respond_to?(:on_frame) }
+    end
+  end
+
+  class VideoTrackInterface < MediaStreamTrack
+    attr_reader :source
+
+    def initialize(source: VideoTrackSourceInterface.new, **options)
+      super({ kind: :video }.merge(options))
+      @source = source
+    end
+
+    def add_sink(sink)
+      @source.add_sink(sink)
+    end
+
+    def remove_sink(sink)
+      @source.remove_sink(sink)
+    end
+  end
+end

data/lib/webrtc/media_stream.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class MediaStream
+    attr_reader :id, :active
+
+    def initialize(tracks = [])
+      @id = generate_id
+      @tracks = {}
+      @callbacks = {}
+
+      tracks.each { |track| add_track(track) }
+    end
+
+    def active?
+      @tracks.values.any? { |track| track.ready_state == :live }
+    end
+
+    def get_audio_tracks
+      @tracks.values.select { |track| track.kind == :audio }
+    end
+
+    def get_video_tracks
+      @tracks.values.select { |track| track.kind == :video }
+    end
+
+    def get_tracks
+      @tracks.values
+    end
+
+    def get_track_by_id(id)
+      @tracks[id]
+    end
+
+    def add_track(track)
+      return if @tracks.key?(track.id)
+
+      @tracks[track.id] = track
+      @callbacks[:add_track]&.call(track)
+    end
+
+    def remove_track(track)
+      removed = @tracks.delete(track.id)
+      @callbacks[:remove_track]&.call(track) if removed
+      removed
+    end
+
+    def clone
+      cloned_tracks = @tracks.values.map(&:clone)
+      MediaStream.new(cloned_tracks)
+    end
+
+    def on_add_track(&block)
+      @callbacks[:add_track] = block
+    end
+
+    def on_remove_track(&block)
+      @callbacks[:remove_track] = block
+    end
+
+    private
+
+    def generate_id
+      "stream-#{SecureRandom.uuid}"
+    end
+  end
+end

data/lib/webrtc/media_stream_track.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class MediaStreamTrack
+    KINDS = %i[audio video].freeze
+    READY_STATES = %i[live ended].freeze
+
+    attr_reader :id, :kind, :label, :ready_state
+    attr_accessor :enabled, :muted, :content_hint
+
+    def initialize(options = {})
+      @id = options[:id] || generate_id
+      @kind = options[:kind]&.to_sym
+      @label = options[:label] || ''
+      @enabled = options.fetch(:enabled, true)
+      @muted = options.fetch(:muted, false)
+      @ready_state = :live
+      @content_hint = options[:content_hint] || ''
+      @callbacks = {}
+      @ptr = options[:ptr]
+
+      validate!
+    end
+
+    def stop
+      @ready_state = :ended
+      @callbacks[:ended]&.call
+    end
+
+    def clone
+      MediaStreamTrack.new(
+        kind: kind,
+        label: label,
+        enabled: enabled,
+        muted: muted,
+        content_hint: content_hint
+      )
+    end
+
+    def get_constraints
+      {}
+    end
+
+    def get_capabilities
+      {}
+    end
+
+    def get_settings
+      {
+        device_id: '',
+        group_id: ''
+      }
+    end
+
+    def apply_constraints(_constraints = {})
+      Promise.resolve(nil)
+    end
+
+    def on_ended(&block)
+      @callbacks[:ended] = block
+    end
+
+    def on_mute(&block)
+      @callbacks[:mute] = block
+    end
+
+    def on_unmute(&block)
+      @callbacks[:unmute] = block
+    end
+
+    private
+
+    def generate_id
+      "track-#{SecureRandom.uuid}"
+    end
+
+    def validate!
+      return if kind.nil? || KINDS.include?(kind)
+
+      raise InvalidParameterError, "Invalid track kind: #{kind}"
+    end
+  end
+end

data/lib/webrtc/observers.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class BaseObserver
+    def initialize(on_success: nil, on_failure: nil)
+      @on_success = on_success
+      @on_failure = on_failure
+    end
+
+    def on_success(value = nil)
+      @on_success&.call(value)
+    end
+
+    def on_failure(error)
+      @on_failure&.call(error)
+    end
+  end
+
+  class CreateSessionDescriptionObserver < BaseObserver; end
+  class SetSessionDescriptionObserver < BaseObserver; end
+  class SetLocalDescriptionObserver < SetSessionDescriptionObserver; end
+  class SetRemoteDescriptionObserver < SetSessionDescriptionObserver; end
+  class AddIceCandidateObserver < BaseObserver; end
+
+  class DataChannelObserver
+    def initialize(on_open: nil, on_close: nil, on_message: nil, on_error: nil)
+      @on_open = on_open
+      @on_close = on_close
+      @on_message = on_message
+      @on_error = on_error
+    end
+
+    def bind(channel)
+      channel.on_open { @on_open&.call }
+      channel.on_close { @on_close&.call }
+      channel.on_message { |message| @on_message&.call(message) }
+      channel.on_error { |error| @on_error&.call(error) }
+      channel
+    end
+  end
+
+  class RTCStatsCollectorCallback
+    def initialize(&block)
+      @block = block
+    end
+
+    def on_stats_delivered(response)
+      @block&.call(response)
+    end
+  end
+end