scene_manager_structured_config/
scene_manager_structured_config_rust_config_lib_source.rs1use fidl::unpersist;
2use fidl_cf_sc_internal_scenemanagerstructuredconfig::Config as FidlConfig;
3use fuchsia_inspect::{ArrayProperty, Node};
4use fuchsia_runtime::{take_startup_handle, HandleInfo, HandleType};
5use std::convert::TryInto;
6const EXPECTED_CHECKSUM: &[u8] = &[
7 0x54, 0xb2, 0x6f, 0x40, 0x5c, 0x8c, 0x28, 0x5d, 0x60, 0x79, 0xe5, 0x57, 0xd0, 0xb9, 0x58, 0x6d,
8 0x78, 0xad, 0x68, 0x60, 0x8a, 0xf7, 0x4a, 0xeb, 0xf2, 0x94, 0x07, 0xaf, 0x67, 0x9f, 0x95, 0xaa,
9];
10#[derive(Debug)]
11pub struct Config {
12 pub attach_a11y_view: bool,
13 pub display_pixel_density: String,
14 pub display_rotation: u64,
15 pub idle_threshold_ms: u64,
16 pub supported_input_devices: Vec<String>,
17 pub suspend_enabled: bool,
18 pub viewing_distance: String,
19}
20impl Config {
21 #[doc = r" Take the config startup handle and parse its contents."]
22 #[doc = r""]
23 #[doc = r" # Panics"]
24 #[doc = r""]
25 #[doc = r" If the config startup handle was already taken or if it is not valid."]
26 pub fn take_from_startup_handle() -> Self {
27 let handle_info = HandleInfo::new(HandleType::ComponentConfigVmo, 0);
28 let config_vmo: zx::Vmo =
29 take_startup_handle(handle_info).expect("Config VMO handle must be present.").into();
30 Self::from_vmo(&config_vmo).expect("Config VMO handle must be valid.")
31 }
32 #[doc = r" Parse `Self` from `vmo`."]
33 pub fn from_vmo(vmo: &zx::Vmo) -> Result<Self, Error> {
34 let config_size = vmo.get_content_size().map_err(Error::GettingContentSize)?;
35 let config_bytes = vmo.read_to_vec(0, config_size).map_err(Error::ReadingConfigBytes)?;
36 Self::from_bytes(&config_bytes)
37 }
38 #[doc = r" Parse `Self` from `bytes`."]
39 pub fn from_bytes(bytes: &[u8]) -> Result<Self, Error> {
40 let (checksum_len_bytes, bytes) = bytes.split_at_checked(2).ok_or(Error::TooFewBytes)?;
41 let checksum_len_bytes: [u8; 2] =
42 checksum_len_bytes.try_into().expect("previous call guaranteed 2 element slice");
43 let checksum_length = u16::from_le_bytes(checksum_len_bytes) as usize;
44 let (observed_checksum, bytes) =
45 bytes.split_at_checked(checksum_length).ok_or(Error::TooFewBytes)?;
46 if observed_checksum != EXPECTED_CHECKSUM {
47 return Err(Error::ChecksumMismatch { observed_checksum: observed_checksum.to_vec() });
48 }
49 let fidl_config: FidlConfig = unpersist(bytes).map_err(Error::Unpersist)?;
50 Ok(Self {
51 attach_a11y_view: fidl_config.attach_a11y_view,
52 display_pixel_density: fidl_config.display_pixel_density,
53 display_rotation: fidl_config.display_rotation,
54 idle_threshold_ms: fidl_config.idle_threshold_ms,
55 supported_input_devices: fidl_config.supported_input_devices,
56 suspend_enabled: fidl_config.suspend_enabled,
57 viewing_distance: fidl_config.viewing_distance,
58 })
59 }
60 pub fn record_inspect(&self, inspector_node: &Node) {
61 inspector_node.record_bool("attach_a11y_view", self.attach_a11y_view);
62 inspector_node.record_string("display_pixel_density", &self.display_pixel_density);
63 inspector_node.record_uint("display_rotation", self.display_rotation);
64 inspector_node.record_uint("idle_threshold_ms", self.idle_threshold_ms);
65 let arr = inspector_node
66 .create_string_array("supported_input_devices", self.supported_input_devices.len());
67 for i in 0..self.supported_input_devices.len() {
68 arr.set(i, &self.supported_input_devices[i]);
69 }
70 inspector_node.record(arr);
71 inspector_node.record_bool("suspend_enabled", self.suspend_enabled);
72 inspector_node.record_string("viewing_distance", &self.viewing_distance);
73 }
74}
75#[derive(Debug)]
76pub enum Error {
77 #[doc = r" Failed to read the content size of the VMO."]
78 GettingContentSize(zx::Status),
79 #[doc = r" Failed to read the content of the VMO."]
80 ReadingConfigBytes(zx::Status),
81 #[doc = r" The VMO was too small for this config library."]
82 TooFewBytes,
83 #[doc = r" The VMO's config ABI checksum did not match this library's."]
84 ChecksumMismatch { observed_checksum: Vec<u8> },
85 #[doc = r" Failed to parse the non-checksum bytes of the VMO as this library's FIDL type."]
86 Unpersist(fidl::Error),
87}
88impl std::fmt::Display for Error {
89 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
90 match self {
91 Self::GettingContentSize(status) => {
92 write!(f, "Failed to get content size: {status}")
93 }
94 Self::ReadingConfigBytes(status) => {
95 write!(f, "Failed to read VMO content: {status}")
96 }
97 Self::TooFewBytes => {
98 write!(f, "VMO content is not large enough for this config library.")
99 }
100 Self::ChecksumMismatch { observed_checksum } => {
101 write!(
102 f,
103 "ABI checksum mismatch, expected {:?}, got {:?}",
104 EXPECTED_CHECKSUM, observed_checksum,
105 )
106 }
107 Self::Unpersist(fidl_error) => {
108 write!(f, "Failed to parse contents of config VMO: {fidl_error}")
109 }
110 }
111 }
112}
113impl std::error::Error for Error {
114 #[allow(unused_parens, reason = "rustfmt errors without parens here")]
115 fn source(&self) -> Option<(&'_ (dyn std::error::Error + 'static))> {
116 match self {
117 Self::GettingContentSize(ref status) | Self::ReadingConfigBytes(ref status) => {
118 Some(status)
119 }
120 Self::TooFewBytes => None,
121 Self::ChecksumMismatch { .. } => None,
122 Self::Unpersist(ref fidl_error) => Some(fidl_error),
123 }
124 }
125 fn description(&self) -> &str {
126 match self {
127 Self::GettingContentSize(_) => "getting content size",
128 Self::ReadingConfigBytes(_) => "reading VMO contents",
129 Self::TooFewBytes => "VMO contents too small",
130 Self::ChecksumMismatch { .. } => "ABI checksum mismatch",
131 Self::Unpersist(_) => "FIDL parsing error",
132 }
133 }
134}