Added logic for ringer and scheduler. still wip

src/main.rs

@@ -1,54 +1,51 @@
 use std::{
     sync::{Arc, Mutex},
-    thread,
 };
 
 use cron_tab::Cron;
-use gpio_cdev::{Chip, LineRequestFlags};
+use gpio_cdev::Chip;
+
+use crate::{ringer::BeepRinger, scheduler::Scheduler};
 
 mod handler;
 mod router;
+mod scheduler;
+mod ringer;
+
+#[derive(Clone)]
+struct AppState {
+	scheduler: Arc<Scheduler<BeepRinger>>
+}
+
+fn app_state() -> AppState {
+	let chip: Arc<Mutex<Chip>> = Arc::new(Mutex::new(Chip::new("/dev/gpiochip0").unwrap()));
+	let cron = Arc::new(Mutex::new(Cron::new(chrono::Local)));
+	AppState {
+		scheduler: Arc::new(Scheduler::new(
+			Arc::new(Mutex::new(BeepRinger::new(chip.clone()))),
+			cron.clone()
+		))
+	}
+}
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let chip = Arc::new(Mutex::new(Chip::new("/dev/gpiochip0")?));
-    let mut cron = Cron::new(chrono::Local);
     let static_time = "0 30 7 * * *";
+	let app_state = app_state();
 
-    println!("Adding alarm {}", static_time);
-    let job_result = cron.add_fn(static_time, move || {
-        let mut guard = chip.lock().unwrap();
-        alarm(&mut *guard).unwrap();
-    });
+	app_state.scheduler.schedule(static_time)?;
+	app_state.scheduler.start();
 
-    let _ = job_result.expect("Failed to add job");
-
-    cron.start();
-
-	start_server().await;
+	start_server(app_state).await;
 
 	Ok(())
 }
 
-async fn start_server() {
-    let router = router::router();
+
+async fn start_server(app_state: AppState) {
+    let router = router::router(app_state);
 	let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();
 
 	println!("Listening on http://0.0.0.0:8080");
 	axum::serve(listener, router).await.unwrap();
 }
-
-fn alarm(chip: &mut Chip) -> Result<(), Box<dyn std::error::Error>> {
-    let beeper = chip
-        .get_line(17)?
-        .request(LineRequestFlags::OUTPUT, 0, "my-gpio")?;
-
-    for _ in 0..5 {
-        beeper.set_value(1)?;
-        thread::sleep(std::time::Duration::from_secs(1));
-        beeper.set_value(0)?;
-        thread::sleep(std::time::Duration::from_secs(1));
-    }
-
-    Ok(())
-}

src/ringer.rs

@@ -0,0 +1,70 @@
+use std::{sync::{Arc, Mutex}, thread};
+
+use gpio_cdev::{Chip, LineRequestFlags};
+
+pub trait Ringer: Send + Sync {
+    fn ring(&self) -> Result<(), String>;
+}
+
+#[derive(Debug)]
+pub struct BeepRinger {
+    chip: Arc<Mutex<Chip>>,
+}
+
+impl BeepRinger {
+
+	fn beep(times: u32, chip: &mut Chip) -> Result<(), String> {
+		let beeper = chip.get_line(17);
+
+		let beeper = match beeper {
+			Ok(beeper) => beeper,
+			Err(e) => {
+				println!("Error opening line: {}", e);
+				return Err("Could not open Line to Beeper".to_string());
+			}
+		};
+
+
+		let beeper = beeper
+			.request(LineRequestFlags::OUTPUT, 0, "my-gpio");
+
+		let beeper = match beeper {
+			Ok(beeper) => beeper,
+			Err(e) => {
+				println!("Error requesting line: {}", e);
+				return Err("Could not request Line to Beeper".to_string());
+			}
+		};
+
+		for _ in 0..times {
+			beeper.set_value(1).map_err(|e| e.to_string())?;
+			thread::sleep(std::time::Duration::from_secs(1));
+			beeper.set_value(0).map_err(|e| e.to_string())?;
+			thread::sleep(std::time::Duration::from_secs(1));
+		}
+
+        return Ok(());
+	}
+
+	pub fn new(chip: Arc<Mutex<Chip>>) -> Self {
+		Self { chip }
+	}
+}
+
+impl Ringer for BeepRinger {
+    fn ring(&self) -> Result<(), String> {
+        let chip = self.chip.lock();
+
+        let mut chip = match chip {
+            Ok(chip) => chip,
+            Err(e) => {
+                println!("Error opening chip: {}", e);
+                return Err("Could not access Chip".to_string());
+            }
+        };
+
+		BeepRinger::beep(5, &mut *chip)?;
+
+		Ok(())
+    }
+}

src/router/alarm.rs

@@ -1,6 +1,6 @@
-use axum::{Router, routing::post};
-use crate::handler::alarm::create_alarm;
+use crate::{handler::alarm::create_alarm, AppState};
+use axum::{routing::post, Router};
 
-pub fn router() -> Router {
+pub fn router() -> Router<AppState> {
     Router::new().route("/", post(create_alarm))
 }

src/router/mod.rs

@@ -2,7 +2,8 @@ use axum::Router;
 
 mod alarm;
 
-pub fn router() -> Router {
+pub fn router(app_state: crate::AppState) -> Router {
     Router::new()
-		.nest("/alarm", alarm::router())
+        .nest("/alarm", alarm::router())
+        .with_state(app_state)
 }

src/scheduler.rs

@@ -0,0 +1,40 @@
+use std::sync::{Arc, Mutex};
+
+use chrono::Local;
+use cron_tab::Cron;
+
+use crate::ringer::Ringer;
+
+#[derive(Debug)]
+pub struct Scheduler<T: Ringer + 'static> {
+    ringer: Arc<Mutex<T>>,
+    cron: Arc<Mutex<Cron<Local>>>,
+}
+
+impl<T: Ringer> Scheduler<T> {
+    pub fn new(ringer: Arc<Mutex<T>>, cron: Arc<Mutex<Cron<Local>>>) -> Self {
+        Self { ringer, cron }
+    }
+
+    pub fn schedule(&self, cron_schedule: &str) -> Result<(), String> {
+        let ringer = self.ringer.clone();
+        let cron = self.cron.clone();
+
+        let job_result = cron
+            .lock()
+            .map_err(|e| e.to_string())?
+            .add_fn(cron_schedule, move || {
+                let guard = ringer.lock();
+                if let Ok(ringer) = guard {
+                    ringer.ring().unwrap();
+                }
+            });
+
+        job_result.expect("Faild to add job");
+        todo!()
+    }
+
+    pub fn start(&self) {
+        self.cron.lock().expect("Failed to lock cron").start();
+    }
+}