Enum Types for NetworkType, station::State (#8)

* Enum types for station state, network type.

* fix typo in file name of `known_network`

Author: abezukor

src/known_netowk.rs renamed to src/known_network.rs

@@ -3,6 +3,8 @@ use std::sync::Arc;
 use zbus::{Connection, Proxy, Result};
 use zvariant::OwnedObjectPath;
 
+use crate::network::NetworkType;
+
 #[derive(Clone, Debug)]
 pub struct KnownNetwork {
     pub(crate) connection: Arc<Connection>,
@@ -39,10 +41,9 @@ impl KnownNetwork {
         Ok(name)
     }
 
-    pub async fn network_type(&self) -> Result<String> {
+    pub async fn network_type(&self) -> Result<NetworkType> {
         let proxy = self.proxy().await?;
-        let network_type: String = proxy.get_property("Type").await?;
-        Ok(network_type)
+        proxy.get_property("Type").await
     }
 
     pub async fn hidden(&self) -> Result<bool> {

src/lib.rs

@@ -10,7 +10,7 @@ pub mod agent;
 
 pub mod network;
 
-pub mod known_netowk;
+pub mod known_network;
 
 pub mod access_point;
 

src/modes.rs

@@ -1,7 +1,9 @@
 use std::fmt::Display;
 
-#[non_exhaustive]
-#[derive(Debug, Clone, PartialEq)]
+use strum::EnumString;
+
+#[derive(Debug, Clone, Copy, PartialEq, EnumString)]
+#[strum(ascii_case_insensitive)]
 pub enum Mode {
     Station,
     Ap,
@@ -15,15 +17,3 @@ impl Display for Mode {
         }
     }
 }
-
-impl TryFrom<&str> for Mode {
-    type Error = &'static str;
-
-    fn try_from(value: &str) -> Result<Self, Self::Error> {
-        match value {
-            "station" => Ok(Mode::Station),
-            "ap" => Ok(Mode::Ap),
-            _ => Err("Unknown mode"),
-        }
-    }
-}

src/network.rs

@@ -1,12 +1,13 @@
-use std::sync::Arc;
+use std::{str::FromStr, sync::Arc};
 
+use strum::EnumString;
 use zbus::{Connection, Proxy, Result as ZbusResult};
-use zvariant::OwnedObjectPath;
+use zvariant::{OwnedObjectPath, OwnedValue};
 
 use crate::{
     device::Device,
     error::{IWDError, network::ConnectError},
-    known_netowk::KnownNetwork,
+    known_network::KnownNetwork,
 };
 
 #[derive(Clone, Debug)]
@@ -62,10 +63,9 @@ impl Network {
         Ok(device)
     }
 
-    pub async fn network_type(&self) -> ZbusResult<String> {
+    pub async fn network_type(&self) -> ZbusResult<NetworkType> {
         let proxy = self.proxy().await?;
-        let network_type: String = proxy.get_property("Type").await?;
-        Ok(network_type)
+        proxy.get_property("Type").await
     }
 
     pub async fn known_network(&self) -> ZbusResult<Option<KnownNetwork>> {
@@ -78,3 +78,22 @@ impl Network {
         Ok(None)
     }
 }
+
+#[derive(Debug, Clone, Copy, PartialEq, EnumString)]
+#[strum(ascii_case_insensitive)]
+pub enum NetworkType {
+    Open,
+    Wep,
+    Psk,
+    #[strum(serialize = "8021x")]
+    Eap,
+}
+
+impl TryFrom<OwnedValue> for NetworkType {
+    type Error = zvariant::Error;
+
+    fn try_from(value: OwnedValue) -> Result<Self, Self::Error> {
+        let state_string: String = value.try_into()?;
+        Self::from_str(&state_string).map_err(|_| zvariant::Error::IncorrectType)
+    }
+}

src/session.rs

@@ -3,7 +3,7 @@ use crate::{
     adapter::Adapter,
     agent::{Agent, AgentManager},
     device::Device,
-    known_netowk::KnownNetwork,
+    known_network::KnownNetwork,
     station::{Station, StationDiagnostics},
 };
 use std::{collections::HashMap, sync::Arc};

src/station.rs

@@ -1,6 +1,7 @@
-use std::{collections::HashMap, sync::Arc};
+use std::{collections::HashMap, str::FromStr, sync::Arc};
 
-use zvariant::{OwnedObjectPath, Value};
+use strum::EnumString;
+use zvariant::{OwnedObjectPath, OwnedValue, Value};
 
 use zbus::{Connection, Proxy};
 
@@ -48,15 +49,14 @@ impl Station {
         Ok(is_scanning)
     }
 
-    pub async fn state(&self) -> zbus::Result<String> {
+    pub async fn state(&self) -> zbus::Result<State> {
         let proxy = self.proxy().await?;
-        let state: String = proxy.get_property("State").await?;
-        Ok(state)
+        proxy.get_property("State").await
     }
 
     pub async fn connected_network(&self) -> zbus::Result<Option<Network>> {
         let state = self.state().await?;
-        if state == "connected" {
+        if matches!(state, State::Connected) {
             let proxy = self.proxy().await?;
             let network_path: OwnedObjectPath = proxy.get_property("ConnectedNetwork").await?;
             let network = Network::new(self.connection.clone(), network_path);
@@ -134,3 +134,22 @@ impl StationDiagnostics {
         Ok(body)
     }
 }
+
+#[derive(Debug, Clone, Copy, PartialEq, EnumString)]
+#[strum(ascii_case_insensitive)]
+pub enum State {
+    Connected,
+    Disconnected,
+    Connecting,
+    Disconnecting,
+    Roaming,
+}
+
+impl TryFrom<OwnedValue> for State {
+    type Error = zvariant::Error;
+
+    fn try_from(value: OwnedValue) -> Result<Self, Self::Error> {
+        let state_string: String = value.try_into()?;
+        Self::from_str(&state_string).map_err(|_| zvariant::Error::IncorrectType)
+    }
+}