Add completed-state to have option to keep window open (not yet working, because of cancel-request intervening)

Author: msirringhaus

credentialsd-common/src/model.rs

@@ -40,6 +40,7 @@ pub struct Device {
 pub enum Operation {
     Create,
     Get,
+    SetDevicePin,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
@@ -139,6 +140,14 @@ impl ViewUpdateFailure {
     }
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum ViewUpdateSuccess {
+    /// Success that requires the window to close
+    CloseWindow,
+    /// Success that requires the window to stay open
+    KeepWindowOpen(String),
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum ViewUpdate {
     SetTitle((String, String)),
@@ -159,7 +168,7 @@ pub enum ViewUpdate {
     HybridConnecting,
     HybridConnected,
 
-    Completed,
+    Completed(ViewUpdateSuccess),
     Cancelled,
     Failed(ViewUpdateFailure),
 }

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

@@ -4,7 +4,7 @@ pub mod device;
 mod window;
 
 use async_std::channel::{Receiver, Sender};
-use credentialsd_common::model::ViewUpdateFailure;
+use credentialsd_common::model::{ViewUpdateFailure, ViewUpdateSuccess};
 use credentialsd_common::server::WindowHandle;
 use gettextrs::{LocaleCategory, gettext, ngettext};
 use glib::clone;
@@ -203,10 +203,15 @@ impl ViewModel {
                                     ));
                                     view_model.set_qr_spinner_visible(false);
                                 }
-                                ViewUpdate::Completed => {
+                                ViewUpdate::Completed(ViewUpdateSuccess::CloseWindow) => {
                                     view_model.set_qr_spinner_visible(false);
                                     view_model.set_completed(true);
                                 }
+                                ViewUpdate::Completed(ViewUpdateSuccess::KeepWindowOpen(text)) => {
+                                    view_model.set_qr_spinner_visible(false);
+                                    // These are already gettext messages
+                                    view_model.set_prompt(text);
+                                }
                                 ViewUpdate::Failed(error) => {
                                     view_model.set_qr_spinner_visible(false);
                                     view_model.set_failed(true);

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

@@ -7,7 +7,7 @@ use async_std::{
     channel::{Receiver, Sender},
     sync::Mutex as AsyncMutex,
 };
-use credentialsd_common::model::RequestingApplication;
+use credentialsd_common::model::{RequestingApplication, ViewUpdateSuccess};
 use credentialsd_common::server::ViewRequest;
 use gettextrs::gettext;
 use serde::{Deserialize, Serialize};
@@ -89,6 +89,7 @@ impl<F: FlowController + Send> ViewModel<F> {
                 // TRANSLATORS: %s1 is the "relying party" (think: domain name) where the request is coming from
                 gettext("Use a passkey for %s1")
             }
+            Operation::SetDevicePin => gettext("Setting Pin on device"),
         }
         .to_string();
         title = title.replace("%s1", &self.rp_id);
@@ -108,6 +109,7 @@ impl<F: FlowController + Send> ViewModel<F> {
                 // TRANSLATORS: %s3 is the absolute path (think: /usr/bin/firefox) of the requesting application
                 gettext("<b>\"%s2\"</b> (process ID: %i1, binary: %s3) is asking to use a credential to sign in to \"%s1\". Only proceed if you trust this process.")
             }
+            Operation::SetDevicePin => gettext("Setting Pin on device"),
         }
         .to_string();
         subtitle = subtitle.replace("%s1", &self.rp_id);
@@ -216,6 +218,7 @@ impl<F: FlowController + Send> ViewModel<F> {
                 Event::View(ViewEvent::SetNewDevicePin(pin)) => {
                     if let Some(device) = &self.selected_device {
                         let mut cred_service = self.flow_controller.lock().await;
+                        self.operation = Operation::SetDevicePin;
                         let resp = match device.transport {
                             Transport::Usb => cred_service.set_usb_device_pin(pin).await,
                             Transport::Nfc => cred_service.set_nfc_device_pin(pin).await,
@@ -282,7 +285,15 @@ impl<F: FlowController + Send> ViewModel<F> {
                                 .unwrap();
                         }
                         UsbState::Completed => {
-                            self.tx_update.send(ViewUpdate::Completed).await.unwrap();
+                            let t = if matches!(self.operation, Operation::SetDevicePin) {
+                                ViewUpdateSuccess::KeepWindowOpen(gettext(
+                                    "Pin successfully set! Please try registering again.",
+                                ))
+                            } else {
+                                ViewUpdateSuccess::CloseWindow
+                            };
+
+                            self.tx_update.send(ViewUpdate::Completed(t)).await.unwrap();
                         }
                         UsbState::SelectingDevice => {
                             self.tx_update
@@ -353,7 +364,14 @@ impl<F: FlowController + Send> ViewModel<F> {
                                 .unwrap();
                         }
                         NfcState::Completed => {
-                            self.tx_update.send(ViewUpdate::Completed).await.unwrap();
+                            let t = if matches!(self.operation, Operation::SetDevicePin) {
+                                ViewUpdateSuccess::KeepWindowOpen(gettext(
+                                    "Pin successfully set! Please try registering again.",
+                                ))
+                            } else {
+                                ViewUpdateSuccess::CloseWindow
+                            };
+                            self.tx_update.send(ViewUpdate::Completed(t)).await.unwrap();
                         }
                         NfcState::Idle | NfcState::Waiting => {}
                         NfcState::SelectingCredential { creds } => {
@@ -429,7 +447,10 @@ impl<F: FlowController + Send> ViewModel<F> {
                         }
                         HybridState::Completed => {
                             self.hybrid_qr_code_data = None;
-                            self.tx_update.send(ViewUpdate::Completed).await.unwrap();
+                            self.tx_update
+                                .send(ViewUpdate::Completed(ViewUpdateSuccess::CloseWindow))
+                                .await
+                                .unwrap();
                         }
                         HybridState::UserCancelled => {
                             self.hybrid_qr_code_data = None;

credentialsd/src/dbus/flow_control.rs

@@ -326,7 +326,7 @@ where
                         );
                         break;
                     }
-                    UsbState::SelectCredential { cred_tx, .. } => {
+                    UsbState::SelectingCredential { cred_tx, .. } => {
                         // TODO: This is not great. The user potentially already selected a device,
                         //       but we are starting a new request cycle, so they have to select one
                         //       again... But the previous cycle has already ended.

credentialsd/src/webauthn.rs

@@ -682,6 +682,7 @@ pub fn format_client_data_json(
     let op_str = match op {
         Operation::Create => "webauthn.create",
         Operation::Get => "webauthn.get",
+        _ => unreachable!(),
     };
     let mut client_data_json = format!(
         r#"{{"type":"{}","challenge":"{}","origin":"{}""#,