webrtc-ruby 1.0.0

data/examples/signaling_server/server.rb

@@ -0,0 +1,200 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# WebRTC Signaling Server Example
+#
+# This is a conceptual example showing how to implement
+# a WebRTC signaling server using WebSockets.
+#
+# In a real application, you would use a WebSocket library
+# like 'faye-websocket' or 'websocket-eventmachine-server'.
+#
+# Usage:
+#   gem install faye-websocket puma
+#   ruby server.rb
+
+require 'json'
+
+# Simulated signaling server logic
+class SignalingServer
+  def initialize
+    @rooms = {}
+    @clients = {}
+  end
+
+  # Handle incoming WebSocket message
+  def handle_message(client_id, message)
+    data = JSON.parse(message)
+    room_id = data['room']
+
+    case data['type']
+    when 'join'
+      join_room(client_id, room_id)
+
+    when 'offer'
+      # Forward offer to other peer in room
+      forward_to_peer(client_id, room_id, {
+                        type: 'offer',
+                        sdp: data['sdp']
+                      })
+
+    when 'answer'
+      # Forward answer to other peer in room
+      forward_to_peer(client_id, room_id, {
+                        type: 'answer',
+                        sdp: data['sdp']
+                      })
+
+    when 'ice-candidate'
+      # Forward ICE candidate to other peer
+      forward_to_peer(client_id, room_id, {
+                        type: 'ice-candidate',
+                        candidate: data['candidate'],
+                        sdpMid: data['sdpMid'],
+                        sdpMLineIndex: data['sdpMLineIndex']
+                      })
+
+    when 'leave'
+      leave_room(client_id, room_id)
+    end
+  end
+
+  private
+
+  def join_room(client_id, room_id)
+    @rooms[room_id] ||= []
+    @rooms[room_id] << client_id
+    @clients[client_id] = room_id
+
+    # Notify if room has 2 peers (ready to connect)
+    return unless @rooms[room_id].size == 2
+
+    # Tell the first peer to create an offer
+    first_peer = @rooms[room_id].first
+    send_to_client(first_peer, { type: 'ready' })
+  end
+
+  def leave_room(client_id, room_id)
+    @rooms[room_id]&.delete(client_id)
+    @clients.delete(client_id)
+
+    # Notify remaining peer
+    @rooms[room_id]&.each do |peer_id|
+      send_to_client(peer_id, { type: 'peer-left' })
+    end
+  end
+
+  def forward_to_peer(from_client_id, room_id, message)
+    @rooms[room_id]&.each do |peer_id|
+      next if peer_id == from_client_id
+
+      send_to_client(peer_id, message)
+    end
+  end
+
+  def send_to_client(client_id, message)
+    # In a real implementation, this would send via WebSocket
+    puts "Sending to #{client_id}: #{message.to_json}"
+  end
+end
+
+# Example client-side pseudocode (would run in browser or Ruby client):
+#
+# class WebRTCClient
+#   def initialize(signaling_url, room_id)
+#     @room_id = room_id
+#     @pc = WebRTC::RTCPeerConnection.new
+#
+#     # Connect to signaling server
+#     @ws = WebSocket.new(signaling_url)
+#
+#     # Set up ICE candidate handling
+#     @pc.on_ice_candidate do |candidate|
+#       @ws.send({
+#         type: 'ice-candidate',
+#         room: @room_id,
+#         candidate: candidate.candidate,
+#         sdpMid: candidate.sdp_mid,
+#         sdpMLineIndex: candidate.sdp_m_line_index
+#       }.to_json)
+#     end
+#
+#     # Handle signaling messages
+#     @ws.on_message do |msg|
+#       data = JSON.parse(msg)
+#       handle_signaling(data)
+#     end
+#   end
+#
+#   def join
+#     @ws.send({ type: 'join', room: @room_id }.to_json)
+#   end
+#
+#   def handle_signaling(data)
+#     case data['type']
+#     when 'ready'
+#       # We're the initiator, create offer
+#       create_and_send_offer
+#
+#     when 'offer'
+#       # Received offer, create answer
+#       @pc.set_remote_description(type: :offer, sdp: data['sdp']).await
+#       answer = @pc.create_answer.await
+#       @pc.set_local_description(answer).await
+#
+#       @ws.send({
+#         type: 'answer',
+#         room: @room_id,
+#         sdp: answer.sdp
+#       }.to_json)
+#
+#     when 'answer'
+#       @pc.set_remote_description(type: :answer, sdp: data['sdp']).await
+#
+#     when 'ice-candidate'
+#       candidate = WebRTC::RTCIceCandidate.new(
+#         candidate: data['candidate'],
+#         sdp_mid: data['sdpMid'],
+#         sdp_m_line_index: data['sdpMLineIndex']
+#       )
+#       @pc.add_ice_candidate(candidate).await
+#     end
+#   end
+#
+#   def create_and_send_offer
+#     offer = @pc.create_offer.await
+#     @pc.set_local_description(offer).await
+#
+#     @ws.send({
+#       type: 'offer',
+#       room: @room_id,
+#       sdp: offer.sdp
+#     }.to_json)
+#   end
+# end
+
+if __FILE__ == $0
+  puts 'WebRTC Signaling Server Example'
+  puts '================================'
+  puts
+  puts 'This is a conceptual example showing signaling server logic.'
+  puts 'In production, use with faye-websocket or similar WebSocket library.'
+  puts
+  puts 'Example signaling flow:'
+  puts "1. Client A joins room 'test'"
+  puts "2. Client B joins room 'test'"
+  puts '3. Server tells Client A to create offer'
+  puts '4. Client A sends offer to server'
+  puts '5. Server forwards offer to Client B'
+  puts '6. Client B creates and sends answer'
+  puts '7. Server forwards answer to Client A'
+  puts '8. Both clients exchange ICE candidates via server'
+  puts '9. P2P connection established!'
+
+  # Demo
+  server = SignalingServer.new
+  server.handle_message('client_a', '{"type":"join","room":"test"}')
+  server.handle_message('client_b', '{"type":"join","room":"test"}')
+  server.handle_message('client_a', '{"type":"offer","room":"test","sdp":"v=0..."}')
+  server.handle_message('client_b', '{"type":"answer","room":"test","sdp":"v=0..."}')
+end

data/examples/simple_data_channel.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Simple Data Channel Example
+# This example demonstrates creating a data channel between two peers
+# using the real libdatachannel WebRTC implementation.
+
+require_relative '../lib/webrtc'
+
+puts '=== WebRTC Ruby DataChannel Example ==='
+puts
+
+WebRTC.init
+
+pc1 = WebRTC::RTCPeerConnection.new
+pc2 = WebRTC::RTCPeerConnection.new
+
+# Track ICE candidates for exchange after remote descriptions are set
+pc1_candidates = []
+pc2_candidates = []
+
+pc1.on_ice_candidate do |candidate|
+  pc1_candidates << candidate if candidate
+end
+
+pc2.on_ice_candidate do |candidate|
+  pc2_candidates << candidate if candidate
+end
+
+pc2.on_data_channel do |dc|
+  puts "PC2: Received data channel: #{dc.label}"
+end
+
+# Create data channel on PC1
+dc1 = pc1.create_data_channel('chat')
+puts "Created data channel: #{dc1.label}"
+
+dc1.on_open do
+  puts 'DataChannel opened!'
+end
+
+dc1.on_message do |event|
+  puts "Received: #{event.data}"
+end
+
+# Step 1: PC1 creates offer
+offer = pc1.create_offer.await
+puts 'Created offer'
+puts "  SDP length: #{offer.sdp.length} bytes"
+
+# Step 2: PC1 sets local description
+pc1.set_local_description(offer).await
+puts 'PC1: Set local description'
+
+# Step 3: PC2 sets remote description (the offer)
+pc2.set_remote_description(offer).await
+puts 'PC2: Set remote description'
+
+# Step 4: Now exchange ICE candidates (after remote descriptions are set)
+puts 'Exchanging ICE candidates...'
+pc1_candidates.each do |candidate|
+  pc2.add_ice_candidate(candidate).await
+rescue StandardError
+  nil
+end
+puts "  Sent #{pc1_candidates.size} candidates from PC1 to PC2"
+
+# NOTE: In a real application, you would wait for the connection to be established
+# before sending data. For this demo, we just show the setup.
+
+puts "\nSignaling complete!"
+puts "DataChannel state: #{dc1.ready_state}"
+puts '  (Channel will open when connection is established)'
+
+# Cleanup
+dc1.destroy
+pc1.close
+pc2.close
+
+WebRTC.cleanup
+puts "\nDone!"

data/examples/video_call.rb

@@ -0,0 +1,152 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# WebRTC Connection Example
+# This example demonstrates a WebRTC connection between two peers
+# with data channel and DTMF support simulation.
+
+require_relative '../lib/webrtc'
+
+puts '=== WebRTC Ruby Connection Example ==='
+puts
+
+# Initialize WebRTC
+WebRTC.init
+
+# Create two peer connections (simulating caller and callee)
+caller_config = {
+  ice_servers: [
+    { urls: 'stun:stun.l.google.com:19302' }
+  ]
+}
+
+caller_pc = WebRTC::RTCPeerConnection.new(caller_config)
+callee_pc = WebRTC::RTCPeerConnection.new(caller_config)
+
+puts 'Created peer connections'
+
+# Set up ICE candidate exchange
+caller_ice_candidates = []
+callee_ice_candidates = []
+
+caller_pc.on_ice_candidate do |candidate|
+  caller_ice_candidates << candidate if candidate
+end
+
+callee_pc.on_ice_candidate do |candidate|
+  callee_ice_candidates << candidate if candidate
+end
+
+# Monitor connection states
+caller_pc.on_connection_state_change do |state|
+  puts "Caller connection state: #{state}"
+end
+
+callee_pc.on_connection_state_change do |state|
+  puts "Callee connection state: #{state}"
+end
+
+# Create data channel for signaling/messaging
+puts "\nCreating data channel..."
+data_channel = caller_pc.create_data_channel('messaging', ordered: true)
+puts "  Data channel created: #{data_channel.label}"
+
+data_channel.on_open do
+  puts '  Data channel opened!'
+end
+
+data_channel.on_message do |event|
+  puts "  Received message: #{event.data}"
+end
+
+# Set up callee to receive data channels
+callee_pc.on_data_channel do |dc|
+  puts "Callee received data channel: #{dc.label}"
+  dc.on_message do |event|
+    puts "Callee received: #{event.data}"
+  end
+end
+
+# Perform signaling
+puts "\n=== Signaling Exchange ==="
+
+# 1. Caller creates offer
+puts "\n1. Caller creates offer..."
+offer = caller_pc.create_offer.await
+puts "   Offer type: #{offer.type}"
+puts "   SDP length: #{offer.sdp.length} bytes"
+
+# 2. Caller sets local description
+puts "\n2. Caller sets local description..."
+caller_pc.set_local_description(offer).await
+puts '   Local description set'
+
+# 3. Callee receives and sets remote description
+puts "\n3. Callee sets remote description..."
+callee_pc.set_remote_description(offer).await
+puts '   Remote description set'
+
+# 4. Exchange ICE candidates
+puts "\n4. Exchanging ICE candidates..."
+caller_ice_candidates.each do |candidate|
+  callee_pc.add_ice_candidate(candidate).await
+rescue StandardError
+  nil
+end
+puts "   Sent #{caller_ice_candidates.size} candidates from caller to callee"
+
+callee_ice_candidates.each do |candidate|
+  caller_pc.add_ice_candidate(candidate).await
+rescue StandardError
+  nil
+end
+puts "   Sent #{callee_ice_candidates.size} candidates from callee to caller"
+
+# Check status
+puts "\n=== Connection Status ==="
+puts "Caller signaling state: #{caller_pc.signaling_state}"
+puts "Callee signaling state: #{callee_pc.signaling_state}"
+puts "Data channel state: #{data_channel.ready_state}"
+
+# Simulate DTMF (audio track simulation)
+puts "\n=== DTMF Simulation ==="
+audio_track = WebRTC::MediaStreamTrack.new(kind: :audio, label: 'virtual-audio')
+sender = WebRTC::RTCRtpSender.new(track: audio_track)
+
+if sender.dtmf
+  dtmf = sender.dtmf
+  puts "DTMF available: #{dtmf.can_insert_dtmf?}"
+
+  if dtmf.can_insert_dtmf?
+    dtmf.on_tone_change do |event|
+      puts "  Playing tone: #{event.tone}"
+    end
+
+    puts 'Sending DTMF tones: 123#'
+    dtmf.insert_dtmf('123#', duration: 100, inter_tone_gap: 70)
+  end
+end
+
+# Get statistics
+puts "\n=== Connection Statistics ==="
+stats = caller_pc.get_stats.await
+puts "Stats entries: #{stats.size}"
+stats.each do |id, stat|
+  case stat
+  when WebRTC::RTCPeerConnectionStats
+    puts '  PeerConnection Stats:'
+    puts "    Data channels opened: #{stat.data_channels_opened}"
+  when WebRTC::RTCTransportStats
+    puts '  Transport Stats:'
+    puts "    Bytes sent: #{stat.bytes_sent}"
+  end
+end
+
+# Cleanup
+puts "\n=== Cleanup ==="
+data_channel.destroy
+caller_pc.close
+callee_pc.close
+WebRTC.cleanup
+
+puts "\nExample completed!"

data/ext/webrtc_ruby/CMakeLists.txt

@@ -0,0 +1,84 @@
+cmake_minimum_required(VERSION 3.14)
+project(webrtc_ruby C)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+set(CMAKE_C_FLAGS_DEBUG "-g -O0")
+set(CMAKE_C_FLAGS_RELEASE "-O3")
+
+add_compile_definitions(WEBRTC_RUBY_BUILDING)
+
+if(APPLE)
+  set(CMAKE_C_VISIBILITY_PRESET hidden)
+endif()
+
+# Find libdatachannel
+set(LIBDATACHANNEL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../vendor/libdatachannel")
+
+if(EXISTS "${LIBDATACHANNEL_DIR}/build/libdatachannel.dylib" OR
+   EXISTS "${LIBDATACHANNEL_DIR}/build/libdatachannel.so")
+  message(STATUS "Found libdatachannel in vendor directory")
+  set(DATACHANNEL_INCLUDE_DIR "${LIBDATACHANNEL_DIR}/include")
+  set(DATACHANNEL_LIBRARY_DIR "${LIBDATACHANNEL_DIR}/build")
+
+  if(APPLE)
+    set(DATACHANNEL_LIBRARY "${DATACHANNEL_LIBRARY_DIR}/libdatachannel.dylib")
+  else()
+    set(DATACHANNEL_LIBRARY "${DATACHANNEL_LIBRARY_DIR}/libdatachannel.so")
+  endif()
+else()
+  # Try pkg-config
+  find_package(PkgConfig QUIET)
+  if(PkgConfig_FOUND)
+    pkg_check_modules(DATACHANNEL libdatachannel)
+  endif()
+
+  if(NOT DATACHANNEL_FOUND)
+    message(FATAL_ERROR "libdatachannel not found. Build it first.")
+  endif()
+endif()
+
+add_library(webrtc_ruby SHARED
+  webrtc_ruby.c
+)
+
+target_include_directories(webrtc_ruby PUBLIC
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  ${DATACHANNEL_INCLUDE_DIR}
+)
+
+target_link_directories(webrtc_ruby PRIVATE
+  ${DATACHANNEL_LIBRARY_DIR}
+)
+
+target_link_libraries(webrtc_ruby PRIVATE
+  ${DATACHANNEL_LIBRARY}
+)
+
+if(APPLE)
+  set_target_properties(webrtc_ruby PROPERTIES
+    SUFFIX ".dylib"
+    INSTALL_RPATH "@loader_path"
+    BUILD_WITH_INSTALL_RPATH TRUE
+  )
+elseif(WIN32)
+  set_target_properties(webrtc_ruby PROPERTIES
+    SUFFIX ".dll"
+  )
+else()
+  set_target_properties(webrtc_ruby PROPERTIES
+    SUFFIX ".so"
+    INSTALL_RPATH "$ORIGIN"
+    BUILD_WITH_INSTALL_RPATH TRUE
+  )
+endif()
+
+install(TARGETS webrtc_ruby
+  LIBRARY DESTINATION lib
+  RUNTIME DESTINATION bin
+)

data/ext/webrtc_ruby/Makefile

@@ -0,0 +1,31 @@
+CC = cc
+CFLAGS = -Wall -Wextra -fPIC -O2 -DWEBRTC_RUBY_BUILDING
+LDFLAGS = -shared
+
+UNAME_S := $(shell uname -s)
+ifeq ($(UNAME_S),Darwin)
+	TARGET = libwebrtc_ruby.dylib
+	LDFLAGS += -dynamiclib -install_name @rpath/$(TARGET)
+else ifeq ($(OS),Windows_NT)
+	TARGET = webrtc_ruby.dll
+else
+	TARGET = libwebrtc_ruby.so
+endif
+
+SOURCES = webrtc_ruby.c
+OBJECTS = $(SOURCES:.c=.o)
+
+BUILD_DIR = build
+
+all: $(BUILD_DIR)/$(TARGET)
+
+$(BUILD_DIR):
+	mkdir -p $(BUILD_DIR)
+
+$(BUILD_DIR)/$(TARGET): $(SOURCES) | $(BUILD_DIR)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(SOURCES)
+
+clean:
+	rm -rf $(BUILD_DIR)
+
+.PHONY: all clean