input_pipeline/light_sensor/
calibrator.rs

1// Copyright 2022 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use super::types::FileLoader;
6use crate::light_sensor::led_watcher::LedState;
7use crate::light_sensor::types::{Calibration, Parameters, Rgbc};
8use anyhow::{format_err, Context, Error};
9use async_trait::async_trait;
10use fidl::endpoints::create_proxy;
11use fidl_fuchsia_factory::MiscFactoryStoreProviderProxy;
12use fidl_fuchsia_io::{DirectoryMarker, DirectoryProxy};
13use std::cell::RefCell;
14use std::rc::Rc;
15
16/// Represents the types of LEDs that are tracked.
17#[derive(Debug, Clone)]
18enum LedType {
19    /// Represents the backlight display.
20    Backlight,
21    /// Represents a specific LED on the device.
22    Named(String),
23}
24
25/// Tracks the coexistence (coex) impact and last brightness of a particular LED. The coex impact is
26/// the impact an LED has on the light sensor when it is turned on.
27#[derive(Debug, Clone)]
28struct CoexLed {
29    led_type: LedType,
30    /// The impact of the LED on the light sensor when it's turned on to its maximum brightest.
31    coex_at_max: Rgbc<f32>,
32    /// The last read brightness for this LED.
33    last_brightness: Option<f32>,
34}
35
36impl CoexLed {
37    fn new(led_type: LedType, coex_at_max: Rgbc<f32>) -> Self {
38        Self { led_type, coex_at_max, last_brightness: None }
39    }
40}
41
42/// Subtract the right value's intercept from the left value's intercept for each color channel.
43fn calculate_coex(left: Rgbc<Parameters>, right: Rgbc<Parameters>) -> Rgbc<f32> {
44    left.map(|c| c.intercept) - right.map(|c| c.intercept)
45}
46
47pub trait Calibrate {
48    /// Calibrate the supplied `sensor_data`.
49    fn calibrate(&self, rgbc: Rgbc<f32>) -> Rgbc<f32>;
50}
51
52/// Handles the calibration calculation.
53#[derive(Clone, Debug)]
54pub struct Calibrator<T> {
55    calibration: Calibration,
56    led_state: T,
57    coex_leds: Rc<RefCell<Vec<CoexLed>>>,
58}
59
60impl<T> Calibrator<T>
61where
62    T: LedState,
63{
64    /// Create a new [CalibrationController].
65    pub(crate) fn new(calibration: Calibration, led_state: T) -> Self {
66        let mut coex_leds: Vec<_> = led_state
67            .light_groups()
68            .into_iter()
69            .filter_map(|(name, light_group)| {
70                calibration.leds().get(&name).copied().map(|cal| (light_group, cal))
71            })
72            .map(|(light_group, cal)| {
73                let coex_at_max = calculate_coex(cal, calibration.off());
74                CoexLed::new(LedType::Named(light_group.name().clone()), coex_at_max)
75            })
76            .collect();
77        // To get the coex for the backlight, get the coex for all lights on...
78        let mut all_coex_at_max = calculate_coex(calibration.all_on(), calibration.off());
79
80        // and then remove the impact from the other leds.
81        for coex_led in &coex_leds {
82            all_coex_at_max = all_coex_at_max - coex_led.coex_at_max;
83        }
84
85        let _ = coex_leds.push(CoexLed::new(LedType::Backlight, all_coex_at_max));
86        Self { calibration, led_state, coex_leds: Rc::new(RefCell::new(coex_leds)) }
87    }
88}
89
90impl<T> Calibrate for Calibrator<T>
91where
92    T: LedState,
93{
94    fn calibrate(&self, sensor_data: Rgbc<f32>) -> Rgbc<f32> {
95        let backlight_brightness = self.led_state.backlight_brightness();
96        let light_groups = self.led_state.light_groups();
97        let total_coex_impact =
98            self.coex_leds.borrow_mut().iter_mut().fold(Rgbc::<f32>::default(), |acc, coex_led| {
99                let current_brightness = match &coex_led.led_type {
100                    LedType::Backlight => {
101                        if backlight_brightness <= 0.0 {
102                            coex_led.last_brightness = None;
103                            return acc;
104                        }
105
106                        backlight_brightness
107                    }
108                    LedType::Named(led_name) => {
109                        let Some(light_group) = light_groups.get(&*led_name) else {
110                            return acc;
111                        };
112                        if let Some(brightness) = light_group.brightness() {
113                            brightness
114                        } else {
115                            coex_led.last_brightness = None;
116                            return acc;
117                        }
118                    }
119                };
120
121                let mean_brightness = match (current_brightness, coex_led.last_brightness) {
122                    (current_brightness, Some(last_brightness)) if current_brightness >= 0.0 => {
123                        (current_brightness + last_brightness) / 2.0
124                    }
125                    (_, Some(last_brightness)) => last_brightness,
126                    (current_brightness, _) => current_brightness,
127                };
128
129                coex_led.last_brightness = Some(current_brightness);
130                acc + coex_led.coex_at_max.map(|c| mean_brightness * c)
131            });
132        let compensated_for_coex = (sensor_data - total_coex_impact).map(|c| c.max(0.0));
133        compensated_for_coex * self.calibration.calibrated_slope()
134    }
135}
136
137pub struct FactoryFileLoader {
138    directory_proxy: DirectoryProxy,
139}
140
141impl FactoryFileLoader {
142    pub fn new(factory_store_proxy: MiscFactoryStoreProviderProxy) -> Result<Self, Error> {
143        let (directory_proxy, directory_server_end) = create_proxy::<DirectoryMarker>();
144        factory_store_proxy
145            .get_factory_store(directory_server_end)
146            .map_err(|e| format_err!("{:?}", e))
147            .context("Update to get factory store")?;
148        Ok(Self { directory_proxy })
149    }
150}
151
152#[async_trait(?Send)]
153impl FileLoader for FactoryFileLoader {
154    async fn load_file(&self, file_path: &str) -> Result<String, Error> {
155        let file_proxy = fuchsia_fs::directory::open_file(
156            &self.directory_proxy,
157            file_path,
158            fuchsia_fs::PERM_READABLE,
159        )
160        .await
161        .with_context(|| format!("Failed to open configuration at {:?}", file_path))?;
162        fuchsia_fs::file::read_to_string(&file_proxy)
163            .await
164            .map_err(|e| format_err!("{:?}", e))
165            .with_context(|| format!("Failed to read contents of {:?}", file_path))
166    }
167}
168
169#[cfg(test)]
170mod calibrator_tests;
input_pipeline/light_sensor/calibrator.rs

input_pipeline/light_sensor/
calibrator.rs
