146 lines
4.3 KiB
Rust
146 lines
4.3 KiB
Rust
pub mod server;
|
|
|
|
use iced_futures::futures;
|
|
use iced_native::subscription::{self, Subscription};
|
|
|
|
use futures::channel::mpsc;
|
|
use futures::sink::SinkExt;
|
|
use futures::stream::StreamExt;
|
|
|
|
use async_tungstenite::tungstenite;
|
|
|
|
pub fn connect() -> Subscription<Event> {
|
|
struct Connect;
|
|
|
|
subscription::unfold(
|
|
std::any::TypeId::of::<Connect>(),
|
|
State::Disconnected,
|
|
|state| async move {
|
|
match state {
|
|
State::Disconnected => {
|
|
const ECHO_SERVER: &str = "ws://localhost:3030";
|
|
|
|
match async_tungstenite::tokio::connect_async(ECHO_SERVER)
|
|
.await
|
|
{
|
|
Ok((websocket, _)) => {
|
|
let (sender, receiver) = mpsc::channel(100);
|
|
|
|
(
|
|
Some(Event::Connected(Connection(sender))),
|
|
State::Connected(websocket, receiver),
|
|
)
|
|
}
|
|
Err(_) => {
|
|
let _ = tokio::time::sleep(
|
|
tokio::time::Duration::from_secs(1),
|
|
)
|
|
.await;
|
|
|
|
(Some(Event::Disconnected), State::Disconnected)
|
|
}
|
|
}
|
|
}
|
|
State::Connected(mut websocket, mut input) => {
|
|
let mut fused_websocket = websocket.by_ref().fuse();
|
|
|
|
futures::select! {
|
|
received = fused_websocket.select_next_some() => {
|
|
match received {
|
|
Ok(tungstenite::Message::Text(message)) => {
|
|
(
|
|
Some(Event::MessageReceived(Message::User(message))),
|
|
State::Connected(websocket, input)
|
|
)
|
|
}
|
|
Ok(_) => {
|
|
(None, State::Connected(websocket, input))
|
|
}
|
|
Err(_) => {
|
|
(Some(Event::Disconnected), State::Disconnected)
|
|
}
|
|
}
|
|
}
|
|
|
|
message = input.select_next_some() => {
|
|
let result = websocket.send(tungstenite::Message::Text(String::from(message))).await;
|
|
|
|
if result.is_ok() {
|
|
(None, State::Connected(websocket, input))
|
|
} else {
|
|
(Some(Event::Disconnected), State::Disconnected)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
)
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
enum State {
|
|
Disconnected,
|
|
Connected(
|
|
async_tungstenite::WebSocketStream<
|
|
async_tungstenite::tokio::ConnectStream,
|
|
>,
|
|
mpsc::Receiver<Message>,
|
|
),
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum Event {
|
|
Connected(Connection),
|
|
Disconnected,
|
|
MessageReceived(Message),
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Connection(mpsc::Sender<Message>);
|
|
|
|
impl Connection {
|
|
pub fn send(&mut self, message: Message) {
|
|
let _ = self
|
|
.0
|
|
.try_send(message)
|
|
.expect("Send message to echo server");
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum Message {
|
|
Connected,
|
|
Disconnected,
|
|
User(String),
|
|
}
|
|
|
|
impl Message {
|
|
pub fn new(message: &str) -> Option<Self> {
|
|
if message.is_empty() {
|
|
None
|
|
} else {
|
|
Some(Self::User(message.to_string()))
|
|
}
|
|
}
|
|
|
|
pub fn connected() -> Self {
|
|
Message::Connected
|
|
}
|
|
|
|
pub fn disconnected() -> Self {
|
|
Message::Disconnected
|
|
}
|
|
}
|
|
|
|
impl From<Message> for String {
|
|
fn from(message: Message) -> Self {
|
|
match message {
|
|
Message::Connected => String::from("Connected successfully!"),
|
|
Message::Disconnected => {
|
|
String::from("Connection lost... Retrying...")
|
|
}
|
|
Message::User(message) => message,
|
|
}
|
|
}
|
|
}
|