webrtc-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 67e8d8f0e59e83bb3a7d49ec981fbb179f4a417e827c9cc2109ab0e204aa20de
+  data.tar.gz: f726ca624518f56a58cf7846e9eb36c7030d13c9f6052fd681165585279f66de
+SHA512:
+  metadata.gz: 2505178e6228f9c0fe66d854355a61601d3fa225c1ee3c4618dc2fa74abccd750f666e581430cda79a310182550271dcfb7a1591093d70cc55bd4708390990c0
+  data.tar.gz: ec7bfeeb58a2a1371cffcce47c45063f518e727f251759fdaf775a76f05258508fed7c4eb6ae1438aa1722e261b0ce648a78fc863a6cc44d7bef6558e1a1bb02

data/.dockerignore

@@ -0,0 +1,19 @@
+# Build directories
+ext/webrtc_ruby/build/
+vendor/libdatachannel/
+
+# Git
+.git/
+
+# Ruby
+*.gem
+.bundle/
+tmp/
+coverage/
+
+# IDE
+.vscode/
+.idea/
+
+# Logs
+*.log

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--format documentation
+--color

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## Unreleased
+
+## 0.1.0 - 2025-12-31
+
+- Initial release

data/Dockerfile

@@ -0,0 +1,49 @@
+FROM ruby:3.3-slim
+
+# Install build dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    cmake \
+    git \
+    libssl-dev \
+    pkg-config \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy gemfiles first for better caching
+COPY Gemfile Gemfile.lock* webrtc-ruby.gemspec ./
+COPY lib/webrtc/version.rb ./lib/webrtc/
+
+# Install Ruby dependencies
+RUN bundle install
+
+# Clone and build libdatachannel
+RUN git clone --depth 1 --recurse-submodules https://github.com/paullouisageneau/libdatachannel.git /tmp/libdatachannel \
+    && cd /tmp/libdatachannel \
+    && mkdir build && cd build \
+    && cmake -DUSE_GNUTLS=0 -DUSE_NICE=0 -DNO_WEBSOCKET=1 -DNO_EXAMPLES=1 -DNO_TESTS=1 -DCMAKE_BUILD_TYPE=Release .. \
+    && make -j$(nproc) \
+    && mkdir -p /app/vendor/libdatachannel/build \
+    && mkdir -p /app/vendor/libdatachannel/include \
+    && cp -r /tmp/libdatachannel/include/* /app/vendor/libdatachannel/include/ \
+    && cp /tmp/libdatachannel/build/libdatachannel.so* /app/vendor/libdatachannel/build/ \
+    && rm -rf /tmp/libdatachannel
+
+# Copy extension source
+COPY ext/ ./ext/
+
+# Build webrtc_ruby extension
+RUN cd ext/webrtc_ruby \
+    && mkdir -p build && cd build \
+    && cmake .. \
+    && make -j$(nproc)
+
+# Copy the rest of the application
+COPY . .
+
+# Set library path
+ENV LD_LIBRARY_PATH=/app/ext/webrtc_ruby/build:/app/vendor/libdatachannel/build
+
+# Run tests by default
+CMD ["bundle", "exec", "rspec", "--format", "documentation"]

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,257 @@
+# WebRTC Ruby
+
+WebRTC bindings for Ruby, providing real-time audio, video, and data channel capabilities.
+
+## Features
+
+- Full WebRTC API following W3C specifications
+- Peer-to-peer connections with ICE/STUN/TURN support
+- Data channels for bidirectional data transfer
+- Media stream and track handling
+- DTMF tone sending
+- Connection statistics
+
+## Requirements
+
+- Ruby 3.1+
+- CMake
+- OpenSSL development libraries
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'webrtc-ruby'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+### Building Native Extension
+
+The gem requires building a native extension that wraps [libdatachannel](https://github.com/paullouisageneau/libdatachannel).
+
+#### macOS
+
+```bash
+brew install cmake openssl
+
+# Clone and build libdatachannel
+git clone --depth 1 --recurse-submodules https://github.com/paullouisageneau/libdatachannel.git vendor/libdatachannel
+cd vendor/libdatachannel
+mkdir build && cd build
+cmake -DUSE_GNUTLS=0 -DUSE_NICE=0 -DNO_WEBSOCKET=1 -DNO_EXAMPLES=1 -DNO_TESTS=1 ..
+make -j$(sysctl -n hw.ncpu)
+cd ../../..
+
+# Build the extension
+cd ext/webrtc_ruby
+mkdir build && cd build
+cmake ..
+make
+```
+
+#### Linux (Ubuntu/Debian)
+
+```bash
+sudo apt install build-essential cmake git libssl-dev pkg-config
+
+# Clone and build libdatachannel
+git clone --depth 1 --recurse-submodules https://github.com/paullouisageneau/libdatachannel.git vendor/libdatachannel
+cd vendor/libdatachannel
+mkdir build && cd build
+cmake -DUSE_GNUTLS=0 -DUSE_NICE=0 -DNO_WEBSOCKET=1 -DNO_EXAMPLES=1 -DNO_TESTS=1 ..
+make -j$(nproc)
+cd ../../..
+
+# Build the extension
+cd ext/webrtc_ruby
+mkdir build && cd build
+cmake ..
+make
+```
+
+#### Docker
+
+You can also use Docker to build and test:
+
+```bash
+docker build -t webrtc-ruby .
+docker run --rm webrtc-ruby
+```
+
+## Usage
+
+### Basic Data Channel Example
+
+```ruby
+require 'webrtc'
+
+# Initialize WebRTC
+WebRTC.init
+
+# Create peer connections
+pc1 = WebRTC::RTCPeerConnection.new
+pc2 = WebRTC::RTCPeerConnection.new
+
+# Collect ICE candidates
+pc1_candidates = []
+pc2_candidates = []
+
+pc1.on_ice_candidate { |candidate| pc1_candidates << candidate if candidate }
+pc2.on_ice_candidate { |candidate| pc2_candidates << candidate if candidate }
+
+# Handle incoming data channel on pc2
+pc2.on_data_channel do |dc|
+  puts "Received data channel: #{dc.label}"
+  dc.on_message { |event| puts "Received: #{event.data}" }
+end
+
+# Create data channel on pc1
+dc1 = pc1.create_data_channel('chat')
+dc1.on_open { puts "Data channel opened!" }
+dc1.on_message { |event| puts "Received: #{event.data}" }
+
+# Signaling: Create and exchange offer/answer
+offer = pc1.create_offer.await
+pc1.set_local_description(offer).await
+pc2.set_remote_description(offer).await
+
+answer = pc2.create_answer.await
+pc2.set_local_description(answer).await
+pc1.set_remote_description(answer).await
+
+# Exchange ICE candidates
+pc1_candidates.each { |c| pc2.add_ice_candidate(c).await rescue nil }
+pc2_candidates.each { |c| pc1.add_ice_candidate(c).await rescue nil }
+
+# Cleanup
+dc1.destroy
+pc1.close
+pc2.close
+WebRTC.cleanup
+```
+
+### Configuration with ICE Servers
+
+```ruby
+config = {
+  ice_servers: [
+    { urls: 'stun:stun.l.google.com:19302' },
+    { urls: 'turn:turn.example.com', username: 'user', credential: 'pass' }
+  ]
+}
+
+pc = WebRTC::RTCPeerConnection.new(config)
+```
+
+### Data Channel Options
+
+```ruby
+# Ordered, reliable channel (default)
+dc = pc.create_data_channel('reliable')
+
+# Unordered channel with max retransmits
+dc = pc.create_data_channel('unreliable', ordered: false, max_retransmits: 3)
+
+# Channel with max packet lifetime
+dc = pc.create_data_channel('timed', max_packet_life_time: 3000)
+```
+
+### Connection State Monitoring
+
+```ruby
+pc.on_connection_state_change do |state|
+  puts "Connection state: #{state}"  # :new, :connecting, :connected, :disconnected, :failed, :closed
+end
+
+pc.on_ice_gathering_state_change do |state|
+  puts "ICE gathering: #{state}"  # :new, :gathering, :complete
+end
+
+pc.on_ice_connection_state_change do |state|
+  puts "ICE connection: #{state}"  # :new, :checking, :connected, :completed, :failed, :disconnected, :closed
+end
+```
+
+### Getting Statistics
+
+```ruby
+stats = pc.get_stats.await
+
+stats.each do |id, stat|
+  case stat
+  when WebRTC::RTCPeerConnectionStats
+    puts "Data channels opened: #{stat.data_channels_opened}"
+  when WebRTC::RTCTransportStats
+    puts "Bytes sent: #{stat.bytes_sent}"
+  end
+end
+```
+
+## API Reference
+
+### Core Classes
+
+- `WebRTC::RTCPeerConnection` - Main peer connection class
+- `WebRTC::RTCSessionDescription` - SDP session description
+- `WebRTC::RTCIceCandidate` - ICE candidate
+- `WebRTC::RTCDataChannel` - Data channel for sending/receiving data
+
+### Media Classes
+
+- `WebRTC::MediaStream` - Collection of media tracks
+- `WebRTC::MediaStreamTrack` - Individual audio or video track
+- `WebRTC::RTCRtpSender` - Sends media to remote peer
+- `WebRTC::RTCRtpReceiver` - Receives media from remote peer
+- `WebRTC::RTCRtpTransceiver` - Combines sender and receiver
+
+### Transport Classes
+
+- `WebRTC::RTCDtlsTransport` - DTLS transport layer
+- `WebRTC::RTCIceTransport` - ICE transport layer
+- `WebRTC::RTCSctpTransport` - SCTP transport for data channels
+
+### Other Classes
+
+- `WebRTC::RTCDTMFSender` - Send DTMF tones
+- `WebRTC::RTCStatsReport` - Connection statistics
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies.
+
+### Running Tests
+
+```bash
+# Build the native extension first
+cd ext/webrtc_ruby/build && cmake .. && make && cd ../../..
+
+# Run tests
+DYLD_LIBRARY_PATH="ext/webrtc_ruby/build:vendor/libdatachannel/build" bundle exec rspec
+```
+
+### Running Examples
+
+```bash
+DYLD_LIBRARY_PATH="ext/webrtc_ruby/build:vendor/libdatachannel/build" bundle exec ruby examples/simple_data_channel.rb
+```
+
+## Acknowledgments
+
+This project is built on top of:
+
+- [libdatachannel](https://github.com/paullouisageneau/libdatachannel) - C/C++ WebRTC network library by Paul-Louis Ageneau
+- [Ruby FFI](https://github.com/ffi/ffi) - Foreign Function Interface for Ruby
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ydah/webrtc-ruby.

data/Rakefile

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :native do
+  desc 'Build native library'
+  task :build do
+    ext_dir = File.join(__dir__, 'ext', 'webrtc_ruby')
+    build_dir = File.join(ext_dir, 'build')
+
+    Dir.mkdir(build_dir) unless Dir.exist?(build_dir)
+
+    case RbConfig::CONFIG['host_os']
+    when /darwin/
+      lib_name = 'libwebrtc_ruby.dylib'
+      flags = '-dynamiclib'
+    when /mswin|mingw/
+      lib_name = 'webrtc_ruby.dll'
+      flags = '-shared'
+    else
+      lib_name = 'libwebrtc_ruby.so'
+      flags = '-shared'
+    end
+
+    cmd = "cc -Wall -Wextra -fPIC -O2 -DWEBRTC_RUBY_BUILDING #{flags} " \
+          "-o #{File.join(build_dir, lib_name)} " \
+          "#{File.join(ext_dir, 'webrtc_ruby.c')}"
+
+    system(cmd) || abort('Native build failed')
+  end
+
+  desc 'Clean native build'
+  task :clean do
+    build_dir = File.join(__dir__, 'ext', 'webrtc_ruby', 'build')
+    FileUtils.rm_rf(build_dir)
+  end
+end
+
+task default: %i[native:build spec]

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!"