update with halfbaked VRPN tracker implementation

src/tracker.rs

@@ -1,52 +1,79 @@
 use bevy::prelude::*;
 
 extern crate vrpn;
+extern crate bytes;
+
 // extern crate tokio;
 
-use std::sync::Arc;
-
+use bytes::Bytes;
+use std::net::{SocketAddr, TcpStream};
 use vrpn::{
-    async_io::{ping, ConnectionIp, ConnectionIpStream},
+    constants::MAGIC_DATA,
+    cookie::check_ver_nonfile_compatible,
     handler::{HandlerCode, TypedHandler},
-    ping::Server,
-    prelude::*,
+    sync_io::{read_cookie, write_cookie, EndpointSyncTcp},
     tracker::PoseReport,
-    Message, Result, ServerInfo, StaticSenderName,
+    CookieData, Message, Result, TypeDispatcher, Unbuffer,
 };
 
 #[derive(Component)]
 pub struct Tracker {
-    stream: ConnectionIpStream,
-    connection: Arc<ConnectionIp>
+    // stream: ConnectionIpStream,
+    // connection: Arc<ConnectionIp>
 }
 
-impl Tracker {
-    pub fn from_info(server_ip: &str, port: u16) -> Self {
-        let server = format!("tcp://{}:{}", server_ip, port)
-            .parse::<ServerInfo>()
-            .unwrap();
-
-        let connection = ConnectionIp::new_client(server, None, None).expect("msg");
-
-        let sender = connection
-            .register_sender(StaticSenderName(b"Tracker0"))
-            .expect("should be able to register sender");
-
-        let ping_client = ping::Client::new(sender, Arc::clone(&connection))
-            .expect("should be able to create ping client");
-
-        Self {
-            stream: ConnectionIpStream::new(Arc::clone(&connection)),
-            connection
-        }
-    }
+#[derive(Debug)]
+struct TrackerHandler {}
 
+impl TypedHandler for TrackerHandler {
+    type Item = PoseReport;
     fn handle_typed(&mut self, msg: &Message<PoseReport>) -> Result<HandlerCode> {
         info!("{:?}\n   {:?}", msg.header, msg.body);
         Ok(HandlerCode::ContinueProcessing)
     }
 }
 
+impl Tracker {
+    pub fn from_info(server_ip: &str, port: u16) -> Result<()> {
+        // let server = format!("tcp://{}:{}", server_ip, port)
+        //     .parse::<ServerInfo>()
+        //     .unwrap();
+
+        // let connection = ConnectionIp::new_client(server, None, None).expect("msg");
+
+        // let sender = connection
+        //     .register_sender(StaticSenderName(b"Tracker0"))
+        //     .expect("should be able to register sender");
+
+        // let ping_client = ping::Client::new(sender, Arc::clone(&connection))
+        //     .expect("should be able to create ping client");
+
+
+        let addr: SocketAddr = "127.0.0.1:3883".parse().unwrap();
+        let mut stream = TcpStream::connect(addr)?;
+        stream.set_nodelay(true)?;
+    
+        // We first write our cookie, then read and check the server's cookie, before the loop.
+        write_cookie(&mut stream, CookieData::from(MAGIC_DATA))?;
+        let cookie_buf = read_cookie(&mut stream)?;
+        let mut cookie_buf = Bytes::from(&cookie_buf[..]);
+    
+        // CookieData::unbuffer_ref(&mut cookie_buf)
+        //     .and_then(|msg| check_ver_nonfile_compatible(msg.version))?;
+    
+        let mut endpoint = EndpointSyncTcp::new(stream);
+        let mut dispatcher = TypeDispatcher::new();
+        let _ = dispatcher.add_typed_handler(Box::new(TrackerHandler {}), None)?;
+
+        // Ok(Self {
+        //     // stream: ConnectionIpStream::new(Arc::clone(&connection)),
+        //     // connection
+        // })
+    }
+
+
+}
+
 pub fn setup_tracker(mut commands: Commands)
 {
     commands.spawn(Tracker::from_info("127.0.0.1",3883));