settings/light/
light_controller.rs

1// Copyright 2020 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 crate::base::{SettingInfo, SettingType};
6use crate::config::default_settings::DefaultSetting;
7use crate::handler::base::Request;
8use crate::handler::setting_handler::persist::{controller as data_controller, ClientProxy};
9use crate::handler::setting_handler::{
10    controller, ControllerError, ControllerStateResult, SettingHandlerResult,
11};
12use crate::input::MediaButtons;
13use crate::light::light_hardware_configuration::DisableConditions;
14use crate::light::types::{LightGroup, LightInfo, LightState, LightType, LightValue};
15use crate::service_context::ExternalServiceProxy;
16use crate::{call_async, LightHardwareConfiguration};
17use async_trait::async_trait;
18use fidl_fuchsia_hardware_light::{Info, LightMarker, LightProxy};
19use fidl_fuchsia_settings_storage::LightGroups;
20use futures::lock::Mutex;
21use settings_storage::fidl_storage::{FidlStorage, FidlStorageConvertible};
22use settings_storage::storage_factory::{NoneT, StorageAccess};
23use std::collections::hash_map::Entry;
24use std::collections::HashMap;
25use std::rc::Rc;
26
27/// Used as the argument field in a ControllerError::InvalidArgument to signal the FIDL handler to
28/// signal that a LightError::INVALID_NAME should be returned to the client.
29pub(crate) const ARG_NAME: &str = "name";
30
31/// Hardware path used to connect to light devices.
32pub(crate) const DEVICE_PATH: &str = "/dev/class/light/*";
33
34impl FidlStorageConvertible for LightInfo {
35    type Storable = LightGroups;
36    type Loader = NoneT;
37    const KEY: &'static str = "light_info";
38
39    #[allow(clippy::redundant_closure)]
40    fn to_storable(self) -> Self::Storable {
41        LightGroups {
42            groups: self
43                .light_groups
44                .into_values()
45                .map(|group| fidl_fuchsia_settings::LightGroup::from(group))
46                .collect(),
47        }
48    }
49
50    fn from_storable(storable: Self::Storable) -> Self {
51        // Unwrap ok since validation would ensure non-None name before writing to storage.
52        let light_groups = storable
53            .groups
54            .into_iter()
55            .map(|group| (group.name.clone().unwrap(), group.into()))
56            .collect();
57        Self { light_groups }
58    }
59}
60
61impl From<LightInfo> for SettingInfo {
62    fn from(info: LightInfo) -> SettingInfo {
63        SettingInfo::Light(info)
64    }
65}
66
67pub struct LightController {
68    /// Provides access to common resources and functionality for controllers.
69    client: ClientProxy,
70
71    /// Proxy for interacting with light hardware.
72    light_proxy: ExternalServiceProxy<LightProxy>,
73
74    /// Hardware configuration that determines what lights to return to the client.
75    ///
76    /// If present, overrides the lights from the underlying fuchsia.hardware.light API.
77    light_hardware_config: Option<LightHardwareConfiguration>,
78
79    /// Cache of data that includes hardware values. The data stored on disk does not persist the
80    /// hardware values, so restoring does not bring the values back into memory. The data needs to
81    /// be cached at this layer so we don't lose track of them.
82    data_cache: Rc<Mutex<Option<LightInfo>>>,
83}
84
85impl StorageAccess for LightController {
86    type Storage = FidlStorage;
87    type Data = LightInfo;
88    const STORAGE_KEY: &'static str = LightInfo::KEY;
89}
90
91#[async_trait(?Send)]
92impl data_controller::CreateWithAsync for LightController {
93    type Data = Rc<Mutex<DefaultSetting<LightHardwareConfiguration, &'static str>>>;
94    async fn create_with(client: ClientProxy, data: Self::Data) -> Result<Self, ControllerError> {
95        let light_hardware_config = data.lock().await.load_default_value().map_err(|_| {
96            ControllerError::InitFailure("Invalid default light hardware config".into())
97        })?;
98
99        LightController::create_with_config(client, light_hardware_config).await
100    }
101}
102
103#[async_trait(?Send)]
104impl controller::Handle for LightController {
105    async fn handle(&self, request: Request) -> Option<SettingHandlerResult> {
106        match request {
107            Request::Restore => {
108                Some(self.restore().await.map(|light_info| Some(SettingInfo::Light(light_info))))
109            }
110            Request::OnButton(MediaButtons { mic_mute: Some(mic_mute), .. }) => {
111                Some(self.on_mic_mute(mic_mute).await)
112            }
113            Request::SetLightGroupValue(name, state) => {
114                // Validate state contains valid float numbers.
115                for light_state in &state {
116                    if !light_state.is_finite() {
117                        return Some(Err(ControllerError::InvalidArgument(
118                            SettingType::Light,
119                            "state".into(),
120                            format!("{light_state:?}").into(),
121                        )));
122                    }
123                }
124                Some(self.set(name, state).await)
125            }
126            Request::Get => {
127                // Read all light values from underlying fuchsia.hardware.light before returning a
128                // value to ensure we have the latest light state.
129                // TODO(https://fxbug.dev/42134045): remove once all clients are migrated.
130                Some(self.restore().await.map(|light_info| Some(SettingInfo::Light(light_info))))
131            }
132            _ => None,
133        }
134    }
135}
136
137/// Controller for processing requests surrounding the Light protocol.
138impl LightController {
139    /// Alternate constructor that allows specifying a configuration.
140    pub(crate) async fn create_with_config(
141        client: ClientProxy,
142        light_hardware_config: Option<LightHardwareConfiguration>,
143    ) -> Result<Self, ControllerError> {
144        let light_proxy = client
145            .get_service_context()
146            .connect_device_path::<LightMarker>(DEVICE_PATH)
147            .await
148            .map_err(|e| {
149                ControllerError::InitFailure(
150                    format!("failed to connect to fuchsia.hardware.light with error: {e:?}").into(),
151                )
152            })?;
153
154        Ok(LightController {
155            client,
156            light_proxy,
157            light_hardware_config,
158            data_cache: Rc::new(Mutex::new(None)),
159        })
160    }
161
162    async fn set(&self, name: String, state: Vec<LightState>) -> SettingHandlerResult {
163        let id = fuchsia_trace::Id::new();
164        let mut light_info = self.data_cache.lock().await;
165        // TODO(https://fxbug.dev/42058901) Deduplicate the code here and in mic_mute if possible.
166        if light_info.is_none() {
167            drop(light_info);
168            let _ = self.restore().await?;
169            light_info = self.data_cache.lock().await;
170        }
171
172        let current = light_info
173            .as_mut()
174            .ok_or_else(|| ControllerError::UnexpectedError("missing data cache".into()))?;
175        let mut entry = match current.light_groups.entry(name.clone()) {
176            Entry::Vacant(_) => {
177                // Reject sets if the light name is not known.
178                return Err(ControllerError::InvalidArgument(
179                    SettingType::Light,
180                    ARG_NAME.into(),
181                    name.into(),
182                ));
183            }
184            Entry::Occupied(entry) => entry,
185        };
186
187        let group = entry.get_mut();
188
189        if state.len() != group.lights.len() {
190            // If the number of light states provided doesn't match the number of lights,
191            // return an error.
192            return Err(ControllerError::InvalidArgument(
193                SettingType::Light,
194                "state".into(),
195                format!("{state:?}").into(),
196            ));
197        }
198
199        if !state.iter().filter_map(|state| state.value.clone()).all(|value| {
200            match group.light_type {
201                LightType::Brightness => matches!(value, LightValue::Brightness(_)),
202                LightType::Rgb => matches!(value, LightValue::Rgb(_)),
203                LightType::Simple => matches!(value, LightValue::Simple(_)),
204            }
205        }) {
206            // If not all the light values match the light type of this light group, return an
207            // error.
208            return Err(ControllerError::InvalidArgument(
209                SettingType::Light,
210                "state".into(),
211                format!("{state:?}").into(),
212            ));
213        }
214
215        // After the main validations, write the state to the hardware.
216        self.write_light_group_to_hardware(group, &state).await?;
217
218        let _ = self.client.write_setting(current.clone().into(), id).await?;
219        Ok(Some(current.clone().into()))
220    }
221
222    /// Writes the given list of light states for a light group to the actual hardware.
223    ///
224    /// [LightState::None] elements in the vector are ignored and not written to the hardware.
225    async fn write_light_group_to_hardware(
226        &self,
227        group: &mut LightGroup,
228        state: &[LightState],
229    ) -> ControllerStateResult {
230        for (i, (light, hardware_index)) in
231            state.iter().zip(group.hardware_index.iter()).enumerate()
232        {
233            let (set_result, method_name) = match light.clone().value {
234                // No value provided for this index, just skip it and don't update the
235                // stored value.
236                None => continue,
237                Some(LightValue::Brightness(brightness)) => (
238                    call_async!(self.light_proxy =>
239                        set_brightness_value(*hardware_index, brightness))
240                    .await,
241                    "set_brightness_value",
242                ),
243                Some(LightValue::Rgb(rgb)) => {
244                    let value = rgb.clone().try_into().map_err(|_| {
245                        ControllerError::InvalidArgument(
246                            SettingType::Light,
247                            "value".into(),
248                            format!("{rgb:?}").into(),
249                        )
250                    })?;
251                    (
252                        call_async!(self.light_proxy =>
253                            set_rgb_value(*hardware_index, & value))
254                        .await,
255                        "set_rgb_value",
256                    )
257                }
258                Some(LightValue::Simple(on)) => (
259                    call_async!(self.light_proxy => set_simple_value(*hardware_index, on)).await,
260                    "set_simple_value",
261                ),
262            };
263            set_result
264                .map_err(|e| format!("{e:?}"))
265                .and_then(|res| res.map_err(|e| format!("{e:?}")))
266                .map_err(|e| {
267                    ControllerError::ExternalFailure(
268                        SettingType::Light,
269                        "fuchsia.hardware.light".into(),
270                        format!("{method_name} for light {hardware_index}").into(),
271                        e.into(),
272                    )
273                })?;
274
275            // Set was successful, save this light value.
276            group.lights[i] = light.clone();
277        }
278        Ok(())
279    }
280
281    async fn on_mic_mute(&self, mic_mute: bool) -> SettingHandlerResult {
282        let id = fuchsia_trace::Id::new();
283        let mut light_info = self.data_cache.lock().await;
284        if light_info.is_none() {
285            drop(light_info);
286            let _ = self.restore().await?;
287            light_info = self.data_cache.lock().await;
288        }
289
290        let current = light_info
291            .as_mut()
292            .ok_or_else(|| ControllerError::UnexpectedError("missing data cache".into()))?;
293        for light in current
294            .light_groups
295            .values_mut()
296            .filter(|l| l.disable_conditions.contains(&DisableConditions::MicSwitch))
297        {
298            // This condition means that the LED is hard-wired to the mute switch and will only be
299            // on when the mic is disabled.
300            light.enabled = mic_mute;
301        }
302
303        let _ = self.client.write_setting(current.clone().into(), id).await?;
304        Ok(Some(current.clone().into()))
305    }
306
307    async fn restore(&self) -> Result<LightInfo, ControllerError> {
308        let light_info = if let Some(config) = self.light_hardware_config.clone() {
309            // Configuration is specified, restore from the configuration.
310            self.restore_from_configuration(config).await
311        } else {
312            // Read light info from hardware.
313            self.restore_from_hardware().await
314        }?;
315        let mut guard = self.data_cache.lock().await;
316        *guard = Some(light_info.clone());
317        Ok(light_info)
318    }
319
320    /// Restores the light information from a pre-defined hardware configuration. Individual light
321    /// states are read from the underlying fuchsia.hardware.Light API, but the structure of the
322    /// light groups is determined by the given `config`.
323    async fn restore_from_configuration(
324        &self,
325        config: LightHardwareConfiguration,
326    ) -> Result<LightInfo, ControllerError> {
327        let id = fuchsia_trace::Id::new();
328        let current = self.client.read_setting::<LightInfo>(id).await;
329        let mut light_groups: HashMap<String, LightGroup> = HashMap::new();
330        for group_config in config.light_groups {
331            let mut light_state: Vec<LightState> = Vec::new();
332
333            // TODO(https://fxbug.dev/42134045): once all clients go through setui, restore state from hardware
334            // only if not found in persistent storage.
335            for light_index in group_config.hardware_index.iter() {
336                light_state.push(
337                    self.light_state_from_hardware_index(*light_index, group_config.light_type)
338                        .await?,
339                );
340            }
341
342            // Restore previous state.
343            let enabled = current
344                .light_groups
345                .get(&group_config.name)
346                .map(|found_group| found_group.enabled)
347                .unwrap_or(true);
348
349            let _ = light_groups.insert(
350                group_config.name.clone(),
351                LightGroup {
352                    name: group_config.name,
353                    enabled,
354                    light_type: group_config.light_type,
355                    lights: light_state,
356                    hardware_index: group_config.hardware_index,
357                    disable_conditions: group_config.disable_conditions,
358                },
359            );
360        }
361
362        Ok(LightInfo { light_groups })
363    }
364
365    /// Restores the light information when no hardware configuration is specified by reading from
366    /// the underlying fuchsia.hardware.Light API and turning each light into a [`LightGroup`].
367    ///
368    /// [`LightGroup`]: ../../light/types/struct.LightGroup.html
369    async fn restore_from_hardware(&self) -> Result<LightInfo, ControllerError> {
370        let num_lights = call_async!(self.light_proxy => get_num_lights()).await.map_err(|e| {
371            ControllerError::ExternalFailure(
372                SettingType::Light,
373                "fuchsia.hardware.light".into(),
374                "get_num_lights".into(),
375                format!("{e:?}").into(),
376            )
377        })?;
378
379        let id = fuchsia_trace::Id::new();
380        let mut current = self.client.read_setting::<LightInfo>(id).await;
381        for i in 0..num_lights {
382            let info = call_async!(self.light_proxy => get_info(i))
383                .await
384                .map_err(|e| format!("{e:?}"))
385                .and_then(|res| res.map_err(|e| format!("{e:?}")))
386                .map_err(|e| {
387                    ControllerError::ExternalFailure(
388                        SettingType::Light,
389                        "fuchsia.hardware.light".into(),
390                        format!("get_info for light {i}").into(),
391                        e.into(),
392                    )
393                })?;
394            let (name, group) = self.light_info_to_group(i, info).await?;
395            let _ = current.light_groups.insert(name, group);
396        }
397
398        Ok(current)
399    }
400
401    /// Converts an Info object from the fuchsia.hardware.Light API into a LightGroup, the internal
402    /// representation used for our service.
403    async fn light_info_to_group(
404        &self,
405        index: u32,
406        info: Info,
407    ) -> Result<(String, LightGroup), ControllerError> {
408        let light_type: LightType = info.capability.into();
409
410        let light_state = self.light_state_from_hardware_index(index, light_type).await?;
411
412        Ok((
413            info.name.clone(),
414            LightGroup {
415                name: info.name,
416                // When there's no config, lights are assumed to be always enabled.
417                enabled: true,
418                light_type,
419                lights: vec![light_state],
420                hardware_index: vec![index],
421                disable_conditions: vec![],
422            },
423        ))
424    }
425
426    /// Reads light state from the underlying fuchsia.hardware.Light API for the given hardware
427    /// index and light type.
428    async fn light_state_from_hardware_index(
429        &self,
430        index: u32,
431        light_type: LightType,
432    ) -> Result<LightState, ControllerError> {
433        // Read the proper value depending on the light type.
434        let value = match light_type {
435            LightType::Brightness => {
436                call_async!(self.light_proxy => get_current_brightness_value(index))
437                    .await
438                    .map_err(|e| format!("{e:?}"))
439                    .and_then(|res| res.map_err(|e| format!("{e:?}")))
440                    .map(LightValue::Brightness)
441                    .map_err(|e| {
442                        ControllerError::ExternalFailure(
443                            SettingType::Light,
444                            "fuchsia.hardware.light".into(),
445                            format!("get_current_brightness_value for light {index}").into(),
446                            e.into(),
447                        )
448                    })?
449            }
450            LightType::Rgb => call_async!(self.light_proxy => get_current_rgb_value(index))
451                .await
452                .map_err(|e| format!("{e:?}"))
453                .and_then(|res| res.map_err(|e| format!("{e:?}")))
454                .map(LightValue::from)
455                .map_err(|e| {
456                    ControllerError::ExternalFailure(
457                        SettingType::Light,
458                        "fuchsia.hardware.light".into(),
459                        format!("get_current_rgb_value for light {index}").into(),
460                        e.into(),
461                    )
462                })?,
463            LightType::Simple => call_async!(self.light_proxy => get_current_simple_value(index))
464                .await
465                .map_err(|e| format!("{e:?}"))
466                .and_then(|res| res.map_err(|e| format!("{e:?}")))
467                .map(LightValue::Simple)
468                .map_err(|e| {
469                    ControllerError::ExternalFailure(
470                        SettingType::Light,
471                        "fuchsia.hardware.light".into(),
472                        format!("get_current_simple_value for light {index}").into(),
473                        e.into(),
474                    )
475                })?,
476        };
477
478        Ok(LightState { value: Some(value) })
479    }
480}
481
482#[cfg(test)]
483mod tests {
484    use crate::handler::setting_handler::persist::ClientProxy;
485    use crate::handler::setting_handler::ClientImpl;
486    use crate::light::types::{LightInfo, LightState, LightType, LightValue};
487    use crate::message::base::MessengerType;
488    use crate::storage::{Payload as StoragePayload, StorageRequest, StorageResponse};
489    use crate::tests::fakes::hardware_light_service::HardwareLightService;
490    use crate::tests::fakes::service_registry::ServiceRegistry;
491    use crate::{service, Address, LightController, ServiceContext, SettingType};
492    use futures::lock::Mutex;
493    use settings_storage::UpdateState;
494    use std::rc::Rc;
495
496    // Verify that a set call without a restore call succeeds. This can happen when the controller
497    // is shutdown after inactivity and is brought up again to handle the set call.
498    #[fuchsia::test(allow_stalls = false)]
499    async fn test_set_before_restore() {
500        let message_hub = service::MessageHub::create_hub();
501
502        // Create the messenger that the client proxy uses to send messages.
503        let (controller_messenger, _) = message_hub
504            .create(MessengerType::Unbound)
505            .await
506            .expect("Unable to create agent messenger");
507
508        // Create a fake hardware light service that responds to FIDL calls and add it to the
509        // service registry so that FIDL calls are routed to this fake service.
510        let service_registry = ServiceRegistry::create();
511        let light_service_handle = Rc::new(Mutex::new(HardwareLightService::new()));
512        service_registry.lock().await.register_service(light_service_handle.clone());
513
514        let service_context =
515            ServiceContext::new(Some(ServiceRegistry::serve(service_registry)), None);
516
517        // Add a light to the fake service.
518        light_service_handle
519            .lock()
520            .await
521            .insert_light(0, "light_1".to_string(), LightType::Simple, LightValue::Simple(false))
522            .await;
523
524        // This isn't actually the signature for the notifier, but it's unused in this test, so just
525        // provide the signature of its own messenger to the client proxy.
526        let signature = controller_messenger.get_signature();
527
528        let base_proxy = ClientImpl::for_test(
529            Default::default(),
530            controller_messenger,
531            signature,
532            Rc::new(service_context),
533            SettingType::Light,
534        );
535
536        // Create a fake storage receptor used to receive and respond to storage messages.
537        let (_, mut storage_receptor) = message_hub
538            .create(MessengerType::Addressable(Address::Storage))
539            .await
540            .expect("Unable to create agent messenger");
541
542        // Spawn a task that mimics the storage agent by responding to read/write calls.
543        fuchsia_async::Task::local(async move {
544            loop {
545                if let Ok((payload, message_client)) = storage_receptor.next_payload().await {
546                    if let Ok(StoragePayload::Request(storage_request)) =
547                        StoragePayload::try_from(payload)
548                    {
549                        match storage_request {
550                            StorageRequest::Read(_, _) => {
551                                // Just respond with the default value as we're not testing storage.
552                                let _ = message_client.reply(service::Payload::Storage(
553                                    StoragePayload::Response(StorageResponse::Read(
554                                        LightInfo::default().into(),
555                                    )),
556                                ));
557                            }
558                            StorageRequest::Write(_, _) => {
559                                // Just respond with Unchanged as we're not testing storage.
560                                let _ = message_client.reply(service::Payload::Storage(
561                                    StoragePayload::Response(StorageResponse::Write(Ok(
562                                        UpdateState::Unchanged,
563                                    ))),
564                                ));
565                            }
566                        }
567                    }
568                }
569            }
570        })
571        .detach();
572
573        let client_proxy = ClientProxy::new(Rc::new(base_proxy), SettingType::Light).await;
574
575        // Create the light controller.
576        let light_controller = LightController::create_with_config(client_proxy, None)
577            .await
578            .expect("Failed to create light controller");
579
580        // Call set and verify it succeeds.
581        let _ = light_controller
582            .set("light_1".to_string(), vec![LightState { value: Some(LightValue::Simple(true)) }])
583            .await
584            .expect("Set call failed");
585
586        // Verify the data cache is populated after the set call.
587        let _ =
588            light_controller.data_cache.lock().await.as_ref().expect("Data cache is not populated");
589    }
590
591    // Verify that an on_mic_mute event without a restore call succeeds. This can happen when the
592    // controller is shutdown after inactivity and is brought up again to handle the set call.
593    #[fuchsia::test(allow_stalls = false)]
594    async fn test_on_mic_mute_before_restore() {
595        let message_hub = service::MessageHub::create_hub();
596
597        // Create the messenger that the client proxy uses to send messages.
598        let (controller_messenger, _) = message_hub
599            .create(MessengerType::Unbound)
600            .await
601            .expect("Unable to create agent messenger");
602
603        // Create a fake hardware light service that responds to FIDL calls and add it to the
604        // service registry so that FIDL calls are routed to this fake service.
605        let service_registry = ServiceRegistry::create();
606        let light_service_handle = Rc::new(Mutex::new(HardwareLightService::new()));
607        service_registry.lock().await.register_service(light_service_handle.clone());
608
609        let service_context =
610            ServiceContext::new(Some(ServiceRegistry::serve(service_registry)), None);
611
612        // Add a light to the fake service.
613        light_service_handle
614            .lock()
615            .await
616            .insert_light(0, "light_1".to_string(), LightType::Simple, LightValue::Simple(false))
617            .await;
618
619        // This isn't actually the signature for the notifier, but it's unused in this test, so just
620        // provide the signature of its own messenger to the client proxy.
621        let signature = controller_messenger.get_signature();
622
623        let base_proxy = ClientImpl::for_test(
624            Default::default(),
625            controller_messenger,
626            signature,
627            Rc::new(service_context),
628            SettingType::Light,
629        );
630
631        // Create a fake storage receptor used to receive and respond to storage messages.
632        let (_, mut storage_receptor) = message_hub
633            .create(MessengerType::Addressable(Address::Storage))
634            .await
635            .expect("Unable to create agent messenger");
636
637        // Spawn a task that mimics the storage agent by responding to read/write calls.
638        fuchsia_async::Task::local(async move {
639            loop {
640                if let Ok((payload, message_client)) = storage_receptor.next_payload().await {
641                    if let Ok(StoragePayload::Request(storage_request)) =
642                        StoragePayload::try_from(payload)
643                    {
644                        match storage_request {
645                            StorageRequest::Read(_, _) => {
646                                // Just respond with the default value as we're not testing storage.
647                                let _ = message_client.reply(service::Payload::Storage(
648                                    StoragePayload::Response(StorageResponse::Read(
649                                        LightInfo::default().into(),
650                                    )),
651                                ));
652                            }
653                            StorageRequest::Write(_, _) => {
654                                // Just respond with Unchanged as we're not testing storage.
655                                let _ = message_client.reply(service::Payload::Storage(
656                                    StoragePayload::Response(StorageResponse::Write(Ok(
657                                        UpdateState::Unchanged,
658                                    ))),
659                                ));
660                            }
661                        }
662                    }
663                }
664            }
665        })
666        .detach();
667
668        let client_proxy = ClientProxy::new(Rc::new(base_proxy), SettingType::Light).await;
669
670        // Create the light controller.
671        let light_controller = LightController::create_with_config(client_proxy, None)
672            .await
673            .expect("Failed to create light controller");
674
675        // Call on_mic_mute and verify it succeeds.
676        let _ = light_controller.on_mic_mute(false).await.expect("Set call failed");
677
678        // Verify the data cache is populated after the set call.
679        let _ =
680            light_controller.data_cache.lock().await.as_ref().expect("Data cache is not populated");
681    }
682}
settings/light/light_controller.rs

settings/light/
light_controller.rs
