working!

src/lib.rs

@@ -1,65 +1,58 @@
-use std::io::{self, Read};
-use std::net::{TcpListener, TcpStream, IpAddr, SocketAddr, Ipv4Addr, SocketAddrV4};
+use std::io::{self, Read, Write};
+use std::net::{TcpListener, TcpStream};
 use std::error::Error;
-use std::str::FromStr;
+use std::sync::mpsc::{Receiver, Sender};
+use std::time::Duration;
 
-type EmptyResult = Result<(), Box<dyn Error>>;
+type StreamResult = Result<TcpStream, Box<dyn Error>>;
 
 
-pub fn listen() -> EmptyResult {
-    let l_stream = listen_on_port(7979)?;
+pub fn listen() -> StreamResult {
+    println!("Listening on {}:8080", local_ipaddress::get().unwrap());
+    let listener = TcpListener::bind(("127.0.0.1", 8080))?;
+    let stream = listener.incoming().next().unwrap()?;
     println!("Connected. Waiting for response stream...");
-    let other_address = l_stream.peer_addr()?.ip();
-    println!("other adress: {}", other_address);
-    let s_stream = connect_to_addr("127.0.0.1", 7980)?;
+    println!("other adress: {}", stream.peer_addr()?.ip());
 
-
-    Ok(())
+    Ok(stream)
 }
 
-pub fn connect(address: String, port: String) -> EmptyResult {
+pub fn connect(address: String, port: String) -> StreamResult {
     println!("Trying to connect to '{}:{}'", &address, &port);
 
     let port: u16 = port.parse()?;
-    let s_stream = connect_to_addr(&*address, port)?;
+    let stream = TcpStream::connect((&*address, port))?;
 
-    println!("Connected. Waiting for response stream...");
-    let l_stream = listen_on_port(7080)?;
-    println!("Connected. Chat is now open...");
+    println!("Connected.");
 
-    Ok(())
+    Ok(stream)
 }
 
-pub fn connect_to_addr(address: &str, port: u16) -> Result<TcpStream, Box<dyn Error>> {
-    let socket_addr = SocketAddrV4::new(Ipv4Addr::from_str(address)?, port);
-    match TcpStream::connect(socket_addr) {
-        Err(e) => Err(Box::new(e)),
-        Ok(s) => Ok(s)
+
+pub fn network_thread(mut stream: TcpStream, rx: Receiver<String>) {
+    let mut data = [0u8; 255]; // using 50 byte buffer
+    stream.set_read_timeout(Some(Duration::from_millis(500))).expect("Could not set timeout");
+    loop {
+        if let Ok(_) = stream.read(&mut data) {
+            println!("> {}", String::from_utf8_lossy(&data));
+            data = [0u8; 255];
+        }
+        if let Ok(v) = rx.recv_timeout(Duration::from_millis(200)) {
+            stream.write(v.as_bytes()).expect("could not send message");
+        }
     }
 }
 
-pub fn listen_on_port(port: u16) -> io::Result<TcpStream> {
-    let listener = TcpListener::bind(("127.0.0.1", port)).unwrap();
-    println!(
-        "Listening on: {}:{}...",
-        local_ipaddress::get().unwrap(),
-        port
-    );
-
-    listener.incoming().next().unwrap()
-}
-
-pub fn read_stream_print(mut stream: TcpStream) {
-    let mut data = [0 as u8; 50]; // using 50 byte buffer
-
-    for _ in stream.read(&mut data) {
-        println!("{}", String::from_utf8_lossy(&data));
+pub fn ui_thread(sx: Sender<String>) {
+    loop {
+        let input = input();
+        sx.send(input).expect("could not send value");
     }
 }
 
 
-fn input() -> String {
+pub fn input() -> String {
     let mut buffer = String::new();
     let _ = io::stdin().read_line(&mut buffer);
-    buffer
+    buffer.trim().to_string()
 }