Detect when remote closes channel to EventStream

[LMH01]

Hello, I'm trying to detect when the event stream to a users client (browser) is closed.

After a short time rocket prints Remote left: channel closed. into the console, indicating that the browser is no longer listening to the event stream. I'm guessing that this is archived, because heartbeat is implemented for the stream.

So my question is: How can I detect when a user stops listening to the event stream?
(I searched the docs but was unable to find a solution)

My code currently looks like this:

EventStream! {
    loop {
        let msg = select! {
            msg = rx.recv() => match msg {
                Ok(msg) => msg,
                Err(RecvError::Closed) => {
                    // This code probably gets executed when a request could not be recieved by the reciever.
                    // It is not executed when the connection is lost
                    info!("User disconnected {}", user_id);
                    user_disconnected(game_manager.inner(), user_id);
                    break
                },
                Err(RecvError::Lagged(_)) => continue,
            },
            _ = &mut end => {
                // This code gets executed when the server shuts down
                info!("End: User disconnected {}", user_id);
                break
            },
            // My guess is that I have to put something here that detects when the user is no longer listening, but I don't know what could work.
        };
        let msg_game_code = msg.game_code();
        let msg_user_id = msg.user_id();
        if msg_game_code == code.to_string() && ((msg_user_id == user_id) || msg_user_id == 0) {
            yield Event::json(&msg);
        }
    }
}

[tguichaoua]

#[get("/hello")]
fn hello() -> TextStream![&'static str] {
    let (send, recv) = rocket::tokio::sync::oneshot::channel::<()>();

    let stream = TextStream! {
        let _ = send; // capture the Sender
        let mut interval = time::interval(Duration::from_secs(1));
        loop {
            println!("HELLO");
            yield "hello";
            interval.tick().await;
        }
    };

    rocket::tokio::spawn(async move {
        // Wait will Sender is alive
        let _ = recv.await;
        println!("User disconnected");
    });

    stream
}

When the connection is closed, the Sender part of the channel is dropped then the Receiver returns None to indicate all senders are closed.
Disclaimer : I'm not an expert of async, so I don't know if it's a good/optimised way to do this.

[LMH01]

Thank you for your response.
I will take a look at it once I have the time.