Struct FpContext

pub struct FpContext { /* private fields */ }

This struct allows you to discover fingerprint scanning hardware. This is the starting point when integrating libfprint-rs into your software.

Implementations

impl FpContext

pub fn new() -> Self

Create a new FpContext

Examples:

use libfprint_rs::FpContext;

let context = FpContext::new();

Examples found in repository

examples/verify.rs (line 5)

fn main() {
    // Get devices
    let ctx = FpContext::new();
    let devices = ctx.devices();
    let dev = devices.get(0).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 7)

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

    // Get the first connected device
    let dev = devices.get(0).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 devices(&self) -> Vec<FpDevice>

Get the list of devices connected to the system

Examples:

use libfprint_rs::FpContext;

let context = FpContext::new();
let devices = context.devices();

Examples found in repository

examples/verify.rs (line 6)

fn main() {
    // Get devices
    let ctx = FpContext::new();
    let devices = ctx.devices();
    let dev = devices.get(0).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 9)

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

    // Get the first connected device
    let dev = devices.get(0).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 enumerate(&self)

Enumerate all the devices connected to the system

This function will enumerate all the devices connected to the system and add them to the context.

Trait Implementations

impl Clone for FpContext

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FpContext

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

Formats the value using the given formatter.

impl HasParamSpec for FpContext

type ParamSpec = ParamSpecObject

type SetValue = FpContext

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

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

fn param_spec_builder() -> Self::BuilderFn

impl Hash for FpContext

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

where H: Hasher,

Feeds this value into the given Hasher.

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 FpContext

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

This method returns an Ordering between self and other.

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 FpContext

type Parent = Object

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

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

Tests for self and other values to be equal, and is used by ==.

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 FpContext

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

This method returns an ordering between self and other values if one exists.

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 FpContext

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for FpContext