Add start/stop and shutdown functionality

src/main.rs

@@ -1,18 +1,113 @@
 use anyhow::Result;
 use obws::Client;
+use clap::Parser;
+
+use tokio::time::{sleep_until, Instant, Duration};
+use tokio::process::Command;
+use serde::{Serialize, Deserialize};
 
 #[tokio::main]
 async fn main() -> Result<()> {
+    let args = Args::parse();
+
+     // Load run config
+    let cfg: RunConfig = match confy::load("obs-cli", None) {
+        Ok(cfg) => cfg,
+        Err(e) => {
+            println!("Error: {}", e);
+            RunConfig::default()
+        }
+    };
+
+    // Print the recording details
+    println!("Recording starts in {}min for {}min", args.start_minutes, args.duration_minutes);
+
+    // Wait the given amount of time
+    sleep_until(Instant::now() + Duration::from_secs(args.start_minutes * 60)).await;
+
     // Connect to the OBS instance through obs-websocket.
-    let client = Client::connect("localhost", 4455, Some("OBS")).await?;
+    let client = Client::connect("localhost", cfg.websocket_port, Some(cfg.websocket_password)).await?;
 
-    // Get and print out version information of OBS and obs-websocket.
-    let version = client.general().version().await?;
-    println!("{:#?}", version);
+    if let Ok(active) = is_recording(&client).await {
+        if active {
+            println!("Already recording. Exiting...");
+            return Ok(());
+        }
+    }
+
+    // Start the recording
+    start_recording(&client).await?;
+    println!("Recording started.");
+
+    // Wait for the recording to finish
+    sleep_until(Instant::now() + Duration::from_secs(args.duration_minutes * 60)).await;
+
+    // Stop the recording
+    stop_recording(&client).await?;
+    println!("Recording stopped.");
+
+    // Shutdown the machine
+    if args.poweroff {
+        // Wait a minute to give OBS some time to write data
+        sleep_until(Instant::now() + Duration::from_secs(60)).await;
+        shutdown().await?;
+    }
 
-    // Get a list of available scenes and print them out.
-    let scene_list = client.scenes().list().await?;
-    println!("{:#?}", scene_list);
 
     Ok(())
 }
+
+async fn start_recording(client: &Client) -> Result<(), obws::Error> {
+    client.recording().start().await?;
+    Ok(())
+}
+
+async fn stop_recording(client: &Client) -> Result<(), obws::Error> {
+    client.recording().stop().await?;
+    Ok(())
+}
+
+async fn is_recording(client: &Client) -> Result<bool, obws::Error> {
+    let status = client.recording().status().await?;
+    Ok(status.active)
+}
+
+async fn shutdown() -> Result<(), anyhow::Error> {
+    Command::new("poweroff").spawn().expect("Could not spawn process").wait().await?;
+    Ok(())
+}
+
+
+// obs-cli is a simple cli tool for planned obs recordings
+#[derive(Parser, Debug)]
+#[command(author, version, about, long_about = None)]
+struct Args {
+   /// Define the minutes where the recording should start
+   #[arg(short, long, default_value_t = 0)]
+   start_minutes: u64,
+
+   /// Define the duration of the recording in minutes
+   #[arg(short, long, default_value_t = 1)]
+   duration_minutes: u64,
+
+   /// Flag to shutdown the machine after recording.
+   #[arg(short, long, default_value_t = false)]
+   poweroff: bool,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+struct RunConfig {
+    websocket_port: u16, 
+    websocket_password: String,
+}
+
+/// `RunConfig` implements `Default`
+impl ::std::default::Default for RunConfig {
+    fn default() -> Self { 
+        Self { 
+            websocket_port: 4455, 
+            websocket_password: "Websocket".to_string()
+        } 
+    }
+}
+