Struct Handle

Source

pub struct Handle<H>where
    H: WebImpl,
{ /* private fields */ }

Available on crate feature web03 only.

Expand description

A handle to the WebSocket service.

Implementations§

Source §

impl<H> Handle<H>
where H: WebImpl,

Source

pub fn request(&self) -> RequestBuilder<'_, H, EmptyBody, EmptyCallback>

Send a request of type T.

Returns a handle for the request.

If the handle is dropped, the request is cancelled.

§Examples

use yew::prelude::*;
use musli_web::web03::prelude::*;

mod api {
    use musli::{Decode, Encode};
    use musli_web::api;

    #[derive(Encode, Decode)]
    pub struct HelloRequest<'de> {
        pub message: &'de str,
    }

    #[derive(Encode, Decode)]
    pub struct HelloResponse<'de> {
        pub message: &'de str,
    }

    api::define! {
        pub type Hello;

        impl Endpoint for Hello {
            impl<'de> Request for HelloRequest<'de>;
            type Response<'de> = HelloResponse<'de>;
        }
    }
}

enum Msg {
    OnHello(Result<ws::Packet<api::Hello>, ws::Error>),
}

#[derive(Properties, PartialEq)]
struct Props {
    ws: ws::Handle,
}

struct App {
    message: String,
    _hello: ws::Request,
}

impl Component for App {
    type Message = Msg;
    type Properties = Props;

    fn create(ctx: &Context<Self>) -> Self {
        let hello = ctx.props().ws
            .request()
            .body(api::HelloRequest { message: "Hello!"})
            .on_packet(ctx.link().callback(Msg::OnHello))
            .send();

        Self {
            message: String::from("No Message :("),
            _hello: hello,
        }
    }

    fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
        match msg {
            Msg::OnHello(Err(error)) => {
                tracing::error!("Request error: {:?}", error);
                false
            }
            Msg::OnHello(Ok(packet)) => {
                if let Ok(response) = packet.decode() {
                    self.message = response.message.to_owned();
                }

                true
            }
        }
    }

    fn view(&self, ctx: &Context<Self>) -> Html {
        html! {
            <div>
                <h1>{"WebSocket Example"}</h1>
                <p>{format!("Message: {}", self.message)}</p>
            </div>
        }
    }
}

Source

pub fn on_broadcast<T>( &self, callback: impl Callback<Result<Packet<T>, Error>>, ) -> Listener
where T: Broadcast,

Listen for broadcasts of type T.

Returns a handle for the listener that will cancel the listener if dropped.

§Examples

use yew::prelude::*;
use musli_web::web03::prelude::*;

mod api {
    use musli::{Decode, Encode};
    use musli_web::api;

    #[derive(Encode, Decode)]
    pub struct TickEvent<'de> {
        pub message: &'de str,
        pub tick: u32,
    }

    api::define! {
        pub type Tick;

        impl Broadcast for Tick {
            impl<'de> Event for TickEvent<'de>;
        }
    }
}

enum Msg {
    Tick(Result<ws::Packet<api::Tick>, ws::Error>),
}

#[derive(Properties, PartialEq)]
struct Props {
    ws: ws::Handle,
}

struct App {
    tick: u32,
    _listen: ws::Listener,
}

impl Component for App {
    type Message = Msg;
    type Properties = Props;

    fn create(ctx: &Context<Self>) -> Self {
        let listen = ctx.props().ws.on_broadcast(ctx.link().callback(Msg::Tick));

        Self {
            tick: 0,
            _listen: listen,
        }
    }

    fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
        match msg {
            Msg::Tick(Err(error)) => {
                tracing::error!("Tick error: {error}");
                false
            }
            Msg::Tick(Ok(packet)) => {
                if let Ok(tick) = packet.decode_event() {
                    self.tick = tick.tick;
                }

                true
            }
        }
    }

    fn view(&self, ctx: &Context<Self>) -> Html {
        html! {
            <div>
                <h1>{"WebSocket Example"}</h1>
                <p>{format!("Tick: {}", self.tick)}</p>
            </div>
        }
    }
}

Source

pub fn on_raw_broadcast<T>( &self, callback: impl Callback<Result<RawPacket, Error>>, ) -> Listener
where T: Broadcast,

Listen for broadcasts of type T.

Returns a handle for the listener that will cancel the listener if dropped.

§Examples

use yew::prelude::*;
use musli_web::web03::prelude::*;

mod api {
    use musli::{Decode, Encode};
    use musli_web::api;

    #[derive(Encode, Decode)]
    pub struct TickEvent<'de> {
        pub message: &'de str,
        pub tick: u32,
    }

    api::define! {
        pub type Tick;

        impl Broadcast for Tick {
            impl<'de> Event for TickEvent<'de>;
        }
    }
}

enum Msg {
    Tick(Result<ws::RawPacket, ws::Error>),
}

#[derive(Properties, PartialEq)]
struct Props {
    ws: ws::Handle,
}

struct App {
    tick: u32,
    _listen: ws::Listener,
}

impl Component for App {
    type Message = Msg;
    type Properties = Props;

    fn create(ctx: &Context<Self>) -> Self {
        let link = ctx.link().clone();
        let listen = ctx.props().ws.on_raw_broadcast::<api::Tick>(ctx.link().callback(Msg::Tick));

        Self {
            tick: 0,
            _listen: listen,
        }
    }

    fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
        match msg {
            Msg::Tick(Err(error)) => {
                tracing::error!("Tick error: {error}");
                false
            }
            Msg::Tick(Ok(packet)) => {
                if let Ok(tick) = packet.decode::<api::TickEvent>() {
                    self.tick = tick.tick;
                }

                true
            }
        }
    }

    fn view(&self, ctx: &Context<Self>) -> Html {
        html! {
            <div>
                <h1>{"WebSocket Example"}</h1>
                <p>{format!("Tick: {}", self.tick)}</p>
            </div>
        }
    }
}

Source

pub fn on_state_change( &self, callback: impl Callback<State>, ) -> (State, StateListener)

Listen for state changes to the underlying connection.

This indicates when the connection is open and ready to receive requests through State::Open, or if it’s closed and requests will be queued through State::Closed.

Note that if you are connecting through a proxy the reported updates might be volatile. It is always best to send a message over the connection on the server side that once received allows the client to know that it is connected.

Dropping the returned handle will cancel the listener.

§Examples

use yew::prelude::*;
use musli_web::web03::prelude::*;

enum Msg {
    StateChange(ws::State),
}

#[derive(Properties, PartialEq)]
struct Props {
    ws: ws::Handle,
}

struct App {
    state: ws::State,
    _listen: ws::StateListener,
}

impl Component for App {
    type Message = Msg;
    type Properties = Props;

    fn create(ctx: &Context<Self>) -> Self {
        let link = ctx.link().clone();

        let (state, listen) = ctx.props().ws.on_state_change(move |state| {
            link.send_message(Msg::StateChange(state));
        });

        Self {
            state,
            _listen: listen,
        }
    }

    fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
        match msg {
            Msg::StateChange(state) => {
                self.state = state;
                true
            }
        }
    }

    fn view(&self, ctx: &Context<Self>) -> Html {
        html! {
            <div>
                <h1>{"WebSocket Example"}</h1>
                <p>{format!("State: {:?}", self.state)}</p>
            </div>
        }
    }
}