Add initial dbus draft of asus_armoury attrs

asusd/src/asus_armoury/attr_enum_str.rs

@@ -0,0 +1,95 @@
+use crate::{error::RogError, ASUS_ZBUS_PATH};
+use log::error;
+use rog_platform::firmware_attributes::{AttrType, AttrValue, Attribute};
+use serde::{Deserialize, Serialize};
+use zbus::{
+    fdo, interface,
+    zvariant::{ObjectPath, OwnedObjectPath, OwnedValue, Type, Value},
+    Connection,
+};
+
+const MOD_NAME: &str = "asus_armoury";
+
+#[derive(Debug, Default, Clone, Deserialize, Serialize, Type, Value, OwnedValue)]
+pub struct PossibleValues {
+    strings: Vec<String>,
+    nums: Vec<i32>,
+}
+
+fn dbus_path_for_attr(attr_name: &str) -> OwnedObjectPath {
+    ObjectPath::from_str_unchecked(&format!("{ASUS_ZBUS_PATH}/{MOD_NAME}/{attr_name}")).into()
+}
+
+pub struct AsusArmouryAttribute(Attribute);
+
+impl AsusArmouryAttribute {
+    pub fn new(attr: Attribute) -> Self {
+        Self(attr)
+    }
+
+    pub async fn start_tasks(self, connection: &Connection) -> Result<(), RogError> {
+        // self.reload()
+        //     .await
+        //     .unwrap_or_else(|err| warn!("Controller error: {}", err));
+        let path = dbus_path_for_attr(self.0.name());
+        connection
+            .object_server()
+            .at(path.clone(), self)
+            .await
+            .map_err(|e| error!("Couldn't add server at path: {path}, {e:?}"))
+            .ok();
+        Ok(())
+    }
+}
+
+#[interface(name = "org.asuslinux.AsusArmoury")]
+impl AsusArmouryAttribute {
+    #[zbus(property)]
+    async fn name(&self) -> String {
+        self.0.name().to_string()
+    }
+
+    #[zbus(property)]
+    fn attribute_type(&self) -> AttrType {
+        self.0.attribute_type()
+    }
+
+    #[zbus(property)]
+    async fn default_value(&self) -> i32 {
+        match self.0.default_value() {
+            AttrValue::Integer(i) => *i,
+            _ => -1,
+        }
+    }
+
+    #[zbus(property)]
+    async fn possible_values(&self) -> Vec<String> {
+        match self.0.possible_values() {
+            AttrValue::EnumStr(s) => s.clone(),
+            _ => Vec::default(),
+        }
+    }
+
+    #[zbus(property)]
+    async fn current_value(&self) -> fdo::Result<String> {
+        if let Ok(v) = self.0.current_value() {
+            if let AttrValue::String(s) = v {
+                return Ok(s);
+            }
+        }
+        Err(fdo::Error::Failed(
+            "Could not read current value".to_string(),
+        ))
+    }
+
+    #[zbus(property)]
+    async fn set_current_value(&mut self, value: String) -> fdo::Result<()> {
+        Ok(self
+            .0
+            .set_current_value(AttrValue::String(value))
+            .map_err(|e| {
+                error!("Could not set value: {e:?}");
+                e
+            })?)
+    }
+}