| // Copyright 2019 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::LOG_VERBOSITY, |
| anyhow::Error, |
| fidl::endpoints::Proxy, |
| fidl_fuchsia_hardware_power as hpower, fidl_fuchsia_power as fpower, fuchsia_async as fasync, |
| fuchsia_syslog::{fx_log_err, fx_vlog}, |
| fuchsia_zircon as zx, |
| futures::{lock::Mutex, TryStreamExt}, |
| std::sync::{Arc, RwLock}, |
| }; |
| |
| #[derive(Debug, PartialEq)] |
| enum StatusUpdateResult { |
| Notify, |
| DoNotNotify, |
| } |
| |
| pub(crate) trait BatterySimulationStateObserver { |
| fn update_simulation(&self, new_state: bool); |
| fn update_simulated_battery_info(&self, battery_info: fpower::BatteryInfo); |
| } |
| |
| impl BatterySimulationStateObserver for BatteryManager { |
| fn update_simulation(&self, is_simulating: bool) { |
| let mut sim_state = self.simulation_state.write().unwrap(); |
| *sim_state = is_simulating; |
| drop(sim_state); |
| if !is_simulating { |
| self.update_watchers(); |
| } |
| } |
| fn update_simulated_battery_info(&self, battery_info: fpower::BatteryInfo) { |
| let mut simulated_battery_info = self.simulated_battery_info.write().unwrap(); |
| *simulated_battery_info = battery_info.clone(); |
| drop(simulated_battery_info); |
| self.update_watchers(); |
| } |
| } |
| |
| /// Core component for the battery manager system. |
| /// |
| /// BatteryManager maintains the current state info for the battery system |
| /// as well as the watchers that share this information with subscribed clients. |
| /// |
| /// simulation_state: true when the simulator is running |
| pub struct BatteryManager { |
| battery_info: RwLock<fpower::BatteryInfo>, |
| watchers: Arc<Mutex<Vec<fpower::BatteryInfoWatcherProxy>>>, |
| simulation_state: RwLock<bool>, |
| simulated_battery_info: RwLock<fpower::BatteryInfo>, |
| } |
| |
| #[inline] |
| fn get_current_time() -> i64 { |
| let t = fuchsia_runtime::utc_time(); |
| (t.into_nanos() / 1000) as i64 |
| } |
| |
| impl BatteryManager { |
| pub fn new() -> BatteryManager { |
| BatteryManager { |
| battery_info: RwLock::new(fpower::BatteryInfo { |
| status: Some(fpower::BatteryStatus::NotAvailable), |
| charge_status: Some(fpower::ChargeStatus::Unknown), |
| charge_source: Some(fpower::ChargeSource::Unknown), |
| level_percent: None, |
| level_status: Some(fpower::LevelStatus::Unknown), |
| health: Some(fpower::HealthStatus::Unknown), |
| time_remaining: Some(fpower::TimeRemaining::Indeterminate(0)), |
| timestamp: Some(get_current_time()), |
| ..fpower::BatteryInfo::EMPTY |
| }), |
| watchers: Arc::new(Mutex::new(Vec::new())), |
| simulation_state: RwLock::new(false), |
| simulated_battery_info: RwLock::new(fpower::BatteryInfo { |
| status: Some(fpower::BatteryStatus::NotAvailable), |
| charge_status: Some(fpower::ChargeStatus::Unknown), |
| charge_source: Some(fpower::ChargeSource::Unknown), |
| level_percent: None, |
| level_status: Some(fpower::LevelStatus::Unknown), |
| health: Some(fpower::HealthStatus::Unknown), |
| time_remaining: Some(fpower::TimeRemaining::Indeterminate(0)), |
| timestamp: Some(get_current_time()), |
| ..fpower::BatteryInfo::EMPTY |
| }), |
| } |
| } |
| |
| // Adds watcher |
| pub async fn add_watcher(&self, watcher: fpower::BatteryInfoWatcherProxy) { |
| let mut watchers = self.watchers.lock().await; |
| fx_vlog!(LOG_VERBOSITY, "::manager:: adding watcher: {:?} [{:?}]", watcher, watchers.len()); |
| watchers.push(watcher) |
| } |
| |
| // Updates the status |
| pub fn update_status( |
| &self, |
| power_info: hpower::SourceInfo, |
| battery_info: Option<hpower::BatteryInfo>, |
| ) -> Result<(), anyhow::Error> { |
| fx_vlog!( |
| LOG_VERBOSITY, |
| "update_status with power info: {:#?} and battery info: {:#?}", |
| &power_info, |
| &battery_info |
| ); |
| |
| match self.update_battery_info(power_info, battery_info) { |
| Ok(StatusUpdateResult::Notify) => { |
| fx_vlog!(LOG_VERBOSITY, "::manager:: update status changed - NOTIFY"); |
| let info = self.get_battery_info_copy(); |
| let watchers = self.watchers.clone(); |
| fx_vlog!( |
| LOG_VERBOSITY, |
| "::manager:: run watchers {:?} with info {:?}", |
| &watchers, |
| &info |
| ); |
| BatteryManager::run_watchers(watchers.clone(), info.clone()); |
| } |
| Ok(StatusUpdateResult::DoNotNotify) => { |
| fx_vlog!(LOG_VERBOSITY, "::manager:: update status unchanged - skipping NOTIFY"); |
| } |
| Err(e) => return Err(e), |
| } |
| |
| Ok(()) |
| } |
| |
| pub fn run_watchers( |
| watchers: Arc<Mutex<Vec<fpower::BatteryInfoWatcherProxy>>>, |
| info: fpower::BatteryInfo, |
| ) { |
| fx_vlog!(LOG_VERBOSITY, "::manager:: run watchers..."); |
| fasync::Task::spawn(async move { |
| let watchers = { |
| let mut watchers = watchers.lock().await; |
| watchers.retain(|w| !w.is_closed()); |
| watchers.clone() |
| }; |
| fx_vlog!(LOG_VERBOSITY, "::manager:: run watchers [{:?}]", &watchers.len()); |
| for w in &watchers { |
| if let Err(e) = w.on_change_battery_info(info.clone().into()).await { |
| fx_log_err!("failed to send battery info to watcher {:?}", e); |
| } |
| } |
| }) |
| .detach() |
| } |
| |
| fn update_battery_info( |
| &self, |
| power_info: hpower::SourceInfo, |
| battery_info: Option<hpower::BatteryInfo>, |
| ) -> Result<StatusUpdateResult, anyhow::Error> { |
| let now = get_current_time(); |
| let old_battery_info = self.get_battery_info_copy(); |
| fx_vlog!(LOG_VERBOSITY, "::battery_manager:: old battery info: {:?}", &old_battery_info); |
| |
| let mut new_battery_info = self.battery_info.write().unwrap(); |
| |
| // info from AC power source |
| if power_info.type_ == hpower::PowerType::Ac { |
| // charge status/source |
| if power_info.state & hpower::POWER_STATE_CHARGING != 0 { |
| new_battery_info.charge_status = Some(fpower::ChargeStatus::Charging); |
| if power_info.type_ == hpower::PowerType::Ac { |
| new_battery_info.charge_source = Some(fpower::ChargeSource::AcAdapter); |
| } else { |
| //TODO: how to detect USB/Wireless |
| new_battery_info.charge_source = Some(fpower::ChargeSource::Unknown); |
| } |
| } |
| } |
| |
| // info from battery power source will include battery info |
| if let Some(bi) = battery_info { |
| assert!( |
| power_info.type_ == hpower::PowerType::Battery, |
| "updating battery info with non-battery power source" |
| ); |
| |
| fx_vlog!( |
| LOG_VERBOSITY, |
| "::battery_manager:: update with hpower info p:{:?} b:{:?}", |
| &power_info, |
| &bi |
| ); |
| |
| // check battery online and update accordingly |
| if power_info.state & hpower::POWER_STATE_ONLINE != 0 { |
| new_battery_info.status = Some(fpower::BatteryStatus::Ok); |
| |
| // charge status/source |
| if power_info.state & hpower::POWER_STATE_CHARGING != 0 { |
| new_battery_info.charge_status = Some(fpower::ChargeStatus::Charging); |
| } |
| |
| if bi.remaining_capacity == bi.last_full_capacity { |
| new_battery_info.charge_status = Some(fpower::ChargeStatus::Full); |
| } |
| |
| // level percent |
| new_battery_info.level_percent = Some( |
| (bi.remaining_capacity.saturating_mul(100)) as f32 |
| / bi.last_full_capacity as f32, |
| ); |
| |
| // level_status |
| if power_info.state & hpower::POWER_STATE_CRITICAL != 0 { |
| new_battery_info.level_status = Some(fpower::LevelStatus::Critical); |
| } else if bi.remaining_capacity <= bi.capacity_low { |
| new_battery_info.level_status = Some(fpower::LevelStatus::Low); |
| } else if bi.remaining_capacity <= bi.capacity_warning { |
| new_battery_info.level_status = Some(fpower::LevelStatus::Warning); |
| } else { |
| new_battery_info.level_status = Some(fpower::LevelStatus::Ok); |
| } |
| |
| // time remaining, provided by hardware as hours |
| let nanos_in_one_hour = zx::Duration::from_hours(1); |
| |
| if bi.present_rate < 0 { |
| // discharging |
| let remaining_hours = |
| bi.remaining_capacity as f32 / (bi.present_rate.saturating_mul(-1)) as f32; |
| new_battery_info.time_remaining = Some(fpower::TimeRemaining::BatteryLife( |
| (remaining_hours as i64).saturating_mul(nanos_in_one_hour.into_nanos()), |
| )); |
| } else { |
| // charging |
| let remaining_hours = (bi.last_full_capacity as f32 |
| - bi.remaining_capacity as f32) |
| / (bi.present_rate) as f32; |
| new_battery_info.time_remaining = Some(fpower::TimeRemaining::FullCharge( |
| (remaining_hours as i64).saturating_mul(nanos_in_one_hour.into_nanos()), |
| )); |
| } |
| |
| // TODO: determine actual battery health |
| new_battery_info.health = Some(fpower::HealthStatus::Unknown); |
| } else { |
| // battery offline/not present |
| new_battery_info.status = Some(fpower::BatteryStatus::NotPresent); |
| } |
| } |
| |
| if power_info.state & hpower::POWER_STATE_DISCHARGING != 0 { |
| new_battery_info.charge_status = Some(fpower::ChargeStatus::Discharging); |
| } |
| |
| if (power_info.state & hpower::POWER_STATE_DISCHARGING == 0) |
| && (power_info.state & hpower::POWER_STATE_CHARGING == 0) |
| { |
| new_battery_info.charge_status = Some(fpower::ChargeStatus::NotCharging); |
| } |
| |
| if new_battery_info.charge_status != Some(fpower::ChargeStatus::Charging) |
| && new_battery_info.charge_status != Some(fpower::ChargeStatus::Full) |
| { |
| new_battery_info.charge_source = Some(fpower::ChargeSource::None); |
| } |
| |
| if *self.simulation_state.read().unwrap() { |
| return Ok(StatusUpdateResult::DoNotNotify); |
| } |
| |
| match old_battery_info == (*new_battery_info) { |
| true => Ok(StatusUpdateResult::DoNotNotify), |
| false => { |
| new_battery_info.timestamp = Some(now); |
| Ok(StatusUpdateResult::Notify) |
| } |
| } |
| } |
| |
| pub fn get_battery_info_copy(&self) -> fpower::BatteryInfo { |
| if *self.simulation_state.read().unwrap() { |
| let info_lock = self.simulated_battery_info.read().unwrap(); |
| (*info_lock).clone() |
| } else { |
| let info_lock = self.battery_info.read().unwrap(); |
| (*info_lock).clone() |
| } |
| } |
| |
| fn update_watchers(&self) { |
| let info = self.get_battery_info_copy(); |
| let watchers = self.watchers.clone(); |
| BatteryManager::run_watchers(watchers.clone(), info.clone()); |
| } |
| |
| pub fn is_simulating(&self) -> bool { |
| *self.simulation_state.read().unwrap() |
| } |
| |
| pub(crate) async fn serve( |
| &self, |
| stream: fpower::BatteryManagerRequestStream, |
| ) -> Result<(), Error> { |
| stream.try_for_each_concurrent(None, move |request| { |
| async move { |
| match request { |
| fpower::BatteryManagerRequest::GetBatteryInfo { responder, .. } => { |
| let info = self.get_battery_info_copy(); |
| fx_vlog!( |
| LOG_VERBOSITY, |
| "::battery_manager_request:: handle GetBatteryInfo request with info: {:?}", |
| &info |
| ); |
| responder.send(info)?; |
| |
| } |
| fpower::BatteryManagerRequest::Watch { watcher, .. } => { |
| let watcher = watcher.into_proxy()?; |
| fx_vlog!(LOG_VERBOSITY, "::battery_manager_request:: handle Watch request"); |
| self.add_watcher(watcher.clone()).await; |
| |
| // make sure watcher has current battery info |
| let info = self.get_battery_info_copy(); |
| |
| fx_vlog!( |
| LOG_VERBOSITY, |
| "::battery_manager_request:: callback on new watcher with info {:?}", |
| &info |
| ); |
| watcher.on_change_battery_info(info).await?; |
| } |
| } |
| Ok(()) |
| } |
| }) |
| .await?; |
| |
| Ok(()) |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| use fidl::endpoints::create_request_stream; |
| use fidl_fuchsia_power as fpower; |
| use fuchsia_async::futures::TryStreamExt; |
| use futures::future::*; |
| |
| macro_rules! cmp_fields { |
| ($got:ident, $want:ident, [$($field:ident,)*], $test_no:expr) => { $( |
| assert_eq!($got.$field, $want.$field, "test no: {}", $test_no); |
| )* } |
| } |
| |
| fn check_status( |
| got: &fpower::BatteryInfo, |
| want: &fpower::BatteryInfo, |
| updated: bool, |
| test_no: u32, |
| ) { |
| if updated { |
| cmp_fields!( |
| want, |
| got, |
| [ |
| status, |
| charge_status, |
| charge_source, |
| level_percent, |
| level_status, |
| health, |
| time_remaining, |
| ], |
| test_no |
| ); |
| } else { |
| assert_eq!(want, got, "test: {}", test_no); |
| } |
| } |
| |
| fn get_default_battery_info() -> hpower::BatteryInfo { |
| let battery_info = hpower::BatteryInfo { |
| unit: hpower::BatteryUnit::Ma, |
| design_capacity: 5000, |
| last_full_capacity: 5000, |
| design_voltage: 7000, |
| capacity_warning: 700, |
| capacity_low: 500, |
| capacity_granularity_low_warning: 1, |
| capacity_granularity_warning_full: 1, |
| present_rate: -500, |
| remaining_capacity: 3000, |
| present_voltage: 7000, |
| }; |
| return battery_info; |
| } |
| |
| #[fuchsia_async::run_until_stalled(test)] |
| async fn test_run_watcher() { |
| let battery_manager = BatteryManager::new(); |
| let mut battery_info: fpower::BatteryInfo = battery_manager.get_battery_info_copy(); |
| battery_info.level_percent = Some(50.0); |
| |
| let (watcher_client_end, mut stream) = |
| create_request_stream::<fpower::BatteryInfoWatcherMarker>().unwrap(); |
| let watcher = watcher_client_end.into_proxy().unwrap(); |
| |
| let watchers = Arc::new(Mutex::new(vec![watcher])); |
| |
| let serve_fut = async move { |
| let request = stream.try_next().await.unwrap(); |
| if let Some(fpower::BatteryInfoWatcherRequest::OnChangeBatteryInfo { |
| info, |
| responder, |
| }) = request |
| { |
| let level = info.level_percent.unwrap().round() as u8; |
| assert_eq!(level, 50); |
| responder.send().unwrap(); |
| } else { |
| panic!("Unexpected message received"); |
| }; |
| }; |
| let request_fut = async move { |
| BatteryManager::run_watchers(watchers, battery_info); |
| }; |
| |
| join(serve_fut, request_fut).await; |
| } |
| |
| #[fuchsia_async::run_singlethreaded(test)] |
| async fn test_run_watchers_channel_closed() { |
| let battery_manager = BatteryManager::new(); |
| let mut battery_info: fpower::BatteryInfo = battery_manager.get_battery_info_copy(); |
| battery_info.level_percent = Some(50.0); |
| |
| let (watcher1_client_end, mut stream1) = |
| create_request_stream::<fpower::BatteryInfoWatcherMarker>().unwrap(); |
| let watcher1 = watcher1_client_end.into_proxy().unwrap(); |
| |
| let (watcher2_client_end, mut stream2) = |
| create_request_stream::<fpower::BatteryInfoWatcherMarker>().unwrap(); |
| let watcher2 = watcher2_client_end.into_proxy().unwrap(); |
| |
| let watchers = Arc::new(Mutex::new(vec![watcher1, watcher2])); |
| |
| let serve1_fut = async move { |
| // first request should match first change notification sent |
| // at 50% |
| let request = stream1.try_next().await.unwrap(); |
| if let Some(fpower::BatteryInfoWatcherRequest::OnChangeBatteryInfo { |
| info, |
| responder, |
| }) = request |
| { |
| let level = info.level_percent.unwrap().round() as u8; |
| assert_eq!(level, 50); |
| responder.send().unwrap(); |
| } else { |
| panic!("Unexpected message received"); |
| }; |
| // second should match subsequent notification at 60% |
| let request = stream1.try_next().await.unwrap(); |
| if let Some(fpower::BatteryInfoWatcherRequest::OnChangeBatteryInfo { |
| info, |
| responder, |
| }) = request |
| { |
| let level = info.level_percent.unwrap().round() as u8; |
| assert_eq!(level, 60); |
| responder.send().unwrap(); |
| } else { |
| panic!("Unexpected message received"); |
| }; |
| }; |
| |
| let serve2_fut = async move { |
| // first request should match first change notification sent |
| // at 50% |
| let request = stream2.try_next().await.unwrap(); |
| if let Some(fpower::BatteryInfoWatcherRequest::OnChangeBatteryInfo { |
| info, |
| responder, |
| }) = request |
| { |
| let level = info.level_percent.unwrap().round() as u8; |
| assert_eq!(level, 50); |
| // but then we drop the channel... |
| std::mem::drop(responder); |
| } else { |
| panic!("Unexpected message received"); |
| }; |
| // should not get the second... |
| if let Some(_) = stream2.try_next().await.unwrap() { |
| panic!("Unexpected message, channel should be closed"); |
| } |
| }; |
| |
| let request_fut = async move { |
| BatteryManager::run_watchers(watchers.clone(), battery_info.clone()); |
| battery_info.level_percent = Some(60.0); |
| BatteryManager::run_watchers(watchers, battery_info); |
| }; |
| |
| join3(serve1_fut, serve2_fut, request_fut).await; |
| } |
| |
| #[fuchsia_async::run_singlethreaded(test)] |
| async fn update_battery_info() { |
| let nanos_in_one_hour = zx::Duration::from_hours(1); |
| |
| let battery_manager = BatteryManager::new(); |
| let mut power_info = hpower::SourceInfo { type_: hpower::PowerType::Ac, state: 1 }; |
| |
| // state: ac powered, with no battery info to update |
| let mut want = battery_manager.get_battery_info_copy(); |
| want.status = Some(fpower::BatteryStatus::NotAvailable); |
| want.charge_source = Some(fpower::ChargeSource::None); |
| want.charge_status = Some(fpower::ChargeStatus::NotCharging); |
| want.level_percent = None; |
| let _ = battery_manager.update_battery_info(power_info.clone(), None); |
| check_status(&battery_manager.get_battery_info_copy(), &want, true, 1); |
| |
| // state: unchanged |
| let want = battery_manager.get_battery_info_copy(); |
| let result = battery_manager.update_battery_info(power_info.clone(), None); |
| assert_eq!(result.unwrap(), StatusUpdateResult::DoNotNotify); |
| check_status(&battery_manager.get_battery_info_copy(), &want, false, 2); |
| |
| // state: battery powered, discharging |
| power_info.type_ = hpower::PowerType::Battery; |
| power_info.state = 0x3; // ONLINE | DISCHARGING |
| let mut want = battery_manager.get_battery_info_copy(); |
| want.status = Some(fpower::BatteryStatus::Ok); |
| want.charge_status = Some(fpower::ChargeStatus::Discharging); |
| want.charge_source = Some(fpower::ChargeSource::None); |
| want.level_status = Some(fpower::LevelStatus::Ok); |
| want.level_percent = Some((3000.0 * 100.0) / 5000.0); |
| want.time_remaining = |
| Some(fpower::TimeRemaining::BatteryLife(6 * nanos_in_one_hour.into_nanos())); |
| let mut battery_info = get_default_battery_info(); |
| let result = |
| battery_manager.update_battery_info(power_info.clone(), Some(battery_info.clone())); |
| assert_eq!(result.unwrap(), StatusUpdateResult::Notify); |
| check_status(&battery_manager.get_battery_info_copy(), &want, true, 3); |
| |
| // state: battery powered, discharging/warning |
| power_info.state = 0x3; // ONLINE | DISCHARGING |
| battery_info.remaining_capacity = 700; |
| let mut want = battery_manager.get_battery_info_copy(); |
| want.status = Some(fpower::BatteryStatus::Ok); |
| want.charge_status = Some(fpower::ChargeStatus::Discharging); |
| want.charge_source = Some(fpower::ChargeSource::None); |
| want.level_status = Some(fpower::LevelStatus::Warning); |
| want.level_percent = Some((700.0 * 100.0) / 5000.0); |
| want.time_remaining = |
| Some(fpower::TimeRemaining::BatteryLife(nanos_in_one_hour.into_nanos())); |
| let _ = battery_manager.update_battery_info(power_info.clone(), Some(battery_info.clone())); |
| check_status(&battery_manager.get_battery_info_copy(), &want, true, 4); |
| |
| // state: battery powered, discharging/low |
| power_info.state = 0x3; // ONLINE | DISCHARGING |
| battery_info.remaining_capacity = 500; |
| let mut want = battery_manager.get_battery_info_copy(); |
| want.status = Some(fpower::BatteryStatus::Ok); |
| want.charge_status = Some(fpower::ChargeStatus::Discharging); |
| want.charge_source = Some(fpower::ChargeSource::None); |
| want.level_status = Some(fpower::LevelStatus::Low); |
| want.level_percent = Some((500.0 * 100.0) / 5000.0); |
| want.time_remaining = |
| Some(fpower::TimeRemaining::BatteryLife(nanos_in_one_hour.into_nanos())); |
| let _ = battery_manager.update_battery_info(power_info.clone(), Some(battery_info.clone())); |
| check_status(&battery_manager.get_battery_info_copy(), &want, true, 5); |
| |
| // state: battery powered, discharging/critical |
| power_info.state = 0xB; // ONLINE | DISCHARGING | CRITICAL |
| let mut want = battery_manager.get_battery_info_copy(); |
| want.status = Some(fpower::BatteryStatus::Ok); |
| want.charge_status = Some(fpower::ChargeStatus::Discharging); |
| want.charge_source = Some(fpower::ChargeSource::None); |
| want.level_status = Some(fpower::LevelStatus::Critical); |
| let _ = battery_manager.update_battery_info(power_info.clone(), Some(battery_info.clone())); |
| check_status(&battery_manager.get_battery_info_copy(), &want, true, 6); |
| |
| // state: battery charging via AC |
| power_info.type_ = hpower::PowerType::Ac; |
| power_info.state = 0x5; // ONLINE | CHARGING |
| let _ = battery_manager.update_battery_info(power_info.clone(), None); |
| power_info.type_ = hpower::PowerType::Battery; |
| power_info.state = 0x5; // ONLINE | CHARGING |
| battery_info.present_rate = 1000; |
| battery_info.remaining_capacity = 3000; |
| let mut want = battery_manager.get_battery_info_copy(); |
| want.status = Some(fpower::BatteryStatus::Ok); |
| want.charge_status = Some(fpower::ChargeStatus::Charging); |
| want.charge_source = Some(fpower::ChargeSource::AcAdapter); |
| want.level_status = Some(fpower::LevelStatus::Ok); |
| want.level_percent = Some((3000.0 * 100.0) / 5000.0); |
| want.time_remaining = |
| Some(fpower::TimeRemaining::FullCharge(2 * nanos_in_one_hour.into_nanos())); |
| let _ = battery_manager.update_battery_info(power_info.clone(), Some(battery_info.clone())); |
| check_status(&battery_manager.get_battery_info_copy(), &want, true, 7); |
| |
| // state: battery charging via AC/level critical |
| power_info.type_ = hpower::PowerType::Ac; |
| power_info.state = 0xD; // ONLINE | CHARGING | CRITICAL |
| let _ = battery_manager.update_battery_info(power_info.clone(), None); |
| power_info.type_ = hpower::PowerType::Battery; |
| power_info.state = 0xD; // ONLINE | CHARGING | CRITICAL |
| let mut want = battery_manager.get_battery_info_copy(); |
| want.status = Some(fpower::BatteryStatus::Ok); |
| want.charge_status = Some(fpower::ChargeStatus::Charging); |
| want.charge_source = Some(fpower::ChargeSource::AcAdapter); |
| want.level_status = Some(fpower::LevelStatus::Critical); |
| let _ = battery_manager.update_battery_info(power_info.clone(), Some(battery_info.clone())); |
| check_status(&battery_manager.get_battery_info_copy(), &want, true, 8); |
| |
| // state: battery charging via AC/level full |
| power_info.state = 0x5; // ONLINE | CHARGING |
| battery_info.remaining_capacity = 5000; |
| let mut want = battery_manager.get_battery_info_copy(); |
| want.status = Some(fpower::BatteryStatus::Ok); |
| want.charge_status = Some(fpower::ChargeStatus::Full); |
| want.charge_source = Some(fpower::ChargeSource::AcAdapter); |
| want.level_status = Some(fpower::LevelStatus::Ok); |
| want.level_percent = Some(100.0); |
| want.time_remaining = Some(fpower::TimeRemaining::FullCharge(0)); |
| let _ = battery_manager.update_battery_info(power_info.clone(), Some(battery_info.clone())); |
| check_status(&battery_manager.get_battery_info_copy(), &want, true, 9); |
| |
| // state: battery charging via AC/extreme values (check overflow) |
| power_info.state = 0x5; // ONLINE | CHARGING |
| battery_info.last_full_capacity = u32::max_value(); |
| battery_info.remaining_capacity = u32::min_value(); |
| battery_info.present_rate = 1; |
| let mut want = battery_manager.get_battery_info_copy(); |
| want.status = Some(fpower::BatteryStatus::Ok); |
| want.charge_status = Some(fpower::ChargeStatus::Charging); |
| want.charge_source = Some(fpower::ChargeSource::AcAdapter); |
| want.level_status = Some(fpower::LevelStatus::Low); |
| want.level_percent = Some(0.0); |
| want.time_remaining = Some(fpower::TimeRemaining::FullCharge(i64::max_value())); |
| let _ = battery_manager.update_battery_info(power_info.clone(), Some(battery_info.clone())); |
| check_status(&battery_manager.get_battery_info_copy(), &want, true, 10); |
| } |
| } |
