blob: b13ea718c3b595a7a51a75d57af236bdeb274a72 [file] [log] [blame]
// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use crate::backlight::BacklightControl;
use crate::sender_channel::SenderChannel;
use crate::sensor::SensorControl;
use async_trait::async_trait;
use std::cmp;
use std::sync::Arc;
use anyhow::{format_err, Error};
use fidl_fuchsia_ui_brightness::{
ControlRequest as BrightnessControlRequest, ControlWatchAutoBrightnessAdjustmentResponder,
ControlWatchAutoBrightnessResponder, ControlWatchCurrentBrightnessResponder,
};
use fuchsia_async::{self as fasync, DurationExt};
use fuchsia_syslog::{self, fx_log_err, fx_log_info};
use fuchsia_zircon::sys::ZX_ERR_NOT_SUPPORTED;
use fuchsia_zircon::{Duration, DurationNum};
use futures::channel::mpsc::UnboundedSender;
use futures::future::{AbortHandle, Abortable};
use futures::lock::Mutex;
use futures::prelude::*;
use lazy_static::lazy_static;
use serde::{Deserialize, Serialize};
use serde_json;
use splines::{Interpolation, Key, Spline};
use std::{fs, io};
use watch_handler::{Sender, WatchHandler};
// Delay between sensor reads
const SLOW_SCAN_TIMEOUT_MS: i64 = 2000;
// Delay if we have made a large change in auto brightness
const QUICK_SCAN_TIMEOUT_MS: i64 = 100;
// What constitutes a large change in brightness?
// This seems small but it is significant and works nicely.
const LARGE_CHANGE_THRESHOLD_NITS: i32 = 0.016 as i32;
const AUTO_MINIMUM_BRIGHTNESS: f32 = 0.004;
const BRIGHTNESS_USER_MULTIPLIER_CENTER: f32 = 1.0;
const BRIGHTNESS_USER_MULTIPLIER_MAX: f32 = 8.0;
const BRIGHTNESS_USER_MULTIPLIER_MIN: f32 = 0.25;
const BRIGHTNESS_TABLE_FILE_PATH: &str = "/data/brightness_table";
const BRIGHTNESS_MINIMUM_CHANGE: f32 = 0.00001;
// Gives pleasing, smooth brightness ramp up and down
const BRIGHTNESS_STEP_SIZE: f32 = 0.001;
// Time between brightness steps. Any longer than this and the screen noticeably shimmers
const MAX_BRIGHTNESS_STEP_TIME_MS: i64 = 100;
// Brightness changes should take this time unless we exceed the MAX_BRIGHTNESS_STEP_TIME
const BRIGHTNESS_CHANGE_DURATION_MS: i64 = 2000;
#[derive(Serialize, Deserialize, Clone)]
struct BrightnessPoint {
ambient_lux: f32,
display_nits: f32,
}
#[derive(Serialize, Deserialize, Clone)]
struct BrightnessTable {
points: Vec<BrightnessPoint>,
}
impl From<fidl_fuchsia_ui_brightness::BrightnessPoint> for BrightnessPoint {
fn from(brightness_point: fidl_fuchsia_ui_brightness::BrightnessPoint) -> Self {
return BrightnessPoint {
ambient_lux: brightness_point.ambient_lux,
display_nits: brightness_point.display_nits,
};
}
}
impl From<fidl_fuchsia_ui_brightness::BrightnessTable> for BrightnessTable {
fn from(brightness_table: fidl_fuchsia_ui_brightness::BrightnessTable) -> Self {
let fidl_fuchsia_ui_brightness::BrightnessTable { points } = brightness_table;
return BrightnessTable { points: points.into_iter().map(|p| p.into()).collect() };
}
}
//This is the default table, and a default curve will be generated base on this table.
//This will be replaced once SetBrightnessTable is called.
lazy_static! {
static ref BRIGHTNESS_TABLE: Arc<Mutex<BrightnessTable>> = {
let mut lux_to_nits = Vec::new();
lux_to_nits.push(BrightnessPoint { ambient_lux: 0., display_nits: 0. });
lux_to_nits.push(BrightnessPoint { ambient_lux: 10., display_nits: 3.33 });
lux_to_nits.push(BrightnessPoint { ambient_lux: 30., display_nits: 8.7 });
lux_to_nits.push(BrightnessPoint { ambient_lux: 60., display_nits: 18.27 });
lux_to_nits.push(BrightnessPoint { ambient_lux: 100., display_nits: 32.785 });
lux_to_nits.push(BrightnessPoint { ambient_lux: 150., display_nits: 36.82 });
lux_to_nits.push(BrightnessPoint { ambient_lux: 210., display_nits: 75.0 });
lux_to_nits.push(BrightnessPoint { ambient_lux: 250., display_nits: 124.16 });
lux_to_nits.push(BrightnessPoint { ambient_lux: 300., display_nits: 162.96 });
lux_to_nits.push(BrightnessPoint { ambient_lux: 340., display_nits: 300. });
Arc::new(Mutex::new(BrightnessTable { points: lux_to_nits }))
};
}
lazy_static! {
static ref AUTO_BRIGHTNESS_ADJUSTMENT: Arc<Mutex<f32>> = Arc::new(Mutex::new(1.0));
static ref GET_BRIGHTNESS_FAILED_FIRST: Arc<Mutex<bool>> = Arc::new(Mutex::new(true));
static ref LAST_SET_BRIGHTNESS: Arc<Mutex<f32>> = Arc::new(Mutex::new(1.0));
static ref BRIGHTNESS_CHANGE_DURATION: Arc<Mutex<Duration>> =
Arc::new(Mutex::new(BRIGHTNESS_CHANGE_DURATION_MS.millis()));
}
pub struct WatcherCurrentResponder {
watcher_current_responder: ControlWatchCurrentBrightnessResponder,
}
impl Sender<f32> for WatcherCurrentResponder {
fn send_response(self, data: f32) {
if let Err(e) = self.watcher_current_responder.send(data) {
fx_log_err!("Failed to reply to WatchCurrentBrightness: {}", e);
}
}
}
pub struct WatcherAutoResponder {
watcher_auto_responder: ControlWatchAutoBrightnessResponder,
}
impl Sender<bool> for WatcherAutoResponder {
fn send_response(self, data: bool) {
if let Err(e) = self.watcher_auto_responder.send(data) {
fx_log_err!("Failed to reply to WatchAutoBrightness: {}", e);
}
}
}
pub struct WatcherAdjustmentResponder {
watcher_adjustment_responder: ControlWatchAutoBrightnessAdjustmentResponder,
}
impl Sender<f32> for WatcherAdjustmentResponder {
fn send_response(self, data: f32) {
if let Err(e) = self.watcher_adjustment_responder.send(data) {
fx_log_err!("Failed to reply to WatchAutoBrightnessAdjustment: {}", e);
}
}
}
pub struct Control {
sensor: Arc<Mutex<dyn SensorControl>>,
backlight: Arc<Mutex<dyn BacklightControl>>,
set_brightness_abort_handle: Arc<Mutex<Option<AbortHandle>>>,
auto_brightness_abort_handle: Option<AbortHandle>,
spline: Spline<f32, f32>,
current_sender_channel: Arc<Mutex<SenderChannel<f32>>>,
auto_sender_channel: Arc<Mutex<SenderChannel<bool>>>,
adjustment_sender_channel: Arc<Mutex<SenderChannel<f32>>>,
}
impl Control {
pub async fn new(
sensor: Arc<Mutex<dyn SensorControl>>,
backlight: Arc<Mutex<dyn BacklightControl>>,
current_sender_channel: Arc<Mutex<SenderChannel<f32>>>,
auto_sender_channel: Arc<Mutex<SenderChannel<bool>>>,
adjustment_sender_channel: Arc<Mutex<SenderChannel<f32>>>,
) -> Control {
fx_log_info!("New Control class");
let set_brightness_abort_handle = Arc::new(Mutex::new(None::<AbortHandle>));
let default_table_points = &*BRIGHTNESS_TABLE.lock().await.points;
let brightness_table = read_brightness_table_file(BRIGHTNESS_TABLE_FILE_PATH)
.unwrap_or_else(|e| {
fx_log_err!("Error occurred when trying to read existing settings: {}, using default table instead.", e);
BrightnessTable { points: default_table_points.to_vec() }
});
let spline = generate_spline(&brightness_table);
let auto_brightness_abort_handle = None::<AbortHandle>;
let mut result = Control {
backlight,
sensor,
set_brightness_abort_handle,
auto_brightness_abort_handle,
spline,
current_sender_channel,
auto_sender_channel,
adjustment_sender_channel,
};
// Startup auto-brightness loop
result.start_auto_brightness_task();
result
}
pub async fn handle_request(
&mut self,
request: BrightnessControlRequest,
watch_current_handler: Arc<Mutex<WatchHandler<f32, WatcherCurrentResponder>>>,
watch_auto_handler: Arc<Mutex<WatchHandler<bool, WatcherAutoResponder>>>,
watch_adjustment_handler: Arc<Mutex<WatchHandler<f32, WatcherAdjustmentResponder>>>,
) {
// TODO(kpt): "Consider adding additional tests against the resulting FIDL service itself so
// that you can ensure it continues serving clients correctly."
match request {
BrightnessControlRequest::SetAutoBrightness { control_handle: _ } => {
self.set_auto_brightness().await;
}
BrightnessControlRequest::WatchAutoBrightness { responder } => {
let watch_auto_result =
self.watch_auto_brightness(watch_auto_handler, responder).await;
match watch_auto_result {
Ok(_v) => {}
Err(e) => fx_log_err!("Watch auto brightness failed due to err {}.", e),
}
}
BrightnessControlRequest::SetManualBrightness { value, control_handle: _ } => {
let value = num_traits::clamp(value, 0.0, 1.0);
self.set_manual_brightness(value).await;
}
BrightnessControlRequest::SetManualBrightnessSmooth {
value,
duration,
control_handle: _,
} => {
self.set_manual_brightness_smooth(value, duration).await;
}
BrightnessControlRequest::WatchCurrentBrightness { responder } => {
let watch_current_result =
self.watch_current_brightness(watch_current_handler, responder).await;
match watch_current_result {
Ok(_v) => {}
Err(e) => fx_log_err!("Watch current brightness failed due to err {}.", e),
}
}
BrightnessControlRequest::SetBrightnessTable { table, control_handle: _ } => {
let result = self.check_brightness_table_and_set_new_curve(&table.into()).await;
match result {
Ok(_v) => fx_log_info!("Brightness table is valid and set"),
Err(e) => {
// TODO(lingxueluo): Close the connection if brightness table not valid.
fx_log_err!("Brightness table is not valid because {}", e);
}
}
}
BrightnessControlRequest::SetAutoBrightnessAdjustment {
adjustment,
control_handle: _,
} => {
self.scale_new_adjustment(adjustment).await;
}
BrightnessControlRequest::WatchAutoBrightnessAdjustment { responder } => {
let watch_adjustment_result = self
.watch_auto_brightness_adjustment(watch_adjustment_handler, responder)
.await;
match watch_adjustment_result {
Ok(_v) => {}
Err(e) => fx_log_err!("Watch adjustment failed due to err {}.", e),
}
}
BrightnessControlRequest::GetMaxAbsoluteBrightness { responder } => {
let result = self.get_max_absolute_brightness();
match result.await {
Ok(value) => {
if let Err(e) = responder.send(&mut Ok(value)) {
fx_log_err!("Failed to reply to GetMaxAbsoluteBrightness: {}", e);
}
}
Err(e) => {
fx_log_err!("Failed to get max absolute brightness: {}", e);
if let Err(e) = responder.send(&mut Err(ZX_ERR_NOT_SUPPORTED)) {
fx_log_err!("Failed to reply to GetMaxAbsoluteBrightness: {}", e);
}
}
}
}
}
}
pub async fn add_current_sender_channel(&mut self, sender: UnboundedSender<f32>) {
self.current_sender_channel.lock().await.add_sender_channel(sender).await;
}
pub async fn add_auto_sender_channel(&mut self, sender: UnboundedSender<bool>) {
self.auto_sender_channel.lock().await.add_sender_channel(sender).await;
}
pub async fn add_adjustment_sender_channel(&mut self, sender: UnboundedSender<f32>) {
self.adjustment_sender_channel.lock().await.add_sender_channel(sender).await;
}
pub fn get_backlight_and_auto_brightness_on(
&mut self,
) -> (Arc<Mutex<dyn BacklightControl>>, bool) {
(self.backlight.clone(), self.auto_brightness_abort_handle.is_some())
}
// FIDL message handlers
async fn set_auto_brightness(&mut self) {
if self.auto_brightness_abort_handle.is_none() {
fx_log_info!("Auto-brightness turned on");
self.start_auto_brightness_task();
self.auto_sender_channel
.lock()
.await
.send_value(self.auto_brightness_abort_handle.is_some());
}
}
async fn watch_auto_brightness(
&mut self,
watch_auto_handler: Arc<Mutex<WatchHandler<bool, WatcherAutoResponder>>>,
responder: ControlWatchAutoBrightnessResponder,
) -> Result<(), Error> {
let mut hanging_get_lock = watch_auto_handler.lock().await;
hanging_get_lock.watch(WatcherAutoResponder { watcher_auto_responder: responder })?;
Ok(())
}
fn start_auto_brightness_task(&mut self) {
if let Some(handle) = &self.auto_brightness_abort_handle.take() {
handle.abort();
}
let backlight = self.backlight.clone();
let sensor = self.sensor.clone();
let set_brightness_abort_handle = self.set_brightness_abort_handle.clone();
let current_sender_channel = self.current_sender_channel.clone();
let spline = self.spline.clone();
let (abort_handle, abort_registration) = AbortHandle::new_pair();
fasync::Task::spawn(
Abortable::new(
async move {
let backlight = backlight.clone();
let max_brightness = {
let backlight = backlight.clone();
let backlight = backlight.lock().await;
let max_result = backlight.get_max_absolute_brightness();
match max_result.await {
Ok(max_value) => max_value,
Err(_e) => 250.0,
}
};
// initialize to an impossible number
let mut last_value: i32 = -1;
loop {
let current_sender_channel = current_sender_channel.clone();
let sensor = sensor.clone();
let mut value =
read_sensor_and_get_brightness(sensor, &spline, max_brightness).await;
let adjustment = *AUTO_BRIGHTNESS_ADJUSTMENT.lock().await;
value = num_traits::clamp(value * adjustment, AUTO_MINIMUM_BRIGHTNESS, 1.0);
set_brightness(
value,
set_brightness_abort_handle.clone(),
backlight.clone(),
current_sender_channel,
)
.await;
let large_change =
(last_value as i32 - value as i32).abs() > LARGE_CHANGE_THRESHOLD_NITS;
last_value = value as i32;
let delay_timeout =
if large_change { QUICK_SCAN_TIMEOUT_MS } else { SLOW_SCAN_TIMEOUT_MS };
fuchsia_async::Timer::new(Duration::from_millis(delay_timeout).after_now())
.await;
}
},
abort_registration,
)
.unwrap_or_else(|_| ()),
)
.detach();
self.auto_brightness_abort_handle = Some(abort_handle);
}
async fn set_manual_brightness(&mut self, value: f32) {
if let Some(handle) = self.auto_brightness_abort_handle.take() {
fx_log_info!("Auto-brightness off, brightness set to {}", value);
handle.abort();
}
self.auto_sender_channel.lock().await.send_value(false);
let current_sender_channel = self.current_sender_channel.clone();
set_brightness(
value,
self.set_brightness_abort_handle.clone(),
self.backlight.clone(),
current_sender_channel,
)
.await;
}
async fn set_manual_brightness_smooth(&mut self, value: f32, duration: i64) {
let duration_nanos = Duration::from_nanos(duration);
*BRIGHTNESS_CHANGE_DURATION.lock().await = duration_nanos.into_millis().millis();
let value = num_traits::clamp(value, 0.0, 1.0);
self.set_manual_brightness(value).await;
}
async fn watch_current_brightness(
&mut self,
watch_current_handler: Arc<Mutex<WatchHandler<f32, WatcherCurrentResponder>>>,
responder: ControlWatchCurrentBrightnessResponder,
) -> Result<(), Error> {
let mut hanging_get_lock = watch_current_handler.lock().await;
hanging_get_lock.watch(WatcherCurrentResponder { watcher_current_responder: responder })?;
Ok(())
}
async fn set_brightness_curve(&mut self, table: &BrightnessTable) {
fx_log_info!("Setting new brightness curve.");
self.spline = generate_spline(table);
self.start_auto_brightness_task();
let result = self.store_brightness_table(table, BRIGHTNESS_TABLE_FILE_PATH);
match result {
Ok(_v) => fx_log_info!("Stored successfully"),
Err(e) => fx_log_info!("Didn't store successfully due to error {}", e),
}
}
fn store_brightness_table(
&mut self,
table: &BrightnessTable,
file_path: &str,
) -> Result<(), Error> {
fx_log_info!("Storing brightness table set.");
let file = fs::File::create(file_path)?;
serde_json::to_writer(io::BufWriter::new(file), &table)
.map_err(|e| anyhow::format_err!("Failed to write to file, ran into error: {:?}", e))
}
async fn check_brightness_table_and_set_new_curve(
&mut self,
table: &BrightnessTable,
) -> Result<(), Error> {
let BrightnessTable { points } = table;
if points.is_empty() {
fx_log_info!("Brightness table can not be empty, use the default table instead.");
let BrightnessTable { points } = &*BRIGHTNESS_TABLE.lock().await;
let brightness_table = BrightnessTable { points: points.to_vec() };
self.set_brightness_curve(&brightness_table).await;
return Ok(());
}
let mut last_lux = -1.0;
for brightness_point in points {
if brightness_point.ambient_lux < 0.0 || brightness_point.display_nits < 0.0 {
fx_log_info!("Lux or nits in this table is negative.");
return Err(format_err!(format!("Lux or nits in this table is negative.")));
}
if brightness_point.ambient_lux > last_lux {
last_lux = brightness_point.ambient_lux;
} else {
fx_log_info!("Not increasing lux in this table.");
return Err(format_err!(format!("Not increasing lux in this table.")));
}
}
self.set_brightness_curve(&table).await;
Ok(())
}
async fn scale_new_adjustment(&mut self, mut adjustment: f32) -> f32 {
self.adjustment_sender_channel.lock().await.send_value(adjustment);
// |adjustment| ranges from [-1.0, 1.0]
// Default adjustment is 0.0, map that to x1.0
if adjustment >= 0.0 {
// Map from [0.0, 1.0] to [BRIGHTNESS_USER_MULTIPLIER_CENTER,
// BRIGHTNESS_USER_MULTIPLIER_MAX]
adjustment = adjustment
* (BRIGHTNESS_USER_MULTIPLIER_MAX - BRIGHTNESS_USER_MULTIPLIER_CENTER)
+ BRIGHTNESS_USER_MULTIPLIER_CENTER;
} else {
// Map from [-1.0, 0.0) to [BRIGHTNESS_USER_MULTIPLIER_MIN,
// BRIGHTNESS_USER_MULTIPLIER_CENTER)
adjustment = adjustment
* (BRIGHTNESS_USER_MULTIPLIER_CENTER - BRIGHTNESS_USER_MULTIPLIER_MIN)
+ BRIGHTNESS_USER_MULTIPLIER_CENTER;
}
*AUTO_BRIGHTNESS_ADJUSTMENT.lock().await = adjustment;
return adjustment;
}
async fn watch_auto_brightness_adjustment(
&mut self,
watch_adjustment_handler: Arc<Mutex<WatchHandler<f32, WatcherAdjustmentResponder>>>,
responder: ControlWatchAutoBrightnessAdjustmentResponder,
) -> Result<(), Error> {
let mut hanging_get_lock = watch_adjustment_handler.lock().await;
hanging_get_lock
.watch(WatcherAdjustmentResponder { watcher_adjustment_responder: responder })?;
Ok(())
}
async fn get_max_absolute_brightness(&mut self) -> Result<f64, Error> {
let backlight = self.backlight.lock().await;
backlight.get_max_absolute_brightness().await
}
}
#[async_trait(? Send)]
pub trait ControlTrait {
async fn handle_request(
&mut self,
request: BrightnessControlRequest,
watch_current_handler: Arc<Mutex<WatchHandler<f32, WatcherCurrentResponder>>>,
watch_auto_handler: Arc<Mutex<WatchHandler<bool, WatcherAutoResponder>>>,
watch_adjustment_handler: Arc<Mutex<WatchHandler<f32, WatcherAdjustmentResponder>>>,
);
async fn add_current_sender_channel(&mut self, sender: UnboundedSender<f32>);
async fn add_auto_sender_channel(&mut self, sender: UnboundedSender<bool>);
async fn add_adjustment_sender_channel(&mut self, sender: UnboundedSender<f32>);
fn get_backlight_and_auto_brightness_on(&mut self) -> (Arc<Mutex<dyn BacklightControl>>, bool);
}
#[async_trait(? Send)]
impl ControlTrait for Control {
async fn handle_request(
&mut self,
request: BrightnessControlRequest,
watch_current_handler: Arc<Mutex<WatchHandler<f32, WatcherCurrentResponder>>>,
watch_auto_handler: Arc<Mutex<WatchHandler<bool, WatcherAutoResponder>>>,
watch_adjustment_handler: Arc<Mutex<WatchHandler<f32, WatcherAdjustmentResponder>>>,
) {
self.handle_request(
request,
watch_current_handler,
watch_auto_handler,
watch_adjustment_handler,
)
.await;
}
async fn add_current_sender_channel(&mut self, sender: UnboundedSender<f32>) {
self.add_current_sender_channel(sender).await;
}
async fn add_auto_sender_channel(&mut self, sender: UnboundedSender<bool>) {
self.add_auto_sender_channel(sender).await;
}
async fn add_adjustment_sender_channel(&mut self, sender: UnboundedSender<f32>) {
self.add_adjustment_sender_channel(sender).await;
}
fn get_backlight_and_auto_brightness_on(&mut self) -> (Arc<Mutex<dyn BacklightControl>>, bool) {
self.get_backlight_and_auto_brightness_on()
}
}
// TODO(kpt) Move all the folllowing functions into Control. This is delayed so that in the CL
// for the creation of this code the reviewer can see more easily that the code is unchanged
// after the extraction from main.rs.
fn read_brightness_table_file(path: &str) -> Result<BrightnessTable, Error> {
let file = fs::File::open(path)?;
let result = serde_json::from_reader(io::BufReader::new(file));
let result = result
.map_err(|e| anyhow::format_err!("Failed to read from file, ran into error: {:?}", e));
result
}
fn generate_spline(table: &BrightnessTable) -> Spline<f32, f32> {
let BrightnessTable { points } = table;
let mut lux_to_nits_table_to_splines = Vec::new();
for brightness_point in points {
lux_to_nits_table_to_splines.push(Key::new(
brightness_point.ambient_lux,
brightness_point.display_nits,
Interpolation::Linear,
));
}
Spline::from_iter(lux_to_nits_table_to_splines.iter().cloned())
}
// TODO(kpt) Move this and other functions into Control so that they can share the struct
/// Runs the main auto-brightness code.
/// This task monitors its running boolean and terminates if it goes false.
async fn get_current_brightness(backlight: Arc<Mutex<dyn BacklightControl>>) -> f32 {
let backlight = backlight.lock().await;
let fut = backlight.get_brightness();
// TODO(lingxueluo) Deal with this in backlight.rs later.
match fut.await {
Ok(brightness) => brightness as f32,
Err(e) => {
if *GET_BRIGHTNESS_FAILED_FIRST.lock().await {
fx_log_err!("Failed to get backlight: {}. assuming 1.0", e);
*GET_BRIGHTNESS_FAILED_FIRST.lock().await = false;
}
*LAST_SET_BRIGHTNESS.lock().await
}
}
}
async fn read_sensor_and_get_brightness(
sensor: Arc<Mutex<dyn SensorControl>>,
spline: &Spline<f32, f32>,
max_brightness: f64,
) -> f32 {
let lux = {
// Get the sensor reading in its own mutex block
let sensor = sensor.lock().await;
// TODO(kpt) Do we need a Mutex if sensor is only read?
let fut = sensor.read();
let report = fut.await.expect("Could not read from the sensor");
report.illuminance
};
brightness_curve_lux_to_nits(lux, spline).await / max_brightness as f32
}
async fn brightness_curve_lux_to_nits(lux: u16, spline: &Spline<f32, f32>) -> f32 {
let result = (*spline).clamped_sample(lux as f32);
match result {
Some(nits) => {
return nits;
}
None => return 1.0,
}
}
/// Sets the brightness of the backlight to a specific value.
/// An abortable task is spawned to handle this as it can take a while to do.
async fn set_brightness(
value: f32,
set_brightness_abort_handle: Arc<Mutex<Option<AbortHandle>>>,
backlight: Arc<Mutex<dyn BacklightControl>>,
current_sender_channel: Arc<Mutex<SenderChannel<f32>>>,
) {
let value = num_traits::clamp(value, 0.0, 1.0);
let current_value = get_current_brightness(backlight.clone()).await;
if (current_value - value).abs() >= BRIGHTNESS_STEP_SIZE {
let mut set_brightness_abort_handle = set_brightness_abort_handle.lock().await;
if let Some(handle) = set_brightness_abort_handle.take() {
handle.abort();
}
let (abort_handle, abort_registration) = AbortHandle::new_pair();
let backlight = backlight.clone();
let current_sender_channel = current_sender_channel.clone();
fasync::Task::spawn(
Abortable::new(
async move {
set_brightness_impl(value, backlight, current_sender_channel).await;
},
abort_registration,
)
.unwrap_or_else(|_task_aborted| ()),
)
.detach();
*set_brightness_abort_handle = Some(abort_handle);
} else if (current_value - value).abs() > BRIGHTNESS_MINIMUM_CHANGE {
set_brightness_impl(value, backlight, current_sender_channel).await;
}
}
async fn set_brightness_impl(
value: f32,
backlight: Arc<Mutex<dyn BacklightControl>>,
current_sender_channel: Arc<Mutex<SenderChannel<f32>>>,
) {
let current_value = get_current_brightness(backlight.clone()).await;
let mut backlight = backlight.lock().await;
let set_brightness = |value| {
backlight
.set_brightness(value)
.unwrap_or_else(|e| fx_log_err!("Failed to set backlight: {}", e))
};
let current_sender_channel = current_sender_channel.clone();
set_brightness_slowly(
current_value,
value,
set_brightness,
*BRIGHTNESS_CHANGE_DURATION.lock().await,
current_sender_channel,
)
.await;
}
/// Change the brightness of the screen slowly to `nits` nits. We don't want to change the screen
/// suddenly so we smooth the transition by doing it in a series of small steps.
/// The time per step can be changed if needed e.g. to fade up slowly and down quickly.
/// When testing we set time_per_step to zero.
async fn set_brightness_slowly(
current_value: f32,
to_value: f32,
mut set_brightness: impl FnMut(f64),
duration: Duration,
current_sender_channel: Arc<Mutex<SenderChannel<f32>>>,
) {
let mut current_value = current_value;
let to_value = num_traits::clamp(to_value, 0.0, 1.0);
assert!(to_value <= 1.0);
assert!(current_value <= 1.0);
let current_sender_channel = current_sender_channel.clone();
let difference = to_value - current_value;
let steps = (difference.abs() / BRIGHTNESS_STEP_SIZE) as u16;
if steps > 0 {
let time_per_step = cmp::min(duration / steps, MAX_BRIGHTNESS_STEP_TIME_MS.millis());
let step_size = difference / steps as f32;
for _i in 0..steps {
let current_sender_channel = current_sender_channel.clone();
current_value = current_value + step_size;
set_brightness(current_value as f64);
current_sender_channel.lock().await.send_value(current_value);
if time_per_step.into_millis() > 0 {
fuchsia_async::Timer::new(time_per_step.after_now()).await;
}
}
}
// Make sure we get to the correct value, there may be rounding errors
set_brightness(to_value as f64);
current_sender_channel.lock().await.send_value(current_value);
*LAST_SET_BRIGHTNESS.lock().await = to_value;
}
#[cfg(test)]
mod tests {
use super::*;
use crate::sender_channel::SenderChannel;
use crate::sensor::AmbientLightInputRpt;
use anyhow::{format_err, Error};
use async_trait::async_trait;
use std::path::Path;
struct MockSensor {
illuminence: u16,
}
#[async_trait]
impl SensorControl for MockSensor {
async fn read(&self) -> Result<AmbientLightInputRpt, Error> {
Ok(AmbientLightInputRpt {
rpt_id: 0,
state: 0,
event: 0,
illuminance: self.illuminence,
red: 0,
green: 0,
blue: 0,
})
}
}
struct MockBacklight {
valid_backlight: bool,
value: f64,
max_brightness: f64,
}
#[async_trait]
impl BacklightControl for MockBacklight {
async fn get_brightness(&self) -> Result<f64, Error> {
if self.valid_backlight {
Ok(self.value)
} else {
Err(format_err!("Get brightness failed."))
}
}
fn set_brightness(&mut self, value: f64) -> Result<(), Error> {
self.value = value;
Ok(())
}
async fn get_max_absolute_brightness(&self) -> Result<f64, Error> {
Ok(self.max_brightness)
}
}
fn set_mocks(
sensor: u16,
backlight: f64,
) -> (Arc<Mutex<impl SensorControl>>, Arc<Mutex<impl BacklightControl>>) {
let sensor = MockSensor { illuminence: sensor };
let sensor = Arc::new(Mutex::new(sensor));
let backlight =
MockBacklight { valid_backlight: true, value: backlight, max_brightness: 250.0 };
let backlight = Arc::new(Mutex::new(backlight));
(sensor, backlight)
}
fn set_mocks_not_valid(
sensor: u16,
backlight: f64,
) -> (Arc<Mutex<impl SensorControl>>, Arc<Mutex<impl BacklightControl>>) {
let sensor = MockSensor { illuminence: sensor };
let sensor = Arc::new(Mutex::new(sensor));
let backlight =
MockBacklight { valid_backlight: false, value: backlight, max_brightness: 250.0 };
let backlight = Arc::new(Mutex::new(backlight));
(sensor, backlight)
}
async fn generate_control_struct(sensor: u16, backlight: f64) -> Control {
let (sensor, backlight) = set_mocks(sensor, backlight);
let set_brightness_abort_handle = Arc::new(Mutex::new(None::<AbortHandle>));
let auto_brightness_abort_handle = None::<AbortHandle>;
let BrightnessTable { points } = &*BRIGHTNESS_TABLE.lock().await;
let brightness_table_old = BrightnessTable { points: points.to_vec() };
let spline_arg = generate_spline(brightness_table_old.clone());
let current_sender_channel: SenderChannel<f32> = SenderChannel::new();
let current_sender_channel = Arc::new(Mutex::new(current_sender_channel));
let auto_sender_channel: SenderChannel<bool> = SenderChannel::new();
let auto_sender_channel = Arc::new(Mutex::new(auto_sender_channel));
let adjustment_sender_channel: SenderChannel<f32> = SenderChannel::new();
let adjustment_sender_channel = Arc::new(Mutex::new(adjustment_sender_channel));
Control {
sensor,
backlight,
set_brightness_abort_handle,
auto_brightness_abort_handle,
spline: spline_arg,
current_sender_channel,
auto_sender_channel,
adjustment_sender_channel,
}
}
fn generate_spline(table: BrightnessTable) -> Spline<f32, f32> {
let BrightnessTable { points } = &table;
let mut lux_to_nits_table_to_splines = Vec::new();
for brightness_point in points {
lux_to_nits_table_to_splines.push(Key::new(
brightness_point.ambient_lux,
brightness_point.display_nits,
Interpolation::Linear,
));
}
Spline::from_iter(lux_to_nits_table_to_splines.iter().cloned())
}
fn cmp_float(value1: f32, value2: f32) -> bool {
(value1 - value2).abs() < 0.01
}
#[fasync::run_singlethreaded(test)]
async fn test_brightness_curve() {
let BrightnessTable { points } = &*BRIGHTNESS_TABLE.lock().await;
let brightness_table = BrightnessTable { points: points.to_vec() };
let spline = generate_spline(brightness_table);
assert_eq!(cmp_float(0., brightness_curve_lux_to_nits(0, &spline).await), true);
assert_eq!(cmp_float(0.333, brightness_curve_lux_to_nits(1, &spline).await), true);
assert_eq!(cmp_float(0.666, brightness_curve_lux_to_nits(2, &spline).await), true);
assert_eq!(cmp_float(4.67, brightness_curve_lux_to_nits(15, &spline).await), true);
assert_eq!(cmp_float(4.94, brightness_curve_lux_to_nits(16, &spline).await), true);
assert_eq!(cmp_float(32.78, brightness_curve_lux_to_nits(100, &spline).await), true);
assert_eq!(cmp_float(36.82, brightness_curve_lux_to_nits(150, &spline).await), true);
assert_eq!(cmp_float(68.63, brightness_curve_lux_to_nits(200, &spline).await), true);
assert_eq!(cmp_float(111.87, brightness_curve_lux_to_nits(240, &spline).await), true);
assert_eq!(cmp_float(162.96, brightness_curve_lux_to_nits(300, &spline).await), true);
assert_eq!(cmp_float(300., brightness_curve_lux_to_nits(340, &spline).await), true);
}
#[fasync::run_singlethreaded(test)]
async fn test_brightness_table_valid() {
let mut control = generate_control_struct(400, 0.5).await;
let brightness_table = {
let mut lux_to_nits = Vec::new();
lux_to_nits.push(BrightnessPoint { ambient_lux: 10., display_nits: 50. });
lux_to_nits.push(BrightnessPoint { ambient_lux: 30., display_nits: 50. });
lux_to_nits.push(BrightnessPoint { ambient_lux: 60., display_nits: 50. });
lux_to_nits.push(BrightnessPoint { ambient_lux: 100., display_nits: 50. });
lux_to_nits.push(BrightnessPoint { ambient_lux: 150., display_nits: 50. });
lux_to_nits.push(BrightnessPoint { ambient_lux: 210., display_nits: 50. });
lux_to_nits.push(BrightnessPoint { ambient_lux: 250., display_nits: 50. });
lux_to_nits.push(BrightnessPoint { ambient_lux: 300., display_nits: 50. });
BrightnessTable { points: lux_to_nits }
};
control.check_brightness_table_and_set_new_curve(&brightness_table).await.unwrap();
assert_eq!(cmp_float(50.0, brightness_curve_lux_to_nits(0, &control.spline).await), true);
assert_eq!(cmp_float(50.0, brightness_curve_lux_to_nits(1, &control.spline).await), true);
assert_eq!(cmp_float(50.0, brightness_curve_lux_to_nits(2, &control.spline).await), true);
assert_eq!(cmp_float(50.0, brightness_curve_lux_to_nits(15, &control.spline).await), true);
assert_eq!(cmp_float(50.0, brightness_curve_lux_to_nits(16, &control.spline).await), true);
assert_eq!(cmp_float(50.0, brightness_curve_lux_to_nits(100, &control.spline).await), true);
assert_eq!(cmp_float(50.0, brightness_curve_lux_to_nits(150, &control.spline).await), true);
assert_eq!(cmp_float(50.0, brightness_curve_lux_to_nits(200, &control.spline).await), true);
assert_eq!(cmp_float(50.0, brightness_curve_lux_to_nits(240, &control.spline).await), true);
assert_eq!(cmp_float(50.0, brightness_curve_lux_to_nits(300, &control.spline).await), true);
}
#[fasync::run_singlethreaded(test)]
async fn test_brightness_table_not_valid_negative_value() {
let mut control = generate_control_struct(400, 0.5).await;
let brightness_table = {
let mut lux_to_nits = Vec::new();
lux_to_nits.push(BrightnessPoint { ambient_lux: -10., display_nits: 50. });
lux_to_nits.push(BrightnessPoint { ambient_lux: 30., display_nits: 50. });
BrightnessTable { points: lux_to_nits }
};
control.check_brightness_table_and_set_new_curve(&brightness_table).await.unwrap_err();
}
#[fasync::run_singlethreaded(test)]
async fn test_brightness_table_not_valid_lux_not_increasing() {
let mut control = generate_control_struct(400, 0.5).await;
let brightness_table = {
let mut lux_to_nits = Vec::new();
lux_to_nits.push(BrightnessPoint { ambient_lux: 10., display_nits: 50. });
lux_to_nits.push(BrightnessPoint { ambient_lux: 30., display_nits: 50. });
lux_to_nits.push(BrightnessPoint { ambient_lux: 3., display_nits: 50. });
lux_to_nits.push(BrightnessPoint { ambient_lux: 100., display_nits: 50. });
BrightnessTable { points: lux_to_nits }
};
control.check_brightness_table_and_set_new_curve(&brightness_table).await.unwrap_err();
}
#[fasync::run_singlethreaded(test)]
async fn test_brightness_table_valid_but_empty() {
let mut control = generate_control_struct(400, 0.5).await;
let brightness_table = {
let lux_to_nits = Vec::new();
BrightnessTable { points: lux_to_nits }
};
let old_curve = &control.spline.clone();
control.check_brightness_table_and_set_new_curve(&brightness_table).await.unwrap();
assert_eq!(
cmp_float(
brightness_curve_lux_to_nits(0, old_curve).await,
brightness_curve_lux_to_nits(0, &control.spline).await,
),
true
);
assert_eq!(
cmp_float(
brightness_curve_lux_to_nits(1, old_curve).await,
brightness_curve_lux_to_nits(1, &control.spline).await,
),
true
);
assert_eq!(
cmp_float(
brightness_curve_lux_to_nits(2, old_curve).await,
brightness_curve_lux_to_nits(2, &control.spline).await,
),
true
);
assert_eq!(
cmp_float(
brightness_curve_lux_to_nits(15, old_curve).await,
brightness_curve_lux_to_nits(15, &control.spline).await,
),
true
);
assert_eq!(
cmp_float(
brightness_curve_lux_to_nits(16, old_curve).await,
brightness_curve_lux_to_nits(16, &control.spline).await,
),
true
);
assert_eq!(
cmp_float(
brightness_curve_lux_to_nits(100, old_curve).await,
brightness_curve_lux_to_nits(100, &control.spline).await,
),
true
);
assert_eq!(
cmp_float(
brightness_curve_lux_to_nits(150, old_curve).await,
brightness_curve_lux_to_nits(150, &control.spline).await,
),
true
);
assert_eq!(
cmp_float(
brightness_curve_lux_to_nits(200, old_curve).await,
brightness_curve_lux_to_nits(200, &control.spline).await,
),
true
);
assert_eq!(
cmp_float(
brightness_curve_lux_to_nits(240, old_curve).await,
brightness_curve_lux_to_nits(240, &control.spline).await,
),
true
);
assert_eq!(
cmp_float(
brightness_curve_lux_to_nits(300, old_curve).await,
brightness_curve_lux_to_nits(300, &control.spline).await,
),
true
);
assert_eq!(
cmp_float(
brightness_curve_lux_to_nits(340, old_curve).await,
brightness_curve_lux_to_nits(340, &control.spline).await,
),
true
);
}
#[fasync::run_singlethreaded(test)]
async fn test_scale_new_adjustment() {
let mut control = generate_control_struct(400, 0.5).await;
let mut new_adjust = control.scale_new_adjustment(-1.0).await;
assert_eq!(0.25, new_adjust);
new_adjust = control.scale_new_adjustment(1.0).await;
assert_eq!(8.0, new_adjust);
new_adjust = control.scale_new_adjustment(0.0).await;
assert_eq!(1.0, new_adjust);
}
#[fasync::run_singlethreaded(test)]
async fn test_set_brightness_slowly_send_value() {
let control = generate_control_struct(400, 0.5).await;
let (channel_sender, mut channel_receiver) = futures::channel::mpsc::unbounded::<f32>();
control.current_sender_channel.lock().await.add_sender_channel(channel_sender).await;
let set_brightness = |_| {};
set_brightness_slowly(0.4, 0.5, set_brightness, 0.millis(), control.current_sender_channel)
.await;
assert_eq!(cmp_float(0.4, channel_receiver.next().await.unwrap()), true);
assert_eq!(cmp_float(0.4, channel_receiver.next().await.unwrap()), true);
for _i in 0..13 {
channel_receiver.next().await;
}
assert_eq!(cmp_float(0.41, channel_receiver.next().await.unwrap()), true);
for _i in 0..4 {
channel_receiver.next().await;
}
assert_eq!(cmp_float(0.42, channel_receiver.next().await.unwrap()), true);
for _i in 0..19 {
channel_receiver.next().await;
}
assert_eq!(cmp_float(0.44, channel_receiver.next().await.unwrap()), true);
for _i in 0..58 {
channel_receiver.next().await;
}
assert_eq!(cmp_float(0.50, channel_receiver.next().await.unwrap()), true);
}
#[fasync::run_singlethreaded(test)]
async fn test_set_brightness_slowly_in_range() {
let control = generate_control_struct(400, 0.5).await;
let mut result = Vec::new();
let set_brightness = |nits| {
result.push(nits as f32);
};
set_brightness_slowly(0.4, 0.8, set_brightness, 0.millis(), control.current_sender_channel)
.await;
assert_eq!(401, result.len(), "wrong length");
assert_eq!(cmp_float(0.4, result[0]), true);
assert_eq!(cmp_float(0.4, result[1]), true);
assert_eq!(cmp_float(0.41, result[15]), true);
assert_eq!(cmp_float(0.42, result[20]), true);
assert_eq!(cmp_float(0.44, result[40]), true);
assert_eq!(cmp_float(0.50, result[100]), true);
assert_eq!(cmp_float(0.55, result[150]), true);
assert_eq!(cmp_float(0.60, result[200]), true);
assert_eq!(cmp_float(0.65, result[250]), true);
assert_eq!(cmp_float(0.70, result[300]), true);
assert_eq!(cmp_float(0.75, result[350]), true);
assert_eq!(cmp_float(0.80, result[399]), true);
}
#[fasync::run_singlethreaded(test)]
async fn test_set_brightness_slowly_min() {
let control = generate_control_struct(400, 0.5).await;
let mut result = Vec::new();
let set_brightness = |nits| {
result.push(nits as f32);
};
set_brightness_slowly(0.4, 0.0, set_brightness, 0.millis(), control.current_sender_channel)
.await;
assert_eq!(401, result.len(), "wrong length");
assert_eq!(cmp_float(0.39, result[0]), true);
assert_eq!(cmp_float(0.39, result[1]), true);
assert_eq!(cmp_float(0.38, result[15]), true);
assert_eq!(cmp_float(0.38, result[20]), true);
assert_eq!(cmp_float(0.35, result[40]), true);
assert_eq!(cmp_float(0.30, result[100]), true);
assert_eq!(cmp_float(0.25, result[150]), true);
assert_eq!(cmp_float(0.20, result[200]), true);
assert_eq!(cmp_float(0.15, result[250]), true);
assert_eq!(cmp_float(0.10, result[300]), true);
assert_eq!(cmp_float(0.05, result[350]), true);
assert_eq!(cmp_float(0.00, result[399]), true);
}
#[fasync::run_singlethreaded(test)]
async fn test_set_brightness_slowly_max() {
let control = generate_control_struct(400, 0.5).await;
let mut result = Vec::new();
let set_brightness = |nits| {
result.push(nits as f32);
};
set_brightness_slowly(0.9, 1.2, set_brightness, 0.millis(), control.current_sender_channel)
.await;
assert_eq!(101, result.len(), "wrong length");
assert_eq!(cmp_float(0.90, result[0]), true);
assert_eq!(cmp_float(0.90, result[1]), true);
assert_eq!(cmp_float(0.91, result[10]), true);
assert_eq!(cmp_float(0.92, result[20]), true);
assert_eq!(cmp_float(0.93, result[30]), true);
assert_eq!(cmp_float(0.94, result[40]), true);
assert_eq!(cmp_float(0.95, result[50]), true);
assert_eq!(cmp_float(0.96, result[60]), true);
assert_eq!(cmp_float(0.97, result[70]), true);
assert_eq!(cmp_float(0.98, result[80]), true);
assert_eq!(cmp_float(0.99, result[90]), true);
assert_eq!(cmp_float(1.00, result[100]), true);
}
#[fasync::run_singlethreaded(test)]
async fn test_read_sensor_and_get_brightness_bright() {
let BrightnessTable { points } = &*BRIGHTNESS_TABLE.lock().await;
let brightness_table = BrightnessTable { points: points.to_vec() };
let spline = generate_spline(brightness_table);
let (sensor, _backlight) = set_mocks(400, 1.5);
let value = read_sensor_and_get_brightness(sensor, &spline, 250.0).await;
assert_eq!(cmp_float(1.2, value), true);
}
#[fasync::run_singlethreaded(test)]
async fn test_read_sensor_and_get_brightness_low_light() {
let BrightnessTable { points } = &*BRIGHTNESS_TABLE.lock().await;
let brightness_table = BrightnessTable { points: points.to_vec() };
let spline = generate_spline(brightness_table);
let (sensor, _backlight) = set_mocks(0, 0.0);
let value = read_sensor_and_get_brightness(sensor, &spline, 250.0).await;
assert_eq!(cmp_float(0.0, value), true);
}
#[fasync::run_singlethreaded(test)]
async fn test_set_brightness_is_abortable_with_auto_brightness_on() {
let control = generate_control_struct(400, 0.5).await;
let set_brightness_abort_handle = Arc::new(Mutex::new(None::<AbortHandle>));
let (_sensor, backlight) = set_mocks(0, 0.0);
let backlight = backlight.clone();
set_brightness(
0.04,
set_brightness_abort_handle.clone(),
backlight.clone(),
control.current_sender_channel,
)
.await;
// Abort the task before it really gets going
let mut set_brightness_abort_handle = set_brightness_abort_handle.lock().await;
if let Some(handle) = set_brightness_abort_handle.take() {
handle.abort();
}
// It should not have reached the final value yet.
// We know that set_brightness_slowly, at the bottom of the task, finishes at the correct
// nits value from other tests if it has sufficient time.
let backlight = backlight.lock().await;
assert_ne!(cmp_float(0.04, backlight.get_brightness().await.unwrap() as f32), true);
}
#[fasync::run_singlethreaded(test)]
async fn test_set_brightness_impl() {
let control = generate_control_struct(400, 0.5).await;
let (_sensor, backlight) = set_mocks(0, 0.0);
let backlight_clone = backlight.clone();
set_brightness_impl(0.3, backlight_clone, control.current_sender_channel).await;
let backlight = backlight.lock().await;
assert_eq!(cmp_float(0.3, backlight.get_brightness().await.unwrap() as f32), true);
}
#[fasync::run_singlethreaded(test)]
async fn test_brightness_manager_fail_gracefully() {
let control = generate_control_struct(400, 0.5).await;
let (_sensor, backlight) = set_mocks_not_valid(0, 0.0);
{
let last_set_brightness = &*LAST_SET_BRIGHTNESS.lock().await;
assert_eq!(cmp_float(*last_set_brightness, 1.0), true);
}
let backlight_clone = backlight.clone();
set_brightness_impl(0.04, backlight_clone, control.current_sender_channel).await;
let last_set_brightness = &*LAST_SET_BRIGHTNESS.lock().await;
assert_eq!(cmp_float(*last_set_brightness, 0.04), true);
}
#[fasync::run_singlethreaded(test)]
async fn test_store_brightness_table() -> Result<(), Error> {
let mut control = generate_control_struct(400, 0.5).await;
let brightness_table = BrightnessTable {
points: vec![
BrightnessPoint { ambient_lux: 10., display_nits: 50. },
BrightnessPoint { ambient_lux: 30., display_nits: 50. },
BrightnessPoint { ambient_lux: 60., display_nits: 50. },
],
};
control.store_brightness_table(&brightness_table, "/data/test_brightness_file")?;
let file = fs::File::open("/data/test_brightness_file")?;
let data = serde_json::from_reader(io::BufReader::new(file))?;
let BrightnessTable { points: read_points } = data;
let BrightnessTable { points: write_points } = brightness_table;
let iter = read_points.iter().zip(write_points.iter());
for point_tuple in iter {
let (read_point, write_point) = point_tuple;
assert_eq!(cmp_float(read_point.ambient_lux, write_point.ambient_lux), true);
assert_eq!(cmp_float(read_point.display_nits, write_point.display_nits), true);
}
Ok(())
}
#[fasync::run_singlethreaded(test)]
async fn test_read_brightness_table_file_empty_file() {
fs::File::create("/data/empty_file").unwrap();
let result = read_brightness_table_file("/data/empty_file");
assert_eq!(true, result.is_err());
}
#[fasync::run_singlethreaded(test)]
async fn test_read_brightness_table_file_missing_file() {
assert_eq!(false, Path::new("/data/nonexistent_file").exists());
let result = read_brightness_table_file("/data/nonexistent_file");
assert_eq!(true, result.is_err());
}
#[fasync::run_singlethreaded(test)]
async fn test_read_brightness_table_file_invalid_data() {
let file = fs::File::create("/data/invalid_brightness_file").unwrap();
serde_json::to_writer(io::BufWriter::new(file), &1.0).unwrap();
let result = read_brightness_table_file("/data/invalid_brightness_file");
assert_eq!(true, result.is_err());
}
#[fasync::run_singlethreaded(test)]
async fn test_set_manual_brightness_smooth_with_duration_got_set() {
let mut control = generate_control_struct(400, 0.5).await;
control.set_manual_brightness_smooth(0.6, 4000000000).await;
let duration = *BRIGHTNESS_CHANGE_DURATION.lock().await;
assert_eq!(4000, duration.into_millis());
}
#[test]
fn test_set_manual_brightness_updates_brightness() {
let mut exec = fasync::Executor::new().unwrap();
let func_fut1 = generate_control_struct(400, 0.5);
futures::pin_mut!(func_fut1);
let mut control = exec.run_singlethreaded(&mut func_fut1);
{
let func_fut2 = control.set_manual_brightness_smooth(0.6, 4000);
futures::pin_mut!(func_fut2);
exec.run_singlethreaded(&mut func_fut2);
}
let _ = exec.run_until_stalled(&mut future::pending::<()>());
let func_fut3 = control.backlight.lock();
futures::pin_mut!(func_fut3);
let backlight = exec.run_singlethreaded(&mut func_fut3);
let func_fut4 = backlight.get_brightness();
futures::pin_mut!(func_fut4);
let value = exec.run_singlethreaded(&mut func_fut4);
assert_eq!(cmp_float(0.6, value.unwrap() as f32), true);
}
#[test]
fn test_set_manual_brightness_updates_brightness_small_change() {
const TARGET_BRIGHTNESS: f32 = 0.0006;
const ORIGINAL_BRIGHTNESS: f32 = 0.001;
assert!((TARGET_BRIGHTNESS - ORIGINAL_BRIGHTNESS).abs() < BRIGHTNESS_STEP_SIZE);
assert!((TARGET_BRIGHTNESS - ORIGINAL_BRIGHTNESS).abs() > BRIGHTNESS_MINIMUM_CHANGE);
let mut exec = fasync::Executor::new().unwrap();
let func_fut1 = generate_control_struct(400, ORIGINAL_BRIGHTNESS as f64);
futures::pin_mut!(func_fut1);
let mut control = exec.run_singlethreaded(&mut func_fut1);
{
let func_fut2 = control.set_manual_brightness_smooth(0.0006, 4000);
futures::pin_mut!(func_fut2);
exec.run_singlethreaded(&mut func_fut2);
}
let _ = exec.run_until_stalled(&mut future::pending::<()>());
let func_fut3 = control.backlight.lock();
futures::pin_mut!(func_fut3);
let backlight = exec.run_singlethreaded(&mut func_fut3);
let func_fut4 = backlight.get_brightness();
futures::pin_mut!(func_fut4);
let value = exec.run_singlethreaded(&mut func_fut4);
let brightness_value = value.unwrap() as f32;
assert_eq!(TARGET_BRIGHTNESS, brightness_value);
}
#[fasync::run_singlethreaded(test)]
async fn test_get_max_absolute_brightness() {
let mut control = generate_control_struct(400, 0.5).await;
let max_brightness = control.get_max_absolute_brightness().await;
assert_eq!(250.0, max_brightness.unwrap());
}
}