freya-camera 0.4.0-rc.20

Camera capture support for Freya.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
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())
    }
}