Struct Peer 

pub struct Peer {
    pub peer_id: PeerId,
    pub direction: PeerDirection,
    pub created_at: Instant,
    pub connected_at: Option<Instant>,
    pub data_channel: Arc<Mutex<Option<Arc<RTCDataChannel>>>>,
    pub pending_requests: Arc<Mutex<HashMap<String, PendingRequest>>>,
    /* private fields */
}

WebRTC peer connection with data channel protocol

Fields

peer_id: PeerId

direction: PeerDirection

created_at: Instant

connected_at: Option<Instant>

data_channel: Arc<Mutex<Option<Arc<RTCDataChannel>>>>

Data channel - can be set from callback when receiving channel from peer

pending_requests: Arc<Mutex<HashMap<String, PendingRequest>>>

Implementations

impl Peer

pub async fn new( peer_id: PeerId, direction: PeerDirection, my_peer_id: PeerId, signaling_tx: Sender<SignalingMessage>, stun_servers: Vec<String>, ) -> Result<Self>

Create a new peer connection

pub async fn new_with_store( peer_id: PeerId, direction: PeerDirection, my_peer_id: PeerId, signaling_tx: Sender<SignalingMessage>, stun_servers: Vec<String>, store: Option<Arc<dyn ContentStore>>, ) -> Result<Self>

Create a new peer connection with content store

pub async fn new_with_store_and_events( peer_id: PeerId, direction: PeerDirection, my_peer_id: PeerId, signaling_tx: Sender<SignalingMessage>, stun_servers: Vec<String>, store: Option<Arc<dyn ContentStore>>, state_event_tx: Option<Sender<PeerStateEvent>>, ) -> Result<Self>

Create a new peer connection with content store and state event channel

pub fn set_store(&mut self, store: Arc<dyn ContentStore>)

Set content store

pub fn state(&self) -> RTCPeerConnectionState

Get connection state

pub fn signaling_state(&self) -> RTCSignalingState

Get signaling state

pub fn is_connected(&self) -> bool

Check if connected

pub async fn setup_handlers(&mut self) -> Result<()>

Setup event handlers for the peer connection

pub async fn connect(&mut self) -> Result<Value>

Initiate connection (create offer) - for outbound connections

pub async fn handle_offer(&mut self, offer: Value) -> Result<Value>

Handle incoming offer and create answer

pub async fn handle_answer(&mut self, answer: Value) -> Result<()>

Handle incoming answer

pub async fn handle_candidate(&mut self, candidate: Value) -> Result<()>

Handle incoming ICE candidate

pub fn has_data_channel(&self) -> bool

Check if data channel is ready

pub async fn request(&self, hash_hex: &str) -> Result<Option<Vec<u8>>>

Request content by hash from this peer

pub async fn send_message(&self, msg: &DataMessage) -> Result<()>

Send a message over the data channel

pub async fn close(&self) -> Result<()>

Close the connection