Rust Channel entre Actix Websocket et Service

use std::{thread, time::Duration};
use actix::prelude::*;
use actix_web::{
    get, middleware, web, App, Error, HttpRequest, HttpResponse, HttpServer, Responder,
};
use actix_web_actors::ws;
use tokio::sync::broadcast;
struct WebSocket {
    receiver: web::Data<broadcast::Receiver>,
    spawn_handle: Option,
}
impl WebSocket {
    fn new(receiver: web::Data<broadcast::Receiver>) -> Self {
        Self {
            receiver,
            spawn_handle: None,
        }
    }
}
impl Actor for WebSocket {
    type Context = ws::WebsocketContext;

    fn started(&mut self, ctx: &mut Self::Context) {
        println!("-- actor");
        let mut receiver = self.receiver.resubscribe();
        self.spawn_handle = Some(ctx.add_stream(async_stream::stream! {
            while let Ok(message) = receiver.recv().await {
                println!("-- msg: {message}");
                yield message.to_string();
            }
        }));
    }
}
impl StreamHandler for WebSocket {
    fn handle(&mut self, msg: String, ctx: &mut Self::Context) {
        ctx.text(msg);
    }
}
impl StreamHandler<Result> for WebSocket {
    fn handle(&mut self, msg: Result, _ctx: &mut Self::Context) {
        println!("Received message: {msg:?}")
    }
}
async fn status_ws(
    req: HttpRequest,
    stream: web::Payload,
    recv: web::Data<broadcast::Receiver>,
) -> Result {
    println!("-- client connect");
    ws::start(WebSocket::new(recv), &req, stream)
}
#[get("/hello/")]
async fn say_hello(sender: web::Data<broadcast::Sender>) -> impl Responder {
    let task = "from service 00".to_string();
    sender
        .send(task.clone())
        .expect("Failed to write to channel");
    println!("say hello");
    web::Json(task)
}
#[actix_web::main]
async fn main() -> std::io::Result {
    HttpServer::new(move || {
        let (sender, receiver) = broadcast::channel::(20);
        let sender2 = sender.clone();
        let _handle = thread::spawn(move || {
            for i in 1..22 {
                thread::sleep(Duration::from_millis(600));
                sender2
                    .send(format!("from loop {i}"))
                    .expect("Failed to write to channel");
            }
        });
        App::new()
            .app_data(web::Data::new(sender))
            .app_data(web::Data::new(receiver))
            .wrap(middleware::Logger::default())
            .service(web::resource("/ws/status").route(web::get().to(status_ws)))
            .service(web::scope("/api").service(say_hello))
    })
    .bind(("127.0.0.1", 8077))?
    .run()
    .await
}