rpms/libfprint
7
0
Fork 0
Code Issues Pull Requests Releases Activity
15f4118004
libfprint/SOURCES/0147-cleanup-Use-FPI-prefix-for-all-the-internal-enum-typ.patch
CentOS Sources 15f4118004 import libfprint-1.90.0-4.el8
2021-09-09 20:12:48 +00:00

1746 lines
67 KiB
Diff
Raw Blame History

From 44152f201b938100ea12a1eb049e6fcfafc7aea0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>
Date: Mon, 16 Dec 2019 22:45:00 +0100
Subject: [PATCH 147/181] cleanup: Use FPI prefix for all the internal enum
types
---
doc/libfprint-sections.txt | 6 +-
doc/libfprint-sections.txt-new-manual | 4 +-
libfprint/drivers/elan.c | 60 +++++++-------
libfprint/drivers/elan.h | 4 +-
libfprint/drivers/synaptics/synaptics.c | 4 +-
libfprint/drivers/uru4000.c | 24 +++---
libfprint/fp-device-private.h | 2 +-
libfprint/fp-device.c | 26 +++---
libfprint/fp-image-device-private.h | 16 ++--
libfprint/fp-image-device.c | 30 +++----
libfprint/fp-print-private.h | 2 +-
libfprint/fp-print.c | 28 +++----
libfprint/fpi-device.c | 66 +++++++--------
libfprint/fpi-device.h | 46 +++++------
libfprint/fpi-image-device.c | 104 ++++++++++++------------
libfprint/fpi-image-device.h | 24 +++---
libfprint/fpi-print.c | 24 +++---
libfprint/fpi-print.h | 20 ++---
tests/test-device-fake.c | 20 ++---
tests/test-fpi-device.c | 20 ++---
20 files changed, 264 insertions(+), 266 deletions(-)
diff --git a/doc/libfprint-sections.txt b/doc/libfprint-sections.txt
index 9e17f8e..30a4e9b 100644
--- a/doc/libfprint-sections.txt
+++ b/doc/libfprint-sections.txt
@@ -129,7 +129,7 @@ fpi_get_driver_types
<FILE>fpi-device</FILE>
FpDeviceClass
FpTimeoutFunc
-FpDeviceAction
+FpiDeviceAction
FpIdEntry
fpi_device_get_usb_device
fpi_device_get_virtual_env
@@ -173,7 +173,7 @@ fpi_image_resize
<SECTION>
<FILE>fpi-image-device</FILE>
<TITLE>FpImageDevice</TITLE>
-FpImageDeviceState
+FpiImageDeviceState
FpImageDeviceClass
fpi_image_device_session_error
fpi_image_device_open_complete
@@ -197,7 +197,7 @@ BUG
<SECTION>
<FILE>fpi-print</FILE>
-FpPrintType
+FpiPrintType
FpiMatchResult
fpi_print_add_print
fpi_print_set_type
diff --git a/doc/libfprint-sections.txt-new-manual b/doc/libfprint-sections.txt-new-manual
index 857425b..da850db 100644
--- a/doc/libfprint-sections.txt-new-manual
+++ b/doc/libfprint-sections.txt-new-manual
@@ -90,7 +90,7 @@ fp_image_get_width
<TITLE>Base class for image devices</TITLE>
FpImageDevice
FpImageDeviceClass
-FpImageDeviceState
+FpiImageDeviceState
</SECTION>
<SECTION>
@@ -114,5 +114,3 @@ FpUsbTransferCallback
FP_USB_ENDPOINT_IN
FP_USB_ENDPOINT_OUT
</SECTION>
-
-
diff --git a/libfprint/drivers/elan.c b/libfprint/drivers/elan.c
index 415aaef..233e4a8 100644
--- a/libfprint/drivers/elan.c
+++ b/libfprint/drivers/elan.c
@@ -73,18 +73,18 @@ struct _FpiDeviceElan
/* end commands */
/* state */
- gboolean deactivating;
- FpImageDeviceState dev_state;
- FpImageDeviceState dev_state_next;
- unsigned char *last_read;
- unsigned char calib_atts_left;
- unsigned char calib_status;
- unsigned short *background;
- unsigned char frame_width;
- unsigned char frame_height;
- unsigned char raw_frame_height;
- int num_frames;
- GSList *frames;
+ gboolean deactivating;
+ FpiImageDeviceState dev_state;
+ FpiImageDeviceState dev_state_next;
+ unsigned char *last_read;
+ unsigned char calib_atts_left;
+ unsigned char calib_status;
+ unsigned short *background;
+ unsigned char frame_width;
+ unsigned char frame_height;
+ unsigned char raw_frame_height;
+ int num_frames;
+ GSList *frames;
/* end state */
};
G_DECLARE_FINAL_TYPE (FpiDeviceElan, fpi_device_elan, FPI, DEVICE_ELAN,
@@ -481,7 +481,7 @@ stop_capture_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
/* The device is inactive at this point. */
- self->dev_state = FP_IMAGE_DEVICE_STATE_INACTIVE;
+ self->dev_state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
if (self->deactivating)
{
@@ -538,7 +538,7 @@ capture_run_state (FpiSsm *ssm, FpDevice *dev)
break;
case CAPTURE_READ_DATA:
- self->dev_state = FP_IMAGE_DEVICE_STATE_CAPTURE;
+ self->dev_state = FPI_IMAGE_DEVICE_STATE_CAPTURE;
/* 0x55 - finger present
* 0xff - device not calibrated (probably) */
@@ -773,7 +773,7 @@ calibrate_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
if (error)
{
- self->dev_state = FP_IMAGE_DEVICE_STATE_INACTIVE;
+ self->dev_state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
fpi_image_device_session_error (FP_IMAGE_DEVICE (dev), error);
}
else
@@ -951,7 +951,7 @@ elan_change_state (FpImageDevice *idev)
{
FpDevice *dev = FP_DEVICE (idev);
FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
- FpImageDeviceState next_state = self->dev_state_next;
+ FpiImageDeviceState next_state = self->dev_state_next;
if (self->dev_state == next_state)
{
@@ -965,18 +965,18 @@ elan_change_state (FpImageDevice *idev)
switch (next_state)
{
- case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
+ case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
/* activation completed or another enroll stage started */
- self->dev_state = FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON;
+ self->dev_state = FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON;
elan_calibrate (dev);
break;
- case FP_IMAGE_DEVICE_STATE_CAPTURE:
+ case FPI_IMAGE_DEVICE_STATE_CAPTURE:
/* not used */
break;
- case FP_IMAGE_DEVICE_STATE_INACTIVE:
- case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
+ case FPI_IMAGE_DEVICE_STATE_INACTIVE:
+ case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
elan_stop_capture (dev);
break;
}
@@ -991,7 +991,7 @@ elan_change_state_async (FpDevice *dev,
}
static void
-dev_change_state (FpImageDevice *dev, FpImageDeviceState state)
+dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)
{
FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
GSource *timeout;
@@ -999,17 +999,17 @@ dev_change_state (FpImageDevice *dev, FpImageDeviceState state)
G_DEBUG_HERE ();
/* Inactive and await finger off are equivalent for the elan driver. */
- if (state == FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
- state = FP_IMAGE_DEVICE_STATE_INACTIVE;
+ if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
+ state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
if (self->dev_state_next == state)
fp_dbg ("change to state %d already queued", state);
switch (state)
{
- case FP_IMAGE_DEVICE_STATE_INACTIVE:
- case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
- case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: {
+ case FPI_IMAGE_DEVICE_STATE_INACTIVE:
+ case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
+ case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: {
char *name;
/* schedule state change instead of calling it directly to allow all actions
@@ -1026,7 +1026,7 @@ dev_change_state (FpImageDevice *dev, FpImageDeviceState state)
break;
}
- case FP_IMAGE_DEVICE_STATE_CAPTURE:
+ case FPI_IMAGE_DEVICE_STATE_CAPTURE:
/* TODO MAYBE: split capture ssm into smaller ssms and use this state */
self->dev_state = state;
self->dev_state_next = state;
@@ -1044,7 +1044,7 @@ dev_deactivate (FpImageDevice *dev)
G_DEBUG_HERE ();
- if (self->dev_state == FP_IMAGE_DEVICE_STATE_INACTIVE)
+ if (self->dev_state == FPI_IMAGE_DEVICE_STATE_INACTIVE)
{
/* The device is inactive already, complete the operation immediately. */
fpi_image_device_deactivate_complete (dev, NULL);
@@ -1055,7 +1055,7 @@ dev_deactivate (FpImageDevice *dev)
* need to signal back deactivation) and then ensure we will change
* to the inactive state eventually. */
self->deactivating = TRUE;
- dev_change_state (dev, FP_IMAGE_DEVICE_STATE_INACTIVE);
+ dev_change_state (dev, FPI_IMAGE_DEVICE_STATE_INACTIVE);
}
}
diff --git a/libfprint/drivers/elan.h b/libfprint/drivers/elan.h
index 1fdd820..2b1c089 100644
--- a/libfprint/drivers/elan.h
+++ b/libfprint/drivers/elan.h
@@ -221,5 +221,5 @@ static void elan_cmd_read (FpiSsm *ssm,
static void elan_calibrate (FpDevice *dev);
static void elan_capture (FpDevice *dev);
-static void dev_change_state (FpImageDevice *dev,
- FpImageDeviceState state);
+static void dev_change_state (FpImageDevice *dev,
+ FpiImageDeviceState state);
diff --git a/libfprint/drivers/synaptics/synaptics.c b/libfprint/drivers/synaptics/synaptics.c
index 97d9d21..af4a2fd 100644
--- a/libfprint/drivers/synaptics/synaptics.c
+++ b/libfprint/drivers/synaptics/synaptics.c
@@ -517,7 +517,7 @@ list_msg_cb (FpiDeviceSynaptics *self,
get_enroll_templates_resp->templates[n].finger_id,
uid);
- fpi_print_set_type (print, FP_PRINT_RAW);
+ fpi_print_set_type (print, FPI_PRINT_RAW);
fpi_print_set_device_stored (print, TRUE);
g_object_set (print, "fp-data", data, NULL);
g_object_set (print, "description", get_enroll_templates_resp->templates[n].user_id, NULL);
@@ -856,7 +856,7 @@ enroll (FpDevice *device)
finger,
uid);
- fpi_print_set_type (print, FP_PRINT_RAW);
+ fpi_print_set_type (print, FPI_PRINT_RAW);
fpi_print_set_device_stored (print, TRUE);
g_object_set (print, "fp-data", data, NULL);
g_object_set (print, "description", user_id, NULL);
diff --git a/libfprint/drivers/uru4000.c b/libfprint/drivers/uru4000.c
index 5128a12..b86c6c8 100644
--- a/libfprint/drivers/uru4000.c
+++ b/libfprint/drivers/uru4000.c
@@ -122,7 +122,7 @@ struct _FpiDeviceUru4000
const struct uru4k_dev_profile *profile;
uint8_t interface;
- FpImageDeviceState activate_state;
+ FpiImageDeviceState activate_state;
unsigned char last_reg_rd[16];
unsigned char last_hwstat;
@@ -408,16 +408,16 @@ change_state_write_reg_cb (FpiUsbTransfer *transfer,
}
static void
-dev_change_state (FpImageDevice *dev, FpImageDeviceState state)
+dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)
{
FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev);
switch (state)
{
- case FP_IMAGE_DEVICE_STATE_INACTIVE:
- case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
- case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
- case FP_IMAGE_DEVICE_STATE_CAPTURE:
+ case FPI_IMAGE_DEVICE_STATE_INACTIVE:
+ case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
+ case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
+ case FPI_IMAGE_DEVICE_STATE_CAPTURE:
break;
default:
@@ -773,7 +773,7 @@ imaging_run_state (FpiSsm *ssm, FpDevice *_dev)
fpimg->flags |= FPI_IMAGE_V_FLIPPED | FPI_IMAGE_H_FLIPPED;
fpi_image_device_image_captured (dev, fpimg);
- if (self->activate_state == FP_IMAGE_DEVICE_STATE_CAPTURE)
+ if (self->activate_state == FPI_IMAGE_DEVICE_STATE_CAPTURE)
fpi_ssm_jump_to_state (ssm, IMAGING_CAPTURE);
else
fpi_ssm_mark_completed (ssm);
@@ -1176,7 +1176,7 @@ deactivate_write_reg_cb (FpiUsbTransfer *transfer, FpDevice *dev,
static void
dev_deactivate (FpImageDevice *dev)
{
- dev_change_state (dev, FP_IMAGE_DEVICE_STATE_INACTIVE);
+ dev_change_state (dev, FPI_IMAGE_DEVICE_STATE_INACTIVE);
}
static void
@@ -1187,7 +1187,7 @@ execute_state_change (FpImageDevice *dev)
switch (self->activate_state)
{
- case FP_IMAGE_DEVICE_STATE_INACTIVE:
+ case FPI_IMAGE_DEVICE_STATE_INACTIVE:
fp_dbg ("deactivating");
self->irq_cb = NULL;
self->irq_cb_data = NULL;
@@ -1195,7 +1195,7 @@ execute_state_change (FpImageDevice *dev)
deactivate_write_reg_cb, NULL);
break;
- case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
+ case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
fp_dbg ("wait finger on");
if (!IRQ_HANDLER_IS_RUNNING (self))
{
@@ -1209,7 +1209,7 @@ execute_state_change (FpImageDevice *dev)
change_state_write_reg_cb, NULL);
break;
- case FP_IMAGE_DEVICE_STATE_CAPTURE:
+ case FPI_IMAGE_DEVICE_STATE_CAPTURE:
fp_dbg ("starting capture");
self->irq_cb = NULL;
@@ -1229,7 +1229,7 @@ execute_state_change (FpImageDevice *dev)
change_state_write_reg_cb, NULL);
break;
- case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
+ case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
fp_dbg ("await finger off");
if (!IRQ_HANDLER_IS_RUNNING (self))
{
diff --git a/libfprint/fp-device-private.h b/libfprint/fp-device-private.h
index 65fb1cb..1a350fe 100644
--- a/libfprint/fp-device-private.h
+++ b/libfprint/fp-device-private.h
@@ -41,7 +41,7 @@ typedef struct
GSList *sources;
/* We always make sure that only one task is run at a time. */
- FpDeviceAction current_action;
+ FpiDeviceAction current_action;
GTask *current_task;
GAsyncReadyCallback current_user_cb;
gulong current_cancellable_id;
diff --git a/libfprint/fp-device.c b/libfprint/fp-device.c
index 3ac3a1c..8041a86 100644
--- a/libfprint/fp-device.c
+++ b/libfprint/fp-device.c
@@ -81,7 +81,7 @@ fp_device_cancel_in_idle_cb (gpointer user_data)
FpDevicePrivate *priv = fp_device_get_instance_private (self);
g_assert (cls->cancel);
- g_assert (priv->current_action != FP_DEVICE_ACTION_NONE);
+ g_assert (priv->current_action != FPI_DEVICE_ACTION_NONE);
g_debug ("Idle cancelling on ongoing operation!");
@@ -148,7 +148,7 @@ fp_device_finalize (GObject *object)
FpDevice *self = (FpDevice *) object;
FpDevicePrivate *priv = fp_device_get_instance_private (self);
- g_assert (priv->current_action == FP_DEVICE_ACTION_NONE);
+ g_assert (priv->current_action == FPI_DEVICE_ACTION_NONE);
g_assert (priv->current_task == NULL);
if (priv->is_open)
g_warning ("User destroyed open device! Not cleaning up properly!");
@@ -268,7 +268,7 @@ fp_device_async_initable_init_async (GAsyncInitable *initable,
return;
}
- priv->current_action = FP_DEVICE_ACTION_PROBE;
+ priv->current_action = FPI_DEVICE_ACTION_PROBE;
priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (self, cancellable);
@@ -584,7 +584,7 @@ fp_device_open (FpDevice *device,
return;
}
- priv->current_action = FP_DEVICE_ACTION_OPEN;
+ priv->current_action = FPI_DEVICE_ACTION_OPEN;
priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable);
@@ -648,7 +648,7 @@ fp_device_close (FpDevice *device,
return;
}
- priv->current_action = FP_DEVICE_ACTION_CLOSE;
+ priv->current_action = FPI_DEVICE_ACTION_CLOSE;
priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable);
@@ -709,7 +709,7 @@ fp_device_enroll (FpDevice *device,
g_autoptr(GTask) task = NULL;
FpDevicePrivate *priv = fp_device_get_instance_private (device);
FpEnrollData *data;
- FpPrintType print_type;
+ FpiPrintType print_type;
task = g_task_new (device, cancellable, callback, user_data);
if (g_task_return_error_if_cancelled (task))
@@ -738,7 +738,7 @@ fp_device_enroll (FpDevice *device,
}
g_object_get (template_print, "fp-type", &print_type, NULL);
- if (print_type != FP_PRINT_UNDEFINED)
+ if (print_type != FPI_PRINT_UNDEFINED)
{
g_warning ("Passed print template must be newly created and blank!");
g_task_return_error (task,
@@ -746,7 +746,7 @@ fp_device_enroll (FpDevice *device,
return;
}
- priv->current_action = FP_DEVICE_ACTION_ENROLL;
+ priv->current_action = FPI_DEVICE_ACTION_ENROLL;
priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable);
@@ -822,7 +822,7 @@ fp_device_verify (FpDevice *device,
return;
}
- priv->current_action = FP_DEVICE_ACTION_VERIFY;
+ priv->current_action = FPI_DEVICE_ACTION_VERIFY;
priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable);
@@ -915,7 +915,7 @@ fp_device_identify (FpDevice *device,
return;
}
- priv->current_action = FP_DEVICE_ACTION_IDENTIFY;
+ priv->current_action = FPI_DEVICE_ACTION_IDENTIFY;
priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable);
@@ -1008,7 +1008,7 @@ fp_device_capture (FpDevice *device,
return;
}
- priv->current_action = FP_DEVICE_ACTION_CAPTURE;
+ priv->current_action = FPI_DEVICE_ACTION_CAPTURE;
priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable);
@@ -1089,7 +1089,7 @@ fp_device_delete_print (FpDevice *device,
return;
}
- priv->current_action = FP_DEVICE_ACTION_DELETE;
+ priv->current_action = FPI_DEVICE_ACTION_DELETE;
priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable);
@@ -1159,7 +1159,7 @@ fp_device_list_prints (FpDevice *device,
return;
}
- priv->current_action = FP_DEVICE_ACTION_LIST;
+ priv->current_action = FPI_DEVICE_ACTION_LIST;
priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable);
diff --git a/libfprint/fp-image-device-private.h b/libfprint/fp-image-device-private.h
index 01454fd..07a0347 100644
--- a/libfprint/fp-image-device-private.h
+++ b/libfprint/fp-image-device-private.h
@@ -25,17 +25,17 @@
typedef struct
{
- FpImageDeviceState state;
- gboolean active;
- gboolean cancelling;
+ FpiImageDeviceState state;
+ gboolean active;
+ gboolean cancelling;
- gboolean enroll_await_on_pending;
- gint enroll_stage;
+ gboolean enroll_await_on_pending;
+ gint enroll_stage;
- guint pending_activation_timeout_id;
- gboolean pending_activation_timeout_waiting_finger_off;
+ guint pending_activation_timeout_id;
+ gboolean pending_activation_timeout_waiting_finger_off;
- gint bz3_threshold;
+ gint bz3_threshold;
} FpImageDevicePrivate;
diff --git a/libfprint/fp-image-device.c b/libfprint/fp-image-device.c
index 24d324d..9e6c375 100644
--- a/libfprint/fp-image-device.c
+++ b/libfprint/fp-image-device.c
@@ -106,7 +106,7 @@ fp_image_device_close (FpDevice *device)
if (!priv->active)
cls->img_close (self);
- else if (priv->state != FP_IMAGE_DEVICE_STATE_INACTIVE)
+ else if (priv->state != FPI_IMAGE_DEVICE_STATE_INACTIVE)
fpi_image_device_deactivate (self);
}
@@ -115,16 +115,16 @@ fp_image_device_cancel_action (FpDevice *device)
{
FpImageDevice *self = FP_IMAGE_DEVICE (device);
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
- FpDeviceAction action;
+ FpiDeviceAction action;
action = fpi_device_get_current_action (device);
/* We can only cancel capture operations, in that case, deactivate and return
* an error immediately. */
- if (action == FP_DEVICE_ACTION_ENROLL ||
- action == FP_DEVICE_ACTION_VERIFY ||
- action == FP_DEVICE_ACTION_IDENTIFY ||
- action == FP_DEVICE_ACTION_CAPTURE)
+ if (action == FPI_DEVICE_ACTION_ENROLL ||
+ action == FPI_DEVICE_ACTION_VERIFY ||
+ action == FPI_DEVICE_ACTION_IDENTIFY ||
+ action == FPI_DEVICE_ACTION_CAPTURE)
{
priv->cancelling = TRUE;
fpi_image_device_deactivate (self);
@@ -143,14 +143,14 @@ fp_image_device_start_capture_action (FpDevice *device)
{
FpImageDevice *self = FP_IMAGE_DEVICE (device);
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
- FpDeviceAction action;
+ FpiDeviceAction action;
/* There is just one action that we cannot support out
* of the box, which is a capture without first waiting
* for a finger to be on the device.
*/
action = fpi_device_get_current_action (device);
- if (action == FP_DEVICE_ACTION_CAPTURE)
+ if (action == FPI_DEVICE_ACTION_CAPTURE)
{
gboolean wait_for_finger;
@@ -162,12 +162,12 @@ fp_image_device_start_capture_action (FpDevice *device)
return;
}
}
- else if (action == FP_DEVICE_ACTION_ENROLL)
+ else if (action == FPI_DEVICE_ACTION_ENROLL)
{
FpPrint *enroll_print = NULL;
fpi_device_get_enroll_data (device, &enroll_print);
- fpi_print_set_type (enroll_print, FP_PRINT_NBIS);
+ fpi_print_set_type (enroll_print, FPI_PRINT_NBIS);
}
priv->enroll_stage = 0;
@@ -178,14 +178,14 @@ fp_image_device_start_capture_action (FpDevice *device)
* error (which will usually say that the user should remove the
* finger).
*/
- if (priv->state != FP_IMAGE_DEVICE_STATE_INACTIVE || priv->active)
+ if (priv->state != FPI_IMAGE_DEVICE_STATE_INACTIVE || priv->active)
{
g_debug ("Got a new request while the device was still active");
g_assert (priv->pending_activation_timeout_id == 0);
priv->pending_activation_timeout_id =
g_timeout_add (100, pending_activation_timeout, device);
- if (priv->state == FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
+ if (priv->state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
priv->pending_activation_timeout_waiting_finger_off = TRUE;
else
priv->pending_activation_timeout_waiting_finger_off = FALSE;
@@ -271,8 +271,8 @@ fp_image_device_class_init (FpImageDeviceClass *klass)
g_param_spec_enum ("fp-image-device-state",
"Image Device State",
"Private: The state of the image device",
- FP_TYPE_IMAGE_DEVICE_STATE,
- FP_IMAGE_DEVICE_STATE_INACTIVE,
+ FPI_TYPE_IMAGE_DEVICE_STATE,
+ FPI_IMAGE_DEVICE_STATE_INACTIVE,
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
signals[FPI_STATE_CHANGED] =
@@ -281,7 +281,7 @@ fp_image_device_class_init (FpImageDeviceClass *klass)
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (FpImageDeviceClass, change_state),
NULL, NULL, NULL,
- G_TYPE_NONE, 1, FP_TYPE_IMAGE_DEVICE_STATE);
+ G_TYPE_NONE, 1, FPI_TYPE_IMAGE_DEVICE_STATE);
g_object_class_install_properties (object_class, N_PROPS, properties);
}
diff --git a/libfprint/fp-print-private.h b/libfprint/fp-print-private.h
index f5822b3..6d44700 100644
--- a/libfprint/fp-print-private.h
+++ b/libfprint/fp-print-private.h
@@ -27,7 +27,7 @@ struct _FpPrint
{
GInitiallyUnowned parent_instance;
- FpPrintType type;
+ FpiPrintType type;
gchar *driver;
gchar *device_id;
diff --git a/libfprint/fp-print.c b/libfprint/fp-print.c
index 30fdf1a..dd45b95 100644
--- a/libfprint/fp-print.c
+++ b/libfprint/fp-print.c
@@ -272,8 +272,8 @@ fp_print_class_init (FpPrintClass *klass)
g_param_spec_enum ("fp-type",
"Type",
"Private: The type of the print data",
- FP_TYPE_PRINT_TYPE,
- FP_PRINT_RAW,
+ FPI_TYPE_PRINT_TYPE,
+ FPI_PRINT_RAW,
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
properties[PROP_FPI_DATA] =
@@ -555,8 +555,8 @@ fp_print_equal (FpPrint *self, FpPrint *other)
{
g_return_val_if_fail (FP_IS_PRINT (self), FALSE);
g_return_val_if_fail (FP_IS_PRINT (other), FALSE);
- g_return_val_if_fail (self->type != FP_PRINT_UNDEFINED, FALSE);
- g_return_val_if_fail (other->type != FP_PRINT_UNDEFINED, FALSE);
+ g_return_val_if_fail (self->type != FPI_PRINT_UNDEFINED, FALSE);
+ g_return_val_if_fail (other->type != FPI_PRINT_UNDEFINED, FALSE);
if (self->type != other->type)
return FALSE;
@@ -567,11 +567,11 @@ fp_print_equal (FpPrint *self, FpPrint *other)
if (g_strcmp0 (self->device_id, other->device_id))
return FALSE;
- if (self->type == FP_PRINT_RAW)
+ if (self->type == FPI_PRINT_RAW)
{
return g_variant_equal (self->data, other->data);
}
- else if (self->type == FP_PRINT_NBIS)
+ else if (self->type == FPI_PRINT_NBIS)
{
gint i;
@@ -595,7 +595,7 @@ fp_print_equal (FpPrint *self, FpPrint *other)
}
}
-#define FP_PRINT_VARIANT_TYPE G_VARIANT_TYPE ("(issbymsmsia{sv}v)")
+#define FPI_PRINT_VARIANT_TYPE G_VARIANT_TYPE ("(issbymsmsia{sv}v)")
G_STATIC_ASSERT (sizeof (((struct xyt_struct *) NULL)->xcol[0]) == 4);
@@ -618,7 +618,7 @@ fp_print_serialize (FpPrint *print,
GError **error)
{
g_autoptr(GVariant) result = NULL;
- GVariantBuilder builder = G_VARIANT_BUILDER_INIT (FP_PRINT_VARIANT_TYPE);
+ GVariantBuilder builder = G_VARIANT_BUILDER_INIT (FPI_PRINT_VARIANT_TYPE);
gsize len;
g_assert (data);
@@ -643,7 +643,7 @@ fp_print_serialize (FpPrint *print,
g_variant_builder_close (&builder);
/* Insert NBIS print data for type NBIS, otherwise the GVariant directly */
- if (print->type == FP_PRINT_NBIS)
+ if (print->type == FPI_PRINT_NBIS)
{
GVariantBuilder nested = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE ("(a(aiaiai))"));
gint i;
@@ -745,7 +745,7 @@ fp_print_deserialize (const guchar *data,
g_autofree gchar *username = NULL;
g_autofree gchar *description = NULL;
gint julian_date;
- FpPrintType type;
+ FpiPrintType type;
const gchar *driver;
const gchar *device_id;
gboolean device_stored;
@@ -766,7 +766,7 @@ fp_print_deserialize (const guchar *data,
* longer. */
aligned_data = g_malloc (length - 3);
memcpy (aligned_data, data + 3, length - 3);
- raw_value = g_variant_new_from_data (FP_PRINT_VARIANT_TYPE,
+ raw_value = g_variant_new_from_data (FPI_PRINT_VARIANT_TYPE,
aligned_data, length - 3,
FALSE, g_free, aligned_data);
@@ -794,7 +794,7 @@ fp_print_deserialize (const guchar *data,
finger = finger_int8;
/* Assume data is valid at this point if the values are somewhat sane. */
- if (type == FP_PRINT_NBIS)
+ if (type == FPI_PRINT_NBIS)
{
g_autoptr(GVariant) prints = g_variant_get_child_value (print_data, 0);
gint i;
@@ -804,7 +804,7 @@ fp_print_deserialize (const guchar *data,
"device-id", device_id,
"device-stored", device_stored,
NULL);
- fpi_print_set_type (result, FP_PRINT_NBIS);
+ fpi_print_set_type (result, FPI_PRINT_NBIS);
for (i = 0; i < g_variant_n_children (prints); i++)
{
g_autofree struct xyt_struct *xyt = g_new0 (struct xyt_struct, 1);
@@ -841,7 +841,7 @@ fp_print_deserialize (const guchar *data,
g_ptr_array_add (result->prints, g_steal_pointer (&xyt));
}
}
- else if (type == FP_PRINT_RAW)
+ else if (type == FPI_PRINT_RAW)
{
g_autoptr(GVariant) fp_data = g_variant_get_child_value (print_data, 0);
diff --git a/libfprint/fpi-device.c b/libfprint/fpi-device.c
index 5fc6b76..51dbee1 100644
--- a/libfprint/fpi-device.c
+++ b/libfprint/fpi-device.c
@@ -350,21 +350,21 @@ fpi_device_get_virtual_env (FpDevice *device)
* fpi_device_get_current_action:
* @device: The #FpDevice
*
- * Get the currently ongoing action or %FP_DEVICE_ACTION_NONE if there
+ * Get the currently ongoing action or %FPI_DEVICE_ACTION_NONE if there
* is no operation at this time.
*
* This is useful for drivers that might share code paths between different
* actions (e.g. verify and identify) and want to find out again later which
* action was started in the beginning.
*
- * Returns: The ongoing #FpDeviceAction
+ * Returns: The ongoing #FpiDeviceAction
*/
-FpDeviceAction
+FpiDeviceAction
fpi_device_get_current_action (FpDevice *device)
{
FpDevicePrivate *priv = fp_device_get_instance_private (device);
- g_return_val_if_fail (FP_IS_DEVICE (device), FP_DEVICE_ACTION_NONE);
+ g_return_val_if_fail (FP_IS_DEVICE (device), FPI_DEVICE_ACTION_NONE);
return priv->current_action;
}
@@ -387,7 +387,7 @@ fpi_device_action_is_cancelled (FpDevice *device)
GCancellable *cancellable;
g_return_val_if_fail (FP_IS_DEVICE (device), TRUE);
- g_return_val_if_fail (priv->current_action != FP_DEVICE_ACTION_NONE, TRUE);
+ g_return_val_if_fail (priv->current_action != FPI_DEVICE_ACTION_NONE, TRUE);
cancellable = g_task_get_cancellable (priv->current_task);
@@ -435,7 +435,7 @@ fpi_device_get_enroll_data (FpDevice *device,
FpEnrollData *data;
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_ENROLL);
+ g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_ENROLL);
data = g_task_get_task_data (priv->current_task);
g_assert (data);
@@ -458,7 +458,7 @@ fpi_device_get_capture_data (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_CAPTURE);
+ g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_CAPTURE);
if (wait_for_finger)
*wait_for_finger = priv->wait_for_finger;
@@ -478,7 +478,7 @@ fpi_device_get_verify_data (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_VERIFY);
+ g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_VERIFY);
if (print)
*print = g_task_get_task_data (priv->current_task);
@@ -498,7 +498,7 @@ fpi_device_get_identify_data (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_IDENTIFY);
+ g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_IDENTIFY);
if (prints)
*prints = g_task_get_task_data (priv->current_task);
@@ -518,7 +518,7 @@ fpi_device_get_delete_data (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_DELETE);
+ g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_DELETE);
if (print)
*print = g_task_get_task_data (priv->current_task);
@@ -542,7 +542,7 @@ fpi_device_get_cancellable (FpDevice *device)
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_val_if_fail (FP_IS_DEVICE (device), NULL);
- g_return_val_if_fail (priv->current_action != FP_DEVICE_ACTION_NONE, NULL);
+ g_return_val_if_fail (priv->current_action != FPI_DEVICE_ACTION_NONE, NULL);
return g_task_get_cancellable (priv->current_task);
}
@@ -564,7 +564,7 @@ fpi_device_action_error (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action != FP_DEVICE_ACTION_NONE);
+ g_return_if_fail (priv->current_action != FPI_DEVICE_ACTION_NONE);
if (error != NULL)
{
@@ -579,44 +579,44 @@ fpi_device_action_error (FpDevice *device,
switch (priv->current_action)
{
- case FP_DEVICE_ACTION_PROBE:
+ case FPI_DEVICE_ACTION_PROBE:
fpi_device_probe_complete (device, NULL, NULL, error);
break;
- case FP_DEVICE_ACTION_OPEN:
+ case FPI_DEVICE_ACTION_OPEN:
fpi_device_open_complete (device, error);
break;
- case FP_DEVICE_ACTION_CLOSE:
+ case FPI_DEVICE_ACTION_CLOSE:
fpi_device_close_complete (device, error);
break;
- case FP_DEVICE_ACTION_ENROLL:
+ case FPI_DEVICE_ACTION_ENROLL:
fpi_device_enroll_complete (device, NULL, error);
break;
- case FP_DEVICE_ACTION_VERIFY:
+ case FPI_DEVICE_ACTION_VERIFY:
fpi_device_verify_complete (device, FPI_MATCH_ERROR, NULL, error);
break;
- case FP_DEVICE_ACTION_IDENTIFY:
+ case FPI_DEVICE_ACTION_IDENTIFY:
fpi_device_identify_complete (device, NULL, NULL, error);
break;
- case FP_DEVICE_ACTION_CAPTURE:
+ case FPI_DEVICE_ACTION_CAPTURE:
fpi_device_capture_complete (device, NULL, error);
break;
- case FP_DEVICE_ACTION_DELETE:
+ case FPI_DEVICE_ACTION_DELETE:
fpi_device_delete_complete (device, error);
break;
- case FP_DEVICE_ACTION_LIST:
+ case FPI_DEVICE_ACTION_LIST:
fpi_device_list_complete (device, NULL, error);
break;
default:
- case FP_DEVICE_ACTION_NONE:
+ case FPI_DEVICE_ACTION_NONE:
g_return_if_reached ();
break;
}
@@ -663,7 +663,7 @@ fp_device_task_return_in_idle_cb (gpointer user_data)
g_debug ("Completing action %d in idle!", priv->current_action);
task = g_steal_pointer (&priv->current_task);
- priv->current_action = FP_DEVICE_ACTION_NONE;
+ priv->current_action = FPI_DEVICE_ACTION_NONE;
priv->current_task_idle_return_source = NULL;
switch (data->type)
@@ -746,7 +746,7 @@ fpi_device_probe_complete (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_PROBE);
+ g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_PROBE);
g_debug ("Device reported probe completion");
@@ -788,7 +788,7 @@ fpi_device_open_complete (FpDevice *device, GError *error)
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_OPEN);
+ g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_OPEN);
g_debug ("Device reported open completion");
@@ -821,7 +821,7 @@ fpi_device_close_complete (FpDevice *device, GError *error)
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_CLOSE);
+ g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_CLOSE);
g_debug ("Device reported close completion");
@@ -873,7 +873,7 @@ fpi_device_enroll_complete (FpDevice *device, FpPrint *print, GError *error)
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_ENROLL);
+ g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_ENROLL);
g_debug ("Device reported enroll completion");
@@ -923,7 +923,7 @@ fpi_device_verify_complete (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_VERIFY);
+ g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_VERIFY);
g_debug ("Device reported verify completion");
@@ -980,7 +980,7 @@ fpi_device_identify_complete (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_IDENTIFY);
+ g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_IDENTIFY);
g_debug ("Device reported identify completion");
@@ -1027,7 +1027,7 @@ fpi_device_capture_complete (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_CAPTURE);
+ g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_CAPTURE);
g_debug ("Device reported capture completion");
@@ -1072,7 +1072,7 @@ fpi_device_delete_complete (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_DELETE);
+ g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_DELETE);
g_debug ("Device reported deletion completion");
@@ -1106,7 +1106,7 @@ fpi_device_list_complete (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_LIST);
+ g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_LIST);
g_debug ("Device reported listing completion");
@@ -1150,7 +1150,7 @@ fpi_device_enroll_progress (FpDevice *device,
FpEnrollData *data;
g_return_if_fail (FP_IS_DEVICE (device));
- g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_ENROLL);
+ g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_ENROLL);
g_return_if_fail (error == NULL || error->domain == FP_DEVICE_RETRY);
g_debug ("Device reported enroll progress, reported %i of %i have been completed", completed_stages, priv->nr_enroll_stages);
diff --git a/libfprint/fpi-device.h b/libfprint/fpi-device.h
index 2333ae2..3d66ee5 100644
--- a/libfprint/fpi-device.h
+++ b/libfprint/fpi-device.h
@@ -142,39 +142,39 @@ typedef void (*FpTimeoutFunc) (FpDevice *device,
gpointer user_data);
/**
- * FpDeviceAction:
- * @FP_DEVICE_ACTION_NONE: No action is active.
- * @FP_DEVICE_ACTION_PROBE: Probe device for support and information.
- * @FP_DEVICE_ACTION_OPEN: Device is currently being opened.
- * @FP_DEVICE_ACTION_CLOSE: Device is currently being closed.
- * @FP_DEVICE_ACTION_ENROLL: Device is currently enrolling.
- * @FP_DEVICE_ACTION_VERIFY: Device is currently verifying.
- * @FP_DEVICE_ACTION_IDENTIFY: Device is currently identifying.
- * @FP_DEVICE_ACTION_CAPTURE: Device is currently capturing an image.
- * @FP_DEVICE_ACTION_LIST: Device stored prints are being queried.
- * @FP_DEVICE_ACTION_DELETE: Device stored print is being deleted.
+ * FpiDeviceAction:
+ * @FPI_DEVICE_ACTION_NONE: No action is active.
+ * @FPI_DEVICE_ACTION_PROBE: Probe device for support and information.
+ * @FPI_DEVICE_ACTION_OPEN: Device is currently being opened.
+ * @FPI_DEVICE_ACTION_CLOSE: Device is currently being closed.
+ * @FPI_DEVICE_ACTION_ENROLL: Device is currently enrolling.
+ * @FPI_DEVICE_ACTION_VERIFY: Device is currently verifying.
+ * @FPI_DEVICE_ACTION_IDENTIFY: Device is currently identifying.
+ * @FPI_DEVICE_ACTION_CAPTURE: Device is currently capturing an image.
+ * @FPI_DEVICE_ACTION_LIST: Device stored prints are being queried.
+ * @FPI_DEVICE_ACTION_DELETE: Device stored print is being deleted.
*
* Current active action of the device. A driver can retrieve the action.
*/
typedef enum {
- FP_DEVICE_ACTION_NONE = 0,
- FP_DEVICE_ACTION_PROBE,
- FP_DEVICE_ACTION_OPEN,
- FP_DEVICE_ACTION_CLOSE,
- FP_DEVICE_ACTION_ENROLL,
- FP_DEVICE_ACTION_VERIFY,
- FP_DEVICE_ACTION_IDENTIFY,
- FP_DEVICE_ACTION_CAPTURE,
- FP_DEVICE_ACTION_LIST,
- FP_DEVICE_ACTION_DELETE,
-} FpDeviceAction;
+ FPI_DEVICE_ACTION_NONE = 0,
+ FPI_DEVICE_ACTION_PROBE,
+ FPI_DEVICE_ACTION_OPEN,
+ FPI_DEVICE_ACTION_CLOSE,
+ FPI_DEVICE_ACTION_ENROLL,
+ FPI_DEVICE_ACTION_VERIFY,
+ FPI_DEVICE_ACTION_IDENTIFY,
+ FPI_DEVICE_ACTION_CAPTURE,
+ FPI_DEVICE_ACTION_LIST,
+ FPI_DEVICE_ACTION_DELETE,
+} FpiDeviceAction;
GUsbDevice *fpi_device_get_usb_device (FpDevice *device);
const gchar *fpi_device_get_virtual_env (FpDevice *device);
//const gchar *fpi_device_get_spi_dev (FpDevice *device);
-FpDeviceAction fpi_device_get_current_action (FpDevice *device);
+FpiDeviceAction fpi_device_get_current_action (FpDevice *device);
gboolean fpi_device_action_is_cancelled (FpDevice *device);
GError * fpi_device_retry_new (FpDeviceRetry error);
diff --git a/libfprint/fpi-image-device.c b/libfprint/fpi-image-device.c
index 6e5802e..e03d60c 100644
--- a/libfprint/fpi-image-device.c
+++ b/libfprint/fpi-image-device.c
@@ -54,7 +54,7 @@ fpi_image_device_activate (FpImageDevice *self)
/* We don't have a neutral ACTIVE state, but we always will
* go into WAIT_FINGER_ON afterwards. */
- priv->state = FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON;
+ priv->state = FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON;
g_object_notify (G_OBJECT (self), "fp-image-device-state");
/* We might have been waiting for deactivation to finish before
@@ -79,10 +79,10 @@ fpi_image_device_deactivate (FpImageDevice *self)
fp_dbg ("Already deactivated, ignoring request.");
return;
}
- if (!priv->cancelling && priv->state == FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
+ if (!priv->cancelling && priv->state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
g_warning ("Deactivating image device while waiting for finger, this should not happen.");
- priv->state = FP_IMAGE_DEVICE_STATE_INACTIVE;
+ priv->state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
g_object_notify (G_OBJECT (self), "fp-image-device-state");
fp_dbg ("Deactivating image device\n");
@@ -92,12 +92,12 @@ fpi_image_device_deactivate (FpImageDevice *self)
/* Static helper functions */
static void
-fp_image_device_change_state (FpImageDevice *self, FpImageDeviceState state)
+fp_image_device_change_state (FpImageDevice *self, FpiImageDeviceState state)
{
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
/* Cannot change to inactive using this function. */
- g_assert (state != FP_IMAGE_DEVICE_STATE_INACTIVE);
+ g_assert (state != FPI_IMAGE_DEVICE_STATE_INACTIVE);
/* We might have been waiting for the finger to go OFF to start the
* next operation. */
@@ -118,7 +118,7 @@ fp_image_device_enroll_maybe_await_finger_on (FpImageDevice *self)
if (priv->enroll_await_on_pending)
{
priv->enroll_await_on_pending = FALSE;
- fp_image_device_change_state (self, FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON);
+ fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON);
}
else
{
@@ -135,7 +135,7 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
FpImageDevice *self = FP_IMAGE_DEVICE (user_data);
FpDevice *device = FP_DEVICE (self);
FpImageDevicePrivate *priv;
- FpDeviceAction action;
+ FpiDeviceAction action;
/* Note: We rely on the device to not disappear during an operation. */
@@ -159,7 +159,7 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
priv = fp_image_device_get_instance_private (FP_IMAGE_DEVICE (device));
action = fpi_device_get_current_action (device);
- if (action == FP_DEVICE_ACTION_CAPTURE)
+ if (action == FPI_DEVICE_ACTION_CAPTURE)
{
fpi_device_capture_complete (device, g_steal_pointer (&image), error);
fpi_image_device_deactivate (self);
@@ -169,12 +169,12 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
if (!error)
{
print = fp_print_new (device);
- fpi_print_set_type (print, FP_PRINT_NBIS);
+ fpi_print_set_type (print, FPI_PRINT_NBIS);
if (!fpi_print_add_from_image (print, image, &error))
g_clear_object (&print);
}
- if (action == FP_DEVICE_ACTION_ENROLL)
+ if (action == FPI_DEVICE_ACTION_ENROLL)
{
FpPrint *enroll_print;
fpi_device_get_enroll_data (device, &enroll_print);
@@ -199,7 +199,7 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
fp_image_device_enroll_maybe_await_finger_on (FP_IMAGE_DEVICE (device));
}
}
- else if (action == FP_DEVICE_ACTION_VERIFY)
+ else if (action == FPI_DEVICE_ACTION_VERIFY)
{
FpPrint *template;
FpiMatchResult result;
@@ -213,7 +213,7 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
fpi_device_verify_complete (device, result, g_steal_pointer (&print), error);
fpi_image_device_deactivate (self);
}
- else if (action == FP_DEVICE_ACTION_IDENTIFY)
+ else if (action == FPI_DEVICE_ACTION_IDENTIFY)
{
gint i;
GPtrArray *templates;
@@ -285,9 +285,9 @@ fpi_image_device_report_finger_status (FpImageDevice *self,
{
FpDevice *device = FP_DEVICE (self);
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
- FpDeviceAction action;
+ FpiDeviceAction action;
- if (priv->state == FP_IMAGE_DEVICE_STATE_INACTIVE)
+ if (priv->state == FPI_IMAGE_DEVICE_STATE_INACTIVE)
{
/* Do we really want to always ignore such reports? We could
* also track the state in case the user had the finger on
@@ -300,16 +300,16 @@ fpi_image_device_report_finger_status (FpImageDevice *self,
action = fpi_device_get_current_action (device);
- g_assert (action != FP_DEVICE_ACTION_OPEN);
- g_assert (action != FP_DEVICE_ACTION_CLOSE);
+ g_assert (action != FPI_DEVICE_ACTION_OPEN);
+ g_assert (action != FPI_DEVICE_ACTION_CLOSE);
g_debug ("Image device reported finger status: %s", present ? "on" : "off");
- if (present && priv->state == FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
+ if (present && priv->state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
{
- fp_image_device_change_state (self, FP_IMAGE_DEVICE_STATE_CAPTURE);
+ fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_CAPTURE);
}
- else if (!present && priv->state == FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
+ else if (!present && priv->state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
{
/* We need to deactivate or continue to await finger */
@@ -324,7 +324,7 @@ fpi_image_device_report_finger_status (FpImageDevice *self,
* minutiae detection to prevent deactivation (without cancellation)
* from the AWAIT_FINGER_ON state.
*/
- if (action != FP_DEVICE_ACTION_ENROLL)
+ if (action != FPI_DEVICE_ACTION_ENROLL)
fpi_image_device_deactivate (self);
else
fp_image_device_enroll_maybe_await_finger_on (self);
@@ -349,18 +349,18 @@ void
fpi_image_device_image_captured (FpImageDevice *self, FpImage *image)
{
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
- FpDeviceAction action;
+ FpiDeviceAction action;
action = fpi_device_get_current_action (FP_DEVICE (self));
g_return_if_fail (image != NULL);
- g_return_if_fail (priv->state == FP_IMAGE_DEVICE_STATE_CAPTURE);
- g_return_if_fail (action == FP_DEVICE_ACTION_ENROLL ||
- action == FP_DEVICE_ACTION_VERIFY ||
- action == FP_DEVICE_ACTION_IDENTIFY ||
- action == FP_DEVICE_ACTION_CAPTURE);
+ g_return_if_fail (priv->state == FPI_IMAGE_DEVICE_STATE_CAPTURE);
+ g_return_if_fail (action == FPI_DEVICE_ACTION_ENROLL ||
+ action == FPI_DEVICE_ACTION_VERIFY ||
+ action == FPI_DEVICE_ACTION_IDENTIFY ||
+ action == FPI_DEVICE_ACTION_CAPTURE);
- fp_image_device_change_state (self, FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF);
+ fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF);
g_debug ("Image device captured an image");
@@ -385,22 +385,22 @@ void
fpi_image_device_retry_scan (FpImageDevice *self, FpDeviceRetry retry)
{
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
- FpDeviceAction action;
+ FpiDeviceAction action;
GError *error;
action = fpi_device_get_current_action (FP_DEVICE (self));
/* We might be waiting for a finger at this point, so just accept
* all but INACTIVE */
- g_return_if_fail (priv->state != FP_IMAGE_DEVICE_STATE_INACTIVE);
- g_return_if_fail (action == FP_DEVICE_ACTION_ENROLL ||
- action == FP_DEVICE_ACTION_VERIFY ||
- action == FP_DEVICE_ACTION_IDENTIFY ||
- action == FP_DEVICE_ACTION_CAPTURE);
+ g_return_if_fail (priv->state != FPI_IMAGE_DEVICE_STATE_INACTIVE);
+ g_return_if_fail (action == FPI_DEVICE_ACTION_ENROLL ||
+ action == FPI_DEVICE_ACTION_VERIFY ||
+ action == FPI_DEVICE_ACTION_IDENTIFY ||
+ action == FPI_DEVICE_ACTION_CAPTURE);
error = fpi_device_retry_new (retry);
- if (action == FP_DEVICE_ACTION_ENROLL)
+ if (action == FPI_DEVICE_ACTION_ENROLL)
{
g_debug ("Reporting retry during enroll");
fpi_device_enroll_progress (FP_DEVICE (self), priv->enroll_stage, NULL, error);
@@ -438,17 +438,17 @@ fpi_image_device_session_error (FpImageDevice *self, GError *error)
if (!priv->active)
{
- FpDeviceAction action = fpi_device_get_current_action (FP_DEVICE (self));
+ FpiDeviceAction action = fpi_device_get_current_action (FP_DEVICE (self));
g_warning ("Driver reported session error, but device is inactive.");
- if (action != FP_DEVICE_ACTION_NONE)
+ if (action != FPI_DEVICE_ACTION_NONE)
{
g_warning ("Translating to activation failure!");
fpi_image_device_activate_complete (self, error);
return;
}
}
- else if (priv->state == FP_IMAGE_DEVICE_STATE_INACTIVE)
+ else if (priv->state == FPI_IMAGE_DEVICE_STATE_INACTIVE)
{
g_warning ("Driver reported session error; translating to deactivation failure.");
fpi_image_device_deactivate_complete (self, error);
@@ -473,15 +473,15 @@ void
fpi_image_device_activate_complete (FpImageDevice *self, GError *error)
{
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
- FpDeviceAction action;
+ FpiDeviceAction action;
action = fpi_device_get_current_action (FP_DEVICE (self));
g_return_if_fail (priv->active == FALSE);
- g_return_if_fail (action == FP_DEVICE_ACTION_ENROLL ||
- action == FP_DEVICE_ACTION_VERIFY ||
- action == FP_DEVICE_ACTION_IDENTIFY ||
- action == FP_DEVICE_ACTION_CAPTURE);
+ g_return_if_fail (action == FPI_DEVICE_ACTION_ENROLL ||
+ action == FPI_DEVICE_ACTION_VERIFY ||
+ action == FPI_DEVICE_ACTION_IDENTIFY ||
+ action == FPI_DEVICE_ACTION_CAPTURE);
if (error)
{
@@ -496,7 +496,7 @@ fpi_image_device_activate_complete (FpImageDevice *self, GError *error)
/* We always want to capture at this point, move to AWAIT_FINGER
* state. */
- fp_image_device_change_state (self, FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON);
+ fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON);
}
/**
@@ -511,10 +511,10 @@ fpi_image_device_deactivate_complete (FpImageDevice *self, GError *error)
{
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (self);
- FpDeviceAction action;
+ FpiDeviceAction action;
g_return_if_fail (priv->active == TRUE);
- g_return_if_fail (priv->state == FP_IMAGE_DEVICE_STATE_INACTIVE);
+ g_return_if_fail (priv->state == FPI_IMAGE_DEVICE_STATE_INACTIVE);
g_debug ("Image device deactivation completed");
@@ -527,7 +527,7 @@ fpi_image_device_deactivate_complete (FpImageDevice *self, GError *error)
/* Special case, if we should be closing, but didn't due to a running
* deactivation, then do so now. */
- if (action == FP_DEVICE_ACTION_CLOSE)
+ if (action == FPI_DEVICE_ACTION_CLOSE)
{
cls->img_close (self);
return;
@@ -553,16 +553,16 @@ void
fpi_image_device_open_complete (FpImageDevice *self, GError *error)
{
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
- FpDeviceAction action;
+ FpiDeviceAction action;
action = fpi_device_get_current_action (FP_DEVICE (self));
g_return_if_fail (priv->active == FALSE);
- g_return_if_fail (action == FP_DEVICE_ACTION_OPEN);
+ g_return_if_fail (action == FPI_DEVICE_ACTION_OPEN);
g_debug ("Image device open completed");
- priv->state = FP_IMAGE_DEVICE_STATE_INACTIVE;
+ priv->state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
g_object_notify (G_OBJECT (self), "fp-image-device-state");
fpi_device_open_complete (FP_DEVICE (self), error);
@@ -579,16 +579,16 @@ void
fpi_image_device_close_complete (FpImageDevice *self, GError *error)
{
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
- FpDeviceAction action;
+ FpiDeviceAction action;
action = fpi_device_get_current_action (FP_DEVICE (self));
g_debug ("Image device close completed");
g_return_if_fail (priv->active == FALSE);
- g_return_if_fail (action == FP_DEVICE_ACTION_CLOSE);
+ g_return_if_fail (action == FPI_DEVICE_ACTION_CLOSE);
- priv->state = FP_IMAGE_DEVICE_STATE_INACTIVE;
+ priv->state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
g_object_notify (G_OBJECT (self), "fp-image-device-state");
fpi_device_close_complete (FP_DEVICE (self), error);
diff --git a/libfprint/fpi-image-device.h b/libfprint/fpi-image-device.h
index 06d1a64..155390d 100644
--- a/libfprint/fpi-image-device.h
+++ b/libfprint/fpi-image-device.h
@@ -23,11 +23,11 @@
#include "fp-image-device.h"
/**
- * FpImageDeviceState:
- * @FP_IMAGE_DEVICE_STATE_INACTIVE: inactive
- * @FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON: waiting for the finger to be pressed or swiped
- * @FP_IMAGE_DEVICE_STATE_CAPTURE: capturing an image
- * @FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: waiting for the finger to be removed
+ * FpiImageDeviceState:
+ * @FPI_IMAGE_DEVICE_STATE_INACTIVE: inactive
+ * @FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON: waiting for the finger to be pressed or swiped
+ * @FPI_IMAGE_DEVICE_STATE_CAPTURE: capturing an image
+ * @FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: waiting for the finger to be removed
*
* The state of an imaging device while doing a capture. The state is
* passed through to the driver using the ::activate() or ::change_state() vfuncs.
@@ -37,11 +37,11 @@
* unconditionally if the device supports raw capturing.
*/
typedef enum {
- FP_IMAGE_DEVICE_STATE_INACTIVE,
- FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON,
- FP_IMAGE_DEVICE_STATE_CAPTURE,
- FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF,
-} FpImageDeviceState;
+ FPI_IMAGE_DEVICE_STATE_INACTIVE,
+ FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON,
+ FPI_IMAGE_DEVICE_STATE_CAPTURE,
+ FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF,
+} FpiImageDeviceState;
/**
* FpImageDeviceClass:
@@ -90,8 +90,8 @@ struct _FpImageDeviceClass
void (*img_open) (FpImageDevice *dev);
void (*img_close) (FpImageDevice *dev);
void (*activate) (FpImageDevice *dev);
- void (*change_state) (FpImageDevice *dev,
- FpImageDeviceState state);
+ void (*change_state) (FpImageDevice *dev,
+ FpiImageDeviceState state);
void (*deactivate) (FpImageDevice *dev);
};
diff --git a/libfprint/fpi-print.c b/libfprint/fpi-print.c
index a407dd9..7a5e1e2 100644
--- a/libfprint/fpi-print.c
+++ b/libfprint/fpi-print.c
@@ -38,15 +38,15 @@
* @print: A #FpPrint
* @add: Print to append to @print
*
- * Appends the single #FP_PRINT_NBIS print from @add to the collection of
- * prints in @print. Both print objects need to be of type #FP_PRINT_NBIS
+ * Appends the single #FPI_PRINT_NBIS print from @add to the collection of
+ * prints in @print. Both print objects need to be of type #FPI_PRINT_NBIS
* for this to work.
*/
void
fpi_print_add_print (FpPrint *print, FpPrint *add)
{
- g_return_if_fail (print->type == FP_PRINT_NBIS);
- g_return_if_fail (add->type == FP_PRINT_NBIS);
+ g_return_if_fail (print->type == FPI_PRINT_NBIS);
+ g_return_if_fail (add->type == FPI_PRINT_NBIS);
g_assert (add->prints->len == 1);
g_ptr_array_add (print->prints, g_memdup (add->prints->pdata[0], sizeof (struct xyt_struct)));
@@ -62,15 +62,15 @@ fpi_print_add_print (FpPrint *print, FpPrint *add)
* print passed during enrollment.
*/
void
-fpi_print_set_type (FpPrint *print,
- FpPrintType type)
+fpi_print_set_type (FpPrint *print,
+ FpiPrintType type)
{
g_return_if_fail (FP_IS_PRINT (print));
/* We only allow setting this once! */
- g_return_if_fail (print->type == FP_PRINT_UNDEFINED);
+ g_return_if_fail (print->type == FPI_PRINT_UNDEFINED);
print->type = type;
- if (print->type == FP_PRINT_NBIS)
+ if (print->type == FPI_PRINT_NBIS)
{
g_assert_null (print->prints);
print->prints = g_ptr_array_new_with_free_func (g_free);
@@ -143,7 +143,7 @@ minutiae_to_xyt (struct fp_minutiae *minutiae,
* @error: Return location for error
*
* Extracts the minutiae from the given image and adds it to @print of
- * type #FP_PRINT_NBIS.
+ * type #FPI_PRINT_NBIS.
*
* The @image will be kept so that API users can get retrieve it e.g.
* for debugging purposes.
@@ -159,7 +159,7 @@ fpi_print_add_from_image (FpPrint *print,
struct fp_minutiae _minutiae;
struct xyt_struct *xyt;
- if (print->type != FP_PRINT_NBIS || !image)
+ if (print->type != FPI_PRINT_NBIS || !image)
{
g_set_error (error,
G_IO_ERROR,
@@ -203,7 +203,7 @@ fpi_print_add_from_image (FpPrint *print,
* Match the newly scanned @print (containing exactly one print) against the
* prints contained in @template which will have been stored during enrollment.
*
- * Both @template and @print need to be of type #FP_PRINT_NBIS for this to
+ * Both @template and @print need to be of type #FPI_PRINT_NBIS for this to
* work.
*
* Returns: Whether the prints match, @error will be set if #FPI_MATCH_ERROR is returned
@@ -216,7 +216,7 @@ fpi_print_bz3_match (FpPrint *template, FpPrint *print, gint bz3_threshold, GErr
gint i;
/* XXX: Use a different error type? */
- if (template->type != FP_PRINT_NBIS || print->type != FP_PRINT_NBIS)
+ if (template->type != FPI_PRINT_NBIS || print->type != FPI_PRINT_NBIS)
{
*error = fpi_device_error_new_msg (FP_DEVICE_ERROR_NOT_SUPPORTED,
"It is only possible to match NBIS type print data");
diff --git a/libfprint/fpi-print.h b/libfprint/fpi-print.h
index 04500d6..c969f12 100644
--- a/libfprint/fpi-print.h
+++ b/libfprint/fpi-print.h
@@ -7,16 +7,16 @@
G_BEGIN_DECLS
/**
- * FpPrintType:
- * @FP_PRINT_UNDEFINED: Undefined type, this happens prior to enrollment
- * @FP_PRINT_RAW: A raw print where the data is directly compared
- * @FP_PRINT_NBIS: NBIS minutiae comparison
+ * FpiPrintType:
+ * @FPI_PRINT_UNDEFINED: Undefined type, this happens prior to enrollment
+ * @FPI_PRINT_RAW: A raw print where the data is directly compared
+ * @FPI_PRINT_NBIS: NBIS minutiae comparison
*/
typedef enum {
- FP_PRINT_UNDEFINED = 0,
- FP_PRINT_RAW,
- FP_PRINT_NBIS,
-} FpPrintType;
+ FPI_PRINT_UNDEFINED = 0,
+ FPI_PRINT_RAW,
+ FPI_PRINT_NBIS,
+} FpiPrintType;
/**
* FpiMatchResult:
@@ -33,8 +33,8 @@ typedef enum {
void fpi_print_add_print (FpPrint *print,
FpPrint *add);
-void fpi_print_set_type (FpPrint *print,
- FpPrintType type);
+void fpi_print_set_type (FpPrint *print,
+ FpiPrintType type);
void fpi_print_set_device_stored (FpPrint *print,
gboolean device_stored);
diff --git a/tests/test-device-fake.c b/tests/test-device-fake.c
index e3b6f38..096d140 100644
--- a/tests/test-device-fake.c
+++ b/tests/test-device-fake.c
@@ -35,7 +35,7 @@ fpi_device_fake_probe (FpDevice *device)
FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
- g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_PROBE);
+ g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_PROBE);
fake_dev->last_called_function = fpi_device_fake_probe;
fpi_device_probe_complete (device, dev_class->id, dev_class->full_name,
@@ -47,7 +47,7 @@ fpi_device_fake_open (FpDevice *device)
{
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
- g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_OPEN);
+ g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_OPEN);
fake_dev->last_called_function = fpi_device_fake_open;
fpi_device_open_complete (device, fake_dev->ret_error);
@@ -58,7 +58,7 @@ fpi_device_fake_close (FpDevice *device)
{
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
- g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_CLOSE);
+ g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_CLOSE);
fake_dev->last_called_function = fpi_device_fake_close;
fpi_device_close_complete (device, fake_dev->ret_error);
@@ -70,7 +70,7 @@ fpi_device_fake_enroll (FpDevice *device)
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
FpPrint *print = fake_dev->ret_print;
- g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_ENROLL);
+ g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_ENROLL);
fpi_device_get_enroll_data (device, (FpPrint **) &fake_dev->action_data);
if (!print && !fake_dev->ret_error)
@@ -86,7 +86,7 @@ fpi_device_fake_verify (FpDevice *device)
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
FpPrint *print = fake_dev->ret_print;
- g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_VERIFY);
+ g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_VERIFY);
fpi_device_get_verify_data (device, (FpPrint **) &fake_dev->action_data);
if (!print && !fake_dev->ret_error)
@@ -103,7 +103,7 @@ fpi_device_fake_identify (FpDevice *device)
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
FpPrint *match = fake_dev->ret_match;
- g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_IDENTIFY);
+ g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_IDENTIFY);
fpi_device_get_identify_data (device, (GPtrArray **) &fake_dev->action_data);
if (!match && !fake_dev->ret_error)
@@ -135,7 +135,7 @@ fpi_device_fake_capture (FpDevice *device)
{
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
- g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_CAPTURE);
+ g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_CAPTURE);
fpi_device_get_capture_data (device, (gboolean *) &fake_dev->action_data);
fake_dev->last_called_function = fpi_device_fake_capture;
@@ -147,7 +147,7 @@ fpi_device_fake_list (FpDevice *device)
{
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
- g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_LIST);
+ g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_LIST);
fake_dev->last_called_function = fpi_device_fake_list;
fpi_device_list_complete (device, fake_dev->ret_list, fake_dev->ret_error);
@@ -158,7 +158,7 @@ fpi_device_fake_delete (FpDevice *device)
{
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
- g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_DELETE);
+ g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_DELETE);
fpi_device_get_delete_data (device, (gpointer) & fake_dev->action_data);
fake_dev->last_called_function = fpi_device_fake_delete;
@@ -170,7 +170,7 @@ fpi_device_fake_cancel (FpDevice *device)
{
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
- g_assert_cmpuint (fpi_device_get_current_action (device), !=, FP_DEVICE_ACTION_NONE);
+ g_assert_cmpuint (fpi_device_get_current_action (device), !=, FPI_DEVICE_ACTION_NONE);
fake_dev->last_called_function = fpi_device_fake_cancel;
}
diff --git a/tests/test-fpi-device.c b/tests/test-fpi-device.c
index 165fc7f..b269ec4 100644
--- a/tests/test-fpi-device.c
+++ b/tests/test-fpi-device.c
@@ -528,7 +528,7 @@ test_driver_enroll_progress (void)
device = auto_close_fake_device_new ();
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
- "*assertion*current_action*FP_DEVICE_ACTION_ENROLL*failed");
+ "*assertion*current_action*FPI_DEVICE_ACTION_ENROLL*failed");
fpi_device_enroll_progress (device, 0, NULL, NULL);
g_test_assert_expected_messages ();
@@ -989,7 +989,7 @@ test_driver_current_action (void)
{
g_autoptr(FpDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
- g_assert_cmpint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_NONE);
+ g_assert_cmpint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_NONE);
}
static void
@@ -997,7 +997,7 @@ test_driver_current_action_open_vfunc (FpDevice *device)
{
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
- g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_OPEN);
+ g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_OPEN);
fake_dev->last_called_function = test_driver_current_action_open_vfunc;
fpi_device_open_complete (device, NULL);
@@ -1015,7 +1015,7 @@ test_driver_current_action_open (void)
fake_dev = FPI_DEVICE_FAKE (device);
g_assert (fake_dev->last_called_function == test_driver_current_action_open_vfunc);
- g_assert_cmpint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_NONE);
+ g_assert_cmpint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_NONE);
}
static void
@@ -1023,7 +1023,7 @@ test_driver_action_get_cancellable_open_vfunc (FpDevice *device)
{
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
- g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_OPEN);
+ g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_OPEN);
fake_dev->last_called_function = test_driver_action_get_cancellable_open_vfunc;
g_assert_true (G_IS_CANCELLABLE (fpi_device_get_cancellable (device)));
@@ -1054,7 +1054,7 @@ test_driver_action_get_cancellable_open_fail_vfunc (FpDevice *device)
{
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
- g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_OPEN);
+ g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_OPEN);
fake_dev->last_called_function = test_driver_action_get_cancellable_open_fail_vfunc;
g_assert_false (G_IS_CANCELLABLE (fpi_device_get_cancellable (device)));
@@ -1084,7 +1084,7 @@ test_driver_action_get_cancellable_error (void)
g_autoptr(FpDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
- "*assertion*current_action*FP_DEVICE_ACTION_NONE*failed");
+ "*assertion*current_action*FPI_DEVICE_ACTION_NONE*failed");
g_assert_null (fpi_device_get_cancellable (device));
g_test_assert_expected_messages ();
}
@@ -1094,7 +1094,7 @@ test_driver_action_is_cancelled_open_vfunc (FpDevice *device)
{
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
- g_assert_cmpuint (fpi_device_get_current_action (device), ==, FP_DEVICE_ACTION_OPEN);
+ g_assert_cmpuint (fpi_device_get_current_action (device), ==, FPI_DEVICE_ACTION_OPEN);
fake_dev->last_called_function = test_driver_action_is_cancelled_open_vfunc;
g_assert_true (G_IS_CANCELLABLE (fpi_device_get_cancellable (device)));
@@ -1132,7 +1132,7 @@ test_driver_action_is_cancelled_error (void)
g_autoptr(FpDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
- "*assertion*current_action*FP_DEVICE_ACTION_NONE*failed");
+ "*assertion*current_action*FPI_DEVICE_ACTION_NONE*failed");
g_assert_true (fpi_device_action_is_cancelled (device));
g_test_assert_expected_messages ();
}
@@ -1194,7 +1194,7 @@ test_driver_action_error_error (void)
g_autoptr(FpDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
- "*assertion*current_action*FP_DEVICE_ACTION_NONE*failed");
+ "*assertion*current_action*FPI_DEVICE_ACTION_NONE*failed");
fpi_device_action_error (device, NULL);
g_test_assert_expected_messages ();
}
--
2.24.1
Reference in New Issue View Git Blame Copy Permalink