Skip to content

Commit 323b941

Browse files
iinuwaiinuwa
committed
ui: Remove unused D-Bus stuff
1 parent 71e6df3 commit 323b941

4 files changed

Lines changed: 6 additions & 235 deletions

File tree

‎credentialsd-ui/src/client.rs‎

Lines changed: 1 addition & 124 deletions
Original file line numberDiff line numberDiff line change
@@ -1,131 +1,8 @@
11
use async_std::{
22
channel::{Receiver, Sender},
3-
stream::Stream,
43
sync::Mutex as AsyncMutex,
54
};
6-
use credentialsd_common::{
7-
client::FlowController,
8-
model::{RequestId, UserInteractedEvent},
9-
server::BackgroundEvent,
10-
};
11-
use futures_lite::StreamExt;
12-
use zbus::Connection;
13-
14-
use crate::dbus::FlowControlServiceProxy;
15-
16-
pub struct DbusCredentialClient {
17-
conn: Connection,
18-
}
19-
20-
impl DbusCredentialClient {
21-
pub fn new(conn: Connection) -> Self {
22-
Self { conn }
23-
}
24-
async fn proxy(&self) -> std::result::Result<FlowControlServiceProxy<'_>, ()> {
25-
FlowControlServiceProxy::new(&self.conn)
26-
.await
27-
.map_err(|err| tracing::error!("Failed to communicate with D-Bus service: {err}"))
28-
}
29-
}
30-
31-
impl FlowController for DbusCredentialClient {
32-
async fn get_available_public_key_devices(
33-
&self,
34-
) -> std::result::Result<Vec<credentialsd_common::model::Device>, ()> {
35-
self.proxy()
36-
.await?
37-
.get_available_public_key_devices()
38-
.await
39-
.map_err(|err| {
40-
tracing::error!("Failed to retrieve available devices/transports: {err}")
41-
})
42-
}
43-
44-
async fn get_hybrid_credential(&mut self) -> std::result::Result<(), ()> {
45-
self.proxy()
46-
.await?
47-
.get_hybrid_credential()
48-
.await
49-
.inspect_err(|err| tracing::error!("Failed to start hybrid credential flow: {err}"))
50-
.map_err(|_| ())
51-
}
52-
53-
async fn get_usb_credential(&mut self) -> std::result::Result<(), ()> {
54-
self.proxy()
55-
.await?
56-
.get_usb_credential()
57-
.await
58-
.inspect_err(|err| tracing::error!("Failed to start USB credential flow: {err}"))
59-
.map_err(|_| ())
60-
}
61-
62-
async fn get_nfc_credential(&mut self) -> std::result::Result<(), ()> {
63-
self.proxy()
64-
.await?
65-
.get_nfc_credential()
66-
.await
67-
.inspect_err(|err| tracing::error!("Failed to start NFC credential flow: {err}"))
68-
.map_err(|_| ())
69-
}
70-
71-
async fn subscribe(
72-
&mut self,
73-
) -> std::result::Result<
74-
std::pin::Pin<
75-
Box<dyn Stream<Item = credentialsd_common::server::BackgroundEvent> + Send + 'static>,
76-
>,
77-
(),
78-
> {
79-
let stream = self
80-
.proxy()
81-
.await?
82-
.receive_state_changed()
83-
.await
84-
.map_err(|err| tracing::error!("Failed to initalize event stream: {err}"))?
85-
.filter_map(|msg| {
86-
msg.args()
87-
.map(|args| args.update)
88-
.inspect_err(|err| tracing::warn!("Failed to parse StateChanged signal: {err}"))
89-
.ok()
90-
})
91-
.boxed();
92-
self.proxy()
93-
.await?
94-
.subscribe()
95-
.await
96-
.map_err(|err| tracing::error!("Failed to initialize event stream: {err}"))
97-
.map(|_| stream)
98-
}
99-
100-
async fn enter_client_pin(&mut self, pin: String) -> std::result::Result<(), ()> {
101-
self.proxy()
102-
.await?
103-
.enter_client_pin(pin)
104-
.await
105-
.map_err(|err| tracing::error!("Failed to send PIN to authenticator: {err}"))
106-
}
107-
108-
async fn select_credential(&self, credential_id: String) -> std::result::Result<(), ()> {
109-
self.proxy()
110-
.await?
111-
.select_credential(credential_id)
112-
.await
113-
.map_err(|err| tracing::error!("Failed to select credential: {err}"))
114-
}
115-
116-
async fn cancel_request(&self, request_id: RequestId) -> Result<(), ()> {
117-
if self
118-
.proxy()
119-
.await?
120-
.cancel_request(request_id)
121-
.await
122-
.is_err()
123-
{
124-
tracing::warn!("Failed to cancel request {request_id}");
125-
}
126-
Ok(())
127-
}
128-
}
5+
use credentialsd_common::{model::UserInteractedEvent, server::BackgroundEvent};
1296

1307
#[derive(Debug)]
1318
pub struct FlowControlClient {

‎credentialsd-ui/src/dbus.rs‎

Lines changed: 3 additions & 102 deletions
Original file line numberDiff line numberDiff line change
@@ -1,126 +1,27 @@
11
use std::sync::Arc;
22

33
use async_std::{
4-
channel::{self, Receiver, Sender},
5-
stream::StreamExt,
4+
channel::{self, Sender},
65
sync::Mutex as AsyncMutex,
76
task::JoinHandle,
87
};
98
use zbus::{
10-
Connection, ObjectServer, fdo, interface,
9+
ObjectServer, fdo, interface,
1110
message::Header,
1211
names::{BusName, OwnedUniqueName},
1312
object_server::SignalEmitter,
14-
proxy,
1513
zvariant::{ObjectPath, Optional},
1614
};
1715

1816
use credentialsd_common::{
19-
client::FlowController,
2017
model::{
2118
Device, Operation, PortalBackendOptions, RequestId, RequestingApplication,
2219
UserInteractedEvent,
2320
},
2421
server::{BackgroundEvent, ViewRequest, WindowHandle},
2522
};
2623

27-
use crate::client::{DbusCredentialClient, FlowControlClient};
28-
29-
#[proxy(
30-
gen_blocking = false,
31-
interface = "xyz.iinuwa.credentialsd.FlowControl1",
32-
default_path = "/xyz/iinuwa/credentialsd/FlowControl",
33-
default_service = "xyz.iinuwa.credentialsd.FlowControl"
34-
)]
35-
pub trait FlowControlService {
36-
async fn subscribe(&self) -> fdo::Result<()>;
37-
38-
async fn get_available_public_key_devices(&self) -> fdo::Result<Vec<Device>>;
39-
40-
async fn get_hybrid_credential(&self) -> fdo::Result<()>;
41-
42-
async fn get_usb_credential(&self) -> fdo::Result<()>;
43-
async fn get_nfc_credential(&self) -> fdo::Result<()>;
44-
45-
async fn select_device(&self, device_id: String) -> fdo::Result<()>;
46-
async fn enter_client_pin(&self, pin: String) -> fdo::Result<()>;
47-
async fn select_credential(&self, credential_id: String) -> fdo::Result<()>;
48-
async fn cancel_request(&self, request_id: RequestId) -> fdo::Result<()>;
49-
50-
#[zbus(signal)]
51-
async fn state_changed(update: BackgroundEvent) -> zbus::Result<()>;
52-
}
53-
54-
pub struct UiControlService {
55-
pub request_tx: Sender<(ViewRequest, Arc<AsyncMutex<FlowControlClient>>)>,
56-
}
57-
58-
/// These methods are called by the credential service to control the UI.
59-
#[interface(name = "xyz.iinuwa.credentialsd.UiControl1")]
60-
impl UiControlService {
61-
async fn launch_ui(
62-
&self,
63-
#[zbus(connection)] conn: &Connection,
64-
request: ViewRequest,
65-
) -> fdo::Result<()> {
66-
tracing::debug!("Received UI launch request");
67-
let mut client = DbusCredentialClient::new(conn.clone());
68-
let (fc_tx, fc_rx) = async_std::channel::unbounded();
69-
let (bg_tx, bg_rx) = async_std::channel::unbounded();
70-
match client.subscribe().await {
71-
Ok(mut bg_event_stream) => async_std::task::spawn(async move {
72-
while let Some(bg_event) = bg_event_stream.next().await {
73-
if let Err(_) = bg_tx.send(bg_event).await {
74-
tracing::debug!("Background event receiver dropped. Stopping.");
75-
break;
76-
}
77-
}
78-
}),
79-
Err(_) => {
80-
tracing::error!(
81-
?request,
82-
"Failed to subscribe to background events for request"
83-
);
84-
return Err(fdo::Error::Failed(
85-
"Failed to subscribe to background events for request".to_string(),
86-
));
87-
}
88-
};
89-
async_std::task::spawn(async move {
90-
while let Ok(msg) = fc_rx.recv().await {
91-
// UI doesn't get an error if these fail...
92-
let result = match &msg {
93-
UserInteractedEvent::HybridDiscoveryRequested => {
94-
client.get_hybrid_credential().await
95-
}
96-
UserInteractedEvent::NfcDiscoveryRequested => client.get_nfc_credential().await,
97-
UserInteractedEvent::UsbDiscoveryRequested => client.get_usb_credential().await,
98-
UserInteractedEvent::ClientPinEntered(pin) => {
99-
client.enter_client_pin(pin.to_string()).await
100-
}
101-
UserInteractedEvent::CredentialSelected(cred_id) => {
102-
client.select_credential(cred_id.to_string()).await
103-
}
104-
UserInteractedEvent::RequestCancelled => {
105-
client.cancel_request(request.id).await
106-
}
107-
};
108-
if let Err(err) = result {
109-
tracing::error!("Failed to send {msg:?} to frontend: {err:?}");
110-
}
111-
}
112-
client
113-
});
114-
let flow_control_client = FlowControlClient {
115-
tx: fc_tx,
116-
rx: AsyncMutex::new(Some(bg_rx)),
117-
};
118-
self.request_tx
119-
.send((request, Arc::new(AsyncMutex::new(flow_control_client))))
120-
.await
121-
.map_err(|_| fdo::Error::Failed("UI failed to launch".to_string()))
122-
}
123-
}
24+
use crate::client::FlowControlClient;
12425

12526
pub struct CredentialPortalBackend {
12627
pub request_tx: Sender<(ViewRequest, Arc<AsyncMutex<FlowControlClient>>)>,

‎credentialsd-ui/src/gui/view_model/mod.rs‎

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -13,9 +13,7 @@ use gettextrs::gettext;
1313
use serde::{Deserialize, Serialize};
1414
use tracing::{error, info};
1515

16-
use credentialsd_common::model::{
17-
Device, Error, HybridState, NfcState, Operation, Transport, UsbState, ViewUpdate,
18-
};
16+
use credentialsd_common::model::{Device, HybridState, Operation, Transport, ViewUpdate};
1917

2018
use crate::client::FlowControlClient;
2119

‎credentialsd-ui/src/main.rs‎

Lines changed: 1 addition & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ mod gui;
66

77
use std::error::Error;
88

9-
use crate::dbus::{CredentialPortalBackend, UiControlService};
9+
use crate::dbus::CredentialPortalBackend;
1010

1111
fn main() -> Result<(), Box<dyn Error>> {
1212
tracing_subscriber::fmt::init();
@@ -23,15 +23,10 @@ async fn run() -> Result<(), Box<dyn Error>> {
2323
println!(" ✅");
2424

2525
print!("Starting UI Control listener...\t");
26-
let interface = UiControlService {
27-
request_tx: request_tx.clone(),
28-
};
2926
let portal_backend_interface = CredentialPortalBackend { request_tx };
30-
let path = "/xyz/iinuwa/credentialsd/UiControl";
3127
let service = "xyz.iinuwa.credentialsd.UiControl";
3228
let _server_conn = zbus::connection::Builder::session()?
3329
.name(service)?
34-
.serve_at(path, interface)?
3530
.serve_at("/org/freedesktop/portal/desktop", portal_backend_interface)?
3631
.build()
3732
.await?;

0 commit comments

Comments
 (0)