settings/night_mode/
night_mode_fidl_handler.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::handler::base::Request;
7use crate::ingress::{request, watch, Scoped};
8use crate::job::source::{Error as JobError, ErrorResponder};
9use crate::job::Job;
10use crate::night_mode::types::NightModeInfo;
11use fidl::prelude::*;
12use fidl_fuchsia_settings::{
13    NightModeRequest, NightModeSetResponder, NightModeSetResult, NightModeSettings,
14    NightModeWatchResponder,
15};
16
17impl ErrorResponder for NightModeSetResponder {
18    fn id(&self) -> &'static str {
19        "NightMode_Set"
20    }
21
22    fn respond(self: Box<Self>, error: fidl_fuchsia_settings::Error) -> Result<(), fidl::Error> {
23        self.send(Err(error))
24    }
25}
26
27impl request::Responder<Scoped<NightModeSetResult>> for NightModeSetResponder {
28    fn respond(self, Scoped(response): Scoped<NightModeSetResult>) {
29        let _ = self.send(response);
30    }
31}
32
33impl watch::Responder<NightModeSettings, zx::Status> for NightModeWatchResponder {
34    fn respond(self, response: Result<NightModeSettings, zx::Status>) {
35        match response {
36            Ok(settings) => {
37                let _ = self.send(&settings);
38            }
39            Err(error) => {
40                self.control_handle().shutdown_with_epitaph(error);
41            }
42        }
43    }
44}
45
46impl From<SettingInfo> for NightModeSettings {
47    fn from(response: SettingInfo) -> Self {
48        if let SettingInfo::NightMode(info) = response {
49            return NightModeSettings {
50                night_mode_enabled: info.night_mode_enabled,
51                ..Default::default()
52            };
53        }
54
55        panic!("incorrect value sent to night_mode");
56    }
57}
58
59impl From<NightModeSettings> for Request {
60    fn from(settings: NightModeSettings) -> Self {
61        let mut night_mode_info = NightModeInfo::empty();
62        night_mode_info.night_mode_enabled = settings.night_mode_enabled;
63        Request::SetNightModeInfo(night_mode_info)
64    }
65}
66
67impl TryFrom<NightModeRequest> for Job {
68    type Error = JobError;
69
70    fn try_from(item: NightModeRequest) -> Result<Self, Self::Error> {
71        #[allow(unreachable_patterns)]
72        match item {
73            NightModeRequest::Set { settings, responder } => {
74                Ok(request::Work::new(SettingType::NightMode, to_request(settings), responder)
75                    .into())
76            }
77            NightModeRequest::Watch { responder } => {
78                Ok(watch::Work::new_job(SettingType::NightMode, responder))
79            }
80            _ => {
81                log::warn!("Received a call to an unsupported API: {:?}", item);
82                Err(JobError::Unsupported)
83            }
84        }
85    }
86}
87
88fn to_request(settings: NightModeSettings) -> Request {
89    Request::SetNightModeInfo(NightModeInfo { night_mode_enabled: settings.night_mode_enabled })
90}
91
92#[cfg(test)]
93mod tests {
94    use super::*;
95    use crate::job::{execution, work};
96    use assert_matches::assert_matches;
97    use fidl_fuchsia_settings::{NightModeMarker, NightModeRequestStream};
98    use futures::StreamExt;
99
100    #[fuchsia::test]
101    fn test_request_from_settings_empty() {
102        let request = to_request(NightModeSettings::default());
103        let night_mode_info = NightModeInfo::empty();
104        assert_eq!(request, Request::SetNightModeInfo(night_mode_info));
105    }
106
107    #[fuchsia::test]
108    fn test_request_from_settings() {
109        const NIGHT_MODE_ENABLED: bool = true;
110
111        let request = to_request(NightModeSettings {
112            night_mode_enabled: Some(NIGHT_MODE_ENABLED),
113            ..Default::default()
114        });
115
116        let mut night_mode_info = NightModeInfo::empty();
117        night_mode_info.night_mode_enabled = Some(NIGHT_MODE_ENABLED);
118
119        assert_eq!(request, Request::SetNightModeInfo(night_mode_info));
120    }
121
122    #[fuchsia::test(allow_stalls = false)]
123    async fn try_from_set_converts_supplied_params() {
124        let (proxy, server) = fidl::endpoints::create_proxy::<NightModeMarker>();
125        let _fut =
126            proxy.set(&NightModeSettings { night_mode_enabled: Some(true), ..Default::default() });
127        let mut request_stream: NightModeRequestStream = server.into_stream();
128        let request = request_stream
129            .next()
130            .await
131            .expect("should have on request before stream is closed")
132            .expect("should have gotten a request");
133        let job = Job::try_from(request);
134        let job = job.as_ref();
135        assert_matches!(job.map(|j| j.workload()), Ok(work::Load::Independent(_)));
136        assert_matches!(job.map(|j| j.execution_type()), Ok(execution::Type::Independent));
137    }
138
139    #[fuchsia::test(allow_stalls = false)]
140    async fn try_from_watch_converts_supplied_params() {
141        let (proxy, server) = fidl::endpoints::create_proxy::<NightModeMarker>();
142        let _fut = proxy.watch();
143        let mut request_stream: NightModeRequestStream = server.into_stream();
144        let request = request_stream
145            .next()
146            .await
147            .expect("should have on request before stream is closed")
148            .expect("should have gotten a request");
149        let job = Job::try_from(request);
150        let job = job.as_ref();
151        assert_matches!(job.map(|j| j.workload()), Ok(work::Load::Sequential(_, _)));
152        assert_matches!(job.map(|j| j.execution_type()), Ok(execution::Type::Sequential(_)));
153    }
154}
settings/night_mode/night_mode_fidl_handler.rs

settings/night_mode/
night_mode_fidl_handler.rs
