Code cleanup

src/gtfs/loader.rs

@@ -1,4 +1,4 @@
-use log::{debug, info, warn};
+use log::debug;
 use gtfs_structures::{Calendar, CalendarDate, RawStopTime, RawTrip, Route, Stop};
 use serde::de::DeserializeOwned;
 use std::{

src/main.rs

@@ -1,13 +1,20 @@
 mod gtfs;
 mod renderer;
-use std::{collections::HashSet, ops::Add, thread::{Builder}, time::SystemTime};
+use std::{collections::HashSet, ops::Add, process, thread::Builder, time::SystemTime};
 use chrono::{DateTime, Duration, Local, NaiveTime};
-use log::{Metadata, Record, debug, info};
+use log::{Metadata, Record, debug, error, info};
-use crate::gtfs::structs::{Arrival, Gtfs};
+use sdl3::event::Event;
+use crate::{gtfs::structs::{Arrival, Gtfs}, renderer::structs::Screen};
 
 const SRC_FILE: &str = "/home/nahuel/Downloads/GTFS_Realtime.zip";
 const NUM_ARRIVALS: usize = 4;
 
+// Custom Event to signal data refresh
+#[derive(Debug)] 
+struct RefreshDataEvent {
+}
+
+
 fn refresh_schedule(gtfs: &Gtfs) -> Box<Vec<Arrival<'_>>>  {
     let current_timestamp = SystemTime::now();
     let datetime: DateTime<Local> = current_timestamp.clone().into(); 
@@ -27,8 +34,6 @@ fn refresh_schedule(gtfs: &Gtfs) -> Box<Vec<Arrival<'_>>>  {
 
 
 fn main() {
-
-
     // Initialize logger
     static MY_LOGGER: MyLogger = MyLogger;
     struct MyLogger;
@@ -49,12 +54,13 @@ fn main() {
     log::set_logger(&MY_LOGGER).unwrap();
     log::set_max_level(log::LevelFilter::Trace);
 
+    // Create preferences structures from config
     let gtfs_prefs = gtfs::structs::Preferences  {
         route_numbers: HashSet::from([String::from("15A"), String::from("F1"), String::from("F2"), String::from("F3")]),
         stop_codes: HashSet::from([String::from("1117")])
     };
 
-    let _screen_prefs = renderer::structs::Prefs {
+    let screen_prefs = renderer::structs::Prefs {
         font_path: String::from("resources/jd_lcd_rounded/jd-lcd-rounded.ttf"),
         screen_width: 1920,
         screen_height: 720,
@@ -65,42 +71,56 @@ fn main() {
     let gtfs = Gtfs::load(SRC_FILE, &gtfs_prefs);
 
     // Init screen
-    //println!("Initializing screen...");
+    info!("Initializing screen...");
-    //let screen = Screen::init(&screen_prefs);
+    let screen = Screen::init(&screen_prefs);
-    //println!("Startup done.");
+    info!("Startup done.");
+
+    // Register our custom event and obtain the event-related objects to interact with the event loop
+    screen.get_context().event().unwrap().register_custom_event::<RefreshDataEvent>().unwrap();
+    let mut event_pump = screen.get_context().event_pump().unwrap();
+    let event_sender = screen.get_context().event().unwrap().event_sender();
 
     // Start an asynchronous refresh thread
-    let update_thread = Builder::new()
+    let _update_thread = Builder::new()
         .name("updater".to_string())
         .spawn(move || { 
             loop {
-                let _data = refresh_schedule(&gtfs);
-                debug!("-------------------------------- Refresh done.");
                 std::thread::sleep(std::time::Duration::new(60,0));
+                let event = RefreshDataEvent {};
+                let send_result = event_sender.push_custom_event(event);
+                if send_result.is_err() {
+                    error!("Error sending custom event: {:#?}", send_result);
+                    process::exit(-1);
+                }
             };
         }).unwrap();
 
-    let _ = update_thread.join();
-
 
     // Main event loop
-    /*
-    let mut event_pump = screen.get_context().event_pump().unwrap();
     loop {
         let event = event_pump.wait_event();
         
         match event {
+            // Handle application quit
             Event::Quit { timestamp: _  } => {
                 process::exit(0);
             }
 
-            Event::User { timestamp: _, window_id: _, type_: _, code: _, data1: _, data2: _ } => {
+            // Handle user events
-                // a message from another thread, probably a refresh?
+            Event::User { timestamp: _, window_id: _, type_: _u32, code: _i32, data1: _, data2: _ } => {
+                // Is the custom event a Refresh Data event?
+                let refresh_data = event.as_user_event_type::<RefreshDataEvent>();
+                if refresh_data.is_some() {
+                    debug!("Received user event: {:#?}", refresh_data.unwrap());
+                    let _data: Box<Vec<Arrival<'_>>> = refresh_schedule(&gtfs);
+                    debug!("-------------------------------- Refresh done.");
+                }
             }
 
             // Ignore all other events
-            _ => {}
+            _ => {
+            }
         }
 
-    }    */
+    }  
 }

src/renderer/mod.rs

@@ -8,11 +8,11 @@ use crate::renderer::structs::Screen;
 
 impl Screen<'_> {
 
-    pub fn _get_context(&self) -> &Sdl {
+    pub fn get_context(&self) -> &Sdl {
         return &self.context;
     }
 
-    pub fn _print(&mut self, line: u32, text: &str) {
+    pub fn print(&mut self, line: u32, text: &str) {
         let rendered_text = self.font.render(text).solid(Color::RED).unwrap();
         let texture_creator = self.canvas.texture_creator();
         let texture = rendered_text.as_texture(&texture_creator).unwrap();
@@ -31,7 +31,7 @@ impl Screen<'_> {
 
     /// Initialize video, allocate buffers and load fonts
     /// Based on https://github.com/vhspace/sdl3-rs/blob/master/examples/ttf-demo.rs
-    pub fn _init(prefs: &Prefs) -> Screen<'_> {
+    pub fn init(prefs: &Prefs) -> Screen<'_> {
         // Initialize the screen   
         let sdl_context = sdl3::init().unwrap();
         let video_subsys = sdl_context.video().unwrap();