webrtc-ruby 0.1.0

data/lib/webrtc/ice_candidate.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class RTCIceCandidate
+    attr_reader :candidate, :sdp_mid, :sdp_m_line_index, :username_fragment
+
+    def initialize(init = {})
+      @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_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/peer_connection.rb

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+module WebRTC
+  class RTCPeerConnection
+    SIGNALING_STATES = %i[stable have_local_offer have_remote_offer
+                          have_local_pranswer have_remote_pranswer closed].freeze
+    ICE_GATHERING_STATES = %i[new gathering complete].freeze
+    ICE_CONNECTION_STATES = %i[new checking connected completed failed
+                               disconnected closed].freeze
+    CONNECTION_STATES = %i[new connecting connected disconnected failed closed].freeze
+
+    attr_reader :ptr, :local_description, :remote_description
+
+    def initialize(configuration = nil)
+      @configuration = configuration || {}
+      @callbacks = {}
+      @senders = []
+      @receivers = []
+      @transceivers = []
+      @ptr = create_native_peer_connection
+    end
+
+    def signaling_state
+      state_index = FFI.webrtc_peer_connection_get_signaling_state(@ptr)
+      SIGNALING_STATES[state_index] || :unknown
+    end
+
+    def ice_gathering_state
+      state_index = FFI.webrtc_peer_connection_get_ice_gathering_state(@ptr)
+      ICE_GATHERING_STATES[state_index] || :unknown
+    end
+
+    def ice_connection_state
+      state_index = FFI.webrtc_peer_connection_get_ice_connection_state(@ptr)
+      ICE_CONNECTION_STATES[state_index] || :unknown
+    end
+
+    def connection_state
+      state_index = FFI.webrtc_peer_connection_get_connection_state(@ptr)
+      CONNECTION_STATES[state_index] || :unknown
+    end
+
+    def close
+      return if @ptr.nil?
+
+      FFI.webrtc_peer_connection_destroy(@ptr)
+      @ptr = nil
+    end
+
+    def closed?
+      @ptr.nil?
+    end
+
+    def sctp_transport
+      @sctp_transport ||= RTCSctpTransport.new
+    end
+
+    def get_configuration
+      @configuration.dup
+    end
+
+    def set_configuration(configuration)
+      @configuration = configuration
+    end
+
+    def get_stats(selector = nil)
+      raise_if_closed!
+      Promise.new do
+        stats = {}
+
+        pc_stats = RTCPeerConnectionStats.new(
+          data_channels_opened: @data_channels_opened || 0,
+          data_channels_closed: @data_channels_closed || 0
+        )
+        stats[pc_stats.id] = pc_stats
+
+        transport_stats = RTCTransportStats.new(
+          bytes_sent: 0,
+          bytes_received: 0,
+          dtls_state: sctp_transport.transport.state
+        )
+        stats[transport_stats.id] = transport_stats
+
+        RTCStatsReport.new(stats)
+      end
+    end
+
+    def create_offer(options = {})
+      raise_if_closed!
+      Promise.new do
+        sdp_ptr = ::FFI::MemoryPointer.new(:pointer)
+        error = FFI::Error.new
+        result = FFI.webrtc_peer_connection_create_offer(@ptr, sdp_ptr, error)
+        raise OperationError, error[:message] if result != 0
+
+        RTCSessionDescription.from_ptr(sdp_ptr.read_pointer)
+      end
+    end
+
+    def create_answer(options = {})
+      raise_if_closed!
+      Promise.new do
+        sdp_ptr = ::FFI::MemoryPointer.new(:pointer)
+        error = FFI::Error.new
+        result = FFI.webrtc_peer_connection_create_answer(@ptr, sdp_ptr, error)
+        raise OperationError, error[:message] if result != 0
+
+        RTCSessionDescription.from_ptr(sdp_ptr.read_pointer)
+      end
+    end
+
+    def set_local_description(description)
+      raise_if_closed!
+      Promise.new do
+        desc = normalize_description(description)
+        error = FFI::Error.new
+        result = FFI.webrtc_peer_connection_set_local_description(@ptr, desc.to_ptr, error)
+        raise OperationError, error[:message] if result != 0
+
+        @local_description = desc
+        nil
+      end
+    end
+
+    def set_remote_description(description)
+      raise_if_closed!
+      Promise.new do
+        desc = normalize_description(description)
+        error = FFI::Error.new
+        result = FFI.webrtc_peer_connection_set_remote_description(@ptr, desc.to_ptr, error)
+        raise OperationError, error[:message] if result != 0
+
+        @remote_description = desc
+        nil
+      end
+    end
+
+    def add_ice_candidate(candidate)
+      raise_if_closed!
+      Promise.new do
+        ice = normalize_ice_candidate(candidate)
+        error = FFI::Error.new
+        result = FFI.webrtc_peer_connection_add_ice_candidate(@ptr, ice.to_ptr, error)
+        raise OperationError, error[:message] if result != 0
+
+        nil
+      end
+    end
+
+    def create_data_channel(label, options = {})
+      raise_if_closed!
+
+      ordered = options.fetch(:ordered, true)
+      max_retransmits = options[:max_retransmits] || -1
+      max_packet_life_time = options[:max_packet_life_time] || -1
+      protocol = options[:protocol] || ''
+      negotiated = options.fetch(:negotiated, false)
+      id = options[:id] || -1
+
+      error = FFI::Error.new
+      dc_ptr = FFI.webrtc_peer_connection_create_data_channel(
+        @ptr,
+        label,
+        ordered,
+        max_retransmits,
+        max_packet_life_time,
+        protocol,
+        negotiated,
+        id,
+        error
+      )
+
+      raise OperationError, error[:message] if dc_ptr.nil? || dc_ptr.null?
+
+      RTCDataChannel.new(dc_ptr, options.merge(label: label))
+    end
+
+    def on_ice_candidate(&block)
+      @callbacks[:ice_candidate] = block
+      setup_ice_candidate_callback
+    end
+
+    def on_connection_state_change(&block)
+      @callbacks[:connection_state_change] = block
+      setup_connection_state_callback
+    end
+
+    def on_signaling_state_change(&block)
+      @callbacks[:signaling_state_change] = block
+    end
+
+    def on_ice_gathering_state_change(&block)
+      @callbacks[:ice_gathering_state_change] = block
+    end
+
+    def on_ice_connection_state_change(&block)
+      @callbacks[:ice_connection_state_change] = block
+    end
+
+    def on_data_channel(&block)
+      @callbacks[:data_channel] = block
+      setup_data_channel_callback
+    end
+
+    def on_negotiation_needed(&block)
+      @callbacks[:negotiation_needed] = block
+    end
+
+    def on_track(&block)
+      @callbacks[:track] = block
+    end
+
+    def add_track(track, *streams)
+      raise_if_closed!
+      raise InvalidParameterError, 'track is required' unless track
+
+      sender = RTCRtpSender.new(track: track)
+      receiver = RTCRtpReceiver.new(track: MediaStreamTrack.new(kind: track.kind))
+      transceiver = RTCRtpTransceiver.new(
+        sender: sender,
+        receiver: receiver,
+        direction: :sendrecv
+      )
+
+      @senders << sender
+      @receivers << receiver
+      @transceivers << transceiver
+
+      @callbacks[:negotiation_needed]&.call
+
+      sender
+    end
+
+    def remove_track(sender)
+      raise_if_closed!
+      return unless @senders.include?(sender)
+
+      sender.replace_track(nil)
+      @callbacks[:negotiation_needed]&.call
+    end
+
+    def get_senders
+      @senders.dup
+    end
+
+    def get_receivers
+      @receivers.dup
+    end
+
+    def get_transceivers
+      @transceivers.dup
+    end
+
+    def add_transceiver(track_or_kind, init = {})
+      raise_if_closed!
+
+      track = if track_or_kind.is_a?(MediaStreamTrack)
+                track_or_kind
+              else
+                MediaStreamTrack.new(kind: track_or_kind.to_sym)
+              end
+
+      sender = RTCRtpSender.new(track: track)
+      receiver = RTCRtpReceiver.new(track: MediaStreamTrack.new(kind: track.kind))
+      transceiver = RTCRtpTransceiver.new(
+        sender: sender,
+        receiver: receiver,
+        direction: init[:direction] || :sendrecv
+      )
+
+      @senders << sender
+      @receivers << receiver
+      @transceivers << transceiver
+
+      @callbacks[:negotiation_needed]&.call
+
+      transceiver
+    end
+
+    private
+
+    def raise_if_closed!
+      raise InvalidStateError, 'PeerConnection is closed' if closed?
+    end
+
+    def normalize_description(desc)
+      return desc if desc.is_a?(RTCSessionDescription)
+
+      RTCSessionDescription.new(desc)
+    end
+
+    def normalize_ice_candidate(candidate)
+      return candidate if candidate.is_a?(RTCIceCandidate)
+
+      RTCIceCandidate.new(candidate)
+    end
+
+    def setup_ice_candidate_callback
+      callback = proc do |candidate_str, sdp_mid, sdp_mline_index, _user_data|
+        ice = RTCIceCandidate.new(
+          candidate: candidate_str,
+          sdp_mid: sdp_mid,
+          sdp_m_line_index: sdp_mline_index
+        )
+        @callbacks[:ice_candidate]&.call(ice)
+      end
+      @callbacks[:ice_candidate_proc] = callback
+      FFI.webrtc_peer_connection_on_ice_candidate(@ptr, callback, ::FFI::Pointer::NULL)
+    end
+
+    def setup_connection_state_callback
+      callback = proc do |state, _user_data|
+        @callbacks[:connection_state_change]&.call(CONNECTION_STATES[state])
+      end
+      @callbacks[:connection_state_proc] = callback
+      FFI.webrtc_peer_connection_on_connection_state_change(@ptr, callback, ::FFI::Pointer::NULL)
+    end
+
+    def setup_data_channel_callback
+      callback = proc do |dc_ptr, _user_data|
+        @callbacks[:data_channel]&.call(dc_ptr)
+      end
+      @callbacks[:data_channel_proc] = callback
+      FFI.webrtc_peer_connection_on_data_channel(@ptr, callback, ::FFI::Pointer::NULL)
+    end
+
+    def create_native_peer_connection
+      error = FFI::Error.new
+      config = build_ffi_configuration
+
+      ptr = FFI.webrtc_peer_connection_create(config, error)
+      raise OperationError, error[:message] if error[:code] != 0
+
+      ptr
+    end
+
+    def build_ffi_configuration
+      config = FFI::Configuration.new
+      config[:ice_servers] = ::FFI::Pointer::NULL
+      config[:ice_servers_count] = 0
+      config[:ice_transport_policy] = ::FFI::Pointer::NULL
+      config[:bundle_policy] = ::FFI::Pointer::NULL
+      config
+    end
+  end
+end

data/lib/webrtc/promise.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'concurrent-ruby'
+
+module WebRTC
+  class Promise
+    def initialize(&block)
+      @future = Concurrent::Promises.future(&block)
+    end
+
+    def self.resolve(value)
+      new { value }
+    end
+
+    def self.reject(error)
+      promise = allocate
+      promise.instance_variable_set(:@future, Concurrent::Promises.rejected_future(error))
+      promise
+    end
+
+    def then(&block)
+      new_promise = Promise.allocate
+      new_promise.instance_variable_set(:@future, @future.then(&block))
+      new_promise
+    end
+
+    def catch(&block)
+      new_promise = Promise.allocate
+      new_promise.instance_variable_set(:@future, @future.rescue(&block))
+      new_promise
+    end
+
+    def finally(&block)
+      new_promise = Promise.allocate
+      new_promise.instance_variable_set(:@future, @future.on_resolution { block.call })
+      new_promise
+    end
+
+    def await(timeout = nil)
+      if timeout
+        @future.value!(timeout)
+      else
+        @future.value!
+      end
+    end
+
+    def pending?
+      @future.pending?
+    end
+
+    def fulfilled?
+      @future.fulfilled?
+    end
+
+    def rejected?
+      @future.rejected?
+    end
+  end
+end