data sent back and forth every frame, works but doesn't have desired effect. progress!

src/sync/comms.rs

@@ -14,16 +14,19 @@ use websocket::{Message, OwnedMessage};
 
 const CONNECTION: &'static str = "ws://127.0.0.1:8765";
 pub struct Communication<T> {
-    pub tx: Sender<T>,
-    pub rx: Receiver<T>,
+    rx: Receiver<T>,
+    tx: Sender<OwnedMessage>,
     inbound_thread: JoinHandle<Result<(), failure::Error>>,
     outbound_thread: JoinHandle<Result<(), failure::Error>>,
 }
 
 impl<T> Communication<T> where T: std::marker::Send, T: Serialize, T: DeserializeOwned, T: 'static {
     pub fn new() -> Self {
-        let (to_thread, from_main): (Sender<T>, Receiver<T>) = mpsc::channel();
-        let (to_main, from_thread): (Sender<T>, Receiver<T>) = mpsc::channel();
+        let (tx, from_main): (Sender<OwnedMessage>, Receiver<OwnedMessage>) = mpsc::channel();
+        let (to_main, rx): (Sender<T>, Receiver<T>) = mpsc::channel();
+
+        // transmitter for ping and close messages
+        let tx_1 = tx.clone();
 
         let ws_client = ClientBuilder::new(CONNECTION)
             .unwrap()
@@ -38,9 +41,8 @@ impl<T> Communication<T> where T: std::marker::Send, T: Serialize, T: Deserializ
             let mut ws_sender = ws_sender;
             let mut flush = || -> Result<(), failure::Error> {
                 let msg = from_main.recv()?;
-                let msg_serialized = serde_json::to_string(&msg)?;
-                println!("sending a message {}", &msg_serialized);
-                ws_sender.send_message(&Message::text(msg_serialized))?;
+                println!("sending a message {:?}", &msg);
+                ws_sender.send_message(&msg)?;
                 Ok(())
             };
 
@@ -58,6 +60,7 @@ impl<T> Communication<T> where T: std::marker::Send, T: Serialize, T: Deserializ
         let inbound = thread::spawn(move || -> Result<(), failure::Error> {
             let mut to_main = to_main;
             let mut ws_receiver = ws_receiver;
+            let mut tx_1 = tx_1;
 
             let mut flush = || -> Result<(), failure::Error> {
                 let msg = ws_receiver.recv_message()?;
@@ -65,15 +68,25 @@ impl<T> Communication<T> where T: std::marker::Send, T: Serialize, T: Deserializ
                     OwnedMessage::Text(text) => match serde_json::from_str(&text) {
                         Ok(m) => {
                             println!("receiving a message {}", &text);
-                            to_main.send(m);
+                            to_main.send(m); // todo print an error
                             Ok(())
                         }
                         Err(e) => Err(failure::err_msg(format!("deserialization error: {:?}", e)))
                     },
                     OwnedMessage::Binary(_) => Err(failure::err_msg("binary message not implemented")),
-                    OwnedMessage::Close(_) => Err(failure::err_msg("close requested")),
-                    OwnedMessage::Ping(_) => Err(failure::err_msg("ping message not implemented")),
-                    OwnedMessage::Pong(_) => Err(failure::err_msg("pong message not implemented")),
+                    OwnedMessage::Close(_) => {
+                        tx_1.send(OwnedMessage::Close(None));
+                        Err(failure::err_msg("Connection closed by request."))
+                    }
+                    OwnedMessage::Ping(data) => {
+                        tx_1.send(OwnedMessage::Pong(data));
+                        // todo print an error
+                        Ok(())
+                    },
+                    OwnedMessage::Pong(_) => {
+                        println!("received pong");
+                        Ok(())
+                    }
                 }
             };
 
@@ -95,12 +108,22 @@ impl<T> Communication<T> where T: std::marker::Send, T: Serialize, T: Deserializ
         });
 
         Communication {
-            tx: to_thread,
-            rx: from_thread,
+            tx: tx,
+            rx: rx,
             inbound_thread: inbound,
             outbound_thread: outbound,
         }
     }
+
+    pub fn send(&mut self, msg: T) -> Result<(), failure::Error> {
+        let msg_serialized = serde_json::to_string(&msg)?;
+        self.tx.send(OwnedMessage::Text(msg_serialized))?;
+        Ok(())
+    }
+
+    pub fn try_recv(&mut self) ->  Result<T, std::sync::mpsc::TryRecvError> {
+        self.rx.try_recv()
+    }
 }
 
 struct WebsocketClient<T> {

src/sync/pokemon_rb.rs

@@ -78,14 +78,14 @@ impl SyncedPokemonRedBlue {
 
         match &mut self.comms {
             Some(comms) => {
-                comms.tx.send(message);
+                comms.send(message);
             },
             None => ()
         }
     }
 
     pub fn handle_inbound_msgs(&mut self) -> Result<(), failure::Error>{
-        let in_msg = self.comms.as_ref().ok_or(failure::err_msg("comms doesn't exist, can't handle inbound msgs"))?.rx.try_recv()?;
+        let in_msg = self.comms.as_mut().ok_or(failure::err_msg("comms doesn't exist, can't handle inbound msgs"))?.try_recv()?;
         self.handle_message(in_msg)
     }