feat: add fprint support

TitouanReal · TitouanReal · commit 15a1d965fc75 · 2025-01-06T09:42:33.000+01:00
diff --git a/cosmic-settings/src/pages/system/users/fprint/fprintdaemon.rs b/cosmic-settings/src/pages/system/users/fprint/fprintdaemon.rs
@@ -0,0 +1,112 @@
+// Copyright 2025 Titouan Real <titouan.real@gmail.com>
+// SPDX-License-Identifier: GPL-3.0-only
+
+use zbus::{proxy, Connection};
+
+#[proxy(
+    interface = "net.reactivated.Fprint.Manager",
+    default_service = "net.reactivated.Fprint",
+    default_path = "/net/reactivated/Fprint/Manager"
+)]
+pub trait FprintManager {
+    fn get_default_device(&self) -> zbus::Result<zbus::zvariant::OwnedObjectPath>;
+
+    fn get_devices(&self) -> zbus::Result<Vec<zbus::zvariant::OwnedObjectPath>>;
+}
+
+#[proxy(
+    interface = "net.reactivated.Fprint.Device",
+    default_service = "net.reactivated.Fprint",
+    assume_defaults = true
+)]
+pub trait FprintDevice {
+    fn claim(&self, username: &str) -> zbus::Result<()>;
+
+    fn delete_enrolled_finger(&self, finger_name: &str) -> zbus::Result<()>;
+
+    fn delete_enrolled_fingers(&self, username: &str) -> zbus::Result<()>;
+
+    fn delete_enrolled_fingers2(&self) -> zbus::Result<()>;
+
+    fn enroll_start(&self, finger_name: &str) -> zbus::Result<()>;
+
+    fn enroll_stop(&self) -> zbus::Result<()>;
+
+    fn list_enrolled_fingers(&self, username: &str) -> zbus::Result<Vec<String>>;
+
+    fn release(&self) -> zbus::Result<()>;
+
+    fn verify_start(&self, finger_name: &str) -> zbus::Result<()>;
+
+    fn verify_stop(&self) -> zbus::Result<()>;
+
+    #[zbus(signal)]
+    fn enroll_status(&self, result: &str, done: bool) -> zbus::Result<()>;
+
+    #[zbus(signal)]
+    fn verify_finger_selected(&self, finger_name: &str) -> zbus::Result<()>;
+
+    #[zbus(signal)]
+    fn verify_status(&self, result: &str, done: bool) -> zbus::Result<()>;
+
+    #[zbus(property, name = "finger-needed")]
+    fn finger_needed(&self) -> zbus::Result<bool>;
+
+    #[zbus(property, name = "finger-present")]
+    fn finger_present(&self) -> zbus::Result<bool>;
+
+    #[zbus(property, name = "name")]
+    fn name(&self) -> zbus::Result<String>;
+
+    #[zbus(property, name = "num-enroll-stages")]
+    fn num_enroll_stages(&self) -> zbus::Result<i32>;
+
+    #[zbus(property, name = "scan-type")]
+    fn scan_type(&self) -> zbus::Result<String>;
+}
+
+pub async fn get_fprint_manager_proxy<'a>() -> Result<FprintManagerProxy<'a>, ()> {
+    let connection = match Connection::system().await {
+        Ok(c) => c,
+        Err(e) => {
+            tracing::error!("zbus connection failed. {e}");
+            return Err(());
+        }
+    };
+
+    match FprintManagerProxy::new(&connection).await {
+        Ok(d) => Ok(d),
+        Err(e) => {
+            tracing::error!("Fprint daemon proxy can't be created. Is it installed? {e}");
+            Err(())
+        }
+    }
+}
+
+pub async fn get_fprint_device_proxy<'a>(
+    device_object_path: zbus::zvariant::OwnedObjectPath,
+) -> Result<FprintDeviceProxy<'a>, ()> {
+    let connection = match Connection::system().await {
+        Ok(c) => c,
+        Err(e) => {
+            tracing::error!("zbus connection failed. {e}");
+            return Err(());
+        }
+    };
+
+    let proxy_builder = match FprintDeviceProxy::builder(&connection).path(device_object_path) {
+        Ok(d) => d,
+        Err(e) => {
+            tracing::error!("{e}");
+            return Err(());
+        }
+    };
+
+    match proxy_builder.build().await {
+        Ok(d) => Ok(d),
+        Err(e) => {
+            tracing::error!("Fprint daemon proxy can't be created. Is it installed? {e}");
+            Err(())
+        }
+    }
+}
diff --git a/cosmic-settings/src/pages/system/users/fprint/mod.rs b/cosmic-settings/src/pages/system/users/fprint/mod.rs
@@ -0,0 +1,119 @@
+mod fprintdaemon;
+
+#[derive(Clone, Debug)]
+pub enum FingerName {
+    Any,
+    LeftThumb,
+    LeftIndexFinger,
+    LeftMiddleFinger,
+    LeftRingFinger,
+    LeftLittleFinger,
+    RightThumb,
+    RightIndexFinger,
+    RightMiddleFinger,
+    RightRingFinger,
+    RightLittleFinger,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct FprintDeviceInfo {
+    pub name: String,
+    pub enrolled_fingers: Vec<FingerName>,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct FprintInfo {
+    pub default_device: Option<FprintDeviceInfo>,
+    pub other_devices: Vec<FprintDeviceInfo>,
+}
+
+async fn get_fprint_device_info(
+    object_path: zbus::zvariant::OwnedObjectPath,
+    username: &str,
+) -> Result<FprintDeviceInfo, ()> {
+    let daemon = fprintdaemon::get_fprint_device_proxy(object_path).await?;
+    let name = match daemon.name().await {
+        Ok(name) => name,
+        Err(e) => {
+            tracing::error!("{e}");
+            return Err(());
+        }
+    };
+    let fingers = match daemon.list_enrolled_fingers(username).await {
+        Ok(fingers) => {
+            let mut fingers_vec = Vec::new();
+            for finger in fingers {
+                fingers_vec.push(match finger.as_ref() {
+                    "left-thumb" => FingerName::LeftThumb,
+                    "left-index-finger" => FingerName::LeftIndexFinger,
+                    "left-middle-finger" => FingerName::LeftMiddleFinger,
+                    "left-ring-finger" => FingerName::LeftRingFinger,
+                    "left-little-finger" => FingerName::LeftLittleFinger,
+                    "right-thumb" => FingerName::RightThumb,
+                    "right-index-finger" => FingerName::RightIndexFinger,
+                    "right-middle-finger" => FingerName::RightMiddleFinger,
+                    "right-ring-finger" => FingerName::RightRingFinger,
+                    "right-little-finger" => FingerName::RightLittleFinger,
+                    other => {
+                        tracing::error!("Received unexpected finger name: {other}");
+                        return Err(());
+                    }
+                });
+            }
+            fingers_vec
+        }
+        Err(e) => {
+            tracing::error!("{e}");
+            return Err(());
+        }
+    };
+
+    Ok(FprintDeviceInfo {
+        name,
+        enrolled_fingers: fingers,
+    })
+}
+
+pub async fn get_fprint_info(username: &str) -> Result<FprintInfo, ()> {
+    let daemon = fprintdaemon::get_fprint_manager_proxy().await?;
+
+    let default_device_path = match daemon.get_default_device().await {
+        Ok(device) => Some(device),
+        Err(zbus::Error::MethodError(_, _, _)) => None,
+        Err(e) => {
+            tracing::error!("{e}");
+            return Err(());
+        }
+    };
+
+    let default_device_info = match default_device_path {
+        Some(ref path) => Some(get_fprint_device_info(path.clone(), username).await?),
+        None => None,
+    };
+
+    tracing::info!("Default device: {:?}", default_device_info);
+
+    let other_devices = match daemon.get_devices().await {
+        Ok(mut devices) => {
+            if let Some(default_device) = default_device_path {
+                devices.retain(|device| device != &default_device);
+            }
+            let mut devices_info = Vec::new();
+            for device in devices {
+                devices_info.push(get_fprint_device_info(device, username).await?)
+            }
+            devices_info
+        }
+        Err(e) => {
+            tracing::error!("{e}");
+            return Err(());
+        }
+    };
+
+    tracing::info!("Other devices: {:?}", other_devices);
+
+    Ok(FprintInfo {
+        default_device: default_device_info,
+        other_devices,
+    })
+}
diff --git a/cosmic-settings/src/pages/system/users/mod.rs b/cosmic-settings/src/pages/system/users/mod.rs
@@ -1,6 +1,7 @@
 // Copyright 2024 System76 <info@system76.com>
 // SPDX-License-Identifier: GPL-3.0-only
 
+mod fprint;
 mod getent;
 
 use cosmic::{
@@ -10,6 +11,7 @@ use cosmic::{
     Apply, Element,
 };
 use cosmic_settings_page::{self as page, section, Section};
+use fprint::FprintInfo;
 use slab::Slab;
 use slotmap::SlotMap;
 use std::{
@@ -37,6 +39,7 @@ pub struct User {
     full_name_edit: bool,
     password_edit: bool,
     username_edit: bool,
+    fprint_info: FprintInfo,
     is_admin: bool,
 }
 
@@ -278,6 +281,9 @@ impl Page {
                         admin_group.map_or(false, |group| group.users.contains(&user.username))
                     }
                 },
+                fprint_info: fprint::get_fprint_info(&user.username)
+                    .await
+                    .unwrap_or_default(),
                 username: String::from(user.username),
                 full_name: String::from(user.full_name),
                 password: String::new(),
@@ -634,19 +640,34 @@ fn user_list() -> Section<crate::pages::Message> {
                         let mut details_list = widget::list_column()
                             .add(settings::item(&page.fullname_label, fullname))
                             .add(settings::item(&page.username_label, username))
-                            .add(settings::item(&page.password_label, password))
-                            .add(settings::item_row(vec![
-                                column::with_capacity(2)
-                                    .push(text::body(crate::fl!("administrator")))
-                                    .push(text::caption(crate::fl!("administrator", "desc")))
-                                    .into(),
-                                widget::horizontal_space().width(Length::Fill).into(),
-                                widget::toggler(user.is_admin)
-                                    .on_toggle(|enabled| {
-                                        Message::SelectedUserSetAdmin(user.id, enabled)
-                                    })
-                                    .into(),
-                            ]));
+                            .add(settings::item(&page.password_label, password));
+
+                        if let Some(device) = &user.fprint_info.default_device {
+                            details_list = details_list.add(settings::item(
+                                format!("{} (Default Device)", device.name.clone()),
+                                widget::text(format!("{:?}", device.enrolled_fingers)),
+                            ));
+                        }
+
+                        for device in &user.fprint_info.other_devices {
+                            details_list = details_list.add(settings::item(
+                                device.name.clone(),
+                                widget::text(format!("{:?}", device.enrolled_fingers)),
+                            ));
+                        }
+
+                        details_list = details_list.add(settings::item_row(vec![
+                            column::with_capacity(2)
+                                .push(text::body(crate::fl!("administrator")))
+                                .push(text::caption(crate::fl!("administrator", "desc")))
+                                .into(),
+                            widget::horizontal_space().width(Length::Fill).into(),
+                            widget::toggler(user.is_admin)
+                                .on_toggle(|enabled| {
+                                    Message::SelectedUserSetAdmin(user.id, enabled)
+                                })
+                                .into(),
+                        ]));
 
                         if page.users.len() > 1 {
                             details_list = details_list.add(settings::item_row(vec![
