common: Remove duplicate BackgroundEvent type

Author: iinuwa

credentialsd-common/src/model.rs

@@ -262,7 +262,7 @@ pub enum UsbState {
     Failed(Error),
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub enum BackgroundEvent {
     UsbStateChanged(UsbState),
     HybridQrStateChanged(HybridState),

credentialsd-common/src/server.rs

@@ -12,14 +12,7 @@ use zvariant::{
     Signature, Structure, StructureBuilder, Type, Value, signature::Fields,
 };
 
-use crate::model::Operation;
-
-#[derive(Clone, Debug)]
-
-pub enum BackgroundEvent {
-    UsbStateChanged(crate::model::UsbState),
-    HybridStateChanged(crate::model::HybridState),
-}
+use crate::model::{BackgroundEvent, Operation};
 
 const TAG_VALUE_SIGNATURE: &'static Signature = &Signature::Structure(Fields::Static {
     fields: &[&Signature::U8, &Signature::Variant],
@@ -42,7 +35,7 @@ impl Serialize for BackgroundEvent {
                 let structure: Structure<'_> = state.into();
                 tuple.serialize_element(&Value::Structure(structure))?;
             }
-            Self::HybridStateChanged(state) => {
+            Self::HybridQrStateChanged(state) => {
                 tuple.serialize_element(&0x02_u8)?;
                 let structure: Structure<'_> = state.try_into().map_err(|err| {
                     S::Error::custom(format!(
@@ -95,7 +88,7 @@ impl<'de> Deserialize<'de> for BackgroundEvent {
                         "could not deserialize HybridState from structure: {err}"
                     ))
                 })?;
-                Ok(BackgroundEvent::HybridStateChanged(state))
+                Ok(BackgroundEvent::HybridQrStateChanged(state))
             }
             _ => Err(D::Error::custom(format!(
                 "Unknown BackgroundEvent tag : {tag}"
@@ -104,40 +97,6 @@ impl<'de> Deserialize<'de> for BackgroundEvent {
     }
 }
 
-impl TryFrom<BackgroundEvent> for crate::model::BackgroundEvent {
-    type Error = zvariant::Error;
-
-    fn try_from(value: BackgroundEvent) -> Result<Self, Self::Error> {
-        match value {
-            BackgroundEvent::HybridStateChanged(hybrid_state_val) => Ok(
-                crate::model::BackgroundEvent::HybridQrStateChanged(hybrid_state_val),
-            ),
-            BackgroundEvent::UsbStateChanged(usb_state) => {
-                Ok(crate::model::BackgroundEvent::UsbStateChanged(usb_state))
-            }
-        }
-    }
-}
-
-impl From<crate::model::BackgroundEvent> for BackgroundEvent {
-    fn from(value: crate::model::BackgroundEvent) -> Self {
-        match value {
-            crate::model::BackgroundEvent::HybridQrStateChanged(state) => {
-                BackgroundEvent::HybridStateChanged(state.into())
-            }
-            crate::model::BackgroundEvent::UsbStateChanged(state) => {
-                BackgroundEvent::UsbStateChanged(state.into())
-                /*
-                let state: UsbState = state.into();
-                let value = Value::new(state)
-                    .try_to_owned()
-                    .expect("non-file descriptor value to succeed");
-                */
-            }
-        }
-    }
-}
-
 #[derive(Clone, Debug, DeserializeDict, Type)]
 #[zvariant(signature = "dict")]
 pub struct CreateCredentialRequest {
@@ -1016,7 +975,7 @@ mod test {
     #[test]
     fn test_serialize_background_hybrid_event() {
         let state = crate::model::HybridState::Started("FIDO:/1234".to_string());
-        let event = BackgroundEvent::HybridStateChanged(state);
+        let event = BackgroundEvent::HybridQrStateChanged(state);
         let ctx = zvariant::serialized::Context::new_dbus(zvariant::BE, 0);
         assert_eq!("(yv)", BackgroundEvent::SIGNATURE.to_string());
         let data = zvariant::to_bytes(ctx, &event).unwrap();
@@ -1033,13 +992,13 @@ mod test {
         let event: BackgroundEvent = data.deserialize().unwrap().0;
         assert!(matches!(
             event,
-            BackgroundEvent::HybridStateChanged(crate::model::HybridState::Completed)
+            BackgroundEvent::HybridQrStateChanged(crate::model::HybridState::Completed)
         ));
     }
 
     #[test]
     fn test_round_trip_background_hybrid_event() {
-        let event = BackgroundEvent::HybridStateChanged(crate::model::HybridState::Started(
+        let event = BackgroundEvent::HybridQrStateChanged(crate::model::HybridState::Started(
             String::from("FIDO:/1234"),
         ));
         let ctx = zvariant::serialized::Context::new_dbus(zvariant::BE, 0);
@@ -1049,7 +1008,7 @@ mod test {
         let event_2: BackgroundEvent = data2.deserialize().unwrap().0;
         assert!(matches!(
             event_2,
-            BackgroundEvent::HybridStateChanged(crate::model::HybridState::Started(ref f)) if f == "FIDO:/1234"
+            BackgroundEvent::HybridQrStateChanged(crate::model::HybridState::Started(ref f)) if f == "FIDO:/1234"
         ));
     }
 

credentialsd-ui/src/client.rs

@@ -1,7 +1,7 @@
 use async_std::stream::Stream;
 use credentialsd_common::{client::FlowController, server::RequestId};
 use futures_lite::StreamExt;
-use zbus::{Connection, zvariant};
+use zbus::Connection;
 
 use crate::dbus::FlowControlServiceProxy;
 
@@ -69,11 +69,7 @@ impl FlowController for DbusCredentialClient {
             .map_err(|err| tracing::error!("Failed to initalize event stream: {err}"))?
             .filter_map(|msg| {
                 msg.args()
-                    .and_then(|args| {
-                        args.update
-                            .try_into()
-                            .map_err(|err: zvariant::Error| err.into())
-                    })
+                    .map(|args| args.update)
                     .inspect_err(|err| tracing::warn!("Failed to parse StateChanged signal: {err}"))
                     .ok()
             })

credentialsd-ui/src/dbus.rs

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

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::{
-    CredentialRequest, CredentialResponse, Error as CredentialServiceError, WebAuthnError,
+    BackgroundEvent, CredentialRequest, CredentialResponse, Error as CredentialServiceError, WebAuthnError
 };
-use credentialsd_common::server::{BackgroundEvent, Device, RequestId};
+use credentialsd_common::server::{Device, RequestId};
 use futures_lite::StreamExt;
 use tokio::sync::oneshot;
 use tokio::{