Clean up a few things

credentialsd-common/src/model.rs

@@ -30,25 +30,29 @@ pub enum CredentialType {
     // Password,
 }
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
 pub struct Device {
     pub id: String,
     pub transport: Transport,
 }
 
-#[derive(Debug, Serialize, Deserialize, Type)]
+#[derive(Clone, Debug, Serialize, Deserialize, Type)]
 pub enum Operation {
     Create,
     Get,
 }
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
+#[zvariant(signature = "s")]
 pub enum Transport {
+    #[serde(rename = "BLE")]
     Ble,
     HybridLinked,
     HybridQr,
     Internal,
+    #[serde(rename = "NFC")]
     Nfc,
+    #[serde(rename = "USB")]
     Usb,
 }
 

credentialsd-common/src/server.rs

@@ -7,11 +7,11 @@ use serde::{
     de::{DeserializeSeed, Error, Visitor},
 };
 use zvariant::{
-    self, Array, DeserializeDict, DynamicDeserialize, LE, NoneValue, Optional, OwnedValue,
+    self, Array, DeserializeDict, DynamicDeserialize, NoneValue, Optional, OwnedValue,
     SerializeDict, Signature, Structure, StructureBuilder, Type, Value, signature::Fields,
 };
 
-use crate::model::{BackgroundEvent, Operation, RequestingApplication};
+use crate::model::{BackgroundEvent, Device, Operation, RequestingApplication};
 
 const TAG_VALUE_SIGNATURE: &Signature = &Signature::Structure(Fields::Static {
     fields: &[&Signature::U8, &Signature::Variant],
@@ -175,43 +175,6 @@ impl From<crate::model::Credential> for Credential {
     }
 }
 
-#[derive(SerializeDict, DeserializeDict, Type)]
-#[zvariant(signature = "a{sv}")]
-pub struct Device {
-    pub id: String,
-    pub transport: String,
-}
-
-impl TryFrom<Value<'_>> for Device {
-    type Error = zvariant::Error;
-    fn try_from(value: Value<'_>) -> std::result::Result<Self, Self::Error> {
-        let ctx = zvariant::serialized::Context::new_dbus(LE, 0);
-        let encoded = zvariant::to_bytes(ctx, &value)?;
-        let device: Device = encoded.deserialize()?.0;
-        Ok(device)
-    }
-}
-
-impl From<crate::model::Device> for Device {
-    fn from(value: crate::model::Device) -> Self {
-        Device {
-            id: value.id,
-            transport: value.transport.as_str().to_owned(),
-        }
-    }
-}
-
-impl TryFrom<Device> for crate::model::Device {
-    type Error = ();
-    fn try_from(value: Device) -> std::result::Result<Self, Self::Error> {
-        let transport = value.transport.try_into().map_err(|_| ())?;
-        Ok(Self {
-            id: value.id,
-            transport,
-        })
-    }
-}
-
 impl TryFrom<&Value<'_>> for crate::model::Error {
     type Error = zvariant::Error;
 

credentialsd-ui/src/client.rs

@@ -24,15 +24,13 @@ impl FlowController for DbusCredentialClient {
     async fn get_available_public_key_devices(
         &self,
     ) -> std::result::Result<Vec<credentialsd_common::model::Device>, ()> {
-        let dbus_devices = self
-            .proxy()
+        self.proxy()
             .await?
             .get_available_public_key_devices()
             .await
             .map_err(|err| {
                 tracing::error!("Failed to retrieve available devices/transports: {err}")
-            })?;
-        dbus_devices.into_iter().map(|d| d.try_into()).collect()
+            })
     }
 
     async fn get_hybrid_credential(&mut self) -> std::result::Result<(), ()> {

credentialsd-ui/src/dbus.rs

@@ -1,7 +1,7 @@
 use async_std::channel::Sender;
 use credentialsd_common::{
-    model::BackgroundEvent,
-    server::{Device, RequestId, ViewRequest},
+    model::{BackgroundEvent, Device},
+    server::{RequestId, ViewRequest},
 };
 use zbus::{fdo, interface, proxy};
 

credentialsd/src/credential_service/mod.rs

@@ -146,7 +146,6 @@ impl<
             .map_err(|err| err.to_string());
         if let Err(err) = launch_ui_response {
             tracing::error!("Failed to launch UI for credentials: {err}. Cancelling request.");
-            _ = self.ctx.lock().unwrap().take();
             let err = Err(CredentialServiceError::Internal(err));
             let ctx = self.ctx.lock().unwrap().take().unwrap();
             ctx.response_channel

credentialsd/src/dbus/flow_control.rs

@@ -5,9 +5,9 @@ use std::future::Future;
 use std::{collections::VecDeque, fmt::Debug, sync::Arc};
 
 use credentialsd_common::model::{
-    BackgroundEvent, Error as CredentialServiceError, RequestingApplication, WebAuthnError,
+    BackgroundEvent, Device, Error as CredentialServiceError, RequestingApplication, WebAuthnError,
 };
-use credentialsd_common::server::{Device, RequestId, WindowHandle};
+use credentialsd_common::server::{RequestId, WindowHandle};
 use futures_lite::StreamExt;
 use tokio::sync::oneshot;
 use tokio::{

credentialsd/src/dbus/gateway.rs

@@ -602,7 +602,7 @@ impl From<WebAuthnError> for Error {
 mod test {
     use credentialsd_common::model::WebAuthnError;
 
-    use crate::webauthn::{AppId, NavigationContext, Origin};
+    use crate::webauthn::{NavigationContext, Origin};
 
     use super::check_origin_from_privileged_client;
     fn check_same_origin(origin: &str) -> Result<NavigationContext, WebAuthnError> {