pre simconnect

avam-client/src/client.rs

@@ -22,7 +22,7 @@ use crate::{config::Config, state_machine::Event, BASE_URL};
 pub async fn start(
     config: Config,
     simconnect_sender: Sender<SimConnectPacket>,
-    socket_receiver: Receiver<Packets>,
+    socket_receiver: Receiver<SimConnectPacket>,
     event_sender: Sender<Event>,
     mut event_receiver: Receiver<Event>,
 ) -> Result<(), anyhow::Error> {
@@ -152,7 +152,7 @@ pub async fn start(
                     futures.spawn(async move {
                         loop {
                             if let Ok(message) = socket_receiver.try_recv() {
-                                let _ = ias.send(message);
+                                let _ = ias.send(Packets::SimConnect(message));
                             }
                             sleep(Duration::from_millis(100)).await;
                         }

avam-client/src/main.rs

@@ -10,6 +10,7 @@ mod lock;
 mod models;
 mod oauth;
 mod pipe;
+mod simconnect;
 mod state_machine;
 
 use crate::config::Config;
@@ -93,8 +94,8 @@ async fn main() -> Result<(), anyhow::Error> {
     futures.spawn(start_code_to_token(c, pipe_receiver, sender, receiver));
 
     // Prepare channels for socket <-> simconnect
-    let (simconnect_sender, __simconnect_receiver) = channel(10);
+    let (simconnect_sender, simconnect_receiver) = channel(10);
-    let (__socket_sender, socket_receiver) = channel(10);
+    let (socket_sender, socket_receiver) = channel(10);
 
     // Start the websocket client
     let c = config.clone();
@@ -112,6 +113,14 @@ async fn main() -> Result<(), anyhow::Error> {
     // The simconnect sends data to the webscoket
     // It also receives data from the websocket to do things like set plane id and fuel and such things
     // If possible even position
+    let sender = event_sender.clone();
+    let receiver = event_receiver.resubscribe();
+    futures.spawn(simconnect::start(
+        simconnect_receiver,
+        socket_sender,
+        sender,
+        receiver,
+    ));
 
     // Start the Tray Icon
     let c = config.clone();

avam-client/src/simconnect.rs

@@ -1,29 +1,60 @@
+use std::time::Duration;
+
+use avam_protocol::SimConnectPacket;
+use tokio::{
+    sync::broadcast::{Receiver, Sender},
+    time::sleep,
+};
+
+use crate::state_machine::Event;
+
 pub struct SimConnect {
-    // whatever we need
+    simconnect_receiver: Receiver<SimConnectPacket>, // Data from the socket
+    socket_sender: Sender<SimConnectPacket>,         // Data to the socket
+    sender: Sender<Event>,
+    receiver: Receiver<Event>,
 }
 
 impl SimConnect {
-    pub fn new() -> Self {
+    pub fn new(
+        simconnect_receiver: Receiver<SimConnectPacket>,
+        socket_sender: Sender<SimConnectPacket>,
+        sender: Sender<Event>,
+        receiver: Receiver<Event>,
+    ) -> Self {
         Self {
-            // websocket receiver
+            simconnect_receiver,
-            // websocket sender
+            socket_sender,
-            // simconnect client handle
+            sender,
+            receiver,
         }
     }
 
-    pub fn run() -> Result<(), anyhow::Error> {
+    pub async fn run(&self) -> Result<(), anyhow::Error> {
+        let mut receiver = self.receiver.resubscribe();
         loop {
-            tokio::select! {
+            if let Ok(Event::Quit) = receiver.try_recv() {
-                // we can either get a message from the websocket to pass to simconnect
+                break;
-
-                // we can get a message from simconnect to pass to the websocket
-
-                // or we get a quit event from the event channel
             }
+
+            // handle simconnect stuff here
+
+            sleep(Duration::from_millis(100)).await;
         }
+
+        Ok(())
     }
 }
 
-pub async fn start() -> Result<(), anyhow::Error> {
+pub async fn start(
-    SimConnect::new().run().await?
+    simconnect_receiver: Receiver<SimConnectPacket>,
+    socket_sender: Sender<SimConnectPacket>,
+    sender: Sender<Event>,
+    receiver: Receiver<Event>,
+) -> Result<(), anyhow::Error> {
+    SimConnect::new(simconnect_receiver, socket_sender, sender, receiver)
+        .run()
+        .await?;
+
+    Ok(())
 }