Merge pull request #28 from piotrpdev/OKO-105-Admin-Camera-Settings

feat: OKO-105 Admin Camera Settings

Author: piotrpdev

backend/fixtures/camera_settings.sql

@@ -1,3 +1,3 @@
 INSERT INTO camera_settings (setting_id, camera_id, flashlight_enabled, resolution, framerate, last_modified, modified_by) VALUES
-    (1, 1, false, '800x600', 5, '2024-10-21 17:02:33', 1),
-    (2, 2, false, '800x600', 5, '2024-10-21 17:02:25', 2);
+    (1, 1, false, 'SVGA', 5, '2024-10-21 17:02:33', 1),
+    (2, 2, false, 'SVGA', 5, '2024-10-21 17:02:25', 2);

backend/src/db/camera_setting.rs

@@ -187,7 +187,7 @@ mod tests {
         assert_eq!(returned_setting.setting_id, setting_id);
         assert_eq!(returned_setting.camera_id, 1);
         assert!(!returned_setting.flashlight_enabled);
-        assert_eq!(returned_setting.resolution, "800x600");
+        assert_eq!(returned_setting.resolution, "SVGA");
         assert_eq!(returned_setting.framerate, 5);
         assert_eq!(
             returned_setting.last_modified,

backend/src/web/app.rs

@@ -259,6 +259,7 @@ async fn ws_handler(
     ws.on_upgrade(move |socket| handle_socket(socket, addr, state, auth_session))
 }
 
+// ! Camera restart does not guarantee new recording, frames will keep going to the same video unless socket times out?
 // TODO: Find out if ECONNRESET after a while of no messages only affects vite dev server or if it is a general issue
 // ? Using tick await for empty tasks might not be the best idea
 /// Actual websocket statemachine (one will be spawned per connection)
@@ -369,11 +370,14 @@ async fn handle_socket(
         cameras = i_cameras;
     }
 
+    let initial_camera_settings_clone = initial_camera_settings.clone();
+
     // ? Maybe use spawn_blocking here, be aware .abort() is not available on blocking tasks
     // ? Maybe assume is camera if IP belongs to camera in DB
     // TODO: Handle stopping recording properly
     // TODO: Inform client/db if recording fails
     // TODO: Find out which is better, ingesting encoded or decoded images
+    // ! Camera restart does not guarantee new recording, frames will keep going to the same video unless socket times out?
     let mut recording_task: JoinHandle<Result<(), Box<dyn std::error::Error + Send + Sync>>> =
         if is_camera {
             // TODO: Check if errors are returned properly here, had some issues with the ? operator being silent
@@ -396,16 +400,38 @@ async fn handle_socket(
                 // ? Maybe don't create video until first frame (or maybe doing this is actually a good approach)?
                 video.create_using_self(&auth_session.backend.db).await?;
 
+                let (frame_width, frame_height, framerate) = match initial_camera_settings_clone {
+                    #[allow(clippy::match_same_arms)] // readability
+                    Some(settings) => {
+                        let (frame_width, frame_height) = match settings.resolution.as_str() {
+                            "SVGA" => (800, 600),
+                            "VGA" => (640, 480),
+                            _ => (800, 600),
+                        };
+
+                        (frame_width, frame_height, settings.framerate)
+                    }
+                    None => (800, 600, 12),
+                };
+
                 // TODO: Don't hardcode these
                 let video_fourcc = VideoWriter::fourcc('m', 'p', '4', 'v')?;
-                let video_size = Size::new(800, 600);
-                let mut video_writer =
-                    VideoWriter::new_def(&video.file_path, video_fourcc, 12.5, video_size)?;
+                let video_size = Size::new(frame_width, frame_height);
+                // TODO: Investigate why video is too fast
+                #[allow(clippy::cast_precision_loss)] // the precision loss is acceptable
+                let mut video_writer = VideoWriter::new_def(
+                    &video.file_path,
+                    video_fourcc,
+                    framerate as f64,
+                    video_size,
+                )?;
 
                 let mut total_bytes = 0;
 
                 let mut first_received = false;
                 // TODO: Adding a sleep might be a good idea?
+                // ! Camera restart does not guarantee new recording, frames will keep going to the same video unless socket times out?
+                // TODO: Handle if user changes resolution/framerate during recording (this is likely to happen)
                 loop {
                     // TODO: this might not be the best way of doing this
                     let message = (*images_rx_rec.borrow_and_update()).clone();

backend/src/web/protected.rs

@@ -36,6 +36,10 @@ pub fn router(api_channel: watch::Sender<ApiChannelMessage>) -> Router<()> {
             "/api/settings/:setting_id",
             patch(self::patch::camera_settings),
         )
+        .route(
+            "/api/cameras/:camera_id/restart",
+            post(self::post::camera_restart),
+        )
         .with_state(api_channel)
 }
 
@@ -221,10 +225,13 @@ mod get {
 
 mod post {
     use super::{AuthSession, IntoResponse, StatusCode};
+    use crate::ApiChannelMessage;
     use crate::{Camera, CameraPermission, CameraSetting, Model};
+    use axum::extract::{Path, State};
     use axum::Form;
     use axum::Json;
     use serde::Deserialize;
+    use tokio::sync::watch;
 
     #[derive(Debug, Clone, Deserialize)]
     pub struct AddCameraForm {
@@ -260,7 +267,7 @@ mod post {
                     setting_id: CameraSetting::DEFAULT.setting_id,
                     camera_id: camera.camera_id,
                     flashlight_enabled: CameraSetting::DEFAULT.flashlight_enabled,
-                    resolution: "800x600".to_string(),
+                    resolution: "SVGA".to_string(),
                     framerate: 5,
                     last_modified: CameraSetting::DEFAULT.last_modified(),
                     modified_by: Some(user.user_id),
@@ -295,6 +302,32 @@ mod post {
             None => StatusCode::UNAUTHORIZED.into_response(),
         }
     }
+
+    pub async fn camera_restart(
+        auth_session: AuthSession,
+        Path(camera_id): Path<i64>,
+        state: State<watch::Sender<ApiChannelMessage>>,
+    ) -> impl IntoResponse {
+        match auth_session.user {
+            Some(user) => {
+                if user.username != "admin" {
+                    return StatusCode::FORBIDDEN.into_response();
+                }
+
+                let api_message = ApiChannelMessage::CameraRelated {
+                    camera_id,
+                    message: crate::web::CameraMessage::Restart,
+                };
+
+                if state.send(api_message).is_err() {
+                    return StatusCode::INTERNAL_SERVER_ERROR.into_response();
+                }
+
+                StatusCode::OK.into_response()
+            }
+            None => StatusCode::UNAUTHORIZED.into_response(),
+        }
+    }
 }
 
 // TODO: Don't always return the same error
@@ -352,8 +385,8 @@ mod patch {
     #[derive(Debug, Clone, Deserialize)]
     pub struct UpdateSettingsForm {
         pub flashlight_enabled: bool,
-        // pub resolution: String,
-        // pub framerate: i64
+        pub resolution: String,
+        pub framerate: i64,
     }
 
     pub async fn camera_settings(
@@ -384,10 +417,23 @@ mod patch {
                     return StatusCode::FORBIDDEN.into_response();
                 }
 
-                // TODO: Update resolution and framerate
+                // TODO: resolution
                 setting.flashlight_enabled = settings_form.flashlight_enabled;
-                // setting.resolution = settings_form.resolution;
-                // setting.framerate = settings_form.framerate;
+
+                // ? Maybe allow any framerate/resolution for admin but give warning
+                if user.username == "admin" {
+                    if (settings_form.framerate < 1) || (settings_form.framerate > 60) {
+                        return StatusCode::BAD_REQUEST.into_response();
+                    }
+
+                    if !["SVGA", "VGA"].contains(&settings_form.resolution.as_str()) {
+                        return StatusCode::BAD_REQUEST.into_response();
+                    }
+
+                    setting.resolution = settings_form.resolution;
+                    setting.framerate = settings_form.framerate;
+                }
+
                 setting.last_modified = CameraSetting::DEFAULT.last_modified();
                 setting.modified_by = Some(user.user_id);
 

backend/tests/web.rs

@@ -849,7 +849,7 @@ async fn camera_setting_updates(
     assert_eq!(camera_setting.camera_id, 2);
     assert_eq!(camera_setting.setting_id, 2);
     assert!(!camera_setting.flashlight_enabled);
-    assert_eq!(camera_setting.resolution, "800x600");
+    assert_eq!(camera_setting.resolution, "SVGA");
     assert_eq!(camera_setting.framerate, 5);
     assert_eq!(camera_setting.modified_by, Some(2));
     assert_eq!(
@@ -898,7 +898,7 @@ async fn camera_setting_updates(
     assert_eq!(updated_camera_setting.camera_id, 2);
     assert_eq!(updated_camera_setting.setting_id, 2);
     assert!(updated_camera_setting.flashlight_enabled);
-    assert_eq!(updated_camera_setting.resolution, "800x600");
+    assert_eq!(updated_camera_setting.resolution, "SVGA");
     assert_eq!(updated_camera_setting.framerate, 5);
     assert_eq!(updated_camera_setting.modified_by, Some(1));
     assert!(updated_camera_setting.last_modified > camera_setting.last_modified);