Struct WsClient 

pub struct WsClient {
    pub url: String,
    pub state: WsState,
    pub auto_reconnect: bool,
    pub max_reconnects: u32,
    pub ping_interval: Duration,
    pub pong_timeout: Duration,
    pub max_queue_size: usize,
    /* private fields */
}

WebSocket client driven by tick().

With the websocket feature the connection is real: a background thread runs tungstenite (ws://, and wss:// through rustls) and tick() exchanges messages with it without blocking. Without the feature, connect reports an error event and the client stays disconnected; before 0.3.0 it pretended to connect to any URL and silently dropped every message.

Channel names given to send_on_channel and subscribe are local labels for your own bookkeeping; they are not sent on the wire.

Fields

url: String

Server URL, ws:// or wss://.

state: WsState

Current connection state.

auto_reconnect: bool

Auto-reconnect on unexpected disconnect.

max_reconnects: u32

Max reconnect attempts before giving up (0 = unlimited).

ping_interval: Duration

Keepalive ping interval.

pong_timeout: Duration

Close connection if no pong received within this time.

max_queue_size: usize

Max size of outbound queue.

Implementations

impl WsClient

pub fn new(url: impl Into<String>) -> Self

A disconnected client for url. Call WsClient::connect to start.

pub fn connect(&mut self)

Initiate a connection. No-op if already connected.

pub fn close(&mut self)

Close the connection intentionally (will not auto-reconnect).

pub fn disconnect(&mut self)

Drop the connection; it reconnects on the next tick if auto_reconnect is on.

pub fn send(&mut self, message: WsMessage) -> bool

Send a message. Queued if not currently connected.

pub fn send_on_channel(&mut self, channel: &str, message: WsMessage) -> bool

Send a message labelled with a local channel name.

pub fn subscribe(&mut self, channel: impl Into<String>)

Register a named logical channel.

pub fn unsubscribe(&mut self, channel: &str)

Remove a logical channel.

pub fn tick(&mut self, dt: f32)

Drive the WebSocket state machine. Call once per frame.

pub fn drain_events(&mut self) -> impl Iterator<Item = WsEvent> + '_

Take all events produced since the last call.

pub fn is_connected(&self) -> bool

Whether the connection is open.

pub fn messages_sent(&self) -> u64

Messages handed to the socket so far.

pub fn messages_received(&self) -> u64

Messages received so far.

pub fn bytes_sent(&self) -> u64

Payload bytes handed to the socket so far.

pub fn bytes_received(&self) -> u64

Payload bytes received so far.

pub fn uptime(&self) -> Option<Duration>

Time since the current connection opened.

pub fn pending_outbound(&self) -> usize

Messages waiting to be sent.