wasm-peers

This crate provides an easy-to-use wrapper around WebRTC and DataChannels for a peer-to-peer connections.

Overview

As creator of agar.io famously stated WebRTC is hard. This library aims to help, by abstracting away all the setup, and providing a simple way to send and receive messages over the data channel.

It's as easy as providing address to a signaling server instance from accompanying crate and specifying two callbacks. One that specifies what should happen when a connection is established, and one for when a message is received. After that you can send messages back and forth without worrying about the implementation details.

Library contains three network topologies, one-to-one, which creates an equal connection between two peers, one-to-many, which specifies a host and arbitrary number of clients and many-to-many that creates connection for each pair of peers and allows sending messages to any of them.

For a "production ready" apps built with this library check out either Live Document or Footballers.

Example

This example shows two peers sending ping and pong messages to each other.

```rust use wasmpeers::ConnectionType; use wasmpeers::onetoone::NetworkManager; use web_sys::console;

// there must be a signaling server from accompanying crate running on this port const SIGNALINGSERVERURL: &str = "ws://0.0.0.0:9001/one-to-one";

fn main() { // there must be some mechanism for exchanging session ids between peers let sessionid = SessionId::new("some-session-id".tostring()); let mut peer1 = NetworkManager::new( SIGNALINGSERVERURL, session_id.clone(), ConnectionType::Stun, ).unwrap();

let peer1_clone = peer1.clone();
let peer1_on_open = move || peer1_clone.send_message("ping!").unwrap();
let peer1_on_message = {
    move |message| {
        console::log_1(&format!("peer1 received message: {}", message).into());
    }
};
peer1.start(peer1_on_open, peer1_on_message).unwrap();

let mut peer2 = NetworkManager::new(
    SIGNALING_SERVER_URL,
    session_id,
    ConnectionType::Stun,
).unwrap();
let peer2_on_open = || { /* do nothing */ };
let peer2_clone = peer2.clone();
let peer2_on_message = {
    let peer2_received_message = peer2_received_message.clone();
    move |message| {
        console::log_1(&format!("peer2 received message: {}", message).into());
        peer2_clone.send_message("pong!").unwrap();
    }
};
peer2.start(peer2_on_open, peer2_on_message).unwrap();

} ``` For examples of other topologies check out the docs.

Roadmap

• [ ] Add tests
• [ ] Improve error handling
• [ ] Introduce alternative API with futures
• [ ] Add possibility to pass video/audio streams over established connection

Version History

• 0.4
  • MiniServer callbacks don't accept UserId argument now (it'd always be hosts)
  • Fix documentation tests so that they compile
• 0.3
  • Initial release to the public

Similar projects

• matchbox

License

This project is licensed under either of

• Apache License, Version 2.0, (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Authors

Tomasz Karwowski LinkedIn

Acknowledgments

These projects helped me grasp WebRTC in Rust:

• Yew WebRTC Chat
• WebRTC in Rust

Also, special thanks to the guys with whom I did my B.Eng. thesis.