p2p_streams_channel 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8bda1bfc27255440985ebe30c675e2177ca08bf446b75d6ae9a7cfa5c619c59
-  data.tar.gz: 4fd9269cf47645dff407538bb4a817c490623bed92b63f3a691c71c1ea8159c1
+  metadata.gz: 133464f081bff5e3415e6129f9ca134a3c09658647aa159ef0327b48670e9efc
+  data.tar.gz: 5b4cd920727bf06e0a64d6a999bd4e4e49ef7b4db19019972adba44c50800792
 SHA512:
-  metadata.gz: 7df5626c1517a3a18a8d495a2ac2d22bdbd1e7fe3c3f04a87b0ff02eed8b33c9c9c3a3f683b14c86ad157960ce2bb8f058fdd841c6ece438115bc6c098f01020
-  data.tar.gz: '082a674eb465701535db76a9d4772658f4bef2dc7b7246e2628ad1afd7af55731259c9041b0e58c9b13840b6f823cd07a4037f9ffa9b85c785285d3b78eaad29'
+  metadata.gz: d0a29b91e5f9f76c1c3da318242bf79e9b36f36e6ff058d196858382be308684719782a8d69c008af0408c1048e08b9c9d5ec8e72d64a090b254faae8d0486cd
+  data.tar.gz: 72b6b4c8d91d4a6e0a01411018e7363a4c6ae1a0347dca41918d0320ba18666f86bd2982fa01037a963af0e24256f56fed5f491b6de4a6fe8b2bb3fa25b604bf

data/README.md

@@ -48,7 +48,8 @@ iceServers --ice-candidate----> client-user --> host-user
 Connected
 =========
 
-After client-user connected to the host-user, all of them will disconnected to the signaling server (in order to save memory and other things), only the host-user keep connect to Rails server.
+After a client-user connected to the host-user, it'll be disconnected to the signaling server (in order to save memory).
+Only the host-user keep connect to Rails server.
 In case you want keep client connection, you could set params `keepCableConnection: true` to the p2p-frame.
 
 client-user1 ----X disconnect from -----> Rails server Action cable
@@ -89,12 +90,6 @@ $ rails g p2p_streams_channel:install
 
 ## Usage
 
-Create a Stimulus P2pController in which you will receive other p2p-connections status, data send by other connected connections, and send your data to others.
-```ruby
-$ rails g p2p_streams_channel:controller chat
-# it will create js file `app/javascript/controllers/chat_controller.js`
-```
-
 Render a p2p-frame-tag
 ```ruby
 # views/chat_rooms/_chat_room.html.erb
@@ -118,10 +113,11 @@ Render a p2p-frame-tag
 <% end %>
 ```
 
-
-Now you could implement your client side, 
-for example: here is a simple chat controller:
-
+Create a Stimulus P2pController in which you will receive other p2p-connections status, data and send back your data to others.
+```ruby
+$ rails g p2p_streams_channel:controller chat
+# it will create js file `app/javascript/controllers/chat_controller.js`
+```
 
 ```js
 // app/javascript/controllers/chat_controller.js
@@ -199,9 +195,6 @@ export default class extends P2pController {
 
 run test:
 ```ruby
-$ cd spec/dummy
-$ rails g p2p_streams_channel:install
-$ cd ../..
 $ rake spec
 ```
 

data/lib/p2p_streams_channel/engine.rb

@@ -3,12 +3,6 @@
 module P2pStreamsChannel
     class Engine < ::Rails::Engine
         config.autoload_once_paths = %W( #{root}/app/channels )
-        
-        initializer "p2p_streams_channel.assets" do
-            if Rails.application.config.respond_to?(:assets)
-              Rails.application.config.assets.precompile += Dir["#{root}/app/assets/javascripts/*/*"]
-            end
-        end
 
         config.autoload_once_paths = %W( #{root}/app/helpers )
         initializer "p2p_streams_channel.helpers" do

data/lib/p2p_streams_channel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module P2pStreamsChannel
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/rails/generators/p2p_streams_channel/install_generator.rb

@@ -5,16 +5,22 @@ module P2pStreamsChannel
   class InstallGenerator < ::Rails::Generators::Base
     source_root File.expand_path("../templates", __FILE__)
     
+    def copy_p2p
+      empty_directory "vendor/javascript/p2p"
+      directory "p2p", "vendor/javascript/p2p"
+    end
+
     def importmap
       return unless (importmap_path = Rails.root.join("config/importmap.rb")).exist?
       
-      append_to_file importmap_path, %(\npin_all_from "#{File.expand_path("../../../../app/assets/javascripts/p2p/", __dir__)}", under: "p2p"\n)
+      append_to_file importmap_path, %(\npin_all_from "vendor/javascript/p2p", under: "p2p"\n)
+      append_to_file Rails.root.join("app/assets/config/manifest.js"), %(\n//= link_tree ../../../vendor/javascript .js\n)
     end
 
     def node
       return unless Rails.root.join("package.json").exist?
 
-      run "yarn add p2p@file:#{File.expand_path("../../../../app/assets/javascripts/p2p/", __dir__)}"
+      run "yarn add p2p@file:vendor/javascript/p2p"
     end
 
     def create_initializer

data/p2p_streams_channel.gemspec

@@ -7,8 +7,8 @@ Gem::Specification.new do |spec|
   spec.authors = ["theforestvn88"]
   spec.email = ["theforestvn88@gmail.com"]
 
-  spec.summary = "rails p2p turbo streams channel"
-  spec.description = "rails p2p turbo streams channel"
+  spec.summary = "Allow to setup one-to-many P2P stream connections (WebRTC) between clients through Rails server (ActionCable) as the signaling server"
+  spec.description = "Allow to setup one-to-many P2P stream connections (WebRTC) between clients through Rails server (ActionCable) as the signaling server"
   spec.homepage = "https://github.com/theforestvn88/p2p_streams_channel"
   spec.required_ruby_version = ">= 2.6.0"
 

data/spec/dummy/config/importmap.rb

@@ -5,3 +5,5 @@ pin "@hotwired/turbo-rails", to: "turbo.min.js", preload: true
 pin "@hotwired/stimulus", to: "stimulus.min.js"
 pin "@hotwired/stimulus-loading", to: "stimulus-loading.js"
 pin_all_from "app/javascript/controllers", under: "controllers"
+
+pin_all_from "vendor/javascript/p2p", under: "p2p"

data/spec/dummy/vendor/javascript/p2p/index.js

@@ -0,0 +1,6 @@
+import "p2p/p2p_frame"
+import P2pController from "p2p/p2p_controller"
+
+export { 
+    P2pController
+}

data/spec/dummy/vendor/javascript/p2p/message.js

@@ -0,0 +1,22 @@
+export const ConnectionState = {
+    SessionJoin: "SessionJoin",
+    SessionReady: "SessionReady",
+    SdpOffer: "SdpOffer",
+    SdpAnswer: "SdpAnswer",
+    IceCandidate: "IceCandidate",
+    Error: "Error",
+    New: "new",
+    Negotiating: "negotiating",
+    Connecting: "connecting",
+    Connected: "connected",
+    DisConnected: "disconnected",
+    Closed: "closed",
+    Failed: "failed",
+}
+
+export const MessageType = {
+    Connection: "Connection",
+    Heartbeat: "Heartbeat",
+    Data: "Data",
+    DataConnectionState: "Data.Connection.State",
+}

data/spec/dummy/vendor/javascript/p2p/p2p_connection.js

@@ -0,0 +1,133 @@
+import { ConnectionState, MessageType } from "p2p/message"
+
+const ICE_CONFIG = {
+    iceServers: [
+		{ 
+            urls: ["stun:stun.l.google.com:19302", "stun:stun1.l.google.com:19302", "stun:stun2.l.google.com:19302"]
+        },
+	],
+}
+
+export default class P2pConnection {
+    constructor(peer, clientId, hostId, iamHost, iceConfig, heartbeatConfig) { // TODO: add heartbeatInterval to config
+        this.peer = peer
+        this.clientId = clientId
+        this.hostId = hostId
+        this.iamHost = iamHost
+        this.state = ConnectionState.New
+        this.lastTimeUpdate = 0
+        this.iceConfig = iceConfig || ICE_CONFIG
+        this.heartbeatConfig = heartbeatConfig
+    }
+
+    setupRTCPeerConnection() {
+        // console.log("connection start ...")
+        this.rtcPeerConnection = new RTCPeerConnection(this.iceConfig)
+
+        this.rtcPeerConnection.onicecandidate = event => {
+            // console.log(event)
+            if (event.candidate) {
+                let ice = {}
+                ice[ConnectionState.IceCandidate] = event.candidate
+                this.peer.signal(ConnectionState.IceCandidate, ice)
+            }
+        }
+        this.rtcPeerConnection.oniceconnectionstatechange = event => {
+            // console.log(event)
+        }
+
+        this.rtcPeerConnection.onconnectionstatechange = (ev) => {
+            // console.log(`onconnectionstatechange ${this.rtcPeerConnection.connectionState}`)
+            this.state = this.rtcPeerConnection.connectionState
+            if (this.state == ConnectionState.DisConnected || this.state == ConnectionState.Closed) {
+                this.close()
+            }
+            this.peer.updateP2pConnectionState(this)
+          }
+        
+        this.sendDataChannel = this.rtcPeerConnection.createDataChannel("sendChannel")
+        this.sendDataChannelOpen = false
+        this.sendDataChannel.onopen = this.handleSendChannelStatusChange.bind(this)
+        this.sendDataChannel.onclose = this.handleSendChannelStatusChange.bind(this)
+
+        this.rtcPeerConnection.ondatachannel = event => {
+            // console.log("ondatachannel p2p ...")
+            this.receiveDataChannel = event.channel
+            this.receiveDataChannel.onmessage = this.receiveP2pMessage.bind(this)
+            this.receiveDataChannel.onopen = this.handleReceiveChannelStatusChange.bind(this)
+            this.receiveDataChannel.onclose = this.handleReceiveChannelStatusChange.bind(this)
+            
+            this.peer.updateP2pConnectionState(this)
+        }
+
+        return this.rtcPeerConnection
+    }
+
+    receiveP2pMessage(event) {
+        // console.log(`p2p received msg: ${event.data}`)
+        const msg = JSON.parse(event.data)
+        switch (msg.type) {
+            case MessageType.Heartbeat:
+                this.state = ConnectionState.Connected
+                this.lastTimeUpdate = Date.now()
+                break
+            default:
+                this.peer.receivedP2pMessage(msg)
+                break
+        }
+    }
+
+    sendP2pMessage(message, type = MessageType.Data, senderId = null) {
+        if (this.sendDataChannel && this.sendDataChannelOpen) {
+            const msgJson = JSON.stringify({
+                type: type,
+                senderId: senderId || this.peer.peerId,
+                data: message
+            })
+            this.sendDataChannel.send(msgJson)
+        } else {
+            // console.warn("the send data channel is not available!")
+        }
+    }
+
+    handleSendChannelStatusChange(event) {
+        // console.log(event)
+        if (this.sendDataChannel) {
+            this.sendDataChannelOpen = this.sendDataChannel.readyState == "open"
+            if (this.sendDataChannelOpen && this.heartbeatConfig) {
+                this.scheduleHeartbeat()
+            }
+        }
+    }
+
+    handleReceiveChannelStatusChange(event) {
+        // console.log(event)
+    }
+
+    scheduleHeartbeat() {
+        this.heartbeat = setTimeout(() => {
+            this.sendHeartbeat()
+        }, this.heartbeatConfig.interval_mls)
+    }
+
+    sendHeartbeat() {
+        if (this.lastTimeUpdate > 0 && Date.now() - this.lastTimeUpdate > this.heartbeatConfig.idle_timeout_mls) {
+            // console.log("HEART-BEAT DETECT DISCONNECTED ............")
+            this.state = ConnectionState.DisConnected
+            this.peer.updateP2pConnectionState(this)
+        } else {
+            this.sendP2pMessage("ping", MessageType.Heartbeat)
+            this.scheduleHeartbeat()
+        }
+    }
+
+    stopHeartbeat() {
+        // console.log(`stop heartbeat ${this.hostId} <-> ${this.clientId}`)
+        clearTimeout(this.heartbeat)
+    }
+    
+    close() {
+        // console.log(`close the connection ${this.hostId} <-> ${this.clientId}`)
+        this.stopHeartbeat()
+    }
+}

data/spec/dummy/vendor/javascript/p2p/p2p_controller.js

@@ -0,0 +1,52 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+    connect() {
+        this.p2pSetup()
+    }
+
+    p2pSetup() {
+        this.p2pFrame = this.element.closest("p2p-frame")
+        if (this.p2pFrame) {
+            this.p2pFrame.setP2pListener(this)
+        } else {
+            throw new Error("Couldn't find p2p-frame!")
+        }
+    }
+
+    get peerId() {
+        this.p2pFrame.peer?.peerId
+    }
+    
+    get hostPeerId() {
+        this.p2pFrame.peer?.hostPeerId
+    }
+
+    get iamHost() {
+        this.p2pFrame.peer?.iamHost
+    }
+
+    // p2p callbacks
+    
+    p2pNegotiating() {}
+
+    p2pConnecting() {}
+
+    p2pConnected() {}
+
+    p2pDisconnected() {}
+
+    p2pClosed() {}
+
+    p2pError() {}
+
+    // send/received p2p message
+
+    p2pSendMessage(message) {
+        if (this.p2pFrame) {
+            this.p2pFrame.sendP2pMessage(message)
+        }
+    }
+
+    p2pReceivedMessage(message) {}
+}

data/spec/dummy/vendor/javascript/p2p/p2p_frame.js

@@ -0,0 +1,152 @@
+import { Turbo, cable } from "@hotwired/turbo-rails"
+import P2pPeer from "p2p/p2p_peer"
+import { MessageType } from "p2p/message"
+
+class P2pFrameElement extends HTMLElement {
+    constructor() {
+      super()
+      this.listeners ||= []
+    }
+
+    // called each time the element is added to the document.
+    async connectedCallback() {
+      Turbo.connectStreamSource(this)
+      this.subscription = await cable.subscribeTo(this.channel, {
+        received: this.receiveSignal.bind(this),
+        connected: this.subscriptionConnected.bind(this),
+        disconnected: this.subscriptionDisconnected.bind(this)
+      }).catch(err => console.log(err))
+
+      this.peer = new P2pPeer(this.sessionId, this.peerId, this, this.subscription, this.iceConfig, this.heartbeatConfig)
+    }
+
+    // called each time the element is removed from the document.
+    disconnectedCallback() {
+      // console.log("p2p-frame disconnected")
+      this.unsubscribeSignalChannel()
+    }
+
+    subscriptionConnected() {
+      // console.log("subscriptionConnected")
+      this.peer.setup()
+    }
+  
+    subscriptionDisconnected() {
+      // console.log("subscriptionDisconnected")
+    }
+
+    receiveSignal(message) {
+      // console.log("receive signal")
+      // console.log(message)
+      if (message.type == MessageType.Connection) {
+        this.peer.negotiate(message)
+      }
+    }
+
+    setP2pListener(listener) {
+      this.listeners ||= []
+      this.listeners.push(listener)
+    }
+
+    dispatchP2pMessage(message) {
+      this.listeners.forEach(listener => {
+        listener.p2pReceivedMessage(message)
+      })
+    }
+
+    sendP2pMessage(msg) {
+      this.peer.sendP2pMessage(msg)
+    }
+
+    p2pNegotiating() {
+      this.listeners.forEach(listener => {
+        listener.p2pNegotiating()
+      })
+    }
+
+    p2pConnecting() {
+      this.listeners.forEach(listener => {
+        listener.p2pConnecting()
+      })
+    }
+
+    p2pConnected() {
+      this.listeners.forEach(listener => {
+        listener.p2pConnected()
+      })
+      
+      // only host-peer retain connect to the signal server
+      if (!this.peer?.iamHost && !this.keepCableConnection) {
+        // console.log("im not host so unsubscribe")
+        this.unsubscribeSignalChannel()
+      }
+    }
+
+    p2pDisconnected() {
+      this.listeners.forEach(listener => {
+        listener.p2pDisconnected()
+      })
+    }
+
+    p2pClosed() {
+      this.listeners.forEach(listener => {
+        listener.p2pClosed()
+      })
+    }
+
+    p2pError() {
+      this.listeners.forEach(listener => {
+        listener.p2pError()
+      })
+    }
+
+    async unsubscribeSignalChannel() { // TODO: MAKE SURE `SignalingChannel stopped streaming`
+      if (this.subscription) this.subscription.unsubscribe()
+      Turbo.disconnectStreamSource(this)
+      let consumer = await cable.getConsumer()
+      if (consumer) consumer.disconnect()
+    }
+
+    get sessionId() {
+      return this.getAttribute("session-id")
+    }
+
+    get peerId() {
+      return this.getAttribute("peer-id")
+    }
+
+    get params() {
+      return JSON.parse(this.getAttribute("params"))
+    }
+
+    get config() {
+      return this.params["config"] || {}
+    }
+
+    get iceConfig() {
+      return {
+        iceServers: this.config["ice_servers"]
+      }
+    }
+
+    get heartbeatConfig() {
+      return this.config["heartbeat"]
+    }
+
+    get keepCableConnection() {
+      return this.config["keep_cable_connection"]
+    }
+
+    get channel() {
+      const channel = this.getAttribute("channel")
+      const signed_stream_name = this.getAttribute("signed-stream-name")
+      return {
+        channel: channel,
+        signed_stream_name: signed_stream_name,
+        session_id: this.sessionId,
+        peer_id: this.peerId,
+      }
+    }
+}
+
+customElements.define("p2p-frame", P2pFrameElement)

data/spec/dummy/vendor/javascript/p2p/p2p_peer.js

@@ -0,0 +1,208 @@
+import { ConnectionState, MessageType } from "p2p/message"
+import P2pConnection from "p2p/p2p_connection"
+
+export default class P2pPeer {
+    constructor(sessionId, peerId, container, signaling, iceConfig, heartbeatConfig) {
+        this.sessionId = sessionId
+        this.container = container
+        this.signaling = signaling
+        this.iceConfig = iceConfig
+        this.heartbeatConfig = heartbeatConfig
+        this.peerId = peerId
+        this.hostPeerId = null
+        this.iamHost = false
+        this.state = null
+    }
+
+    setup() {
+        this.connections = new Map()
+        this.signal(ConnectionState.SessionJoin, {})
+        this.dispatchP2pConnectionState({state: ConnectionState.Negotiating})
+    }
+
+    signal(state, data) {
+        let msg = {
+            "type": MessageType.Connection,
+            "session_id": this.sessionId,
+            "peer_id": this.peerId,
+            "state": state,
+            ...data
+        }
+        this.signaling.send(msg)
+    }
+
+    negotiate(msg) {
+        switch (msg.state) {
+            case ConnectionState.SessionJoin:
+                break
+            case ConnectionState.SessionReady:
+                if (msg.host_peer_id == this.peerId) { // iam host
+                    this.iamHost = true
+                    this.hostPeerId = this.peerId
+                    if (msg.peer_id == this.peerId) {
+                        this.updateP2pConnectionState()
+                        return
+                    }
+
+                    const connection = new P2pConnection(this, msg.peer_id, this.peerId, this.iamHost, this.iceConfig, this.heartbeatConfig)
+                    this.connections.set(msg.peer_id, connection)
+
+                    const rtcPeerConnection = connection.setupRTCPeerConnection()
+                    if (!rtcPeerConnection) {
+                        // TODO: failed case
+                        return
+                    }
+                    rtcPeerConnection.createOffer()
+                        .then(offer => {
+                            return rtcPeerConnection.setLocalDescription(offer)
+                        })
+                        .then(() => {
+                            let offer = {"host_peer_id": msg.host_peer_id}
+                            offer[ConnectionState.SdpOffer] = JSON.stringify(rtcPeerConnection.localDescription)
+                            this.signal(ConnectionState.SdpOffer, offer)
+                        })
+                        .catch(err => console.log(err))
+                }
+
+                this.state = ConnectionState.SessionReady
+
+                break
+            case ConnectionState.SdpOffer:
+                if (msg.host_peer_id != this.peerId && this.state != ConnectionState.SdpOffer) { // iam not host
+                    this.hostPeerId = msg.host_peer_id
+                    const connection = new P2pConnection(this, this.peerId, msg.host_peer_id, this.iamHost, this.iceConfig, this.heartbeatConfig)
+                    this.connections.set(this.peerId, connection)
+                    
+                    const rtcPeerConnection = connection.setupRTCPeerConnection()
+
+                    let offer = JSON.parse(msg[ConnectionState.SdpOffer])
+                    // console.log(`${this.peerId} get Offer`)
+                    // console.log(offer)
+                    rtcPeerConnection.setRemoteDescription(new RTCSessionDescription(offer))
+                        .then(() => {
+                            rtcPeerConnection.createAnswer()
+                                .then(answer => {
+                                    return rtcPeerConnection.setLocalDescription(answer)
+                                })
+                                .then(() => {
+                                    let answer = {"host_peer_id": msg.host_peer_id}
+                                    answer[ConnectionState.SdpAnswer] = JSON.stringify(rtcPeerConnection.localDescription)
+                                    this.signal(ConnectionState.SdpAnswer, answer)
+                                })
+                                .catch(err => console.log(err))
+                        })
+                }
+                break
+            case ConnectionState.SdpAnswer:
+                if (msg.host_peer_id == this.peerId) { // iam host
+                    // console.log(` ${this.peerId} get Answer`)
+                    const clientConnection = this.connections.get(msg.peer_id)
+                    if (!clientConnection) return;
+
+                    const rtcPeerConnection = clientConnection.rtcPeerConnection
+                    let answer = JSON.parse(msg[ConnectionState.SdpAnswer])
+                    
+                    rtcPeerConnection.setRemoteDescription(new RTCSessionDescription(answer))
+                        .catch(err => console.log(err))
+                }
+                break
+            case ConnectionState.IceCandidate:
+                if (msg[ConnectionState.IceCandidate]) {
+                    this.connections.forEach((connection, peerId) => {
+                        connection.rtcPeerConnection.addIceCandidate(new RTCIceCandidate(msg[ConnectionState.IceCandidate]))
+                            .catch(err => console.log(err))
+                    })
+                }
+                break
+            case ConnectionState.Error:
+                // console.log("Connection Error")
+                break
+            default:
+                break
+        }
+    }
+
+    dispatchP2pMessage(message, type, senderId) {
+        this.connections.forEach((connection, peerId) => {
+            connection.sendP2pMessage(message, type, senderId)
+        })
+    }
+    
+    sendP2pMessage(message) {
+        if (this.iamHost) {
+            this.container.dispatchP2pMessage({
+                type: MessageType.Data,
+                senderId: this.peerId,
+                data: message
+            })
+        }
+
+        this.connections.forEach((connection, peerId) => {
+            connection.sendP2pMessage(message, MessageType.Data, this.peerId)
+        })
+    }
+
+    receivedP2pMessage(message) {
+        switch (message.type) {
+            case MessageType.Data:
+            case MessageType.DataConnectionState:
+                if (this.iamHost) {
+                    //broadcast to all connections
+                    this.dispatchP2pMessage(message.data, message.type, message.senderId)
+                }
+                
+                // dispatch msg to all sub views
+                this.container.dispatchP2pMessage(message)
+                break
+            default:
+                break
+        }
+    }
+
+    updateP2pConnectionState(connection = null) {
+        if (this.iamHost) {
+            this.connectionStatus ||= {}
+            this.connections.forEach((connection, peerId) => {
+                this.connectionStatus[peerId] = connection.state
+            })
+            this.connectionStatus[this.hostPeerId] = ConnectionState.Connected
+
+            this.container.dispatchP2pMessage({
+                type: MessageType.DataConnectionState,
+                senderId: this.peerId,
+                data: this.connectionStatus
+            })
+
+            this.dispatchP2pMessage(this.connectionStatus, MessageType.DataConnectionState, this.hostPeerId)
+        }
+
+        if (connection) {
+            this.dispatchP2pConnectionState(connection)
+        }
+    }
+
+    dispatchP2pConnectionState(connection) {
+        switch (connection.state) {
+            case ConnectionState.Negotiating:
+                this.container.p2pNegotiating()
+                break
+            case ConnectionState.Connecting:
+                this.container.p2pConnecting()
+                break
+            case ConnectionState.Connected:
+                this.container.p2pConnected()
+                break
+            case ConnectionState.DisConnected:
+                this.container.p2pDisconnected()
+                break
+            case ConnectionState.Closed:
+                this.container.p2pClosed()
+                break
+            case ConnectionState.Failed:
+                this.container.p2pError()
+                break
+            default:
+                break
+          }
+    }
+}

data/spec/dummy/vendor/javascript/p2p/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "p2p",
+  "version": "0.0.1",
+  "files": ["./*.*"],
+  "main": "./index.js",
+  "dependencies": {
+    "@hotwired/stimulus": "^3.2.2",
+    "@hotwired/turbo-rails": "^8.0.4",
+    "esbuild": "^0.20.2"
+  },
+  "scripts": {
+    "build": "esbuild app/assets/javascripts/*.* --bundle --minify --format=esm --outdir=app/assets/builds --public-path=/assets"
+  }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: p2p_streams_channel
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - theforestvn88
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-03-28 00:00:00.000000000 Z
+date: 2024-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -80,7 +80,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: rails p2p turbo streams channel
+description: Allow to setup one-to-many P2P stream connections (WebRTC) between clients
+  through Rails server (ActionCable) as the signaling server
 email:
 - theforestvn88@gmail.com
 executables: []
@@ -90,13 +91,6 @@ files:
 - ".rspec"
 - README.md
 - Rakefile
-- app/assets/javascripts/p2p/index.js
-- app/assets/javascripts/p2p/message.js
-- app/assets/javascripts/p2p/p2p_connection.js
-- app/assets/javascripts/p2p/p2p_controller.js
-- app/assets/javascripts/p2p/p2p_frame.js
-- app/assets/javascripts/p2p/p2p_peer.js
-- app/assets/javascripts/p2p/package.json
 - app/channels/signaling_channel.rb
 - app/helpers/p2p_streams_channel/tag_helper.rb
 - lib/p2p_streams_channel.rb
@@ -111,6 +105,13 @@ files:
 - lib/rails/generators/p2p_streams_channel/install_generator.rb
 - lib/rails/generators/p2p_streams_channel/templates/controller.js
 - lib/rails/generators/p2p_streams_channel/templates/initializer.rb
+- lib/rails/generators/p2p_streams_channel/templates/p2p/index.js
+- lib/rails/generators/p2p_streams_channel/templates/p2p/message.js
+- lib/rails/generators/p2p_streams_channel/templates/p2p/p2p_connection.js
+- lib/rails/generators/p2p_streams_channel/templates/p2p/p2p_controller.js
+- lib/rails/generators/p2p_streams_channel/templates/p2p/p2p_frame.js
+- lib/rails/generators/p2p_streams_channel/templates/p2p/p2p_peer.js
+- lib/rails/generators/p2p_streams_channel/templates/p2p/package.json
 - p2p_streams_channel.gemspec
 - sig/p2p_streams_channel.rbs
 - spec/dummy/Rakefile
@@ -158,6 +159,7 @@ files:
 - spec/dummy/config/routes.rb
 - spec/dummy/config/storage.yml
 - spec/dummy/db/test.sqlite3
+- spec/dummy/log/development.log
 - spec/dummy/log/test.log
 - spec/dummy/public/404.html
 - spec/dummy/public/422.html
@@ -166,6 +168,13 @@ files:
 - spec/dummy/public/apple-touch-icon.png
 - spec/dummy/public/favicon.ico
 - spec/dummy/tmp/development_secret.txt
+- spec/dummy/vendor/javascript/p2p/index.js
+- spec/dummy/vendor/javascript/p2p/message.js
+- spec/dummy/vendor/javascript/p2p/p2p_connection.js
+- spec/dummy/vendor/javascript/p2p/p2p_controller.js
+- spec/dummy/vendor/javascript/p2p/p2p_frame.js
+- spec/dummy/vendor/javascript/p2p/p2p_peer.js
+- spec/dummy/vendor/javascript/p2p/package.json
 - spec/p2p_peer_status_spec.rb
 - spec/p2p_send_data_spec.rb
 - spec/p2p_streams_channel_spec.rb
@@ -196,7 +205,8 @@ requirements: []
 rubygems_version: 3.5.4
 signing_key: 
 specification_version: 4
-summary: rails p2p turbo streams channel
+summary: Allow to setup one-to-many P2P stream connections (WebRTC) between clients
+  through Rails server (ActionCable) as the signaling server
 test_files:
 - spec/dummy/Rakefile
 - spec/dummy/app/assets/config/manifest.js
@@ -243,6 +253,7 @@ test_files:
 - spec/dummy/config/storage.yml
 - spec/dummy/config.ru
 - spec/dummy/db/test.sqlite3
+- spec/dummy/log/development.log
 - spec/dummy/log/test.log
 - spec/dummy/public/404.html
 - spec/dummy/public/422.html
@@ -251,6 +262,13 @@ test_files:
 - spec/dummy/public/apple-touch-icon.png
 - spec/dummy/public/favicon.ico
 - spec/dummy/tmp/development_secret.txt
+- spec/dummy/vendor/javascript/p2p/index.js
+- spec/dummy/vendor/javascript/p2p/message.js
+- spec/dummy/vendor/javascript/p2p/p2p_connection.js
+- spec/dummy/vendor/javascript/p2p/p2p_controller.js
+- spec/dummy/vendor/javascript/p2p/p2p_frame.js
+- spec/dummy/vendor/javascript/p2p/p2p_peer.js
+- spec/dummy/vendor/javascript/p2p/package.json
 - spec/p2p_peer_status_spec.rb
 - spec/p2p_send_data_spec.rb
 - spec/p2p_streams_channel_spec.rb