fprint

https://fprint.freedesktop.org/
Admin
fprint is a collection of open source software providing fingerprint reader support for Linux and...
Tokens:54,695
Snippets:484
Trust Score:7.9
Update:6 months ago
Show doc for...
Tokens:
Raw
### fpi_ssm_start

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Sequential-state-machine.html

Starts a state machine or restarts a completed/failed one.

```APIDOC
## fpi_ssm_start

### Description
Starts a state machine. You can also use this function to restart a completed or failed state machine. The callback will be called on completion. Note that ssm will be stolen when this function is called.

### Parameters
#### Path Parameters
- **ssm** (FpiSsm) - Required - an FpiSsm state machine
- **callback** (FpiSsmCompletedCallback) - Required - the FpiSsmCompletedCallback callback to call on completion
```

--------------------------------

### Start a sub-state machine

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Sequential-state-machine.html

Starts a child state machine. Completion or failure of the child automatically advances or fails the parent.

```c
void
fpi_ssm_start_subsm (_FpiSsm *parent_,
                     _FpiSsm *child_);
```

--------------------------------

### Start an FpiSsm state machine

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Sequential-state-machine.html

Starts or restarts a state machine. The machine is stolen upon calling this, and associated data is freed after the callback runs.

```c
void
fpi_ssm_start (_FpiSsm *ssm_,
               _FpiSsmCompletedCallback callback_);
```

--------------------------------

### Create a new FpPrint

Source: https://fprint.freedesktop.org/libfprint-dev/FpPrint.html

Initializes a new FpPrint object, typically used before starting an enrollment process with fp_device_enroll().

```c
FpPrint *
fp_print_new (_FpDevice *device_);
```

--------------------------------

### Verify Finger Methods

Source: https://fprint.freedesktop.org/fprintd-dev/Device.html

Starts and stops the fingerprint verification process. VerifyStart initiates verification for a specific finger, and VerifyStop terminates the process.

```dbus
VerifyStart            (in  's'  finger_name)
VerifyStop             ()
```

--------------------------------

### Allocate New State Machine with fpi_ssm_new_full()

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Sequential-state-machine.html

Allocates a new state machine with a specified number of states, handler callback, cleanup state start, and machine name for debugging.

```c
FpiSsm *
fpi_ssm_new_full (_FpDevice *dev_,
                  _FpiSsmHandlerCallback handler_,
                  _int nr_states_,
                  _int start_cleanup_,
                  _const char *machine_name_);
```

--------------------------------

### Prepare Device for System Suspend - fp_device_suspend

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Prepares the device for system suspension by initiating an asynchronous operation. This call must be paired with a corresponding resume call. Ongoing operations might be completed, cancelled, or allowed to finish after host resume. Operations started during suspension will fail with `FP_DEVICE_ERROR_BUSY`.

```c
void
fp_device_suspend (_FpDevice *device_,
                   _GCancellable *cancellable_,
                   _GAsyncReadyCallback callback_,
                   _gpointer user_data_);
```

--------------------------------

### Enroll Fingerprint (Asynchronous)

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Starts an asynchronous operation to enroll a fingerprint. Progress can be monitored via a callback.

```APIDOC
## fp_device_enroll

### Description
Start an asynchronous operation to enroll a print. The callback will be called once the operation has finished. Retrieve the result with `fp_device_enroll_finish()`.

The `template_print` parameter is a FpPrint with available metadata filled in and, optionally, with existing fingerprint data to be updated with newly enrolled fingerprints if a device driver supports it. The driver may make use of the metadata, when e.g. storing the print on device memory. It is undefined whether this print is filled in by the driver and returned, or whether the driver will return a newly created print after enrollment succeeded.

### Method
POST (conceptual, as this is an operation initiation)

### Endpoint
N/A (Function call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **template_print** (_FpPrint_) - A FpPrint with available metadata filled in and, optionally, with existing fingerprint data to be updated.
- **cancellable** (_GCancellable_) - A GCancellable, or `NULL`.
- **progress_cb** (_FpEnrollProgress_) - Progress reporting callback.
- **progress_data** (_gpointer_) - User data for `progress_cb`.
- **progress_destroy** (_GDestroyNotify_) - Destroy notify for `progress_data`.
- **callback** (_GAsyncReadyCallback_) - The function to call on completion.
- **user_data** (_gpointer_) - The data to pass to `callback`.

### Request Example
```c
fp_device_enroll(device, template_print, cancellable, progress_cb, progress_data, progress_destroy, callback, user_data);
```

### Response
#### Success Response (void)
Operation completes asynchronously. Result is obtained via `fp_device_enroll_finish()`.

#### Response Example
N/A (Asynchronous operation)
```

--------------------------------

### Enroll Finger Methods

Source: https://fprint.freedesktop.org/fprintd-dev/Device.html

Starts and stops the fingerprint enrollment process. EnrollStart begins enrollment for a specific finger, and EnrollStop concludes it.

```dbus
EnrollStart            (in  's'  finger_name)
EnrollStop             ()
```

--------------------------------

### fp_device_capture

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Starts an asynchronous operation to capture a fingerprint image. The callback is invoked upon completion.

```APIDOC
## fp_device_capture

### Description
Start an asynchronous operation to capture an image. The callback will be called once the operation has finished. Retrieve the result with `fp_device_capture_finish()`.

### Method
Asynchronous Operation (Callback-based)

### Endpoint
N/A (Function Call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
void fp_device_capture (_FpDevice *device_, _gboolean wait_for_finger_, _GCancellable *cancellable_, _GAsyncReadyCallback callback_, _gpointer user_data_);
```

### Response
#### Success Response
N/A (Asynchronous operation, result retrieved via callback)

#### Response Example
N/A
```

--------------------------------

### Start Asynchronous Image Capture - fp_device_capture

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Initiates an asynchronous operation to capture a fingerprint image. The provided callback is invoked upon completion. Use `fp_device_capture_finish()` to retrieve the result.

```c
void
fp_device_capture (_FpDevice *device_,
                   _gboolean wait_for_finger_,
                   _GCancellable *cancellable_,
                   _GAsyncReadyCallback callback_,
                   _gpointer user_data_);
```

--------------------------------

### Verify Fingerprint

Source: https://fprint.freedesktop.org/fprintd-dev/Device.html

Starts and stops the fingerprint verification process.

```APIDOC
## VerifyStart ()

### Description
Check the chosen finger against a saved fingerprint. You need to have claimed the device using Device.Claim.

### Parameters
#### Request Body
- finger_name (string) - Required - A string representing the finger to verify.

### Errors
- net.reactivated.Fprint.Error.PermissionDenied: if the caller lacks the appropriate PolicyKit authorization
- net.reactivated.Fprint.Error.ClaimDevice: if the device was not claimed
- net.reactivated.Fprint.Error.AlreadyInUse: if the device was already being used
- net.reactivated.Fprint.Error.NoEnrolledPrints: if there are no enrolled prints for the chosen user
- net.reactivated.Fprint.Error.Internal: if there was an internal error

## VerifyStop ()

### Description
Stop an on-going fingerprint verification started with Device.VerifyStart.

### Errors
- net.reactivated.Fprint.Error.PermissionDenied: if the caller lacks the appropriate PolicyKit authorization
- net.reactivated.Fprint.Error.ClaimDevice: if the device was not claimed
- net.reactivated.Fprint.Error.NoActionInProgress: if there was no ongoing verification
- net.reactivated.Fprint.Error.Internal: if there was an internal error
```

--------------------------------

### Start Asynchronous Print Listing - fp_device_list_prints

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Initiates an asynchronous operation to retrieve a list of all fingerprints stored on the device. This functionality is relevant for devices with on-chip storage. The callback is invoked upon completion, and the list can be retrieved using `fp_device_list_prints_finish()`.

```c
void
fp_device_list_prints (_FpDevice *device_,
                       _GCancellable *cancellable_,
                       _GAsyncReadyCallback callback_,
                       _gpointer user_data_);
```

--------------------------------

### Get state machine device

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Sequential-state-machine.html

Retrieves the FpDevice associated with the state machine.

```c
FpDevice	*
fpi_ssm_get_device (_FpiSsm *machine_);
```

--------------------------------

### Verify Fingerprint (Asynchronous)

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Starts an asynchronous operation to verify a fingerprint against an enrolled print. Match results are handled by a callback.

```APIDOC
## fp_device_verify

### Description
Start an asynchronous operation to verify a print. The callback will be called once the operation has finished. Retrieve the result with `fp_device_verify_finish()`.

### Method
POST (conceptual, as this is an operation initiation)

### Endpoint
N/A (Function call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **enrolled_print** (_FpPrint_) - A FpPrint to verify.
- **cancellable** (_GCancellable_) - A GCancellable, or `NULL`.
- **match_cb** (_FpMatchCb_) - Match reporting callback.
- **match_data** (_gpointer_) - User data for `match_cb`.
- **match_destroy** (_GDestroyNotify_) - Destroy notify for `match_data`.
- **callback** (_GAsyncReadyCallback_) - The function to call on completion.
- **user_data** (_gpointer_) - The data to pass to `callback`.

### Request Example
```c
fp_device_verify(device, enrolled_print, cancellable, match_cb, match_data, match_destroy, callback, user_data);
```

### Response
#### Success Response (void)
Operation completes asynchronously. Result is obtained via `fp_device_verify_finish()`.

#### Response Example
N/A (Asynchronous operation)
```

--------------------------------

### Get Udev Data for FpDevice

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpDevice.html

Fetches subtype-specific hardware resources for an FpDevice. This function is intended for devices of type FP_DEVICE_TYPE_UDEV. For SPIDEV/HIDRAW, it returns a device path.

```c
gpointer
fpi_device_get_udev_data (_FpDevice *device_,
                          _FpiDeviceUdevSubtypeFlags subtype_);
```

--------------------------------

### Start Asynchronous Storage Clearing - fp_device_clear_storage

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Begins an asynchronous operation to erase all stored fingerprints from the device. This operation is intended for devices with on-chip storage but is safe to call on any device. The callback is triggered upon completion, and results can be accessed via `fp_device_clear_storage_finish()`.

```c
void
fp_device_clear_storage (_FpDevice *device_,
                         _GCancellable *cancellable_,
                         _GAsyncReadyCallback callback_,
                         _gpointer user_data_);
```

--------------------------------

### Create a new FpContext

Source: https://fprint.freedesktop.org/libfprint-dev/FpContext.html

Initializes a new instance of FpContext.

```c
FpContext	*
fp_context_new (_void_);
```

--------------------------------

### FpContext Initialization and Device Discovery

Source: https://fprint.freedesktop.org/libfprint-dev/FpContext.html

Methods for creating a context, enumerating hardware, and retrieving the list of available fingerprint devices.

```APIDOC
## fp_context_new

### Description
Creates a new FpContext instance to begin fingerprint device discovery.

### Returns
- **FpContext** - A newly created FpContext instance.

---

## fp_context_enumerate

### Description
Enumerates all available fingerprint devices. This should be called exactly once at startup and iterates the mainloop until completion.

### Parameters
- **context** (FpContext) - Required - The FpContext instance.

---

## fp_context_get_devices

### Description
Retrieves the list of all discovered fingerprint devices.

### Parameters
- **context** (FpContext) - Required - The FpContext instance.

### Returns
- **GPtrArray** - A new GPtrArray of FpDevice objects.
```

--------------------------------

### Enroll Fingerprint

Source: https://fprint.freedesktop.org/fprintd-dev/Device.html

Starts and stops the fingerprint enrollment process.

```APIDOC
## EnrollStart ()

### Description
Start enrollment for the selected finger. You need to have claimed the device using Device.Claim before calling this method.

### Parameters
#### Request Body
- finger_name (string) - Required - A string representing the finger to enroll.

### Errors
- net.reactivated.Fprint.Error.PermissionDenied: if the caller lacks the appropriate PolicyKit authorization
- net.reactivated.Fprint.Error.ClaimDevice: if the device was not claimed
- net.reactivated.Fprint.Error.AlreadyInUse: if the device was already being used
- net.reactivated.Fprint.Error.InvalidFingername: if the finger name passed is invalid
- net.reactivated.Fprint.Error.Internal: if there was an internal error

## EnrollStop ()

### Description
Stop an on-going fingerprint enrollment started with Device.EnrollStart.

### Errors
- net.reactivated.Fprint.Error.PermissionDenied: if the caller lacks the appropriate PolicyKit authorization
- net.reactivated.Fprint.Error.ClaimDevice: if the device was not claimed
- net.reactivated.Fprint.Error.NoActionInProgress: if there was no ongoing verification
- net.reactivated.Fprint.Error.Internal: if there was an internal error
```

--------------------------------

### Get state machine error

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Sequential-state-machine.html

Retrieves the error code set by fpi_ssm_mark_failed.

```c
GError	*
fpi_ssm_get_error (_FpiSsm *machine_);
```

--------------------------------

### fpi_ssm_new_full

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Sequential-state-machine.html

Allocates a new state machine with full configuration options including cleanup states.

```APIDOC
## fpi_ssm_new_full

### Description
Allocates a new state machine with a specific number of states and cleanup state configuration.

### Parameters
- **dev** (FpDevice) - Required - The fingerprint device instance.
- **handler** (FpiSsmHandlerCallback) - Required - The callback function called after each state transition.
- **nr_states** (int) - Required - The total number of states.
- **start_cleanup** (int) - Required - The index of the first cleanup state.
- **machine_name** (const char) - Required - A name for the machine for debugging purposes.

### Returns
- **FpiSsm*** - A new state machine instance.
```

--------------------------------

### Get FpImage Height

Source: https://fprint.freedesktop.org/libfprint-dev/FpImage.html

Retrieves the pixel height of an FpImage. The height is a guint value.

```c
guint
fp_image_get_height (_FpImage *self_);
```

--------------------------------

### Get FpImage Width

Source: https://fprint.freedesktop.org/libfprint-dev/FpImage.html

Retrieves the pixel width of an FpImage. The width is a guint value.

```c
guint
fp_image_get_width (_FpImage *self_);
```

--------------------------------

### Create New FpImage

Source: https://fprint.freedesktop.org/libfprint-dev/FpImage.html

Creates a new FpImage object with the specified width and height. Use this to initialize an image structure.

```c
FpImage *
fp_image_new (_gint width_,
              _gint height_);
```

--------------------------------

### Get state machine data

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Sequential-state-machine.html

Retrieves the custom data pointer associated with the state machine.

```c
gpointer
fpi_ssm_get_data (_FpiSsm *machine_);
```

--------------------------------

### Enumerate fingerprint devices

Source: https://fprint.freedesktop.org/libfprint-dev/FpContext.html

Discovers all available devices. Must be called exactly once at startup and iterates the mainloop.

```c
void
fp_context_enumerate (_FpContext *context_);
```

--------------------------------

### Get GUsbDevice for FpDevice

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpDevice.html

Retrieves the GUsbDevice associated with an FpDevice. This function is only valid for devices of type FP_DEVICE_TYPE_USB.

```c
GUsbDevice *
fpi_device_get_usb_device (_FpDevice *device_);
```

--------------------------------

### fpi_device_class_auto_initialize_features

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpDevice.html

Initializes device class features.

```APIDOC
## fpi_device_class_auto_initialize_features

### Description
Initializes the FpDeviceClass features flags checking what device vfuncs are implemented. Drivers should call this at the end of the class initialization.

### Parameters
- **device_class** (FpDeviceClass) - Required - The FpDeviceClass to initialize
```

--------------------------------

### fpi_device_open_complete

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpDevice.html

Finish an ongoing open operation.

```APIDOC
## fpi_device_open_complete

### Description
Finish an ongoing open operation. If error is NULL success is assumed.

### Parameters
#### Path Parameters
- **device** (FpDevice) - Required - The FpDevice
- **error** (GError) - Optional - The GError or NULL on success.
```

--------------------------------

### Define FP_TYPE_IMAGE_DEVICE

Source: https://fprint.freedesktop.org/libfprint-dev/FpImageDevice.html

Defines the type identifier for FpImageDevice. This macro is used to get the GType of the image device.

```c
#define FP_TYPE_IMAGE_DEVICE (fp_image_device_get_type ())
```

--------------------------------

### GetDevices Method

Source: https://fprint.freedesktop.org/fprintd-dev/Manager.html

Retrieves an array of object paths for all fingerprint readers attached to the system.

```dbus
GetDevices (out 'ao' devices)
```

--------------------------------

### Prepare Bulk USB Transfer with Custom Buffer

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-USB-transfer-helpers.html

Prepares a bulk USB transfer using a provided buffer. Allows sending custom data or receiving into a pre-defined buffer.

```c
void
fpi_usb_transfer_fill_bulk_full (_FpiUsbTransfer *transfer_,
                                 _guint8 endpoint_,
                                 _guint8 *buffer_,
                                 _gsize length_,
                                 _GDestroyNotify free_func_);
```

--------------------------------

### Identify Fingerprint (Asynchronous)

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Starts an asynchronous operation to identify fingerprints from a list against the device. Match results are handled by a callback.

```APIDOC
## fp_device_identify

### Description
Start an asynchronous operation to identify prints. The callback will be called once the operation has finished. Retrieve the result with `fp_device_identify_finish()`.

### Method
POST (conceptual, as this is an operation initiation)

### Endpoint
N/A (Function call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **prints** (_GPtrArray*) - A GPtrArray containing FpPrint objects to identify.
- **cancellable** (_GCancellable_) - A GCancellable, or `NULL`.
- **match_cb** (_FpMatchCb_) - Match reporting callback.
- **match_data** (_gpointer_) - User data for `match_cb`.
- **match_destroy** (_GDestroyNotify_) - Destroy notify for `match_data`.
- **callback** (_GAsyncReadyCallback_) - The function to call on completion.
- **user_data** (_gpointer_) - The data to pass to `callback`.

### Request Example
```c
fp_device_identify(device, prints, cancellable, match_cb, match_data, match_destroy, callback, user_data);
```

### Response
#### Success Response (void)
Operation completes asynchronously. Result is obtained via `fp_device_identify_finish()`.

#### Response Example
N/A (Asynchronous operation)
```

--------------------------------

### Manager Interface Methods

Source: https://fprint.freedesktop.org/fprintd-dev/Manager.html

Lists the available methods for the Manager interface.

```dbus
GetDevices       (out 'ao' devices)
GetDefaultDevice (out 'o'  device)
```

--------------------------------

### Leave Critical Section

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpDevice.html

Leaves a critical section started by `fpi_device_critical_enter()`. Once all critical sections are left, libfprint flushes queued requests.

```c
void
fpi_device_critical_leave (_FpDevice *device_);
```

--------------------------------

### Report Activation Completion - C

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpImageDevice.html

Reports the completion of the device activation process. Pass NULL for error on success.

```c
void
fpi_image_device_activate_complete (_FpImageDevice *self_,
                                    _GError *error_);
```

--------------------------------

### Allocate New State Machine with fpi_ssm_new()

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Sequential-state-machine.html

Macro to allocate a new state machine with a specified number of states and a handler callback. It simplifies the creation process by calling fpi_ssm_new_full().

```c
#define             fpi_ssm_new(dev, handler, nr_states)
```

--------------------------------

### Get Minutia Coordinates

Source: https://fprint.freedesktop.org/libfprint-dev/FpImage.html

Returns the X and Y coordinates of a detected minutia. This function is primarily for debugging and its API is not considered stable for production use.

```c
void
fp_minutia_get_coords (_FpMinutia *min_,
                       _gint *x_,
                       _gint *y_);
```

--------------------------------

### FpDevice Parameters and Return Values

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Details the parameters and return values for a function operating on an FpDevice.

```APIDOC
## FpDevice Operation

### Description
This section describes the parameters and return values for a generic operation on an FpDevice.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters Table
| Parameter | Type | Description | Notes |
|---|---|---|---|
| device | FpDevice | The fingerprint device object. | |
| cancellable | GCancellable | A GCancellable object, or NULL. Currently not used. | [nullable] |
| error | Return location for errors, or NULL to ignore | | |

### Returns
`FALSE` on error, `TRUE` otherwise.

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Get FpImage Resolution (PPMm)

Source: https://fprint.freedesktop.org/libfprint-dev/FpImage.html

Retrieves the resolution of the image in points per millimeter. This is typically fixed at approximately 19.685 p/mm for most drivers.

```c
gdouble
fp_image_get_ppmm (_FpImage *self_);
```

--------------------------------

### Get Virtual Environment Variable for FpDevice

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpDevice.html

Retrieves the environment variable that triggered the creation of a virtual FpDevice. This is applicable only to devices of type FP_DEVICE_TYPE_VIRTUAL.

```c
const gchar *
fpi_device_get_virtual_env (_FpDevice *device_);
```

--------------------------------

### fpi_device_resume_complete

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpDevice.html

Completes a resume request for an FpDevice.

```APIDOC
## fpi_device_resume_complete

### Description
Finish a resume request.

### Parameters
- **device** (FpDevice) - Required - The FpDevice
- **error** (GError) - Required - The GError or NULL on success.
```

--------------------------------

### fpi_ssm_new

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Sequential-state-machine.html

Allocates a new state machine with a specified number of states and a handler callback.

```APIDOC
## fpi_ssm_new

### Description
Allocates a new state machine with a defined number of states. This is a macro that calls fpi_ssm_new_full.

### Parameters
- **dev** (FpDevice) - Required - The fingerprint device instance.
- **handler** (FpiSsmHandlerCallback) - Required - The callback function called after each state transition.
- **nr_states** (int) - Required - The total number of states.

### Returns
- **FpiSsm*** - A new state machine instance.
```

--------------------------------

### Get Binarized Image Data

Source: https://fprint.freedesktop.org/libfprint-dev/FpImage.html

Retrieves the binarized data for an image. This data must not be modified or freed. Minutiae detection should be performed prior to calling this function.

```c
const guchar *
fp_image_get_binarized (_FpImage *self_,
                        _gsize *len_);
```

--------------------------------

### Get Detected Minutiae

Source: https://fprint.freedesktop.org/libfprint-dev/FpImage.html

Retrieves the detected minutiae for an image. The returned GPtrArray must not be modified or freed. Minutiae must be detected first using `fp_image_detect_minutiae()`.

```c
GPtrArray *
fp_image_get_minutiae (_FpImage *self_);
```

--------------------------------

### Prepare Control USB Transfer

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-USB-transfer-helpers.html

Prepares a control USB transfer. A buffer is created internally; it can be initialized after calling this function.

```c
void
fpi_usb_transfer_fill_control (_FpiUsbTransfer *transfer_,
                               _GUsbDeviceDirection direction_,
                               _GUsbDeviceRequestType request_type_,
                               _GUsbDeviceRecipient recipient_,
                               _guint8 request_,
                               _guint16 value_,
                               _guint16 idx_,
                               _gsize length_);
```

--------------------------------

### Get Current FpDevice Action

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpDevice.html

Returns the current ongoing action of the FpDevice or FPI_DEVICE_ACTION_NONE if no operation is active. Useful for differentiating actions like verify and identify.

```c
FpiDeviceAction
fpi_device_get_current_action (_FpDevice *device_);
```

--------------------------------

### Enums, Macros, and Types

Source: https://fprint.freedesktop.org/libfprint-dev/api-index.html

Details related enums, macros, and type definitions.

```APIDOC
## Enums, Macros, and Types

### Description
Related enumerations, macros, and type definitions.

### Enums
- **FpScanType**: Enum in FpDevice for scan types.

### Macros
- **FP_TYPE_CONTEXT**: Macro in FpContext.
- **FP_TYPE_DEVICE**: Macro in FpDevice.
- **FP_TYPE_IMAGE**: Macro in FpImage.
- **FP_TYPE_IMAGE_DEVICE**: Macro in FpImageDevice.
- **FP_TYPE_PRINT**: Macro in FpPrint.
- **fp_warn**: Macro in Logging for warnings.

### User Defined Types
- **FpTimeoutFunc**: User function type in Internal FpDevice.
```

--------------------------------

### Create New FpiUsbTransfer

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-USB-transfer-helpers.html

Creates a new FpiUsbTransfer for a given FpDevice. Use this to initiate a USB transfer.

```c
FpiUsbTransfer *
fpi_usb_transfer_new (_FpDevice *device_);
```

--------------------------------

### Prepare Bulk USB Transfer

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-USB-transfer-helpers.html

Prepares a bulk USB transfer. This function allocates a buffer for the transfer. Use `fpi_usb_transfer_fill_bulk_full()` for sending pre-allocated buffers.

```c
void
fpi_usb_transfer_fill_bulk (_FpiUsbTransfer *transfer_,
                            _guint8 endpoint_,
                            _gsize length_);
```

--------------------------------

### Get Greyscale Image Data

Source: https://fprint.freedesktop.org/libfprint-dev/FpImage.html

Retrieves the raw greyscale data for an image. The returned data must not be modified or freed. The length of the data is returned via the 'len' parameter.

```c
const guchar *
fp_image_get_data (_FpImage *self_,
                   _gsize *len_);
```

--------------------------------

### Finish device open operation

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Completes the asynchronous device opening process.

```c
gboolean
fp_device_open_finish (_FpDevice *device_,
                       _GAsyncResult *result_,
                       _GError **error_);
```

--------------------------------

### Enter Critical Section

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpDevice.html

Enters a critical section in the driver code, preventing external calls from libfprint. Drivers can assume single-threaded execution within this section. This is useful for preventing cancellations during device setup.

```c
void
fpi_device_critical_enter (_FpDevice *device_);
```

--------------------------------

### Object Hierarchy for FpContext

Source: https://fprint.freedesktop.org/libfprint-dev/FpContext.html

Shows the inheritance structure of the FpContext class.

```text
    GObject
    ╰── FpContext
```

--------------------------------

### Initiate Minutiae Detection

Source: https://fprint.freedesktop.org/libfprint-dev/FpImage.html

Asynchronously detects the minutiae found in an image. Requires a cancellable object, a callback function, and user data.

```c
void
fp_image_detect_minutiae (_FpImage *self_,
                          _GCancellable *cancellable_,
                          _GAsyncReadyCallback callback_,
                          _gpointer user_data_);
```

--------------------------------

### Assemble lines into an image

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Image-frame-assembly.html

Assembles individual lines into a single image and rescales to account for variable swiping speed.

```c
FpImage *
fpi_assemble_lines (struct fpi_line_asmbl_ctx *ctx,
                    GSList *lines,
                    size_t num_lines);
```

--------------------------------

### Start Asynchronous Print Deletion - fp_device_delete_print

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Begins an asynchronous operation to remove a specific fingerprint from the device's storage. This is primarily for devices that store prints on-chip but is safe to call on all devices. The callback is executed upon completion, and results can be obtained using `fp_device_delete_print_finish()`.

```c
void
fp_device_delete_print (_FpDevice *device_,
                        _FpPrint *enrolled_print_,
                        _GCancellable *cancellable_,
                        _GAsyncReadyCallback callback_,
                        _gpointer user_data_);
```

--------------------------------

### Create FpiSpiTransfer

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-SPI-transfer-helpers.html

Initializes a new FpiSpiTransfer object. Requires the FpDevice and the spidev file descriptor. This function is used to set up SPI transfer structures.

```c
FpiSpiTransfer *
fpi_spi_transfer_new (_FpDevice *device_,
                      _int spidev_fd_);
```

--------------------------------

### Report Open Operation Completion - C

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpImageDevice.html

Reports the completion of an open operation on the fingerprint device. Pass NULL for error on success.

```c
void
fpi_image_device_open_complete (_FpImageDevice *self_,
                                _GError *error_);
```

--------------------------------

### Suspend Fingerprint Device Synchronously

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Prepares the fingerprint device for suspension synchronously. This function requires a `_FpDevice` and an optional `_GCancellable`. It returns `TRUE` on success and `FALSE` on error.

```c
gboolean
fp_device_suspend_sync (_FpDevice *device_,
                        _GCancellable *cancellable_,
                        _GError **error_);
```

--------------------------------

### fpi_usb_transfer_fill_bulk

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-USB-transfer-helpers.html

Prepares a bulk transfer by allocating a buffer automatically.

```APIDOC
## fpi_usb_transfer_fill_bulk

### Description
Prepare a bulk transfer. A buffer will be created for you.

### Parameters
- **transfer** (FpiUsbTransfer) - Required - The FpiUsbTransfer
- **endpoint** (guint8) - Required - The endpoint to send the transfer to
- **length** (gsize) - Required - The buffer size to allocate
```

--------------------------------

### fpi_ssm_usb_transfer_with_weak_pointer_cb

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Sequential-state-machine.html

Callback handler for USB transfers with weak pointer support.

```APIDOC
## fpi_ssm_usb_transfer_with_weak_pointer_cb()

### Description
Can be used as a FpiUsbTransfer callback handler to automatically advance or fail a statemachine on transfer completion. Passing a gpointer* as _`weak_ptr`_ permits to nullify it once we're done with the transfer. Make sure to set the FpiSsm on the transfer.

### Method
N/A (Function)

### Endpoint
N/A (Function)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
N/A (void function)

#### Response Example
N/A
```

--------------------------------

### GetDevices

Source: https://fprint.freedesktop.org/fprintd-dev/Manager.html

Enumerates all fingerprint readers attached to the system.

```APIDOC
## GetDevices

### Description
Enumerate all the fingerprint readers attached to the system. If there are no devices available, an empty array is returned.

### Method
DBus Method Call

### Response
- **devices** (ao) - An array of object paths for devices.
```

--------------------------------

### Finish print enrollment

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Completes the asynchronous enrollment operation. Check for FP_DEVICE_RETRY errors to handle interaction issues.

```c
FpPrint *
fp_device_enroll_finish (_FpDevice *device_,
                         _GAsyncResult *result_,
                         _GError **error_);
```

--------------------------------

### Verify Fingerprint Synchronously

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Use this function to verify a given fingerprint against enrolled prints synchronously. It requires a `_FpDevice`, an enrolled `_FpPrint`, and optionally a `_GCancellable` callback, a match callback, and user data. Output parameters include whether a match was found and the scanned print.

```c
gboolean
fp_device_verify_sync (_FpDevice *device_,
                       _FpPrint *enrolled_print_,
                       _GCancellable *cancellable_,
                       _FpMatchCb match_cb_,
                       _gpointer match_data_,
                       _gboolean *match_,
                       _FpPrint **print_,
                       _GError **error_);
```

--------------------------------

### List Enrolled Prints Synchronously

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Retrieves a list of all enrolled fingerprints from the device synchronously. This function takes a `_FpDevice` and an optional `_GCancellable`. It returns a `GPtrArray` of `_FpPrint`s or `NULL` if an error occurs.

```c
GPtrArray *
fp_device_list_prints_sync (_FpDevice *device_,
                            _GCancellable *cancellable_,
                            _GError **error_);
```

--------------------------------

### FpImage Structure and Properties

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpImage.html

Details about the FpImage structure, including its properties like width and height.

```APIDOC
## FpImage Structure

### Description
Structure holding an image. The public fields are only public for internal use by the drivers.

### Fields
- **width** (guint) - Read / Write / Construct Only - The width of the image. Allowed values: <= 65535. Default value: 0.
- **height** (guint) - Read / Write / Construct Only - The height of the image. Allowed values: <= 65535. Default value: 0.
- **ppmm** (gdouble) - Pixels per millimeter.
- **flags** (FpiImageFlags) - Flags used in an FpImage structure to describe the contained image.
```

--------------------------------

### Display Object Hierarchy

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpImage.html

Shows the inheritance structure of the FpImage object.

```text
    GObject
    ╰── FpImage
```

--------------------------------

### fpi_device_get_enroll_data

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpDevice.html

Retrieves data for enrollment.

```APIDOC
## fpi_device_get_enroll_data

### Description
Get data for enrollment.

### Parameters
#### Path Parameters
- **device** (FpDevice *) - Required - The FpDevice
- **print** (FpPrint **) - Required - The user provided template print
```

--------------------------------

### FpContextClass structure

Source: https://fprint.freedesktop.org/libfprint-dev/FpContext.html

Defines the class structure for FpContext, including signal handlers for device changes.

```c
struct FpContextClass {
  GObjectClass parent_class;

  void         (*device_added)            (FpContext *context,
                                           FpDevice  *device);
  void         (*device_removed)          (FpContext *context,
                                           FpDevice  *device);
};
```

--------------------------------

### Assemble frames into an image

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Image-frame-assembly.html

Assembles individual frames into a single image, requiring pre-populated delta_x and delta_y values.

```c
FpImage *
fpi_assemble_frames (struct fpi_frame_asmbl_ctx *ctx,
                     GSList *stripes);
```

--------------------------------

### Claim and Release Device Methods

Source: https://fprint.freedesktop.org/fprintd-dev/Device.html

Claim a device for exclusive use by a username, and Release it when done. PolicyKit authorization is required for claiming other users' devices.

```dbus
Claim                  (in  's'  username)
Release                ()
```

--------------------------------

### fpi_device_enroll_complete

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpDevice.html

Finish an ongoing enroll operation.

```APIDOC
## fpi_device_enroll_complete

### Description
Finish an ongoing enroll operation. The FpPrint can be stored by the caller for later verification.

### Parameters
#### Path Parameters
- **device** (FpDevice) - Required - The FpDevice
- **print** (FpPrint) - Optional - The FpPrint or NULL on failure
- **error** (GError) - Optional - The GError or NULL on success.
```

--------------------------------

### Define FpImageDeviceClass structure

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpImageDevice.html

The structure defining the main entry points for image device drivers. This API is internal and not stable.

```c
typedef struct {
  FpDeviceClass parent_class;

  gint          bz3_threshold;
  gint          img_width;
  gint          img_height;

  void          (*img_open)     (FpImageDevice *dev);
  void          (*img_close)    (FpImageDevice *dev);
  void          (*activate)     (FpImageDevice *dev);
  void          (*change_state) (FpImageDevice      *dev,
                                 FpiImageDeviceState state);
  void          (*deactivate)   (FpImageDevice *dev);
} FpImageDeviceClass;
```

--------------------------------

### fpi_image_device_open_complete

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpImageDevice.html

Reports the completion of an open operation for the device.

```APIDOC
## fpi_image_device_open_complete

### Description
Reports completion of open operation.

### Parameters
- **self** (FpImageDevice) - Required - A FpImageDevice imaging fingerprint device
- **error** (GError) - Required - The GError or NULL on success
```

--------------------------------

### FpPrint Creation and Management

Source: https://fprint.freedesktop.org/libfprint-dev/FpPrint.html

Functions for creating, retrieving, and setting properties of an FpPrint object.

```APIDOC
## FpPrint Object

FpPrint — Fingerprint handling

### Description
Interaction with prints and their storage.

## Functions

### fp_print_new (Create FpPrint)

```c
FpPrint *fp_print_new (_FpDevice *device_); 
```

Create a new FpPrint. This is only useful to prepare an enrollment of a new print using `fp_device_enroll()`. For this you should first create a new print, fill in the relevant metadata, and then start enrollment.

#### Parameters
- **device** (_FpDevice *) - A FpDevice

#### Returns
- A newly created FpPrint. [transfer floating]

### fp_print_get_driver

```c
const gchar *fp_print_get_driver (_FpPrint *print_);
```

Returns the driver that the print was created for.

#### Parameters
- **print** (_FpPrint *) - A FpPrint

#### Returns
- The driver. [transfer none]

### fp_print_get_device_id

```c
const gchar *fp_print_get_device_id (_FpPrint *print_);
```

Returns the device ID that the print was created for.

#### Parameters
- **print** (_FpPrint *) - A FpPrint

#### Returns
- The device ID. [transfer none]

### fp_print_get_device_stored

```c
gboolean fp_print_get_device_stored (_FpPrint *print_);
```

Whether the print is actually stored on the device and this is just a handle to use that references the device stored data.

#### Parameters
- **print** (_FpPrint *) - A FpPrint

#### Returns
- Whether the print is stored on the device

### fp_print_get_image

```c
FpImage *fp_print_get_image (_FpPrint *print_);
```

Returns the image that the print was created from, or `NULL`

#### Parameters
- **print** (_FpPrint *) - A FpPrint

#### Returns
- The FpImage. [transfer none][nullable]

### fp_print_get_finger

```c
FpFinger fp_print_get_finger (_FpPrint *print_);
```

Returns the finger that the print was created for.

#### Parameters
- **print** (_FpPrint *) - A FpPrint

#### Returns
- The FpFinger

### fp_print_get_username

```c
const gchar *fp_print_get_username (_FpPrint *print_);
```

Returns the user defined username for the print.

#### Parameters
- **print** (_FpPrint *) - A FpPrint

#### Returns
- The username. [transfer none][nullable]

### fp_print_get_description

```c
const gchar *fp_print_get_description (_FpPrint *print_);
```

Returns the user defined description for the print.

#### Parameters
- **print** (_FpPrint *) - A FpPrint

#### Returns
- The description. [transfer none][nullable]

### fp_print_get_enroll_date

```c
const GDate *fp_print_get_enroll_date (_FpPrint *print_);
```

Returns the user defined enroll date for the print.

#### Parameters
- **print** (_FpPrint *) - A FpPrint

#### Returns
- The GDate. [transfer none][nullable]

### fp_print_set_finger

```c
void fp_print_set_finger (_FpPrint *print_, _FpFinger finger_);
```

Set the finger that the print is for.

#### Parameters
- **print** (_FpPrint *) - A FpPrint
- **finger** (_FpFinger) - The FpFinger

### fp_print_set_username

```c
void fp_print_set_username (_FpPrint *print_, _const gchar *username_);
```

Set the username for the print.

#### Parameters
- **print** (_FpPrint *) - A FpPrint
- **username** (_const gchar *) - The new username. [transfer none]

### fp_print_set_description

```c
void fp_print_set_description (_FpPrint *print_, _const gchar *description_);
```

Set the description for the print.

#### Parameters
- **print** (_FpPrint *) - A FpPrint
- **description** (_const gchar *) - The new description. [transfer none]

### fp_print_set_enroll_date

```c
void fp_print_set_enroll_date (_FpPrint *print_, _const GDate *enroll_date_);
```

Set the enroll date for the print.

#### Parameters
- **print** (_FpPrint *) - A FpPrint
- **enroll_date** (_const GDate *) - The new enroll date. [transfer none]

### fp_print_compatible

```c
gboolean fp_print_compatible (_FpPrint *print_, _FpPrint *other_);
```

Check if two prints are compatible.

#### Parameters
- **print** (_FpPrint *) - A FpPrint
- **other** (_FpPrint *) - Another FpPrint

#### Returns
- `TRUE` if compatible, `FALSE` otherwise.

### fp_print_equal

```c
gboolean fp_print_equal (_FpPrint *print_, _FpPrint *other_);
```

Check if two prints are equal.

#### Parameters
- **print** (_FpPrint *) - A FpPrint
- **other** (_FpPrint *) - Another FpPrint

#### Returns
- `TRUE` if equal, `FALSE` otherwise.

### fp_print_serialize

```c
gboolean fp_print_serialize (_FpPrint *print_, _GVariant **data_);
```

Serialize the print data into a GVariant.

#### Parameters
- **print** (_FpPrint *) - A FpPrint
- **data** (_GVariant **) - Pointer to store the serialized data.

#### Returns
- `TRUE` on success, `FALSE` on failure.

### fp_print_deserialize

```c
FpPrint *fp_print_deserialize (_GVariant *data_);
```

Deserialize print data from a GVariant.

#### Parameters
- **data** (_GVariant *) - The GVariant containing serialized print data.

#### Returns
- A new FpPrint object on success, or `NULL` on failure. [transfer full]

```

--------------------------------

### Open Fingerprint Device (Asynchronous)

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Initiates an asynchronous operation to open the fingerprint device. The result is handled by a callback function.

```APIDOC
## fp_device_open

### Description
Start an asynchronous operation to open the device. The callback will be called once the operation has finished. Retrieve the result with `fp_device_open_finish()`.

### Method
POST (conceptual, as this is an operation initiation)

### Endpoint
N/A (Function call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
fp_device_open(device, cancellable, callback, user_data);
```

### Response
#### Success Response (void)
Operation completes asynchronously. Result is obtained via `fp_device_open_finish()`.

#### Response Example
N/A (Asynchronous operation)
```

--------------------------------

### Prepare SPI Write Transfer (Custom Buffer)

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-SPI-transfer-helpers.html

Prepares the write portion of an SPI transfer using a provided buffer. Allows specifying a custom buffer and a destroy notify function for its cleanup.

```c
void
fpi_spi_transfer_write_full (_FpiSpiTransfer *transfer_,
                             _guint8 *buffer_,
                             _gsize length_,
                             _GDestroyNotify free_func_);
```

--------------------------------

### FpDevice Property Definitions

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Definitions for various properties available on the FpDevice object.

```c
  “device-id”                char *
```

```c
  “driver”                   char *
```

```c
  “finger-status”            FpFingerStatusFlags
```

```c
  “fpi-driver-data”          guint64
```

```c
  “fpi-environ”              char *
```

--------------------------------

### Retrieve discovered devices

Source: https://fprint.freedesktop.org/libfprint-dev/FpContext.html

Returns a list of all discovered devices as a GPtrArray.

```c
GPtrArray	*
fp_context_get_devices (_FpContext *context_);
```

--------------------------------

### Define FpDevice Type

Source: https://fprint.freedesktop.org/libfprint-dev/FpDevice.html

Macro to retrieve the GType for FpDevice.

```c
#define FP_TYPE_DEVICE (fp_device_get_type ())
```

--------------------------------

### FpImage Object Methods

Source: https://fprint.freedesktop.org/libfprint-dev/FpImage.html

Functions for creating, querying, and processing FpImage objects.

```APIDOC
## fp_image_new

### Description
Creates a new FpImage instance.

### Parameters
- **width** (gint) - Required - The width of the image.
- **height** (gint) - Required - The height of the image.

## fp_image_get_width

### Description
Gets the pixel width of an image.

### Parameters
- **self** (FpImage*) - Required - A FpImage instance.

### Response
- **Returns** (guint) - The width of the image.

## fp_image_get_height

### Description
Gets the pixel height of an image.

### Parameters
- **self** (FpImage*) - Required - A FpImage instance.

### Response
- **Returns** (guint) - The height of the image.

## fp_image_get_ppmm

### Description
Gets the resolution of the image in points per millimeter.

### Parameters
- **self** (FpImage*) - Required - A FpImage instance.

### Response
- **Returns** (gdouble) - The resolution of the image.

## fp_image_get_minutiae

### Description
Gets the minutiae for an image. Requires prior detection via fp_image_detect_minutiae.

### Parameters
- **self** (FpImage*) - Required - A FpImage instance.

### Response
- **Returns** (GPtrArray*) - The detected minutiae.

## fp_image_detect_minutiae

### Description
Asynchronously detects the minutiae found in an image.

### Parameters
- **self** (FpImage*) - Required - A FpImage instance.
- **cancellable** (GCancellable*) - Optional - A GCancellable object.
- **callback** (GAsyncReadyCallback) - Required - Function to call on completion.
- **user_data** (gpointer) - Optional - Data to pass to the callback.

## fp_image_detect_minutiae_finish

### Description
Finishes the asynchronous minutiae detection process.

### Parameters
- **self** (FpImage*) - Required - A FpImage instance.
- **result** (GAsyncResult*) - Required - The GAsyncResult from the operation.
- **error** (GError**) - Optional - Return location for errors.

### Response
- **Returns** (gboolean) - TRUE on success.

## fp_image_get_data

### Description
Gets the raw greyscale data for an image.

### Parameters
- **self** (FpImage*) - Required - A FpImage instance.
- **len** (gsize*) - Optional - Return location for length.

### Response
- **Returns** (const guchar*) - The image data.

## fp_image_get_binarized

### Description
Gets the binarized data for an image. Requires prior detection via fp_image_detect_minutiae.

### Parameters
- **self** (FpImage*) - Required - A FpImage instance.
- **len** (gsize*) - Optional - Return location for length.

### Response
- **Returns** (const guchar*) - The binarized image data.
```

--------------------------------

### fpi_device_verify_complete

Source: https://fprint.freedesktop.org/libfprint-dev/libfprint-2-Internal-FpDevice.html

Finish an ongoing verify operation.

```APIDOC
## fpi_device_verify_complete

### Description
Finish an ongoing verify operation. Note that error should only be set for actual errors.

### Parameters
#### Path Parameters
- **device** (FpDevice) - Required - The FpDevice
- **error** (GError) - Optional - A GError if result is FPI_MATCH_ERROR
```
Tokens:
Raw