feat(camera): Bring back freya-camera (#1835)

Author: marc2332

CONTRIBUTING.md

@@ -101,6 +101,7 @@ Freya is split in various crates, each with it's own meaning and purpose, here i
 - `freya-material-design`: Material Design Components for Freya apps.
 - `freya-plotters-backend`: Freya's skia-safe backend for plotters.
 - `freya-code-editor`: Set of APIs to create text Code Editors in Freya.
+- `freya-camera`: Camera capture support for Freya.
 
 ## Examples
 All important examples are located in the  `./examples` folder although you might also find some in the form of docs comments in the code itself.

Cargo.toml

@@ -44,6 +44,7 @@ members = [
   "./crates/freya-webview",
   "./crates/freya-terminal",
   "./crates/freya-code-editor",
+  "./crates/freya-camera",
   "./crates/freya-android",
   "./examples/ai-chat",
   "./examples/state_query_sqlite",
@@ -83,6 +84,7 @@ freya-terminal = { path = "./crates/freya-terminal", version = "0.4.0-rc.19" }
 freya-code-editor = { path = "./crates/freya-code-editor", version = "0.4.0-rc.19", features = [
   "rust",
 ] }
+freya-camera = { path = "./crates/freya-camera", version = "0.4.0-rc.19" }
 freya-android = { path = "./crates/freya-android", version = "0.4.0-rc.19" }
 mundy = { version = "0.2.3", default-features = false, features = [
   "async-io",
@@ -100,6 +102,7 @@ futures-util = "0.3.31"
 futures-channel = "0.3.31"
 futures-lite = "2.6.1"
 async-io = "2.5.0"
+async-channel = "2.5.0"
 blocking = "1.6.2"
 ureq = "3.1.4"
 serde = { version = "1", features = ["derive"] }

crates/freya-camera/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "freya-camera"
+version = "0.4.0-rc.19"
+description = "Camera capture support for Freya."
+edition = "2024"
+license = "MIT"
+authors = ["Marc Espín <mespinsanz@gmail.com>"]
+readme = "../../README.md"
+homepage = "https://freyaui.dev/"
+repository = "https://github.com/marc2332/freya"
+keywords = ["freya", "camera", "webcam", "video"]
+categories = ["gui", "multimedia::video"]
+
+[lints]
+workspace = true
+
+[dependencies]
+freya-core = { workspace = true }
+freya-engine = { workspace = true }
+nokhwa = { version = "0.10", features = ["input-native"] }
+blocking = { workspace = true }
+bytes = { workspace = true }
+tracing = { workspace = true }
+
+[dev-dependencies]
+freya = { path = "../freya" }

crates/freya-camera/src/camera.rs

@@ -0,0 +1,86 @@
+//! Camera configuration types.
+
+pub use nokhwa::{
+    NokhwaError as CameraError,
+    utils::{
+        CameraIndex,
+        CameraInfo,
+    },
+};
+use nokhwa::{
+    query as nokhwa_query,
+    utils::ApiBackend,
+};
+
+/// Requested capture format. The negotiated values are reported via [`StreamInfo`].
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Default)]
+pub enum CameraFormat {
+    /// Highest framerate available, any resolution.
+    #[default]
+    HighestFrameRate,
+    /// Highest resolution available, any framerate.
+    HighestResolution,
+    /// Highest framerate at the given resolution.
+    Resolution { width: u32, height: u32 },
+    /// Closest match to the given resolution and framerate.
+    Exact {
+        width: u32,
+        height: u32,
+        frame_rate: u32,
+    },
+}
+
+/// Configuration used to open a camera.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct CameraConfig {
+    pub device: CameraIndex,
+    pub format: CameraFormat,
+}
+
+impl Default for CameraConfig {
+    fn default() -> Self {
+        Self {
+            device: CameraIndex::Index(0),
+            format: CameraFormat::default(),
+        }
+    }
+}
+
+impl CameraConfig {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn device(mut self, device: CameraIndex) -> Self {
+        self.device = device;
+        self
+    }
+
+    pub fn format(mut self, format: CameraFormat) -> Self {
+        self.format = format;
+        self
+    }
+}
+
+/// Negotiated information about a running camera.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct StreamInfo {
+    pub width: u32,
+    pub height: u32,
+    pub frame_rate: u32,
+}
+
+/// Enumerate the cameras available on the system.
+///
+/// # Example
+///
+/// ```rust, no_run
+/// use freya::camera::*;
+///
+/// for device in query().unwrap_or_default() {
+///     println!("{}: {}", device.human_name(), device.description());
+/// }
+/// ```
+pub fn query() -> Result<Vec<CameraInfo>, CameraError> {
+    nokhwa_query(ApiBackend::Auto)
+}

crates/freya-camera/src/camera_viewer.rs

@@ -0,0 +1,153 @@
+//! [`CameraViewer`] component.
+
+use freya_core::{
+    elements::image::*,
+    prelude::*,
+};
+
+use crate::{
+    camera::CameraError,
+    use_camera::Camera,
+};
+
+/// Renders the latest frame produced by a [`Camera`].
+///
+/// # Example
+///
+/// ```rust, no_run
+/// use freya::{
+///     camera::*,
+///     prelude::*,
+/// };
+///
+/// fn app() -> impl IntoElement {
+///     let camera = use_camera(CameraConfig::default);
+///     CameraViewer::new(camera)
+/// }
+/// ```
+#[derive(PartialEq)]
+pub struct CameraViewer {
+    camera: Camera,
+
+    layout: LayoutData,
+    image_data: ImageData,
+    accessibility: AccessibilityData,
+    effect: EffectData,
+    corner_radius: Option<CornerRadius>,
+
+    children: Vec<Element>,
+    loading_placeholder: Option<Element>,
+    error_renderer: Option<Callback<CameraError, Element>>,
+
+    key: DiffKey,
+}
+
+impl CameraViewer {
+    pub fn new(camera: Camera) -> Self {
+        Self {
+            camera,
+            layout: LayoutData::default(),
+            image_data: ImageData::default(),
+            accessibility: AccessibilityData::default(),
+            effect: EffectData::default(),
+            corner_radius: None,
+            children: Vec::new(),
+            loading_placeholder: None,
+            error_renderer: None,
+            key: DiffKey::None,
+        }
+    }
+
+    pub fn corner_radius(mut self, corner_radius: impl Into<CornerRadius>) -> Self {
+        self.corner_radius = Some(corner_radius.into());
+        self
+    }
+
+    /// Custom element rendered while the camera has not yet produced a frame.
+    pub fn loading_placeholder(mut self, placeholder: impl Into<Element>) -> Self {
+        self.loading_placeholder = Some(placeholder.into());
+        self
+    }
+
+    /// Custom element rendered when the camera fails before producing any frame.
+    pub fn error_renderer(mut self, renderer: impl Into<Callback<CameraError, Element>>) -> Self {
+        self.error_renderer = Some(renderer.into());
+        self
+    }
+}
+
+impl KeyExt for CameraViewer {
+    fn write_key(&mut self) -> &mut DiffKey {
+        &mut self.key
+    }
+}
+
+impl LayoutExt for CameraViewer {
+    fn get_layout(&mut self) -> &mut LayoutData {
+        &mut self.layout
+    }
+}
+
+impl ContainerExt for CameraViewer {}
+impl ContainerWithContentExt for CameraViewer {}
+
+impl ImageExt for CameraViewer {
+    fn get_image_data(&mut self) -> &mut ImageData {
+        &mut self.image_data
+    }
+}
+
+impl AccessibilityExt for CameraViewer {
+    fn get_accessibility_data(&mut self) -> &mut AccessibilityData {
+        &mut self.accessibility
+    }
+}
+
+impl ChildrenExt for CameraViewer {
+    fn get_children(&mut self) -> &mut Vec<Element> {
+        &mut self.children
+    }
+}
+
+impl EffectExt for CameraViewer {
+    fn get_effect(&mut self) -> &mut EffectData {
+        &mut self.effect
+    }
+}
+
+impl Component for CameraViewer {
+    fn render(&self) -> impl IntoElement {
+        if let Some(holder) = self.camera.frame.read().clone() {
+            return image(holder)
+                .accessibility(self.accessibility.clone())
+                .a11y_role(AccessibilityRole::Image)
+                .a11y_focusable(true)
+                .layout(self.layout.clone())
+                .image_data(self.image_data.clone())
+                .effect(self.effect.clone())
+                .children(self.children.clone())
+                .map(self.corner_radius, |img, corner_radius| {
+                    img.corner_radius(corner_radius)
+                })
+                .into_element();
+        }
+
+        if let Some(renderer) = &self.error_renderer
+            && let Some(err) = self.camera.error.read().clone()
+        {
+            return renderer.call(err);
+        }
+
+        rect()
+            .layout(self.layout.clone())
+            .center()
+            .map(self.loading_placeholder.clone(), |r, placeholder| {
+                r.child(placeholder)
+            })
+            .into_element()
+    }
+
+    fn render_key(&self) -> DiffKey {
+        self.key.clone().or(self.default_key())
+    }
+}