Struct FpDevice 

pub struct FpDevice { /* private fields */ }

Fingerpint device routines. You can interact with fingerprint devices using this struct.

Examples:

use libfprint_rs::FpContext;

let context = FpContext::new();
let devices = context.devices();
let device = devices.get(0).unwrap();

device.open_sync(None).unwrap();
let name = device.name().unwrap();
println!("Device name: {}", name);

GLib type: GObject with reference counted clone semantics.

Implementations

impl FpDevice

pub fn open_sync(&self, cancellable: Option<&Cancellable>) -> Result<(), GError>

Open the device synchronously.

Example:

use libfprint_rs::{FpDevice, FpContext};

let ctx = FpContext::new();
let devices = ctx.devices();
let dev = devices.get(0).unwrap();

dev.open_sync(None).unwrap();

Examples found in repository

examples/verify.rs (line 8)

fn main() {
    // Get devices
    let ctx = FpContext::new();
    let devices = ctx.devices();
    let dev = devices.first().unwrap();
    dev.open_sync(None).unwrap();

    // Create a template print
    let template = FpPrint::new(dev);
    let enrolled_print = dev
        .enroll_sync(template, None, Some(progress_cb), None)
        .unwrap();

    // New print where we will store the next print
    let mut new_print = FpPrint::new(dev);

    // Verify if the next print matches the previously enrolled print
    let matched = dev
        .verify_sync(
            &enrolled_print,
            None,
            Some(match_cb),
            None,
            Some(&mut new_print),
        )
        .unwrap();
    if matched {
        println!("Matched again");
    }
}

examples/enroll.rs (line 15)

fn main() {
    // Get context
    let ctx = FpContext::new();
    // Collect connected devices
    let devices = ctx.devices();

    // Get the first connected device
    let dev = devices.first().unwrap();

    // Open the device to start operations
    dev.open_sync(None).unwrap();

    // Create a template print
    let template = FpPrint::new(dev);
    template.set_finger(FpFinger::RightRing);
    template.set_username("test");

    // User data that we will use on the callback function,
    // to mutate the value of a counter, it must be wrapped in an Arc<Mutex<T>>
    let counter = Arc::new(Mutex::new(0));

    // Get the new print from the user
    let _new_print = dev
        .enroll_sync(template, None, Some(progress_cb), Some(counter.clone()))
        .unwrap();

    // Get the total of time the enroll callback was called
    println!("Total enroll stages: {}", counter.lock().unwrap());
}

pub fn close_sync( &self, cancellable: Option<&Cancellable>, ) -> Result<(), GError>

Close the device synchronously.

Example:

use libfprint_rs::{FpDevice, FpContext};

let ctx = FpContext::new();
let devices = ctx.devices();
let dev = devices.get(0).unwrap();

dev.open_sync(None).unwrap();
dev.close_sync(None).unwrap();

pub fn enroll_sync<T>( &self, template: FpPrint, cancellable: Option<&Cancellable>, progress_cb: Option<FpEnrollProgress<T>>, progress_data: Option<T>, ) -> Result<FpPrint, GError>

Enroll a new print. Enrolls a print, progress_cb will be called for each stage of the enrollment process.

Example:

use libfprint_rs::{FpDevice, FpContext, FpPrint};

pub fn enroll_cb(device: &FpDevice,enroll_stage: i32, print: Option<FpPrint>, error: Option<libfprint_rs::GError>, data: &Option<i32>,) -> () {
    println!("Enroll stage: {}", enroll_stage);
}

let ctx = FpContext::new();
let devices = ctx.devices();
let dev = devices.get(0).unwrap();
dev.open_sync(None).unwrap();

let template = FpPrint::new(&dev);
let new_print = dev.enroll_sync(template, None, Some(enroll_cb), Some(10)).unwrap();

dev.close_sync(None).unwrap();

Examples found in repository

examples/verify.rs (line 13)

fn main() {
    // Get devices
    let ctx = FpContext::new();
    let devices = ctx.devices();
    let dev = devices.first().unwrap();
    dev.open_sync(None).unwrap();

    // Create a template print
    let template = FpPrint::new(dev);
    let enrolled_print = dev
        .enroll_sync(template, None, Some(progress_cb), None)
        .unwrap();

    // New print where we will store the next print
    let mut new_print = FpPrint::new(dev);

    // Verify if the next print matches the previously enrolled print
    let matched = dev
        .verify_sync(
            &enrolled_print,
            None,
            Some(match_cb),
            None,
            Some(&mut new_print),
        )
        .unwrap();
    if matched {
        println!("Matched again");
    }
}

examples/enroll.rs (line 28)

fn main() {
    // Get context
    let ctx = FpContext::new();
    // Collect connected devices
    let devices = ctx.devices();

    // Get the first connected device
    let dev = devices.first().unwrap();

    // Open the device to start operations
    dev.open_sync(None).unwrap();

    // Create a template print
    let template = FpPrint::new(dev);
    template.set_finger(FpFinger::RightRing);
    template.set_username("test");

    // User data that we will use on the callback function,
    // to mutate the value of a counter, it must be wrapped in an Arc<Mutex<T>>
    let counter = Arc::new(Mutex::new(0));

    // Get the new print from the user
    let _new_print = dev
        .enroll_sync(template, None, Some(progress_cb), Some(counter.clone()))
        .unwrap();

    // Get the total of time the enroll callback was called
    println!("Total enroll stages: {}", counter.lock().unwrap());
}

pub fn verify_sync<T>( &self, enrolled_print: &FpPrint, cancellable: Option<Cancellable>, match_cb: Option<FpMatchCb<T>>, match_data: Option<T>, print: Option<&mut FpPrint>, ) -> Result<bool, GError>

Verify a given print synchronously. match_cb will be called when the verification is done.

Example:

use libfprint_rs::{FpDevice, FpContext, FpPrint, GError};

pub fn match_cb(device: &FpDevice, matched_print: Option<FpPrint>, enrolled_print: FpPrint,
error: Option<GError>, data: &Option<i32>) {
    if matched_print.is_some() {
        println!("Matched print: {:?}", matched_print);
    }
}
let ctx = FpContext::new();
let devices = ctx.devices();
let dev = devices.get(0).unwrap();
dev.open_sync(None).unwrap();

let some_print: FpPrint = foreign_function_that_gets_print();
let mut new_print = FpPrint::new(&dev); // The variable that will hold the new print
let verified = dev.verify_sync(&some_print, None, Some(match_cb), Some(10), Some(&mut
new_print)).unwrap();
if verified {
   println!("Print verified");println
}

Examples found in repository

examples/verify.rs (lines 21-27)

fn main() {
    // Get devices
    let ctx = FpContext::new();
    let devices = ctx.devices();
    let dev = devices.first().unwrap();
    dev.open_sync(None).unwrap();

    // Create a template print
    let template = FpPrint::new(dev);
    let enrolled_print = dev
        .enroll_sync(template, None, Some(progress_cb), None)
        .unwrap();

    // New print where we will store the next print
    let mut new_print = FpPrint::new(dev);

    // Verify if the next print matches the previously enrolled print
    let matched = dev
        .verify_sync(
            &enrolled_print,
            None,
            Some(match_cb),
            None,
            Some(&mut new_print),
        )
        .unwrap();
    if matched {
        println!("Matched again");
    }
}

pub fn suspend_sync( &self, cancellable: Option<&Cancellable>, ) -> Result<(), GError>

Prepare device for suspend.

pub fn resume_sync( &self, cancellable: Option<&Cancellable>, ) -> Result<(), GError>

Resume device after suspend.

pub fn identify_sync<T>( &self, prints: &[FpPrint], cancellable: Option<&Cancellable>, match_cb: Option<FpMatchCb<T>>, match_data: Option<T>, print: Option<&mut FpPrint>, ) -> Result<Option<FpPrint>, GError>

Identify a print synchronously.

match_cb will be called when a print matches or at the end of the operation.

Example:

use libfprint_rs::{FpDevice, FpContext, FpPrint, GError};

pub fn match_cb(device: &FpDevice, matched_print: Option<FpPrint>, enrolled_print: FpPrint,
error: Option<GError>, data: &Option<i32>) {
    if matched_print.is_some() {
        println!("Matched print: {:?}", matched_print);
    }
}

let ctx = FpContext::new();
let devices = ctx.devices();
let dev = devices.get(0).unwrap();
dev.open_sync(None).unwrap();

let vec_prints: Vec<FpPrint> = function_returning_Vec_prints();
let mut new_print = FpPrint::new(&dev); // The variable that will hold the new print
let print_identified = dev.identify_sync(&vec_prints, None, Some(match_cb), Some(10), Some(&mut
new_print)).unwrap();
if print_identified.is_some() {
    println!("Found matching print on vector passed");
}

pub fn capture_sync( &self, wait_for_finger: bool, cancellable: Option<&Cancellable>, ) -> Result<FpImage, GError>

Start an synchronous operation to capture an image.

Example:

let ctx = FpContext::new();
let devices = ctx.devices();
let dev = devices.get(0).unwrap();
dev.open_sync(None).unwrap();

let image = dev.capture_sync(true, None).unwrap();

pub fn delete_print_sync()

Delete a given print from the device.

pub fn list_prints_sync()

List device stored prints synchronously.

pub fn clear_storage_sync()

Clear sensor storage.

impl FpDevice

pub fn driver(&self) -> String

The ID of the driver.

pub fn device_id(&self) -> String

The ID of the device.

pub fn name(&self) -> String

The human readable name of the device.

pub fn scan_type(&self) -> FpScanType

Retrieves the scan type of the device.

pub fn nr_enroll_stage(&self) -> i32

Retrieves the number of enroll stages for this device.

pub fn finger_status(&self) -> FpFingerStatus

Retrieves the finger status flags for the device. This can be used by the UI to present the relevant feedback, although it is not guaranteed to be a relevant value when not performing any action.

pub fn features(&self) -> Vec<FpDeviceFeature>

Gets the FpDeviceFeature’s supported by the device .

pub fn has_feature(&self, feature: FpDeviceFeature) -> bool

Checks if device supports the requested FpDeviceFeature.

pub fn is_open(&self) -> bool

Whether the device is open or not

Trait Implementations

impl Clone for FpDevice

fn clone(&self) -> Self

Makes a clone of this shared reference.

This increments the strong reference count of the object. Dropping the object will decrement it again.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FpDevice

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl HasParamSpec for FpDevice

type ParamSpec = ParamSpecObject

type SetValue = FpDevice

Preferred value to be used as setter for the associated ParamSpec.

type BuilderFn = fn(&str) -> ParamSpecObjectBuilder<'_, FpDevice>

fn param_spec_builder() -> Self::BuilderFn

impl Hash for FpDevice

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Hashes the memory address of this object.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for FpDevice

fn cmp(&self, other: &Self) -> Ordering

Comparison for two GObjects.

Compares the memory addresses of the provided objects.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl ParentClassIs for FpDevice

type Parent = Object

impl<OT: ObjectType> PartialEq<OT> for FpDevice

fn eq(&self, other: &OT) -> bool

Equality for two GObjects.

Two GObjects are equal if their memory addresses are equal.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<OT: ObjectType> PartialOrd<OT> for FpDevice

fn partial_cmp(&self, other: &OT) -> Option<Ordering>

Partial comparison for two GObjects.

Compares the memory addresses of the provided objects.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for FpDevice

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for FpDevice

impl IsA<AsyncInitable> for FpDevice